Update to org-mode 8.0.2
authorJoerg Jaspert <joerg@debian.org>
Sun, 12 May 2013 10:10:53 +0000 (12:10 +0200)
committerJoerg Jaspert <joerg@debian.org>
Sun, 12 May 2013 10:10:53 +0000 (12:10 +0200)
167 files changed:
.emacs.d/elisp/org/ob-C.el
.emacs.d/elisp/org/ob-R.el
.emacs.d/elisp/org/ob-awk.el
.emacs.d/elisp/org/ob-calc.el
.emacs.d/elisp/org/ob-clojure.el
.emacs.d/elisp/org/ob-comint.el
.emacs.d/elisp/org/ob-core.el
.emacs.d/elisp/org/ob-ditaa.el
.emacs.d/elisp/org/ob-dot.el
.emacs.d/elisp/org/ob-emacs-lisp.el
.emacs.d/elisp/org/ob-eval.el
.emacs.d/elisp/org/ob-exp.el
.emacs.d/elisp/org/ob-fortran.el
.emacs.d/elisp/org/ob-gnuplot.el
.emacs.d/elisp/org/ob-haskell.el
.emacs.d/elisp/org/ob-io.el
.emacs.d/elisp/org/ob-java.el
.emacs.d/elisp/org/ob-js.el
.emacs.d/elisp/org/ob-keys.el
.emacs.d/elisp/org/ob-latex.el
.emacs.d/elisp/org/ob-lilypond.el
.emacs.d/elisp/org/ob-lisp.el
.emacs.d/elisp/org/ob-lob.el
.emacs.d/elisp/org/ob-maxima.el
.emacs.d/elisp/org/ob-mscgen.el
.emacs.d/elisp/org/ob-ocaml.el
.emacs.d/elisp/org/ob-octave.el
.emacs.d/elisp/org/ob-org.el
.emacs.d/elisp/org/ob-perl.el
.emacs.d/elisp/org/ob-picolisp.el
.emacs.d/elisp/org/ob-plantuml.el
.emacs.d/elisp/org/ob-python.el
.emacs.d/elisp/org/ob-ref.el
.emacs.d/elisp/org/ob-ruby.el
.emacs.d/elisp/org/ob-sass.el
.emacs.d/elisp/org/ob-scala.el
.emacs.d/elisp/org/ob-scheme.el
.emacs.d/elisp/org/ob-screen.el
.emacs.d/elisp/org/ob-sh.el
.emacs.d/elisp/org/ob-shen.el
.emacs.d/elisp/org/ob-sql.el
.emacs.d/elisp/org/ob-sqlite.el
.emacs.d/elisp/org/ob-table.el
.emacs.d/elisp/org/ob-tangle.el
.emacs.d/elisp/org/ob.el
.emacs.d/elisp/org/org-agenda.el
.emacs.d/elisp/org/org-archive.el
.emacs.d/elisp/org/org-ascii.el [deleted file]
.emacs.d/elisp/org/org-attach.el
.emacs.d/elisp/org/org-bbdb.el
.emacs.d/elisp/org/org-beamer.el [deleted file]
.emacs.d/elisp/org/org-bibtex-extras.el
.emacs.d/elisp/org/org-bibtex.el
.emacs.d/elisp/org/org-bookmark.el
.emacs.d/elisp/org/org-bullets.el [new file with mode: 0644]
.emacs.d/elisp/org/org-capture.el
.emacs.d/elisp/org/org-checklist.el
.emacs.d/elisp/org/org-choose.el
.emacs.d/elisp/org/org-clock.el
.emacs.d/elisp/org/org-collector.el
.emacs.d/elisp/org/org-colview-xemacs.el
.emacs.d/elisp/org/org-colview.el
.emacs.d/elisp/org/org-compat.el
.emacs.d/elisp/org/org-contacts.el
.emacs.d/elisp/org/org-contribdir.el
.emacs.d/elisp/org/org-crypt.el
.emacs.d/elisp/org/org-datetree.el
.emacs.d/elisp/org/org-depend.el
.emacs.d/elisp/org/org-docbook.el [deleted file]
.emacs.d/elisp/org/org-docview.el
.emacs.d/elisp/org/org-drill.el
.emacs.d/elisp/org/org-e-ascii.el [deleted file]
.emacs.d/elisp/org/org-e-beamer.el [deleted file]
.emacs.d/elisp/org/org-e-groff.el [deleted file]
.emacs.d/elisp/org/org-e-html.el [deleted file]
.emacs.d/elisp/org/org-e-latex.el [deleted file]
.emacs.d/elisp/org/org-e-man.el [deleted file]
.emacs.d/elisp/org/org-e-odt.el [deleted file]
.emacs.d/elisp/org/org-e-publish.el [deleted file]
.emacs.d/elisp/org/org-e-texinfo.el [deleted file]
.emacs.d/elisp/org/org-element.el
.emacs.d/elisp/org/org-elisp-symbol.el
.emacs.d/elisp/org/org-entities.el
.emacs.d/elisp/org/org-eval-light.el
.emacs.d/elisp/org/org-eval.el
.emacs.d/elisp/org/org-exp-bibtex.el [deleted file]
.emacs.d/elisp/org/org-exp-blocks.el [deleted file]
.emacs.d/elisp/org/org-exp.el [deleted file]
.emacs.d/elisp/org/org-expiry.el
.emacs.d/elisp/org/org-export-generic.el [deleted file]
.emacs.d/elisp/org/org-export.el [deleted file]
.emacs.d/elisp/org/org-faces.el
.emacs.d/elisp/org/org-favtable.el [new file with mode: 0644]
.emacs.d/elisp/org/org-footnote.el
.emacs.d/elisp/org/org-freemind.el [deleted file]
.emacs.d/elisp/org/org-git-link.el
.emacs.d/elisp/org/org-gnus.el
.emacs.d/elisp/org/org-html.el [deleted file]
.emacs.d/elisp/org/org-icalendar.el [deleted file]
.emacs.d/elisp/org/org-id.el
.emacs.d/elisp/org/org-indent.el
.emacs.d/elisp/org/org-inlinetask.el
.emacs.d/elisp/org/org-interactive-query.el
.emacs.d/elisp/org/org-invoice.el
.emacs.d/elisp/org/org-jira.el [deleted file]
.emacs.d/elisp/org/org-jsinfo.el [deleted file]
.emacs.d/elisp/org/org-latex.el [deleted file]
.emacs.d/elisp/org/org-learn.el
.emacs.d/elisp/org/org-list.el
.emacs.d/elisp/org/org-loaddefs.el
.emacs.d/elisp/org/org-lparse.el [deleted file]
.emacs.d/elisp/org/org-mac-iCal.el
.emacs.d/elisp/org/org-mac-link-grabber.el
.emacs.d/elisp/org/org-mac-message.el
.emacs.d/elisp/org/org-macro.el
.emacs.d/elisp/org/org-macs.el
.emacs.d/elisp/org/org-mairix.el
.emacs.d/elisp/org/org-man.el
.emacs.d/elisp/org/org-md.el [deleted file]
.emacs.d/elisp/org/org-mew.el
.emacs.d/elisp/org/org-mime.el
.emacs.d/elisp/org/org-mks.el [deleted file]
.emacs.d/elisp/org/org-mobile.el
.emacs.d/elisp/org/org-mouse.el
.emacs.d/elisp/org/org-mtags.el
.emacs.d/elisp/org/org-notify.el
.emacs.d/elisp/org/org-notmuch.el
.emacs.d/elisp/org/org-odt.el [deleted file]
.emacs.d/elisp/org/org-panel.el
.emacs.d/elisp/org/org-pcomplete.el
.emacs.d/elisp/org/org-plot.el
.emacs.d/elisp/org/org-protocol.el
.emacs.d/elisp/org/org-publish.el [deleted file]
.emacs.d/elisp/org/org-registry.el
.emacs.d/elisp/org/org-remember.el [deleted file]
.emacs.d/elisp/org/org-screen.el
.emacs.d/elisp/org/org-secretary.el
.emacs.d/elisp/org/org-special-blocks.el [deleted file]
.emacs.d/elisp/org/org-src.el
.emacs.d/elisp/org/org-static-mathjax.el
.emacs.d/elisp/org/org-sudoku.el
.emacs.d/elisp/org/org-table.el
.emacs.d/elisp/org/org-taskjuggler.el [deleted file]
.emacs.d/elisp/org/org-toc.el
.emacs.d/elisp/org/org-track.el
.emacs.d/elisp/org/org-velocity.el
.emacs.d/elisp/org/org-version.el
.emacs.d/elisp/org/org-vm.el
.emacs.d/elisp/org/org-w3m.el
.emacs.d/elisp/org/org-wikinodes.el
.emacs.d/elisp/org/org-wl.el
.emacs.d/elisp/org/org-xoxo.el [deleted file]
.emacs.d/elisp/org/org.el
.emacs.d/elisp/org/orgtbl-sqlinsert.el [new file with mode: 0644]
.emacs.d/elisp/org/ox-ascii.el
.emacs.d/elisp/org/ox-beamer.el
.emacs.d/elisp/org/ox-html.el
.emacs.d/elisp/org/ox-icalendar.el
.emacs.d/elisp/org/ox-jsinfo.el [deleted file]
.emacs.d/elisp/org/ox-latex.el
.emacs.d/elisp/org/ox-man.el
.emacs.d/elisp/org/ox-md.el
.emacs.d/elisp/org/ox-odt.el
.emacs.d/elisp/org/ox-org.el
.emacs.d/elisp/org/ox-publish.el
.emacs.d/elisp/org/ox-texinfo.el
.emacs.d/elisp/org/ox.el

index 42a98de..b1e8a06 100644 (file)
@@ -31,7 +31,6 @@
 
 ;;; Code:
 (require 'ob)
-(require 'ob-eval)
 (require 'cc-mode)
 
 (declare-function org-entry-get "org"
@@ -106,11 +105,11 @@ or `org-babel-execute:C++'."
                     (org-babel-process-file-name tmp-src-file)) ""))))
     ((lambda (results)
        (org-babel-reassemble-table
-       (if (member "vector" (cdr (assoc :result-params params)))
-           (let ((tmp-file (org-babel-temp-file "c-")))
-             (with-temp-file tmp-file (insert results))
-             (org-babel-import-elisp-from-file tmp-file))
-         (org-babel-read results))
+       (org-babel-result-cond (cdr (assoc :result-params params))
+         (org-babel-read results)
+         (let ((tmp-file (org-babel-temp-file "c-")))
+           (with-temp-file tmp-file (insert results))
+           (org-babel-import-elisp-from-file tmp-file)))
        (org-babel-pick-name
         (cdr (assoc :colname-names params)) (cdr (assoc :colnames params)))
        (org-babel-pick-name
index 562f37d..67d3c37 100644 (file)
@@ -28,9 +28,6 @@
 
 ;;; Code:
 (require 'ob)
-(require 'ob-ref)
-(require 'ob-comint)
-(require 'ob-eval)
 (eval-when-compile (require 'cl))
 
 (declare-function orgtbl-to-tsv "org-table" (table params))
@@ -212,6 +209,9 @@ This function is called by `org-babel-execute-src-block'."
       (if (org-babel-comint-buffer-livep session)
          session
        (save-window-excursion
+         (when (get-buffer session)
+           ;; Session buffer exists, but with dead process
+           (set-buffer session))
          (require 'ess) (R)
          (rename-buffer
           (if (bufferp session)
@@ -240,7 +240,7 @@ current code buffer."
         '((:bmp . "bmp")
           (:jpg . "jpeg")
           (:jpeg . "jpeg")
-          (:tex . "tikz")
+          (:tikz . "tikz")
           (:tiff . "tiff")
           (:png . "png")
           (:svg . "svg")
@@ -302,11 +302,10 @@ last statement in BODY, as elisp."
                               (format "{function ()\n{\n%s\n}}()" body)
                               (org-babel-process-file-name tmp-file 'noquote)))
        (org-babel-R-process-value-result
-       (if (or (member "scalar" result-params)
-               (member "verbatim" result-params))
-           (with-temp-buffer
-             (insert-file-contents tmp-file)
-             (buffer-string))
+       (org-babel-result-cond result-params
+         (with-temp-buffer
+           (insert-file-contents tmp-file)
+           (buffer-string))
          (org-babel-import-elisp-from-file tmp-file '(16)))
        column-names-p)))
     (output (org-babel-eval org-babel-R-command body))))
@@ -335,11 +334,10 @@ last statement in BODY, as elisp."
                  "FALSE")
                ".Last.value" (org-babel-process-file-name tmp-file 'noquote)))
        (org-babel-R-process-value-result
-       (if (or (member "scalar" result-params)
-               (member "verbatim" result-params))
-           (with-temp-buffer
-             (insert-file-contents tmp-file)
-             (buffer-string))
+       (org-babel-result-cond result-params
+         (with-temp-buffer
+           (insert-file-contents tmp-file)
+           (buffer-string))
          (org-babel-import-elisp-from-file tmp-file '(16)))
        column-names-p)))
     (output
index 12d625a..373d5fd 100644 (file)
@@ -32,7 +32,6 @@
 
 ;;; Code:
 (require 'ob)
-(require 'ob-eval)
 (require 'org-compat)
 (eval-when-compile (require 'cl))
 
@@ -45,7 +44,7 @@
 (defvar org-babel-awk-command "awk"
   "Name of the awk executable command.")
 
-(defun org-babel-expand-body:awk (body params &optional processed-params)
+(defun org-babel-expand-body:awk (body params)
   "Expand BODY according to PARAMS, return the expanded body."
   (dolist (pair (mapcar #'cdr (org-babel-get-header params :var)))
     (setf body (replace-regexp-in-string
@@ -78,10 +77,8 @@ called by `org-babel-execute-src-block'"
     (org-babel-reassemble-table
      ((lambda (results)
        (when results
-         (if (or (member "scalar" result-params)
-                 (member "verbatim" result-params)
-                 (member "output" result-params))
-             results
+         (org-babel-result-cond result-params
+           results
            (let ((tmp (org-babel-temp-file "awk-results-")))
              (with-temp-file tmp (insert results))
              (org-babel-import-elisp-from-file tmp)))))
index a8e53c0..766f6ce 100644 (file)
@@ -31,7 +31,6 @@
 (unless (featurep 'xemacs)
   (require 'calc-trail)
   (require 'calc-store))
-(eval-when-compile (require 'ob-comint))
 
 (declare-function calc-store-into    "calc-store" (&optional var))
 (declare-function calc-recall        "calc-store" (&optional var))
index b020498..bc2bbc0 100644 (file)
@@ -79,9 +79,8 @@
     (insert (org-babel-expand-body:clojure body params))
     ((lambda (result)
        (let ((result-params (cdr (assoc :result-params params))))
-        (if (or (member "scalar" result-params)
-                (member "verbatim" result-params))
-            result
+        (org-babel-result-cond result-params
+          result
           (condition-case nil (org-babel-script-escape result)
             (error result)))))
      (slime-eval
index 5ea3be2..f156297 100644 (file)
@@ -30,7 +30,7 @@
 ;; org-babel at large.
 
 ;;; Code:
-(require 'ob)
+(require 'ob-core)
 (require 'org-compat)
 (require 'comint)
 (eval-when-compile (require 'cl))
index 3278bf9..55d8f45 100644 (file)
@@ -33,7 +33,8 @@
   (if (memq system-type '(windows-nt cygwin))
       ".exe"
     nil))
-(defvar org-babel-call-process-region-original)
+;; dynamically scoped for tramp
+(defvar org-babel-call-process-region-original nil)
 (defvar org-src-lang-modes)
 (defvar org-babel-library-of-babel)
 (declare-function show-all "outline" ())
@@ -135,6 +136,8 @@ remove code block execution from the C-c C-c keybinding."
 Should be either RESULTS or NAME however any capitalization may
 be used."
   :group 'org-babel
+  :version "24.4"
+  :package-version '(Org . "8.0")
   :type 'string)
 
 (defcustom org-babel-noweb-wrap-start "<<"
@@ -167,7 +170,7 @@ See also `org-babel-noweb-wrap-start'."
          "\\("
          org-babel-multi-line-header-regexp
          "\\)*"
-         "\\([^ ()\f\t\n\r\v]+\\)\\(\(\\(.*\\)\)\\|\\)")
+         "\\([^ ()\f\t\n\r\v]+\\)")
   "Regular expression matching source name lines with a name.")
 
 (defvar org-babel-src-block-regexp
@@ -258,21 +261,7 @@ Returns a list
                   (nth 2 info)
                   (org-babel-parse-header-arguments (match-string 1)))))
          (when (looking-at org-babel-src-name-w-name-regexp)
-           (setq name (org-no-properties (match-string 3)))
-           (when (and (match-string 5) (> (length (match-string 5)) 0))
-             (setf (nth 2 info) ;; merge functional-syntax vars and header-args
-                   (org-babel-merge-params
-                    (mapcar
-                     (lambda (ref) (cons :var ref))
-                     (mapcar
-                      (lambda (var) ;; check that each variable is initialized
-                        (if (string-match ".+=.+" var)
-                            var
-                          (error
-                           "variable \"%s\"%s must be assigned a default value"
-                           var (if name (format " in block \"%s\"" name) ""))))
-                      (org-babel-ref-split-args (match-string 5))))
-                    (nth 2 info))))))
+           (setq name (org-no-properties (match-string 3)))))
       ;; inline source block
       (when (org-babel-get-inline-src-block-matches)
        (setq info (org-babel-parse-inline-src-block-match))))
@@ -282,42 +271,72 @@ Returns a list
     (when info (append info (list name indent)))))
 
 (defvar org-current-export-file) ; dynamically bound
-(defun org-babel-confirm-evaluate (info)
+(defmacro org-babel-check-confirm-evaluate (info &rest body)
+  "Evaluate BODY with special execution confirmation variables set.
+
+Specifically; NOEVAL will indicate if evaluation is allowed,
+QUERY will indicate if a user query is required, CODE-BLOCK will
+hold the language of the code block, and BLOCK-NAME will hold the
+name of the code block."
+  (declare (indent defun))
+  (org-with-gensyms
+      (lang block-body headers name eval eval-no export eval-no-export)
+    `(let* ((,lang           (nth 0 ,info))
+           (,block-body     (nth 1 ,info))
+           (,headers        (nth 2 ,info))
+           (,name           (nth 4 ,info))
+           (,eval           (or (cdr  (assoc :eval   ,headers))
+                                (when (assoc :noeval ,headers) "no")))
+           (,eval-no        (or (equal ,eval "no")
+                                (equal ,eval "never")))
+           (,export         (org-bound-and-true-p org-current-export-file))
+           (,eval-no-export (and ,export (or (equal ,eval "no-export")
+                                             (equal ,eval "never-export"))))
+           (noeval          (or ,eval-no ,eval-no-export))
+           (query           (or (equal ,eval "query")
+                                (and ,export (equal ,eval "query-export"))
+                                (when (functionp org-confirm-babel-evaluate)
+                                  (funcall org-confirm-babel-evaluate
+                                           ,lang ,block-body))
+                                org-confirm-babel-evaluate))
+           (code-block      (if ,info (format  " %s "  ,lang) " "))
+           (block-name      (if ,name (format " (%s) " ,name) " ")))
+       ,@body)))
+
+(defsubst org-babel-check-evaluate (info)
+  "Check if code block INFO should be evaluated.
+Do not query the user."
+  (org-babel-check-confirm-evaluate info
+    (not (when noeval
+          (message (format "Evaluation of this%scode-block%sis disabled."
+                           code-block block-name))))))
+
+ ;; dynamically scoped for asynchroneous export
+(defvar org-babel-confirm-evaluate-answer-no)
+
+(defsubst org-babel-confirm-evaluate (info)
   "Confirm evaluation of the code block INFO.
-This behavior can be suppressed by setting the value of
+
+If the variable `org-babel-confirm-evaluate-answer-no' is bound
+to a non-nil value, auto-answer with \"no\".
+
+This query can also be suppressed by setting the value of
 `org-confirm-babel-evaluate' to nil, in which case all future
 interactive code block evaluations will proceed without any
 confirmation from the user.
 
 Note disabling confirmation may result in accidental evaluation
 of potentially harmful code."
-  (let* ((eval (or (cdr (assoc :eval (nth 2 info)))
-                  (when (assoc :noeval (nth 2 info)) "no")))
-         (query (cond ((equal eval "query") t)
-                     ((and (boundp 'org-current-export-file)
-                           org-current-export-file
-                           (equal eval "query-export")) t)
-                      ((functionp org-confirm-babel-evaluate)
-                       (funcall org-confirm-babel-evaluate
-                                (nth 0 info) (nth 1 info)))
-                      (t org-confirm-babel-evaluate))))
-    (if (or (equal eval "never") (equal eval "no")
-           (and (boundp 'org-current-export-file)
-                org-current-export-file
-                (or (equal eval "no-export")
-                    (equal eval "never-export")))
-           (and query
-                (not (yes-or-no-p
-                      (format "Evaluate this%scode block%son your system? "
-                              (if info (format " %s " (nth 0 info)) " ")
-                              (if (nth 4 info)
-                                  (format " (%s) " (nth 4 info)) " "))))))
-       (prog1 nil (message "Evaluation %s"
-                           (if (or (equal eval "never") (equal eval "no")
-                                   (equal eval "no-export")
-                                   (equal eval "never-export"))
-                               "Disabled" "Aborted")))
-      t)))
+  (org-babel-check-confirm-evaluate info
+    (not (when query
+          (unless
+              (and (not (org-bound-and-true-p
+                         org-babel-confirm-evaluate-answer-no))
+                   (yes-or-no-p
+                    (format "Evaluate this%scode block%son your system? "
+                            code-block block-name)))
+            (message (format "Evaluation of this%scode-block%sis aborted."
+                             code-block block-name)))))))
 
 ;;;###autoload
 (defun org-babel-execute-safely-maybe ()
@@ -332,15 +351,25 @@ of potentially harmful code."
   (or (org-babel-execute-src-block-maybe)
       (org-babel-lob-execute-maybe)))
 
+(defmacro org-babel-when-in-src-block (&rest body)
+  "Execute BODY if point is in a source block and return t.
+
+Otherwise do nothing and return nil."
+  `(if (or (org-babel-where-is-src-block-head)
+           (org-babel-get-inline-src-block-matches))
+       (progn
+        ,@body
+        t)
+     nil))
+
 (defun org-babel-execute-src-block-maybe ()
   "Conditionally execute a source block.
 Detect if this is context for a Babel src-block and if so
 then run `org-babel-execute-src-block'."
   (interactive)
-  (let ((info (org-babel-get-src-block-info)))
-    (if info
-       (progn (org-babel-eval-wipe-error-buffer)
-              (org-babel-execute-src-block current-prefix-arg info) t) nil)))
+  (org-babel-when-in-src-block
+   (org-babel-eval-wipe-error-buffer)
+   (org-babel-execute-src-block current-prefix-arg)))
 
 ;;;###autoload
 (defun org-babel-view-src-block-info ()
@@ -376,10 +405,8 @@ a window into the `org-babel-get-src-block-info' function."
 Detect if this is context for a org-babel src-block and if so
 then run `org-babel-expand-src-block'."
   (interactive)
-  (let ((info (org-babel-get-src-block-info)))
-    (if info
-       (progn (org-babel-expand-src-block current-prefix-arg info) t)
-      nil)))
+  (org-babel-when-in-src-block
+   (org-babel-expand-src-block current-prefix-arg)))
 
 ;;;###autoload
 (defun org-babel-load-in-session-maybe ()
@@ -387,10 +414,8 @@ then run `org-babel-expand-src-block'."
 Detect if this is context for a org-babel src-block and if so
 then run `org-babel-load-in-session'."
   (interactive)
-  (let ((info (org-babel-get-src-block-info)))
-    (if info
-       (progn (org-babel-load-in-session current-prefix-arg info) t)
-      nil)))
+  (org-babel-when-in-src-block
+   (org-babel-load-in-session current-prefix-arg)))
 
 (add-hook 'org-metaup-hook 'org-babel-load-in-session-maybe)
 
@@ -398,10 +423,10 @@ then run `org-babel-load-in-session'."
 (defun org-babel-pop-to-session-maybe ()
   "Conditionally pop to a session.
 Detect if this is context for a org-babel src-block and if so
-then run `org-babel-pop-to-session'."
+then run `org-babel-switch-to-session'."
   (interactive)
-  (let ((info (org-babel-get-src-block-info)))
-    (if info (progn (org-babel-pop-to-session current-prefix-arg info) t) nil)))
+  (org-babel-when-in-src-block
+   (org-babel-switch-to-session current-prefix-arg)))
 
 (add-hook 'org-metadown-hook 'org-babel-pop-to-session-maybe)
 
@@ -423,6 +448,7 @@ then run `org-babel-pop-to-session'."
     (noweb-ref . :any)
     (noweb-sep  . :any)
     (padline   . ((yes no)))
+    (post       . :any)
     (results   . ((file list vector table scalar verbatim)
                   (raw html latex org code pp drawer)
                   (replace silent none append prepend)
@@ -486,7 +512,7 @@ can not be resolved.")
   "Number of initial characters to show of a hidden results hash.")
 
 (defvar org-babel-hash-show-time nil
-  "When not nil show the time the code block was evaluated in the result hash.")
+  "Non-nil means show the time the code block was evaluated in the result hash.")
 
 (defvar org-babel-after-execute-hook nil
   "Hook for functions to be called after `org-babel-execute-src-block'")
@@ -521,83 +547,107 @@ Optionally supply a value for PARAMS which will be merged with
 the header arguments specified at the front of the source code
 block."
   (interactive)
-  (let ((info (or info (org-babel-get-src-block-info))))
-    (when (org-babel-confirm-evaluate
-          (let ((i info))
-            (setf (nth 2 i) (org-babel-merge-params (nth 2 info) params))
-            i))
-      (let* ((lang (nth 0 info))
-            (params (if params
-                        (org-babel-process-params
-                         (org-babel-merge-params (nth 2 info) params))
+  (let* ((info (if info
+                  (copy-tree info)
+                (org-babel-get-src-block-info)))
+        (merged-params (org-babel-merge-params (nth 2 info) params)))
+    (when (org-babel-check-evaluate
+          (let ((i info)) (setf (nth 2 i) merged-params) i))
+      (let* ((params (if params
+                        (org-babel-process-params merged-params)
                       (nth 2 info)))
-            (cache? (and (not arg) (cdr (assoc :cache params))
-                         (string= "yes" (cdr (assoc :cache params)))))
-            (result-params (cdr (assoc :result-params params)))
-            (new-hash (when cache? (org-babel-sha1-hash info)))
-            (old-hash (when cache? (org-babel-current-result-hash)))
-            (body (setf (nth 1 info)
-                        (if (org-babel-noweb-p params :eval)
-                            (org-babel-expand-noweb-references info)
-                          (nth 1 info))))
-            (dir (cdr (assoc :dir params)))
-            (default-directory
-              (or (and dir (file-name-as-directory (expand-file-name dir)))
-                  default-directory))
-            (org-babel-call-process-region-original
-             (if (boundp 'org-babel-call-process-region-original)
-                 org-babel-call-process-region-original
-               (symbol-function 'call-process-region)))
-            (indent (car (last info)))
-            result cmd)
-       (unwind-protect
-           (let ((call-process-region
-                  (lambda (&rest args)
-                    (apply 'org-babel-tramp-handle-call-process-region args))))
-             (let ((lang-check (lambda (f)
-                                 (let ((f (intern (concat "org-babel-execute:" f))))
-                                   (when (fboundp f) f)))))
-               (setq cmd
-                     (or (funcall lang-check lang)
-                         (funcall lang-check (symbol-name
-                                              (cdr (assoc lang org-src-lang-modes))))
-                         (error "No org-babel-execute function for %s!" lang))))
-             (if (and (not arg) new-hash (equal new-hash old-hash))
-                 (save-excursion ;; return cached result
-                   (goto-char (org-babel-where-is-src-block-result nil info))
-                   (end-of-line 1) (forward-char 1)
-                   (setq result (org-babel-read-result))
-                   (message (replace-regexp-in-string
-                             "%" "%%" (format "%S" result))) result)
-               (message "executing %s code block%s..."
-                        (capitalize lang)
-                        (if (nth 4 info) (format " (%s)" (nth 4 info)) ""))
-               (if (member "none" result-params)
-                   (progn
-                     (funcall cmd body params)
-                     (message "result silenced"))
-               (setq result
-                     ((lambda (result)
-                        (if (and (eq (cdr (assoc :result-type params)) 'value)
-                                 (or (member "vector" result-params)
-                                     (member "table" result-params))
-                                 (not (listp result)))
-                            (list (list result)) result))
-                      (funcall cmd body params)))
-               ;; if non-empty result and :file then write to :file
-               (when (cdr (assoc :file params))
-                 (when result
-                   (with-temp-file (cdr (assoc :file params))
-                     (insert
-                      (org-babel-format-result
-                       result (cdr (assoc :sep (nth 2 info)))))))
-                 (setq result (cdr (assoc :file params))))
-               (org-babel-insert-result
-                result result-params info new-hash indent lang)
-               (run-hooks 'org-babel-after-execute-hook)
-               result
-               )))
-         (setq call-process-region 'org-babel-call-process-region-original))))))
+            (cachep (and (not arg) (cdr (assoc :cache params))
+                          (string= "yes" (cdr (assoc :cache params)))))
+            (new-hash (when cachep (org-babel-sha1-hash info)))
+            (old-hash (when cachep (org-babel-current-result-hash)))
+            (cache-current-p (and (not arg) new-hash
+                                  (equal new-hash old-hash))))
+       (cond
+        (cache-current-p
+         (save-excursion ;; return cached result
+           (goto-char (org-babel-where-is-src-block-result nil info))
+           (end-of-line 1) (forward-char 1)
+           (let ((result (org-babel-read-result)))
+             (message (replace-regexp-in-string
+                       "%" "%%" (format "%S" result))) result)))
+        ((org-babel-confirm-evaluate
+          (let ((i info)) (setf (nth 2 i) merged-params) i))
+         (let* ((lang (nth 0 info))
+                (result-params (cdr (assoc :result-params params)))
+                (body (setf (nth 1 info)
+                            (if (org-babel-noweb-p params :eval)
+                                (org-babel-expand-noweb-references info)
+                              (nth 1 info))))
+                (dir (cdr (assoc :dir params)))
+                (default-directory
+                  (or (and dir (file-name-as-directory (expand-file-name dir)))
+                      default-directory))
+                (org-babel-call-process-region-original ;; for tramp handler
+                 (or (org-bound-and-true-p
+                      org-babel-call-process-region-original)
+                     (symbol-function 'call-process-region)))
+                (indent (car (last info)))
+                result cmd)
+           (unwind-protect
+               (let ((call-process-region
+                      (lambda (&rest args)
+                        (apply 'org-babel-tramp-handle-call-process-region
+                               args))))
+                 (let ((lang-check
+                        (lambda (f)
+                          (let ((f (intern (concat "org-babel-execute:" f))))
+                            (when (fboundp f) f)))))
+                   (setq cmd
+                         (or (funcall lang-check lang)
+                             (funcall lang-check
+                                      (symbol-name
+                                       (cdr (assoc lang org-src-lang-modes))))
+                             (error "No org-babel-execute function for %s!"
+                                    lang))))
+                 (message "executing %s code block%s..."
+                          (capitalize lang)
+                          (if (nth 4 info) (format " (%s)" (nth 4 info)) ""))
+                 (if (member "none" result-params)
+                     (progn
+                       (funcall cmd body params)
+                       (message "result silenced"))
+                   (setq result
+                         ((lambda (result)
+                            (if (and (eq (cdr (assoc :result-type params))
+                                         'value)
+                                     (or (member "vector" result-params)
+                                         (member "table" result-params))
+                                     (not (listp result)))
+                                (list (list result)) result))
+                          (funcall cmd body params)))
+                   ;; if non-empty result and :file then write to :file
+                   (when (cdr (assoc :file params))
+                     (when result
+                       (with-temp-file (cdr (assoc :file params))
+                         (insert
+                          (org-babel-format-result
+                           result (cdr (assoc :sep (nth 2 info)))))))
+                     (setq result (cdr (assoc :file params))))
+                   ;; possibly perform post process provided its appropriate
+                   (when (cdr (assoc :post params))
+                     (let ((*this* (if (cdr (assoc :file params))
+                                       (org-babel-result-to-file
+                                        (cdr (assoc :file params))
+                                        (when (assoc :file-desc params)
+                                          (or (cdr (assoc :file-desc params))
+                                              result)))
+                                     result)))
+                       (setq result (org-babel-ref-resolve
+                                     (cdr (assoc :post params))))
+                       (when (cdr (assoc :file params))
+                         (setq result-params
+                               (remove "file" result-params)))))
+                   (org-babel-insert-result
+                    result result-params info new-hash indent lang)
+                   (run-hooks 'org-babel-after-execute-hook)
+                   result))
+             (setq call-process-region
+                   'org-babel-call-process-region-original)))))))))
 
 (defun org-babel-expand-body:generic (body params &optional var-lines)
   "Expand BODY with PARAMS.
@@ -630,7 +680,7 @@ arguments and pop open the results in a preview buffer."
            (org-babel-expand-body:generic
             body params (and (fboundp assignments-cmd)
                              (funcall assignments-cmd params))))))
-    (if (called-interactively-p 'any)
+    (if (org-called-interactively-p 'any)
        (org-edit-src-code
         nil expanded
         (concat "*Org-Babel Preview " (buffer-name) "[ " lang " ]*"))
@@ -759,10 +809,12 @@ session."
   (let* ((info (or info (org-babel-get-src-block-info)))
          (lang (nth 0 info))
          (params (nth 2 info))
-         (body (setf (nth 1 info)
-                    (if (org-babel-noweb-p params :eval)
-                         (org-babel-expand-noweb-references info)
-                      (nth 1 info))))
+         (body (if (not info)
+                  (user-error "No src code block at point")
+                (setf (nth 1 info)
+                      (if (org-babel-noweb-p params :eval)
+                          (org-babel-expand-noweb-references info)
+                        (nth 1 info)))))
          (session (cdr (assoc :session params)))
         (dir (cdr (assoc :dir params)))
         (default-directory
@@ -1734,7 +1786,8 @@ following the source block."
           (inlinep (when (org-babel-get-inline-src-block-matches)
                      (match-end 0)))
           (name (if on-lob-line
-                    (mapconcat #'identity (butlast (org-babel-lob-get-info)) "")
+                    (mapconcat #'identity (butlast (org-babel-lob-get-info))
+                               "")
                   (nth 4 (or info (org-babel-get-src-block-info 'light)))))
           (head (unless on-lob-line (org-babel-where-is-src-block-head)))
           found beg end)
@@ -1763,21 +1816,26 @@ following the source block."
          (progn (end-of-line 1)
                 (if (eobp) (insert "\n") (forward-char 1))
                 (setq end (point))
-                (or (and (not name)
-                         (progn ;; unnamed results line already exists
-                           (re-search-forward "[^ \f\t\n\r\v]" nil t)
+                (or (and
+                     (not name)
+                     (progn ;; unnamed results line already exists
+                       (catch 'non-comment
+                         (while (re-search-forward "[^ \f\t\n\r\v]" nil t)
                            (beginning-of-line 1)
-                           (looking-at
-                            (concat org-babel-result-regexp "\n")))
-                         (let ((this-hash (match-string 5)))
-                           (prog1 (point)
-                             ;; must remove and rebuild if hash!=old-hash
-                             (if (and hash (not (string= hash this-hash)))
-                                 (prog1 nil
-                                   (forward-line 1)
-                                   (delete-region
-                                    end (org-babel-result-end)))
-                               (setq end nil)))))))))))
+                           (cond
+                            ((looking-at (concat org-babel-result-regexp "\n"))
+                             (throw 'non-comment t))
+                            ((looking-at "^[ \t]*#") (end-of-line 1))
+                            (t (throw 'non-comment nil))))))
+                     (let ((this-hash (match-string 5)))
+                       (prog1 (point)
+                         ;; must remove and rebuild if hash!=old-hash
+                         (if (and hash (not (string= hash this-hash)))
+                             (prog1 nil
+                               (forward-line 1)
+                               (delete-region
+                                end (org-babel-result-end)))
+                           (setq end nil)))))))))))
       (if (not (and insert end)) found
        (goto-char end)
        (unless beg
@@ -1987,7 +2045,7 @@ code ---- the results are extracted in the syntax of the source
                     (cons 'unordered
                           (mapcar
                            (lambda (el) (list nil (if (stringp el) el (format "%S" el))))
-                           (if (listp result) result (list result))))
+                           (if (listp result) result (split-string result "\n" t))))
                     '(:splicep nil :istart "- " :iend "\n")))
                   "\n"))
                 ;; assume the result is a table if it's not a string
@@ -2019,6 +2077,7 @@ code ---- the results are extracted in the syntax of the source
                 ((member "latex" result-params)
                  (funcall wrap "#+BEGIN_LaTeX" "#+END_LaTeX"))
                 ((member "org" result-params)
+                 (goto-char beg) (if (org-at-table-p) (org-cycle))
                  (funcall wrap "#+BEGIN_SRC org" "#+END_SRC"))
                 ((member "code" result-params)
                  (funcall wrap (format "#+BEGIN_SRC %s%s" (or lang "none") results-switches)
@@ -2028,6 +2087,7 @@ code ---- the results are extracted in the syntax of the source
                 ((or (member "drawer" result-params)
                      ;; Stay backward compatible with <7.9.2
                      (member "wrap" result-params))
+                 (goto-char beg) (if (org-at-table-p) (org-cycle))
                  (funcall wrap ":RESULTS:" ":END:" 'no-escape))
                 ((and (not (funcall proper-list-p result))
                       (not (member "file" result-params)))
@@ -2462,7 +2522,8 @@ appropriate."
   (if (and (stringp cell) (not (equal cell "")))
       (or (org-babel-number-p cell)
           (if (and (not inhibit-lisp-eval)
-                  (member (substring cell 0 1) '("(" "'" "`" "[")))
+                  (or (member (substring cell 0 1) '("(" "'" "`" "["))
+                      (string= cell "*this*")))
               (eval (read cell))
             (if (string= (substring cell 0 1) "\"")
                (read cell)
@@ -2471,7 +2532,8 @@ appropriate."
 
 (defun org-babel-number-p (string)
   "If STRING represents a number return its value."
-  (if (and (string-match "^-?[0-9]*\\.?[0-9]*$" string)
+  (if (and (string-match "[0-9]+" string)
+          (string-match "^-?[0-9]*\\.?[0-9]*$" string)
            (= (length (substring string (match-beginning 0)
                                 (match-end 0)))
              (length string)))
@@ -2524,7 +2586,6 @@ of the string."
                     (org-babel-chomp (org-reverse-string string) regexp))
                    regexp))
 
-(defvar org-babel-org-babel-call-process-region-original nil)
 (defun org-babel-tramp-handle-call-process-region
   (start end program &optional delete buffer display &rest args)
   "Use Tramp to handle `call-process-region'.
@@ -2577,30 +2638,39 @@ Emacs shutdown."))
   "Call the code to parse raw string results according to RESULT-PARAMS."
   (declare (indent 1)
           (debug (form form &rest form)))
-  `(unless (member "none" ,result-params)
-     (if (or (member "scalar" ,result-params)
-            (member "verbatim" ,result-params)
-            (member "html" ,result-params)
-            (member "code" ,result-params)
-            (member "pp" ,result-params)
-            (and (member "output" ,result-params)
-                 (not (member "table" ,result-params))))
-        ,scalar-form
-       ,@table-forms)))
+  (org-with-gensyms (params)
+    `(let ((,params ,result-params))
+       (unless (member "none" ,params)
+        (if (or (member "scalar" ,params)
+                (member "verbatim" ,params)
+                (member "html" ,params)
+                (member "code" ,params)
+                (member "pp" ,params)
+                (and (or (member "output" ,params)
+                         (member "raw"    ,params)
+                         (member "org"    ,params)
+                         (member "drawer" ,params))
+                     (not (member "table" ,params))))
+            ,scalar-form
+          ,@table-forms)))))
+(def-edebug-spec org-babel-result-cond (form form body))
 
 (defun org-babel-temp-file (prefix &optional suffix)
   "Create a temporary file in the `org-babel-temporary-directory'.
 Passes PREFIX and SUFFIX directly to `make-temp-file' with the
 value of `temporary-file-directory' temporarily set to the value
 of `org-babel-temporary-directory'."
-  (let ((temporary-file-directory
-        (if (file-remote-p default-directory)
-            (concat (file-remote-p default-directory) "/tmp")
+  (if (file-remote-p default-directory)
+      (let ((prefix
+             (concat (file-remote-p default-directory)
+                     (expand-file-name prefix temporary-file-directory))))
+        (make-temp-file prefix nil suffix))
+    (let ((temporary-file-directory
           (or (and (boundp 'org-babel-temporary-directory)
                    (file-exists-p org-babel-temporary-directory)
                    org-babel-temporary-directory)
-              temporary-file-directory))))
-      (make-temp-file prefix nil suffix)))
+              temporary-file-directory)))
+      (make-temp-file prefix nil suffix))))
 
 (defun org-babel-remove-temporary-directory ()
   "Remove `org-babel-temporary-directory' on Emacs shutdown."
index d6bbbbc..d3d76e5 100644 (file)
 ;; 3) we are adding the "file" and "cmdline" header arguments
 ;;
 ;; 4) there are no variables (at least for now)
-;;
-;; 5) it depends on a variable defined in org-exp-blocks (namely
-;;    `org-ditaa-jar-path') so be sure you have org-exp-blocks loaded
 
 ;;; Code:
 (require 'ob)
 (require 'org-compat)
 
-(defvar org-ditaa-jar-path) ;; provided by org-exp-blocks
-
 (defvar org-babel-default-header-args:ditaa
   '((:results . "file")
     (:exports . "results")
     (:java . "-Dfile.encoding=UTF-8"))
   "Default arguments for evaluating a ditaa source block.")
 
+(defcustom org-ditaa-jar-path (expand-file-name
+                              "ditaa.jar"
+                              (file-name-as-directory
+                               (expand-file-name
+                                "scripts"
+                                (file-name-as-directory
+                                 (expand-file-name
+                                  "../contrib"
+                                  (file-name-directory (org-find-library-dir "org")))))))
+  "Path to the ditaa jar executable."
+  :group 'org-babel
+  :type 'string)
+
+(defcustom org-ditaa-eps-jar-path
+  (expand-file-name "DitaaEps.jar" (file-name-directory org-ditaa-jar-path))
+  "Path to the DitaaEps.jar executable."
+  :group 'org-babel
+  :version "24.4"
+  :package-version '(Org . "8.0")
+  :type 'string)
+
 (defcustom org-ditaa-jar-option "-jar"
   "Option for the ditaa jar file.
 Do not leave leading or trailing spaces in this string."
@@ -69,16 +85,25 @@ This function is called by `org-babel-execute-src-block'."
         (cmdline (cdr (assoc :cmdline params)))
         (java (cdr (assoc :java params)))
         (in-file (org-babel-temp-file "ditaa-"))
+        (eps (cdr (assoc :eps params)))
         (cmd (concat "java " java " " org-ditaa-jar-option " "
                      (shell-quote-argument
-                      (expand-file-name org-ditaa-jar-path))
+                      (expand-file-name
+                       (if eps org-ditaa-eps-jar-path org-ditaa-jar-path)))
                      " " cmdline
                      " " (org-babel-process-file-name in-file)
-                     " " (org-babel-process-file-name out-file))))
+                     " " (org-babel-process-file-name out-file)))
+        (pdf-cmd (when (and (or (string= (file-name-extension out-file) "pdf")
+                                (cdr (assoc :pdf params))))
+                   (concat
+                    "epstopdf"
+                    " " (org-babel-process-file-name (concat in-file ".eps"))
+                    " -o=" (org-babel-process-file-name out-file)))))
     (unless (file-exists-p org-ditaa-jar-path)
       (error "Could not find ditaa.jar at %s" org-ditaa-jar-path))
     (with-temp-file in-file (insert body))
     (message cmd) (shell-command cmd)
+    (when pdf-cmd (message pdf-cmd) (shell-command pdf-cmd))
     nil)) ;; signal that output has already been written to file
 
 (defun org-babel-prep-session:ditaa (session params)
index b5e7880..7504264 100644 (file)
@@ -39,7 +39,6 @@
 
 ;;; Code:
 (require 'ob)
-(require 'ob-eval)
 
 (defvar org-babel-default-header-args:dot
   '((:results . "file") (:exports . "results"))
index d6073ca..886645d 100644 (file)
@@ -27,7 +27,6 @@
 
 ;;; Code:
 (require 'ob)
-(eval-when-compile (require 'ob-comint))
 
 (defvar org-babel-default-header-args:emacs-lisp
   '((:hlines . "yes") (:colnames . "no"))
   "Execute a block of emacs-lisp code with Babel."
   (save-window-excursion
     ((lambda (result)
-       (if (or (member "scalar" (cdr (assoc :result-params params)))
-              (member "verbatim" (cdr (assoc :result-params params))))
-          (let ((print-level nil)
-                (print-length nil))
-            (format "%S" result))
+       (org-babel-result-cond (cdr (assoc :result-params params))
+        (let ((print-level nil)
+              (print-length nil))
+          (if (or (member "scalar" (cdr (assoc :result-params params)))
+                  (member "verbatim" (cdr (assoc :result-params params))))
+              (format "%S" result)
+            (format "%s" result)))
         (org-babel-reassemble-table
          result
          (org-babel-pick-name (cdr (assoc :colname-names params))
index 22d2bcf..681362f 100644 (file)
@@ -50,8 +50,8 @@ STDERR with `org-babel-eval-error-notify'."
     (with-temp-buffer
       (insert body)
       (setq exit-code
-           (org-babel-shell-command-on-region
-            (point-min) (point-max) cmd t 'replace err-buff))
+           (org-babel--shell-command-on-region
+            (point-min) (point-max) cmd err-buff))
       (if (or (not (numberp exit-code)) (> exit-code 0))
          (progn
            (with-current-buffer err-buff
@@ -64,79 +64,15 @@ STDERR with `org-babel-eval-error-notify'."
   (with-temp-buffer (insert-file-contents file)
                    (buffer-string)))
 
-(defun org-babel-shell-command-on-region (start end command
-                                               &optional output-buffer replace
-                                               error-buffer display-error-buffer)
+(defun org-babel--shell-command-on-region (start end command error-buffer)
   "Execute COMMAND in an inferior shell with region as input.
 
-Fixes bugs in the emacs 23.1.1 version of `shell-command-on-region'
-
-Normally display output (if any) in temp buffer `*Shell Command Output*';
-Prefix arg means replace the region with it.  Return the exit code of
-COMMAND.
-
-To specify a coding system for converting non-ASCII characters in
-the input and output to the shell command, use
-\\[universal-coding-system-argument] before this command.  By
-default, the input (from the current buffer) is encoded in the
-same coding system that will be used to save the file,
-`buffer-file-coding-system'.  If the output is going to replace
-the region, then it is decoded from that same coding system.
-
-The noninteractive arguments are START, END, COMMAND,
-OUTPUT-BUFFER, REPLACE, ERROR-BUFFER, and DISPLAY-ERROR-BUFFER.
-Noninteractive callers can specify coding systems by binding
-`coding-system-for-read' and `coding-system-for-write'.
-
-If the command generates output, the output may be displayed
-in the echo area or in a buffer.
-If the output is short enough to display in the echo area
-\(determined by the variable `max-mini-window-height' if
-`resize-mini-windows' is non-nil), it is shown there.  Otherwise
-it is displayed in the buffer `*Shell Command Output*'.  The output
-is available in that buffer in both cases.
-
-If there is output and an error, a message about the error
-appears at the end of the output.
-
-If there is no output, or if output is inserted in the current buffer,
-then `*Shell Command Output*' is deleted.
-
-If the optional fourth argument OUTPUT-BUFFER is non-nil,
-that says to put the output in some other buffer.
-If OUTPUT-BUFFER is a buffer or buffer name, put the output there.
-If OUTPUT-BUFFER is not a buffer and not nil,
-insert output in the current buffer.
-In either case, the output is inserted after point (leaving mark after it).
-
-If REPLACE, the optional fifth argument, is non-nil, that means insert
-the output in place of text from START to END, putting point and mark
-around it.
-
-If optional sixth argument ERROR-BUFFER is non-nil, it is a buffer
-or buffer name to which to direct the command's standard error output.
-If it is nil, error output is mingled with regular output.
-If DISPLAY-ERROR-BUFFER is non-nil, display the error buffer if there
-were any errors.  (This is always t, interactively.)
-In an interactive call, the variable `shell-command-default-error-buffer'
-specifies the value of ERROR-BUFFER."
-  (interactive (let (string)
-                (unless (mark)
-                  (error "The mark is not set now, so there is no region"))
-                ;; Do this before calling region-beginning
-                ;; and region-end, in case subprocess output
-                ;; relocates them while we are in the minibuffer.
-                (setq string (read-shell-command "Shell command on region: "))
-                ;; call-interactively recognizes region-beginning and
-                ;; region-end specially, leaving them in the history.
-                (list (region-beginning) (region-end)
-                      string
-                      current-prefix-arg
-                      current-prefix-arg
-                      shell-command-default-error-buffer
-                      t)))
-  (let ((input-file (org-babel-temp-file "input-"))
-       (error-file (if error-buffer (org-babel-temp-file "scor-") nil))
+Stripped down version of shell-command-on-region for internal use
+in Babel only.  This lets us work around errors in the original
+function in various versions of Emacs.
+"
+  (let ((input-file (org-babel-temp-file "ob-input-"))
+       (error-file (if error-buffer (org-babel-temp-file "ob-error-") nil))
        ;; Unfortunately, `executable-find' does not support file name
        ;; handlers.  Therefore, we could use it in the local case
        ;; only.
@@ -154,96 +90,26 @@ specifies the value of ERROR-BUFFER."
     ;; workaround for now.
     (unless (file-remote-p default-directory)
       (delete-file error-file))
-    (if (or replace
-           (and output-buffer
-                (not (or (bufferp output-buffer) (stringp output-buffer)))))
-       ;; Replace specified region with output from command.
-       (let ((swap (and replace (< start end))))
-         ;; Don't muck with mark unless REPLACE says we should.
-         (goto-char start)
-         (and replace (push-mark (point) 'nomsg))
-         (write-region start end input-file)
-         (delete-region start end)
-         (setq exit-status
-               (process-file shell-file-name input-file
-                             (if error-file
-                                 (list output-buffer error-file)
-                               t)
-                             nil shell-command-switch command))
-         ;; It is rude to delete a buffer which the command is not using.
-         ;; (let ((shell-buffer (get-buffer "*Shell Command Output*")))
-         ;;   (and shell-buffer (not (eq shell-buffer (current-buffer)))
-         ;;     (kill-buffer shell-buffer)))
-         ;; Don't muck with mark unless REPLACE says we should.
-         (and replace swap (exchange-point-and-mark)))
-      ;; No prefix argument: put the output in a temp buffer,
-      ;; replacing its entire contents.
-      (let ((buffer (get-buffer-create
-                    (or output-buffer "*Shell Command Output*"))))
-       (unwind-protect
-           (if (eq buffer (current-buffer))
-               ;; If the input is the same buffer as the output,
-               ;; delete everything but the specified region,
-               ;; then replace that region with the output.
-               (progn (setq buffer-read-only nil)
-                      (delete-region (max start end) (point-max))
-                      (delete-region (point-min) (min start end))
-                      (write-region (point-min) (point-max) input-file)
-                      (delete-region (point-min) (point-max))
-                      (setq exit-status
-                            (process-file shell-file-name input-file
-                                          (if error-file
-                                              (list t error-file)
-                                            t)
-                                          nil shell-command-switch command)))
-             ;; Clear the output buffer, then run the command with
-             ;; output there.
-             (let ((directory default-directory))
-               (with-current-buffer buffer
-                 (setq buffer-read-only nil)
-                 (if (not output-buffer)
-                     (setq default-directory directory))
-                 (erase-buffer)))
-             (setq exit-status
-                   (process-file shell-file-name nil
-                                 (if error-file
-                                     (list buffer error-file)
-                                   buffer)
-                                 nil shell-command-switch command)))
-         ;; Report the output.
-         (with-current-buffer buffer
-           (setq mode-line-process
-                 (cond ((null exit-status)
-                        " - Error")
-                       ((stringp exit-status)
-                        (format " - Signal [%s]" exit-status))
-                       ((not (equal 0 exit-status))
-                        (format " - Exit [%d]" exit-status)))))
-         (if (with-current-buffer buffer (> (point-max) (point-min)))
-             ;; There's some output, display it
-             (display-message-or-buffer buffer)
-           ;; No output; error?
-           (let ((output
-                  (if (and error-file
-                           (< 0 (nth 7 (file-attributes error-file))))
-                      "some error output"
-                    "no output")))
-             (cond ((null exit-status)
-                    (message "(Shell command failed with error)"))
-                   ((equal 0 exit-status)
-                    (message "(Shell command succeeded with %s)"
-                             output))
-                   ((stringp exit-status)
-                    (message "(Shell command killed by signal %s)"
-                             exit-status))
-                   (t
-                    (message "(Shell command failed with code %d and %s)"
-                             exit-status output))))
-           ;; Don't kill: there might be useful info in the undo-log.
-           ;; (kill-buffer buffer)
-           ))))
-
-    (when (and input-file (file-exists-p input-file))
+    ;; we always call this with 'replace, remove conditional
+    ;; Replace specified region with output from command.
+    (let ((swap (< start end)))
+      (goto-char start)
+      (push-mark (point) 'nomsg)
+      (write-region start end input-file)
+      (delete-region start end)
+      (setq exit-status
+           (process-file shell-file-name input-file
+                         (if error-file
+                             (list t error-file)
+                           t)
+                         nil shell-command-switch command))
+      (when swap (exchange-point-and-mark)))
+
+    (when (and input-file (file-exists-p input-file)
+              ;; bind org-babel--debug-input around the call to keep
+              ;; the temporary input files available for inspection
+              (not (when (boundp 'org-babel--debug-input)
+                     org-babel--debug-input)))
       (delete-file input-file))
 
     (when (and error-file (file-exists-p error-file))
@@ -258,8 +124,7 @@ specifies the value of ERROR-BUFFER."
              (format-insert-file error-file nil)
              ;; Put point after the inserted errors.
              (goto-char (- (point-max) pos-from-end)))
-           (and display-error-buffer
-                (display-buffer (current-buffer)))))
+           (current-buffer)))
       (delete-file error-file))
     exit-status))
 
index 37a9f71..d9fb294 100644 (file)
@@ -23,8 +23,7 @@
 ;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
 
 ;;; Code:
-(require 'ob)
-(require 'org-exp-blocks)
+(require 'ob-core)
 (eval-when-compile
   (require 'cl))
 
 
 (declare-function org-babel-lob-get-info "ob-lob" ())
 (declare-function org-babel-eval-wipe-error-buffer "ob-eval" ())
+(declare-function org-between-regexps-p "org"
+                 (start-re end-re &optional lim-up lim-down))
+(declare-function org-get-indentation "org" (&optional line))
 (declare-function org-heading-components "org" ())
+(declare-function org-in-block-p "org" (names))
+(declare-function org-in-verbatim-emphasis "org" ())
 (declare-function org-link-search "org" (s &optional type avoid-pos stealth))
 (declare-function org-fill-template "org" (template alist))
-(declare-function org-in-verbatim-emphasis "org" ())
-(declare-function org-in-block-p "org" (names))
-(declare-function org-between-regexps-p "org" (start-re end-re &optional lim-up lim-down))
-
-(add-to-list 'org-export-interblocks '(src org-babel-exp-non-block-elements))
-(org-export-blocks-add-block '(src org-babel-exp-src-block nil))
+(declare-function org-split-string "org" (string &optional separators))
+(declare-function org-element-at-point "org-element" (&optional keep-trail))
+(declare-function org-element-context "org-element" ())
+(declare-function org-element-property "org-element" (property element))
+(declare-function org-element-type "org-element" (element))
+(declare-function org-escape-code-in-string "org-src" (s))
 
 (defcustom org-export-babel-evaluate t
   "Switch controlling code evaluation during export.
 When set to nil no code will be evaluated as part of the export
-process."
+process.  When set to 'inline-only, only inline code blocks will
+be executed."
   :group 'org-babel
   :version "24.1"
-  :type 'boolean)
+  :type '(choice (const :tag "Never" nil)
+                (const :tag "Only inline code" inline-only)
+                (const :tag "Always" t)))
 (put 'org-export-babel-evaluate 'safe-local-variable (lambda (x) (eq x nil)))
 
 (defun org-babel-exp-get-export-buffer ()
@@ -86,10 +93,10 @@ process."
        results)))
 (def-edebug-spec org-babel-exp-in-export-file (form body))
 
-(defun org-babel-exp-src-block (body &rest headers)
+(defun org-babel-exp-src-block (&rest headers)
   "Process source block for export.
-Depending on the 'export' headers argument in replace the source
-code block with...
+Depending on the 'export' headers argument, replace the source
+code block like this:
 
 both ---- display the code and the results
 
@@ -99,11 +106,12 @@ code ---- the default, display the code inside the block but do
 results - just like none only the block is run on export ensuring
           that it's results are present in the org-mode buffer
 
-none ----- do not display either code or results upon export"
+none ---- do not display either code or results upon export
+
+Assume point is at the beginning of block's starting line."
   (interactive)
   (unless noninteractive (message "org-babel-exp processing..."))
   (save-excursion
-    (goto-char (match-beginning 0))
     (let* ((info (org-babel-get-src-block-info 'light))
           (lang (nth 0 info))
           (raw-params (nth 2 info)) hash)
@@ -149,66 +157,156 @@ this template."
       (let ((m (make-marker)))
        (set-marker m end (current-buffer))
        (setq end m)))
-    (let ((rx (concat "\\("  org-babel-inline-src-block-regexp
+    (let ((rx (concat "\\(?:"  org-babel-inline-src-block-regexp
                      "\\|" org-babel-lob-one-liner-regexp "\\)")))
-      (while (and (< (point) (marker-position end))
-                 (re-search-forward rx end t))
-       (if (save-excursion
-             (goto-char (match-beginning 0))
-             (looking-at org-babel-inline-src-block-regexp))
-           (progn
-             (forward-char 1)
-             (let* ((info (save-match-data
-                            (org-babel-parse-inline-src-block-match)))
-                    (params (nth 2 info)))
-               (save-match-data
-                 (goto-char (match-beginning 2))
-                 (unless (org-babel-in-example-or-verbatim)
-                   ;; expand noweb references in the original file
-                   (setf (nth 1 info)
-                         (if (and (cdr (assoc :noweb params))
-                                  (string= "yes" (cdr (assoc :noweb params))))
-                             (org-babel-expand-noweb-references
-                              info (org-babel-exp-get-export-buffer))
-                           (nth 1 info)))
-                   (let ((code-replacement (save-match-data
-                                             (org-babel-exp-do-export
-                                              info 'inline))))
-                     (if code-replacement
-                         (progn (replace-match code-replacement nil nil nil 1)
-                                (delete-char 1))
-                       (org-babel-examplize-region (match-beginning 1)
-                                                   (match-end 1))
-                       (forward-char 2)))))))
-         (unless (org-babel-in-example-or-verbatim)
-           (let* ((lob-info (org-babel-lob-get-info))
-                  (inlinep (match-string 11))
-                  (inline-start (match-end 11))
-                  (inline-end (match-end 0))
-                  (results (save-match-data
-                             (org-babel-exp-do-export
-                              (list "emacs-lisp" "results"
-                                    (org-babel-merge-params
-                                     org-babel-default-header-args
-                                     org-babel-default-lob-header-args
-                                     (org-babel-params-from-properties)
-                                     (org-babel-parse-header-arguments
-                                      (org-no-properties
-                                       (concat ":var results="
-                                               (mapconcat #'identity
-                                                          (butlast lob-info)
-                                                          " ")))))
-                                    "" nil (car (last lob-info)))
-                              'lob)))
-                  (rep (org-fill-template
-                        org-babel-exp-call-line-template
-                        `(("line"  . ,(nth 0 lob-info))))))
-             (if inlinep
-                 (save-excursion
-                   (goto-char inline-start)
-                   (delete-region inline-start inline-end)
-                   (insert rep))
-               (replace-match rep t t)))))))))
+      (while (re-search-forward rx end t)
+       (save-excursion
+         (let* ((element (save-excursion
+                           ;; If match is inline, point is at its
+                           ;; end.  Move backward so
+                           ;; `org-element-context' can get the
+                           ;; object, not the following one.
+                           (backward-char)
+                           (save-match-data (org-element-context))))
+                (type (org-element-type element)))
+           (when (memq type '(babel-call inline-babel-call inline-src-block))
+             (let ((beg-el (org-element-property :begin element))
+                   (end-el (org-element-property :end element)))
+               (case type
+                 (inline-src-block
+                  (let* ((info (org-babel-parse-inline-src-block-match))
+                         (params (nth 2 info)))
+                    (setf (nth 1 info)
+                          (if (and (cdr (assoc :noweb params))
+                                   (string= "yes" (cdr (assoc :noweb params))))
+                              (org-babel-expand-noweb-references
+                               info (org-babel-exp-get-export-buffer))
+                            (nth 1 info)))
+                    (goto-char beg-el)
+                    (let ((replacement (org-babel-exp-do-export info 'inline)))
+                      (if (equal replacement "")
+                          ;; Replacement code is empty: completely
+                          ;; remove inline src block, including extra
+                          ;; white space that might have been created
+                          ;; when inserting results.
+                          (delete-region beg-el
+                                         (progn (goto-char end-el)
+                                                (skip-chars-forward " \t")
+                                                (point)))
+                        ;; Otherwise: remove inline src block but
+                        ;; preserve following white spaces.  Then
+                        ;; insert value.
+                        (delete-region beg-el
+                                       (progn (goto-char end-el)
+                                              (skip-chars-backward " \t")
+                                              (point)))
+                        (insert replacement)))))
+                 ((babel-call inline-babel-call)
+                  (let* ((lob-info (org-babel-lob-get-info))
+                         (results
+                          (org-babel-exp-do-export
+                           (list "emacs-lisp" "results"
+                                 (org-babel-merge-params
+                                  org-babel-default-header-args
+                                  org-babel-default-lob-header-args
+                                  (org-babel-params-from-properties)
+                                  (org-babel-parse-header-arguments
+                                   (org-no-properties
+                                    (concat ":var results="
+                                            (mapconcat 'identity
+                                                       (butlast lob-info)
+                                                       " ")))))
+                                 "" nil (car (last lob-info)))
+                           'lob))
+                         (rep (org-fill-template
+                               org-babel-exp-call-line-template
+                               `(("line"  . ,(nth 0 lob-info))))))
+                    ;; If replacement is empty, completely remove the
+                    ;; object/element, including any extra white space
+                    ;; that might have been created when including
+                    ;; results.
+                    (if (equal rep "")
+                        (delete-region
+                         beg-el
+                         (progn (goto-char end-el)
+                                (if (not (eq type 'babel-call))
+                                    (progn (skip-chars-forward " \t") (point))
+                                  (skip-chars-forward " \r\t\n")
+                                  (line-beginning-position))))
+                      ;; Otherwise, preserve following white
+                      ;; spaces/newlines and then, insert replacement
+                      ;; string.
+                      (goto-char beg-el)
+                      (delete-region beg-el
+                                     (progn (goto-char end-el)
+                                            (skip-chars-backward " \r\t\n")
+                                            (point)))
+                      (insert rep)))))))))))))
+
+(defvar org-src-preserve-indentation)  ; From org-src.el
+(defun org-babel-exp-process-buffer ()
+  "Execute all blocks in visible part of buffer."
+  (interactive)
+  (save-window-excursion
+    (let ((case-fold-search t)
+         (pos (point-min)))
+      (goto-char pos)
+      (while (re-search-forward "^[ \t]*#\\+BEGIN_SRC" nil t)
+        (let ((element (save-match-data (org-element-at-point))))
+          (when (eq (org-element-type element) 'src-block)
+            (let* ((match-start (copy-marker (match-beginning 0)))
+                   (begin (copy-marker (org-element-property :begin element)))
+                   ;; Make sure we don't remove any blank lines after
+                   ;; the block when replacing it.
+                   (block-end (save-excursion
+                               (goto-char (org-element-property :end element))
+                               (skip-chars-backward " \r\t\n")
+                               (copy-marker (line-end-position))))
+                   (ind (org-get-indentation))
+                   (headers
+                   (cons
+                    (org-element-property :language element)
+                    (let ((params (org-element-property :parameters element)))
+                      (and params (org-split-string params "[ \t]+")))))
+                   (preserve-indent
+                   (or org-src-preserve-indentation
+                       (org-element-property :preserve-indent element))))
+              ;; Execute all non-block elements between POS and
+              ;; current block.
+              (org-babel-exp-non-block-elements pos begin)
+             ;; Take care of matched block: compute replacement
+             ;; string. In particular, a nil REPLACEMENT means the
+             ;; block should be left as-is while an empty string
+             ;; should remove the block.
+              (let ((replacement (progn (goto-char match-start)
+                                       (org-babel-exp-src-block headers))))
+                (cond ((not replacement) (goto-char block-end))
+                     ((equal replacement "")
+                      (delete-region begin
+                                     (progn (goto-char block-end)
+                                            (skip-chars-forward " \r\t\n")
+                                            (if (eobp) (point)
+                                              (line-beginning-position)))))
+                     (t
+                      (goto-char match-start)
+                      (delete-region (point) block-end)
+                      (insert replacement)
+                      (if preserve-indent
+                          ;; Indent only the code block markers.
+                          (save-excursion (skip-chars-backward " \r\t\n")
+                                          (indent-line-to ind)
+                                          (goto-char match-start)
+                                          (indent-line-to ind))
+                        ;; Indent everything.
+                        (indent-rigidly match-start (point) ind)))))
+             (setq pos (line-beginning-position))
+              ;; Cleanup markers.
+             (set-marker match-start nil)
+             (set-marker begin nil)
+              (set-marker block-end nil)))))
+      ;; Eventually execute all non-block Babel elements between last
+      ;; src-block and end of buffer.
+      (org-babel-exp-non-block-elements pos (point-max)))))
 
 (defun org-babel-in-example-or-verbatim ()
   "Return true if point is in example or verbatim code.
@@ -269,9 +367,7 @@ replaced with its value."
   (org-fill-template
    org-babel-exp-code-template
    `(("lang"  . ,(nth 0 info))
-     ("body"  . ,(if (string= (nth 0 info) "org")
-                    (replace-regexp-in-string "^" "," (nth 1 info))
-                  (nth 1 info)))
+     ("body"  . ,(org-escape-code-in-string (nth 1 info)))
      ,@(mapcar (lambda (pair)
                 (cons (substring (symbol-name (car pair)) 1)
                       (format "%S" (cdr pair))))
@@ -285,7 +381,9 @@ Results are prepared in a manner suitable for export by org-mode.
 This function is called by `org-babel-exp-do-export'.  The code
 block will be evaluated.  Optional argument SILENT can be used to
 inhibit insertion of results into the buffer."
-  (when (and org-export-babel-evaluate
+  (when (and (or (eq org-export-babel-evaluate t)
+                (and (eq type 'inline)
+                     (eq org-export-babel-evaluate 'inline-only)))
             (not (and hash (equal hash (org-babel-current-result-hash)))))
     (let ((lang (nth 0 info))
          (body (if (org-babel-noweb-p (nth 2 info) :eval)
@@ -318,10 +416,10 @@ inhibit insertion of results into the buffer."
           ((equal type 'lob)
            (save-excursion
              (re-search-backward org-babel-lob-one-liner-regexp nil t)
-             (org-babel-execute-src-block nil info)))))))))
-
-(provide 'ob-exp)
+             (let (org-confirm-babel-evaluate)
+               (org-babel-execute-src-block nil info))))))))))
 
 
+(provide 'ob-exp)
 
 ;;; ob-exp.el ends here
index 8d5012f..1eab03e 100644 (file)
@@ -28,7 +28,6 @@
 
 ;;; Code:
 (require 'ob)
-(require 'ob-eval)
 (require 'cc-mode)
 
 (declare-function org-entry-get "org"
                     (org-babel-process-file-name tmp-src-file)) ""))))
     ((lambda (results)
        (org-babel-reassemble-table
-       (if (member "vector" (cdr (assoc :result-params params)))
-           (let ((tmp-file (org-babel-temp-file "f-")))
-             (with-temp-file tmp-file (insert results))
-             (org-babel-import-elisp-from-file tmp-file))
-         (org-babel-read results))
+       (org-babel-result-cond (cdr (assoc :result-params params))
+         (org-babel-read results)
+         (let ((tmp-file (org-babel-temp-file "f-")))
+           (with-temp-file tmp-file (insert results))
+           (org-babel-import-elisp-from-file tmp-file)))
        (org-babel-pick-name
         (cdr (assoc :colname-names params)) (cdr (assoc :colnames params)))
        (org-babel-pick-name
index 488d250..4b3a1c6 100644 (file)
@@ -39,8 +39,6 @@
 
 ;;; Code:
 (require 'ob)
-(require 'ob-ref)
-(require 'ob-comint)
 (eval-when-compile (require 'cl))
 
 (declare-function org-time-string-to-time "org" (s))
index eca6d82..6f0fbcd 100644 (file)
@@ -40,7 +40,6 @@
 
 ;;; Code:
 (require 'ob)
-(require 'ob-comint)
 (require 'comint)
 (eval-when-compile (require 'cl))
 
                    (cdr (member org-babel-haskell-eoe
                                 (reverse (mapcar #'org-babel-trim raw)))))))
     (org-babel-reassemble-table
-     (cond
-      ((equal result-type 'output)
-       (mapconcat #'identity (reverse (cdr results)) "\n"))
-      ((equal result-type 'value)
-       (org-babel-haskell-table-or-string (car results))))
+     ((lambda (result)
+       (org-babel-result-cond (cdr (assoc :result-params params))
+         result (org-babel-haskell-table-or-string result)))
+      (case result-type
+       ('output (mapconcat #'identity (reverse (cdr results)) "\n"))
+       ('value (car results))))
      (org-babel-pick-name (cdr (assoc :colname-names params))
                          (cdr (assoc :colname-names params)))
      (org-babel-pick-name (cdr (assoc :rowname-names params))
@@ -147,8 +147,9 @@ specifying a variable of the same value."
     (format "%S" var)))
 
 (defvar org-src-preserve-indentation)
-(declare-function org-export-as-latex "org-latex"
-                 (arg &optional ext-plist to-buffer body-only pub-dir))
+(declare-function org-export-to-file "ox"
+                 (backend file
+                          &optional subtreep visible-only body-only ext-plist))
 (defun org-babel-haskell-export-to-lhs (&optional arg)
   "Export to a .lhs file with all haskell code blocks escaped.
 When called with a prefix argument the resulting
@@ -192,7 +193,11 @@ constructs (header arguments, no-web syntax etc...) are ignored."
         (indent-code-rigidly (match-beginning 0) (match-end 0) indentation)))
     (save-excursion
       ;; export to latex w/org and save as .lhs
-      (find-file tmp-org-file) (funcall 'org-export-as-latex nil)
+      (require 'ox-latex)
+      (find-file tmp-org-file)
+      ;; Ensure we do not clutter kill ring with incomplete results.
+      (let (org-export-copy-to-kill-ring)
+       (org-export-to-file 'latex tmp-tex-file))
       (kill-buffer nil)
       (delete-file tmp-org-file)
       (find-file tmp-tex-file)
index d4686a9..af18f74 100644 (file)
@@ -33,9 +33,6 @@
 
 ;;; Code:
 (require 'ob)
-(require 'ob-ref)
-(require 'ob-comint)
-(require 'ob-eval)
 (eval-when-compile (require 'cl))
 
 (defvar org-babel-tangle-lang-exts) ;; Autoloaded
@@ -98,8 +95,8 @@ in BODY as elisp."
                   (wrapper (format org-babel-io-wrapper-method body)))
              (with-temp-file src-file (insert wrapper))
              ((lambda (raw)
-                (if (member "code" result-params)
-                    raw
+                (org-babel-result-cond result-params
+                 raw
                   (org-babel-io-table-or-string raw)))
               (org-babel-eval
                (concat org-babel-io-command " " src-file) ""))))))
index 96128ed..c0e9a53 100644 (file)
@@ -28,7 +28,6 @@
 
 ;;; Code:
 (require 'ob)
-(require 'ob-eval)
 
 (defvar org-babel-tangle-lang-exts)
 (add-to-list 'org-babel-tangle-lang-exts '("java" . "java"))
       (make-directory packagename 'parents))
     ((lambda (results)
        (org-babel-reassemble-table
-       (if (member "vector" (cdr (assoc :result-params params)))
-           (let ((tmp-file (org-babel-temp-file "c-")))
+       (org-babel-result-cond (cdr (assoc :result-params params))
+         (org-babel-read results)
+         (let ((tmp-file (org-babel-temp-file "c-")))
              (with-temp-file tmp-file (insert results))
-             (org-babel-import-elisp-from-file tmp-file))
-         (org-babel-read results))
+             (org-babel-import-elisp-from-file tmp-file)))
        (org-babel-pick-name
         (cdr (assoc :colname-names params)) (cdr (assoc :colnames params)))
        (org-babel-pick-name
index 4e4c3ab..78914bc 100644 (file)
@@ -39,9 +39,6 @@
 
 ;;; Code:
 (require 'ob)
-(require 'ob-ref)
-(require 'ob-comint)
-(require 'ob-eval)
 (eval-when-compile (require 'cl))
 
 (declare-function run-mozilla "ext:moz" (arg))
@@ -68,30 +65,32 @@ This function is called by `org-babel-execute-src-block'"
   (let* ((org-babel-js-cmd (or (cdr (assoc :cmd params)) org-babel-js-cmd))
          (result-type (cdr (assoc :result-type params)))
          (full-body (org-babel-expand-body:generic
-                    body params (org-babel-variable-assignments:js params))))
-    (org-babel-js-read
-     (if (not (string= (cdr (assoc :session params)) "none"))
-        ;; session evaluation
-         (let ((session (org-babel-prep-session:js
-                        (cdr (assoc :session params)) params)))
-          (nth 1
-               (org-babel-comint-with-output
-                   (session (format "%S" org-babel-js-eoe) t body)
-                 (mapc
-                  (lambda (line)
-                    (insert (org-babel-chomp line)) (comint-send-input nil t))
-                  (list body (format "%S" org-babel-js-eoe))))))
-       ;; external evaluation
-       (let ((script-file (org-babel-temp-file "js-script-")))
-         (with-temp-file script-file
-           (insert
-            ;; return the value or the output
-            (if (string= result-type "value")
-                (format org-babel-js-function-wrapper full-body)
-              full-body)))
-         (org-babel-eval
-         (format "%s %s" org-babel-js-cmd
-                 (org-babel-process-file-name script-file)) ""))))))
+                    body params (org-babel-variable-assignments:js params)))
+        (result (if (not (string= (cdr (assoc :session params)) "none"))
+                    ;; session evaluation
+                    (let ((session (org-babel-prep-session:js
+                                    (cdr (assoc :session params)) params)))
+                      (nth 1
+                           (org-babel-comint-with-output
+                               (session (format "%S" org-babel-js-eoe) t body)
+                             (mapc
+                              (lambda (line)
+                                (insert (org-babel-chomp line))
+                                (comint-send-input nil t))
+                              (list body (format "%S" org-babel-js-eoe))))))
+                  ;; external evaluation
+                  (let ((script-file (org-babel-temp-file "js-script-")))
+                    (with-temp-file script-file
+                      (insert
+                       ;; return the value or the output
+                       (if (string= result-type "value")
+                           (format org-babel-js-function-wrapper full-body)
+                         full-body)))
+                    (org-babel-eval
+                     (format "%s %s" org-babel-js-cmd
+                             (org-babel-process-file-name script-file)) "")))))
+    (org-babel-result-cond (cdr (assoc :result-params params))
+      result (org-babel-js-read result))))
 
 (defun org-babel-js-read (results)
   "Convert RESULTS into an appropriate elisp value.
index 01a54ca..6cc7387 100644 (file)
@@ -29,7 +29,7 @@
 ;; functions and their associated keys.
 
 ;;; Code:
-(require 'ob)
+(require 'ob-core)
 
 (defvar org-babel-key-prefix "\C-c\C-v"
   "The key prefix for Babel interactive key-bindings.
index 104f971..94d5133 100644 (file)
 (declare-function org-create-formula-image "org" (string tofile options buffer))
 (declare-function org-splice-latex-header "org"
                  (tpl def-pkg pkg snippets-p &optional extra))
-(declare-function org-export-latex-fix-inputenc "org-latex" ())
+(declare-function org-latex-guess-inputenc "ox-latex" (header))
+(declare-function org-latex-compile "ox-latex" (file))
+
 (defvar org-babel-tangle-lang-exts)
 (add-to-list 'org-babel-tangle-lang-exts '("latex" . "tex"))
 
-(defvar org-format-latex-header)
-(defvar org-format-latex-header-extra)
-(defvar org-export-latex-packages-alist)
-(defvar org-export-latex-default-packages-alist)
-(defvar org-export-pdf-logfiles)
-(defvar org-latex-to-pdf-process)
-(defvar org-export-pdf-remove-logfiles)
-(defvar org-format-latex-options)
-(defvar org-export-latex-packages-alist)
+(defvar org-format-latex-header)         ; From org.el
+(defvar org-format-latex-options)        ; From org.el
+(defvar org-latex-default-packages-alist) ; From org.el
+(defvar org-latex-packages-alist)        ; From org.el
 
 (defvar org-babel-default-header-args:latex
   '((:results . "latex") (:exports . "results"))
@@ -81,28 +78,28 @@ This function is called by `org-babel-execute-src-block'."
             (width (and fit (cdr (assoc :pdfwidth params))))
             (headers (cdr (assoc :headers params)))
             (in-buffer (not (string= "no" (cdr (assoc :buffer params)))))
-            (org-export-latex-packages-alist
-             (append (cdr (assoc :packages params))
-                     org-export-latex-packages-alist)))
+            (org-latex-packages-alist
+             (append (cdr (assoc :packages params)) org-latex-packages-alist)))
         (cond
          ((and (string-match "\\.png$" out-file) (not imagemagick))
           (org-create-formula-image
            body out-file org-format-latex-options in-buffer))
          ((or (string-match "\\.pdf$" out-file) imagemagick)
-         (require 'org-latex)
          (with-temp-file tex-file
+           (require 'ox-latex)
            (insert
-            (org-splice-latex-header
-             org-format-latex-header
-             (delq
-              nil
-              (mapcar
-               (lambda (el)
-                 (unless (and (listp el) (string= "hyperref" (cadr el)))
-                   el))
-               org-export-latex-default-packages-alist))
-             org-export-latex-packages-alist
-             org-format-latex-header-extra)
+            (org-latex-guess-inputenc
+             (org-splice-latex-header
+              org-format-latex-header
+              (delq
+               nil
+               (mapcar
+                (lambda (el)
+                  (unless (and (listp el) (string= "hyperref" (cadr el)))
+                    el))
+                org-latex-default-packages-alist))
+              org-latex-packages-alist
+              nil))
             (if fit "\n\\usepackage[active, tightpage]{preview}\n" "")
             (if border (format "\\setlength{\\PreviewBorder}{%s}" border) "")
             (if height (concat "\n" (format "\\pdfpageheight %s" height)) "")
@@ -113,14 +110,10 @@ This function is called by `org-babel-execute-src-block'."
                             (mapconcat #'identity headers "\n")
                           headers) "\n")
               "")
-            (if org-format-latex-header-extra
-                (concat "\n" org-format-latex-header-extra)
-              "")
             (if fit
                 (concat "\n\\begin{document}\n\\begin{preview}\n" body
                         "\n\\end{preview}\n\\end{document}\n")
-              (concat "\n\\begin{document}\n" body "\n\\end{document}\n")))
-           (org-export-latex-fix-inputenc))
+              (concat "\n\\begin{document}\n" body "\n\\end{document}\n"))))
           (when (file-exists-p out-file) (delete-file out-file))
          (let ((transient-pdf-file (org-babel-latex-tex-to-pdf tex-file)))
            (cond
@@ -137,7 +130,6 @@ This function is called by `org-babel-execute-src-block'."
         nil) ;; signal that output has already been written to file
     body))
 
-
 (defun convert-pdf (pdffile out-file im-in-options im-out-options)
   "Generate a file from a pdf file using imagemagick."
   (let ((cmd (concat "convert " im-in-options " " pdffile " "
@@ -146,55 +138,14 @@ This function is called by `org-babel-execute-src-block'."
     (shell-command cmd)))
 
 (defun org-babel-latex-tex-to-pdf (file)
-  "Generate a pdf file according to the contents FILE.
-Extracted from `org-export-as-pdf' in org-latex.el."
-  (let* ((wconfig (current-window-configuration))
-         (default-directory (file-name-directory file))
-         (base (file-name-sans-extension file))
-         (pdffile (concat base ".pdf"))
-         (cmds org-latex-to-pdf-process)
-         (outbuf (get-buffer-create "*Org PDF LaTeX Output*"))
-         output-dir cmd)
-    (with-current-buffer outbuf (erase-buffer))
-    (message (concat "Processing LaTeX file " file "..."))
-    (setq output-dir (file-name-directory file))
-    (if (and cmds (symbolp cmds))
-       (funcall cmds (shell-quote-argument file))
-      (while cmds
-       (setq cmd (pop cmds))
-       (while (string-match "%b" cmd)
-         (setq cmd (replace-match
-                    (save-match-data
-                      (shell-quote-argument base))
-                    t t cmd)))
-       (while (string-match "%f" cmd)
-         (setq cmd (replace-match
-                    (save-match-data
-                      (shell-quote-argument file))
-                    t t cmd)))
-       (while (string-match "%o" cmd)
-         (setq cmd (replace-match
-                    (save-match-data
-                      (shell-quote-argument output-dir))
-                    t t cmd)))
-       (shell-command cmd outbuf)))
-    (message (concat "Processing LaTeX file " file "...done"))
-    (if (not (file-exists-p pdffile))
-       (error (concat "PDF file " pdffile " was not produced"))
-      (set-window-configuration wconfig)
-      (when org-export-pdf-remove-logfiles
-       (dolist (ext org-export-pdf-logfiles)
-         (setq file (concat base "." ext))
-         (and (file-exists-p file) (delete-file file))))
-      (message "Exporting to PDF...done")
-      pdffile)))
+  "Generate a pdf file according to the contents FILE."
+  (require 'ox-latex)
+  (org-latex-compile file))
 
 (defun org-babel-prep-session:latex (session params)
   "Return an error because LaTeX doesn't support sessions."
   (error "LaTeX does not support sessions"))
 
-(provide 'ob-latex)
-
-
 
+(provide 'ob-latex)
 ;;; ob-latex.el ends here
index 0554a36..6080a5a 100644 (file)
 ;; http://lilypond.org/manuals.html
 
 ;;; Code:
-
 (require 'ob)
-(require 'ob-eval)
-(require 'ob-tangle)
 (require 'outline)
 (defalias 'lilypond-mode 'LilyPond-mode)
 
@@ -155,7 +152,11 @@ specific arguments to =org-babel-tangle="
       " -dbackend=eps "
       "-dno-gs-load-fonts "
       "-dinclude-eps-fonts "
-      "--png "
+      (or (cdr (assoc (file-name-extension out-file)
+                     '(("pdf" . "--pdf ")
+                       ("ps" . "--ps ")
+                       ("png" . "--png "))))
+         "--png ")
       "--output="
       (file-name-sans-extension out-file)
       " "
index 4ff9718..2bb1a25 100644 (file)
@@ -76,8 +76,8 @@ current directory string."
   (require 'slime)
   (org-babel-reassemble-table
    ((lambda (result)
-      (if (member "output" (cdr (assoc :result-params params)))
-         (car result)
+      (org-babel-result-cond (cdr (assoc :result-params params))
+       (car result)
        (condition-case nil
            (read (org-babel-lisp-vector-to-list (cadr result)))
          (error (cadr result)))))
index 3727829..802aa60 100644 (file)
@@ -25,7 +25,7 @@
 ;;; Code:
 (eval-when-compile
   (require 'cl))
-(require 'ob)
+(require 'ob-core)
 (require 'ob-table)
 
 (declare-function org-babel-in-example-or-verbatim "ob-exp" nil)
@@ -116,27 +116,30 @@ if so then run the appropriate source block from the Library."
         (list (length (if (= (length (match-string 12)) 0)
                           (match-string 2) (match-string 11)))))))))
 
+(defvar org-babel-default-header-args:emacs-lisp) ; Defined in ob-emacs-lisp.el
 (defun org-babel-lob-execute (info)
   "Execute the lob call specified by INFO."
   (let* ((mkinfo (lambda (p) (list "emacs-lisp" "results" p nil nil (nth 2 info))))
         (pre-params (org-babel-merge-params
                      org-babel-default-header-args
+                     org-babel-default-header-args:emacs-lisp
                      (org-babel-params-from-properties)
                      (org-babel-parse-header-arguments
                       (org-no-properties
                        (concat ":var results="
                                (mapconcat #'identity (butlast info) " "))))))
         (pre-info (funcall mkinfo pre-params))
-        (cache? (and (cdr (assoc :cache pre-params))
-                     (string= "yes" (cdr (assoc :cache pre-params)))))
-        (new-hash (when cache? (org-babel-sha1-hash pre-info)))
-        (old-hash (when cache? (org-babel-current-result-hash))))
-    (if (and cache? (equal new-hash old-hash))
+        (cache-p (and (cdr (assoc :cache pre-params))
+                      (string= "yes" (cdr (assoc :cache pre-params)))))
+        (new-hash (when cache-p (org-babel-sha1-hash pre-info)))
+        (old-hash (when cache-p (org-babel-current-result-hash))))
+    (if (and cache-p (equal new-hash old-hash))
        (save-excursion (goto-char (org-babel-where-is-src-block-result))
                        (forward-line 1)
                        (message "%S" (org-babel-read-result)))
-      (prog1 (org-babel-execute-src-block
-             nil (funcall mkinfo (org-babel-process-params pre-params)))
+      (prog1 (let* ((proc-params (org-babel-process-params pre-params))
+                    org-confirm-babel-evaluate)
+              (org-babel-execute-src-block nil (funcall mkinfo proc-params)))
        ;; update the hash
        (when new-hash (org-babel-set-current-result-hash new-hash))))))
 
index 4a91ca9..726d686 100644 (file)
@@ -83,16 +83,15 @@ called by `org-babel-execute-src-block'."
                     (mapcar (lambda (line)
                               (unless (or (string-match "batch" line)
                                           (string-match "^rat: replaced .*$" line)
+                                          (string-match "^;;; Loading #P" line)
                                           (= 0 (length line)))
                                 line))
                             (split-string raw "[\r\n]"))) "\n"))
            (org-babel-eval cmd "")))))
     (if (org-babel-maxima-graphical-output-file params)
        nil
-      (if (or (member "scalar" result-params)
-             (member "verbatim" result-params)
-             (member "output" result-params))
-         result
+      (org-babel-result-cond result-params
+       result
        (let ((tmp-file (org-babel-temp-file "maxima-res-")))
          (with-temp-file tmp-file (insert result))
          (org-babel-import-elisp-from-file tmp-file))))))
index 5838d7d..209ad7d 100644 (file)
@@ -55,7 +55,6 @@
 
 ;;; Code:
 (require 'ob)
-(require 'ob-eval)
 
 (defvar org-babel-default-header-args:mscgen
   '((:results . "file") (:exports . "results"))
index bff41f8..6a83908 100644 (file)
 
 ;;; Code:
 (require 'ob)
-(require 'ob-comint)
 (require 'comint)
 (eval-when-compile (require 'cl))
 
 (declare-function tuareg-run-caml "ext:tuareg" ())
+(declare-function tuareg-run-ocaml "ext:tuareg" ())
 (declare-function tuareg-interactive-send-input "ext:tuareg" ())
 
 (defvar org-babel-tangle-lang-exts)
                                         (progn (setq out t) nil))))
                                   (mapcar #'org-babel-trim (reverse raw))))))))
     (org-babel-reassemble-table
-     (org-babel-ocaml-parse-output (org-babel-trim clean))
+     (let ((raw (org-babel-trim clean)))
+       (org-babel-result-cond (cdr (assoc :result-params params))
+        ;; strip type information from output
+        (if (string-match "= \\(.+\\)$" raw) (match-string 1 raw) raw)
+        (org-babel-ocaml-parse-output raw)))
      (org-babel-pick-name
       (cdr (assoc :colname-names params)) (cdr (assoc :colnames params)))
      (org-babel-pick-name
@@ -89,8 +93,9 @@
                                                  (stringp session))
                                             session
                                           tuareg-interactive-buffer-name)))
-    (save-window-excursion (tuareg-run-caml)
-                           (get-buffer tuareg-interactive-buffer-name))))
+    (save-window-excursion
+      (if (fboundp 'tuareg-run-caml) (tuareg-run-caml) (tuareg-run-ocaml))
+      (get-buffer tuareg-interactive-buffer-name))))
 
 (defun org-babel-variable-assignments:ocaml (params)
   "Return list of ocaml statements assigning the block's variables."
index 3394d57..c2a3abb 100644 (file)
@@ -30,9 +30,6 @@
 
 ;;; Code:
 (require 'ob)
-(require 'ob-ref)
-(require 'ob-comint)
-(require 'ob-eval)
 (eval-when-compile (require 'cl))
 
 (declare-function matlab-shell "ext:matlab-mode")
index a5cd96a..18cce3b 100644 (file)
@@ -29,7 +29,8 @@
 ;;; Code:
 (require 'ob)
 
-(declare-function org-export-string "org-exp" (string fmt &optional dir))
+(declare-function org-export-string-as "ox"
+                 (string backend &optional body-only ext-plist))
 
 (defvar org-babel-default-header-args:org
   '((:results . "raw silent") (:exports . "code"))
@@ -53,10 +54,10 @@ This function is called by `org-babel-execute-src-block'."
        (body (org-babel-expand-body:org
               (replace-regexp-in-string "^," "" body) params)))
     (cond
-     ((member "latex" result-params) (org-export-string
-                                     (concat "#+Title: \n" body) "latex"))
-     ((member "html" result-params)  (org-export-string body "html"))
-     ((member "ascii" result-params) (org-export-string body "ascii"))
+     ((member "latex" result-params)
+      (org-export-string-as (concat "#+Title: \n" body) 'latex t))
+     ((member "html" result-params) (org-export-string-as  body 'html t))
+     ((member "ascii" result-params) (org-export-string-as body 'ascii t))
      (t body))))
 
 (defun org-babel-prep-session:org (session params)
index b37df80..43ab946 100644 (file)
@@ -28,7 +28,6 @@
 
 ;;; Code:
 (require 'ob)
-(require 'ob-eval)
 (eval-when-compile (require 'cl))
 
 (defvar org-babel-tangle-lang-exts)
@@ -49,7 +48,7 @@ This function is called by `org-babel-execute-src-block'."
                     body params (org-babel-variable-assignments:perl params)))
         (session (org-babel-perl-initiate-session session)))
     (org-babel-reassemble-table
-     (org-babel-perl-evaluate session full-body result-type)
+     (org-babel-perl-evaluate session full-body result-type result-params)
      (org-babel-pick-name
       (cdr (assoc :colname-names params)) (cdr (assoc :colnames params)))
      (org-babel-pick-name
@@ -63,20 +62,33 @@ This function is called by `org-babel-execute-src-block'."
   "Return list of perl statements assigning the block's variables."
   (mapcar
    (lambda (pair)
-     (format "$%s=%s;"
-            (car pair)
-            (org-babel-perl-var-to-perl (cdr pair))))
+     (org-babel-perl--var-to-perl (cdr pair) (car pair)))
    (mapcar #'cdr (org-babel-get-header params :var))))
 
 ;; helper functions
 
-(defun org-babel-perl-var-to-perl (var)
+(defvar org-babel-perl-var-wrap "q(%s)"
+  "Wrapper for variables inserted into Perl code.")
+
+(defvar org-babel-perl--lvl)
+(defun org-babel-perl--var-to-perl (var &optional varn)
   "Convert an elisp value to a perl variable.
 The elisp value, VAR, is converted to a string of perl source code
 specifying a var of the same value."
-  (if (listp var)
-      (concat "[" (mapconcat #'org-babel-perl-var-to-perl var ", ") "]")
-    (format "%S" var)))
+  (if varn
+      (let ((org-babel-perl--lvl 0) (lvar (listp var)) prefix)
+       (concat "my $" (symbol-name varn) "=" (when lvar "\n")
+               (org-babel-perl--var-to-perl var)
+               ";\n"))
+    (let ((prefix (make-string (* 2 org-babel-perl--lvl) ?\ )))
+      (concat prefix
+             (if (listp var)
+                 (let ((org-babel-perl--lvl (1+ org-babel-perl--lvl)))
+                   (concat "[\n"
+                           (mapconcat #'org-babel-perl--var-to-perl var "")
+                           prefix "]"))
+               (format "q(%s)" var))
+             (unless (zerop org-babel-perl--lvl) ",\n")))))
 
 (defvar org-babel-perl-buffers '(:default . nil))
 
@@ -84,32 +96,60 @@ specifying a var of the same value."
   "Return nil because sessions are not supported by perl."
   nil)
 
-(defvar org-babel-perl-wrapper-method
-  "
-sub main {
-%s
-}
-@r = main;
-open(o, \">%s\");
-print o join(\"\\n\", @r), \"\\n\"")
+(defvar org-babel-perl-wrapper-method "{
+    my $babel_sub = sub {
+        %s
+    };
+    open my $BOH, qq(>%s) or die qq(Perl: Could not open output file.$/);
+    my $rv = &$babel_sub();
+    my $rt = ref $rv;
+    select $BOH;
+    if (qq(ARRAY) eq $rt) {
+        local $\\=$/;
+        local $,=qq(\t);
+       foreach my $rv ( @$rv ) {
+           my $rt = ref $rv;
+           if (qq(ARRAY) eq $rt) {
+               print @$rv;
+           } else {
+               print $rv;
+           }
+       }
+    } else {
+       print $rv;
+    }
+}")
+
+(defvar org-babel-perl-preface nil)
 
 (defvar org-babel-perl-pp-wrapper-method
   nil)
 
-(defun org-babel-perl-evaluate (session body &optional result-type)
+(defun org-babel-perl-evaluate (session ibody &optional result-type result-params)
   "Pass BODY to the Perl 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."
   (when session (error "Sessions are not supported for Perl"))
-  (case result-type
-    (output (org-babel-eval org-babel-perl-command body))
-    (value (let ((tmp-file (org-babel-temp-file "perl-")))
-            (org-babel-eval
-             org-babel-perl-command
-             (format org-babel-perl-wrapper-method body
-                     (org-babel-process-file-name tmp-file 'noquote)))
-            (org-babel-eval-read-file tmp-file)))))
+  (let* ((body (concat org-babel-perl-preface ibody))
+        (tmp-file (org-babel-temp-file "perl-"))
+        (tmp-babel-file (org-babel-process-file-name
+                         tmp-file 'noquote)))
+    ((lambda (results)
+       (when results
+        (org-babel-result-cond result-params
+          (org-babel-eval-read-file tmp-file)
+          (org-babel-import-elisp-from-file tmp-file '(16)))))
+     (case result-type
+       (output
+       (with-temp-file tmp-file
+         (insert
+          (org-babel-eval org-babel-perl-command body))
+         (buffer-string)))
+       (value
+       (org-babel-eval org-babel-perl-command
+                       (format org-babel-perl-wrapper-method
+                               body tmp-babel-file)))))))
 
 (provide 'ob-perl)
 
index 1029b6f..1d17919 100644 (file)
@@ -54,8 +54,6 @@
 
 ;;; Code:
 (require 'ob)
-(require 'ob-eval)
-(require 'ob-comint)
 (require 'comint)
 (eval-when-compile (require 'cl))
 
@@ -80,7 +78,7 @@
   :version "24.1"
   :type 'string)
 
-(defun org-babel-expand-body:picolisp (body params &optional processed-params)
+(defun org-babel-expand-body:picolisp (body params)
   "Expand BODY according to PARAMS, return the expanded body."
   (let ((vars (mapcar #'cdr (org-babel-get-header params :var)))
         (result-params (cdr (assoc :result-params params)))
            (t full-body))))
 
     ((lambda (result)
-       (if (or (member "verbatim" result-params)
-               (member "scalar" result-params)
-               (member "output" result-params)
-               (member "code" result-params)
-               (member "pp" result-params)
-               (= (length result) 0))
-           result
+       (org-babel-result-cond result-params
+        result
          (read result)))
      (if (not (string= session-name "none"))
          ;; session based evaluation
index bb52c37..c17d444 100644 (file)
@@ -35,7 +35,6 @@
 
 ;;; Code:
 (require 'ob)
-(require 'ob-eval)
 
 (defvar org-babel-default-header-args:plantuml
   '((:results . "file") (:exports . "results"))
index 79cc53e..eca4c82 100644 (file)
@@ -28,9 +28,6 @@
 
 ;;; Code:
 (require 'ob)
-(require 'ob-ref)
-(require 'ob-comint)
-(require 'ob-eval)
 (eval-when-compile (require 'cl))
 
 (declare-function org-remove-indentation "org" )
 
 (defvar org-babel-default-header-args:python '())
 
-(defvar org-babel-python-command "python"
-  "Name of the command for executing Python code.")
+(defcustom org-babel-python-command "python"
+  "Name of the command for executing Python code."
+  :version "24.4"
+  :package-version '(Org . "8.0")
+  :group 'org-babel
+  :type 'string)
 
-(defvar org-babel-python-mode (if (featurep 'xemacs) 'python-mode 'python)
+(defcustom org-babel-python-mode
+  (if (or (featurep 'xemacs) (featurep 'python-mode)) 'python-mode 'python)
   "Preferred python mode for use in running python interactively.
-This will typically be either 'python or 'python-mode.")
+This will typically be either 'python or 'python-mode."
+  :group 'org-babel
+  :version "24.4"
+  :package-version '(Org . "8.0")
+  :type 'function)
 
 (defvar org-src-preserve-indentation)
 
+(defcustom org-babel-python-hline-to "None"
+  "Replace hlines in incoming tables with this when translating to python."
+  :group 'org-babel
+  :version "24.4"
+  :package-version '(Org . "8.0")
+  :type 'string)
+
+(defcustom org-babel-python-None-to 'hline
+  "Replace 'None' in python tables with this before returning."
+  :group 'org-babel
+  :version "24.4"
+  :package-version '(Org . "8.0")
+  :type 'string)
+
 (defun org-babel-execute:python (body params)
   "Execute a block of Python code with Babel.
 This function is called by `org-babel-execute-src-block'."
@@ -114,7 +134,7 @@ specifying a variable of the same value."
   (if (listp var)
       (concat "[" (mapconcat #'org-babel-python-var-to-python var ", ") "]")
     (if (equal var 'hline)
-       "None"
+       org-babel-python-hline-to
       (format
        (if (and (stringp var) (string-match "[\n\r]" var)) "\"\"%S\"\"" "%S")
        var))))
@@ -123,14 +143,34 @@ specifying a variable of the same value."
   "Convert RESULTS into an appropriate elisp value.
 If the results look like a list or tuple, then convert them into an
 Emacs-lisp table, otherwise return the results as a string."
-  (org-babel-script-escape results))
+  ((lambda (res)
+     (if (listp res)
+        (mapcar (lambda (el) (if (equal el 'None)
+                            org-babel-python-None-to el))
+                res)
+       res))
+   (org-babel-script-escape results)))
 
-(defvar org-babel-python-buffers '((:default . nil)))
+(defvar org-babel-python-buffers '((:default . "*Python*")))
 
 (defun org-babel-python-session-buffer (session)
   "Return the buffer associated with SESSION."
   (cdr (assoc session org-babel-python-buffers)))
 
+(defun org-babel-python-with-earmufs (session)
+  (let ((name (if (stringp session) session (format "%s" session))))
+    (if (and (string= "*" (substring name 0 1))
+            (string= "*" (substring name (- (length name) 1))))
+       name
+      (format "*%s*" name))))
+
+(defun org-babel-python-without-earmufs (session)
+  (let ((name (if (stringp session) session (format "%s" session))))
+    (if (and (string= "*" (substring name 0 1))
+            (string= "*" (substring name (- (length name) 1))))
+       (substring name 1 (- (length name) 1))
+      name)))
+
 (defvar py-default-interpreter)
 (defun org-babel-python-initiate-session-by-key (&optional session)
   "Initiate a python session.
@@ -144,7 +184,15 @@ then create.  Return the initialized session."
        ((and (eq 'python org-babel-python-mode)
             (fboundp 'run-python)) ; python.el
        (if (version< "24.1" emacs-version)
-           (run-python org-babel-python-command)
+           (progn
+             (unless python-buffer
+               (setq python-buffer (org-babel-python-with-earmufs session)))
+             (let ((python-shell-buffer-name
+                    (org-babel-python-without-earmufs python-buffer)))
+               (run-python
+                (if (member system-type '(cygwin windows-nt ms-dos))
+                    (concat org-babel-python-command " -i")
+                  org-babel-python-command))))
          (run-python)))
        ((and (eq 'python-mode org-babel-python-mode)
             (fboundp 'py-shell)) ; python-mode.el
@@ -160,7 +208,7 @@ then create.  Return the initialized session."
                          (concat "Python-" (symbol-name session))))
               (py-which-bufname bufname))
          (py-shell)
-         (setq python-buffer (concat "*" bufname "*"))))
+         (setq python-buffer (org-babel-python-with-earmufs bufname))))
        (t
        (error "No function available for running an inferior Python")))
       (setq org-babel-python-buffers
@@ -206,11 +254,8 @@ If RESULT-TYPE equals 'output then return standard output as a
 string.  If RESULT-TYPE equals 'value then return the value of the
 last statement in BODY, as elisp."
   ((lambda (raw)
-     (if (or (member "code" result-params)
-            (member "pp" result-params)
-            (and (member "output" result-params)
-                 (not (member "table" result-params))))
-        raw
+     (org-babel-result-cond result-params
+       raw
        (org-babel-python-table-or-string (org-babel-trim raw))))
    (case result-type
      (output (org-babel-eval org-babel-python-command
@@ -259,11 +304,8 @@ last statement in BODY, as elisp."
                       (funcall send-wait))))
     ((lambda (results)
        (unless (string= (substring org-babel-python-eoe-indicator 1 -1) results)
-        (if (or (member "code" result-params)
-                (member "pp" result-params)
-                (and (member "output" result-params)
-                     (not (member "table" result-params))))
-            results
+        (org-babel-result-cond result-params
+          results
           (org-babel-python-table-or-string results))))
      (case result-type
        (output
index 389c363..a2814ea 100644 (file)
@@ -40,7 +40,7 @@
 ;; So an example of a simple src block referencing table data in the
 ;; same file would be
 
-;;  #+TBLNAME: sandbox
+;;  #+NAME: sandbox
 ;;  | 1 |         2 | 3 |
 ;;  | 4 | org-babel | 6 |
 ;;
@@ -49,7 +49,7 @@
 ;;  #+end_src
 
 ;;; Code:
-(require 'ob)
+(require 'ob-core)
 (eval-when-compile
   (require 'cl))
 
index 747c6fc..20fb418 100644 (file)
@@ -37,9 +37,6 @@
 
 ;;; Code:
 (require 'ob)
-(require 'ob-ref)
-(require 'ob-comint)
-(require 'ob-eval)
 (eval-when-compile (require 'cl))
 
 (declare-function run-ruby "ext:inf-ruby" (&optional command name))
@@ -71,7 +68,9 @@ This function is called by `org-babel-execute-src-block'."
                   (org-babel-ruby-evaluate
                    session full-body result-type result-params))))
     (org-babel-reassemble-table
-     result
+     (org-babel-result-cond result-params
+       result
+       (org-babel-ruby-table-or-string result))
      (org-babel-pick-name (cdr (assoc :colname-names params))
                          (cdr (assoc :colnames params)))
      (org-babel-pick-name (cdr (assoc :rowname-names params))
@@ -206,31 +205,27 @@ return the value of the last statement in BODY, as elisp."
              (comint-send-input nil t)) 2)
           "\n") "[\r\n]")) "\n"))
       (value
-       ((lambda (results)
-         (if (or (member "code" result-params) (member "pp" result-params))
-             results
-           (org-babel-ruby-table-or-string results)))
-       (let* ((tmp-file (org-babel-temp-file "ruby-"))
-              (ppp (or (member "code" result-params)
-                       (member "pp" result-params))))
-         (org-babel-comint-with-output
-             (buffer org-babel-ruby-eoe-indicator t body)
-           (when ppp (insert "require 'pp';") (comint-send-input nil t))
-           (mapc
-            (lambda (line)
-              (insert (org-babel-chomp line)) (comint-send-input nil t))
-            (append
-             (list body)
-             (if (not ppp)
-                 (list (format org-babel-ruby-f-write
-                               (org-babel-process-file-name tmp-file 'noquote)))
-               (list
-                "results=_" "require 'pp'" "orig_out = $stdout"
-                (format org-babel-ruby-pp-f-write
-                        (org-babel-process-file-name tmp-file 'noquote))))
-             (list org-babel-ruby-eoe-indicator)))
-           (comint-send-input nil t))
-         (org-babel-eval-read-file tmp-file)))))))
+       (let* ((tmp-file (org-babel-temp-file "ruby-"))
+             (ppp (or (member "code" result-params)
+                      (member "pp" result-params))))
+        (org-babel-comint-with-output
+            (buffer org-babel-ruby-eoe-indicator t body)
+          (when ppp (insert "require 'pp';") (comint-send-input nil t))
+          (mapc
+           (lambda (line)
+             (insert (org-babel-chomp line)) (comint-send-input nil t))
+           (append
+            (list body)
+            (if (not ppp)
+                (list (format org-babel-ruby-f-write
+                              (org-babel-process-file-name tmp-file 'noquote)))
+              (list
+               "results=_" "require 'pp'" "orig_out = $stdout"
+               (format org-babel-ruby-pp-f-write
+                       (org-babel-process-file-name tmp-file 'noquote))))
+            (list org-babel-ruby-eoe-indicator)))
+          (comint-send-input nil t))
+        (org-babel-eval-read-file tmp-file))))))
 
 (defun org-babel-ruby-read-string (string)
   "Strip \\\"s from around a ruby string."
index 60a10db..cdb75be 100644 (file)
@@ -39,7 +39,6 @@
 
 ;;; Code:
 (require 'ob)
-(require 'ob-eval)
 
 (defvar org-babel-default-header-args:sass '())
 
index 3a07b34..7cb3099 100644 (file)
@@ -31,9 +31,6 @@
 
 ;;; Code:
 (require 'ob)
-(require 'ob-ref)
-(require 'ob-comint)
-(require 'ob-eval)
 (eval-when-compile (require 'cl))
 
 (defvar org-babel-tangle-lang-exts) ;; Autoloaded
@@ -104,8 +101,8 @@ in BODY as elisp."
             (wrapper (format org-babel-scala-wrapper-method body)))
        (with-temp-file src-file (insert wrapper))
        ((lambda (raw)
-          (if (member "code" result-params)
-              raw
+          (org-babel-result-cond result-params
+           raw
             (org-babel-scala-table-or-string raw)))
         (org-babel-eval
          (concat org-babel-scala-command " " src-file) ""))))))
index bd7ea82..89dd003 100644 (file)
@@ -38,9 +38,6 @@
 
 ;;; Code:
 (require 'ob)
-(require 'ob-ref)
-(require 'ob-comint)
-(require 'ob-eval)
 (eval-when-compile (require 'cl))
 
 (declare-function run-scheme "ext:cmuscheme" (cmd))
@@ -75,29 +72,31 @@ This function is called by `org-babel-execute-src-block'"
   (let* ((result-type (cdr (assoc :result-type params)))
         (org-babel-scheme-cmd (or (cdr (assoc :scheme params))
                                   org-babel-scheme-cmd))
-         (full-body (org-babel-expand-body:scheme body params)))
-    (read
-     (if (not (string= (cdr (assoc :session params)) "none"))
-         ;; session evaluation
-        (let ((session (org-babel-prep-session:scheme
-                        (cdr (assoc :session params)) params)))
-          (org-babel-comint-with-output
-              (session (format "%S" org-babel-scheme-eoe) t body)
-            (mapc
-             (lambda (line)
-               (insert (org-babel-chomp line)) (comint-send-input nil t))
-             (list body (format "%S" org-babel-scheme-eoe)))))
-       ;; external evaluation
-       (let ((script-file (org-babel-temp-file "scheme-script-")))
-         (with-temp-file script-file
-           (insert
-            ;; return the value or the output
-            (if (string= result-type "value")
-                (format "(display %s)" full-body)
-              full-body)))
-         (org-babel-eval
-         (format "%s %s" org-babel-scheme-cmd
-                 (org-babel-process-file-name script-file)) ""))))))
+         (full-body (org-babel-expand-body:scheme body params))
+        (result (if (not (string= (cdr (assoc :session params)) "none"))
+                    ;; session evaluation
+                    (let ((session (org-babel-prep-session:scheme
+                                    (cdr (assoc :session params)) params)))
+                      (org-babel-comint-with-output
+                          (session (format "%S" org-babel-scheme-eoe) t body)
+                        (mapc
+                         (lambda (line)
+                           (insert (org-babel-chomp line))
+                           (comint-send-input nil t))
+                         (list body (format "%S" org-babel-scheme-eoe)))))
+                  ;; external evaluation
+                  (let ((script-file (org-babel-temp-file "scheme-script-")))
+                    (with-temp-file script-file
+                      (insert
+                       ;; return the value or the output
+                       (if (string= result-type "value")
+                           (format "(display %s)" full-body)
+                         full-body)))
+                    (org-babel-eval
+                     (format "%s %s" org-babel-scheme-cmd
+                             (org-babel-process-file-name script-file)) "")))))
+    (org-babel-result-cond (cdr (assoc :result-params params))
+      result (read result))))
 
 (defun org-babel-prep-session:scheme (session params)
   "Prepare SESSION according to the header arguments specified in PARAMS."
index 621110b..f263376 100644 (file)
@@ -34,7 +34,6 @@
 
 ;;; Code:
 (require 'ob)
-(require 'ob-ref)
 
 (defvar org-babel-screen-location "screen"
   "The command location for screen.
index c0e6b15..f11b799 100644 (file)
@@ -27,9 +27,6 @@
 
 ;;; Code:
 (require 'ob)
-(require 'ob-ref)
-(require 'ob-comint)
-(require 'ob-eval)
 (require 'shell)
 (eval-when-compile (require 'cl))
 
@@ -141,10 +138,8 @@ return the value of the last statement in BODY."
   ((lambda (results)
      (when results
        (let ((result-params (cdr (assoc :result-params params))))
-        (if (or (member "scalar" result-params)
-                (member "verbatim" result-params)
-                (member "output" result-params))
-            results
+        (org-babel-result-cond result-params
+          results
           (let ((tmp-file (org-babel-temp-file "sh-")))
             (with-temp-file tmp-file (insert results))
             (org-babel-import-elisp-from-file tmp-file))))))
index ec31546..a41580f 100644 (file)
@@ -66,9 +66,8 @@ This function is called by `org-babel-execute-src-block'"
         (result-params (cdr (assoc :result-params params)))
          (full-body (org-babel-expand-body:shen body params)))
     ((lambda (results)
-       (if (or (member 'scalar result-params)
-              (member 'verbatim result-params))
-          results
+       (org-babel-result-cond result-params 
+        results
         (condition-case nil (org-babel-script-escape results)
           (error results))))
      (with-temp-buffer
index 131fa46..658a54f 100644 (file)
 ;;
 ;; Also SQL evaluation generally takes place inside of a database.
 ;;
-;; For now lets just allow a generic ':cmdline' header argument.
+;; Header args used:
+;; - engine
+;; - cmdline
+;; - dbhost
+;; - dbuser
+;; - dbpassword
+;; - database
+;; - colnames (default, nil, means "yes")
+;; - result-params
+;; - out-file
+;; The following are used but not really implemented for SQL:
+;; - colname-names
+;; - rownames
+;; - rowname-names
 ;;
 ;; TODO:
 ;;
 ;; - support for sessions
-;; - add more useful header arguments (user, passwd, database, etc...)
 ;; - support for more engines (currently only supports mysql)
 ;; - what's a reasonable way to drop table data into SQL?
 ;;
 
 (defvar org-babel-default-header-args:sql '())
 
-(defvar org-babel-header-args:sql
-  '((engine   . :any)
-    (out-file . :any)))
+(defconst org-babel-header-args:sql
+  '((engine           . :any)
+    (out-file         . :any)
+    (dbhost           . :any)
+    (dbuser           . :any)
+    (dbpassword               . :any)
+    (database         . :any))
+  "SQL-specific header arguments.")
 
 (defun org-babel-expand-body:sql (body params)
   "Expand BODY according to the values of PARAMS."
   (org-babel-sql-expand-vars
    body (mapcar #'cdr (org-babel-get-header params :var))))
 
+(defun dbstring-mysql (host user password database)
+  "Make MySQL cmd line args for database connection.  Pass nil to omit that arg."
+  (combine-and-quote-strings
+   (remq nil
+        (list (when host     (concat "-h" host))
+              (when user     (concat "-u" user))
+              (when password (concat "-p" password))
+              (when database (concat "-D" database))))))
+
 (defun org-babel-execute:sql (body params)
   "Execute a block of Sql code with Babel.
 This function is called by `org-babel-execute-src-block'."
   (let* ((result-params (cdr (assoc :result-params params)))
          (cmdline (cdr (assoc :cmdline params)))
+         (dbhost (cdr (assoc :dbhost params)))
+         (dbuser (cdr (assoc :dbuser params)))
+         (dbpassword (cdr (assoc :dbpassword params)))
+         (database (cdr (assoc :database params)))
          (engine (cdr (assoc :engine params)))
+         (colnames-p (not (equal "no" (cdr (assoc :colnames params)))))
          (in-file (org-babel-temp-file "sql-in-"))
          (out-file (or (cdr (assoc :out-file params))
                        (org-babel-temp-file "sql-out-")))
         (header-delim "")
          (command (case (intern engine)
-                    ('dbi (format "dbish --batch '%s' < %s | sed '%s' > %s"
+                    ('dbi (format "dbish --batch %s < %s | sed '%s' > %s"
                                  (or cmdline "")
                                  (org-babel-process-file-name in-file)
-                                 "/^+/d;s/^\|//;$d"
+                                 "/^+/d;s/^\|//;s/(NULL)/ /g;$d"
                                  (org-babel-process-file-name out-file)))
                     ('monetdb (format "mclient -f tab %s < %s > %s"
                                       (or cmdline "")
@@ -85,7 +116,9 @@ This function is called by `org-babel-execute-src-block'."
                                      (or cmdline "")
                                      (org-babel-process-file-name in-file)
                                      (org-babel-process-file-name out-file)))
-                    ('mysql (format "mysql %s < %s > %s"
+                    ('mysql (format "mysql %s %s %s < %s > %s"
+                                   (dbstring-mysql dbhost dbuser dbpassword database)
+                                   (if colnames-p "" "-N")
                                     (or cmdline "")
                                    (org-babel-process-file-name in-file)
                                    (org-babel-process-file-name out-file)))
@@ -102,28 +135,39 @@ This function is called by `org-babel-execute-src-block'."
         (t ""))
        (org-babel-expand-body:sql body params)))
     (message command)
-    (shell-command command)
-    (if (or (member "scalar" result-params)
-           (member "verbatim" result-params)
-           (member "html" result-params)
-           (member "code" result-params)
-           (equal (point-min) (point-max)))
-       (with-temp-buffer
+    (org-babel-eval command "")
+    (org-babel-result-cond result-params
+      (with-temp-buffer
          (progn (insert-file-contents-literally out-file) (buffer-string)))
       (with-temp-buffer
-       ;; need to figure out what the delimiter is for the header row
-       (with-temp-buffer
-         (insert-file-contents out-file)
-         (goto-char (point-min))
-         (when (re-search-forward "^\\(-+\\)[^-]" nil t)
-           (setq header-delim (match-string-no-properties 1)))
-         (goto-char (point-max))
-         (forward-char -1)
-         (while (looking-at "\n")
-           (delete-char 1)
-           (goto-char (point-max))
-           (forward-char -1))
-         (write-file out-file))
+       (cond
+         ((or (eq (intern engine) 'mysql)
+              (eq (intern engine) 'dbi)
+              (eq (intern engine) 'postgresql))
+          ;; Add header row delimiter after column-names header in first line
+          (cond
+           (colnames-p
+            (with-temp-buffer
+              (insert-file-contents out-file)
+              (goto-char (point-min))
+              (forward-line 1)
+              (insert "-\n")
+              (setq header-delim "-")
+              (write-file out-file)))))
+         (t
+          ;; Need to figure out the delimiter for the header row
+          (with-temp-buffer
+            (insert-file-contents out-file)
+            (goto-char (point-min))
+            (when (re-search-forward "^\\(-+\\)[^-]" nil t)
+              (setq header-delim (match-string-no-properties 1)))
+            (goto-char (point-max))
+            (forward-char -1)
+            (while (looking-at "\n")
+              (delete-char 1)
+              (goto-char (point-max))
+              (forward-char -1))
+            (write-file out-file))))
        (org-table-import out-file '(16))
        (org-babel-reassemble-table
         (mapcar (lambda (x)
index c25e786..84d4688 100644 (file)
@@ -27,8 +27,6 @@
 
 ;;; Code:
 (require 'ob)
-(require 'ob-eval)
-(require 'ob-ref)
 
 (declare-function org-fill-template "org" (template alist))
 (declare-function org-table-convert-region "org-table"
@@ -98,23 +96,21 @@ This function is called by `org-babel-execute-src-block'."
          (cons "db " db)))
        ;; body of the code block
        (org-babel-expand-body:sqlite body params)))
-      (if (or (member "scalar" result-params)
-             (member "verbatim" result-params)
-             (member "html" result-params)
-             (member "code" result-params)
-             (equal (point-min) (point-max)))
-         (buffer-string)
-       (org-table-convert-region (point-min) (point-max)
-                                 (if (or (member :csv others)
-                                         (member :column others)
-                                         (member :line others)
-                                         (member :list others)
-                                         (member :html others) separator)
-                                     nil
-                                   '(4)))
-       (org-babel-sqlite-table-or-scalar
-        (org-babel-sqlite-offset-colnames
-         (org-table-to-lisp) headers-p))))))
+      (org-babel-result-cond result-params
+       (buffer-string)
+       (if (equal (point-min) (point-max))
+           ""
+         (org-table-convert-region (point-min) (point-max)
+                                   (if (or (member :csv others)
+                                           (member :column others)
+                                           (member :line others)
+                                           (member :list others)
+                                           (member :html others) separator)
+                                       nil
+                                     '(4)))
+         (org-babel-sqlite-table-or-scalar
+          (org-babel-sqlite-offset-colnames
+           (org-table-to-lisp) headers-p)))))))
 
 (defun org-babel-sqlite-expand-vars (body vars)
   "Expand the variables held in VARS in BODY."
@@ -147,7 +143,7 @@ This function is called by `org-babel-execute-src-block'."
     (mapcar (lambda (row)
              (if (equal 'hline row)
                  'hline
-               (mapcar #'org-babel-read row))) result)))
+               (mapcar #'org-babel-string-read row))) result)))
 
 (defun org-babel-sqlite-offset-colnames (table headers-p)
   "If HEADERS-P is non-nil then offset the first row as column names."
index 99951ca..869d992 100644 (file)
@@ -50,7 +50,7 @@
 ;; #+TBLFM: $2='(sbe 'fibbd (n $1))
 
 ;;; Code:
-(require 'ob)
+(require 'ob-core)
 
 (defun org-babel-table-truncate-at-newline (string)
   "Replace newline character with ellipses.
index c3b6a48..f15567f 100644 (file)
@@ -26,7 +26,6 @@
 ;; Extract the code from source blocks out into raw source-code files.
 
 ;;; Code:
-(require 'ob)
 (require 'org-src)
 (eval-when-compile
   (require 'cl))
@@ -136,27 +135,6 @@ evaluating BODY."
        ,temp-result)))
 (def-edebug-spec org-babel-with-temp-filebuffer (form body))
 
-;;;###autoload
-(defun org-babel-load-file (file)
-  "Load Emacs Lisp source code blocks in the Org-mode FILE.
-This function exports the source code using
-`org-babel-tangle' and then loads the resulting file using
-`load-file'."
-  (interactive "fFile to load: ")
-  (let* ((age (lambda (file)
-               (float-time
-                (time-subtract (current-time)
-                               (nth 5 (or (file-attributes (file-truename file))
-                                          (file-attributes file)))))))
-        (base-name (file-name-sans-extension file))
-        (exported-file (concat base-name ".el")))
-    ;; tangle if the org-mode file is newer than the elisp file
-    (unless (and (file-exists-p exported-file)
-                (> (funcall age file) (funcall age exported-file)))
-      (org-babel-tangle-file file exported-file "emacs-lisp"))
-    (load-file exported-file)
-    (message "Loaded %s" exported-file)))
-
 ;;;###autoload
 (defun org-babel-tangle-file (file &optional target-file lang)
   "Extract the bodies of source code blocks in FILE.
@@ -179,26 +157,25 @@ used to limit the exported source code blocks by language."
   (mapc (lambda (el) (copy-file el pub-dir t)) (org-babel-tangle-file filename)))
 
 ;;;###autoload
-(defun org-babel-tangle (&optional only-this-block target-file lang)
+(defun org-babel-tangle (&optional arg target-file lang)
   "Write code blocks to source-specific files.
 Extract the bodies of all source code blocks from the current
-file into their own source-specific files.  Optional argument
-TARGET-FILE can be used to specify a default export file for all
-source blocks.  Optional argument LANG can be used to limit the
-exported source code blocks by language."
+file into their own source-specific files.
+With one universal prefix argument, only tangle the block at point.
+When two universal prefix arguments, only tangle blocks for the
+tangle file of the block at point.
+Optional argument TARGET-FILE can be used to specify a default
+export file for all source blocks.  Optional argument LANG can be
+used to limit the exported source code blocks by language."
   (interactive "P")
   (run-hooks 'org-babel-pre-tangle-hook)
-  ;; possibly restrict the buffer to the current code block
+  ;; Possibly Restrict the buffer to the current code block
   (save-restriction
-    (when only-this-block
-      (unless (org-babel-where-is-src-block-head)
-       (error "Point is not currently inside of a code block"))
-      (save-match-data
-       (unless (or (cdr (assoc :tangle (nth 2 (org-babel-get-src-block-info))))
-                   target-file)
-         (setq target-file
-               (read-from-minibuffer "Tangle to: " (buffer-file-name)))))
-      (narrow-to-region (match-beginning 0) (match-end 0)))
+    (when (equal arg '(4))
+      (let ((head (org-babel-where-is-src-block-head)))
+         (if head
+             (goto-char head)
+           (user-error "Point is not in a source code block"))))
     (save-excursion
       (let ((block-counter 0)
            (org-babel-default-header-args
@@ -206,6 +183,10 @@ exported source code blocks by language."
                 (org-babel-merge-params org-babel-default-header-args
                                         (list (cons :tangle target-file)))
               org-babel-default-header-args))
+           (tangle-file
+            (when (equal arg '(16))
+              (or (cdr (assoc :tangle (nth 2 (org-babel-get-src-block-info))))
+                  (user-error "Point is not in a source code block"))))
            path-collector)
        (mapc ;; map over all languages
         (lambda (by-lang)
@@ -266,7 +247,9 @@ exported source code blocks by language."
                      (setq block-counter (+ 1 block-counter))
                      (add-to-list 'path-collector file-name)))))
              specs)))
-        (org-babel-tangle-collect-blocks lang))
+        (if (equal arg '(4))
+            (org-babel-tangle-single-block 1 t)
+          (org-babel-tangle-collect-blocks lang tangle-file)))
        (message "Tangled %d code block%s from %s" block-counter
                 (if (= block-counter 1) "" "s")
                 (file-name-nondirectory
@@ -298,12 +281,12 @@ references."
 (defvar org-bracket-link-regexp)
 (defun org-babel-spec-to-string (spec)
   "Insert SPEC into the current file.
-Insert the source-code specified by SPEC into the current
-source code file.  This function uses `comment-region' which
-assumes that the appropriate major-mode is set.  SPEC has the
-form
 
-  (start-line file link source-name params body comment)"
+Insert the source-code specified by SPEC into the current source
+code file.  This function uses `comment-region' which assumes
+that the appropriate major-mode is set.  SPEC has the form:
+
+  \(start-line file link source-name params body comment)"
   (let* ((start-line (nth 0 spec))
         (file (nth 1 spec))
         (link (nth 2 spec))
@@ -335,116 +318,137 @@ form
     (insert
      (format
       "%s\n"
-      (replace-regexp-in-string
-       "^," ""
+      (org-unescape-code-in-string
        (org-babel-trim body (if org-src-preserve-indentation "[\f\n\r\v]")))))
     (when link-p
       (funcall
        insert-comment
        (org-fill-template org-babel-tangle-comment-format-end link-data)))))
 
-(defun org-babel-tangle-collect-blocks (&optional language)
+(defvar org-comment-string) ;; Defined in org.el
+(defun org-babel-tangle-collect-blocks (&optional language tangle-file)
   "Collect source blocks in the current Org-mode file.
 Return an association list of source-code block specifications of
 the form used by `org-babel-spec-to-string' grouped by language.
-Optional argument LANG can be used to limit the collected source
-code blocks by language."
-  (let ((block-counter 1) (current-heading "") blocks)
+Optional argument LANGUAGE can be used to limit the collected
+source code blocks by language.  Optional argument TANGLE-FILE
+can be used to limit the collected code blocks by target file."
+  (let ((block-counter 1) (current-heading "") blocks by-lang)
     (org-babel-map-src-blocks (buffer-file-name)
-      ((lambda (new-heading)
-        (if (not (string= new-heading current-heading))
-            (progn
-              (setq block-counter 1)
-              (setq current-heading new-heading))
-          (setq block-counter (+ 1 block-counter))))
-       (replace-regexp-in-string "[ \t]" "-"
-                                (condition-case nil
-                                    (or (nth 4 (org-heading-components))
-                                        "(dummy for heading without text)")
-                                  (error (buffer-file-name)))))
-      (let* ((start-line (save-restriction (widen)
-                                          (+ 1 (line-number-at-pos (point)))))
-            (file (buffer-file-name))
-            (info (org-babel-get-src-block-info 'light))
-            (src-lang (nth 0 info)))
-        (unless (string= (cdr (assoc :tangle (nth 2 info))) "no")
+      (lambda (new-heading)
+       (if (not (string= new-heading current-heading))
+           (progn
+             (setq block-counter 1)
+             (setq current-heading new-heading))
+         (setq block-counter (+ 1 block-counter))))
+      (replace-regexp-in-string "[ \t]" "-"
+                               (condition-case nil
+                                   (or (nth 4 (org-heading-components))
+                                       "(dummy for heading without text)")
+                                 (error (buffer-file-name))))
+      (let* ((info (org-babel-get-src-block-info 'light))
+            (src-lang (nth 0 info))
+            (src-tfile (cdr (assoc :tangle (nth 2 info)))))
+        (unless (or (string-match (concat "^" org-comment-string) current-heading)
+                   (string= (cdr (assoc :tangle (nth 2 info))) "no")
+                   (and tangle-file (not (equal tangle-file src-tfile))))
           (unless (and language (not (string= language src-lang)))
-           (let* ((info (org-babel-get-src-block-info))
-                  (params (nth 2 info))
-                  (extra (nth 3 info))
-                  (cref-fmt (or (and (string-match "-l \"\\(.+\\)\"" extra)
-                                     (match-string 1 extra))
-                                org-coderef-label-format))
-                  (link ((lambda (link)
-                           (and (string-match org-bracket-link-regexp link)
-                                (match-string 1 link)))
-                         (org-no-properties
-                          (org-store-link nil))))
-                  (source-name
-                   (intern (or (nth 4 info)
-                               (format "%s:%d"
-                                       current-heading block-counter))))
-                  (expand-cmd
-                   (intern (concat "org-babel-expand-body:" src-lang)))
-                  (assignments-cmd
-                   (intern (concat "org-babel-variable-assignments:" src-lang)))
-                  (body
-                   ((lambda (body) ;; run the tangle-body-hook
-                      (with-temp-buffer
-                        (insert body)
-                        (when (string-match "-r" extra)
-                          (goto-char (point-min))
-                          (while (re-search-forward
-                                  (replace-regexp-in-string "%s" ".+" cref-fmt) nil t)
-                            (replace-match "")))
-                        (run-hooks 'org-babel-tangle-body-hook)
-                        (buffer-string)))
-                    ((lambda (body) ;; expand the body in language specific manner
-                       (if (assoc :no-expand params)
-                           body
-                         (if (fboundp expand-cmd)
-                             (funcall expand-cmd body params)
-                           (org-babel-expand-body:generic
-                            body params
-                            (and (fboundp assignments-cmd)
-                                 (funcall assignments-cmd params))))))
-                     (if (org-babel-noweb-p params :tangle)
-                         (org-babel-expand-noweb-references info)
-                       (nth 1 info)))))
-                  (comment
-                   (when (or (string= "both" (cdr (assoc :comments params)))
-                             (string= "org" (cdr (assoc :comments params))))
-                     ;; from the previous heading or code-block end
-                     (funcall
-                      org-babel-process-comment-text
-                      (buffer-substring
-                       (max (condition-case nil
-                                (save-excursion
-                                  (org-back-to-heading t)  ; sets match data
-                                  (match-end 0))
-                              (error (point-min)))
-                            (save-excursion
-                              (if (re-search-backward
-                                   org-babel-src-block-regexp nil t)
-                                  (match-end 0)
-                                (point-min))))
-                       (point)))))
-                  by-lang)
-             ;; add the spec for this block to blocks under it's language
-             (setq by-lang (cdr (assoc src-lang blocks)))
-             (setq blocks (delq (assoc src-lang blocks) blocks))
-             (setq blocks (cons
-                           (cons src-lang
-                                 (cons (list start-line file link
-                                             source-name params body comment)
-                                       by-lang)) blocks)))))))
-    ;; ensure blocks in the correct order
+           ;; Add the spec for this block to blocks under it's language
+           (setq by-lang (cdr (assoc src-lang blocks)))
+           (setq blocks (delq (assoc src-lang blocks) blocks))
+           (setq blocks (cons
+                         (cons src-lang
+                               (cons
+                                (org-babel-tangle-single-block
+                                 block-counter)
+                                by-lang)) blocks))))))
+    ;; Ensure blocks are in the correct order
     (setq blocks
           (mapcar
           (lambda (by-lang) (cons (car by-lang) (reverse (cdr by-lang))))
           blocks))
     blocks))
 
+(defun org-babel-tangle-single-block
+  (block-counter &optional only-this-block)
+  "Collect the tangled source for current block.
+Return the list of block attributes needed by
+`org-babel-tangle-collect-blocks'.
+When ONLY-THIS-BLOCK is non-nil, return the full association
+list to be used by `org-babel-tangle' directly."
+  (let* ((info (org-babel-get-src-block-info))
+        (start-line
+         (save-restriction (widen)
+                           (+ 1 (line-number-at-pos (point)))))
+        (file (buffer-file-name))
+        (src-lang (nth 0 info))
+        (params (nth 2 info))
+        (extra (nth 3 info))
+        (cref-fmt (or (and (string-match "-l \"\\(.+\\)\"" extra)
+                           (match-string 1 extra))
+                      org-coderef-label-format))
+        (link ((lambda (link)
+                 (and (string-match org-bracket-link-regexp link)
+                      (match-string 1 link)))
+               (org-no-properties
+                (org-store-link nil))))
+        (source-name
+         (intern (or (nth 4 info)
+                     (format "%s:%d"
+                             (or (ignore-errors (nth 4 (org-heading-components)))
+                                 "No heading")
+                             block-counter))))
+        (expand-cmd
+         (intern (concat "org-babel-expand-body:" src-lang)))
+        (assignments-cmd
+         (intern (concat "org-babel-variable-assignments:" src-lang)))
+        (body
+         ((lambda (body) ;; Run the tangle-body-hook
+            (with-temp-buffer
+              (insert body)
+              (when (string-match "-r" extra)
+                (goto-char (point-min))
+                (while (re-search-forward
+                        (replace-regexp-in-string "%s" ".+" cref-fmt) nil t)
+                  (replace-match "")))
+              (run-hooks 'org-babel-tangle-body-hook)
+              (buffer-string)))
+          ((lambda (body) ;; Expand the body in language specific manner
+             (if (assoc :no-expand params)
+                 body
+               (if (fboundp expand-cmd)
+                   (funcall expand-cmd body params)
+                 (org-babel-expand-body:generic
+                  body params
+                  (and (fboundp assignments-cmd)
+                       (funcall assignments-cmd params))))))
+           (if (org-babel-noweb-p params :tangle)
+               (org-babel-expand-noweb-references info)
+             (nth 1 info)))))
+        (comment
+         (when (or (string= "both" (cdr (assoc :comments params)))
+                   (string= "org" (cdr (assoc :comments params))))
+           ;; From the previous heading or code-block end
+           (funcall
+            org-babel-process-comment-text
+            (buffer-substring
+             (max (condition-case nil
+                      (save-excursion
+                        (org-back-to-heading t)  ; Sets match data
+                        (match-end 0))
+                    (error (point-min)))
+                  (save-excursion
+                    (if (re-search-backward
+                         org-babel-src-block-regexp nil t)
+                        (match-end 0)
+                      (point-min))))
+             (point)))))
+        (result
+         (list start-line file link source-name params body comment)))
+    (if only-this-block
+       (list (cons src-lang (list result)))
+      result)))
+
 (defun org-babel-tangle-comment-links ( &optional info)
   "Return a list of begin and end link comments for the code block at point."
   (let* ((start-line (org-babel-where-is-src-block-head))
index 7245714..6cacac7 100644 (file)
@@ -3,7 +3,6 @@
 ;; Copyright (C) 2009-2013 Free Software Foundation, Inc.
 
 ;; Authors: Eric Schulte
-;;     Dan Davison
 ;; Keywords: literate programming, reproducible research
 ;; Homepage: http://orgmode.org
 
 ;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
 
 ;;; Code:
-(eval-when-compile
-  (require 'cl))
 (require 'ob-eval)
-(require 'org-macs)
-(require 'org-compat)
-
-(defconst org-babel-exeext
-  (if (memq system-type '(windows-nt cygwin))
-      ".exe"
-    nil))
-(defvar org-babel-call-process-region-original)
-(defvar org-src-lang-modes)
-(defvar org-babel-library-of-babel)
-(declare-function show-all "outline" ())
-(declare-function org-reduce "org" (CL-FUNC CL-SEQ &rest CL-KEYS))
-(declare-function org-mark-ring-push "org" (&optional pos buffer))
-(declare-function tramp-compat-make-temp-file "tramp-compat"
-                  (filename &optional dir-flag))
-(declare-function tramp-dissect-file-name "tramp" (name &optional nodefault))
-(declare-function tramp-file-name-user "tramp" (vec))
-(declare-function tramp-file-name-host "tramp" (vec))
-(declare-function with-parsed-tramp-file-name "tramp" (filename var &rest body))
-(declare-function org-icompleting-read "org" (&rest args))
-(declare-function org-edit-src-code "org-src"
-                  (&optional context code edit-buffer-name quietp))
-(declare-function org-edit-src-exit "org-src"  (&optional context))
-(declare-function org-open-at-point "org" (&optional in-emacs reference-buffer))
-(declare-function org-save-outline-visibility "org-macs" (use-markers &rest body))
-(declare-function org-outline-overlay-data "org" (&optional use-markers))
-(declare-function org-set-outline-overlay-data "org" (data))
-(declare-function org-narrow-to-subtree "org" ())
-(declare-function org-entry-get "org"
-                 (pom property &optional inherit literal-nil))
-(declare-function org-make-options-regexp "org" (kwds &optional extra))
-(declare-function org-do-remove-indentation "org" (&optional n))
-(declare-function org-show-context "org" (&optional key))
-(declare-function org-at-table-p "org" (&optional table-type))
-(declare-function org-cycle "org" (&optional arg))
-(declare-function org-uniquify "org" (list))
-(declare-function org-current-level "org" ())
-(declare-function org-table-import "org-table" (file arg))
-(declare-function org-add-hook "org-compat"
-                 (hook function &optional append local))
-(declare-function org-table-align "org-table" ())
-(declare-function org-table-end "org-table" (&optional table-type))
-(declare-function orgtbl-to-generic "org-table" (table params))
-(declare-function orgtbl-to-orgtbl "org-table" (table params))
-(declare-function org-babel-tangle-comment-links "ob-tangle" (&optional info))
-(declare-function org-babel-lob-get-info "ob-lob" nil)
-(declare-function org-babel-ref-split-args "ob-ref" (arg-string))
-(declare-function org-babel-ref-parse "ob-ref" (assignment))
-(declare-function org-babel-ref-resolve "ob-ref" (ref))
-(declare-function org-babel-ref-goto-headline-id "ob-ref" (id))
-(declare-function org-babel-ref-headline-body "ob-ref" ())
-(declare-function org-babel-lob-execute-maybe "ob-lob" ())
-(declare-function org-number-sequence "org-compat" (from &optional to inc))
-(declare-function org-at-item-p "org-list" ())
-(declare-function org-list-parse-list "org-list" (&optional delete))
-(declare-function org-list-to-generic "org-list" (LIST PARAMS))
-(declare-function org-list-struct "org-list" ())
-(declare-function org-list-prevs-alist "org-list" (struct))
-(declare-function org-list-get-list-end "org-list" (item struct prevs))
-(declare-function org-remove-if "org" (predicate seq))
-(declare-function org-completing-read "org" (&rest args))
-(declare-function org-escape-code-in-region "org-src" (beg end))
-(declare-function org-unescape-code-in-string "org-src" (s))
-(declare-function org-table-to-lisp "org-table" (&optional txt))
-
-(defgroup org-babel nil
-  "Code block evaluation and management in `org-mode' documents."
-  :tag "Babel"
-  :group 'org)
-
-(defcustom org-confirm-babel-evaluate t
-  "Confirm before evaluation.
-Require confirmation before interactively evaluating code
-blocks in Org-mode buffers.  The default value of this variable
-is t, meaning confirmation is required for any code block
-evaluation.  This variable can be set to nil to inhibit any
-future confirmation requests.  This variable can also be set to a
-function which takes two arguments the language of the code block
-and the body of the code block.  Such a function should then
-return a non-nil value if the user should be prompted for
-execution or nil if no prompt is required.
-
-Warning: Disabling confirmation may result in accidental
-evaluation of potentially harmful code.  It may be advisable
-remove code block execution from C-c C-c as further protection
-against accidental code block evaluation.  The
-`org-babel-no-eval-on-ctrl-c-ctrl-c' variable can be used to
-remove code block execution from the C-c C-c keybinding."
-  :group 'org-babel
-  :version "24.1"
-  :type '(choice boolean function))
-;; don't allow this variable to be changed through file settings
-(put 'org-confirm-babel-evaluate 'safe-local-variable (lambda (x) (eq x t)))
-
-(defcustom org-babel-no-eval-on-ctrl-c-ctrl-c nil
-  "Remove code block evaluation from the C-c C-c key binding."
-  :group 'org-babel
-  :version "24.1"
-  :type 'boolean)
-
-(defcustom org-babel-results-keyword "RESULTS"
-  "Keyword used to name results generated by code blocks.
-Should be either RESULTS or NAME however any capitalization may
-be used."
-  :group 'org-babel
-  :type 'string)
-
-(defcustom org-babel-noweb-wrap-start "<<"
-  "String used to begin a noweb reference in a code block.
-See also `org-babel-noweb-wrap-end'."
-  :group 'org-babel
-  :type 'string)
-
-(defcustom org-babel-noweb-wrap-end ">>"
-  "String used to end a noweb reference in a code block.
-See also `org-babel-noweb-wrap-start'."
-  :group 'org-babel
-  :type 'string)
-
-(defun org-babel-noweb-wrap (&optional regexp)
-  (concat org-babel-noweb-wrap-start
-         (or regexp "\\([^ \t\n].+?[^ \t]\\|[^ \t\n]\\)")
-         org-babel-noweb-wrap-end))
-
-(defvar org-babel-src-name-regexp
-  "^[ \t]*#\\+name:[ \t]*"
-  "Regular expression used to match a source name line.")
-
-(defvar org-babel-multi-line-header-regexp
-  "^[ \t]*#\\+headers?:[ \t]*\\([^\n]*\\)$"
-  "Regular expression used to match multi-line header arguments.")
-
-(defvar org-babel-src-name-w-name-regexp
-  (concat org-babel-src-name-regexp
-         "\\("
-         org-babel-multi-line-header-regexp
-         "\\)*"
-         "\\([^ ()\f\t\n\r\v]+\\)\\(\(\\(.*\\)\)\\|\\)")
-  "Regular expression matching source name lines with a name.")
-
-(defvar org-babel-src-block-regexp
-  (concat
-   ;; (1) indentation                 (2) lang
-   "^\\([ \t]*\\)#\\+begin_src[ \t]+\\([^ \f\t\n\r\v]+\\)[ \t]*"
-   ;; (3) switches
-   "\\([^\":\n]*\"[^\"\n*]*\"[^\":\n]*\\|[^\":\n]*\\)"
-   ;; (4) header arguments
-   "\\([^\n]*\\)\n"
-   ;; (5) body
-   "\\([^\000]*?\n\\)?[ \t]*#\\+end_src")
-  "Regexp used to identify code blocks.")
-
-(defvar org-babel-inline-src-block-regexp
-  (concat
-   ;; (1) replacement target (2) lang
-   "\\(?:^\\|[^-[:alnum:]]\\)\\(src_\\([^ \f\t\n\r\v]+\\)"
-   ;; (3,4) (unused, headers)
-   "\\(\\|\\[\\(.*?\\)\\]\\)"
-   ;; (5) body
-   "{\\([^\f\n\r\v]+?\\)}\\)")
-  "Regexp used to identify inline src-blocks.")
-
-(defun org-babel-get-header (params key &optional others)
-  "Select only header argument of type KEY from a list.
-Optional argument OTHERS indicates that only the header that do
-not match KEY should be returned."
-  (delq nil
-       (mapcar
-        (lambda (p) (when (funcall (if others #'not #'identity) (eq (car p) key)) p))
-        params)))
-
-(defun org-babel-get-inline-src-block-matches()
-  "Set match data if within body of an inline source block.
-Returns non-nil if match-data set"
-  (let ((src-at-0-p (save-excursion
-                     (beginning-of-line 1)
-                     (string= "src" (thing-at-point 'word))))
-       (first-line-p (= 1 (line-number-at-pos)))
-       (orig (point)))
-    (let ((search-for (cond ((and src-at-0-p first-line-p  "src_"))
-                           (first-line-p "[[:punct:] \t]src_")
-                           (t "[[:punct:] \f\t\n\r\v]src_")))
-         (lower-limit (if first-line-p
-                          nil
-                        (- (point-at-bol) 1))))
-      (save-excursion
-       (when (or (and src-at-0-p (bobp))
-                 (and (re-search-forward "}" (point-at-eol) t)
-                      (re-search-backward search-for lower-limit t)
-                      (> orig (point))))
-         (when (looking-at org-babel-inline-src-block-regexp)
-           t ))))))
-
-(defvar org-babel-inline-lob-one-liner-regexp)
-(defun org-babel-get-lob-one-liner-matches()
-  "Set match data if on line of an lob one liner.
-Returns non-nil if match-data set"
-  (save-excursion
-    (unless (= (point) (point-at-bol)) ;; move before inline block
-      (re-search-backward "[ \f\t\n\r\v]" nil t))
-    (if (looking-at org-babel-inline-lob-one-liner-regexp)
-       t
-      nil)))
-
-(defun org-babel-get-src-block-info (&optional light)
-  "Get information on the current source block.
-
-Optional argument LIGHT does not resolve remote variable
-references; a process which could likely result in the execution
-of other code blocks.
-
-Returns a list
- (language body header-arguments-alist switches name indent)."
-  (let ((case-fold-search t) head info name indent)
-    ;; full code block
-    (if (setq head (org-babel-where-is-src-block-head))
-       (save-excursion
-         (goto-char head)
-         (setq info (org-babel-parse-src-block-match))
-         (setq indent (car (last info)))
-         (setq info (butlast info))
-         (while (and (forward-line -1)
-                     (looking-at org-babel-multi-line-header-regexp))
-           (setf (nth 2 info)
-                 (org-babel-merge-params
-                  (nth 2 info)
-                  (org-babel-parse-header-arguments (match-string 1)))))
-         (when (looking-at org-babel-src-name-w-name-regexp)
-           (setq name (org-no-properties (match-string 3)))
-           (when (and (match-string 5) (> (length (match-string 5)) 0))
-             (setf (nth 2 info) ;; merge functional-syntax vars and header-args
-                   (org-babel-merge-params
-                    (mapcar
-                     (lambda (ref) (cons :var ref))
-                     (mapcar
-                      (lambda (var) ;; check that each variable is initialized
-                        (if (string-match ".+=.+" var)
-                            var
-                          (error
-                           "variable \"%s\"%s must be assigned a default value"
-                           var (if name (format " in block \"%s\"" name) ""))))
-                      (org-babel-ref-split-args (match-string 5))))
-                    (nth 2 info))))))
-      ;; inline source block
-      (when (org-babel-get-inline-src-block-matches)
-       (setq info (org-babel-parse-inline-src-block-match))))
-    ;; resolve variable references and add summary parameters
-    (when (and info (not light))
-      (setf (nth 2 info) (org-babel-process-params (nth 2 info))))
-    (when info (append info (list name indent)))))
-
-(defvar org-current-export-file) ; dynamically bound
-(defun org-babel-confirm-evaluate (info)
-  "Confirm evaluation of the code block INFO.
-This behavior can be suppressed by setting the value of
-`org-confirm-babel-evaluate' to nil, in which case all future
-interactive code block evaluations will proceed without any
-confirmation from the user.
-
-Note disabling confirmation may result in accidental evaluation
-of potentially harmful code."
-  (let* ((eval (or (cdr (assoc :eval (nth 2 info)))
-                  (when (assoc :noeval (nth 2 info)) "no")))
-         (query (cond ((equal eval "query") t)
-                     ((and (boundp 'org-current-export-file)
-                           org-current-export-file
-                           (equal eval "query-export")) t)
-                      ((functionp org-confirm-babel-evaluate)
-                       (funcall org-confirm-babel-evaluate
-                                (nth 0 info) (nth 1 info)))
-                      (t org-confirm-babel-evaluate))))
-    (if (or (equal eval "never") (equal eval "no")
-           (and (boundp 'org-current-export-file)
-                org-current-export-file
-                (or (equal eval "no-export")
-                    (equal eval "never-export")))
-           (and query
-                (not (yes-or-no-p
-                      (format "Evaluate this%scode block%son your system? "
-                              (if info (format " %s " (nth 0 info)) " ")
-                              (if (nth 4 info)
-                                  (format " (%s) " (nth 4 info)) " "))))))
-       (prog1 nil (message "Evaluation %s"
-                           (if (or (equal eval "never") (equal eval "no")
-                                   (equal eval "no-export")
-                                   (equal eval "never-export"))
-                               "Disabled" "Aborted")))
-      t)))
-
-;;;###autoload
-(defun org-babel-execute-safely-maybe ()
-  (unless org-babel-no-eval-on-ctrl-c-ctrl-c
-    (org-babel-execute-maybe)))
-
-(add-hook 'org-ctrl-c-ctrl-c-hook 'org-babel-execute-safely-maybe)
-
-;;;###autoload
-(defun org-babel-execute-maybe ()
-  (interactive)
-  (or (org-babel-execute-src-block-maybe)
-      (org-babel-lob-execute-maybe)))
-
-(defun org-babel-execute-src-block-maybe ()
-  "Conditionally execute a source block.
-Detect if this is context for a Babel src-block and if so
-then run `org-babel-execute-src-block'."
-  (interactive)
-  (let ((info (org-babel-get-src-block-info)))
-    (if info
-       (progn (org-babel-eval-wipe-error-buffer)
-              (org-babel-execute-src-block current-prefix-arg info) t) nil)))
-
-;;;###autoload
-(defun org-babel-view-src-block-info ()
-  "Display information on the current source block.
-This includes header arguments, language and name, and is largely
-a window into the `org-babel-get-src-block-info' function."
-  (interactive)
-  (let ((info (org-babel-get-src-block-info 'light))
-       (full (lambda (it) (> (length it) 0)))
-       (printf (lambda (fmt &rest args) (princ (apply #'format fmt args)))))
-    (when info
-      (with-help-window (help-buffer)
-       (let ((name        (nth 4 info))
-             (lang        (nth 0 info))
-             (switches    (nth 3 info))
-             (header-args (nth 2 info)))
-         (when name            (funcall printf "Name: %s\n"     name))
-         (when lang            (funcall printf "Lang: %s\n"     lang))
-         (when (funcall full switches) (funcall printf "Switches: %s\n" switches))
-         (funcall printf "Header Arguments:\n")
-         (dolist (pair (sort header-args
-                             (lambda (a b) (string< (symbol-name (car a))
-                                                    (symbol-name (car b))))))
-           (when (funcall full (cdr pair))
-             (funcall printf "\t%S%s\t%s\n"
-                      (car pair)
-                      (if (> (length (format "%S" (car pair))) 7) "" "\t")
-                      (cdr pair)))))))))
-
-;;;###autoload
-(defun org-babel-expand-src-block-maybe ()
-  "Conditionally expand a source block.
-Detect if this is context for a org-babel src-block and if so
-then run `org-babel-expand-src-block'."
-  (interactive)
-  (let ((info (org-babel-get-src-block-info)))
-    (if info
-       (progn (org-babel-expand-src-block current-prefix-arg info) t)
-      nil)))
-
-;;;###autoload
-(defun org-babel-load-in-session-maybe ()
-  "Conditionally load a source block in a session.
-Detect if this is context for a org-babel src-block and if so
-then run `org-babel-load-in-session'."
-  (interactive)
-  (let ((info (org-babel-get-src-block-info)))
-    (if info
-       (progn (org-babel-load-in-session current-prefix-arg info) t)
-      nil)))
-
-(add-hook 'org-metaup-hook 'org-babel-load-in-session-maybe)
-
-;;;###autoload
-(defun org-babel-pop-to-session-maybe ()
-  "Conditionally pop to a session.
-Detect if this is context for a org-babel src-block and if so
-then run `org-babel-pop-to-session'."
-  (interactive)
-  (let ((info (org-babel-get-src-block-info)))
-    (if info (progn (org-babel-pop-to-session current-prefix-arg info) t) nil)))
-
-(add-hook 'org-metadown-hook 'org-babel-pop-to-session-maybe)
-
-(defconst org-babel-common-header-args-w-values
-  '((cache     . ((no yes)))
-    (cmdline   . :any)
-    (colnames  . ((nil no yes)))
-    (comments  . ((no link yes org both noweb)))
-    (dir       . :any)
-    (eval      . ((never query)))
-    (exports   . ((code results both none)))
-    (file      . :any)
-    (file-desc  . :any)
-    (hlines    . ((no yes)))
-    (mkdirp    . ((yes no)))
-    (no-expand)
-    (noeval)
-    (noweb     . ((yes no tangle no-export strip-export)))
-    (noweb-ref . :any)
-    (noweb-sep  . :any)
-    (padline   . ((yes no)))
-    (results   . ((file list vector table scalar verbatim)
-                  (raw html latex org code pp drawer)
-                  (replace silent append prepend)
-                  (output value)))
-    (rownames  . ((no yes)))
-    (sep       . :any)
-    (session   . :any)
-    (shebang   . :any)
-    (tangle    . ((tangle yes no :any)))
-    (var       . :any)
-    (wrap       . :any)))
-
-(defconst org-babel-header-arg-names
-  (mapcar #'car org-babel-common-header-args-w-values)
-  "Common header arguments used by org-babel.
-Note that individual languages may define their own language
-specific header arguments as well.")
-
-(defvar org-babel-default-header-args
-  '((:session . "none") (:results . "replace") (:exports . "code")
-    (:cache . "no") (:noweb . "no") (:hlines . "no") (:tangle . "no")
-    (:padnewline . "yes"))
-  "Default arguments to use when evaluating a source block.")
-
-(defvar org-babel-default-inline-header-args
-  '((:session . "none") (:results . "replace") (:exports . "results"))
-  "Default arguments to use when evaluating an inline source block.")
-
-(defvar org-babel-data-names '("tblname" "results" "name"))
-
-(defvar org-babel-result-regexp
-  (concat "^[ \t]*#\\+"
-         (regexp-opt org-babel-data-names t)
-         "\\(\\[\\([[:alnum:]]+\\)\\]\\)?\\:[ \t]*")
-  "Regular expression used to match result lines.
-If the results are associated with a hash key then the hash will
-be saved in the second match data.")
-
-(defvar org-babel-result-w-name-regexp
-  (concat org-babel-result-regexp
-         "\\([^ ()\f\t\n\r\v]+\\)\\(\(\\(.*\\)\)\\|\\)"))
-
-(defvar org-babel-min-lines-for-block-output 10
-  "The minimum number of lines for block output.
-If number of lines of output is equal to or exceeds this
-value, the output is placed in a #+begin_example...#+end_example
-block.  Otherwise the output is marked as literal by inserting
-colons at the starts of the lines.  This variable only takes
-effect if the :results output option is in effect.")
-
-(defvar org-babel-noweb-error-langs nil
-  "Languages for which Babel will raise literate programming errors.
-List of languages for which errors should be raised when the
-source code block satisfying a noweb reference in this language
-can not be resolved.")
-
-(defvar org-babel-hash-show 4
-  "Number of initial characters to show of a hidden results hash.")
-
-(defvar org-babel-after-execute-hook nil
-  "Hook for functions to be called after `org-babel-execute-src-block'")
-
-(defun org-babel-named-src-block-regexp-for-name (name)
-  "This generates a regexp used to match a src block named NAME."
-  (concat org-babel-src-name-regexp (regexp-quote name)
-         "[ \t(]*[\r\n]\\(?:^#.*[\r\n]\\)*"
-         (substring org-babel-src-block-regexp 1)))
-
-(defun org-babel-named-data-regexp-for-name (name)
-  "This generates a regexp used to match data named NAME."
-  (concat org-babel-result-regexp (regexp-quote name) "\\([ \t]\\|$\\)"))
-
-;;; functions
-(defvar call-process-region)
-
-;;;###autoload
-(defun org-babel-execute-src-block (&optional arg info params)
-  "Execute the current source code block.
-Insert the results of execution into the buffer.  Source code
-execution and the collection and formatting of results can be
-controlled through a variety of header arguments.
-
-With prefix argument ARG, force re-execution even if an existing
-result cached in the buffer would otherwise have been returned.
-
-Optionally supply a value for INFO in the form returned by
-`org-babel-get-src-block-info'.
-
-Optionally supply a value for PARAMS which will be merged with
-the header arguments specified at the front of the source code
-block."
-  (interactive)
-  (let ((info (or info (org-babel-get-src-block-info))))
-    (when (org-babel-confirm-evaluate
-          (let ((i info))
-            (setf (nth 2 i) (org-babel-merge-params (nth 2 info) params))
-            i))
-      (let* ((lang (nth 0 info))
-            (params (if params
-                        (org-babel-process-params
-                         (org-babel-merge-params (nth 2 info) params))
-                      (nth 2 info)))
-            (cache? (and (not arg) (cdr (assoc :cache params))
-                         (string= "yes" (cdr (assoc :cache params)))))
-            (result-params (cdr (assoc :result-params params)))
-            (new-hash (when cache? (org-babel-sha1-hash info)))
-            (old-hash (when cache? (org-babel-current-result-hash)))
-            (body (setf (nth 1 info)
-                        (if (org-babel-noweb-p params :eval)
-                            (org-babel-expand-noweb-references info)
-                          (nth 1 info))))
-            (dir (cdr (assoc :dir params)))
-            (default-directory
-              (or (and dir (file-name-as-directory (expand-file-name dir)))
-                  default-directory))
-            (org-babel-call-process-region-original
-             (if (boundp 'org-babel-call-process-region-original)
-                 org-babel-call-process-region-original
-               (symbol-function 'call-process-region)))
-            (indent (car (last info)))
-            result cmd)
-       (unwind-protect
-           (let ((call-process-region
-                  (lambda (&rest args)
-                    (apply 'org-babel-tramp-handle-call-process-region args))))
-             (let ((lang-check (lambda (f)
-                                 (let ((f (intern (concat "org-babel-execute:" f))))
-                                   (when (fboundp f) f)))))
-               (setq cmd
-                     (or (funcall lang-check lang)
-                         (funcall lang-check (symbol-name
-                                              (cdr (assoc lang org-src-lang-modes))))
-                         (error "No org-babel-execute function for %s!" lang))))
-             (if (and (not arg) new-hash (equal new-hash old-hash))
-                 (save-excursion ;; return cached result
-                   (goto-char (org-babel-where-is-src-block-result nil info))
-                   (end-of-line 1) (forward-char 1)
-                   (setq result (org-babel-read-result))
-                   (message (replace-regexp-in-string
-                             "%" "%%" (format "%S" result))) result)
-               (message "executing %s code block%s..."
-                        (capitalize lang)
-                        (if (nth 4 info) (format " (%s)" (nth 4 info)) ""))
-               (setq result
-                     ((lambda (result)
-                        (if (and (eq (cdr (assoc :result-type params)) 'value)
-                                 (or (member "vector" result-params)
-                                     (member "table" result-params))
-                                 (not (listp result)))
-                            (list (list result)) result))
-                      (funcall cmd body params)))
-               ;; if non-empty result and :file then write to :file
-               (when (cdr (assoc :file params))
-                 (when result
-                   (with-temp-file (cdr (assoc :file params))
-                     (insert
-                      (org-babel-format-result
-                       result (cdr (assoc :sep (nth 2 info)))))))
-                 (setq result (cdr (assoc :file params))))
-               (org-babel-insert-result
-                result result-params info new-hash indent lang)
-               (run-hooks 'org-babel-after-execute-hook)
-               result))
-         (setq call-process-region 'org-babel-call-process-region-original))))))
-
-(defun org-babel-expand-body:generic (body params &optional var-lines)
-  "Expand BODY with PARAMS.
-Expand a block of code with org-babel according to its header
-arguments.  This generic implementation of body expansion is
-called for languages which have not defined their own specific
-org-babel-expand-body:lang function."
-  (mapconcat #'identity (append var-lines (list body)) "\n"))
-
-;;;###autoload
-(defun org-babel-expand-src-block (&optional arg info params)
-  "Expand the current source code block.
-Expand according to the source code block's header
-arguments and pop open the results in a preview buffer."
-  (interactive)
-  (let* ((info (or info (org-babel-get-src-block-info)))
-         (lang (nth 0 info))
-        (params (setf (nth 2 info)
-                       (sort (org-babel-merge-params (nth 2 info) params)
-                             (lambda (el1 el2) (string< (symbol-name (car el1))
-                                                       (symbol-name (car el2)))))))
-         (body (setf (nth 1 info)
-                    (if (org-babel-noweb-p params :eval)
-                        (org-babel-expand-noweb-references info) (nth 1 info))))
-         (expand-cmd (intern (concat "org-babel-expand-body:" lang)))
-        (assignments-cmd (intern (concat "org-babel-variable-assignments:"
-                                         lang)))
-         (expanded
-         (if (fboundp expand-cmd) (funcall expand-cmd body params)
-           (org-babel-expand-body:generic
-            body params (and (fboundp assignments-cmd)
-                             (funcall assignments-cmd params))))))
-    (org-edit-src-code
-     nil expanded (concat "*Org-Babel Preview " (buffer-name) "[ " lang " ]*"))))
-
-(defun org-babel-edit-distance (s1 s2)
-  "Return the edit (levenshtein) distance between strings S1 S2."
-  (let* ((l1 (length s1))
-        (l2 (length s2))
-        (dist (vconcat (mapcar (lambda (_) (make-vector (1+ l2) nil))
-                               (number-sequence 1 (1+ l1)))))
-        (in (lambda (i j) (aref (aref dist i) j)))
-        (mmin (lambda (&rest lst) (apply #'min (remove nil lst)))))
-    (setf (aref (aref dist 0) 0) 0)
-    (dolist (i (number-sequence 1 l1))
-      (dolist (j (number-sequence 1 l2))
-       (setf (aref (aref dist i) j)
-             (+ (if (equal (aref s1 (1- i)) (aref s2 (1- j))) 0 1)
-                (funcall mmin (funcall in (1- i) j)
-                         (funcall in i (1- j))
-                         (funcall in (1- i) (1- j)))))))
-    (funcall in l1 l2)))
-
-(defun org-babel-combine-header-arg-lists (original &rest others)
-  "Combine a number of lists of header argument names and arguments."
-  (let ((results (copy-sequence original)))
-    (dolist (new-list others)
-      (dolist (arg-pair new-list)
-       (let ((header (car arg-pair))
-             (args (cdr arg-pair)))
-         (setq results
-               (cons arg-pair (org-remove-if
-                               (lambda (pair) (equal header (car pair)))
-                               results))))))
-    results))
-
-;;;###autoload
-(defun org-babel-check-src-block ()
-  "Check for misspelled header arguments in the current code block."
-  (interactive)
-  ;; TODO: report malformed code block
-  ;; TODO: report incompatible combinations of header arguments
-  ;; TODO: report uninitialized variables
-  (let ((too-close 2) ;; <- control closeness to report potential match
-       (names (mapcar #'symbol-name org-babel-header-arg-names)))
-    (dolist (header (mapcar (lambda (arg) (substring (symbol-name (car arg)) 1))
-                           (and (org-babel-where-is-src-block-head)
-                                (org-babel-parse-header-arguments
-                                 (org-no-properties
-                                  (match-string 4))))))
-      (dolist (name names)
-       (when (and (not (string= header name))
-                  (<= (org-babel-edit-distance header name) too-close)
-                  (not (member header names)))
-         (error "Supplied header \"%S\" is suspiciously close to \"%S\""
-                header name))))
-    (message "No suspicious header arguments found.")))
-
-;;;###autoload
-(defun org-babel-insert-header-arg ()
-  "Insert a header argument selecting from lists of common args and values."
-  (interactive)
-  (let* ((lang (car (org-babel-get-src-block-info 'light)))
-        (lang-headers (intern (concat "org-babel-header-args:" lang)))
-        (headers (org-babel-combine-header-arg-lists
-                  org-babel-common-header-args-w-values
-                  (if (boundp lang-headers) (eval lang-headers) nil)))
-        (arg (org-icompleting-read
-              "Header Arg: "
-              (mapcar
-               (lambda (header-spec) (symbol-name (car header-spec)))
-               headers))))
-    (insert ":" arg)
-    (let ((vals (cdr (assoc (intern arg) headers))))
-      (when vals
-       (insert
-        " "
-        (cond
-         ((eq vals :any)
-          (read-from-minibuffer "value: "))
-         ((listp vals)
-          (mapconcat
-           (lambda (group)
-             (let ((arg (org-icompleting-read
-                         "value: "
-                         (cons "default" (mapcar #'symbol-name group)))))
-               (if (and arg (not (string= "default" arg)))
-                   (concat arg " ")
-                 "")))
-           vals ""))))))))
-
-;; Add support for completing-read insertion of header arguments after ":"
-(defun org-babel-header-arg-expand ()
-  "Call `org-babel-enter-header-arg-w-completion' in appropriate contexts."
-  (when (and (equal (char-before) ?\:) (org-babel-where-is-src-block-head))
-    (org-babel-enter-header-arg-w-completion (match-string 2))))
-
-(defun org-babel-enter-header-arg-w-completion (&optional lang)
-  "Insert header argument appropriate for LANG with completion."
-  (let* ((lang-headers-var (intern (concat "org-babel-header-args:" lang)))
-         (lang-headers (when (boundp lang-headers-var) (eval lang-headers-var)))
-        (headers-w-values (org-babel-combine-header-arg-lists
-                           org-babel-common-header-args-w-values lang-headers))
-         (headers (mapcar #'symbol-name (mapcar #'car headers-w-values)))
-         (header (org-completing-read "Header Arg: " headers))
-         (args (cdr (assoc (intern header) headers-w-values)))
-         (arg (when (and args (listp args))
-                (org-completing-read
-                 (format "%s: " header)
-                 (mapcar #'symbol-name (apply #'append args))))))
-    (insert (concat header " " (or arg "")))
-    (cons header arg)))
-
-(add-hook 'org-tab-first-hook 'org-babel-header-arg-expand)
-
-;;;###autoload
-(defun org-babel-load-in-session (&optional arg info)
-  "Load the body of the current source-code block.
-Evaluate the header arguments for the source block before
-entering the session.  After loading the body this pops open the
-session."
-  (interactive)
-  (let* ((info (or info (org-babel-get-src-block-info)))
-         (lang (nth 0 info))
-         (params (nth 2 info))
-         (body (setf (nth 1 info)
-                    (if (org-babel-noweb-p params :eval)
-                         (org-babel-expand-noweb-references info)
-                      (nth 1 info))))
-         (session (cdr (assoc :session params)))
-        (dir (cdr (assoc :dir params)))
-        (default-directory
-          (or (and dir (file-name-as-directory dir)) default-directory))
-        (cmd (intern (concat "org-babel-load-session:" lang))))
-    (unless (fboundp cmd)
-      (error "No org-babel-load-session function for %s!" lang))
-    (pop-to-buffer (funcall cmd session body params))
-    (end-of-line 1)))
-
-;;;###autoload
-(defun org-babel-initiate-session (&optional arg info)
-  "Initiate session for current code block.
-If called with a prefix argument then resolve any variable
-references in the header arguments and assign these variables in
-the session.  Copy the body of the code block to the kill ring."
-  (interactive "P")
-  (let* ((info (or info (org-babel-get-src-block-info (not arg))))
-         (lang (nth 0 info))
-         (body (nth 1 info))
-         (params (nth 2 info))
-         (session (cdr (assoc :session params)))
-        (dir (cdr (assoc :dir params)))
-        (default-directory
-          (or (and dir (file-name-as-directory dir)) default-directory))
-        (init-cmd (intern (format "org-babel-%s-initiate-session" lang)))
-        (prep-cmd (intern (concat "org-babel-prep-session:" lang))))
-    (if (and (stringp session) (string= session "none"))
-       (error "This block is not using a session!"))
-    (unless (fboundp init-cmd)
-      (error "No org-babel-initiate-session function for %s!" lang))
-    (with-temp-buffer (insert (org-babel-trim body))
-                      (copy-region-as-kill (point-min) (point-max)))
-    (when arg
-      (unless (fboundp prep-cmd)
-       (error "No org-babel-prep-session function for %s!" lang))
-      (funcall prep-cmd session params))
-    (funcall init-cmd session params)))
-
-;;;###autoload
-(defun org-babel-switch-to-session (&optional arg info)
-  "Switch to the session of the current code block.
-Uses `org-babel-initiate-session' to start the session.  If called
-with a prefix argument then this is passed on to
-`org-babel-initiate-session'."
-  (interactive "P")
-  (pop-to-buffer (org-babel-initiate-session arg info))
-  (end-of-line 1))
-
-(defalias 'org-babel-pop-to-session 'org-babel-switch-to-session)
-
-;;;###autoload
-(defun org-babel-switch-to-session-with-code (&optional arg info)
-  "Switch to code buffer and display session."
-  (interactive "P")
-  (let ((swap-windows
-        (lambda ()
-          (let ((other-window-buffer (window-buffer (next-window))))
-            (set-window-buffer (next-window) (current-buffer))
-            (set-window-buffer (selected-window) other-window-buffer))
-          (other-window 1)))
-       (info (org-babel-get-src-block-info))
-       (org-src-window-setup 'reorganize-frame))
-    (save-excursion
-      (org-babel-switch-to-session arg info))
-    (org-edit-src-code)
-    (funcall swap-windows)))
-
-(defmacro org-babel-do-in-edit-buffer (&rest body)
-  "Evaluate BODY in edit buffer if there is a code block at point.
-Return t if a code block was found at point, nil otherwise."
-  `(let ((org-src-window-setup 'switch-invisibly))
-     (when (and (org-babel-where-is-src-block-head)
-               (org-edit-src-code nil nil nil))
-       (unwind-protect (progn ,@body)
-        (if (org-bound-and-true-p org-edit-src-from-org-mode)
-            (org-edit-src-exit)))
-       t)))
-(def-edebug-spec org-babel-do-in-edit-buffer (body))
-
-(defun org-babel-do-key-sequence-in-edit-buffer (key)
-  "Read key sequence and execute the command in edit buffer.
-Enter a key sequence to be executed in the language major-mode
-edit buffer.  For example, TAB will alter the contents of the
-Org-mode code block according to the effect of TAB in the
-language major-mode buffer.  For languages that support
-interactive sessions, this can be used to send code from the Org
-buffer to the session for evaluation using the native major-mode
-evaluation mechanisms."
-  (interactive "kEnter key-sequence to execute in edit buffer: ")
-  (org-babel-do-in-edit-buffer
-   (call-interactively
-    (key-binding (or key (read-key-sequence nil))))))
-
-(defvar org-bracket-link-regexp)
-
-;;;###autoload
-(defun org-babel-open-src-block-result (&optional re-run)
-  "If `point' is on a src block then open the results of the
-source code block, otherwise return nil.  With optional prefix
-argument RE-RUN the source-code block is evaluated even if
-results already exist."
-  (interactive "P")
-  (let ((info (org-babel-get-src-block-info)))
-    (when info
-      (save-excursion
-       ;; go to the results, if there aren't any then run the block
-       (goto-char (or (and (not re-run) (org-babel-where-is-src-block-result))
-                      (progn (org-babel-execute-src-block)
-                             (org-babel-where-is-src-block-result))))
-       (end-of-line 1)
-       (while (looking-at "[\n\r\t\f ]") (forward-char 1))
-       ;; open the results
-       (if (looking-at org-bracket-link-regexp)
-           ;; file results
-           (org-open-at-point)
-         (let ((r (org-babel-format-result
-                   (org-babel-read-result) (cdr (assoc :sep (nth 2 info))))))
-           (pop-to-buffer (get-buffer-create "*Org-Babel Results*"))
-           (delete-region (point-min) (point-max))
-           (insert r)))
-       t))))
-
-;;;###autoload
-(defmacro org-babel-map-src-blocks (file &rest body)
-  "Evaluate BODY forms on each source-block in FILE.
-If FILE is nil evaluate BODY forms on source blocks in current
-buffer.  During evaluation of BODY the following local variables
-are set relative to the currently matched code block.
-
-full-block ------- string holding the entirety of the code block
-beg-block -------- point at the beginning of the code block
-end-block -------- point at the end of the matched code block
-lang ------------- string holding the language of the code block
-beg-lang --------- point at the beginning of the lang
-end-lang --------- point at the end of the lang
-switches --------- string holding the switches
-beg-switches ----- point at the beginning of the switches
-end-switches ----- point at the end of the switches
-header-args ------ string holding the header-args
-beg-header-args -- point at the beginning of the header-args
-end-header-args -- point at the end of the header-args
-body ------------- string holding the body of the code block
-beg-body --------- point at the beginning of the body
-end-body --------- point at the end of the body"
-  (declare (indent 1))
-  (let ((tempvar (make-symbol "file")))
-    `(let* ((,tempvar ,file)
-           (visited-p (or (null ,tempvar)
-                          (get-file-buffer (expand-file-name ,tempvar))))
-           (point (point)) to-be-removed)
-       (save-window-excursion
-        (when ,tempvar (find-file ,tempvar))
-        (setq to-be-removed (current-buffer))
-        (goto-char (point-min))
-        (while (re-search-forward org-babel-src-block-regexp nil t)
-          (goto-char (match-beginning 0))
-          (let ((full-block (match-string 0))
-                (beg-block (match-beginning 0))
-                (end-block (match-end 0))
-                (lang (match-string 2))
-                (beg-lang (match-beginning 2))
-                (end-lang (match-end 2))
-                (switches (match-string 3))
-                (beg-switches (match-beginning 3))
-                (end-switches (match-end 3))
-                (header-args (match-string 4))
-                (beg-header-args (match-beginning 4))
-                (end-header-args (match-end 4))
-                (body (match-string 5))
-                (beg-body (match-beginning 5))
-                (end-body (match-end 5)))
-            ,@body
-            (goto-char end-block))))
-       (unless visited-p (kill-buffer to-be-removed))
-       (goto-char point))))
-(def-edebug-spec org-babel-map-src-blocks (form body))
-
-;;;###autoload
-(defmacro org-babel-map-inline-src-blocks (file &rest body)
-  "Evaluate BODY forms on each inline source-block in FILE.
-If FILE is nil evaluate BODY forms on source blocks in current
-buffer."
-  (declare (indent 1))
-  (let ((tempvar (make-symbol "file")))
-    `(let* ((,tempvar ,file)
-           (visited-p (or (null ,tempvar)
-                          (get-file-buffer (expand-file-name ,tempvar))))
-           (point (point)) to-be-removed)
-       (save-window-excursion
-        (when ,tempvar (find-file ,tempvar))
-        (setq to-be-removed (current-buffer))
-        (goto-char (point-min))
-        (while (re-search-forward org-babel-inline-src-block-regexp nil t)
-          (goto-char (match-beginning 1))
-          (save-match-data ,@body)
-          (goto-char (match-end 0))))
-       (unless visited-p (kill-buffer to-be-removed))
-       (goto-char point))))
-(def-edebug-spec org-babel-map-inline-src-blocks (form body))
-
-(defvar org-babel-lob-one-liner-regexp)
-
-;;;###autoload
-(defmacro org-babel-map-call-lines (file &rest body)
-  "Evaluate BODY forms on each call line in FILE.
-If FILE is nil evaluate BODY forms on source blocks in current
-buffer."
-  (declare (indent 1))
-  (let ((tempvar (make-symbol "file")))
-    `(let* ((,tempvar ,file)
-           (visited-p (or (null ,tempvar)
-                          (get-file-buffer (expand-file-name ,tempvar))))
-           (point (point)) to-be-removed)
-       (save-window-excursion
-        (when ,tempvar (find-file ,tempvar))
-        (setq to-be-removed (current-buffer))
-        (goto-char (point-min))
-        (while (re-search-forward org-babel-lob-one-liner-regexp nil t)
-          (goto-char (match-beginning 1))
-          (save-match-data ,@body)
-          (goto-char (match-end 0))))
-       (unless visited-p (kill-buffer to-be-removed))
-       (goto-char point))))
-(def-edebug-spec org-babel-map-call-lines (form body))
-
-;;;###autoload
-(defmacro org-babel-map-executables (file &rest body)
-  (declare (indent 1))
-  (let ((tempvar (make-symbol "file"))
-       (rx (make-symbol "rx")))
-    `(let* ((,tempvar ,file)
-           (,rx (concat "\\(" org-babel-src-block-regexp
-                        "\\|" org-babel-inline-src-block-regexp
-                        "\\|" org-babel-lob-one-liner-regexp "\\)"))
-           (visited-p (or (null ,tempvar)
-                          (get-file-buffer (expand-file-name ,tempvar))))
-           (point (point)) to-be-removed)
-       (save-window-excursion
-        (when ,tempvar (find-file ,tempvar))
-        (setq to-be-removed (current-buffer))
-        (goto-char (point-min))
-        (while (re-search-forward ,rx nil t)
-          (goto-char (match-beginning 1))
-          (when (looking-at org-babel-inline-src-block-regexp)(forward-char 1))
-          (save-match-data ,@body)
-          (goto-char (match-end 0))))
-       (unless visited-p (kill-buffer to-be-removed))
-       (goto-char point))))
-(def-edebug-spec org-babel-map-executables (form body))
-
-;;;###autoload
-(defun org-babel-execute-buffer (&optional arg)
-  "Execute source code blocks in a buffer.
-Call `org-babel-execute-src-block' on every source block in
-the current buffer."
-  (interactive "P")
-  (org-babel-eval-wipe-error-buffer)
-  (org-save-outline-visibility t
-    (org-babel-map-executables nil
-      (if (looking-at org-babel-lob-one-liner-regexp)
-          (org-babel-lob-execute-maybe)
-        (org-babel-execute-src-block arg)))))
-
-;;;###autoload
-(defun org-babel-execute-subtree (&optional arg)
-  "Execute source code blocks in a subtree.
-Call `org-babel-execute-src-block' on every source block in
-the current subtree."
-  (interactive "P")
-  (save-restriction
-    (save-excursion
-      (org-narrow-to-subtree)
-      (org-babel-execute-buffer arg)
-      (widen))))
-
-;;;###autoload
-(defun org-babel-sha1-hash (&optional info)
-  "Generate an sha1 hash based on the value of info."
-  (interactive)
-  (let ((print-level nil)
-       (info (or info (org-babel-get-src-block-info))))
-    (setf (nth 2 info)
-         (sort (copy-sequence (nth 2 info))
-               (lambda (a b) (string< (car a) (car b)))))
-    (let* ((rm (lambda (lst)
-                (dolist (p '("replace" "silent" "append" "prepend"))
-                  (setq lst (remove p lst)))
-                lst))
-          (norm (lambda (arg)
-                  (let ((v (if (and (listp (cdr arg)) (null (cddr arg)))
-                               (copy-sequence (cdr arg))
-                             (cdr arg))))
-                    (when (and v (not (and (sequencep v)
-                                           (not (consp v))
-                                           (= (length v) 0))))
-                      (cond
-                       ((and (listp v) ; lists are sorted
-                             (member (car arg) '(:result-params)))
-                        (sort (funcall rm v) #'string<))
-                       ((and (stringp v) ; strings are sorted
-                             (member (car arg) '(:results :exports)))
-                        (mapconcat #'identity (sort (funcall rm (split-string v))
-                                                    #'string<) " "))
-                       (t v)))))))
-      ((lambda (hash)
-        (when (org-called-interactively-p 'interactive) (message hash)) hash)
-       (let ((it (format "%s-%s"
-                        (mapconcat
-                         #'identity
-                         (delq nil (mapcar (lambda (arg)
-                                             (let ((normalized (funcall norm arg)))
-                                               (when normalized
-                                                 (format "%S" normalized))))
-                                           (nth 2 info))) ":")
-                        (nth 1 info))))
-        (sha1 it))))))
-
-(defun org-babel-current-result-hash ()
-  "Return the current in-buffer hash."
-  (org-babel-where-is-src-block-result)
-  (org-no-properties (match-string 3)))
-
-(defun org-babel-set-current-result-hash (hash)
-  "Set the current in-buffer hash to HASH."
-  (org-babel-where-is-src-block-result)
-  (save-excursion (goto-char (match-beginning 3))
-                 ;; (mapc #'delete-overlay (overlays-at (point)))
-                 (replace-match hash nil nil nil 3)
-                 (org-babel-hide-hash)))
-
-(defun org-babel-hide-hash ()
-  "Hide the hash in the current results line.
-Only the initial `org-babel-hash-show' characters of the hash
-will remain visible."
-  (add-to-invisibility-spec '(org-babel-hide-hash . t))
-  (save-excursion
-    (when (and (re-search-forward org-babel-result-regexp nil t)
-               (match-string 3))
-      (let* ((start (match-beginning 3))
-             (hide-start (+ org-babel-hash-show start))
-             (end (match-end 3))
-             (hash (match-string 3))
-             ov1 ov2)
-        (setq ov1 (make-overlay start hide-start))
-        (setq ov2 (make-overlay hide-start end))
-        (overlay-put ov2 'invisible 'org-babel-hide-hash)
-        (overlay-put ov1 'babel-hash hash)))))
-
-(defun org-babel-hide-all-hashes ()
-  "Hide the hash in the current buffer.
-Only the initial `org-babel-hash-show' characters of each hash
-will remain visible.  This function should be called as part of
-the `org-mode-hook'."
-  (save-excursion
-    (while (re-search-forward org-babel-result-regexp nil t)
-      (goto-char (match-beginning 0))
-      (org-babel-hide-hash)
-      (goto-char (match-end 0)))))
-(add-hook 'org-mode-hook 'org-babel-hide-all-hashes)
-
-(defun org-babel-hash-at-point (&optional point)
-  "Return the value of the hash at POINT.
-The hash is also added as the last element of the kill ring.
-This can be called with C-c C-c."
-  (interactive)
-  (let ((hash (car (delq nil (mapcar
-                             (lambda (ol) (overlay-get ol 'babel-hash))
-                              (overlays-at (or point (point))))))))
-    (when hash (kill-new hash) (message hash))))
-(add-hook 'org-ctrl-c-ctrl-c-hook 'org-babel-hash-at-point)
-
-(defun org-babel-result-hide-spec ()
-  "Hide portions of results lines.
-Add `org-babel-hide-result' as an invisibility spec for hiding
-portions of results lines."
-  (add-to-invisibility-spec '(org-babel-hide-result . t)))
-(add-hook 'org-mode-hook 'org-babel-result-hide-spec)
-
-(defvar org-babel-hide-result-overlays nil
-  "Overlays hiding results.")
-
-(defun org-babel-result-hide-all ()
-  "Fold all results in the current buffer."
-  (interactive)
-  (org-babel-show-result-all)
-  (save-excursion
-    (while (re-search-forward org-babel-result-regexp nil t)
-      (save-excursion (goto-char (match-beginning 0))
-                      (org-babel-hide-result-toggle-maybe)))))
-
-(defun org-babel-show-result-all ()
-  "Unfold all results in the current buffer."
-  (mapc 'delete-overlay org-babel-hide-result-overlays)
-  (setq org-babel-hide-result-overlays nil))
-
-;;;###autoload
-(defun org-babel-hide-result-toggle-maybe ()
-  "Toggle visibility of result at point."
-  (interactive)
-  (let ((case-fold-search t))
-    (if (save-excursion
-          (beginning-of-line 1)
-          (looking-at org-babel-result-regexp))
-        (progn (org-babel-hide-result-toggle)
-               t) ;; to signal that we took action
-      nil))) ;; to signal that we did not
-
-(defun org-babel-hide-result-toggle (&optional force)
-  "Toggle the visibility of the current result."
-  (interactive)
-  (save-excursion
-    (beginning-of-line)
-    (if (re-search-forward org-babel-result-regexp nil t)
-        (let ((start (progn (beginning-of-line 2) (- (point) 1)))
-             (end (progn
-                    (while (looking-at org-babel-multi-line-header-regexp)
-                      (forward-line 1))
-                    (goto-char (- (org-babel-result-end) 1)) (point)))
-             ov)
-          (if (memq t (mapcar (lambda (overlay)
-                                (eq (overlay-get overlay 'invisible)
-                                   'org-babel-hide-result))
-                              (overlays-at start)))
-              (if (or (not force) (eq force 'off))
-                  (mapc (lambda (ov)
-                          (when (member ov org-babel-hide-result-overlays)
-                            (setq org-babel-hide-result-overlays
-                                  (delq ov org-babel-hide-result-overlays)))
-                          (when (eq (overlay-get ov 'invisible)
-                                    'org-babel-hide-result)
-                            (delete-overlay ov)))
-                        (overlays-at start)))
-            (setq ov (make-overlay start end))
-            (overlay-put ov 'invisible 'org-babel-hide-result)
-            ;; make the block accessible to isearch
-            (overlay-put
-             ov 'isearch-open-invisible
-             (lambda (ov)
-               (when (member ov org-babel-hide-result-overlays)
-                 (setq org-babel-hide-result-overlays
-                       (delq ov org-babel-hide-result-overlays)))
-               (when (eq (overlay-get ov 'invisible)
-                         'org-babel-hide-result)
-                 (delete-overlay ov))))
-            (push ov org-babel-hide-result-overlays)))
-      (error "Not looking at a result line"))))
-
-;; org-tab-after-check-for-cycling-hook
-(add-hook 'org-tab-first-hook 'org-babel-hide-result-toggle-maybe)
-;; Remove overlays when changing major mode
-(add-hook 'org-mode-hook
-         (lambda () (org-add-hook 'change-major-mode-hook
-                                  'org-babel-show-result-all 'append 'local)))
-
-(defvar org-file-properties)
-(defun org-babel-params-from-properties (&optional lang)
-  "Retrieve parameters specified as properties.
-Return an association list of any source block params which
-may be specified in the properties of the current outline entry."
-  (save-match-data
-    (let (val sym)
-      (org-babel-parse-multiple-vars
-       (delq nil
-            (mapcar
-             (lambda (header-arg)
-               (and (setq val (org-entry-get (point) header-arg t))
-                    (cons (intern (concat ":" header-arg))
-                          (org-babel-read val))))
-             (mapcar
-              #'symbol-name
-              (mapcar
-               #'car
-               (org-babel-combine-header-arg-lists
-                org-babel-common-header-args-w-values
-                (progn
-                  (setq sym (intern (concat "org-babel-header-args:" lang)))
-                  (and (boundp sym) (eval sym))))))))))))
-
-(defvar org-src-preserve-indentation)
-(defun org-babel-parse-src-block-match ()
-  "Parse the results from a match of the `org-babel-src-block-regexp'."
-  (let* ((block-indentation (length (match-string 1)))
-        (lang (org-no-properties (match-string 2)))
-         (lang-headers (intern (concat "org-babel-default-header-args:" lang)))
-        (switches (match-string 3))
-         (body (org-no-properties
-               (let* ((body (match-string 5))
-                      (sub-length (- (length body) 1)))
-                 (if (and (> sub-length 0)
-                          (string= "\n" (substring body sub-length)))
-                     (substring body 0 sub-length)
-                   (or body "")))))
-        (preserve-indentation (or org-src-preserve-indentation
-                                  (save-match-data
-                                    (string-match "-i\\>" switches)))))
-    (list lang
-          ;; get block body less properties, protective commas, and indentation
-          (with-temp-buffer
-            (save-match-data
-              (insert (org-unescape-code-in-string body))
-             (unless preserve-indentation (org-do-remove-indentation))
-              (buffer-string)))
-         (org-babel-merge-params
-          org-babel-default-header-args
-           (org-babel-params-from-properties lang)
-          (if (boundp lang-headers) (eval lang-headers) nil)
-          (org-babel-parse-header-arguments
-            (org-no-properties (or (match-string 4) ""))))
-         switches
-         block-indentation)))
-
-(defun org-babel-parse-inline-src-block-match ()
-  "Parse the results from a match of the `org-babel-inline-src-block-regexp'."
-  (let* ((lang (org-no-properties (match-string 2)))
-         (lang-headers (intern (concat "org-babel-default-header-args:" lang))))
-    (list lang
-          (org-unescape-code-in-string (org-no-properties (match-string 5)))
-          (org-babel-merge-params
-           org-babel-default-inline-header-args
-           (org-babel-params-from-properties lang)
-           (if (boundp lang-headers) (eval lang-headers) nil)
-           (org-babel-parse-header-arguments
-            (org-no-properties (or (match-string 4) "")))))))
-
-(defun org-babel-balanced-split (string alts)
-  "Split STRING on instances of ALTS.
-ALTS is a cons of two character options where each option may be
-either the numeric code of a single character or a list of
-character alternatives.  For example to split on balanced
-instances of \"[ \t]:\" set ALTS to '((32 9) . 58)."
-  (let* ((matches (lambda (ch spec) (if (listp spec) (member ch spec) (equal spec ch))))
-        (matched (lambda (ch last)
-                   (if (consp alts)
-                       (and (funcall matches ch (cdr alts))
-                            (funcall matches last (car alts)))
-                     (funcall matches ch alts))))
-        (balance 0) (last 0)
-        quote partial lst)
-    (mapc (lambda (ch)  ; split on [], (), "" balanced instances of [ \t]:
-           (setq balance (+ balance
-                            (cond ((or (equal 91 ch) (equal 40 ch)) 1)
-                                  ((or (equal 93 ch) (equal 41 ch)) -1)
-                                  (t 0))))
-           (when (and (equal 34 ch) (not (equal 92 last)))
-             (setq quote (not quote)))
-           (setq partial (cons ch partial))
-           (when (and (= balance 0) (not quote) (funcall matched ch last))
-             (setq lst (cons (apply #'string (nreverse
-                                              (if (consp alts)
-                                                  (cddr partial)
-                                                (cdr partial))))
-                             lst))
-             (setq partial nil))
-           (setq last ch))
-         (string-to-list string))
-    (nreverse (cons (apply #'string (nreverse partial)) lst))))
-
-(defun org-babel-join-splits-near-ch (ch list)
-  "Join splits where \"=\" is on either end of the split."
-  (let ((last= (lambda (str) (= ch (aref str (1- (length str))))))
-       (first= (lambda (str) (= ch (aref str 0)))))
-    (reverse
-     (org-reduce (lambda (acc el)
-                  (let ((head (car acc)))
-                    (if (and head (or (funcall last= head) (funcall first= el)))
-                        (cons (concat head el) (cdr acc))
-                      (cons el acc))))
-                list :initial-value nil))))
-
-(defun org-babel-parse-header-arguments (arg-string)
-  "Parse a string of header arguments returning an alist."
-  (when (> (length arg-string) 0)
-    (org-babel-parse-multiple-vars
-     (delq nil
-          (mapcar
-           (lambda (arg)
-             (if (string-match
-                  "\\([^ \f\t\n\r\v]+\\)[ \f\t\n\r\v]+\\([^ \f\t\n\r\v]+.*\\)"
-                  arg)
-                 (cons (intern (match-string 1 arg))
-                       (org-babel-read (org-babel-chomp (match-string 2 arg))))
-               (cons (intern (org-babel-chomp arg)) nil)))
-           ((lambda (raw)
-              (cons (car raw) (mapcar (lambda (r) (concat ":" r)) (cdr raw))))
-            (org-babel-balanced-split arg-string '((32 9) . 58))))))))
-
-(defun org-babel-parse-multiple-vars (header-arguments)
-  "Expand multiple variable assignments behind a single :var keyword.
-
-This allows expression of multiple variables with one :var as
-shown below.
-
-#+PROPERTY: var foo=1, bar=2"
-  (let (results)
-    (mapc (lambda (pair)
-           (if (eq (car pair) :var)
-               (mapcar (lambda (v) (push (cons :var (org-babel-trim v)) results))
-                       (org-babel-join-splits-near-ch
-                        61 (org-babel-balanced-split (cdr pair) 32)))
-             (push pair results)))
-         header-arguments)
-    (nreverse results)))
-
-(defun org-babel-process-params (params)
-  "Expand variables in PARAMS and add summary parameters."
-  (let* ((processed-vars (mapcar (lambda (el)
-                                  (if (consp (cdr el))
-                                      (cdr el)
-                                    (org-babel-ref-parse (cdr el))))
-                                (org-babel-get-header params :var)))
-        (vars-and-names (if (and (assoc :colname-names params)
-                                 (assoc :rowname-names params))
-                            (list processed-vars)
-                          (org-babel-disassemble-tables
-                           processed-vars
-                           (cdr (assoc :hlines params))
-                           (cdr (assoc :colnames params))
-                           (cdr (assoc :rownames params)))))
-        (raw-result (or (cdr (assoc :results params)) ""))
-        (result-params (append
-                        (split-string (if (stringp raw-result)
-                                          raw-result
-                                        (eval raw-result)))
-                        (cdr (assoc :result-params params)))))
-    (append
-     (mapcar (lambda (var) (cons :var var)) (car vars-and-names))
-     (list
-      (cons :colname-names (or (cdr (assoc :colname-names params))
-                              (cadr  vars-and-names)))
-      (cons :rowname-names (or (cdr (assoc :rowname-names params))
-                              (caddr vars-and-names)))
-      (cons :result-params result-params)
-      (cons :result-type  (cond ((member "output" result-params) 'output)
-                               ((member "value" result-params) 'value)
-                               (t 'value))))
-     (org-babel-get-header params :var 'other))))
-
-;; row and column names
-(defun org-babel-del-hlines (table)
-  "Remove all 'hlines from TABLE."
-  (remove 'hline table))
-
-(defun org-babel-get-colnames (table)
-  "Return the column names of TABLE.
-Return a cons cell, the `car' of which contains the TABLE less
-colnames, and the `cdr' of which contains a list of the column
-names."
-  (if (equal 'hline (nth 1 table))
-      (cons (cddr table) (car table))
-    (cons (cdr table) (car table))))
-
-(defun org-babel-get-rownames (table)
-  "Return the row names of TABLE.
-Return a cons cell, the `car' of which contains the TABLE less
-colnames, and the `cdr' of which contains a list of the column
-names.  Note: this function removes any hlines in TABLE."
-  (let* ((trans (lambda (table) (apply #'mapcar* #'list table)))
-        (width (apply 'max
-                      (mapcar (lambda (el) (if (listp el) (length el) 0)) table)))
-        (table (funcall trans (mapcar (lambda (row)
-                                        (if (not (equal row 'hline))
-                                            row
-                                          (setq row '())
-                                          (dotimes (n width)
-                                            (setq row (cons 'hline row)))
-                                          row))
-                                      table))))
-    (cons (mapcar (lambda (row) (if (equal (car row) 'hline) 'hline row))
-                 (funcall trans (cdr table)))
-         (remove 'hline (car table)))))
-
-(defun org-babel-put-colnames (table colnames)
-  "Add COLNAMES to TABLE if they exist."
-  (if colnames (apply 'list colnames 'hline table) table))
-
-(defun org-babel-put-rownames (table rownames)
-  "Add ROWNAMES to TABLE if they exist."
-  (if rownames
-      (mapcar (lambda (row)
-                (if (listp row)
-                    (cons (or (pop rownames) "") row)
-                  row)) table)
-    table))
-
-(defun org-babel-pick-name (names selector)
-  "Select one out of an alist of row or column names.
-SELECTOR can be either a list of names in which case those names
-will be returned directly, or an index into the list NAMES in
-which case the indexed names will be return."
-  (if (listp selector)
-      selector
-    (when names
-      (if (and selector (symbolp selector) (not (equal t selector)))
-         (cdr (assoc selector names))
-       (if (integerp selector)
-           (nth (- selector 1) names)
-         (cdr (car (last names))))))))
-
-(defun org-babel-disassemble-tables (vars hlines colnames rownames)
-  "Parse tables for further processing.
-Process the variables in VARS according to the HLINES,
-ROWNAMES and COLNAMES header arguments.  Return a list consisting
-of the vars, cnames and rnames."
-  (let (cnames rnames)
-    (list
-     (mapcar
-      (lambda (var)
-        (when (listp (cdr var))
-          (when (and (not (equal colnames "no"))
-                     (or colnames (and (equal (nth 1 (cdr var)) 'hline)
-                                       (not (member 'hline (cddr (cdr var)))))))
-            (let ((both (org-babel-get-colnames (cdr var))))
-              (setq cnames (cons (cons (car var) (cdr both))
-                                 cnames))
-              (setq var (cons (car var) (car both)))))
-          (when (and rownames (not (equal rownames "no")))
-            (let ((both (org-babel-get-rownames (cdr var))))
-              (setq rnames (cons (cons (car var) (cdr both))
-                                 rnames))
-              (setq var (cons (car var) (car both)))))
-          (when (and hlines (not (equal hlines "yes")))
-            (setq var (cons (car var) (org-babel-del-hlines (cdr var))))))
-        var)
-      vars)
-     (reverse cnames) (reverse rnames))))
-
-(defun org-babel-reassemble-table (table colnames rownames)
-  "Add column and row names to a table.
-Given a TABLE and set of COLNAMES and ROWNAMES add the names
-to the table for reinsertion to org-mode."
-  (if (listp table)
-      ((lambda (table)
-         (if (and colnames (listp (car table)) (= (length (car table))
-                                                  (length colnames)))
-             (org-babel-put-colnames table colnames) table))
-       (if (and rownames (= (length table) (length rownames)))
-           (org-babel-put-rownames table rownames) table))
-    table))
-
-(defun org-babel-where-is-src-block-head ()
-  "Find where the current source block begins.
-Return the point at the beginning of the current source
-block.  Specifically at the beginning of the #+BEGIN_SRC line.
-If the point is not on a source block then return nil."
-  (let ((initial (point)) (case-fold-search t) top bottom)
-    (or
-     (save-excursion ;; on a source name line or a #+header line
-       (beginning-of-line 1)
-       (and (or (looking-at org-babel-src-name-regexp)
-               (looking-at org-babel-multi-line-header-regexp))
-           (progn
-             (while (and (forward-line 1)
-                         (or (looking-at org-babel-src-name-regexp)
-                             (looking-at org-babel-multi-line-header-regexp))))
-             (looking-at org-babel-src-block-regexp))
-            (point)))
-     (save-excursion ;; on a #+begin_src line
-       (beginning-of-line 1)
-       (and (looking-at org-babel-src-block-regexp)
-            (point)))
-     (save-excursion ;; inside a src block
-       (and
-        (re-search-backward "^[ \t]*#\\+begin_src" nil t) (setq top (point))
-        (re-search-forward "^[ \t]*#\\+end_src" nil t) (setq bottom (point))
-        (< top initial) (< initial bottom)
-        (progn (goto-char top) (beginning-of-line 1)
-              (looking-at org-babel-src-block-regexp))
-        (point))))))
-
-;;;###autoload
-(defun org-babel-goto-src-block-head ()
-  "Go to the beginning of the current code block."
-  (interactive)
-  ((lambda (head)
-     (if head (goto-char head) (error "Not currently in a code block")))
-   (org-babel-where-is-src-block-head)))
-
-;;;###autoload
-(defun org-babel-goto-named-src-block (name)
-  "Go to a named source-code block."
-  (interactive
-   (let ((completion-ignore-case t)
-        (case-fold-search t)
-        (under-point (thing-at-point 'line)))
-     (list (org-icompleting-read
-           "source-block name: " (org-babel-src-block-names) nil t
-           (cond
-            ;; noweb
-            ((string-match (org-babel-noweb-wrap) under-point)
-             (let ((block-name (match-string 1 under-point)))
-               (string-match "[^(]*" block-name)
-               (match-string 0 block-name)))
-            ;; #+call:
-            ((string-match org-babel-lob-one-liner-regexp under-point)
-             (let ((source-info (car (org-babel-lob-get-info))))
-               (if (string-match "^\\([^\\[]+?\\)\\(\\[.*\\]\\)?(" source-info)
-                   (let ((source-name (match-string 1 source-info)))
-                     source-name))))
-            ;; #+results:
-            ((string-match (concat "#\\+" org-babel-results-keyword
-                                   "\\:\s+\\([^\\(]*\\)") under-point)
-             (match-string 1 under-point))
-            ;; symbol-at-point
-            ((and (thing-at-point 'symbol))
-             (org-babel-find-named-block (thing-at-point 'symbol))
-             (thing-at-point 'symbol))
-            (""))))))
-  (let ((point (org-babel-find-named-block name)))
-    (if point
-        ;; taken from `org-open-at-point'
-        (progn (org-mark-ring-push) (goto-char point) (org-show-context))
-      (message "source-code block '%s' not found in this buffer" name))))
-
-(defun org-babel-find-named-block (name)
-  "Find a named source-code block.
-Return the location of the source block identified by source
-NAME, or nil if no such block exists.  Set match data according to
-org-babel-named-src-block-regexp."
-  (save-excursion
-    (let ((case-fold-search t)
-         (regexp (org-babel-named-src-block-regexp-for-name name)) msg)
-      (goto-char (point-min))
-      (when (or (re-search-forward regexp nil t)
-               (re-search-backward regexp nil t))
-        (match-beginning 0)))))
-
-(defun org-babel-src-block-names (&optional file)
-  "Returns the names of source blocks in FILE or the current buffer."
-  (save-excursion
-    (when file (find-file file)) (goto-char (point-min))
-    (let ((case-fold-search t) names)
-      (while (re-search-forward org-babel-src-name-w-name-regexp nil t)
-       (setq names (cons (match-string 3) names)))
-      names)))
-
-;;;###autoload
-(defun org-babel-goto-named-result (name)
-  "Go to a named result."
-  (interactive
-   (let ((completion-ignore-case t))
-     (list (org-icompleting-read "source-block name: "
-                                (org-babel-result-names) nil t))))
-  (let ((point (org-babel-find-named-result name)))
-    (if point
-        ;; taken from `org-open-at-point'
-        (progn (goto-char point) (org-show-context))
-      (message "result '%s' not found in this buffer" name))))
-
-(defun org-babel-find-named-result (name &optional point)
-  "Find a named result.
-Return the location of the result named NAME in the current
-buffer or nil if no such result exists."
-  (save-excursion
-    (let ((case-fold-search t))
-      (goto-char (or point (point-min)))
-      (catch 'is-a-code-block
-       (when (re-search-forward
-              (concat org-babel-result-regexp
-                      "[ \t]" (regexp-quote name) "[ \t]*[\n\f\v\r]") nil t)
-         (when (and (string= "name" (downcase (match-string 1)))
-                    (or (beginning-of-line 1)
-                        (looking-at org-babel-src-block-regexp)
-                        (looking-at org-babel-multi-line-header-regexp)))
-           (throw 'is-a-code-block (org-babel-find-named-result name (point))))
-         (beginning-of-line 0) (point))))))
-
-(defun org-babel-result-names (&optional file)
-  "Returns the names of results in FILE or the current buffer."
-  (save-excursion
-    (when file (find-file file)) (goto-char (point-min))
-    (let ((case-fold-search t) names)
-      (while (re-search-forward org-babel-result-w-name-regexp nil t)
-       (setq names (cons (match-string 4) names)))
-      names)))
-
-;;;###autoload
-(defun org-babel-next-src-block (&optional arg)
-  "Jump to the next source block.
-With optional prefix argument ARG, jump forward ARG many source blocks."
-  (interactive "P")
-  (when (looking-at org-babel-src-block-regexp) (forward-char 1))
-  (condition-case nil
-      (re-search-forward org-babel-src-block-regexp nil nil (or arg 1))
-    (error (error "No further code blocks")))
-  (goto-char (match-beginning 0)) (org-show-context))
-
-;;;###autoload
-(defun org-babel-previous-src-block (&optional arg)
-  "Jump to the previous source block.
-With optional prefix argument ARG, jump backward ARG many source blocks."
-  (interactive "P")
-  (condition-case nil
-      (re-search-backward org-babel-src-block-regexp nil nil (or arg 1))
-    (error (error "No previous code blocks")))
-  (goto-char (match-beginning 0)) (org-show-context))
-
-(defvar org-babel-load-languages)
-
-;;;###autoload
-(defun org-babel-mark-block ()
-  "Mark current src block."
-  (interactive)
-  ((lambda (head)
-     (when head
-       (save-excursion
-        (goto-char head)
-        (looking-at org-babel-src-block-regexp))
-       (push-mark (match-end 5) nil t)
-       (goto-char (match-beginning 5))))
-   (org-babel-where-is-src-block-head)))
-
-(defun org-babel-demarcate-block (&optional arg)
-  "Wrap or split the code in the region or on the point.
-When called from inside of a code block the current block is
-split.  When called from outside of a code block a new code block
-is created.  In both cases if the region is demarcated and if the
-region is not active then the point is demarcated."
-  (interactive "P")
-  (let ((info (org-babel-get-src-block-info 'light))
-       (headers (progn (org-babel-where-is-src-block-head)
-                       (match-string 4)))
-       (stars (concat (make-string (or (org-current-level) 1) ?*) " ")))
-    (if info
-        (mapc
-         (lambda (place)
-           (save-excursion
-             (goto-char place)
-             (let ((lang (nth 0 info))
-                   (indent (make-string (nth 5 info) ? )))
-              (when (string-match "^[[:space:]]*$"
-                                  (buffer-substring (point-at-bol)
-                                                    (point-at-eol)))
-                (delete-region (point-at-bol) (point-at-eol)))
-               (insert (concat
-                       (if (looking-at "^") "" "\n")
-                       indent "#+end_src\n"
-                       (if arg stars indent) "\n"
-                       indent "#+begin_src " lang
-                       (if (> (length headers) 1)
-                           (concat " " headers) headers)
-                       (if (looking-at "[\n\r]")
-                           ""
-                         (concat "\n" (make-string (current-column) ? )))))))
-          (move-end-of-line 2))
-         (sort (if (org-region-active-p) (list (mark) (point)) (list (point))) #'>))
-      (let ((start (point))
-           (lang (org-icompleting-read "Lang: "
-                                       (mapcar (lambda (el) (symbol-name (car el)))
-                                               org-babel-load-languages)))
-           (body (delete-and-extract-region
-                  (if (org-region-active-p) (mark) (point)) (point))))
-       (insert (concat (if (looking-at "^") "" "\n")
-                       (if arg (concat stars "\n") "")
-                       "#+begin_src " lang "\n"
-                       body
-                       (if (or (= (length body) 0)
-                               (string-match "[\r\n]$" body)) "" "\n")
-                       "#+end_src\n"))
-       (goto-char start) (move-end-of-line 1)))))
-
-(defvar org-babel-lob-one-liner-regexp)
-(defun org-babel-where-is-src-block-result (&optional insert info hash indent)
-  "Find where the current source block results begin.
-Return the point at the beginning of the result of the current
-source block.  Specifically at the beginning of the results line.
-If no result exists for this block then create a results line
-following the source block."
-  (save-excursion
-    (let* ((case-fold-search t)
-          (on-lob-line (save-excursion
-                         (beginning-of-line 1)
-                         (looking-at org-babel-lob-one-liner-regexp)))
-          (inlinep (when (org-babel-get-inline-src-block-matches)
-                     (match-end 0)))
-          (name (if on-lob-line
-                    (mapconcat #'identity (butlast (org-babel-lob-get-info)) "")
-                  (nth 4 (or info (org-babel-get-src-block-info 'light)))))
-          (head (unless on-lob-line (org-babel-where-is-src-block-head)))
-          found beg end)
-      (when head (goto-char head))
-      (setq
-       found ;; was there a result (before we potentially insert one)
-       (or
-       inlinep
-       (and
-        ;; named results:
-        ;; - return t if it is found, else return nil
-        ;; - if it does not need to be rebuilt, then don't set end
-        ;; - if it does need to be rebuilt then do set end
-        name (setq beg (org-babel-find-named-result name))
-        (prog1 beg
-          (when (and hash (not (string= hash (match-string 3))))
-            (goto-char beg) (setq end beg) ;; beginning of result
-            (forward-line 1)
-            (delete-region end (org-babel-result-end)) nil)))
-       (and
-        ;; unnamed results:
-        ;; - return t if it is found, else return nil
-        ;; - if it is found, and the hash doesn't match, delete and set end
-        (or on-lob-line (re-search-forward "^[ \t]*#\\+end_src" nil t))
-        (progn (end-of-line 1)
-               (if (eobp) (insert "\n") (forward-char 1))
-               (setq end (point))
-               (or (and (not name)
-                        (progn ;; unnamed results line already exists
-                          (re-search-forward "[^ \f\t\n\r\v]" nil t)
-                          (beginning-of-line 1)
-                          (looking-at
-                           (concat org-babel-result-regexp "\n")))
-                        (prog1 (point)
-                          ;; must remove and rebuild if hash!=old-hash
-                          (if (and hash (not (string= hash (match-string 3))))
-                              (prog1 nil
-                                (forward-line 1)
-                                (delete-region
-                                 end (org-babel-result-end)))
-                            (setq end nil)))))))))
-      (if (and insert end)
-         (progn
-           (goto-char end)
-           (unless beg
-             (if (looking-at "[\n\r]") (forward-char 1) (insert "\n")))
-           (insert (concat
-                    (if indent
-                        (mapconcat
-                         (lambda (el) " ")
-                         (org-number-sequence 1 indent) "")
-                      "")
-                    "#+" org-babel-results-keyword
-                    (when hash (concat "["hash"]"))
-                    ":"
-                    (when name (concat " " name)) "\n"))
-           (unless beg (insert "\n") (backward-char))
-           (beginning-of-line 0)
-           (if hash (org-babel-hide-hash))
-           (point))
-       found))))
-
-(defvar org-block-regexp)
-(defun org-babel-read-result ()
-  "Read the result at `point' into emacs-lisp."
-  (let ((case-fold-search t) result-string)
-    (cond
-     ((org-at-table-p) (org-babel-read-table))
-     ((org-at-item-p) (org-babel-read-list))
-     ((looking-at org-bracket-link-regexp) (org-babel-read-link))
-     ((looking-at org-block-regexp) (org-babel-trim (match-string 4)))
-     ((looking-at "^[ \t]*: ")
-      (setq result-string
-           (org-babel-trim
-            (mapconcat (lambda (line)
-                          (if (and (> (length line) 1)
-                                   (string-match "^[ \t]*: \\(.+\\)" line))
-                              (match-string 1 line)
-                            line))
-                       (split-string
-                        (buffer-substring
-                          (point) (org-babel-result-end)) "[\r\n]+")
-                       "\n")))
-      (or (org-babel-number-p result-string) result-string))
-     ((looking-at org-babel-result-regexp)
-      (save-excursion (forward-line 1) (org-babel-read-result))))))
-
-(defun org-babel-read-table ()
-  "Read the table at `point' into emacs-lisp."
-  (mapcar (lambda (row)
-            (if (and (symbolp row) (equal row 'hline)) row
-              (mapcar (lambda (el) (org-babel-read el 'inhibit-lisp-eval)) row)))
-          (org-table-to-lisp)))
-
-(defun org-babel-read-list ()
-  "Read the list at `point' into emacs-lisp."
-  (mapcar (lambda (el) (org-babel-read el 'inhibit-lisp-eval))
-         (mapcar #'cadr (cdr (org-list-parse-list)))))
-
-(defvar org-link-types-re)
-(defun org-babel-read-link ()
-  "Read the link at `point' into emacs-lisp.
-If the path of the link is a file path it is expanded using
-`expand-file-name'."
-  (let* ((case-fold-search t)
-         (raw (and (looking-at org-bracket-link-regexp)
-                   (org-no-properties (match-string 1))))
-         (type (and (string-match org-link-types-re raw)
-                    (match-string 1 raw))))
-    (cond
-     ((not type) (expand-file-name raw))
-     ((string= type "file")
-      (and (string-match "file\\(.*\\):\\(.+\\)" raw)
-           (expand-file-name (match-string 2 raw))))
-     (t raw))))
-
-(defun org-babel-format-result (result &optional sep)
-  "Format RESULT for writing to file."
-  (let ((echo-res (lambda (r) (if (stringp r) r (format "%S" r)))))
-    (if (listp result)
-       ;; table result
-       (orgtbl-to-generic
-        result (list :sep (or sep "\t") :fmt echo-res))
-      ;; scalar result
-      (funcall echo-res result))))
-
-(defun org-babel-insert-result
-  (result &optional result-params info hash indent lang)
-  "Insert RESULT into the current buffer.
-By default RESULT is inserted after the end of the
-current source block.  With optional argument RESULT-PARAMS
-controls insertion of results in the org-mode file.
-RESULT-PARAMS can take the following values:
-
-replace - (default option) insert results after the source block
-          replacing any previously inserted results
-
-silent -- no results are inserted
-
-file ---- the results are interpreted as a file path, and are
-          inserted into the buffer using the Org-mode file syntax
-
-list ---- the results are interpreted as an Org-mode list.
-
-raw ----- results are added directly to the Org-mode file.  This
-          is a good option if you code block will output org-mode
-          formatted text.
-
-drawer -- results are added directly to the Org-mode file as with
-          \"raw\", but are wrapped in a RESULTS drawer, allowing
-          them to later be replaced or removed automatically.
-
-org ----- results are added inside of a \"#+BEGIN_SRC org\" block.
-          They are not comma-escaped when inserted, but Org syntax
-          here will be discarded when exporting the file.
-
-html ---- results are added inside of a #+BEGIN_HTML block.  This
-          is a good option if you code block will output html
-          formatted text.
-
-latex --- results are added inside of a #+BEGIN_LATEX block.
-          This is a good option if you code block will output
-          latex formatted text.
-
-code ---- the results are extracted in the syntax of the source
-          code of the language being evaluated and are added
-          inside of a #+BEGIN_SRC block with the source-code
-          language set appropriately.  Note this relies on the
-          optional LANG argument."
-  (if (stringp result)
-      (progn
-        (setq result (org-no-properties result))
-        (when (member "file" result-params)
-         (setq result (org-babel-result-to-file
-                       result (when (assoc :file-desc (nth 2 info))
-                                (or (cdr (assoc :file-desc (nth 2 info)))
-                                    result))))))
-    (unless (listp result) (setq result (format "%S" result))))
-  (if (and result-params (member "silent" result-params))
-      (progn
-       (message (replace-regexp-in-string "%" "%%" (format "%S" result)))
-       result)
-    (save-excursion
-      (let* ((inlinep
-             (save-excursion
-               (when (or (org-babel-get-inline-src-block-matches)
-                         (org-babel-get-lob-one-liner-matches))
-                 (goto-char (match-end 0))
-                 (insert (if (listp result) "\n" " "))
-                 (point))))
-            (existing-result (unless inlinep
-                               (org-babel-where-is-src-block-result
-                                t info hash indent)))
-            (results-switches
-             (cdr (assoc :results_switches (nth 2 info))))
-            beg end)
-       (when (and (stringp result)  ; ensure results end in a newline
-                  (not inlinep)
-                  (> (length result) 0)
-                  (not (or (string-equal (substring result -1) "\n")
-                           (string-equal (substring result -1) "\r"))))
-         (setq result (concat result "\n")))
-       (if (not existing-result)
-           (setq beg (or inlinep (point)))
-         (goto-char existing-result)
-         (save-excursion
-           (re-search-forward "#" nil t)
-           (setq indent (- (current-column) 1)))
-         (forward-line 1)
-         (setq beg (point))
-         (cond
-          ((member "replace" result-params)
-           (delete-region (point) (org-babel-result-end)))
-          ((member "append" result-params)
-           (goto-char (org-babel-result-end)) (setq beg (point-marker)))
-          ((member "prepend" result-params)))) ; already there
-       (setq results-switches
-             (if results-switches (concat " " results-switches) ""))
-       (let ((wrap (lambda (start finish)
-                     (goto-char end) (insert (concat finish "\n"))
-                     (goto-char beg) (insert (concat start "\n"))
-                     (org-escape-code-in-region (point) end)
-                     (goto-char end) (goto-char (point-at-eol))
-                     (setq end (point-marker))))
-             (proper-list-p (lambda (it) (and (listp it) (null (cdr (last it)))))))
-         ;; insert results based on type
-         (cond
-          ;; do nothing for an empty result
-          ((null result))
-          ;; insert a list if preferred
-          ((member "list" result-params)
-           (insert
-            (org-babel-trim
-             (org-list-to-generic
-              (cons 'unordered
-                    (mapcar
-                     (lambda (el) (list nil (if (stringp el) el (format "%S" el))))
-                     (if (listp result) result (list result))))
-              '(:splicep nil :istart "- " :iend "\n")))
-            "\n"))
-          ;; assume the result is a table if it's not a string
-          ((funcall proper-list-p result)
-           (goto-char beg)
-           (insert (concat (orgtbl-to-orgtbl
-                            (if (or (eq 'hline (car result))
-                                    (and (listp (car result))
-                                         (listp (cdr (car result)))))
-                                result (list result))
-                            '(:fmt (lambda (cell) (format "%s" cell)))) "\n"))
-           (goto-char beg) (when (org-at-table-p) (org-table-align)))
-          ((and (listp result) (not (funcall proper-list-p result)))
-           (insert (format "%s\n" result)))
-          ((member "file" result-params)
-           (when inlinep (goto-char inlinep))
-           (insert result))
-          (t (goto-char beg) (insert result)))
-         (when (funcall proper-list-p result) (goto-char (org-table-end)))
-         (setq end (point-marker))
-         ;; possibly wrap result
-         (cond
-          ((assoc :wrap (nth 2 info))
-           (let ((name (or (cdr (assoc :wrap (nth 2 info))) "RESULTS")))
-             (funcall wrap (concat "#+BEGIN_" name) (concat "#+END_" name))))
-          ((member "html" result-params)
-           (funcall wrap "#+BEGIN_HTML" "#+END_HTML"))
-          ((member "latex" result-params)
-           (funcall wrap "#+BEGIN_LaTeX" "#+END_LaTeX"))
-          ((member "org" result-params)
-           (funcall wrap "#+BEGIN_SRC org" "#+END_SRC"))
-          ((member "code" result-params)
-           (funcall wrap (format "#+BEGIN_SRC %s%s" (or lang "none") results-switches)
-                    "#+END_SRC"))
-          ((member "raw" result-params)
-           (goto-char beg) (if (org-at-table-p) (org-cycle)))
-          ((or (member "drawer" result-params)
-               ;; Stay backward compatible with <7.9.2
-               (member "wrap" result-params))
-           (funcall wrap ":RESULTS:" ":END:"))
-          ((and (not (funcall proper-list-p result))
-                (not (member "file" result-params)))
-           (org-babel-examplize-region beg end results-switches)
-           (setq end (point)))))
-       ;; possibly indent the results to match the #+results line
-       (when (and (not inlinep) (numberp indent) indent (> indent 0)
-                  ;; in this case `table-align' does the work for us
-                  (not (and (listp result)
-                            (member "append" result-params))))
-         (indent-rigidly beg end indent))))
-    (if (null result)
-       (if (member "value" result-params)
-           (message "Code block returned no value.")
-         (message "Code block produced no output."))
-      (message "Code block evaluation complete."))))
-
-(defun org-babel-remove-result (&optional info)
-  "Remove the result of the current source block."
-  (interactive)
-  (let ((location (org-babel-where-is-src-block-result nil info)) start)
-    (when location
-      (setq start (- location 1))
-      (save-excursion
-        (goto-char location) (forward-line 1)
-        (delete-region start (org-babel-result-end))))))
-
-(defun org-babel-result-end ()
-  "Return the point at the end of the current set of results."
-  (save-excursion
-    (cond
-     ((org-at-table-p) (progn (goto-char (org-table-end)) (point)))
-     ((org-at-item-p) (let* ((struct (org-list-struct))
-                            (prvs (org-list-prevs-alist struct)))
-                       (org-list-get-list-end (point-at-bol) struct prvs)))
-     ((let ((case-fold-search t)) (looking-at "^\\([ \t]*\\):results:"))
-      (progn (re-search-forward (concat "^" (match-string 1) ":END:"))
-            (forward-char 1) (point)))
-     (t
-      (let ((case-fold-search t))
-       (if (looking-at (concat "[ \t]*#\\+begin_\\([^ \t\n\r]+\\)"))
-           (progn (re-search-forward (concat "[ \t]*#\\+end_" (match-string 1))
-                                     nil t)
-                  (forward-char 1))
-         (while (looking-at "[ \t]*\\(: \\|\\[\\[\\)")
-           (forward-line 1))))
-      (point)))))
-
-(defun org-babel-result-to-file (result &optional description)
-  "Convert RESULT into an `org-mode' link with optional DESCRIPTION.
-If the `default-directory' is different from the containing
-file's directory then expand relative links."
-  (when (stringp result)
-    (format "[[file:%s]%s]"
-           (if (and default-directory
-                    buffer-file-name
-                    (not (string= (expand-file-name default-directory)
-                                  (expand-file-name
-                                   (file-name-directory buffer-file-name)))))
-               (expand-file-name result default-directory)
-             result)
-           (if description (concat "[" description "]") ""))))
-
-(defvar org-babel-capitalize-examplize-region-markers nil
-  "Make true to capitalize begin/end example markers inserted by code blocks.")
-
-(defun org-babel-examplize-region (beg end &optional results-switches)
-  "Comment out region using the inline '==' or ': ' org example quote."
-  (interactive "*r")
-  (let ((chars-between (lambda (b e)
-                        (not (string-match "^[\\s]*$" (buffer-substring b e)))))
-       (maybe-cap (lambda (str) (if org-babel-capitalize-examplize-region-markers
-                                    (upcase str) str))))
-    (if (or (funcall chars-between (save-excursion (goto-char beg) (point-at-bol)) beg)
-           (funcall chars-between end (save-excursion (goto-char end) (point-at-eol))))
-       (save-excursion
-         (goto-char beg)
-         (insert (format "=%s=" (prog1 (buffer-substring beg end)
-                                  (delete-region beg end)))))
-      (let ((size (count-lines beg end)))
-       (save-excursion
-         (cond ((= size 0))          ; do nothing for an empty result
-               ((< size org-babel-min-lines-for-block-output)
-                (goto-char beg)
-                (dotimes (n size)
-                  (beginning-of-line 1) (insert ": ") (forward-line 1)))
-               (t
-                (goto-char beg)
-                (insert (if results-switches
-                            (format "%s%s\n"
-                                    (funcall maybe-cap "#+begin_example")
-                                    results-switches)
-                          (funcall maybe-cap "#+begin_example\n")))
-                (if (markerp end) (goto-char end) (forward-char (- end beg)))
-                (insert (funcall maybe-cap "#+end_example\n")))))))))
-
-(defun org-babel-update-block-body (new-body)
-  "Update the body of the current code block to NEW-BODY."
-  (if (not (org-babel-where-is-src-block-head))
-      (error "Not in a source block")
-    (save-match-data
-      (replace-match (concat (org-babel-trim new-body) "\n") nil t nil 5))
-    (indent-rigidly (match-beginning 5) (match-end 5) 2)))
-
-(defun org-babel-merge-params (&rest plists)
-  "Combine all parameter association lists in PLISTS.
-Later elements of PLISTS override the values of previous elements.
-This takes into account some special considerations for certain
-parameters when merging lists."
-  (let* ((results-exclusive-groups
-         (mapcar (lambda (group) (mapcar #'symbol-name group))
-                 (cdr (assoc 'results org-babel-common-header-args-w-values))))
-        (exports-exclusive-groups
-         (mapcar (lambda (group) (mapcar #'symbol-name group))
-                 (cdr (assoc 'exports org-babel-common-header-args-w-values))))
-        (variable-index 0)
-        (e-merge (lambda (exclusive-groups &rest result-params)
-                   ;; maintain exclusivity of mutually exclusive parameters
-                   (let (output)
-                     (mapc (lambda (new-params)
-                             (mapc (lambda (new-param)
-                                     (mapc (lambda (exclusive-group)
-                                             (when (member new-param exclusive-group)
-                                               (mapcar (lambda (excluded-param)
-                                                         (setq output
-                                                               (delete
-                                                                excluded-param
-                                                                output)))
-                                                       exclusive-group)))
-                                           exclusive-groups)
-                                     (setq output (org-uniquify
-                                                   (cons new-param output))))
-                                   new-params))
-                           result-params)
-                     output)))
-        params results exports tangle noweb cache vars shebang comments padline)
-
-    (mapc
-     (lambda (plist)
-       (mapc
-       (lambda (pair)
-         (case (car pair)
-           (:var
-            (let ((name (if (listp (cdr pair))
-                            (cadr pair)
-                          (and (string-match "^\\([^= \f\t\n\r\v]+\\)[ \t]*="
-                                             (cdr pair))
-                               (intern (match-string 1 (cdr pair)))))))
-              (if name
-                  (setq vars
-                        (append
-                         (if (member name (mapcar #'car vars))
-                             (delq nil
-                                   (mapcar
-                                    (lambda (p)
-                                      (unless (equal (car p) name) p))
-                                    vars))
-                           vars)
-                         (list (cons name pair))))
-                ;; if no name is given and we already have named variables
-                ;; then assign to named variables in order
-                (if (and vars (nth variable-index vars))
-                    (prog1 (setf (cddr (nth variable-index vars))
-                                 (concat (symbol-name
-                                          (car (nth variable-index vars)))
-                                         "=" (cdr pair)))
-                      (incf variable-index))
-                  (error "Variable \"%s\" must be assigned a default value"
-                         (cdr pair))))))
-           (:results
-            (setq results (funcall e-merge results-exclusive-groups
-                                   results
-                                   (split-string
-                                    (let ((r (cdr pair)))
-                                      (if (stringp r) r (eval r)))))))
-           (:file
-            (when (cdr pair)
-              (setq results (funcall e-merge results-exclusive-groups
-                                     results '("file")))
-              (unless (or (member "both" exports)
-                          (member "none" exports)
-                          (member "code" exports))
-                (setq exports (funcall e-merge exports-exclusive-groups
-                                       exports '("results"))))
-              (setq params (cons pair (assq-delete-all (car pair) params)))))
-           (:exports
-            (setq exports (funcall e-merge exports-exclusive-groups
-                                   exports (split-string (cdr pair)))))
-           (:tangle ;; take the latest -- always overwrite
-            (setq tangle (or (list (cdr pair)) tangle)))
-           (:noweb
-            (setq noweb (funcall e-merge
-                                 '(("yes" "no" "tangle" "no-export"
-                                    "strip-export" "eval"))
-                                 noweb
-                                 (split-string (or (cdr pair) "")))))
-           (:cache
-            (setq cache (funcall e-merge '(("yes" "no")) cache
-                                 (split-string (or (cdr pair) "")))))
-           (:padline
-            (setq padline (funcall e-merge '(("yes" "no")) padline
-                                   (split-string (or (cdr pair) "")))))
-           (:shebang ;; take the latest -- always overwrite
-            (setq shebang (or (list (cdr pair)) shebang)))
-           (:comments
-            (setq comments (funcall e-merge '(("yes" "no")) comments
-                                    (split-string (or (cdr pair) "")))))
-           (t ;; replace: this covers e.g. :session
-            (setq params (cons pair (assq-delete-all (car pair) params))))))
-       plist))
-     plists)
-    (setq vars (reverse vars))
-    (while vars (setq params (cons (cons :var (cddr (pop vars))) params)))
-    (mapc
-     (lambda (hd)
-       (let ((key (intern (concat ":" (symbol-name hd))))
-            (val (eval hd)))
-        (setf params (cons (cons key (mapconcat 'identity val " ")) params))))
-     '(results exports tangle noweb padline cache shebang comments))
-    params))
-
-(defvar *org-babel-use-quick-and-dirty-noweb-expansion* nil
-  "Set to true to use regular expressions to expand noweb references.
-This results in much faster noweb reference expansion but does
-not properly allow code blocks to inherit the \":noweb-ref\"
-header argument from buffer or subtree wide properties.")
-
-(defun org-babel-noweb-p (params context)
-  "Check if PARAMS require expansion in CONTEXT.
-CONTEXT may be one of :tangle, :export or :eval."
-  (let* (intersect
-        (intersect (lambda (as bs)
-                     (when as
-                       (if (member (car as) bs)
-                           (car as)
-                         (funcall intersect (cdr as) bs))))))
-    (funcall intersect (case context
-                        (:tangle '("yes" "tangle" "no-export" "strip-export"))
-                        (:eval   '("yes" "no-export" "strip-export" "eval"))
-                        (:export '("yes")))
-            (split-string (or (cdr (assoc :noweb params)) "")))))
-
-(defun org-babel-expand-noweb-references (&optional info parent-buffer)
-  "Expand Noweb references in the body of the current source code block.
-
-For example the following reference would be replaced with the
-body of the source-code block named 'example-block'.
-
-<<example-block>>
-
-Note that any text preceding the <<foo>> construct on a line will
-be interposed between the lines of the replacement text.  So for
-example if <<foo>> is placed behind a comment, then the entire
-replacement text will also be commented.
-
-This function must be called from inside of the buffer containing
-the source-code block which holds BODY.
-
-In addition the following syntax can be used to insert the
-results of evaluating the source-code block named 'example-block'.
-
-<<example-block()>>
-
-Any optional arguments can be passed to example-block by placing
-the arguments inside the parenthesis following the convention
-defined by `org-babel-lob'.  For example
-
-<<example-block(a=9)>>
-
-would set the value of argument \"a\" equal to \"9\".  Note that
-these arguments are not evaluated in the current source-code
-block but are passed literally to the \"example-block\"."
-  (let* ((parent-buffer (or parent-buffer (current-buffer)))
-         (info (or info (org-babel-get-src-block-info)))
-         (lang (nth 0 info))
-         (body (nth 1 info))
-        (ob-nww-start org-babel-noweb-wrap-start)
-        (ob-nww-end org-babel-noweb-wrap-end)
-        (comment (string= "noweb" (cdr (assoc :comments (nth 2 info)))))
-        (rx-prefix (concat "\\(" org-babel-src-name-regexp "\\|"
-                           ":noweb-ref[ \t]+" "\\)"))
-         (new-body "")
-        (nb-add (lambda (text) (setq new-body (concat new-body text))))
-        (c-wrap (lambda (text)
-                  (with-temp-buffer
-                    (funcall (intern (concat lang "-mode")))
-                    (comment-region (point) (progn (insert text) (point)))
-                    (org-babel-trim (buffer-string)))))
-        index source-name evaluate prefix blocks-in-buffer)
-    (with-temp-buffer
-      (org-set-local 'org-babel-noweb-wrap-start ob-nww-start)
-      (org-set-local 'org-babel-noweb-wrap-end ob-nww-end)
-      (insert body) (goto-char (point-min))
-      (setq index (point))
-      (while (and (re-search-forward (org-babel-noweb-wrap) nil t))
-       (save-match-data (setf source-name (match-string 1)))
-       (save-match-data (setq evaluate (string-match "\(.*\)" source-name)))
-       (save-match-data
-         (setq prefix
-               (buffer-substring (match-beginning 0)
-                                 (save-excursion
-                                   (beginning-of-line 1) (point)))))
-       ;; add interval to new-body (removing noweb reference)
-       (goto-char (match-beginning 0))
-       (funcall nb-add (buffer-substring index (point)))
-       (goto-char (match-end 0))
-       (setq index (point))
-       (funcall nb-add
-                (with-current-buffer parent-buffer
-                  (save-restriction
-                    (widen)
-                    (mapconcat ;; interpose PREFIX between every line
-                     #'identity
-                     (split-string
-                      (if evaluate
-                          (let ((raw (org-babel-ref-resolve source-name)))
-                            (if (stringp raw) raw (format "%S" raw)))
-                        (or
-                         ;; retrieve from the library of babel
-                         (nth 2 (assoc (intern source-name)
-                                       org-babel-library-of-babel))
-                         ;; return the contents of headlines literally
-                         (save-excursion
-                           (when (org-babel-ref-goto-headline-id source-name)
-                             (org-babel-ref-headline-body)))
-                         ;; find the expansion of reference in this buffer
-                         (let ((rx (concat rx-prefix source-name "[ \t\n]"))
-                               expansion)
-                           (save-excursion
-                             (goto-char (point-min))
-                             (if *org-babel-use-quick-and-dirty-noweb-expansion*
-                                 (while (re-search-forward rx nil t)
-                                   (let* ((i (org-babel-get-src-block-info 'light))
-                                          (body (org-babel-expand-noweb-references i))
-                                          (sep (or (cdr (assoc :noweb-sep (nth 2 i)))
-                                                   "\n"))
-                                          (full (if comment
-                                                    ((lambda (cs)
-                                                       (concat (funcall c-wrap (car cs)) "\n"
-                                                               body "\n"
-                                                               (funcall c-wrap (cadr cs))))
-                                                     (org-babel-tangle-comment-links i))
-                                                  body)))
-                                     (setq expansion (cons sep (cons full expansion)))))
-                               (org-babel-map-src-blocks nil
-                                 (let ((i (org-babel-get-src-block-info 'light)))
-                                   (when (equal (or (cdr (assoc :noweb-ref (nth 2 i)))
-                                                    (nth 4 i))
-                                                source-name)
-                                     (let* ((body (org-babel-expand-noweb-references i))
-                                            (sep (or (cdr (assoc :noweb-sep (nth 2 i)))
-                                                     "\n"))
-                                            (full (if comment
-                                                      ((lambda (cs)
-                                                         (concat (funcall c-wrap (car cs)) "\n"
-                                                                 body "\n"
-                                                                 (funcall c-wrap (cadr cs))))
-                                                       (org-babel-tangle-comment-links i))
-                                                    body)))
-                                       (setq expansion
-                                             (cons sep (cons full expansion)))))))))
-                           (and expansion
-                                (mapconcat #'identity (nreverse (cdr expansion)) "")))
-                         ;; possibly raise an error if named block doesn't exist
-                         (if (member lang org-babel-noweb-error-langs)
-                             (error "%s" (concat
-                                          (org-babel-noweb-wrap source-name)
-                                          "could not be resolved (see "
-                                          "`org-babel-noweb-error-langs')"))
-                           "")))
-                      "[\n\r]") (concat "\n" prefix))))))
-      (funcall nb-add (buffer-substring index (point-max))))
-    new-body))
-
-(defun org-babel-script-escape (str &optional force)
-  "Safely convert tables into elisp lists."
-  (let (in-single in-double out)
-    ((lambda (escaped) (condition-case nil (org-babel-read escaped) (error escaped)))
-     (if (or force
-            (and (stringp str)
-                 (> (length str) 2)
-                 (or (and (string-equal "[" (substring str 0 1))
-                          (string-equal "]" (substring str -1)))
-                     (and (string-equal "{" (substring str 0 1))
-                          (string-equal "}" (substring str -1)))
-                     (and (string-equal "(" (substring str 0 1))
-                          (string-equal ")" (substring str -1))))))
-        (org-babel-read
-         (concat
-          "'"
-          (progn
-            (mapc
-             (lambda (ch)
-               (setq
-                out
-                (case ch
-                  (91 (if (or in-double in-single) ; [
-                          (cons 91 out)
-                        (cons 40 out)))
-                  (93 (if (or in-double in-single) ; ]
-                          (cons 93 out)
-                        (cons 41 out)))
-                  (123 (if (or in-double in-single) ; {
-                           (cons 123 out)
-                         (cons 40 out)))
-                  (125 (if (or in-double in-single) ; }
-                           (cons 125 out)
-                         (cons 41 out)))
-                  (44 (if (or in-double in-single) ; ,
-                          (cons 44 out) (cons 32 out)))
-                  (39 (if in-double    ; '
-                          (cons 39 out)
-                        (setq in-single (not in-single)) (cons 34 out)))
-                  (34 (if in-single    ; "
-                          (append (list 34 32) out)
-                        (setq in-double (not in-double)) (cons 34 out)))
-                  (t  (cons ch out)))))
-             (string-to-list str))
-            (apply #'string (reverse out)))))
-       str))))
-
-(defun org-babel-read (cell &optional inhibit-lisp-eval)
-  "Convert the string value of CELL to a number if appropriate.
-Otherwise if cell looks like lisp (meaning it starts with a
-\"(\", \"'\", \"`\" or a \"[\") then read it as lisp, otherwise
-return it unmodified as a string.  Optional argument NO-LISP-EVAL
-inhibits lisp evaluation for situations in which is it not
-appropriate."
-  (if (and (stringp cell) (not (equal cell "")))
-      (or (org-babel-number-p cell)
-          (if (and (not inhibit-lisp-eval)
-                  (member (substring cell 0 1) '("(" "'" "`" "[")))
-              (eval (read cell))
-            (if (string= (substring cell 0 1) "\"")
-               (read cell)
-             (progn (set-text-properties 0 (length cell) nil cell) cell))))
-    cell))
-
-(defun org-babel-number-p (string)
-  "If STRING represents a number return its value."
-  (if (and (string-match "^-?[0-9]*\\.?[0-9]*$" string)
-           (= (length (substring string (match-beginning 0)
-                                (match-end 0)))
-             (length string)))
-      (string-to-number string)))
-
-(defun org-babel-import-elisp-from-file (file-name &optional separator)
-  "Read the results located at FILE-NAME into an elisp table.
-If the table is trivial, then return it as a scalar."
-  (let (result)
-    (save-window-excursion
-      (with-temp-buffer
-       (condition-case err
-           (progn
-             (org-table-import file-name separator)
-             (delete-file file-name)
-             (setq result (mapcar (lambda (row)
-                                    (mapcar #'org-babel-string-read row))
-                                  (org-table-to-lisp))))
-         (error (message "Error reading results: %s" err) nil)))
-      (if (null (cdr result)) ;; if result is trivial vector, then scalarize it
-         (if (consp (car result))
-             (if (null (cdr (car result)))
-                 (caar result)
-               result)
-           (car result))
-       result))))
-
-(defun org-babel-string-read (cell)
-  "Strip nested \"s from around strings."
-  (org-babel-read (or (and (stringp cell)
-                           (string-match "\\\"\\(.+\\)\\\"" cell)
-                           (match-string 1 cell))
-                      cell) t))
-
-(defun org-babel-reverse-string (string)
-  "Return the reverse of STRING."
-  (apply 'string (reverse (string-to-list string))))
-
-(defun org-babel-chomp (string &optional regexp)
-  "Strip trailing spaces and carriage returns from STRING.
-Default regexp used is \"[ \f\t\n\r\v]\" but can be
-overwritten by specifying a regexp as a second argument."
-  (let ((regexp (or regexp "[ \f\t\n\r\v]")))
-    (while (and (> (length string) 0)
-                (string-match regexp (substring string -1)))
-      (setq string (substring string 0 -1)))
-    string))
-
-(defun org-babel-trim (string &optional regexp)
-  "Strip leading and trailing spaces and carriage returns from STRING.
-Like `org-babel-chomp' only it runs on both the front and back
-of the string."
-  (org-babel-chomp (org-babel-reverse-string
-                    (org-babel-chomp (org-babel-reverse-string string) regexp))
-                   regexp))
-
-(defvar org-babel-org-babel-call-process-region-original nil)
-(defun org-babel-tramp-handle-call-process-region
-  (start end program &optional delete buffer display &rest args)
-  "Use Tramp to handle `call-process-region'.
-Fixes a bug in `tramp-handle-call-process-region'."
-  (if (and (featurep 'tramp) (file-remote-p default-directory))
-      (let ((tmpfile (tramp-compat-make-temp-file "")))
-       (write-region start end tmpfile)
-       (when delete (delete-region start end))
-       (unwind-protect
-           ;;  (apply 'call-process program tmpfile buffer display args)
-            ;; bug in tramp
-           (apply 'process-file program tmpfile buffer display args)
-         (delete-file tmpfile)))
-    ;; org-babel-call-process-region-original is the original emacs
-    ;; definition.  It is in scope from the let binding in
-    ;; org-babel-execute-src-block
-    (apply org-babel-call-process-region-original
-           start end program delete buffer display args)))
-
-(defun org-babel-local-file-name (file)
-  "Return the local name component of FILE."
-  (if (file-remote-p file)
-      (let (localname)
-       (with-parsed-tramp-file-name file nil
-                                    localname))
-    file))
-
-(defun org-babel-process-file-name (name &optional no-quote-p)
-  "Prepare NAME to be used in an external process.
-If NAME specifies a remote location, the remote portion of the
-name is removed, since in that case the process will be executing
-remotely.  The file name is then processed by `expand-file-name'.
-Unless second argument NO-QUOTE-P is non-nil, the file name is
-additionally processed by `shell-quote-argument'"
-  ((lambda (f) (if no-quote-p f (shell-quote-argument f)))
-   (expand-file-name (org-babel-local-file-name name))))
-
-(defvar org-babel-temporary-directory)
-(unless (or noninteractive (boundp 'org-babel-temporary-directory))
-  (defvar org-babel-temporary-directory
-    (or (and (boundp 'org-babel-temporary-directory)
-            (file-exists-p org-babel-temporary-directory)
-            org-babel-temporary-directory)
-       (make-temp-file "babel-" t))
-    "Directory to hold temporary files created to execute code blocks.
-Used by `org-babel-temp-file'.  This directory will be removed on
-Emacs shutdown."))
-
-(defun org-babel-temp-file (prefix &optional suffix)
-  "Create a temporary file in the `org-babel-temporary-directory'.
-Passes PREFIX and SUFFIX directly to `make-temp-file' with the
-value of `temporary-file-directory' temporarily set to the value
-of `org-babel-temporary-directory'."
-  (let ((temporary-file-directory
-        (if (file-remote-p default-directory)
-            (concat (file-remote-p default-directory) "/tmp")
-          (or (and (boundp 'org-babel-temporary-directory)
-                   (file-exists-p org-babel-temporary-directory)
-                   org-babel-temporary-directory)
-              temporary-file-directory))))
-      (make-temp-file prefix nil suffix)))
-
-(defun org-babel-remove-temporary-directory ()
-  "Remove `org-babel-temporary-directory' on Emacs shutdown."
-  (when (and (boundp 'org-babel-temporary-directory)
-            (file-exists-p org-babel-temporary-directory))
-    ;; taken from `delete-directory' in files.el
-    (condition-case nil
-       (progn
-         (mapc (lambda (file)
-                 ;; This test is equivalent to
-                 ;; (and (file-directory-p fn) (not (file-symlink-p fn)))
-                 ;; but more efficient
-                 (if (eq t (car (file-attributes file)))
-                     (delete-directory file)
-                   (delete-file file)))
-               ;; We do not want to delete "." and "..".
-               (directory-files org-babel-temporary-directory 'full
-                                "^\\([^.]\\|\\.\\([^.]\\|\\..\\)\\).*"))
-         (delete-directory org-babel-temporary-directory))
-      (error
-       (message "Failed to remove temporary Org-babel directory %s"
-               (if (boundp 'org-babel-temporary-directory)
-                   org-babel-temporary-directory
-                 "[directory not defined]"))))))
-
-(add-hook 'kill-emacs-hook 'org-babel-remove-temporary-directory)
+(require 'ob-core)
+(require 'ob-comint)
+(require 'ob-exp)
+(require 'ob-keys)
+(require 'ob-table)
+(require 'ob-lob)
+(require 'ob-ref)
+(require 'ob-tangle)
 
 (provide 'ob)
 
index 48328d8..1fd9ee8 100644 (file)
@@ -242,6 +242,11 @@ you can \"misuse\" it to also add other text to the header."
 (defconst org-sorting-choice
   '(choice
     (const time-up) (const time-down)
+    (const timestamp-up) (const timestamp-down)
+    (const scheduled-up) (const scheduled-down)
+    (const deadline-up)  (const deadline-down)
+    (const ts-up) (const ts-down)
+    (const tsia-up) (const tsia-down)
     (const category-keep) (const category-up) (const category-down)
     (const tag-down) (const tag-up)
     (const priority-up) (const priority-down)
@@ -254,9 +259,50 @@ you can \"misuse\" it to also add other text to the header."
 
 ;; Keep custom values for `org-agenda-filter-preset' compatible with
 ;; the new variable `org-agenda-tag-filter-preset'.
-(if (fboundp 'defvaralias)
-    (defvaralias 'org-agenda-filter-preset 'org-agenda-tag-filter-preset)
-  (defvaralias 'org-agenda-filter 'org-agenda-tag-filter))
+(org-defvaralias 'org-agenda-filter-preset 'org-agenda-tag-filter-preset)
+(org-defvaralias 'org-agenda-filter 'org-agenda-tag-filter)
+
+(defvar org-agenda-entry-types '(:deadline :scheduled :timestamp :sexp)
+  "List of types searched for when creating the daily/weekly agenda.
+This variable is a list of symbols that controls the types of
+items that appear in the daily/weekly agenda.  Allowed symbols in this
+list are are
+
+  :timestamp   List items containing a date stamp or date range matching
+               the selected date.  This includes sexp entries in angular
+               brackets.
+
+  :sexp        List entries resulting from plain diary-like sexps.
+
+  :deadline    List deadline due on that date.  When the date is today,
+               also list any deadlines past due, or due within
+              `org-deadline-warning-days'.  `:deadline' must appear before
+               `:scheduled' if the setting of
+               `org-agenda-skip-scheduled-if-deadline-is-shown' is to have
+               any effect.
+
+  :deadline*   Same as above, but only include the deadline if it has an
+               hour specification as [h]h:mm.
+
+  :scheduled   List all items which are scheduled for the given date.
+              The diary for *today* also contains items which were
+              scheduled earlier and are not yet marked DONE.
+
+  :scheduled*  Same as above, but only include the scheduled item if it
+               has an hour specification as [h]h:mm.
+
+By default, all four non-starred types are turned on.
+
+When :scheduled* or :deadline* are included, :schedule or :deadline
+will be ignored.
+
+Never set this variable globally using `setq', because then it
+will apply to all future agenda commands.  Instead, bind it with
+`let' to scope it dynamically into the agenda-constructing
+command.  A good way to set it is through options in
+`org-agenda-custom-commands'.  For a more flexible (though
+somewhat less efficient) way of determining what is included in
+the daily/weekly agenda, see `org-agenda-skip-function'.")
 
 (defconst org-agenda-custom-commands-local-options
   `(repeat :tag "Local settings for this command.  Remember to quote values"
@@ -311,13 +357,21 @@ you can \"misuse\" it to also add other text to the header."
                          (const :format "" quote)
                          (repeat
                           (string :tag "+tag or -tag"))))
+                  (list :tag "Regexp filter preset"
+                        (const org-agenda-regexp-filter-preset)
+                        (list
+                         (const :format "" quote)
+                         (repeat
+                          (string :tag "+regexp or -regexp"))))
                   (list :tag "Set daily/weekly entry types"
                         (const org-agenda-entry-types)
                         (list
                          (const :format "" quote)
-                         (set :greedy t :value (:deadline :scheduled :timestamp :sexp)
+                         (set :greedy t :value ,org-agenda-entry-types
                               (const :deadline)
                               (const :scheduled)
+                              (const :deadline*)
+                              (const :scheduled*)
                               (const :timestamp)
                               (const :sexp))))
                   (list :tag "Standard skipping condition"
@@ -371,8 +425,8 @@ This will be spliced into the custom type of
 `org-agenda-custom-commands'.")
 
 
-(defcustom org-agenda-custom-commands '(("n" "Agenda and all TODO's"
-                                        ((agenda "") (alltodo))))
+(defcustom org-agenda-custom-commands
+  '(("n" "Agenda and all TODO's" ((agenda "") (alltodo ""))))
   "Custom commands for the agenda.
 These commands will be offered on the splash screen displayed by the
 agenda dispatcher \\[org-agenda].  Each entry is a list like this:
@@ -603,6 +657,13 @@ that are marked with the ARCHIVE tag will be included anyway.  When this is
 t, also all archive files associated with the current selection of agenda
 files will be included.")
 
+(defcustom org-agenda-restriction-lock-highlight-subtree t
+  "Non-nil means highlight the whole subtree when restriction is active.
+Otherwise only highlight the headline.  Highlighting the whole subtree is
+useful to ensure no edits happen beyond the restricted region."
+  :group 'org-agenda
+  :type 'boolean)
+
 (defcustom org-agenda-skip-comment-trees t
   "Non-nil means skip trees that start with the COMMENT keyword.
 When nil, these trees are also scanned by agenda commands."
@@ -740,8 +801,24 @@ to make his option also apply to the tags-todo list."
          (const :tag "Show all TODOs, even if they have a deadline" nil)
          (integer :tag "Ignore if N or more days in past(-) or future(+).")))
 
+(defcustom org-agenda-todo-ignore-time-comparison-use-seconds nil
+  "Time unit to use when possibly ignoring an agenda item.
+
+See the docstring of various `org-agenda-todo-ignore-*' options.
+The default is to compare time&