Merge from origin/emacs-26

1fc98ed073 ; Spelling fix
bb396a369c Update Org to v9.1.6
fa582153f7 Use text-pixels values only when saving framesets (Bug#30141)
6b01b9475d Minor improvement in section "Pages" of the usere manual
e8c8bd3de2 Minor improvements in user manual
26b8b92e63 Improve the "Mark" chapter of the user manual
759569fe40 Improve the "Buffers" chapter of the user manual
c2e6d121ff * lisp/term.el (term-send-input): Fix text duplication in ...
854a1c0a61 Improve "Buffers" in the user manual

# Conflicts:
#	etc/NEWS

28 files changed, 242 insertions, 172 deletions

diff --git a/lisp/org/ob-core.el b/lisp/org/ob-core.el
index 8a17ee4f1fa..5f378b2173f 100644
--- a/lisp/org/ob-core.el
+++ b/lisp/org/ob-core.el
@@ -74,7 +74,6 @@
 (declare-function org-mark-ring-push "org" (&optional pos buffer))
 (declare-function org-narrow-to-subtree "org" ())
 (declare-function org-next-block "org" (arg &optional backward block-regexp))
-(declare-function org-number-sequence "org-compat" (from &optional to inc))
 (declare-function org-open-at-point "org" (&optional in-emacs reference-buffer))
 (declare-function org-outline-overlay-data "org" (&optional use-markers))
 (declare-function org-previous-block "org" (arg &optional block-regexp))
@@ -82,7 +81,7 @@
 (declare-function org-reverse-string "org" (string))
 (declare-function org-set-outline-overlay-data "org" (data))
 (declare-function org-show-context "org" (&optional key))
-(declare-function org-src-coderef-format "org-src" (element))
+(declare-function org-src-coderef-format "org-src" (&optional element))
 (declare-function org-src-coderef-regexp "org-src" (fmt &optional label))
 (declare-function org-table-align "org-table" ())
 (declare-function org-table-end "org-table" (&optional table-type))
@@ -2476,7 +2475,7 @@ in the buffer."
 	     (point))))))
 
 (defun org-babel-result-to-file (result &optional description)
-  "Convert RESULT into an `org-mode' link with optional DESCRIPTION.
+  "Convert RESULT into an Org link with optional DESCRIPTION.
 If the `default-directory' is different from the containing
 file's directory then expand relative links."
   (when (stringp result)
@@ -2761,22 +2760,27 @@ block but are passed literally to the \"example-block\"."
                       (if org-babel-use-quick-and-dirty-noweb-expansion
                           (while (re-search-forward rx nil t)
                             (let* ((i (org-babel-get-src-block-info 'light))
-                                   (body (org-babel-expand-noweb-references i))
+                                   (body (if (org-babel-noweb-p (nth 2 i) :eval)
+					     (org-babel-expand-noweb-references i)
+					   (nth 1 i)))
                                    (sep (or (cdr (assq :noweb-sep (nth 2 i)))
                                             "\n"))
                                    (full (if comment
                                              (let ((cs (org-babel-tangle-comment-links i)))
-                                                (concat (funcall c-wrap (car cs)) "\n"
-                                                        body "\n"
-                                                        (funcall c-wrap (cadr cs))))
+					       (concat (funcall c-wrap (car cs)) "\n"
+						       body "\n"
+						       (funcall c-wrap (cadr cs))))
                                            body)))
                               (setq expansion (cons sep (cons full expansion)))))
                         (org-babel-map-src-blocks nil
-			  (let ((i (org-babel-get-src-block-info 'light)))
+			  (let ((i (let ((org-babel-current-src-block-location (point)))
+				     (org-babel-get-src-block-info 'light))))
                             (when (equal (or (cdr (assq :noweb-ref (nth 2 i)))
                                              (nth 4 i))
                                          source-name)
-                              (let* ((body (org-babel-expand-noweb-references i))
+                              (let* ((body (if (org-babel-noweb-p (nth 2 i) :eval)
+					       (org-babel-expand-noweb-references i)
+					     (nth 1 i)))
                                      (sep (or (cdr (assq :noweb-sep (nth 2 i)))
                                               "\n"))
                                      (full (if comment
diff --git a/lisp/org/ob-exp.el b/lisp/org/ob-exp.el
index c474b1e2be7..d2c32fac81a 100644
--- a/lisp/org/ob-exp.el
+++ b/lisp/org/ob-exp.el
@@ -58,9 +58,13 @@ returned is the value of the last form in BODY.  Assume that
 point is at the beginning of the Babel block."
   (declare (indent 1) (debug body))
   `(let ((source (get-text-property (point) 'org-reference)))
-     (with-current-buffer org-babel-exp-reference-buffer
+     ;; Source blocks created during export process (e.g., by other
+     ;; source blocks) are not referenced.  In this case, do not move
+     ;; point at all.
+     (with-current-buffer (if source org-babel-exp-reference-buffer
+			    (current-buffer))
        (org-with-wide-buffer
-	(goto-char source)
+	(when source (goto-char source))
 	,@body))))
 
 (defun org-babel-exp-src-block ()
diff --git a/lisp/org/ob-gnuplot.el b/lisp/org/ob-gnuplot.el
index 1acce502475..674627b8fa0 100644
--- a/lisp/org/ob-gnuplot.el
+++ b/lisp/org/ob-gnuplot.el
@@ -116,6 +116,8 @@ code."
            (timefmt (cdr (assq :timefmt params)))
            (time-ind (or (cdr (assq :timeind params))
                          (when timefmt 1)))
+	   (directory (and (buffer-file-name)
+			   (file-name-directory (buffer-file-name))))
 	   (add-to-body (lambda (text) (setq body (concat text "\n" body)))))
       ;; append header argument settings to body
       (when title (funcall add-to-body (format "set title '%s'" title)))
@@ -161,7 +163,10 @@ code."
 			  (format "\\$%s" (car pair)) (cdr pair) body)))
 	    vars)
       (when prologue (funcall add-to-body prologue))
-      (when epilogue (setq body (concat body "\n" epilogue))))
+      (when epilogue (setq body (concat body "\n" epilogue)))
+      ;; Setting the directory needs to be done first so that
+      ;; subsequent 'output' directive goes to the right place.
+      (when directory (funcall add-to-body (format "cd '%s'" directory))))
     body))
 
 (defun org-babel-execute:gnuplot (body params)
diff --git a/lisp/org/ob-haskell.el b/lisp/org/ob-haskell.el
index 301c6837b3c..b19ee6d70fe 100644
--- a/lisp/org/ob-haskell.el
+++ b/lisp/org/ob-haskell.el
@@ -59,14 +59,23 @@
 
 (defvar org-babel-haskell-eoe "\"org-babel-haskell-eoe\"")
 
+(defvar haskell-prompt-regexp)
+
 (defun org-babel-execute:haskell (body params)
   "Execute a block of Haskell code."
+  (require 'inf-haskell)
+  (add-hook 'inferior-haskell-hook
+            (lambda ()
+              (setq-local comint-prompt-regexp
+                          (concat haskell-prompt-regexp "\\|^λ?> "))))
   (let* ((session (cdr (assq :session params)))
          (result-type (cdr (assq :result-type params)))
          (full-body (org-babel-expand-body:generic
 		     body params
 		     (org-babel-variable-assignments:haskell params)))
          (session (org-babel-haskell-initiate-session session params))
+	 (comint-preoutput-filter-functions
+	       (cons 'ansi-color-filter-apply comint-preoutput-filter-functions))
          (raw (org-babel-comint-with-output
 		  (session org-babel-haskell-eoe t full-body)
                 (insert (org-trim full-body))
diff --git a/lisp/org/ob-picolisp.el b/lisp/org/ob-picolisp.el
index 0d44c9832db..b6dc8986f95 100644
--- a/lisp/org/ob-picolisp.el
+++ b/lisp/org/ob-picolisp.el
@@ -39,9 +39,9 @@
 ;; directory).
 
 ;; Although it might seem more natural to use Emacs Lisp for most
-;; Lisp-based programming tasks inside Org-Mode, an Emacs library
-;; written in Emacs Lisp, PicoLisp has at least two outstanding
-;; features that make it a valuable addition to Org-Babel:
+;; Lisp-based programming tasks inside Org, an Emacs library written
+;; in Emacs Lisp, PicoLisp has at least two outstanding features that
+;; make it a valuable addition to Org Babel:
 
 ;; PicoLisp _is_ an object-oriented database with a Prolog-based query
 ;; language implemented in PicoLisp (Pilog). Database objects are
diff --git a/lisp/org/ob-python.el b/lisp/org/ob-python.el
index 3ea050fffea..951e4d2a4b4 100644
--- a/lisp/org/ob-python.el
+++ b/lisp/org/ob-python.el
@@ -239,6 +239,15 @@ def main():
 
 open('%s', 'w').write( pprint.pformat(main()) )")
 
+(defconst org-babel-python--exec-tmpfile
+  (concat
+   "__org_babel_python_fname = '%s'; "
+   "__org_babel_python_fh = open(__org_babel_python_fname); "
+   "exec(compile("
+   "__org_babel_python_fh.read(), __org_babel_python_fname, 'exec'"
+   ")); "
+   "__org_babel_python_fh.close()"))
+
 (defun org-babel-python-evaluate
   (session body &optional result-type result-params preamble)
   "Evaluate BODY as Python code."
@@ -306,16 +315,23 @@ last statement in BODY, as elisp."
          (results
           (pcase result-type
             (`output
-             (mapconcat
-              #'org-trim
-              (butlast
-               (org-babel-comint-with-output
-                   (session org-babel-python-eoe-indicator t body)
-                 (funcall input-body body)
-                 (funcall send-wait) (funcall send-wait)
-                 (insert org-babel-python-eoe-indicator)
-                 (funcall send-wait))
-               2) "\n"))
+	     (let ((body (if (string-match-p ".\n+." body) ; Multiline
+			     (let ((tmp-src-file (org-babel-temp-file
+						  "python-")))
+			       (with-temp-file tmp-src-file (insert body))
+			       (format org-babel-python--exec-tmpfile
+				       tmp-src-file))
+			   body)))
+	       (mapconcat
+		#'org-trim
+		(butlast
+		 (org-babel-comint-with-output
+		     (session org-babel-python-eoe-indicator t body)
+		   (funcall input-body body)
+		   (funcall send-wait) (funcall send-wait)
+		   (insert org-babel-python-eoe-indicator)
+		   (funcall send-wait))
+		 2) "\n")))
             (`value
              (let ((tmp-file (org-babel-temp-file "python-")))
                (org-babel-comint-with-output
diff --git a/lisp/org/ob-ref.el b/lisp/org/ob-ref.el
index de30a761293..872f7f98151 100644
--- a/lisp/org/ob-ref.el
+++ b/lisp/org/ob-ref.el
@@ -65,24 +65,21 @@
 (declare-function org-show-context "org" (&optional key))
 (declare-function org-trim "org" (s &optional keep-lead))
 
-(defvar org-babel-ref-split-regexp
-  "[ \f\t\n\r\v]*\\(.+?\\)[ \f\t\n\r\v]*=[ \f\t\n\r\v]*\\(.+\\)[ \f\t\n\r\v]*")
-
 (defvar org-babel-update-intermediate nil
   "Update the in-buffer results of code blocks executed to resolve references.")
 
 (defun org-babel-ref-parse (assignment)
   "Parse a variable ASSIGNMENT in a header argument.
+
 If the right hand side of the assignment has a literal value
-return that value, otherwise interpret as a reference to an
-external resource and find its value using
-`org-babel-ref-resolve'.  Return a list with two elements.  The
-first element of the list will be the name of the variable, and
-the second will be an emacs-lisp representation of the value of
-the variable."
-  (when (string-match org-babel-ref-split-regexp assignment)
-    (let ((var (match-string 1 assignment))
-	  (ref (match-string 2 assignment)))
+return that value, otherwise interpret it as a reference to an
+external resource and find its value using `org-babel-ref-resolve'.
+
+Return a list with two elements: the name of the variable, and an
+Emacs Lisp representation of the value of the variable."
+  (when (string-match "\\(.+?\\)=" assignment)
+    (let ((var (org-trim (match-string 1 assignment)))
+	  (ref (org-trim (substring assignment (match-end 0)))))
       (cons (intern var)
 	    (let ((out (save-excursion
 			 (when org-babel-current-src-block-location
diff --git a/lisp/org/ob-scheme.el b/lisp/org/ob-scheme.el
index 029569edacc..cc78b574d07 100644
--- a/lisp/org/ob-scheme.el
+++ b/lisp/org/ob-scheme.el
@@ -40,6 +40,7 @@
 ;;; Code:
 (require 'ob)
 (require 'geiser nil t)
+(require 'geiser-impl nil t)
 (defvar geiser-repl--repl)             ; Defined in geiser-repl.el
 (defvar geiser-impl--implementation)   ; Defined in geiser-impl.el
 (defvar geiser-default-implementation) ; Defined in geiser-impl.el
diff --git a/lisp/org/ob-stan.el b/lisp/org/ob-stan.el
index 38cda4cdbc7..6fa9fe5c94f 100644
--- a/lisp/org/ob-stan.el
+++ b/lisp/org/ob-stan.el
@@ -49,11 +49,12 @@
 
 (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."
+Call \"make\" from this directory to compile the Stan block.
+When nil, executing Stan blocks dumps the content to a file."
   :group 'org-babel
-  :type 'string)
+  :type '(choice
+	  (directory :tag "Compilation directory")
+	  (const :tag "Dump to a file" nil)))
 
 (defvar org-babel-default-header-args:stan
   '((:results . "file")))
diff --git a/lisp/org/org-agenda.el b/lisp/org/org-agenda.el
index 9f8d294044c..9aaec330708 100644
--- a/lisp/org/org-agenda.el
+++ b/lisp/org/org-agenda.el
@@ -395,35 +395,35 @@ the daily/weekly agenda, see `org-agenda-skip-function'.")
 				   (choice
 				    :tag "Condition type"
 				    (list :tag "Regexp matches" :inline t
-					  (const :format "" 'regexp)
+					  (const :format "" regexp)
 					  (regexp))
 				    (list :tag "Regexp does not match" :inline t
-					  (const :format "" 'notregexp)
+					  (const :format "" notregexp)
 					  (regexp))
 				    (list :tag "TODO state is" :inline t
-					  (const 'todo)
+					  (const todo)
 					  (choice
-					   (const :tag "Any not-done state" 'todo)
-					   (const :tag "Any done state" 'done)
-					   (const :tag "Any state" 'any)
+					   (const :tag "Any not-done state" todo)
+					   (const :tag "Any done state" done)
+					   (const :tag "Any state" any)
 					   (list :tag "Keyword list"
 						 (const :format "" quote)
 						 (repeat (string :tag "Keyword")))))
 				    (list :tag "TODO state is not" :inline t
-					  (const 'nottodo)
+					  (const nottodo)
 					  (choice
-					   (const :tag "Any not-done state" 'todo)
-					   (const :tag "Any done state" 'done)
-					   (const :tag "Any state" 'any)
+					   (const :tag "Any not-done state" todo)
+					   (const :tag "Any done state" done)
+					   (const :tag "Any state" any)
 					   (list :tag "Keyword list"
 						 (const :format "" quote)
 						 (repeat (string :tag "Keyword")))))
-				    (const :tag "scheduled" 'scheduled)
-				    (const :tag "not scheduled" 'notscheduled)
-				    (const :tag "deadline" 'deadline)
-				    (const :tag "no deadline" 'notdeadline)
-				    (const :tag "timestamp" 'timestamp)
-				    (const :tag "no timestamp" 'nottimestamp))))))
+				    (const :tag "scheduled" scheduled)
+				    (const :tag "not scheduled" notscheduled)
+				    (const :tag "deadline" deadline)
+				    (const :tag "no deadline" notdeadline)
+				    (const :tag "timestamp" timestamp)
+				    (const :tag "no timestamp" nottimestamp))))))
 		   (list :tag "Non-standard skipping condition"
 			 :value (org-agenda-skip-function)
 			 (const org-agenda-skip-function)
@@ -3563,7 +3563,7 @@ removed from the entry content.  Currently only `planning' is allowed here."
     txt))
 
 (defun org-check-for-org-mode ()
-  "Make sure current buffer is in org-mode.  Error if not."
+  "Make sure current buffer is in Org mode.  Error if not."
   (or (derived-mode-p 'org-mode)
       (error "Cannot execute Org agenda command on buffer in %s"
 	     major-mode)))
@@ -4509,7 +4509,7 @@ is active."
 	  (with-current-buffer buffer
 	    (with-syntax-table (org-search-syntax-table)
 	      (unless (derived-mode-p 'org-mode)
-		(error "Agenda file %s is not in `org-mode'" file))
+		(error "Agenda file %s is not in Org mode" file))
 	      (let ((case-fold-search t))
 		(save-excursion
 		  (save-restriction
@@ -4774,7 +4774,7 @@ The prefix arg TODO-ONLY limits the search to TODO entries."
 		    rtnall (append rtnall rtn))
 	    (with-current-buffer buffer
 	      (unless (derived-mode-p 'org-mode)
-		(error "Agenda file %s is not in `org-mode'" file))
+		(error "Agenda file %s is not in Org mode" file))
 	      (save-excursion
 		(save-restriction
 		  (if (eq buffer org-agenda-restrict)
@@ -5067,9 +5067,9 @@ of what a project is and how to check if it stuck, customize the variable
 
 (defun org-agenda-cleanup-fancy-diary ()
   "Remove unwanted stuff in buffer created by `fancy-diary-display'.
-This gets rid of the date, the underline under the date, and
-the dummy entry installed by `org-mode' to ensure non-empty diary for each
-date.  It also removes lines that contain only whitespace."
+This gets rid of the date, the underline under the date, and the
+dummy entry installed by Org mode to ensure non-empty diary for
+each date.  It also removes lines that contain only whitespace."
   (goto-char (point-min))
   (if (looking-at ".*?:[ \t]*")
       (progn
@@ -5214,7 +5214,7 @@ the documentation of `org-diary'."
 	(list (format "ORG-AGENDA-ERROR: No such org-file %s" file))
       (with-current-buffer buffer
 	(unless (derived-mode-p 'org-mode)
-	  (error "Agenda file %s is not in `org-mode'" file))
+	  (error "Agenda file %s is not in Org mode" file))
 	(setq org-agenda-buffer (or org-agenda-buffer buffer))
 	(setf org-agenda-current-date date)
 	(save-excursion
diff --git a/lisp/org/org-archive.el b/lisp/org/org-archive.el
index a78113493b6..755de7fdac2 100644
--- a/lisp/org/org-archive.el
+++ b/lisp/org/org-archive.el
@@ -429,7 +429,7 @@ Archiving time is retained in the ARCHIVE_TIME node property."
 	(looking-at org-outline-regexp)
 	(setq leader (match-string 0)
 	      level (funcall outline-level))
-	(setq pos (point))
+	(setq pos (point-marker))
 	(condition-case nil
 	    (outline-up-heading 1 t)
 	  (error (setq e (point-max)) (goto-char (point-min))))
diff --git a/lisp/org/org-capture.el b/lisp/org/org-capture.el
index 24fc0a61f0b..cb1741f2f91 100644
--- a/lisp/org/org-capture.el
+++ b/lisp/org/org-capture.el
@@ -927,18 +927,24 @@ Store them in the capture property list."
 	   (_ (error "Cannot find target ID \"%s\"" id))))
 	(`(file+headline ,path ,headline)
 	 (set-buffer (org-capture-target-buffer path))
+	 ;; Org expects the target file to be in Org mode, otherwise
+	 ;; it throws an error.  However, the default notes files
+	 ;; should work out of the box.  In this case, we switch it to
+	 ;; Org mode.
 	 (unless (derived-mode-p 'org-mode)
-	   (error "Target buffer \"%s\" for file+headline not in Org mode"
-		  (current-buffer)))
+	   (org-display-warning
+	    (format "Capture requirement: switching buffer %S to Org mode"
+		    (current-buffer)))
+	   (org-mode))
 	 (org-capture-put-target-region-and-position)
 	 (widen)
 	 (goto-char (point-min))
 	 (if (re-search-forward (format org-complex-heading-regexp-format
 					(regexp-quote headline))
 				nil t)
-	     (goto-char (line-beginning-position))
+	     (beginning-of-line)
 	   (goto-char (point-max))
-	   (or (bolp) (insert "\n"))
+	   (unless (bolp) (insert "\n"))
 	   (insert "* " headline "\n")
 	   (beginning-of-line 0)))
 	(`(file+olp ,path . ,outline-path)
diff --git a/lisp/org/org-clock.el b/lisp/org/org-clock.el
index fd076de34e2..9bc1f0c06d7 100644
--- a/lisp/org/org-clock.el
+++ b/lisp/org/org-clock.el
@@ -1456,8 +1456,7 @@ The time is always returned as UTC."
 	     (day (nth 3 dt)))
 	(if (< hour org-extend-today-until) (setf (nth 3 dt) (1- day)))
 	(setf (nth 2 dt) org-extend-today-until)
-	(setq dt (append (list 0 0) (nthcdr 2 dt) '(t)))
-	(apply #'encode-time dt)))
+	(apply #'encode-time (append (list 0 0) (nthcdr 2 dt)))))
      ((or (equal cmt "all")
 	  (and (or (not cmt) (equal cmt "auto"))
 	       (not lr)))
diff --git a/lisp/org/org-compat.el b/lisp/org/org-compat.el
index 138e14e30b1..f32fcd1783e 100644
--- a/lisp/org/org-compat.el
+++ b/lisp/org/org-compat.el
@@ -32,12 +32,12 @@
 (require 'cl-lib)
 (require 'org-macs)
 
-(declare-function org-at-table.el-p "org" (&optional table-type))
+(declare-function org-at-table.el-p "org" ())
 (declare-function org-element-at-point "org-element" ())
 (declare-function org-element-type "org-element" (element))
 (declare-function org-end-of-subtree "org" (&optional invisible-ok to-heading))
 (declare-function org-link-set-parameters "org" (type &rest rest))
-(declare-function org-table-end (&optional table-type))
+(declare-function org-table-end "org-table" (&optional table-type))
 (declare-function outline-next-heading "outline" ())
 (declare-function table--at-cell-p "table" (position &optional object at-column))
 
diff --git a/lisp/org/org-duration.el b/lisp/org/org-duration.el
index 356a0343ea2..1c962ba94e0 100644
--- a/lisp/org/org-duration.el
+++ b/lisp/org/org-duration.el
@@ -51,7 +51,7 @@
 
 (require 'cl-lib)
 (require 'org-macs)
-(declare-function org-trim "org-trim" (s &optional keep-lead))
+(declare-function org-trim "org" (s &optional keep-lead))
 
 
 ;;; Public variables
@@ -99,8 +99,8 @@ sure to call the following command:
   :set (lambda (var val) (set-default var val) (org-duration-set-regexps))
   :initialize 'custom-initialize-changed
   :type '(choice
-	  (const :tag "H:MM" 'h:mm)
-	  (const :tag "H:MM:SS" 'h:mm:ss)
+	  (const :tag "H:MM" h:mm)
+	  (const :tag "H:MM:SS" h:mm:ss)
 	  (alist :key-type (string :tag "Unit")
 		 :value-type (number :tag "Modifier"))))
 
diff --git a/lisp/org/org-footnote.el b/lisp/org/org-footnote.el
index f9d8055648c..4d3f154c257 100644
--- a/lisp/org/org-footnote.el
+++ b/lisp/org/org-footnote.el
@@ -45,7 +45,7 @@
 (declare-function org-element-property "org-element" (property element))
 (declare-function org-element-type "org-element" (element))
 (declare-function org-end-of-subtree "org"  (&optional invisible-ok to-heading))
-(declare-function org-fill-paragraph "org" (&optional justify))
+(declare-function org-fill-paragraph "org" (&optional justify region))
 (declare-function org-in-block-p "org" (names))
 (declare-function org-in-regexp "org" (re &optional nlines visually))
 (declare-function org-in-verbatim-emphasis "org" ())
diff --git a/lisp/org/org-inlinetask.el b/lisp/org/org-inlinetask.el
index 5b65fab5932..1825b88cdf6 100644
--- a/lisp/org/org-inlinetask.el
+++ b/lisp/org/org-inlinetask.el
@@ -182,24 +182,28 @@ The number of levels is controlled by `org-inlinetask-min-level'."
 
 (defun org-inlinetask-goto-end ()
   "Go to the end of the inline task at point.
-Return point."
+    Return point."
   (save-match-data
     (beginning-of-line)
     (let* ((case-fold-search t)
-	   (inlinetask-re (org-inlinetask-outline-regexp))
-	   (task-end-re (concat inlinetask-re "END[ \t]*$")))
+           (inlinetask-re (org-inlinetask-outline-regexp))
+           (task-end-re (concat inlinetask-re "END[ \t]*$")))
       (cond
-       ((looking-at task-end-re))
-       ((looking-at inlinetask-re)
-	(forward-line)
-	(cond
-	 ((looking-at task-end-re))
-	 ((looking-at inlinetask-re))
-	 ((org-inlinetask-in-task-p)
-	  (re-search-forward inlinetask-re nil t))))
-       (t (re-search-forward inlinetask-re nil t)))
-      (end-of-line)
-      (point))))
+       ((looking-at-p task-end-re)
+        (forward-line))
+       ((looking-at-p inlinetask-re)
+        (forward-line)
+        (cond
+         ((looking-at-p task-end-re) (forward-line))
+         ((looking-at-p inlinetask-re))
+         ((org-inlinetask-in-task-p)
+          (re-search-forward inlinetask-re nil t)
+          (forward-line))
+         (t nil)))
+       (t
+        (re-search-forward inlinetask-re nil t)
+        (forward-line)))))
+  (point))
 
 (defun org-inlinetask-get-task-level ()
   "Get the level of the inline task around.
@@ -330,7 +334,9 @@ This function is meant to be used in `org-cycle-hook'."
 	   (org-inlinetask-goto-end)))))
     (`children
      (save-excursion
-       (while (and (outline-next-heading) (org-inlinetask-at-task-p))
+       (while
+	   (or (org-inlinetask-at-task-p)
+	       (and (outline-next-heading) (org-inlinetask-at-task-p)))
 	 (org-inlinetask-toggle-visibility)
 	 (org-inlinetask-goto-end))))))
 
diff --git a/lisp/org/org-pcomplete.el b/lisp/org/org-pcomplete.el
index f0c07938271..a7cc09def4b 100644
--- a/lisp/org/org-pcomplete.el
+++ b/lisp/org/org-pcomplete.el
@@ -41,11 +41,6 @@
 
 ;;;; Customization variables
 
-(defgroup org-complete nil
-  "Outline-based notes management and organizer."
-  :tag "Org"
-  :group 'org)
-
 (defvar org-drawer-regexp)
 (defvar org-property-re)
 (defvar org-current-tag-alist)
diff --git a/lisp/org/org-table.el b/lisp/org/org-table.el
index 0ba7165abe9..3932671e8b7 100644
--- a/lisp/org/org-table.el
+++ b/lisp/org/org-table.el
@@ -644,17 +644,30 @@ nil      When nil, the command tries to be smart and figure out the
       (org-table-align))))
 
 ;;;###autoload
-(defun org-table-import (file arg)
+(defun org-table-import (file separator)
   "Import FILE as a table.
-The file is assumed to be tab-separated.  Such files can be produced by most
-spreadsheet and database applications.  If no tabs (at least one per line)
-are found, lines will be split on whitespace into fields."
+
+The command tries to be smart and figure out the separator in the
+following way:
+
+  - when each line contains a TAB, assume TAB-separated material
+  - when each line contains a comma, assume CSV material
+  - else, assume one or more SPACE characters as separator.
+
+When non-nil, SEPARATOR specifies the field separator in the
+lines.  It can have the following values:
+
+(4)     Use the comma as a field separator
+(16)    Use a TAB as field separator
+(64)    Prompt for a regular expression as field separator
+integer When a number, use that many spaces, or a TAB, as field separator
+regexp  When a regular expression, use it to match the separator."
   (interactive "f\nP")
-  (or (bolp) (newline))
+  (unless (bolp) (insert "\n"))
   (let ((beg (point))
 	(pm (point-max)))
     (insert-file-contents file)
-    (org-table-convert-region beg (+ (point) (- (point-max) pm)) arg)))
+    (org-table-convert-region beg (+ (point) (- (point-max) pm)) separator)))
 
 
 ;;;###autoload
@@ -1166,7 +1179,7 @@ to a number.  In the case of a timestamp, increment by days."
 			      (- (org-time-string-to-absolute txt)
 				 (org-time-string-to-absolute txt-up)))
 			     ((string-match org-ts-regexp3 txt) 1)
-			     ((string-match "\\([-+]\\)?[0-9]+\\(?:\.[0-9]+\\)?" txt-up)
+			     ((string-match "\\([-+]\\)?\\(?:[0-9]+\\)?\\(?:\.[0-9]+\\)?" txt-up)
 			      (- (string-to-number txt)
 				 (string-to-number (match-string 0 txt-up))))
 			     (t 1)))
@@ -4311,14 +4324,14 @@ FACE, when non-nil, for the highlight."
 
 ;;;###autoload
 (define-minor-mode orgtbl-mode
-  "The `org-mode' table editor as a minor mode for use in other modes."
+  "The Org mode table editor as a minor mode for use in other modes."
   :lighter " OrgTbl" :keymap orgtbl-mode-map
   (org-load-modules-maybe)
   (cond
    ((derived-mode-p 'org-mode)
-    ;; Exit without error, in case some hook functions calls this
-    ;; by accident in org-mode.
-    (message "Orgtbl-mode is not useful in org-mode, command ignored"))
+    ;; Exit without error, in case some hook functions calls this by
+    ;; accident in Org mode.
+    (message "Orgtbl mode is not useful in Org mode, command ignored"))
    (orgtbl-mode
     (and (orgtbl-setup) (defun orgtbl-setup () nil)) ;; FIXME: Yuck!?!
     ;; Make sure we are first in minor-mode-map-alist
diff --git a/lisp/org/org-version.el b/lisp/org/org-version.el
index 749cbe063e8..8ec120e9b2f 100644
--- a/lisp/org/org-version.el
+++ b/lisp/org/org-version.el
@@ -5,13 +5,13 @@
 (defun org-release ()
   "The release version of Org.
 Inserted by installing Org mode or when a release is made."
-   (let ((org-release "9.1.4"))
+   (let ((org-release "9.1.6"))
      org-release))
 ;;;###autoload
 (defun org-git-version ()
-  "The Git version of org-mode.
+  "The Git version of Org mode.
 Inserted by installing Org or when a release is made."
-   (let ((org-git-version "release_9.1.4-44-gfe7310"))
+   (let ((org-git-version "release_9.1.6-50-g96b33f"))
      org-git-version))
 
 (provide 'org-version)
diff --git a/lisp/org/org-w3m.el b/lisp/org/org-w3m.el
index a3ca4786959..706619c5d2b 100644
--- a/lisp/org/org-w3m.el
+++ b/lisp/org/org-w3m.el
@@ -57,7 +57,7 @@
      :description (or w3m-current-title w3m-current-url))))
 
 (defun org-w3m-copy-for-org-mode ()
-  "Copy current buffer content or active region with `org-mode' style links.
+  "Copy current buffer content or active region with Org style links.
 This will encode `link-title' and `link-location' with
 `org-make-link-string', and insert the transformed test into the kill ring,
 so that it can be yanked into an Org  buffer with links working correctly."
@@ -94,7 +94,7 @@ so that it can be yanked into an Org  buffer with links working correctly."
               ;; get link title at current point.
               (setq link-title (buffer-substring (point)
                                                  (org-w3m-get-anchor-end)))
-              ;; concat `org-mode' style url to `return-content'.
+              ;; concat Org style url to `return-content'.
               (setq return-content (concat return-content
                                            (org-make-link-string
                                             link-location link-title))))
diff --git a/lisp/org/org.el b/lisp/org/org.el
index 173003d6438..5272061ccc9 100644
--- a/lisp/org/org.el
+++ b/lisp/org/org.el
@@ -749,7 +749,7 @@ For export specific modules, see also `org-export-backends'."
 	(const :tag "C  panel:             Simple routines for us with bad memory" org-panel)
 	(const :tag "C  registry:          A registry for Org links" org-registry)
 	(const :tag "C  screen:            Visit screen sessions through Org links" org-screen)
-	(const :tag "C  secretary:         Team management with org-mode" org-secretary)
+	(const :tag "C  secretary:         Team management with Org" org-secretary)
 	(const :tag "C  sqlinsert:         Convert Org tables to SQL insertions" orgtbl-sqlinsert)
 	(const :tag "C  toc:               Table of contents for Org buffer" org-toc)
 	(const :tag "C  track:             Keep up with Org mode development" org-track)
@@ -1710,7 +1710,7 @@ doesn't specify any upper case character."
   :type '(choice
 	  (const :tag "Case-sensitive" nil)
 	  (const :tag "Case-insensitive" t)
-	  (const :tag "Case-insensitive for lower case searches only" 'smart)))
+	  (const :tag "Case-insensitive for lower case searches only" smart)))
 
 (defcustom org-occur-hook '(org-first-headline-recenter)
   "Hook that is run after `org-occur' has constructed a sparse tree.
@@ -4167,7 +4167,10 @@ A string will be inserted as-is in the header of the document."
 	   (list :tag "options/package pair"
 		 (string :tag "options")
 		 (string :tag "package")
-		 (boolean :tag "Snippet"))
+		 (boolean :tag "Snippet")
+		 (choice
+		  (const :tag "For all compilers" nil)
+		  (repeat :tag "Allowed compiler" string)))
 	   (string :tag "A line of LaTeX"))))
 
 (defcustom org-latex-packages-alist nil
@@ -4870,7 +4873,7 @@ After a match, the following groups carry important information:
     ("beamer" org-startup-with-beamer-mode t)
     ("entitiespretty" org-pretty-entities t)
     ("entitiesplain" org-pretty-entities nil))
-  "Variable associated with STARTUP options for org-mode.
+  "Variable associated with STARTUP options for Org.
 Each element is a list of three items: the startup options (as written
 in the #+STARTUP line), the corresponding variable, and the value to set
 this variable to if the option is found.  An optional forth element PUSH
@@ -5934,7 +5937,7 @@ by a #."
 (defun org-fontify-meta-lines-and-blocks (limit)
   (condition-case nil
       (org-fontify-meta-lines-and-blocks-1 limit)
-    (error (message "org-mode fontification error in %S at %d"
+    (error (message "Org mode fontification error in %S at %d"
 		    (current-buffer)
 		    (line-number-at-pos)))))
 
@@ -6925,6 +6928,7 @@ If POS is nil, use `point' instead."
 	  (org-list-set-item-visibility (point-at-bol) struct 'children)
 	(org-show-entry)
 	(org-with-limited-levels (org-show-children))
+	(org-show-set-visibility 'canonical)
 	;; FIXME: This slows down the func way too much.
 	;; How keep drawers hidden in subtree anyway?
 	;; (when (memq 'org-cycle-hide-drawers org-cycle-hook)
@@ -7019,20 +7023,22 @@ With a numeric prefix, show all headlines up to that level."
 	 (save-excursion
 	   (org-back-to-heading t)
 	   (outline-hide-subtree)
-	   (org-reveal)
-	   (cond
-	    ((equal state "folded")
-	     (outline-hide-subtree))
-	    ((equal state "children")
-	     (org-show-hidden-entry)
-	     (org-show-children))
-	    ((equal state "content")
-	     (save-excursion
-	       (save-restriction
-		 (org-narrow-to-subtree)
-		 (org-content))))
-	    ((member state '("all" "showall"))
-	     (outline-show-subtree)))))))
+	   (org-reveal))
+	 (cond
+	  ((equal state "folded")
+	   (outline-hide-subtree)
+	   (org-end-of-subtree t t))
+	  ((equal state "children")
+	   (org-show-hidden-entry)
+	   (org-show-children))
+	  ((equal state "content")
+	   (save-excursion
+	     (save-restriction
+	       (org-narrow-to-subtree)
+	       (org-content)))
+	   (org-end-of-subtree t t))
+	  ((member state '("all" "showall"))
+	   (outline-show-subtree))))))
    (unless no-cleanup
      (org-cycle-hide-archived-subtrees 'all)
      (org-cycle-hide-drawers 'all)
@@ -7181,11 +7187,12 @@ are at least `org-cycle-separator-lines' empty lines before the headline."
   "Return `org-agenda-files' list, plus all open Org files.
 This is useful for operations that need to scan all of a user's
 open and agenda-wise Org files."
-  (let ((files (mapcar 'expand-file-name (org-agenda-files))))
+  (let ((files (mapcar #'expand-file-name (org-agenda-files))))
     (dolist (buf (buffer-list))
       (with-current-buffer buf
 	(when (and (derived-mode-p 'org-mode) (buffer-file-name))
-	  (cl-pushnew (expand-file-name (buffer-file-name)) files))))
+	  (cl-pushnew (expand-file-name (buffer-file-name)) files
+		      :test #'equal))))
     files))
 
 (defsubst org-entry-beginning-position ()
@@ -9949,20 +9956,24 @@ according to FMT (default from `org-email-link-description-format')."
 				    (reverse slines))) "\n")))))
     (mapconcat #'identity (split-string s) " ")))
 
+(defconst org-link-escape-chars
+  ;;%20 %5B %5D %25
+  '(?\s ?\[ ?\] ?%)
+  "List of characters that should be escaped in a link when stored to Org.
+This is the list that is used for internal purposes.")
+
 (defun org-make-link-string (link &optional description)
   "Make a link with brackets, consisting of LINK and DESCRIPTION."
   (unless (org-string-nw-p link) (error "Empty link"))
   (let ((uri (cond ((string-match org-link-types-re link)
 		    (concat (match-string 1 link)
 			    (org-link-escape (substring link (match-end 1)))))
-		   ;; For readability, url-encode internal links only
-		   ;; when absolutely needed (i.e, when they contain
-		   ;; square brackets).  File links however, are
-		   ;; encoded since, e.g., spaces are significant.
 		   ((or (file-name-absolute-p link)
-			(string-match-p "\\`\\.\\.?/\\|[][]" link))
+			(string-match-p "\\`\\.\\.?/" link))
 		    (org-link-escape link))
-		   (t link)))
+		   ;; For readability, do not encode space characters
+		   ;; in fuzzy links.
+		   (t (org-link-escape link (remq ?\s org-link-escape-chars)))))
 	(description
 	 (and (org-string-nw-p description)
 	      ;; Remove brackets from description, as they are fatal.
@@ -9973,12 +9984,6 @@ according to FMT (default from `org-email-link-description-format')."
 	    uri
 	    (if description (format "[%s]" description) ""))))
 
-(defconst org-link-escape-chars
-  ;;%20 %5B %5D %25
-  '(?\s ?\[ ?\] ?%)
-  "List of characters that should be escaped in a link when stored to Org.
-This is the list that is used for internal purposes.")
-
 (defun org-link-escape (text &optional table merge)
   "Return percent escaped representation of TEXT.
 TEXT is a string with the text to escape.
@@ -10280,11 +10285,19 @@ Use TAB to complete link prefixes, then RET for type-specific completion support
 	    ;; We are linking to this same file, with a search option
 	    (setq link search)))))
 
-    ;; Check if we can/should use a relative path.  If yes, simplify the link
+    ;; Check if we can/should use a relative path.  If yes, simplify
+    ;; the link.
     (let ((case-fold-search nil))
       (when (string-match "\\`\\(file\\|docview\\):" link)
 	(let* ((type (match-string-no-properties 0 link))
-	       (path (substring-no-properties link (match-end 0)))
+	       (path-start (match-end 0))
+	       (search (and (string-match "::\\(.*\\)\\'" link)
+			    (match-string 1 link)))
+	       (path
+		(if search
+		    (substring-no-properties
+		     link path-start (match-beginning 0))
+		  (substring-no-properties link (match-end 0))))
 	       (origpath path))
 	  (cond
 	   ((or (eq org-link-file-path-type 'absolute)
@@ -10305,7 +10318,7 @@ Use TAB to complete link prefixes, then RET for type-specific completion support
 		  (setq path (substring (expand-file-name path)
 					(match-end 0)))
 		(setq path (abbreviate-file-name (expand-file-name path)))))))
-	  (setq link (concat type path))
+	  (setq link (concat type path (and search (concat "::" search))))
 	  (when (equal desc origpath)
 	    (setq desc path)))))
 
@@ -12185,7 +12198,7 @@ There are two templates for each key, the first uses the original Org syntax,
 the second uses Emacs Muse-like syntax tags.  These Muse-like tags become
 the default when the /org-mtags.el/ module has been loaded.  See also the
 variable `org-mtags-prefer-muse-templates'."
-  :group 'org-completion
+  :group 'org-edit-structure
   :type '(repeat
 	  (list
 	   (string :tag "Key")
@@ -12377,7 +12390,7 @@ When called through ELisp, arg is also interpreted in the following way:
 	  (or (looking-at (concat " +" org-todo-regexp "\\( +\\|[ \t]*$\\)"))
 	      (looking-at "\\(?: *\\|[ \t]*$\\)"))
 	  (let* ((match-data (match-data))
-		 (startpos (point-at-bol))
+		 (startpos (copy-marker (line-beginning-position)))
 		 (logging (save-match-data (org-entry-get nil "LOGGING" t t)))
 		 (org-log-done org-log-done)
 		 (org-log-repeat org-log-repeat)
diff --git a/lisp/org/ox-beamer.el b/lisp/org/ox-beamer.el
index e17087b43c7..15b78dcdbce 100644
--- a/lisp/org/ox-beamer.el
+++ b/lisp/org/ox-beamer.el
@@ -174,11 +174,11 @@ through `org-beamer-environments-extra' variable.")
     ("quotation"      "q" "\\begin{quotation}%a %% %h"    "\\end{quotation}")
     ("quote"          "Q" "\\begin{quote}%a %% %h"        "\\end{quote}")
     ("structureenv"   "s" "\\begin{structureenv}%a %% %h" "\\end{structureenv}")
-    ("theorem"        "t" "\\begin{theorem}%a%U"          "\\end{theorem}")
-    ("definition"     "d" "\\begin{definition}%a%U"       "\\end{definition}")
-    ("example"        "e" "\\begin{example}%a%U"          "\\end{example}")
+    ("theorem"        "t" "\\begin{theorem}%a[%h]"        "\\end{theorem}")
+    ("definition"     "d" "\\begin{definition}%a[%h]"     "\\end{definition}")
+    ("example"        "e" "\\begin{example}%a[%h]"        "\\end{example}")
     ("exampleblock"   "E" "\\begin{exampleblock}%a{%h}"   "\\end{exampleblock}")
-    ("proof"          "p" "\\begin{proof}%a%U"            "\\end{proof}")
+    ("proof"          "p" "\\begin{proof}%a[%h]"          "\\end{proof}")
     ("beamercolorbox" "o" "\\begin{beamercolorbox}%o{%h}" "\\end{beamercolorbox}"))
   "Environments triggered by properties in Beamer export.
 These are the defaults - for user definitions, see
diff --git a/lisp/org/ox-latex.el b/lisp/org/ox-latex.el
index 2dce7bc29bf..a656e065b94 100644
--- a/lisp/org/ox-latex.el
+++ b/lisp/org/ox-latex.el
@@ -2180,19 +2180,16 @@ contextual information."
 			 (nth (1- level) '("i" "ii" "iii" "iv"))
 			 (1- count)))))
 	 (checkbox (cl-case (org-element-property :checkbox item)
-		     (on "$\\boxtimes$ ")
-		     (off "$\\square$ ")
-		     (trans "$\\boxminus$ ")))
+		     (on "$\\boxtimes$")
+		     (off "$\\square$")
+		     (trans "$\\boxminus$")))
 	 (tag (let ((tag (org-element-property :tag item)))
-		;; Check-boxes must belong to the tag.
-		(and tag (format "[{%s}] "
-				 (concat checkbox
-					 (org-export-data tag info)))))))
+		(and tag (org-export-data tag info)))))
     (concat counter
 	    "\\item"
 	    (cond
-	     (tag)
-	     (checkbox (concat " " checkbox))
+	     ((and checkbox tag) (format "[{%s %s}] " checkbox tag))
+	     ((or checkbox tag) (format "[{%s}] " (or checkbox tag)))
 	     ;; Without a tag or a check-box, if CONTENTS starts with
 	     ;; an opening square bracket, add "\relax" to "\item",
 	     ;; unless the brackets comes from an initial export
diff --git a/lisp/org/ox-md.el b/lisp/org/ox-md.el
index a90a29ff029..c4da8fcb145 100644
--- a/lisp/org/ox-md.el
+++ b/lisp/org/ox-md.el
@@ -500,14 +500,15 @@ TEXT is the string to transcode.  INFO is a plist holding
 contextual information."
   (when (plist-get info :with-smart-quotes)
     (setq text (org-export-activate-smart-quotes text :html info)))
+  ;; The below series of replacements in `text' is order sensitive.
+  ;; Protect `, *, _, and \
+  (setq text (replace-regexp-in-string "[`*_\\]" "\\\\\\&" text))
   ;; Protect ambiguous #.  This will protect # at the beginning of
   ;; a line, but not at the beginning of a paragraph.  See
   ;; `org-md-paragraph'.
   (setq text (replace-regexp-in-string "\n#" "\n\\\\#" text))
   ;; Protect ambiguous !
   (setq text (replace-regexp-in-string "\\(!\\)\\[" "\\\\!" text nil nil 1))
-  ;; Protect `, *, _ and \
-  (setq text (replace-regexp-in-string "[`*_\\]" "\\\\\\&" text))
   ;; Handle special strings, if required.
   (when (plist-get info :with-special-strings)
     (setq text (org-html-convert-special-strings text)))
diff --git a/lisp/org/ox-odt.el b/lisp/org/ox-odt.el
index a7f8e045161..e0c51662d10 100644
--- a/lisp/org/ox-odt.el
+++ b/lisp/org/ox-odt.el
@@ -721,16 +721,17 @@ nil            Ignore math snippets.
                imagemagick to convert pdf files to png files.
 `mathjax'      Do MathJax preprocessing and arrange for MathJax.js to
                be loaded.
-t              Synonym for `mathjax'."
+
+Any other symbol is a synonym for `mathjax'."
   :group 'org-export-odt
   :version "24.4"
   :package-version '(Org . "8.0")
   :type '(choice
 	  (const :tag "Do not process math in any way" nil)
+	  (const :tag "Leave math verbatim" verbatim)
 	  (const :tag "Use dvipng to make images" dvipng)
 	  (const :tag "Use imagemagick to make images" imagemagick)
-	  (const :tag "Use MathJax to display math" mathjax)
-	  (const :tag "Leave math verbatim" verbatim)))
+	  (other :tag "Use MathJax to display math" mathjax)))
 
 
 ;;;; Links
diff --git a/lisp/org/ox-publish.el b/lisp/org/ox-publish.el
index 15c9e942b7f..5deb7c54e71 100644
--- a/lisp/org/ox-publish.el
+++ b/lisp/org/ox-publish.el
@@ -57,10 +57,10 @@ Every function in this hook will be called with two arguments:
 the name of the original file and the name of the file
 produced.")
 
-(defgroup org-publish nil
+(defgroup org-export-publish nil
   "Options for publishing a set of files."
   :tag "Org Publishing"
-  :group 'org)
+  :group 'org-export)
 
 (defcustom org-publish-project-alist nil
   "Association list to control publishing behavior.
diff --git a/lisp/org/ox.el b/lisp/org/ox.el
index 1b52f3968f7..7bdac4f290d 100644
--- a/lisp/org/ox.el
+++ b/lisp/org/ox.el
@@ -3699,7 +3699,9 @@ the communication channel used for export, as a plist."
 		    :translate-alist all-transcoders
 		    :exported-data (make-hash-table :test #'eq :size 401)))))
 	;; `:internal-references' are shared across back-ends.
-	(prog1 (funcall transcoder data contents new-info)
+	(prog1 (if (eq type 'plain-text)
+		   (funcall transcoder data new-info)
+		 (funcall transcoder data contents new-info))
 	  (plist-put info :internal-references
 		     (plist-get new-info :internal-references)))))))