Merge branch 'master' of git+ssh://repo.or.cz/srv/git/org-mode

contrib/babel/lisp/langs/org-babel-R.el

@@ -37,10 +37,13 @@
 
 (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' via multiple-value-bind."
+called by `org-babel-execute-src-block'."
   (message "executing R source code block...")
   (save-window-excursion
-    (let* ((session (org-babel-R-initiate-session session))
+    (let* ((processed-params (org-babel-process-params params))
+           (result-type (fourth processed-params))
+           (session (org-babel-R-initiate-session (first processed-params)))
+           (vars (second processed-params))
 	   (column-names-p (cdr (assoc :colnames params)))
 	   (out-file (cdr (assoc :file params)))
 	   (augmented-body
@@ -120,8 +123,8 @@ called by `org-babel-execute-src-block' via multiple-value-bind."
 (defvar org-babel-R-wrapper-method "main <- function ()\n{\n%s\n}
 write.table(main(), file=\"%s\", sep=\"\\t\", na=\"nil\",row.names=FALSE, col.names=%s, quote=FALSE)")
 
-(defun org-babel-R-evaluate (buffer body result-type column-names-p)
-  "Pass BODY to the R process in BUFFER.  If RESULT-TYPE equals
+(defun org-babel-R-evaluate (session body result-type column-names-p)
+  "Pass BODY to the R process in SESSION.  If RESULT-TYPE equals
 'output then return a list of the outputs of the statements in
 BODY, if RESULT-TYPE equals 'value then return the value of the
 last statement in BODY, as elisp."
@@ -143,7 +146,7 @@ last statement in BODY, as elisp."
 	   (org-babel-R-process-value-result
 	    (org-babel-import-elisp-from-file out-tmp-file) column-names-p))))
     ;; comint session evaluation
-    (org-babel-comint-in-buffer buffer
+    (org-babel-comint-in-buffer session
       (let* ((tmp-file (make-temp-file "org-babel-R"))
 	     (full-body
 	      (case result-type
@@ -153,7 +156,7 @@ last statement in BODY, as elisp."
 						    org-babel-R-eoe-indicator) "\n"))
 		(output
 		 (mapconcat #'org-babel-chomp (list body org-babel-R-eoe-indicator) "\n"))))
-	     (raw (org-babel-comint-with-output buffer org-babel-R-eoe-output nil
+	     (raw (org-babel-comint-with-output session org-babel-R-eoe-output nil
                     (insert full-body) (inferior-ess-send-input)))
 	     (comint-prompt-regexp
 	      (concat "^\\("

contrib/babel/lisp/langs/org-babel-clojure.el

@@ -195,14 +195,11 @@ last statement in BODY, as elisp."
     (org-babel-clojure-evaluate-external-process buffer body result-type)))
 
 (defun org-babel-execute:clojure (body params)
-  "Execute a block of Clojure code with org-babel.  This function
-is called by `org-babel-execute-src-block' with the following
-variables pre-set using `multiple-value-bind'.
-
-  (session vars result-params result-type)"
-  
-  (let* ((body (org-babel-clojure-build-full-form body vars))     
-         (session (org-babel-clojure-initiate-session session)))  
-    (org-babel-clojure-evaluate session body result-type)))
+  "Execute a block of Clojure code with org-babel."
+  (let* ((processed-params (org-babel-process-params params))
+         (vars (second processed-params))
+         (body (org-babel-clojure-build-full-form body vars))     
+         (session (org-babel-clojure-initiate-session (first processed-params))))  
+    (org-babel-clojure-evaluate session body (fourth processed-params))))
 
 (provide 'org-babel-clojure)

contrib/babel/lisp/langs/org-babel-css.el

@@ -38,7 +38,7 @@
 
 (defun org-babel-execute:css (body params)
   "Execute a block of CSS code with org-babel.  This function is
-called by `org-babel-execute-src-block' via multiple-value-bind."
+called by `org-babel-execute-src-block'."
   (message "executing CSS source code block")
   body)
 

contrib/babel/lisp/langs/org-babel-emacs-lisp.el

@@ -36,16 +36,20 @@
 (add-to-list 'org-babel-tangle-langs '("emacs-lisp" "el"))
 
 (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' via multiple-value-bind."
+  "Execute a block of emacs-lisp code with org-babel."
   (message "executing emacs-lisp code block...")
   (save-window-excursion
-    (let ((print-level nil) (print-length nil))
-      (eval `(let ,(mapcar (lambda (var) `(,(car var) ',(cdr var))) vars)
+    (let* ((processed-params (org-babel-process-params params))
+           (result-params (third processed-params))
+           (vars (second (org-babel-process-params params)))
+           (print-level nil) (print-length nil))
+      (eval `(let ,(mapcar (lambda (var) `(,(car var) ',(cdr var)))
+                           vars)
 	       ,(read (concat "(progn "
 			      (if (or (member "code" result-params)
 				      (member "pp" result-params))
 				  (concat "(pp " body ")") body)
 			      ")")))))))
+
 (provide 'org-babel-emacs-lisp)
 ;;; org-babel-emacs-lisp.el ends here

contrib/babel/lisp/langs/org-babel-gnuplot.el

@@ -70,10 +70,11 @@ variable names and the value to be used in the gnuplot code."
 
 (defun org-babel-execute:gnuplot (body params)
   "Execute a block of Gnuplot code with org-babel.  This function is
-called by `org-babel-execute-src-block' via multiple-value-bind."
+called by `org-babel-execute-src-block'."
   (message "executing Gnuplot source code block")
   (save-window-excursion
     (let* ((vars (org-babel-gnuplot-process-vars params))
+           (session (cdr (assoc :session params)))
            (out-file (cdr (assoc :file params)))
            (term (or (cdr (assoc :term params))
                      (when out-file (file-name-extension out-file))))

contrib/babel/lisp/langs/org-babel-haskell.el

@@ -55,13 +55,13 @@
 (defvar org-babel-haskell-eoe "\"org-babel-haskell-eoe\"")
 
 (defun org-babel-execute:haskell (body params)
-  "Execute a block of Haskell code with org-babel.  This function
-is called by `org-babel-execute-src-block' with the following
-variables pre-set using `multiple-value-bind'.
-
-  (session vars result-params result-type)"
+  "Execute a block of Haskell code with org-babel."
   (message "executing haskell source code block")
-  (let* ((full-body (concat
+  (let* ((processed-params (org-babel-process-params params))
+         (session (first processed-params))
+         (vars (second processed-params))
+         (result-type (fourth processed-params))
+         (full-body (concat
                      (mapconcat
                       (lambda (pair) (format "let %s = %s;" (car pair) (cdr pair)))
                       vars "\n") "\n" body "\n"))

contrib/babel/lisp/langs/org-babel-latex.el

@@ -53,7 +53,7 @@ called by `org-babel-execute-src-block'."
                  (regexp-quote (format "%S" (car pair)))
                  (if (stringp (cdr pair))
                      (cdr pair) (format "%S" (cdr pair)))
-                 body))) vars)
+                 body))) (second (org-babel-process-params params)))
   body)
 
 (defun org-babel-prep-session:latex (session params)

contrib/babel/lisp/langs/org-babel-ocaml.el

@@ -49,13 +49,11 @@
 (defvar org-babel-ocaml-eoe-output "org-babel-ocaml-eoe")
 
 (defun org-babel-execute:ocaml (body params)
-  "Execute a block of Ocaml code with org-babel.  This function
-is called by `org-babel-execute-src-block' with the following
-variables pre-set using `multiple-value-bind'.
-
-  (session vars result-params result-type)"
+  "Execute a block of Ocaml code with org-babel."
   (message "executing ocaml source code block")
-  (let* ((full-body (concat
+  (let* ((processed-params (org-babel-process-params params))
+         (vars (second processed-params))
+         (full-body (concat
                      (mapconcat
                       (lambda (pair) (format "let %s = %s;" (car pair) (cdr pair)))
                       vars "\n") "\n" body "\n"))

contrib/babel/lisp/langs/org-babel-perl.el

@@ -37,9 +37,14 @@
 
 (defun org-babel-execute:perl (body params)
   "Execute a block of Perl code with org-babel.  This function is
-called by `org-babel-execute-src-block' via multiple-value-bind."
+called by `org-babel-execute-src-block'."
   (message "executing Perl source code block")
-  (let ((full-body (concat
+  (let* ((processed-params (org-babel-process-params params))
+         (session (first processed-params))
+         (vars (second processed-params))
+         (result-params (third processed-params))
+         (result-type (fourth processed-params))
+         (full-body (concat
 		    (mapconcat ;; define any variables
 		     (lambda (pair)
 		       (format "$%s=%s;"

contrib/babel/lisp/langs/org-babel-python.el

@@ -38,17 +38,22 @@
 
 (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' via multiple-value-bind."
+called by `org-babel-execute-src-block'."
   (message "executing Python source code block")
-  (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))
-	(result (org-babel-python-evaluate session full-body result-type)))
+  (let* ((processed-params (org-babel-process-params params))
+         (session (org-babel-python-initiate-session (first processed-params)))
+         (vars (second processed-params))
+         (result-params (third processed-params))
+         (result-type (fourth processed-params))
+         (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
+         
+         (result (org-babel-python-evaluate session full-body result-type)))
     (or (cdr (assoc :file params)) result)))
 
 (defun org-babel-prep-session:python (session params)

contrib/babel/lisp/langs/org-babel-ruby.el

@@ -48,17 +48,21 @@
 
 (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' via multiple-value-bind."
+called by `org-babel-execute-src-block'."
   (message "executing Ruby source code block")
-  (let* ((full-body (concat
+  (let* ((processed-params (org-babel-process-params params))
+         (session (org-babel-ruby-initiate-session (first processed-params)))
+         (vars (second processed-params))
+         (result-params (third processed-params))
+         (result-type (fourth processed-params))
+         (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))
-	(result (org-babel-ruby-evaluate session full-body result-type)))
+         (result (org-babel-ruby-evaluate session full-body result-type)))
     (or (cdr (assoc :file params)) result)))
 
 (defun org-babel-prep-session:ruby (session params)

contrib/babel/lisp/langs/org-babel-screen.el

@@ -61,7 +61,10 @@ In case you want to use a different screen than one selected by your $PATH")
 
 (defun org-babel-prep-session:screen (session params)
   "Prepare SESSION according to the header arguments specified in PARAMS."
-  (let* ((socket (org-babel-screen-session-socketname session))
+  (let* ((processed-params (org-babel-process-params params))
+         (session (first processed-params))
+         (vars (second processed-params))
+         (socket (org-babel-screen-session-socketname session))
          (vars (org-babel-ref-variables params))
          (cmd (cdr (assoc :cmd params)))
          (terminal (cdr (assoc :terminal params)))

contrib/babel/lisp/langs/org-babel-sh.el

@@ -38,16 +38,19 @@
 
 (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' via multiple-value-bind."
+function is called by `org-babel-execute-src-block'."
   (message "executing Shell source code block")
-  (let* ((full-body (concat
+  (let* ((processed-params (org-babel-process-params params))
+         (session (org-babel-sh-initiate-session (first processed-params)))
+         (vars (second processed-params))
+         (result-type (fourth processed-params))
+         (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 session)))
+                      vars "\n") "\n" body "\n\n"))) ;; then the source block body
     (org-babel-sh-evaluate session full-body result-type)))
 
 (defun org-babel-prep-session:sh (session params)

contrib/babel/lisp/langs/org-babel-sql.el

@@ -53,7 +53,7 @@
 
 (defun org-babel-execute:sql (body params)
   "Execute a block of Sql code with org-babel.  This function is
-called by `org-babel-execute-src-block' via multiple-value-bind."
+called by `org-babel-execute-src-block'."
   (message "executing Sql source code block")
   (let* ((result-params (split-string (or (cdr (assoc :results params)) "")))
          (cmdline (cdr (assoc :cmdline params)))

contrib/babel/lisp/org-babel-ref.el

@@ -59,8 +59,9 @@
 names, and the emacs-lisp representation of the related value."
   (let ((assignments
 	 (delq nil (mapcar (lambda (pair) (if (eq (car pair) :var) (cdr pair))) params)))
-	(other-params (assq-delete-all :var params)))
-    (mapcar (lambda (assignment) (org-babel-ref-parse assignment other-params)) assignments)))
+	(others
+         (delq nil (mapcar (lambda (pair) (unless (eq :var (car pair)) pair)) params))))
+    (mapcar (lambda (assignment) (org-babel-ref-parse assignment others)) assignments)))
 
 (defvar org-babel-ref-split-regexp
   "[ \f\t\n\r\v]*\\(.+?\\)[ \f\t\n\r\v]*=[ \f\t\n\r\v]*\\(.+\\)[ \f\t\n\r\v]*")

contrib/babel/lisp/org-babel-table.el

@@ -61,12 +61,11 @@
     string))
 
 (defmacro sbe (source-block &rest variables)
-  "Return the results of calling SOURCE-BLOCK with all assigning
-every variable in VARIABLES.  Each element of VARIABLES should be
-a two element list, whose first element is the name of the
-variable and second element is a string of its value.  The
-following call to `sbe' would be equivalent to the following
-source code block.
+  "Return the results of calling SOURCE-BLOCK assigning every
+variable in VARIABLES.  Each element of VARIABLES should be a two
+element list, whose first element is the name of the variable and
+second element is a string of its value.  The following call to
+`sbe' would be equivalent to the following source code block.
 
  (sbe 'source-block (n 2) (m 3))
 
@@ -85,7 +84,9 @@ results
 					   (format "%S=%s" (first var-spec) (second var-spec)))
 					 ',variables ", ")
 			      ")")))))
-         (org-babel-execute-src-block t (list "emacs-lisp" "results" params)))
+         (org-babel-execute-src-block
+          nil (list "emacs-lisp" "results"
+                    (org-babel-merge-params '((:results . "silent")) params))))
      "")))
 
 (provide 'org-babel-table)

contrib/babel/lisp/org-babel.el

@@ -184,20 +184,23 @@ the header arguments specified at the source code block."
          (body (setf (second info)
 		     (if (assoc :noweb params)
 			 (org-babel-expand-noweb-references info) (second info))))
-         (processed-params (org-babel-process-params params))
-         (result-params (third processed-params))
-         (result-type (fourth processed-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)))
          (cmd (intern (concat "org-babel-execute:" lang)))
          result)
-    ;; (message "params=%S" params) ;; debugging statement
-    ;; (message "vars=%S" (second processed-params)) ;; debugging statement
+    ;; (message "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 (multiple-value-bind (session vars result-params result-type) processed-params
-                   (funcall cmd body params)))
+    (setq result (funcall cmd body params))
     (if (eq result-type 'value)
-        (setq result (org-babel-process-value-result result result-params)))
+        (setq result (if (and (or (member "vector" result-params)
+                                  (member "table" result-params))
+                              (not (listp result)))
+                         (list (list result))
+                       result)))
     (org-babel-insert-result result result-params info)
     result))
 
@@ -267,26 +270,6 @@ results already exist."
               (insert (echo-res results))))))
       t)))
 
-(defun org-babel-process-value-result (result result-params)
-  "Process returned value for insertion in buffer.
-
-Currently, this function forces to table output if :results
-table or :results vector has been supplied.
-
-  You can see below the various fragments of results-processing
-code that were present in the language-specific files. Out of
-those fragments, I've moved the org-babel-python-table-or-results
-and org-babel-import-elisp-from-file functionality into the
-org-babel-*-evaluate functions. I think those should only be used
-in the :results value case, as in the 'output case we are not
-concerned with creating elisp versions of results. "
-
-  (if (and (or (member "vector" result-params)
-               (member "table" result-params))
-           (not (listp result)))
-      (list (list result))
-    result))
-
 (defun org-babel-execute-buffer (&optional arg)
   "Replace EVAL snippets in the entire buffer."
   (interactive "P")
@@ -413,9 +396,7 @@ may be specified in the properties of the current outline entry."
 (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."
+Return a list (session vars result-params result-type)."
   (let* ((session (cdr (assoc :session params)))
 	 (vars (org-babel-ref-variables params))
 	 (result-params (split-string (or (cdr (assoc :results params)) "")))