Browse Source

Merge branch 'master' of orgmode.org:org-mode

Bastien Guerry 14 years ago
parent
commit
02ee22345d

+ 1 - 0
Makefile

@@ -503,6 +503,7 @@ lisp/org-publish.elc:
 lisp/org-protocol.elc:	lisp/org.el
 lisp/org-protocol.elc:	lisp/org.el
 lisp/org-remember.elc:	lisp/org.el
 lisp/org-remember.elc:	lisp/org.el
 lisp/org-rmail.elc:	lisp/org.el
 lisp/org-rmail.elc:	lisp/org.el
+lisp/org-special-blocks.elc:	lisp/org-compat.el
 lisp/org-src.elc:	lisp/org-macs.el lisp/org-compat.el
 lisp/org-src.elc:	lisp/org-macs.el lisp/org-compat.el
 lisp/org-table.elc:	lisp/org.el
 lisp/org-table.elc:	lisp/org.el
 lisp/org-taskjuggler.elc: lisp/org.el lisp/org-exp.el
 lisp/org-taskjuggler.elc: lisp/org.el lisp/org-exp.el

+ 2 - 0
lisp/ob-calc.el

@@ -29,6 +29,7 @@
 ;;; Code:
 ;;; Code:
 (require 'ob)
 (require 'ob)
 (require 'calc)
 (require 'calc)
+(require 'calc-store)
 (unless (featurep 'xemacs) (require 'calc-trail))
 (unless (featurep 'xemacs) (require 'calc-trail))
 (eval-when-compile (require 'ob-comint))
 (eval-when-compile (require 'ob-comint))
 
 
@@ -83,6 +84,7 @@
     (with-current-buffer (get-buffer "*Calculator*")
     (with-current-buffer (get-buffer "*Calculator*")
       (calc-eval (calc-top 1)))))
       (calc-eval (calc-top 1)))))
 
 
+(defvar var-syms) ; Dynamically scoped from org-babel-execute:calc
 (defun ob-calc-maybe-resolve-var (el)
 (defun ob-calc-maybe-resolve-var (el)
   (if (consp el)
   (if (consp el)
       (if (and (equal 'var (car el)) (member (cadr el) var-syms))
       (if (and (equal 'var (car el)) (member (cadr el) var-syms))

+ 2 - 1
lisp/ob-exp.el

@@ -248,7 +248,8 @@ This function is called by `org-babel-exp-do-export'.  The code
 block will be evaluated.  Optional argument SILENT can be used to
 block will be evaluated.  Optional argument SILENT can be used to
 inhibit insertion of results into the buffer."
 inhibit insertion of results into the buffer."
   (when (and org-export-babel-evaluate
   (when (and org-export-babel-evaluate
-	     (not (equal hash (org-babel-result-hash))))
+	     (not (equal hash (org-babel-exp-in-export-file
+			       (org-babel-result-hash)))))
     (let ((lang (nth 0 info))
     (let ((lang (nth 0 info))
 	  (body (nth 1 info)))
 	  (body (nth 1 info)))
       (setf (nth 2 info) (org-babel-exp-in-export-file
       (setf (nth 2 info) (org-babel-exp-in-export-file

+ 1 - 0
lisp/ob-python.el

@@ -130,6 +130,7 @@ Emacs-lisp table, otherwise return the results as a string."
   "Return the buffer associated with SESSION."
   "Return the buffer associated with SESSION."
   (cdr (assoc session org-babel-python-buffers)))
   (cdr (assoc session org-babel-python-buffers)))
 
 
+(defvar py-default-interpreter)
 (defun org-babel-python-initiate-session-by-key (&optional session)
 (defun org-babel-python-initiate-session-by-key (&optional session)
   "Initiate a python session.
   "Initiate a python session.
 If there is not a current inferior-process-buffer in SESSION
 If there is not a current inferior-process-buffer in SESSION

+ 1 - 0
lisp/ob-ref.el

@@ -57,6 +57,7 @@
 (declare-function org-at-table-p "org" (&optional table-type))
 (declare-function org-at-table-p "org" (&optional table-type))
 (declare-function org-count "org" (CL-ITEM CL-SEQ))
 (declare-function org-count "org" (CL-ITEM CL-SEQ))
 (declare-function org-in-item-p "org-list" ())
 (declare-function org-in-item-p "org-list" ())
+(declare-function org-at-item-p "org-list" ())
 
 
 (defvar org-babel-ref-split-regexp
 (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]*")
   "[ \f\t\n\r\v]*\\(.+?\\)[ \f\t\n\r\v]*=[ \f\t\n\r\v]*\\(.+\\)[ \f\t\n\r\v]*")

+ 2 - 1
lisp/ob-table.el

@@ -97,7 +97,8 @@ example above."
 	   variables)))
 	   variables)))
     (unless (stringp source-block)
     (unless (stringp source-block)
       (setq source-block (symbol-name source-block)))
       (setq source-block (symbol-name source-block)))
-    (org-babel-trim
+    ((lambda (result)
+       (org-babel-trim (if (stringp result) result (format "%S" result))))
      (if (and source-block (> (length source-block) 0))
      (if (and source-block (> (length source-block) 0))
          (let ((params
          (let ((params
                 (eval `(org-babel-parse-header-arguments
                 (eval `(org-babel-parse-header-arguments

+ 14 - 11
lisp/ob.el

@@ -35,6 +35,7 @@
 (require 'org-macs)
 (require 'org-macs)
 
 
 (defvar org-babel-call-process-region-original)
 (defvar org-babel-call-process-region-original)
+(defvar org-src-lang-modes)
 (declare-function show-all "outline" ())
 (declare-function show-all "outline" ())
 (declare-function tramp-compat-make-temp-file "tramp-compat"
 (declare-function tramp-compat-make-temp-file "tramp-compat"
                   (filename &optional dir-flag))
                   (filename &optional dir-flag))
@@ -74,6 +75,7 @@
 (declare-function org-babel-lob-execute-maybe "ob-lob" ())
 (declare-function org-babel-lob-execute-maybe "ob-lob" ())
 (declare-function org-number-sequence "org-compat" (from &optional to inc))
 (declare-function org-number-sequence "org-compat" (from &optional to inc))
 (declare-function org-in-item-p "org-list" ())
 (declare-function org-in-item-p "org-list" ())
+(declare-function org-at-item-p "org-list" ())
 (declare-function org-list-parse-list "org-list" (&optional delete))
 (declare-function org-list-parse-list "org-list" (&optional delete))
 (declare-function org-list-to-generic "org-list" (LIST PARAMS))
 (declare-function org-list-to-generic "org-list" (LIST PARAMS))
 (declare-function org-list-struct "org-list" ())
 (declare-function org-list-struct "org-list" ())
@@ -1393,12 +1395,13 @@ following the source block."
   "Read the table at `point' into emacs-lisp."
   "Read the table at `point' into emacs-lisp."
   (mapcar (lambda (row)
   (mapcar (lambda (row)
             (if (and (symbolp row) (equal row 'hline)) row
             (if (and (symbolp row) (equal row 'hline)) row
-              (mapcar #'org-babel-read row)))
+              (mapcar (lambda (el) (org-babel-read el 'inhibit-lisp-eval)) row)))
           (org-table-to-lisp)))
           (org-table-to-lisp)))
 
 
 (defun org-babel-read-list ()
 (defun org-babel-read-list ()
   "Read the list at `point' into emacs-lisp."
   "Read the list at `point' into emacs-lisp."
-  (mapcar #'org-babel-read (mapcar #'cadr (cdr (org-list-parse-list)))))
+  (mapcar (lambda (el) (org-babel-read el 'inhibit-lisp-eval))
+	  (mapcar #'cadr (cdr (org-list-parse-list)))))
 
 
 (defvar org-link-types-re)
 (defvar org-link-types-re)
 (defun org-babel-read-link ()
 (defun org-babel-read-link ()
@@ -1908,18 +1911,18 @@ block but are passed literally to the \"example-block\"."
 	     (apply #'string (reverse out)))))
 	     (apply #'string (reverse out)))))
        str))))
        str))))
 
 
-(defun org-babel-read (cell)
+(defun org-babel-read (cell &optional inhibit-lisp-eval)
   "Convert the string value of CELL to a number if appropriate.
   "Convert the string value of CELL to a number if appropriate.
-Otherwise if cell looks like lisp (meaning it starts with a
-\"(\" or a \"'\") then read it as lisp, otherwise return it
-unmodified as a string.
-
-This is taken almost directly from `org-read-prop'."
+Otherwise if cell looks like lisp (meaning it starts with a \"(\"
+or a \"'\") then read it as lisp, otherwise return it unmodified
+as a string.  Optional argument NO-LISP-EVAL inhibits lisp
+evaluation for situations in which is it not appropriate."
   (if (and (stringp cell) (not (equal cell "")))
   (if (and (stringp cell) (not (equal cell "")))
       (or (org-babel-number-p cell)
       (or (org-babel-number-p cell)
-          (if (or (equal "(" (substring cell 0 1))
-                  (equal "'" (substring cell 0 1))
-                  (equal "`" (substring cell 0 1)))
+          (if (and (not inhibit-lisp-eval)
+		   (or (equal "(" (substring cell 0 1))
+		       (equal "'" (substring cell 0 1))
+		       (equal "`" (substring cell 0 1))))
               (eval (read cell))
               (eval (read cell))
             (progn (set-text-properties 0 (length cell) nil cell) cell)))
             (progn (set-text-properties 0 (length cell) nil cell) cell)))
     cell))
     cell))

+ 3 - 9
lisp/org-agenda.el

@@ -4307,7 +4307,7 @@ of what a project is and how to check if it stuck, customize the variable
 
 
 (defvar org-disable-agenda-to-diary nil)          ;Dynamically-scoped param.
 (defvar org-disable-agenda-to-diary nil)          ;Dynamically-scoped param.
 (defvar list-diary-entries-hook)
 (defvar list-diary-entries-hook)
-
+(defvar diary-time-regexp)
 (defun org-get-entries-from-diary (date)
 (defun org-get-entries-from-diary (date)
   "Get the (Emacs Calendar) diary entries for DATE."
   "Get the (Emacs Calendar) diary entries for DATE."
   (require 'diary-lib)
   (require 'diary-lib)
@@ -4695,7 +4695,7 @@ This function is invoked if `org-agenda-todo-ignore-deadlines',
 	   "\\|\\(<%%\\(([^>\n]+)\\)>\\)"))
 	   "\\|\\(<%%\\(([^>\n]+)\\)>\\)"))
 	 marker hdmarker deadlinep scheduledp clockp closedp inactivep
 	 marker hdmarker deadlinep scheduledp clockp closedp inactivep
 	 donep tmp priority category ee txt timestr tags b0 b3 e3 head
 	 donep tmp priority category ee txt timestr tags b0 b3 e3 head
-	 todo-state end-of-match)
+	 todo-state end-of-match show-all)
     (goto-char (point-min))
     (goto-char (point-min))
     (while (setq end-of-match (re-search-forward regexp nil t))
     (while (setq end-of-match (re-search-forward regexp nil t))
       (setq b0 (match-beginning 0)
       (setq b0 (match-beginning 0)
@@ -5051,7 +5051,7 @@ FRACTION is what fraction of the head-warning time has passed."
 			      (cons (marker-position mm) a)))
 			      (cons (marker-position mm) a)))
 		  deadline-results))
 		  deadline-results))
 	 d2 diff pos pos1 category tags donep
 	 d2 diff pos pos1 category tags donep
-	 ee txt head pastschedp todo-state face timestr s habitp)
+	 ee txt head pastschedp todo-state face timestr s habitp show-all)
     (goto-char (point-min))
     (goto-char (point-min))
     (while (re-search-forward regexp nil t)
     (while (re-search-forward regexp nil t)
       (catch :skip
       (catch :skip
@@ -5473,12 +5473,6 @@ The modified list may contain inherited tags, and tags matched by
 	  (append new list)
 	  (append new list)
 	(append list new)))))
 	(append list new)))))
 
 
-(defun org-eval (form)
-  "Eval FORM and return result."
-  (condition-case error
-      (eval form)
-    (error (format "%%![Error: %s]" error))))
-
 (defun org-compile-prefix-format (key)
 (defun org-compile-prefix-format (key)
   "Compile the prefix format into a Lisp form that can be evaluated.
   "Compile the prefix format into a Lisp form that can be evaluated.
 The resulting form is returned and stored in the variable
 The resulting form is returned and stored in the variable

+ 1 - 1
lisp/org-archive.el

@@ -211,7 +211,7 @@ this heading."
 		 (current-time)))
 		 (current-time)))
 	  category todo priority ltags itags atags
 	  category todo priority ltags itags atags
           ;; end of variables that will be used for saving context
           ;; end of variables that will be used for saving context
-	  location afile heading buffer level newfile-p visiting)
+	  location afile heading buffer level newfile-p infile-p visiting)
 
 
       ;; Find the local archive location
       ;; Find the local archive location
       (setq location (org-get-local-archive-location)
       (setq location (org-get-local-archive-location)

+ 1 - 1
lisp/org-capture.el

@@ -1054,7 +1054,7 @@ Point will remain at the first line after the inserted text."
     (setq beg (point))
     (setq beg (point))
     (cond
     (cond
      ((and (eq type 'entry) (org-mode-p))
      ((and (eq type 'entry) (org-mode-p))
-      (org-capture-verify-tree txt)
+      (org-capture-verify-tree (org-capture-get :template))
       (org-paste-subtree nil template t))
       (org-paste-subtree nil template t))
      ((and (memq type '(item checkitem))
      ((and (memq type '(item checkitem))
 	   (org-mode-p)
 	   (org-mode-p)

+ 2 - 0
lisp/org-exp-blocks.el

@@ -76,6 +76,8 @@
   (require 'cl))
   (require 'cl))
 (require 'org)
 (require 'org)
 
 
+(defvar backend) ; dynamically scoped from caller
+
 (defvar org-exp-blocks-block-regexp
 (defvar org-exp-blocks-block-regexp
   (concat
   (concat
    "^\\([ \t]*\\)#\\+begin_\\(\\S-+\\)"
    "^\\([ \t]*\\)#\\+begin_\\(\\S-+\\)"

+ 1 - 1
lisp/org-latex.el

@@ -1817,7 +1817,7 @@ The conversion is made depending of STRING-BEFORE and STRING-AFTER."
              (org-table-last-column-widths (copy-sequence
              (org-table-last-column-widths (copy-sequence
                                             org-table-last-column-widths))
                                             org-table-last-column-widths))
              fnum fields line lines olines gr colgropen line-fmt align
              fnum fields line lines olines gr colgropen line-fmt align
-             caption shortn label attr floatp placement
+             caption width shortn label attr floatp placement
 	     longtblp tblenv tabular-env)
 	     longtblp tblenv tabular-env)
         (if org-export-latex-tables-verbatim
         (if org-export-latex-tables-verbatim
             (let* ((tbl (concat "\\begin{verbatim}\n" raw-table
             (let* ((tbl (concat "\\begin{verbatim}\n" raw-table

+ 72 - 87
lisp/org-list.el

@@ -476,8 +476,8 @@ This checks `org-list-ending-method'."
   "Is point in a line starting a hand-formatted item?"
   "Is point in a line starting a hand-formatted item?"
   (save-excursion
   (save-excursion
     (beginning-of-line)
     (beginning-of-line)
-    (and (not (eq (nth 2 (org-list-context)) 'invalid))
-	 (looking-at (org-item-re)))))
+    (and (looking-at (org-item-re))
+	 (not (eq (nth 2 (org-list-context)) 'invalid)))))
 
 
 (defun org-at-item-bullet-p ()
 (defun org-at-item-bullet-p ()
   "Is point at the bullet of a plain list item?"
   "Is point at the bullet of a plain list item?"
@@ -514,89 +514,75 @@ Context will be a cell like (MIN MAX CONTEXT) where MIN and MAX
 are boundaries and CONTEXT is a symbol among `drawer', `block',
 are boundaries and CONTEXT is a symbol among `drawer', `block',
 `invalid', `inlinetask' and nil.
 `invalid', `inlinetask' and nil.
 
 
-Contexts `block' and `invalid' refer to
-`org-list-forbidden-blocks'."
+Contexts `block' and `invalid' refer to `org-list-forbidden-blocks'."
   (save-match-data
   (save-match-data
-    (save-excursion
-      (beginning-of-line)
-      (let* ((outline-regexp (org-get-limited-outline-regexp))
-	     ;; Can't use org-drawers-regexp as this function might be
-	     ;; called in buffers not in Org mode
-	     (drawers-re (concat "^[ \t]*:\\("
-				 (mapconcat 'regexp-quote org-drawers "\\|")
-				 "\\):[ \t]*$"))
-	     (case-fold-search t)
-	     ;; Compute position of surrounding headings. This is the
-	     ;; default context.
-	     (heading
-	      (save-excursion
-		(list
-		 (or (and (org-at-heading-p) (point-at-bol))
-		     (outline-previous-heading)
-		     (point-min))
-		 (or (outline-next-heading)
-		     (point-max))
-		 nil)))
-	     (prev-head (car heading))
-	     (next-head (nth 1 heading))
-	     ;; Is point inside a drawer?
-	     (drawerp
-	      (when (and (org-in-regexps-block-p
-			  drawers-re "^[ \t]*:END:" prev-head)
-			 (save-excursion
-			   (beginning-of-line)
-			   (and (not (looking-at drawers-re))
-				(not (looking-at "^[ \t]*:END:")))))
-		(save-excursion
-		  (list
-		   (progn
-		     (re-search-backward drawers-re prev-head t)
-		     (1+ (point-at-eol)))
-		   (if (re-search-forward "^[ \t]*:END:" next-head t)
-		       (1- (point-at-bol))
-		     next-head)
-		   'drawer))))
-	     ;; Is point strictly in a block, and of which type?
-	     (blockp
-	      (save-excursion
-		(when (and (org-in-regexps-block-p
-			    "^[ \t]*#\\+begin_" "^[ \t]*#\\+end_" prev-head)
-			   (save-excursion
-			     (beginning-of-line)
-			     (not (looking-at
-				   "^[ \t]*#\\+\\(begin\\|end\\)_"))))
-		  (list
-		   (progn
-		     (re-search-backward
-		      "^[ \t]*#\\+begin_\\(\\S-+\\)" prev-head t)
-		     (1+ (point-at-eol)))
-		   (save-match-data
-		     (if (re-search-forward "^[ \t]*#\\+end_" next-head t)
-			 (1- (point-at-bol))
-		       next-head))
-		   (if (member (downcase (match-string 1))
-			       org-list-forbidden-blocks)
-		       'invalid
-		     'block)))))
-	     ;; Is point in an inlinetask?
-	     (inlinetaskp
-	      (when (and (featurep 'org-inlinetask)
-			 (org-inlinetask-in-task-p)
-			 (not (looking-at "^\\*+")))
-		(save-excursion
-		  (list
-		   (progn (org-inlinetask-goto-beginning)
-			  (1+ (point-at-eol)))
-		   (progn
-		     (org-inlinetask-goto-end)
-		     (forward-line -1)
-		     (1- (point-at-bol)))
-		   'inlinetask))))
-	     ;; List actual candidates
-	     (context-list
-	      (delq nil (list heading drawerp blockp inlinetaskp))))
-	;; Return the closest context around
-	(assq (apply 'max (mapcar 'car context-list)) context-list)))))
+    (org-with-limited-levels
+     (beginning-of-line)
+     (let* ((case-fold-search t) (pos (point)) beg end
+	    ;; Compute position of surrounding headings. This is the
+	    ;; default context.
+	    (heading
+	     (save-excursion
+	       (list (or (and (org-at-heading-p) (point-at-bol))
+			 (outline-previous-heading)
+			 (point-min))
+		     (or (outline-next-heading) (point-max))
+		     nil)))
+	    (prev-head (car heading))
+	    (next-head (nth 1 heading))
+	    ;; Is point inside a drawer?
+	    (drawerp
+	     (save-excursion
+	       (let ((end-re "^[ \t]*:END:")
+		     ;; Can't use org-drawers-regexp as this function
+		     ;; might be called in buffers not in Org mode
+		     (drawers-re (concat "^[ \t]*:\\("
+					 (mapconcat 'regexp-quote org-drawers "\\|")
+				"\\):[ \t]*$")))
+		 (and (not (looking-at drawers-re))
+		      (not (looking-at end-re))
+		      (setq beg (and (re-search-backward drawers-re prev-head t)
+				     (1+ (point-at-eol))))
+		      (setq end (or (and (re-search-forward end-re next-head t)
+					 (1- (match-beginning 0)))
+				    next-head))
+		      (>= end pos)
+		      (list beg end 'drawer)))))
+	    ;; Is point strictly in a block, and of which type?
+	    (blockp
+	     (save-excursion
+	       (let ((block-re "^[ \t]*#\\+\\(begin\\|end\\)_") type)
+		 (and (not (looking-at block-re))
+		      (setq beg (and (re-search-backward block-re prev-head t)
+				     (1+ (point-at-eol))))
+		      (looking-at "^[ \t]*#\\+begin_\\(\\S-+\\)")
+		      (setq type (downcase (match-string 1)))
+		      (goto-char beg)
+		      (setq end (or (and (re-search-forward block-re next-head t)
+					 (1- (point-at-bol)))
+				    next-head))
+		      (>= end pos)
+		      (equal (downcase (match-string 1)) "end")
+		      (list beg end (if (member type org-list-forbidden-blocks)
+					'invalid 'block))))))
+	    ;; Is point in an inlinetask?
+	    (inlinetaskp
+	     (when (featurep 'org-inlinetask)
+	       (save-excursion
+		 (let* ((stars-re (org-inlinetask-outline-regexp))
+			(end-re (concat stars-re "END[ \t]*$")))
+		   (and (not (looking-at "^\\*+"))
+			(setq beg (and (re-search-backward stars-re prev-head t)
+				       (1+ (point-at-eol))))
+			(not (looking-at end-re))
+			(setq end (and (re-search-forward end-re next-head t)
+				       (1- (match-beginning 0))))
+			(> (point) pos)
+			(list beg end 'inlinetask))))))
+	    ;; List actual candidates
+	    (context-list (delq nil (list heading drawerp blockp inlinetaskp))))
+       ;; Return the closest context around
+       (assq (apply 'max (mapcar 'car context-list)) context-list)))))
 
 
 (defun org-list-struct ()
 (defun org-list-struct ()
   "Return structure of list at point.
   "Return structure of list at point.
@@ -1197,8 +1183,7 @@ This function modifies STRUCT."
       ;; 4. Insert effectively item into buffer
       ;; 4. Insert effectively item into buffer
       (goto-char item)
       (goto-char item)
       (org-indent-to-column ind)
       (org-indent-to-column ind)
-      (insert body)
-      (insert item-sep)
+      (insert body item-sep)
       ;; 5. Add new item to STRUCT.
       ;; 5. Add new item to STRUCT.
       (mapc (lambda (e)
       (mapc (lambda (e)
       	      (let ((p (car e))
       	      (let ((p (car e))
@@ -1238,7 +1223,7 @@ This function modifies STRUCT."
 		 ;; SIZE-OFFSET.
 		 ;; SIZE-OFFSET.
 		 (t (setcar e (+ p size-offset))
 		 (t (setcar e (+ p size-offset))
 		    (setcar (nthcdr 6 e) (+ end size-offset))))))
 		    (setcar (nthcdr 6 e) (+ end size-offset))))))
-      	    struct)
+	    struct)
       (push (list item ind bullet nil box nil (+ item item-size)) struct)
       (push (list item ind bullet nil box nil (+ item item-size)) struct)
       (setq struct (sort struct (lambda (e1 e2) (< (car e1) (car e2)))))
       (setq struct (sort struct (lambda (e1 e2) (< (car e1) (car e2)))))
       ;; 6. If not BEFOREP, new item must appear after ITEM, so
       ;; 6. If not BEFOREP, new item must appear after ITEM, so

+ 2 - 0
lisp/org-special-blocks.el

@@ -40,6 +40,8 @@
 ;; user to add this class to his or her stylesheet if this div is to
 ;; user to add this class to his or her stylesheet if this div is to
 ;; mean anything.
 ;; mean anything.
 
 
+(require 'org-compat)
+
 (defvar org-special-blocks-ignore-regexp "^\\(LaTeX\\|HTML\\)$"
 (defvar org-special-blocks-ignore-regexp "^\\(LaTeX\\|HTML\\)$"
   "A regexp indicating the names of blocks that should be ignored
   "A regexp indicating the names of blocks that should be ignored
 by org-special-blocks.  These blocks will presumably be
 by org-special-blocks.  These blocks will presumably be

+ 1 - 1
lisp/org-table.el

@@ -3715,7 +3715,7 @@ to execute outside of tables."
 If it is a table to be sent away to a receiver, do it.
 If it is a table to be sent away to a receiver, do it.
 With prefix arg, also recompute table."
 With prefix arg, also recompute table."
   (interactive "P")
   (interactive "P")
-  (let ((pos (point)) action consts-str consts cst)
+  (let ((pos (point)) action consts-str consts cst const-str)
     (save-excursion
     (save-excursion
       (beginning-of-line 1)
       (beginning-of-line 1)
       (setq action (cond
       (setq action (cond

+ 6 - 0
lisp/org.el

@@ -18201,6 +18201,12 @@ With prefix arg UNCOMPILED, load the uncompiled versions."
       (display-buffer buf)
       (display-buffer buf)
       (sit-for 0))))
       (sit-for 0))))
 
 
+(defun org-eval (form)
+  "Eval FORM and return result."
+  (condition-case error
+      (eval form)
+    (error (format "%%![Error: %s]" error))))
+
 (defun org-in-commented-line ()
 (defun org-in-commented-line ()
   "Is point in a line starting with `#'?"
   "Is point in a line starting with `#'?"
   (equal (char-after (point-at-bol)) ?#))
   (equal (char-after (point-at-bol)) ?#))