2009-05-24 21:10:03 +00:00
|
|
|
;;; org-babel.el --- facilitating communication between programming languages and people
|
2009-02-22 21:19:32 +00:00
|
|
|
|
2009-06-12 23:55:42 +00:00
|
|
|
;; Copyright (C) 2009 Eric Schulte, Dan Davison
|
2009-02-22 21:19:32 +00:00
|
|
|
|
2009-06-12 23:55:42 +00:00
|
|
|
;; Author: Eric Schulte, Dan Davison
|
2009-02-22 21:19:32 +00:00
|
|
|
;; Keywords: literate programming, reproducible research
|
|
|
|
;; Homepage: http://orgmode.org
|
|
|
|
;; Version: 0.01
|
|
|
|
|
|
|
|
;;; 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; see the file COPYING. If not, write to the
|
|
|
|
;; Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
|
|
|
|
;; Boston, MA 02110-1301, USA.
|
|
|
|
|
|
|
|
;;; Commentary:
|
|
|
|
|
2009-06-02 23:26:57 +00:00
|
|
|
;; See org-babel.org in the parent directory for more information
|
2009-02-22 21:19:32 +00:00
|
|
|
|
|
|
|
;;; Code:
|
|
|
|
(require 'org)
|
|
|
|
|
2009-05-24 20:38:01 +00:00
|
|
|
(defun org-babel-execute-src-block-maybe ()
|
|
|
|
"Detect if this is context for a org-babel src-block and if so
|
|
|
|
then run `org-babel-execute-src-block'."
|
2009-05-22 23:23:52 +00:00
|
|
|
(interactive)
|
2009-05-24 20:38:01 +00:00
|
|
|
(let ((info (org-babel-get-src-block-info)))
|
|
|
|
(if info (progn (org-babel-execute-src-block current-prefix-arg info) t) nil)))
|
2009-02-22 21:19:32 +00:00
|
|
|
|
2009-05-24 20:38:01 +00:00
|
|
|
(add-hook 'org-ctrl-c-ctrl-c-hook 'org-babel-execute-src-block-maybe)
|
2009-02-22 21:19:32 +00:00
|
|
|
|
2009-06-14 18:08:12 +00:00
|
|
|
(defun org-babel-pop-to-session-maybe ()
|
|
|
|
"Detect if this is context for a org-babel src-block and if so
|
|
|
|
then run `org-babel-pop-to-session'."
|
|
|
|
(interactive)
|
|
|
|
(let ((info (org-babel-get-src-block-info)))
|
|
|
|
(if info (progn (org-babel-pop-to-session current-prefix-arg info) t) nil)))
|
|
|
|
|
|
|
|
(add-hook 'org-metadown-hook 'org-babel-pop-to-session-maybe)
|
|
|
|
|
2009-07-07 23:48:19 +00:00
|
|
|
(defvar org-babel-default-header-args '((:session . "none") (:results . "replace"))
|
2009-05-23 16:05:53 +00:00
|
|
|
"Default arguments to use when evaluating a source block.")
|
|
|
|
|
2009-07-18 04:08:02 +00:00
|
|
|
(defvar org-babel-default-inline-header-args '((:results . "silent") (:exports . "code"))
|
2009-04-26 18:42:36 +00:00
|
|
|
"Default arguments to use when evaluating an inline source block.")
|
|
|
|
|
2009-05-24 20:38:01 +00:00
|
|
|
(defvar org-babel-src-block-regexp nil
|
|
|
|
"Regexp used to test when inside of a org-babel src-block")
|
2009-02-22 21:19:32 +00:00
|
|
|
|
2009-05-24 20:38:01 +00:00
|
|
|
(defvar org-babel-inline-src-block-regexp nil
|
|
|
|
"Regexp used to test when on an inline org-babel src-block")
|
2009-04-26 18:42:36 +00:00
|
|
|
|
2009-07-18 19:52:51 +00:00
|
|
|
(defvar org-babel-min-lines-for-block-output 10
|
2009-07-18 19:38:21 +00:00
|
|
|
"If number of lines of output is equal to or exceeds this
|
|
|
|
value, the output is placed in a
|
|
|
|
#+begin_example...#+end_example block. Otherwise the output is
|
|
|
|
marked as literal by inserting colons at the starts of the
|
|
|
|
lines. This variable only takes effect if the :results output
|
|
|
|
option is in effect.")
|
|
|
|
|
2009-06-13 22:46:26 +00:00
|
|
|
(defun org-babel-named-src-block-regexp-for-name (name)
|
|
|
|
"Regexp used to match named src block."
|
|
|
|
(concat "#\\+srcname:[ \t]*" (regexp-quote name) "[ \t\n]*"
|
|
|
|
org-babel-src-block-regexp))
|
|
|
|
|
2009-05-24 20:38:01 +00:00
|
|
|
(defun org-babel-set-interpreters (var value)
|
2009-02-22 21:19:32 +00:00
|
|
|
(set-default var value)
|
2009-05-24 20:38:01 +00:00
|
|
|
(setq org-babel-src-block-regexp
|
2009-02-22 21:19:32 +00:00
|
|
|
(concat "#\\+begin_src \\("
|
|
|
|
(mapconcat 'regexp-quote value "\\|")
|
2009-05-14 13:39:20 +00:00
|
|
|
"\\)[ \t]*"
|
2009-02-22 21:19:32 +00:00
|
|
|
"\\([ \t]+\\([^\n]+\\)\\)?\n" ;; match header arguments
|
2009-04-26 18:42:36 +00:00
|
|
|
"\\([^\000]+?\\)#\\+end_src"))
|
2009-05-24 20:38:01 +00:00
|
|
|
(setq org-babel-inline-src-block-regexp
|
2009-04-26 18:42:36 +00:00
|
|
|
(concat "src_\\("
|
|
|
|
(mapconcat 'regexp-quote value "\\|")
|
|
|
|
"\\)"
|
2009-05-10 15:29:30 +00:00
|
|
|
"\\(\\|\\[\\(.*\\)\\]\\)"
|
2009-04-26 18:42:36 +00:00
|
|
|
"{\\([^\n]+\\)}")))
|
2009-02-22 21:19:32 +00:00
|
|
|
|
2009-05-24 20:38:01 +00:00
|
|
|
(defun org-babel-add-interpreter (interpreter)
|
|
|
|
"Add INTERPRETER to `org-babel-interpreters' and update
|
|
|
|
`org-babel-src-block-regexp' appropriately."
|
|
|
|
(unless (member interpreter org-babel-interpreters)
|
|
|
|
(setq org-babel-interpreters (cons interpreter org-babel-interpreters))
|
2009-06-11 22:04:10 +00:00
|
|
|
;; (add-to-list 'org-babel-session-defaults (cons interpreter (format "org-babel-%s" interpreter)))
|
2009-05-24 20:38:01 +00:00
|
|
|
(org-babel-set-interpreters 'org-babel-interpreters org-babel-interpreters)))
|
2009-02-24 00:07:07 +00:00
|
|
|
|
2009-05-24 20:38:01 +00:00
|
|
|
(defcustom org-babel-interpreters '()
|
2009-02-22 21:19:32 +00:00
|
|
|
"Interpreters allows for evaluation tags.
|
|
|
|
This is a list of program names (as strings) that can evaluate code and
|
2009-02-23 06:19:34 +00:00
|
|
|
insert the output into an Org-mode buffer. Valid choices are
|
2009-02-22 21:19:32 +00:00
|
|
|
|
|
|
|
R Evaluate R code
|
|
|
|
emacs-lisp Evaluate Emacs Lisp code and display the result
|
|
|
|
sh Pass command to the shell and display the result
|
|
|
|
perl The perl interpreter
|
|
|
|
python The python interpreter
|
2009-02-24 00:07:07 +00:00
|
|
|
ruby The ruby interpreter
|
|
|
|
|
2009-05-24 20:38:01 +00:00
|
|
|
The source block regexp `org-babel-src-block-regexp' is updated
|
2009-02-24 00:07:07 +00:00
|
|
|
when a new interpreter is added to this list through the
|
|
|
|
customize interface. To add interpreters to this variable from
|
2009-05-24 20:38:01 +00:00
|
|
|
lisp code use the `org-babel-add-interpreter' function."
|
|
|
|
:group 'org-babel
|
|
|
|
:set 'org-babel-set-interpreters
|
2009-02-22 21:19:32 +00:00
|
|
|
:type '(set :greedy t
|
|
|
|
(const "R")
|
|
|
|
(const "emacs-lisp")
|
|
|
|
(const "sh")
|
|
|
|
(const "perl")
|
|
|
|
(const "python")
|
2009-07-05 17:53:52 +00:00
|
|
|
(const "ruby")))
|
2009-02-22 21:19:32 +00:00
|
|
|
|
|
|
|
;;; functions
|
2009-06-14 18:08:12 +00:00
|
|
|
(defun org-babel-pop-to-session (&optional arg info)
|
|
|
|
"Pop to the session of the current source-code block. If
|
|
|
|
called with a prefix argument then evaluate the header arguments
|
|
|
|
for the source block before entering the session. Copy the body
|
|
|
|
of the source block to the kill ring."
|
|
|
|
(interactive)
|
|
|
|
(let* ((info (or info (org-babel-get-src-block-info)))
|
|
|
|
(lang (first info))
|
|
|
|
(body (second info))
|
|
|
|
(params (third info))
|
|
|
|
(session (cdr (assoc :session params))))
|
|
|
|
(unless (member lang org-babel-interpreters)
|
|
|
|
(error "Language is not in `org-babel-interpreters': %s" lang))
|
|
|
|
;; copy body to the kill ring
|
2009-06-14 18:10:09 +00:00
|
|
|
(with-temp-buffer (insert (org-babel-trim body)) (copy-region-as-kill (point-min) (point-max)))
|
2009-06-14 18:08:12 +00:00
|
|
|
;; if called with a prefix argument, then process header arguments
|
|
|
|
(if arg (funcall (intern (concat "org-babel-prep-session:" lang)) session params))
|
|
|
|
;; just to the session using pop-to-buffer
|
2009-06-14 18:34:06 +00:00
|
|
|
(pop-to-buffer (funcall (intern (format "org-babel-%s-initiate-session" lang)) session))
|
|
|
|
(move-end-of-line 1)))
|
2009-06-14 18:08:12 +00:00
|
|
|
|
2009-05-24 20:38:01 +00:00
|
|
|
(defun org-babel-execute-src-block (&optional arg info params)
|
2009-02-22 21:19:32 +00:00
|
|
|
"Execute the current source code block, and dump the results
|
|
|
|
into the buffer immediately following the block. Results are
|
2009-03-17 21:44:50 +00:00
|
|
|
commented by `org-toggle-fixed-width-section'. With optional
|
2009-04-03 00:58:04 +00:00
|
|
|
prefix don't dump results into buffer but rather return the
|
|
|
|
results in raw elisp (this is useful for automated execution of a
|
2009-04-26 18:42:36 +00:00
|
|
|
source block).
|
|
|
|
|
|
|
|
Optionally supply a value for INFO in the form returned by
|
2009-05-24 20:38:01 +00:00
|
|
|
`org-babel-get-src-block-info'.
|
2009-05-09 16:34:55 +00:00
|
|
|
|
|
|
|
Optionally supply a value for PARAMS which will be merged with
|
2009-05-10 21:03:26 +00:00
|
|
|
the header arguments specified at the source code block."
|
2009-05-21 14:22:24 +00:00
|
|
|
(interactive)
|
2009-07-23 01:02:12 +00:00
|
|
|
(message "supplied params=%S" params)
|
2009-05-24 20:38:01 +00:00
|
|
|
(let* ((info (or info (org-babel-get-src-block-info)))
|
2009-02-22 21:19:32 +00:00
|
|
|
(lang (first info))
|
|
|
|
(body (second info))
|
2009-07-10 05:35:15 +00:00
|
|
|
(params (org-babel-merge-params
|
|
|
|
(third info) (org-babel-get-src-block-function-args) params))
|
2009-07-16 20:21:07 +00:00
|
|
|
(processed-params (org-babel-process-params params))
|
|
|
|
(result-params (third processed-params))
|
|
|
|
(result-type (fourth processed-params))
|
2009-05-24 20:38:01 +00:00
|
|
|
(cmd (intern (concat "org-babel-execute:" lang)))
|
2009-02-22 21:19:32 +00:00
|
|
|
result)
|
2009-07-23 01:02:12 +00:00
|
|
|
(message "params=%S" params) ;; debugging statement
|
2009-05-24 20:38:01 +00:00
|
|
|
(unless (member lang org-babel-interpreters)
|
|
|
|
(error "Language is not in `org-babel-interpreters': %s" lang))
|
2009-07-06 01:57:42 +00:00
|
|
|
(when arg (setq result-params (cons "silent" result-params)))
|
2009-07-17 18:37:43 +00:00
|
|
|
(setq result (multiple-value-bind (session vars result-params result-type) processed-params
|
|
|
|
(funcall cmd body params)))
|
|
|
|
(if (eq result-type 'value)
|
2009-07-18 19:39:00 +00:00
|
|
|
(setq result (org-babel-process-value-result result result-params)))
|
2009-07-06 01:57:42 +00:00
|
|
|
(org-babel-insert-result result result-params)
|
|
|
|
(case result-type (output nil) (value result))))
|
2009-07-16 20:21:07 +00:00
|
|
|
|
2009-07-18 19:39:00 +00:00
|
|
|
(defun org-babel-process-value-result (result result-params)
|
2009-07-17 18:37:43 +00:00
|
|
|
"Process returned value for insertion in buffer.
|
2009-07-06 01:37:00 +00:00
|
|
|
|
2009-07-17 18:37:43 +00:00
|
|
|
Currently, this function forces to table output if :results
|
|
|
|
vector has been supplied.
|
2009-07-06 01:37:00 +00:00
|
|
|
|
2009-07-17 18:37:43 +00:00
|
|
|
You can see below the various fragments of results-processing
|
|
|
|
code that were present in the language-specific files. Out of
|
|
|
|
those fragments, I've moved the org-babel-python-table-or-results
|
|
|
|
and org-babel-import-elisp-from-file functionality into the
|
|
|
|
org-babel-*-evaluate functions. I think those should only be used
|
|
|
|
in the :results value case, as in the 'output case we are not
|
|
|
|
concerned with creating elisp versions of results. "
|
2009-07-06 01:37:00 +00:00
|
|
|
|
2009-07-17 18:37:43 +00:00
|
|
|
(if (and (member "vector" result-params) (not (listp result)))
|
|
|
|
(list (list result))
|
2009-07-23 01:02:12 +00:00
|
|
|
result))
|
2009-02-22 21:19:32 +00:00
|
|
|
|
2009-07-16 18:57:01 +00:00
|
|
|
(defun org-babel-execute-buffer (&optional arg)
|
2009-02-23 23:14:48 +00:00
|
|
|
"Replace EVAL snippets in the entire buffer."
|
|
|
|
(interactive "P")
|
|
|
|
(save-excursion
|
|
|
|
(goto-char (point-min))
|
2009-07-16 18:57:01 +00:00
|
|
|
(while (re-search-forward org-babel-src-block-regexp nil t)
|
|
|
|
(goto-char (match-beginning 0))
|
|
|
|
(org-babel-execute-src-block arg)
|
|
|
|
(goto-char (match-end 0)))))
|
2009-02-23 23:14:48 +00:00
|
|
|
|
2009-07-16 18:57:01 +00:00
|
|
|
(defun org-babel-execute-subtree (&optional arg)
|
2009-02-22 21:19:32 +00:00
|
|
|
"Replace EVAL snippets in the entire subtree."
|
|
|
|
(interactive "P")
|
|
|
|
(save-excursion
|
|
|
|
(org-narrow-to-subtree)
|
2009-07-16 18:57:01 +00:00
|
|
|
(org-babel-execute-buffer)
|
2009-02-22 21:19:32 +00:00
|
|
|
(widen)))
|
|
|
|
|
2009-05-24 20:38:01 +00:00
|
|
|
(defun org-babel-get-src-block-name ()
|
Enabling LoB to put results in buffer, and slowly moving towards more
unified concept of function calls.
Previously LoB calls were not able to produce results in the
buffer. These changes go some way to allowing them to do that. [There
are still some bugs to deal with]. That meant changing org-babel.el so
that there is a notion of the `source block name' for a LoB line, in
order to construct a #+resname (currently I've made the name the same
as the function call).
I'm also slowly moving towards unifying the notion of `function calls'
a bit more: I've changed the org-babel-lob-one-liner-regexp so that
instead of a monolithic match it now matches first the function name,
and second the function arguments in
parentheses. org-babel-lob-get-info makes that match, and although it
still concatenates them and returns the string, the two elements can
be accessed immediately afterwards using match-string. So that
situation is very similar to org-babel-get-src-block-name, whose
job (in this branch) is also to parse the function *name* and the
function *arguments*. In a few places in the code (esp. function
names), I think the word `info' should be replaced with `call' or
`function call', which I believe more accurately indicates what the
`info' is: a function definition, together with bound
arguments/references.
The function call syntax, i.e. function-name(arg1=ref1), originally
introduced for references (and thereby in LoB), and which I'm
proposing we use throughout, raises the question of default arguments,
and those being over-ridden by supplied arguments, as in e.g. python,
and R.
2009-07-11 02:59:10 +00:00
|
|
|
"Return the name of the current source block if one exists.
|
|
|
|
|
|
|
|
This function is analogous to org-babel-lob-get-info. For both
|
|
|
|
functions, after they are called, (match-string 1) matches the
|
|
|
|
function name, and (match-string 2) matches the function
|
|
|
|
arguments inside the parentheses. I think perhaps these functions
|
|
|
|
should be renamed to bring out this similarity, perhaps involving
|
|
|
|
the word 'call'."
|
2009-07-10 22:38:12 +00:00
|
|
|
(let ((case-fold-search t)
|
|
|
|
(head (org-babel-where-is-src-block-head)))
|
Enabling LoB to put results in buffer, and slowly moving towards more
unified concept of function calls.
Previously LoB calls were not able to produce results in the
buffer. These changes go some way to allowing them to do that. [There
are still some bugs to deal with]. That meant changing org-babel.el so
that there is a notion of the `source block name' for a LoB line, in
order to construct a #+resname (currently I've made the name the same
as the function call).
I'm also slowly moving towards unifying the notion of `function calls'
a bit more: I've changed the org-babel-lob-one-liner-regexp so that
instead of a monolithic match it now matches first the function name,
and second the function arguments in
parentheses. org-babel-lob-get-info makes that match, and although it
still concatenates them and returns the string, the two elements can
be accessed immediately afterwards using match-string. So that
situation is very similar to org-babel-get-src-block-name, whose
job (in this branch) is also to parse the function *name* and the
function *arguments*. In a few places in the code (esp. function
names), I think the word `info' should be replaced with `call' or
`function call', which I believe more accurately indicates what the
`info' is: a function definition, together with bound
arguments/references.
The function call syntax, i.e. function-name(arg1=ref1), originally
introduced for references (and thereby in LoB), and which I'm
proposing we use throughout, raises the question of default arguments,
and those being over-ridden by supplied arguments, as in e.g. python,
and R.
2009-07-11 02:59:10 +00:00
|
|
|
(if head
|
|
|
|
(save-excursion
|
|
|
|
(goto-char head)
|
|
|
|
(if (save-excursion
|
|
|
|
(forward-line -1)
|
2009-07-19 18:29:10 +00:00
|
|
|
(looking-at "#\\+srcname:[ \f\t\n\r\v]*\\([^ ()\f\t\n\r\v]+\\)\(\\(.*\\)\)"))
|
2009-07-11 07:04:41 +00:00
|
|
|
(org-babel-clean-text-properties (match-string 1)))))))
|
2009-05-21 01:36:28 +00:00
|
|
|
|
2009-05-24 20:38:01 +00:00
|
|
|
(defun org-babel-get-src-block-info ()
|
2009-04-26 18:42:36 +00:00
|
|
|
"Return the information of the current source block as a list
|
|
|
|
of the following form. (language body header-arguments-alist)"
|
2009-05-21 01:36:28 +00:00
|
|
|
(let ((case-fold-search t) head)
|
2009-05-24 20:38:01 +00:00
|
|
|
(if (setq head (org-babel-where-is-src-block-head))
|
|
|
|
(save-excursion (goto-char head) (org-babel-parse-src-block-match))
|
2009-04-26 18:42:36 +00:00
|
|
|
(if (save-excursion ;; inline source block
|
|
|
|
(re-search-backward "[ \f\t\n\r\v]" nil t)
|
|
|
|
(forward-char 1)
|
2009-05-24 20:38:01 +00:00
|
|
|
(looking-at org-babel-inline-src-block-regexp))
|
|
|
|
(org-babel-parse-inline-src-block-match)
|
2009-04-26 18:42:36 +00:00
|
|
|
nil)))) ;; indicate that no source block was found
|
2009-02-23 06:19:34 +00:00
|
|
|
|
2009-07-10 05:35:15 +00:00
|
|
|
(defun org-babel-get-src-block-function-args ()
|
|
|
|
(when (org-babel-get-src-block-name)
|
|
|
|
(mapcar (lambda (ref) (cons :var ref))
|
2009-07-24 03:11:17 +00:00
|
|
|
(org-babel-ref-split-args (match-string 2)))))
|
2009-07-10 05:35:15 +00:00
|
|
|
|
2009-06-14 21:10:04 +00:00
|
|
|
(defmacro org-babel-map-source-blocks (file &rest body)
|
|
|
|
"Evaluate BODY forms on each source-block in FILE."
|
|
|
|
(declare (indent 1))
|
|
|
|
`(save-window-excursion
|
|
|
|
(find-file ,file) (goto-char (point-min))
|
|
|
|
(while (re-search-forward org-babel-src-block-regexp nil t)
|
|
|
|
(goto-char (match-beginning 0))
|
|
|
|
(save-match-data ,@body)
|
|
|
|
(goto-char (match-end 0)))))
|
2009-06-14 05:08:27 +00:00
|
|
|
|
2009-05-24 20:38:01 +00:00
|
|
|
(defun org-babel-parse-src-block-match ()
|
2009-07-17 00:52:31 +00:00
|
|
|
(let* ((lang (org-babel-clean-text-properties (match-string 1)))
|
|
|
|
(lang-headers (intern (concat "org-babel-default-header-args:" lang))))
|
2009-07-17 04:50:02 +00:00
|
|
|
(list lang
|
2009-07-17 14:49:26 +00:00
|
|
|
(org-babel-strip-protective-commas (org-babel-clean-text-properties (match-string 4)))
|
2009-07-17 04:50:02 +00:00
|
|
|
(org-babel-merge-params
|
|
|
|
org-babel-default-header-args
|
|
|
|
(if (boundp lang-headers) (eval lang-headers) nil)
|
|
|
|
(org-babel-parse-header-arguments (org-babel-clean-text-properties (or (match-string 3) "")))))))
|
2009-04-26 20:29:59 +00:00
|
|
|
|
2009-05-24 20:38:01 +00:00
|
|
|
(defun org-babel-parse-inline-src-block-match ()
|
2009-07-17 00:52:31 +00:00
|
|
|
(let* ((lang (org-babel-clean-text-properties (match-string 1)))
|
|
|
|
(lang-headers (intern (concat "org-babel-default-header-args:" lang))))
|
|
|
|
(list lang
|
2009-07-17 14:49:26 +00:00
|
|
|
(org-babel-strip-protective-commas (org-babel-clean-text-properties (match-string 4)))
|
2009-07-18 03:36:47 +00:00
|
|
|
(org-babel-merge-params
|
2009-07-17 00:52:31 +00:00
|
|
|
org-babel-default-inline-header-args
|
|
|
|
(if (boundp lang-headers) (eval lang-headers) nil)
|
|
|
|
(org-babel-parse-header-arguments (org-babel-clean-text-properties (or (match-string 3) "")))))))
|
2009-04-26 20:29:59 +00:00
|
|
|
|
2009-05-24 20:38:01 +00:00
|
|
|
(defun org-babel-parse-header-arguments (arg-string)
|
2009-02-23 06:19:34 +00:00
|
|
|
"Parse a string of header arguments returning an alist."
|
2009-07-11 07:01:54 +00:00
|
|
|
(if (> (length arg-string) 0)
|
|
|
|
(delq nil
|
|
|
|
(mapcar
|
|
|
|
(lambda (arg)
|
|
|
|
(if (string-match "\\([^ \f\t\n\r\v]+\\)[ \f\t\n\r\v]+\\([^ \f\t\n\r\v]+.*\\)" arg)
|
|
|
|
(cons (intern (concat ":" (match-string 1 arg)))
|
|
|
|
(org-babel-chomp (match-string 2 arg)))
|
|
|
|
(cons (intern (concat ":" arg)) nil)))
|
|
|
|
(split-string (concat " " arg-string) "[ \f\t\n\r\v]+:" t)))))
|
2009-02-23 06:19:34 +00:00
|
|
|
|
2009-07-16 20:21:07 +00:00
|
|
|
(defun org-babel-process-params (params)
|
|
|
|
"Parse params and resolve references.
|
|
|
|
|
|
|
|
Return a list (session vars result-params result-type). These are
|
|
|
|
made available to the org-babel-execute:LANG functions via
|
|
|
|
multiple-value-bind."
|
|
|
|
(let* ((session (cdr (assoc :session params)))
|
|
|
|
(vars (org-babel-ref-variables params))
|
|
|
|
(result-params (split-string (or (cdr (assoc :results params)) "")))
|
|
|
|
(result-type (cond ((member "output" result-params) 'output)
|
|
|
|
((member "value" result-params) 'value)
|
|
|
|
(t 'value))))
|
|
|
|
(list session vars result-params result-type)))
|
|
|
|
|
2009-05-24 20:38:01 +00:00
|
|
|
(defun org-babel-where-is-src-block-head ()
|
2009-05-21 13:40:04 +00:00
|
|
|
"Return the point at the beginning of the current source
|
|
|
|
block. Specifically at the beginning of the #+BEGIN_SRC line.
|
|
|
|
If the point is not on a source block then return nil."
|
|
|
|
(let ((initial (point)) top bottom)
|
|
|
|
(or
|
|
|
|
(save-excursion ;; on a #+srcname: line
|
|
|
|
(beginning-of-line 1)
|
|
|
|
(and (looking-at "#\\+srcname") (forward-line 1)
|
2009-05-24 20:38:01 +00:00
|
|
|
(looking-at org-babel-src-block-regexp)
|
2009-05-21 13:40:04 +00:00
|
|
|
(point)))
|
|
|
|
(save-excursion ;; on a #+begin_src line
|
|
|
|
(beginning-of-line 1)
|
2009-05-24 20:38:01 +00:00
|
|
|
(and (looking-at org-babel-src-block-regexp)
|
2009-05-21 13:40:04 +00:00
|
|
|
(point)))
|
|
|
|
(save-excursion ;; inside a src block
|
|
|
|
(and
|
|
|
|
(re-search-backward "#\\+begin_src" nil t) (setq top (point))
|
|
|
|
(re-search-forward "#\\+end_src" nil t) (setq bottom (point))
|
|
|
|
(< top initial) (< initial bottom)
|
2009-05-24 20:38:01 +00:00
|
|
|
(goto-char top) (looking-at org-babel-src-block-regexp)
|
2009-05-21 13:40:04 +00:00
|
|
|
(point))))))
|
|
|
|
|
2009-06-15 05:06:11 +00:00
|
|
|
(defun org-babel-goto-named-source-block (&optional name)
|
|
|
|
"Go to a named source-code block."
|
|
|
|
(interactive "ssource-block name: ")
|
2009-06-15 19:43:15 +00:00
|
|
|
(let ((point (org-babel-find-named-block name)))
|
2009-06-15 05:06:11 +00:00
|
|
|
(if point
|
|
|
|
;; taken from `org-open-at-point'
|
2009-06-15 19:43:15 +00:00
|
|
|
(progn (goto-char point) (org-show-context))
|
2009-06-15 05:06:11 +00:00
|
|
|
(message "source-code block '%s' not found in this buffer" name))))
|
|
|
|
|
2009-06-13 22:43:24 +00:00
|
|
|
(defun org-babel-find-named-block (name)
|
|
|
|
"Find a named source-code block.
|
|
|
|
Return the location of the source block identified by
|
|
|
|
#+srcname 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)
|
2009-06-14 02:48:44 +00:00
|
|
|
(regexp (org-babel-named-src-block-regexp-for-name name)) msg)
|
2009-06-15 05:06:11 +00:00
|
|
|
(goto-char (point-min))
|
|
|
|
(when (or (re-search-forward regexp nil t)
|
|
|
|
(re-search-backward regexp nil t))
|
|
|
|
(match-beginning 0)))))
|
2009-06-13 22:43:24 +00:00
|
|
|
|
2009-05-24 20:38:01 +00:00
|
|
|
(defun org-babel-find-named-result (name)
|
2009-05-21 13:40:04 +00:00
|
|
|
"Return the location of the result named NAME in the current
|
|
|
|
buffer or nil if no such result exists."
|
|
|
|
(save-excursion
|
|
|
|
(goto-char (point-min))
|
2009-07-19 18:29:10 +00:00
|
|
|
(when (re-search-forward ;; ellow end-of-buffer in following regexp?
|
|
|
|
(concat "#\\+resname:[ \t]*" (regexp-quote name) "[ \t\n\f\v\r]") nil t)
|
2009-05-21 13:40:04 +00:00
|
|
|
(move-beginning-of-line 1) (point))))
|
|
|
|
|
2009-05-24 20:38:01 +00:00
|
|
|
(defun org-babel-where-is-src-block-result ()
|
2009-05-21 13:40:04 +00:00
|
|
|
"Return the point at the beginning of the result of the current
|
|
|
|
source block. Specifically at the beginning of the #+RESNAME:
|
|
|
|
line. If no result exists for this block then create a
|
|
|
|
#+RESNAME: line following the source block."
|
|
|
|
(save-excursion
|
2009-07-11 17:39:05 +00:00
|
|
|
(let* ((on-lob-line (progn (beginning-of-line 1)
|
|
|
|
(looking-at org-babel-lob-one-liner-regexp)))
|
|
|
|
(name (if on-lob-line (org-babel-lob-get-info) (org-babel-get-src-block-name)))
|
2009-07-17 13:54:11 +00:00
|
|
|
(head (unless on-lob-line (org-babel-where-is-src-block-head))) end)
|
2009-07-17 04:18:03 +00:00
|
|
|
(when head (goto-char head))
|
2009-05-24 20:38:01 +00:00
|
|
|
(or (and name (message name) (org-babel-find-named-result name))
|
Enabling LoB to put results in buffer, and slowly moving towards more
unified concept of function calls.
Previously LoB calls were not able to produce results in the
buffer. These changes go some way to allowing them to do that. [There
are still some bugs to deal with]. That meant changing org-babel.el so
that there is a notion of the `source block name' for a LoB line, in
order to construct a #+resname (currently I've made the name the same
as the function call).
I'm also slowly moving towards unifying the notion of `function calls'
a bit more: I've changed the org-babel-lob-one-liner-regexp so that
instead of a monolithic match it now matches first the function name,
and second the function arguments in
parentheses. org-babel-lob-get-info makes that match, and although it
still concatenates them and returns the string, the two elements can
be accessed immediately afterwards using match-string. So that
situation is very similar to org-babel-get-src-block-name, whose
job (in this branch) is also to parse the function *name* and the
function *arguments*. In a few places in the code (esp. function
names), I think the word `info' should be replaced with `call' or
`function call', which I believe more accurately indicates what the
`info' is: a function definition, together with bound
arguments/references.
The function call syntax, i.e. function-name(arg1=ref1), originally
introduced for references (and thereby in LoB), and which I'm
proposing we use throughout, raises the question of default arguments,
and those being over-ridden by supplied arguments, as in e.g. python,
and R.
2009-07-11 02:59:10 +00:00
|
|
|
(and (or on-lob-line (re-search-forward "#\\+end_src" nil t))
|
2009-05-30 03:34:50 +00:00
|
|
|
(progn (move-end-of-line 1)
|
|
|
|
(if (eobp) (insert "\n") (forward-char 1))
|
|
|
|
(setq end (point))
|
2009-05-21 13:40:04 +00:00
|
|
|
(or (progn ;; either an unnamed #+resname: line already exists
|
|
|
|
(re-search-forward "[^ \f\t\n\r\v]" nil t)
|
|
|
|
(move-beginning-of-line 1) (looking-at "#\\+resname:"))
|
|
|
|
(progn ;; or we need to back up and make one ourselves
|
2009-05-21 14:22:24 +00:00
|
|
|
(goto-char end) (open-line 2) (forward-char 1)
|
2009-05-23 15:11:22 +00:00
|
|
|
(insert (concat "#+resname:" (if name (concat " " name))))
|
|
|
|
(move-beginning-of-line 1) t)))
|
2009-05-21 13:40:04 +00:00
|
|
|
(point))))))
|
|
|
|
|
2009-07-25 02:52:55 +00:00
|
|
|
(defun org-babel-read-result ()
|
|
|
|
"Read the result at `point' into emacs-lisp."
|
|
|
|
(cond
|
|
|
|
((org-at-table-p) (org-babel-read-table))
|
|
|
|
((looking-at ": ")
|
|
|
|
(let ((result-string
|
|
|
|
(org-babel-trim
|
|
|
|
(mapconcat (lambda (line) (if (and (> (length line) 1)
|
|
|
|
(string= ": " (substring line 0 2)))
|
|
|
|
(substring line 2)
|
|
|
|
line))
|
|
|
|
(split-string
|
|
|
|
(buffer-substring (point) (org-babel-result-end)) "[\r\n]+")
|
|
|
|
"\n"))))
|
|
|
|
(or (org-babel-number-p result-string) result-string)))
|
|
|
|
((looking-at "^#\\+RESNAME:")
|
|
|
|
(save-excursion (forward-line 1) (org-babel-read-result)))))
|
|
|
|
|
|
|
|
(defun org-babel-read-table ()
|
|
|
|
"Read the table at `point' into emacs-lisp."
|
|
|
|
(mapcar (lambda (row)
|
|
|
|
(if (and (symbolp row) (equal row 'hline)) row
|
|
|
|
(mapcar #'org-babel-read row)))
|
|
|
|
(org-table-to-lisp)))
|
|
|
|
|
2009-05-24 20:38:01 +00:00
|
|
|
(defun org-babel-insert-result (result &optional insert)
|
2009-02-23 06:19:34 +00:00
|
|
|
"Insert RESULT into the current buffer after the end of the
|
2009-04-01 22:46:55 +00:00
|
|
|
current source block. With optional argument INSERT controls
|
|
|
|
insertion of results in the org-mode file. INSERT can take the
|
|
|
|
following values...
|
|
|
|
|
2009-07-18 04:06:37 +00:00
|
|
|
t ------ the default option, simply insert the results after the
|
2009-04-01 22:46:55 +00:00
|
|
|
source block
|
2009-07-18 04:06:37 +00:00
|
|
|
|
2009-04-01 22:46:55 +00:00
|
|
|
replace - insert results after the source block replacing any
|
|
|
|
previously inserted results
|
|
|
|
|
|
|
|
silent -- no results are inserted"
|
2009-05-22 22:38:51 +00:00
|
|
|
(if (stringp result)
|
|
|
|
(progn
|
2009-05-24 20:38:01 +00:00
|
|
|
(setq result (org-babel-clean-text-properties result))
|
|
|
|
(if (member "file" insert) (setq result (org-babel-result-to-file result))))
|
2009-04-03 22:56:02 +00:00
|
|
|
(unless (listp result) (setq result (format "%S" result))))
|
2009-07-17 17:58:04 +00:00
|
|
|
(if (and insert (member "replace" insert) (not (member "silent" insert)))
|
|
|
|
(org-babel-remove-result))
|
2009-03-29 22:08:53 +00:00
|
|
|
(if (= (length result) 0)
|
2009-07-16 05:16:49 +00:00
|
|
|
(if (member "value" result-params)
|
|
|
|
(message "No result returned by source block")
|
|
|
|
(message "Source block produced no output"))
|
2009-05-22 22:12:51 +00:00
|
|
|
(if (and insert (member "silent" insert))
|
2009-06-12 20:07:56 +00:00
|
|
|
(progn (message (replace-regexp-in-string "%" "%%" (format "%S" result))) result)
|
2009-05-21 14:22:24 +00:00
|
|
|
(when (and (stringp result) ;; ensure results end in a newline
|
2009-04-01 22:46:55 +00:00
|
|
|
(not (or (string-equal (substring result -1) "\n")
|
|
|
|
(string-equal (substring result -1) "\r"))))
|
|
|
|
(setq result (concat result "\n")))
|
|
|
|
(save-excursion
|
2009-07-17 04:18:03 +00:00
|
|
|
(let ((existing-result (org-babel-where-is-src-block-result)))
|
|
|
|
(when existing-result (goto-char existing-result) (forward-line 1)))
|
2009-04-01 22:46:55 +00:00
|
|
|
(if (stringp result) ;; assume the result is a table if it's not a string
|
2009-05-22 22:38:51 +00:00
|
|
|
(if (member "file" insert)
|
|
|
|
(insert result)
|
2009-05-24 20:38:01 +00:00
|
|
|
(org-babel-examplize-region (point) (progn (insert result) (point))))
|
2009-04-01 22:46:55 +00:00
|
|
|
(progn
|
2009-05-22 22:38:51 +00:00
|
|
|
(insert
|
2009-04-01 22:46:55 +00:00
|
|
|
(concat (orgtbl-to-orgtbl
|
|
|
|
(if (consp (car result)) result (list result))
|
|
|
|
'(:fmt (lambda (cell) (format "%S" cell)))) "\n"))
|
|
|
|
(forward-line -1)
|
2009-04-26 20:29:59 +00:00
|
|
|
(org-cycle))))
|
|
|
|
(message "finished"))))
|
2009-03-26 05:02:50 +00:00
|
|
|
|
2009-07-25 02:52:55 +00:00
|
|
|
(defun org-babel-open-src-block-result ()
|
|
|
|
(interactive)
|
|
|
|
"If `point' is on a src block then open the results of the
|
|
|
|
source code block, otherwise return nil."
|
|
|
|
(when (org-babel-get-src-block-info)
|
|
|
|
(save-excursion
|
|
|
|
;; go to the results, if there aren't any then run the block
|
|
|
|
(goto-char (or (org-babel-where-is-src-block-result)
|
|
|
|
(progn (org-babel-execute-src-block)
|
|
|
|
(org-babel-where-is-src-block-result))))
|
|
|
|
;; open the results
|
|
|
|
(if (looking-at org-bracket-link-regexp)
|
|
|
|
;; file
|
|
|
|
(org-open-at-point)
|
|
|
|
;; vector or scalar
|
|
|
|
(let ((results (org-babel-read-result)))
|
|
|
|
(pop-to-buffer (get-buffer-create "org-babel-results"))
|
|
|
|
(delete-region (point-min) (point-max))
|
|
|
|
(if (listp results)
|
|
|
|
(insert (orgtbl-to-tsv results))
|
|
|
|
(insert results)))))))
|
|
|
|
|
2009-05-24 20:38:01 +00:00
|
|
|
(defun org-babel-result-to-org-string (result)
|
2009-04-23 22:48:22 +00:00
|
|
|
"Return RESULT as a string in org-mode format. This function
|
2009-05-24 20:38:01 +00:00
|
|
|
relies on `org-babel-insert-result'."
|
|
|
|
(with-temp-buffer (org-babel-insert-result result) (buffer-string)))
|
2009-04-23 22:48:22 +00:00
|
|
|
|
2009-05-24 20:38:01 +00:00
|
|
|
(defun org-babel-remove-result ()
|
2009-05-21 14:22:24 +00:00
|
|
|
"Remove the result of the current source block."
|
2009-05-30 19:59:46 +00:00
|
|
|
(interactive)
|
2009-02-23 06:19:34 +00:00
|
|
|
(save-excursion
|
2009-05-24 20:38:01 +00:00
|
|
|
(goto-char (org-babel-where-is-src-block-result)) (forward-line 1)
|
2009-06-14 00:07:03 +00:00
|
|
|
(delete-region (point) (org-babel-result-end))))
|
|
|
|
|
|
|
|
(defun org-babel-result-end ()
|
|
|
|
"Return the point at the end of the current set of results"
|
|
|
|
(save-excursion
|
|
|
|
(if (org-at-table-p)
|
|
|
|
(org-table-end)
|
2009-07-18 21:47:30 +00:00
|
|
|
(let ((case-fold-search nil))
|
2009-07-23 15:06:44 +00:00
|
|
|
(if (looking-at "#\\+begin_example")
|
2009-07-18 21:47:30 +00:00
|
|
|
(search-forward "#+end_example" nil t)
|
|
|
|
(progn
|
|
|
|
(while (if (looking-at "\\(: \\|\\[\\[\\)")
|
|
|
|
(progn (while (looking-at "\\(: \\|\\[\\[\\)")
|
|
|
|
(forward-line 1)) t))
|
|
|
|
(forward-line 1))
|
|
|
|
(forward-line -1))))
|
2009-06-14 00:07:03 +00:00
|
|
|
(point))))
|
2009-02-23 06:19:34 +00:00
|
|
|
|
2009-05-24 20:38:01 +00:00
|
|
|
(defun org-babel-result-to-file (result)
|
2009-05-22 22:38:51 +00:00
|
|
|
"Return an `org-mode' link with the path being the value or
|
|
|
|
RESULT, and the display being the `file-name-nondirectory' if
|
|
|
|
non-nil."
|
|
|
|
(let ((name (file-name-nondirectory result)))
|
2009-07-17 00:17:51 +00:00
|
|
|
(concat "[[file:" result (if name (concat "][" name "]]") "]]"))))
|
2009-05-22 22:38:51 +00:00
|
|
|
|
2009-05-24 20:38:01 +00:00
|
|
|
(defun org-babel-examplize-region (beg end)
|
2009-03-25 22:55:56 +00:00
|
|
|
"Comment out region using the ': ' org example quote."
|
|
|
|
(interactive "*r")
|
|
|
|
(let ((size (abs (- (line-number-at-pos end)
|
|
|
|
(line-number-at-pos beg)))))
|
2009-07-18 19:38:21 +00:00
|
|
|
(save-excursion
|
|
|
|
(cond ((= size 0)
|
|
|
|
(error "This should be impossible: a newline was appended to result if missing")
|
|
|
|
(let ((result (buffer-substring beg end)))
|
|
|
|
(delete-region beg end)
|
|
|
|
(insert (concat ": " result))))
|
|
|
|
((< size org-babel-min-lines-for-block-output)
|
|
|
|
(goto-char beg)
|
|
|
|
(dotimes (n size)
|
|
|
|
(move-beginning-of-line 1) (insert ": ") (forward-line 1)))
|
|
|
|
(t
|
|
|
|
(goto-char beg)
|
|
|
|
(insert "#+begin_example\n")
|
|
|
|
(forward-char (- end beg))
|
|
|
|
(insert "#+end_example\n"))))))
|
2009-03-25 22:55:56 +00:00
|
|
|
|
2009-06-15 16:22:36 +00:00
|
|
|
(defun org-babel-merge-params (&rest plists)
|
|
|
|
"Combine all parameter association lists in PLISTS. Later
|
|
|
|
elements of PLISTS override the values of previous element. This
|
2009-07-07 23:44:27 +00:00
|
|
|
takes into account some special considerations for certain
|
|
|
|
parameters when merging lists."
|
2009-07-23 00:30:30 +00:00
|
|
|
(let (params results exports tangle vars var ref)
|
2009-07-18 20:15:43 +00:00
|
|
|
(flet ((e-merge (exclusive-groups &rest result-params)
|
2009-07-18 20:24:02 +00:00
|
|
|
;; maintain exclusivity of mutually exclusive parameters
|
2009-07-18 20:15:43 +00:00
|
|
|
(let (output)
|
|
|
|
(mapc (lambda (new-params)
|
|
|
|
(mapc (lambda (new-param)
|
|
|
|
(mapc (lambda (exclusive-group)
|
|
|
|
(when (member new-param exclusive-group)
|
|
|
|
(mapcar (lambda (excluded-param)
|
|
|
|
(setq output (delete excluded-param output)))
|
|
|
|
exclusive-group)))
|
|
|
|
exclusive-groups)
|
|
|
|
(setq output (org-uniquify (cons new-param output))))
|
|
|
|
new-params))
|
|
|
|
result-params)
|
|
|
|
output)))
|
|
|
|
(mapc (lambda (plist)
|
|
|
|
(mapc (lambda (pair)
|
|
|
|
(case (car pair)
|
|
|
|
(:var
|
|
|
|
;; we want only one specification per variable
|
|
|
|
(when (string-match "^\\([^= \f\t\n\r\v]+\\)[ \t]*=[ \t]*\\([^\f\n\r\v]+\\)$" (cdr pair))
|
|
|
|
;; TODO: When is this not true?
|
|
|
|
(setq var (intern (match-string 1 (cdr pair)))
|
|
|
|
ref (match-string 2 (cdr pair))
|
|
|
|
vars (cons (cons var ref) (assq-delete-all var vars)))))
|
|
|
|
(:results
|
|
|
|
(setq results (e-merge '(("file" "vector" "scalar")
|
2009-07-22 23:17:06 +00:00
|
|
|
("replace" "silent")
|
|
|
|
("output" "value"))
|
2009-07-18 20:15:43 +00:00
|
|
|
results (split-string (cdr pair)))))
|
2009-07-18 20:24:02 +00:00
|
|
|
(:exports
|
|
|
|
(setq exports (e-merge '(("code" "results" "both"))
|
|
|
|
exports (split-string (cdr pair)))))
|
2009-07-23 00:30:30 +00:00
|
|
|
(:tangle
|
|
|
|
(setq tangle (e-merge '(("yes" "no"))
|
|
|
|
tangle (split-string (cdr pair)))))
|
2009-07-18 20:24:02 +00:00
|
|
|
(t ;; replace: this covers e.g. :session
|
|
|
|
(setq params (cons pair (assq-delete-all (car pair) params))))))
|
2009-07-18 20:15:43 +00:00
|
|
|
plist))
|
|
|
|
plists))
|
2009-07-07 23:44:27 +00:00
|
|
|
(setq vars (mapcar (lambda (pair) (format "%s=%s" (car pair) (cdr pair))) vars))
|
|
|
|
(while vars (setq params (cons (cons :var (pop vars)) params)))
|
2009-07-23 00:30:30 +00:00
|
|
|
(cons (cons :tangle (mapconcat 'identity tangle " "))
|
|
|
|
(cons (cons :exports (mapconcat 'identity exports " "))
|
|
|
|
(cons (cons :results (mapconcat 'identity results " "))
|
|
|
|
params)))))
|
2009-06-15 16:22:36 +00:00
|
|
|
|
2009-05-24 20:38:01 +00:00
|
|
|
(defun org-babel-clean-text-properties (text)
|
2009-02-22 21:19:32 +00:00
|
|
|
"Strip all properties from text return."
|
|
|
|
(set-text-properties 0 (length text) nil text) text)
|
|
|
|
|
2009-07-05 17:52:21 +00:00
|
|
|
(defun org-babel-strip-protective-commas (body)
|
|
|
|
"Strip protective commas from bodies of source blocks."
|
2009-06-02 23:26:57 +00:00
|
|
|
(replace-regexp-in-string "^,#" "#" body))
|
|
|
|
|
2009-05-24 20:38:01 +00:00
|
|
|
(defun org-babel-read (cell)
|
2009-05-08 23:20:05 +00:00
|
|
|
"Convert the string value of CELL to a number if appropriate.
|
2009-07-12 02:45:57 +00:00
|
|
|
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.
|
2009-05-08 23:20:05 +00:00
|
|
|
|
|
|
|
This is taken almost directly from `org-read-prop'."
|
|
|
|
(if (and (stringp cell) (not (equal cell "")))
|
2009-06-14 00:07:03 +00:00
|
|
|
(or (org-babel-number-p cell)
|
|
|
|
(if (or (equal "(" (substring cell 0 1))
|
2009-07-12 02:45:57 +00:00
|
|
|
(equal "'" (substring cell 0 1)))
|
2009-06-14 00:07:03 +00:00
|
|
|
(read cell)
|
|
|
|
(progn (set-text-properties 0 (length cell) nil cell) cell)))
|
2009-05-08 23:20:05 +00:00
|
|
|
cell))
|
|
|
|
|
2009-05-24 20:38:01 +00:00
|
|
|
(defun org-babel-number-p (string)
|
2009-05-12 02:41:56 +00:00
|
|
|
"Return t if STRING represents a number"
|
2009-06-14 00:07:03 +00:00
|
|
|
(if (string-match "^[[:digit:]]*\\.?[[:digit:]]*$" string)
|
|
|
|
(string-to-number string)))
|
2009-05-12 02:41:56 +00:00
|
|
|
|
2009-07-19 16:01:00 +00:00
|
|
|
(defun org-babel-import-elisp-from-file (file-name)
|
2009-06-11 22:04:10 +00:00
|
|
|
"Read the results located at FILE-NAME into an elisp table. If
|
|
|
|
the table is trivial, then return it as a scalar."
|
2009-06-12 00:04:42 +00:00
|
|
|
(let (result)
|
|
|
|
(with-temp-buffer
|
|
|
|
(condition-case nil
|
|
|
|
(progn
|
|
|
|
(org-table-import file-name nil)
|
|
|
|
(delete-file file-name)
|
|
|
|
(setq result (mapcar (lambda (row)
|
|
|
|
(mapcar #'org-babel-string-read row))
|
|
|
|
(org-table-to-lisp))))
|
2009-07-19 05:07:07 +00:00
|
|
|
(error nil)))
|
2009-07-19 16:01:00 +00:00
|
|
|
(if (null (cdr result)) ;; if result is trivial vector, then scalarize it
|
|
|
|
(if (consp (car result))
|
|
|
|
(if (null (cdr (car result)))
|
|
|
|
(caar result)
|
|
|
|
result)
|
|
|
|
(car result))
|
|
|
|
result)))
|
2009-06-12 00:04:42 +00:00
|
|
|
|
|
|
|
(defun org-babel-string-read (cell)
|
|
|
|
"Strip nested \"s from around strings in exported R values."
|
|
|
|
(org-babel-read (or (and (stringp cell)
|
|
|
|
(string-match "\\\"\\(.+\\)\\\"" cell)
|
|
|
|
(match-string 1 cell))
|
|
|
|
cell)))
|
2009-06-11 22:04:10 +00:00
|
|
|
|
2009-06-11 21:31:37 +00:00
|
|
|
(defun org-babel-reverse-string (string)
|
|
|
|
(apply 'string (reverse (string-to-list string))))
|
|
|
|
|
2009-05-24 20:38:01 +00:00
|
|
|
(defun org-babel-chomp (string &optional regexp)
|
2009-05-14 13:53:52 +00:00
|
|
|
"Remove any trailing space or carriage returns characters from
|
|
|
|
STRING. Default regexp used is \"[ \f\t\n\r\v]\" but can be
|
|
|
|
overwritten by specifying a regexp as a second argument."
|
2009-06-10 23:17:04 +00:00
|
|
|
(while (and (> (length string) 0) (string-match "[ \f\t\n\r\v]" (substring string -1)))
|
2009-06-09 23:10:43 +00:00
|
|
|
(setq string (substring string 0 -1)))
|
|
|
|
string)
|
2009-05-14 13:53:52 +00:00
|
|
|
|
2009-06-11 21:31:37 +00:00
|
|
|
(defun org-babel-trim (string &optional regexp)
|
|
|
|
"Like `org-babel-chomp' only it runs on both the front and back of the string"
|
|
|
|
(org-babel-chomp (org-babel-reverse-string
|
|
|
|
(org-babel-chomp (org-babel-reverse-string string) regexp)) regexp))
|
|
|
|
|
2009-05-24 20:38:01 +00:00
|
|
|
(provide 'org-babel)
|
|
|
|
;;; org-babel.el ends here
|