update
authorJoerg Jaspert <joerg@debian.org>
Wed, 3 Apr 2013 20:34:50 +0000 (22:34 +0200)
committerJoerg Jaspert <joerg@debian.org>
Wed, 3 Apr 2013 20:34:50 +0000 (22:34 +0200)
137 files changed:
elisp/org/ob-C.el
elisp/org/ob-R.el
elisp/org/ob-awk.el
elisp/org/ob-calc.el
elisp/org/ob-clojure.el
elisp/org/ob-comint.el
elisp/org/ob-ditaa.el
elisp/org/ob-dot.el
elisp/org/ob-emacs-lisp.el
elisp/org/ob-exp.el
elisp/org/ob-fortran.el
elisp/org/ob-gnuplot.el
elisp/org/ob-haskell.el
elisp/org/ob-io.el
elisp/org/ob-java.el
elisp/org/ob-js.el
elisp/org/ob-keys.el
elisp/org/ob-latex.el
elisp/org/ob-lilypond.el
elisp/org/ob-lisp.el
elisp/org/ob-lob.el
elisp/org/ob-maxima.el
elisp/org/ob-mscgen.el
elisp/org/ob-ocaml.el
elisp/org/ob-octave.el
elisp/org/ob-org.el
elisp/org/ob-perl.el
elisp/org/ob-picolisp.el
elisp/org/ob-plantuml.el
elisp/org/ob-python.el
elisp/org/ob-ref.el
elisp/org/ob-ruby.el
elisp/org/ob-sass.el
elisp/org/ob-scala.el
elisp/org/ob-scheme.el
elisp/org/ob-screen.el
elisp/org/ob-sh.el
elisp/org/ob-shen.el
elisp/org/ob-sql.el
elisp/org/ob-sqlite.el
elisp/org/ob-table.el
elisp/org/ob-tangle.el
elisp/org/ob.el
elisp/org/org-agenda.el
elisp/org/org-annotate-file.el
elisp/org/org-archive.el
elisp/org/org-ascii.el
elisp/org/org-attach.el
elisp/org/org-beamer.el
elisp/org/org-bibtex-extras.el
elisp/org/org-bibtex.el
elisp/org/org-bookmark.el
elisp/org/org-capture.el
elisp/org/org-checklist.el
elisp/org/org-choose.el
elisp/org/org-clock.el
elisp/org/org-collector.el
elisp/org/org-colview-xemacs.el
elisp/org/org-colview.el
elisp/org/org-compat.el
elisp/org/org-contacts.el
elisp/org/org-contribdir.el
elisp/org/org-datetree.el
elisp/org/org-depend.el
elisp/org/org-docbook.el
elisp/org/org-docview.el
elisp/org/org-e-ascii.el
elisp/org/org-e-beamer.el
elisp/org/org-e-groff.el
elisp/org/org-e-html.el
elisp/org/org-e-latex.el
elisp/org/org-e-man.el
elisp/org/org-e-odt.el
elisp/org/org-e-publish.el
elisp/org/org-e-texinfo.el
elisp/org/org-element.el
elisp/org/org-elisp-symbol.el
elisp/org/org-entities.el
elisp/org/org-eval-light.el
elisp/org/org-eval.el
elisp/org/org-exp-bibtex.el
elisp/org/org-exp-blocks.el
elisp/org/org-exp.el
elisp/org/org-expiry.el
elisp/org/org-export-generic.el
elisp/org/org-export.el
elisp/org/org-faces.el
elisp/org/org-footnote.el
elisp/org/org-freemind.el
elisp/org/org-git-link.el
elisp/org/org-gnus.el
elisp/org/org-html.el
elisp/org/org-icalendar.el
elisp/org/org-id.el
elisp/org/org-indent.el
elisp/org/org-inlinetask.el
elisp/org/org-interactive-query.el
elisp/org/org-invoice.el
elisp/org/org-jira.el
elisp/org/org-jsinfo.el
elisp/org/org-latex.el
elisp/org/org-learn.el
elisp/org/org-list.el
elisp/org/org-loaddefs.el
elisp/org/org-lparse.el
elisp/org/org-mac-iCal.el
elisp/org/org-mac-link-grabber.el
elisp/org/org-macs.el
elisp/org/org-mairix.el
elisp/org/org-md.el
elisp/org/org-mime.el
elisp/org/org-mobile.el
elisp/org/org-mtags.el
elisp/org/org-notify.el
elisp/org/org-notmuch.el
elisp/org/org-odt.el
elisp/org/org-pcomplete.el
elisp/org/org-plot.el
elisp/org/org-protocol.el
elisp/org/org-publish.el
elisp/org/org-registry.el
elisp/org/org-remember.el
elisp/org/org-screen.el
elisp/org/org-secretary.el
elisp/org/org-special-blocks.el
elisp/org/org-src.el
elisp/org/org-sudoku.el
elisp/org/org-table.el
elisp/org/org-taskjuggler.el
elisp/org/org-toc.el
elisp/org/org-track.el
elisp/org/org-velocity.el
elisp/org/org-version.el
elisp/org/org-w3m.el
elisp/org/org-wikinodes.el
elisp/org/org-xoxo.el
elisp/org/org.el

index b1e8a06..42a98de 100644 (file)
@@ -31,6 +31,7 @@
 
 ;;; Code:
 (require 'ob)
+(require 'ob-eval)
 (require 'cc-mode)
 
 (declare-function org-entry-get "org"
@@ -105,11 +106,11 @@ or `org-babel-execute:C++'."
                     (org-babel-process-file-name tmp-src-file)) ""))))
     ((lambda (results)
        (org-babel-reassemble-table
-       (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)))
+       (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-pick-name
         (cdr (assoc :colname-names params)) (cdr (assoc :colnames params)))
        (org-babel-pick-name
index 8db0853..562f37d 100644 (file)
@@ -28,6 +28,9 @@
 
 ;;; 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))
@@ -299,10 +302,11 @@ 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
-       (org-babel-result-cond result-params
-         (with-temp-buffer
-           (insert-file-contents tmp-file)
-           (buffer-string))
+       (if (or (member "scalar" result-params)
+               (member "verbatim" 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))))
@@ -331,10 +335,11 @@ last statement in BODY, as elisp."
                  "FALSE")
                ".Last.value" (org-babel-process-file-name tmp-file 'noquote)))
        (org-babel-R-process-value-result
-       (org-babel-result-cond result-params
-         (with-temp-buffer
-           (insert-file-contents tmp-file)
-           (buffer-string))
+       (if (or (member "scalar" result-params)
+               (member "verbatim" 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 f717fec..12d625a 100644 (file)
@@ -32,6 +32,7 @@
 
 ;;; Code:
 (require 'ob)
+(require 'ob-eval)
 (require 'org-compat)
 (eval-when-compile (require 'cl))
 
@@ -77,8 +78,10 @@ called by `org-babel-execute-src-block'"
     (org-babel-reassemble-table
      ((lambda (results)
        (when results
-         (org-babel-result-cond result-params
-           results
+         (if (or (member "scalar" result-params)
+                 (member "verbatim" result-params)
+                 (member "output" 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 766f6ce..a8e53c0 100644 (file)
@@ -31,6 +31,7 @@
 (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 bc2bbc0..b020498 100644 (file)
@@ -79,8 +79,9 @@
     (insert (org-babel-expand-body:clojure body params))
     ((lambda (result)
        (let ((result-params (cdr (assoc :result-params params))))
-        (org-babel-result-cond result-params
-          result
+        (if (or (member "scalar" result-params)
+                (member "verbatim" result-params))
+            result
           (condition-case nil (org-babel-script-escape result)
             (error result)))))
      (slime-eval
index f156297..5ea3be2 100644 (file)
@@ -30,7 +30,7 @@
 ;; org-babel at large.
 
 ;;; Code:
-(require 'ob-core)
+(require 'ob)
 (require 'org-compat)
 (require 'comint)
 (eval-when-compile (require 'cl))
index 5ef519c..d6bbbbc 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
-  :type 'string)
-
 (defcustom org-ditaa-jar-option "-jar"
   "Option for the ditaa jar file.
 Do not leave leading or trailing spaces in this string."
@@ -83,25 +69,16 @@ 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
-                       (if eps org-ditaa-eps-jar-path org-ditaa-jar-path)))
+                      (expand-file-name org-ditaa-jar-path))
                      " " cmdline
                      " " (org-babel-process-file-name in-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)))))
+                     " " (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 7504264..b5e7880 100644 (file)
@@ -39,6 +39,7 @@
 
 ;;; Code:
 (require 'ob)
+(require 'ob-eval)
 
 (defvar org-babel-default-header-args:dot
   '((:results . "file") (:exports . "results"))
index 886645d..d6073ca 100644 (file)
@@ -27,6 +27,7 @@
 
 ;;; 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)
-       (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)))
+       (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-reassemble-table
          result
          (org-babel-pick-name (cdr (assoc :colname-names params))
index 0d98690..37a9f71 100644 (file)
@@ -23,7 +23,8 @@
 ;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
 
 ;;; Code:
-(require 'ob-core)
+(require 'ob)
+(require 'org-exp-blocks)
 (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-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))
+(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))
 
 (defcustom org-export-babel-evaluate t
   "Switch controlling code evaluation during export.
@@ -90,7 +86,7 @@ process."
        results)))
 (def-edebug-spec org-babel-exp-in-export-file (form body))
 
-(defun org-babel-exp-src-block (&rest headers)
+(defun org-babel-exp-src-block (body &rest headers)
   "Process source block for export.
 Depending on the 'export' headers argument in replace the source
 code block with...
@@ -103,12 +99,11 @@ 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
-
-Assume point is at the beginning of block's starting line."
+none ----- do not display either code or results upon export"
   (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)
@@ -154,156 +149,66 @@ 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 (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)))))
+      (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)))))))))
 
 (defun org-babel-in-example-or-verbatim ()
   "Return true if point is in example or verbatim code.
@@ -364,7 +269,9 @@ replaced with its value."
   (org-fill-template
    org-babel-exp-code-template
    `(("lang"  . ,(nth 0 info))
-     ("body"  . ,(org-escape-code-in-string (nth 1 info)))
+     ("body"  . ,(if (string= (nth 0 info) "org")
+                    (replace-regexp-in-string "^" "," (nth 1 info))
+                  (nth 1 info)))
      ,@(mapcar (lambda (pair)
                 (cons (substring (symbol-name (car pair)) 1)
                       (format "%S" (cdr pair))))
@@ -413,7 +320,8 @@ inhibit insertion of results into the buffer."
              (re-search-backward org-babel-lob-one-liner-regexp nil t)
              (org-babel-execute-src-block nil info)))))))))
 
-
 (provide 'ob-exp)
 
+
+
 ;;; ob-exp.el ends here
index 1eab03e..8d5012f 100644 (file)
@@ -28,6 +28,7 @@
 
 ;;; 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
-       (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)))
+       (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-pick-name
         (cdr (assoc :colname-names params)) (cdr (assoc :colnames params)))
        (org-babel-pick-name
index 4b3a1c6..488d250 100644 (file)
@@ -39,6 +39,8 @@
 
 ;;; Code:
 (require 'ob)
+(require 'ob-ref)
+(require 'ob-comint)
 (eval-when-compile (require 'cl))
 
 (declare-function org-time-string-to-time "org" (s))
index a04963f..eca6d82 100644 (file)
@@ -40,6 +40,7 @@
 
 ;;; Code:
 (require 'ob)
+(require 'ob-comint)
 (require 'comint)
 (eval-when-compile (require 'cl))
 
@@ -146,9 +147,8 @@ specifying a variable of the same value."
     (format "%S" var)))
 
 (defvar org-src-preserve-indentation)
-(declare-function org-export-to-file "ox"
-                 (backend file
-                          &optional subtreep visible-only body-only ext-plist))
+(declare-function org-export-as-latex "org-latex"
+                 (arg &optional ext-plist to-buffer body-only pub-dir))
 (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,11 +192,7 @@ 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
-      (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))
+      (find-file tmp-org-file) (funcall 'org-export-as-latex nil)
       (kill-buffer nil)
       (delete-file tmp-org-file)
       (find-file tmp-tex-file)
index af18f74..d4686a9 100644 (file)
@@ -33,6 +33,9 @@
 
 ;;; Code:
 (require 'ob)
+(require 'ob-ref)
+(require 'ob-comint)
+(require 'ob-eval)
 (eval-when-compile (require 'cl))
 
 (defvar org-babel-tangle-lang-exts) ;; Autoloaded
@@ -95,8 +98,8 @@ in BODY as elisp."
                   (wrapper (format org-babel-io-wrapper-method body)))
              (with-temp-file src-file (insert wrapper))
              ((lambda (raw)
-                (org-babel-result-cond result-params
-                 raw
+                (if (member "code" result-params)
+                    raw
                   (org-babel-io-table-or-string raw)))
               (org-babel-eval
                (concat org-babel-io-command " " src-file) ""))))))
index c0e9a53..96128ed 100644 (file)
@@ -28,6 +28,7 @@
 
 ;;; 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
-       (org-babel-result-cond (cdr (assoc :result-params params))
-         (org-babel-read results)
-         (let ((tmp-file (org-babel-temp-file "c-")))
+       (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-import-elisp-from-file tmp-file))
+         (org-babel-read results))
        (org-babel-pick-name
         (cdr (assoc :colname-names params)) (cdr (assoc :colnames params)))
        (org-babel-pick-name
index 8cae35b..4e4c3ab 100644 (file)
@@ -39,6 +39,9 @@
 
 ;;; Code:
 (require 'ob)
+(require 'ob-ref)
+(require 'ob-comint)
+(require 'ob-eval)
 (eval-when-compile (require 'cl))
 
 (declare-function run-mozilla "ext:moz" (arg))
index 6cc7387..01a54ca 100644 (file)
@@ -29,7 +29,7 @@
 ;; functions and their associated keys.
 
 ;;; Code:
-(require 'ob-core)
+(require 'ob)
 
 (defvar org-babel-key-prefix "\C-c\C-v"
   "The key prefix for Babel interactive key-bindings.
index 94d5133..104f971 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-latex-guess-inputenc "ox-latex" (header))
-(declare-function org-latex-compile "ox-latex" (file))
-
+(declare-function org-export-latex-fix-inputenc "org-latex" ())
 (defvar org-babel-tangle-lang-exts)
 (add-to-list 'org-babel-tangle-lang-exts '("latex" . "tex"))
 
-(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-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-babel-default-header-args:latex
   '((:results . "latex") (:exports . "results"))
@@ -78,28 +81,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-latex-packages-alist
-             (append (cdr (assoc :packages params)) org-latex-packages-alist)))
+            (org-export-latex-packages-alist
+             (append (cdr (assoc :packages params))
+                     org-export-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-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))
+            (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)
             (if fit "\n\\usepackage[active, tightpage]{preview}\n" "")
             (if border (format "\\setlength{\\PreviewBorder}{%s}" border) "")
             (if height (concat "\n" (format "\\pdfpageheight %s" height)) "")
@@ -110,10 +113,14 @@ 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"))))
+              (concat "\n\\begin{document}\n" body "\n\\end{document}\n")))
+           (org-export-latex-fix-inputenc))
           (when (file-exists-p out-file) (delete-file out-file))
          (let ((transient-pdf-file (org-babel-latex-tex-to-pdf tex-file)))
            (cond
@@ -130,6 +137,7 @@ 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 " "
@@ -138,14 +146,55 @@ 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."
-  (require 'ox-latex)
-  (org-latex-compile 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)))
 
 (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)
+
+
+
 ;;; ob-latex.el ends here
index 6080a5a..0554a36 100644 (file)
 ;; http://lilypond.org/manuals.html
 
 ;;; Code:
+
 (require 'ob)
+(require 'ob-eval)
+(require 'ob-tangle)
 (require 'outline)
 (defalias 'lilypond-mode 'LilyPond-mode)
 
@@ -152,11 +155,7 @@ specific arguments to =org-babel-tangle="
       " -dbackend=eps "
       "-dno-gs-load-fonts "
       "-dinclude-eps-fonts "
-      (or (cdr (assoc (file-name-extension out-file)
-                     '(("pdf" . "--pdf ")
-                       ("ps" . "--ps ")
-                       ("png" . "--png "))))
-         "--png ")
+      "--png "
       "--output="
       (file-name-sans-extension out-file)
       " "
index 2bb1a25..4ff9718 100644 (file)
@@ -76,8 +76,8 @@ current directory string."
   (require 'slime)
   (org-babel-reassemble-table
    ((lambda (result)
-      (org-babel-result-cond (cdr (assoc :result-params params))
-       (car result)
+      (if (member "output" (cdr (assoc :result-params params)))
+         (car result)
        (condition-case nil
            (read (org-babel-lisp-vector-to-list (cadr result)))
          (error (cadr result)))))
index 2fcebcf..3727829 100644 (file)
@@ -25,7 +25,7 @@
 ;;; Code:
 (eval-when-compile
   (require 'cl))
-(require 'ob-core)
+(require 'ob)
 (require 'ob-table)
 
 (declare-function org-babel-in-example-or-verbatim "ob-exp" nil)
index 916dd7e..4a91ca9 100644 (file)
@@ -89,8 +89,10 @@ called by `org-babel-execute-src-block'."
            (org-babel-eval cmd "")))))
     (if (org-babel-maxima-graphical-output-file params)
        nil
-      (org-babel-result-cond result-params
-       result
+      (if (or (member "scalar" result-params)
+             (member "verbatim" result-params)
+             (member "output" 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 209ad7d..5838d7d 100644 (file)
@@ -55,6 +55,7 @@
 
 ;;; Code:
 (require 'ob)
+(require 'ob-eval)
 
 (defvar org-babel-default-header-args:mscgen
   '((:results . "file") (:exports . "results"))
index 9390fab..bff41f8 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)
@@ -89,9 +89,8 @@
                                                  (stringp session))
                                             session
                                           tuareg-interactive-buffer-name)))
-    (save-window-excursion
-      (if (fboundp 'tuareg-run-caml) (tuareg-run-caml) (tuareg-run-ocaml))
-      (get-buffer tuareg-interactive-buffer-name))))
+    (save-window-excursion (tuareg-run-caml)
+                           (get-buffer tuareg-interactive-buffer-name))))
 
 (defun org-babel-variable-assignments:ocaml (params)
   "Return list of ocaml statements assigning the block's variables."
index c2a3abb..3394d57 100644 (file)
@@ -30,6 +30,9 @@
 
 ;;; 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 18cce3b..a5cd96a 100644 (file)
@@ -29,8 +29,7 @@
 ;;; Code:
 (require 'ob)
 
-(declare-function org-export-string-as "ox"
-                 (string backend &optional body-only ext-plist))
+(declare-function org-export-string "org-exp" (string fmt &optional dir))
 
 (defvar org-babel-default-header-args:org
   '((:results . "raw silent") (:exports . "code"))
@@ -54,10 +53,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-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))
+     ((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"))
      (t body))))
 
 (defun org-babel-prep-session:org (session params)
index e449fbe..b37df80 100644 (file)
@@ -28,6 +28,7 @@
 
 ;;; Code:
 (require 'ob)
+(require 'ob-eval)
 (eval-when-compile (require 'cl))
 
 (defvar org-babel-tangle-lang-exts)
@@ -69,16 +70,13 @@ This function is called by `org-babel-execute-src-block'."
 
 ;; helper functions
 
-(defvar org-babel-perl-var-wrap "q(%s)"
-  "Wrapper for variables inserted into Perl code.")
-
 (defun org-babel-perl-var-to-perl (var)
   "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 org-babel-perl-var-wrap var)))
+    (format "%S" var)))
 
 (defvar org-babel-perl-buffers '(:default . nil))
 
index e785366..1029b6f 100644 (file)
@@ -54,6 +54,8 @@
 
 ;;; Code:
 (require 'ob)
+(require 'ob-eval)
+(require 'ob-comint)
 (require 'comint)
 (eval-when-compile (require 'cl))
 
            (t full-body))))
 
     ((lambda (result)
-       (org-babel-result-cond result-params
-        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
          (read result)))
      (if (not (string= session-name "none"))
          ;; session based evaluation
index c17d444..bb52c37 100644 (file)
@@ -35,6 +35,7 @@
 
 ;;; Code:
 (require 'ob)
+(require 'ob-eval)
 
 (defvar org-babel-default-header-args:plantuml
   '((:results . "file") (:exports . "results"))
index f2806c7..79cc53e 100644 (file)
@@ -28,6 +28,9 @@
 
 ;;; 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 '())
 
-(defcustom org-babel-python-command "python"
-  "Name of the command for executing Python code."
-  :group 'org-babel
-  :version "24.3"
-  :type 'string)
+(defvar org-babel-python-command "python"
+  "Name of the command for executing Python code.")
 
-(defcustom org-babel-python-mode
-  (if (or (featurep 'xemacs) (featurep 'python-mode)) 'python-mode 'python)
+(defvar org-babel-python-mode (if (featurep 'xemacs) 'python-mode 'python)
   "Preferred python mode for use in running python interactively.
-This will typically be either 'python or 'python-mode."
-  :group 'org-babel
-  :version "24.3"
-  :type 'function)
+This will typically be either 'python or 'python-mode.")
 
 (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
-  :type 'string)
-
-(defcustom org-babel-python-None-to 'hline
-  "Replace 'None' in python tables with this before returning."
-  :group 'org-babel
-  :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'."
@@ -128,7 +114,7 @@ specifying a variable of the same value."
   (if (listp var)
       (concat "[" (mapconcat #'org-babel-python-var-to-python var ", ") "]")
     (if (equal var 'hline)
-       org-babel-python-hline-to
+       "None"
       (format
        (if (and (stringp var) (string-match "[\n\r]" var)) "\"\"%S\"\"" "%S")
        var))))
@@ -137,13 +123,7 @@ 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."
-  ((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)))
+  (org-babel-script-escape results))
 
 (defvar org-babel-python-buffers '((:default . nil)))
 
@@ -226,8 +206,11 @@ 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)
-     (org-babel-result-cond result-params
-       raw
+     (if (or (member "code" result-params)
+            (member "pp" result-params)
+            (and (member "output" result-params)
+                 (not (member "table" result-params))))
+        raw
        (org-babel-python-table-or-string (org-babel-trim raw))))
    (case result-type
      (output (org-babel-eval org-babel-python-command
@@ -276,8 +259,11 @@ last statement in BODY, as elisp."
                       (funcall send-wait))))
     ((lambda (results)
        (unless (string= (substring org-babel-python-eoe-indicator 1 -1) results)
-        (org-babel-result-cond result-params
-          results
+        (if (or (member "code" result-params)
+                (member "pp" result-params)
+                (and (member "output" result-params)
+                     (not (member "table" result-params))))
+            results
           (org-babel-python-table-or-string results))))
      (case result-type
        (output
index 7b92936..389c363 100644 (file)
@@ -49,7 +49,7 @@
 ;;  #+end_src
 
 ;;; Code:
-(require 'ob-core)
+(require 'ob)
 (eval-when-compile
   (require 'cl))
 
index bef8fba..747c6fc 100644 (file)
@@ -37,6 +37,9 @@
 
 ;;; 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))
index cdb75be..60a10db 100644 (file)
@@ -39,6 +39,7 @@
 
 ;;; Code:
 (require 'ob)
+(require 'ob-eval)
 
 (defvar org-babel-default-header-args:sass '())
 
index 7cb3099..3a07b34 100644 (file)
@@ -31,6 +31,9 @@
 
 ;;; Code:
 (require 'ob)
+(require 'ob-ref)
+(require 'ob-comint)
+(require 'ob-eval)
 (eval-when-compile (require 'cl))
 
 (defvar org-babel-tangle-lang-exts) ;; Autoloaded
@@ -101,8 +104,8 @@ in BODY as elisp."
             (wrapper (format org-babel-scala-wrapper-method body)))
        (with-temp-file src-file (insert wrapper))
        ((lambda (raw)
-          (org-babel-result-cond result-params
-           raw
+          (if (member "code" result-params)
+              raw
             (org-babel-scala-table-or-string raw)))
         (org-babel-eval
          (concat org-babel-scala-command " " src-file) ""))))))
index c9fa44a..bd7ea82 100644 (file)
@@ -38,6 +38,9 @@
 
 ;;; Code:
 (require 'ob)
+(require 'ob-ref)
+(require 'ob-comint)
+(require 'ob-eval)
 (eval-when-compile (require 'cl))
 
 (declare-function run-scheme "ext:cmuscheme" (cmd))
index f263376..621110b 100644 (file)
@@ -34,6 +34,7 @@
 
 ;;; Code:
 (require 'ob)
+(require 'ob-ref)
 
 (defvar org-babel-screen-location "screen"
   "The command location for screen.
index f11b799..c0e6b15 100644 (file)
@@ -27,6 +27,9 @@
 
 ;;; Code:
 (require 'ob)
+(require 'ob-ref)
+(require 'ob-comint)
+(require 'ob-eval)
 (require 'shell)
 (eval-when-compile (require 'cl))
 
@@ -138,8 +141,10 @@ return the value of the last statement in BODY."
   ((lambda (results)
      (when results
        (let ((result-params (cdr (assoc :result-params params))))
-        (org-babel-result-cond result-params
-          results
+        (if (or (member "scalar" result-params)
+                (member "verbatim" result-params)
+                (member "output" 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 a41580f..ec31546 100644 (file)
@@ -66,8 +66,9 @@ 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)
-       (org-babel-result-cond result-params 
-        results
+       (if (or (member 'scalar result-params)
+              (member 'verbatim result-params))
+          results
         (condition-case nil (org-babel-script-escape results)
           (error results))))
      (with-temp-buffer
index 20e62d0..131fa46 100644 (file)
 ;;
 ;; Also SQL evaluation generally takes place inside of a database.
 ;;
-;; 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
+;; For now lets just allow a generic ':cmdline' header argument.
 ;;
 ;; 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 '())
 
-(defconst org-babel-header-args:sql
-  '((engine           . :any)
-    (out-file         . :any)
-    (dbhost           . :any)
-    (dbuser           . :any)
-    (dbpassword               . :any)
-    (database         . :any))
-  "SQL-specific header arguments.")
+(defvar org-babel-header-args:sql
+  '((engine   . :any)
+    (out-file . :any)))
 
 (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-")))
@@ -116,9 +85,7 @@ 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 < %s > %s"
-                                   (dbstring-mysql dbhost dbuser dbpassword database)
-                                   (if colnames-p "" "-N")
+                    ('mysql (format "mysql %s < %s > %s"
                                     (or cmdline "")
                                    (org-babel-process-file-name in-file)
                                    (org-babel-process-file-name out-file)))
@@ -135,38 +102,28 @@ This function is called by `org-babel-execute-src-block'."
         (t ""))
        (org-babel-expand-body:sql body params)))
     (message command)
-    (org-babel-eval command "")
-    (org-babel-result-cond result-params
-      (with-temp-buffer
+    (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
          (progn (insert-file-contents-literally out-file) (buffer-string)))
       (with-temp-buffer
-       (cond
-         ((or (eq (intern engine) 'mysql)
-              (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))))
+       ;; 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))
        (org-table-import out-file '(16))
        (org-babel-reassemble-table
         (mapcar (lambda (x)
index 30bfc73..c25e786 100644 (file)
@@ -27,6 +27,8 @@
 
 ;;; 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"
@@ -96,21 +98,23 @@ 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)))
-      (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)))))))
+      (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))))))
 
 (defun org-babel-sqlite-expand-vars (body vars)
   "Expand the variables held in VARS in BODY."
index 869d992..99951ca 100644 (file)
@@ -50,7 +50,7 @@
 ;; #+TBLFM: $2='(sbe 'fibbd (n $1))
 
 ;;; Code:
-(require 'ob-core)
+(require 'ob)
 
 (defun org-babel-table-truncate-at-newline (string)
   "Replace newline character with ellipses.
index 6c79794..c3b6a48 100644 (file)
@@ -26,6 +26,7 @@
 ;; Extract the code from source blocks out into raw source-code files.
 
 ;;; Code:
+(require 'ob)
 (require 'org-src)
 (eval-when-compile
   (require 'cl))
@@ -136,13 +137,12 @@ evaluating BODY."
 (def-edebug-spec org-babel-with-temp-filebuffer (form body))
 
 ;;;###autoload
-(defun org-babel-load-file (file &optional compile)
+(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'.  With prefix
-arg (noninteractively: 2nd arg) COMPILE the tangled Emacs Lisp
-file to byte-code before it is loaded."
-  (interactive "fFile to load: \nP")
+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)
@@ -154,12 +154,8 @@ file to byte-code before it is loaded."
     (unless (and (file-exists-p exported-file)
                 (> (funcall age file) (funcall age exported-file)))
       (org-babel-tangle-file file exported-file "emacs-lisp"))
-    (message "%s %s"
-            (if compile
-                (progn (byte-compile-file exported-file 'load)
-                       "Compiled and loaded")
-              (progn (load-file exported-file) "Loaded"))
-            exported-file)))
+    (load-file exported-file)
+    (message "Loaded %s" exported-file)))
 
 ;;;###autoload
 (defun org-babel-tangle-file (file &optional target-file lang)
@@ -202,14 +198,7 @@ exported source code blocks by language."
                    target-file)
          (setq target-file
                (read-from-minibuffer "Tangle to: " (buffer-file-name)))))
-      (narrow-to-region
-       (save-match-data
-        (save-excursion
-          (goto-char (org-babel-where-is-src-block-head))
-          (while (and (forward-line -1)
-                      (looking-at org-babel-multi-line-header-regexp)))
-          (point)))
-       (match-end 0)))
+      (narrow-to-region (match-beginning 0) (match-end 0)))
     (save-excursion
       (let ((block-counter 0)
            (org-babel-default-header-args
index 6cacac7..7245714 100644 (file)
@@ -3,6 +3,7 @@
 ;; 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 'ob-core)
-(require 'ob-comint)
-(require 'ob-exp)
-(require 'ob-keys)
-(require 'ob-table)
-(require 'ob-lob)
-(require 'ob-ref)
-(require 'ob-tangle)
+(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)
 
 (provide 'ob)
 
index efde570..48328d8 100644 (file)
@@ -740,20 +740,6 @@ 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 stamps using days.  An item is thus
-considered to be in the future if it is at least one day after today.
-Non-nil means to compare time stamps using seconds.  An item is then
-considered future if it has a time value later than current time."
-  :group 'org-agenda-skip
-  :group 'org-agenda-todo-list
-  :type '(choice
-         (const :tag "Compare time with days" nil)
-         (const :tag "Compare time with seconds" t)))
-
 (defcustom org-agenda-tags-todo-honor-ignore-options nil
   "Non-nil means honor todo-list ...ignore options also in tags-todo search.
 The variables
@@ -827,10 +813,9 @@ deadlines are always turned off when the item is DONE."
 This will apply on all days where a prewarning for the deadline would
 be shown, but not at the day when the entry is actually due.  On that day,
 the deadline will be shown anyway.
-This variable may be set to nil, t, the symbol `pre-scheduled',
-or a number which will then give the number of days before the actual
-deadline when the prewarnings should resume.  The symbol `pre-scheduled'
-eliminates the deadline prewarning only prior to the scheduled date.
+This variable may be set to nil, t, or a number which will then give
+the number of days before the actual deadline when the prewarnings
+should resume.
 This can be used in a workflow where the first showing of the deadline will
 trigger you to schedule it, and then you don't want to be reminded of it
 because you will take care of it on the day when scheduled."
@@ -839,25 +824,9 @@ because you will take care of it on the day when scheduled."
   :version "24.1"
   :type '(choice
          (const :tag "Always show prewarning" nil)
-         (const :tag "Remove prewarning prior to scheduled date" pre-scheduled)
          (const :tag "Remove prewarning if entry is scheduled" t)
          (integer :tag "Restart prewarning N days before deadline")))
 
-(defcustom org-agenda-skip-scheduled-delay-if-deadline nil
-  "Non-nil means skip scheduled delay when entry also has a deadline.
-This variable may be set to nil, t, the symbol `post-deadline',
-or a number which will then give the number of days after the actual
-scheduled date when the delay should expire.  The symbol `post-deadline'
-eliminates the schedule delay when the date is posterior to the deadline."
-  :group 'org-agenda-skip
-  :group 'org-agenda-daily/weekly
-  :version "24.3"
-  :type '(choice
-         (const :tag "Always honor delay" nil)
-         (const :tag "Ignore delay if posterior to the deadline" post-deadline)
-         (const :tag "Ignore delay if entry has a deadline" t)
-         (integer :tag "Honor delay up until N days after the scheduled date")))
-
 (defcustom org-agenda-skip-additional-timestamps-same-entry nil
   "When nil, multiple same-day timestamps in entry make multiple agenda lines.
 When non-nil, after the search for timestamps has matched once in an
@@ -1336,14 +1305,6 @@ When nil, they may also match part of a word."
   :version "24.1"
   :type 'boolean)
 
-(defcustom org-agenda-search-view-max-outline-level nil
-  "Maximum outline level to display in search view.
-E.g. when this is set to 1, the search view will only
-show headlines of level 1."
-  :group 'org-agenda-search-view
-  :version "24.3"
-  :type 'integer)
-
 (defgroup org-agenda-time-grid nil
   "Options concerning the time grid in the Org-mode Agenda."
   :tag "Org Agenda Time Grid"
@@ -1432,16 +1393,6 @@ symbols are recognized:
 
 time-up            Put entries with time-of-day indications first, early first
 time-down          Put entries with time-of-day indications first, late first
-timestamp-up       Sort by any timestamp, early first
-timestamp-down     Sort by any timestamp, late first
-scheduled-up       Sort by scheduled timestamp, early first
-scheduled-down     Sort by scheduled timestamp, late first
-deadline-up        Sort by deadline timestamp, early first
-deadline-down      Sort by deadline timestamp, late first
-ts-up              Sort by active timestamp, early first
-ts-down            Sort by active timestamp, late first
-tsia-up            Sort by inactive timestamp, early first
-tsia-down          Sort by inactive timestamp, late first
 category-keep      Keep the default order of categories, corresponding to the
                   sequence in `org-agenda-files'.
 category-up        Sort alphabetically by category, A-Z.
@@ -1542,17 +1493,15 @@ This format works similar to a printf format, with the following meaning:
   %c   the category of the item, \"Diary\" for entries from the diary,
        or as given by the CATEGORY keyword or derived from the file name
   %e   the effort required by the item
-  %l   the level of the item (insert X space(s) if item is of level X)
   %i   the icon category of the item, see `org-agenda-category-icon-alist'
   %T   the last tag of the item (ignore inherited tags, which come first)
   %t   the HH:MM time-of-day specification if one applies to the entry
   %s   Scheduling/Deadline information, a short string
-  %b   show breadcrumbs, i.e., the names of the higher levels
   %(expression) Eval EXPRESSION and replace the control string
                 by the result
 
 All specifiers work basically like the standard `%s' of printf, but may
-contain two additional characters: a question mark just after the `%'
+contain two additional characters:  a question mark just after the `%'
 and a whitespace/punctuation character just before the final letter.
 
 If the first character after `%' is a question mark, the entire field
@@ -1562,11 +1511,11 @@ present, but zero width when absent.  For example, \"%?-12t\" will
 result in a 12 character time field if a time of the day is specified,
 but will completely disappear in entries which do not contain a time.
 
-If there is punctuation or whitespace character just before the
-final format letter, this character will be appended to the field
-value if the value is not empty.  For example, the format
-\"%-12:c\" leads to \"Diary: \" if the category is \"Diary\".  If
-the category is empty, no additional colon is inserted.
+If there is punctuation or whitespace character just before the final
+format letter, this character will be appended to the field value if
+the value is not empty.  For example, the format \"%-12:c\" leads to
+\"Diary: \" if the category is \"Diary\".  If the category were be
+empty, no additional colon would be inserted.
 
 The default value for the agenda sublist is \"  %-12:c%?-12t% s\",
 which means:
@@ -1985,11 +1934,6 @@ When nil, `q' will kill the single agenda buffer."
           (message "Sticky agenda was %s"
                    (if org-agenda-sticky "enabled" "disabled"))))))
 
-(autoload 'org-toggle-sticky-agenda "org-agenda" "\
-Toggle `org-agenda-sticky'.
-
-\(fn &optional ARG)" t nil)
-
 (defvar org-agenda-buffer nil
   "Agenda buffer currently being generated.")
 
@@ -2363,7 +2307,7 @@ The following commands are available:
      ["Holidays" org-agenda-holidays (org-agenda-check-type nil 'agenda 'timeline)]
      ["Convert" org-agenda-convert-date (org-agenda-check-type nil 'agenda 'timeline)]
      "--"
-     ["Create iCalendar File" org-icalendar-combine-agenda-files t])
+     ["Create iCalendar File" org-export-icalendar-combine-agenda-files t])
     "--"
     ["Undo Remote Editing" org-agenda-undo org-agenda-undo-list]
     "--"
@@ -2448,8 +2392,6 @@ Here are the available contexts definitions:
       in-mode: command displayed only in matching modes
   not-in-file: command not displayed in matching files
   not-in-mode: command not displayed in matching modes
-    in-buffer: command displayed only in matching buffers
-not-in-buffer: command not displayed in matching buffers
    [function]: a custom function taking no argument
 
 If you define several checks, the agenda command will be
@@ -2475,85 +2417,11 @@ duplicates.)"
                                      (choice
                                       (const :tag "In file" in-file)
                                       (const :tag "Not in file" not-in-file)
-                                      (const :tag "In buffer" in-buffer)
-                                      (const :tag "Not in buffer" not-in-buffer)
                                       (const :tag "In mode" in-mode)
                                       (const :tag "Not in mode" not-in-mode))
                                      (regexp))
                                (function :tag "Custom function"))))))
 
-(defcustom org-agenda-max-entries nil
-  "Maximum number of entries to display in an agenda.
-This can be nil (no limit) or an integer or an alist of agenda
-types with an associated number of entries to display in this
-type."
-  :version "24.3"
-  :group 'org-agenda-custom-commands
-  :type '(choice (symbol :tag "No limit" nil)
-                (integer :tag "Max number of entries")
-                (repeat
-                 (cons (choice :tag "Agenda type"
-                               (const agenda)
-                               (const todo)
-                               (const tags)
-                               (const search)
-                               (const timeline))
-                       (integer :tag "Max number of entries")))))
-
-(defcustom org-agenda-max-todos nil
-  "Maximum number of TODOs to display in an agenda.
-This can be nil (no limit) or an integer or an alist of agenda
-types with an associated number of entries to display in this
-type."
-  :version "24.3"
-  :group 'org-agenda-custom-commands
-  :type '(choice (symbol :tag "No limit" nil)
-                (integer :tag "Max number of entries")
-                (repeat
-                 (cons (choice :tag "Agenda type"
-                               (const agenda)
-                               (const todo)
-                               (const tags)
-                               (const search)
-                               (const timeline))
-                       (integer :tag "Max number of entries")))))
-
-(defcustom org-agenda-max-tags nil
-  "Maximum number of tagged entries to display in an agenda.
-This can be nil (no limit) or an integer or an alist of agenda
-types with an associated number of entries to display in this
-type."
-  :version "24.3"
-  :group 'org-agenda-custom-commands
-  :type '(choice (symbol :tag "No limit" nil)
-                (integer :tag "Max number of entries")
-                (repeat
-                 (cons (choice :tag "Agenda type"
-                               (const agenda)
-                               (const todo)
-                               (const tags)
-                               (const search)
-                               (const timeline))
-                       (integer :tag "Max number of entries")))))
-
-(defcustom org-agenda-max-effort nil
-  "Maximum cumulated effort duration for the agenda.
-This can be nil (no limit) or a number of minutes (as an integer)
-or an alist of agenda types with an associated number of minutes
-to limit entries to in this type."
-  :version "24.3"
-  :group 'org-agenda-custom-commands
-  :type '(choice (symbol :tag "No limit" nil)
-                (integer :tag "Max number of entries")
-                (repeat
-                 (cons (choice :tag "Agenda type"
-                               (const agenda)
-                               (const todo)
-                               (const tags)
-                               (const search)
-                               (const timeline))
-                       (integer :tag "Max number of entries")))))
-
 (defvar org-keys nil)
 (defvar org-match nil)
 ;;;###autoload
@@ -2741,43 +2609,6 @@ Pressing `<' twice means to restrict to the current subtree or region
        ((equal org-keys "!") (customize-variable 'org-stuck-projects))
        (t (error "Invalid agenda key"))))))
 
-(autoload 'org-agenda "org-agenda" "\
-Dispatch agenda commands to collect entries to the agenda buffer.
-Prompts for a command to execute.  Any prefix arg will be passed
-on to the selected command.  The default selections are:
-
-a     Call `org-agenda-list' to display the agenda for current day or week.
-t     Call `org-todo-list' to display the global todo list.
-T     Call `org-todo-list' to display the global todo list, select only
-      entries with a specific TODO keyword (the user gets a prompt).
-m     Call `org-tags-view' to display headlines with tags matching
-      a condition  (the user is prompted for the condition).
-M     Like `m', but select only TODO entries, no ordinary headlines.
-L     Create a timeline for the current buffer.
-e     Export views to associated files.
-s     Search entries for keywords.
-S     Search entries for keywords, only with TODO keywords.
-/     Multi occur across all agenda files and also files listed
-      in `org-agenda-text-search-extra-files'.
-<     Restrict agenda commands to buffer, subtree, or region.
-      Press several times to get the desired effect.
->     Remove a previous restriction.
-#     List \"stuck\" projects.
-!     Configure what \"stuck\" means.
-C     Configure custom agenda commands.
-
-More commands can be added by configuring the variable
-`org-agenda-custom-commands'.  In particular, specific tags and TODO keyword
-searches can be pre-defined in this way.
-
-If the current buffer is in Org-mode and visiting a file, you can also
-first press `<' once to indicate that the agenda should be temporarily
-\(until the next use of \\[org-agenda]) restricted to the current file.
-Pressing `<' twice means to restrict to the current subtree or region
-\(if active).
-
-\(fn &optional ARG ORG-KEYS RESTRICTION)" t nil)
-
 (defun org-agenda-append-agenda ()
   "Append another agenda view to the current one.
 This function allows interactive building of block agendas.
@@ -3073,17 +2904,6 @@ before running the agenda command."
   (set-buffer org-agenda-buffer-name)
   (princ (buffer-string)))
 
-(autoload 'org-batch-agenda "org-agenda" "\
-Run an agenda command in batch mode and send the result to STDOUT.
-If CMD-KEY is a string of length 1, it is used as a key in
-`org-agenda-custom-commands' and triggers this command.  If it is a
-longer string it is used as a tags/todo match string.
-Parameters are alternating variable names and values that will be bound
-before running the agenda command.
-
-\(fn CMD-KEY &rest PARAMETERS)" nil t)
-(def-edebug-spec org-batch-agenda (form &rest sexp))
-
 (defvar org-agenda-info nil)
 
 ;;;###autoload
@@ -3141,44 +2961,6 @@ agenda-day   The day in the agenda where this is listed"
                    ","))
        (princ "\n")))))
 
-(autoload 'org-batch-agenda-csv "org-agenda" "\
-Run an agenda command in batch mode and send the result to STDOUT.
-If CMD-KEY is a string of length 1, it is used as a key in
-`org-agenda-custom-commands' and triggers this command.  If it is a
-longer string it is used as a tags/todo match string.
-Parameters are alternating variable names and values that will be bound
-before running the agenda command.
-
-The output gives a line for each selected agenda item.  Each
-item is a list of comma-separated values, like this:
-
-category,head,type,todo,tags,date,time,extra,priority-l,priority-n
-
-category     The category of the item
-head         The headline, without TODO kwd, TAGS and PRIORITY
-type         The type of the agenda entry, can be
-                todo               selected in TODO match
-                tagsmatch          selected in tags match
-                diary              imported from diary
-                deadline           a deadline on given date
-                scheduled          scheduled on given date
-                timestamp          entry has timestamp on given date
-                closed             entry was closed on given date
-                upcoming-deadline  warning about deadline
-                past-scheduled     forwarded scheduled item
-                block              entry has date block including g. date
-todo         The todo keyword, if any
-tags         All tags including inherited ones, separated by colons
-date         The relevant date, like 2007-2-14
-time         The time, like 15:00-16:50
-extra        Sting with extra planning info
-priority-l   The priority letter if any was given
-priority-n   The computed numerical priority
-agenda-day   The day in the agenda where this is listed
-
-\(fn CMD-KEY &rest PARAMETERS)" nil t)
-(def-edebug-spec org-batch-agenda-csv (form &rest sexp))
-
 (defun org-fix-agenda-info (props)
   "Make sure all properties on an agenda item have a canonical form.
 This ensures the export commands can easily use it."
@@ -3226,11 +3008,6 @@ This ensures the export commands can easily use it."
   (interactive)
   (eval (list 'org-batch-store-agenda-views)))
 
-(autoload 'org-store-agenda-views "org-agenda" "\
-
-
-\(fn &rest PARAMETERS)" t nil)
-
 ;;;###autoload
 (defmacro org-batch-store-agenda-views (&rest parameters)
   "Run all custom agenda commands that have a file argument."
@@ -3266,12 +3043,6 @@ This ensures the export commands can easily use it."
          (and (get-buffer bufname)
               (kill-buffer bufname)))))))
 
-(autoload 'org-batch-store-agenda-views "org-agenda" "\
-Run all custom agenda commands that have a file argument.
-
-\(fn &rest PARAMETERS)" nil t)
-(def-edebug-spec org-batch-store-agenda-views (&rest sexp))
-
 (defvar org-agenda-current-span nil
   "The current span used in the agenda view.") ; local variable in the agenda buffer
 (defun org-agenda-mark-header-line (pos)
@@ -3289,12 +3060,10 @@ Run all custom agenda commands that have a file argument.
 (defun org-agenda-write (file &optional open nosettings agenda-bufname)
   "Write the current buffer (an agenda view) as a file.
 Depending on the extension of the file name, plain text (.txt),
-HTML (.html or .htm), PDF (.pdf) or Postscript (.ps) is produced.
+HTML (.html or .htm) or Postscript (.ps) is produced.
 If the extension is .ics, run icalendar export over all files used
 to construct the agenda and limit the export to entries listed in the
 agenda now.
-If the extension is .org, collect all subtrees corresponding to the
-agenda entries and add them in an .org file.
 With prefix argument OPEN, open the new file immediately.
 If NOSETTINGS is given, do not scope the settings of
 `org-agenda-exporter-settings' into the export commands.  This is used when
@@ -3308,7 +3077,7 @@ If AGENDA-BUFFER-NAME, use this as the buffer name for the agenda to write."
     '(save-excursion
        (save-window-excursion
         (org-agenda-mark-filtered-text)
-        (let ((bs (copy-sequence (buffer-string))) beg content)
+        (let ((bs (copy-sequence (buffer-string))) beg)
           (org-agenda-unmark-filtered-text)
           (with-temp-buffer
             (rename-buffer org-agenda-write-buffer-name t)
@@ -3324,25 +3093,6 @@ If AGENDA-BUFFER-NAME, use this as the buffer name for the agenda to write."
             (cond
              ((org-bound-and-true-p org-mobile-creating-agendas)
               (org-mobile-write-agenda-for-mobile file))
-             ((string-match "\\.org\\'" file)
-              (let (content p m message-log-max)
-                (goto-char (point-min))
-                (while (setq p (next-single-property-change (point) 'org-hd-marker nil))
-                  (goto-char p)
-                  (setq m (get-text-property (point) 'org-hd-marker))
-                  (when m
-                    (push (save-excursion
-                            (set-buffer (marker-buffer m))
-                            (goto-char m)
-                            (org-copy-subtree 1 nil t t)
-                            org-subtree-clip)
-                          content)))
-                (find-file file)
-                (erase-buffer)
-                (mapcar (lambda (s) (org-paste-subtree 1 s)) (reverse content))
-                (write-file file)
-                (kill-buffer (current-buffer))
-                (message "Org file written to %s" file)))
              ((string-match "\\.html?\\'" file)
               (require 'htmlize)
               (set-buffer (htmlize-buffer (current-buffer)))
@@ -3370,8 +3120,14 @@ If AGENDA-BUFFER-NAME, use this as the buffer name for the agenda to write."
               (delete-file (concat (file-name-sans-extension file) ".ps"))
               (message "PDF written to %s" file))
              ((string-match "\\.ics\\'" file)
-              (require 'ox-icalendar)
-              (org-icalendar-export-current-agenda (expand-file-name file)))
+              (require 'org-icalendar)
+              (let ((org-agenda-marker-table
+                     (org-create-marker-find-array
+                      (org-agenda-collect-markers)))
+                    (org-icalendar-verify-function 'org-check-agenda-marker-table)
+                    (org-combined-agenda-icalendar-file file))
+                (apply 'org-export-icalendar 'combine
+                       (org-agenda-files nil 'ifmode))))
              (t
               (let ((bs (buffer-string)))
                 (find-file file)
@@ -3764,7 +3520,10 @@ generating a new one."
 
 (defun org-agenda-mark-clocking-task ()
   "Mark the current clock entry in the agenda if it is present."
-  (org-agenda-unmark-clocking-task)
+  (mapc (lambda (o)
+         (if (eq (overlay-get o 'type) 'org-agenda-clocking)
+             (delete-overlay o)))
+       (overlays-in (point-min) (point-max)))
   (when (marker-buffer org-clock-hd-marker)
     (save-excursion
       (goto-char (point-min))
@@ -3779,13 +3538,6 @@ generating a new one."
            (overlay-put ov 'help-echo
                         "The clock is running in this item")))))))
 
-(defun org-agenda-unmark-clocking-task ()
-  "Unmark the current clocking task."
-  (mapc (lambda (o)
-         (if (eq (overlay-get o 'type) 'org-agenda-clocking)
-             (delete-overlay o)))
-       (overlays-in (point-min) (point-max))))
-
 (defun org-agenda-fontify-priorities ()
   "Make highest priority lines bold, and lowest italic."
   (interactive)
@@ -3793,7 +3545,8 @@ generating a new one."
                        (delete-overlay o)))
        (overlays-in (point-min) (point-max)))
   (save-excursion
-    (let (b e p ov h l)
+    (let ((inhibit-read-only t)
+         b e p ov h l)
       (goto-char (point-min))
       (while (re-search-forward "\\[#\\(.\\)\\]" nil t)
        (setq h (or (get-char-property (point) 'org-highest-priority)
@@ -3808,16 +3561,15 @@ generating a new one."
              ov (make-overlay b e))
        (overlay-put
         ov 'face
-        (cons (cond ((org-face-from-face-or-color
-                      'priority nil
-                      (cdr (assoc p org-priority-faces))))
-                    ((and (listp org-agenda-fontify-priorities)
-                          (org-face-from-face-or-color
-                           'priority nil
-                           (cdr (assoc p org-agenda-fontify-priorities)))))
-                    ((equal p l) 'italic)
-                    ((equal p h) 'bold))
-              'org-priority))
+        (cond ((org-face-from-face-or-color
+                'priority nil
+                (cdr (assoc p org-priority-faces))))
+              ((and (listp org-agenda-fontify-priorities)
+                    (org-face-from-face-or-color
+                     'priority nil
+                     (cdr (assoc p org-agenda-fontify-priorities)))))
+              ((equal p l) 'italic)
+              ((equal p h) 'bold)))
        (overlay-put ov 'org-type 'org-priority)))))
 
 (defun org-agenda-dim-blocked-tasks (&optional invisible)
@@ -4063,7 +3815,7 @@ dates."
              (put-text-property s (1- (point)) 'org-agenda-date-header t)
              (if (equal d today)
                  (put-text-property s (1- (point)) 'org-today t))
-             (and rtn (insert (org-agenda-finalize-entries rtn 'timeline) "\n"))
+             (and rtn (insert (org-agenda-finalize-entries rtn) "\n"))
              (put-text-property s (1- (point)) 'day d)))))
     (goto-char (point-min))
     (goto-char (or (text-property-any (point-min) (point-max) 'org-today t)
@@ -4122,8 +3874,7 @@ When EMPTY is non-nil, also include days without any entries."
 
 (defvar org-agenda-start-day nil  ; dynamically scoped parameter
   "Start day for the agenda view.
-Custom commands can set this variable in the options section.
-See the docstring of `org-read-date' on allowed values.")
+Custom commands can set this variable in the options section.")
 (defvar org-starting-day nil) ; local variable in the agenda buffer
 (defvar org-arg-loc nil) ; local variable
 
@@ -4305,7 +4056,7 @@ given in `org-agenda-start-on-weekday'."
              (setq rtnall
                    (org-agenda-add-time-grid-maybe rtnall ndays todayp))
              (if rtnall (insert ;; all entries
-                         (org-agenda-finalize-entries rtnall 'agenda)
+                         (org-agenda-finalize-entries rtnall)
                          "\n"))
              (put-text-property s (1- (point)) 'day d)
              (put-text-property s (1- (point)) 'org-day-cnt day-cnt))))
@@ -4350,20 +4101,6 @@ given in `org-agenda-start-on-weekday'."
       (setq buffer-read-only t)
       (message ""))))
 
-(autoload 'org-agenda-list "org-agenda" "\
-Produce a daily/weekly view from all files in variable `org-agenda-files'.
-The view will be for the current day or week, but from the overview buffer
-you will be able to go to other days/weeks.
-
-With a numeric prefix argument in an interactive call, the agenda will
-span ARG days.  Lisp programs should instead specify SPAN to change
-the number of days.  SPAN defaults to `org-agenda-span'.
-
-START-DAY defaults to TODAY, or to the most recent match for the weekday
-given in `org-agenda-start-on-weekday'.
-
-\(fn &optional ARG START-DAY SPAN)" t nil)
-
 (defun org-agenda-ndays-to-span (n)
   "Return a span symbol for a span of N days, or N if none matches."
   (cond ((symbolp n) n)
@@ -4469,7 +4206,7 @@ in `org-agenda-text-search-extra-files'."
         (full-words org-agenda-search-view-force-full-words)
         (org-agenda-text-search-extra-files org-agenda-text-search-extra-files)
         regexp rtn rtnall files file pos inherited-tags
-        marker category category-pos level tags c neg re boolean
+        marker category category-pos tags c neg re boolean
         ee txt beg end words regexps+ regexps- hdl-only buffer beg1 str)
     (unless (and (not edit-at)
                 (stringp string)
@@ -4597,23 +4334,10 @@ in `org-agenda-text-search-extra-files'."
                    (goto-char (max (point-min) (1- (point))))
                    (while (re-search-forward regexp nil t)
                      (org-back-to-heading t)
-                     (while (and org-agenda-search-view-max-outline-level
-                                 (> (org-reduced-level (org-outline-level))
-                                    org-agenda-search-view-max-outline-level)
-                                 (forward-line -1)
-                                 (outline-back-to-heading t)))
                      (skip-chars-forward "* ")
                      (setq beg (point-at-bol)
                            beg1 (point)
-                           end (progn
-                                 (outline-next-heading)
-                                 (while (and org-agenda-search-view-max-outline-level
-                                             (> (org-reduced-level (org-outline-level))
-                                                org-agenda-search-view-max-outline-level)
-                                             (forward-line 1)
-                                             (outline-next-heading)))
-                                 (point)))
-
+                           end (progn (outline-next-heading) (point)))
                      (catch :skip
                        (goto-char beg)
                        (org-agenda-skip)
@@ -4634,7 +4358,6 @@ in `org-agenda-text-search-extra-files'."
                        (goto-char beg)
                        (setq marker (org-agenda-new-marker (point))
                              category (org-get-category)
-                             level (make-string (org-reduced-level (org-outline-level)) ? )
                              category-pos (get-text-property (point) 'org-category-position)
                              inherited-tags
                              (or (eq org-agenda-show-inherited-tags 'always)
@@ -4648,11 +4371,10 @@ in `org-agenda-text-search-extra-files'."
                                   ""
                                   (buffer-substring-no-properties
                                    beg1 (point-at-eol))
-                                  level category tags t))
+                                  category tags t))
                        (org-add-props txt props
                          'org-marker marker 'org-hd-marker marker
                          'org-todo-regexp org-todo-regexp
-                         'level level
                          'org-complex-heading-regexp org-complex-heading-regexp
                          'priority 1000 'org-category category
                          'org-category-position category-pos
@@ -4677,7 +4399,7 @@ in `org-agenda-text-search-extra-files'."
                               (list 'face 'org-agenda-structure))))
       (org-agenda-mark-header-line (point-min))
       (when rtnall
-       (insert (org-agenda-finalize-entries rtnall 'search) "\n"))
+       (insert (org-agenda-finalize-entries rtnall) "\n"))
       (goto-char (point-min))
       (or org-agenda-multi (org-agenda-fit-window-to-buffer))
       (add-text-properties (point-min) (point-max)
@@ -4688,66 +4410,8 @@ in `org-agenda-text-search-extra-files'."
       (org-agenda-finalize)
       (setq buffer-read-only t))))
 
-(autoload 'org-search-view "org-agenda" "\
-Show all entries that contain a phrase or words or regular expressions.
-
-With optional prefix argument TODO-ONLY, only consider entries that are
-TODO entries.  The argument STRING can be used to pass a default search
-string into this function.  If EDIT-AT is non-nil, it means that the
-user should get a chance to edit this string, with cursor at position
-EDIT-AT.
-
-The search string can be viewed either as a phrase that should be found as
-is, or it can be broken into a number of snippets, each of which must match
-in a Boolean way to select an entry.  The default depends on the variable
-`org-agenda-search-view-always-boolean'.
-Even if this is turned off (the default) you can always switch to
-Boolean search dynamically by preceding the first word with  \"+\" or \"-\".
-
-The default is a direct search of the whole phrase, where each space in
-the search string can expand to an arbitrary amount of whitespace,
-including newlines.
-
-If using a Boolean search, the search string is split on whitespace and
-each snippet is searched separately, with logical AND to select an entry.
-Words prefixed with a minus must *not* occur in the entry.  Words without
-a prefix or prefixed with a plus must occur in the entry.  Matching is
-case-insensitive.  Words are enclosed by word delimiters (i.e. they must
-match whole words, not parts of a word) if
-`org-agenda-search-view-force-full-words' is set (default is nil).
-
-Boolean search snippets enclosed by curly braces are interpreted as
-regular expressions that must or (when preceded with \"-\") must not
-match in the entry.  Snippets enclosed into double quotes will be taken
-as a whole, to include whitespace.
-
-- If the search string starts with an asterisk, search only in headlines.
-- If (possibly after the leading star) the search string starts with an
-  exclamation mark, this also means to look at TODO entries only, an effect
-  that can also be achieved with a prefix argument.
-- If (possibly after star and exclamation mark) the search string starts
-  with a colon, this will mean that the (non-regexp) snippets of the
-  Boolean search must match as full words.
-
-This command searches the agenda files, and in addition the files listed
-in `org-agenda-text-search-extra-files'.
-
-\(fn &optional TODO-ONLY STRING EDIT-AT)" t nil)
-
 ;;; Agenda TODO list
 
-(defun org-agenda-propertize-selected-todo-keywords (keywords)
-  "Use `org-todo-keyword-faces' for the selected todo KEYWORDS."
-  (concat
-   (if (or (equal keywords "ALL") (not keywords))
-       (propertize "ALL" 'face 'warning)
-     (mapconcat
-      (lambda (kw)
-        (propertize kw 'face (org-get-todo-face kw)))
-      (org-split-string keywords "|")
-      "|"))
-   "\n"))
-
 (defvar org-select-this-todo-keyword nil)
 (defvar org-last-arg nil)
 
@@ -4808,8 +4472,9 @@ for a keyword.  A numeric prefix directly selects the Nth keyword in
                                   (concat "ToDo: "
                                           (or org-select-this-todo-keyword "ALL"))))
        (org-agenda-mark-header-line (point-min))
-       (insert (org-agenda-propertize-selected-todo-keywords
-                org-select-this-todo-keyword))
+       (setq pos (point))
+       (insert (or org-select-this-todo-keyword "ALL") "\n")
+       (add-text-properties pos (1- (point)) (list 'face 'org-warning))
        (setq pos (point))
        (unless org-agenda-multi
          (insert "Available with `N r': (0)[ALL]")
@@ -4824,7 +4489,7 @@ for a keyword.  A numeric prefix directly selects the Nth keyword in
        (add-text-properties pos (1- (point)) (list 'face 'org-agenda-structure)))
       (org-agenda-mark-header-line (point-min))
       (when rtnall
-       (insert (org-agenda-finalize-entries rtnall 'todo) "\n"))
+       (insert (org-agenda-finalize-entries rtnall) "\n"))
       (goto-char (point-min))
       (or org-agenda-multi (org-agenda-fit-window-to-buffer))
       (add-text-properties (point-min) (point-max)
@@ -4835,15 +4500,6 @@ for a keyword.  A numeric prefix directly selects the Nth keyword in
       (org-agenda-finalize)
       (setq buffer-read-only t))))
 
-(autoload 'org-todo-list "org-agenda" "\
-Show all (not done) TODO entries from all agenda file in a single list.
-The prefix arg can be used to select a specific TODO keyword and limit
-the list to these.  When using \\[universal-argument], you will be prompted
-for a keyword.  A numeric prefix directly selects the Nth keyword in
-`org-todo-keywords-1'.
-
-\(fn &optional ARG)" t nil)
-
 ;;; Agenda tags match
 
 ;;;###autoload
@@ -4918,7 +4574,7 @@ The prefix arg TODO-ONLY limits the search to TODO entries."
        (add-text-properties pos (1- (point)) (list 'face 'org-agenda-structure)))
       (org-agenda-mark-header-line (point-min))
       (when rtnall
-       (insert (org-agenda-finalize-entries rtnall 'tags) "\n"))
+       (insert (org-agenda-finalize-entries rtnall) "\n"))
       (goto-char (point-min))
       (or org-agenda-multi (org-agenda-fit-window-to-buffer))
       (add-text-properties (point-min) (point-max)
@@ -4929,12 +4585,6 @@ The prefix arg TODO-ONLY limits the search to TODO entries."
       (org-agenda-finalize)
       (setq buffer-read-only t))))
 
-(autoload 'org-tags-view "org-agenda" "\
-Show all headlines for all `org-agenda-files' matching a TAGS criterion.
-The prefix arg TODO-ONLY limits the search to TODO entries.
-
-\(fn &optional TODO-ONLY MATCH)" t nil)
-
 ;;; Agenda Finding stuck projects
 
 (defvar org-agenda-skip-regexp nil
@@ -5163,14 +4813,6 @@ of what a project is and how to check if it stuck, customize the variable
       (setq org-agenda-redo-command
            `(org-agenda-list-stuck-projects ,current-prefix-arg)))))
 
-(autoload 'org-agenda-list-stuck-projects "org-agenda" "\
-Create agenda view for projects that are stuck.
-Stuck projects are project that have no next actions.  For the definitions
-of what a project is and how to check if it stuck, customize the variable
-`org-stuck-projects'.
-
-\(fn &rest IGNORE)" t nil)
-
 ;;; Diary integration
 
 (defvar org-disable-agenda-to-diary nil)          ;Dynamically-scoped param.
@@ -5221,7 +4863,7 @@ of what a project is and how to check if it stuck, customize the variable
       (setq entries
            (mapcar
             (lambda (x)
-              (setq x (org-agenda-format-item "" x nil "Diary" nil 'time))
+              (setq x (org-agenda-format-item "" x "Diary" nil 'time))
               ;; Extend the text properties to the beginning of the line
               (org-add-props x (text-properties-at (1- (length x)) x)
                 'type "diary" 'date date 'face 'org-agenda-diary))
@@ -5346,40 +4988,8 @@ function from a program - use `org-agenda-get-day-entries' instead."
     (while (setq file (pop files))
       (setq rtn (apply 'org-agenda-get-day-entries file date args))
       (setq results (append results rtn)))
-    (when results
-      (setq results
-           (mapcar (lambda (i) (replace-regexp-in-string
-                                org-bracket-link-regexp "\\3" i)) results))
-      (concat (org-agenda-finalize-entries results) "\n"))))
-
-(autoload 'org-diary "org-agenda" "\
-Return diary information from org files.
-This function can be used in a \"sexp\" diary entry in the Emacs calendar.
-It accesses org files and extracts information from those files to be
-listed in the diary.  The function accepts arguments specifying what
-items should be listed.  For a list of arguments allowed here, see the
-variable `org-agenda-entry-types'.
-
-The call in the diary file should look like this:
-
-   &%%(org-diary) ~/path/to/some/orgfile.org
-
-Use a separate line for each org file to check.  Or, if you omit the file name,
-all files listed in `org-agenda-files' will be checked automatically:
-
-   &%%(org-diary)
-
-If you don't give any arguments (as in the example above), the default
-arguments (:deadline :scheduled :timestamp :sexp) are used.
-So the example above may also be written as
-
-   &%%(org-diary :deadline :timestamp :sexp :scheduled)
-
-The function expects the lisp variables `entry' and `date' to be provided
-by the caller, because this is how the calendar works.  Don't use this
-function from a program - use `org-agenda-get-day-entries' instead.
-
-\(fn &rest ARGS)" nil nil)
+    (if results
+       (concat (org-agenda-finalize-entries results) "\n"))))
 
 ;;; Agenda entry finders
 
@@ -5438,13 +5048,7 @@ the documentation of `org-diary'."
                  (setq results (append results rtn))))))))
        results))))
 
-(defsubst org-em (x y list)
-  "Is X or Y a member of LIST?"
-  (or (memq x list) (memq y list)))
-
 (defvar org-heading-keyword-regexp-format) ; defined in org.el
-(defvar org-agenda-sorting-strategy-selected nil)
-
 (defun org-agenda-get-todos ()
   "Return the TODO information for agenda display."
   (let* ((props (list 'face nil
@@ -5469,7 +5073,7 @@ the documentation of `org-diary'."
                                               "|")
                                              "\\|") "\\)"))
                          (t org-not-done-regexp))))
-        marker priority category category-pos level tags todo-state ts-date ts-date-type
+        marker priority category category-pos tags todo-state
         ee txt beg end inherited-tags)
     (goto-char (point-min))
     (while (re-search-forward regexp nil t)
@@ -5485,33 +5089,6 @@ the documentation of `org-diary'."
        (goto-char (match-beginning 2))
        (setq marker (org-agenda-new-marker (match-beginning 0))
              category (org-get-category)
-             ts-date (let (ts)
-                       (save-match-data
-                         (cond ((org-em 'scheduled-up 'scheduled-down
-                                        org-agenda-sorting-strategy-selected)
-                                (setq ts (org-entry-get (point) "SCHEDULED")
-                                      ts-date-type " scheduled"))
-                               ((org-em 'deadline-up 'deadline-down
-                                        org-agenda-sorting-strategy-selected)
-                                (setq ts (org-entry-get (point) "DEADLINE")
-                                      ts-date-type " deadline"))
-                               ((org-em 'ts-up 'ts-down
-                                        org-agenda-sorting-strategy-selected)
-                                (setq ts (org-entry-get (point) "TIMESTAMP")
-                                      ts-date-type " timestamp"))
-                               ((org-em 'tsia-up 'tsia-down
-                                        org-agenda-sorting-strategy-selected)
-                                (setq ts (org-entry-get (point) "TIMESTAMP_IA")
-                                      ts-date-type " timestamp_ia"))
-                               ((org-em 'timestamp-up 'timestamp-down
-                                        org-agenda-sorting-strategy-selected)
-                                (setq ts (or (org-entry-get (point) "SCHEDULED")
-                                             (org-entry-get (point) "DEADLINE")
-                                             (org-entry-get (point) "TIMESTAMP")
-                                             (org-entry-get (point) "TIMESTAMP_IA"))
-                                      ts-date-type ""))
-                               (t (setq ts-date-type "")))
-                         (when ts (ignore-errors (org-time-string-to-absolute ts)))))
              category-pos (get-text-property (point) 'org-category-position)
              txt (org-trim
                   (buffer-substring (match-beginning 2) (match-end 0)))
@@ -5523,17 +5100,14 @@ the documentation of `org-diary'."
                       (or (eq org-agenda-use-tag-inheritance t)
                           (memq 'todo org-agenda-use-tag-inheritance))))
              tags (org-get-tags-at nil (not inherited-tags))
-             level (make-string (org-reduced-level (org-outline-level)) ? )
-             txt (org-agenda-format-item "" txt level category tags t)
+             txt (org-agenda-format-item "" txt category tags t)
              priority (1+ (org-get-priority txt))
              todo-state (org-get-todo-state))
        (org-add-props txt props
          'org-marker marker 'org-hd-marker marker
          'priority priority 'org-category category
-         'level level
-         'ts-date ts-date
          'org-category-position category-pos
-         'type (concat "todo" ts-date-type) 'todo-state todo-state)
+         'type "todo" 'todo-state todo-state)
        (push txt ee)
        (if org-agenda-todo-list-sublevels
            (goto-char (match-end 2))
@@ -5545,8 +5119,7 @@ the documentation of `org-diary'."
 This function is invoked if `org-agenda-todo-ignore-deadlines',
 `org-agenda-todo-ignore-scheduled' or
 `org-agenda-todo-ignore-timestamp' is set to an integer."
-  (let ((days (org-time-stamp-to-now
-              time org-agenda-todo-ignore-time-comparison-use-seconds)))
+  (let ((days (org-days-to-time time)))
     (if (>= n 0)
        (>= days n)
       (<= days n))))
@@ -5566,11 +5139,9 @@ This function is invoked if `org-agenda-todo-ignore-deadlines',
               (re-search-forward org-scheduled-time-regexp end t)
               (cond
                ((eq org-agenda-todo-ignore-scheduled 'future)
-                (> (org-time-stamp-to-now
-                    (match-string 1) org-agenda-todo-ignore-time-comparison-use-seconds) 0))
+                (> (org-days-to-time (match-string 1)) 0))
                ((eq org-agenda-todo-ignore-scheduled 'past)
-                (<= (org-time-stamp-to-now
-                     (match-string 1) org-agenda-todo-ignore-time-comparison-use-seconds) 0))
+                (<= (org-days-to-time (match-string 1)) 0))
                ((numberp org-agenda-todo-ignore-scheduled)
                 (org-agenda-todo-custom-ignore-p
                  (match-string 1) org-agenda-todo-ignore-scheduled))
@@ -5582,11 +5153,9 @@ This function is invoked if `org-agenda-todo-ignore-deadlines',
                ((eq org-agenda-todo-ignore-deadlines 'far)
                 (not (org-deadline-close (match-string 1))))
                ((eq org-agenda-todo-ignore-deadlines 'future)
-                (> (org-time-stamp-to-now
-                    (match-string 1) org-agenda-todo-ignore-time-comparison-use-seconds) 0))
+                (> (org-days-to-time (match-string 1)) 0))
                ((eq org-agenda-todo-ignore-deadlines 'past)
-                (<= (org-time-stamp-to-now
-                     (match-string 1) org-agenda-todo-ignore-time-comparison-use-seconds) 0))
+                (<= (org-days-to-time (match-string 1)) 0))
                ((numberp org-agenda-todo-ignore-deadlines)
                 (org-agenda-todo-custom-ignore-p
                  (match-string 1) org-agenda-todo-ignore-deadlines))
@@ -5609,21 +5178,14 @@ This function is invoked if `org-agenda-todo-ignore-deadlines',
                   (when (re-search-forward org-ts-regexp nil t)
                     (cond
                      ((eq org-agenda-todo-ignore-timestamp 'future)
-                      (> (org-time-stamp-to-now
-                          (match-string 1) org-agenda-todo-ignore-time-comparison-use-seconds) 0))
+                      (> (org-days-to-time (match-string 1)) 0))
                      ((eq org-agenda-todo-ignore-timestamp 'past)
-                      (<= (org-time-stamp-to-now
-                           (match-string 1) org-agenda-todo-ignore-time-comparison-use-seconds) 0))
+                      (<= (org-days-to-time (match-string 1)) 0))
                      ((numberp org-agenda-todo-ignore-timestamp)
                       (org-agenda-todo-custom-ignore-p
                        (match-string 1) org-agenda-todo-ignore-timestamp))
                      (t))))))))))
 
-(autoload 'org-agenda-check-for-timestamp-as-reason-to-ignore-todo-item "org-agenda" "\
-Do we have a reason to ignore this TODO entry because it has a time stamp?
-
-\(fn &optional END)" nil nil)
-
 (defun org-agenda-get-timestamps (&optional deadline-results)
   "Return the date stamp information for agenda display."
   (let* ((props (list 'face 'org-agenda-calendar-event
@@ -5655,9 +5217,9 @@ Do we have a reason to ignore this TODO entry because it has a time stamp?
           "\\|\\(<[0-9]+-[0-9]+-[0-9]+[^>\n]+?\\+[0-9]+[hdwmy]>\\)"
           "\\|\\(<%%\\(([^>\n]+)\\)>\\)"))
         marker hdmarker deadlinep scheduledp clockp closedp inactivep
-        donep tmp priority category category-pos level ee txt timestr tags
+        donep tmp priority category category-pos ee txt timestr tags
         b0 b3 e3 head todo-state end-of-match show-all warntime habitp
-        inherited-tags ts-date)
+        inherited-tags)
     (goto-char (point-min))
     (while (setq end-of-match (re-search-forward regexp nil t))
       (setq b0 (match-beginning 0)
@@ -5716,21 +5278,18 @@ Do we have a reason to ignore this TODO entry because it has a time stamp?
                      (and (eq org-agenda-show-inherited-tags t)
                           (or (eq org-agenda-use-tag-inheritance t)
                               (memq 'agenda org-agenda-use-tag-inheritance))))
-                 tags (org-get-tags-at nil (not inherited-tags))
-                 level (make-string (org-reduced-level (org-outline-level)) ? ))
+                 tags (org-get-tags-at nil (not inherited-tags)))
            (looking-at "\\*+[ \t]+\\([^\r\n]+\\)")
            (setq head (or (match-string 1) ""))
            (setq txt (org-agenda-format-item
                       (if inactivep org-agenda-inactive-leader nil)
-                      head level category tags timestr
+                      head category tags timestr
                       remove-re habitp)))
          (setq priority (org-get-priority txt))
-         (org-add-props txt props 'priority priority
-                        'org-marker marker 'org-hd-marker hdmarker
+         (org-add-props txt props
+           'org-marker marker 'org-hd-marker hdmarker)
+         (org-add-props txt nil 'priority priority
                         'org-category category 'date date
-                        'level level
-                        'ts-date
-                        (ignore-errors (org-time-string-to-absolute timestr))
                         'org-category-position category-pos
                         'todo-state todo-state
                         'warntime warntime
@@ -5750,7 +5309,7 @@ Do we have a reason to ignore this TODO entry because it has a time stamp?
                      (format "mouse-2 or RET jump to org file %s"
                              (abbreviate-file-name buffer-file-name))))
         (regexp "^&?%%(")
-        marker category extra category-pos level ee txt tags entry
+        marker category extra category-pos ee txt tags entry
         result beg b sexp sexp-entry todo-state warntime inherited-tags)
     (goto-char (point-min))
     (while (re-search-forward regexp nil t)
@@ -5767,7 +5326,6 @@ Do we have a reason to ignore this TODO entry because it has a time stamp?
        (setq result (org-diary-sexp-entry sexp sexp-entry date))
        (when result
          (setq marker (org-agenda-new-marker beg)
-               level (make-string (org-reduced-level (org-outline-level)) ? )
                category (org-get-category beg)
                category-pos (get-text-property beg 'org-category-position)
                inherited-tags
@@ -5792,11 +5350,13 @@ Do we have a reason to ignore this TODO entry because it has a time stamp?
            (if (string-match "\\S-" r)
                (setq txt r)
              (setq txt "SEXP entry returned empty string"))
-           (setq txt (org-agenda-format-item extra txt level category tags 'time))
-           (org-add-props txt props 'org-marker marker
+
+           (setq txt (org-agenda-format-item
+                      extra txt category tags 'time))
+           (org-add-props txt props 'org-marker marker)
+           (org-add-props txt nil
              'org-category category 'date date 'todo-state todo-state
              'org-category-position category-pos 'tags tags
-             'level level
              'type "sexp" 'warntime warntime)
            (push txt ee)))))
     (nreverse ee)))
@@ -5834,12 +5394,10 @@ DAYNAME is a number between 0 (Sunday) and 6 (Saturday).
 SKIP-WEEKS is any number of ISO weeks in the block period for which the
 item should be skipped.  If any of the SKIP-WEEKS arguments is the symbol
 `holidays', then any date that is known by the Emacs calendar to be a
-holiday will also be skipped.  If SKIP-WEEKS arguments are holiday strings,
-then those holidays will be skipped."
+holiday will also be skipped."
   (let* ((date1 (calendar-absolute-from-gregorian (list m1 d1 y1)))
         (date2 (calendar-absolute-from-gregorian (list m2 d2 y2)))
-        (d (calendar-absolute-from-gregorian date))
-        (h (when skip-weeks (calendar-check-holidays date))))
+        (d (calendar-absolute-from-gregorian date)))
     (and
      (<= date1 d)
      (<= d date2)
@@ -5848,8 +5406,8 @@ then those holidays will be skipped."
         (progn
           (require 'cal-iso)
           (not (member (car (calendar-iso-from-absolute d)) skip-weeks))))
-     (not (or (and h (memq 'holidays skip-weeks))
-             (delq nil (mapcar (lambda(g) (member g skip-weeks)) h))))
+     (not (and (memq 'holidays skip-weeks)
+              (calendar-check-holidays date)))
      entry)))
 
 (defun org-diary-class (m1 d1 y1 m2 d2 y2 dayname &rest skip-weeks)
@@ -5907,7 +5465,7 @@ please use `org-class' instead."
                            (list 0 0 0 (nth 1 date) (car date) (nth 2 date))))
                    1 11))))
         (org-agenda-search-headline-for-time nil)
-        marker hdmarker priority category category-pos level tags closedp
+        marker hdmarker priority category category-pos tags closedp
         statep clockp state ee txt extra timestr rest clocked inherited-tags)
     (goto-char (point-min))
     (while (re-search-forward regexp nil t)
@@ -5953,8 +5511,7 @@ please use `org-class' instead."
                      (and (eq org-agenda-show-inherited-tags t)
                           (or (eq org-agenda-use-tag-inheritance t)
                               (memq 'todo org-agenda-use-tag-inheritance))))
-                 tags (org-get-tags-at nil (not inherited-tags))
-                 level (make-string (org-reduced-level (org-outline-level)) ? ))
+                 tags (org-get-tags-at nil (not inherited-tags)))
            (looking-at "\\*+[ \t]+\\([^\r\n]+\\)")
            (setq txt (match-string 1))
            (when extra
@@ -5967,13 +5524,12 @@ please use `org-class' instead."
                        (closedp "Closed:    ")
                        (statep (concat "State:     (" state ")"))
                        (t (concat "Clocked:   (" clocked  ")")))
-                      txt level category tags timestr)))
+                      txt category tags timestr)))
          (setq priority 100000)
          (org-add-props txt props
            'org-marker marker 'org-hd-marker hdmarker 'face 'org-agenda-done
            'priority priority 'org-category category
            'org-category-position category-pos
-           'level level
            'type "closed" 'date date
            'undone-face 'org-warning 'done-face 'org-agenda-done)
          (push txt ee))
@@ -5984,8 +5540,7 @@ please use `org-class' instead."
   "Add overlays, showing issues with clocking.
 See also the user option `org-agenda-clock-consistency-checks'."
   (interactive)
-  (let* ((org-time-clocksum-use-effort-durations nil)
-        (pl org-agenda-clock-consistency-checks)
+  (let* ((pl org-agenda-clock-consistency-checks)
         (re (concat "^[ \t]*"
                     org-clock-string
                     "[ \t]+"
@@ -6034,13 +5589,13 @@ See also the user option `org-agenda-clock-consistency-checks'."
         ((> dt (* 60 maxtime))
          ;; a very long clocking chunk
          (setq issue (format "Clocking interval is very long: %s"
-                             (org-minutes-to-clocksum-string
+                             (org-minutes-to-hh:mm-string
                               (floor (/ (float dt) 60.))))
                face (or (plist-get pl :long-face) face)))
         ((< dt (* 60 mintime))
          ;; a very short clocking chunk
          (setq issue (format "Clocking interval is very short: %s"
-                             (org-minutes-to-clocksum-string
+                             (org-minutes-to-hh:mm-string
                               (floor (/ (float dt) 60.))))
                face (or (plist-get pl :short-face) face)))
         ((and (> tlend 0) (< ts tlend))
@@ -6111,14 +5666,24 @@ See also the user option `org-agenda-clock-consistency-checks'."
                              (abbreviate-file-name buffer-file-name))))
         (regexp org-deadline-time-regexp)
         (todayp (org-agenda-todayp date)) ; DATE bound by calendar
-        (d1 (calendar-absolute-from-gregorian date)) ; DATE bound by calendar
-        d2 diff dfrac wdays pos pos1 category category-pos level
+        (d1 (calendar-absolute-from-gregorian date))  ; DATE bound by calendar
+        d2 diff dfrac wdays pos pos1 category category-pos
         tags suppress-prewarning ee txt head face s todo-state
-        show-all upcomingp donep timestr warntime inherited-tags ts-date)
+        show-all upcomingp donep timestr warntime inherited-tags)
     (goto-char (point-min))
     (while (re-search-forward regexp nil t)
+      (setq suppress-prewarning nil)
       (catch :skip
        (org-agenda-skip)
+       (when (and org-agenda-skip-deadline-prewarning-if-scheduled
+                  (save-match-data
+                    (string-match org-scheduled-time-regexp
+                                  (buffer-substring (point-at-bol)
+                                                    (point-at-eol)))))
+         (setq suppress-prewarning
+               (if (integerp org-agenda-skip-deadline-prewarning-if-scheduled)
+                   org-agenda-skip-deadline-prewarning-if-scheduled
+                 0)))
        (setq s (match-string 1)
              txt nil
              pos (1- (match-beginning 1))
@@ -6127,32 +5692,10 @@ See also the user option `org-agenda-clock-consistency-checks'."
                           (member todo-state
                                   org-agenda-repeating-timestamp-show-all))
              d2 (org-time-string-to-absolute
-                 s d1 'past show-all (current-buffer) pos)
-             diff (- d2 d1))
-       (setq suppress-prewarning
-             (let ((ds (and org-agenda-skip-deadline-prewarning-if-scheduled
-                            (let ((item (buffer-substring (point-at-bol)
-                                                          (point-at-eol))))
-                              (save-match-data
-                                (and (string-match
-                                      org-scheduled-time-regexp item)
-                                     (match-string 1 item)))))))
-               (cond
-                ((not ds) nil)
-                ;; The current item has a scheduled date (in ds), so
-                ;; evaluate its prewarning lead time.
-                ((integerp org-agenda-skip-deadline-prewarning-if-scheduled)
-                 ;; Use global prewarning-restart lead time.
-                 org-agenda-skip-deadline-prewarning-if-scheduled)
-                ((eq org-agenda-skip-deadline-prewarning-if-scheduled
-                     'pre-scheduled)
-                 ;; Set prewarning to no earlier than scheduled.
-                 (min (- d2 (org-time-string-to-absolute
-                             ds d1 'past show-all (current-buffer) pos))
-                      org-deadline-warning-days))
-                ;; Set prewarning to deadline.
-                (t 0))))
-       (setq wdays (if suppress-prewarning
+                 (match-string 1) d1 'past show-all
+                 (current-buffer) pos)
+             diff (- d2 d1)
+             wdays (if suppress-prewarning
                        (let ((org-deadline-warning-days suppress-prewarning))
                          (org-get-wdays s))
                      (org-get-wdays s))
@@ -6178,7 +5721,6 @@ See also the user option `org-agenda-clock-consistency-checks'."
                    (throw :skip nil)
                  (goto-char (match-end 0))
                  (setq pos1 (match-beginning 0))
-                 (setq level (make-string (org-reduced-level (org-outline-level)) ? ))
                  (setq inherited-tags
                        (or (eq org-agenda-show-inherited-tags 'always)
                            (and (listp org-agenda-show-inherited-tags)
@@ -6205,15 +5747,13 @@ See also the user option `org-agenda-clock-consistency-checks'."
                                    diff date)
                                 (format (nth 1 org-agenda-deadline-leaders)
                                         diff)))
-                            head level category tags
+                            head category tags
                             (if (not (= diff 0)) nil timestr)))))
              (when txt
                (setq face (org-agenda-deadline-face dfrac))
                (org-add-props txt props
                  'org-marker (org-agenda-new-marker pos)
                  'warntime warntime
-                 'level level
-                 'ts-date d2
                  'org-hd-marker (org-agenda-new-marker pos1)
                  'priority (+ (- diff)
                               (org-get-priority txt))
@@ -6254,10 +5794,9 @@ FRACTION is what fraction of the head-warning time has passed."
                                             0 'org-hd-marker a))
                                   (cons (marker-position mm) a)))
                  deadline-results))
-        d2 diff pos pos1 category category-pos level tags donep
+        d2 diff pos pos1 category category-pos tags donep
         ee txt head pastschedp todo-state face timestr s habitp show-all
-        did-habit-check-p warntime inherited-tags ts-date suppress-delay
-        ddays)
+        did-habit-check-p warntime inherited-tags)
     (goto-char (point-min))
     (while (re-search-forward regexp nil t)
       (catch :skip
@@ -6270,50 +5809,18 @@ FRACTION is what fraction of the head-warning time has passed."
                           (member todo-state
                                   org-agenda-repeating-timestamp-show-all))
              d2 (org-time-string-to-absolute
-                 s d1 'past show-all (current-buffer) pos)
+                 (match-string 1) d1 'past show-all
+                 (current-buffer) pos)
              diff (- d2 d1)
              warntime (get-text-property (point) 'org-appt-warntime))
        (setq pastschedp (and todayp (< diff 0)))
        (setq did-habit-check-p nil)
-       (setq suppress-delay
-             (let ((ds (and org-agenda-skip-scheduled-delay-if-deadline
-                            (let ((item (buffer-substring (point-at-bol) (point-at-eol))))
-                              (save-match-data
-                                (and (string-match
-                                      org-deadline-time-regexp item)
-                                     (match-string 1 item)))))))
-               (cond
-                ((not ds) nil)
-                ;; The current item has a deadline date (in ds), so
-                ;; evaluate its delay time.
-                ((integerp org-agenda-skip-scheduled-delay-if-deadline)
-                 ;; Use global delay time.
-                 (- org-agenda-skip-scheduled-delay-if-deadline))
-                ((eq org-agenda-skip-scheduled-delay-if-deadline
-                     'post-deadline)
-                 ;; Set delay to no later than deadline.
-                 (min (- d2 (org-time-string-to-absolute
-                             ds d1 'past show-all (current-buffer) pos))
-                      org-scheduled-delay-days))
-                (t 0))))
-       (setq ddays (if suppress-delay
-                       (let ((org-scheduled-delay-days suppress-delay))
-                         (org-get-wdays s t t))
-                     (org-get-wdays s t)))
-       ;; Use a delay of 0 when there is a repeater and the delay is
-       ;; of the form --3d
-       (when (and (save-match-data (string-match "--[0-9]+[hdwmy]" s))
-                  (< (org-time-string-to-absolute s)
-                     (org-time-string-to-absolute
-                      s d2 'past nil (current-buffer) pos)))
-         (setq ddays 0))
        ;; When to show a scheduled item in the calendar:
        ;; If it is on or past the date.
-       (when (or (and (> ddays 0) (= diff (- ddays)))
-                 (and (zerop ddays) (= diff 0))
-                 (and (< (+ diff ddays) 0)
+       (when (or (and (< diff 0)
                       (< (abs diff) org-scheduled-past-days)
                       (and todayp (not org-agenda-only-exact-dates)))
+                 (= diff 0)
                  ;; org-is-habit-p uses org-entry-get, which is expansive
                  ;; so we go extra mile to only call it once
                  (and todayp
@@ -6358,9 +5865,7 @@ FRACTION is what fraction of the head-warning time has passed."
                          (and (eq org-agenda-show-inherited-tags t)
                               (or (eq org-agenda-use-tag-inheritance t)
                                   (memq 'agenda org-agenda-use-tag-inheritance))))
-
                      tags (org-get-tags-at nil (not inherited-tags)))
-               (setq level (make-string (org-reduced-level (org-outline-level)) ? ))
                (setq head (buffer-substring
                            (point)
                            (progn (skip-chars-forward "^\r\n") (point))))
@@ -6373,7 +5878,7 @@ FRACTION is what fraction of the head-warning time has passed."
                               (car org-agenda-scheduled-leaders)
                             (format (nth 1 org-agenda-scheduled-leaders)
                                     (- 1 diff)))
-                          head level category tags
+                          head category tags
                           (if (not (= diff 0)) nil timestr)
                           nil habitp))))
            (when txt
@@ -6391,9 +5896,7 @@ FRACTION is what fraction of the head-warning time has passed."
                'org-hd-marker (org-agenda-new-marker pos1)
                'type (if pastschedp "past-scheduled" "scheduled")
                'date (if pastschedp d2 date)
-               'ts-date d2
                'warntime warntime
-               'level level
                'priority (if habitp
                              (org-habit-get-priority habitp)
                            (+ 94 (- 5 diff) (org-get-priority txt)))
@@ -6417,7 +5920,7 @@ FRACTION is what fraction of the head-warning time has passed."
         (regexp org-tr-regexp)
         (d0 (calendar-absolute-from-gregorian date))
         marker hdmarker ee txt d1 d2 s1 s2 category category-pos
-        level todo-state tags pos head donep inherited-tags)
+        todo-state tags pos head donep inherited-tags)
     (goto-char (point-min))
     (while (re-search-forward regexp nil t)
       (catch :skip
@@ -6451,9 +5954,7 @@ FRACTION is what fraction of the head-warning time has passed."
                            (and (eq org-agenda-show-inherited-tags t)
                                 (or (eq org-agenda-use-tag-inheritance t)
                                     (memq 'agenda org-agenda-use-tag-inheritance))))
-
                        tags (org-get-tags-at nil (not inherited-tags)))
-                 (setq level (make-string (org-reduced-level (org-outline-level)) ? ))
                  (looking-at "\\*+[ \t]+\\([^\r\n]+\\)")
                  (setq head (match-string 1))
                  (let ((remove-re
@@ -6468,7 +5969,7 @@ FRACTION is what fraction of the head-warning time has passed."
                                (nth (if (= d1 d2) 0 1)
                                     org-agenda-timerange-leaders)
                                (1+ (- d0 d1)) (1+ (- d2 d1)))
-                              head level category tags
+                              head category tags
                               (cond ((and (= d1 d0) (= d2 d0))
                                      (concat "<" start-time ">--<" end-time ">"))
                                      ((= d1 d0)
@@ -6479,7 +5980,6 @@ FRACTION is what fraction of the head-warning time has passed."
                (org-add-props txt props
                  'org-marker marker 'org-hd-marker hdmarker
                  'type "block" 'date date
-                 'level level
                  'todo-state todo-state
                  'priority (org-get-priority txt) 'org-category category
                  'org-category-position category-pos)
@@ -6499,9 +5999,6 @@ The flag is set if the currently compiled format contains a `%T'.")
 (defvar org-prefix-has-effort nil
   "A flag, set by `org-compile-prefix-format'.
 The flag is set if the currently compiled format contains a `%e'.")
-(defvar org-prefix-has-breadcrumbs nil
-  "A flag, set by `org-compile-prefix-format'.
-The flag is set if the currently compiled format contains a `%b'.")
 (defvar org-prefix-category-length nil
   "Used by `org-compile-prefix-format' to remember the category field width.")
 (defvar org-prefix-category-max-length nil
@@ -6515,23 +6012,20 @@ The flag is set if the currently compiled format contains a `%b'.")
          (return (cadr entry))
        (return (apply 'create-image (cdr entry)))))))
 
-(defun org-agenda-format-item (extra txt &optional level category tags dotime
+(defun org-agenda-format-item (extra txt &optional category tags dotime
                                     remove-re habitp)
   "Format TXT to be inserted into the agenda buffer.
-In particular, add the prefix and corresponding text properties.
-
-EXTRA must be a string to replace the `%s' specifier in the prefix format.
-LEVEL may be a string to replace the `%l' specifier.
-CATEGORY (a string, a symbol or nil) may be used to overrule the default
+In particular, it adds the prefix and corresponding text properties.  EXTRA
+must be a string and replaces the `%s' specifier in the prefix format.
+CATEGORY (string, symbol or nil) may be used to overrule the default
 category taken from local variable or file name.  It will replace the `%c'
-specifier in the format.
-DOTIME, when non-nil, indicates that a time-of-day should be extracted from
-TXT for sorting of this entry, and for the `%t' specifier in the format.
-When DOTIME is a string, this string is searched for a time before TXT is.
-TAGS can be the tags of the headline.
+specifier in the format.  DOTIME, when non-nil, indicates that a
+time-of-day should be extracted from TXT for sorting of this entry, and for
+the `%t' specifier in the format.  When DOTIME is a string, this string is
+searched for a time before TXT is.  TAGS can be the tags of the headline.
 Any match of REMOVE-RE will be removed from TXT."
   ;; We keep the org-prefix-* variable values along with a compiled
-  ;; formatter, so that multiple agendas existing at the same time do
+  ;; formatter, so that multiple agendas existing at the same time, do
   ;; not step on each other toes.
   ;;
   ;; It was inconvenient to make these variables buffer local in
@@ -6544,14 +6038,13 @@ Any match of REMOVE-RE will be removed from TXT."
          do (set var value))
     (save-match-data
       ;; Diary entries sometimes have extra whitespace at the beginning
-      (setq txt (org-trim txt))
+      (if (string-match "^ +" txt) (setq txt (replace-match "" nil nil txt)))
 
       ;; Fix the tags part in txt
       (setq txt (org-agenda-fix-displayed-tags
                 txt tags
                 org-agenda-show-inherited-tags
                 org-agenda-hide-tags-regexp))
-
       (let* ((category (or category
                           (if (stringp org-category)
                               org-category
@@ -6572,7 +6065,7 @@ Any match of REMOVE-RE will be removed from TXT."
                             (and org-agenda-search-headline-for-time txt))))
             (time-of-day (and dotime (org-get-time-of-day ts)))
             stamp plain s0 s1 s2 rtn srp l
-            duration thecategory breadcrumbs)
+            duration thecategory)
        (and (derived-mode-p 'org-mode) buffer-file-name
             (add-to-list 'org-agenda-contributing-files buffer-file-name))
        (when (and dotime time-of-day)
@@ -6600,12 +6093,10 @@ Any match of REMOVE-RE will be removed from TXT."
          (if s2 (setq s2 (org-get-time-of-day s2 'string t)))
 
          ;; Try to set s2 if s1 and `org-agenda-default-appointment-duration' are set
-         (let (org-time-clocksum-use-effort-durations)
-           (when (and s1 (not s2) org-agenda-default-appointment-duration)
-             (setq s2
-                   (org-minutes-to-clocksum-string
-                    (+ (org-hh:mm-string-to-minutes s1)
-                       org-agenda-default-appointment-duration)))))
+         (when (and s1 (not s2) org-agenda-default-appointment-duration)
+           (setq s2
+                 (org-minutes-to-hh:mm-string
+                  (+ (org-hh:mm-string-to-minutes s1) org-agenda-default-appointment-duration))))
 
          ;; Compute the duration
          (when s2
@@ -6625,11 +6116,11 @@ Any match of REMOVE-RE will be removed from TXT."
                       t t txt))))
        (when (derived-mode-p 'org-mode)
          (setq effort (ignore-errors (get-text-property 0 'org-effort txt)))
-         (if effort
-             (setq neffort (org-duration-string-to-minutes effort)
-                   effort (setq effort (concat "[" effort "]")))
-           ;; prevent erroring out with %e format when there is no effort
-           (setq effort "")))
+         (when effort
+           (setq neffort (org-duration-string-to-minutes effort)
+                 effort (setq effort (concat "[" effort "]")))))
+       ;; prevent erroring out with %e format when there is no effort
+       (or effort (setq effort ""))
 
        (when remove-re
          (while (string-match remove-re txt)
@@ -6640,10 +6131,6 @@ Any match of REMOVE-RE will be removed from TXT."
        (add-text-properties 0 (length txt) '(org-heading t) txt)
 
        ;; Prepare the variables needed in the eval of the compiled format
-       (if org-prefix-has-breadcrumbs
-           (setq breadcrumbs (org-with-point-at (org-get-at-bol 'org-marker)
-                               (let ((s (org-display-outline-path nil nil "->" t)))
-                                 (if (eq "" s) "" (concat s "->"))))))
        (setq time (cond (s2 (concat
                              (org-agenda-time-of-day-to-ampm-maybe s1)
                              "-" (org-agenda-time-of-day-to-ampm-maybe s2)
@@ -6656,8 +6143,7 @@ Any match of REMOVE-RE will be removed from TXT."
                         (t ""))
              extra (or (and (not habitp) extra) "")
              category (if (symbolp category) (symbol-name category) category)
-             thecategory (copy-sequence category)
-             level (or level ""))
+             thecategory (copy-sequence category))
        (if (string-match org-bracket-link-regexp category)
            (progn
              (setq l (if (match-end 3)
@@ -6685,9 +6171,7 @@ Any match of REMOVE-RE will be removed from TXT."
          'duration duration
          'effort effort
          'effort-minutes neffort
-         'breadcrumbs breadcrumbs
          'txt txt
-         'level level
          'time time
          'extra extra
          'format org-prefix-format-compiled
@@ -6732,13 +6216,9 @@ The modified list may contain inherited tags, and tags matched by
     s))
 
 (defvar org-agenda-sorting-strategy) ;; because the def is in a let form
+(defvar org-agenda-sorting-strategy-selected nil)
 
 (defun org-agenda-add-time-grid-maybe (list ndays todayp)
-  "Add a time-grid for agenda items which need it.
-
-LIST is the list of agenda items formatted by `org-agenda-list'.
-NDAYS is the span of the current agenda view.
-TODAYP is `t' when the current agenda view is on today."
   (catch 'exit
     (cond ((not org-agenda-use-time-grid) (throw 'exit list))
          ((and todayp (member 'today (car org-agenda-time-grid))))
@@ -6760,14 +6240,16 @@ TODAYP is `t' when the current agenda view is on today."
        (unless (and remove (member time have))
          (setq time (replace-regexp-in-string " " "0" (format "%04s" time)))
          (push (org-agenda-format-item
-                nil string nil "" nil
+                nil string "" nil
                 (concat (substring time 0 -2) ":" (substring time -2)))
                new)
          (put-text-property
           2 (length (car new)) 'face 'org-time-grid (car new))))
       (when (and todayp org-agenda-show-current-time-in-grid)
        (push (org-agenda-format-item
-              nil org-agenda-current-time-string nil "" nil
+              nil
+              org-agenda-current-time-string
+              "" nil
               (format-time-string "%H:%M "))
              new)
        (put-text-property
@@ -6781,11 +6263,9 @@ TODAYP is `t' when the current agenda view is on today."
   "Compile the prefix format into a Lisp form that can be evaluated.
 The resulting form and associated variable bindings is returned
 and stored in the variable `org-prefix-format-compiled'."
-  (setq org-prefix-has-time nil
-       org-prefix-has-tag nil
+  (setq org-prefix-has-time nil org-prefix-has-tag nil
        org-prefix-category-length nil
-       org-prefix-has-effort nil
-       org-prefix-has-breadcrumbs nil)
+       org-prefix-has-effort nil)
   (let ((s (cond
            ((stringp org-agenda-prefix-format)
             org-agenda-prefix-format)
@@ -6794,11 +6274,11 @@ and stored in the variable `org-prefix-format-compiled'."
            (t "  %-12:c%?-12t% s")))
        (start 0)
        varform vars var e c f opt)
-    (while (string-match "%\\(\\?\\)?\\([-+]?[0-9.]*\\)\\([ .;,:!?=|/<>]?\\)\\([cltseib]\\|(.+)\\)"
+    (while (string-match "%\\(\\?\\)?\\([-+]?[0-9.]*\\)\\([ .;,:!?=|/<>]?\\)\\([ctsei]\\|(.+)\\)"
                         s start)
       (setq var (or (cdr (assoc (match-string 4 s)
-                               '(("c" . category) ("t" . time) ("l" . level) ("s" . extra)
-                                 ("i" . category-icon) ("T" . tag) ("e" . effort) ("b" . breadcrumbs))))
+                               '(("c" . category) ("t" . time) ("s" . extra)
+                                 ("i" . category-icon) ("T" . tag) ("e" . effort))))
                    'eval)
            c (or (match-string 3 s) "")
            opt (match-beginning 1)
@@ -6806,7 +6286,6 @@ and stored in the variable `org-prefix-format-compiled'."
       (if (equal var 'time) (setq org-prefix-has-time t))
       (if (equal var 'tag)  (setq org-prefix-has-tag  t))
       (if (equal var 'effort) (setq org-prefix-has-effort t))
-      (if (equal var 'breadcrumbs) (setq org-prefix-has-breadcrumbs t))
       (setq f (concat "%" (match-string 2 s) "s"))
       (when (equal var 'category)
        (setq org-prefix-category-length
@@ -6833,8 +6312,7 @@ and stored in the variable `org-prefix-format-compiled'."
             `((org-prefix-has-time ,org-prefix-has-time)
               (org-prefix-has-tag ,org-prefix-has-tag)
               (org-prefix-category-length ,org-prefix-category-length)
-              (org-prefix-has-effort ,org-prefix-has-effort)
-              (org-prefix-has-breadcrumbs ,org-prefix-has-breadcrumbs))
+              (org-prefix-has-effort ,org-prefix-has-effort))
             `(format ,s ,@vars))))))
 
 (defun org-set-sorting-strategy (key)
@@ -6894,47 +6372,14 @@ You can also use this function as a filter, by returning nil for lines
 you don't want to have in the agenda at all.  For this application, you
 could bind the variable in the options section of a custom command.")
 
-(defun org-agenda-finalize-entries (list &optional type)
-  "Sort, limit and concatenate the LIST of agenda items.
-The optional argument TYPE tells the agenda type."
-  (let ((max-effort (cond ((listp org-agenda-max-effort)
-                          (cdr (assoc type org-agenda-max-effort)))
-                         (t org-agenda-max-effort)))
-       (max-todo (cond ((listp org-agenda-max-todos)
-                        (cdr (assoc type org-agenda-max-todos)))
-                       (t org-agenda-max-todos)))
-       (max-tags (cond ((listp org-agenda-max-tags)
-                        (cdr (assoc type org-agenda-max-tags)))
-                       (t org-agenda-max-tags)))
-       (max-entries (cond ((listp org-agenda-max-entries)
-                           (cdr (assoc type org-agenda-max-entries)))
-                          (t org-agenda-max-entries))) l)
+(defun org-agenda-finalize-entries (list &optional nosort)
+  "Sort and concatenate the agenda items."
+  (setq list (mapcar 'org-agenda-highlight-todo list))
+  (if nosort
+      list
     (when org-agenda-before-sorting-filter-function
-      (setq list
-           (delq nil
-                 (mapcar
-                  org-agenda-before-sorting-filter-function list))))
-    (setq list (mapcar 'org-agenda-highlight-todo list)
-         list (mapcar 'identity (sort list 'org-entries-lessp))
-         list (org-agenda-limit-entries
-               list 'effort-minutes max-effort 'identity)
-         list (org-agenda-limit-entries list 'todo-state max-todo)
-         list (org-agenda-limit-entries list 'tags max-tags)
-         list (org-agenda-limit-entries list 'org-hd-marker max-entries)
-         list (mapconcat 'identity list "\n"))))
-
-(defun org-agenda-limit-entries (list prop limit &optional fn)
-  "Limit the number of agenda entries."
-  (if limit
-      (let ((f (or fn (lambda (p) (and p 1)))) (lim 0))
-       (delq nil
-             (mapcar
-              (lambda (e)
-                (let ((pval (funcall f (get-text-property 1 prop e))))
-                  (if pval (setq lim (+ lim pval)))
-                  (if (or (not pval) (<= lim limit)) e)))
-              list)))
-    list))
+      (setq list (delq nil (mapcar org-agenda-before-sorting-filter-function list))))
+    (mapconcat 'identity (sort list 'org-entries-lessp) "\n")))
 
 (defun org-agenda-highlight-todo (x)
   (let ((org-done-keywords org-done-keywords-for-agenda)
@@ -7061,20 +6506,6 @@ The optional argument TYPE tells the agenda type."
     (cond ((< ta tb) -1)
          ((< tb ta) +1))))
 
-(defsubst org-cmp-ts (a b &optional type)
-  "Compare the timestamps values of entries A and B.
-When TYPE is \"scheduled\", \"deadline\", \"timestamp\"
-or \"timestamp_ia\", compare within each of these type.
-When TYPE is the empty string, compare all timestamps
-without respect of their type."
-  (let* ((def (if org-sort-agenda-notime-is-late 9901 -1))
-        (ta (or (and (string-match type (get-text-property 1 'type a))
-                     (get-text-property 1 'ts-date a)) def))
-        (tb (or (and (string-match type (get-text-property 1 'type b))
-                     (get-text-property 1 'ts-date b)) def)))
-    (cond ((< ta tb) -1)
-         ((< tb ta) +1))))
-
 (defsubst org-cmp-habit-p (a b)
   "Compare the todo states of strings A and B."
   (let ((ha (get-text-property 1 'org-habit-p a))
@@ -7082,26 +6513,13 @@ without respect of their type."
     (cond ((and ha (not hb)) -1)
          ((and (not ha) hb) +1))))
 
+(defsubst org-em (x y list) (or (memq x list) (memq y list)))
+
 (defun org-entries-lessp (a b)
   "Predicate for sorting agenda entries."
   ;; The following variables will be used when the form is evaluated.
   ;; So even though the compiler complains, keep them.
   (let* ((ss org-agenda-sorting-strategy-selected)
-        (timestamp-up    (and (org-em 'timestamp-up 'timestamp-down ss)
-                              (org-cmp-ts a b "")))
-        (timestamp-down  (if timestamp-up (- timestamp-up) nil))
-        (scheduled-up    (and (org-em 'scheduled-up 'scheduled-down ss)
-                              (org-cmp-ts a b "scheduled")))
-        (scheduled-down  (if scheduled-up (- scheduled-up) nil))
-        (deadline-up     (and (org-em 'deadline-up 'deadline-down ss)
-                              (org-cmp-ts a b "deadline")))
-        (deadline-down   (if deadline-up (- deadline-up) nil))
-        (tsia-up         (and (org-em 'tsia-up 'tsia-down ss)
-                              (org-cmp-ts a b "iatimestamp_ia")))
-        (tsia-down       (if tsia-up (- tsia-up) nil))
-        (ts-up           (and (org-em 'ts-up 'ts-down ss)
-                              (org-cmp-ts a b "timestamp")))
-        (ts-down         (if ts-up (- ts-up) nil))
         (time-up         (and (org-em 'time-up 'time-down ss)
                               (org-cmp-time a b)))
         (time-down       (if time-up (- time-up) nil))
@@ -7169,11 +6587,10 @@ in the file.  Otherwise, restriction will be to the current subtree."
        (put 'org-agenda-files 'org-restrict
             (list (buffer-file-name (buffer-base-buffer))))
        (org-back-to-heading t)
-       (move-overlay org-agenda-restriction-lock-overlay
-                     (point) (save-excursion (org-end-of-subtree t t) (point)))
+       (move-overlay org-agenda-restriction-lock-overlay (point) (point-at-eol))
        (move-marker org-agenda-restrict-begin (point))
        (move-marker org-agenda-restrict-end
-                    (save-excursion (org-end-of-subtree t t)))
+                    (save-excursion (org-end-of-subtree t)))
        (message "Locking agenda restriction to subtree"))
     (put 'org-agenda-files 'org-restrict
         (list (buffer-file-name (buffer-base-buffer))))
@@ -7226,9 +6643,8 @@ Allowed types are 'agenda 'timeline 'todo 'tags 'search."
          (error "Not allowed in %s-type agenda buffers" org-agenda-type)
        nil))))
 
-(defun org-agenda-Quit ()
-  "Exit the agenda and kill buffers loaded by `org-agenda'.
-Also restore the window configuration."
+(defun org-agenda-Quit (&optional arg)
+  "Exit agenda by removing the window or the buffer."
   (interactive)
   (if org-agenda-columns-active
       (org-columns-quit)
@@ -7255,8 +6671,8 @@ Also restore the window configuration."
         (setq org-agenda-pre-window-conf nil))))
 
 (defun org-agenda-quit ()
-  "Exit the agenda and restore the window configuration.
-When `org-agenda-sticky' is non-nil, only bury the agenda."
+  "Exit agenda by killing agenda buffer or burying it when
+`org-agenda-sticky' is non-NIL"
   (interactive)
   (if (and (eq org-indirect-buffer-display 'other-window)
           org-last-indirect-buffer)
@@ -7285,9 +6701,9 @@ When `org-agenda-sticky' is non-nil, only bury the agenda."
       (org-agenda-Quit))))
 
 (defun org-agenda-exit ()
-  "Exit the agenda and restore the window configuration.
-Also kill Org-mode buffers loaded by `org-agenda'.  Org-mode
-buffers visited directly by the user will not be touched."
+  "Exit agenda by removing the window or the buffer.
+Also kill all Org-mode buffers which have been loaded by `org-agenda'.
+Org-mode buffers visited directly by the user will not be touched."
   (interactive)
   (org-release-buffers org-agenda-new-buffers)
   (setq org-agenda-new-buffers nil)
@@ -7295,8 +6711,8 @@ buffers visited directly by the user will not be touched."
 
 (defun org-agenda-kill-all-agenda-buffers ()
   "Kill all buffers in `org-agenda-mode'.
-This is used when toggling sticky agendas.
-You can also explicitly invoke it with `C-c a C-k'."
+This is used when toggling sticky agendas.  You can also explicitly invoke it
+with `C-c a C-k'."
   (interactive)
   (let (blist)
     (dolist (buf (buffer-list))
@@ -7571,6 +6987,8 @@ If the line does not have an effort defined, return nil."
 
 (defun org-agenda-filter-apply (filter type)
   "Set FILTER as the new agenda filter and apply it."
+  ;; Deactivate `org-agenda-entry-text-mode' when filtering
+  (if org-agenda-entry-text-mode (org-agenda-entry-text-mode))
   (let (tags cat)
     (if (eq type 'tag)
        (setq org-agenda-tag-filter filter)
@@ -8002,17 +7420,23 @@ so that the date SD will be in that range."
 (defun org-agenda-entry-text-mode (&optional arg)
   "Toggle entry text mode in an agenda buffer."
   (interactive "P")
-  (setq org-agenda-entry-text-mode (or (integerp arg)
-                                       (not org-agenda-entry-text-mode)))
-  (org-agenda-entry-text-hide)
-  (and org-agenda-entry-text-mode
-       (let ((org-agenda-entry-text-maxlines
-             (if (integerp arg) arg org-agenda-entry-text-maxlines)))
-        (org-agenda-entry-text-show)))
-  (org-agenda-set-mode-name)
-  (message "Entry text mode is %s.  Maximum number of lines is %d"
-          (if org-agenda-entry-text-mode "on" "off")
-          (if (integerp arg) arg org-agenda-entry-text-maxlines)))
+  (if (or org-agenda-tag-filter
+         org-agenda-category-filter
+         org-agenda-top-category-filter)
+      (user-error "Can't show entry text in filtered views")
+    (setq org-agenda-entry-text-mode (or (integerp arg)
+                                        (not org-agenda-entry-text-mode)))
+    (org-agenda-entry-text-hide)
+    (and org-agenda-entry-text-mode
+        (let ((org-agenda-entry-text-maxlines
+               (if (integerp arg) arg org-agenda-entry-text-maxlines)))
+          (org-agenda-entry-text-show)))
+    (org-agenda-set-mode-name)
+    (message "Entry text mode is %s%s"
+            (if org-agenda-entry-text-mode "on" "off")
+            (if (not org-agenda-entry-text-mode) ""
+              (format " (maximum number of lines is %d)"
+                      (if (integerp arg) arg org-agenda-entry-text-maxlines))))))
 
 (defun org-agenda-clockreport-mode (&optional with-filter)
   "Toggle clocktable mode in an agenda buffer.
@@ -8731,7 +8155,7 @@ If FORCE-TAGS is non nil, the car of it returns the new tags."
                    (save-excursion (save-restriction (widen)
                                                      (goto-char hdmarker)
                                                      (org-get-tags-at)))))
-        props m pl undone-face done-face finish new dotime level cat tags)
+        props m pl undone-face done-face finish new dotime cat tags)
     (save-excursion
       (goto-char (point-max))
       (beginning-of-line 1)
@@ -8743,7 +8167,6 @@ If FORCE-TAGS is non nil, the car of it returns the new tags."
          (setq props (text-properties-at (point))
                dotime (org-get-at-bol 'dotime)
                cat (org-get-at-bol 'org-category)
-               level (org-get-at-bol 'level)
                tags thetags
                new
                (let ((org-prefix-format-compiled
@@ -8754,7 +8177,7 @@ If FORCE-TAGS is non nil, the car of it returns the new tags."
                    (save-excursion
                      (save-restriction
                        (widen)
-                       (org-agenda-format-item extra newhead level cat tags dotime)))))
+                       (org-agenda-format-item extra newhead cat tags dotime)))))
                pl (text-property-any (point-at-bol) (point-at-eol) 'org-heading t)
                undone-face (org-get-at-bol 'undone-face)
                done-face (org-get-at-bol 'done-face))
@@ -9145,9 +8568,9 @@ ARG is passed through to `org-deadline'."
       (org-clock-in arg)
     (let* ((marker (or (org-get-at-bol 'org-marker)
                       (org-agenda-error)))
-          (hdmarker (or (org-get-at-bol 'org-hd-marker) marker))
+          (hdmarker (or (org-get-at-bol 'org-hd-marker)
+                        marker))
           (pos (marker-position marker))
-          (col (current-column))
           newhead)
       (org-with-remote-undo (marker-buffer marker)
         (with-current-buffer (marker-buffer marker)
@@ -9158,15 +8581,14 @@ ARG is passed through to `org-deadline'."
          (org-cycle-hide-drawers 'children)
          (org-clock-in arg)
          (setq newhead (org-get-heading)))
-       (org-agenda-change-all-lines newhead hdmarker))
-      (org-move-to-column col))))
+       (org-agenda-change-all-lines newhead hdmarker)))))
 
 (defun org-agenda-clock-out ()
   "Stop the currently running clock."
   (interactive)
   (unless (marker-buffer org-clock-marker)
     (error "No running clock"))
-  (let ((marker (make-marker)) (col (current-column)) newhead)
+  (let ((marker (make-marker)) newhead)
     (org-with-remote-undo (marker-buffer org-clock-marker)
       (with-current-buffer (marker-buffer org-clock-marker)
        (save-excursion
@@ -9178,9 +8600,7 @@ ARG is passed through to `org-deadline'."
            (org-clock-out)
            (setq newhead (org-get-heading))))))
     (org-agenda-change-all-lines newhead marker)
-    (move-marker marker nil)
-    (org-move-to-column col)
-    (org-agenda-unmark-clocking-task)))
+    (move-marker marker nil)))
 
 (defun org-agenda-clock-cancel (&optional arg)
   "Cancel the currently running clock."
@@ -9305,7 +8725,7 @@ the resulting entry will not be shown.  When TEXT is empty, switch to
            ;; Use org-agenda-format-item to parse text for a time-range and
            ;; remove it.  FIXME: This is a hack, we should refactor
            ;; that function to make time extraction available separately
-           (setq fmt (org-agenda-format-item nil text nil nil nil t)
+           (setq fmt (org-agenda-format-item nil text nil nil t)
                  time (get-text-property 0 'time fmt)
                  time2 (if (> (length time) 0)
                            ;; split-string removes trailing ...... if
@@ -9498,12 +8918,6 @@ This is a command that has to be installed in `calendar-mode-map'."
                        (calendar-cursor-to-date))
                   nil))
 
-(autoload 'org-calendar-goto-agenda "org-agenda" "\
-Compute the Org-mode agenda for the calendar date displayed at the cursor.
-This is a command that has to be installed in `calendar-mode-map'.
-
-\(fn)" t nil)
-
 (defun org-agenda-convert-date ()
   (interactive)
   (org-agenda-check-type t 'agenda 'timeline)
@@ -9796,15 +9210,13 @@ The prefix arg is passed through to the command if possible."
                 (if (not org-agenda-persistent-marks)
                     "" " (kept marked)"))))))
 
-(defun org-agenda-capture (&optional with-time)
-  "Call `org-capture' with the date at point.
-With a `C-1' prefix, use the HH:MM value at point (if any) or the
-current HH:MM time."
-  (interactive "P")
+(defun org-agenda-capture ()
+  "Call `org-capture' with the date at point."
+  (interactive)
   (if (not (eq major-mode 'org-agenda-mode))
-      (user-error "You cannot do this outside of agenda buffers")
+      (error "You cannot do this outside of agenda buffers")
     (let ((org-overriding-default-time
-          (org-get-cursor-date (equal with-time 1))))
+          (org-get-cursor-date)))
       (call-interactively 'org-capture))))
 
 ;;; Flagging notes
@@ -9948,40 +9360,6 @@ to override `appt-message-warning-time'."
        (message "No event to add")
       (message "Added %d event%s for today" cnt (if (> cnt 1) "s" "")))))
 
-(autoload 'org-agenda-to-appt "org-agenda" "\
-Activate appointments found in `org-agenda-files'.
-With a \\[universal-argument] prefix, refresh the list of
-appointments.
-
-If FILTER is t, interactively prompt the user for a regular
-expression, and filter out entries that don't match it.
-
-If FILTER is a string, use this string as a regular expression
-for filtering entries out.
-
-If FILTER is a function, filter out entries against which
-calling the function returns nil.  This function takes one
-argument: an entry from `org-agenda-get-day-entries'.
-
-FILTER can also be an alist with the car of each cell being
-either 'headline or 'category.  For example:
-
-  '((headline \"IMPORTANT\")
-    (category \"Work\"))
-
-will only add headlines containing IMPORTANT or headlines
-belonging to the \"Work\" category.
-
-ARGS are symbols indicating what kind of entries to consider.
-By default `org-agenda-to-appt' will use :deadline, :scheduled
-and :timestamp entries.  See the docstring of `org-diary' for
-details and examples.
-
-If an entry has a APPT_WARNTIME property, its value will be used
-to override `appt-message-warning-time'.
-
-\(fn &optional REFRESH FILTER &rest ARGS)" t nil)
-
 (defun org-agenda-todayp (date)
   "Does DATE mean today, when considering `org-extend-today-until'?"
   (let ((today (org-today))
index 55e5a32..bdb9acb 100644 (file)
@@ -1,6 +1,6 @@
 ;;; org-annotate-file.el --- Annotate a file with org syntax
 
-;; Copyright (C) 2008-2012 Philip Jackson
+;; Copyright (C) 2008-2013 Philip Jackson
 
 ;; Author: Philip Jackson <phil@shellarchive.co.uk>
 ;; Version: 0.2