Eliminating duplicated code (take 2...).

This proposal for code tidying uses multiple-value-bind to satisfy:

1. The various parsed/resolved components of the param list (session,
   vars, result-type) are available in the org-babel-execute:LANG
   functions.
2. Those functions don't duplicate the code for parsing the params
   list and resolving references
3. The functions still have the params list available to them, should
   they need to implement language-specific behaviour using it.

If the org-babel-execute:LANG functions need to be called directly,
then that would now have to be via
(multiple-value-bind (session vars result-params result-type)
      (org-babel-process-params params) (funcall cmd body params))

as in org-babel-exp.el. (But is it actually necessary to by-pass
org-babel-execute-src-block?)

lisp/langs/org-babel-R.el

@@ -37,20 +37,15 @@
 
 (defun org-babel-execute:R (body params)
   "Execute a block of R code with org-babel.  This function is
-called by `org-babel-execute-src-block'."
+called by `org-babel-execute-src-block' via multiple-value-bind."
   (message "executing R source code block...")
   (save-window-excursion
-    (let* ((vars (org-babel-ref-variables params))
-           (full-body (concat
-                       (mapconcat ;; define any variables
-                        (lambda (pair)
-                          (org-babel-R-assign-elisp (car pair) (cdr pair)))
-                        vars "\n") "\n" body "\n"))
-           (result-params (split-string (or (cdr (assoc :results params)) "")))
-           (result-type (cond ((member "output" result-params) 'output)
-                              ((member "value" result-params) 'value)
-                              (t 'value)))
-           (session (org-babel-R-initiate-session (cdr (assoc :session params)))))
+    (let ((full-body (concat
+		      (mapconcat ;; define any variables
+		       (lambda (pair)
+			 (org-babel-R-assign-elisp (car pair) (cdr pair)))
+		       vars "\n") "\n" body "\n"))
+	  (session (org-babel-R-initiate-session session)))
       (org-babel-R-evaluate session full-body result-type))))
 
 (defun org-babel-prep-session:R (session params)

lisp/langs/org-babel-lisp.el

@@ -37,11 +37,10 @@
 
 (defun org-babel-execute:emacs-lisp (body params)
   "Execute a block of emacs-lisp code with org-babel.  This
-function is called by `org-babel-execute-src-block'."
+function is called by `org-babel-execute-src-block' via multiple-value-bind."
   (message "executing emacs-lisp code block...")
   (save-window-excursion
-    (let ((vars (org-babel-ref-variables params))
-          (print-level nil) (print-length nil) results)
+    (let ((print-level nil) (print-length nil) results)
       (setq results
             (eval `(let ,(mapcar (lambda (var) `(,(car var) ',(cdr var))) vars)
                      ,(read (concat "(progn " body ")")))))

lisp/langs/org-babel-python.el

@@ -38,21 +38,16 @@
 
 (defun org-babel-execute:python (body params)
   "Execute a block of Python code with org-babel.  This function is
-called by `org-babel-execute-src-block'."
+called by `org-babel-execute-src-block' via multiple-value-bind."
   (message "executing Python source code block")
-  (let* ((vars (org-babel-ref-variables params))
-         (result-params (split-string (or (cdr (assoc :results params)) "")))
-         (result-type (cond ((member "output" result-params) 'output)
-                            ((member "value" result-params) 'value)
-                            (t 'value)))
-         (full-body (concat
-                     (mapconcat ;; define any variables
-                      (lambda (pair)
-                        (format "%s=%s"
-                                (car pair)
-                                (org-babel-python-var-to-python (cdr pair))))
-                      vars "\n") "\n" (org-babel-trim body) "\n")) ;; then the source block body
-         (session (org-babel-python-initiate-session (cdr (assoc :session params)))))
+  (let ((full-body (concat
+		    (mapconcat ;; define any variables
+		     (lambda (pair)
+		       (format "%s=%s"
+			       (car pair)
+			       (org-babel-python-var-to-python (cdr pair))))
+		     vars "\n") "\n" (org-babel-trim body) "\n")) ;; then the source block body
+	(session (org-babel-python-initiate-session session)))
     (org-babel-python-evaluate session full-body result-type)))
 
 (defun org-babel-prep-session:python (session params)

lisp/langs/org-babel-ruby.el

@@ -38,21 +38,16 @@
 
 (defun org-babel-execute:ruby (body params)
   "Execute a block of Ruby code with org-babel.  This function is
-called by `org-babel-execute-src-block'."
+called by `org-babel-execute-src-block' via multiple-value-bind."
   (message "executing Ruby source code block")
-  (let* ((vars (org-babel-ref-variables params))
-         (result-params (split-string (or (cdr (assoc :results params)) "")))
-         (result-type (cond ((member "output" result-params) 'output)
-                            ((member "value" result-params) 'value)
-                            (t 'value)))
-         (full-body (concat
-                     (mapconcat ;; define any variables
-                      (lambda (pair)
-                        (format "%s=%s"
-                                (car pair)
-                                (org-babel-ruby-var-to-ruby (cdr pair))))
-                      vars "\n") "\n" body "\n")) ;; then the source block body
-         (session (org-babel-ruby-initiate-session (cdr (assoc :session params)))))
+  (let ((full-body (concat
+		    (mapconcat ;; define any variables
+		     (lambda (pair)
+		       (format "%s=%s"
+			       (car pair)
+			       (org-babel-ruby-var-to-ruby (cdr pair))))
+		     vars "\n") "\n" body "\n")) ;; then the source block body
+	(session (org-babel-ruby-initiate-session session)))
     (org-babel-ruby-evaluate session full-body result-type)))
 
 (defun org-babel-prep-session:ruby (session params)

lisp/langs/org-babel-sh.el

@@ -38,21 +38,16 @@
 
 (defun org-babel-execute:sh (body params)
   "Execute a block of Shell commands with org-babel.  This
-function is called by `org-babel-execute-src-block'."
+function is called by `org-babel-execute-src-block' via multiple-value-bind."
   (message "executing Shell source code block")
-  (let* ((vars (org-babel-ref-variables params))
-         (result-params (split-string (or (cdr (assoc :results params)) "")))
-         (result-type (cond ((member "output" result-params) 'output)
-                            ((member "value" result-params) 'value)
-                            (t 'value)))
-         (full-body (concat
+  (let* ((full-body (concat
                      (mapconcat ;; define any variables
                       (lambda (pair)
                         (format "%s=%s"
                                 (car pair)
                                 (org-babel-sh-var-to-sh (cdr pair))))
                       vars "\n") "\n" body "\n\n")) ;; then the source block body
-         (session (org-babel-sh-initiate-session (cdr (assoc :session params)))))
+         (session (org-babel-sh-initiate-session session)))
     (org-babel-sh-evaluate session full-body result-type)))
 
 (defun org-babel-prep-session:sh (session params)

lisp/org-babel-exp.el

@@ -84,8 +84,12 @@ options and are taken from `org-babel-defualt-inline-header-args'."
             (if (string-match "\n$" body) "" "\n"))))
 
 (defun org-babel-exp-results (body lang params &optional inline)
+  ;; I expect there's a good reason why not, but would it be possible
+  ;; to use org-babel-execute-src-block here? [ded]
   (let* ((cmd (intern (concat "org-babel-execute:" lang)))
-         (result (funcall cmd body params))
+         (result
+	  (multiple-value-bind (session vars result-params result-type)
+	      (org-babel-process-params params) (funcall cmd body params)))
          (result-as-org (org-babel-result-to-org-string result)))
     (if inline
         (format "=%s=" result)

lisp/org-babel.el

@@ -156,20 +156,22 @@ the header arguments specified at the source code block."
          (body (second info))
          (params (org-babel-merge-params
 		  (third info) (org-babel-get-src-block-function-args) params))
-	 (result-params (split-string (or (cdr (assoc :results params)) "")))
-         (result-type (cond ((member "output" result-params) 'output)
-                            ((member "value" result-params) 'value)
-                            (t 'value)))
+	 (processed-params (org-babel-process-params params))
+	 (result-params (third processed-params))
+	 (result-type (fourth processed-params))
          (cmd (intern (concat "org-babel-execute:" lang)))
 	 result)
     ;; (message (format "params=%S" params)) ;; debugging
     (unless (member lang org-babel-interpreters)
       (error "Language is not in `org-babel-interpreters': %s" lang))
     (when arg (setq result-params (cons "silent" result-params)))
-    (setq result (org-babel-process-result (funcall cmd body params) result-type))
+    (setq result
+	  (org-babel-process-result 
+	   (multiple-value-bind (session vars result-params result-type) processed-params
+	     (funcall cmd body params)) result-type))
     (org-babel-insert-result result result-params)
     (case result-type (output nil) (value result))))
-			      
+
 (defun org-babel-process-result (result result-type)
   "This doesn't do anything currently.
 
@@ -330,6 +332,20 @@ of the following form.  (language body header-arguments-alist)"
 		 (cons (intern (concat ":" arg)) nil)))
 	     (split-string (concat " " arg-string) "[ \f\t\n\r\v]+:" t)))))
 
+(defun org-babel-process-params (params)
+  "Parse params and resolve references.
+
+Return a list (session vars result-params result-type). These are
+made available to the org-babel-execute:LANG functions via
+multiple-value-bind."
+  (let* ((session (cdr (assoc :session params)))
+	 (vars (org-babel-ref-variables params))
+	 (result-params (split-string (or (cdr (assoc :results params)) "")))
+	 (result-type (cond ((member "output" result-params) 'output)
+			    ((member "value" result-params) 'value)
+			    (t 'value))))
+    (list session vars result-params result-type)))
+
 (defun org-babel-where-is-src-block-head ()
   "Return the point at the beginning of the current source
 block.  Specifically at the beginning of the #+BEGIN_SRC line.