add org-mode
authorJoerg Jaspert <joerg@debian.org>
Sun, 3 Mar 2013 13:35:50 +0000 (14:35 +0100)
committerJoerg Jaspert <joerg@debian.org>
Sun, 3 Mar 2013 13:35:50 +0000 (14:35 +0100)
180 files changed:
elisp/org/ob-C.el [new file with mode: 0644]
elisp/org/ob-R.el [new file with mode: 0644]
elisp/org/ob-asymptote.el [new file with mode: 0644]
elisp/org/ob-awk.el [new file with mode: 0644]
elisp/org/ob-calc.el [new file with mode: 0644]
elisp/org/ob-clojure.el [new file with mode: 0644]
elisp/org/ob-comint.el [new file with mode: 0644]
elisp/org/ob-core.el [new file with mode: 0644]
elisp/org/ob-css.el [new file with mode: 0644]
elisp/org/ob-ditaa.el [new file with mode: 0644]
elisp/org/ob-dot.el [new file with mode: 0644]
elisp/org/ob-emacs-lisp.el [new file with mode: 0644]
elisp/org/ob-eval.el [new file with mode: 0644]
elisp/org/ob-exp.el [new file with mode: 0644]
elisp/org/ob-fortran.el [new file with mode: 0644]
elisp/org/ob-gnuplot.el [new file with mode: 0644]
elisp/org/ob-haskell.el [new file with mode: 0644]
elisp/org/ob-io.el [new file with mode: 0644]
elisp/org/ob-java.el [new file with mode: 0644]
elisp/org/ob-js.el [new file with mode: 0644]
elisp/org/ob-keys.el [new file with mode: 0644]
elisp/org/ob-latex.el [new file with mode: 0644]
elisp/org/ob-ledger.el [new file with mode: 0644]
elisp/org/ob-lilypond.el [new file with mode: 0644]
elisp/org/ob-lisp.el [new file with mode: 0644]
elisp/org/ob-lob.el [new file with mode: 0644]
elisp/org/ob-makefile.el [new file with mode: 0644]
elisp/org/ob-matlab.el [new file with mode: 0644]
elisp/org/ob-maxima.el [new file with mode: 0644]
elisp/org/ob-mscgen.el [new file with mode: 0644]
elisp/org/ob-ocaml.el [new file with mode: 0644]
elisp/org/ob-octave.el [new file with mode: 0644]
elisp/org/ob-org.el [new file with mode: 0644]
elisp/org/ob-perl.el [new file with mode: 0644]
elisp/org/ob-picolisp.el [new file with mode: 0644]
elisp/org/ob-plantuml.el [new file with mode: 0644]
elisp/org/ob-python.el [new file with mode: 0644]
elisp/org/ob-ref.el [new file with mode: 0644]
elisp/org/ob-ruby.el [new file with mode: 0644]
elisp/org/ob-sass.el [new file with mode: 0644]
elisp/org/ob-scala.el [new file with mode: 0644]
elisp/org/ob-scheme.el [new file with mode: 0644]
elisp/org/ob-screen.el [new file with mode: 0644]
elisp/org/ob-sh.el [new file with mode: 0644]
elisp/org/ob-shen.el [new file with mode: 0644]
elisp/org/ob-sql.el [new file with mode: 0644]
elisp/org/ob-sqlite.el [new file with mode: 0644]
elisp/org/ob-table.el [new file with mode: 0644]
elisp/org/ob-tangle.el [new file with mode: 0644]
elisp/org/ob.el [new file with mode: 0644]
elisp/org/org-agenda.el [new file with mode: 0644]
elisp/org/org-annotate-file.el [new file with mode: 0644]
elisp/org/org-archive.el [new file with mode: 0644]
elisp/org/org-ascii.el [new file with mode: 0644]
elisp/org/org-attach.el [new file with mode: 0644]
elisp/org/org-bbdb.el [new file with mode: 0644]
elisp/org/org-beamer.el [new file with mode: 0644]
elisp/org/org-bibtex-extras.el [new file with mode: 0644]
elisp/org/org-bibtex.el [new file with mode: 0644]
elisp/org/org-bookmark.el [new file with mode: 0644]
elisp/org/org-capture.el [new file with mode: 0644]
elisp/org/org-checklist.el [new file with mode: 0644]
elisp/org/org-choose.el [new file with mode: 0644]
elisp/org/org-clock.el [new file with mode: 0644]
elisp/org/org-collector.el [new file with mode: 0644]
elisp/org/org-colview-xemacs.el [new file with mode: 0644]
elisp/org/org-colview.el [new file with mode: 0644]
elisp/org/org-compat.el [new file with mode: 0644]
elisp/org/org-contacts.el [new file with mode: 0644]
elisp/org/org-contribdir.el [new file with mode: 0644]
elisp/org/org-crypt.el [new file with mode: 0644]
elisp/org/org-ctags.el [new file with mode: 0644]
elisp/org/org-datetree.el [new file with mode: 0644]
elisp/org/org-depend.el [new file with mode: 0644]
elisp/org/org-docbook.el [new file with mode: 0644]
elisp/org/org-docview.el [new file with mode: 0644]
elisp/org/org-drill.el [new file with mode: 0644]
elisp/org/org-e-ascii.el [new file with mode: 0644]
elisp/org/org-e-beamer.el [new file with mode: 0644]
elisp/org/org-e-groff.el [new file with mode: 0644]
elisp/org/org-e-html.el [new file with mode: 0644]
elisp/org/org-e-latex.el [new file with mode: 0644]
elisp/org/org-e-man.el [new file with mode: 0644]
elisp/org/org-e-odt.el [new file with mode: 0644]
elisp/org/org-e-publish.el [new file with mode: 0644]
elisp/org/org-e-texinfo.el [new file with mode: 0644]
elisp/org/org-element.el [new file with mode: 0644]
elisp/org/org-elisp-symbol.el [new file with mode: 0644]
elisp/org/org-entities.el [new file with mode: 0644]
elisp/org/org-eshell.el [new file with mode: 0644]
elisp/org/org-eval-light.el [new file with mode: 0644]
elisp/org/org-eval.el [new file with mode: 0644]
elisp/org/org-exp-bibtex.el [new file with mode: 0644]
elisp/org/org-exp-blocks.el [new file with mode: 0644]
elisp/org/org-exp.el [new file with mode: 0644]
elisp/org/org-expiry.el [new file with mode: 0644]
elisp/org/org-export-generic.el [new file with mode: 0644]
elisp/org/org-export.el [new file with mode: 0644]
elisp/org/org-faces.el [new file with mode: 0644]
elisp/org/org-feed.el [new file with mode: 0644]
elisp/org/org-footnote.el [new file with mode: 0644]
elisp/org/org-freemind.el [new file with mode: 0644]
elisp/org/org-git-link.el [new file with mode: 0644]
elisp/org/org-gnus.el [new file with mode: 0644]
elisp/org/org-habit.el [new file with mode: 0644]
elisp/org/org-html.el [new file with mode: 0644]
elisp/org/org-icalendar.el [new file with mode: 0644]
elisp/org/org-id.el [new file with mode: 0644]
elisp/org/org-indent.el [new file with mode: 0644]
elisp/org/org-info.el [new file with mode: 0644]
elisp/org/org-inlinetask.el [new file with mode: 0644]
elisp/org/org-install.el [new file with mode: 0644]
elisp/org/org-interactive-query.el [new file with mode: 0644]
elisp/org/org-invoice.el [new file with mode: 0644]
elisp/org/org-irc.el [new file with mode: 0644]
elisp/org/org-jira.el [new file with mode: 0644]
elisp/org/org-jsinfo.el [new file with mode: 0644]
elisp/org/org-latex.el [new file with mode: 0644]
elisp/org/org-learn.el [new file with mode: 0644]
elisp/org/org-list.el [new file with mode: 0644]
elisp/org/org-loaddefs.el [new file with mode: 0644]
elisp/org/org-lparse.el [new file with mode: 0644]
elisp/org/org-mac-iCal.el [new file with mode: 0644]
elisp/org/org-mac-link-grabber.el [new file with mode: 0644]
elisp/org/org-mac-message.el [new file with mode: 0644]
elisp/org/org-macro.el [new file with mode: 0644]
elisp/org/org-macs.el [new file with mode: 0644]
elisp/org/org-mairix.el [new file with mode: 0644]
elisp/org/org-man.el [new file with mode: 0644]
elisp/org/org-md.el [new file with mode: 0644]
elisp/org/org-mew.el [new file with mode: 0644]
elisp/org/org-mhe.el [new file with mode: 0644]
elisp/org/org-mime.el [new file with mode: 0644]
elisp/org/org-mks.el [new file with mode: 0644]
elisp/org/org-mobile.el [new file with mode: 0644]
elisp/org/org-mouse.el [new file with mode: 0644]
elisp/org/org-mtags.el [new file with mode: 0644]
elisp/org/org-notify.el [new file with mode: 0644]
elisp/org/org-notmuch.el [new file with mode: 0644]
elisp/org/org-odt.el [new file with mode: 0644]
elisp/org/org-panel.el [new file with mode: 0644]
elisp/org/org-pcomplete.el [new file with mode: 0644]
elisp/org/org-plot.el [new file with mode: 0644]
elisp/org/org-protocol.el [new file with mode: 0644]
elisp/org/org-publish.el [new file with mode: 0644]
elisp/org/org-registry.el [new file with mode: 0644]
elisp/org/org-remember.el [new file with mode: 0644]
elisp/org/org-rmail.el [new file with mode: 0644]
elisp/org/org-screen.el [new file with mode: 0644]
elisp/org/org-secretary.el [new file with mode: 0644]
elisp/org/org-special-blocks.el [new file with mode: 0644]
elisp/org/org-src.el [new file with mode: 0644]
elisp/org/org-static-mathjax.el [new file with mode: 0644]
elisp/org/org-sudoku.el [new file with mode: 0644]
elisp/org/org-table.el [new file with mode: 0644]
elisp/org/org-taskjuggler.el [new file with mode: 0644]
elisp/org/org-timer.el [new file with mode: 0644]
elisp/org/org-toc.el [new file with mode: 0644]
elisp/org/org-track.el [new file with mode: 0644]
elisp/org/org-velocity.el [new file with mode: 0644]
elisp/org/org-version.el [new file with mode: 0644]
elisp/org/org-vm.el [new file with mode: 0644]
elisp/org/org-w3m.el [new file with mode: 0644]
elisp/org/org-wikinodes.el [new file with mode: 0644]
elisp/org/org-wl.el [new file with mode: 0644]
elisp/org/org-xoxo.el [new file with mode: 0644]
elisp/org/org.el [new file with mode: 0644]
elisp/org/ox-ascii.el [new file with mode: 0644]
elisp/org/ox-beamer.el [new file with mode: 0644]
elisp/org/ox-html.el [new file with mode: 0644]
elisp/org/ox-icalendar.el [new file with mode: 0644]
elisp/org/ox-jsinfo.el [new file with mode: 0644]
elisp/org/ox-latex.el [new file with mode: 0644]
elisp/org/ox-man.el [new file with mode: 0644]
elisp/org/ox-md.el [new file with mode: 0644]
elisp/org/ox-odt.el [new file with mode: 0644]
elisp/org/ox-org.el [new file with mode: 0644]
elisp/org/ox-publish.el [new file with mode: 0644]
elisp/org/ox-texinfo.el [new file with mode: 0644]
elisp/org/ox.el [new file with mode: 0644]

diff --git a/elisp/org/ob-C.el b/elisp/org/ob-C.el
new file mode 100644 (file)
index 0000000..b1e8a06
--- /dev/null
@@ -0,0 +1,194 @@
+;;; ob-C.el --- org-babel functions for C and similar languages
+
+;; Copyright (C) 2010-2013 Free Software Foundation, Inc.
+
+;; Author: Eric Schulte
+;; Keywords: literate programming, reproducible research
+;; Homepage: http://orgmode.org
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
+
+;;; Commentary:
+
+;; Org-Babel support for evaluating C code.
+;;
+;; very limited implementation:
+;; - currently only support :results output
+;; - not much in the way of error feedback
+
+;;; Code:
+(require 'ob)
+(require 'cc-mode)
+
+(declare-function org-entry-get "org"
+                 (pom property &optional inherit literal-nil))
+
+
+(defvar org-babel-tangle-lang-exts)
+(add-to-list 'org-babel-tangle-lang-exts '("C++" . "cpp"))
+
+(defvar org-babel-default-header-args:C '())
+
+(defvar org-babel-C-compiler "gcc"
+  "Command used to compile a C source code file into an
+  executable.")
+
+(defvar org-babel-C++-compiler "g++"
+  "Command used to compile a C++ source code file into an
+  executable.")
+
+(defvar org-babel-c-variant nil
+  "Internal variable used to hold which type of C (e.g. C or C++)
+is currently being evaluated.")
+
+(defun org-babel-execute:cpp (body params)
+  "Execute BODY according to PARAMS.  This function calls
+`org-babel-execute:C++'."
+  (org-babel-execute:C++ body params))
+
+(defun org-babel-execute:C++ (body params)
+  "Execute a block of C++ code with org-babel.  This function is
+called by `org-babel-execute-src-block'."
+  (let ((org-babel-c-variant 'cpp)) (org-babel-C-execute body params)))
+
+(defun org-babel-expand-body:C++ (body params)
+  "Expand a block of C++ code with org-babel according to it's
+header arguments (calls `org-babel-C-expand')."
+  (let ((org-babel-c-variant 'cpp)) (org-babel-C-expand body params)))
+
+(defun org-babel-execute:C (body params)
+  "Execute a block of C code with org-babel.  This function is
+called by `org-babel-execute-src-block'."
+  (let ((org-babel-c-variant 'c)) (org-babel-C-execute body params)))
+
+(defun org-babel-expand-body:c (body params)
+  "Expand a block of C code with org-babel according to it's
+header arguments (calls `org-babel-C-expand')."
+  (let ((org-babel-c-variant 'c)) (org-babel-C-expand body params)))
+
+(defun org-babel-C-execute (body params)
+  "This function should only be called by `org-babel-execute:C'
+or `org-babel-execute:C++'."
+  (let* ((tmp-src-file (org-babel-temp-file
+                       "C-src-"
+                       (cond
+                        ((equal org-babel-c-variant 'c) ".c")
+                        ((equal org-babel-c-variant 'cpp) ".cpp"))))
+         (tmp-bin-file (org-babel-temp-file "C-bin-" org-babel-exeext))
+         (cmdline (cdr (assoc :cmdline params)))
+         (flags (cdr (assoc :flags params)))
+         (full-body (org-babel-C-expand body params))
+         (compile
+         (progn
+           (with-temp-file tmp-src-file (insert full-body))
+           (org-babel-eval
+            (format "%s -o %s %s %s"
+                    (cond
+                     ((equal org-babel-c-variant 'c) org-babel-C-compiler)
+                     ((equal org-babel-c-variant 'cpp) org-babel-C++-compiler))
+                    (org-babel-process-file-name tmp-bin-file)
+                    (mapconcat 'identity
+                               (if (listp flags) flags (list flags)) " ")
+                    (org-babel-process-file-name tmp-src-file)) ""))))
+    ((lambda (results)
+       (org-babel-reassemble-table
+       (org-babel-result-cond (cdr (assoc :result-params params))
+         (org-babel-read results)
+         (let ((tmp-file (org-babel-temp-file "c-")))
+           (with-temp-file tmp-file (insert results))
+           (org-babel-import-elisp-from-file tmp-file)))
+       (org-babel-pick-name
+        (cdr (assoc :colname-names params)) (cdr (assoc :colnames params)))
+       (org-babel-pick-name
+        (cdr (assoc :rowname-names params)) (cdr (assoc :rownames params)))))
+     (org-babel-trim
+      (org-babel-eval
+       (concat tmp-bin-file (if cmdline (concat " " cmdline) "")) "")))))
+
+(defun org-babel-C-expand (body params)
+  "Expand a block of C or C++ code with org-babel according to
+it's header arguments."
+  (let ((vars (mapcar #'cdr (org-babel-get-header params :var)))
+        (main-p (not (string= (cdr (assoc :main params)) "no")))
+        (includes (or (cdr (assoc :includes params))
+                      (org-babel-read (org-entry-get nil "includes" t))))
+        (defines (org-babel-read
+                  (or (cdr (assoc :defines params))
+                      (org-babel-read (org-entry-get nil "defines" t))))))
+    (mapconcat 'identity
+              (list
+               ;; includes
+               (mapconcat
+                (lambda (inc) (format "#include %s" inc))
+                (if (listp includes) includes (list includes)) "\n")
+               ;; defines
+               (mapconcat
+                (lambda (inc) (format "#define %s" inc))
+                (if (listp defines) defines (list defines)) "\n")
+               ;; variables
+               (mapconcat 'org-babel-C-var-to-C vars "\n")
+               ;; body
+               (if main-p
+                   (org-babel-C-ensure-main-wrap body)
+                 body) "\n") "\n")))
+
+(defun org-babel-C-ensure-main-wrap (body)
+  "Wrap body in a \"main\" function call if none exists."
+  (if (string-match "^[ \t]*[intvod]+[ \t\n\r]*main[ \t]*(.*)" body)
+      body
+    (format "int main() {\n%s\nreturn(0);\n}\n" body)))
+
+(defun org-babel-prep-session:C (session params)
+  "This function does nothing as C is a compiled language with no
+support for sessions"
+  (error "C is a compiled languages -- no support for sessions"))
+
+(defun org-babel-load-session:C (session body params)
+  "This function does nothing as C is a compiled language with no
+support for sessions"
+  (error "C is a compiled languages -- no support for sessions"))
+
+;; helper functions
+
+(defun org-babel-C-var-to-C (pair)
+  "Convert an elisp val into a string of C code specifying a var
+of the same value."
+  ;; TODO list support
+  (let ((var (car pair))
+        (val (cdr pair)))
+    (when (symbolp val)
+      (setq val (symbol-name val))
+      (when (= (length val) 1)
+        (setq val (string-to-char val))))
+    (cond
+     ((integerp val)
+      (format "int %S = %S;" var val))
+     ((floatp val)
+      (format "double %S = %S;" var val))
+     ((or (integerp val))
+      (format "char %S = '%S';" var val))
+     ((stringp val)
+      (format "char %S[%d] = \"%s\";"
+              var (+ 1 (length val)) val))
+     (t
+      (format "u32 %S = %S;" var val)))))
+
+
+(provide 'ob-C)
+
+
+
+;;; ob-C.el ends here
diff --git a/elisp/org/ob-R.el b/elisp/org/ob-R.el
new file mode 100644 (file)
index 0000000..8db0853
--- /dev/null
@@ -0,0 +1,370 @@
+;;; ob-R.el --- org-babel functions for R code evaluation
+
+;; Copyright (C) 2009-2013 Free Software Foundation, Inc.
+
+;; Author: Eric Schulte
+;;     Dan Davison
+;; Keywords: literate programming, reproducible research, R, statistics
+;; Homepage: http://orgmode.org
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
+
+;;; Commentary:
+
+;; Org-Babel support for evaluating R code
+
+;;; Code:
+(require 'ob)
+(eval-when-compile (require 'cl))
+
+(declare-function orgtbl-to-tsv "org-table" (table params))
+(declare-function R "ext:essd-r" (&optional start-args))
+(declare-function inferior-ess-send-input "ext:ess-inf" ())
+(declare-function ess-make-buffer-current "ext:ess-inf" ())
+(declare-function ess-eval-buffer "ext:ess-inf" (vis))
+(declare-function org-number-sequence "org-compat" (from &optional to inc))
+(declare-function org-remove-if-not "org" (predicate seq))
+
+(defconst org-babel-header-args:R
+  '((width              . :any)
+    (height             . :any)
+    (bg                         . :any)
+    (units              . :any)
+    (pointsize          . :any)
+    (antialias          . :any)
+    (quality            . :any)
+    (compression        . :any)
+    (res                . :any)
+    (type               . :any)
+    (family             . :any)
+    (title              . :any)
+    (fonts              . :any)
+    (version            . :any)
+    (paper              . :any)
+    (encoding           . :any)
+    (pagecentre                 . :any)
+    (colormodel                 . :any)
+    (useDingbats        . :any)
+    (horizontal                 . :any)
+    (results             . ((file list vector table scalar verbatim)
+                           (raw org html latex code pp wrap)
+                           (replace silent append prepend)
+                           (output value graphics))))
+  "R-specific header arguments.")
+
+(defvar org-babel-default-header-args:R '())
+
+(defcustom org-babel-R-command "R --slave --no-save"
+  "Name of command to use for executing R code."
+  :group 'org-babel
+  :version "24.1"
+  :type 'string)
+
+(defvar ess-local-process-name) ; dynamically scoped
+(defun org-babel-edit-prep:R (info)
+  (let ((session (cdr (assoc :session (nth 2 info)))))
+    (when (and session (string-match "^\\*\\(.+?\\)\\*$" session))
+      (save-match-data (org-babel-R-initiate-session session nil)))))
+
+(defun org-babel-expand-body:R (body params &optional graphics-file)
+  "Expand BODY according to PARAMS, return the expanded body."
+  (let ((graphics-file
+        (or graphics-file (org-babel-R-graphical-output-file params))))
+    (mapconcat
+     #'identity
+     ((lambda (inside)
+       (if graphics-file
+           (append
+            (list (org-babel-R-construct-graphics-device-call
+                   graphics-file params))
+            inside
+            (list "dev.off()"))
+         inside))
+      (append (org-babel-variable-assignments:R params)
+             (list body))) "\n")))
+
+(defun org-babel-execute:R (body params)
+  "Execute a block of R code.
+This function is called by `org-babel-execute-src-block'."
+  (save-excursion
+    (let* ((result-params (cdr (assoc :result-params params)))
+          (result-type (cdr (assoc :result-type params)))
+           (session (org-babel-R-initiate-session
+                    (cdr (assoc :session params)) params))
+          (colnames-p (cdr (assoc :colnames params)))
+          (rownames-p (cdr (assoc :rownames params)))
+          (graphics-file (org-babel-R-graphical-output-file params))
+          (full-body (org-babel-expand-body:R body params graphics-file))
+          (result
+           (org-babel-R-evaluate
+            session full-body result-type result-params
+            (or (equal "yes" colnames-p)
+                (org-babel-pick-name
+                 (cdr (assoc :colname-names params)) colnames-p))
+            (or (equal "yes" rownames-p)
+                (org-babel-pick-name
+                 (cdr (assoc :rowname-names params)) rownames-p)))))
+      (if graphics-file nil result))))
+
+(defun org-babel-prep-session:R (session params)
+  "Prepare SESSION according to the header arguments specified in PARAMS."
+  (let* ((session (org-babel-R-initiate-session session params))
+        (var-lines (org-babel-variable-assignments:R params)))
+    (org-babel-comint-in-buffer session
+      (mapc (lambda (var)
+              (end-of-line 1) (insert var) (comint-send-input nil t)
+              (org-babel-comint-wait-for-output session)) var-lines))
+    session))
+
+(defun org-babel-load-session:R (session body params)
+  "Load BODY into SESSION."
+  (save-window-excursion
+    (let ((buffer (org-babel-prep-session:R session params)))
+      (with-current-buffer buffer
+        (goto-char (process-mark (get-buffer-process (current-buffer))))
+        (insert (org-babel-chomp body)))
+      buffer)))
+
+;; helper functions
+
+(defun org-babel-variable-assignments:R (params)
+  "Return list of R statements assigning the block's variables."
+  (let ((vars (mapcar #'cdr (org-babel-get-header params :var))))
+    (mapcar
+     (lambda (pair)
+       (org-babel-R-assign-elisp
+       (car pair) (cdr pair)
+       (equal "yes" (cdr (assoc :colnames params)))
+       (equal "yes" (cdr (assoc :rownames params)))))
+     (mapcar
+      (lambda (i)
+       (cons (car (nth i vars))
+             (org-babel-reassemble-table
+              (cdr (nth i vars))
+              (cdr (nth i (cdr (assoc :colname-names params))))
+              (cdr (nth i (cdr (assoc :rowname-names params)))))))
+      (org-number-sequence 0 (1- (length vars)))))))
+
+(defun org-babel-R-quote-tsv-field (s)
+  "Quote field S for export to R."
+  (if (stringp s)
+      (concat "\"" (mapconcat 'identity (split-string s "\"") "\"\"") "\"")
+    (format "%S" s)))
+
+(defun org-babel-R-assign-elisp (name value colnames-p rownames-p)
+  "Construct R code assigning the elisp VALUE to a variable named NAME."
+  (if (listp value)
+      (let ((max (apply #'max (mapcar #'length (org-remove-if-not
+                                               #'sequencep value))))
+           (min (apply #'min (mapcar #'length (org-remove-if-not
+                                               #'sequencep value))))
+           (transition-file (org-babel-temp-file "R-import-")))
+        ;; ensure VALUE has an orgtbl structure (depth of at least 2)
+        (unless (listp (car value)) (setq value (list value)))
+        (with-temp-file transition-file
+          (insert
+          (orgtbl-to-tsv value '(:fmt org-babel-R-quote-tsv-field))
+          "\n"))
+       (let ((file (org-babel-process-file-name transition-file 'noquote))
+             (header (if (or (eq (nth 1 value) 'hline) colnames-p)
+                         "TRUE" "FALSE"))
+             (row-names (if rownames-p "1" "NULL")))
+         (if (= max min)
+             (format "%s <- read.table(\"%s\",
+                      header=%s,
+                      row.names=%s,
+                      sep=\"\\t\",
+                      as.is=TRUE)" name file header row-names)
+           (format "%s <- read.table(\"%s\",
+                   header=%s,
+                   row.names=%s,
+                   sep=\"\\t\",
+                   as.is=TRUE,
+                   fill=TRUE,
+                   col.names = paste(\"V\", seq_len(%d), sep =\"\"))"
+                   name file header row-names max))))
+    (format "%s <- %s" name (org-babel-R-quote-tsv-field value))))
+
+(defvar ess-ask-for-ess-directory) ; dynamically scoped
+(defun org-babel-R-initiate-session (session params)
+  "If there is not a current R process then create one."
+  (unless (string= session "none")
+    (let ((session (or session "*R*"))
+         (ess-ask-for-ess-directory
+          (and (and (boundp 'ess-ask-for-ess-directory) ess-ask-for-ess-directory)
+               (not (cdr (assoc :dir params))))))
+      (if (org-babel-comint-buffer-livep session)
+         session
+       (save-window-excursion
+         (require 'ess) (R)
+         (rename-buffer
+          (if (bufferp session)
+              (buffer-name session)
+            (if (stringp session)
+                session
+              (buffer-name))))
+         (current-buffer))))))
+
+(defun org-babel-R-associate-session (session)
+  "Associate R code buffer with an R session.
+Make SESSION be the inferior ESS process associated with the
+current code buffer."
+  (setq ess-local-process-name
+       (process-name (get-buffer-process session)))
+  (ess-make-buffer-current))
+
+(defun org-babel-R-graphical-output-file (params)
+  "Name of file to which R should send graphical output."
+  (and (member "graphics" (cdr (assq :result-params params)))
+       (cdr (assq :file params))))
+
+(defun org-babel-R-construct-graphics-device-call (out-file params)
+  "Construct the call to the graphics device."
+  (let ((devices
+        '((:bmp . "bmp")
+          (:jpg . "jpeg")
+          (:jpeg . "jpeg")
+          (:tex . "tikz")
+          (:tiff . "tiff")
+          (:png . "png")
+          (:svg . "svg")
+          (:pdf . "pdf")
+          (:ps . "postscript")
+          (:postscript . "postscript")))
+       (allowed-args '(:width :height :bg :units :pointsize
+                              :antialias :quality :compression :res
+                              :type :family :title :fonts :version
+                              :paper :encoding :pagecentre :colormodel
+                              :useDingbats :horizontal))
+       (device (and (string-match ".+\\.\\([^.]+\\)" out-file)
+                    (match-string 1 out-file)))
+       (extra-args (cdr (assq :R-dev-args params))) filearg args)
+    (setq device (or (and device (cdr (assq (intern (concat ":" device))
+                                           devices))) "png"))
+    (setq filearg
+         (if (member device '("pdf" "postscript" "svg" "tikz")) "file" "filename"))
+    (setq args (mapconcat
+               (lambda (pair)
+                 (if (member (car pair) allowed-args)
+                     (format ",%s=%S"
+                             (substring (symbol-name (car pair)) 1)
+                             (cdr pair)) ""))
+               params ""))
+    (format "%s(%s=\"%s\"%s%s%s)"
+           device filearg out-file args
+           (if extra-args "," "") (or extra-args ""))))
+
+(defvar org-babel-R-eoe-indicator "'org_babel_R_eoe'")
+(defvar org-babel-R-eoe-output "[1] \"org_babel_R_eoe\"")
+
+(defvar org-babel-R-write-object-command "{function(object,transfer.file){object;invisible(if(inherits(try({tfile<-tempfile();write.table(object,file=tfile,sep=\"\\t\",na=\"nil\",row.names=%s,col.names=%s,quote=FALSE);file.rename(tfile,transfer.file)},silent=TRUE),\"try-error\")){if(!file.exists(transfer.file))file.create(transfer.file)})}}(object=%s,transfer.file=\"%s\")")
+
+(defun org-babel-R-evaluate
+  (session body result-type result-params column-names-p row-names-p)
+  "Evaluate R code in BODY."
+  (if session
+      (org-babel-R-evaluate-session
+       session body result-type result-params column-names-p row-names-p)
+    (org-babel-R-evaluate-external-process
+     body result-type result-params column-names-p row-names-p)))
+
+(defun org-babel-R-evaluate-external-process
+  (body result-type result-params column-names-p row-names-p)
+  "Evaluate BODY in external R process.
+If RESULT-TYPE equals 'output then return standard output as a
+string.  If RESULT-TYPE equals 'value then return the value of the
+last statement in BODY, as elisp."
+  (case result-type
+    (value
+     (let ((tmp-file (org-babel-temp-file "R-")))
+       (org-babel-eval org-babel-R-command
+                      (format org-babel-R-write-object-command
+                              (if row-names-p "TRUE" "FALSE")
+                              (if column-names-p
+                                  (if row-names-p "NA" "TRUE")
+                                "FALSE")
+                              (format "{function ()\n{\n%s\n}}()" body)
+                              (org-babel-process-file-name tmp-file 'noquote)))
+       (org-babel-R-process-value-result
+       (org-babel-result-cond result-params
+         (with-temp-buffer
+           (insert-file-contents tmp-file)
+           (buffer-string))
+         (org-babel-import-elisp-from-file tmp-file '(16)))
+       column-names-p)))
+    (output (org-babel-eval org-babel-R-command body))))
+
+(defun org-babel-R-evaluate-session
+  (session body result-type result-params column-names-p row-names-p)
+  "Evaluate BODY in SESSION.
+If RESULT-TYPE equals 'output then return standard output as a
+string.  If RESULT-TYPE equals 'value then return the value of the
+last statement in BODY, as elisp."
+  (case result-type
+    (value
+     (with-temp-buffer
+       (insert (org-babel-chomp body))
+       (let ((ess-local-process-name
+             (process-name (get-buffer-process session)))
+            (ess-eval-visibly-p nil))
+        (ess-eval-buffer nil)))
+     (let ((tmp-file (org-babel-temp-file "R-")))
+       (org-babel-comint-eval-invisibly-and-wait-for-file
+       session tmp-file
+       (format org-babel-R-write-object-command
+               (if row-names-p "TRUE" "FALSE")
+               (if column-names-p
+                   (if row-names-p "NA" "TRUE")
+                 "FALSE")
+               ".Last.value" (org-babel-process-file-name tmp-file 'noquote)))
+       (org-babel-R-process-value-result
+       (org-babel-result-cond result-params
+         (with-temp-buffer
+           (insert-file-contents tmp-file)
+           (buffer-string))
+         (org-babel-import-elisp-from-file tmp-file '(16)))
+       column-names-p)))
+    (output
+     (mapconcat
+      #'org-babel-chomp
+      (butlast
+       (delq nil
+            (mapcar
+             (lambda (line) (when (> (length line) 0) line))
+             (mapcar
+              (lambda (line) ;; cleanup extra prompts left in output
+                (if (string-match
+                     "^\\([ ]*[>+\\.][ ]?\\)+\\([[0-9]+\\|[ ]\\)" line)
+                    (substring line (match-end 1))
+                  line))
+              (org-babel-comint-with-output (session org-babel-R-eoe-output)
+                (insert (mapconcat #'org-babel-chomp
+                                   (list body org-babel-R-eoe-indicator)
+                                   "\n"))
+                (inferior-ess-send-input)))))) "\n"))))
+
+(defun org-babel-R-process-value-result (result column-names-p)
+  "R-specific processing of return value.
+Insert hline if column names in output have been requested."
+  (if column-names-p
+      (cons (car result) (cons 'hline (cdr result)))
+    result))
+
+(provide 'ob-R)
+
+
+
+;;; ob-R.el ends here
diff --git a/elisp/org/ob-asymptote.el b/elisp/org/ob-asymptote.el
new file mode 100644 (file)
index 0000000..4ea68df
--- /dev/null
@@ -0,0 +1,150 @@
+;;; ob-asymptote.el --- org-babel functions for asymptote evaluation
+
+;; Copyright (C) 2009-2013 Free Software Foundation, Inc.
+
+;; Author: Eric Schulte
+;; Keywords: literate programming, reproducible research
+;; Homepage: http://orgmode.org
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
+
+;;; Commentary:
+
+;; Org-Babel support for evaluating asymptote source code.
+;;
+;; This differs from most standard languages in that
+;;
+;; 1) there is no such thing as a "session" in asymptote
+;;
+;; 2) we are generally only going to return results of type "file"
+;;
+;; 3) we are adding the "file" and "cmdline" header arguments, if file
+;;    is omitted then the -V option is passed to the asy command for
+;;    interactive viewing
+
+;;; Requirements:
+
+;; - The asymptote program :: http://asymptote.sourceforge.net/
+;;
+;; - asy-mode :: Major mode for editing asymptote files
+
+;;; Code:
+(require 'ob)
+(eval-when-compile (require 'cl))
+
+(declare-function orgtbl-to-generic "org-table" (table params))
+(declare-function org-combine-plists "org" (&rest plists))
+
+(defvar org-babel-tangle-lang-exts)
+(add-to-list 'org-babel-tangle-lang-exts '("asymptote" . "asy"))
+
+(defvar org-babel-default-header-args:asymptote
+  '((:results . "file") (:exports . "results"))
+  "Default arguments when evaluating an Asymptote source block.")
+
+(defun org-babel-execute:asymptote (body params)
+  "Execute a block of Asymptote code.
+This function is called by `org-babel-execute-src-block'."
+  (let* ((result-params (split-string (or (cdr (assoc :results params)) "")))
+         (out-file (cdr (assoc :file params)))
+         (format (or (and out-file
+                          (string-match ".+\\.\\(.+\\)" out-file)
+                          (match-string 1 out-file))
+                     "pdf"))
+         (cmdline (cdr (assoc :cmdline params)))
+         (in-file (org-babel-temp-file "asymptote-"))
+         (cmd
+         (concat "asy "
+                 (if out-file
+                     (concat
+                      "-globalwrite -f " format
+                      " -o " (org-babel-process-file-name out-file))
+                   "-V")
+                 " " cmdline
+                 " " (org-babel-process-file-name in-file))))
+    (with-temp-file in-file
+      (insert (org-babel-expand-body:generic
+              body params
+              (org-babel-variable-assignments:asymptote params))))
+    (message cmd) (shell-command cmd)
+    nil)) ;; signal that output has already been written to file
+
+(defun org-babel-prep-session:asymptote (session params)
+  "Return an error if the :session header argument is set.
+Asymptote does not support sessions"
+  (error "Asymptote does not support sessions"))
+
+(defun org-babel-variable-assignments:asymptote (params)
+  "Return list of asymptote statements assigning the block's variables."
+  (mapcar #'org-babel-asymptote-var-to-asymptote
+         (mapcar #'cdr (org-babel-get-header params :var))))
+
+(defun org-babel-asymptote-var-to-asymptote (pair)
+  "Convert an elisp value into an Asymptote variable.
+The elisp value PAIR is converted into Asymptote code specifying
+a variable of the same value."
+  (let ((var (car pair))
+        (val (let ((v (cdr pair)))
+              (if (symbolp v) (symbol-name v) v))))
+    (cond
+     ((integerp val)
+      (format "int %S=%S;" var val))
+     ((floatp val)
+      (format "real %S=%S;" var val))
+     ((stringp val)
+      (format "string %S=\"%s\";" var val))
+     ((and (listp val) (not (listp (car val))))
+      (let* ((type (org-babel-asymptote-define-type val))
+            (fmt (if (eq 'string type) "\"%s\"" "%s"))
+            (vect (mapconcat (lambda (e) (format fmt e)) val ", ")))
+       (format "%s[] %S={%s};" type var vect)))
+     ((listp val)
+      (let* ((type (org-babel-asymptote-define-type val))
+            (fmt (if (eq 'string type) "\"%s\"" "%s"))
+             (array (mapconcat (lambda (row)
+                                (concat "{"
+                                        (mapconcat (lambda (e) (format fmt e))
+                                                   row ", ")
+                                        "}"))
+                              val ",")))
+        (format "%S[][] %S={%s};" type var array))))))
+
+(defun org-babel-asymptote-define-type (data)
+  "Determine type of DATA.
+
+DATA is a list.  Return type as a symbol.
+
+The type is `string' if any element in DATA is
+a string.  Otherwise, it is either `real', if some elements are
+floats, or `int'."
+  (let* ((type 'int)
+        find-type                      ; for byte-compiler
+        (find-type
+         (function
+          (lambda (row)
+            (catch 'exit
+              (mapc (lambda (el)
+                      (cond ((listp el) (funcall find-type el))
+                            ((stringp el) (throw 'exit (setq type 'string)))
+                            ((floatp el) (setq type 'real))))
+                    row))))))
+    (funcall find-type data) type))
+
+(provide 'ob-asymptote)
+
+
+
+;;; ob-asymptote.el ends here
diff --git a/elisp/org/ob-awk.el b/elisp/org/ob-awk.el
new file mode 100644 (file)
index 0000000..f717fec
--- /dev/null
@@ -0,0 +1,114 @@
+;;; ob-awk.el --- org-babel functions for awk evaluation
+
+;; Copyright (C) 2011-2013 Free Software Foundation, Inc.
+
+;; Author: Eric Schulte
+;; Keywords: literate programming, reproducible research
+;; Homepage: http://orgmode.org
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
+
+;;; Commentary:
+
+;; Babel's awk can use special header argument:
+;;
+;; - :in-file takes a path to a file of data to be processed by awk
+;;
+;; - :stdin takes an Org-mode data or code block reference, the value
+;;          of which will be passed to the awk process through STDIN
+
+;;; Code:
+(require 'ob)
+(require 'org-compat)
+(eval-when-compile (require 'cl))
+
+(declare-function org-babel-ref-resolve "ob-ref" (ref))
+(declare-function orgtbl-to-generic "org-table" (table params))
+
+(defvar org-babel-tangle-lang-exts)
+(add-to-list 'org-babel-tangle-lang-exts '("awk" . "awk"))
+
+(defvar org-babel-awk-command "awk"
+  "Name of the awk executable command.")
+
+(defun org-babel-expand-body:awk (body params &optional processed-params)
+  "Expand BODY according to PARAMS, return the expanded body."
+  (dolist (pair (mapcar #'cdr (org-babel-get-header params :var)))
+    (setf body (replace-regexp-in-string
+                (regexp-quote (format "$%s" (car pair))) (cdr pair) body)))
+  body)
+
+(defun org-babel-execute:awk (body params)
+  "Execute a block of Awk code with org-babel.  This function is
+called by `org-babel-execute-src-block'"
+  (message "executing Awk source code block")
+  (let* ((result-params (cdr (assoc :result-params params)))
+         (cmd-line (cdr (assoc :cmd-line params)))
+         (in-file (cdr (assoc :in-file params)))
+        (full-body (org-babel-expand-body:awk body params))
+        (code-file ((lambda (file) (with-temp-file file (insert full-body)) file)
+                     (org-babel-temp-file "awk-")))
+        (stdin ((lambda (stdin)
+                  (when stdin
+                    (let ((tmp (org-babel-temp-file "awk-stdin-"))
+                          (res (org-babel-ref-resolve stdin)))
+                      (with-temp-file tmp
+                        (insert (org-babel-awk-var-to-awk res)))
+                      tmp)))
+                (cdr (assoc :stdin params))))
+         (cmd (mapconcat #'identity (remove nil (list org-babel-awk-command
+                                                     "-f" code-file
+                                                     cmd-line
+                                                     in-file))
+                        " ")))
+    (org-babel-reassemble-table
+     ((lambda (results)
+       (when results
+         (org-babel-result-cond result-params
+           results
+           (let ((tmp (org-babel-temp-file "awk-results-")))
+             (with-temp-file tmp (insert results))
+             (org-babel-import-elisp-from-file tmp)))))
+      (cond
+       (stdin (with-temp-buffer
+               (call-process-shell-command cmd stdin (current-buffer))
+               (buffer-string)))
+       (t (org-babel-eval cmd ""))))
+     (org-babel-pick-name
+      (cdr (assoc :colname-names params)) (cdr (assoc :colnames params)))
+     (org-babel-pick-name
+      (cdr (assoc :rowname-names params)) (cdr (assoc :rownames params))))))
+
+(defun org-babel-awk-var-to-awk (var &optional sep)
+  "Return a printed value of VAR suitable for parsing with awk."
+  (let ((echo-var (lambda (v) (if (stringp v) v (format "%S" v)))))
+    (cond
+     ((and (listp var) (listp (car var)))
+      (orgtbl-to-generic var  (list :sep (or sep "\t") :fmt echo-var)))
+     ((listp var)
+      (mapconcat echo-var var "\n"))
+     (t (funcall echo-var var)))))
+
+(defun org-babel-awk-table-or-string (results)
+  "If the results look like a table, then convert them into an
+Emacs-lisp table, otherwise return the results as a string."
+  (org-babel-script-escape results))
+
+(provide 'ob-awk)
+
+
+
+;;; ob-awk.el ends here
diff --git a/elisp/org/ob-calc.el b/elisp/org/ob-calc.el
new file mode 100644 (file)
index 0000000..766f6ce
--- /dev/null
@@ -0,0 +1,107 @@
+;;; ob-calc.el --- org-babel functions for calc code evaluation
+
+;; Copyright (C) 2010-2013 Free Software Foundation, Inc.
+
+;; Author: Eric Schulte
+;; Keywords: literate programming, reproducible research
+;; Homepage: http://orgmode.org
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
+
+;;; Commentary:
+
+;; Org-Babel support for evaluating calc code
+
+;;; Code:
+(require 'ob)
+(require 'calc)
+(unless (featurep 'xemacs)
+  (require 'calc-trail)
+  (require 'calc-store))
+
+(declare-function calc-store-into    "calc-store" (&optional var))
+(declare-function calc-recall        "calc-store" (&optional var))
+(declare-function math-evaluate-expr "calc-ext"   (x))
+
+(defvar org-babel-default-header-args:calc nil
+  "Default arguments for evaluating an calc source block.")
+
+(defun org-babel-expand-body:calc (body params)
+  "Expand BODY according to PARAMS, return the expanded body." body)
+
+(defun org-babel-execute:calc (body params)
+  "Execute a block of calc code with Babel."
+  (unless (get-buffer "*Calculator*")
+    (save-window-excursion (calc) (calc-quit)))
+  (let* ((vars (mapcar #'cdr (org-babel-get-header params :var)))
+        (var-syms (mapcar #'car vars))
+        (var-names (mapcar #'symbol-name var-syms)))
+    (mapc
+     (lambda (pair)
+       (calc-push-list (list (cdr pair)))
+       (calc-store-into (car pair)))
+     vars)
+    (mapc
+     (lambda (line)
+       (when (> (length line) 0)
+        (cond
+         ;; simple variable name
+         ((member line var-names) (calc-recall (intern line)))
+         ;; stack operation
+         ((string= "'" (substring line 0 1))
+          (funcall (lookup-key calc-mode-map (substring line 1)) nil))
+         ;; complex expression
+         (t
+          (calc-push-list
+           (list ((lambda (res)
+                    (cond
+                     ((numberp res) res)
+                     ((math-read-number res) (math-read-number res))
+                     ((listp res) (error "Calc error \"%s\" on input \"%s\""
+                                         (cadr res) line))
+                     (t (replace-regexp-in-string
+                         "'" ""
+                         (calc-eval
+                          (math-evaluate-expr
+                           ;; resolve user variables, calc built in
+                           ;; variables are handled automatically
+                           ;; upstream by calc
+                           (mapcar #'org-babel-calc-maybe-resolve-var
+                                   ;; parse line into calc objects
+                                   (car (math-read-exprs line)))))))))
+                  (calc-eval line))))))))
+     (mapcar #'org-babel-trim
+            (split-string (org-babel-expand-body:calc body params) "[\n\r]"))))
+  (save-excursion
+    (with-current-buffer (get-buffer "*Calculator*")
+      (calc-eval (calc-top 1)))))
+
+(defvar var-syms) ; Dynamically scoped from org-babel-execute:calc
+(defun org-babel-calc-maybe-resolve-var (el)
+  (if (consp el)
+      (if (and (equal 'var (car el)) (member (cadr el) var-syms))
+         (progn
+           (calc-recall (cadr el))
+           (prog1 (calc-top 1)
+             (calc-pop 1)))
+       (mapcar #'org-babel-calc-maybe-resolve-var el))
+    el))
+
+(provide 'ob-calc)
+
+
+
+;;; ob-calc.el ends here
diff --git a/elisp/org/ob-clojure.el b/elisp/org/ob-clojure.el
new file mode 100644 (file)
index 0000000..bc2bbc0
--- /dev/null
@@ -0,0 +1,95 @@
+;;; ob-clojure.el --- org-babel functions for clojure evaluation
+
+;; Copyright (C) 2009-2013 Free Software Foundation, Inc.
+
+;; Author: Joel Boehland
+;;     Eric Schulte
+;; Keywords: literate programming, reproducible research
+;; Homepage: http://orgmode.org
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
+
+;;; Commentary:
+
+;;; support for evaluating clojure code, relies on slime for all eval
+
+;;; Requirements:
+
+;;; - clojure (at least 1.2.0)
+;;; - clojure-mode
+;;; - slime
+
+;;; By far, the best way to install these components is by following
+;;; the directions as set out by Phil Hagelberg (Technomancy) on the
+;;; web page: http://technomancy.us/126
+
+;;; Code:
+(require 'ob)
+
+(declare-function slime-eval "ext:slime" (sexp &optional package))
+
+(defvar org-babel-tangle-lang-exts)
+(add-to-list 'org-babel-tangle-lang-exts '("clojure" . "clj"))
+
+(defvar org-babel-default-header-args:clojure '())
+(defvar org-babel-header-args:clojure '((package . :any)))
+
+(defun org-babel-expand-body:clojure (body params)
+  "Expand BODY according to PARAMS, return the expanded body."
+  (let* ((vars (mapcar #'cdr (org-babel-get-header params :var)))
+        (result-params (cdr (assoc :result-params params)))
+        (print-level nil) (print-length nil)
+        (body (org-babel-trim
+               (if (> (length vars) 0)
+                   (concat "(let ["
+                           (mapconcat
+                            (lambda (var)
+                              (format "%S (quote %S)" (car var) (cdr var)))
+                            vars "\n      ")
+                           "]\n" body ")")
+                 body))))
+    (cond ((or (member "code" result-params) (member "pp" result-params))
+          (format (concat "(let [org-mode-print-catcher (java.io.StringWriter.)] "
+                          "(clojure.pprint/with-pprint-dispatch clojure.pprint/%s-dispatch "
+                          "(clojure.pprint/pprint (do %s) org-mode-print-catcher) "
+                          "(str org-mode-print-catcher)))")
+                  (if (member "code" result-params) "code" "simple") body))
+         ;; if (:results output), collect printed output
+         ((member "output" result-params)
+          (format "(clojure.core/with-out-str %s)" body))
+         (t body))))
+
+(defun org-babel-execute:clojure (body params)
+  "Execute a block of Clojure code with Babel."
+  (require 'slime)
+  (with-temp-buffer
+    (insert (org-babel-expand-body:clojure body params))
+    ((lambda (result)
+       (let ((result-params (cdr (assoc :result-params params))))
+        (org-babel-result-cond result-params
+          result
+          (condition-case nil (org-babel-script-escape result)
+            (error result)))))
+     (slime-eval
+      `(swank:eval-and-grab-output
+       ,(buffer-substring-no-properties (point-min) (point-max)))
+      (cdr (assoc :package params))))))
+
+(provide 'ob-clojure)
+
+
+
+;;; ob-clojure.el ends here
diff --git a/elisp/org/ob-comint.el b/elisp/org/ob-comint.el
new file mode 100644 (file)
index 0000000..f156297
--- /dev/null
@@ -0,0 +1,166 @@
+;;; ob-comint.el --- org-babel functions for interaction with comint buffers
+
+;; Copyright (C) 2009-2013 Free Software Foundation, Inc.
+
+;; Author: Eric Schulte
+;; Keywords: literate programming, reproducible research, comint
+;; Homepage: http://orgmode.org
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
+
+;;; Commentary:
+
+;; These functions build on comint to ease the sending and receiving
+;; of commands and results from comint buffers.
+
+;; Note that the buffers in this file are analogous to sessions in
+;; org-babel at large.
+
+;;; Code:
+(require 'ob-core)
+(require 'org-compat)
+(require 'comint)
+(eval-when-compile (require 'cl))
+(declare-function with-parsed-tramp-file-name "tramp" (filename var &rest body))
+(declare-function tramp-flush-directory-property "tramp" (vec directory))
+
+(defun org-babel-comint-buffer-livep (buffer)
+  "Check if BUFFER is a comint buffer with a live process."
+  (let ((buffer (if buffer (get-buffer buffer))))
+    (and buffer (buffer-live-p buffer) (get-buffer-process buffer) buffer)))
+
+(defmacro org-babel-comint-in-buffer (buffer &rest body)
+  "Check BUFFER and execute BODY.
+BUFFER is checked with `org-babel-comint-buffer-livep'.  BODY is
+executed inside the protection of `save-excursion' and
+`save-match-data'."
+  (declare (indent 1))
+  `(save-excursion
+     (save-match-data
+       (unless (org-babel-comint-buffer-livep ,buffer)
+         (error "Buffer %s does not exist or has no process" ,buffer))
+       (set-buffer ,buffer)
+       ,@body)))
+(def-edebug-spec org-babel-comint-in-buffer (form body))
+
+(defmacro org-babel-comint-with-output (meta &rest body)
+  "Evaluate BODY in BUFFER and return process output.
+Will wait until EOE-INDICATOR appears in the output, then return
+all process output.  If REMOVE-ECHO and FULL-BODY are present and
+non-nil, then strip echo'd body from the returned output.  META
+should be a list containing the following where the last two
+elements are optional.
+
+ (BUFFER EOE-INDICATOR REMOVE-ECHO FULL-BODY)
+
+This macro ensures that the filter is removed in case of an error
+or user `keyboard-quit' during execution of body."
+  (declare (indent 1))
+  (let ((buffer (car meta))
+       (eoe-indicator (cadr meta))
+       (remove-echo (cadr (cdr meta)))
+       (full-body (cadr (cdr (cdr meta)))))
+    `(org-babel-comint-in-buffer ,buffer
+       (let ((string-buffer "") dangling-text raw)
+        ;; setup filter
+        (setq comint-output-filter-functions
+              (cons (lambda (text) (setq string-buffer (concat string-buffer text)))
+                    comint-output-filter-functions))
+        (unwind-protect
+            (progn
+              ;; got located, and save dangling text
+              (goto-char (process-mark (get-buffer-process (current-buffer))))
+              (let ((start (point))
+                    (end (point-max)))
+                (setq dangling-text (buffer-substring start end))
+                (delete-region start end))
+              ;; pass FULL-BODY to process
+              ,@body
+              ;; wait for end-of-evaluation indicator
+              (while (progn
+                       (goto-char comint-last-input-end)
+                       (not (save-excursion
+                              (and (re-search-forward
+                                    (regexp-quote ,eoe-indicator) nil t)
+                                   (re-search-forward
+                                    comint-prompt-regexp nil t)))))
+                (accept-process-output (get-buffer-process (current-buffer)))
+                ;; thought the following this would allow async
+                ;; background running, but I was wrong...
+                ;; (run-with-timer .5 .5 'accept-process-output
+                ;;              (get-buffer-process (current-buffer)))
+                )
+              ;; replace cut dangling text
+              (goto-char (process-mark (get-buffer-process (current-buffer))))
+              (insert dangling-text))
+          ;; remove filter
+          (setq comint-output-filter-functions
+                (cdr comint-output-filter-functions)))
+        ;; remove echo'd FULL-BODY from input
+        (if (and ,remove-echo ,full-body
+                 (string-match
+                  (replace-regexp-in-string
+                   "\n" "[\r\n]+" (regexp-quote (or ,full-body "")))
+                  string-buffer))
+            (setq raw (substring string-buffer (match-end 0))))
+        (split-string string-buffer comint-prompt-regexp)))))
+(def-edebug-spec org-babel-comint-with-output (form body))
+
+(defun org-babel-comint-input-command (buffer cmd)
+  "Pass CMD to BUFFER.
+The input will not be echoed."
+  (org-babel-comint-in-buffer buffer
+    (goto-char (process-mark (get-buffer-process buffer)))
+    (insert cmd)
+    (comint-send-input)
+    (org-babel-comint-wait-for-output buffer)))
+
+(defun org-babel-comint-wait-for-output (buffer)
+  "Wait until output arrives from BUFFER.
+Note: this is only safe when waiting for the result of a single
+statement (not large blocks of code)."
+  (org-babel-comint-in-buffer buffer
+    (while (progn
+             (goto-char comint-last-input-end)
+             (not (and (re-search-forward comint-prompt-regexp nil t)
+                       (goto-char (match-beginning 0))
+                       (string= (face-name (face-at-point))
+                                "comint-highlight-prompt"))))
+      (accept-process-output (get-buffer-process buffer)))))
+
+(defun org-babel-comint-eval-invisibly-and-wait-for-file
+  (buffer file string &optional period)
+  "Evaluate STRING in BUFFER invisibly.
+Don't return until FILE exists.  Code in STRING must ensure that
+FILE exists at end of evaluation."
+  (unless (org-babel-comint-buffer-livep buffer)
+    (error "Buffer %s does not exist or has no process" buffer))
+  (if (file-exists-p file) (delete-file file))
+  (process-send-string
+   (get-buffer-process buffer)
+   (if (string-match "\n$" string) string (concat string "\n")))
+  ;; From Tramp 2.1.19 the following cache flush is not necessary
+  (if (file-remote-p default-directory)
+      (let (v)
+       (with-parsed-tramp-file-name default-directory nil
+                                    (tramp-flush-directory-property v ""))))
+  (while (not (file-exists-p file)) (sit-for (or period 0.25))))
+
+(provide 'ob-comint)
+
+
+
+;;; ob-comint.el ends here
diff --git a/elisp/org/ob-core.el b/elisp/org/ob-core.el
new file mode 100644 (file)
index 0000000..3278bf9
--- /dev/null
@@ -0,0 +1,2637 @@
+;;; ob-core.el --- working with code blocks in org-mode
+
+;; Copyright (C) 2009-2012  Free Software Foundation, Inc.
+
+;; Authors: Eric Schulte
+;;     Dan Davison
+;; Keywords: literate programming, reproducible research
+;; Homepage: http://orgmode.org
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
+
+;;; Code:
+(eval-when-compile
+  (require 'cl))
+(require 'ob-eval)
+(require 'org-macs)
+(require 'org-compat)
+
+(defconst org-babel-exeext
+  (if (memq system-type '(windows-nt cygwin))
+      ".exe"
+    nil))
+(defvar org-babel-call-process-region-original)
+(defvar org-src-lang-modes)
+(defvar org-babel-library-of-babel)
+(declare-function show-all "outline" ())
+(declare-function org-reduce "org" (CL-FUNC CL-SEQ &rest CL-KEYS))
+(declare-function org-mark-ring-push "org" (&optional pos buffer))
+(declare-function tramp-compat-make-temp-file "tramp-compat"
+                  (filename &optional dir-flag))
+(declare-function tramp-dissect-file-name "tramp" (name &optional nodefault))
+(declare-function tramp-file-name-user "tramp" (vec))
+(declare-function tramp-file-name-host "tramp" (vec))
+(declare-function with-parsed-tramp-file-name "tramp" (filename var &rest body))
+(declare-function org-icompleting-read "org" (&rest args))
+(declare-function org-edit-src-code "org-src"
+                  (&optional context code edit-buffer-name quietp))
+(declare-function org-edit-src-exit "org-src"  (&optional context))
+(declare-function org-open-at-point "org" (&optional in-emacs reference-buffer))
+(declare-function org-save-outline-visibility "org-macs" (use-markers &rest body))
+(declare-function org-outline-overlay-data "org" (&optional use-markers))
+(declare-function org-set-outline-overlay-data "org" (data))
+(declare-function org-narrow-to-subtree "org" ())
+(declare-function org-split-string "org" (string &optional separators))
+(declare-function org-entry-get "org"
+                 (pom property &optional inherit literal-nil))
+(declare-function org-make-options-regexp "org" (kwds &optional extra))
+(declare-function org-do-remove-indentation "org" (&optional n))
+(declare-function org-next-block "org" (arg &optional backward block-regexp))
+(declare-function org-previous-block "org" (arg &optional block-regexp))
+(declare-function org-show-context "org" (&optional key))
+(declare-function org-at-table-p "org" (&optional table-type))
+(declare-function org-cycle "org" (&optional arg))
+(declare-function org-uniquify "org" (list))
+(declare-function org-current-level "org" ())
+(declare-function org-table-import "org-table" (file arg))
+(declare-function org-add-hook "org-compat"
+                 (hook function &optional append local))
+(declare-function org-table-align "org-table" ())
+(declare-function org-table-end "org-table" (&optional table-type))
+(declare-function orgtbl-to-generic "org-table" (table params))
+(declare-function orgtbl-to-orgtbl "org-table" (table params))
+(declare-function org-babel-tangle-comment-links "ob-tangle" (&optional info))
+(declare-function org-babel-lob-get-info "ob-lob" nil)
+(declare-function org-babel-ref-split-args "ob-ref" (arg-string))
+(declare-function org-babel-ref-parse "ob-ref" (assignment))
+(declare-function org-babel-ref-resolve "ob-ref" (ref))
+(declare-function org-babel-ref-goto-headline-id "ob-ref" (id))
+(declare-function org-babel-ref-headline-body "ob-ref" ())
+(declare-function org-babel-lob-execute-maybe "ob-lob" ())
+(declare-function org-number-sequence "org-compat" (from &optional to inc))
+(declare-function org-at-item-p "org-list" ())
+(declare-function org-list-parse-list "org-list" (&optional delete))
+(declare-function org-list-to-generic "org-list" (LIST PARAMS))
+(declare-function org-list-struct "org-list" ())
+(declare-function org-list-prevs-alist "org-list" (struct))
+(declare-function org-list-get-list-end "org-list" (item struct prevs))
+(declare-function org-remove-if "org" (predicate seq))
+(declare-function org-completing-read "org" (&rest args))
+(declare-function org-escape-code-in-region "org-src" (beg end))
+(declare-function org-unescape-code-in-string "org-src" (s))
+(declare-function org-table-to-lisp "org-table" (&optional txt))
+(declare-function org-reverse-string "org" (string))
+
+(defgroup org-babel nil
+  "Code block evaluation and management in `org-mode' documents."
+  :tag "Babel"
+  :group 'org)
+
+(defcustom org-confirm-babel-evaluate t
+  "Confirm before evaluation.
+Require confirmation before interactively evaluating code
+blocks in Org-mode buffers.  The default value of this variable
+is t, meaning confirmation is required for any code block
+evaluation.  This variable can be set to nil to inhibit any
+future confirmation requests.  This variable can also be set to a
+function which takes two arguments the language of the code block
+and the body of the code block.  Such a function should then
+return a non-nil value if the user should be prompted for
+execution or nil if no prompt is required.
+
+Warning: Disabling confirmation may result in accidental
+evaluation of potentially harmful code.  It may be advisable
+remove code block execution from C-c C-c as further protection
+against accidental code block evaluation.  The
+`org-babel-no-eval-on-ctrl-c-ctrl-c' variable can be used to
+remove code block execution from the C-c C-c keybinding."
+  :group 'org-babel
+  :version "24.1"
+  :type '(choice boolean function))
+;; don't allow this variable to be changed through file settings
+(put 'org-confirm-babel-evaluate 'safe-local-variable (lambda (x) (eq x t)))
+
+(defcustom org-babel-no-eval-on-ctrl-c-ctrl-c nil
+  "Remove code block evaluation from the C-c C-c key binding."
+  :group 'org-babel
+  :version "24.1"
+  :type 'boolean)
+
+(defcustom org-babel-results-keyword "RESULTS"
+  "Keyword used to name results generated by code blocks.
+Should be either RESULTS or NAME however any capitalization may
+be used."
+  :group 'org-babel
+  :type 'string)
+
+(defcustom org-babel-noweb-wrap-start "<<"
+  "String used to begin a noweb reference in a code block.
+See also `org-babel-noweb-wrap-end'."
+  :group 'org-babel
+  :type 'string)
+
+(defcustom org-babel-noweb-wrap-end ">>"
+  "String used to end a noweb reference in a code block.
+See also `org-babel-noweb-wrap-start'."
+  :group 'org-babel
+  :type 'string)
+
+(defun org-babel-noweb-wrap (&optional regexp)
+  (concat org-babel-noweb-wrap-start
+         (or regexp "\\([^ \t\n].+?[^ \t]\\|[^ \t\n]\\)")
+         org-babel-noweb-wrap-end))
+
+(defvar org-babel-src-name-regexp
+  "^[ \t]*#\\+name:[ \t]*"
+  "Regular expression used to match a source name line.")
+
+(defvar org-babel-multi-line-header-regexp
+  "^[ \t]*#\\+headers?:[ \t]*\\([^\n]*\\)$"
+  "Regular expression used to match multi-line header arguments.")
+
+(defvar org-babel-src-name-w-name-regexp
+  (concat org-babel-src-name-regexp
+         "\\("
+         org-babel-multi-line-header-regexp
+         "\\)*"
+         "\\([^ ()\f\t\n\r\v]+\\)\\(\(\\(.*\\)\)\\|\\)")
+  "Regular expression matching source name lines with a name.")
+
+(defvar org-babel-src-block-regexp
+  (concat
+   ;; (1) indentation                 (2) lang
+   "^\\([ \t]*\\)#\\+begin_src[ \t]+\\([^ \f\t\n\r\v]+\\)[ \t]*"
+   ;; (3) switches
+   "\\([^\":\n]*\"[^\"\n*]*\"[^\":\n]*\\|[^\":\n]*\\)"
+   ;; (4) header arguments
+   "\\([^\n]*\\)\n"
+   ;; (5) body
+   "\\([^\000]*?\n\\)?[ \t]*#\\+end_src")
+  "Regexp used to identify code blocks.")
+
+(defvar org-babel-inline-src-block-regexp
+  (concat
+   ;; (1) replacement target (2) lang
+   "\\(?:^\\|[^-[:alnum:]]\\)\\(src_\\([^ \f\t\n\r\v]+\\)"
+   ;; (3,4) (unused, headers)
+   "\\(\\|\\[\\(.*?\\)\\]\\)"
+   ;; (5) body
+   "{\\([^\f\n\r\v]+?\\)}\\)")
+  "Regexp used to identify inline src-blocks.")
+
+(defun org-babel-get-header (params key &optional others)
+  "Select only header argument of type KEY from a list.
+Optional argument OTHERS indicates that only the header that do
+not match KEY should be returned."
+  (delq nil
+       (mapcar
+        (lambda (p) (when (funcall (if others #'not #'identity) (eq (car p) key)) p))
+        params)))
+
+(defun org-babel-get-inline-src-block-matches()
+  "Set match data if within body of an inline source block.
+Returns non-nil if match-data set"
+  (let ((src-at-0-p (save-excursion
+                     (beginning-of-line 1)
+                     (string= "src" (thing-at-point 'word))))
+       (first-line-p (= 1 (line-number-at-pos)))
+       (orig (point)))
+    (let ((search-for (cond ((and src-at-0-p first-line-p  "src_"))
+                           (first-line-p "[[:punct:] \t]src_")
+                           (t "[[:punct:] \f\t\n\r\v]src_")))
+         (lower-limit (if first-line-p
+                          nil
+                        (- (point-at-bol) 1))))
+      (save-excursion
+       (when (or (and src-at-0-p (bobp))
+                 (and (re-search-forward "}" (point-at-eol) t)
+                      (re-search-backward search-for lower-limit t)
+                      (> orig (point))))
+         (when (looking-at org-babel-inline-src-block-regexp)
+           t ))))))
+
+(defvar org-babel-inline-lob-one-liner-regexp)
+(defun org-babel-get-lob-one-liner-matches()
+  "Set match data if on line of an lob one liner.
+Returns non-nil if match-data set"
+  (save-excursion
+    (unless (= (point) (point-at-bol)) ;; move before inline block
+      (re-search-backward "[ \f\t\n\r\v]" nil t))
+    (if (looking-at org-babel-inline-lob-one-liner-regexp)
+       t
+      nil)))
+
+(defun org-babel-get-src-block-info (&optional light)
+  "Get information on the current source block.
+
+Optional argument LIGHT does not resolve remote variable
+references; a process which could likely result in the execution
+of other code blocks.
+
+Returns a list
+ (language body header-arguments-alist switches name indent)."
+  (let ((case-fold-search t) head info name indent)
+    ;; full code block
+    (if (setq head (org-babel-where-is-src-block-head))
+       (save-excursion
+         (goto-char head)
+         (setq info (org-babel-parse-src-block-match))
+         (setq indent (car (last info)))
+         (setq info (butlast info))
+         (while (and (forward-line -1)
+                     (looking-at org-babel-multi-line-header-regexp))
+           (setf (nth 2 info)
+                 (org-babel-merge-params
+                  (nth 2 info)
+                  (org-babel-parse-header-arguments (match-string 1)))))
+         (when (looking-at org-babel-src-name-w-name-regexp)
+           (setq name (org-no-properties (match-string 3)))
+           (when (and (match-string 5) (> (length (match-string 5)) 0))
+             (setf (nth 2 info) ;; merge functional-syntax vars and header-args
+                   (org-babel-merge-params
+                    (mapcar
+                     (lambda (ref) (cons :var ref))
+                     (mapcar
+                      (lambda (var) ;; check that each variable is initialized
+                        (if (string-match ".+=.+" var)
+                            var
+                          (error
+                           "variable \"%s\"%s must be assigned a default value"
+                           var (if name (format " in block \"%s\"" name) ""))))
+                      (org-babel-ref-split-args (match-string 5))))
+                    (nth 2 info))))))
+      ;; inline source block
+      (when (org-babel-get-inline-src-block-matches)
+       (setq info (org-babel-parse-inline-src-block-match))))
+    ;; resolve variable references and add summary parameters
+    (when (and info (not light))
+      (setf (nth 2 info) (org-babel-process-params (nth 2 info))))
+    (when info (append info (list name indent)))))
+
+(defvar org-current-export-file) ; dynamically bound
+(defun org-babel-confirm-evaluate (info)
+  "Confirm evaluation of the code block INFO.
+This behavior can be suppressed by setting the value of
+`org-confirm-babel-evaluate' to nil, in which case all future
+interactive code block evaluations will proceed without any
+confirmation from the user.
+
+Note disabling confirmation may result in accidental evaluation
+of potentially harmful code."
+  (let* ((eval (or (cdr (assoc :eval (nth 2 info)))
+                  (when (assoc :noeval (nth 2 info)) "no")))
+         (query (cond ((equal eval "query") t)
+                     ((and (boundp 'org-current-export-file)
+                           org-current-export-file
+                           (equal eval "query-export")) t)
+                      ((functionp org-confirm-babel-evaluate)
+                       (funcall org-confirm-babel-evaluate
+                                (nth 0 info) (nth 1 info)))
+                      (t org-confirm-babel-evaluate))))
+    (if (or (equal eval "never") (equal eval "no")
+           (and (boundp 'org-current-export-file)
+                org-current-export-file
+                (or (equal eval "no-export")
+                    (equal eval "never-export")))
+           (and query
+                (not (yes-or-no-p
+                      (format "Evaluate this%scode block%son your system? "
+                              (if info (format " %s " (nth 0 info)) " ")
+                              (if (nth 4 info)
+                                  (format " (%s) " (nth 4 info)) " "))))))
+       (prog1 nil (message "Evaluation %s"
+                           (if (or (equal eval "never") (equal eval "no")
+                                   (equal eval "no-export")
+                                   (equal eval "never-export"))
+                               "Disabled" "Aborted")))
+      t)))
+
+;;;###autoload
+(defun org-babel-execute-safely-maybe ()
+  (unless org-babel-no-eval-on-ctrl-c-ctrl-c
+    (org-babel-execute-maybe)))
+
+(add-hook 'org-ctrl-c-ctrl-c-hook 'org-babel-execute-safely-maybe)
+
+;;;###autoload
+(defun org-babel-execute-maybe ()
+  (interactive)
+  (or (org-babel-execute-src-block-maybe)
+      (org-babel-lob-execute-maybe)))
+
+(defun org-babel-execute-src-block-maybe ()
+  "Conditionally execute a source block.
+Detect if this is context for a Babel src-block and if so
+then run `org-babel-execute-src-block'."
+  (interactive)
+  (let ((info (org-babel-get-src-block-info)))
+    (if info
+       (progn (org-babel-eval-wipe-error-buffer)
+              (org-babel-execute-src-block current-prefix-arg info) t) nil)))
+
+;;;###autoload
+(defun org-babel-view-src-block-info ()
+  "Display information on the current source block.
+This includes header arguments, language and name, and is largely
+a window into the `org-babel-get-src-block-info' function."
+  (interactive)
+  (let ((info (org-babel-get-src-block-info 'light))
+       (full (lambda (it) (> (length it) 0)))
+       (printf (lambda (fmt &rest args) (princ (apply #'format fmt args)))))
+    (when info
+      (with-help-window (help-buffer)
+       (let ((name        (nth 4 info))
+             (lang        (nth 0 info))
+             (switches    (nth 3 info))
+             (header-args (nth 2 info)))
+         (when name            (funcall printf "Name: %s\n"     name))
+         (when lang            (funcall printf "Lang: %s\n"     lang))
+         (when (funcall full switches) (funcall printf "Switches: %s\n" switches))
+         (funcall printf "Header Arguments:\n")
+         (dolist (pair (sort header-args
+                             (lambda (a b) (string< (symbol-name (car a))
+                                                    (symbol-name (car b))))))
+           (when (funcall full (cdr pair))
+             (funcall printf "\t%S%s\t%s\n"
+                      (car pair)
+                      (if (> (length (format "%S" (car pair))) 7) "" "\t")
+                      (cdr pair)))))))))
+
+;;;###autoload
+(defun org-babel-expand-src-block-maybe ()
+  "Conditionally expand a source block.
+Detect if this is context for a org-babel src-block and if so
+then run `org-babel-expand-src-block'."
+  (interactive)
+  (let ((info (org-babel-get-src-block-info)))
+    (if info
+       (progn (org-babel-expand-src-block current-prefix-arg info) t)
+      nil)))
+
+;;;###autoload
+(defun org-babel-load-in-session-maybe ()
+  "Conditionally load a source block in a session.
+Detect if this is context for a org-babel src-block and if so
+then run `org-babel-load-in-session'."
+  (interactive)
+  (let ((info (org-babel-get-src-block-info)))
+    (if info
+       (progn (org-babel-load-in-session current-prefix-arg info) t)
+      nil)))
+
+(add-hook 'org-metaup-hook 'org-babel-load-in-session-maybe)
+
+;;;###autoload
+(defun org-babel-pop-to-session-maybe ()
+  "Conditionally pop to a session.
+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)
+
+(defconst org-babel-common-header-args-w-values
+  '((cache     . ((no yes)))
+    (cmdline   . :any)
+    (colnames  . ((nil no yes)))
+    (comments  . ((no link yes org both noweb)))
+    (dir       . :any)
+    (eval      . ((never query)))
+    (exports   . ((code results both none)))
+    (file      . :any)
+    (file-desc  . :any)
+    (hlines    . ((no yes)))
+    (mkdirp    . ((yes no)))
+    (no-expand)
+    (noeval)
+    (noweb     . ((yes no tangle no-export strip-export)))
+    (noweb-ref . :any)
+    (noweb-sep  . :any)
+    (padline   . ((yes no)))
+    (results   . ((file list vector table scalar verbatim)
+                  (raw html latex org code pp drawer)
+                  (replace silent none append prepend)
+                  (output value)))
+    (rownames  . ((no yes)))
+    (sep       . :any)
+    (session   . :any)
+    (shebang   . :any)
+    (tangle    . ((tangle yes no :any)))
+    (var       . :any)
+    (wrap       . :any)))
+
+(defconst org-babel-header-arg-names
+  (mapcar #'car org-babel-common-header-args-w-values)
+  "Common header arguments used by org-babel.
+Note that individual languages may define their own language
+specific header arguments as well.")
+
+(defvar org-babel-default-header-args
+  '((:session . "none") (:results . "replace") (:exports . "code")
+    (:cache . "no") (:noweb . "no") (:hlines . "no") (:tangle . "no")
+    (:padnewline . "yes"))
+  "Default arguments to use when evaluating a source block.")
+
+(defvar org-babel-default-inline-header-args
+  '((:session . "none") (:results . "replace") (:exports . "results"))
+  "Default arguments to use when evaluating an inline source block.")
+
+(defvar org-babel-data-names '("tblname" "results" "name"))
+
+(defvar org-babel-result-regexp
+  (concat "^[ \t]*#\\+"
+         (regexp-opt org-babel-data-names t)
+         "\\(\\[\\("
+         ;; FIXME The string below is `org-ts-regexp'
+         "<\\([0-9]\\{4\\}-[0-9]\\{2\\}-[0-9]\\{2\\} ?[^\r\n>]*?\\)>"
+         " \\)?\\([[:alnum:]]+\\)\\]\\)?\\:[ \t]*")
+  "Regular expression used to match result lines.
+If the results are associated with a hash key then the hash will
+be saved in the second match data.")
+
+(defvar org-babel-result-w-name-regexp
+  (concat org-babel-result-regexp
+         "\\([^ ()\f\t\n\r\v]+\\)\\(\(\\(.*\\)\)\\|\\)"))
+
+(defvar org-babel-min-lines-for-block-output 10
+  "The minimum number of lines for block output.
+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.")
+
+(defvar org-babel-noweb-error-langs nil
+  "Languages for which Babel will raise literate programming errors.
+List of languages for which errors should be raised when the
+source code block satisfying a noweb reference in this language
+can not be resolved.")
+
+(defvar org-babel-hash-show 4
+  "Number of initial characters to show of a hidden results hash.")
+
+(defvar org-babel-hash-show-time nil
+  "When not nil show the time the code block was evaluated in the result hash.")
+
+(defvar org-babel-after-execute-hook nil
+  "Hook for functions to be called after `org-babel-execute-src-block'")
+
+(defun org-babel-named-src-block-regexp-for-name (name)
+  "This generates a regexp used to match a src block named NAME."
+  (concat org-babel-src-name-regexp (regexp-quote name)
+         "[ \t(]*[\r\n]\\(?:^#.*[\r\n]\\)*"
+         (substring org-babel-src-block-regexp 1)))
+
+(defun org-babel-named-data-regexp-for-name (name)
+  "This generates a regexp used to match data named NAME."
+  (concat org-babel-result-regexp (regexp-quote name) "\\([ \t]\\|$\\)"))
+
+;;; functions
+(defvar call-process-region)
+
+;;;###autoload
+(defun org-babel-execute-src-block (&optional arg info params)
+  "Execute the current source code block.
+Insert the results of execution into the buffer.  Source code
+execution and the collection and formatting of results can be
+controlled through a variety of header arguments.
+
+With prefix argument ARG, force re-execution even if an existing
+result cached in the buffer would otherwise have been returned.
+
+Optionally supply a value for INFO in the form returned by
+`org-babel-get-src-block-info'.
+
+Optionally supply a value for PARAMS which will be merged with
+the header arguments specified at the front of the source code
+block."
+  (interactive)
+  (let ((info (or info (org-babel-get-src-block-info))))
+    (when (org-babel-confirm-evaluate
+          (let ((i info))
+            (setf (nth 2 i) (org-babel-merge-params (nth 2 info) params))
+            i))
+      (let* ((lang (nth 0 info))
+            (params (if params
+                        (org-babel-process-params
+                         (org-babel-merge-params (nth 2 info) params))
+                      (nth 2 info)))
+            (cache? (and (not arg) (cdr (assoc :cache params))
+                         (string= "yes" (cdr (assoc :cache params)))))
+            (result-params (cdr (assoc :result-params params)))
+            (new-hash (when cache? (org-babel-sha1-hash info)))
+            (old-hash (when cache? (org-babel-current-result-hash)))
+            (body (setf (nth 1 info)
+                        (if (org-babel-noweb-p params :eval)
+                            (org-babel-expand-noweb-references info)
+                          (nth 1 info))))
+            (dir (cdr (assoc :dir params)))
+            (default-directory
+              (or (and dir (file-name-as-directory (expand-file-name dir)))
+                  default-directory))
+            (org-babel-call-process-region-original
+             (if (boundp 'org-babel-call-process-region-original)
+                 org-babel-call-process-region-original
+               (symbol-function 'call-process-region)))
+            (indent (car (last info)))
+            result cmd)
+       (unwind-protect
+           (let ((call-process-region
+                  (lambda (&rest args)
+                    (apply 'org-babel-tramp-handle-call-process-region args))))
+             (let ((lang-check (lambda (f)
+                                 (let ((f (intern (concat "org-babel-execute:" f))))
+                                   (when (fboundp f) f)))))
+               (setq cmd
+                     (or (funcall lang-check lang)
+                         (funcall lang-check (symbol-name
+                                              (cdr (assoc lang org-src-lang-modes))))
+                         (error "No org-babel-execute function for %s!" lang))))
+             (if (and (not arg) new-hash (equal new-hash old-hash))
+                 (save-excursion ;; return cached result
+                   (goto-char (org-babel-where-is-src-block-result nil info))
+                   (end-of-line 1) (forward-char 1)
+                   (setq result (org-babel-read-result))
+                   (message (replace-regexp-in-string
+                             "%" "%%" (format "%S" result))) result)
+               (message "executing %s code block%s..."
+                        (capitalize lang)
+                        (if (nth 4 info) (format " (%s)" (nth 4 info)) ""))
+               (if (member "none" result-params)
+                   (progn
+                     (funcall cmd body params)
+                     (message "result silenced"))
+               (setq result
+                     ((lambda (result)
+                        (if (and (eq (cdr (assoc :result-type params)) 'value)
+                                 (or (member "vector" result-params)
+                                     (member "table" result-params))
+                                 (not (listp result)))
+                            (list (list result)) result))
+                      (funcall cmd body params)))
+               ;; if non-empty result and :file then write to :file
+               (when (cdr (assoc :file params))
+                 (when result
+                   (with-temp-file (cdr (assoc :file params))
+                     (insert
+                      (org-babel-format-result
+                       result (cdr (assoc :sep (nth 2 info)))))))
+                 (setq result (cdr (assoc :file params))))
+               (org-babel-insert-result
+                result result-params info new-hash indent lang)
+               (run-hooks 'org-babel-after-execute-hook)
+               result
+               )))
+         (setq call-process-region 'org-babel-call-process-region-original))))))
+
+(defun org-babel-expand-body:generic (body params &optional var-lines)
+  "Expand BODY with PARAMS.
+Expand a block of code with org-babel according to its header
+arguments.  This generic implementation of body expansion is
+called for languages which have not defined their own specific
+org-babel-expand-body:lang function."
+  (mapconcat #'identity (append var-lines (list body)) "\n"))
+
+;;;###autoload
+(defun org-babel-expand-src-block (&optional arg info params)
+  "Expand the current source code block.
+Expand according to the source code block's header
+arguments and pop open the results in a preview buffer."
+  (interactive)
+  (let* ((info (or info (org-babel-get-src-block-info)))
+         (lang (nth 0 info))
+        (params (setf (nth 2 info)
+                       (sort (org-babel-merge-params (nth 2 info) params)
+                             (lambda (el1 el2) (string< (symbol-name (car el1))
+                                                       (symbol-name (car el2)))))))
+         (body (setf (nth 1 info)
+                    (if (org-babel-noweb-p params :eval)
+                        (org-babel-expand-noweb-references info) (nth 1 info))))
+         (expand-cmd (intern (concat "org-babel-expand-body:" lang)))
+        (assignments-cmd (intern (concat "org-babel-variable-assignments:"
+                                         lang)))
+         (expanded
+         (if (fboundp expand-cmd) (funcall expand-cmd body params)
+           (org-babel-expand-body:generic
+            body params (and (fboundp assignments-cmd)
+                             (funcall assignments-cmd params))))))
+    (if (called-interactively-p 'any)
+       (org-edit-src-code
+        nil expanded
+        (concat "*Org-Babel Preview " (buffer-name) "[ " lang " ]*"))
+      expanded)))
+
+(defun org-babel-edit-distance (s1 s2)
+  "Return the edit (levenshtein) distance between strings S1 S2."
+  (let* ((l1 (length s1))
+        (l2 (length s2))
+        (dist (vconcat (mapcar (lambda (_) (make-vector (1+ l2) nil))
+                               (number-sequence 1 (1+ l1)))))
+        (in (lambda (i j) (aref (aref dist i) j))))
+    (setf (aref (aref dist 0) 0) 0)
+    (dolist (j (number-sequence 1 l2))
+      (setf (aref (aref dist 0) j) j))
+    (dolist (i (number-sequence 1 l1))
+      (setf (aref (aref dist i) 0) i)
+      (dolist (j (number-sequence 1 l2))
+       (setf (aref (aref dist i) j)
+             (min
+              (1+ (funcall in (1- i) j))
+              (1+ (funcall in i (1- j)))
+              (+ (if (equal (aref s1 (1- i)) (aref s2 (1- j))) 0 1)
+                 (funcall in (1- i) (1- j)))))))
+    (funcall in l1 l2)))
+
+(defun org-babel-combine-header-arg-lists (original &rest others)
+  "Combine a number of lists of header argument names and arguments."
+  (let ((results (copy-sequence original)))
+    (dolist (new-list others)
+      (dolist (arg-pair new-list)
+       (let ((header (car arg-pair))
+             (args (cdr arg-pair)))
+         (setq results
+               (cons arg-pair (org-remove-if
+                               (lambda (pair) (equal header (car pair)))
+                               results))))))
+    results))
+
+;;;###autoload
+(defun org-babel-check-src-block ()
+  "Check for misspelled header arguments in the current code block."
+  (interactive)
+  ;; TODO: report malformed code block
+  ;; TODO: report incompatible combinations of header arguments
+  ;; TODO: report uninitialized variables
+  (let ((too-close 2) ;; <- control closeness to report potential match
+       (names (mapcar #'symbol-name org-babel-header-arg-names)))
+    (dolist (header (mapcar (lambda (arg) (substring (symbol-name (car arg)) 1))
+                           (and (org-babel-where-is-src-block-head)
+                                (org-babel-parse-header-arguments
+                                 (org-no-properties
+                                  (match-string 4))))))
+      (dolist (name names)
+       (when (and (not (string= header name))
+                  (<= (org-babel-edit-distance header name) too-close)
+                  (not (member header names)))
+         (error "Supplied header \"%S\" is suspiciously close to \"%S\""
+                header name))))
+    (message "No suspicious header arguments found.")))
+
+;;;###autoload
+(defun org-babel-insert-header-arg ()
+  "Insert a header argument selecting from lists of common args and values."
+  (interactive)
+  (let* ((lang (car (org-babel-get-src-block-info 'light)))
+        (lang-headers (intern (concat "org-babel-header-args:" lang)))
+        (headers (org-babel-combine-header-arg-lists
+                  org-babel-common-header-args-w-values
+                  (if (boundp lang-headers) (eval lang-headers) nil)))
+        (arg (org-icompleting-read
+              "Header Arg: "
+              (mapcar
+               (lambda (header-spec) (symbol-name (car header-spec)))
+               headers))))
+    (insert ":" arg)
+    (let ((vals (cdr (assoc (intern arg) headers))))
+      (when vals
+       (insert
+        " "
+        (cond
+         ((eq vals :any)
+          (read-from-minibuffer "value: "))
+         ((listp vals)
+          (mapconcat
+           (lambda (group)
+             (let ((arg (org-icompleting-read
+                         "value: "
+                         (cons "default" (mapcar #'symbol-name group)))))
+               (if (and arg (not (string= "default" arg)))
+                   (concat arg " ")
+                 "")))
+           vals ""))))))))
+
+;; Add support for completing-read insertion of header arguments after ":"
+(defun org-babel-header-arg-expand ()
+  "Call `org-babel-enter-header-arg-w-completion' in appropriate contexts."
+  (when (and (equal (char-before) ?\:) (org-babel-where-is-src-block-head))
+    (org-babel-enter-header-arg-w-completion (match-string 2))))
+
+(defun org-babel-enter-header-arg-w-completion (&optional lang)
+  "Insert header argument appropriate for LANG with completion."
+  (let* ((lang-headers-var (intern (concat "org-babel-header-args:" lang)))
+         (lang-headers (when (boundp lang-headers-var) (eval lang-headers-var)))
+        (headers-w-values (org-babel-combine-header-arg-lists
+                           org-babel-common-header-args-w-values lang-headers))
+         (headers (mapcar #'symbol-name (mapcar #'car headers-w-values)))
+         (header (org-completing-read "Header Arg: " headers))
+         (args (cdr (assoc (intern header) headers-w-values)))
+         (arg (when (and args (listp args))
+                (org-completing-read
+                 (format "%s: " header)
+                 (mapcar #'symbol-name (apply #'append args))))))
+    (insert (concat header " " (or arg "")))
+    (cons header arg)))
+
+(add-hook 'org-tab-first-hook 'org-babel-header-arg-expand)
+
+;;;###autoload
+(defun org-babel-load-in-session (&optional arg info)
+  "Load the body of the current source-code block.
+Evaluate the header arguments for the source block before
+entering the session.  After loading the body this pops open the
+session."
+  (interactive)
+  (let* ((info (or info (org-babel-get-src-block-info)))
+         (lang (nth 0 info))
+         (params (nth 2 info))
+         (body (setf (nth 1 info)
+                    (if (org-babel-noweb-p params :eval)
+                         (org-babel-expand-noweb-references info)
+                      (nth 1 info))))
+         (session (cdr (assoc :session params)))
+        (dir (cdr (assoc :dir params)))
+        (default-directory
+          (or (and dir (file-name-as-directory dir)) default-directory))
+        (cmd (intern (concat "org-babel-load-session:" lang))))
+    (unless (fboundp cmd)
+      (error "No org-babel-load-session function for %s!" lang))
+    (pop-to-buffer (funcall cmd session body params))
+    (end-of-line 1)))
+
+;;;###autoload
+(defun org-babel-initiate-session (&optional arg info)
+  "Initiate session for current code block.
+If called with a prefix argument then resolve any variable
+references in the header arguments and assign these variables in
+the session.  Copy the body of the code block to the kill ring."
+  (interactive "P")
+  (let* ((info (or info (org-babel-get-src-block-info (not arg))))
+         (lang (nth 0 info))
+         (body (nth 1 info))
+         (params (nth 2 info))
+         (session (cdr (assoc :session params)))
+        (dir (cdr (assoc :dir params)))
+        (default-directory
+          (or (and dir (file-name-as-directory dir)) default-directory))
+        (init-cmd (intern (format "org-babel-%s-initiate-session" lang)))
+        (prep-cmd (intern (concat "org-babel-prep-session:" lang))))
+    (if (and (stringp session) (string= session "none"))
+       (error "This block is not using a session!"))
+    (unless (fboundp init-cmd)
+      (error "No org-babel-initiate-session function for %s!" lang))
+    (with-temp-buffer (insert (org-babel-trim body))
+                      (copy-region-as-kill (point-min) (point-max)))
+    (when arg
+      (unless (fboundp prep-cmd)
+       (error "No org-babel-prep-session function for %s!" lang))
+      (funcall prep-cmd session params))
+    (funcall init-cmd session params)))
+
+;;;###autoload
+(defun org-babel-switch-to-session (&optional arg info)
+  "Switch to the session of the current code block.
+Uses `org-babel-initiate-session' to start the session.  If called
+with a prefix argument then this is passed on to
+`org-babel-initiate-session'."
+  (interactive "P")
+  (pop-to-buffer (org-babel-initiate-session arg info))
+  (end-of-line 1))
+
+(defalias 'org-babel-pop-to-session 'org-babel-switch-to-session)
+
+;;;###autoload
+(defun org-babel-switch-to-session-with-code (&optional arg info)
+  "Switch to code buffer and display session."
+  (interactive "P")
+  (let ((swap-windows
+        (lambda ()
+          (let ((other-window-buffer (window-buffer (next-window))))
+            (set-window-buffer (next-window) (current-buffer))
+            (set-window-buffer (selected-window) other-window-buffer))
+          (other-window 1)))
+       (info (org-babel-get-src-block-info))
+       (org-src-window-setup 'reorganize-frame))
+    (save-excursion
+      (org-babel-switch-to-session arg info))
+    (org-edit-src-code)
+    (funcall swap-windows)))
+
+(defmacro org-babel-do-in-edit-buffer (&rest body)
+  "Evaluate BODY in edit buffer if there is a code block at point.
+Return t if a code block was found at point, nil otherwise."
+  `(let ((org-src-window-setup 'switch-invisibly))
+     (when (and (org-babel-where-is-src-block-head)
+               (org-edit-src-code nil nil nil))
+       (unwind-protect (progn ,@body)
+        (if (org-bound-and-true-p org-edit-src-from-org-mode)
+            (org-edit-src-exit)))
+       t)))
+(def-edebug-spec org-babel-do-in-edit-buffer (body))
+
+(defun org-babel-do-key-sequence-in-edit-buffer (key)
+  "Read key sequence and execute the command in edit buffer.
+Enter a key sequence to be executed in the language major-mode
+edit buffer.  For example, TAB will alter the contents of the
+Org-mode code block according to the effect of TAB in the
+language major-mode buffer.  For languages that support
+interactive sessions, this can be used to send code from the Org
+buffer to the session for evaluation using the native major-mode
+evaluation mechanisms."
+  (interactive "kEnter key-sequence to execute in edit buffer: ")
+  (org-babel-do-in-edit-buffer
+   (call-interactively
+    (key-binding (or key (read-key-sequence nil))))))
+
+(defvar org-bracket-link-regexp)
+
+;;;###autoload
+(defun org-babel-open-src-block-result (&optional re-run)
+  "If `point' is on a src block then open the results of the
+source code block, otherwise return nil.  With optional prefix
+argument RE-RUN the source-code block is evaluated even if
+results already exist."
+  (interactive "P")
+  (let ((info (org-babel-get-src-block-info)))
+    (when info
+      (save-excursion
+       ;; go to the results, if there aren't any then run the block
+       (goto-char (or (and (not re-run) (org-babel-where-is-src-block-result))
+                      (progn (org-babel-execute-src-block)
+                             (org-babel-where-is-src-block-result))))
+       (end-of-line 1)
+       (while (looking-at "[\n\r\t\f ]") (forward-char 1))
+       ;; open the results
+       (if (looking-at org-bracket-link-regexp)
+           ;; file results
+           (org-open-at-point)
+         (let ((r (org-babel-format-result
+                   (org-babel-read-result) (cdr (assoc :sep (nth 2 info))))))
+           (pop-to-buffer (get-buffer-create "*Org-Babel Results*"))
+           (delete-region (point-min) (point-max))
+           (insert r)))
+       t))))
+
+;;;###autoload
+(defmacro org-babel-map-src-blocks (file &rest body)
+  "Evaluate BODY forms on each source-block in FILE.
+If FILE is nil evaluate BODY forms on source blocks in current
+buffer.  During evaluation of BODY the following local variables
+are set relative to the currently matched code block.
+
+full-block ------- string holding the entirety of the code block
+beg-block -------- point at the beginning of the code block
+end-block -------- point at the end of the matched code block
+lang ------------- string holding the language of the code block
+beg-lang --------- point at the beginning of the lang
+end-lang --------- point at the end of the lang
+switches --------- string holding the switches
+beg-switches ----- point at the beginning of the switches
+end-switches ----- point at the end of the switches
+header-args ------ string holding the header-args
+beg-header-args -- point at the beginning of the header-args
+end-header-args -- point at the end of the header-args
+body ------------- string holding the body of the code block
+beg-body --------- point at the beginning of the body
+end-body --------- point at the end of the body"
+  (declare (indent 1))
+  (let ((tempvar (make-symbol "file")))
+    `(let* ((,tempvar ,file)
+           (visited-p (or (null ,tempvar)
+                          (get-file-buffer (expand-file-name ,tempvar))))
+           (point (point)) to-be-removed)
+       (save-window-excursion
+        (when ,tempvar (find-file ,tempvar))
+        (setq to-be-removed (current-buffer))
+        (goto-char (point-min))
+        (while (re-search-forward org-babel-src-block-regexp nil t)
+          (goto-char (match-beginning 0))
+          (let ((full-block (match-string 0))
+                (beg-block (match-beginning 0))
+                (end-block (match-end 0))
+                (lang (match-string 2))
+                (beg-lang (match-beginning 2))
+                (end-lang (match-end 2))
+                (switches (match-string 3))
+                (beg-switches (match-beginning 3))
+                (end-switches (match-end 3))
+                (header-args (match-string 4))
+                (beg-header-args (match-beginning 4))
+                (end-header-args (match-end 4))
+                (body (match-string 5))
+                (beg-body (match-beginning 5))
+                (end-body (match-end 5)))
+            ,@body
+            (goto-char end-block))))
+       (unless visited-p (kill-buffer to-be-removed))
+       (goto-char point))))
+(def-edebug-spec org-babel-map-src-blocks (form body))
+
+;;;###autoload
+(defmacro org-babel-map-inline-src-blocks (file &rest body)
+  "Evaluate BODY forms on each inline source-block in FILE.
+If FILE is nil evaluate BODY forms on source blocks in current
+buffer."
+  (declare (indent 1))
+  (let ((tempvar (make-symbol "file")))
+    `(let* ((,tempvar ,file)
+           (visited-p (or (null ,tempvar)
+                          (get-file-buffer (expand-file-name ,tempvar))))
+           (point (point)) to-be-removed)
+       (save-window-excursion
+        (when ,tempvar (find-file ,tempvar))
+        (setq to-be-removed (current-buffer))
+        (goto-char (point-min))
+        (while (re-search-forward org-babel-inline-src-block-regexp nil t)
+          (goto-char (match-beginning 1))
+          (save-match-data ,@body)
+          (goto-char (match-end 0))))
+       (unless visited-p (kill-buffer to-be-removed))
+       (goto-char point))))
+(def-edebug-spec org-babel-map-inline-src-blocks (form body))
+
+(defvar org-babel-lob-one-liner-regexp)
+
+;;;###autoload
+(defmacro org-babel-map-call-lines (file &rest body)
+  "Evaluate BODY forms on each call line in FILE.
+If FILE is nil evaluate BODY forms on source blocks in current
+buffer."
+  (declare (indent 1))
+  (let ((tempvar (make-symbol "file")))
+    `(let* ((,tempvar ,file)
+           (visited-p (or (null ,tempvar)
+                          (get-file-buffer (expand-file-name ,tempvar))))
+           (point (point)) to-be-removed)
+       (save-window-excursion
+        (when ,tempvar (find-file ,tempvar))
+        (setq to-be-removed (current-buffer))
+        (goto-char (point-min))
+        (while (re-search-forward org-babel-lob-one-liner-regexp nil t)
+          (goto-char (match-beginning 1))
+          (save-match-data ,@body)
+          (goto-char (match-end 0))))
+       (unless visited-p (kill-buffer to-be-removed))
+       (goto-char point))))
+(def-edebug-spec org-babel-map-call-lines (form body))
+
+;;;###autoload
+(defmacro org-babel-map-executables (file &rest body)
+  (declare (indent 1))
+  (let ((tempvar (make-symbol "file"))
+       (rx (make-symbol "rx")))
+    `(let* ((,tempvar ,file)
+           (,rx (concat "\\(" org-babel-src-block-regexp
+                        "\\|" org-babel-inline-src-block-regexp
+                        "\\|" org-babel-lob-one-liner-regexp "\\)"))
+           (visited-p (or (null ,tempvar)
+                          (get-file-buffer (expand-file-name ,tempvar))))
+           (point (point)) to-be-removed)
+       (save-window-excursion
+        (when ,tempvar (find-file ,tempvar))
+        (setq to-be-removed (current-buffer))
+        (goto-char (point-min))
+        (while (re-search-forward ,rx nil t)
+          (goto-char (match-beginning 1))
+          (when (looking-at org-babel-inline-src-block-regexp)(forward-char 1))
+          (save-match-data ,@body)
+          (goto-char (match-end 0))))
+       (unless visited-p (kill-buffer to-be-removed))
+       (goto-char point))))
+(def-edebug-spec org-babel-map-executables (form body))
+
+;;;###autoload
+(defun org-babel-execute-buffer (&optional arg)
+  "Execute source code blocks in a buffer.
+Call `org-babel-execute-src-block' on every source block in
+the current buffer."
+  (interactive "P")
+  (org-babel-eval-wipe-error-buffer)
+  (org-save-outline-visibility t
+    (org-babel-map-executables nil
+      (if (looking-at org-babel-lob-one-liner-regexp)
+          (org-babel-lob-execute-maybe)
+        (org-babel-execute-src-block arg)))))
+
+;;;###autoload
+(defun org-babel-execute-subtree (&optional arg)
+  "Execute source code blocks in a subtree.
+Call `org-babel-execute-src-block' on every source block in
+the current subtree."
+  (interactive "P")
+  (save-restriction
+    (save-excursion
+      (org-narrow-to-subtree)
+      (org-babel-execute-buffer arg)
+      (widen))))
+
+;;;###autoload
+(defun org-babel-sha1-hash (&optional info)
+  "Generate an sha1 hash based on the value of info."
+  (interactive)
+  (let ((print-level nil)
+       (info (or info (org-babel-get-src-block-info))))
+    (setf (nth 2 info)
+         (sort (copy-sequence (nth 2 info))
+               (lambda (a b) (string< (car a) (car b)))))
+    (let* ((rm (lambda (lst)
+                (dolist (p '("replace" "silent" "none"
+                             "append" "prepend"))
+                  (setq lst (remove p lst)))
+                lst))
+          (norm (lambda (arg)
+                  (let ((v (if (and (listp (cdr arg)) (null (cddr arg)))
+                               (copy-sequence (cdr arg))
+                             (cdr arg))))
+                    (when (and v (not (and (sequencep v)
+                                           (not (consp v))
+                                           (= (length v) 0))))
+                      (cond
+                       ((and (listp v) ; lists are sorted
+                             (member (car arg) '(:result-params)))
+                        (sort (funcall rm v) #'string<))
+                       ((and (stringp v) ; strings are sorted
+                             (member (car arg) '(:results :exports)))
+                        (mapconcat #'identity (sort (funcall rm (split-string v))
+                                                    #'string<) " "))
+                       (t v)))))))
+      ((lambda (hash)
+        (when (org-called-interactively-p 'interactive) (message hash)) hash)
+       (let ((it (format "%s-%s"
+                        (mapconcat
+                         #'identity
+                         (delq nil (mapcar (lambda (arg)
+                                             (let ((normalized (funcall norm arg)))
+                                               (when normalized
+                                                 (format "%S" normalized))))
+                                           (nth 2 info))) ":")
+                        (nth 1 info))))
+        (sha1 it))))))
+
+(defun org-babel-current-result-hash ()
+  "Return the current in-buffer hash."
+  (org-babel-where-is-src-block-result)
+  (org-no-properties (match-string 5)))
+
+(defun org-babel-set-current-result-hash (hash)
+  "Set the current in-buffer hash to HASH."
+  (org-babel-where-is-src-block-result)
+  (save-excursion (goto-char (match-beginning 3))
+                 ;; (mapc #'delete-overlay (overlays-at (point)))
+                 (replace-match hash nil nil nil 3)
+                 (org-babel-hide-hash)))
+
+(defun org-babel-hide-hash ()
+  "Hide the hash in the current results line.
+Only the initial `org-babel-hash-show' characters of the hash
+will remain visible."
+  (add-to-invisibility-spec '(org-babel-hide-hash . t))
+  (save-excursion
+    (when (and (re-search-forward org-babel-result-regexp nil t)
+               (match-string 5))
+      (let* ((start (match-beginning 5))
+             (hide-start (+ org-babel-hash-show start))
+             (end (match-end 5))
+             (hash (match-string 5))
+             ov1 ov2)
+        (setq ov1 (make-overlay start hide-start))
+        (setq ov2 (make-overlay hide-start end))
+        (overlay-put ov2 'invisible 'org-babel-hide-hash)
+        (overlay-put ov1 'babel-hash hash)))))
+
+(defun org-babel-hide-all-hashes ()
+  "Hide the hash in the current buffer.
+Only the initial `org-babel-hash-show' characters of each hash
+will remain visible.  This function should be called as part of
+the `org-mode-hook'."
+  (save-excursion
+    (while (and (not org-babel-hash-show-time)
+               (re-search-forward org-babel-result-regexp nil t))
+      (goto-char (match-beginning 0))
+      (org-babel-hide-hash)
+      (goto-char (match-end 0)))))
+(add-hook 'org-mode-hook 'org-babel-hide-all-hashes)
+
+(defun org-babel-hash-at-point (&optional point)
+  "Return the value of the hash at POINT.
+The hash is also added as the last element of the kill ring.
+This can be called with C-c C-c."
+  (interactive)
+  (let ((hash (car (delq nil (mapcar
+                             (lambda (ol) (overlay-get ol 'babel-hash))
+                              (overlays-at (or point (point))))))))
+    (when hash (kill-new hash) (message hash))))
+(add-hook 'org-ctrl-c-ctrl-c-hook 'org-babel-hash-at-point)
+
+(defun org-babel-result-hide-spec ()
+  "Hide portions of results lines.
+Add `org-babel-hide-result' as an invisibility spec for hiding
+portions of results lines."
+  (add-to-invisibility-spec '(org-babel-hide-result . t)))
+(add-hook 'org-mode-hook 'org-babel-result-hide-spec)
+
+(defvar org-babel-hide-result-overlays nil
+  "Overlays hiding results.")
+
+(defun org-babel-result-hide-all ()
+  "Fold all results in the current buffer."
+  (interactive)
+  (org-babel-show-result-all)
+  (save-excursion
+    (while (re-search-forward org-babel-result-regexp nil t)
+      (save-excursion (goto-char (match-beginning 0))
+                      (org-babel-hide-result-toggle-maybe)))))
+
+(defun org-babel-show-result-all ()
+  "Unfold all results in the current buffer."
+  (mapc 'delete-overlay org-babel-hide-result-overlays)
+  (setq org-babel-hide-result-overlays nil))
+
+;;;###autoload
+(defun org-babel-hide-result-toggle-maybe ()
+  "Toggle visibility of result at point."
+  (interactive)
+  (let ((case-fold-search t))
+    (if (save-excursion
+          (beginning-of-line 1)
+          (looking-at org-babel-result-regexp))
+        (progn (org-babel-hide-result-toggle)
+               t) ;; to signal that we took action
+      nil))) ;; to signal that we did not
+
+(defun org-babel-hide-result-toggle (&optional force)
+  "Toggle the visibility of the current result."
+  (interactive)
+  (save-excursion
+    (beginning-of-line)
+    (if (re-search-forward org-babel-result-regexp nil t)
+        (let ((start (progn (beginning-of-line 2) (- (point) 1)))
+             (end (progn
+                    (while (looking-at org-babel-multi-line-header-regexp)
+                      (forward-line 1))
+                    (goto-char (- (org-babel-result-end) 1)) (point)))
+             ov)
+          (if (memq t (mapcar (lambda (overlay)
+                                (eq (overlay-get overlay 'invisible)
+                                   'org-babel-hide-result))
+                              (overlays-at start)))
+              (if (or (not force) (eq force 'off))
+                  (mapc (lambda (ov)
+                          (when (member ov org-babel-hide-result-overlays)
+                            (setq org-babel-hide-result-overlays
+                                  (delq ov org-babel-hide-result-overlays)))
+                          (when (eq (overlay-get ov 'invisible)
+                                    'org-babel-hide-result)
+                            (delete-overlay ov)))
+                        (overlays-at start)))
+            (setq ov (make-overlay start end))
+            (overlay-put ov 'invisible 'org-babel-hide-result)
+            ;; make the block accessible to isearch
+            (overlay-put
+             ov 'isearch-open-invisible
+             (lambda (ov)
+               (when (member ov org-babel-hide-result-overlays)
+                 (setq org-babel-hide-result-overlays
+                       (delq ov org-babel-hide-result-overlays)))
+               (when (eq (overlay-get ov 'invisible)
+                         'org-babel-hide-result)
+                 (delete-overlay ov))))
+            (push ov org-babel-hide-result-overlays)))
+      (error "Not looking at a result line"))))
+
+;; org-tab-after-check-for-cycling-hook
+(add-hook 'org-tab-first-hook 'org-babel-hide-result-toggle-maybe)
+;; Remove overlays when changing major mode
+(add-hook 'org-mode-hook
+         (lambda () (org-add-hook 'change-major-mode-hook
+                                  'org-babel-show-result-all 'append 'local)))
+
+(defvar org-file-properties)
+(defun org-babel-params-from-properties (&optional lang)
+  "Retrieve parameters specified as properties.
+Return an association list of any source block params which
+may be specified in the properties of the current outline entry."
+  (save-match-data
+    (let (val sym)
+      (org-babel-parse-multiple-vars
+       (delq nil
+            (mapcar
+             (lambda (header-arg)
+               (and (setq val (org-entry-get (point) header-arg t))
+                    (cons (intern (concat ":" header-arg))
+                          (org-babel-read val))))
+             (mapcar
+              #'symbol-name
+              (mapcar
+               #'car
+               (org-babel-combine-header-arg-lists
+                org-babel-common-header-args-w-values
+                (progn
+                  (setq sym (intern (concat "org-babel-header-args:" lang)))
+                  (and (boundp sym) (eval sym))))))))))))
+
+(defvar org-src-preserve-indentation)
+(defun org-babel-parse-src-block-match ()
+  "Parse the results from a match of the `org-babel-src-block-regexp'."
+  (let* ((block-indentation (length (match-string 1)))
+        (lang (org-no-properties (match-string 2)))
+         (lang-headers (intern (concat "org-babel-default-header-args:" lang)))
+        (switches (match-string 3))
+         (body (org-no-properties
+               (let* ((body (match-string 5))
+                      (sub-length (- (length body) 1)))
+                 (if (and (> sub-length 0)
+                          (string= "\n" (substring body sub-length)))
+                     (substring body 0 sub-length)
+                   (or body "")))))
+        (preserve-indentation (or org-src-preserve-indentation
+                                  (save-match-data
+                                    (string-match "-i\\>" switches)))))
+    (list lang
+          ;; get block body less properties, protective commas, and indentation
+          (with-temp-buffer
+            (save-match-data
+              (insert (org-unescape-code-in-string body))
+             (unless preserve-indentation (org-do-remove-indentation))
+              (buffer-string)))
+         (org-babel-merge-params
+          org-babel-default-header-args
+           (org-babel-params-from-properties lang)
+          (if (boundp lang-headers) (eval lang-headers) nil)
+          (org-babel-parse-header-arguments
+            (org-no-properties (or (match-string 4) ""))))
+         switches
+         block-indentation)))
+
+(defun org-babel-parse-inline-src-block-match ()
+  "Parse the results from a match of the `org-babel-inline-src-block-regexp'."
+  (let* ((lang (org-no-properties (match-string 2)))
+         (lang-headers (intern (concat "org-babel-default-header-args:" lang))))
+    (list lang
+          (org-unescape-code-in-string (org-no-properties (match-string 5)))
+          (org-babel-merge-params
+           org-babel-default-inline-header-args
+           (org-babel-params-from-properties lang)
+           (if (boundp lang-headers) (eval lang-headers) nil)
+           (org-babel-parse-header-arguments
+            (org-no-properties (or (match-string 4) "")))))))
+
+(defun org-babel-balanced-split (string alts)
+  "Split STRING on instances of ALTS.
+ALTS is a cons of two character options where each option may be
+either the numeric code of a single character or a list of
+character alternatives.  For example to split on balanced
+instances of \"[ \t]:\" set ALTS to '((32 9) . 58)."
+  (let* ((matches (lambda (ch spec) (if (listp spec) (member ch spec) (equal spec ch))))
+        (matched (lambda (ch last)
+                   (if (consp alts)
+                       (and (funcall matches ch (cdr alts))
+                            (funcall matches last (car alts)))
+                     (funcall matches ch alts))))
+        (balance 0) (last 0)
+        quote partial lst)
+    (mapc (lambda (ch)  ; split on [], (), "" balanced instances of [ \t]:
+           (setq balance (+ balance
+                            (cond ((or (equal 91 ch) (equal 40 ch)) 1)
+                                  ((or (equal 93 ch) (equal 41 ch)) -1)
+                                  (t 0))))
+           (when (and (equal 34 ch) (not (equal 92 last)))
+             (setq quote (not quote)))
+           (setq partial (cons ch partial))
+           (when (and (= balance 0) (not quote) (funcall matched ch last))
+             (setq lst (cons (apply #'string (nreverse
+                                              (if (consp alts)
+                                                  (cddr partial)
+                                                (cdr partial))))
+                             lst))
+             (setq partial nil))
+           (setq last ch))
+         (string-to-list string))
+    (nreverse (cons (apply #'string (nreverse partial)) lst))))
+
+(defun org-babel-join-splits-near-ch (ch list)
+  "Join splits where \"=\" is on either end of the split."
+  (let ((last= (lambda (str) (= ch (aref str (1- (length str))))))
+       (first= (lambda (str) (= ch (aref str 0)))))
+    (reverse
+     (org-reduce (lambda (acc el)
+                  (let ((head (car acc)))
+                    (if (and head (or (funcall last= head) (funcall first= el)))
+                        (cons (concat head el) (cdr acc))
+                      (cons el acc))))
+                list :initial-value nil))))
+
+(defun org-babel-parse-header-arguments (arg-string)
+  "Parse a string of header arguments returning an alist."
+  (when (> (length arg-string) 0)
+    (org-babel-parse-multiple-vars
+     (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 (match-string 1 arg))
+                       (org-babel-read (org-babel-chomp (match-string 2 arg))))
+               (cons (intern (org-babel-chomp arg)) nil)))
+           ((lambda (raw)
+              (cons (car raw) (mapcar (lambda (r) (concat ":" r)) (cdr raw))))
+            (org-babel-balanced-split arg-string '((32 9) . 58))))))))
+
+(defun org-babel-parse-multiple-vars (header-arguments)
+  "Expand multiple variable assignments behind a single :var keyword.
+
+This allows expression of multiple variables with one :var as
+shown below.
+
+#+PROPERTY: var foo=1, bar=2"
+  (let (results)
+    (mapc (lambda (pair)
+           (if (eq (car pair) :var)
+               (mapcar (lambda (v) (push (cons :var (org-babel-trim v)) results))
+                       (org-babel-join-splits-near-ch
+                        61 (org-babel-balanced-split (cdr pair) 32)))
+             (push pair results)))
+         header-arguments)
+    (nreverse results)))
+
+(defun org-babel-process-params (params)
+  "Expand variables in PARAMS and add summary parameters."
+  (let* ((processed-vars (mapcar (lambda (el)
+                                  (if (consp (cdr el))
+                                      (cdr el)
+                                    (org-babel-ref-parse (cdr el))))
+                                (org-babel-get-header params :var)))
+        (vars-and-names (if (and (assoc :colname-names params)
+                                 (assoc :rowname-names params))
+                            (list processed-vars)
+                          (org-babel-disassemble-tables
+                           processed-vars
+                           (cdr (assoc :hlines params))
+                           (cdr (assoc :colnames params))
+                           (cdr (assoc :rownames params)))))
+        (raw-result (or (cdr (assoc :results params)) ""))
+        (result-params (append
+                        (split-string (if (stringp raw-result)
+                                          raw-result
+                                        (eval raw-result)))
+                        (cdr (assoc :result-params params)))))
+    (append
+     (mapcar (lambda (var) (cons :var var)) (car vars-and-names))
+     (list
+      (cons :colname-names (or (cdr (assoc :colname-names params))
+                              (cadr  vars-and-names)))
+      (cons :rowname-names (or (cdr (assoc :rowname-names params))
+                              (caddr vars-and-names)))
+      (cons :result-params result-params)
+      (cons :result-type  (cond ((member "output" result-params) 'output)
+                               ((member "value" result-params) 'value)
+                               (t 'value))))
+     (org-babel-get-header params :var 'other))))
+
+;; row and column names
+(defun org-babel-del-hlines (table)
+  "Remove all 'hlines from TABLE."
+  (remove 'hline table))
+
+(defun org-babel-get-colnames (table)
+  "Return the column names of TABLE.
+Return a cons cell, the `car' of which contains the TABLE less
+colnames, and the `cdr' of which contains a list of the column
+names."
+  (if (equal 'hline (nth 1 table))
+      (cons (cddr table) (car table))
+    (cons (cdr table) (car table))))
+
+(defun org-babel-get-rownames (table)
+  "Return the row names of TABLE.
+Return a cons cell, the `car' of which contains the TABLE less
+colnames, and the `cdr' of which contains a list of the column
+names.  Note: this function removes any hlines in TABLE."
+  (let* ((trans (lambda (table) (apply #'mapcar* #'list table)))
+        (width (apply 'max
+                      (mapcar (lambda (el) (if (listp el) (length el) 0)) table)))
+        (table (funcall trans (mapcar (lambda (row)
+                                        (if (not (equal row 'hline))
+                                            row
+                                          (setq row '())
+                                          (dotimes (n width)
+                                            (setq row (cons 'hline row)))
+                                          row))
+                                      table))))
+    (cons (mapcar (lambda (row) (if (equal (car row) 'hline) 'hline row))
+                 (funcall trans (cdr table)))
+         (remove 'hline (car table)))))
+
+(defun org-babel-put-colnames (table colnames)
+  "Add COLNAMES to TABLE if they exist."
+  (if colnames (apply 'list colnames 'hline table) table))
+
+(defun org-babel-put-rownames (table rownames)
+  "Add ROWNAMES to TABLE if they exist."
+  (if rownames
+      (mapcar (lambda (row)
+                (if (listp row)
+                    (cons (or (pop rownames) "") row)
+                  row)) table)
+    table))
+
+(defun org-babel-pick-name (names selector)
+  "Select one out of an alist of row or column names.
+SELECTOR can be either a list of names in which case those names
+will be returned directly, or an index into the list NAMES in
+which case the indexed names will be return."
+  (if (listp selector)
+      selector
+    (when names
+      (if (and selector (symbolp selector) (not (equal t selector)))
+         (cdr (assoc selector names))
+       (if (integerp selector)
+           (nth (- selector 1) names)
+         (cdr (car (last names))))))))
+
+(defun org-babel-disassemble-tables (vars hlines colnames rownames)
+  "Parse tables for further processing.
+Process the variables in VARS according to the HLINES,
+ROWNAMES and COLNAMES header arguments.  Return a list consisting
+of the vars, cnames and rnames."
+  (let (cnames rnames)
+    (list
+     (mapcar
+      (lambda (var)
+        (when (listp (cdr var))
+          (when (and (not (equal colnames "no"))
+                     (or colnames (and (equal (nth 1 (cdr var)) 'hline)
+                                       (not (member 'hline (cddr (cdr var)))))))
+            (let ((both (org-babel-get-colnames (cdr var))))
+              (setq cnames (cons (cons (car var) (cdr both))
+                                 cnames))
+              (setq var (cons (car var) (car both)))))
+          (when (and rownames (not (equal rownames "no")))
+            (let ((both (org-babel-get-rownames (cdr var))))
+              (setq rnames (cons (cons (car var) (cdr both))
+                                 rnames))
+              (setq var (cons (car var) (car both)))))
+          (when (and hlines (not (equal hlines "yes")))
+            (setq var (cons (car var) (org-babel-del-hlines (cdr var))))))
+        var)
+      vars)
+     (reverse cnames) (reverse rnames))))
+
+(defun org-babel-reassemble-table (table colnames rownames)
+  "Add column and row names to a table.
+Given a TABLE and set of COLNAMES and ROWNAMES add the names
+to the table for reinsertion to org-mode."
+  (if (listp table)
+      ((lambda (table)
+         (if (and colnames (listp (car table)) (= (length (car table))
+                                                  (length colnames)))
+             (org-babel-put-colnames table colnames) table))
+       (if (and rownames (= (length table) (length rownames)))
+           (org-babel-put-rownames table rownames) table))
+    table))
+
+(defun org-babel-where-is-src-block-head ()
+  "Find where the current source block begins.
+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)) (case-fold-search t) top bottom)
+    (or
+     (save-excursion ;; on a source name line or a #+header line
+       (beginning-of-line 1)
+       (and (or (looking-at org-babel-src-name-regexp)
+               (looking-at org-babel-multi-line-header-regexp))
+           (progn
+             (while (and (forward-line 1)
+                         (or (looking-at org-babel-src-name-regexp)
+                             (looking-at org-babel-multi-line-header-regexp))))
+             (looking-at org-babel-src-block-regexp))
+            (point)))
+     (save-excursion ;; on a #+begin_src line
+       (beginning-of-line 1)
+       (and (looking-at org-babel-src-block-regexp)
+            (point)))
+     (save-excursion ;; inside a src block
+       (and
+        (re-search-backward "^[ \t]*#\\+begin_src" nil t) (setq top (point))
+        (re-search-forward "^[ \t]*#\\+end_src" nil t) (setq bottom (point))
+        (< top initial) (< initial bottom)
+        (progn (goto-char top) (beginning-of-line 1)
+              (looking-at org-babel-src-block-regexp))
+        (point))))))
+
+;;;###autoload
+(defun org-babel-goto-src-block-head ()
+  "Go to the beginning of the current code block."
+  (interactive)
+  ((lambda (head)
+     (if head (goto-char head) (error "Not currently in a code block")))
+   (org-babel-where-is-src-block-head)))
+
+;;;###autoload
+(defun org-babel-goto-named-src-block (name)
+  "Go to a named source-code block."
+  (interactive
+   (let ((completion-ignore-case t)
+        (case-fold-search t)
+        (under-point (thing-at-point 'line)))
+     (list (org-icompleting-read
+           "source-block name: " (org-babel-src-block-names) nil t
+           (cond
+            ;; noweb
+            ((string-match (org-babel-noweb-wrap) under-point)
+             (let ((block-name (match-string 1 under-point)))
+               (string-match "[^(]*" block-name)
+               (match-string 0 block-name)))
+            ;; #+call:
+            ((string-match org-babel-lob-one-liner-regexp under-point)
+             (let ((source-info (car (org-babel-lob-get-info))))
+               (if (string-match "^\\([^\\[]+?\\)\\(\\[.*\\]\\)?(" source-info)
+                   (let ((source-name (match-string 1 source-info)))
+                     source-name))))
+            ;; #+results:
+            ((string-match (concat "#\\+" org-babel-results-keyword
+                                   "\\:\s+\\([^\\(]*\\)") under-point)
+             (match-string 1 under-point))
+            ;; symbol-at-point
+            ((and (thing-at-point 'symbol))
+             (org-babel-find-named-block (thing-at-point 'symbol))
+             (thing-at-point 'symbol))
+            (""))))))
+  (let ((point (org-babel-find-named-block name)))
+    (if point
+        ;; taken from `org-open-at-point'
+        (progn (org-mark-ring-push) (goto-char point) (org-show-context))
+      (message "source-code block '%s' not found in this buffer" name))))
+
+(defun org-babel-find-named-block (name)
+  "Find a named source-code block.
+Return the location of the source block identified by source
+NAME, or nil if no such block exists.  Set match data according to
+org-babel-named-src-block-regexp."
+  (save-excursion
+    (let ((case-fold-search t)
+         (regexp (org-babel-named-src-block-regexp-for-name name)) msg)
+      (goto-char (point-min))
+      (when (or (re-search-forward regexp nil t)
+               (re-search-backward regexp nil t))
+        (match-beginning 0)))))
+
+(defun org-babel-src-block-names (&optional file)
+  "Returns the names of source blocks in FILE or the current buffer."
+  (save-excursion
+    (when file (find-file file)) (goto-char (point-min))
+    (let ((case-fold-search t) names)
+      (while (re-search-forward org-babel-src-name-w-name-regexp nil t)
+       (setq names (cons (match-string 3) names)))
+      names)))
+
+;;;###autoload
+(defun org-babel-goto-named-result (name)
+  "Go to a named result."
+  (interactive
+   (let ((completion-ignore-case t))
+     (list (org-icompleting-read "source-block name: "
+                                (org-babel-result-names) nil t))))
+  (let ((point (org-babel-find-named-result name)))
+    (if point
+        ;; taken from `org-open-at-point'
+        (progn (goto-char point) (org-show-context))
+      (message "result '%s' not found in this buffer" name))))
+
+(defun org-babel-find-named-result (name &optional point)
+  "Find a named result.
+Return the location of the result named NAME in the current
+buffer or nil if no such result exists."
+  (save-excursion
+    (let ((case-fold-search t))
+      (goto-char (or point (point-min)))
+      (catch 'is-a-code-block
+       (when (re-search-forward
+              (concat org-babel-result-regexp
+                      "[ \t]" (regexp-quote name) "[ \t]*[\n\f\v\r]") nil t)
+         (when (and (string= "name" (downcase (match-string 1)))
+                    (or (beginning-of-line 1)
+                        (looking-at org-babel-src-block-regexp)
+                        (looking-at org-babel-multi-line-header-regexp)))
+           (throw 'is-a-code-block (org-babel-find-named-result name (point))))
+         (beginning-of-line 0) (point))))))
+
+(defun org-babel-result-names (&optional file)
+  "Returns the names of results in FILE or the current buffer."
+  (save-excursion
+    (when file (find-file file)) (goto-char (point-min))
+    (let ((case-fold-search t) names)
+      (while (re-search-forward org-babel-result-w-name-regexp nil t)
+       (setq names (cons (match-string 4) names)))
+      names)))
+
+;;;###autoload
+(defun org-babel-next-src-block (&optional arg)
+  "Jump to the next source block.
+With optional prefix argument ARG, jump forward ARG many source blocks."
+  (interactive "p")
+  (org-next-block arg nil org-babel-src-block-regexp))
+
+;;;###autoload
+(defun org-babel-previous-src-block (&optional arg)
+  "Jump to the previous source block.
+With optional prefix argument ARG, jump backward ARG many source blocks."
+  (interactive "p")
+  (org-previous-block arg org-babel-src-block-regexp))
+
+(defvar org-babel-load-languages)
+
+;;;###autoload
+(defun org-babel-mark-block ()
+  "Mark current src block."
+  (interactive)
+  ((lambda (head)
+     (when head
+       (save-excursion
+        (goto-char head)
+        (looking-at org-babel-src-block-regexp))
+       (push-mark (match-end 5) nil t)
+       (goto-char (match-beginning 5))))
+   (org-babel-where-is-src-block-head)))
+
+(defun org-babel-demarcate-block (&optional arg)
+  "Wrap or split the code in the region or on the point.
+When called from inside of a code block the current block is
+split.  When called from outside of a code block a new code block
+is created.  In both cases if the region is demarcated and if the
+region is not active then the point is demarcated."
+  (interactive "P")
+  (let ((info (org-babel-get-src-block-info 'light))
+       (headers (progn (org-babel-where-is-src-block-head)
+                       (match-string 4)))
+       (stars (concat (make-string (or (org-current-level) 1) ?*) " ")))
+    (if info
+        (mapc
+         (lambda (place)
+           (save-excursion
+             (goto-char place)
+             (let ((lang (nth 0 info))
+                   (indent (make-string (nth 5 info) ? )))
+              (when (string-match "^[[:space:]]*$"
+                                  (buffer-substring (point-at-bol)
+                                                    (point-at-eol)))
+                (delete-region (point-at-bol) (point-at-eol)))
+               (insert (concat
+                       (if (looking-at "^") "" "\n")
+                       indent "#+end_src\n"
+                       (if arg stars indent) "\n"
+                       indent "#+begin_src " lang
+                       (if (> (length headers) 1)
+                           (concat " " headers) headers)
+                       (if (looking-at "[\n\r]")
+                           ""
+                         (concat "\n" (make-string (current-column) ? )))))))
+          (move-end-of-line 2))
+         (sort (if (org-region-active-p) (list (mark) (point)) (list (point))) #'>))
+      (let ((start (point))
+           (lang (org-icompleting-read "Lang: "
+                                       (mapcar (lambda (el) (symbol-name (car el)))
+                                               org-babel-load-languages)))
+           (body (delete-and-extract-region
+                  (if (org-region-active-p) (mark) (point)) (point))))
+       (insert (concat (if (looking-at "^") "" "\n")
+                       (if arg (concat stars "\n") "")
+                       "#+begin_src " lang "\n"
+                       body
+                       (if (or (= (length body) 0)
+                               (string-match "[\r\n]$" body)) "" "\n")
+                       "#+end_src\n"))
+       (goto-char start) (move-end-of-line 1)))))
+
+(defvar org-babel-lob-one-liner-regexp)
+(defun org-babel-where-is-src-block-result (&optional insert info hash indent)
+  "Find where the current source block results begin.
+Return the point at the beginning of the result of the current
+source block.  Specifically at the beginning of the results line.
+If no result exists for this block then create a results line
+following the source block."
+  (save-excursion
+    (let* ((case-fold-search t)
+          (on-lob-line (save-excursion
+                         (beginning-of-line 1)
+                         (looking-at org-babel-lob-one-liner-regexp)))
+          (inlinep (when (org-babel-get-inline-src-block-matches)
+                     (match-end 0)))
+          (name (if on-lob-line
+                    (mapconcat #'identity (butlast (org-babel-lob-get-info)) "")
+                  (nth 4 (or info (org-babel-get-src-block-info 'light)))))
+          (head (unless on-lob-line (org-babel-where-is-src-block-head)))
+          found beg end)
+      (when head (goto-char head))
+      (org-with-wide-buffer
+       (setq
+       found ;; was there a result (before we potentially insert one)
+       (or
+        inlinep
+        (and
+         ;; named results:
+         ;; - return t if it is found, else return nil
+         ;; - if it does not need to be rebuilt, then don't set end
+         ;; - if it does need to be rebuilt then do set end
+         name (setq beg (org-babel-find-named-result name))
+         (prog1 beg
+           (when (and hash (not (string= hash (match-string 5))))
+             (goto-char beg) (setq end beg) ;; beginning of result
+             (forward-line 1)
+             (delete-region end (org-babel-result-end)) nil)))
+        (and
+         ;; unnamed results:
+         ;; - return t if it is found, else return nil
+         ;; - if it is found, and the hash doesn't match, delete and set end
+         (or on-lob-line (re-search-forward "^[ \t]*#\\+end_src" nil t))
+         (progn (end-of-line 1)
+                (if (eobp) (insert "\n") (forward-char 1))
+                (setq end (point))
+                (or (and (not name)
+                         (progn ;; unnamed results line already exists
+                           (re-search-forward "[^ \f\t\n\r\v]" nil t)
+                           (beginning-of-line 1)
+                           (looking-at
+                            (concat org-babel-result-regexp "\n")))
+                         (let ((this-hash (match-string 5)))
+                           (prog1 (point)
+                             ;; must remove and rebuild if hash!=old-hash
+                             (if (and hash (not (string= hash this-hash)))
+                                 (prog1 nil
+                                   (forward-line 1)
+                                   (delete-region
+                                    end (org-babel-result-end)))
+                               (setq end nil)))))))))))
+      (if (not (and insert end)) found
+       (goto-char end)
+       (unless beg
+         (if (looking-at "[\n\r]") (forward-char 1) (insert "\n")))
+       (insert (concat
+                (when (wholenump indent) (make-string indent ? ))
+                "#+" org-babel-results-keyword
+                (when hash
+                  (if org-babel-hash-show-time
+                      (concat
+                       "["(format-time-string "<%Y-%m-%d %H:%M:%S>")" "hash"]")
+                    (concat "["hash"]")))
+                ":"
+                (when name (concat " " name)) "\n"))
+       (unless beg (insert "\n") (backward-char))
+       (beginning-of-line 0)
+       (if hash (org-babel-hide-hash))
+       (point)))))
+
+(defvar org-block-regexp)
+(defun org-babel-read-result ()
+  "Read the result at `point' into emacs-lisp."
+  (let ((case-fold-search t) result-string)
+    (cond
+     ((org-at-table-p) (org-babel-read-table))
+     ((org-at-item-p) (org-babel-read-list))
+     ((looking-at org-bracket-link-regexp) (org-babel-read-link))
+     ((looking-at org-block-regexp) (org-babel-trim (match-string 4)))
+     ((looking-at "^[ \t]*: ")
+      (setq result-string
+           (org-babel-trim
+            (mapconcat (lambda (line)
+                          (if (and (> (length line) 1)
+                                   (string-match "^[ \t]*: \\(.+\\)" line))
+                              (match-string 1 line)
+                            line))
+                       (split-string
+                        (buffer-substring
+                          (point) (org-babel-result-end)) "[\r\n]+")
+                       "\n")))
+      (or (org-babel-number-p result-string) result-string))
+     ((looking-at org-babel-result-regexp)
+      (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 (lambda (el) (org-babel-read el 'inhibit-lisp-eval)) row)))
+          (org-table-to-lisp)))
+
+(defun org-babel-read-list ()
+  "Read the list at `point' into emacs-lisp."
+  (mapcar (lambda (el) (org-babel-read el 'inhibit-lisp-eval))
+         (mapcar #'cadr (cdr (org-list-parse-list)))))
+
+(defvar org-link-types-re)
+(defun org-babel-read-link ()
+  "Read the link at `point' into emacs-lisp.
+If the path of the link is a file path it is expanded using
+`expand-file-name'."
+  (let* ((case-fold-search t)
+         (raw (and (looking-at org-bracket-link-regexp)
+                   (org-no-properties (match-string 1))))
+         (type (and (string-match org-link-types-re raw)
+                    (match-string 1 raw))))
+    (cond
+     ((not type) (expand-file-name raw))
+     ((string= type "file")
+      (and (string-match "file\\(.*\\):\\(.+\\)" raw)
+           (expand-file-name (match-string 2 raw))))
+     (t raw))))
+
+(defun org-babel-format-result (result &optional sep)
+  "Format RESULT for writing to file."
+  (let ((echo-res (lambda (r) (if (stringp r) r (format "%S" r)))))
+    (if (listp result)
+       ;; table result
+       (orgtbl-to-generic
+        result (list :sep (or sep "\t") :fmt echo-res))
+      ;; scalar result
+      (funcall echo-res result))))
+
+(defun org-babel-insert-result
+  (result &optional result-params info hash indent lang)
+  "Insert RESULT into the current buffer.
+By default RESULT is inserted after the end of the
+current source block.  With optional argument RESULT-PARAMS
+controls insertion of results in the org-mode file.
+RESULT-PARAMS can take the following values:
+
+replace - (default option) insert results after the source block
+          replacing any previously inserted results
+
+silent -- no results are inserted into the Org-mode buffer but
+          the results are echoed to the minibuffer and are
+          ingested by Emacs (a potentially time consuming
+          process)
+
+file ---- the results are interpreted as a file path, and are
+          inserted into the buffer using the Org-mode file syntax
+
+list ---- the results are interpreted as an Org-mode list.
+
+raw ----- results are added directly to the Org-mode file.  This
+          is a good option if you code block will output org-mode
+          formatted text.
+
+drawer -- results are added directly to the Org-mode file as with
+          \"raw\", but are wrapped in a RESULTS drawer, allowing
+          them to later be replaced or removed automatically.
+
+org ----- results are added inside of a \"#+BEGIN_SRC org\" block.
+          They are not comma-escaped when inserted, but Org syntax
+          here will be discarded when exporting the file.
+
+html ---- results are added inside of a #+BEGIN_HTML block.  This
+          is a good option if you code block will output html
+          formatted text.
+
+latex --- results are added inside of a #+BEGIN_LATEX block.
+          This is a good option if you code block will output
+          latex formatted text.
+
+code ---- the results are extracted in the syntax of the source
+          code of the language being evaluated and are added
+          inside of a #+BEGIN_SRC block with the source-code
+          language set appropriately.  Note this relies on the
+          optional LANG argument."
+  (if (stringp result)
+      (progn
+        (setq result (org-no-properties result))
+        (when (member "file" result-params)
+         (setq result (org-babel-result-to-file
+                       result (when (assoc :file-desc (nth 2 info))
+                                (or (cdr (assoc :file-desc (nth 2 info)))
+                                    result))))))
+    (unless (listp result) (setq result (format "%S" result))))
+  (if (and result-params (member "silent" result-params))
+      (progn
+       (message (replace-regexp-in-string "%" "%%" (format "%S" result)))
+       result)
+    (save-excursion
+      (let* ((inlinep
+             (save-excursion
+               (when (or (org-babel-get-inline-src-block-matches)
+                         (org-babel-get-lob-one-liner-matches))
+                 (goto-char (match-end 0))
+                 (insert (if (listp result) "\n" " "))
+                 (point))))
+            (existing-result (unless inlinep
+                               (org-babel-where-is-src-block-result
+                                t info hash indent)))
+            (results-switches
+             (cdr (assoc :results_switches (nth 2 info))))
+            (visible-beg (copy-marker (point-min)))
+            (visible-end (copy-marker (point-max)))
+            ;; When results exist outside of the current visible
+            ;; region of the buffer, be sure to widen buffer to
+            ;; update them.
+            (outside-scope-p (and existing-result
+                                  (or (> visible-beg existing-result)
+                                      (<= visible-end existing-result))))
+            beg end)
+       (when (and (stringp result)  ; ensure results end in a newline
+                  (not inlinep)
+                  (> (length result) 0)
+                  (not (or (string-equal (substring result -1) "\n")
+                           (string-equal (substring result -1) "\r"))))
+         (setq result (concat result "\n")))
+       (unwind-protect
+           (progn
+             (when outside-scope-p (widen))
+             (if (not existing-result)
+                 (setq beg (or inlinep (point)))
+               (goto-char existing-result)
+               (save-excursion
+                 (re-search-forward "#" nil t)
+                 (setq indent (- (current-column) 1)))
+               (forward-line 1)
+               (setq beg (point))
+               (cond
+                ((member "replace" result-params)
+                 (delete-region (point) (org-babel-result-end)))
+                ((member "append" result-params)
+                 (goto-char (org-babel-result-end)) (setq beg (point-marker)))
+                ((member "prepend" result-params)))) ; already there
+             (setq results-switches
+                   (if results-switches (concat " " results-switches) ""))
+             (let ((wrap (lambda (start finish &optional no-escape)
+                           (goto-char end) (insert (concat finish "\n"))
+                           (goto-char beg) (insert (concat start "\n"))
+                           (unless no-escape
+                             (org-escape-code-in-region (min (point) end) end))
+                           (goto-char end) (goto-char (point-at-eol))
+                           (setq end (point-marker))))
+                   (proper-list-p (lambda (it) (and (listp it) (null (cdr (last it)))))))
+               ;; insert results based on type
+               (cond
+                ;; do nothing for an empty result
+                ((null result))
+                ;; insert a list if preferred
+                ((member "list" result-params)
+                 (insert
+                  (org-babel-trim
+                   (org-list-to-generic
+                    (cons 'unordered
+                          (mapcar
+                           (lambda (el) (list nil (if (stringp el) el (format "%S" el))))
+                           (if (listp result) result (list result))))
+                    '(:splicep nil :istart "- " :iend "\n")))
+                  "\n"))
+                ;; assume the result is a table if it's not a string
+                ((funcall proper-list-p result)
+                 (goto-char beg)
+                 (insert (concat (orgtbl-to-orgtbl
+                                  (if (or (eq 'hline (car result))
+                                          (and (listp (car result))
+                                               (listp (cdr (car result)))))
+                                      result (list result))
+                                  '(:fmt (lambda (cell) (format "%s" cell)))) "\n"))
+                 (goto-char beg) (when (org-at-table-p) (org-table-align)))
+                ((and (listp result) (not (funcall proper-list-p result)))
+                 (insert (format "%s\n" result)))
+                ((member "file" result-params)
+                 (when inlinep (goto-char inlinep))
+                 (insert result))
+                (t (goto-char beg) (insert result)))
+               (when (funcall proper-list-p result) (goto-char (org-table-end)))
+               (setq end (point-marker))
+               ;; possibly wrap result
+               (cond
+                ((assoc :wrap (nth 2 info))
+                 (let ((name (or (cdr (assoc :wrap (nth 2 info))) "RESULTS")))
+                   (funcall wrap (concat "#+BEGIN_" name)
+                            (concat "#+END_" (car (org-split-string name))))))
+                ((member "html" result-params)
+                 (funcall wrap "#+BEGIN_HTML" "#+END_HTML"))
+                ((member "latex" result-params)
+                 (funcall wrap "#+BEGIN_LaTeX" "#+END_LaTeX"))
+                ((member "org" result-params)
+                 (funcall wrap "#+BEGIN_SRC org" "#+END_SRC"))
+                ((member "code" result-params)
+                 (funcall wrap (format "#+BEGIN_SRC %s%s" (or lang "none") results-switches)
+                          "#+END_SRC"))
+                ((member "raw" result-params)
+                 (goto-char beg) (if (org-at-table-p) (org-cycle)))
+                ((or (member "drawer" result-params)
+                     ;; Stay backward compatible with <7.9.2
+                     (member "wrap" result-params))
+                 (funcall wrap ":RESULTS:" ":END:" 'no-escape))
+                ((and (not (funcall proper-list-p result))
+                      (not (member "file" result-params)))
+                 (org-babel-examplize-region beg end results-switches)
+                 (setq end (point)))))
+             ;; possibly indent the results to match the #+results line
+             (when (and (not inlinep) (numberp indent) indent (> indent 0)
+                        ;; in this case `table-align' does the work for us
+                        (not (and (listp result)
+                                  (member "append" result-params))))
+               (indent-rigidly beg end indent))
+             (if (null result)
+                 (if (member "value" result-params)
+                     (message "Code block returned no value.")
+                   (message "Code block produced no output."))
+               (message "Code block evaluation complete.")))
+         (when outside-scope-p (narrow-to-region visible-beg visible-end))
+         (set-marker visible-beg nil)
+         (set-marker visible-end nil))))))
+
+(defun org-babel-remove-result (&optional info)
+  "Remove the result of the current source block."
+  (interactive)
+  (let ((location (org-babel-where-is-src-block-result nil info)) start)
+    (when location
+      (setq start (- location 1))
+      (save-excursion
+        (goto-char location) (forward-line 1)
+        (delete-region start (org-babel-result-end))))))
+
+(defun org-babel-result-end ()
+  "Return the point at the end of the current set of results."
+  (save-excursion
+    (cond
+     ((org-at-table-p) (progn (goto-char (org-table-end)) (point)))
+     ((org-at-item-p) (let* ((struct (org-list-struct))
+                            (prvs (org-list-prevs-alist struct)))
+                       (org-list-get-list-end (point-at-bol) struct prvs)))
+     ((let ((case-fold-search t)) (looking-at "^\\([ \t]*\\):results:"))
+      (progn (re-search-forward (concat "^" (match-string 1) ":END:"))
+            (forward-char 1) (point)))
+     (t
+      (let ((case-fold-search t))
+       (if (looking-at (concat "[ \t]*#\\+begin_\\([^ \t\n\r]+\\)"))
+           (progn (re-search-forward (concat "[ \t]*#\\+end_" (match-string 1))
+                                     nil t)
+                  (forward-char 1))
+         (while (looking-at "[ \t]*\\(: \\|\\[\\[\\)")
+           (forward-line 1))))
+      (point)))))
+
+(defun org-babel-result-to-file (result &optional description)
+  "Convert RESULT into an `org-mode' link with optional DESCRIPTION.
+If the `default-directory' is different from the containing
+file's directory then expand relative links."
+  (when (stringp result)
+    (format "[[file:%s]%s]"
+           (if (and default-directory
+                    buffer-file-name
+                    (not (string= (expand-file-name default-directory)
+                                  (expand-file-name
+                                   (file-name-directory buffer-file-name)))))
+               (expand-file-name result default-directory)
+             result)
+           (if description (concat "[" description "]") ""))))
+
+(defvar org-babel-capitalize-examplize-region-markers nil
+  "Make true to capitalize begin/end example markers inserted by code blocks.")
+
+(defun org-babel-examplize-region (beg end &optional results-switches)
+  "Comment out region using the inline '==' or ': ' org example quote."
+  (interactive "*r")
+  (let ((chars-between (lambda (b e)
+                        (not (string-match "^[\\s]*$" (buffer-substring b e)))))
+       (maybe-cap (lambda (str) (if org-babel-capitalize-examplize-region-markers
+                                    (upcase str) str))))
+    (if (or (funcall chars-between (save-excursion (goto-char beg) (point-at-bol)) beg)
+           (funcall chars-between end (save-excursion (goto-char end) (point-at-eol))))
+       (save-excursion
+         (goto-char beg)
+         (insert (format "=%s=" (prog1 (buffer-substring beg end)
+                                  (delete-region beg end)))))
+      (let ((size (count-lines beg end)))
+       (save-excursion
+         (cond ((= size 0))          ; do nothing for an empty result
+               ((< size org-babel-min-lines-for-block-output)
+                (goto-char beg)
+                (dotimes (n size)
+                  (beginning-of-line 1) (insert ": ") (forward-line 1)))
+               (t
+                (goto-char beg)
+                (insert (if results-switches
+                            (format "%s%s\n"
+                                    (funcall maybe-cap "#+begin_example")
+                                    results-switches)
+                          (funcall maybe-cap "#+begin_example\n")))
+                (if (markerp end) (goto-char end) (forward-char (- end beg)))
+                (insert (funcall maybe-cap "#+end_example\n")))))))))
+
+(defun org-babel-update-block-body (new-body)
+  "Update the body of the current code block to NEW-BODY."
+  (if (not (org-babel-where-is-src-block-head))
+      (error "Not in a source block")
+    (save-match-data
+      (replace-match (concat (org-babel-trim new-body) "\n") nil t nil 5))
+    (indent-rigidly (match-beginning 5) (match-end 5) 2)))
+
+(defun org-babel-merge-params (&rest plists)
+  "Combine all parameter association lists in PLISTS.
+Later elements of PLISTS override the values of previous elements.
+This takes into account some special considerations for certain
+parameters when merging lists."
+  (let* ((results-exclusive-groups
+         (mapcar (lambda (group) (mapcar #'symbol-name group))
+                 (cdr (assoc 'results org-babel-common-header-args-w-values))))
+        (exports-exclusive-groups
+         (mapcar (lambda (group) (mapcar #'symbol-name group))
+                 (cdr (assoc 'exports org-babel-common-header-args-w-values))))
+        (variable-index 0)
+        (e-merge (lambda (exclusive-groups &rest result-params)
+                   ;; maintain exclusivity of mutually exclusive parameters
+                   (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)))
+        params results exports tangle noweb cache vars shebang comments padline)
+
+    (mapc
+     (lambda (plist)
+       (mapc
+       (lambda (pair)
+         (case (car pair)
+           (:var
+            (let ((name (if (listp (cdr pair))
+                            (cadr pair)
+                          (and (string-match "^\\([^= \f\t\n\r\v]+\\)[ \t]*="
+                                             (cdr pair))
+                               (intern (match-string 1 (cdr pair)))))))
+              (if name
+                  (setq vars
+                        (append
+                         (if (member name (mapcar #'car vars))
+                             (delq nil
+                                   (mapcar
+                                    (lambda (p)
+                                      (unless (equal (car p) name) p))
+                                    vars))
+                           vars)
+                         (list (cons name pair))))
+                ;; if no name is given and we already have named variables
+                ;; then assign to named variables in order
+                (if (and vars (nth variable-index vars))
+                    (prog1 (setf (cddr (nth variable-index vars))
+                                 (concat (symbol-name
+                                          (car (nth variable-index vars)))
+                                         "=" (cdr pair)))
+                      (incf variable-index))
+                  (error "Variable \"%s\" must be assigned a default value"
+                         (cdr pair))))))
+           (:results
+            (setq results (funcall e-merge results-exclusive-groups
+                                   results
+                                   (split-string
+                                    (let ((r (cdr pair)))
+                                      (if (stringp r) r (eval r)))))))
+           (:file
+            (when (cdr pair)
+              (setq results (funcall e-merge results-exclusive-groups
+                                     results '("file")))
+              (unless (or (member "both" exports)
+                          (member "none" exports)
+                          (member "code" exports))
+                (setq exports (funcall e-merge exports-exclusive-groups
+                                       exports '("results"))))
+              (setq params (cons pair (assq-delete-all (car pair) params)))))
+           (:exports
+            (setq exports (funcall e-merge exports-exclusive-groups
+                                   exports (split-string (cdr pair)))))
+           (:tangle ;; take the latest -- always overwrite
+            (setq tangle (or (list (cdr pair)) tangle)))
+           (:noweb
+            (setq noweb (funcall e-merge
+                                 '(("yes" "no" "tangle" "no-export"
+                                    "strip-export" "eval"))
+                                 noweb
+                                 (split-string (or (cdr pair) "")))))
+           (:cache
+            (setq cache (funcall e-merge '(("yes" "no")) cache
+                                 (split-string (or (cdr pair) "")))))
+           (:padline
+            (setq padline (funcall e-merge '(("yes" "no")) padline
+                                   (split-string (or (cdr pair) "")))))
+           (:shebang ;; take the latest -- always overwrite
+            (setq shebang (or (list (cdr pair)) shebang)))
+           (:comments
+            (setq comments (funcall e-merge '(("yes" "no")) comments
+                                    (split-string (or (cdr pair) "")))))
+           (t ;; replace: this covers e.g. :session
+            (setq params (cons pair (assq-delete-all (car pair) params))))))
+       plist))
+     plists)
+    (setq vars (reverse vars))
+    (while vars (setq params (cons (cons :var (cddr (pop vars))) params)))
+    (mapc
+     (lambda (hd)
+       (let ((key (intern (concat ":" (symbol-name hd))))
+            (val (eval hd)))
+        (setf params (cons (cons key (mapconcat 'identity val " ")) params))))
+     '(results exports tangle noweb padline cache shebang comments))
+    params))
+
+(defvar org-babel-use-quick-and-dirty-noweb-expansion nil
+  "Set to true to use regular expressions to expand noweb references.
+This results in much faster noweb reference expansion but does
+not properly allow code blocks to inherit the \":noweb-ref\"
+header argument from buffer or subtree wide properties.")
+
+(defun org-babel-noweb-p (params context)
+  "Check if PARAMS require expansion in CONTEXT.
+CONTEXT may be one of :tangle, :export or :eval."
+  (let* (intersect
+        (intersect (lambda (as bs)
+                     (when as
+                       (if (member (car as) bs)
+                           (car as)
+                         (funcall intersect (cdr as) bs))))))
+    (funcall intersect (case context
+                        (:tangle '("yes" "tangle" "no-export" "strip-export"))
+                        (:eval   '("yes" "no-export" "strip-export" "eval"))
+                        (:export '("yes")))
+            (split-string (or (cdr (assoc :noweb params)) "")))))
+
+(defun org-babel-expand-noweb-references (&optional info parent-buffer)
+  "Expand Noweb references in the body of the current source code block.
+
+For example the following reference would be replaced with the
+body of the source-code block named 'example-block'.
+
+<<example-block>>
+
+Note that any text preceding the <<foo>> construct on a line will
+be interposed between the lines of the replacement text.  So for
+example if <<foo>> is placed behind a comment, then the entire
+replacement text will also be commented.
+
+This function must be called from inside of the buffer containing
+the source-code block which holds BODY.
+
+In addition the following syntax can be used to insert the
+results of evaluating the source-code block named 'example-block'.
+
+<<example-block()>>
+
+Any optional arguments can be passed to example-block by placing
+the arguments inside the parenthesis following the convention
+defined by `org-babel-lob'.  For example
+
+<<example-block(a=9)>>
+
+would set the value of argument \"a\" equal to \"9\".  Note that
+these arguments are not evaluated in the current source-code
+block but are passed literally to the \"example-block\"."
+  (let* ((parent-buffer (or parent-buffer (current-buffer)))
+         (info (or info (org-babel-get-src-block-info)))
+         (lang (nth 0 info))
+         (body (nth 1 info))
+        (ob-nww-start org-babel-noweb-wrap-start)
+        (ob-nww-end org-babel-noweb-wrap-end)
+        (comment (string= "noweb" (cdr (assoc :comments (nth 2 info)))))
+        (rx-prefix (concat "\\(" org-babel-src-name-regexp "\\|"
+                           ":noweb-ref[ \t]+" "\\)"))
+         (new-body "")
+        (nb-add (lambda (text) (setq new-body (concat new-body text))))
+        (c-wrap (lambda (text)
+                  (with-temp-buffer
+                    (funcall (intern (concat lang "-mode")))
+                    (comment-region (point) (progn (insert text) (point)))
+                    (org-babel-trim (buffer-string)))))
+        index source-name evaluate prefix blocks-in-buffer)
+    (with-temp-buffer
+      (org-set-local 'org-babel-noweb-wrap-start ob-nww-start)
+      (org-set-local 'org-babel-noweb-wrap-end ob-nww-end)
+      (insert body) (goto-char (point-min))
+      (setq index (point))
+      (while (and (re-search-forward (org-babel-noweb-wrap) nil t))
+       (save-match-data (setf source-name (match-string 1)))
+       (save-match-data (setq evaluate (string-match "\(.*\)" source-name)))
+       (save-match-data
+         (setq prefix
+               (buffer-substring (match-beginning 0)
+                                 (save-excursion
+                                   (beginning-of-line 1) (point)))))
+       ;; add interval to new-body (removing noweb reference)
+       (goto-char (match-beginning 0))
+       (funcall nb-add (buffer-substring index (point)))
+       (goto-char (match-end 0))
+       (setq index (point))
+       (funcall nb-add
+                (with-current-buffer parent-buffer
+                  (save-restriction
+                    (widen)
+                    (mapconcat ;; interpose PREFIX between every line
+                     #'identity
+                     (split-string
+                      (if evaluate
+                          (let ((raw (org-babel-ref-resolve source-name)))
+                            (if (stringp raw) raw (format "%S" raw)))
+                        (or
+                         ;; retrieve from the library of babel
+                         (nth 2 (assoc (intern source-name)
+                                       org-babel-library-of-babel))
+                         ;; return the contents of headlines literally
+                         (save-excursion
+                           (when (org-babel-ref-goto-headline-id source-name)
+                             (org-babel-ref-headline-body)))
+                         ;; find the expansion of reference in this buffer
+                         (let ((rx (concat rx-prefix source-name "[ \t\n]"))
+                               expansion)
+                           (save-excursion
+                             (goto-char (point-min))
+                             (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))
+                                          (sep (or (cdr (assoc :noweb-sep (nth 2 i)))
+                                                   "\n"))
+                                          (full (if comment
+                                                    ((lambda (cs)
+                                                       (concat (funcall c-wrap (car cs)) "\n"
+                                                               body "\n"
+                                                               (funcall c-wrap (cadr cs))))
+                                                     (org-babel-tangle-comment-links i))
+                                                  body)))
+                                     (setq expansion (cons sep (cons full expansion)))))
+                               (org-babel-map-src-blocks nil
+                                 (let ((i (org-babel-get-src-block-info 'light)))
+                                   (when (equal (or (cdr (assoc :noweb-ref (nth 2 i)))
+                                                    (nth 4 i))
+                                                source-name)
+                                     (let* ((body (org-babel-expand-noweb-references i))
+                                            (sep (or (cdr (assoc :noweb-sep (nth 2 i)))
+                                                     "\n"))
+                                            (full (if comment
+                                                      ((lambda (cs)
+                                                         (concat (funcall c-wrap (car cs)) "\n"
+                                                                 body "\n"
+                                                                 (funcall c-wrap (cadr cs))))
+                                                       (org-babel-tangle-comment-links i))
+                                                    body)))
+                                       (setq expansion
+                                             (cons sep (cons full expansion)))))))))
+                           (and expansion
+                                (mapconcat #'identity (nreverse (cdr expansion)) "")))
+                         ;; possibly raise an error if named block doesn't exist
+                         (if (member lang org-babel-noweb-error-langs)
+                             (error "%s" (concat
+                                          (org-babel-noweb-wrap source-name)
+                                          "could not be resolved (see "
+                                          "`org-babel-noweb-error-langs')"))
+                           "")))
+                      "[\n\r]") (concat "\n" prefix))))))
+      (funcall nb-add (buffer-substring index (point-max))))
+    new-body))
+
+(defun org-babel-script-escape (str &optional force)
+  "Safely convert tables into elisp lists."
+  (let (in-single in-double out)
+    ((lambda (escaped) (condition-case nil (org-babel-read escaped) (error escaped)))
+     (if (or force
+            (and (stringp str)
+                 (> (length str) 2)
+                 (or (and (string-equal "[" (substring str 0 1))
+                          (string-equal "]" (substring str -1)))
+                     (and (string-equal "{" (substring str 0 1))
+                          (string-equal "}" (substring str -1)))
+                     (and (string-equal "(" (substring str 0 1))
+                          (string-equal ")" (substring str -1))))))
+        (org-babel-read
+         (concat
+          "'"
+          (progn
+            (mapc
+             (lambda (ch)
+               (setq
+                out
+                (case ch
+                  (91 (if (or in-double in-single) ; [
+                          (cons 91 out)
+                        (cons 40 out)))
+                  (93 (if (or in-double in-single) ; ]
+                          (cons 93 out)
+                        (cons 41 out)))
+                  (123 (if (or in-double in-single) ; {
+                           (cons 123 out)
+                         (cons 40 out)))
+                  (125 (if (or in-double in-single) ; }
+                           (cons 125 out)
+                         (cons 41 out)))
+                  (44 (if (or in-double in-single) ; ,
+                          (cons 44 out) (cons 32 out)))
+                  (39 (if in-double    ; '
+                          (cons 39 out)
+                        (setq in-single (not in-single)) (cons 34 out)))
+                  (34 (if in-single    ; "
+                          (append (list 34 32) out)
+                        (setq in-double (not in-double)) (cons 34 out)))
+                  (t  (cons ch out)))))
+             (string-to-list str))
+            (apply #'string (reverse out)))))
+       str))))
+
+(defun org-babel-read (cell &optional inhibit-lisp-eval)
+  "Convert the string value of CELL to a number if appropriate.
+Otherwise if cell looks like lisp (meaning it starts with a
+\"(\", \"'\", \"`\" or a \"[\") then read 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 "")))
+      (or (org-babel-number-p cell)
+          (if (and (not inhibit-lisp-eval)
+                  (member (substring cell 0 1) '("(" "'" "`" "[")))
+              (eval (read cell))
+            (if (string= (substring cell 0 1) "\"")
+               (read cell)
+             (progn (set-text-properties 0 (length cell) nil cell) cell))))
+    cell))
+
+(defun org-babel-number-p (string)
+  "If STRING represents a number return its value."
+  (if (and (string-match "^-?[0-9]*\\.?[0-9]*$" string)
+           (= (length (substring string (match-beginning 0)
+                                (match-end 0)))
+             (length string)))
+      (string-to-number string)))
+
+(defun org-babel-import-elisp-from-file (file-name &optional separator)
+  "Read the results located at FILE-NAME into an elisp table.
+If the table is trivial, then return it as a scalar."
+  (let (result)
+    (save-window-excursion
+      (with-temp-buffer
+       (condition-case err
+           (progn
+             (org-table-import file-name separator)
+             (delete-file file-name)
+             (setq result (mapcar (lambda (row)
+                                    (mapcar #'org-babel-string-read row))
+                                  (org-table-to-lisp))))
+         (error (message "Error reading results: %s" err) nil)))
+      (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))))
+
+(defun org-babel-string-read (cell)
+  "Strip nested \"s from around strings."
+  (org-babel-read (or (and (stringp cell)
+                           (string-match "\\\"\\(.+\\)\\\"" cell)
+                           (match-string 1 cell))
+                      cell) t))
+
+(defun org-babel-chomp (string &optional regexp)
+  "Strip trailing spaces and carriage returns from STRING.
+Default regexp used is \"[ \f\t\n\r\v]\" but can be
+overwritten by specifying a regexp as a second argument."
+  (let ((regexp (or regexp "[ \f\t\n\r\v]")))
+    (while (and (> (length string) 0)
+                (string-match regexp (substring string -1)))
+      (setq string (substring string 0 -1)))
+    string))
+
+(defun org-babel-trim (string &optional regexp)
+  "Strip leading and trailing spaces and carriage returns from STRING.
+Like `org-babel-chomp' only it runs on both the front and back
+of the string."
+  (org-babel-chomp (org-reverse-string
+                    (org-babel-chomp (org-reverse-string string) regexp))
+                   regexp))
+
+(defvar org-babel-org-babel-call-process-region-original nil)
+(defun org-babel-tramp-handle-call-process-region
+  (start end program &optional delete buffer display &rest args)
+  "Use Tramp to handle `call-process-region'.
+Fixes a bug in `tramp-handle-call-process-region'."
+  (if (and (featurep 'tramp) (file-remote-p default-directory))
+      (let ((tmpfile (tramp-compat-make-temp-file "")))
+       (write-region start end tmpfile)
+       (when delete (delete-region start end))
+       (unwind-protect
+           ;;  (apply 'call-process program tmpfile buffer display args)
+            ;; bug in tramp
+           (apply 'process-file program tmpfile buffer display args)
+         (delete-file tmpfile)))
+    ;; org-babel-call-process-region-original is the original emacs
+    ;; definition.  It is in scope from the let binding in
+    ;; org-babel-execute-src-block
+    (apply org-babel-call-process-region-original
+           start end program delete buffer display args)))
+
+(defun org-babel-local-file-name (file)
+  "Return the local name component of FILE."
+  (if (file-remote-p file)
+      (let (localname)
+       (with-parsed-tramp-file-name file nil
+                                    localname))
+    file))
+
+(defun org-babel-process-file-name (name &optional no-quote-p)
+  "Prepare NAME to be used in an external process.
+If NAME specifies a remote location, the remote portion of the
+name is removed, since in that case the process will be executing
+remotely.  The file name is then processed by `expand-file-name'.
+Unless second argument NO-QUOTE-P is non-nil, the file name is
+additionally processed by `shell-quote-argument'"
+  ((lambda (f) (if no-quote-p f (shell-quote-argument f)))
+   (expand-file-name (org-babel-local-file-name name))))
+
+(defvar org-babel-temporary-directory)
+(unless (or noninteractive (boundp 'org-babel-temporary-directory))
+  (defvar org-babel-temporary-directory
+    (or (and (boundp 'org-babel-temporary-directory)
+            (file-exists-p org-babel-temporary-directory)
+            org-babel-temporary-directory)
+       (make-temp-file "babel-" t))
+    "Directory to hold temporary files created to execute code blocks.
+Used by `org-babel-temp-file'.  This directory will be removed on
+Emacs shutdown."))
+
+(defmacro org-babel-result-cond (result-params scalar-form &rest table-forms)
+  "Call the code to parse raw string results according to RESULT-PARAMS."
+  (declare (indent 1)
+          (debug (form form &rest form)))
+  `(unless (member "none" ,result-params)
+     (if (or (member "scalar" ,result-params)
+            (member "verbatim" ,result-params)
+            (member "html" ,result-params)
+            (member "code" ,result-params)
+            (member "pp" ,result-params)
+            (and (member "output" ,result-params)
+                 (not (member "table" ,result-params))))
+        ,scalar-form
+       ,@table-forms)))
+
+(defun org-babel-temp-file (prefix &optional suffix)
+  "Create a temporary file in the `org-babel-temporary-directory'.
+Passes PREFIX and SUFFIX directly to `make-temp-file' with the
+value of `temporary-file-directory' temporarily set to the value
+of `org-babel-temporary-directory'."
+  (let ((temporary-file-directory
+        (if (file-remote-p default-directory)
+            (concat (file-remote-p default-directory) "/tmp")
+          (or (and (boundp 'org-babel-temporary-directory)
+                   (file-exists-p org-babel-temporary-directory)
+                   org-babel-temporary-directory)
+              temporary-file-directory))))
+      (make-temp-file prefix nil suffix)))
+
+(defun org-babel-remove-temporary-directory ()
+  "Remove `org-babel-temporary-directory' on Emacs shutdown."
+  (when (and (boundp 'org-babel-temporary-directory)
+            (file-exists-p org-babel-temporary-directory))
+    ;; taken from `delete-directory' in files.el
+    (condition-case nil
+       (progn
+         (mapc (lambda (file)
+                 ;; This test is equivalent to
+                 ;; (and (file-directory-p fn) (not (file-symlink-p fn)))
+                 ;; but more efficient
+                 (if (eq t (car (file-attributes file)))
+                     (delete-directory file)
+                   (delete-file file)))
+               ;; We do not want to delete "." and "..".
+               (directory-files org-babel-temporary-directory 'full
+                                "^\\([^.]\\|\\.\\([^.]\\|\\..\\)\\).*"))
+         (delete-directory org-babel-temporary-directory))
+      (error
+       (message "Failed to remove temporary Org-babel directory %s"
+               (if (boundp 'org-babel-temporary-directory)
+                   org-babel-temporary-directory
+                 "[directory not defined]"))))))
+
+(add-hook 'kill-emacs-hook 'org-babel-remove-temporary-directory)
+
+(provide 'ob-core)
+
+;; Local variables:
+;; generated-autoload-file: "org-loaddefs.el"
+;; End:
+
+;;; ob-core.el ends here
diff --git a/elisp/org/ob-css.el b/elisp/org/ob-css.el
new file mode 100644 (file)
index 0000000..a1205f5
--- /dev/null
@@ -0,0 +1,48 @@
+;;; ob-css.el --- org-babel functions for css evaluation
+
+;; Copyright (C) 2009-2013 Free Software Foundation, Inc.
+
+;; Author: Eric Schulte
+;; Keywords: literate programming, reproducible research
+;; Homepage: http://orgmode.org
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
+
+;;; Commentary:
+
+;; Since CSS can't be executed, this file exists solely for tangling
+;; CSS from org-mode files.
+
+;;; Code:
+(require 'ob)
+
+(defvar org-babel-default-header-args:css '())
+
+(defun org-babel-execute:css (body params)
+  "Execute a block of CSS code.
+This function is called by `org-babel-execute-src-block'."
+  body)
+
+(defun org-babel-prep-session:css (session params)
+  "Return an error if the :session header argument is set.
+CSS does not support sessions."
+  (error "CSS sessions are nonsensical"))
+
+(provide 'ob-css)
+
+
+
+;;; ob-css.el ends here
diff --git a/elisp/org/ob-ditaa.el b/elisp/org/ob-ditaa.el
new file mode 100644 (file)
index 0000000..5ef519c
--- /dev/null
@@ -0,0 +1,115 @@
+;;; ob-ditaa.el --- org-babel functions for ditaa evaluation
+
+;; Copyright (C) 2009-2013 Free Software Foundation, Inc.
+
+;; Author: Eric Schulte
+;; Keywords: literate programming, reproducible research
+;; Homepage: http://orgmode.org
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
+
+;;; Commentary:
+
+;; Org-Babel support for evaluating ditaa source code.
+;;
+;; This differs from most standard languages in that
+;;
+;; 1) there is no such thing as a "session" in ditaa
+;;
+;; 2) we are generally only going to return results of type "file"
+;;
+;; 3) we are adding the "file" and "cmdline" header arguments
+;;
+;; 4) there are no variables (at least for now)
+
+;;; Code:
+(require 'ob)
+(require 'org-compat)
+
+(defvar org-babel-default-header-args:ditaa
+  '((:results . "file")
+    (:exports . "results")
+    (:java . "-Dfile.encoding=UTF-8"))
+  "Default arguments for evaluating a ditaa source block.")
+
+(defcustom org-ditaa-jar-path (expand-file-name
+                              "ditaa.jar"
+                              (file-name-as-directory
+                               (expand-file-name
+                                "scripts"
+                                (file-name-as-directory
+                                 (expand-file-name
+                                  "../contrib"
+                                  (file-name-directory (org-find-library-dir "org")))))))
+  "Path to the ditaa jar executable."
+  :group 'org-babel
+  :type 'string)
+
+(defcustom org-ditaa-eps-jar-path
+  (expand-file-name "DitaaEps.jar" (file-name-directory org-ditaa-jar-path))
+  "Path to the DitaaEps.jar executable."
+  :group 'org-babel
+  :type 'string)
+
+(defcustom org-ditaa-jar-option "-jar"
+  "Option for the ditaa jar file.
+Do not leave leading or trailing spaces in this string."
+  :group 'org-babel
+  :version "24.1"
+  :type 'string)
+
+(defun org-babel-execute:ditaa (body params)
+  "Execute a block of Ditaa code with org-babel.
+This function is called by `org-babel-execute-src-block'."
+  (let* ((result-params (split-string (or (cdr (assoc :results params)) "")))
+        (out-file ((lambda (el)
+                     (or el
+                         (error
+                          "ditaa code block requires :file header argument")))
+                   (cdr (assoc :file params))))
+        (cmdline (cdr (assoc :cmdline params)))
+        (java (cdr (assoc :java params)))
+        (in-file (org-babel-temp-file "ditaa-"))
+        (eps (cdr (assoc :eps params)))
+        (cmd (concat "java " java " " org-ditaa-jar-option " "
+                     (shell-quote-argument
+                      (expand-file-name
+                       (if eps org-ditaa-eps-jar-path org-ditaa-jar-path)))
+                     " " cmdline
+                     " " (org-babel-process-file-name in-file)
+                     " " (org-babel-process-file-name out-file)))
+        (pdf-cmd (when (and (or (string= (file-name-extension out-file) "pdf")
+                                (cdr (assoc :pdf params))))
+                   (concat
+                    "epstopdf"
+                    " " (org-babel-process-file-name (concat in-file ".eps"))
+                    " -o=" (org-babel-process-file-name out-file)))))
+    (unless (file-exists-p org-ditaa-jar-path)
+      (error "Could not find ditaa.jar at %s" org-ditaa-jar-path))
+    (with-temp-file in-file (insert body))
+    (message cmd) (shell-command cmd)
+    (when pdf-cmd (message pdf-cmd) (shell-command pdf-cmd))
+    nil)) ;; signal that output has already been written to file
+
+(defun org-babel-prep-session:ditaa (session params)
+  "Return an error because ditaa does not support sessions."
+  (error "Ditaa does not support sessions"))
+
+(provide 'ob-ditaa)
+
+
+
+;;; ob-ditaa.el ends here
diff --git a/elisp/org/ob-dot.el b/elisp/org/ob-dot.el
new file mode 100644 (file)
index 0000000..7504264
--- /dev/null
@@ -0,0 +1,89 @@
+;;; ob-dot.el --- org-babel functions for dot evaluation
+
+;; Copyright (C) 2009-2013 Free Software Foundation, Inc.
+
+;; Author: Eric Schulte
+;; Keywords: literate programming, reproducible research
+;; Homepage: http://orgmode.org
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
+
+;;; Commentary:
+
+;; Org-Babel support for evaluating dot source code.
+;;
+;; For information on dot see http://www.graphviz.org/
+;;
+;; This differs from most standard languages in that
+;;
+;; 1) there is no such thing as a "session" in dot
+;;
+;; 2) we are generally only going to return results of type "file"
+;;
+;; 3) we are adding the "file" and "cmdline" header arguments
+;;
+;; 4) there are no variables (at least for now)
+
+;;; Code:
+(require 'ob)
+
+(defvar org-babel-default-header-args:dot
+  '((:results . "file") (:exports . "results"))
+  "Default arguments to use when evaluating a dot source block.")
+
+(defun org-babel-expand-body:dot (body params)
+  "Expand BODY according to PARAMS, return the expanded body."
+  (let ((vars (mapcar #'cdr (org-babel-get-header params :var))))
+    (mapc
+     (lambda (pair)
+       (let ((name (symbol-name (car pair)))
+            (value (cdr pair)))
+        (setq body
+              (replace-regexp-in-string
+               (concat "\$" (regexp-quote name))
+               (if (stringp value) value (format "%S" value))
+               body))))
+     vars)
+    body))
+
+(defun org-babel-execute:dot (body params)
+  "Execute a block of Dot code with org-babel.
+This function is called by `org-babel-execute-src-block'."
+  (let* ((result-params (cdr (assoc :result-params params)))
+        (out-file (cdr (or (assoc :file params)
+                           (error "You need to specify a :file parameter"))))
+        (cmdline (or (cdr (assoc :cmdline params))
+                     (format "-T%s" (file-name-extension out-file))))
+        (cmd (or (cdr (assoc :cmd params)) "dot"))
+        (in-file (org-babel-temp-file "dot-")))
+    (with-temp-file in-file
+      (insert (org-babel-expand-body:dot body params)))
+    (org-babel-eval
+     (concat cmd
+            " " (org-babel-process-file-name in-file)
+            " " cmdline
+            " -o " (org-babel-process-file-name out-file)) "")
+    nil)) ;; signal that output has already been written to file
+
+(defun org-babel-prep-session:dot (session params)
+  "Return an error because Dot does not support sessions."
+  (error "Dot does not support sessions"))
+
+(provide 'ob-dot)
+
+
+
+;;; ob-dot.el ends here
diff --git a/elisp/org/ob-emacs-lisp.el b/elisp/org/ob-emacs-lisp.el
new file mode 100644 (file)
index 0000000..886645d
--- /dev/null
@@ -0,0 +1,81 @@
+;;; ob-emacs-lisp.el --- org-babel functions for emacs-lisp code evaluation
+
+;; Copyright (C) 2009-2013 Free Software Foundation, Inc.
+
+;; Author: Eric Schulte
+;; Keywords: literate programming, reproducible research
+;; Homepage: http://orgmode.org
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
+
+;;; Commentary:
+
+;; Org-Babel support for evaluating emacs-lisp code
+
+;;; Code:
+(require 'ob)
+
+(defvar org-babel-default-header-args:emacs-lisp
+  '((:hlines . "yes") (:colnames . "no"))
+  "Default arguments for evaluating an emacs-lisp source block.")
+
+(declare-function orgtbl-to-generic "org-table" (table params))
+
+(defun org-babel-expand-body:emacs-lisp (body params)
+  "Expand BODY according to PARAMS, return the expanded body."
+  (let* ((vars (mapcar #'cdr (org-babel-get-header params :var)))
+         (result-params (cdr (assoc :result-params params)))
+         (print-level nil) (print-length nil)
+         (body (if (> (length vars) 0)
+                  (concat "(let ("
+                          (mapconcat
+                           (lambda (var)
+                             (format "%S" (print `(,(car var) ',(cdr var)))))
+                           vars "\n      ")
+                          ")\n" body "\n)")
+                (concat body "\n"))))
+    (if (or (member "code" result-params)
+           (member "pp" result-params))
+       (concat "(pp " body ")") body)))
+
+(defun org-babel-execute:emacs-lisp (body params)
+  "Execute a block of emacs-lisp code with Babel."
+  (save-window-excursion
+    ((lambda (result)
+       (org-babel-result-cond (cdr (assoc :result-params params))
+        (let ((print-level nil)
+              (print-length nil))
+          (if (or (member "scalar" (cdr (assoc :result-params params)))
+                  (member "verbatim" (cdr (assoc :result-params params))))
+              (format "%S" result)
+            (format "%s" result)))
+        (org-babel-reassemble-table
+         result
+         (org-babel-pick-name (cdr (assoc :colname-names params))
+                              (cdr (assoc :colnames params)))
+         (org-babel-pick-name (cdr (assoc :rowname-names params))
+                              (cdr (assoc :rownames params))))))
+     (eval (read (format (if (member "output"
+                                    (cdr (assoc :result-params params)))
+                            "(with-output-to-string %s)"
+                          "(progn %s)")
+                        (org-babel-expand-body:emacs-lisp body params)))))))
+
+(provide 'ob-emacs-lisp)
+
+
+
+;;; ob-emacs-lisp.el ends here
diff --git a/elisp/org/ob-eval.el b/elisp/org/ob-eval.el
new file mode 100644 (file)
index 0000000..22d2bcf
--- /dev/null
@@ -0,0 +1,277 @@
+;;; ob-eval.el --- org-babel functions for external code evaluation
+
+;; Copyright (C) 2009-2013 Free Software Foundation, Inc.
+
+;; Author: Eric Schulte
+;; Keywords: literate programming, reproducible research, comint
+;; Homepage: http://orgmode.org
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
+
+;;; Commentary:
+
+;; These functions build existing Emacs support for executing external
+;; shell commands.
+
+;;; Code:
+(eval-when-compile (require 'cl))
+
+(defvar org-babel-error-buffer-name "*Org-Babel Error Output*")
+(declare-function org-babel-temp-file "ob-core" (prefix &optional suffix))
+
+(defun org-babel-eval-error-notify (exit-code stderr)
+  "Open a buffer to display STDERR and a message with the value of EXIT-CODE."
+  (let ((buf (get-buffer-create org-babel-error-buffer-name)))
+    (with-current-buffer buf
+      (goto-char (point-max))
+      (save-excursion (insert stderr)))
+    (display-buffer buf))
+  (message "Babel evaluation exited with code %S" exit-code))
+
+(defun org-babel-eval (cmd body)
+  "Run CMD on BODY.
+If CMD succeeds then return its results, otherwise display
+STDERR with `org-babel-eval-error-notify'."
+  (let ((err-buff (get-buffer-create " *Org-Babel Error*")) exit-code)
+    (with-current-buffer err-buff (erase-buffer))
+    (with-temp-buffer
+      (insert body)
+      (setq exit-code
+           (org-babel-shell-command-on-region
+            (point-min) (point-max) cmd t 'replace err-buff))
+      (if (or (not (numberp exit-code)) (> exit-code 0))
+         (progn
+           (with-current-buffer err-buff
+             (org-babel-eval-error-notify exit-code (buffer-string)))
+           nil)
+       (buffer-string)))))
+
+(defun org-babel-eval-read-file (file)
+  "Return the contents of FILE as a string."
+  (with-temp-buffer (insert-file-contents file)
+                   (buffer-string)))
+
+(defun org-babel-shell-command-on-region (start end command
+                                               &optional output-buffer replace
+                                               error-buffer display-error-buffer)
+  "Execute COMMAND in an inferior shell with region as input.
+
+Fixes bugs in the emacs 23.1.1 version of `shell-command-on-region'
+
+Normally display output (if any) in temp buffer `*Shell Command Output*';
+Prefix arg means replace the region with it.  Return the exit code of
+COMMAND.
+
+To specify a coding system for converting non-ASCII characters in
+the input and output to the shell command, use
+\\[universal-coding-system-argument] before this command.  By
+default, the input (from the current buffer) is encoded in the
+same coding system that will be used to save the file,
+`buffer-file-coding-system'.  If the output is going to replace
+the region, then it is decoded from that same coding system.
+
+The noninteractive arguments are START, END, COMMAND,
+OUTPUT-BUFFER, REPLACE, ERROR-BUFFER, and DISPLAY-ERROR-BUFFER.
+Noninteractive callers can specify coding systems by binding
+`coding-system-for-read' and `coding-system-for-write'.
+
+If the command generates output, the output may be displayed
+in the echo area or in a buffer.
+If the output is short enough to display in the echo area
+\(determined by the variable `max-mini-window-height' if
+`resize-mini-windows' is non-nil), it is shown there.  Otherwise
+it is displayed in the buffer `*Shell Command Output*'.  The output
+is available in that buffer in both cases.
+
+If there is output and an error, a message about the error
+appears at the end of the output.
+
+If there is no output, or if output is inserted in the current buffer,
+then `*Shell Command Output*' is deleted.
+
+If the optional fourth argument OUTPUT-BUFFER is non-nil,
+that says to put the output in some other buffer.
+If OUTPUT-BUFFER is a buffer or buffer name, put the output there.
+If OUTPUT-BUFFER is not a buffer and not nil,
+insert output in the current buffer.
+In either case, the output is inserted after point (leaving mark after it).
+
+If REPLACE, the optional fifth argument, is non-nil, that means insert
+the output in place of text from START to END, putting point and mark
+around it.
+
+If optional sixth argument ERROR-BUFFER is non-nil, it is a buffer
+or buffer name to which to direct the command's standard error output.
+If it is nil, error output is mingled with regular output.
+If DISPLAY-ERROR-BUFFER is non-nil, display the error buffer if there
+were any errors.  (This is always t, interactively.)
+In an interactive call, the variable `shell-command-default-error-buffer'
+specifies the value of ERROR-BUFFER."
+  (interactive (let (string)
+                (unless (mark)
+                  (error "The mark is not set now, so there is no region"))
+                ;; Do this before calling region-beginning
+                ;; and region-end, in case subprocess output
+                ;; relocates them while we are in the minibuffer.
+                (setq string (read-shell-command "Shell command on region: "))
+                ;; call-interactively recognizes region-beginning and
+                ;; region-end specially, leaving them in the history.
+                (list (region-beginning) (region-end)
+                      string
+                      current-prefix-arg
+                      current-prefix-arg
+                      shell-command-default-error-buffer
+                      t)))
+  (let ((input-file (org-babel-temp-file "input-"))
+       (error-file (if error-buffer (org-babel-temp-file "scor-") nil))
+       ;; Unfortunately, `executable-find' does not support file name
+       ;; handlers.  Therefore, we could use it in the local case
+       ;; only.
+       (shell-file-name
+        (cond ((and (not (file-remote-p default-directory))
+                    (executable-find shell-file-name))
+               shell-file-name)
+              ((file-executable-p
+                (concat (file-remote-p default-directory) shell-file-name))
+               shell-file-name)
+              ("/bin/sh")))
+       exit-status)
+    ;; There is an error in `process-file' when `error-file' exists.
+    ;; This is fixed in Emacs trunk as of 2012-12-21; let's use this
+    ;; workaround for now.
+    (unless (file-remote-p default-directory)
+      (delete-file error-file))
+    (if (or replace
+           (and output-buffer
+                (not (or (bufferp output-buffer) (stringp output-buffer)))))
+       ;; Replace specified region with output from command.
+       (let ((swap (and replace (< start end))))
+         ;; Don't muck with mark unless REPLACE says we should.
+         (goto-char start)
+         (and replace (push-mark (point) 'nomsg))
+         (write-region start end input-file)
+         (delete-region start end)
+         (setq exit-status
+               (process-file shell-file-name input-file
+                             (if error-file
+                                 (list output-buffer error-file)
+                               t)
+                             nil shell-command-switch command))
+         ;; It is rude to delete a buffer which the command is not using.
+         ;; (let ((shell-buffer (get-buffer "*Shell Command Output*")))
+         ;;   (and shell-buffer (not (eq shell-buffer (current-buffer)))
+         ;;     (kill-buffer shell-buffer)))
+         ;; Don't muck with mark unless REPLACE says we should.
+         (and replace swap (exchange-point-and-mark)))
+      ;; No prefix argument: put the output in a temp buffer,
+      ;; replacing its entire contents.
+      (let ((buffer (get-buffer-create
+                    (or output-buffer "*Shell Command Output*"))))
+       (unwind-protect
+           (if (eq buffer (current-buffer))
+               ;; If the input is the same buffer as the output,
+               ;; delete everything but the specified region,
+               ;; then replace that region with the output.
+               (progn (setq buffer-read-only nil)
+                      (delete-region (max start end) (point-max))
+                      (delete-region (point-min) (min start end))
+                      (write-region (point-min) (point-max) input-file)
+                      (delete-region (point-min) (point-max))
+                      (setq exit-status
+                            (process-file shell-file-name input-file
+                                          (if error-file
+                                              (list t error-file)
+                                            t)
+                                          nil shell-command-switch command)))
+             ;; Clear the output buffer, then run the command with
+             ;; output there.
+             (let ((directory default-directory))
+               (with-current-buffer buffer
+                 (setq buffer-read-only nil)
+                 (if (not output-buffer)
+                     (setq default-directory directory))
+                 (erase-buffer)))
+             (setq exit-status
+                   (process-file shell-file-name nil
+                                 (if error-file
+                                     (list buffer error-file)
+                                   buffer)
+                                 nil shell-command-switch command)))
+         ;; Report the output.
+         (with-current-buffer buffer
+           (setq mode-line-process
+                 (cond ((null exit-status)
+                        " - Error")
+                       ((stringp exit-status)
+                        (format " - Signal [%s]" exit-status))
+                       ((not (equal 0 exit-status))
+                        (format " - Exit [%d]" exit-status)))))
+         (if (with-current-buffer buffer (> (point-max) (point-min)))
+             ;; There's some output, display it
+             (display-message-or-buffer buffer)
+           ;; No output; error?
+           (let ((output
+                  (if (and error-file
+                           (< 0 (nth 7 (file-attributes error-file))))
+                      "some error output"
+                    "no output")))
+             (cond ((null exit-status)
+                    (message "(Shell command failed with error)"))
+                   ((equal 0 exit-status)
+                    (message "(Shell command succeeded with %s)"
+                             output))
+                   ((stringp exit-status)
+                    (message "(Shell command killed by signal %s)"
+                             exit-status))
+                   (t
+                    (message "(Shell command failed with code %d and %s)"
+                             exit-status output))))
+           ;; Don't kill: there might be useful info in the undo-log.
+           ;; (kill-buffer buffer)
+           ))))
+
+    (when (and input-file (file-exists-p input-file))
+      (delete-file input-file))
+
+    (when (and error-file (file-exists-p error-file))
+      (if (< 0 (nth 7 (file-attributes error-file)))
+         (with-current-buffer (get-buffer-create error-buffer)
+           (let ((pos-from-end (- (point-max) (point))))
+             (or (bobp)
+                 (insert "\f\n"))
+             ;; Do no formatting while reading error file,
+             ;; because that can run a shell command, and we
+             ;; don't want that to cause an infinite recursion.
+             (format-insert-file error-file nil)
+             ;; Put point after the inserted errors.
+             (goto-char (- (point-max) pos-from-end)))
+           (and display-error-buffer
+                (display-buffer (current-buffer)))))
+      (delete-file error-file))
+    exit-status))
+
+(defun org-babel-eval-wipe-error-buffer ()
+  "Delete the contents of the Org code block error buffer.
+This buffer is named by `org-babel-error-buffer-name'."
+  (when (get-buffer org-babel-error-buffer-name)
+    (with-current-buffer org-babel-error-buffer-name
+      (delete-region (point-min) (point-max)))))
+
+(provide 'ob-eval)
+
+
+
+;;; ob-eval.el ends here
diff --git a/elisp/org/ob-exp.el b/elisp/org/ob-exp.el
new file mode 100644 (file)
index 0000000..0d98690
--- /dev/null
@@ -0,0 +1,419 @@
+;;; ob-exp.el --- Exportation of org-babel source blocks
+
+;; Copyright (C) 2009-2013 Free Software Foundation, Inc.
+
+;; Authors: Eric Schulte
+;;     Dan Davison
+;; Keywords: literate programming, reproducible research
+;; Homepage: http://orgmode.org
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
+
+;;; Code:
+(require 'ob-core)
+(eval-when-compile
+  (require 'cl))
+
+(defvar org-current-export-file)
+(defvar org-babel-lob-one-liner-regexp)
+(defvar org-babel-ref-split-regexp)
+(defvar org-list-forbidden-blocks)
+
+(declare-function org-babel-lob-get-info "ob-lob" ())
+(declare-function org-babel-eval-wipe-error-buffer "ob-eval" ())
+(declare-function org-between-regexps-p "org"
+                 (start-re end-re &optional lim-up lim-down))
+(declare-function org-get-indentation "org" (&optional line))
+(declare-function org-heading-components "org" ())
+(declare-function org-in-block-p "org" (names))
+(declare-function org-in-verbatim-emphasis "org" ())
+(declare-function org-link-search "org" (s &optional type avoid-pos stealth))
+(declare-function org-fill-template "org" (template alist))
+(declare-function org-split-string "org" (string &optional separators))
+(declare-function org-element-at-point "org-element" (&optional keep-trail))
+(declare-function org-element-context "org-element" ())
+(declare-function org-element-property "org-element" (property element))
+(declare-function org-element-type "org-element" (element))
+(declare-function org-escape-code-in-string "org-src" (s))
+
+(defcustom org-export-babel-evaluate t
+  "Switch controlling code evaluation during export.
+When set to nil no code will be evaluated as part of the export
+process."
+  :group 'org-babel
+  :version "24.1"
+  :type 'boolean)
+(put 'org-export-babel-evaluate 'safe-local-variable (lambda (x) (eq x nil)))
+
+(defun org-babel-exp-get-export-buffer ()
+  "Return the current export buffer if possible."
+  (cond
+   ((bufferp org-current-export-file) org-current-export-file)
+   (org-current-export-file (get-file-buffer org-current-export-file))
+   ('otherwise
+    (error "Requested export buffer when `org-current-export-file' is nil"))))
+
+(defmacro org-babel-exp-in-export-file (lang &rest body)
+  (declare (indent 1))
+  `(let* ((lang-headers (intern (concat "org-babel-default-header-args:" ,lang)))
+         (heading (nth 4 (ignore-errors (org-heading-components))))
+         (export-buffer (current-buffer))
+         (original-buffer (org-babel-exp-get-export-buffer)) results)
+     (when original-buffer
+       ;; resolve parameters in the original file so that
+       ;; headline and file-wide parameters are included, attempt
+       ;; to go to the same heading in the original file
+       (set-buffer original-buffer)
+       (save-restriction
+        (when heading
+          (condition-case nil
+              (let ((org-link-search-inhibit-query t))
+                (org-link-search heading))
+            (error (when heading
+                     (goto-char (point-min))
+                     (re-search-forward (regexp-quote heading) nil t)))))
+        (setq results ,@body))
+       (set-buffer export-buffer)
+       results)))
+(def-edebug-spec org-babel-exp-in-export-file (form body))
+
+(defun org-babel-exp-src-block (&rest headers)
+  "Process source block for export.
+Depending on the 'export' headers argument in replace the source
+code block with...
+
+both ---- display the code and the results
+
+code ---- the default, display the code inside the block but do
+          not process
+
+results - just like none only the block is run on export ensuring
+          that it's results are present in the org-mode buffer
+
+none ----- do not display either code or results upon export
+
+Assume point is at the beginning of block's starting line."
+  (interactive)
+  (unless noninteractive (message "org-babel-exp processing..."))
+  (save-excursion
+    (let* ((info (org-babel-get-src-block-info 'light))
+          (lang (nth 0 info))
+          (raw-params (nth 2 info)) hash)
+      ;; bail if we couldn't get any info from the block
+      (when info
+       ;; if we're actually going to need the parameters
+       (when (member (cdr (assoc :exports (nth 2 info))) '("both" "results"))
+         (org-babel-exp-in-export-file lang
+           (setf (nth 2 info)
+                 (org-babel-process-params
+                  (org-babel-merge-params
+                   org-babel-default-header-args
+                   (org-babel-params-from-properties lang)
+                   (if (boundp lang-headers) (eval lang-headers) nil)
+                   raw-params))))
+         (setf hash (org-babel-sha1-hash info)))
+       (org-babel-exp-do-export info 'block hash)))))
+
+(defcustom org-babel-exp-call-line-template
+  ""
+  "Template used to export call lines.
+This template may be customized to include the call line name
+with any export markup.  The template is filled out using
+`org-fill-template', and the following %keys may be used.
+
+ line --- call line
+
+An example value would be \"\\n: call: %line\" to export the call line
+wrapped in a verbatim environment.
+
+Note: the results are inserted separately after the contents of
+this template."
+  :group 'org-babel
+  :type 'string)
+
+(defvar org-babel-default-lob-header-args)
+(defun org-babel-exp-non-block-elements (start end)
+  "Process inline source and call lines between START and END for export."
+  (interactive)
+  (save-excursion
+    (goto-char start)
+    (unless (markerp end)
+      (let ((m (make-marker)))
+       (set-marker m end (current-buffer))
+       (setq end m)))
+    (let ((rx (concat "\\(?:"  org-babel-inline-src-block-regexp
+                     "\\|" org-babel-lob-one-liner-regexp "\\)")))
+      (while (re-search-forward rx end t)
+       (save-excursion
+         (let* ((element (save-excursion
+                           ;; If match is inline, point is at its
+                           ;; end.  Move backward so
+                           ;; `org-element-context' can get the
+                           ;; object, not the following one.
+                           (backward-char)
+                           (save-match-data (org-element-context))))
+                (type (org-element-type element)))
+           (when (memq type '(babel-call inline-babel-call inline-src-block))
+             (let ((beg-el (org-element-property :begin element))
+                   (end-el (org-element-property :end element)))
+               (case type
+                 (inline-src-block
+                  (let* ((info (org-babel-parse-inline-src-block-match))
+                         (params (nth 2 info)))
+                    (setf (nth 1 info)
+                          (if (and (cdr (assoc :noweb params))
+                                   (string= "yes" (cdr (assoc :noweb params))))
+                              (org-babel-expand-noweb-references
+                               info (org-babel-exp-get-export-buffer))
+                            (nth 1 info)))
+                    (goto-char beg-el)
+                    (let ((replacement (org-babel-exp-do-export info 'inline)))
+                      (if (equal replacement "")
+                          ;; Replacement code is empty: completely
+                          ;; remove inline src block, including extra
+                          ;; white space that might have been created
+                          ;; when inserting results.
+                          (delete-region beg-el
+                                         (progn (goto-char end-el)
+                                                (skip-chars-forward " \t")
+                                                (point)))
+                        ;; Otherwise: remove inline src block but
+                        ;; preserve following white spaces.  Then
+                        ;; insert value.
+                        (delete-region beg-el
+                                       (progn (goto-char end-el)
+                                              (skip-chars-backward " \t")
+                                              (point)))
+                        (insert replacement)))))
+                 ((babel-call inline-babel-call)
+                  (let* ((lob-info (org-babel-lob-get-info))
+                         (results
+                          (org-babel-exp-do-export
+                           (list "emacs-lisp" "results"
+                                 (org-babel-merge-params
+                                  org-babel-default-header-args
+                                  org-babel-default-lob-header-args
+                                  (org-babel-params-from-properties)
+                                  (org-babel-parse-header-arguments
+                                   (org-no-properties
+                                    (concat ":var results="
+                                            (mapconcat 'identity
+                                                       (butlast lob-info)
+                                                       " ")))))
+                                 "" nil (car (last lob-info)))
+                           'lob))
+                         (rep (org-fill-template
+                               org-babel-exp-call-line-template
+                               `(("line"  . ,(nth 0 lob-info))))))
+                    ;; If replacement is empty, completely remove the
+                    ;; object/element, including any extra white space
+                    ;; that might have been created when including
+                    ;; results.
+                    (if (equal rep "")
+                        (delete-region
+                         beg-el
+                         (progn (goto-char end-el)
+                                (if (not (eq type 'babel-call))
+                                    (progn (skip-chars-forward " \t") (point))
+                                  (skip-chars-forward " \r\t\n")
+                                  (line-beginning-position))))
+                      ;; Otherwise, preserve following white
+                      ;; spaces/newlines and then, insert replacement
+                      ;; string.
+                      (goto-char beg-el)
+                      (delete-region beg-el
+                                     (progn (goto-char end-el)
+                                            (skip-chars-backward " \r\t\n")
+                                            (point)))
+                      (insert rep)))))))))))))
+
+(defvar org-src-preserve-indentation)  ; From org-src.el
+(defun org-babel-exp-process-buffer ()
+  "Execute all blocks in visible part of buffer."
+  (interactive)
+  (save-window-excursion
+    (let ((case-fold-search t)
+         (pos (point-min)))
+      (goto-char pos)
+      (while (re-search-forward "^[ \t]*#\\+BEGIN_SRC" nil t)
+        (let ((element (save-match-data (org-element-at-point))))
+          (when (eq (org-element-type element) 'src-block)
+            (let* ((match-start (copy-marker (match-beginning 0)))
+                   (begin (copy-marker (org-element-property :begin element)))
+                   ;; Make sure we don't remove any blank lines after
+                   ;; the block when replacing it.
+                   (block-end (save-excursion
+                               (goto-char (org-element-property :end element))
+                               (skip-chars-backward " \r\t\n")
+                               (copy-marker (line-end-position))))
+                   (ind (org-get-indentation))
+                   (headers
+                   (cons
+                    (org-element-property :language element)
+                    (let ((params (org-element-property :parameters element)))
+                      (and params (org-split-string params "[ \t]+")))))
+                   (preserve-indent
+                   (or org-src-preserve-indentation
+                       (org-element-property :preserve-indent element))))
+              ;; Execute all non-block elements between POS and
+              ;; current block.
+              (org-babel-exp-non-block-elements pos begin)
+             ;; Take care of matched block: compute replacement
+             ;; string. In particular, a nil REPLACEMENT means the
+             ;; block should be left as-is while an empty string
+             ;; should remove the block.
+              (let ((replacement (progn (goto-char match-start)
+                                       (org-babel-exp-src-block headers))))
+                (cond ((not replacement) (goto-char block-end))
+                     ((equal replacement "")
+                      (delete-region begin
+                                     (progn (goto-char block-end)
+                                            (skip-chars-forward " \r\t\n")
+                                            (if (eobp) (point)
+                                              (line-beginning-position)))))
+                     (t
+                      (goto-char match-start)
+                      (delete-region (point) block-end)
+                      (insert replacement)
+                      (if preserve-indent
+                          ;; Indent only the code block markers.
+                          (save-excursion (skip-chars-backward " \r\t\n")
+                                          (indent-line-to ind)
+                                          (goto-char match-start)
+                                          (indent-line-to ind))
+                        ;; Indent everything.
+                        (indent-rigidly match-start (point) ind)))))
+             (setq pos (line-beginning-position))
+              ;; Cleanup markers.
+             (set-marker match-start nil)
+             (set-marker begin nil)
+              (set-marker block-end nil)))))
+      ;; Eventually execute all non-block Babel elements between last
+      ;; src-block and end of buffer.
+      (org-babel-exp-non-block-elements pos (point-max)))))
+
+(defun org-babel-in-example-or-verbatim ()
+  "Return true if point is in example or verbatim code.
+Example and verbatim code include escaped portions of
+an org-mode buffer code that should be treated as normal
+org-mode text."
+  (or (save-match-data
+       (save-excursion
+         (goto-char (point-at-bol))
+         (looking-at "[ \t]*:[ \t]")))
+      (org-in-verbatim-emphasis)
+      (org-in-block-p org-list-forbidden-blocks)
+      (org-between-regexps-p "^[ \t]*#\\+begin_src" "^[ \t]*#\\+end_src")))
+
+(defun org-babel-exp-do-export (info type &optional hash)
+  "Return a string with the exported content of a code block.
+The function respects the value of the :exports header argument."
+  (let ((silently (lambda () (let ((session (cdr (assoc :session (nth 2 info)))))
+                              (when (not (and session (equal "none" session)))
+                                (org-babel-exp-results info type 'silent)))))
+       (clean (lambda () (unless (eq type 'inline) (org-babel-remove-result info)))))
+    (case (intern (or (cdr (assoc :exports (nth 2 info))) "code"))
+      ('none (funcall silently) (funcall clean) "")
+      ('code (funcall silently) (funcall clean) (org-babel-exp-code info))
+      ('results (org-babel-exp-results info type nil hash) "")
+      ('both (org-babel-exp-results info type nil hash)
+            (org-babel-exp-code info)))))
+
+(defcustom org-babel-exp-code-template
+  "#+BEGIN_SRC %lang%flags\n%body\n#+END_SRC"
+  "Template used to export the body of code blocks.
+This template may be customized to include additional information
+such as the code block name, or the values of particular header
+arguments.  The template is filled out using `org-fill-template',
+and the following %keys may be used.
+
+ lang ------ the language of the code block
+ name ------ the name of the code block
+ body ------ the body of the code block
+ flags ----- the flags passed to the code block
+
+In addition to the keys mentioned above, every header argument
+defined for the code block may be used as a key and will be
+replaced with its value."
+  :group 'org-babel
+  :type 'string)
+
+(defun org-babel-exp-code (info)
+  "Return the original code block formatted for export."
+  (setf (nth 1 info)
+       (if (string= "strip-export" (cdr (assoc :noweb (nth 2 info))))
+           (replace-regexp-in-string
+            (org-babel-noweb-wrap) "" (nth 1 info))
+         (if (org-babel-noweb-p (nth 2 info) :export)
+             (org-babel-expand-noweb-references
+              info (org-babel-exp-get-export-buffer))
+           (nth 1 info))))
+  (org-fill-template
+   org-babel-exp-code-template
+   `(("lang"  . ,(nth 0 info))
+     ("body"  . ,(org-escape-code-in-string (nth 1 info)))
+     ,@(mapcar (lambda (pair)
+                (cons (substring (symbol-name (car pair)) 1)
+                      (format "%S" (cdr pair))))
+              (nth 2 info))
+     ("flags" . ,((lambda (f) (when f (concat " " f))) (nth 3 info)))
+     ("name"  . ,(or (nth 4 info) "")))))
+
+(defun org-babel-exp-results (info type &optional silent hash)
+  "Evaluate and return the results of the current code block for export.
+Results are prepared in a manner suitable for export by org-mode.
+This function is called by `org-babel-exp-do-export'.  The code
+block will be evaluated.  Optional argument SILENT can be used to
+inhibit insertion of results into the buffer."
+  (when (and org-export-babel-evaluate
+            (not (and hash (equal hash (org-babel-current-result-hash)))))
+    (let ((lang (nth 0 info))
+         (body (if (org-babel-noweb-p (nth 2 info) :eval)
+                   (org-babel-expand-noweb-references
+                    info (org-babel-exp-get-export-buffer))
+                 (nth 1 info)))
+         (info (copy-sequence info)))
+      ;; skip code blocks which we can't evaluate
+      (when (fboundp (intern (concat "org-babel-execute:" lang)))
+       (org-babel-eval-wipe-error-buffer)
+       (prog1 nil
+         (setf (nth 1 info) body)
+         (setf (nth 2 info)
+               (org-babel-exp-in-export-file lang
+                 (org-babel-process-params
+                  (org-babel-merge-params
+                   (nth 2 info)
+                   `((:results . ,(if silent "silent" "replace")))))))
+         (cond
+          ((equal type 'block)
+           (org-babel-execute-src-block nil info))
+          ((equal type 'inline)
+           ;; position the point on the inline source block allowing
+           ;; `org-babel-insert-result' to check that the block is
+           ;; inline
+           (re-search-backward "[ \f\t\n\r\v]" nil t)
+           (re-search-forward org-babel-inline-src-block-regexp nil t)
+           (re-search-backward "src_" nil t)
+           (org-babel-execute-src-block nil info))
+          ((equal type 'lob)
+           (save-excursion
+             (re-search-backward org-babel-lob-one-liner-regexp nil t)
+             (org-babel-execute-src-block nil info)))))))))
+
+
+(provide 'ob-exp)
+
+;;; ob-exp.el ends here
diff --git a/elisp/org/ob-fortran.el b/elisp/org/ob-fortran.el
new file mode 100644 (file)
index 0000000..1eab03e
--- /dev/null
@@ -0,0 +1,161 @@
+;;; ob-fortran.el --- org-babel functions for fortran
+
+;; Copyright (C) 2011-2013 Free Software Foundation, Inc.
+
+;; Authors: Sergey Litvinov
+;;       Eric Schulte
+;; Keywords: literate programming, reproducible research, fortran
+;; Homepage: http://orgmode.org
+
+;; This file is part of GNU Emacs.
+;;
+;; GNU Emacs is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
+
+;;; Commentary:
+
+;; Org-Babel support for evaluating fortran code.
+
+;;; Code:
+(require 'ob)
+(require 'cc-mode)
+
+(declare-function org-entry-get "org"
+                 (pom property &optional inherit literal-nil))
+
+(defvar org-babel-tangle-lang-exts)
+(add-to-list 'org-babel-tangle-lang-exts '("fortran" . "F90"))
+
+(defvar org-babel-default-header-args:fortran '())
+
+(defvar org-babel-fortran-compiler "gfortran"
+  "fortran command used to compile a fortran source code file into an
+  executable.")
+
+(defun org-babel-execute:fortran (body params)
+  "This function should only be called by `org-babel-execute:fortran'"
+  (let* ((tmp-src-file (org-babel-temp-file "fortran-src-" ".F90"))
+         (tmp-bin-file (org-babel-temp-file "fortran-bin-" org-babel-exeext))
+         (cmdline (cdr (assoc :cmdline params)))
+         (flags (cdr (assoc :flags params)))
+         (full-body (org-babel-expand-body:fortran body params))
+         (compile
+         (progn
+           (with-temp-file tmp-src-file (insert full-body))
+           (org-babel-eval
+            (format "%s -o %s %s %s"
+                    org-babel-fortran-compiler
+                    (org-babel-process-file-name tmp-bin-file)
+                    (mapconcat 'identity
+                               (if (listp flags) flags (list flags)) " ")
+                    (org-babel-process-file-name tmp-src-file)) ""))))
+    ((lambda (results)
+       (org-babel-reassemble-table
+       (org-babel-result-cond (cdr (assoc :result-params params))
+         (org-babel-read results)
+         (let ((tmp-file (org-babel-temp-file "f-")))
+           (with-temp-file tmp-file (insert results))
+           (org-babel-import-elisp-from-file tmp-file)))
+       (org-babel-pick-name
+        (cdr (assoc :colname-names params)) (cdr (assoc :colnames params)))
+       (org-babel-pick-name
+        (cdr (assoc :rowname-names params)) (cdr (assoc :rownames params)))))
+     (org-babel-trim
+      (org-babel-eval
+       (concat tmp-bin-file (if cmdline (concat " " cmdline) "")) "")))))
+
+(defun org-babel-expand-body:fortran (body params)
+  "Expand a block of fortran or fortran code with org-babel according to
+it's header arguments."
+  (let ((vars (mapcar #'cdr (org-babel-get-header params :var)))
+        (main-p (not (string= (cdr (assoc :main params)) "no")))
+        (includes (or (cdr (assoc :includes params))
+                      (org-babel-read (org-entry-get nil "includes" t))))
+        (defines (org-babel-read
+                  (or (cdr (assoc :defines params))
+                      (org-babel-read (org-entry-get nil "defines" t))))))
+    (mapconcat 'identity
+              (list
+               ;; includes
+               (mapconcat
+                (lambda (inc) (format "#include %s" inc))
+                (if (listp includes) includes (list includes)) "\n")
+               ;; defines
+               (mapconcat
+                (lambda (inc) (format "#define %s" inc))
+                (if (listp defines) defines (list defines)) "\n")
+               ;; body
+               (if main-p
+                   (org-babel-fortran-ensure-main-wrap
+                    (concat
+                     ;; variables
+                     (mapconcat 'org-babel-fortran-var-to-fortran vars "\n")
+                     body) params)
+                 body) "\n") "\n")))
+
+(defun org-babel-fortran-ensure-main-wrap (body params)
+  "Wrap body in a \"program ... end program\" block if none exists."
+  (if (string-match "^[ \t]*program[ \t]*.*" (capitalize body))
+      (let ((vars (mapcar #'cdr (org-babel-get-header params :var))))
+       (if vars (error "Cannot use :vars if 'program' statement is present"))
+       body)
+    (format "program main\n%s\nend program main\n" body)))
+
+(defun org-babel-prep-session:fortran (session params)
+  "This function does nothing as fortran is a compiled language with no
+support for sessions"
+  (error "Fortran is a compiled languages -- no support for sessions"))
+
+(defun org-babel-load-session:fortran (session body params)
+  "This function does nothing as fortran is a compiled language with no
+support for sessions"
+  (error "Fortran is a compiled languages -- no support for sessions"))
+
+;; helper functions
+
+(defun org-babel-fortran-var-to-fortran (pair)
+  "Convert an elisp val into a string of fortran code specifying a var
+of the same value."
+  ;; TODO list support
+  (let ((var (car pair))
+        (val (cdr pair)))
+    (when (symbolp val)
+      (setq val (symbol-name val))
+      (when (= (length val) 1)
+        (setq val (string-to-char val))))
+    (cond
+     ((integerp val)
+      (format "integer, parameter  ::  %S = %S\n" var val))
+     ((floatp val)
+      (format "real, parameter ::  %S = %S\n" var val))
+     ((or (integerp val))
+      (format "character, parameter :: %S = '%S'\n" var val))
+     ((stringp val)
+      (format "character(len=%d), parameter ::  %S = '%s'\n"
+              (length val) var val))
+     ((listp val)
+      (format "real, parameter :: %S(%d) = %s\n"
+             var (length val) (org-babel-fortran-transform-list val)))
+     (t
+      (error (format "the type of parameter %s is not supported by ob-fortran"
+                    var))))))
+
+(defun org-babel-fortran-transform-list (val)
+  "Return a fortran representation of enclose syntactic lists."
+  (if (listp val)
+      (concat "(/" (mapconcat #'org-babel-fortran-transform-list val ", ") "/)")
+    (format "%S" val)))
+
+(provide 'ob-fortran)
+
+;;; ob-fortran.el ends here
diff --git a/elisp/org/ob-gnuplot.el b/elisp/org/ob-gnuplot.el
new file mode 100644 (file)
index 0000000..4b3a1c6
--- /dev/null
@@ -0,0 +1,234 @@
+;;; ob-gnuplot.el --- org-babel functions for gnuplot evaluation
+
+;; Copyright (C) 2009-2013 Free Software Foundation, Inc.
+
+;; Author: Eric Schulte
+;; Keywords: literate programming, reproducible research
+;; Homepage: http://orgmode.org
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
+
+;;; Commentary:
+
+;; Org-Babel support for evaluating gnuplot source code.
+;;
+;; This differs from most standard languages in that
+;;
+;; 1) we are generally only going to return results of type "file"
+;;
+;; 2) we are adding the "file" and "cmdline" header arguments
+
+;;; Requirements:
+
+;; - gnuplot :: http://www.gnuplot.info/
+;;
+;; - gnuplot-mode :: http://cars9.uchicago.edu/~ravel/software/gnuplot-mode.html
+
+;;; Code:
+(require 'ob)
+(eval-when-compile (require 'cl))
+
+(declare-function org-time-string-to-time "org" (s))
+(declare-function org-combine-plists "org" (&rest plists))
+(declare-function orgtbl-to-generic "org-table" (table params))
+(declare-function gnuplot-mode "ext:gnuplot-mode" ())
+(declare-function gnuplot-send-string-to-gnuplot "ext:gnuplot-mode" (str txt))
+(declare-function gnuplot-send-buffer-to-gnuplot "ext:gnuplot-mode" ())
+
+(defvar org-babel-default-header-args:gnuplot
+  '((:results . "file") (:exports . "results") (:session . nil))
+  "Default arguments to use when evaluating a gnuplot source block.")
+
+(defvar org-babel-gnuplot-timestamp-fmt nil)
+
+(defun org-babel-gnuplot-process-vars (params)
+  "Extract variables from PARAMS and process the variables.
+Dumps all vectors into files and returns an association list
+of variable names and the related value to be used in the gnuplot
+code."
+  (mapcar
+   (lambda (pair)
+     (cons
+      (car pair) ;; variable name
+      (if (listp (cdr pair)) ;; variable value
+          (org-babel-gnuplot-table-to-data
+           (cdr pair) (org-babel-temp-file "gnuplot-") params)
+        (cdr pair))))
+   (mapcar #'cdr (org-babel-get-header params :var))))
+
+(defun org-babel-expand-body:gnuplot (body params)
+  "Expand BODY according to PARAMS, return the expanded body."
+  (save-window-excursion
+    (let* ((vars (org-babel-gnuplot-process-vars params))
+           (out-file (cdr (assoc :file params)))
+           (term (or (cdr (assoc :term params))
+                     (when out-file (file-name-extension out-file))))
+           (cmdline (cdr (assoc :cmdline params)))
+           (title (plist-get params :title))
+           (lines (plist-get params :line))
+           (sets (plist-get params :set))
+           (x-labels (plist-get params :xlabels))
+           (y-labels (plist-get params :ylabels))
+           (timefmt (plist-get params :timefmt))
+           (time-ind (or (plist-get params :timeind)
+                         (when timefmt 1)))
+          (add-to-body (lambda (text) (setq body (concat text "\n" body))))
+           output)
+      ;; append header argument settings to body
+      (when title (funcall add-to-body (format "set title '%s'" title))) ;; title
+      (when lines (mapc (lambda (el) (funcall add-to-body el)) lines)) ;; line
+      (when sets
+       (mapc (lambda (el) (funcall add-to-body (format "set %s" el))) sets))
+      (when x-labels
+       (funcall add-to-body
+                (format "set xtics (%s)"
+                        (mapconcat (lambda (pair)
+                                     (format "\"%s\" %d" (cdr pair) (car pair)))
+                                   x-labels ", "))))
+      (when y-labels
+       (funcall add-to-body
+                (format "set ytics (%s)"
+                        (mapconcat (lambda (pair)
+                                     (format "\"%s\" %d" (cdr pair) (car pair)))
+                                   y-labels ", "))))
+      (when time-ind
+       (funcall add-to-body "set xdata time")
+       (funcall add-to-body (concat "set timefmt \""
+                                    (or timefmt
+                                        "%Y-%m-%d-%H:%M:%S") "\"")))
+      (when out-file (funcall add-to-body (format "set output \"%s\"" out-file)))
+      (when term (funcall add-to-body (format "set term %s" term)))
+      ;; insert variables into code body: this should happen last
+      ;; placing the variables at the *top* of the code in case their
+      ;; values are used later
+      (funcall add-to-body (mapconcat #'identity
+                                     (org-babel-variable-assignments:gnuplot params)
+                                     "\n"))
+      ;; replace any variable names preceded by '$' with the actual
+      ;; value of the variable
+      (mapc (lambda (pair)
+             (setq body (replace-regexp-in-string
+                         (format "\\$%s" (car pair)) (cdr pair) body)))
+           vars))
+    body))
+
+(defun org-babel-execute:gnuplot (body params)
+  "Execute a block of Gnuplot code.
+This function is called by `org-babel-execute-src-block'."
+  (require 'gnuplot)
+  (let ((session (cdr (assoc :session params)))
+        (result-type (cdr (assoc :results params)))
+        (out-file (cdr (assoc :file params)))
+        (body (org-babel-expand-body:gnuplot body params))
+       output)
+    (save-window-excursion
+      ;; evaluate the code body with gnuplot
+      (if (string= session "none")
+          (let ((script-file (org-babel-temp-file "gnuplot-script-")))
+            (with-temp-file script-file
+              (insert (concat body "\n")))
+            (message "gnuplot \"%s\"" script-file)
+            (setq output
+                  (shell-command-to-string
+                  (format
+                   "gnuplot \"%s\""
+                   (org-babel-process-file-name
+                    script-file
+                    (if (member system-type '(cygwin windows-nt ms-dos))
+                        t nil)))))
+            (message output))
+        (with-temp-buffer
+          (insert (concat body "\n"))
+          (gnuplot-mode)
+          (gnuplot-send-buffer-to-gnuplot)))
+      (if (member "output" (split-string result-type))
+          output
+       nil)))) ;; signal that output has already been written to file
+
+(defun org-babel-prep-session:gnuplot (session params)
+  "Prepare SESSION according to the header arguments in PARAMS."
+  (let* ((session (org-babel-gnuplot-initiate-session session))
+         (var-lines (org-babel-variable-assignments:gnuplot params)))
+    (message "%S" session)
+    (org-babel-comint-in-buffer session
+      (mapc (lambda (var-line)
+              (insert var-line) (comint-send-input nil t)
+              (org-babel-comint-wait-for-output session)
+              (sit-for .1) (goto-char (point-max))) var-lines))
+    session))
+
+(defun org-babel-load-session:gnuplot (session body params)
+  "Load BODY into SESSION."
+  (save-window-excursion
+    (let ((buffer (org-babel-prep-session:gnuplot session params)))
+      (with-current-buffer buffer
+        (goto-char (process-mark (get-buffer-process (current-buffer))))
+        (insert (org-babel-chomp body)))
+      buffer)))
+
+(defun org-babel-variable-assignments:gnuplot (params)
+  "Return list of gnuplot statements assigning the block's variables."
+  (mapcar
+   (lambda (pair) (format "%s = \"%s\"" (car pair) (cdr pair)))
+   (org-babel-gnuplot-process-vars params)))
+
+(defvar gnuplot-buffer)
+(defun org-babel-gnuplot-initiate-session (&optional session params)
+  "Initiate a gnuplot session.
+If there is not a current inferior-process-buffer in SESSION
+then create one.  Return the initialized session.  The current
+`gnuplot-mode' doesn't provide support for multiple sessions."
+  (require 'gnuplot)
+  (unless (string= session "none")
+    (save-window-excursion
+      (gnuplot-send-string-to-gnuplot "" "line")
+      gnuplot-buffer)))
+
+(defun org-babel-gnuplot-quote-timestamp-field (s)
+  "Convert S from timestamp to Unix time and export to gnuplot."
+  (format-time-string org-babel-gnuplot-timestamp-fmt (org-time-string-to-time s)))
+
+(defvar org-table-number-regexp)
+(defvar org-ts-regexp3)
+(defun org-babel-gnuplot-quote-tsv-field (s)
+  "Quote S for export to gnuplot."
+  (unless (stringp s)
+    (setq s (format "%s" s)))
+  (if (string-match org-table-number-regexp s) s
+    (if (string-match org-ts-regexp3 s)
+       (org-babel-gnuplot-quote-timestamp-field s)
+      (concat "\"" (mapconcat 'identity (split-string s "\"") "\"\"") "\""))))
+
+(defun org-babel-gnuplot-table-to-data (table data-file params)
+  "Export TABLE to DATA-FILE in a format readable by gnuplot.
+Pass PARAMS through to `orgtbl-to-generic' when exporting TABLE."
+  (with-temp-file data-file
+    (make-local-variable 'org-babel-gnuplot-timestamp-fmt)
+    (setq org-babel-gnuplot-timestamp-fmt (or
+                                           (plist-get params :timefmt)
+                                           "%Y-%m-%d-%H:%M:%S"))
+    (insert (orgtbl-to-generic
+            table
+            (org-combine-plists
+             '(:sep "\t" :fmt org-babel-gnuplot-quote-tsv-field)
+             params))))
+  data-file)
+
+(provide 'ob-gnuplot)
+
+
+
+;;; ob-gnuplot.el ends here
diff --git a/elisp/org/ob-haskell.el b/elisp/org/ob-haskell.el
new file mode 100644 (file)
index 0000000..a04963f
--- /dev/null
@@ -0,0 +1,223 @@
+;;; ob-haskell.el --- org-babel functions for haskell evaluation
+
+;; Copyright (C) 2009-2013 Free Software Foundation, Inc.
+
+;; Author: Eric Schulte
+;; Keywords: literate programming, reproducible research
+;; Homepage: http://orgmode.org
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
+
+;;; Commentary:
+
+;; Org-Babel support for evaluating haskell source code.  This one will
+;; be sort of tricky because haskell programs must be compiled before
+;; they can be run, but haskell code can also be run through an
+;; interactive interpreter.
+;;
+;; For now lets only allow evaluation using the haskell interpreter.
+
+;;; Requirements:
+
+;; - haskell-mode :: http://www.iro.umontreal.ca/~monnier/elisp/#haskell-mode
+;;
+;; - inf-haskell :: http://www.iro.umontreal.ca/~monnier/elisp/#haskell-mode
+;;
+;; - (optionally) lhs2tex :: http://people.cs.uu.nl/andres/lhs2tex/
+
+;;; Code:
+(require 'ob)
+(require 'comint)
+(eval-when-compile (require 'cl))
+
+(declare-function org-remove-indentation "org" (code &optional n))
+(declare-function haskell-mode "ext:haskell-mode" ())
+(declare-function run-haskell "ext:inf-haskell" (&optional arg))
+(declare-function inferior-haskell-load-file
+                 "ext:inf-haskell" (&optional reload))
+
+(defvar org-babel-tangle-lang-exts)
+(add-to-list 'org-babel-tangle-lang-exts '("haskell" . "hs"))
+
+(defvar org-babel-default-header-args:haskell '())
+
+(defvar org-babel-haskell-lhs2tex-command "lhs2tex")
+
+(defvar org-babel-haskell-eoe "\"org-babel-haskell-eoe\"")
+
+(defun org-babel-execute:haskell (body params)
+  "Execute a block of Haskell code."
+  (let* ((session (cdr (assoc :session params)))
+         (vars (mapcar #'cdr (org-babel-get-header params :var)))
+         (result-type (cdr (assoc :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))
+         (raw (org-babel-comint-with-output
+                 (session org-babel-haskell-eoe t full-body)
+                (insert (org-babel-trim full-body))
+                (comint-send-input nil t)
+                (insert org-babel-haskell-eoe)
+                (comint-send-input nil t)))
+         (results (mapcar
+                   #'org-babel-haskell-read-string
+                   (cdr (member org-babel-haskell-eoe
+                                (reverse (mapcar #'org-babel-trim raw)))))))
+    (org-babel-reassemble-table
+     (cond
+      ((equal result-type 'output)
+       (mapconcat #'identity (reverse (cdr results)) "\n"))
+      ((equal result-type 'value)
+       (org-babel-haskell-table-or-string (car results))))
+     (org-babel-pick-name (cdr (assoc :colname-names params))
+                         (cdr (assoc :colname-names params)))
+     (org-babel-pick-name (cdr (assoc :rowname-names params))
+                         (cdr (assoc :rowname-names params))))))
+
+(defun org-babel-haskell-read-string (string)
+  "Strip \\\"s from around a haskell string."
+  (if (string-match "^\"\\([^\000]+\\)\"$" string)
+      (match-string 1 string)
+    string))
+
+(defun org-babel-haskell-initiate-session (&optional session params)
+  "Initiate a haskell session.
+If there is not a current inferior-process-buffer in SESSION
+then create one.  Return the initialized session."
+  (require 'inf-haskell)
+  (or (get-buffer "*haskell*")
+      (save-window-excursion (run-haskell) (sleep-for 0.25) (current-buffer))))
+
+(defun org-babel-load-session:haskell (session body params)
+  "Load BODY into SESSION."
+  (save-window-excursion
+    (let* ((buffer (org-babel-prep-session:haskell session params))
+           (load-file (concat (org-babel-temp-file "haskell-load-") ".hs")))
+      (with-temp-buffer
+        (insert body) (write-file load-file)
+        (haskell-mode) (inferior-haskell-load-file))
+      buffer)))
+
+(defun org-babel-prep-session:haskell (session params)
+  "Prepare SESSION according to the header arguments in PARAMS."
+  (save-window-excursion
+    (let ((buffer (org-babel-haskell-initiate-session session)))
+      (org-babel-comint-in-buffer buffer
+       (mapc (lambda (line)
+               (insert line)
+               (comint-send-input nil t))
+             (org-babel-variable-assignments:haskell params)))
+      (current-buffer))))
+
+(defun org-babel-variable-assignments:haskell (params)
+  "Return list of haskell statements assigning the block's variables."
+  (mapcar (lambda (pair)
+           (format "let %s = %s"
+                   (car pair)
+                   (org-babel-haskell-var-to-haskell (cdr pair))))
+         (mapcar #'cdr (org-babel-get-header params :var))))
+
+(defun org-babel-haskell-table-or-string (results)
+  "Convert RESULTS to an Emacs-lisp table or string.
+If RESULTS look like a table, then convert them into an
+Emacs-lisp table, otherwise return the results as a string."
+  (org-babel-script-escape results))
+
+(defun org-babel-haskell-var-to-haskell (var)
+  "Convert an elisp value VAR into a haskell variable.
+The elisp VAR is converted to a string of haskell source code
+specifying a variable of the same value."
+  (if (listp var)
+      (concat "[" (mapconcat #'org-babel-haskell-var-to-haskell var ", ") "]")
+    (format "%S" var)))
+
+(defvar org-src-preserve-indentation)
+(declare-function org-export-to-file "ox"
+                 (backend file
+                          &optional subtreep visible-only body-only ext-plist))
+(defun org-babel-haskell-export-to-lhs (&optional arg)
+  "Export to a .lhs file with all haskell code blocks escaped.
+When called with a prefix argument the resulting
+.lhs file will be exported to a .tex file.  This function will
+create two new files, base-name.lhs and base-name.tex where
+base-name is the name of the current org-mode file.
+
+Note that all standard Babel literate programming
+constructs (header arguments, no-web syntax etc...) are ignored."
+  (interactive "P")
+  (let* ((contents (buffer-string))
+         (haskell-regexp
+          (concat "^\\([ \t]*\\)#\\+begin_src[ \t]haskell*\\(.*\\)?[\r\n]"
+                  "\\([^\000]*?\\)[\r\n][ \t]*#\\+end_src.*"))
+         (base-name (file-name-sans-extension (buffer-file-name)))
+         (tmp-file (org-babel-temp-file "haskell-"))
+         (tmp-org-file (concat tmp-file ".org"))
+         (tmp-tex-file (concat tmp-file ".tex"))
+         (lhs-file (concat base-name ".lhs"))
+         (tex-file (concat base-name ".tex"))
+         (command (concat org-babel-haskell-lhs2tex-command
+                         " " (org-babel-process-file-name lhs-file)
+                         " > " (org-babel-process-file-name tex-file)))
+         (preserve-indentp org-src-preserve-indentation)
+         indentation)
+    ;; escape haskell source-code blocks
+    (with-temp-file tmp-org-file
+      (insert contents)
+      (goto-char (point-min))
+      (while (re-search-forward haskell-regexp nil t)
+        (save-match-data (setq indentation (length (match-string 1))))
+        (replace-match (save-match-data
+                         (concat
+                          "#+begin_latex\n\\begin{code}\n"
+                          (if (or preserve-indentp
+                                  (string-match "-i" (match-string 2)))
+                              (match-string 3)
+                            (org-remove-indentation (match-string 3)))
+                          "\n\\end{code}\n#+end_latex\n"))
+                       t t)
+        (indent-code-rigidly (match-beginning 0) (match-end 0) indentation)))
+    (save-excursion
+      ;; export to latex w/org and save as .lhs
+      (require 'ox-latex)
+      (find-file tmp-org-file)
+      ;; Ensure we do not clutter kill ring with incomplete results.
+      (let (org-export-copy-to-kill-ring)
+       (org-export-to-file 'latex tmp-tex-file))
+      (kill-buffer nil)
+      (delete-file tmp-org-file)
+      (find-file tmp-tex-file)
+      (goto-char (point-min)) (forward-line 2)
+      (insert "%include polycode.fmt\n")
+      ;; ensure all \begin/end{code} statements start at the first column
+      (while (re-search-forward "^[ \t]+\\\\begin{code}[^\000]+\\\\end{code}" nil t)
+        (replace-match (save-match-data (org-remove-indentation (match-string 0)))
+                       t t))
+      (setq contents (buffer-string))
+      (save-buffer) (kill-buffer nil))
+    (delete-file tmp-tex-file)
+    ;; save org exported latex to a .lhs file
+    (with-temp-file lhs-file (insert contents))
+    (if (not arg)
+        (find-file lhs-file)
+      ;; process .lhs file with lhs2tex
+      (message "running %s" command) (shell-command command) (find-file tex-file))))
+
+(provide 'ob-haskell)
+
+
+
+;;; ob-haskell.el ends here
diff --git a/elisp/org/ob-io.el b/elisp/org/ob-io.el
new file mode 100644 (file)
index 0000000..af18f74
--- /dev/null
@@ -0,0 +1,119 @@
+;;; ob-io.el --- org-babel functions for Io evaluation
+
+;; Copyright (C) 2012-2013 Free Software Foundation, Inc.
+
+;; Author: Andrzej Lichnerowicz
+;; Keywords: literate programming, reproducible research
+;; Homepage: http://orgmode.org
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
+
+;;; Commentary:
+;; Currently only supports the external execution.  No session support yet.
+;; :results output -- runs in scripting mode
+;; :results output repl -- runs in repl mode
+
+;;; Requirements:
+;; - Io language :: http://iolanguage.org/
+;; - Io major mode :: Can be installed from Io sources
+;;  https://github.com/stevedekorte/io/blob/master/extras/SyntaxHighlighters/Emacs/io-mode.el
+
+;;; Code:
+(require 'ob)
+(eval-when-compile (require 'cl))
+
+(defvar org-babel-tangle-lang-exts) ;; Autoloaded
+(add-to-list 'org-babel-tangle-lang-exts '("io" . "io"))
+(defvar org-babel-default-header-args:io '())
+(defvar org-babel-io-command "io"
+  "Name of the command to use for executing Io code.")
+
+(defun org-babel-execute:io (body params)
+  "Execute a block of Io code with org-babel.  This function is
+called by `org-babel-execute-src-block'"
+  (message "executing Io source code block")
+  (let* ((processed-params (org-babel-process-params params))
+         (session (org-babel-io-initiate-session (nth 0 processed-params)))
+         (vars (nth 1 processed-params))
+         (result-params (nth 2 processed-params))
+         (result-type (cdr (assoc :result-type params)))
+         (full-body (org-babel-expand-body:generic
+                     body params))
+         (result (org-babel-io-evaluate
+                  session full-body result-type result-params)))
+
+    (org-babel-reassemble-table
+     result
+     (org-babel-pick-name
+      (cdr (assoc :colname-names params)) (cdr (assoc :colnames params)))
+     (org-babel-pick-name
+      (cdr (assoc :rowname-names params)) (cdr (assoc :rownames params))))))
+
+
+(defun org-babel-io-table-or-string (results)
+  "Convert RESULTS into an appropriate elisp value.
+If RESULTS look like a table, then convert them into an
+Emacs-lisp table, otherwise return the results as a string."
+  (org-babel-script-escape results))
+
+
+(defvar org-babel-io-wrapper-method
+  "(
+%s
+) asString print
+")
+
+
+(defun org-babel-io-evaluate (session body &optional result-type result-params)
+  "Evaluate BODY in external Io process.
+If RESULT-TYPE equals 'output then return standard output as a string.
+If RESULT-TYPE equals 'value then return the value of the last statement
+in BODY as elisp."
+  (when session (error "Sessions are not (yet) supported for Io"))
+  (case result-type
+    (output
+     (if (member "repl" result-params)
+         (org-babel-eval org-babel-io-command body)
+       (let ((src-file (org-babel-temp-file "io-")))
+         (progn (with-temp-file src-file (insert body))
+                (org-babel-eval
+                 (concat org-babel-io-command " " src-file) "")))))
+    (value (let* ((src-file (org-babel-temp-file "io-"))
+                  (wrapper (format org-babel-io-wrapper-method body)))
+             (with-temp-file src-file (insert wrapper))
+             ((lambda (raw)
+                (org-babel-result-cond result-params
+                 raw
+                  (org-babel-io-table-or-string raw)))
+              (org-babel-eval
+               (concat org-babel-io-command " " src-file) ""))))))
+
+
+(defun org-babel-prep-session:io (session params)
+  "Prepare SESSION according to the header arguments specified in PARAMS."
+  (error "Sessions are not (yet) supported for Io"))
+
+(defun org-babel-io-initiate-session (&optional session)
+  "If there is not a current inferior-process-buffer in SESSION
+then create.  Return the initialized session.  Sessions are not
+supported in Io."
+  nil)
+
+(provide 'ob-io)
+
+
+
+;;; ob-io.el ends here
diff --git a/elisp/org/ob-java.el b/elisp/org/ob-java.el
new file mode 100644 (file)
index 0000000..c0e9a53
--- /dev/null
@@ -0,0 +1,76 @@
+;;; ob-java.el --- org-babel functions for java evaluation
+
+;; Copyright (C) 2011-2013 Free Software Foundation, Inc.
+
+;; Author: Eric Schulte
+;; Keywords: literate programming, reproducible research
+;; Homepage: http://orgmode.org
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
+
+;;; Commentary:
+
+;; Currently this only supports the external compilation and execution
+;; of java code blocks (i.e., no session support).
+
+;;; Code:
+(require 'ob)
+
+(defvar org-babel-tangle-lang-exts)
+(add-to-list 'org-babel-tangle-lang-exts '("java" . "java"))
+
+(defvar org-babel-java-command "java"
+  "Name of the java command.")
+
+(defvar org-babel-java-compiler "javac"
+  "Name of the java compiler.")
+
+(defun org-babel-execute:java (body params)
+  (let* ((classname (or (cdr (assoc :classname params))
+                       (error
+                        "Can't compile a java block without a classname")))
+        (packagename (file-name-directory classname))
+        (src-file (concat classname ".java"))
+        (cmpflag (or (cdr (assoc :cmpflag params)) ""))
+        (cmdline (or (cdr (assoc :cmdline params)) ""))
+        (full-body (org-babel-expand-body:generic body params))
+        (compile
+         (progn (with-temp-file src-file (insert full-body))
+                (org-babel-eval
+                 (concat org-babel-java-compiler
+                         " " cmpflag " " src-file) ""))))
+    ;; created package-name directories if missing
+    (unless (or (not packagename) (file-exists-p packagename))
+      (make-directory packagename 'parents))
+    ((lambda (results)
+       (org-babel-reassemble-table
+       (org-babel-result-cond (cdr (assoc :result-params params))
+         (org-babel-read results)
+         (let ((tmp-file (org-babel-temp-file "c-")))
+             (with-temp-file tmp-file (insert results))
+             (org-babel-import-elisp-from-file tmp-file)))
+       (org-babel-pick-name
+        (cdr (assoc :colname-names params)) (cdr (assoc :colnames params)))
+       (org-babel-pick-name
+        (cdr (assoc :rowname-names params)) (cdr (assoc :rownames params)))))
+     (org-babel-eval (concat org-babel-java-command
+                            " " cmdline " " classname) ""))))
+
+(provide 'ob-java)
+
+
+
+;;; ob-java.el ends here
diff --git a/elisp/org/ob-js.el b/elisp/org/ob-js.el
new file mode 100644 (file)
index 0000000..8cae35b
--- /dev/null
@@ -0,0 +1,160 @@
+;;; ob-js.el --- org-babel functions for Javascript
+
+;; Copyright (C) 2010-2013 Free Software Foundation, Inc.
+
+;; Author: Eric Schulte
+;; Keywords: literate programming, reproducible research, js
+;; Homepage: http://orgmode.org
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
+
+;;; Commentary:
+
+;; Now working with SBCL for both session and external evaluation.
+;;
+;; This certainly isn't optimally robust, but it seems to be working
+;; for the basic use cases.
+
+;;; Requirements:
+
+;; - a non-browser javascript engine such as node.js http://nodejs.org/
+;;   or mozrepl http://wiki.github.com/bard/mozrepl/
+;;
+;; - for session based evaluation mozrepl and moz.el are required see
+;;   http://wiki.github.com/bard/mozrepl/emacs-integration for
+;;   configuration instructions
+
+;;; Code:
+(require 'ob)
+(eval-when-compile (require 'cl))
+
+(declare-function run-mozilla "ext:moz" (arg))
+
+(defvar org-babel-default-header-args:js '()
+  "Default header arguments for js code blocks.")
+
+(defvar org-babel-js-eoe "org-babel-js-eoe"
+  "String to indicate that evaluation has completed.")
+
+(defcustom org-babel-js-cmd "node"
+  "Name of command used to evaluate js blocks."
+  :group 'org-babel
+  :version "24.1"
+  :type 'string)
+
+(defvar org-babel-js-function-wrapper
+  "require('sys').print(require('sys').inspect(function(){%s}()));"
+  "Javascript code to print value of body.")
+
+(defun org-babel-execute:js (body params)
+  "Execute a block of Javascript code with org-babel.
+This function is called by `org-babel-execute-src-block'"
+  (let* ((org-babel-js-cmd (or (cdr (assoc :cmd params)) org-babel-js-cmd))
+         (result-type (cdr (assoc :result-type params)))
+         (full-body (org-babel-expand-body:generic
+                    body params (org-babel-variable-assignments:js params))))
+    (org-babel-js-read
+     (if (not (string= (cdr (assoc :session params)) "none"))
+        ;; session evaluation
+         (let ((session (org-babel-prep-session:js
+                        (cdr (assoc :session params)) params)))
+          (nth 1
+               (org-babel-comint-with-output
+                   (session (format "%S" org-babel-js-eoe) t body)
+                 (mapc
+                  (lambda (line)
+                    (insert (org-babel-chomp line)) (comint-send-input nil t))
+                  (list body (format "%S" org-babel-js-eoe))))))
+       ;; external evaluation
+       (let ((script-file (org-babel-temp-file "js-script-")))
+         (with-temp-file script-file
+           (insert
+            ;; return the value or the output
+            (if (string= result-type "value")
+                (format org-babel-js-function-wrapper full-body)
+              full-body)))
+         (org-babel-eval
+         (format "%s %s" org-babel-js-cmd
+                 (org-babel-process-file-name script-file)) ""))))))
+
+(defun org-babel-js-read (results)
+  "Convert RESULTS into an appropriate elisp value.
+If RESULTS look like a table, then convert them into an
+Emacs-lisp table, otherwise return the results as a string."
+  (org-babel-read
+   (if (and (stringp results) (string-match "^\\[.+\\]$" results))
+       (org-babel-read
+        (concat "'"
+                (replace-regexp-in-string
+                 "\\[" "(" (replace-regexp-in-string
+                            "\\]" ")" (replace-regexp-in-string
+                                       ", " " " (replace-regexp-in-string
+                                                "'" "\"" results))))))
+     results)))
+
+(defun org-babel-js-var-to-js (var)
+  "Convert VAR into a js variable.
+Convert an elisp value into a string of js source code
+specifying a variable of the same value."
+  (if (listp var)
+      (concat "[" (mapconcat #'org-babel-js-var-to-js var ", ") "]")
+    (format "%S" var)))
+
+(defun org-babel-prep-session:js (session params)
+  "Prepare SESSION according to the header arguments specified in PARAMS."
+  (let* ((session (org-babel-js-initiate-session session))
+        (var-lines (org-babel-variable-assignments:js params)))
+    (when session
+      (org-babel-comint-in-buffer session
+       (sit-for .5) (goto-char (point-max))
+       (mapc (lambda (var)
+               (insert var) (comint-send-input nil t)
+               (org-babel-comint-wait-for-output session)
+               (sit-for .1) (goto-char (point-max))) var-lines)))
+    session))
+
+(defun org-babel-variable-assignments:js (params)
+  "Return list of Javascript statements assigning the block's variables."
+  (mapcar
+   (lambda (pair) (format "var %s=%s;"
+                         (car pair) (org-babel-js-var-to-js (cdr pair))))
+   (mapcar #'cdr (org-babel-get-header params :var))))
+
+(defun org-babel-js-initiate-session (&optional session)
+  "If there is not a current inferior-process-buffer in SESSION
+then create.  Return the initialized session."
+  (unless (string= session "none")
+    (cond
+     ((string= "mozrepl" org-babel-js-cmd)
+      (require 'moz)
+      (let ((session-buffer (save-window-excursion
+                             (run-mozilla nil)
+                             (rename-buffer session)
+                             (current-buffer))))
+       (if (org-babel-comint-buffer-livep session-buffer)
+           (progn (sit-for .25) session-buffer)
+         (sit-for .5)
+         (org-babel-js-initiate-session session))))
+     ((string= "node" org-babel-js-cmd )
+      (error "Session evaluation with node.js is not supported"))
+     (t
+      (error "Sessions are only supported with mozrepl add \":cmd mozrepl\"")))))
+
+(provide 'ob-js)
+
+
+
+;;; ob-js.el ends here
diff --git a/elisp/org/ob-keys.el b/elisp/org/ob-keys.el
new file mode 100644 (file)
index 0000000..6cc7387
--- /dev/null
@@ -0,0 +1,105 @@
+;;; ob-keys.el --- key bindings for org-babel
+
+;; Copyright (C) 2009-2013 Free Software Foundation, Inc.
+
+;; Author: Eric Schulte
+;; Keywords: literate programming, reproducible research
+;; Homepage: http://orgmode.org
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
+
+;;; Commentary:
+
+;; Add org-babel keybindings to the org-mode keymap for exposing
+;; org-babel functions.  These will all share a common prefix.  See
+;; the value of `org-babel-key-bindings' for a list of interactive
+;; functions and their associated keys.
+
+;;; Code:
+(require 'ob-core)
+
+(defvar org-babel-key-prefix "\C-c\C-v"
+  "The key prefix for Babel interactive key-bindings.
+See `org-babel-key-bindings' for the list of interactive babel
+functions which are assigned key bindings, and see
+`org-babel-map' for the actual babel keymap.")
+
+(defvar org-babel-map (make-sparse-keymap)
+  "The keymap for interactive Babel functions.")
+
+;;;###autoload
+(defun org-babel-describe-bindings ()
+  "Describe all keybindings behind `org-babel-key-prefix'."
+  (interactive)
+  (describe-bindings org-babel-key-prefix))
+
+(defvar org-babel-key-bindings
+  '(("p" . org-babel-previous-src-block)
+    ("\C-p" . org-babel-previous-src-block)
+    ("n" . org-babel-next-src-block)
+    ("\C-n" . org-babel-next-src-block)
+    ("e" . org-babel-execute-maybe)
+    ("\C-e" . org-babel-execute-maybe)
+    ("o" . org-babel-open-src-block-result)
+    ("\C-o" . org-babel-open-src-block-result)
+    ("\C-v" . org-babel-expand-src-block)
+    ("v" . org-babel-expand-src-block)
+    ("u" . org-babel-goto-src-block-head)
+    ("\C-u" . org-babel-goto-src-block-head)
+    ("g" . org-babel-goto-named-src-block)
+    ("r" . org-babel-goto-named-result)
+    ("\C-r" . org-babel-goto-named-result)
+    ("\C-b" . org-babel-execute-buffer)
+    ("b" . org-babel-execute-buffer)
+    ("\C-s" . org-babel-execute-subtree)
+    ("s" . org-babel-execute-subtree)
+    ("\C-d" . org-babel-demarcate-block)
+    ("d" . org-babel-demarcate-block)
+    ("\C-t" . org-babel-tangle)
+    ("t" . org-babel-tangle)
+    ("\C-f" . org-babel-tangle-file)
+    ("f" . org-babel-tangle-file)
+    ("\C-c" . org-babel-check-src-block)
+    ("c" . org-babel-check-src-block)
+    ("\C-j" . org-babel-insert-header-arg)
+    ("j" . org-babel-insert-header-arg)
+    ("\C-l" . org-babel-load-in-session)
+    ("l" . org-babel-load-in-session)
+    ("\C-i" . org-babel-lob-ingest)
+    ("i" . org-babel-lob-ingest)
+    ("\C-I" . org-babel-view-src-block-info)
+    ("I" . org-babel-view-src-block-info)
+    ("\C-z" . org-babel-switch-to-session)
+    ("z" . org-babel-switch-to-session-with-code)
+    ("\C-a" . org-babel-sha1-hash)
+    ("a" . org-babel-sha1-hash)
+    ("h" . org-babel-describe-bindings)
+    ("\C-x" . org-babel-do-key-sequence-in-edit-buffer)
+    ("x" . org-babel-do-key-sequence-in-edit-buffer)
+    ("\C-\M-h" . org-babel-mark-block))
+  "Alist of key bindings and interactive Babel functions.
+This list associates interactive Babel functions
+with keys.  Each element of this list will add an entry to the
+`org-babel-map' using the letter key which is the `car' of the
+a-list placed behind the generic `org-babel-key-prefix'.")
+
+(provide 'ob-keys)
+
+;; Local variables:
+;; generated-autoload-file: "org-loaddefs.el"
+;; End:
+
+;;; ob-keys.el ends here
diff --git a/elisp/org/ob-latex.el b/elisp/org/ob-latex.el
new file mode 100644 (file)
index 0000000..94d5133
--- /dev/null
@@ -0,0 +1,151 @@
+;;; ob-latex.el --- org-babel functions for latex "evaluation"
+
+;; Copyright (C) 2009-2013 Free Software Foundation, Inc.
+
+;; Author: Eric Schulte
+;; Keywords: literate programming, reproducible research
+;; Homepage: http://orgmode.org
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
+
+;;; Commentary:
+
+;; Org-Babel support for evaluating LaTeX source code.
+;;
+;; Currently on evaluation this returns raw LaTeX code, unless a :file
+;; header argument is given in which case small png or pdf files will
+;; be created directly form the latex source code.
+
+;;; Code:
+(require 'ob)
+
+(declare-function org-create-formula-image "org" (string tofile options buffer))
+(declare-function org-splice-latex-header "org"
+                 (tpl def-pkg pkg snippets-p &optional extra))
+(declare-function org-latex-guess-inputenc "ox-latex" (header))
+(declare-function org-latex-compile "ox-latex" (file))
+
+(defvar org-babel-tangle-lang-exts)
+(add-to-list 'org-babel-tangle-lang-exts '("latex" . "tex"))
+
+(defvar org-format-latex-header)         ; From org.el
+(defvar org-format-latex-options)        ; From org.el
+(defvar org-latex-default-packages-alist) ; From org.el
+(defvar org-latex-packages-alist)        ; From org.el
+
+(defvar org-babel-default-header-args:latex
+  '((:results . "latex") (:exports . "results"))
+  "Default arguments to use when evaluating a LaTeX source block.")
+
+(defun org-babel-expand-body:latex (body params)
+  "Expand BODY according to PARAMS, return the expanded body."
+  (mapc (lambda (pair) ;; replace variables
+          (setq body
+                (replace-regexp-in-string
+                 (regexp-quote (format "%S" (car pair)))
+                 (if (stringp (cdr pair))
+                     (cdr pair) (format "%S" (cdr pair)))
+                 body))) (mapcar #'cdr (org-babel-get-header params :var)))
+  (org-babel-trim body))
+
+(defun org-babel-execute:latex (body params)
+  "Execute a block of Latex code with Babel.
+This function is called by `org-babel-execute-src-block'."
+  (setq body (org-babel-expand-body:latex body params))
+  (if (cdr (assoc :file params))
+      (let* ((out-file (cdr (assoc :file params)))
+            (tex-file (org-babel-temp-file "latex-" ".tex"))
+            (border (cdr (assoc :border params)))
+            (imagemagick (cdr (assoc :imagemagick params)))
+            (im-in-options (cdr (assoc :iminoptions params)))
+            (im-out-options (cdr (assoc :imoutoptions params)))
+            (pdfpng (cdr (assoc :pdfpng params)))
+            (fit (or (cdr (assoc :fit params)) border))
+            (height (and fit (cdr (assoc :pdfheight params))))
+            (width (and fit (cdr (assoc :pdfwidth params))))
+            (headers (cdr (assoc :headers params)))
+            (in-buffer (not (string= "no" (cdr (assoc :buffer params)))))
+            (org-latex-packages-alist
+             (append (cdr (assoc :packages params)) org-latex-packages-alist)))
+        (cond
+         ((and (string-match "\\.png$" out-file) (not imagemagick))
+          (org-create-formula-image
+           body out-file org-format-latex-options in-buffer))
+         ((or (string-match "\\.pdf$" out-file) imagemagick)
+         (with-temp-file tex-file
+           (require 'ox-latex)
+           (insert
+            (org-latex-guess-inputenc
+             (org-splice-latex-header
+              org-format-latex-header
+              (delq
+               nil
+               (mapcar
+                (lambda (el)
+                  (unless (and (listp el) (string= "hyperref" (cadr el)))
+                    el))
+                org-latex-default-packages-alist))
+              org-latex-packages-alist
+              nil))
+            (if fit "\n\\usepackage[active, tightpage]{preview}\n" "")
+            (if border (format "\\setlength{\\PreviewBorder}{%s}" border) "")
+            (if height (concat "\n" (format "\\pdfpageheight %s" height)) "")
+            (if width  (concat "\n" (format "\\pdfpagewidth %s" width))   "")
+            (if headers
+                (concat "\n"
+                        (if (listp headers)
+                            (mapconcat #'identity headers "\n")
+                          headers) "\n")
+              "")
+            (if fit
+                (concat "\n\\begin{document}\n\\begin{preview}\n" body
+                        "\n\\end{preview}\n\\end{document}\n")
+              (concat "\n\\begin{document}\n" body "\n\\end{document}\n"))))
+          (when (file-exists-p out-file) (delete-file out-file))
+         (let ((transient-pdf-file (org-babel-latex-tex-to-pdf tex-file)))
+           (cond
+            ((string-match "\\.pdf$" out-file)
+             (rename-file transient-pdf-file out-file))
+            (imagemagick
+             (convert-pdf
+              transient-pdf-file out-file im-in-options im-out-options)
+             (when (file-exists-p transient-pdf-file)
+               (delete-file transient-pdf-file))))))
+         ((string-match "\\.\\([^\\.]+\\)$" out-file)
+          (error "Can not create %s files, please specify a .png or .pdf file or try the :imagemagick header argument"
+                (match-string 1 out-file))))
+        nil) ;; signal that output has already been written to file
+    body))
+
+(defun convert-pdf (pdffile out-file im-in-options im-out-options)
+  "Generate a file from a pdf file using imagemagick."
+  (let ((cmd (concat "convert " im-in-options " " pdffile " "
+                    im-out-options " " out-file)))
+    (message (concat "Converting pdffile file " cmd  "..."))
+    (shell-command cmd)))
+
+(defun org-babel-latex-tex-to-pdf (file)
+  "Generate a pdf file according to the contents FILE."
+  (require 'ox-latex)
+  (org-latex-compile file))
+
+(defun org-babel-prep-session:latex (session params)
+  "Return an error because LaTeX doesn't support sessions."
+  (error "LaTeX does not support sessions"))
+
+
+(provide 'ob-latex)
+;;; ob-latex.el ends here
diff --git a/elisp/org/ob-ledger.el b/elisp/org/ob-ledger.el
new file mode 100644 (file)
index 0000000..17911cc
--- /dev/null
@@ -0,0 +1,71 @@
+;;; ob-ledger.el --- org-babel functions for ledger evaluation
+
+;; Copyright (C) 2010-2013 Free Software Foundation, Inc.
+
+;; Author: Eric S Fraga
+;; Keywords: literate programming, reproducible research, accounting
+;; Homepage: http://orgmode.org
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
+
+;;; Commentary:
+
+;; Org-Babel support for evaluating ledger entries.
+;;
+;; This differs from most standard languages in that
+;;
+;; 1) there is no such thing as a "session" in ledger
+;;
+;; 2) we are generally only going to return output from the ledger program
+;;
+;; 3) we are adding the "cmdline" header argument
+;;
+;; 4) there are no variables
+
+;;; Code:
+(require 'ob)
+
+(defvar org-babel-default-header-args:ledger
+  '((:results . "output") (:cmdline . "bal"))
+  "Default arguments to use when evaluating a ledger source block.")
+
+(defun org-babel-execute:ledger (body params)
+  "Execute a block of Ledger entries with org-babel.  This function is
+called by `org-babel-execute-src-block'."
+  (message "executing Ledger source code block")
+  (let ((result-params (split-string (or (cdr (assoc :results params)) "")))
+       (cmdline (cdr (assoc :cmdline params)))
+        (in-file (org-babel-temp-file "ledger-"))
+       (out-file (org-babel-temp-file "ledger-output-")))
+    (with-temp-file in-file (insert body))
+    (message "%s" (concat "ledger"
+                         " -f " (org-babel-process-file-name in-file)
+                         " " cmdline))
+    (with-output-to-string
+      (shell-command (concat "ledger"
+                            " -f " (org-babel-process-file-name in-file)
+                            " " cmdline
+                            " > " (org-babel-process-file-name out-file))))
+    (with-temp-buffer (insert-file-contents out-file) (buffer-string))))
+
+(defun org-babel-prep-session:ledger (session params)
+  (error "Ledger does not support sessions"))
+
+(provide 'ob-ledger)
+
+
+
+;;; ob-ledger.el ends here
diff --git a/elisp/org/ob-lilypond.el b/elisp/org/ob-lilypond.el
new file mode 100644 (file)
index 0000000..6080a5a
--- /dev/null
@@ -0,0 +1,437 @@
+;;; ob-lilypond.el --- org-babel functions for lilypond evaluation
+
+;; Copyright (C) 2010-2013 Free Software Foundation, Inc.
+
+;; Author: Martyn Jago
+;; Keywords: babel language, literate programming
+;; Homepage: http://orgmode.org/worg/org-contrib/babel/languages/ob-doc-lilypond.html
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
+
+;;; Commentary:
+
+;; Installation, ob-lilypond documentation, and examples are available at
+;; http://orgmode.org/worg/org-contrib/babel/languages/ob-doc-lilypond.html
+;;
+;; Lilypond documentation can be found at
+;; http://lilypond.org/manuals.html
+
+;;; Code:
+(require 'ob)
+(require 'outline)
+(defalias 'lilypond-mode 'LilyPond-mode)
+
+(add-to-list 'org-babel-tangle-lang-exts '("LilyPond" . "ly"))
+
+(defvar org-babel-default-header-args:lilypond '()
+  "Default header arguments for lilypond code blocks.
+NOTE: The arguments are determined at lilypond compile time.
+See (ly-set-header-args)")
+
+(defvar ly-compile-post-tangle t
+  "Following the org-babel-tangle (C-c C-v t) command,
+ly-compile-post-tangle determines whether ob-lilypond should
+automatically attempt to compile the resultant tangled file.
+If the value is nil, no automated compilation takes place.
+Default value is t")
+
+(defvar ly-display-pdf-post-tangle t
+  "Following a successful LilyPond compilation
+ly-display-pdf-post-tangle determines whether to automate the
+drawing / redrawing of the resultant pdf.  If the value is nil,
+the pdf is not automatically redrawn.  Default value is t")
+
+(defvar ly-play-midi-post-tangle t
+  "Following a successful LilyPond compilation
+ly-play-midi-post-tangle determines whether to automate the
+playing of the resultant midi file.  If the value is nil,
+the midi file is not automatically played.  Default value is t")
+
+(defvar ly-OSX-ly-path
+  "/Applications/lilypond.app/Contents/Resources/bin/lilypond")
+(defvar ly-OSX-pdf-path "open")
+(defvar ly-OSX-midi-path "open")
+
+(defvar ly-nix-ly-path "/usr/bin/lilypond")
+(defvar ly-nix-pdf-path "evince")
+(defvar ly-nix-midi-path "timidity")
+
+(defvar ly-w32-ly-path "lilypond")
+(defvar ly-w32-pdf-path "")
+(defvar ly-w32-midi-path "")
+
+(defvar ly-gen-png nil
+  "Image generation (png) can be turned on by default by setting
+LY-GEN-PNG to t")
+
+(defvar ly-gen-svg nil
+  "Image generation (SVG) can be turned on by default by setting
+LY-GEN-SVG to t")
+
+(defvar ly-gen-html nil
+  "HTML generation can be turned on by default by setting
+LY-GEN-HTML to t")
+
+(defvar ly-gen-pdf nil
+  "PDF generation can be turned on by default by setting
+LY-GEN-PDF to t")
+
+(defvar ly-use-eps nil
+  "You can force the compiler to use the EPS backend by setting
+LY-USE-EPS to t")
+
+(defvar ly-arrange-mode nil
+  "Arrange mode is turned on by setting LY-ARRANGE-MODE
+to t.  In Arrange mode the following settings are altered
+from default...
+:tangle yes,    :noweb yes
+:results silent :comments yes.
+In addition lilypond block execution causes tangling of all lilypond
+blocks")
+
+(defun org-babel-expand-body:lilypond (body params)
+  "Expand BODY according to PARAMS, return the expanded body."
+  (let ((vars (mapcar #'cdr (org-babel-get-header params :var))))
+    (mapc
+     (lambda (pair)
+       (let ((name (symbol-name (car pair)))
+            (value (cdr pair)))
+        (setq body
+              (replace-regexp-in-string
+               (concat "\$" (regexp-quote name))
+               (if (stringp value) value (format "%S" value))
+               body))))
+     vars)
+    body))
+
+(defun org-babel-execute:lilypond (body params)
+  "This function is called by `org-babel-execute-src-block'.
+Depending on whether we are in arrange mode either:
+1. Attempt to execute lilypond block according to header settings
+  (This is the default basic mode)
+2. Tangle all lilypond blocks and process the result (arrange mode)"
+  (ly-set-header-args ly-arrange-mode)
+  (if ly-arrange-mode
+      (ly-tangle)
+    (ly-process-basic body params)))
+
+(defun ly-tangle ()
+  "ob-lilypond specific tangle, attempts to invoke
+=ly-execute-tangled-ly= if tangle is successful.  Also passes
+specific arguments to =org-babel-tangle="
+  (interactive)
+  (if (org-babel-tangle nil "yes" "lilypond")
+      (ly-execute-tangled-ly) nil))
+
+(defun ly-process-basic (body params)
+  "Execute a lilypond block in basic mode."
+  (let* ((result-params (cdr (assoc :result-params params)))
+        (out-file (cdr (assoc :file params)))
+        (cmdline (or (cdr (assoc :cmdline params))
+                     ""))
+        (in-file (org-babel-temp-file "lilypond-")))
+
+    (with-temp-file in-file
+      (insert (org-babel-expand-body:generic body params)))
+    (org-babel-eval
+     (concat
+      (ly-determine-ly-path)
+      " -dbackend=eps "
+      "-dno-gs-load-fonts "
+      "-dinclude-eps-fonts "
+      (or (cdr (assoc (file-name-extension out-file)
+                     '(("pdf" . "--pdf ")
+                       ("ps" . "--ps ")
+                       ("png" . "--png "))))
+         "--png ")
+      "--output="
+      (file-name-sans-extension out-file)
+      " "
+      cmdline
+      in-file) "")) nil)
+
+(defun org-babel-prep-session:lilypond (session params)
+  "Return an error because LilyPond exporter does not support sessions."
+  (error "Sorry, LilyPond does not currently support sessions!"))
+
+(defun ly-execute-tangled-ly ()
+  "Compile result of block tangle with lilypond.
+If error in compilation, attempt to mark the error in lilypond org file"
+  (when ly-compile-post-tangle
+    (let ((ly-tangled-file (ly-switch-extension
+                            (buffer-file-name) ".lilypond"))
+          (ly-temp-file (ly-switch-extension
+                         (buffer-file-name) ".ly")))
+      (if (file-exists-p ly-tangled-file)
+          (progn
+            (when (file-exists-p ly-temp-file)
+              (delete-file ly-temp-file))
+            (rename-file ly-tangled-file
+                         ly-temp-file))
+        (error "Error: Tangle Failed!") t)
+      (switch-to-buffer-other-window "*lilypond*")
+      (erase-buffer)
+      (ly-compile-lilyfile ly-temp-file)
+      (goto-char (point-min))
+      (if (not (ly-check-for-compile-error ly-temp-file))
+          (progn
+            (other-window -1)
+            (ly-attempt-to-open-pdf ly-temp-file)
+            (ly-attempt-to-play-midi ly-temp-file))
+        (error "Error in Compilation!")))) nil)
+
+(defun ly-compile-lilyfile (file-name &optional test)
+  "Compile lilypond file and check for compile errors
+FILE-NAME is full path to lilypond (.ly) file"
+  (message "Compiling LilyPond...")
+  (let ((arg-1 (ly-determine-ly-path)) ;program
+        (arg-2 nil)                    ;infile
+        (arg-3 "*lilypond*")           ;buffer
+        (arg-4 t)                      ;display
+       (arg-4 t)                      ;display
+       (arg-5 (if ly-gen-png  "--png"  "")) ;&rest...
+       (arg-6 (if ly-gen-html "--html" ""))
+        (arg-7 (if ly-gen-pdf "--pdf" ""))
+        (arg-8 (if ly-use-eps  "-dbackend=eps" ""))
+        (arg-9 (if ly-gen-svg  "-dbackend=svg" ""))
+        (arg-10 (concat "--output=" (file-name-sans-extension file-name)))
+        (arg-11 file-name))
+    (if test
+        `(,arg-1 ,arg-2 ,arg-3 ,arg-4 ,arg-5 ,arg-6
+                 ,arg-7 ,arg-8 ,arg-9 ,arg-10 ,arg-11)
+      (call-process
+       arg-1 arg-2 arg-3 arg-4 arg-5 arg-6
+       arg-7 arg-8 arg-9 arg-10 arg-11))))
+
+(defun ly-check-for-compile-error (file-name &optional test)
+  "Check for compile error.
+This is performed by parsing the *lilypond* buffer
+containing the output message from the compilation.
+FILE-NAME is full path to lilypond file.
+If TEST is t just return nil if no error found, and pass
+nil as file-name since it is unused in this context"
+  (let ((is-error (search-forward "error:" nil t)))
+    (if (not test)
+        (if (not is-error)
+            nil
+          (ly-process-compile-error file-name))
+      is-error)))
+
+(defun ly-process-compile-error (file-name)
+  "Process the compilation error that has occurred.
+FILE-NAME is full path to lilypond file"
+  (let ((line-num (ly-parse-line-num)))
+    (let ((error-lines (ly-parse-error-line file-name line-num)))
+      (ly-mark-error-line file-name error-lines)
+      (error "Error: Compilation Failed!"))))
+
+(defun ly-mark-error-line (file-name line)
+  "Mark the erroneous lines in the lilypond org buffer.
+FILE-NAME is full path to lilypond file.
+LINE is the erroneous line"
+  (switch-to-buffer-other-window
+   (concat (file-name-nondirectory
+            (ly-switch-extension file-name ".org"))))
+  (let ((temp (point)))
+    (goto-char (point-min))
+    (setq case-fold-search nil)
+    (if (search-forward line nil t)
+        (progn
+          (show-all)
+          (set-mark (point))
+          (goto-char (- (point) (length line))))
+      (goto-char temp))))
+
+(defun ly-parse-line-num (&optional buffer)
+  "Extract error line number."
+  (when buffer
+    (set-buffer buffer))
+  (let ((start
+         (and (search-backward ":" nil t)
+              (search-backward ":" nil t)
+              (search-backward ":" nil t)
+              (search-backward ":" nil t)))
+        (num nil))
+    (if start
+        (progn
+          (forward-char)
+          (let ((num (buffer-substring
+                      (+ 1 start)
+                      (- (search-forward ":" nil t) 1))))
+            (setq num (string-to-number num))
+            (if (numberp num)
+                num
+              nil)))
+      nil)))
+
+(defun ly-parse-error-line (file-name lineNo)
+  "Extract the erroneous line from the tangled .ly file
+FILE-NAME is full path to lilypond file.
+LINENO is the number of the erroneous line"
+  (with-temp-buffer
+    (insert-file-contents (ly-switch-extension file-name ".ly")
+                         nil nil nil t)
+    (if (> lineNo 0)
+       (progn
+         (goto-char (point-min))
+         (forward-line (- lineNo 1))
+         (buffer-substring (point) (point-at-eol)))
+      nil)))
+
+(defun ly-attempt-to-open-pdf (file-name &optional test)
+  "Attempt to display the generated pdf file
+FILE-NAME is full path to lilypond file
+If TEST is non-nil, the shell command is returned and is not run"
+  (when ly-display-pdf-post-tangle
+    (let ((pdf-file (ly-switch-extension file-name ".pdf")))
+      (if (file-exists-p pdf-file)
+          (let ((cmd-string
+                 (concat (ly-determine-pdf-path) " " pdf-file)))
+            (if test
+                cmd-string
+             (start-process
+              "\"Audition pdf\""
+              "*lilypond*"
+              (ly-determine-pdf-path)
+              pdf-file)))
+       (message  "No pdf file generated so can't display!")))))
+
+(defun ly-attempt-to-play-midi (file-name &optional test)
+  "Attempt to play the generated MIDI file
+FILE-NAME is full path to lilypond file
+If TEST is non-nil, the shell command is returned and is not run"
+  (when ly-play-midi-post-tangle
+    (let ((midi-file (ly-switch-extension file-name ".midi")))
+      (if (file-exists-p midi-file)
+          (let ((cmd-string
+                 (concat (ly-determine-midi-path) " " midi-file)))
+            (if test
+                cmd-string
+              (start-process
+               "\"Audition midi\""
+               "*lilypond*"
+               (ly-determine-midi-path)
+               midi-file)))
+        (message "No midi file generated so can't play!")))))
+
+(defun ly-determine-ly-path (&optional test)
+  "Return correct path to ly binary depending on OS
+If TEST is non-nil, it contains a simulation of the OS for test purposes"
+  (let ((sys-type
+         (or test system-type)))
+    (cond ((string= sys-type  "darwin")
+           ly-OSX-ly-path)
+          ((string= sys-type "windows-nt")
+           ly-w32-ly-path)
+          (t ly-nix-ly-path))))
+
+(defun ly-determine-pdf-path (&optional test)
+  "Return correct path to pdf viewer depending on OS
+If TEST is non-nil, it contains a simulation of the OS for test purposes"
+  (let ((sys-type
+         (or test system-type)))
+    (cond ((string= sys-type  "darwin")
+           ly-OSX-pdf-path)
+          ((string= sys-type "windows-nt")
+           ly-w32-pdf-path)
+          (t ly-nix-pdf-path))))
+
+(defun ly-determine-midi-path (&optional test)
+  "Return correct path to midi player depending on OS
+If TEST is non-nil, it contains a simulation of the OS for test purposes"
+  (let ((sys-type
+         (or test test system-type)))
+    (cond ((string= sys-type  "darwin")
+           ly-OSX-midi-path)
+          ((string= sys-type "windows-nt")
+           ly-w32-midi-path)
+          (t ly-nix-midi-path))))
+
+(defun ly-toggle-midi-play ()
+  "Toggle whether midi will be played following a successful compilation."
+  (interactive)
+  (setq ly-play-midi-post-tangle
+        (not ly-play-midi-post-tangle))
+  (message (concat "Post-Tangle MIDI play has been "
+                   (if ly-play-midi-post-tangle
+                       "ENABLED." "DISABLED."))))
+
+(defun ly-toggle-pdf-display ()
+  "Toggle whether pdf will be displayed following a successful compilation."
+  (interactive)
+  (setq ly-display-pdf-post-tangle
+        (not ly-display-pdf-post-tangle))
+  (message (concat "Post-Tangle PDF display has been "
+                   (if ly-display-pdf-post-tangle
+                       "ENABLED." "DISABLED."))))
+
+(defun ly-toggle-png-generation ()
+  "Toggle whether png image will be generated by compilation."
+  (interactive)
+  (setq ly-gen-png (not ly-gen-png))
+  (message (concat "PNG image generation has been "
+                   (if ly-gen-png "ENABLED." "DISABLED."))))
+
+(defun ly-toggle-html-generation ()
+  "Toggle whether html will be generated by compilation."
+  (interactive)
+  (setq ly-gen-html (not ly-gen-html))
+  (message (concat "HTML generation has been "
+                   (if ly-gen-html "ENABLED." "DISABLED."))))
+
+(defun ly-toggle-pdf-generation ()
+  "Toggle whether pdf will be generated by compilation."
+  (interactive)
+  (setq ly-gen-pdf (not ly-gen-pdf))
+  (message (concat "PDF generation has been "
+                   (if ly-gen-pdf "ENABLED." "DISABLED."))))
+
+(defun ly-toggle-arrange-mode ()
+  "Toggle whether in Arrange mode or Basic mode."
+  (interactive)
+  (setq ly-arrange-mode
+        (not ly-arrange-mode))
+  (message (concat "Arrange mode has been "
+                   (if ly-arrange-mode "ENABLED." "DISABLED."))))
+
+(defun ly-switch-extension (file-name ext)
+  "Utility command to swap current FILE-NAME extension with EXT"
+  (concat (file-name-sans-extension
+           file-name) ext))
+
+(defun ly-get-header-args (mode)
+  "Default arguments to use when evaluating a lilypond
+source block.  These depend upon whether we are in arrange
+mode i.e.  ARRANGE-MODE is t"
+  (cond (mode
+         '((:tangle . "yes")
+           (:noweb . "yes")
+           (:results . "silent")
+           (:cache . "yes")
+           (:comments . "yes")))
+        (t
+         '((:results . "file")
+           (:exports . "results")))))
+
+(defun ly-set-header-args (mode)
+  "Set org-babel-default-header-args:lilypond
+dependent on LY-ARRANGE-MODE"
+  (setq org-babel-default-header-args:lilypond
+        (ly-get-header-args mode)))
+
+(provide 'ob-lilypond)
+
+;;; ob-lilypond.el ends here
diff --git a/elisp/org/ob-lisp.el b/elisp/org/ob-lisp.el
new file mode 100644 (file)
index 0000000..2bb1a25
--- /dev/null
@@ -0,0 +1,108 @@
+;;; ob-lisp.el --- org-babel functions for common lisp evaluation
+
+;; Copyright (C) 2009-2013 Free Software Foundation, Inc.
+
+;; Authors: Joel Boehland
+;;      Eric Schulte
+;;      David T. O'Toole <dto@gnu.org>
+;; Keywords: literate programming, reproducible research
+;; Homepage: http://orgmode.org
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
+
+;;; Commentary:
+
+;;; support for evaluating common lisp code, relies on slime for all eval
+
+;;; Requirements:
+
+;; Requires SLIME (Superior Lisp Interaction Mode for Emacs.)
+;; See http://common-lisp.net/project/slime/
+
+;;; Code:
+(require 'ob)
+
+(declare-function slime-eval "ext:slime" (sexp &optional package))
+
+(defvar org-babel-tangle-lang-exts)
+(add-to-list 'org-babel-tangle-lang-exts '("lisp" . "lisp"))
+
+(defvar org-babel-default-header-args:lisp '())
+(defvar org-babel-header-args:lisp '((package . :any)))
+
+(defcustom org-babel-lisp-dir-fmt
+  "(let ((*default-pathname-defaults* #P%S)) %%s)"
+  "Format string used to wrap code bodies to set the current directory.
+For example a value of \"(progn ;; %s\\n   %%s)\" would ignore the
+current directory string."
+  :group 'org-babel
+  :version "24.1"
+  :type 'string)
+
+(defun org-babel-expand-body:lisp (body params)
+  "Expand BODY according to PARAMS, return the expanded body."
+  (let* ((vars (mapcar #'cdr (org-babel-get-header params :var)))
+        (result-params (cdr (assoc :result-params params)))
+        (print-level nil) (print-length nil)
+        (body (org-babel-trim
+               (if (> (length vars) 0)
+                   (concat "(let ("
+                           (mapconcat
+                            (lambda (var)
+                              (format "(%S (quote %S))" (car var) (cdr var)))
+                            vars "\n      ")
+                           ")\n" body ")")
+                 body))))
+    (if (or (member "code" result-params)
+           (member "pp" result-params))
+       (format "(pprint %s)" body)
+      body)))
+
+(defun org-babel-execute:lisp (body params)
+  "Execute a block of Common Lisp code with Babel."
+  (require 'slime)
+  (org-babel-reassemble-table
+   ((lambda (result)
+      (org-babel-result-cond (cdr (assoc :result-params params))
+       (car result)
+       (condition-case nil
+           (read (org-babel-lisp-vector-to-list (cadr result)))
+         (error (cadr result)))))
+    (with-temp-buffer
+      (insert (org-babel-expand-body:lisp body params))
+      (slime-eval `(swank:eval-and-grab-output
+                   ,(let ((dir (if (assoc :dir params)
+                                   (cdr (assoc :dir params))
+                                 default-directory)))
+                      (format
+                       (if dir (format org-babel-lisp-dir-fmt dir) "(progn %s)")
+                       (buffer-substring-no-properties
+                        (point-min) (point-max)))))
+                 (cdr (assoc :package params)))))
+   (org-babel-pick-name (cdr (assoc :colname-names params))
+                       (cdr (assoc :colnames params)))
+   (org-babel-pick-name (cdr (assoc :rowname-names params))
+                       (cdr (assoc :rownames params)))))
+
+(defun org-babel-lisp-vector-to-list (results)
+  ;; TODO: better would be to replace #(...) with [...]
+  (replace-regexp-in-string "#(" "(" results))
+
+(provide 'ob-lisp)
+
+
+
+;;; ob-lisp.el ends here
diff --git a/elisp/org/ob-lob.el b/elisp/org/ob-lob.el
new file mode 100644 (file)
index 0000000..2fcebcf
--- /dev/null
@@ -0,0 +1,149 @@
+;;; ob-lob.el --- functions supporting the Library of Babel
+
+;; Copyright (C) 2009-2013 Free Software Foundation, Inc.
+
+;; Authors: Eric Schulte
+;;      Dan Davison
+;; Keywords: literate programming, reproducible research
+;; Homepage: http://orgmode.org
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
+
+;;; Code:
+(eval-when-compile
+  (require 'cl))
+(require 'ob-core)
+(require 'ob-table)
+
+(declare-function org-babel-in-example-or-verbatim "ob-exp" nil)
+
+(defvar org-babel-library-of-babel nil
+  "Library of source-code blocks.
+This is an association list.  Populate the library by adding
+files to `org-babel-lob-files'.")
+
+(defcustom org-babel-lob-files '()
+  "Files used to populate the `org-babel-library-of-babel'.
+To add files to this list use the `org-babel-lob-ingest' command."
+  :group 'org-babel
+  :version "24.1"
+  :type 'list)
+
+(defvar org-babel-default-lob-header-args '((:exports . "results"))
+  "Default header arguments to use when exporting #+lob/call lines.")
+
+(defun org-babel-lob-ingest (&optional file)
+  "Add all named source-blocks defined in FILE to
+`org-babel-library-of-babel'."
+  (interactive "fFile: ")
+  (let ((lob-ingest-count 0))
+    (org-babel-map-src-blocks file
+      (let* ((info (org-babel-get-src-block-info 'light))
+            (source-name (nth 4 info)))
+       (when source-name
+         (setq source-name (intern source-name)
+               org-babel-library-of-babel
+               (cons (cons source-name info)
+                     (assq-delete-all source-name org-babel-library-of-babel))
+               lob-ingest-count (1+ lob-ingest-count)))))
+    (message "%d src block%s added to Library of Babel"
+            lob-ingest-count (if (> lob-ingest-count 1) "s" ""))
+    lob-ingest-count))
+
+(defconst org-babel-block-lob-one-liner-regexp
+  (concat
+   "^\\([ \t]*?\\)#\\+call:[ \t]+\\([^\(\)\n]+?\\)\\(\\[\\(.*\\)\\]\\|\\(\\)\\)"
+   "\(\\([^\n]*?\\)\)\\(\\[.+\\]\\|\\)[ \t]*\\(\\([^\n]*\\)\\)?")
+  "Regexp to match non-inline calls to predefined source block functions.")
+
+(defconst org-babel-inline-lob-one-liner-regexp
+  (concat
+   "\\([^\n]*?\\)call_\\([^\(\)\n]+?\\)\\(\\[\\(.*?\\)\\]\\|\\(\\)\\)"
+   "\(\\([^\n]*?\\)\)\\(\\[\\(.*?\\)\\]\\)?")
+  "Regexp to match inline calls to predefined source block functions.")
+
+(defconst org-babel-lob-one-liner-regexp
+  (concat "\\(" org-babel-block-lob-one-liner-regexp
+         "\\|" org-babel-inline-lob-one-liner-regexp "\\)")
+  "Regexp to match calls to predefined source block functions.")
+
+;; functions for executing lob one-liners
+
+;;;###autoload
+(defun org-babel-lob-execute-maybe ()
+  "Execute a Library of Babel source block, if appropriate.
+Detect if this is context for a Library Of Babel source block and
+if so then run the appropriate source block from the Library."
+  (interactive)
+  (let ((info (org-babel-lob-get-info)))
+    (if (and (nth 0 info) (not (org-babel-in-example-or-verbatim)))
+       (progn (org-babel-lob-execute info) t)
+      nil)))
+
+;;;###autoload
+(defun org-babel-lob-get-info ()
+  "Return a Library of Babel function call as a string."
+  (let ((case-fold-search t)
+       (nonempty (lambda (a b)
+                   (let ((it (match-string a)))
+                     (if (= (length it) 0) (match-string b) it)))))
+    (save-excursion
+      (beginning-of-line 1)
+      (when (looking-at org-babel-lob-one-liner-regexp)
+       (append
+        (mapcar #'org-no-properties
+                (list
+                 (format "%s%s(%s)%s"
+                         (funcall nonempty 3 12)
+                         (if (not (= 0 (length (funcall nonempty 5 14))))
+                             (concat "[" (funcall nonempty 5 14) "]") "")
+                         (or (funcall nonempty 7 16) "")
+                         (or (funcall nonempty 8 19) ""))
+                 (funcall nonempty 9 18)))
+        (list (length (if (= (length (match-string 12)) 0)
+                          (match-string 2) (match-string 11)))))))))
+
+(defun org-babel-lob-execute (info)
+  "Execute the lob call specified by INFO."
+  (let* ((mkinfo (lambda (p) (list "emacs-lisp" "results" p nil nil (nth 2 info))))
+        (pre-params (org-babel-merge-params
+                     org-babel-default-header-args
+                     (org-babel-params-from-properties)
+                     (org-babel-parse-header-arguments
+                      (org-no-properties
+                       (concat ":var results="
+                               (mapconcat #'identity (butlast info) " "))))))
+        (pre-info (funcall mkinfo pre-params))
+        (cache? (and (cdr (assoc :cache pre-params))
+                     (string= "yes" (cdr (assoc :cache pre-params)))))
+        (new-hash (when cache? (org-babel-sha1-hash pre-info)))
+        (old-hash (when cache? (org-babel-current-result-hash))))
+    (if (and cache? (equal new-hash old-hash))
+       (save-excursion (goto-char (org-babel-where-is-src-block-result))
+                       (forward-line 1)
+                       (message "%S" (org-babel-read-result)))
+      (prog1 (org-babel-execute-src-block
+             nil (funcall mkinfo (org-babel-process-params pre-params)))
+       ;; update the hash
+       (when new-hash (org-babel-set-current-result-hash new-hash))))))
+
+(provide 'ob-lob)
+
+;; Local variables:
+;; generated-autoload-file: "org-loaddefs.el"
+;; End:
+
+;;; ob-lob.el ends here
diff --git a/elisp/org/ob-makefile.el b/elisp/org/ob-makefile.el
new file mode 100644 (file)
index 0000000..7b0ff93
--- /dev/null
@@ -0,0 +1,47 @@
+;;; ob-makefile.el --- org-babel functions for makefile evaluation
+
+;; Copyright (C) 2009-2012  Free Software Foundation, Inc.
+
+;; Author: Eric Schulte and Thomas S. Dye
+;; Keywords: literate programming, reproducible research
+;; Homepage: http://orgmode.org
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
+
+;;; Commentary:
+
+;; This file exists solely for tangling a Makefile from org-mode files.
+
+;;; Code:
+(require 'ob)
+
+(defvar org-babel-default-header-args:makefile '())
+
+(defun org-babel-execute:makefile (body params)
+  "Execute a block of makefile code.
+This function is called by `org-babel-execute-src-block'."
+  body)
+
+(defun org-babel-prep-session:makefile (session params)
+  "Return an error if the :session header argument is set.  Make
+does not support sessions."
+  (error "Makefile sessions are nonsensical"))
+
+(provide 'ob-makefile)
+
+
+
+;;; ob-makefile.el ends here
diff --git a/elisp/org/ob-matlab.el b/elisp/org/ob-matlab.el
new file mode 100644 (file)
index 0000000..481ed24
--- /dev/null
@@ -0,0 +1,47 @@
+;;; ob-matlab.el --- org-babel support for matlab evaluation
+
+;; Copyright (C) 2010-2013 Free Software Foundation, Inc.
+
+;; Author: Dan Davison
+;; Keywords: literate programming, reproducible research
+;; Homepage: http://orgmode.org
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
+
+;;; Commentary:
+
+;; Functions that are common to org-babel support for matlab and
+;; octave are in org-babel-octave.el
+
+;;; Requirements:
+
+;; Matlab
+
+;; matlab.el required for interactive emacs sessions and matlab-mode
+;; major mode for source code editing buffer
+;; http://matlab-emacs.sourceforge.net/
+
+;;; Code:
+(require 'ob)
+(require 'ob-octave)
+
+;; see ob-octave for matlab implementation
+
+(provide 'ob-matlab)
+
+
+
+;;; ob-matlab.el ends here
diff --git a/elisp/org/ob-maxima.el b/elisp/org/ob-maxima.el
new file mode 100644 (file)
index 0000000..916dd7e
--- /dev/null
@@ -0,0 +1,130 @@
+;;; ob-maxima.el --- org-babel functions for maxima evaluation
+
+;; Copyright (C) 2009-2013 Free Software Foundation, Inc.
+
+;; Author: Eric S Fraga
+;;     Eric Schulte
+;; Keywords: literate programming, reproducible research, maxima
+;; Homepage: http://orgmode.org
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
+
+;;; Commentary:
+
+;; Org-Babel support for evaluating maxima entries.
+;;
+;; This differs from most standard languages in that
+;;
+;; 1) there is no such thing as a "session" in maxima
+;;
+;; 2) we are adding the "cmdline" header argument
+
+;;; Code:
+(require 'ob)
+
+(defvar org-babel-tangle-lang-exts)
+(add-to-list 'org-babel-tangle-lang-exts '("maxima" . "max"))
+
+(defvar org-babel-default-header-args:maxima '())
+
+(defcustom org-babel-maxima-command
+  (if (boundp 'maxima-command) maxima-command "maxima")
+  "Command used to call maxima on the shell."
+  :group 'org-babel)
+
+(defun org-babel-maxima-expand (body params)
+  "Expand a block of Maxima code according to its header arguments."
+  (let ((vars (mapcar #'cdr (org-babel-get-header params :var))))
+    (mapconcat 'identity
+              (list
+               ;; graphic output
+               (let ((graphic-file (org-babel-maxima-graphical-output-file params)))
+                 (if graphic-file
+                     (format
+                      "set_plot_option ([gnuplot_term, png]); set_plot_option ([gnuplot_out_file, %S]);"
+                      graphic-file)
+                   ""))
+               ;; variables
+               (mapconcat 'org-babel-maxima-var-to-maxima vars "\n")
+               ;; body
+               body
+               "gnuplot_close ()$")
+              "\n")))
+
+(defun org-babel-execute:maxima (body params)
+  "Execute a block of Maxima entries with org-babel.  This function is
+called by `org-babel-execute-src-block'."
+  (message "executing Maxima source code block")
+  (let ((result-params (split-string (or (cdr (assoc :results params)) "")))
+       (result
+        (let* ((cmdline (or (cdr (assoc :cmdline params)) ""))
+               (in-file (org-babel-temp-file "maxima-" ".max"))
+               (cmd (format "%s --very-quiet -r 'batchload(%S)$' %s"
+                            org-babel-maxima-command in-file cmdline)))
+          (with-temp-file in-file (insert (org-babel-maxima-expand body params)))
+          (message cmd)
+          ((lambda (raw) ;; " | grep -v batch | grep -v 'replaced' | sed '/^$/d' "
+             (mapconcat
+              #'identity
+              (delq nil
+                    (mapcar (lambda (line)
+                              (unless (or (string-match "batch" line)
+                                          (string-match "^rat: replaced .*$" line)
+                                          (= 0 (length line)))
+                                line))
+                            (split-string raw "[\r\n]"))) "\n"))
+           (org-babel-eval cmd "")))))
+    (if (org-babel-maxima-graphical-output-file params)
+       nil
+      (org-babel-result-cond result-params
+       result
+       (let ((tmp-file (org-babel-temp-file "maxima-res-")))
+         (with-temp-file tmp-file (insert result))
+         (org-babel-import-elisp-from-file tmp-file))))))
+
+
+(defun org-babel-prep-session:maxima (session params)
+  (error "Maxima does not support sessions"))
+
+(defun org-babel-maxima-var-to-maxima (pair)
+  "Convert an elisp val into a string of maxima code specifying a var
+of the same value."
+  (let ((var (car pair))
+        (val (cdr pair)))
+    (when (symbolp val)
+      (setq val (symbol-name val))
+      (when (= (length val) 1)
+        (setq val (string-to-char val))))
+    (format "%S: %s$" var
+           (org-babel-maxima-elisp-to-maxima val))))
+
+(defun org-babel-maxima-graphical-output-file (params)
+  "Name of file to which maxima should send graphical output."
+  (and (member "graphics" (cdr (assq :result-params params)))
+       (cdr (assq :file params))))
+
+(defun org-babel-maxima-elisp-to-maxima (val)
+  "Return a string of maxima code which evaluates to VAL."
+  (if (listp val)
+      (concat "[" (mapconcat #'org-babel-maxima-elisp-to-maxima val ", ") "]")
+    (format "%s" val)))
+
+
+(provide 'ob-maxima)
+
+
+
+;;; ob-maxima.el ends here
diff --git a/elisp/org/ob-mscgen.el b/elisp/org/ob-mscgen.el
new file mode 100644 (file)
index 0000000..209ad7d
--- /dev/null
@@ -0,0 +1,84 @@
+;;; ob-msc.el --- org-babel functions for mscgen evaluation
+
+;; Copyright (C) 2010-2013 Free Software Foundation, Inc.
+
+;; Author: Juan Pechiar
+;; Keywords: literate programming, reproducible research
+;; Homepage: http://orgmode.org
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
+
+;;; Commentary:
+;;
+;; This software provides EMACS org-babel export support for message
+;; sequence charts.  The mscgen utility is used for processing the
+;; sequence definition, and must therefore be installed in the system.
+;;
+;; Mscgen is available and documented at
+;; http://www.mcternan.me.uk/mscgen/index.html
+;;
+;; This code is directly inspired by Eric Schulte's ob-dot.el
+;;
+;; Example:
+;;
+;; #+begin_src mscgen :file example.png
+;; msc {
+;;  A,B;
+;;  A -> B [ label = "send message" ];
+;;  A <- B [ label = "get answer" ];
+;; }
+;; #+end_src
+;;
+;; Header for alternative file type:
+;;
+;; #+begin_src mscgen :file ex2.svg :filetype svg
+
+;; This differs from most standard languages in that
+;;
+;; 1) there is no such thing as a "session" in mscgen
+;; 2) we are generally only going to return results of type "file"
+;; 3) we are adding the "file" and "filetype" header arguments
+;; 4) there are no variables
+
+;;; Code:
+(require 'ob)
+
+(defvar org-babel-default-header-args:mscgen
+  '((:results . "file") (:exports . "results"))
+  "Default arguments to use when evaluating a mscgen source block.")
+
+(defun org-babel-execute:mscgen (body params)
+  "Execute a block of Mscgen code with Babel.
+This function is called by `org-babel-execute-src-block'.
+Default filetype is png.  Modify by setting :filetype parameter to
+mscgen supported formats."
+  (let* ((out-file (or (cdr (assoc :file params)) "output.png" ))
+         (filetype (or (cdr (assoc :filetype params)) "png" )))
+    (unless (cdr (assoc :file params))
+      (error "
+ERROR: no output file specified.  Add \":file name.png\" to the src header"))
+    (org-babel-eval (concat "mscgen -T " filetype " -o " out-file) body)
+    nil)) ;; signal that output has already been written to file
+
+(defun org-babel-prep-session:mscgen (session params)
+  "Raise an error because Mscgen doesn't support sessions."
+  (error "Mscgen does not support sessions"))
+
+(provide 'ob-mscgen)
+
+
+
+;;; ob-msc.el ends here
diff --git a/elisp/org/ob-ocaml.el