babel: `org-babel-comint-with-output' no longer assumes `full-body' variable

* lisp/babel/ob-comint.el (org-babel-comint-with-output):
  Fixed egregious oversight in which we were assuming that the
  `full-body' variable would be in scope at the time of macro
  execution.  Thanks to the compiler for finding this bug.

* lisp/babel/langs/ob-R.el (org-babel-R-evaluate): now using the fixed
  `org-babel-comint-with-output' macro

* lisp/babel/langs/ob-haskell.el (org-babel-execute:haskell): now
  using the fixed `org-babel-comint-with-output' macro

* lisp/babel/langs/ob-ocaml.el (org-babel-execute:ocaml): now using
  the fixed `org-babel-comint-with-output' macro

* lisp/babel/langs/ob-octave.el (org-babel-octave-evaluate-session):
  now using the fixed `org-babel-comint-with-output' macro

* lisp/babel/langs/ob-python.el (org-babel-python-evaluate): now using
  the fixed `org-babel-comint-with-output' macro

* lisp/babel/langs/ob-ruby.el (org-babel-ruby-evaluate): now using the
  fixed `org-babel-comint-with-output' macro

* lisp/babel/langs/ob-sh.el (org-babel-sh-evaluate): now using the
  fixed `org-babel-comint-with-output' macro

lisp/babel/langs/ob-R.el

@@ -212,8 +212,9 @@ 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 session org-babel-R-eoe-output nil
-                    (insert full-body) (inferior-ess-send-input)))
+	     (raw
+	      (org-babel-comint-with-output (list session org-babel-R-eoe-output)
+		(insert full-body) (inferior-ess-send-input)))
 	     (comint-prompt-regexp
 	      (concat "^\\("
 		      inferior-ess-primary-prompt

lisp/babel/langs/ob-haskell.el

@@ -71,7 +71,8 @@
          (result-type (fourth processed-params))
          (full-body (org-babel-expand-body:haskell body params processed-params))
          (session (org-babel-prep-session:haskell session params))
-         (raw (org-babel-comint-with-output session org-babel-haskell-eoe t
+         (raw (org-babel-comint-with-output
+		  (list session org-babel-haskell-eoe t full-body)
                 (insert (org-babel-trim full-body))
                 (comint-send-input nil t)
                 (insert org-babel-haskell-eoe)

lisp/babel/langs/ob-ocaml.el

@@ -63,7 +63,8 @@
          (vars (second processed-params))
          (full-body (org-babel-expand-body:ocaml body params processed-params))
          (session (org-babel-prep-session:ocaml session params))
-         (raw (org-babel-comint-with-output session org-babel-ocaml-eoe-output t
+         (raw (org-babel-comint-with-output
+		  (list session org-babel-ocaml-eoe-output t full-body)
                 (insert (concat (org-babel-chomp full-body) " ;;"))
                 (comint-send-input nil t)
                 (insert org-babel-ocaml-eoe-indicator)

lisp/babel/langs/ob-octave.el

@@ -181,8 +181,12 @@ statement in BODY, as elisp."
 			   ;; make *matlab* buffer contents easily
 			   ;; available, so :results output currently
 			   ;; won't work
-		(org-babel-comint-with-output session
-		    (if matlabp org-babel-octave-eoe-indicator org-babel-octave-eoe-output) t
+		(org-babel-comint-with-output
+		    (list session
+			  (if matlabp
+			      org-babel-octave-eoe-indicator
+			    org-babel-octave-eoe-output)
+			  t full-body)
 		  (insert full-body) (comint-send-input nil t)))) results)
     (case result-type
       (value

lisp/babel/langs/ob-python.el

@@ -217,7 +217,8 @@ last statement in BODY, as elisp."
                  (org-babel-python-table-or-string raw)))))))
     ;; comint session evaluation
     (org-babel-comint-in-buffer buffer
-      (let* ((raw (org-babel-comint-with-output buffer org-babel-python-eoe-indicator t
+      (let* ((raw (org-babel-comint-with-output
+		      (list buffer org-babel-python-eoe-indicator t full-body)
                     ;; for some reason python is fussy, and likes enters after every input
 		    (let ((comint-process-echoes nil))
 		      (mapc (lambda (statement) (insert statement) (comint-send-input))

lisp/babel/langs/ob-ruby.el

@@ -214,7 +214,7 @@ last statement in BODY, as elisp."
                           org-babel-ruby-last-value-eval)
                    org-babel-ruby-eoe-indicator) "\n"))
            (raw (org-babel-comint-with-output
-		    buffer org-babel-ruby-eoe-indicator t
+		    (list buffer org-babel-ruby-eoe-indicator t full-body)
                   (insert full-body) (comint-send-input nil t)))
            (results (cdr (member
 			  org-babel-ruby-eoe-indicator

lisp/babel/langs/ob-sh.el

@@ -166,7 +166,7 @@ last statement in BODY."
                      (mapcar #'org-babel-sh-strip-weird-long-prompt
                              (mapcar #'org-babel-trim
                                      (org-babel-comint-with-output
-                                         session org-babel-sh-eoe-output t
+                                         (list session org-babel-sh-eoe-output t full-body)
                                        (mapc (lambda (line) (insert line) (comint-send-input))
                                              (strip-empty (split-string body "\n")))
                                        (insert org-babel-sh-eoe-indicator)

lisp/babel/ob-comint.el

@@ -53,55 +53,65 @@ body inside the protection of `save-window-excursion' and
        (set-buffer ,buffer)
        ,@body)))
 
-(defmacro org-babel-comint-with-output
-  (buffer eoe-indicator remove-echo &rest body)
+(defmacro org-babel-comint-with-output (meta &rest body)
   "Evaluate BODY in BUFFER, wait until EOE-INDICATOR appears in
-output, then return all process output.  This ensures that the
-filter is removed in case of an error or user `keyboard-quit'
-during execution of body."
-  (declare (indent 3))
-  `(org-babel-comint-in-buffer ,buffer
-     (let ((string-buffer "") dangling-text)
-       (flet ((my-filt (text) (setq string-buffer (concat string-buffer text))))
-         ;; setup filter
-         (add-hook 'comint-output-filter-functions 'my-filt)
-         (unwind-protect
-             (progn
-               ;; got located, and save dangling text
-               (goto-char (process-mark (get-buffer-process (current-buffer))))
-	       (let ((start (point))
-		     (end (point-max)))
-		 (setq dangling-text (buffer-substring start end))
-		 (delete-region start end))
-	       ;; pass FULL-BODY to process
-               ,@body
-               ;; wait for end-of-evaluation indicator
-               (while (progn
-                        (goto-char comint-last-input-end)
-                        (not (save-excursion
-			       (and (re-search-forward
-				     comint-prompt-regexp nil t)
-				    (re-search-forward
-				     (regexp-quote ,eoe-indicator) nil t)))))
-                 (accept-process-output (get-buffer-process (current-buffer)))
-                 ;; thought the following this would allow async
-                 ;; background running, but I was wrong...
-                 ;; (run-with-timer .5 .5 'accept-process-output
-		 ;; 		 (get-buffer-process (current-buffer)))
-                 )
-	       ;; replace cut dangling text
-	       (goto-char (process-mark (get-buffer-process (current-buffer))))
-	       (insert dangling-text))
-           ;; remove filter
-           (remove-hook 'comint-output-filter-functions 'my-filt)))
-       ;; remove echo'd FULL-BODY from input
-       (if (and ,remove-echo
-		(string-match
-		 (replace-regexp-in-string
-		  "\n" "[\r\n]+" (regexp-quote ,full-body))
-		 string-buffer))
-           (setq raw (substring string-buffer (match-end 0))))
-       (split-string string-buffer comint-prompt-regexp))))
+output, then return all process output.  If REMOVE-ECHO and
+FULL-BODY are present and non-nil, then strip echo'd body from
+the returned output.  META should be a list containing the
+following where the last two elements are optional.
+
+ (BUFFER EOE-INDICATOR REMOVE-ECHO FULL-BODY)
+
+This macro ensures that the filter is removed in case of an error
+or user `keyboard-quit' during execution of body."
+  (declare (indent 1))
+  (let ((buffer (car meta))
+	(eoe-indicator (cadr meta))
+	(remove-echo (caddr meta))
+	(full-body (cadddr meta)))
+    `(org-babel-comint-in-buffer ,buffer
+       (let ((string-buffer "") dangling-text)
+	 (flet ((my-filt (text)
+			 (setq string-buffer (concat string-buffer text))))
+	   ;; setup filter
+	   (add-hook 'comint-output-filter-functions 'my-filt)
+	   (unwind-protect
+	       (progn
+		 ;; got located, and save dangling text
+		 (goto-char (process-mark (get-buffer-process (current-buffer))))
+		 (let ((start (point))
+		       (end (point-max)))
+		   (setq dangling-text (buffer-substring start end))
+		   (delete-region start end))
+		 ;; pass FULL-BODY to process
+		 ,@body
+		 ;; wait for end-of-evaluation indicator
+		 (while (progn
+			  (goto-char comint-last-input-end)
+			  (not (save-excursion
+				 (and (re-search-forward
+				       comint-prompt-regexp nil t)
+				      (re-search-forward
+				       (regexp-quote ,eoe-indicator) nil t)))))
+		   (accept-process-output (get-buffer-process (current-buffer)))
+		   ;; thought the following this would allow async
+		   ;; background running, but I was wrong...
+		   ;; (run-with-timer .5 .5 'accept-process-output
+		   ;; 		 (get-buffer-process (current-buffer)))
+		   )
+		 ;; replace cut dangling text
+		 (goto-char (process-mark (get-buffer-process (current-buffer))))
+		 (insert dangling-text))
+	     ;; remove filter
+	     (remove-hook 'comint-output-filter-functions 'my-filt)))
+	 ;; remove echo'd FULL-BODY from input
+	 (if (and ,remove-echo ,full-body
+		  (string-match
+		   (replace-regexp-in-string
+		    "\n" "[\r\n]+" (regexp-quote ,full-body))
+		   string-buffer))
+	     (setq raw (substring string-buffer (match-end 0))))
+	 (split-string string-buffer comint-prompt-regexp)))))
 
 (defun org-babel-comint-input-command (buffer cmd)
   "Pass CMD to BUFFER  The input will not be echoed."