Update org-mode
authorJoerg Jaspert <joerg@debian.org>
Wed, 16 Sep 2015 07:58:15 +0000 (09:58 +0200)
committerJoerg Jaspert <joerg@debian.org>
Wed, 21 Oct 2015 05:58:26 +0000 (07:58 +0200)
115 files changed:
.emacs.d/elisp/org/ob-C.el
.emacs.d/elisp/org/ob-R.el
.emacs.d/elisp/org/ob-awk.el
.emacs.d/elisp/org/ob-calc.el
.emacs.d/elisp/org/ob-clojure.el
.emacs.d/elisp/org/ob-comint.el
.emacs.d/elisp/org/ob-coq.el
.emacs.d/elisp/org/ob-core.el
.emacs.d/elisp/org/ob-css.el
.emacs.d/elisp/org/ob-ditaa.el
.emacs.d/elisp/org/ob-dot.el
.emacs.d/elisp/org/ob-emacs-lisp.el
.emacs.d/elisp/org/ob-eval.el
.emacs.d/elisp/org/ob-exp.el
.emacs.d/elisp/org/ob-fortran.el
.emacs.d/elisp/org/ob-gnuplot.el
.emacs.d/elisp/org/ob-groovy.el
.emacs.d/elisp/org/ob-haskell.el
.emacs.d/elisp/org/ob-io.el
.emacs.d/elisp/org/ob-java.el
.emacs.d/elisp/org/ob-js.el
.emacs.d/elisp/org/ob-keys.el
.emacs.d/elisp/org/ob-latex.el
.emacs.d/elisp/org/ob-ledger.el
.emacs.d/elisp/org/ob-lilypond.el
.emacs.d/elisp/org/ob-lisp.el
.emacs.d/elisp/org/ob-makefile.el
.emacs.d/elisp/org/ob-matlab.el
.emacs.d/elisp/org/ob-maxima.el
.emacs.d/elisp/org/ob-mscgen.el
.emacs.d/elisp/org/ob-octave.el
.emacs.d/elisp/org/ob-org.el
.emacs.d/elisp/org/ob-perl.el
.emacs.d/elisp/org/ob-picolisp.el
.emacs.d/elisp/org/ob-plantuml.el
.emacs.d/elisp/org/ob-processing.el [new file with mode: 0644]
.emacs.d/elisp/org/ob-ref.el
.emacs.d/elisp/org/ob-ruby.el
.emacs.d/elisp/org/ob-sass.el
.emacs.d/elisp/org/ob-scala.el
.emacs.d/elisp/org/ob-scheme.el
.emacs.d/elisp/org/ob-screen.el
.emacs.d/elisp/org/ob-sed.el [new file with mode: 0644]
.emacs.d/elisp/org/ob-shell.el
.emacs.d/elisp/org/ob-shen.el
.emacs.d/elisp/org/ob-sql.el
.emacs.d/elisp/org/ob-sqlite.el
.emacs.d/elisp/org/ob-stan.el [new file with mode: 0644]
.emacs.d/elisp/org/ob-table.el
.emacs.d/elisp/org/ob-tangle.el
.emacs.d/elisp/org/ob.el
.emacs.d/elisp/org/org-agenda.el
.emacs.d/elisp/org/org-archive.el
.emacs.d/elisp/org/org-attach.el
.emacs.d/elisp/org/org-bbdb.el
.emacs.d/elisp/org/org-bibtex.el
.emacs.d/elisp/org/org-capture.el
.emacs.d/elisp/org/org-clock.el
.emacs.d/elisp/org/org-colview.el
.emacs.d/elisp/org/org-compat.el
.emacs.d/elisp/org/org-contacts.el
.emacs.d/elisp/org/org-crypt.el
.emacs.d/elisp/org/org-ctags.el
.emacs.d/elisp/org/org-datetree.el
.emacs.d/elisp/org/org-drill.el
.emacs.d/elisp/org/org-element.el
.emacs.d/elisp/org/org-entities.el
.emacs.d/elisp/org/org-eshell.el
.emacs.d/elisp/org/org-eww.el
.emacs.d/elisp/org/org-faces.el
.emacs.d/elisp/org/org-feed.el
.emacs.d/elisp/org/org-footnote.el
.emacs.d/elisp/org/org-gnus.el
.emacs.d/elisp/org/org-id.el
.emacs.d/elisp/org/org-indent.el
.emacs.d/elisp/org/org-index.el
.emacs.d/elisp/org/org-info.el
.emacs.d/elisp/org/org-inlinetask.el
.emacs.d/elisp/org/org-irc.el
.emacs.d/elisp/org/org-jira.el [deleted file]
.emacs.d/elisp/org/org-link-edit.el [new file with mode: 0644]
.emacs.d/elisp/org/org-lint.el [new file with mode: 0644]
.emacs.d/elisp/org/org-list.el
.emacs.d/elisp/org/org-loaddefs.el
.emacs.d/elisp/org/org-mac-link.el
.emacs.d/elisp/org/org-macro.el
.emacs.d/elisp/org/org-macs.el
.emacs.d/elisp/org/org-mhe.el
.emacs.d/elisp/org/org-mime.el
.emacs.d/elisp/org/org-mobile.el
.emacs.d/elisp/org/org-mouse.el
.emacs.d/elisp/org/org-notify.el
.emacs.d/elisp/org/org-notmuch.el
.emacs.d/elisp/org/org-pcomplete.el
.emacs.d/elisp/org/org-protocol.el
.emacs.d/elisp/org/org-rmail.el
.emacs.d/elisp/org/org-src.el
.emacs.d/elisp/org/org-table.el
.emacs.d/elisp/org/org-timer.el
.emacs.d/elisp/org/org-toc.el
.emacs.d/elisp/org/org-version.el
.emacs.d/elisp/org/org-w3m.el
.emacs.d/elisp/org/org.el
.emacs.d/elisp/org/ox-ascii.el
.emacs.d/elisp/org/ox-beamer.el
.emacs.d/elisp/org/ox-html.el
.emacs.d/elisp/org/ox-icalendar.el
.emacs.d/elisp/org/ox-latex.el
.emacs.d/elisp/org/ox-man.el
.emacs.d/elisp/org/ox-md.el
.emacs.d/elisp/org/ox-odt.el
.emacs.d/elisp/org/ox-org.el
.emacs.d/elisp/org/ox-publish.el
.emacs.d/elisp/org/ox-texinfo.el
.emacs.d/elisp/org/ox.el

index 0857795..f02950a 100644 (file)
@@ -1,6 +1,6 @@
 ;;; ob-C.el --- org-babel functions for C and similar languages
 
-;; Copyright (C) 2010-2014 Free Software Foundation, Inc.
+;; Copyright (C) 2010-2015 Free Software Foundation, Inc.
 
 ;; Author: Eric Schulte
 ;;      Thierry Banel
@@ -194,7 +194,6 @@ it's header arguments."
                  nil)))
     (when (stringp includes)
       (setq includes (split-string includes)))
-    (setq includes (append includes '("<string.h>" "<stdio.h>" "<stdlib.h>")))
     (when (stringp defines)
       (let ((y nil)
            (result (list t)))
index c10224a..ac84d7d 100644 (file)
@@ -63,8 +63,8 @@
     (useDingbats        . :any)
     (horizontal                 . :any)
     (results             . ((file list vector table scalar verbatim)
-                           (raw org html latex code pp wrap)
-                           (replace silent append prepend)
+                           (raw html latex org code pp drawer)
+                           (replace silent none append prepend)
                            (output value graphics))))
   "R-specific header arguments.")
 
index a96ba1a..eb03b46 100644 (file)
@@ -1,6 +1,6 @@
 ;;; ob-awk.el --- org-babel functions for awk evaluation
 
-;; Copyright (C) 2011-2014 Free Software Foundation, Inc.
+;; Copyright (C) 2011-2015 Free Software Foundation, Inc.
 
 ;; Author: Eric Schulte
 ;; Keywords: literate programming, reproducible research
index cdb528a..5dec244 100644 (file)
@@ -1,6 +1,6 @@
 ;;; ob-calc.el --- org-babel functions for calc code evaluation
 
-;; Copyright (C) 2010-2014 Free Software Foundation, Inc.
+;; Copyright (C) 2010-2015 Free Software Foundation, Inc.
 
 ;; Author: Eric Schulte
 ;; Keywords: literate programming, reproducible research
index 21a3ef8..68f748c 100644 (file)
@@ -1,6 +1,6 @@
 ;;; ob-clojure.el --- org-babel functions for clojure evaluation
 
-;; Copyright (C) 2009-2014 Free Software Foundation, Inc.
+;; Copyright (C) 2009-2015 Free Software Foundation, Inc.
 
 ;; Author: Joel Boehland, Eric Schulte, Oleh Krehel
 ;;
index 7c768d3..afbbf84 100644 (file)
@@ -1,6 +1,6 @@
 ;;; ob-comint.el --- org-babel functions for interaction with comint buffers
 
-;; Copyright (C) 2009-2014 Free Software Foundation, Inc.
+;; Copyright (C) 2009-2015 Free Software Foundation, Inc.
 
 ;; Author: Eric Schulte
 ;; Keywords: literate programming, reproducible research, comint
index b6ebcff..0147786 100644 (file)
@@ -1,6 +1,6 @@
 ;;; ob-coq.el --- org-babel functions for Coq
 
-;; Copyright (C) 2010-2014 Free Software Foundation, Inc.
+;; Copyright (C) 2010-2015 Free Software Foundation, Inc.
 
 ;; Author: Eric Schulte
 ;; Keywords: literate programming, reproducible research
index 971cb64..f642b18 100644 (file)
@@ -187,14 +187,6 @@ This string must include a \"%s\" which will be replaced by the results."
   "^[ \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
@@ -271,8 +263,8 @@ Returns a list
                  (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 (looking-at (org-babel-named-src-block-regexp-for-name))
+           (setq name (org-match-string-no-properties 9))))
       ;; inline source block
       (when (org-babel-get-inline-src-block-matches)
        (setq head (match-beginning 0))
@@ -329,8 +321,8 @@ name of the code block."
 Do not query the user."
   (org-babel-check-confirm-evaluate info
     (not (when noeval
-          (message (format "Evaluation of this%scode-block%sis disabled."
-                           code-block block-name))))))
+          (message "Evaluation of this%scode-block%sis disabled."
+                    code-block block-name)))))
 
  ;; dynamically scoped for asynchronous export
 (defvar org-babel-confirm-evaluate-answer-no)
@@ -356,8 +348,8 @@ of potentially harmful code."
                    (yes-or-no-p
                     (format "Evaluate this%scode block%son your system? "
                             code-block block-name)))
-            (message (format "Evaluation of this%scode-block%sis aborted."
-                             code-block block-name)))))))
+            (message "Evaluation of this%scode-block%sis aborted."
+                      code-block block-name))))))
 
 ;;;###autoload
 (defun org-babel-execute-safely-maybe ()
@@ -461,11 +453,13 @@ then run `org-babel-switch-to-session'."
     (colnames  . ((nil no yes)))
     (comments  . ((no link yes org both noweb)))
     (dir       . :any)
-    (eval      . ((never query)))
+    (eval      . ((yes no no-export strip-export never-export eval never
+                       query)))
     (exports   . ((code results both none)))
     (epilogue   . :any)
     (file      . :any)
     (file-desc  . :any)
+    (file-ext   . :any)
     (hlines    . ((no yes)))
     (mkdirp    . ((yes no)))
     (no-expand)
@@ -592,10 +586,15 @@ to raise errors for all languages.")
 (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]\\(?:^[[:space:]]*#.*[\r\n]\\)*"
+(defun org-babel-named-src-block-regexp-for-name (&optional name)
+  "This generates a regexp used to match a src block named NAME.
+If NAME is nil, match any name.  Matched name is then put in
+match group 9.  Other match groups are defined in
+`org-babel-src-block-regexp'."
+  (concat org-babel-src-name-regexp
+         (concat (if name (regexp-quote name) "\\(?9:.*?\\)") "[ \t]*" )
+         "\\(?:\n[ \t]*#\\+\\S-+:.*\\)*?"
+         "\n"
          (substring org-babel-src-block-regexp 1)))
 
 (defun org-babel-named-data-regexp-for-name (name)
@@ -654,7 +653,8 @@ block."
         (cache-current-p
          (save-excursion ;; return cached result
            (goto-char (org-babel-where-is-src-block-result nil info))
-           (end-of-line 1) (forward-char 1)
+           (forward-line)
+           (skip-chars-forward " \t")
            (let ((result (org-babel-read-result)))
              (message (replace-regexp-in-string
                        "%" "%%" (format "%S" result))) result)))
@@ -1409,48 +1409,45 @@ specified in the properties of the current outline entry."
   (save-match-data
     (list
      ;; DEPRECATED header arguments specified as separate property at
-     ;; point of definition
-     (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))))))))))
+     ;; point of definition.
+     (org-babel-parse-multiple-vars
+      (delq nil
+           (mapcar
+            (lambda (header)
+              (let* ((arg (symbol-name (car header)))
+                     (val (org-entry-get (point) arg t)))
+                (and val
+                     (cons (intern (concat ":" arg))
+                           (org-babel-read val)))))
+            (org-babel-combine-header-arg-lists
+             org-babel-common-header-args-w-values
+             (let ((sym (intern (concat "org-babel-header-args:" lang))))
+               (and (boundp sym) (symbol-value sym)))))))
      ;; header arguments specified with the header-args property at
-     ;; point of call
+     ;; point of call.
      (org-babel-parse-header-arguments
       (org-entry-get org-babel-current-src-block-location
-                    "header-args" 'inherit))
-     (when lang ;; language-specific header arguments at point of call
-        (org-babel-parse-header-arguments
-         (org-entry-get org-babel-current-src-block-location
-                        (concat "header-args:" lang) 'inherit))))))
+                    "header-args"
+                    'inherit))
+     (and lang  ; language-specific header arguments at point of call
+         (org-babel-parse-header-arguments
+          (org-entry-get org-babel-current-src-block-location
+                         (concat "header-args:" lang)
+                         'inherit))))))
 
 (defvar org-src-preserve-indentation) ;; declare defcustom from org-src
 (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)))
+  (let* ((block-indentation (string-width (match-string 1)))
+        (lang (org-match-string-no-properties 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 "")))))
+         (body (let* ((body (org-match-string-no-properties 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)))))
@@ -1758,23 +1755,22 @@ If the point is not on a source block then return nil."
 (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."
+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)))))
+    (goto-char (point-min))
+    (ignore-errors
+      (org-next-block 1 nil (org-babel-named-src-block-regexp-for-name name)))))
 
 (defun org-babel-src-block-names (&optional file)
   "Returns the names of source blocks in FILE or the current buffer."
+  (when file (find-file file))
   (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)))
+    (goto-char (point-min))
+    (let ((re (org-babel-named-src-block-regexp-for-name))
+         names)
+      (while (ignore-errors (org-next-block 1 nil re))
+       (push (org-match-string-no-properties 9) names))
       names)))
 
 ;;;###autoload
@@ -1975,8 +1971,8 @@ following the source block."
        (goto-char end)
        (unless beg
          (if (looking-at "[\n\r]") (forward-char 1) (insert "\n")))
+       (when (wholenump indent) (indent-to indent))
        (insert (concat
-                (when (wholenump indent) (make-string indent ? ))
                 "#+" org-babel-results-keyword
                 (when hash
                   (if org-babel-hash-show-time
@@ -1987,7 +1983,7 @@ following the source block."
                 (when name (concat " " name)) "\n"))
        (unless beg (insert "\n") (backward-char))
        (beginning-of-line 0)
-       (if hash (org-babel-hide-hash))
+       (when hash (org-babel-hide-hash))
        (point)))))
 
 (defvar org-block-regexp)
@@ -2163,8 +2159,8 @@ INFO may provide the values of these header arguments (in the
                 (and (member "list" result-params) "`:results list'"))))
             (results-switches
              (cdr (assoc :results_switches (nth 2 info))))
-            (visible-beg (copy-marker (point-min)))
-            (visible-end (copy-marker (point-max)))
+            (visible-beg (point-min-marker))
+            (visible-end (point-max-marker))
             ;; When results exist outside of the current visible
             ;; region of the buffer, be sure to widen buffer to
             ;; update them.
@@ -2848,7 +2844,7 @@ block but are passed literally to the \"example-block\"."
 (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 and evaluate it as
+\"(\", \"'\", \"\\=`\" or a \"[\") then read and evaluate it as
 lisp, otherwise return it unmodified as a string.  Optional
 argument INHIBIT-LISP-EVAL inhibits lisp evaluation for
 situations in which is it not appropriate."
@@ -2980,6 +2976,7 @@ Emacs shutdown."))
                 (member "html" ,params)
                 (member "code" ,params)
                 (member "pp" ,params)
+                (member "file" ,params)
                 (and (or (member "output" ,params)
                          (member "raw"    ,params)
                          (member "org"    ,params)
index 2fedb35..a0f0ad1 100644 (file)
@@ -1,6 +1,6 @@
 ;;; ob-css.el --- org-babel functions for css evaluation
 
-;; Copyright (C) 2009-2014 Free Software Foundation, Inc.
+;; Copyright (C) 2009-2015 Free Software Foundation, Inc.
 
 ;; Author: Eric Schulte
 ;; Keywords: literate programming, reproducible research
index 888cafc..081cddf 100644 (file)
@@ -1,6 +1,6 @@
 ;;; ob-ditaa.el --- org-babel functions for ditaa evaluation
 
-;; Copyright (C) 2009-2014 Free Software Foundation, Inc.
+;; Copyright (C) 2009-2015 Free Software Foundation, Inc.
 
 ;; Author: Eric Schulte
 ;; Keywords: literate programming, reproducible research
index 1e399e7..2f56208 100644 (file)
@@ -1,6 +1,6 @@
 ;;; ob-dot.el --- org-babel functions for dot evaluation
 
-;; Copyright (C) 2009-2014 Free Software Foundation, Inc.
+;; Copyright (C) 2009-2015 Free Software Foundation, Inc.
 
 ;; Author: Eric Schulte
 ;; Keywords: literate programming, reproducible research
index f9f3671..5eb7003 100644 (file)
@@ -1,6 +1,6 @@
 ;;; ob-emacs-lisp.el --- org-babel functions for emacs-lisp code evaluation
 
-;; Copyright (C) 2009-2014 Free Software Foundation, Inc.
+;; Copyright (C) 2009-2015 Free Software Foundation, Inc.
 
 ;; Author: Eric Schulte
 ;; Keywords: literate programming, reproducible research
index b3ce2af..d94b695 100644 (file)
@@ -1,6 +1,6 @@
 ;;; ob-eval.el --- org-babel functions for external code evaluation
 
-;; Copyright (C) 2009-2014 Free Software Foundation, Inc.
+;; Copyright (C) 2009-2015 Free Software Foundation, Inc.
 
 ;; Author: Eric Schulte
 ;; Keywords: literate programming, reproducible research, comint
index decdb8e..1f01973 100644 (file)
@@ -1,6 +1,6 @@
 ;;; ob-exp.el --- Exportation of org-babel source blocks
 
-;; Copyright (C) 2009-2014 Free Software Foundation, Inc.
+;; Copyright (C) 2009-2015 Free Software Foundation, Inc.
 
 ;; Authors: Eric Schulte
 ;;     Dan Davison
@@ -41,7 +41,7 @@
 (declare-function org-in-commented-heading-p "org" (&optional no-inheritance))
 (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-link-search "org" (s &optional 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" ())
index baeb4ba..d32092a 100644 (file)
@@ -1,6 +1,6 @@
 ;;; ob-fortran.el --- org-babel functions for fortran
 
-;; Copyright (C) 2011-2014 Free Software Foundation, Inc.
+;; Copyright (C) 2011-2015 Free Software Foundation, Inc.
 
 ;; Authors: Sergey Litvinov
 ;;       Eric Schulte
@@ -149,15 +149,14 @@ of the same value."
      ;; val is a matrix
      ((and (listp val) (org-every #'listp val))
       (format "real, parameter :: %S(%d,%d) = transpose( reshape( %s , (/ %d, %d /) ) )\n"
-             var (length val) (length (car val)) 
+             var (length val) (length (car val))
              (org-babel-fortran-transform-list val)
              (length (car val)) (length val)))
      ((listp val)
       (format "real, parameter :: %S(%d) = %s\n"
              var (length val) (org-babel-fortran-transform-list val)))
      (t
-      (error (format "the type of parameter %s is not supported by ob-fortran"
-                    var))))))
+      (error "the type of parameter %s is not supported by ob-fortran" var)))))
 
 (defun org-babel-fortran-transform-list (val)
   "Return a fortran representation of enclose syntactic lists."
index a350186..8490b16 100644 (file)
@@ -1,6 +1,6 @@
 ;;; ob-gnuplot.el --- org-babel functions for gnuplot evaluation
 
-;; Copyright (C) 2009-2014 Free Software Foundation, Inc.
+;; Copyright (C) 2009-2015 Free Software Foundation, Inc.
 
 ;; Author: Eric Schulte
 ;; Keywords: literate programming, reproducible research
index 8797ec9..91100d2 100644 (file)
@@ -1,6 +1,6 @@
 ;;; ob-groovy.el --- org-babel functions for Groovy evaluation
 
-;; Copyright (C) 2013-2014 Free Software Foundation, Inc.
+;; Copyright (C) 2013-2015 Free Software Foundation, Inc.
 
 ;; Author: Miro Bezjak
 ;; Keywords: literate programming, reproducible research
index 2e1d390..e7e9cb4 100644 (file)
@@ -1,6 +1,6 @@
 ;;; ob-haskell.el --- org-babel functions for haskell evaluation
 
-;; Copyright (C) 2009-2014 Free Software Foundation, Inc.
+;; Copyright (C) 2009-2015 Free Software Foundation, Inc.
 
 ;; Author: Eric Schulte
 ;; Keywords: literate programming, reproducible research
index c309b88..a5e5cda 100644 (file)
@@ -1,6 +1,6 @@
 ;;; ob-io.el --- org-babel functions for Io evaluation
 
-;; Copyright (C) 2012-2014 Free Software Foundation, Inc.
+;; Copyright (C) 2012-2015 Free Software Foundation, Inc.
 
 ;; Author: Andrzej Lichnerowicz
 ;; Keywords: literate programming, reproducible research
index 8c64171..f808911 100644 (file)
@@ -1,6 +1,6 @@
 ;;; ob-java.el --- org-babel functions for java evaluation
 
-;; Copyright (C) 2011-2014 Free Software Foundation, Inc.
+;; Copyright (C) 2011-2015 Free Software Foundation, Inc.
 
 ;; Author: Eric Schulte
 ;; Keywords: literate programming, reproducible research
index e126787..f8ce300 100644 (file)
@@ -1,6 +1,6 @@
 ;;; ob-js.el --- org-babel functions for Javascript
 
-;; Copyright (C) 2010-2014 Free Software Foundation, Inc.
+;; Copyright (C) 2010-2015 Free Software Foundation, Inc.
 
 ;; Author: Eric Schulte
 ;; Keywords: literate programming, reproducible research, js
index dc1f437..7b70998 100644 (file)
@@ -1,6 +1,6 @@
 ;;; ob-keys.el --- key bindings for org-babel
 
-;; Copyright (C) 2009-2014 Free Software Foundation, Inc.
+;; Copyright (C) 2009-2015 Free Software Foundation, Inc.
 
 ;; Author: Eric Schulte
 ;; Keywords: literate programming, reproducible research
index 2727a2a..17e1803 100644 (file)
@@ -1,6 +1,6 @@
 ;;; ob-latex.el --- org-babel functions for latex "evaluation"
 
-;; Copyright (C) 2009-2014 Free Software Foundation, Inc.
+;; Copyright (C) 2009-2015 Free Software Foundation, Inc.
 
 ;; Author: Eric Schulte
 ;; Keywords: literate programming, reproducible research
   '((:results . "latex") (:exports . "results"))
   "Default arguments to use when evaluating a LaTeX source block.")
 
+(defconst org-babel-header-args:latex
+  '((border      . :any)
+    (fit          . :any)
+    (iminoptions  . :any)
+    (imoutoptions . :any)
+    (packages     . :any)
+    (pdfheight    . :any)
+    (pdfpng       . :any)
+    (pdfwidth     . :any))
+  "LaTeX-specific header arguments.")
+
 (defcustom org-babel-latex-htlatex "htlatex"
   "The htlatex command to enable conversion of latex to SVG or HTML."
   :group 'org-babel
index 806fec6..cda2d32 100644 (file)
@@ -1,6 +1,6 @@
 ;;; ob-ledger.el --- org-babel functions for ledger evaluation
 
-;; Copyright (C) 2010-2014 Free Software Foundation, Inc.
+;; Copyright (C) 2010-2015 Free Software Foundation, Inc.
 
 ;; Author: Eric S Fraga
 ;; Keywords: literate programming, reproducible research, accounting
index 43433a3..fe0416e 100644 (file)
@@ -1,6 +1,6 @@
 ;;; ob-lilypond.el --- org-babel functions for lilypond evaluation
 
-;; Copyright (C) 2010-2014 Free Software Foundation, Inc.
+;; Copyright (C) 2010-2015 Free Software Foundation, Inc.
 
 ;; Author: Martyn Jago
 ;; Keywords: babel language, literate programming
@@ -62,12 +62,15 @@ org-babel-lilypond-play-midi-post-tangle determines whether to automate the
 playing of the resultant midi file.  If the value is nil,
 the midi file is not automatically played.  Default value is t")
 
-(defconst org-babel-lilypond-ly-command
-  "Command to execute lilypond on your system.")
-(defconst org-babel-lilypond-pdf-command
-  "Command to show a PDF file on your system.")
-(defconst org-babel-lilypond-midi-command
-  "Command to play a MIDI file on your system.")
+(defvar org-babel-lilypond-ly-command ""
+  "Command to execute lilypond on your system.
+Do not set it directly.  Customize `org-babel-lilypond-commands' instead.")
+(defvar org-babel-lilypond-pdf-command ""
+  "Command to show a PDF file on your system.
+Do not set it directly.  Customize `org-babel-lilypond-commands' instead.")
+(defvar org-babel-lilypond-midi-command ""
+  "Command to play a MIDI file on your system.
+Do not set it directly.  Customize `org-babel-lilypond-commands' instead.")
 (defcustom org-babel-lilypond-commands
   (cond
    ((eq system-type 'darwin)
@@ -96,33 +99,27 @@ you can leave the string empty on this case."
      org-babel-lilypond-midi-command (nth 2 value))))
 
 (defvar org-babel-lilypond-gen-png nil
-  "Image generation (png) can be turned on by default by setting
-ORG-BABEL-LILYPOND-GEN-PNG to t")
+  "Non-nil means image generation (PNG) is turned on by default.")
 
 (defvar org-babel-lilypond-gen-svg nil
-  "Image generation (SVG) can be turned on by default by setting
-ORG-BABEL-LILYPOND-GEN-SVG to t")
+  "Non-nil means image generation (SVG) is be turned on by default.")
 
 (defvar org-babel-lilypond-gen-html nil
-  "HTML generation can be turned on by default by setting
-ORG-BABEL-LILYPOND-GEN-HTML to t")
+  "Non-nil means HTML generation is turned on by default.")
 
 (defvar org-babel-lilypond-gen-pdf nil
-  "PDF generation can be turned on by default by setting
-ORG-BABEL-LILYPOND-GEN-PDF to t")
+  "Non-nil means PDF generation is be turned on by default.")
 
 (defvar org-babel-lilypond-use-eps nil
-  "You can force the compiler to use the EPS backend by setting
-ORG-BABEL-LILYPOND-USE-EPS to t")
+  "Non-nil forces the compiler to use the EPS backend.")
 
 (defvar org-babel-lilypond-arrange-mode nil
-  "Arrange mode is turned on by setting ORG-BABEL-LILYPOND-ARRANGE-MODE
-to t.  In Arrange mode the following settings are altered
-from default...
+  "Non-nil turns Arrange mode on.
+In Arrange mode the following settings are altered from default:
 :tangle yes,    :noweb yes
 :results silent :comments yes.
 In addition lilypond block execution causes tangling of all lilypond
-blocks")
+blocks.")
 
 (defun org-babel-expand-body:lilypond (body params)
   "Expand BODY according to PARAMS, return the expanded body."
index a59dab3..bd80dee 100644 (file)
@@ -1,6 +1,6 @@
 ;;; ob-lisp.el --- org-babel functions for common lisp evaluation
 
-;; Copyright (C) 2009-2014 Free Software Foundation, Inc.
+;; Copyright (C) 2009-2015 Free Software Foundation, Inc.
 
 ;; Authors: Joel Boehland
 ;;      Eric Schulte
index af7e66e..b43a9b3 100644 (file)
@@ -1,6 +1,6 @@
 ;;; ob-makefile.el --- org-babel functions for makefile evaluation
 
-;; Copyright (C) 2009-2014 Free Software Foundation, Inc.
+;; Copyright (C) 2009-2015 Free Software Foundation, Inc.
 
 ;; Author: Eric Schulte
 ;;        Thomas S. Dye
index ef77de3..31464f9 100644 (file)
@@ -1,6 +1,6 @@
 ;;; ob-matlab.el --- org-babel support for matlab evaluation
 
-;; Copyright (C) 2010-2014 Free Software Foundation, Inc.
+;; Copyright (C) 2010-2015 Free Software Foundation, Inc.
 
 ;; Author: Dan Davison
 ;; Keywords: literate programming, reproducible research
index 4e559d1..02e96b8 100644 (file)
@@ -1,6 +1,6 @@
 ;;; ob-maxima.el --- org-babel functions for maxima evaluation
 
-;; Copyright (C) 2009-2014 Free Software Foundation, Inc.
+;; Copyright (C) 2009-2015 Free Software Foundation, Inc.
 
 ;; Author: Eric S Fraga
 ;;     Eric Schulte
index 4a4dc05..6d57210 100644 (file)
@@ -1,6 +1,6 @@
 ;;; ob-msc.el --- org-babel functions for mscgen evaluation
 
-;; Copyright (C) 2010-2014 Free Software Foundation, Inc.
+;; Copyright (C) 2010-2015 Free Software Foundation, Inc.
 
 ;; Author: Juan Pechiar
 ;; Keywords: literate programming, reproducible research
index 14b55d2..094b32c 100644 (file)
@@ -1,6 +1,6 @@
 ;;; ob-octave.el --- org-babel functions for octave and matlab evaluation
 
-;; Copyright (C) 2010-2014 Free Software Foundation, Inc.
+;; Copyright (C) 2010-2015 Free Software Foundation, Inc.
 
 ;; Author: Dan Davison
 ;; Keywords: literate programming, reproducible research
index bc02f23..ab0db67 100644 (file)
@@ -1,6 +1,6 @@
 ;;; ob-org.el --- org-babel functions for org code block evaluation
 
-;; Copyright (C) 2010-2014 Free Software Foundation, Inc.
+;; Copyright (C) 2010-2015 Free Software Foundation, Inc.
 
 ;; Author: Eric Schulte
 ;; Keywords: literate programming, reproducible research
index ff4cbea..d27c18e 100644 (file)
@@ -1,6 +1,6 @@
 ;;; ob-perl.el --- org-babel functions for perl evaluation
 
-;; Copyright (C) 2009-2014 Free Software Foundation, Inc.
+;; Copyright (C) 2009-2015 Free Software Foundation, Inc.
 
 ;; Authors: Dan Davison
 ;;      Eric Schulte
index b240138..5b696f1 100644 (file)
@@ -1,6 +1,6 @@
 ;;; ob-picolisp.el --- org-babel functions for picolisp evaluation
 
-;; Copyright (C) 2010-2014 Free Software Foundation, Inc.
+;; Copyright (C) 2010-2015 Free Software Foundation, Inc.
 
 ;; Authors: Thorsten Jolitz
 ;;      Eric Schulte
index ebc5a10..f0f7220 100644 (file)
@@ -1,6 +1,6 @@
 ;;; ob-plantuml.el --- org-babel functions for plantuml evaluation
 
-;; Copyright (C) 2010-2014 Free Software Foundation, Inc.
+;; Copyright (C) 2010-2015 Free Software Foundation, Inc.
 
 ;; Author: Zhang Weize
 ;; Keywords: literate programming, reproducible research
diff --git a/.emacs.d/elisp/org/ob-processing.el b/.emacs.d/elisp/org/ob-processing.el
new file mode 100644 (file)
index 0000000..d983afe
--- /dev/null
@@ -0,0 +1,197 @@
+;;; ob-processing.el --- Babel functions for evaluation of processing
+
+;; Copyright (C) 2015 Free Software Foundation, Inc.
+
+;; Author: Jarmo Hurri (adapted from ob-asymptote.el written by Eric Schulte)
+;; Keywords: literate programming, reproducible research
+;; Homepage: http://orgmode.org
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
+
+;;; Commentary:
+
+;; Babel support for evaluating processing source code.
+;;
+;; This differs from most standard languages in that
+;;
+;; 1) there is no such thing as a "session" in processing
+;;
+;; 2) results can only be exported as html; in this case, the
+;;    processing code is embedded via a file into a javascript block
+;;    using the processing.js module; the script then draws the
+;;    resulting output when the web page is viewed in a browser; note
+;;    that the user is responsible for making sure that processing.js
+;;    is available on the website
+;;
+;; 3) it is possible to interactively view the sketch of the
+;;    Processing code block via Processing 2.0 Emacs mode, using
+;;    `org-babel-processing-view-sketch'.  You can bind this command
+;;    to, e.g., C-c C-v C-k with
+;;
+;;      (define-key org-babel-map (kbd "C-k") 'org-babel-processing-view-sketch)
+
+
+;;; Requirements:
+
+;; - processing2-emacs mode :: https://github.com/ptrv/processing2-emacs
+;; - Processing.js module :: http://processingjs.org/
+
+;;; Code:
+(require 'ob)
+(require 'sha1)
+(eval-when-compile (require 'cl))
+
+(declare-function processing-sketch-run "ext:processing-mode" ())
+
+(defvar org-babel-temporary-directory)
+
+(defvar org-babel-tangle-lang-exts)
+(add-to-list 'org-babel-tangle-lang-exts '("processing" . "pde"))
+
+;; Default header tags depend on whether exporting html or not; if not
+;; exporting html, then no results are produced; otherwise results are
+;; HTML.
+(defvar org-babel-default-header-args:processing
+  '((:results . "html") (:exports . "results"))
+  "Default arguments when evaluating a Processing source block.")
+
+(defvar org-babel-processing-processing-js-filename "processing.js"
+  "Filename of the processing.js file.")
+
+(defun org-babel-processing-view-sketch ()
+  "Show the sketch of the Processing block under point in an external viewer."
+  (interactive)
+  (require 'processing-mode)
+  (let ((info (org-babel-get-src-block-info)))
+    (if (string= (nth 0 info) "processing")
+       (let* ((body (nth 1 info))
+              (params (org-babel-process-params (nth 2 info)))
+              (sketch-code
+               (org-babel-expand-body:generic
+                body
+                params
+                (org-babel-variable-assignments:processing params))))
+         ;; Note: sketch filename can not contain a hyphen, since it
+         ;; has to be a valid java class name; for this reason
+         ;; make-temp-file is repeated until no hyphen is in the
+         ;; name; also sketch dir name must be the same as the
+         ;; basename of the sketch file.
+         (let* ((temporary-file-directory org-babel-temporary-directory)
+                (sketch-dir
+                 (let (sketch-dir-candidate)
+                   (while
+                       (progn
+                         (setq sketch-dir-candidate
+                               (make-temp-file "processing" t))
+                         (when (org-string-match-p
+                                "-"
+                                (file-name-nondirectory sketch-dir-candidate))
+                           (delete-directory sketch-dir-candidate)
+                           t)))
+                   sketch-dir-candidate))
+                (sketch-filename
+                 (concat sketch-dir
+                         "/"
+                         (file-name-nondirectory sketch-dir)
+                         ".pde")))
+           (with-temp-file sketch-filename (insert sketch-code))
+           (find-file sketch-filename)
+           (processing-sketch-run)
+           (kill-buffer)))
+      (message "Not inside a Processing source block."))))
+
+(defun org-babel-execute:processing (body params)
+  "Execute a block of Processing code.
+This function is called by `org-babel-execute-src-block'."
+  (let ((sketch-code
+        (org-babel-expand-body:generic
+         body
+         params
+         (org-babel-variable-assignments:processing params))))
+    ;; Results are HTML.
+    (let ((sketch-canvas-id (concat "ob-" (sha1 sketch-code))))
+      (concat "<script src=\""
+             org-babel-processing-processing-js-filename
+             "\"></script>\n <script type=\"text/processing\""
+             " data-processing-target=\""
+             sketch-canvas-id
+             "\">\n"
+             sketch-code
+             "\n</script> <canvas id=\""
+             sketch-canvas-id
+             "\"></canvas>"))))
+
+(defun org-babel-prep-session:processing (session params)
+  "Return an error if the :session header argument is set.
+Processing does not support sessions"
+  (error "Processing does not support sessions"))
+
+(defun org-babel-variable-assignments:processing (params)
+  "Return list of processing statements assigning the block's variables."
+  (mapcar #'org-babel-processing-var-to-processing
+         (mapcar #'cdr (org-babel-get-header params :var))))
+
+(defun org-babel-processing-var-to-processing (pair)
+  "Convert an elisp value into a Processing variable.
+The elisp value PAIR is converted into Processing code specifying
+a variable of the same value."
+  (let ((var (car pair))
+        (val (let ((v (cdr pair)))
+              (if (symbolp v) (symbol-name v) v))))
+    (cond
+     ((integerp val)
+      (format "int %S=%S;" var val))
+     ((floatp val)
+      (format "float %S=%S;" var val))
+     ((stringp val)
+      (format "String %S=\"%s\";" var val))
+     ((and (listp val) (not (listp (car val))))
+      (let* ((type (org-babel-processing-define-type val))
+            (fmt (if (eq 'String type) "\"%s\"" "%s"))
+            (vect (mapconcat (lambda (e) (format fmt e)) val ", ")))
+       (format "%s[] %S={%s};" type var vect)))
+     ((listp val)
+      (let* ((type (org-babel-processing-define-type val))
+            (fmt (if (eq 'String type) "\"%s\"" "%s"))
+             (array (mapconcat (lambda (row)
+                                (concat "{"
+                                        (mapconcat (lambda (e) (format fmt e))
+                                                   row ", ")
+                                        "}"))
+                              val ",")))
+        (format "%S[][] %S={%s};" type var array))))))
+
+(defun org-babel-processing-define-type (data)
+  "Determine type of DATA.
+
+DATA is a list.  Return type as a symbol.
+
+The type is `String' if any element in DATA is
+a string.  Otherwise, it is either `float', if some elements are
+floats, or `int'."
+  (let* ((type 'int)
+        find-type                      ; For byte-compiler.
+        (find-type
+         (lambda (row)
+           (dolist (e row type)
+             (cond ((listp e) (setq type (funcall find-type e)))
+                   ((stringp e) (throw 'exit 'String))
+                   ((floatp e) (setq type 'float)))))))
+    (catch 'exit (funcall find-type data))))
+
+(provide 'ob-processing)
+
+;;; ob-processing.el ends here
index 6172895..b8a921e 100644 (file)
@@ -1,6 +1,6 @@
 ;;; ob-ref.el --- org-babel functions for referencing external data
 
-;; Copyright (C) 2009-2014 Free Software Foundation, Inc.
+;; Copyright (C) 2009-2015 Free Software Foundation, Inc.
 
 ;; Authors: Eric Schulte
 ;;      Dan Davison
@@ -53,6 +53,8 @@
 (eval-when-compile
   (require 'cl))
 
+(declare-function org-end-of-meta-data "org" (&optional full))
+(declare-function org-find-property "org" (property &optional value))
 (declare-function org-remove-if-not "org" (predicate seq))
 (declare-function org-at-table-p "org" (&optional table-type))
 (declare-function org-count "org" (CL-ITEM CL-SEQ))
@@ -98,29 +100,24 @@ the variable."
                out))))))
 
 (defun org-babel-ref-goto-headline-id (id)
-  (goto-char (point-min))
-  (let ((rx (regexp-quote id)))
-    (or (re-search-forward
-        (concat "^[ \t]*:CUSTOM_ID:[ \t]+" rx "[ \t]*$") nil t)
-       (let* ((file (org-id-find-id-file id))
-              (m (when file (org-id-find-id-in-file id file 'marker))))
-         (when (and file m)
-           (message "file:%S" file)
-           (org-pop-to-buffer-same-window (marker-buffer m))
-           (goto-char m)
-           (move-marker m nil)
-           (org-show-context)
-           t)))))
+  (or (let ((h (org-find-property "CUSTOM_ID" id)))
+       (when h (goto-char h)))
+      (let* ((file (org-id-find-id-file id))
+            (m (when file (org-id-find-id-in-file id file 'marker))))
+       (when (and file m)
+         (message "file:%S" file)
+         (org-pop-to-buffer-same-window (marker-buffer m))
+         (goto-char m)
+         (move-marker m nil)
+         (org-show-context)
+         t))))
 
 (defun org-babel-ref-headline-body ()
   (save-restriction
     (org-narrow-to-subtree)
     (buffer-substring
      (save-excursion (goto-char (point-min))
-                    (forward-line 1)
-                    (when (looking-at "[ \t]*:PROPERTIES:")
-                      (re-search-forward ":END:" nil)
-                      (forward-char))
+                    (org-end-of-meta-data)
                     (point))
      (point-max))))
 
index 26285eb..0ff460e 100644 (file)
@@ -1,6 +1,6 @@
 ;;; ob-ruby.el --- org-babel functions for ruby evaluation
 
-;; Copyright (C) 2009-2014 Free Software Foundation, Inc.
+;; Copyright (C) 2009-2015 Free Software Foundation, Inc.
 
 ;; Author: Eric Schulte
 ;; Keywords: literate programming, reproducible research
@@ -58,7 +58,7 @@
   :type 'string)
 
 (defcustom org-babel-ruby-nil-to 'hline
-  "Replace 'nil' in ruby tables with this before returning."
+  "Replace nil in ruby tables with this before returning."
   :group 'org-babel
   :version "24.4"
   :package-version '(Org . "8.0")
@@ -201,11 +201,7 @@ return the value of the last statement in BODY, as elisp."
                              org-babel-ruby-pp-wrapper-method
                            org-babel-ruby-wrapper-method)
                          body (org-babel-process-file-name tmp-file 'noquote)))
-                (let ((raw (org-babel-eval-read-file tmp-file)))
-                   (if (or (member "code" result-params)
-                           (member "pp" result-params))
-                       raw
-                     (org-babel-ruby-table-or-string raw))))))
+                (org-babel-eval-read-file tmp-file))))
     ;; comint session evaluation
     (case result-type
       (output
index 78c0c95..a39248d 100644 (file)
@@ -1,6 +1,6 @@
 ;;; ob-sass.el --- org-babel functions for the sass css generation language
 
-;; Copyright (C) 2009-2014 Free Software Foundation, Inc.
+;; Copyright (C) 2009-2015 Free Software Foundation, Inc.
 
 ;; Author: Eric Schulte
 ;; Keywords: literate programming, reproducible research
index 838bc8f..656667a 100644 (file)
@@ -1,6 +1,6 @@
 ;;; ob-scala.el --- org-babel functions for Scala evaluation
 
-;; Copyright (C) 2012-2014 Free Software Foundation, Inc.
+;; Copyright (C) 2012-2015 Free Software Foundation, Inc.
 
 ;; Author: Andrzej Lichnerowicz
 ;; Keywords: literate programming, reproducible research
index 2095534..b10dfc3 100644 (file)
@@ -1,6 +1,6 @@
 ;;; ob-scheme.el --- org-babel functions for Scheme
 
-;; Copyright (C) 2010-2014 Free Software Foundation, Inc.
+;; Copyright (C) 2010-2015 Free Software Foundation, Inc.
 
 ;; Authors: Eric Schulte
 ;;         Michael Gauland
index 1d4ccdd..54ae5e1 100644 (file)
@@ -1,6 +1,6 @@
 ;;; ob-screen.el --- org-babel support for interactive terminal
 
-;; Copyright (C) 2009-2014 Free Software Foundation, Inc.
+;; Copyright (C) 2009-2015 Free Software Foundation, Inc.
 
 ;; Author: Benjamin Andresen
 ;; Keywords: literate programming, interactive shell
diff --git a/.emacs.d/elisp/org/ob-sed.el b/.emacs.d/elisp/org/ob-sed.el
new file mode 100644 (file)
index 0000000..9e3db37
--- /dev/null
@@ -0,0 +1,107 @@
+;;; ob-sed.el --- org-babel functions for sed scripts
+
+;; Copyright (C) 2015 Free Software Foundation
+
+;; Author: Bjarte Johansen
+;; Keywords: literate programming, reproducible research
+;; Version: 0.1.0
+
+;; This file is part of GNU Emacs.
+
+;;; License:
+
+;; This program is free software; you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation; either version 3, or (at your option)
+;; any later version.
+;;
+;; This program is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+;;
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>.
+
+;;; Commentary:
+
+;; Provides a way to evaluate sed scripts in Org mode.
+
+;;; Usage:
+
+;; Add to your Emacs config:
+
+;; (org-babel-do-load-languages
+;;  'org-babel-load-languages
+;;  '((sed . t)))
+
+;; In addition to the normal header arguments, ob-sed also provides
+;; :cmd-line and :in-file. :cmd-line allows one to pass other flags to
+;; the sed command like the "--in-place" flag which makes sed edit the
+;; file pass to it instead of outputting to standard out or to a
+;; different file. :in-file is a header arguments that allows one to
+;; tell Org Babel which file the sed script to act on.
+
+;;; Code:
+(require 'ob)
+
+(defvar org-babel-sed-command "sed"
+  "Name of the sed executable command.")
+
+(defvar org-babel-tangle-lang-exts)
+(add-to-list 'org-babel-tangle-lang-exts '("sed" . "sed"))
+
+(defconst org-babel-header-args:sed
+  '((:cmd-line . :any)
+    (:in-file  . :any))
+  "Sed specific header arguments.")
+
+(defvar org-babel-default-header-args:sed '()
+  "Default arguments for evaluating a sed source block.")
+
+(defun org-babel-execute:sed (body params)
+  "Execute a block of sed code with Org Babel.
+BODY is the source inside a sed source block and PARAMS is an
+association list over the source block configurations.  This
+function is called by `org-babel-execute-src-block'."
+  (message "executing sed source code block")
+  (let* ((result-params (cdr (assq :result-params params)))
+         (cmd-line (cdr (assq :cmd-line params)))
+         (in-file (cdr (assq :in-file params)))
+        (code-file (let ((file (org-babel-temp-file "sed-")))
+                      (with-temp-file file
+                       (insert body)) file))
+        (stdin (let ((stdin (cdr (assq :stdin params))))
+                  (when stdin
+                    (let ((tmp (org-babel-temp-file "sed-stdin-"))
+                          (res (org-babel-ref-resolve stdin)))
+                      (with-temp-file tmp
+                        (insert res))
+                      tmp))))
+         (cmd (mapconcat #'identity
+                        (remq nil
+                              (list org-babel-sed-command
+                                    (format "--file=\"%s\"" code-file)
+                                    cmd-line
+                                    in-file))
+                        " ")))
+    (org-babel-reassemble-table
+     (let ((results
+            (cond
+             (stdin (with-temp-buffer
+                      (call-process-shell-command cmd stdin (current-buffer))
+                      (buffer-string)))
+             (t (org-babel-eval cmd "")))))
+       (when results
+         (org-babel-result-cond result-params
+          results
+          (let ((tmp (org-babel-temp-file "sed-results-")))
+            (with-temp-file tmp (insert results))
+            (org-babel-import-elisp-from-file tmp)))))
+     (org-babel-pick-name
+      (cdr (assq :colname-names params)) (cdr (assq :colnames params)))
+     (org-babel-pick-name
+      (cdr (assq :rowname-names params)) (cdr (assq :rownames params))))))
+
+(provide 'ob-sed)
+;;; ob-sed.el ends here
index 4d6d7c4..efa992f 100644 (file)
@@ -1,6 +1,6 @@
 ;;; ob-shell.el --- org-babel functions for shell evaluation
 
-;; Copyright (C) 2009-2014 Free Software Foundation, Inc.
+;; Copyright (C) 2009-2015 Free Software Foundation, Inc.
 
 ;; Author: Eric Schulte
 ;; Keywords: literate programming, reproducible research
@@ -36,7 +36,7 @@
 (declare-function org-babel-comint-with-output "ob-comint" (meta &rest body))
 (declare-function orgtbl-to-generic "org-table" (table params))
 
-(defvar org-babel-default-header-args:sh '())
+(defvar org-babel-default-header-args:shell '())
 
 (defcustom org-babel-shell-names
   '("sh" "bash" "csh" "ash" "dash" "ksh" "mksh" "posh")
@@ -64,7 +64,7 @@ This function is called by `org-babel-execute-src-block'."
                                (org-babel-ref-resolve stdin)))))
         (cmdline (cdr (assoc :cmdline params)))
          (full-body (org-babel-expand-body:generic
-                    body params (org-babel-variable-assignments:sh params))))
+                    body params (org-babel-variable-assignments:shell params))))
     (org-babel-reassemble-table
      (org-babel-sh-evaluate session full-body params stdin cmdline)
      (org-babel-pick-name
@@ -72,20 +72,20 @@ This function is called by `org-babel-execute-src-block'."
      (org-babel-pick-name
       (cdr (assoc :rowname-names params)) (cdr (assoc :rownames params))))))
 
-(defun org-babel-prep-session:sh (session params)
+(defun org-babel-prep-session:shell (session params)
   "Prepare SESSION according to the header arguments specified in PARAMS."
   (let* ((session (org-babel-sh-initiate-session session))
-        (var-lines (org-babel-variable-assignments:sh params)))
+        (var-lines (org-babel-variable-assignments:shell params)))
     (org-babel-comint-in-buffer session
       (mapc (lambda (var)
               (insert var) (comint-send-input nil t)
               (org-babel-comint-wait-for-output session)) var-lines))
     session))
 
-(defun org-babel-load-session:sh (session body params)
+(defun org-babel-load-session:shell (session body params)
   "Load BODY into SESSION."
   (save-window-excursion
-    (let ((buffer (org-babel-prep-session:sh session params)))
+    (let ((buffer (org-babel-prep-session:shell session params)))
       (with-current-buffer buffer
         (goto-char (process-mark (get-buffer-process (current-buffer))))
         (insert (org-babel-chomp body)))
@@ -129,7 +129,7 @@ This function is called by `org-babel-execute-src-block'."
        (org-babel-variable-assignments:bash_assoc varname values sep hline))
     (org-babel-variable-assignments:sh-generic varname values sep hline)))
 
-(defun org-babel-variable-assignments:sh (params)
+(defun org-babel-variable-assignments:shell (params)
   "Return list of shell statements assigning the block's variables."
   (let ((sep (cdr (assoc :separator params)))
        (hline (when (string= "yes" (cdr (assoc :hlines params)))
@@ -202,11 +202,11 @@ return the value of the last statement in BODY."
              (with-temp-file stdin-file (insert (or stdin "")))
              (with-temp-buffer
                (call-process-shell-command
-                (if shebang
-                    script-file
-                  (format "%s %s" shell-file-name script-file))
+                (concat (if shebang script-file
+                         (format "%s %s" shell-file-name script-file))
+                       (and cmdline (concat " " cmdline)))
                 stdin-file
-                (current-buffer) nil cmdline)
+               (current-buffer))
                (buffer-string))))
           (session                      ; session evaluation
            (mapconcat
index e40e45c..190d69b 100644 (file)
@@ -1,6 +1,6 @@
 ;;; ob-shen.el --- org-babel functions for Shen
 
-;; Copyright (C) 2010-2014 Free Software Foundation, Inc.
+;; Copyright (C) 2010-2015 Free Software Foundation, Inc.
 
 ;; Author: Eric Schulte
 ;; Keywords: literate programming, reproducible research, shen
index 493b3dc..2748b43 100644 (file)
@@ -1,6 +1,6 @@
 ;;; ob-sql.el --- org-babel functions for sql evaluation
 
-;; Copyright (C) 2009-2014 Free Software Foundation, Inc.
+;; Copyright (C) 2009-2015 Free Software Foundation, Inc.
 
 ;; Author: Eric Schulte
 ;; Keywords: literate programming, reproducible research
@@ -36,6 +36,7 @@
 ;; - engine
 ;; - cmdline
 ;; - dbhost
+;; - dbport
 ;; - dbuser
 ;; - dbpassword
 ;; - database
@@ -68,6 +69,7 @@
   '((engine           . :any)
     (out-file         . :any)
     (dbhost           . :any)
+    (dbport           . :any)
     (dbuser           . :any)
     (dbpassword               . :any)
     (database         . :any))
   (org-babel-sql-expand-vars
    body (mapcar #'cdr (org-babel-get-header params :var))))
 
-(defun org-babel-sql-dbstring-mysql (host user password database)
+(defun org-babel-sql-dbstring-mysql (host port user password database)
   "Make MySQL cmd line args for database connection.  Pass nil to omit that arg."
   (combine-and-quote-strings
    (delq nil
         (list (when host     (concat "-h" host))
+              (when port     (format "-P%d" port))
               (when user     (concat "-u" user))
               (when password (concat "-p" password))
               (when database (concat "-D" database))))))
@@ -102,6 +105,7 @@ 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)))
+         (dbport (cdr (assq :dbport params)))
          (dbuser (cdr (assoc :dbuser params)))
          (dbpassword (cdr (assoc :dbpassword params)))
          (database (cdr (assoc :database params)))
@@ -126,7 +130,8 @@ This function is called by `org-babel-execute-src-block'."
                                      (org-babel-process-file-name in-file)
                                      (org-babel-process-file-name out-file)))
                     ('mysql (format "mysql %s %s %s < %s > %s"
-                                   (org-babel-sql-dbstring-mysql dbhost dbuser dbpassword database)
+                                   (org-babel-sql-dbstring-mysql
+                                    dbhost dbport dbuser dbpassword database)
                                    (if colnames-p "" "-N")
                                     (or cmdline "")
                                    (org-babel-process-file-name in-file)
index 098626f..33c8d9b 100644 (file)
@@ -1,6 +1,6 @@
 ;;; ob-sqlite.el --- org-babel functions for sqlite database interaction
 
-;; Copyright (C) 2010-2014 Free Software Foundation, Inc.
+;; Copyright (C) 2010-2015 Free Software Foundation, Inc.
 
 ;; Author: Eric Schulte
 ;; Keywords: literate programming, reproducible research
diff --git a/.emacs.d/elisp/org/ob-stan.el b/.emacs.d/elisp/org/ob-stan.el
new file mode 100644 (file)
index 0000000..7891600
--- /dev/null
@@ -0,0 +1,84 @@
+;;; ob-stan.el --- org-babel functions for Stan
+
+;; Copyright (C) 2015 Free Software Foundation, Inc.
+
+;; Author: Kyle Meyer
+;; Keywords: literate programming, reproducible research
+;; Homepage: http://orgmode.org
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
+
+;;; Commentary:
+
+;; Org-Babel support for evaluating Stan [1] source code.
+;;
+;; Evaluating a Stan block can produce two different results.
+;;
+;; 1) Dump the source code contents to a file.
+;;
+;;    This file can then be used as a variable in other blocks, which
+;;    allows interfaces like RStan to use the model.
+;;
+;; 2) Compile the contents to a model file.
+;;
+;;    This provides access to the CmdStan interface.  To use this, set
+;;    `org-babel-stan-cmdstan-directory' and provide a :file argument
+;;    that does not end in ".stan".
+;;
+;; For more information and usage examples, visit
+;; http://orgmode.org/worg/org-contrib/babel/languages/ob-doc-stan.html
+;;
+;; [1] http://mc-stan.org/
+
+;;; Code:
+(require 'ob)
+(require 'org-compat)
+
+(defcustom org-babel-stan-cmdstan-directory nil
+  "CmdStan source directory.
+'make' will be called from this directory to compile the Stan
+block.  When nil, executing Stan blocks dumps the content to a
+plain text file."
+  :group 'org-babel
+  :type 'string)
+
+(defvar org-babel-default-header-args:stan
+  '((:results . "file")))
+
+(defun org-babel-execute:stan (body params)
+  "Generate Stan file from BODY according to PARAMS.
+A :file header argument must be given.  If
+`org-babel-stan-cmdstan-directory' is non-nil and the file name
+does not have a \".stan\" extension, save an intermediate
+\".stan\" file and compile the block to the named file.
+Otherwise, write the Stan code directly to the named file."
+  (let ((file (expand-file-name
+              (or (cdr (assq :file params))
+                  (user-error "Set :file argument to execute Stan blocks")))))
+    (if (or (not org-babel-stan-cmdstan-directory)
+           (org-string-match-p "\\.stan\\'" file))
+       (with-temp-file file (insert body))
+      (with-temp-file (concat file ".stan") (insert body))
+      (let ((default-directory org-babel-stan-cmdstan-directory))
+       (call-process-shell-command (concat "make " file))))
+    nil))              ; Signal that output has been written to file.
+
+(defun org-babel-prep-session:stan (session params)
+  "Return an error because Stan does not support sessions."
+  (user-error "Stan does not support sessions"))
+
+(provide 'ob-stan)
+;;; ob-stan.el ends here
index b2a8da6..3dccc71 100644 (file)
@@ -1,6 +1,6 @@
 ;;; ob-table.el --- support for calling org-babel functions from tables
 
-;; Copyright (C) 2009-2014 Free Software Foundation, Inc.
+;; Copyright (C) 2009-2015 Free Software Foundation, Inc.
 
 ;; Author: Eric Schulte
 ;; Keywords: literate programming, reproducible research
index 1c159a5..3852185 100644 (file)
@@ -1,6 +1,6 @@
 ;;; ob-tangle.el --- extract source code from org-mode files
 
-;; Copyright (C) 2009-2014 Free Software Foundation, Inc.
+;; Copyright (C) 2009-2015 Free Software Foundation, Inc.
 
 ;; Author: Eric Schulte
 ;; Keywords: literate programming, reproducible research
 ;;; Code:
 (require 'org-src)
 
+(declare-function make-directory "files" (dir &optional parents))
+(declare-function org-babel-update-block-body "org" (new-body))
+(declare-function org-back-to-heading "org" (invisible-ok))
+(declare-function org-before-first-heading-p "org" ())
 (declare-function org-edit-special "org" (&optional arg))
+(declare-function org-fill-template "org" (template alist))
+(declare-function org-heading-components "org" ())
+(declare-function org-in-commented-heading-p "org" (&optional no-inheritance))
 (declare-function org-link-escape "org" (text &optional table))
-(declare-function org-store-link "org" (arg))
 (declare-function org-open-link-from-string "org" (s &optional arg reference-buffer))
-(declare-function org-heading-components "org" ())
-(declare-function org-back-to-heading "org" (invisible-ok))
-(declare-function org-fill-template "org" (template alist))
-(declare-function org-babel-update-block-body "org" (new-body))
+(declare-function org-store-link "org" (arg))
 (declare-function org-up-heading-safe "org" ())
-(declare-function org-in-commented-heading-p "org" (&optional no-inheritance))
-(declare-function make-directory "files" (dir &optional parents))
-(declare-function org-before-first-heading-p "org" ())
+(declare-function outline-previous-heading "outline" ())
 
 (defcustom org-babel-tangle-lang-exts
   '(("emacs-lisp" . "el")
@@ -241,7 +242,7 @@ used to limit the exported source code blocks by language."
                         (base-name (cond
                                     ((string= "yes" tangle)
                                      (file-name-sans-extension
-                                      (buffer-file-name)))
+                                      (nth 1 spec)))
                                     ((string= "no" tangle) nil)
                                     ((> (length tangle) 0) tangle)))
                         (file-name (when base-name
@@ -361,13 +362,17 @@ that the appropriate major-mode is set.  SPEC has the form:
                           (when (and comments (not (string= comments "no"))
                                      (> (length text) 0))
                             (if org-babel-tangle-uncomment-comments
-                                ;; just plain comments with no processing
+                                ;; Plain comments: no processing.
                                 (insert text)
-                              ;; ensure comments are made to be
-                              ;; comments, and add a trailing newline
+                              ;; Ensure comments are made to be
+                              ;; comments, and add a trailing
+                              ;; newline.  Also ignore invisible
+                              ;; characters when commenting.
                               (comment-region
-                               (point) (progn (insert text) (point)))
-                              (end-of-line nil)
+                               (point)
+                               (progn (insert (org-no-properties text))
+                                      (point)))
+                              (end-of-line)
                               (insert "\n"))))))
     (when comment (funcall insert-comment comment))
     (when link-p
@@ -385,47 +390,35 @@ that the appropriate major-mode is set.  SPEC has the form:
        (org-fill-template org-babel-tangle-comment-format-end link-data)))))
 
 (defun org-babel-tangle-collect-blocks (&optional language tangle-file)
-  "Collect source blocks in the current Org-mode file.
+  "Collect source blocks in the current Org file.
 Return an association list of source-code block specifications of
 the form used by `org-babel-spec-to-string' grouped by language.
 Optional argument LANGUAGE can be used to limit the collected
 source code blocks by language.  Optional argument TANGLE-FILE
 can be used to limit the collected code blocks by target file."
-  (let ((block-counter 1) (current-heading "") blocks by-lang)
+  (let ((counter 0) last-heading-pos blocks)
     (org-babel-map-src-blocks (buffer-file-name)
-      ((lambda (new-heading)
-        (if (not (string= new-heading current-heading))
-            (progn
-              (setq block-counter 1)
-              (setq current-heading new-heading))
-          (setq block-counter (+ 1 block-counter))))
-       (replace-regexp-in-string "[ \t]" "-"
-                                (condition-case nil
-                                    (or (nth 4 (org-heading-components))
-                                        "(dummy for heading without text)")
-                                  (error (buffer-file-name)))))
-      (let* ((info (org-babel-get-src-block-info 'light))
-            (src-lang (nth 0 info))
-            (src-tfile (cdr (assoc :tangle (nth 2 info)))))
-        (unless (or (org-in-commented-heading-p)
-                   (string= (cdr (assoc :tangle (nth 2 info))) "no")
-                   (and tangle-file (not (equal tangle-file src-tfile))))
-          (unless (and language (not (string= language src-lang)))
-           ;; Add the spec for this block to blocks under it's language
-           (setq by-lang (cdr (assoc src-lang blocks)))
-           (setq blocks (delq (assoc src-lang blocks) blocks))
-           (setq blocks (cons
-                         (cons src-lang
-                               (cons
-                                (org-babel-tangle-single-block
-                                 block-counter)
-                                by-lang)) blocks))))))
-    ;; Ensure blocks are in the correct order
-    (setq blocks
-          (mapcar
-          (lambda (by-lang) (cons (car by-lang) (reverse (cdr by-lang))))
-          blocks))
-    blocks))
+      (let ((current-heading-pos
+            (org-with-wide-buffer
+             (org-with-limited-levels (outline-previous-heading)))))
+       (cond ((eq last-heading-pos current-heading-pos) (incf counter))
+             ((= counter 1))
+             (t (setq counter 1))))
+      (unless (org-in-commented-heading-p)
+       (let* ((info (org-babel-get-src-block-info 'light))
+              (src-lang (nth 0 info))
+              (src-tfile (cdr (assq :tangle (nth 2 info)))))
+         (unless (or (string= (cdr (assq :tangle (nth 2 info))) "no")
+                     (and tangle-file (not (equal tangle-file src-tfile)))
+                     (and language (not (string= language src-lang))))
+           ;; Add the spec for this block to blocks under its
+           ;; language.
+           (let ((by-lang (assoc src-lang blocks))
+                 (block (org-babel-tangle-single-block counter)))
+             (if by-lang (setcdr by-lang (cons block (cdr by-lang)))
+               (push (cons src-lang (list block)) blocks)))))))
+    ;; Ensure blocks are in the correct order.
+    (mapcar (lambda (b) (cons (car b) (nreverse (cdr b)))) blocks)))
 
 (defun org-babel-tangle-single-block
   (block-counter &optional only-this-block)
@@ -438,7 +431,7 @@ list to be used by `org-babel-tangle' directly."
         (start-line
          (save-restriction (widen)
                            (+ 1 (line-number-at-pos (point)))))
-        (file (buffer-file-name))
+        (file (buffer-file-name (buffer-base-buffer)))
         (src-lang (nth 0 info))
         (params (nth 2 info))
         (extra (nth 3 info))
index 87657fe..42137c2 100644 (file)
@@ -1,6 +1,6 @@
 ;;; ob.el --- working with code blocks in org-mode
 
-;; Copyright (C) 2009-2014 Free Software Foundation, Inc.
+;; Copyright (C) 2009-2015 Free Software Foundation, Inc.
 
 ;; Authors: Eric Schulte
 ;; Keywords: literate programming, reproducible research
index 9d39ef1..9f85cfa 100644 (file)
@@ -2070,7 +2070,7 @@ When nil, `q' will kill the single agenda buffer."
       (setq org-agenda-sticky new-value)
       (org-agenda-kill-all-agenda-buffers)
       (and (org-called-interactively-p 'interactive)
-          (message "Sticky agenda was %s"
+          (message "Sticky agenda %s"
                    (if org-agenda-sticky "enabled" "disabled"))))))
 
 (defvar org-agenda-buffer nil
@@ -3642,10 +3642,12 @@ FILTER-ALIST is an alist of filters we need to apply when
 
 (defun org-agenda-prepare (&optional name)
   (let ((filter-alist (if org-agenda-persistent-filter
-                         (list `(tag . ,org-agenda-tag-filter)
-                               `(re . ,org-agenda-regexp-filter)
-                               `(effort . ,org-agenda-effort-filter)
-                               `(car . ,org-agenda-category-filter)))))
+                         (with-current-buffer
+                             (get-buffer-create org-agenda-buffer-name)
+                           (list `(tag . ,org-agenda-tag-filter)
+                                 `(re . ,org-agenda-regexp-filter)
+                                 `(effort . ,org-agenda-effort-filter)
+                                 `(cat . ,org-agenda-category-filter))))))
     (if (org-agenda-use-sticky-p)
        (progn
          (put 'org-agenda-tag-filter :preset-filter nil)
@@ -3815,7 +3817,7 @@ FILTER-ALIST is an alist of filters we need to apply when
   "Make highest priority lines bold, and lowest italic."
   (interactive)
   (mapc (lambda (o) (if (eq (overlay-get o 'org-type) 'org-priority)
-                       (delete-overlay o)))
+                  (delete-overlay o)))
        (overlays-in (point-min) (point-max)))
   (save-excursion
     (let (b e p ov h l)
@@ -3833,16 +3835,17 @@ FILTER-ALIST is an alist of filters we need to apply when
              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))
+        (let ((special-face
+               (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))))
+          (if special-face (list special-face 'org-priority) 'org-priority)))
        (overlay-put ov 'org-type 'org-priority)))))
 
 (defvar org-depend-tag-blocked)
@@ -3854,36 +3857,36 @@ dimming them."
   (interactive "P")
   (when (org-called-interactively-p 'interactive)
     (message "Dim or hide blocked tasks..."))
-  (mapc (lambda (o) (if (eq (overlay-get o 'org-type) 'org-blocked-todo)
-                       (delete-overlay o)))
-       (overlays-in (point-min) (point-max)))
+  (dolist (o (overlays-in (point-min) (point-max)))
+    (when (eq (overlay-get o 'org-type) 'org-blocked-todo)
+      (delete-overlay o)))
   (save-excursion
     (let ((inhibit-read-only t)
          (org-depend-tag-blocked nil)
-         (invis (or (not (null invisible))
-                    (eq org-agenda-dim-blocked-tasks 'invisible)))
-         org-blocked-by-checkboxes
-         invis1 b e p ov h l)
+         org-blocked-by-checkboxes)
       (goto-char (point-min))
-      (while (let ((pos (next-single-property-change (point) 'todo-state)))
-              (and pos (goto-char (1+ pos))))
-       (setq org-blocked-by-checkboxes nil invis1 invis)
+      (while (let ((pos (text-property-not-all
+                        (point) (point-max) 'todo-state nil)))
+              (when pos (goto-char pos)))
+       (setq org-blocked-by-checkboxes nil)
        (let ((marker (org-get-at-bol 'org-hd-marker)))
-         (when (and marker
+         (when (and (markerp marker)
                     (with-current-buffer (marker-buffer marker)
                       (save-excursion (goto-char marker)
                                       (org-entry-blocked-p))))
-           (if org-blocked-by-checkboxes (setq invis1 nil))
-           (setq b (if invis1
-                       (max (point-min) (1- (point-at-bol)))
-                     (point-at-bol))
-                 e (point-at-eol)
-                 ov (make-overlay b e))
-           (if invis1
-               (progn (overlay-put ov 'invisible t)
-                      (overlay-put ov 'intangible t))
-             (overlay-put ov 'face 'org-agenda-dimmed-todo-face))
-           (overlay-put ov 'org-type 'org-blocked-todo))))))
+           ;; Entries blocked by checkboxes cannot be made invisible.
+           ;; See `org-agenda-dim-blocked-tasks' for details.
+           (let* ((really-invisible
+                   (and (not org-blocked-by-checkboxes)
+                        (or invisible (eq org-agenda-dim-blocked-tasks
+                                          'invisible))))
+                  (ov (make-overlay (if really-invisible (line-end-position 0)
+                                      (line-beginning-position))
+                                    (line-end-position))))
+             (if really-invisible (overlay-put ov 'invisible t)
+               (overlay-put ov 'face 'org-agenda-dimmed-todo-face))
+             (overlay-put ov 'org-type 'org-blocked-todo))))
+       (forward-line))))
   (when (org-called-interactively-p 'interactive)
     (message "Dim or hide blocked tasks...done")))
 
@@ -5746,7 +5749,7 @@ This function is invoked if `org-agenda-todo-ignore-deadlines',
    (let ((calendar-date-style 'european)       (european-calendar-style t))
      (diary-date day month year mark))))
 
-;; Define theorg-class' function
+;; Define the `org-class' function
 (defun org-class (y1 m1 d1 y2 m2 d2 dayname &rest skip-weeks)
   "Entry applies if date is between dates on DAYNAME, but skips SKIP-WEEKS.
 DAYNAME is a number between 0 (Sunday) and 6 (Saturday).
@@ -6651,7 +6654,7 @@ The modified list may contain inherited tags, and tags matched by
 
 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."
+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))))
@@ -7166,7 +7169,9 @@ in the file.  Otherwise, restriction will be to the current subtree."
 
 (defun org-agenda-maybe-redo ()
   "If there is any window showing the agenda view, update it."
-  (let ((w (get-buffer-window org-agenda-buffer-name t))
+  (let ((w (get-buffer-window (or org-agenda-this-buffer-name
+                                 org-agenda-buffer-name)
+                             t))
        (w0 (selected-window)))
     (when w
       (select-window w)
@@ -7347,8 +7352,11 @@ in the agenda."
 (defvar org-agenda-filtered-by-category nil)
 
 (defun org-agenda-filter-by-category (strip)
-  "Keep only those lines in the agenda buffer that have a specific category.
-The category is that of the current line."
+  "Filter lines in the agenda buffer that have a specific category.
+The category is that of the current line.
+Without prefix argument, keep only the lines of that category.
+With a prefix argument, exclude the lines of that category.
+"
   (interactive "P")
   (if (and org-agenda-filtered-by-category
           org-agenda-category-filter)
@@ -7358,7 +7366,7 @@ The category is that of the current line."
        ((and cat strip)
         (org-agenda-filter-apply
          (push (concat "-" cat) org-agenda-category-filter) 'category))
-       ((and cat)
+       (cat
         (org-agenda-filter-apply
          (setq org-agenda-category-filter
               (list (concat "+" cat))) 'category))
@@ -8386,13 +8394,13 @@ When called with a prefix argument, include all archive files as well."
       (org-show-context 'agenda)
       (save-excursion
        (and (outline-next-heading)
-            (org-flag-heading nil))))  ; show the next heading
-    (when (outline-invisible-p)
-      (show-entry))                    ; display invisible text
-    (recenter (/ (window-height) 2))
-    (org-back-to-heading t)
-    (if (re-search-forward org-complex-heading-regexp nil t)
-       (goto-char (match-beginning 4)))
+            (org-flag-heading nil)))   ; show the next heading
+      (when (outline-invisible-p)
+       (show-entry))                   ; display invisible text
+      (recenter (/ (window-height) 2))
+      (org-back-to-heading t)
+      (if (re-search-forward org-complex-heading-regexp nil t)
+         (goto-char (match-beginning 4))))
     (run-hooks 'org-agenda-after-show-hook)
     (and highlight (org-highlight (point-at-bol) (point-at-eol)))))
 
@@ -8591,7 +8599,9 @@ It also looks at the text of the entry itself."
                           (symbol-value var))))))
 
 (defun org-agenda-switch-to (&optional delete-other-windows)
-  "Go to the Org-mode file which contains the item at point."
+  "Go to the Org mode file which contains the item at point.
+When optional argument DELETE-OTHER-WINDOWS is non-nil, the
+displayed Org file fills the frame."
   (interactive)
   (if (and org-return-follows-link
           (not (org-get-at-bol 'org-marker))
@@ -8603,17 +8613,11 @@ It also looks at the text of the entry itself."
           (pos (marker-position marker)))
       (unless buffer (user-error "Trying to switch to non-existent buffer"))
       (org-pop-to-buffer-same-window buffer)
-      (and delete-other-windows (delete-other-windows))
+      (when delete-other-windows (delete-other-windows))
       (widen)
       (goto-char pos)
-      (org-back-to-heading t)
       (when (derived-mode-p 'org-mode)
        (org-show-context 'agenda)
-       (save-excursion
-         (and (outline-next-heading)
-              (org-flag-heading nil))) ; show the next heading
-       (when (outline-invisible-p)
-         (show-entry))                 ; display invisible text
        (run-hooks 'org-agenda-after-show-hook)))))
 
 (defun org-agenda-goto-mouse (ev)
@@ -8688,7 +8692,7 @@ if it was hidden in the outline."
       (message "Remote: show with default settings"))
      ((= more 2)
       (show-entry)
-      (show-children)
+      (org-show-children)
       (save-excursion
        (org-back-to-heading)
        (run-hook-with-args 'org-cycle-hook 'children))
@@ -9416,11 +9420,13 @@ buffer, display it in another window."
   "Where in `org-agenda-diary-file' should new entries be added?
 Valid values:
 
-date-tree    in the date tree, as child of the date
-top-level    as top-level entries at the end of the file."
+date-tree         in the date tree, as first child of the date
+date-tree-last    in the date tree, as last child of the date
+top-level         as top-level entries at the end of the file."
   :group 'org-agenda
   :type '(choice
-         (const :tag "in a date tree" date-tree)
+         (const :tag "first in a date tree" date-tree)
+         (const :tag "last in a date tree" date-tree-last)
          (const :tag "as top level at end of file" top-level)))
 
 (defcustom org-agenda-insert-diary-extract-time nil
@@ -9524,14 +9530,20 @@ a timestamp can be added there."
   (when org-adapt-indentation (org-indent-to-column 2)))
 
 (defun org-agenda-insert-diary-make-new-entry (text)
-  "Make a new entry with TEXT as the first child of the current subtree.
+  "Make a new entry with TEXT as a child of the current subtree.
 Position the point in the heading's first body line so that
 a timestamp can be added there."
-  (outline-next-heading)
-  (org-back-over-empty-lines)
-  (unless (looking-at "[ \t]*$") (save-excursion (insert "\n")))
-  (org-insert-heading nil t)
-  (org-do-demote)
+  (cond
+   ((eq org-agenda-insert-diary-strategy 'date-tree-last)
+    (end-of-line)
+    (org-insert-heading '(4) t)
+    (org-do-demote))
+   (t
+    (outline-next-heading)
+    (org-back-over-empty-lines)
+    (unless (looking-at "[ \t]*$") (save-excursion (insert "\n")))
+    (org-insert-heading nil t)
+    (org-do-demote)))
   (let ((col (current-column)))
     (insert text)
     (org-end-of-meta-data)
index 3e14291..2919fda 100644 (file)
@@ -1,6 +1,6 @@
 ;;; org-archive.el --- Archiving for Org-mode
 
-;; Copyright (C) 2004-2014 Free Software Foundation, Inc.
+;; Copyright (C) 2004-2015 Free Software Foundation, Inc.
 
 ;; Author: Carsten Dominik <carsten at orgmode dot org>
 ;; Keywords: outlines, hypermedia, calendar, wp
@@ -241,8 +241,7 @@ this heading."
                       (error "No file associated to buffer"))))
            (olpath (mapconcat 'identity (org-get-outline-path) "/"))
            (time (format-time-string
-                  (substring (cdr org-time-stamp-formats) 1 -1)
-                  (current-time)))
+                  (substring (cdr org-time-stamp-formats) 1 -1)))
            category todo priority ltags itags atags
            ;; end of variables that will be used for saving context
            location afile heading buffer level newfile-p infile-p visiting
@@ -453,8 +452,7 @@ sibling does not exist, it will be created at the end of the subtree."
        (org-set-property
         "ARCHIVE_TIME"
         (format-time-string
-         (substring (cdr org-time-stamp-formats) 1 -1)
-         (current-time)))
+         (substring (cdr org-time-stamp-formats) 1 -1)))
        (outline-up-heading 1 t)
        (hide-subtree)
        (org-cycle-show-empty-lines 'folded)
index 1737ec1..fb4c385 100644 (file)
@@ -1,6 +1,6 @@
 ;;; org-attach.el --- Manage file attachments to org-mode tasks
 
-;; Copyright (C) 2008-2014 Free Software Foundation, Inc.
+;; Copyright (C) 2008-2015 Free Software Foundation, Inc.
 
 ;; Author: John Wiegley <johnw@newartisans.com>
 ;; Keywords: org data task
@@ -283,7 +283,8 @@ This checks for the existence of a \".git\" directory in that directory."
        (cd dir)
        (let ((have-annex
               (and org-attach-git-annex-cutoff
-                   (file-exists-p (expand-file-name "annex" git-dir)))))
+                   (or (file-exists-p (expand-file-name "annex" git-dir))
+                       (file-exists-p (expand-file-name ".git/annex" git-dir))))))
          (dolist (new-or-modified
                   (split-string
                    (shell-command-to-string
index cfd5b3b..c489385 100644 (file)
@@ -1,6 +1,6 @@
 ;;; org-bbdb.el --- Support for links to BBDB entries from within Org-mode
 
-;; Copyright (C) 2004-2014 Free Software Foundation, Inc.
+;; Copyright (C) 2004-2015 Free Software Foundation, Inc.
 
 ;; Authors: Carsten Dominik <carsten at orgmode dot org>
 ;;       Thomas Baumann <thomas dot baumann at ch dot tum dot de>
@@ -37,7 +37,7 @@
 ;; the diary using bbdb-anniv.el.
 ;;
 ;; Put the following in /somewhere/at/home/diary.org and make sure
-;; that this file is in `org-agenda-files`
+;; that this file is in `org-agenda-files'.
 ;;
 ;; %%(org-bbdb-anniversaries)
 ;;
index 7b2ed48..d795c53 100644 (file)
@@ -1,6 +1,6 @@
 ;;; org-bibtex.el --- Org links to BibTeX entries
 ;;
-;; Copyright (C) 2007-2014 Free Software Foundation, Inc.
+;; Copyright (C) 2007-2015 Free Software Foundation, Inc.
 ;;
 ;; Authors: Bastien Guerry <bzg@gnu.org>
 ;;       Carsten Dominik <carsten dot dominik at gmail dot com>
index 6de5f6b..93a7f2a 100644 (file)
@@ -1,6 +1,6 @@
 ;;; org-capture.el --- Fast note taking in Org-mode
 
-;; Copyright (C) 2010-2014 Free Software Foundation, Inc.
+;; Copyright (C) 2010-2015 Free Software Foundation, Inc.
 
 ;; Author: Carsten Dominik <carsten at orgmode dot org>
 ;; Keywords: outlines, hypermedia, calendar, wp
@@ -53,7 +53,7 @@
 
 (declare-function org-datetree-find-date-create "org-datetree"
                  (date &optional keep-restriction))
-(declare-function org-table-get-specials "org-table" ())
+(declare-function org-table-analyze "org-table" ())
 (declare-function org-table-goto-line "org-table" (N))
 (declare-function org-pop-to-buffer-same-window "org-compat"
                  (&optional buffer-or-name norecord label))
@@ -64,6 +64,7 @@
 (defvar org-remember-default-headline)
 (defvar org-remember-templates)
 (defvar org-table-hlines)
+(defvar org-table-current-begin-pos)
 (defvar dired-buffers)
 
 (defvar org-capture-clock-was-started nil
@@ -201,7 +202,7 @@ properties are:
 
  :clock-resume       Start the interrupted clock when finishing the capture.
                      Note that :clock-keep has precedence over :clock-resume.
-                     When setting both to `t', the current clock will run and
+                     When setting both to t, the current clock will run and
                      the previous one will not be resumed.
 
  :unnarrowed         Do not narrow the target buffer, simply show the
@@ -434,7 +435,9 @@ Turning on this mode runs the normal hook `org-capture-mode-hook'."
   nil " Rem" org-capture-mode-map
   (org-set-local
    'header-line-format
-   "Capture buffer.  Finish `C-c C-c', refile `C-c C-w', abort `C-c C-k'."))
+   (substitute-command-keys
+    "\\<org-capture-mode-map>Capture buffer.  Finish \\[org-capture-finalize], \
+refile \\[org-capture-refile], abort \\[org-capture-kill].")))
 (define-key org-capture-mode-map "\C-c\C-c" 'org-capture-finalize)
 (define-key org-capture-mode-map "\C-c\C-k" 'org-capture-kill)
 (define-key org-capture-mode-map "\C-c\C-w" 'org-capture-refile)
@@ -966,12 +969,15 @@ Store them in the capture property list."
 (defun org-capture-expand-file (file)
   "Expand functions and symbols for FILE.
 When FILE is a function, call it.  When it is a form, evaluate
-it.  When it is a variable, retrieve the value.  Return whatever we get."
+it.  When it is a variable, retrieve the value.  When it is
+a string, return it.  However, if it is the empty string, return
+`org-default-notes-file' instead."
   (cond
+   ((equal file "") org-default-notes-file)
    ((org-string-nw-p file) file)
    ((functionp file) (funcall file))
    ((and (symbolp file) (boundp file)) (symbol-value file))
-   ((and file (consp file)) (eval file))
+   ((consp file) (eval file))
    (t file)))
 
 (defun org-capture-target-buffer (file)
@@ -1158,17 +1164,16 @@ may have been stored before."
      ((and table-line-pos
           (string-match "\\(I+\\)\\([-+][0-9]\\)" table-line-pos))
       ;; we have a complex line specification
-      (goto-char (point-min))
-      (let ((nh (- (match-end 1) (match-beginning 1)))
-           (delta (string-to-number (match-string 2 table-line-pos)))
-           ll)
+      (let ((ll (ignore-errors
+                 (save-match-data (org-table-analyze))
+                 (aref org-table-hlines
+                       (- (match-end 1) (match-beginning 1)))))
+           (delta (string-to-number (match-string 2 table-line-pos))))
        ;; The user wants a special position in the table
-       (org-table-get-specials)
-       (setq ll (ignore-errors (aref org-table-hlines nh)))
-       (unless ll (error "Invalid table line specification \"%s\""
-                         table-line-pos))
-       (setq ll (+ ll delta (if (< delta 0) 0 -1)))
-       (org-goto-line ll)
+       (unless ll
+         (error "Invalid table line specification \"%s\"" table-line-pos))
+       (goto-char org-table-current-begin-pos)
+       (forward-line (+ ll delta (if (< delta 0) 0 -1)))
        (org-table-insert-row 'below)
        (beginning-of-line 1)
        (delete-region (point) (1+ (point-at-eol)))
@@ -1587,8 +1592,7 @@ The template may still contain \"%?\" for cursor positioning."
     (unless template (setq template "") (message "No template") (ding)
            (sit-for 1))
     (save-window-excursion
-      (delete-other-windows)
-      (org-pop-to-buffer-same-window (get-buffer-create "*Capture*"))
+      (org-switch-to-buffer-other-window (get-buffer-create "*Capture*"))
       (erase-buffer)
       (insert template)
       (goto-char (point-min))
index 125209e..5533d4a 100644 (file)
@@ -1,6 +1,6 @@
 ;;; org-clock.el --- The time clocking code for Org-mode
 
-;; Copyright (C) 2004-2014 Free Software Foundation, Inc.
+;; Copyright (C) 2004-2015 Free Software Foundation, Inc.
 
 ;; Author: Carsten Dominik <carsten at orgmode dot org>
 ;; Keywords: outlines, hypermedia, calendar, wp
@@ -441,6 +441,7 @@ This applies when using `org-clock-goto'."
                 (const lastmonth)
                 (const thisyear)
                 (const lastyear)
+                (const untilnow)
                 (const :tag "Select range interactively" interactive)))
 
 (defvar org-clock-in-prepare-hook nil
@@ -460,6 +461,28 @@ to add an effort property.")
 (defvar org-clock-has-been-used nil
   "Has the clock been used during the current Emacs session?")
 
+(defconst org-clock--oldest-date
+  (let* ((dichotomy
+         (lambda (min max pred)
+           (if (funcall pred min) min
+             (incf min)
+             (while (> (- max min) 1)
+               (let ((mean (+ (ash min -1) (ash max -1) (logand min max 1))))
+                 (if (funcall pred mean) (setq max mean) (setq min mean)))))
+           max))
+        (high
+         (funcall dichotomy
+                  most-negative-fixnum
+                  0
+                  (lambda (m) (ignore-errors (decode-time (list m 0))))))
+        (low
+         (funcall dichotomy
+                  most-negative-fixnum
+                  0
+                  (lambda (m) (ignore-errors (decode-time (list high m)))))))
+    (list high low))
+  "Internal time for oldest date representable on the system.")
+
 ;;; The clock for measuring work time.
 
 (defvar org-mode-line-string "")
@@ -533,6 +556,13 @@ of a different task.")
   (mapc (lambda (m) (org-check-and-save-marker m beg end))
        org-clock-history))
 
+(defun org-clock-drawer-name ()
+  "Return clock drawer's name for current entry, or nil."
+  (let ((drawer (org-clock-into-drawer)))
+    (cond ((integerp drawer) (org-log-into-drawer))
+         ((stringp drawer) drawer)
+         (t nil))))
+
 (defun org-clocking-buffer ()
   "Return the clocking buffer if we are currently clocking a task or nil."
   (marker-buffer org-clock-marker))
@@ -927,7 +957,7 @@ If necessary, clock-out of the currently active clock."
       (when drawer
        (org-with-wide-buffer
         (let ((drawer-re (format "^[ \t]*:%s:[ \t]*$"
-                                 (regexp-quote (or drawer "LOGBOOK"))))
+                                 (regexp-quote (if (stringp drawer) drawer "LOGBOOK"))))
               (beg (save-excursion (outline-back-to-heading t) (point))))
           (catch 'exit
             (while (re-search-backward drawer-re beg t)
@@ -1073,9 +1103,9 @@ If `only-dangling-p' is non-nil, only ask to resolve dangling
                        (lambda (clock)
                          (format
                           "Dangling clock started %d mins ago"
-                          (floor
-                           (/ (- (org-float-time (current-time))
-                                 (org-float-time (cdr clock))) 60))))))
+                          (floor (- (org-float-time)
+                                    (org-float-time (cdr clock)))
+                                 60)))))
                   (or last-valid
                       (cdr clock)))))))))))
 
@@ -1093,9 +1123,11 @@ If `only-dangling-p' is non-nil, only ask to resolve dangling
 (defvar org-x11idle-exists-p
   ;; Check that x11idle exists
   (and (eq window-system 'x)
-       (eq (call-process-shell-command "command" nil nil nil "-v" org-clock-x11idle-program-name) 0)
+       (eq 0 (call-process-shell-command
+              (format "command -v %s" org-clock-x11idle-program-name)))
        ;; Check that x11idle can retrieve the idle time
-       (eq (call-process-shell-command org-clock-x11idle-program-name nil nil nil) 0)))
+       ;; FIXME: Why "..-shell-command" rather than just `call-process'?
+       (eq 0 (call-process-shell-command org-clock-x11idle-program-name))))
 
 (defun org-x11-idle-seconds ()
   "Return the current X11 idle time in seconds."
@@ -1396,7 +1428,7 @@ decides which time to use."
       (current-time))
      ((equal cmt "today")
       (setq org--msg-extra "showing today's task time.")
-      (let* ((dt (decode-time (current-time)))
+      (let* ((dt (decode-time))
             (hour (nth 2 dt))
             (day (nth 3 dt)))
        (if (< hour org-extend-today-until) (setf (nth 3 dt) (1- day)))
@@ -1426,10 +1458,7 @@ line and position cursor in that line."
     (let* ((beg (line-beginning-position 2))
           (end (save-excursion (outline-next-heading) (point)))
           (org-clock-into-drawer (org-clock-into-drawer))
-          (drawer (cond
-                   ((not org-clock-into-drawer) nil)
-                   ((stringp org-clock-into-drawer) org-clock-into-drawer)
-                   (t "LOGBOOK"))))
+          (drawer (org-clock-drawer-name)))
       ;; Look for a running clock if FIND-UNCLOSED in non-nil.
       (when find-unclosed
        (let ((open-clock-re
@@ -1621,18 +1650,19 @@ to, overriding the existing value of `org-clock-out-switch-to-state'."
 
 (add-hook 'org-clock-out-hook 'org-clock-remove-empty-clock-drawer)
 
-(defun org-clock-remove-empty-clock-drawer nil
-  "Remove empty clock drawer in the current subtree."
-  (let ((clock-drawer (org-log-into-drawer))
-       (end (save-excursion (org-end-of-subtree t t))))
-    (when clock-drawer
-      (save-excursion
-       (org-back-to-heading t)
-       (while (and (< (point) end)
-                   (search-forward clock-drawer end t))
-         (goto-char (match-beginning 0))
-         (org-remove-empty-drawer-at (point))
-         (forward-line 1))))))
+(defun org-clock-remove-empty-clock-drawer ()
+  "Remove empty clock drawers in current subtree."
+  (save-excursion
+    (org-back-to-heading t)
+    (org-map-tree
+     (lambda ()
+       (let ((drawer (org-clock-drawer-name))
+            (case-fold-search t))
+        (when drawer
+          (let ((re (format "^[ \t]*:%s:[ \t]*$" (regexp-quote drawer)))
+                (end (save-excursion (outline-next-heading))))
+            (while (re-search-forward re end t)
+              (org-remove-empty-drawer-at (point))))))))))
 
 (defun org-clock-timestamps-up (&optional n)
   "Increase CLOCK timestamps at cursor.
@@ -1698,7 +1728,8 @@ Optional argument N tells to change by that many units."
   (save-excursion    ; Do not replace this with `with-current-buffer'.
     (org-no-warnings (set-buffer (org-clocking-buffer)))
     (goto-char org-clock-marker)
-    (if (org-looking-back (concat "^[ \t]*" org-clock-string ".*"))
+    (if (org-looking-back (concat "^[ \t]*" org-clock-string ".*")
+                          (line-beginning-position))
        (progn (delete-region (1- (point-at-bol)) (point-at-eol))
               (org-remove-empty-drawer-at (point)))
       (message "Clock gone, cancel the timer anyway")
@@ -1877,9 +1908,9 @@ Use \\[org-clock-remove-overlays] to remove the subtree times."
   (org-clock-remove-overlays)
   (let* ((todayp (equal arg '(4)))
         (customp (member arg '((16) today yesterday
-                              thisweek lastweek thismonth
-                              lastmonth thisyear lastyear
-                              interactive)))
+                               thisweek lastweek thismonth
+                               lastmonth thisyear lastyear
+                               untilnow interactive)))
         (prop (cond ((not arg) :org-clock-minutes-default)
                     (todayp :org-clock-minutes-today)
                     (customp :org-clock-minutes-custom)
@@ -2088,134 +2119,159 @@ buffer and update it."
 
 (defun org-clock-special-range (key &optional time as-strings wstart mstart)
   "Return two times bordering a special time range.
-Key is a symbol specifying the range and can be one of `today', `yesterday',
-`thisweek', `lastweek', `thismonth', `lastmonth', `thisyear', `lastyear'.
-By default, a week starts Monday 0:00 and ends Sunday 24:00.
-The range is determined relative to TIME, which defaults to current time.
-The return value is a cons cell with two internal times like the ones
-returned by `current time' or `encode-time'.
-If AS-STRINGS is non-nil, the returned times will be formatted strings.
-If WSTART is non-nil, use this number to specify the starting day of a
-week (monday is 1).
-If MSTART is non-nil, use this number to specify the starting day of a
-month (1 is the first day of the month).
-If you can combine both, the month starting day will have priority."
-  (if (integerp key) (setq key (intern (number-to-string key))))
-  (let* ((tm (decode-time (or time (current-time))))
-        (s 0) (m (nth 1 tm)) (h (nth 2 tm))
-        (d (nth 3 tm)) (month (nth 4 tm)) (y (nth 5 tm))
+
+KEY is a symbol specifying the range and can be one of `today',
+`yesterday', `thisweek', `lastweek', `thismonth', `lastmonth',
+`thisyear', `lastyear' or `untilnow'.  If set to `interactive',
+user is prompted for range boundaries.  It can be a string or an
+integer.
+
+By default, a week starts Monday 0:00 and ends Sunday 24:00.  The
+range is determined relative to TIME, which defaults to current
+time.
+
+The return value is a list containing two internal times, one for
+the beginning of the range and one for its end, like the ones
+returned by `current time' or `encode-time' and a string used to
+display information.  If AS-STRINGS is non-nil, the returned
+times will be formatted strings.
+
+If WSTART is non-nil, use this number to specify the starting day
+of a week (monday is 1).  If MSTART is non-nil, use this number
+to specify the starting day of a month (1 is the first day of the
+month).  If you can combine both, the month starting day will
+have priority."
+  (let* ((tm (decode-time time))
+        (m (nth 1 tm))
+        (h (nth 2 tm))
+        (d (nth 3 tm))
+        (month (nth 4 tm))
+        (y (nth 5 tm))
         (dow (nth 6 tm))
-        (ws (or wstart 1))
-        (ms (or mstart 1))
-        (skey (symbol-name key))
+        (skey (format "%s" key))
         (shift 0)
-         (q (cond ((>= (nth 4 tm) 10) 4)
-                  ((>= (nth 4 tm) 7) 3)
-                  ((>= (nth 4 tm) 4) 2)
-                  ((>= (nth 4 tm) 1) 1)))
-        s1 m1 h1 d1 month1 y1 diff ts te fm txt w date
-        interval tmp shiftedy shiftedm shiftedq)
+        (q (cond ((>= month 10) 4)
+                 ((>= month 7) 3)
+                 ((>= month 4) 2)
+                 (t 1)))
+        m1 h1 d1 month1 y1 shiftedy shiftedm shiftedq)
     (cond
-     ((string-match "^[0-9]+$" skey)
-      (setq y (string-to-number skey) m 1 d 1 key 'year))
-     ((string-match "^\\([0-9]+\\)-\\([0-9]\\{1,2\\}\\)$" skey)
+     ((string-match "\\`[0-9]+\\'" skey)
+      (setq y (string-to-number skey) month 1 d 1 key 'year))
+     ((string-match "\\`\\([0-9]+\\)-\\([0-9]\\{1,2\\}\\)\\'" skey)
       (setq y (string-to-number (match-string 1 skey))
            month (string-to-number (match-string 2 skey))
-           d 1 key 'month))
-     ((string-match "^\\([0-9]+\\)-[wW]\\([0-9]\\{1,2\\}\\)$" skey)
+           d 1
+           key 'month))
+     ((string-match "\\`\\([0-9]+\\)-[wW]\\([0-9]\\{1,2\\}\\)\\'" skey)
       (require 'cal-iso)
-      (setq y (string-to-number (match-string 1 skey))
-           w (string-to-number (match-string 2 skey)))
-      (setq date (calendar-gregorian-from-absolute
-                 (calendar-iso-to-absolute (list w 1 y))))
-      (setq d (nth 1 date) month (car date) y (nth 2 date)
-           dow 1
-           key 'week))
-     ((string-match "^\\([0-9]+\\)-[qQ]\\([1-4]\\)$" skey)
+      (let ((date (calendar-gregorian-from-absolute
+                  (calendar-iso-to-absolute
+                   (list (string-to-number (match-string 2 skey))
+                         1
+                         (string-to-number (match-string 1 skey)))))))
+       (setq d (nth 1 date)
+             month (car date)
+             y (nth 2 date)
+             dow 1
+             key 'week)))
+     ((string-match "\\`\\([0-9]+\\)-[qQ]\\([1-4]\\)\\'" skey)
       (require 'cal-iso)
-      (setq y (string-to-number (match-string 1 skey)))
-      (setq q (string-to-number (match-string 2 skey)))
-      (setq date (calendar-gregorian-from-absolute
-                 (calendar-iso-to-absolute (org-quarter-to-date q y))))
-      (setq d (nth 1 date) month (car date) y (nth 2 date)
-            dow 1
-            key 'quarter))
-     ((string-match "^\\([0-9]+\\)-\\([0-9]\\{1,2\\}\\)-\\([0-9]\\{1,2\\}\\)$" skey)
+      (let ((date (calendar-gregorian-from-absolute
+                  (calendar-iso-to-absolute
+                   (org-quarter-to-date
+                    (string-to-number (match-string 2 skey))
+                    (string-to-number (match-string 1 skey)))))))
+       (setq d (nth 1 date)
+             month (car date)
+             y (nth 2 date)
+             dow 1
+             key 'quarter)))
+     ((string-match
+       "\\`\\([0-9]+\\)-\\([0-9]\\{1,2\\}\\)-\\([0-9]\\{1,2\\}\\)\\'"
+       skey)
       (setq y (string-to-number (match-string 1 skey))
            month (string-to-number (match-string 2 skey))
            d (string-to-number (match-string 3 skey))
            key 'day))
-     ((string-match "\\([-+][0-9]+\\)$" skey)
+     ((string-match "\\([-+][0-9]+\\)\\'" skey)
       (setq shift (string-to-number (match-string 1 skey))
-            key (intern (substring skey 0 (match-beginning 1))))
-      (if (and (memq key '(quarter thisq)) (> shift 0))
-         (error "Looking forward with quarters isn't implemented"))))
-
+           key (intern (substring skey 0 (match-beginning 1))))
+      (when (and (memq key '(quarter thisq)) (> shift 0))
+       (error "Looking forward with quarters isn't implemented"))))
     (when (= shift 0)
-      (cond ((eq key 'yesterday) (setq key 'today   shift -1))
-            ((eq key 'lastweek)  (setq key 'week    shift -1))
-            ((eq key 'lastmonth) (setq key 'month   shift -1))
-            ((eq key 'lastyear)  (setq key 'year    shift -1))
-            ((eq key 'lastq)     (setq key 'quarter shift -1))))
-    (cond
-     ((memq key '(day today))
-      (setq d (+ d shift) h 0 m 0 h1 24 m1 0))
-     ((memq key '(week thisweek))
-      (setq diff (+ (* -7 shift) (if (= dow 0) (- 7 ws) (- dow ws)))
-           m 0 h 0 d (- d diff) d1 (+ 7 d)))
-     ((memq key '(month thismonth))
-      (setq d (or ms 1) h 0 m 0 d1 (or ms 1)
-           month (+ month shift) month1 (1+ month) h1 0 m1 0))
-     ((memq key '(quarter thisq))
-      ;; Compute if this shift remains in this year.  If not, compute
-      ;; how many years and quarters we have to shift (via floor*) and
-      ;; compute the shifted years, months and quarters.
-      (cond
-       ((< (+ (- q 1) shift) 0) ; shift not in this year
-       (setq interval (* -1 (+ (- q 1) shift)))
-       ;; Set tmp to ((years to shift) (quarters to shift)).
-       (setq tmp (org-floor* interval 4))
-       ;; Due to the use of floor, 0 quarters actually means 4.
-       (if (= 0 (nth 1 tmp))
-           (setq shiftedy (- y (nth 0 tmp))
-                 shiftedm 1
-                 shiftedq 1)
-         (setq shiftedy (- y (+ 1 (nth 0 tmp)))
-               shiftedm (- 13 (* 3 (nth 1 tmp)))
-               shiftedq (- 5 (nth 1 tmp))))
-       (setq d 1 h 0 m 0 d1 1 month shiftedm month1 (+ 3 shiftedm) h1 0 m1 0 y shiftedy))
-       ((> (+ q shift) 0) ; shift is within this year
-       (setq shiftedq (+ q shift))
-       (setq shiftedy y)
-       (setq d 1 h 0 m 0 d1 1 month (+ 1 (* 3 (- (+ q shift) 1)))
-             month1 (+ 4 (* 3 (- (+ q shift) 1))) h1 0 m1 0))))
-     ((memq key '(year thisyear))
-      (setq m 0 h 0 d 1 month 1 y (+ y shift) y1 (1+ y)))
-     ((eq key 'interactive) nil)
-     (t (user-error "No such time block %s" key)))
-    (setq ts (encode-time s m h d month y)
-         te (encode-time (or s1 s) (or m1 m) (or h1 h)
-                         (or d1 d) (or month1 month) (or y1 y)))
-    (setq fm (cdr org-time-stamp-formats))
-    (cond
-     ((memq key '(day today))
-      (setq txt (format-time-string "%A, %B %d, %Y" ts)))
-     ((memq key '(week thisweek))
-      (setq txt (format-time-string "week %G-W%V" ts)))
-     ((memq key '(month thismonth))
-      (setq txt (format-time-string "%B %Y" ts)))
-     ((memq key '(year thisyear))
-      (setq txt (format-time-string "the year %Y" ts)))
-     ((memq key '(quarter thisq))
-      (setq txt (concat (org-count-quarter shiftedq)
-                       " quarter of " (number-to-string shiftedy)))))
-    (if as-strings
-       (list (format-time-string fm ts) (format-time-string fm te) txt)
-      (if (eq key 'interactive)
-         (list (org-read-date nil t nil "Range start? ")
-               (org-read-date nil t nil "Range end? ")
-               "(Range interactively set)")
-       (list ts te txt)))))
+      (case key
+       (yesterday (setq key 'today   shift -1))
+       (lastweek  (setq key 'week    shift -1))
+       (lastmonth (setq key 'month   shift -1))
+       (lastyear  (setq key 'year    shift -1))
+       (lastq     (setq key 'quarter shift -1))))
+    ;; Prepare start and end times depending on KEY's type.
+    (case key
+      ((day today) (setq m 0 h 0 h1 24 d (+ d shift)))
+      ((week thisweek)
+       (let* ((ws (or wstart 1))
+             (diff (+ (* -7 shift) (if (= dow 0) (- 7 ws) (- dow ws)))))
+        (setq m 0 h 0 d (- d diff) d1 (+ 7 d))))
+      ((month thismonth)
+       (setq h 0 m 0 d (or mstart 1) month (+ month shift) month1 (1+ month)))
+      ((quarter thisq)
+       ;; Compute if this shift remains in this year.  If not, compute
+       ;; how many years and quarters we have to shift (via floor*) and
+       ;; compute the shifted years, months and quarters.
+       (cond
+       ((< (+ (- q 1) shift) 0)        ; Shift not in this year.
+        (let* ((interval (* -1 (+ (- q 1) shift)))
+               ;; Set tmp to ((years to shift) (quarters to shift)).
+               (tmp (org-floor* interval 4)))
+          ;; Due to the use of floor, 0 quarters actually means 4.
+          (if (= 0 (nth 1 tmp))
+              (setq shiftedy (- y (nth 0 tmp))
+                    shiftedm 1
+                    shiftedq 1)
+            (setq shiftedy (- y (+ 1 (nth 0 tmp)))
+                  shiftedm (- 13 (* 3 (nth 1 tmp)))
+                  shiftedq (- 5 (nth 1 tmp)))))
+        (setq m 0 h 0 d 1 month shiftedm month1 (+ 3 shiftedm) y shiftedy))
+       ((> (+ q shift) 0)              ; Shift is within this year.
+        (setq shiftedq (+ q shift))
+        (setq shiftedy y)
+        (let ((qshift (* 3 (1- (+ q shift)))))
+          (setq m 0 h 0 d 1 month (+ 1 qshift) month1 (+ 4 qshift))))))
+      ((year thisyear)
+       (setq m 0 h 0 d 1 month 1 y (+ y shift) y1 (1+ y)))
+      ((interactive untilnow))         ; Special cases, ignore them.
+      (t (user-error "No such time block %s" key)))
+    ;; Format start and end times according to AS-STRINGS.
+    (let* ((start (case key
+                   (interactive (org-read-date nil t nil "Range start? "))
+                   (untilnow org-clock--oldest-date)
+                   (t (encode-time 0 m h d month y))))
+          (end (case key
+                 (interactive (org-read-date nil t nil "Range end? "))
+                 (untilnow (current-time))
+                 (t (encode-time 0
+                                 (or m1 m)
+                                 (or h1 h)
+                                 (or d1 d)
+                                 (or month1 month)
+                                 (or y1 y)))))
+          (text
+           (case key
+             ((day today) (format-time-string "%A, %B %d, %Y" start))
+             ((week thisweek) (format-time-string "week %G-W%V" start))
+             ((month thismonth) (format-time-string "%B %Y" start))
+             ((year thisyear) (format-time-string "the year %Y" start))
+             ((quarter thisq)
+              (concat (org-count-quarter shiftedq)
+                      " quarter of " (number-to-string shiftedy)))
+             (interactive "(Range interactively set)")
+             (untilnow "now"))))
+      (if (not as-strings) (list start end text)
+       (let ((f (cdr org-time-stamp-formats)))
+         (list (format-time-string f start)
+               (format-time-string f end)
+               text))))))
 
 (defun org-count-quarter (n)
   (cond
@@ -2352,7 +2408,8 @@ the currently selected interval size."
        (setq scope (org-agenda-files t))
        (setq scope (org-add-archive-files scope)))
        ((eq scope 'file-with-archives)
-       (setq scope (org-add-archive-files (list (buffer-file-name)))
+       (setq scope (and buffer-file-name
+                        (org-add-archive-files (list buffer-file-name)))
              one-file-with-archives t)))
       (setq scope-is-list (and scope (listp scope)))
       (if scope-is-list
@@ -2368,7 +2425,8 @@ the currently selected interval size."
        ;; Just from the current file
        (save-restriction
          ;; get the right range into the restriction
-         (org-agenda-prepare-buffers (list (buffer-file-name)))
+         (org-agenda-prepare-buffers (list (or (buffer-file-name)
+                                               (current-buffer))))
          (cond
           ((not scope))  ; use the restriction as it is now
           ((eq scope 'file) (widen))
@@ -2755,10 +2813,8 @@ TIME:      The sum of all time spend in this tree, in minutes.  This time
     (when (and te (listp te))
       (setq te (format "%4d-%02d-%02d" (nth 2 te) (car te) (nth 1 te))))
     ;; Now the times are strings we can parse.
-    (if ts (setq ts (org-float-time
-                    (seconds-to-time (org-matcher-time ts)))))
-    (if te (setq te (org-float-time
-                    (seconds-to-time (org-matcher-time te)))))
+    (if ts (setq ts (org-matcher-time ts)))
+    (if te (setq te (org-matcher-time te)))
     (save-excursion
       (org-clock-sum ts te
                     (unless (null matcher)
@@ -2898,8 +2954,8 @@ The details of what will be saved are regulated by the variable
          (delete-region (point-min) (point-max))
          ;;Store clock
          (insert (format ";; org-persist.el - %s at %s\n"
-                         system-name (format-time-string
-                                      (cdr org-time-stamp-formats))))
+                         (system-name) (format-time-string
+                                        (cdr org-time-stamp-formats))))
          (if (and (memq org-clock-persist '(t clock))
                   (setq b (org-clocking-buffer))
                   (setq b (or (buffer-base-buffer b) b))
index 993afdb..3838531 100644 (file)
@@ -1,6 +1,6 @@
 ;;; org-colview.el --- Column View in Org-mode
 
-;; Copyright (C) 2004-2014 Free Software Foundation, Inc.
+;; Copyright (C) 2004-2015 Free Software Foundation, Inc.
 
 ;; Author: Carsten Dominik <carsten at orgmode dot org>
 ;; Keywords: outlines, hypermedia, calendar, wp
@@ -146,11 +146,15 @@ This is the compiled version of the format.")
     "--"
     ["Quit" org-columns-quit t]))
 
+(defun org-columns--value (property pos)
+  "Return value for PROPERTY at buffer position POS."
+  (or (cdr (assoc-string property (get-text-property pos 'org-summaries) t))
+      (org-entry-get pos property 'selective t)))
+
 (defun org-columns-new-overlay (beg end &optional string face)
   "Create a new column overlay and add it to the list."
   (let ((ov (make-overlay beg end)))
     (overlay-put ov 'face (or face 'secondary-selection))
-    (remove-text-properties 0 (length string) '(face nil) string)
     (org-overlay-display ov string face)
     (push ov org-columns-overlays)
     ov))
@@ -158,95 +162,113 @@ This is the compiled version of the format.")
 (defun org-columns-display-here (&optional props dateline)
   "Overlay the current line with column display."
   (interactive)
-  (let* ((fmt org-columns-current-fmt-compiled)
-        (beg (point-at-bol))
-        (level-face (save-excursion
-                      (beginning-of-line 1)
-                      (and (looking-at "\\(\\**\\)\\(\\* \\)")
-                           (org-get-level-face 2))))
-        (ref-face (or level-face
-                      (and (eq major-mode 'org-agenda-mode)
-                           (get-text-property (point-at-bol) 'face))
-                      'default))
-        (color (list :foreground (face-attribute ref-face :foreground)))
-        (font (list :height (face-attribute 'default :height)
-                    :family (face-attribute 'default :family)))
-        (face (list color font 'org-column ref-face))
-        (face1 (list color font 'org-agenda-column-dateline ref-face))
-        (cphr (get-text-property (point-at-bol) 'org-complex-heading-regexp))
-        pom property ass width f fc string fm ov column val modval s2 title calc)
-    ;; Check if the entry is in another buffer.
-    (unless props
-      (if (eq major-mode 'org-agenda-mode)
-         (setq pom (or (org-get-at-bol 'org-hd-marker)
-                       (org-get-at-bol 'org-marker))
-               props (if pom (org-entry-properties pom) nil))
-       (setq props (org-entry-properties nil))))
-    ;; Walk the format
-    (while (setq column (pop fmt))
-      (setq property (car column)
-           title (nth 1 column)
-           ass (assoc-string property props t)
-           width (or (cdr
-                      (assoc-string property org-columns-current-maxwidths t))
-                     (nth 2 column)
-                     (length property))
-           f (format "%%-%d.%ds | " width width)
-           fm (nth 4 column)
-           fc (nth 5 column)
-           calc (nth 7 column)
-           val (or (cdr ass) "")
-           modval (cond ((and org-columns-modify-value-for-display-function
-                              (functionp
-                               org-columns-modify-value-for-display-function))
-                         (funcall org-columns-modify-value-for-display-function
-                                  title val))
-                        ((equal property "ITEM")
-                         (org-columns-compact-links val))
-                        (fc (org-columns-number-to-string
-                             (org-columns-string-to-number val fm) fm fc))
-                        ((and calc (functionp calc)
-                              (not (string= val ""))
-                              (not (get-text-property 0 'org-computed val)))
-                         (org-columns-number-to-string
-                          (funcall calc (org-columns-string-to-number
-                                         val fm)) fm))))
-      (setq s2 (org-columns-add-ellipses (or modval val) width))
-      (setq string (format f s2))
-      ;; Create the overlay
+  (save-excursion
+    (beginning-of-line)
+    (let* ((level-face (and (looking-at "\\(\\**\\)\\(\\* \\)")
+                           (org-get-level-face 2)))
+          (ref-face (or level-face
+                        (and (eq major-mode 'org-agenda-mode)
+                             (org-get-at-bol 'face))
+                        'default))
+          (color (list :foreground (face-attribute ref-face :foreground)))
+          (font (list :height (face-attribute 'default :height)
+                      :family (face-attribute 'default :family)))
+          (face (list color font 'org-column ref-face))
+          (face1 (list color font 'org-agenda-column-dateline ref-face))
+          (pom (and (eq major-mode 'org-agenda-mode)
+                    (or (org-get-at-bol 'org-hd-marker)
+                        (org-get-at-bol 'org-marker))))
+          (props (cond (props)
+                       ((eq major-mode 'org-agenda-mode)
+                        (and pom (org-entry-properties pom)))
+                       (t (org-entry-properties)))))
+      ;; Each column is an overlay on top of a character.  So there has
+      ;; to be at least as many characters available on the line as
+      ;; columns to display.
+      (let ((columns (length org-columns-current-fmt-compiled))
+           (chars (- (line-end-position) (line-beginning-position))))
+       (when (> columns chars)
+         (save-excursion
+           (end-of-line)
+           (let ((inhibit-read-only t))
+             (insert (make-string (- columns chars) ?\s))))))
+      ;; Walk the format.  Create and install the overlay for the
+      ;; current column on the next character.
+      (dolist (column org-columns-current-fmt-compiled)
+       (let* ((property (car column))
+              (title (nth 1 column))
+              (ass (assoc-string property props t))
+              (width
+               (or
+                (cdr (assoc-string property org-columns-current-maxwidths t))
+                (nth 2 column)
+                (length property)))
+              (f (format "%%-%d.%ds | " width width))
+              (fm (nth 4 column))
+              (fc (nth 5 column))
+              (calc (nth 7 column))
+              (val (or (cdr ass) ""))
+              (modval
+               (cond
+                ((functionp org-columns-modify-value-for-display-function)
+                 (funcall org-columns-modify-value-for-display-function
+                          title val))
+                ((equal property "ITEM") (org-columns-compact-links val))
+                (fc (org-columns-number-to-string
+                     (org-columns-string-to-number val fm) fm fc))
+                ((and calc (functionp calc)
+                      (not (string= val ""))
+                      (not (get-text-property 0 'org-computed val)))
+                 (org-columns-number-to-string
+                  (funcall calc (org-columns-string-to-number val fm)) fm))))
+              (string
+               (format f
+                       (let ((v (org-columns-add-ellipses
+                                 (or modval val) width)))
+                         (cond
+                          ((equal property "PRIORITY")
+                           (propertize v 'face (org-get-priority-face val)))
+                          ((equal property "TAGS")
+                           (if (not org-tags-special-faces-re)
+                               (propertize v 'face 'org-tag)
+                             (replace-regexp-in-string
+                              org-tags-special-faces-re
+                              (lambda (m)
+                                (propertize m 'face (org-get-tag-face m)))
+                              v nil nil 1)))
+                          ((equal property "TODO")
+                           (propertize v 'face (org-get-todo-face val)))
+                          (t v)))))
+              (ov (org-columns-new-overlay
+                   (point) (1+ (point)) string (if dateline face1 face))))
+         (overlay-put ov 'keymap org-columns-map)
+         (overlay-put ov 'org-columns-key property)
+         (overlay-put ov 'org-columns-value (cdr ass))
+         (overlay-put ov 'org-columns-value-modified modval)
+         (overlay-put ov 'org-columns-pom pom)
+         (overlay-put ov 'org-columns-format f)
+         (overlay-put ov 'line-prefix "")
+         (overlay-put ov 'wrap-prefix "")
+         (forward-char)))
+      ;; Make the rest of the line disappear.
+      (let ((ov (org-columns-new-overlay (point) (line-end-position))))
+       (overlay-put ov 'invisible t)
+       (overlay-put ov 'keymap org-columns-map)
+       (overlay-put ov 'line-prefix "")
+       (overlay-put ov 'wrap-prefix ""))
+      (let ((ov (make-overlay (1- (line-end-position))
+                             (line-beginning-position 2))))
+       (overlay-put ov 'keymap org-columns-map)
+       (push ov org-columns-overlays))
       (org-with-silent-modifications
-       (setq ov (org-columns-new-overlay
-                beg (setq beg (1+ beg)) string (if dateline face1 face)))
-       (overlay-put ov 'keymap org-columns-map)
-       (overlay-put ov 'org-columns-key property)
-       (overlay-put ov 'org-columns-value (cdr ass))
-       (overlay-put ov 'org-columns-value-modified modval)
-       (overlay-put ov 'org-columns-pom pom)
-       (overlay-put ov 'org-columns-format f)
-       (overlay-put ov 'line-prefix "")
-       (overlay-put ov 'wrap-prefix ""))
-      (if (or (not (char-after beg))
-             (equal (char-after beg) ?\n))
-         (let ((inhibit-read-only t))
-           (save-excursion
-             (goto-char beg)
-             (org-unmodified (insert " ")))))) ;; FIXME: add props and remove later?
-    ;; Make the rest of the line disappear.
-    (org-unmodified
-     (setq ov (org-columns-new-overlay beg (point-at-eol)))
-     (overlay-put ov 'invisible t)
-     (overlay-put ov 'keymap org-columns-map)
-     (overlay-put ov 'intangible t)
-     (overlay-put ov 'line-prefix "")
-     (overlay-put ov 'wrap-prefix "")
-     (push ov org-columns-overlays)
-     (setq ov (make-overlay (1- (point-at-eol)) (1+ (point-at-eol))))
-     (overlay-put ov 'keymap org-columns-map)
-     (push ov org-columns-overlays)
-     (let ((inhibit-read-only t))
-       (put-text-property (max (point-min) (1- (point-at-bol)))
-                         (min (point-max) (1+ (point-at-eol)))
-                         'read-only "Type `e' to edit property")))))
+       (let ((inhibit-read-only t))
+        (put-text-property
+         (line-end-position 0)
+         (line-beginning-position 2)
+         'read-only
+         (substitute-command-keys
+          "Type \\<org-columns-map>\\[org-columns-edit-value] \
+to edit property")))))))
 
 (defun org-columns-add-ellipses (string width)
   "Truncate STRING with WIDTH characters, with ellipses."
@@ -658,11 +680,14 @@ around it."
     fmt))
 
 (defun org-columns-goto-top-level ()
-  (when (condition-case nil (org-back-to-heading) (error nil))
-    (org-entry-get nil "COLUMNS" t))
-  (if (marker-position org-entry-property-inherited-from)
-      (move-marker org-columns-top-level-marker org-entry-property-inherited-from)
-    (move-marker org-columns-top-level-marker (point))))
+  "Move to the beginning of the column view area.
+Also sets `org-columns-top-level-marker' to the new position."
+  (goto-char
+   (move-marker
+    org-columns-top-level-marker
+    (cond ((org-before-first-heading-p) (point-min))
+         ((org-entry-get nil "COLUMNS" t) org-entry-property-inherited-from)
+         (t (org-back-to-heading) (point))))))
 
 ;;;###autoload
 (defun org-columns (&optional columns-fmt-string)
@@ -672,49 +697,46 @@ When COLUMNS-FMT-STRING is non-nil, use it as the column format."
   (org-verify-version 'columns)
   (org-columns-remove-overlays)
   (move-marker org-columns-begin-marker (point))
-  (let ((org-columns-time (time-to-number-of-days (current-time)))
-       beg end fmt cache maxwidths)
-    (org-columns-goto-top-level)
-    (setq fmt (org-columns-get-format columns-fmt-string))
-    (save-excursion
-      (goto-char org-columns-top-level-marker)
-      (setq beg (point))
-      (unless org-columns-inhibit-recalculation
-       (org-columns-compute-all))
-      (setq end (or (condition-case nil (org-end-of-subtree t t) (error nil))
-                   (point-max)))
-      ;; Get and cache the properties
-      (goto-char beg)
+  (org-columns-goto-top-level)
+  ;; Initialize `org-columns-current-fmt' and
+  ;; `org-columns-current-fmt-compiled'.
+  (let ((org-columns-time (time-to-number-of-days (current-time))))
+    (org-columns-get-format columns-fmt-string))
+  (unless org-columns-inhibit-recalculation (org-columns-compute-all))
+  (save-excursion
+    (save-restriction
+      (narrow-to-region
+       (point)
+       (if (org-at-heading-p) (org-end-of-subtree t t) (point-max)))
       (when (assoc "CLOCKSUM" org-columns-current-fmt-compiled)
-       (save-excursion
-         (save-restriction
-           (narrow-to-region beg end)
-           (org-clock-sum))))
+       (org-clock-sum))
       (when (assoc "CLOCKSUM_T" org-columns-current-fmt-compiled)
-       (save-excursion
-         (save-restriction
-           (narrow-to-region beg end)
-           (org-clock-sum-today))))
-      (while (re-search-forward org-outline-regexp-bol end t)
-       (if (and org-columns-skip-archived-trees
-                (looking-at (concat ".*:" org-archive-tag ":")))
-           (org-end-of-subtree t)
-         (push (cons (org-current-line) (org-entry-properties)) cache)))
-      (when cache
-       (setq maxwidths (org-columns-get-autowidth-alist fmt cache))
-       (org-set-local 'org-columns-current-maxwidths maxwidths)
-       (org-columns-display-here-title)
-       (when (org-set-local 'org-columns-flyspell-was-active
-                            (org-bound-and-true-p flyspell-mode))
-         (flyspell-mode 0))
-       (unless (local-variable-p 'org-colview-initial-truncate-line-value)
-         (org-set-local 'org-colview-initial-truncate-line-value
-                        truncate-lines))
-       (setq truncate-lines t)
-       (mapc (lambda (x)
-               (org-goto-line (car x))
-               (org-columns-display-here (cdr x)))
-             cache)))))
+       (org-clock-sum-today))
+      (let* ((column-names (mapcar #'car org-columns-current-fmt-compiled))
+            (cache
+             (org-map-entries
+              (lambda ()
+                (cons (point)
+                      (mapcar (lambda (p)
+                                (cons p (org-columns--value p (point))))
+                              column-names)))
+              nil nil (and org-columns-skip-archived-trees 'archive))))
+       (when cache
+         (org-set-local 'org-columns-current-maxwidths
+                        (org-columns-get-autowidth-alist
+                         org-columns-current-fmt
+                         cache))
+         (org-columns-display-here-title)
+         (when (org-set-local 'org-columns-flyspell-was-active
+                              (org-bound-and-true-p flyspell-mode))
+           (flyspell-mode 0))
+         (unless (local-variable-p 'org-colview-initial-truncate-line-value)
+           (org-set-local 'org-colview-initial-truncate-line-value
+                          truncate-lines))
+         (setq truncate-lines t)
+         (dolist (x cache)
+           (goto-char (car x))
+           (org-columns-display-here (cdr x))))))))
 
 (eval-when-compile (defvar org-columns-time))
 
@@ -1065,7 +1087,7 @@ display, or in the #+COLUMNS line of the current buffer."
 (defun org-nofm-to-completion (n m &optional percent)
   (if (not percent)
       (format "[%d/%d]" n m)
-    (format "[%d%%]"(floor (+ 0.5 (* 100. (/ (* 1.0 n) m)))))))
+    (format "[%d%%]" (round (* 100.0 n) m))))
 
 
 (defun org-columns-string-to-number (s fmt)
@@ -1127,7 +1149,8 @@ display, or in the #+COLUMNS line of the current buffer."
     (org-trim rtn)))
 
 (defun org-columns-compile-format (fmt)
-  "Turn a column format string into an alist of specifications.
+  "Turn a column format string FMT into an alist of specifications.
+
 The alist has one entry for each column in the format.  The elements of
 that list are:
 property     the property
@@ -1137,7 +1160,9 @@ operator     the operator if any
 format       the output format for computed results, derived from operator
 printf       a printf format for computed values
 fun          the lisp function to compute summary values, derived from operator
-calc         function to get values from base elements"
+calc         function to get values from base elements
+
+This function updates `org-columns-current-fmt-compiled'."
   (let ((start 0) width prop title op op-match f printf fun calc)
     (setq org-columns-current-fmt-compiled nil)
     (while (string-match
@@ -1356,60 +1381,73 @@ and tailing newline characters."
   (org-columns-remove-overlays)
   (move-marker org-columns-begin-marker (point))
   (let ((org-columns-time (time-to-number-of-days (current-time)))
-       cache maxwidths m p a d fmt)
-    (cond
-     ((and (boundp 'org-agenda-overriding-columns-format)
-          org-agenda-overriding-columns-format)
-      (setq fmt org-agenda-overriding-columns-format))
-     ((setq m (org-get-at-bol 'org-hd-marker))
-      (setq fmt (or (org-entry-get m "COLUMNS" t)
-                   (with-current-buffer (marker-buffer m)
-                     org-columns-default-format))))
-     ((and (boundp 'org-columns-current-fmt)
-          (local-variable-p 'org-columns-current-fmt)
-          org-columns-current-fmt)
-      (setq fmt org-columns-current-fmt))
-     ((setq m (next-single-property-change (point-min) 'org-hd-marker))
-      (setq m (get-text-property m 'org-hd-marker))
-      (setq fmt (or (org-entry-get m "COLUMNS" t)
-                   (with-current-buffer (marker-buffer m)
-                     org-columns-default-format)))))
-    (setq fmt (or fmt org-columns-default-format))
+       (fmt
+        (cond
+         ((org-bound-and-true-p org-agenda-overriding-columns-format))
+         ((let ((m (org-get-at-bol 'org-hd-marker)))
+            (and m
+                 (or (org-entry-get m "COLUMNS" t)
+                     (with-current-buffer (marker-buffer m)
+                       org-columns-default-format)))))
+         ((and (local-variable-p 'org-columns-current-fmt)
+               org-columns-current-fmt))
+         ((let ((m (next-single-property-change (point-min) 'org-hd-marker)))
+            (and m
+                 (let ((m (get-text-property m 'org-hd-marker)))
+                   (or (org-entry-get m "COLUMNS" t)
+                       (with-current-buffer (marker-buffer m)
+                         org-columns-default-format))))))
+         (t org-columns-default-format))))
     (org-set-local 'org-columns-current-fmt fmt)
     (org-columns-compile-format fmt)
     (when org-agenda-columns-compute-summary-properties
       (org-agenda-colview-compute org-columns-current-fmt-compiled))
     (save-excursion
-      ;; Get and cache the properties
+      ;; Collect properties for each headline in current view.
       (goto-char (point-min))
-      (while (not (eobp))
-       (when (setq m (or (org-get-at-bol 'org-hd-marker)
-                         (org-get-at-bol 'org-marker)))
-         (setq p (org-entry-properties m))
-
-         (when (or (not (setq a (assoc-string org-effort-property p t)))
-                   (not (string-match "\\S-" (or (cdr a) ""))))
-           ;; OK, the property is not defined.  Use appointment duration?
-           (when (and org-agenda-columns-add-appointments-to-effort-sum
-                      (setq d (get-text-property (point) 'duration)))
-             (setq d (org-minutes-to-clocksum-string d))
-             (put-text-property 0 (length d) 'face 'org-warning d)
-             (push (cons org-effort-property d) p)))
-         (push (cons (org-current-line) p) cache))
-       (beginning-of-line 2))
-      (when cache
-       (setq maxwidths (org-columns-get-autowidth-alist fmt cache))
-       (org-set-local 'org-columns-current-maxwidths maxwidths)
-       (org-columns-display-here-title)
-       (when (org-set-local 'org-columns-flyspell-was-active
-                            (org-bound-and-true-p flyspell-mode))
-         (flyspell-mode 0))
-       (mapc (lambda (x)
-               (org-goto-line (car x))
-               (org-columns-display-here (cdr x)))
-             cache)
-       (when org-agenda-columns-show-summaries
-         (org-agenda-colview-summarize cache))))))
+      (let (cache)
+       (let ((names (mapcar #'car org-columns-current-fmt-compiled)) m)
+         (while (not (eobp))
+           (when (setq m (or (org-get-at-bol 'org-hd-marker)
+                             (org-get-at-bol 'org-marker)))
+             (push
+              (cons
+               (line-beginning-position)
+               (org-with-point-at m
+                 (mapcar
+                  (lambda (name)
+                    (let ((value (org-columns--value name (point))))
+                      (cons
+                       name
+                       (if (and org-agenda-columns-add-appointments-to-effort-sum
+                                (not value)
+                                (eq (compare-strings name nil nil
+                                                     org-effort-property nil nil
+                                                     t)
+                                    t)
+                                ;; Effort property is not defined.  Try
+                                ;; to use appointment duration.
+                                (get-text-property (point) 'duration))
+                           (org-propertize
+                            (org-minutes-to-clocksum-string
+                             (get-text-property (point) 'duration))
+                            'face 'org-warning)
+                         value))))
+                  names)))
+              cache))
+           (forward-line)))
+       (when cache
+         (org-set-local 'org-columns-current-maxwidths
+                        (org-columns-get-autowidth-alist fmt cache))
+         (org-columns-display-here-title)
+         (when (org-set-local 'org-columns-flyspell-was-active
+                              (org-bound-and-true-p flyspell-mode))
+           (flyspell-mode 0))
+         (dolist (x cache)
+           (goto-char (car x))
+           (org-columns-display-here (cdr x)))
+         (when org-agenda-columns-show-summaries
+           (org-agenda-colview-summarize cache)))))))
 
 (defun org-agenda-colview-summarize (cache)
   "Summarize the summarizable columns in column view in the agenda.
index 64e0379..a762b8e 100644 (file)
 ;; it in org-mode, because the Byte compiler evaluates (featurep 'xemacs)
 ;; at compilation time and can therefore optimize code better.
 (defconst org-xemacs-p (featurep 'xemacs))
-(defconst org-format-transports-properties-p
-  (let ((x "a"))
-    (add-text-properties 0 1 '(test t) x)
-    (get-text-property 0 'test (format "%s" x)))
-  "Does format transport text properties?")
 
 (defun org-compatible-face (inherits specs)
   "Make a compatible face specification.
@@ -241,7 +236,7 @@ ignored in this case."
   (or window (selected-window)))
 
 (defun org-number-sequence (from &optional to inc)
-  "Call `number-sequence or emulate it."
+  "Call `number-sequence' or emulate it."
   (if (fboundp 'number-sequence)
       (number-sequence from to inc)
     (if (or (not to) (= from to))
@@ -402,12 +397,8 @@ Pass BUFFER to the XEmacs version of `move-to-column'."
         (when focus-follows-mouse
           (set-mouse-position frame (1- (frame-width frame)) 0)))))
 
-(defun org-float-time (&optional time)
-  "Convert time value TIME to a floating point number.
-TIME defaults to the current time."
-  (if (featurep 'xemacs)
-      (time-to-seconds (or time (current-time)))
-    (float-time time)))
+(defalias 'org-float-time
+  (if (featurep 'xemacs) 'time-to-seconds 'float-time))
 
 ;; `user-error' is only available from 24.2.50 on
 (unless (fboundp 'user-error)
index bc07fc1..edc09fe 100644 (file)
@@ -261,16 +261,37 @@ to dead or no buffer."
             (make-progress-reporter "Updating Org Contacts Database..." 0 (length org-contacts-files)))
            (i 0))
        (dolist (file (org-contacts-files))
-         (org-check-agenda-file file)
-         (with-current-buffer (org-get-agenda-file-buffer file)
-           (unless (eq major-mode 'org-mode)
-             (error "File %s is not in `org-mode'" file))
-           (setf result
-                 (append result
-                         (org-scan-tags
-                          'org-contacts-at-point
-                          contacts-matcher
-                          todo-only))))
+         (if (catch 'nextfile
+                ;; if file doesn't exist and the user agrees to removing it
+                ;; from org-agendas-list, 'nextfile is thrown.  Catch it here
+                ;; and skip processing the file.
+                ;;
+                ;; TODO: suppose that the user has set an org-contacts-files
+                ;; list that contains an element that doesn't exist in the
+                ;; file system: in that case, the org-agenda-files list could
+                ;; be updated (and saved to the customizations of the user) if
+                ;; it contained the same file even though the org-agenda-files
+                ;; list wasn't actually used.  I don't think it is normal that
+                ;; org-contacts updates org-agenda-files in this case, but
+                ;; short of duplicating org-check-agenda-files and
+                ;; org-remove-files, I don't know how to avoid it.
+                ;;
+                ;; A side effect of the TODO is that the faulty
+                ;; org-contacts-files list never gets updated and thus the
+                ;; user is always queried about the missing files when
+                ;; org-contacts-db-need-update-p returns true.
+                (org-check-agenda-file file))
+              (message "Skipped %s removed from org-agenda-files list."
+                       (abbreviate-file-name file))
+           (with-current-buffer (org-get-agenda-file-buffer file)
+             (unless (eq major-mode 'org-mode)
+               (error "File %s is not in `org-mode'" file))
+             (setf result
+                   (append result
+                           (org-scan-tags
+                            'org-contacts-at-point
+                            contacts-matcher
+                            todo-only)))))
          (progress-reporter-update progress-reporter (setq i (1+ i))))
        (setf org-contacts-db result
              org-contacts-last-update (current-time))
index 46fd3e6..f527673 100644 (file)
@@ -1,6 +1,6 @@
 ;;; org-crypt.el --- Public key encryption for org-mode entries
 
-;; Copyright (C) 2007-2014 Free Software Foundation, Inc.
+;; Copyright (C) 2007-2015 Free Software Foundation, Inc.
 
 ;; Emacs Lisp Archive Entry
 ;; Filename: org-crypt.el
index 41775bd..a9baf04 100644 (file)
@@ -1,6 +1,6 @@
 ;;; org-ctags.el - Integrate Emacs "tags" facility with org mode.
 ;;
-;; Copyright (C) 2007-2014 Free Software Foundation, Inc.
+;; Copyright (C) 2007-2015 Free Software Foundation, Inc.
 
 ;; Author: Paul Sexton <eeeickythump@gmail.com>
 
 ;; with the same name as the link; then, if unsuccessful, ask the user if
 ;; he/she wants to rebuild the 'TAGS' database and try again; then ask if
 ;; the user wishes to append 'tag' as a new toplevel heading at the end of
-;; the buffer; and finally, defer to org's default behaviour which is to
+;; the buffer; and finally, defer to org's default behavior which is to
 ;; search the entire text of the current buffer for 'tag'.
 ;;
-;; This behaviour can be modified by changing the value of
+;; This behavior can be modified by changing the value of
 ;; ORG-CTAGS-OPEN-LINK-FUNCTIONS. For example I have the following in my
-;; .emacs, which describes the same behaviour as the above paragraph with
+;; .emacs, which describes the same behavior as the above paragraph with
 ;; one difference:
 ;;
 ;; (setq org-ctags-open-link-functions
 ;;       '(org-ctags-find-tag
 ;;         org-ctags-ask-rebuild-tags-file-then-find-tag
 ;;         org-ctags-ask-append-topic
-;;         org-ctags-fail-silently))  ; <-- prevents org default behaviour
+;;         org-ctags-fail-silently))  ; <-- prevents org default behavior
 ;;
 ;;
 ;; Usage
index 0646c3b..a97a9d0 100644 (file)
@@ -1,6 +1,6 @@
 ;;; org-datetree.el --- Create date entries in a tree
 
-;; Copyright (C) 2009-2014 Free Software Foundation, Inc.
+;; Copyright (C) 2009-2015 Free Software Foundation, Inc.
 
 ;; Author: Carsten Dominik <carsten at orgmode dot org>
 ;; Keywords: outlines, hypermedia, calendar, wp
@@ -39,7 +39,8 @@ property (any value), the date tree will become a subtree under that entry,
 so the base level will be properly adjusted.")
 
 (defcustom org-datetree-add-timestamp nil
-  "When non-nil, add a time stamp when create a datetree entry."
+  "When non-nil, add a time stamp matching date of entry.
+Added time stamp is active unless value is `inactive'."
   :group 'org-capture
   :version "24.3"
   :type '(choice
@@ -53,23 +54,22 @@ so the base level will be properly adjusted.")
 If KEEP-RESTRICTION is non-nil, do not widen the buffer.
 When it is nil, the buffer will be widened to make sure an existing date
 tree can be found."
-  (let ((year (nth 2 date))
-       (month (car date))
-       (day (nth 1 date)))
-    (org-set-local 'org-datetree-base-level 1)
-    (or keep-restriction (widen))
-    (goto-char (point-min))
-    (save-restriction
-      (when (re-search-forward "^[ \t]*:DATE_TREE:[ \t]+\\S-" nil t)
-       (org-back-to-heading t)
+  (org-set-local 'org-datetree-base-level 1)
+  (or keep-restriction (widen))
+  (save-restriction
+    (let ((prop (org-find-property "DATE_TREE")))
+      (when prop
+       (goto-char prop)
        (org-set-local 'org-datetree-base-level
-                      (org-get-valid-level (funcall outline-level) 1))
-       (org-narrow-to-subtree))
-      (goto-char (point-min))
+                      (org-get-valid-level (org-current-level) 1))
+       (org-narrow-to-subtree)))
+    (goto-char (point-min))
+    (let ((year (nth 2 date))
+         (month (car date))
+         (day (nth 1 date)))
       (org-datetree-find-year-create year)
       (org-datetree-find-month-create year month)
-      (org-datetree-find-day-create year month day)
-      (goto-char (prog1 (point) (widen))))))
+      (org-datetree-find-day-create year month day))))
 
 (defun org-datetree-find-year-create (year)
   "Find the YEAR datetree or create it."
@@ -131,28 +131,30 @@ tree can be found."
       (org-datetree-insert-line year month day)))))
 
 (defun org-datetree-insert-line (year &optional month day)
-  (let ((pos (point)) ts-type)
-    (skip-chars-backward " \t\n")
-    (delete-region (point) pos)
-    (insert "\n" (make-string org-datetree-base-level ?*) " \n")
-    (backward-char 1)
-    (if month (org-do-demote))
-    (if day (org-do-demote))
-    (insert (format "%d" year))
-    (when month
-      (insert (format "-%02d" month))
-      (if day
-         (insert (format "-%02d %s"
-                         day (format-time-string
-                              "%A" (encode-time 0 0 0 day month year))))
-       (insert (format " %s"
-                       (format-time-string
-                        "%B" (encode-time 0 0 0 1 month year))))))
-    (when (and day (setq ts-type org-datetree-add-timestamp))
+  (delete-region (save-excursion (skip-chars-backward " \t\n") (point)) (point))
+  (insert "\n" (make-string org-datetree-base-level ?*) " \n")
+  (backward-char)
+  (when month (org-do-demote))
+  (when day (org-do-demote))
+  (insert (format "%d" year))
+  (when month
+    (insert
+     (format "-%02d" month)
+     (if day
+        (format "-%02d %s"
+                day
+                (format-time-string "%A" (encode-time 0 0 0 day month year)))
+       (format " %s"
+              (format-time-string "%B" (encode-time 0 0 0 1 month year))))))
+  (when (and day org-datetree-add-timestamp)
+    (save-excursion
       (insert "\n")
       (org-indent-line)
-      (org-insert-time-stamp (encode-time 0 0 0 day month year) nil ts-type))
-    (beginning-of-line 1)))
+      (org-insert-time-stamp
+       (encode-time 0 0 0 day month year)
+       nil
+       (eq org-datetree-add-timestamp 'inactive))))
+  (beginning-of-line))
 
 (defun org-datetree-file-entry-under (txt date)
   "Insert a node TXT into the date tree under DATE."
index 81012e1..a78b806 100644 (file)
@@ -1,10 +1,28 @@
-;;; -*- coding: utf-8-unix -*-
+;; -*- coding: utf-8-unix -*-
 ;;; org-drill.el - Self-testing using spaced repetition
 ;;;
+;;; Copyright (C) 2010-2015  Paul Sexton
+;;;
 ;;; Author: Paul Sexton <eeeickythump@gmail.com>
-;;; Version: 2.4.5
+;;; Version: 2.4.7
+;;; Keywords: flashcards, memory, learning, memorization
 ;;; Repository at http://bitbucket.org/eeeickythump/org-drill/
 ;;;
+;;; This file is not part of GNU Emacs.
+;;;
+;;; This program is free software; you can redistribute it and/or modify
+;;; it under the terms of the GNU General Public License as published by
+;;; the Free Software Foundation, either version 3 of the License, or
+;;; (at your option) any later version.
+;;;
+;;; This program is distaributed in the hope that it will be useful,
+;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;;; GNU General Public License for more details.
+;;;
+;;; You should have received a copy of the GNU General Public License
+;;; along with this program.  If not, see <http://www.gnu.org/licenses/>.
+;;;
 ;;;
 ;;; Synopsis
 ;;; ========
@@ -31,6 +49,7 @@
 (require 'org)
 (require 'org-id)
 (require 'org-learn)
+(require 'savehist)
 
 
 (defgroup org-drill nil
@@ -203,6 +222,8 @@ during a drill session."
                     face default
                     window t))
 
+(add-hook 'org-font-lock-set-keywords-hook 'org-drill-add-cloze-fontification)
+
 
 (defvar org-drill-hint-separator "||"
   "String which, if it occurs within a cloze expression, signifies that the
@@ -233,6 +254,23 @@ the hidden cloze during a test.")
   (org-drill--compute-cloze-keywords))
 
 
+;; Variables defining what keys can be pressed during drill sessions to quit the
+;; session, edit the item, etc.
+(defvar org-drill--quit-key ?q
+  "If this character is pressed during a drill session, quit the session.")
+(defvar org-drill--edit-key ?e
+  "If this character is pressed during a drill session, suspend the session
+with the cursor at the current item..")
+(defvar org-drill--help-key ??
+  "If this character is pressed during a drill session, show help.")
+(defvar org-drill--skip-key ?s
+  "If this character is pressed during a drill session, skip to the next
+item.")
+(defvar org-drill--tags-key ?t
+  "If this character is pressed during a drill session, edit the tags for
+the current item.")
+
+
 (defcustom org-drill-card-type-alist
   '((nil org-drill-present-simple-card)
     ("simple" org-drill-present-simple-card)
@@ -349,16 +387,37 @@ Available choices are:
 
 (defcustom org-drill-optimal-factor-matrix
   nil
+  "Obsolete and will be removed in future. The SM5 optimal factor
+matrix data is now stored in the variable
+`org-drill-sm5-optimal-factor-matrix'."
+  :group 'org-drill
+  :type 'sexp)
+
+
+(defvar org-drill-sm5-optimal-factor-matrix
+  nil
   "DO NOT CHANGE THE VALUE OF THIS VARIABLE.
 
-Persistent matrix of optimal factors, used by the SuperMemo SM5 algorithm.
-The matrix is saved (using the 'customize' facility) at the end of each
-drill session.
+Persistent matrix of optimal factors, used by the SuperMemo SM5
+algorithm. The matrix is saved at the end of each drill session.
 
 Over time, values in the matrix will adapt to the individual user's
-pace of learning."
-  :group 'org-drill
-  :type 'sexp)
+pace of learning.")
+
+
+(add-to-list 'savehist-additional-variables
+             'org-drill-sm5-optimal-factor-matrix)
+(unless savehist-mode
+  (savehist-mode 1))
+
+
+(defun org-drill--transfer-optimal-factor-matrix ()
+  (if (and org-drill-optimal-factor-matrix
+           (null org-drill-sm5-optimal-factor-matrix))
+      (setq org-drill-sm5-optimal-factor-matrix
+            org-drill-optimal-factor-matrix)))
+
+(add-hook 'after-init-hook 'org-drill--transfer-optimal-factor-matrix)
 
 
 (defcustom org-drill-sm5-initial-interval
@@ -979,7 +1038,7 @@ Returns a list: (INTERVAL REPEATS EF FAILURES MEAN TOTAL-REPEATS OFMATRIX), wher
       ;; When an item is failed, its interval is reset to 0,
       ;; but its EF is unchanged
       (list -1 1 ef (1+ failures) meanq (1+ total-repeats)
-            org-drill-optimal-factor-matrix)
+            org-drill-sm5-optimal-factor-matrix)
     ;; else:
     (let* ((next-ef (modify-e-factor ef quality))
            (interval
@@ -1003,7 +1062,7 @@ Returns a list: (INTERVAL REPEATS EF FAILURES MEAN TOTAL-REPEATS OFMATRIX), wher
             (1+ n)
             next-ef
             failures meanq (1+ total-repeats)
-            org-drill-optimal-factor-matrix))))
+            org-drill-sm5-optimal-factor-matrix))))
 
 
 ;;; SM5 Algorithm =============================================================
@@ -1025,7 +1084,7 @@ Returns a list: (INTERVAL REPEATS EF FAILURES MEAN TOTAL-REPEATS OFMATRIX), wher
 
 (defun inter-repetition-interval-sm5 (last-interval n ef &optional of-matrix)
   (let ((of (get-optimal-factor-sm5 n ef (or of-matrix
-                                             org-drill-optimal-factor-matrix))))
+                                             org-drill-sm5-optimal-factor-matrix))))
     (if (= 1 n)
         of
       (* of last-interval))))
@@ -1039,7 +1098,7 @@ Returns a list: (INTERVAL REPEATS EF FAILURES MEAN TOTAL-REPEATS OFMATRIX), wher
   (assert (> n 0))
   (assert (and (>= quality 0) (<= quality 5)))
   (unless of-matrix
-    (setq of-matrix org-drill-optimal-factor-matrix))
+    (setq of-matrix org-drill-sm5-optimal-factor-matrix))
   (setq of-matrix (cl-copy-tree of-matrix))
 
   (setq meanq (if meanq
@@ -1205,7 +1264,7 @@ item will be scheduled exactly this many days into the future."
   (let ((delta-days (- (time-to-days (current-time))
                        (time-to-days (or (org-get-scheduled-time (point))
                                          (current-time)))))
-        (ofmatrix org-drill-optimal-factor-matrix)
+        (ofmatrix org-drill-sm5-optimal-factor-matrix)
         ;; Entries can have weights, 1 by default. Intervals are divided by the
         ;; item's weight, so an item with a weight of 2 will have all intervals
         ;; halved, meaning you will end up reviewing it twice as often.
@@ -1244,7 +1303,7 @@ item will be scheduled exactly this many days into the future."
                                    total-repeats meanq ease)
 
         (if (eql 'sm5 org-drill-spaced-repetition-algorithm)
-            (setq org-drill-optimal-factor-matrix new-ofmatrix))
+            (setq org-drill-sm5-optimal-factor-matrix new-ofmatrix))
 
         (cond
          ((= 0 days-ahead)
@@ -1274,7 +1333,7 @@ of QUALITY."
             (sm5 (determine-next-interval-sm5 last-interval repetitions
                                               ease quality failures
                                               meanq total-repeats
-                                              org-drill-optimal-factor-matrix))
+                                              org-drill-sm5-optimal-factor-matrix))
             (sm2 (determine-next-interval-sm2 last-interval repetitions
                                               ease quality failures
                                               meanq total-repeats))
@@ -1304,11 +1363,19 @@ of QUALITY."
   "Returns quality rating (0-5), or nil if the user quit."
   (let ((ch nil)
         (input nil)
-        (next-review-dates (org-drill-hypothetical-next-review-dates)))
+        (next-review-dates (org-drill-hypothetical-next-review-dates))
+        (key-prompt (format "(0-5, %c=help, %c=edit, %c=tags, %c=quit)"
+                            org-drill--help-key
+                            org-drill--edit-key
+                            org-drill--tags-key
+                            org-drill--quit-key)))
     (save-excursion
-      (while (not (memq ch '(?q ?e ?0 ?1 ?2 ?3 ?4 ?5)))
+      (while (not (memq ch (list org-drill--quit-key
+                                 org-drill--edit-key
+                                 7          ; C-g
+                                 ?0 ?1 ?2 ?3 ?4 ?5)))
         (setq input (read-key-sequence
-                     (if (eq ch ??)
+                     (if (eq ch org-drill--help-key)
                          (format "0-2 Means you have forgotten the item.
 3-5 Means you have remembered the item.
 
@@ -1319,11 +1386,12 @@ of QUALITY."
 4 - After a little bit of thought you remembered. (+%s days)
 5 - You remembered the item really easily. (+%s days)
 
-How well did you do? (0-5, ?=help, e=edit, t=tags, q=quit)"
+How well did you do? %s"
                                  (round (nth 3 next-review-dates))
                                  (round (nth 4 next-review-dates))
-                                 (round (nth 5 next-review-dates)))
-                       "How well did you do? (0-5, ?=help, e=edit, t=tags, q=quit)")))
+                                 (round (nth 5 next-review-dates))
+                                 key-prompt)
+                       (format "How well did you do? %s" key-prompt))))
         (cond
          ((stringp input)
           (setq ch (elt input 0)))
@@ -1340,7 +1408,7 @@ How well did you do? (0-5, ?=help, e=edit, t=tags, q=quit)"
           (case (car (elt input 0))
             (wheel-up (ignore-errors (mwheel-scroll (elt input 0))))
             (wheel-down (ignore-errors (mwheel-scroll (elt input 0)))))))
-        (if (eql ch ?t)
+        (if (eql ch org-drill--tags-key)
             (org-set-tags-command))))
     (cond
      ((and (>= ch ?0) (<= ch ?5))
@@ -1371,7 +1439,7 @@ How well did you do? (0-5, ?=help, e=edit, t=tags, q=quit)"
           (org-set-property "DRILL_LAST_REVIEWED"
                             (time-to-inactive-org-timestamp (current-time))))
         quality))
-     ((= ch ?e)
+     ((= ch org-drill--edit-key)
       'edit)
      (t
       nil))))
@@ -1442,8 +1510,12 @@ the current topic."
               (apply 'format
                      (first fmt-and-args)
                      (rest fmt-and-args))
-            (concat "Press key for answer, "
-                    "e=edit, t=tags, s=skip, q=quit."))))
+            (format (concat "Press key for answer, "
+                            "%c=edit, %c=tags, %c=skip, %c=quit.")
+                    org-drill--edit-key
+                    org-drill--tags-key
+                    org-drill--skip-key
+                    org-drill--quit-key))))
     (setq prompt
           (format "%s %s %s %s %s %s"
                   (propertize
@@ -1489,7 +1561,7 @@ You seem to be having a lot of trouble memorising this item.
 Consider reformulating the item to make it easier to remember.\n"
                                   'face '(:foreground "red"))
                       prompt)))
-    (while (memq ch '(nil ?t))
+    (while (memq ch '(nil org-drill--tags-key))
       (setq ch nil)
       (while (not (input-pending-p))
         (let ((elapsed (time-subtract (current-time) item-start-time)))
@@ -1500,12 +1572,12 @@ Consider reformulating the item to make it easier to remember.\n"
           (sit-for 1)))
       (setq input (read-key-sequence nil))
       (if (stringp input) (setq ch (elt input 0)))
-      (if (eql ch ?t)
+      (if (eql ch org-drill--tags-key)
           (org-set-tags-command)))
     (case ch
-      (?q nil)
-      (?e 'edit)
-      (?s 'skip)
+      (org-drill--quit-key nil)
+      (org-drill--edit-key 'edit)
+      (org-drill--skip-key 'skip)
       (otherwise t))))
 
 
@@ -2517,11 +2589,55 @@ STATUS is one of the following values:
            (sym1 (if (oddp (floor scanned (* 50 meter-width))) ?| ?.))
            (sym2 (if (eql sym1 ?.) ?| ?.)))
       (message "Collecting due drill items:%4d %s%s"
-              collected
-              (make-string (% (ceiling scanned 50) meter-width)
-                           sym2)
-              (make-string (- meter-width (% (ceiling scanned 50) meter-width))
-                           sym1)))))
+               collected
+               (make-string (% (ceiling scanned 50) meter-width)
+                            sym2)
+               (make-string (- meter-width (% (ceiling scanned 50) meter-width))
+                            sym1)))))
+
+
+(defun org-map-drill-entry-function ()
+  (org-drill-progress-message
+   (+ (length *org-drill-new-entries*)
+      (length *org-drill-overdue-entries*)
+      (length *org-drill-young-mature-entries*)
+      (length *org-drill-old-mature-entries*)
+      (length *org-drill-failed-entries*))
+   (incf cnt))
+  (cond
+   ((not (org-drill-entry-p))
+    nil)               ; skip
+   (t
+    (when (and (not warned-about-id-creation)
+               (null (org-id-get)))
+      (message (concat "Creating unique IDs for items "
+                       "(slow, but only happens once)"))
+      (sit-for 0.5)
+      (setq warned-about-id-creation t))
+    (org-id-get-create) ; ensure drill entry has unique ID
+    (destructuring-bind (status due age)
+        (org-drill-entry-status)
+      (case status
+        (:unscheduled
+         (incf *org-drill-dormant-entry-count*))
+        ;; (:tomorrow
+        ;;  (incf *org-drill-dormant-entry-count*)
+        ;;  (incf *org-drill-due-tomorrow-count*))
+        (:future
+         (incf *org-drill-dormant-entry-count*)
+         (if (eq -1 due)
+             (incf *org-drill-due-tomorrow-count*)))
+        (:new
+         (push (point-marker) *org-drill-new-entries*))
+        (:failed
+         (push (point-marker) *org-drill-failed-entries*))
+        (:young
+         (push (point-marker) *org-drill-young-mature-entries*))
+        (:overdue
+         (push (list (point-marker) due age) overdue-data))
+        (:old
+         (push (point-marker) *org-drill-old-mature-entries*))
+        )))))
 
 
 (defun org-drill (&optional scope drill-match resume-p)
@@ -2597,48 +2713,7 @@ work correctly with older versions of org mode. Your org mode version (%s) appea
               (let ((org-trust-scanner-tags t)
                     (warned-about-id-creation nil))
                 (org-map-drill-entries
-                 (lambda ()
-                   (org-drill-progress-message
-                    (+ (length *org-drill-new-entries*)
-                       (length *org-drill-overdue-entries*)
-                       (length *org-drill-young-mature-entries*)
-                       (length *org-drill-old-mature-entries*)
-                       (length *org-drill-failed-entries*))
-                    (incf cnt))
-                   (cond
-                    ((not (org-drill-entry-p))
-                     nil)               ; skip
-                    (t
-                     (when (and (not warned-about-id-creation)
-                                (null (org-id-get)))
-                       (message (concat "Creating unique IDs for items "
-                                        "(slow, but only happens once)"))
-                       (sit-for 0.5)
-                       (setq warned-about-id-creation t))
-                     (org-id-get-create) ; ensure drill entry has unique ID
-                     (destructuring-bind (status due age)
-                         (org-drill-entry-status)
-                       (case status
-                         (:unscheduled
-                          (incf *org-drill-dormant-entry-count*))
-                         ;; (:tomorrow
-                         ;;  (incf *org-drill-dormant-entry-count*)
-                         ;;  (incf *org-drill-due-tomorrow-count*))
-                         (:future
-                          (incf *org-drill-dormant-entry-count*)
-                          (if (eq -1 due)
-                              (incf *org-drill-due-tomorrow-count*)))
-                         (:new
-                          (push (point-marker) *org-drill-new-entries*))
-                         (:failed
-                          (push (point-marker) *org-drill-failed-entries*))
-                         (:young
-                          (push (point-marker) *org-drill-young-mature-entries*))
-                         (:overdue
-                          (push (list (point-marker) due age) overdue-data))
-                         (:old
-                          (push (point-marker) *org-drill-old-mature-entries*))
-                         )))))
+                 'org-map-drill-entry-function
                  scope drill-match)
                 (org-drill-order-overdue-entries overdue-data)
                 (setq *org-drill-overdue-entry-count*
@@ -2681,9 +2756,7 @@ work correctly with older versions of org mode. Your org mode version (%s) appea
 
 
 (defun org-drill-save-optimal-factor-matrix ()
-  (message "Saving optimal factor matrix...")
-  (customize-save-variable 'org-drill-optimal-factor-matrix
-                           org-drill-optimal-factor-matrix))
+  (savehist-autosave))
 
 
 (defun org-drill-cram (&optional scope drill-match)
@@ -2794,7 +2867,6 @@ values as `org-drill-scope'."
     (add-to-list 'org-font-lock-extra-keywords
                  (first org-drill-cloze-keywords))))
 
-(add-hook 'org-font-lock-set-keywords-hook 'org-drill-add-cloze-fontification)
 
 ;; Can't add to org-mode-hook, because local variables won't have been loaded
 ;; yet.
index 74d99f1..3c882e5 100644 (file)
@@ -1,4 +1,4 @@
-;;; org-element.el --- Parser And Applications for Org syntax
+;;; org-element.el --- Parser for Org Syntax         -*- lexical-binding: t; -*-
 
 ;; Copyright (C) 2012-2015 Free Software Foundation, Inc.
 
 
 ;;; Code:
 
-(eval-when-compile (require 'cl))
 (require 'org)
 (require 'avl-tree)
 
@@ -158,22 +157,27 @@ specially in `org-element--object-lex'.")
                ;; Empty lines.
                "$" "\\|"
                ;; Tables (any type).
-               "\\(?:|\\|\\+-[-+]\\)" "\\|"
-               ;; Blocks (any type), Babel calls and keywords.  This
-               ;; is only an indication and need some thorough check.
-               "#\\(?:[+ ]\\|$\\)" "\\|"
-               ;; Drawers (any type) and fixed-width areas.  This is
-               ;; also only an indication.
-               ":" "\\|"
+               "|" "\\|"
+               "\\+\\(?:-+\\+\\)+[ \t]*$" "\\|"
+               ;; Comments, keyword-like or block-like constructs.
+               ;; Blocks and keywords with dual values need to be
+               ;; double-checked.
+               "#\\(?: \\|$\\|\\+\\(?:"
+               "BEGIN_\\S-+" "\\|"
+               "\\S-+\\(?:\\[.*\\]\\)?:[ \t]*\\)\\)"
+               "\\|"
+               ;; Drawers (any type) and fixed-width areas.  Drawers
+               ;; need to be double-checked.
+               ":\\(?: \\|$\\|[-_[:word:]]+:[ \t]*$\\)" "\\|"
                ;; Horizontal rules.
                "-\\{5,\\}[ \t]*$" "\\|"
                ;; LaTeX environments.
-               "\\\\begin{\\([A-Za-z0-9]+\\*?\\)}" "\\|"
+               "\\\\begin{\\([A-Za-z0-9*]+\\)}" "\\|"
                ;; Clock lines.
                (regexp-quote org-clock-string) "\\|"
                ;; Lists.
-               (let ((term (case org-plain-list-ordered-item-terminator
-                             (?\) ")") (?. "\\.") (otherwise "[.)]")))
+               (let ((term (pcase org-plain-list-ordered-item-terminator
+                             (?\) ")") (?. "\\.") (_ "[.)]")))
                      (alpha (and org-list-allow-alphabetical "\\|[A-Za-z]")))
                  (concat "\\(?:[-+*]\\|\\(?:[0-9]+" alpha "\\)" term "\\)"
                          "\\(?:[ \t]\\|$\\)"))
@@ -319,13 +323,8 @@ associated to a hash value with the following:
 This list is checked after translations have been applied.  See
 `org-element-keyword-translation-alist'.")
 
-(defconst org-element-document-properties '("AUTHOR" "DATE" "TITLE")
-  "List of properties associated to the whole document.
-Any keyword in this list will have its value parsed and stored as
-a secondary string.")
-
 (defconst org-element--affiliated-re
-  (format "[ \t]*#\\+\\(?:%s\\):\\(?: \\|$\\)"
+  (format "[ \t]*#\\+\\(?:%s\\):[ \t]*"
          (concat
           ;; Dual affiliated keywords.
           (format "\\(?1:%s\\)\\(?:\\[\\(.*\\)\\]\\)?"
@@ -335,8 +334,7 @@ a secondary string.")
           (format "\\(?1:%s\\)"
                   (regexp-opt
                    (org-remove-if
-                    #'(lambda (keyword)
-                        (member keyword org-element-dual-keywords))
+                    (lambda (k) (member k org-element-dual-keywords))
                     org-element-affiliated-keywords)))
           "\\|"
           ;; Export attributes.
@@ -491,18 +489,18 @@ objects, or a strings.
 
 The function takes care of setting `:parent' property for CHILD.
 Return parent element."
-  ;; Link every child to PARENT. If PARENT is nil, it is a secondary
-  ;; string: parent is the list itself.
-  (mapc (lambda (child)
-         (org-element-put-property child :parent (or parent children)))
-       children)
-  ;; Add CHILDREN at the end of PARENT contents.
-  (when parent
-    (apply 'org-element-set-contents
-          parent
-          (nconc (org-element-contents parent) children)))
-  ;; Return modified PARENT element.
-  (or parent children))
+  (if (not children) parent
+    ;; Link every child to PARENT. If PARENT is nil, it is a secondary
+    ;; string: parent is the list itself.
+    (dolist (child children)
+      (org-element-put-property child :parent (or parent children)))
+    ;; Add CHILDREN at the end of PARENT contents.
+    (when parent
+      (apply #'org-element-set-contents
+            parent
+            (nconc (org-element-contents parent) children)))
+    ;; Return modified PARENT element.
+    (or parent children)))
 
 (defun org-element-extract-element (element)
   "Extract ELEMENT from parse tree.
@@ -575,17 +573,24 @@ The function takes care of setting `:parent' property for NEW."
     ;; Transfer type.
     (setcar old (car new))))
 
+(defun org-element-create (type &optional props &rest children)
+  "Create a new element of type TYPE.
+Optional argument PROPS, when non-nil, is a plist defining the
+properties of the element.  CHILDREN can be elements, objects or
+strings."
+  (apply #'org-element-adopt-elements (list type props) children))
+
 (defun org-element-copy (datum)
   "Return a copy of DATUM.
 DATUM is an element, object, string or nil.  `:parent' property
 is cleared and contents are removed in the process."
   (when datum
     (let ((type (org-element-type datum)))
-      (case type
-       (org-data (list 'org-data nil))
-       (plain-text (substring-no-properties datum))
-       ((nil) (copy-sequence datum))
-       (otherwise
+      (pcase type
+       (`org-data (list 'org-data nil))
+       (`plain-text (substring-no-properties datum))
+       (`nil (copy-sequence datum))
+       (_
         (list type (plist-put (copy-sequence (nth 1 datum)) :parent nil)))))))
 
 
@@ -668,8 +673,8 @@ Assume point is at the beginning of the block."
                       :post-affiliated post-affiliated)
                 (cdr affiliated))))))))
 
-(defun org-element-center-block-interpreter (center-block contents)
-  "Interpret CENTER-BLOCK element as Org syntax.
+(defun org-element-center-block-interpreter (_ contents)
+  "Interpret a center-block element as Org syntax.
 CONTENTS is the contents of the element."
   (format "#+BEGIN_CENTER\n%s#+END_CENTER" contents))
 
@@ -947,8 +952,6 @@ Assume point is at beginning of the headline."
                                     (skip-chars-backward " \r\t\n")
                                     (forward-line)
                                     (point)))))
-      ;; Clean TAGS from archive tag, if any.
-      (when archivedp (setq tags (delete org-archive-tag tags)))
       (let ((headline
             (list 'headline
                   (nconc
@@ -997,10 +1000,7 @@ CONTENTS is the contents of the element."
         (priority (org-element-property :priority headline))
         (title (org-element-interpret-data
                 (org-element-property :title headline)))
-        (tags (let ((tag-list (if (org-element-property :archivedp headline)
-                                  (cons org-archive-tag
-                                        (org-element-property :tags headline))
-                                (org-element-property :tags headline))))
+        (tags (let ((tag-list (org-element-property :tags headline)))
                 (and tag-list
                      (format ":%s:" (mapconcat #'identity tag-list ":")))))
         (commentedp (org-element-property :commentedp headline))
@@ -1168,7 +1168,7 @@ CONTENTS is the contents of inlinetask."
 
 ;;;; Item
 
-(defun org-element-item-parser (limit struct &optional raw-secondary-p)
+(defun org-element-item-parser (_ struct &optional raw-secondary-p)
   "Parse an item.
 
 STRUCT is the structure of the plain list.
@@ -1188,11 +1188,11 @@ Assume point is at the beginning of the item."
     (looking-at org-list-full-item-re)
     (let* ((begin (point))
           (bullet (org-match-string-no-properties 1))
-          (checkbox (let ((box (org-match-string-no-properties 3)))
+          (checkbox (let ((box (match-string 3)))
                       (cond ((equal "[ ]" box) 'off)
                             ((equal "[X]" box) 'on)
                             ((equal "[-]" box) 'trans))))
-          (counter (let ((c (org-match-string-no-properties 2)))
+          (counter (let ((c (match-string 2)))
                      (save-match-data
                        (cond
                         ((not c) nil)
@@ -1202,8 +1202,7 @@ Assume point is at the beginning of the item."
                         ((string-match "[0-9]+" c)
                          (string-to-number (match-string 0 c)))))))
           (end (progn (goto-char (nth 6 (assq (point) struct)))
-                      (unless (bolp) (forward-line))
-                      (point)))
+                      (if (bolp) (point) (line-beginning-position 2))))
           (contents-begin
            (progn (goto-char
                    ;; Ignore tags in un-ordered lists: they are just
@@ -1212,30 +1211,27 @@ Assume point is at the beginning of the item."
                             (save-match-data (string-match "[.)]" bullet)))
                        (match-beginning 4)
                      (match-end 0)))
-                  (skip-chars-forward " \r\t\n" limit)
-                  ;; If first line isn't empty, contents really start
-                  ;; at the text after item's meta-data.
-                  (if (= (point-at-bol) begin) (point) (point-at-bol))))
-          (contents-end (progn (goto-char end)
-                               (skip-chars-backward " \r\t\n")
-                               (forward-line)
-                               (point)))
+                  (skip-chars-forward " \r\t\n" end)
+                  (cond ((= (point) end) nil)
+                        ;; If first line isn't empty, contents really
+                        ;; start at the text after item's meta-data.
+                        ((= (line-beginning-position) begin) (point))
+                        (t (line-beginning-position)))))
+          (contents-end (and contents-begin
+                             (progn (goto-char end)
+                                    (skip-chars-backward " \r\t\n")
+                                    (line-beginning-position 2))))
           (item
            (list 'item
                  (list :bullet bullet
                        :begin begin
                        :end end
-                       ;; CONTENTS-BEGIN and CONTENTS-END may be
-                       ;; mixed up in the case of an empty item
-                       ;; separated from the next by a blank line.
-                       ;; Thus ensure the former is always the
-                       ;; smallest.
-                       :contents-begin (min contents-begin contents-end)
-                       :contents-end (max contents-begin contents-end)
+                       :contents-begin contents-begin
+                       :contents-end contents-end
                        :checkbox checkbox
                        :counter counter
                        :structure struct
-                       :post-blank (count-lines contents-end end)
+                       :post-blank (count-lines (or contents-end begin) end)
                        :post-affiliated begin))))
       (org-element-put-property
        item :tag
@@ -1269,10 +1265,11 @@ CONTENTS is the contents of the element."
     (concat
      bullet
      (and counter (format "[@%d] " counter))
-     (case checkbox
-       (on "[X] ")
-       (off "[ ] ")
-       (trans "[-] "))
+     (pcase checkbox
+       (`on "[X] ")
+       (`off "[ ] ")
+       (`trans "[-] ")
+       (_ nil))
      (and tag (format "%s :: " tag))
      (when contents
        (let ((contents (replace-regexp-in-string
@@ -1344,7 +1341,8 @@ CONTENTS is the contents of the element."
                  (goto-char origin)))))
           ;; At some text line.  Check if it ends any previous item.
           (t
-           (let ((ind (progn (skip-chars-forward " \t") (current-column))))
+           (let ((ind (save-excursion (skip-chars-forward " \t")
+                                      (current-column))))
              (when (<= ind top-ind)
                (skip-chars-backward " \r\t\n")
                (forward-line))
@@ -1353,10 +1351,10 @@ CONTENTS is the contents of the element."
                  (setcar (nthcdr 6 item) (line-beginning-position))
                  (push item struct)
                  (unless items
-                   (throw 'exit (sort struct 'car-less-than-car))))))
+                   (throw 'exit (sort struct #'car-less-than-car))))))
            ;; Skip blocks (any type) and drawers contents.
            (cond
-            ((and (looking-at "#\\+BEGIN\\(:\\|_\\S-+\\)")
+            ((and (looking-at "[ \t]*#\\+BEGIN\\(:\\|_\\S-+\\)")
                   (re-search-forward
                    (format "^[ \t]*#\\+END%s[ \t]*$" (match-string 1))
                    limit t)))
@@ -1409,8 +1407,8 @@ Assume point is at the beginning of the list."
                   :post-affiliated contents-begin)
             (cdr affiliated))))))
 
-(defun org-element-plain-list-interpreter (plain-list contents)
-  "Interpret PLAIN-LIST element as Org syntax.
+(defun org-element-plain-list-interpreter (_ contents)
+  "Interpret plain-list element as Org syntax.
 CONTENTS is the contents of the element."
   (with-temp-buffer
     (insert contents)
@@ -1449,8 +1447,8 @@ Assume point is at the beginning of the property drawer."
                    :post-blank (count-lines before-blank end)
                    :post-affiliated begin))))))
 
-(defun org-element-property-drawer-interpreter (property-drawer contents)
-  "Interpret PROPERTY-DRAWER element as Org syntax.
+(defun org-element-property-drawer-interpreter (_ contents)
+  "Interpret property-drawer element as Org syntax.
 CONTENTS is the properties within the drawer."
   (format ":PROPERTIES:\n%s:END:" contents))
 
@@ -1499,19 +1497,17 @@ Assume point is at the beginning of the block."
                         :post-affiliated post-affiliated)
                   (cdr affiliated)))))))))
 
-(defun org-element-quote-block-interpreter (quote-block contents)
-  "Interpret QUOTE-BLOCK element as Org syntax.
+(defun org-element-quote-block-interpreter (_ contents)
+  "Interpret quote-block element as Org syntax.
 CONTENTS is the contents of the element."
   (format "#+BEGIN_QUOTE\n%s#+END_QUOTE" contents))
 
 
 ;;;; Section
 
-(defun org-element-section-parser (limit)
+(defun org-element-section-parser (_)
   "Parse a section.
 
-LIMIT bounds the search.
-
 Return a list whose CAR is `section' and CDR is a plist
 containing `:begin', `:end', `:contents-begin', `contents-end',
 `:post-blank' and `:post-affiliated' keywords."
@@ -1522,8 +1518,7 @@ containing `:begin', `:end', `:contents-begin', `contents-end',
          (end (progn (org-with-limited-levels (outline-next-heading))
                      (point)))
          (pos-before-blank (progn (skip-chars-backward " \r\t\n")
-                                  (forward-line)
-                                  (point))))
+                                  (line-beginning-position 2))))
       (list 'section
            (list :begin begin
                  :end end
@@ -1532,8 +1527,8 @@ containing `:begin', `:end', `:contents-begin', `contents-end',
                  :post-blank (count-lines pos-before-blank end)
                  :post-affiliated begin)))))
 
-(defun org-element-section-interpreter (section contents)
-  "Interpret SECTION element as Org syntax.
+(defun org-element-section-interpreter (_ contents)
+  "Interpret section element as Org syntax.
 CONTENTS is the contents of the element."
   contents)
 
@@ -1614,37 +1609,54 @@ CONTENTS is the contents of the element."
 (defun org-element-babel-call-parser (limit affiliated)
   "Parse a babel call.
 
-LIMIT bounds the search.  AFFILIATED is a list of which CAR is
+LIMIT bounds the search.  AFFILIATED is a list of which car is
 the buffer position at the beginning of the first affiliated
-keyword and CDR is a plist of affiliated keywords along with
+keyword and cdr is a plist of affiliated keywords along with
 their value.
 
-Return a list whose CAR is `babel-call' and CDR is a plist
-containing `:begin', `:end', `:value', `:post-blank' and
+Return a list whose car is `babel-call' and cdr is a plist
+containing `:call', `:inside-header', `:arguments',
+`:end-header', `:begin', `:end', `:value', `:post-blank' and
 `:post-affiliated' as keywords."
   (save-excursion
-    (let ((begin (car affiliated))
-         (post-affiliated (point))
-         (value (progn (let ((case-fold-search t))
-                         (re-search-forward "call:[ \t]*" nil t))
-                       (buffer-substring-no-properties (point)
-                                                       (line-end-position))))
-         (pos-before-blank (progn (forward-line) (point)))
-         (end (progn (skip-chars-forward " \r\t\n" limit)
-                     (if (eobp) (point) (line-beginning-position)))))
+    (let* ((begin (car affiliated))
+          (post-affiliated (point))
+          (value (progn (search-forward ":" nil t)
+                        (org-trim
+                         (buffer-substring-no-properties
+                          (point) (line-end-position)))))
+          (pos-before-blank (progn (forward-line) (point)))
+          (end (progn (skip-chars-forward " \r\t\n" limit)
+                      (if (eobp) (point) (line-beginning-position))))
+          (valid-value
+           (string-match
+            "\\([^()\n]+?\\)\\(?:\\[\\(.*?\\)\\]\\)?(\\(.*\\))[ \t]*\\(.*\\)"
+            value)))
       (list 'babel-call
            (nconc
-            (list :begin begin
+            (list :call (and valid-value (match-string 1 value))
+                  :inside-header (and valid-value
+                                      (org-string-nw-p (match-string 2 value)))
+                  :arguments (and valid-value
+                                  (org-string-nw-p (match-string 3 value)))
+                  :end-header (and valid-value
+                                   (org-string-nw-p (match-string 4 value)))
+                  :begin begin
                   :end end
                   :value value
                   :post-blank (count-lines pos-before-blank end)
                   :post-affiliated post-affiliated)
             (cdr affiliated))))))
 
-(defun org-element-babel-call-interpreter (babel-call contents)
-  "Interpret BABEL-CALL element as Org syntax.
-CONTENTS is nil."
-  (concat "#+CALL: " (org-element-property :value babel-call)))
+(defun org-element-babel-call-interpreter (babel-call _)
+  "Interpret BABEL-CALL element as Org syntax."
+  (concat "#+CALL: "
+         (org-element-property :call babel-call)
+         (let ((h (org-element-property :inside-header babel-call)))
+           (and h (format "[%s]" h)))
+         (concat "(" (org-element-property :arguments babel-call) ")")
+         (let ((h (org-element-property :end-header babel-call)))
+           (and h (concat " " h)))))
 
 
 ;;;; Clock
@@ -1683,9 +1695,8 @@ Return a list whose CAR is `clock' and CDR is a plist containing
                  :post-blank post-blank
                  :post-affiliated begin)))))
 
-(defun org-element-clock-interpreter (clock contents)
-  "Interpret CLOCK element as Org syntax.
-CONTENTS is nil."
+(defun org-element-clock-interpreter (clock _)
+  "Interpret CLOCK element as Org syntax."
   (concat org-clock-string " "
          (org-element-timestamp-interpreter
           (org-element-property :value clock) nil)
@@ -1744,7 +1755,7 @@ Assume point is at comment beginning."
                   :post-affiliated post-affiliated)
             (cdr affiliated))))))
 
-(defun org-element-comment-interpreter (comment contents)
+(defun org-element-comment-interpreter (comment _)
   "Interpret COMMENT element as Org syntax.
 CONTENTS is nil."
   (replace-regexp-in-string "^" "# " (org-element-property :value comment)))
@@ -1791,9 +1802,8 @@ Assume point is at comment block beginning."
                         :post-affiliated post-affiliated)
                   (cdr affiliated)))))))))
 
-(defun org-element-comment-block-interpreter (comment-block contents)
-  "Interpret COMMENT-BLOCK element as Org syntax.
-CONTENTS is nil."
+(defun org-element-comment-block-interpreter (comment-block _)
+  "Interpret COMMENT-BLOCK element as Org syntax."
   (format "#+BEGIN_COMMENT\n%s#+END_COMMENT"
          (org-element-normalize-string
           (org-remove-indentation
@@ -1830,9 +1840,8 @@ containing `:begin', `:end', `:value', `:post-blank' and
                   :post-affiliated post-affiliated)
             (cdr affiliated))))))
 
-(defun org-element-diary-sexp-interpreter (diary-sexp contents)
-  "Interpret DIARY-SEXP as Org syntax.
-CONTENTS is nil."
+(defun org-element-diary-sexp-interpreter (diary-sexp _)
+  "Interpret DIARY-SEXP as Org syntax."
   (org-element-property :value diary-sexp))
 
 
@@ -1914,9 +1923,8 @@ containing `:begin', `:end', `:number-lines', `:preserve-indent',
                         :post-affiliated post-affiliated)
                   (cdr affiliated)))))))))
 
-(defun org-element-example-block-interpreter (example-block contents)
-  "Interpret EXAMPLE-BLOCK element as Org syntax.
-CONTENTS is nil."
+(defun org-element-example-block-interpreter (example-block _)
+  "Interpret EXAMPLE-BLOCK element as Org syntax."
   (let ((switches (org-element-property :switches example-block))
        (value (org-element-property :value example-block)))
     (concat "#+BEGIN_EXAMPLE" (and switches (concat " " switches)) "\n"
@@ -1974,9 +1982,8 @@ Assume point is at export-block beginning."
                         :post-affiliated post-affiliated)
                   (cdr affiliated)))))))))
 
-(defun org-element-export-block-interpreter (export-block contents)
-  "Interpret EXPORT-BLOCK element as Org syntax.
-CONTENTS is nil."
+(defun org-element-export-block-interpreter (export-block _)
+  "Interpret EXPORT-BLOCK element as Org syntax."
   (let ((type (org-element-property :type export-block)))
     (concat (format "#+BEGIN_%s\n" type)
            (org-element-property :value export-block)
@@ -2025,9 +2032,8 @@ Assume point is at the beginning of the fixed-width area."
                   :post-affiliated post-affiliated)
             (cdr affiliated))))))
 
-(defun org-element-fixed-width-interpreter (fixed-width contents)
-  "Interpret FIXED-WIDTH element as Org syntax.
-CONTENTS is nil."
+(defun org-element-fixed-width-interpreter (fixed-width _)
+  "Interpret FIXED-WIDTH element as Org syntax."
   (let ((value (org-element-property :value fixed-width)))
     (and value
         (replace-regexp-in-string
@@ -2062,9 +2068,8 @@ keywords."
                   :post-affiliated post-affiliated)
             (cdr affiliated))))))
 
-(defun org-element-horizontal-rule-interpreter (horizontal-rule contents)
-  "Interpret HORIZONTAL-RULE element as Org syntax.
-CONTENTS is nil."
+(defun org-element-horizontal-rule-interpreter (&rest _)
+  "Interpret HORIZONTAL-RULE element as Org syntax."
   "-----")
 
 
@@ -2104,9 +2109,8 @@ containing `:key', `:value', `:begin', `:end', `:post-blank' and
                   :post-affiliated post-affiliated)
             (cdr affiliated))))))
 
-(defun org-element-keyword-interpreter (keyword contents)
-  "Interpret KEYWORD element as Org syntax.
-CONTENTS is nil."
+(defun org-element-keyword-interpreter (keyword _)
+  "Interpret KEYWORD element as Org syntax."
   (format "#+%s: %s"
          (org-element-property :key keyword)
          (org-element-property :value keyword)))
@@ -2162,9 +2166,8 @@ Assume point is at the beginning of the latex environment."
                       :post-affiliated code-begin)
                 (cdr affiliated))))))))
 
-(defun org-element-latex-environment-interpreter (latex-environment contents)
-  "Interpret LATEX-ENVIRONMENT element as Org syntax.
-CONTENTS is nil."
+(defun org-element-latex-environment-interpreter (latex-environment _)
+  "Interpret LATEX-ENVIRONMENT element as Org syntax."
   (org-element-property :value latex-environment))
 
 
@@ -2196,9 +2199,8 @@ containing `:key', `:value', `:begin', `:end', `:post-blank' and
                :post-blank 0
                :post-affiliated begin))))
 
-(defun org-element-node-property-interpreter (node-property contents)
-  "Interpret NODE-PROPERTY element as Org syntax.
-CONTENTS is nil."
+(defun org-element-node-property-interpreter (node-property _)
+  "Interpret NODE-PROPERTY element as Org syntax."
   (format org-property-format
          (format ":%s:" (org-element-property :key node-property))
          (or (org-element-property :value node-property) "")))
@@ -2225,65 +2227,42 @@ Assume point is at the beginning of the paragraph."
           (before-blank
            (let ((case-fold-search t))
              (end-of-line)
-             (if (not (re-search-forward
-                       org-element-paragraph-separate limit 'm))
-                 limit
-               ;; A matching `org-element-paragraph-separate' is not
-               ;; necessarily the end of the paragraph.  In
-               ;; particular, lines starting with # or : as a first
-               ;; non-space character are ambiguous.  We have to
-               ;; check if they are valid Org syntax (e.g., not an
-               ;; incomplete keyword).
-               (beginning-of-line)
-               (while (not
-                       (or
-                        ;; There's no ambiguity for other symbols or
-                        ;; empty lines: stop here.
-                        (looking-at "[ \t]*\\(?:[^:#]\\|$\\)")
-                        ;; Stop at valid fixed-width areas.
-                        (looking-at "[ \t]*:\\(?: \\|$\\)")
-                        ;; Stop at drawers.
-                        (and (looking-at org-drawer-regexp)
-                             (save-excursion
-                               (re-search-forward
-                                "^[ \t]*:END:[ \t]*$" limit t)))
-                        ;; Stop at valid comments.
-                        (looking-at "[ \t]*#\\(?: \\|$\\)")
-                        ;; Stop at valid dynamic blocks.
-                        (and (looking-at org-dblock-start-re)
-                             (save-excursion
-                               (re-search-forward
-                                "^[ \t]*#\\+END:?[ \t]*$" limit t)))
-                        ;; Stop at valid blocks.
-                        (and (looking-at "[ \t]*#\\+BEGIN_\\(\\S-+\\)")
-                             (save-excursion
-                               (re-search-forward
-                                (format "^[ \t]*#\\+END_%s[ \t]*$"
-                                        (regexp-quote
-                                         (org-match-string-no-properties 1)))
-                                limit t)))
-                        ;; Stop at valid latex environments.
-                        (and (looking-at org-element--latex-begin-environment)
-                             (save-excursion
-                               (re-search-forward
-                                (format org-element--latex-end-environment
-                                        (regexp-quote
-                                         (org-match-string-no-properties 1)))
-                                limit t)))
-                        ;; Stop at valid keywords.
-                        (looking-at "[ \t]*#\\+\\S-+:")
-                        ;; Skip everything else.
-                        (not
-                         (progn
-                           (end-of-line)
-                           (re-search-forward org-element-paragraph-separate
-                                              limit 'm)))))
-                 (beginning-of-line)))
+             ;; A matching `org-element-paragraph-separate' is not
+             ;; necessarily the end of the paragraph.  In particular,
+             ;; drawers, blocks or LaTeX environments opening lines
+             ;; must be closed.  Moreover keywords with a secondary
+             ;; value must belong to "dual keywords".
+             (while (not
+                     (cond
+                      ((not (and (re-search-forward
+                                  org-element-paragraph-separate limit 'move)
+                                 (progn (beginning-of-line) t))))
+                      ((looking-at org-drawer-regexp)
+                       (save-excursion
+                         (re-search-forward "^[ \t]*:END:[ \t]*$" limit t)))
+                      ((looking-at "[ \t]*#\\+BEGIN_\\(\\S-+\\)")
+                       (save-excursion
+                         (re-search-forward
+                          (format "^[ \t]*#\\+END_%s[ \t]*$"
+                                  (regexp-quote (match-string 1)))
+                          limit t)))
+                      ((looking-at org-element--latex-begin-environment)
+                       (save-excursion
+                         (re-search-forward
+                          (format org-element--latex-end-environment
+                                  (regexp-quote (match-string 1)))
+                          limit t)))
+                      ((looking-at "[ \t]*#\\+\\(\\S-+\\)\\[.*\\]:")
+                       (member-ignore-case (match-string 1)
+                                           org-element-dual-keywords))
+                      ;; Everything else is unambiguous.
+                      (t)))
+               (end-of-line))
              (if (= (point) limit) limit
                (goto-char (line-beginning-position)))))
-          (contents-end (progn (skip-chars-backward " \r\t\n" contents-begin)
-                               (forward-line)
-                               (point)))
+          (contents-end (save-excursion
+                          (skip-chars-backward " \r\t\n" contents-begin)
+                          (line-beginning-position 2)))
           (end (progn (skip-chars-forward " \r\t\n" limit)
                       (if (eobp) (point) (line-beginning-position)))))
       (list 'paragraph
@@ -2296,8 +2275,8 @@ Assume point is at the beginning of the paragraph."
                   :post-affiliated contents-begin)
             (cdr affiliated))))))
 
-(defun org-element-paragraph-interpreter (paragraph contents)
-  "Interpret PARAGRAPH element as Org syntax.
+(defun org-element-paragraph-interpreter (_ contents)
+  "Interpret paragraph element as Org syntax.
 CONTENTS is the contents of the element."
   contents)
 
@@ -2340,11 +2319,10 @@ containing `:closed', `:deadline', `:scheduled', `:begin',
                  :post-blank post-blank
                  :post-affiliated begin)))))
 
-(defun org-element-planning-interpreter (planning contents)
-  "Interpret PLANNING element as Org syntax.
-CONTENTS is nil."
+(defun org-element-planning-interpreter (planning _)
+  "Interpret PLANNING element as Org syntax."
   (mapconcat
-   'identity
+   #'identity
    (delq nil
         (list (let ((deadline (org-element-property :deadline planning)))
                 (when deadline
@@ -2456,9 +2434,8 @@ Assume point is at the beginning of the block."
                         :post-affiliated post-affiliated)
                   (cdr affiliated)))))))))
 
-(defun org-element-src-block-interpreter (src-block contents)
-  "Interpret SRC-BLOCK element as Org syntax.
-CONTENTS is nil."
+(defun org-element-src-block-interpreter (src-block _)
+  "Interpret SRC-BLOCK element as Org syntax."
   (let ((lang (org-element-property :language src-block))
        (switches (org-element-property :switches src-block))
        (params (org-element-property :parameters src-block))
@@ -2500,10 +2477,12 @@ Assume point is at the beginning of the table."
   (save-excursion
     (let* ((case-fold-search t)
           (table-begin (point))
-          (type (if (org-at-table.el-p) 'table.el 'org))
+          (type (if (looking-at "[ \t]*|") 'org 'table.el))
+           (end-re (format "^[ \t]*\\($\\|[^| \t%s]\\)"
+                          (if (eq type 'org) "" "+")))
           (begin (car affiliated))
           (table-end
-           (if (re-search-forward org-table-any-border-regexp limit 'm)
+           (if (re-search-forward end-re limit 'move)
                (goto-char (match-beginning 0))
              (point)))
           (tblfm (let (acc)
@@ -2547,11 +2526,9 @@ CONTENTS is a string, if table's type is `org', or nil."
 
 ;;;; Table Row
 
-(defun org-element-table-row-parser (limit)
+(defun org-element-table-row-parser (_)
   "Parse table row at point.
 
-LIMIT bounds the search.
-
 Return a list whose CAR is `table-row' and CDR is a plist
 containing `:begin', `:end', `:contents-begin', `:contents-end',
 `:type', `:post-blank' and `:post-affiliated' keywords."
@@ -2560,15 +2537,13 @@ containing `:begin', `:end', `:contents-begin', `:contents-end',
           (begin (point))
           ;; A table rule has no contents.  In that case, ensure
           ;; CONTENTS-BEGIN matches CONTENTS-END.
-          (contents-begin (and (eq type 'standard)
-                               (search-forward "|")
-                               (point)))
+          (contents-begin (and (eq type 'standard) (search-forward "|")))
           (contents-end (and (eq type 'standard)
                              (progn
                                (end-of-line)
                                (skip-chars-backward " \t")
                                (point))))
-          (end (progn (forward-line) (point))))
+          (end (line-beginning-position 2)))
       (list 'table-row
            (list :type type
                  :begin begin
@@ -2625,8 +2600,8 @@ Assume point is at beginning of the block."
                         :post-affiliated post-affiliated)
                   (cdr affiliated)))))))))
 
-(defun org-element-verse-block-interpreter (verse-block contents)
-  "Interpret VERSE-BLOCK element as Org syntax.
+(defun org-element-verse-block-interpreter (_ contents)
+  "Interpret verse-block element as Org syntax.
 CONTENTS is verse block contents."
   (format "#+BEGIN_VERSE\n%s#+END_VERSE" contents))
 
@@ -2674,8 +2649,8 @@ Assume point is at the first star marker."
                    :contents-end contents-end
                    :post-blank post-blank))))))
 
-(defun org-element-bold-interpreter (bold contents)
-  "Interpret BOLD object as Org syntax.
+(defun org-element-bold-interpreter (_ contents)
+  "Interpret bold object as Org syntax.
 CONTENTS is the contents of the object."
   (format "*%s*" contents))
 
@@ -2704,9 +2679,8 @@ Assume point is at the first tilde marker."
                    :end end
                    :post-blank post-blank))))))
 
-(defun org-element-code-interpreter (code contents)
-  "Interpret CODE object as Org syntax.
-CONTENTS is nil."
+(defun org-element-code-interpreter (code _)
+  "Interpret CODE object as Org syntax."
   (format "~%s~" (org-element-property :value code)))
 
 
@@ -2745,9 +2719,8 @@ Assume point is at the beginning of the entity."
                      :use-brackets-p bracketsp
                      :post-blank post-blank)))))))
 
-(defun org-element-entity-interpreter (entity contents)
-  "Interpret ENTITY object as Org syntax.
-CONTENTS is nil."
+(defun org-element-entity-interpreter (entity _)
+  "Interpret ENTITY object as Org syntax."
   (concat "\\"
          (org-element-property :name entity)
          (when (org-element-property :use-brackets-p entity) "{}")))
@@ -2784,9 +2757,8 @@ Assume point is at the beginning of the snippet."
                      :end end
                      :post-blank post-blank)))))))
 
-(defun org-element-export-snippet-interpreter (export-snippet contents)
-  "Interpret EXPORT-SNIPPET object as Org syntax.
-CONTENTS is nil."
+(defun org-element-export-snippet-interpreter (export-snippet _)
+  "Interpret EXPORT-SNIPPET object as Org syntax."
   (format "@@%s:%s@@"
          (org-element-property :back-end export-snippet)
          (org-element-property :value export-snippet)))
@@ -2841,7 +2813,8 @@ CONTENTS is its definition, when inline, or nil."
   "Parse inline babel call at point, if any.
 
 When at an inline babel call, return a list whose car is
-`inline-babel-call' and cdr a plist with `:begin', `:end',
+`inline-babel-call' and cdr a plist with `:call',
+`:inside-header', `:arguments', `:end-header', `:begin', `:end',
 `:value' and `:post-blank' as keywords.  Otherwise, return nil.
 
 Assume point is at the beginning of the babel call."
@@ -2850,20 +2823,33 @@ Assume point is at the beginning of the babel call."
     (when (let ((case-fold-search t))
            (looking-at org-babel-inline-lob-one-liner-regexp))
       (let ((begin (match-end 1))
+           (call (org-match-string-no-properties 2))
+           (inside-header (org-string-nw-p (org-match-string-no-properties 4)))
+           (arguments (org-string-nw-p (org-match-string-no-properties 6)))
+           (end-header (org-string-nw-p (org-match-string-no-properties 8)))
            (value (buffer-substring-no-properties (match-end 1) (match-end 0)))
            (post-blank (progn (goto-char (match-end 0))
                               (skip-chars-forward " \t")))
            (end (point)))
        (list 'inline-babel-call
-             (list :begin begin
+             (list :call call
+                   :inside-header inside-header
+                   :arguments arguments
+                   :end-header end-header
+                   :begin begin
                    :end end
                    :value value
                    :post-blank post-blank))))))
 
-(defun org-element-inline-babel-call-interpreter (inline-babel-call contents)
-  "Interpret INLINE-BABEL-CALL object as Org syntax.
-CONTENTS is nil."
-  (org-element-property :value inline-babel-call))
+(defun org-element-inline-babel-call-interpreter (inline-babel-call _)
+  "Interpret INLINE-BABEL-CALL object as Org syntax."
+  (concat "call_"
+         (org-element-property :call inline-babel-call)
+         (let ((h (org-element-property :inside-header inline-babel-call)))
+           (and h (format "[%s]" h)))
+         "(" (org-element-property :arguments inline-babel-call) ")"
+         (let ((h (org-element-property :end-header inline-babel-call)))
+           (and h (format "[%s]" h)))))
 
 
 ;;;; Inline Src Block
@@ -2895,9 +2881,8 @@ Assume point is at the beginning of the inline src block."
                    :end end
                    :post-blank post-blank))))))
 
-(defun org-element-inline-src-block-interpreter (inline-src-block contents)
-  "Interpret INLINE-SRC-BLOCK object as Org syntax.
-CONTENTS is nil."
+(defun org-element-inline-src-block-interpreter (inline-src-block _)
+  "Interpret INLINE-SRC-BLOCK object as Org syntax."
   (let ((language (org-element-property :language inline-src-block))
        (arguments (org-element-property :parameters inline-src-block))
        (body (org-element-property :value inline-src-block)))
@@ -2933,8 +2918,8 @@ Assume point is at the first slash marker."
                    :contents-end contents-end
                    :post-blank post-blank))))))
 
-(defun org-element-italic-interpreter (italic contents)
-  "Interpret ITALIC object as Org syntax.
+(defun org-element-italic-interpreter (_ contents)
+  "Interpret italic object as Org syntax.
 CONTENTS is the contents of the object."
   (format "/%s/" contents))
 
@@ -2960,14 +2945,15 @@ Assume point is at the beginning of the LaTeX fragment."
                         (search-forward "$" nil t 2)
                         (not (memq (char-before (match-beginning 0))
                                    '(?\s ?\t ?\n ?, ?.)))
-                        (looking-at "\\([- \t.,?;:'\"]\\|$\\)")
+                        (looking-at "\\(\\s.\\|\\s-\\|\\s(\\|\\s)\\|\\s\"\\|$\\)")
                         (point)))
-               (case (char-after (1+ (point)))
+               (pcase (char-after (1+ (point)))
                  (?\( (search-forward "\\)" nil t))
                  (?\[ (search-forward "\\]" nil t))
-                 (otherwise
+                 (_
                   ;; Macro.
-                  (and (looking-at "\\\\[a-zA-Z]+\\*?\\(\\(\\[[^][\n{}]*\\]\\)\\|\\({[^{}\n]*}\\)\\)*")
+                  (and (looking-at "\\\\[a-zA-Z]+\\*?\\(\\(\\[[^][\n{}]*\\]\\)\
+\\|\\({[^{}\n]*}\\)\\)*")
                        (match-end 0))))))
             (post-blank (if (not after-fragment) (throw 'no-object nil)
                           (goto-char after-fragment)
@@ -2979,9 +2965,8 @@ Assume point is at the beginning of the LaTeX fragment."
                    :end end
                    :post-blank post-blank))))))
 
-(defun org-element-latex-fragment-interpreter (latex-fragment contents)
-  "Interpret LATEX-FRAGMENT object as Org syntax.
-CONTENTS is nil."
+(defun org-element-latex-fragment-interpreter (latex-fragment _)
+  "Interpret LATEX-FRAGMENT object as Org syntax."
   (org-element-property :value latex-fragment))
 
 ;;;; Line Break
@@ -3001,9 +2986,8 @@ Assume point is at the beginning of the line break."
                :end (line-beginning-position 2)
                :post-blank 0))))
 
-(defun org-element-line-break-interpreter (line-break contents)
-  "Interpret LINE-BREAK object as Org syntax.
-CONTENTS is nil."
+(defun org-element-line-break-interpreter (&rest _)
+  "Interpret LINE-BREAK object as Org syntax."
   "\\\\\n")
 
 
@@ -3022,7 +3006,7 @@ Assume point is at the beginning of the link."
   (catch 'no-object
     (let ((begin (point))
          end contents-begin contents-end link-end post-blank path type
-         raw-link link search-option application)
+         raw-link search-option application)
       (cond
        ;; Type 1: Text targeted from a radio target.
        ((and org-target-link-regexp
@@ -3035,89 +3019,122 @@ Assume point is at the beginning of the link."
              contents-end (match-end 1)))
        ;; Type 2: Standard link, i.e. [[http://orgmode.org][homepage]]
        ((looking-at org-bracket-link-regexp)
-       (setq contents-begin (match-beginning 3)
-             contents-end (match-end 3)
-             link-end (match-end 0)
-             ;; RAW-LINK is the original link.  Expand any
-             ;; abbreviation in it.
-             raw-link (org-translate-link
-                       (org-link-expand-abbrev
+       (setq contents-begin (match-beginning 3))
+       (setq contents-end (match-end 3))
+       (setq link-end (match-end 0))
+       ;; RAW-LINK is the original link.  Expand any
+       ;; abbreviation in it.
+       ;;
+       ;; Also treat any newline character and associated
+       ;; indentation as a single space character.  This is not
+       ;; compatible with RFC 3986, which requires to ignore
+       ;; them altogether.  However, doing so would require
+       ;; users to encode spaces on the fly when writing links
+       ;; (e.g., insert [[shell:ls%20*.org]] instead of
+       ;; [[shell:ls *.org]], which defeats Org's focus on
+       ;; simplicity.
+       (setq raw-link (org-link-expand-abbrev
+                       (replace-regexp-in-string
+                        "[ \t]*\n[ \t]*" " "
                         (org-match-string-no-properties 1))))
-       ;; Determine TYPE of link and set PATH accordingly.
+       ;; Determine TYPE of link and set PATH accordingly.  According
+       ;; to RFC 3986, remove whitespaces from URI in external links.
+       ;; In internal ones, treat indentation as a single space.
        (cond
         ;; File type.
         ((or (file-name-absolute-p raw-link)
              (string-match "\\`\\.\\.?/" raw-link))
-         (setq type "file" path raw-link))
+         (setq type "file")
+         (setq path raw-link))
         ;; Explicit type (http, irc, bbdb...).  See `org-link-types'.
         ((string-match org-link-types-re raw-link)
-         (setq type (match-string 1 raw-link)
-               ;; According to RFC 3986, extra whitespace should be
-               ;; ignored when a URI is extracted.
-               path (replace-regexp-in-string
-                     "[ \t]*\n[ \t]*" "" (substring raw-link (match-end 0)))))
+         (setq type (match-string 1 raw-link))
+         (setq path (substring raw-link (match-end 0))))
         ;; Id type: PATH is the id.
-        ((string-match "\\`id:\\([-a-f0-9]+\\)" raw-link)
+        ((string-match "\\`id:\\([-a-f0-9]+\\)\\'" raw-link)
          (setq type "id" path (match-string 1 raw-link)))
         ;; Code-ref type: PATH is the name of the reference.
-        ((string-match "\\`(\\(.*\\))\\'" raw-link)
-         (setq type "coderef" path (match-string 1 raw-link)))
+        ((and (org-string-match-p "\\`(" raw-link)
+              (org-string-match-p ")\\'" raw-link))
+         (setq type "coderef")
+         (setq path (substring raw-link 1 -1)))
         ;; Custom-id type: PATH is the name of the custom id.
-        ((= (aref raw-link 0) ?#)
-         (setq type "custom-id" path (substring raw-link 1)))
+        ((= (string-to-char raw-link) ?#)
+         (setq type "custom-id")
+         (setq path (substring raw-link 1)))
         ;; Fuzzy type: Internal link either matches a target, an
         ;; headline name or nothing.  PATH is the target or
         ;; headline's name.
-        (t (setq type "fuzzy" path raw-link))))
+        (t
+         (setq type "fuzzy")
+         (setq path raw-link))))
        ;; Type 3: Plain link, e.g., http://orgmode.org
        ((looking-at org-plain-link-re)
        (setq raw-link (org-match-string-no-properties 0)
              type (org-match-string-no-properties 1)
              link-end (match-end 0)
              path (org-match-string-no-properties 2)))
-       ;; Type 4: Angular link, e.g., <http://orgmode.org>
+       ;; Type 4: Angular link, e.g., <http://orgmode.org>.  Unlike to
+       ;; bracket links, follow RFC 3986 and remove any extra
+       ;; whitespace in URI.
        ((looking-at org-angle-link-re)
-       (setq raw-link (buffer-substring-no-properties
-                       (match-beginning 1) (match-end 2))
-             type (org-match-string-no-properties 1)
-             link-end (match-end 0)
-             path (org-match-string-no-properties 2)))
+       (setq type (org-match-string-no-properties 1))
+       (setq link-end (match-end 0))
+       (setq raw-link
+             (buffer-substring-no-properties
+              (match-beginning 1) (match-end 2)))
+       (setq path (replace-regexp-in-string
+                   "[ \t]*\n[ \t]*" "" (org-match-string-no-properties 2))))
        (t (throw 'no-object nil)))
       ;; In any case, deduce end point after trailing white space from
       ;; LINK-END variable.
       (save-excursion
-       (setq post-blank (progn (goto-char link-end) (skip-chars-forward " \t"))
-             end (point))
-       ;; Special "file" type link processing.  Extract opening
-       ;; application and search option, if any.  Also normalize URI.
-       (when (string-match "\\`file\\(?:\\+\\(.+\\)\\)?\\'" type)
-         (setq application (match-string 1 type) type "file")
-         (when (string-match "::\\(.*\\)\\'" path)
-           (setq search-option (match-string 1 path)
-                 path (replace-match "" nil nil path)))
-         (when (and (file-name-absolute-p path)
-                    (not (org-string-match-p "\\`[/~]/" path)))
-           (setq path (concat "//" path))))
-       (list 'link
-             (list :type type
-                   :path path
-                   :raw-link (or raw-link path)
-                   :application application
-                   :search-option search-option
-                   :begin begin
-                   :end end
-                   :contents-begin contents-begin
-                   :contents-end contents-end
-                   :post-blank post-blank))))))
+       (setq post-blank
+             (progn (goto-char link-end) (skip-chars-forward " \t")))
+       (setq end (point)))
+      ;; Special "file" type link processing.  Extract opening
+      ;; application and search option, if any.  Also normalize URI.
+      (when (string-match "\\`file\\(?:\\+\\(.+\\)\\)?\\'" type)
+       (setq application (match-string 1 type) type "file")
+       (when (string-match "::\\(.*\\)\\'" path)
+         (setq search-option (match-string 1 path))
+         (setq path (replace-match "" nil nil path)))
+       (setq path (replace-regexp-in-string "\\`/+" "/" path)))
+      ;; Translate link, if `org-link-translation-function' is set.
+      (let ((trans (and (functionp org-link-translation-function)
+                       (funcall org-link-translation-function type path))))
+       (when trans
+         (setq type (car trans))
+        (setq path (cdr trans))))
+      (list 'link
+           (list :type type
+                 :path path
+                 :raw-link (or raw-link path)
+                 :application application
+                 :search-option search-option
+                 :begin begin
+                 :end end
+                 :contents-begin contents-begin
+                 :contents-end contents-end
+                 :post-blank post-blank)))))
 
 (defun org-element-link-interpreter (link contents)
   "Interpret LINK object as Org syntax.
 CONTENTS is the contents of the object, or nil."
   (let ((type (org-element-property :type link))
-       (raw-link (org-element-property :raw-link link)))
-    (if (string= type "radio") raw-link
+       (path (org-element-property :path link)))
+    (if (string= type "radio") path
       (format "[[%s]%s]"
-             raw-link
+             (cond ((string= type "coderef") (format "(%s)" path))
+                   ((string= type "custom-id") (concat "#" path))
+                   ((string= type "file")
+                    (let ((app (org-element-property :application link))
+                          (opt (org-element-property :search-option link)))
+                      (concat type (and app (concat "+" app)) ":"
+                              path
+                              (and opt (concat "::" opt)))))
+                   ((string= type "fuzzy") path)
+                   (t (concat type ":" path)))
              (if contents (format "[%s]" contents) "")))))
 
 
@@ -3149,9 +3166,8 @@ Assume point is at the macro."
                    :end end
                    :post-blank post-blank))))))
 
-(defun org-element-macro-interpreter (macro contents)
-  "Interpret MACRO object as Org syntax.
-CONTENTS is nil."
+(defun org-element-macro-interpreter (macro _)
+  "Interpret MACRO object as Org syntax."
   (org-element-property :value macro))
 
 
@@ -3183,8 +3199,8 @@ Assume point is at the radio target."
                    :post-blank post-blank
                    :value value))))))
 
-(defun org-element-radio-target-interpreter (target contents)
-  "Interpret TARGET object as Org syntax.
+(defun org-element-radio-target-interpreter (_ contents)
+  "Interpret target object as Org syntax.
 CONTENTS is the contents of the object."
   (concat "<<<" contents ">>>"))
 
@@ -3213,9 +3229,8 @@ Assume point is at the beginning of the statistics-cookie."
                    :value value
                    :post-blank post-blank))))))
 
-(defun org-element-statistics-cookie-interpreter (statistics-cookie contents)
-  "Interpret STATISTICS-COOKIE object as Org syntax.
-CONTENTS is nil."
+(defun org-element-statistics-cookie-interpreter (statistics-cookie _)
+  "Interpret STATISTICS-COOKIE object as Org syntax."
   (org-element-property :value statistics-cookie))
 
 
@@ -3246,8 +3261,8 @@ Assume point is at the first plus sign marker."
                    :contents-end contents-end
                    :post-blank post-blank))))))
 
-(defun org-element-strike-through-interpreter (strike-through contents)
-  "Interpret STRIKE-THROUGH object as Org syntax.
+(defun org-element-strike-through-interpreter (_ contents)
+  "Interpret strike-through object as Org syntax.
 CONTENTS is the contents of the object."
   (format "+%s+" contents))
 
@@ -3347,8 +3362,8 @@ and `:post-blank' keywords."
                :contents-end contents-end
                :post-blank 0))))
 
-(defun org-element-table-cell-interpreter (table-cell contents)
-  "Interpret TABLE-CELL element as Org syntax.
+(defun org-element-table-cell-interpreter (_ contents)
+  "Interpret table-cell element as Org syntax.
 CONTENTS is the contents of the cell, or nil."
   (concat  " " contents " |"))
 
@@ -3376,9 +3391,8 @@ Assume point is at the target."
                    :value value
                    :post-blank post-blank))))))
 
-(defun org-element-target-interpreter (target contents)
-  "Interpret TARGET object as Org syntax.
-CONTENTS is nil."
+(defun org-element-target-interpreter (target _)
+  "Interpret TARGET object as Org syntax."
   (format "<<%s>>" (org-element-property :value target)))
 
 
@@ -3443,8 +3457,8 @@ Assume point is at the beginning of the timestamp."
                            (t 'cumulate)))
                    :repeater-value (string-to-number (match-string 2 raw-value))
                    :repeater-unit
-                   (case (string-to-char (match-string 3 raw-value))
-                     (?h 'hour) (?d 'day) (?w 'week) (?m 'month) (t 'year)))))
+                   (pcase (string-to-char (match-string 3 raw-value))
+                     (?h 'hour) (?d 'day) (?w 'week) (?m 'month) (_ 'year)))))
             (warning-props
              (and (not diaryp)
                   (string-match "\\(-\\)?-\\([0-9]+\\)\\([hdwmy]\\)" raw-value)
@@ -3452,8 +3466,8 @@ Assume point is at the beginning of the timestamp."
                    :warning-type (if (match-string 1 raw-value) 'first 'all)
                    :warning-value (string-to-number (match-string 2 raw-value))
                    :warning-unit
-                   (case (string-to-char (match-string 3 raw-value))
-                     (?h 'hour) (?d 'day) (?w 'week) (?m 'month) (t 'year)))))
+                   (pcase (string-to-char (match-string 3 raw-value))
+                     (?h 'hour) (?d 'day) (?w 'week) (?m 'month) (_ 'year)))))
             year-start month-start day-start hour-start minute-start year-end
             month-end day-end hour-end minute-end)
        ;; Parse date-start.
@@ -3493,26 +3507,24 @@ Assume point is at the beginning of the timestamp."
                     repeater-props
                     warning-props))))))
 
-(defun org-element-timestamp-interpreter (timestamp contents)
-  "Interpret TIMESTAMP object as Org syntax.
-CONTENTS is nil."
+(defun org-element-timestamp-interpreter (timestamp _)
+  "Interpret TIMESTAMP object as Org syntax."
   (let* ((repeat-string
          (concat
-          (case (org-element-property :repeater-type timestamp)
-            (cumulate "+") (catch-up "++") (restart ".+"))
+          (pcase (org-element-property :repeater-type timestamp)
+            (`cumulate "+") (`catch-up "++") (`restart ".+"))
           (let ((val (org-element-property :repeater-value timestamp)))
             (and val (number-to-string val)))
-          (case (org-element-property :repeater-unit timestamp)
-            (hour "h") (day "d") (week "w") (month "m") (year "y"))))
+          (pcase (org-element-property :repeater-unit timestamp)
+            (`hour "h") (`day "d") (`week "w") (`month "m") (`year "y"))))
         (warning-string
          (concat
-          (case (org-element-property :warning-type timestamp)
-            (first "--")
-            (all "-"))
+          (pcase (org-element-property :warning-type timestamp)
+            (`first "--") (`all "-"))
           (let ((val (org-element-property :warning-value timestamp)))
             (and val (number-to-string val)))
-          (case (org-element-property :warning-unit timestamp)
-            (hour "h") (day "d") (week "w") (month "m") (year "y"))))
+          (pcase (org-element-property :warning-unit timestamp)
+            (`hour "h") (`day "d") (`week "w") (`month "m") (`year "y"))))
         (build-ts-string
          ;; Build an Org timestamp string from TIME.  ACTIVEP is
          ;; non-nil when time stamp is active.  If WITH-TIME-P is
@@ -3521,7 +3533,7 @@ CONTENTS is nil."
          ;; the repeater string, if any.
          (lambda (time activep &optional with-time-p hour-end minute-end)
            (let ((ts (format-time-string
-                      (funcall (if with-time-p 'cdr 'car)
+                      (funcall (if with-time-p #'cdr #'car)
                                org-time-stamp-formats)
                       time)))
              (when (and hour-end minute-end)
@@ -3540,8 +3552,8 @@ CONTENTS is nil."
              ;; Return value.
              ts)))
         (type (org-element-property :type timestamp)))
-    (case type
-      ((active inactive)
+    (pcase type
+      ((or `active `inactive)
        (let* ((minute-start (org-element-property :minute-start timestamp))
              (minute-end (org-element-property :minute-end timestamp))
              (hour-start (org-element-property :hour-start timestamp))
@@ -3561,7 +3573,7 @@ CONTENTS is nil."
          (and hour-start minute-start)
          (and time-range-p hour-end)
          (and time-range-p minute-end))))
-      ((active-range inactive-range)
+      ((or `active-range `inactive-range)
        (let ((minute-start (org-element-property :minute-start timestamp))
             (minute-end (org-element-property :minute-end timestamp))
             (hour-start (org-element-property :hour-start timestamp))
@@ -3587,7 +3599,7 @@ CONTENTS is nil."
                                (org-element-property :year-end timestamp))
                   (eq type 'active-range)
                   (and hour-end minute-end)))))
-      (otherwise (org-element-property :raw-value timestamp)))))
+      (_ (org-element-property :raw-value timestamp)))))
 
 
 ;;;; Underline
@@ -3617,8 +3629,8 @@ Assume point is at the first underscore marker."
                    :contents-end contents-end
                    :post-blank post-blank))))))
 
-(defun org-element-underline-interpreter (underline contents)
-  "Interpret UNDERLINE object as Org syntax.
+(defun org-element-underline-interpreter (_ contents)
+  "Interpret underline object as Org syntax.
 CONTENTS is the contents of the object."
   (format "_%s_" contents))
 
@@ -3647,9 +3659,8 @@ Assume point is at the first equal sign marker."
                    :end end
                    :post-blank post-blank))))))
 
-(defun org-element-verbatim-interpreter (verbatim contents)
-  "Interpret VERBATIM object as Org syntax.
-CONTENTS is nil."
+(defun org-element-verbatim-interpreter (verbatim _)
+  "Interpret VERBATIM object as Org syntax."
   (format "=%s=" (org-element-property :value verbatim)))
 
 
@@ -3782,7 +3793,8 @@ element it has to parse."
             ((looking-at "%%(")
              (org-element-diary-sexp-parser limit affiliated))
             ;; Table.
-            ((org-at-table-p t) (org-element-table-parser limit affiliated))
+            ((looking-at "[ \t]*\\(|\\|\\+\\(-+\\+\\)+[ \t]*$\\)")
+             (org-element-table-parser limit affiliated))
             ;; List.
             ((looking-at (org-item-re))
              (org-element-plain-list-parser
@@ -3837,8 +3849,9 @@ position of point and CDR is nil."
                (and dualp
                     (let ((sec (org-match-string-no-properties 2)))
                       (if (or (not sec) (not parsedp)) sec
-                        (org-element--parse-objects
-                         (match-beginning 2) (match-end 2) nil restrict)))))
+                        (save-match-data
+                          (org-element--parse-objects
+                           (match-beginning 2) (match-end 2) nil restrict))))))
               ;; Attribute a property name to KWD.
               (kwd-sym (and kwd (intern (concat ":" (downcase kwd))))))
          ;; Now set final shape for VALUE.
@@ -4028,94 +4041,93 @@ looking into captions:
                         (list no-recursion)))
         ;; Recursion depth is determined by --CATEGORY.
         (--category
-         (catch 'found
+         (catch :--found
            (let ((category 'greater-elements)
                  (all-objects (cons 'plain-text org-element-all-objects)))
              (dolist (type types category)
                (cond ((memq type all-objects)
-                      ;; If one object is found, the function has to
-                      ;; recurse into every object.
-                      (throw 'found 'objects))
+                      ;; If one object is found, the function has
+                      ;; to recurse into every object.
+                      (throw :--found 'objects))
                      ((not (memq type org-element-greater-elements))
                       ;; If one regular element is found, the
                       ;; function has to recurse, at least, into
                       ;; every element it encounters.
                       (and (not (eq category 'elements))
                            (setq category 'elements))))))))
-        --acc
-        --walk-tree
-        (--walk-tree
-         (lambda (--data)
-           ;; Recursively walk DATA.  INFO, if non-nil, is a plist
-           ;; holding contextual information.
-           (let ((--type (org-element-type --data)))
-             (cond
-              ((not --data))
-              ;; Ignored element in an export context.
-              ((and info (memq --data (plist-get info :ignore-list))))
-              ;; List of elements or objects.
-              ((not --type) (mapc --walk-tree --data))
-              ;; Unconditionally enter parse trees.
-              ((eq --type 'org-data)
-               (mapc --walk-tree (org-element-contents --data)))
-              (t
-               ;; Check if TYPE is matching among TYPES.  If so,
-               ;; apply FUN to --DATA and accumulate return value
-               ;; into --ACC (or exit if FIRST-MATCH is non-nil).
-               (when (memq --type types)
-                 (let ((result (funcall fun --data)))
-                   (cond ((not result))
-                         (first-match (throw '--map-first-match result))
-                         (t (push result --acc)))))
-               ;; If --DATA has a secondary string that can contain
-               ;; objects with their type among TYPES, look into it.
-               (when (and (eq --category 'objects) (not (stringp --data)))
-                 (dolist (p (cdr (assq --type
-                                       org-element-secondary-value-alist)))
-                   (funcall --walk-tree (org-element-property p --data))))
-               ;; If --DATA has any parsed affiliated keywords and
-               ;; WITH-AFFILIATED is non-nil, look for objects in
-               ;; them.
-               (when (and with-affiliated
-                          (eq --category 'objects)
-                          (memq --type org-element-all-elements))
-                 (dolist (kwd-pair org-element--parsed-properties-alist)
-                   (let ((kwd (car kwd-pair))
-                         (value (org-element-property (cdr kwd-pair) --data)))
-                     ;; Pay attention to the type of parsed keyword.
-                     ;; In particular, preserve order for multiple
-                     ;; keywords.
-                     (cond
-                      ((not value))
-                      ((member kwd org-element-dual-keywords)
-                       (if (member kwd org-element-multiple-keywords)
-                           (dolist (line (reverse value))
-                             (funcall --walk-tree (cdr line))
-                             (funcall --walk-tree (car line)))
-                         (funcall --walk-tree (cdr value))
-                         (funcall --walk-tree (car value))))
-                      ((member kwd org-element-multiple-keywords)
-                       (mapc --walk-tree (reverse value)))
-                      (t (funcall --walk-tree value))))))
-               ;; Determine if a recursion into --DATA is possible.
-               (cond
-                ;; --TYPE is explicitly removed from recursion.
-                ((memq --type no-recursion))
-                ;; --DATA has no contents.
-                ((not (org-element-contents --data)))
-                ;; Looking for greater elements but --DATA is simply
-                ;; an element or an object.
-                ((and (eq --category 'greater-elements)
-                      (not (memq --type org-element-greater-elements))))
-                ;; Looking for elements but --DATA is an object.
-                ((and (eq --category 'elements)
-                      (memq --type org-element-all-objects)))
-                ;; In any other case, map contents.
-                (t (mapc --walk-tree (org-element-contents --data))))))))))
-    (catch '--map-first-match
-      (funcall --walk-tree data)
-      ;; Return value in a proper order.
-      (nreverse --acc))))
+        --acc)
+    (letrec ((--walk-tree
+             (lambda (--data)
+               ;; Recursively walk DATA.  INFO, if non-nil, is a plist
+               ;; holding contextual information.
+               (let ((--type (org-element-type --data)))
+                 (cond
+                  ((not --data))
+                  ;; Ignored element in an export context.
+                  ((and info (memq --data (plist-get info :ignore-list))))
+                  ;; List of elements or objects.
+                  ((not --type) (mapc --walk-tree --data))
+                  ;; Unconditionally enter parse trees.
+                  ((eq --type 'org-data)
+                   (mapc --walk-tree (org-element-contents --data)))
+                  (t
+                   ;; Check if TYPE is matching among TYPES.  If so,
+                   ;; apply FUN to --DATA and accumulate return value
+                   ;; into --ACC (or exit if FIRST-MATCH is non-nil).
+                   (when (memq --type types)
+                     (let ((result (funcall fun --data)))
+                       (cond ((not result))
+                             (first-match (throw :--map-first-match result))
+                             (t (push result --acc)))))
+                   ;; If --DATA has a secondary string that can contain
+                   ;; objects with their type among TYPES, look inside.
+                   (when (and (eq --category 'objects) (not (stringp --data)))
+                     (dolist (p (cdr (assq --type
+                                           org-element-secondary-value-alist)))
+                       (funcall --walk-tree (org-element-property p --data))))
+                   ;; If --DATA has any parsed affiliated keywords and
+                   ;; WITH-AFFILIATED is non-nil, look for objects in
+                   ;; them.
+                   (when (and with-affiliated
+                              (eq --category 'objects)
+                              (memq --type org-element-all-elements))
+                     (dolist (kwd-pair org-element--parsed-properties-alist)
+                       (let ((kwd (car kwd-pair))
+                             (value (org-element-property (cdr kwd-pair) --data)))
+                         ;; Pay attention to the type of parsed
+                         ;; keyword.  In particular, preserve order for
+                         ;; multiple keywords.
+                         (cond
+                          ((not value))
+                          ((member kwd org-element-dual-keywords)
+                           (if (member kwd org-element-multiple-keywords)
+                               (dolist (line (reverse value))
+                                 (funcall --walk-tree (cdr line))
+                                 (funcall --walk-tree (car line)))
+                             (funcall --walk-tree (cdr value))
+                             (funcall --walk-tree (car value))))
+                          ((member kwd org-element-multiple-keywords)
+                           (mapc --walk-tree (reverse value)))
+                          (t (funcall --walk-tree value))))))
+                   ;; Determine if a recursion into --DATA is possible.
+                   (cond
+                    ;; --TYPE is explicitly removed from recursion.
+                    ((memq --type no-recursion))
+                    ;; --DATA has no contents.
+                    ((not (org-element-contents --data)))
+                    ;; Looking for greater elements but --DATA is
+                    ;; simply an element or an object.
+                    ((and (eq --category 'greater-elements)
+                          (not (memq --type org-element-greater-elements))))
+                    ;; Looking for elements but --DATA is an object.
+                    ((and (eq --category 'elements)
+                          (memq --type org-element-all-objects)))
+                    ;; In any other case, map contents.
+                    (t (mapc --walk-tree (org-element-contents --data))))))))))
+      (catch :--map-first-match
+       (funcall --walk-tree data)
+       ;; Return value in a proper order.
+       (nreverse --acc)))))
 (put 'org-element-map 'lisp-indent-function 2)
 
 ;; The following functions are internal parts of the parser.
@@ -4136,17 +4148,17 @@ otherwise.  Modes can be either `first-section', `item',
 `node-property', `planning', `property-drawer', `section',
 `table-row' or nil."
   (if parentp
-      (case type
-       (headline 'section)
-       (plain-list 'item)
-       (property-drawer 'node-property)
-       (section 'planning)
-       (table 'table-row))
-    (case type
-      (item 'item)
-      (node-property 'node-property)
-      (planning 'property-drawer)
-      (table-row 'table-row))))
+      (pcase type
+       (`headline 'section)
+       (`plain-list 'item)
+       (`property-drawer 'node-property)
+       (`section 'planning)
+       (`table 'table-row))
+    (pcase type
+      (`item 'item)
+      (`node-property 'node-property)
+      (`planning 'property-drawer)
+      (`table-row 'table-row))))
 
 (defun org-element--parse-elements
   (beg end mode structure granularity visible-only acc)
@@ -4245,7 +4257,7 @@ to an appropriate container (e.g., a paragraph)."
                    (and (memq 'inline-src-block restriction)
                         (org-element-inline-src-block-parser)))
                   (t
-                   (case (char-after)
+                   (pcase (char-after)
                      (?^ (and (memq 'superscript restriction)
                               (org-element-superscript-parser)))
                      (?_ (or (and (memq 'subscript restriction)
@@ -4297,7 +4309,7 @@ to an appropriate container (e.g., a paragraph)."
                             (and (memq 'statistics-cookie restriction)
                                  (org-element-statistics-cookie-parser)))))
                      ;; This is probably a plain link.
-                     (otherwise (and (or (memq 'link restriction)
+                     (_ (and (or (memq 'link restriction)
                                          (memq 'plain-link restriction))
                                      (org-element-link-parser)))))))
            (or (eobp) (forward-char))))
@@ -4327,7 +4339,7 @@ the current object."
                    (org-element-adopt-elements
                     acc
                     (replace-regexp-in-string
-                     "\t" (make-string tab-width ? )
+                     "\t" (make-string tab-width ?\s)
                      (buffer-substring-no-properties (point) obj-beg))))))
          ;; 2. Object...
          (let ((obj-end (org-element-property :end next-object))
@@ -4347,7 +4359,7 @@ the current object."
              (org-element-adopt-elements
               acc
               (replace-regexp-in-string
-               "\t" (make-string tab-width ? )
+               "\t" (make-string tab-width ?\s)
                (buffer-substring-no-properties (point) end)))))
       ;; Result.
       acc)))
@@ -4369,73 +4381,73 @@ the current object."
   "Interpret DATA as Org syntax.
 DATA is a parse tree, an element, an object or a secondary string
 to interpret.  Return Org syntax as a string."
-  (org-element--interpret-data-1 data nil))
-
-(defun org-element--interpret-data-1 (data parent)
-  "Interpret DATA as Org syntax.
-
-DATA is a parse tree, an element, an object or a secondary string
-to interpret.  PARENT is used for recursive calls.  It contains
-the element or object containing data, or nil.
-
-Return Org syntax as a string."
-  (let* ((type (org-element-type data))
-        ;; Find interpreter for current object or element.  If it
-        ;; doesn't exist (e.g. this is a pseudo object or element),
-        ;; return contents, if any.
-        (interpret
-         (let ((fun (intern (format "org-element-%s-interpreter" type))))
-           (if (fboundp fun) fun (lambda (data contents) contents))))
-        (results
-         (cond
-          ;; Secondary string.
-          ((not type)
-           (mapconcat
-            (lambda (obj) (org-element--interpret-data-1 obj parent)) data ""))
-          ;; Full Org document.
-          ((eq type 'org-data)
-           (mapconcat (lambda (obj) (org-element--interpret-data-1 obj parent))
-                      (org-element-contents data) ""))
-          ;; Plain text: return it.
-          ((stringp data) data)
-          ;; Element or object without contents.
-          ((not (org-element-contents data)) (funcall interpret data nil))
-          ;; Element or object with contents.
-          (t
-           (funcall interpret data
-                    ;; Recursively interpret contents.
-                    (mapconcat
-                     (lambda (obj) (org-element--interpret-data-1 obj data))
-                     (org-element-contents
-                      (if (not (memq type '(paragraph verse-block)))
-                          data
-                        ;; Fix indentation of elements containing
-                        ;; objects.  We ignore `table-row' elements
-                        ;; as they are one line long anyway.
-                        (org-element-normalize-contents
-                         data
-                         ;; When normalizing first paragraph of an
-                         ;; item or a footnote-definition, ignore
-                         ;; first line's indentation.
-                         (and (eq type 'paragraph)
-                              (equal data (car (org-element-contents parent)))
-                              (memq (org-element-type parent)
-                                    '(footnote-definition item))))))
-                     ""))))))
-    (if (memq type '(org-data plain-text nil)) results
-      ;; Build white spaces.  If no `:post-blank' property is
-      ;; specified, assume its value is 0.
-      (let ((post-blank (or (org-element-property :post-blank data) 0)))
-       (if (or (memq type org-element-all-objects)
-               (and parent
-                    (let ((type (org-element-type parent)))
-                      (or (not type)
-                          (memq type org-element-object-containers)))))
-           (concat results (make-string post-blank ?\s))
-         (concat
-          (org-element--interpret-affiliated-keywords data)
-          (org-element-normalize-string results)
-          (make-string post-blank ?\n)))))))
+  (letrec ((fun
+           (lambda (--data parent)
+             (let* ((type (org-element-type --data))
+                    ;; Find interpreter for current object or
+                    ;; element.  If it doesn't exist (e.g. this is
+                    ;; a pseudo object or element), return contents,
+                    ;; if any.
+                    (interpret
+                     (let ((fun (intern
+                                 (format "org-element-%s-interpreter" type))))
+                       (if (fboundp fun) fun (lambda (_ contents) contents))))
+                    (results
+                     (cond
+                      ;; Secondary string.
+                      ((not type)
+                       (mapconcat (lambda (obj) (funcall fun obj parent))
+                                  --data ""))
+                      ;; Full Org document.
+                      ((eq type 'org-data)
+                       (mapconcat (lambda (obj) (funcall fun obj parent))
+                                  (org-element-contents --data) ""))
+                      ;; Plain text: return it.
+                      ((stringp --data) --data)
+                      ;; Element or object without contents.
+                      ((not (org-element-contents --data))
+                       (funcall interpret --data nil))
+                      ;; Element or object with contents.
+                      (t
+                       (funcall
+                        interpret
+                        --data
+                        ;; Recursively interpret contents.
+                        (mapconcat
+                         (lambda (obj) (funcall fun obj --data))
+                         (org-element-contents
+                          (if (not (memq type '(paragraph verse-block)))
+                              --data
+                            ;; Fix indentation of elements containing
+                            ;; objects.  We ignore `table-row'
+                            ;; elements as they are one line long
+                            ;; anyway.
+                            (org-element-normalize-contents
+                             --data
+                             ;; When normalizing first paragraph of
+                             ;; an item or a footnote-definition,
+                             ;; ignore first line's indentation.
+                             (and (eq type 'paragraph)
+                                  (equal --data
+                                         (car (org-element-contents parent)))
+                                  (memq (org-element-type parent)
+                                        '(footnote-definition item))))))
+                         ""))))))
+               (if (memq type '(org-data plain-text nil)) results
+                 ;; Build white spaces.  If no `:post-blank' property
+                 ;; is specified, assume its value is 0.
+                 (let ((blank (or (org-element-property :post-blank --data) 0)))
+                   (if (or (memq type org-element-all-objects)
+                           (and parent
+                                (let ((type (org-element-type parent)))
+                                  (or (not type)
+                                      (memq type org-element-object-containers)))))
+                       (concat results (make-string blank ?\s))
+                     (concat
+                      (org-element--interpret-affiliated-keywords --data)
+                      (org-element-normalize-string results)
+                      (make-string blank ?\n)))))))))
+    (funcall fun data nil)))
 
 (defun org-element--interpret-affiliated-keywords (element)
   "Return ELEMENT's affiliated keywords as Org syntax.
@@ -4514,72 +4526,76 @@ indentation to compute maximal common indentation.
 Return the normalized element that is element with global
 indentation removed from its contents.  The function assumes that
 indentation is not done with TAB characters."
-  (let* ((min-ind most-positive-fixnum)
-        find-min-ind                   ; For byte-compiler.
-        (find-min-ind
-         ;; Return minimal common indentation within BLOB.  This is
-         ;; done by walking recursively BLOB and updating MIN-IND
-         ;; along the way.  FIRST-FLAG is non-nil when the next
-         ;; object is expected to be a string that doesn't start with
-         ;; a newline character.  It happens for strings at the
-         ;; beginnings of the contents or right after a line break.
-         (lambda (blob first-flag)
-           (dolist (object (org-element-contents blob))
-             (when first-flag
-               (setq first-flag nil)
-               ;; Objects cannot start with spaces: in this case,
-               ;; indentation is 0.
-               (if (not (stringp object)) (throw 'zero (setq min-ind 0))
-                 (string-match "\\` *" object)
-                 (let ((len (match-end 0)))
-                   ;; An indentation of zero means no string will be
-                   ;; modified.  Quit the process.
-                   (if (zerop len) (throw 'zero (setq min-ind 0))
-                     (setq min-ind (min len min-ind))))))
-             (cond
-              ((stringp object)
-               (dolist (line (cdr (org-split-string object " *\n")))
-                 (unless (string= line "")
-                   (setq min-ind (min (org-get-indentation line) min-ind)))))
-              ((eq (org-element-type object) 'line-break) (setq first-flag t))
-              ((memq (org-element-type object) org-element-recursive-objects)
-               (funcall find-min-ind object first-flag)))))))
-    ;; Find minimal indentation in ELEMENT.
-    (catch 'zero (funcall find-min-ind element (not ignore-first)))
+  (letrec ((find-min-ind
+           ;; Return minimal common indentation within BLOB.  This is
+           ;; done by walking recursively BLOB and updating MIN-IND
+           ;; along the way.  FIRST-FLAG is non-nil when the next
+           ;; object is expected to be a string that doesn't start
+           ;; with a newline character.  It happens for strings at
+           ;; the beginnings of the contents or right after a line
+           ;; break.
+           (lambda (blob first-flag min-ind)
+             (catch 'zero
+               (dolist (object (org-element-contents blob) min-ind)
+                 (when first-flag
+                   (setq first-flag nil)
+                   ;; Objects cannot start with spaces: in this case,
+                   ;; indentation is 0.
+                   (if (not (stringp object)) (throw 'zero 0)
+                     (string-match "\\` *" object)
+                     (let ((len (match-end 0)))
+                       ;; An indentation of zero means no string will
+                       ;; be modified.  Quit the process.
+                       (if (zerop len) (throw 'zero 0)
+                         (setq min-ind (min len min-ind))))))
+                 (cond
+                  ((stringp object)
+                   (dolist (line (cdr (org-split-string object " *\n")))
+                     (unless (string= line "")
+                       (setq min-ind
+                             (min (org-get-indentation line) min-ind)))))
+                  ((eq (org-element-type object) 'line-break)
+                   (setq first-flag t))
+                  ((memq (org-element-type object)
+                         org-element-recursive-objects)
+                   (setq min-ind
+                         (funcall find-min-ind
+                                  object first-flag min-ind))))))))
+          (min-ind (funcall find-min-ind
+                            element (not ignore-first) most-positive-fixnum)))
     (if (or (zerop min-ind) (= min-ind most-positive-fixnum)) element
       ;; Build ELEMENT back, replacing each string with the same
       ;; string minus common indentation.
-      (let* (build                     ; For byte compiler.
-            (build
-             (lambda (blob first-flag)
-               ;; Return BLOB with all its strings indentation
-               ;; shortened from MIN-IND white spaces.  FIRST-FLAG is
-               ;; non-nil when the next object is expected to be
-               ;; a string that doesn't start with a newline
-               ;; character.
-               (setcdr (cdr blob)
-                       (mapcar
-                        (lambda (object)
-                          (when first-flag
-                            (setq first-flag nil)
-                            (when (stringp object)
-                              (setq object
-                                    (replace-regexp-in-string
-                                     (format "\\` \\{%d\\}" min-ind)
-                                     "" object))))
-                          (cond
-                           ((stringp object)
-                            (replace-regexp-in-string
-                             (format "\n \\{%d\\}" min-ind) "\n" object))
-                           ((memq (org-element-type object)
-                                  org-element-recursive-objects)
-                            (funcall build object first-flag))
-                           ((eq (org-element-type object) 'line-break)
-                            (setq first-flag t)
-                            object)
-                           (t object)))
-                        (org-element-contents blob)))
-               blob)))
+      (letrec ((build
+               (lambda (datum first-flag)
+                 ;; Return DATUM with all its strings indentation
+                 ;; shortened from MIN-IND white spaces.
+                 ;; FIRST-FLAG is non-nil when the next object is
+                 ;; expected to be a string that doesn't start with
+                 ;; a newline character.
+                 (setcdr (cdr datum)
+                         (mapcar
+                          (lambda (object)
+                            (when first-flag
+                              (setq first-flag nil)
+                              (when (stringp object)
+                                (setq object
+                                      (replace-regexp-in-string
+                                       (format "\\` \\{%d\\}" min-ind)
+                                       "" object))))
+                            (cond
+                             ((stringp object)
+                              (replace-regexp-in-string
+                               (format "\n \\{%d\\}" min-ind) "\n" object))
+                             ((memq (org-element-type object)
+                                    org-element-recursive-objects)
+                              (funcall build object first-flag))
+                             ((eq (org-element-type object) 'line-break)
+                              (setq first-flag t)
+                              object)
+                             (t object)))
+                          (org-element-contents datum)))
+                 datum)))
        (funcall build element (not ignore-first))))))
 
 
@@ -4690,7 +4706,7 @@ This cache is used in `org-element-context'.")
 
 A request is a vector with the following pattern:
 
- \[NEXT BEG END OFFSET OUTREACH PARENT PHASE]
+ \[NEXT BEG END OFFSET PARENT PHASE]
 
 Processing a synchronization request consists of three phases:
 
@@ -4701,7 +4717,7 @@ Processing a synchronization request consists of three phases:
 During phase 0, NEXT is the key of the first element to be
 removed, BEG and END is buffer position delimiting the
 modifications.  Elements starting between them (inclusive) are
-removed and so are those contained within OUTREACH.  PARENT, when
+removed.  So are elements whose parent is removed.  PARENT, when
 non-nil, is the parent of the first element to be removed.
 
 During phase 1, NEXT is the key of the next known element in
@@ -4859,6 +4875,7 @@ This function assumes `org-element--cache' is a valid AVL tree."
 (defsubst org-element--cache-active-p ()
   "Non-nil when cache is active in current buffer."
   (and org-element-use-cache
+       org-element--cache
        (or (derived-mode-p 'org-mode) orgstruct-mode)))
 
 (defun org-element--cache-find (pos &optional side)
@@ -4915,10 +4932,10 @@ the cache."
          (setq node nil
                lower element
                upper element)))))
-    (case side
-      (both (cons lower upper))
-      ((nil) lower)
-      (otherwise upper))))
+    (pcase side
+      (`both (cons lower upper))
+      (`nil lower)
+      (_ upper))))
 
 (defun org-element--cache-put (element &optional data)
   "Store ELEMENT in current buffer's cache, if allowed.
@@ -5043,7 +5060,7 @@ updated before current modification are actually submitted."
          (clrhash org-element--cache-sync-keys))))))
 
 (defun org-element--cache-process-request
-  (request next threshold time-limit future-change)
+    (request next threshold time-limit future-change)
   "Process synchronization REQUEST for all entries before NEXT.
 
 REQUEST is a vector, built by `org-element--cache-submit-request'.
@@ -5063,54 +5080,61 @@ not registered yet in the cache are going to happen.  See
 Throw `interrupt' if the process stops before completing the
 request."
   (catch 'quit
-    (when (= (aref request 6) 0)
+    (when (= (aref request 5) 0)
       ;; Phase 0.
       ;;
       ;; Delete all elements starting after BEG, but not after buffer
-      ;; position END or past element with key NEXT.
+      ;; position END or past element with key NEXT.  Also delete
+      ;; elements contained within a previously removed element
+      ;; (stored in `last-container').
       ;;
       ;; At each iteration, we start again at tree root since
       ;; a deletion modifies structure of the balanced tree.
       (catch 'end-phase
-        (let ((beg (aref request 0))
-              (end (aref request 2))
-             (outreach (aref request 4)))
-          (while t
-            (when (org-element--cache-interrupt-p time-limit)
-             (throw 'interrupt nil))
-            ;; Find first element in cache with key BEG or after it.
-            (let ((node (org-element--cache-root)) data data-key)
-              (while node
-                (let* ((element (avl-tree--node-data node))
-                       (key (org-element--cache-key element)))
-                  (cond
-                   ((org-element--cache-key-less-p key beg)
-                    (setq node (avl-tree--node-right node)))
-                   ((org-element--cache-key-less-p beg key)
-                    (setq data element
-                          data-key key
-                          node (avl-tree--node-left node)))
-                   (t (setq data element
-                            data-key key
-                            node nil)))))
-             (if data
-                 (let ((pos (org-element-property :begin data)))
-                   (if (if (or (not next)
-                               (org-element--cache-key-less-p data-key next))
-                           (<= pos end)
-                         (let ((up data))
-                           (while (and up (not (eq up outreach)))
-                             (setq up (org-element-property :parent up)))
-                           up))
-                       (org-element--cache-remove data)
-                     (aset request 0 data-key)
-                     (aset request 1 pos)
-                     (aset request 6 1)
-                     (throw 'end-phase nil)))
-               ;; No element starting after modifications left in
-               ;; cache: further processing is futile.
-               (throw 'quit t)))))))
-    (when (= (aref request 6) 1)
+        (while t
+         (when (org-element--cache-interrupt-p time-limit)
+           (throw 'interrupt nil))
+         ;; Find first element in cache with key BEG or after it.
+         (let ((beg (aref request 0))
+               (end (aref request 2))
+               (node (org-element--cache-root))
+               data data-key last-container)
+           (while node
+             (let* ((element (avl-tree--node-data node))
+                    (key (org-element--cache-key element)))
+               (cond
+                ((org-element--cache-key-less-p key beg)
+                 (setq node (avl-tree--node-right node)))
+                ((org-element--cache-key-less-p beg key)
+                 (setq data element
+                       data-key key
+                       node (avl-tree--node-left node)))
+                (t (setq data element
+                         data-key key
+                         node nil)))))
+           (if data
+               (let ((pos (org-element-property :begin data)))
+                 (if (if (or (not next)
+                             (org-element--cache-key-less-p data-key next))
+                         (<= pos end)
+                       (and last-container
+                            (let ((up data))
+                              (while (and up (not (eq up last-container)))
+                                (setq up (org-element-property :parent up)))
+                              up)))
+                     (progn (when (and (not last-container)
+                                       (> (org-element-property :end data)
+                                          end))
+                              (setq last-container data))
+                            (org-element--cache-remove data))
+                   (aset request 0 data-key)
+                   (aset request 1 pos)
+                   (aset request 5 1)
+                   (throw 'end-phase nil)))
+             ;; No element starting after modifications left in
+             ;; cache: further processing is futile.
+             (throw 'quit t))))))
+    (when (= (aref request 5) 1)
       ;; Phase 1.
       ;;
       ;; Phase 0 left a hole in the cache.  Some elements after it
@@ -5144,7 +5168,7 @@ request."
          (let ((next-request (nth 1 org-element--cache-sync-requests)))
            (aset next-request 0 key)
            (aset next-request 1 (aref request 1))
-           (aset next-request 6 1))
+           (aset next-request 5 1))
          (throw 'quit t)))
       ;; Next element will start at its beginning position plus
       ;; offset, since it hasn't been shifted yet.  Therefore, LIMIT
@@ -5156,11 +5180,11 @@ request."
               ;; Changes are going to happen around this element and
               ;; they will trigger another phase 1 request.  Skip the
               ;; current one.
-              (aset request 6 2))
+              (aset request 5 2))
              (t
               (let ((parent (org-element--parse-to limit t time-limit)))
-                (aset request 5 parent)
-                (aset request 6 2))))))
+                (aset request 4 parent)
+                (aset request 5 2))))))
     ;; Phase 2.
     ;;
     ;; Shift all elements starting from key START, but before NEXT, by
@@ -5174,7 +5198,7 @@ request."
     ;; request is updated.
     (let ((start (aref request 0))
          (offset (aref request 3))
-         (parent (aref request 5))
+         (parent (aref request 4))
          (node (org-element--cache-root))
          (stack (list nil))
          (leftp t)
@@ -5194,7 +5218,7 @@ request."
              ;; Handle interruption request.  Update current request.
              (when (or exit-flag (org-element--cache-interrupt-p time-limit))
                (aset request 0 key)
-               (aset request 5 parent)
+               (aset request 4 parent)
                (throw 'interrupt nil))
              ;; Shift element.
              (unless (zerop offset)
@@ -5365,12 +5389,10 @@ the process stopped before finding the expected result."
 (defconst org-element--cache-sensitive-re
   (concat
    org-outline-regexp-bol "\\|"
+   "\\\\end{[A-Za-z0-9*]+}[ \t]*$" "\\|"
    "^[ \t]*\\(?:"
-   ;; Blocks
    "#\\+\\(?:BEGIN