Sync Org 7.9.2 from the commit tagged "release_7.9.2" in Org's Git repo.

1 files changed, 106 insertions, 105 deletions

diff --git a/lisp/org/ob-ref.el b/lisp/org/ob-ref.el
index 08cb4e3a25f..79861f1b78a 100644
--- a/lisp/org/ob-ref.el
+++ b/lisp/org/ob-ref.el
@@ -120,89 +120,89 @@ the variable."
 (defun org-babel-ref-resolve (ref)
   "Resolve the reference REF and return its value."
   (save-window-excursion
-  (save-excursion
-    (let ((case-fold-search t)
-          type args new-refere new-header-args new-referent result
-	  lob-info split-file split-ref index index-row index-col id)
-      ;; if ref is indexed grab the indices -- beware nested indices
-      (when (and (string-match "\\[\\([^\\[]+\\)\\]$" ref)
-		 (let ((str (substring ref 0 (match-beginning 0))))
-		   (= (org-count ?( str) (org-count ?) str))))
-        (setq index (match-string 1 ref))
-        (setq ref (substring ref 0 (match-beginning 0))))
-      ;; assign any arguments to pass to source block
-      (when (string-match
-	     "^\\(.+?\\)\\(\\[\\(.*\\)\\]\\|\\(\\)\\)\(\\(.*\\)\)$" ref)
-        (setq new-refere      (match-string 1 ref))
-	(setq new-header-args (match-string 3 ref))
-        (setq new-referent    (match-string 5 ref))
-        (when (> (length new-refere) 0)
-          (when (> (length new-referent) 0)
-	    (setq args (mapcar (lambda (ref) (cons :var ref))
-			       (org-babel-ref-split-args new-referent))))
-	  (when (> (length new-header-args) 0)
-	    (setq args (append (org-babel-parse-header-arguments
-				new-header-args) args)))
-          (setq ref new-refere)))
-      (when (string-match "^\\(.+\\):\\(.+\\)$" ref)
-        (setq split-file (match-string 1 ref))
-        (setq split-ref (match-string 2 ref))
-        (find-file split-file) (setq ref split-ref))
-      (save-restriction
-	(widen)
-	(goto-char (point-min))
-	(if (let ((src-rx (org-babel-named-src-block-regexp-for-name ref))
-		  (res-rx (org-babel-named-data-regexp-for-name ref)))
-	      ;; goto ref in the current buffer
-	      (or
-	       ;; check for code blocks
-	       (re-search-forward src-rx nil t)
-	       ;; check for named data
-	       (re-search-forward res-rx nil t)
-	       ;; check for local or global headlines by id
-	       (setq id (org-babel-ref-goto-headline-id ref))
-	       ;; check the Library of Babel
-	       (setq lob-info (cdr (assoc (intern ref)
-					  org-babel-library-of-babel)))))
-	    (unless (or lob-info id) (goto-char (match-beginning 0)))
-	  ;; ;; TODO: allow searching for names in other buffers
-	  ;; (setq id-loc (org-id-find ref 'marker)
-	  ;;       buffer (marker-buffer id-loc)
-	  ;;       loc (marker-position id-loc))
-	  ;; (move-marker id-loc nil)
-	  (error "reference '%s' not found in this buffer" ref))
-	(cond
-	 (lob-info (setq type 'lob))
-	 (id (setq type 'id))
-	 ((and (looking-at org-babel-src-name-regexp)
-	       (save-excursion
-		 (forward-line 1)
-		 (or (looking-at org-babel-src-block-regexp)
-		     (looking-at org-babel-multi-line-header-regexp))))
-	  (setq type 'source-block))
-	 (t (while (not (setq type (org-babel-ref-at-ref-p)))
-	      (forward-line 1)
-	      (beginning-of-line)
-	      (if (or (= (point) (point-min)) (= (point) (point-max)))
-		  (error "reference not found")))))
-	(let ((params (append args '((:results . "silent")))))
-	  (setq result
-		(case type
-		  (results-line (org-babel-read-result))
-		  (table        (org-babel-read-table))
-		  (list         (org-babel-read-list))
-		  (file         (org-babel-read-link))
-		  (source-block (org-babel-execute-src-block
-				 nil nil (if org-babel-update-intermediate
-					     nil params)))
-		  (lob          (org-babel-execute-src-block
-				 nil lob-info params))
-		  (id           (org-babel-ref-headline-body)))))
-	(if (symbolp result)
-	    (format "%S" result)
-	  (if (and index (listp result))
-	      (org-babel-ref-index-list index result)
-	    result)))))))
+    (save-excursion
+      (let ((case-fold-search t)
+	    type args new-refere new-header-args new-referent result
+	    lob-info split-file split-ref index index-row index-col id)
+	;; if ref is indexed grab the indices -- beware nested indices
+	(when (and (string-match "\\[\\([^\\[]+\\)\\]$" ref)
+		   (let ((str (substring ref 0 (match-beginning 0))))
+		     (= (org-count ?( str) (org-count ?) str))))
+	  (setq index (match-string 1 ref))
+	  (setq ref (substring ref 0 (match-beginning 0))))
+	;; assign any arguments to pass to source block
+	(when (string-match
+	       "^\\(.+?\\)\\(\\[\\(.*\\)\\]\\|\\(\\)\\)\(\\(.*\\)\)$" ref)
+	  (setq new-refere      (match-string 1 ref))
+	  (setq new-header-args (match-string 3 ref))
+	  (setq new-referent    (match-string 5 ref))
+	  (when (> (length new-refere) 0)
+	    (when (> (length new-referent) 0)
+	      (setq args (mapcar (lambda (ref) (cons :var ref))
+				 (org-babel-ref-split-args new-referent))))
+	    (when (> (length new-header-args) 0)
+	      (setq args (append (org-babel-parse-header-arguments
+				  new-header-args) args)))
+	    (setq ref new-refere)))
+	(when (string-match "^\\(.+\\):\\(.+\\)$" ref)
+	  (setq split-file (match-string 1 ref))
+	  (setq split-ref (match-string 2 ref))
+	  (find-file split-file) (setq ref split-ref))
+	(save-restriction
+	  (widen)
+	  (goto-char (point-min))
+	  (if (let ((src-rx (org-babel-named-src-block-regexp-for-name ref))
+		    (res-rx (org-babel-named-data-regexp-for-name ref)))
+		;; goto ref in the current buffer
+		(or
+		 ;; check for code blocks
+		 (re-search-forward src-rx nil t)
+		 ;; check for named data
+		 (re-search-forward res-rx nil t)
+		 ;; check for local or global headlines by id
+		 (setq id (org-babel-ref-goto-headline-id ref))
+		 ;; check the Library of Babel
+		 (setq lob-info (cdr (assoc (intern ref)
+					    org-babel-library-of-babel)))))
+	      (unless (or lob-info id) (goto-char (match-beginning 0)))
+	    ;; ;; TODO: allow searching for names in other buffers
+	    ;; (setq id-loc (org-id-find ref 'marker)
+	    ;;       buffer (marker-buffer id-loc)
+	    ;;       loc (marker-position id-loc))
+	    ;; (move-marker id-loc nil)
+	    (error "Reference '%s' not found in this buffer" ref))
+	  (cond
+	   (lob-info (setq type 'lob))
+	   (id (setq type 'id))
+	   ((and (looking-at org-babel-src-name-regexp)
+		 (save-excursion
+		   (forward-line 1)
+		   (or (looking-at org-babel-src-block-regexp)
+		       (looking-at org-babel-multi-line-header-regexp))))
+	    (setq type 'source-block))
+	   (t (while (not (setq type (org-babel-ref-at-ref-p)))
+		(forward-line 1)
+		(beginning-of-line)
+		(if (or (= (point) (point-min)) (= (point) (point-max)))
+		    (error "Reference not found")))))
+	  (let ((params (append args '((:results . "silent")))))
+	    (setq result
+		  (case type
+		    (results-line (org-babel-read-result))
+		    (table        (org-babel-read-table))
+		    (list         (org-babel-read-list))
+		    (file         (org-babel-read-link))
+		    (source-block (org-babel-execute-src-block
+				   nil nil (if org-babel-update-intermediate
+					       nil params)))
+		    (lob          (org-babel-execute-src-block
+				   nil lob-info params))
+		    (id           (org-babel-ref-headline-body)))))
+	  (if (symbolp result)
+	      (format "%S" result)
+	    (if (and index (listp result))
+		(org-babel-ref-index-list index result)
+	      result)))))))
 
 (defun org-babel-ref-index-list (index lis)
   "Return the subset of LIS indexed by INDEX.
@@ -218,28 +218,29 @@ returned, or an empty string or \"*\" both of which are
 interpreted to mean the entire range and as such are equivalent
 to \"0:-1\"."
   (if (and (> (length index) 0) (string-match "^\\([^,]*\\),?" index))
-      (let ((ind-re "\\(\\([-[:digit:]]+\\):\\([-[:digit:]]+\\)\\|\*\\)")
-	    (length (length lis))
-            (portion (match-string 1 index))
-            (remainder (substring index (match-end 0))))
-        (flet ((wrap (num) (if (< num 0) (+ length num) num))
-               (open (ls) (if (and (listp ls) (= (length ls) 1)) (car ls) ls)))
-          (open
-           (mapcar
-            (lambda (sub-lis)
-	      (if (listp sub-lis)
-		  (org-babel-ref-index-list remainder sub-lis)
-		sub-lis))
-            (if (or (= 0 (length portion)) (string-match ind-re portion))
-                (mapcar
-		 (lambda (n) (nth n lis))
-		 (apply 'org-number-sequence
-			(if (and (> (length portion) 0) (match-string 2 portion))
-			    (list
-			     (wrap (string-to-number (match-string 2 portion)))
-			     (wrap (string-to-number (match-string 3 portion))))
-			  (list (wrap 0) (wrap -1)))))
-              (list (nth (wrap (string-to-number portion)) lis)))))))
+      (let* ((ind-re "\\(\\([-[:digit:]]+\\):\\([-[:digit:]]+\\)\\|\*\\)")
+	     (lgth (length lis))
+	     (portion (match-string 1 index))
+	     (remainder (substring index (match-end 0)))
+	     (wrap (lambda (num) (if (< num 0) (+ lgth num) num)))
+	     (open (lambda (ls) (if (and (listp ls) (= (length ls) 1)) (car ls) ls))))
+	(funcall
+	 open
+	 (mapcar
+	  (lambda (sub-lis)
+	    (if (listp sub-lis)
+		(org-babel-ref-index-list remainder sub-lis)
+	      sub-lis))
+	  (if (or (= 0 (length portion)) (string-match ind-re portion))
+	      (mapcar
+	       (lambda (n) (nth n lis))
+	       (apply 'org-number-sequence
+		      (if (and (> (length portion) 0) (match-string 2 portion))
+			  (list
+			   (funcall wrap (string-to-number (match-string 2 portion)))
+			   (funcall wrap (string-to-number (match-string 3 portion))))
+			(list (funcall wrap 0) (funcall wrap -1)))))
+	    (list (nth (funcall wrap (string-to-number portion)) lis))))))
     lis))
 
 (defun org-babel-ref-split-args (arg-string)