Remove old org
authorJoerg Jaspert <joerg@debian.org>
Sat, 26 Aug 2017 11:51:57 +0000 (13:51 +0200)
committerJoerg Jaspert <joerg@debian.org>
Sat, 26 Aug 2017 11:51:57 +0000 (13:51 +0200)
167 files changed:
.emacs.d/elisp/org/ob-C.el [deleted file]
.emacs.d/elisp/org/ob-J.el [deleted file]
.emacs.d/elisp/org/ob-R.el [deleted file]
.emacs.d/elisp/org/ob-abc.el [deleted file]
.emacs.d/elisp/org/ob-asymptote.el [deleted file]
.emacs.d/elisp/org/ob-awk.el [deleted file]
.emacs.d/elisp/org/ob-calc.el [deleted file]
.emacs.d/elisp/org/ob-clojure.el [deleted file]
.emacs.d/elisp/org/ob-comint.el [deleted file]
.emacs.d/elisp/org/ob-coq.el [deleted file]
.emacs.d/elisp/org/ob-core.el [deleted file]
.emacs.d/elisp/org/ob-css.el [deleted file]
.emacs.d/elisp/org/ob-ditaa.el [deleted file]
.emacs.d/elisp/org/ob-dot.el [deleted file]
.emacs.d/elisp/org/ob-ebnf.el [deleted file]
.emacs.d/elisp/org/ob-emacs-lisp.el [deleted file]
.emacs.d/elisp/org/ob-eval.el [deleted file]
.emacs.d/elisp/org/ob-exp.el [deleted file]
.emacs.d/elisp/org/ob-forth.el [deleted file]
.emacs.d/elisp/org/ob-fortran.el [deleted file]
.emacs.d/elisp/org/ob-gnuplot.el [deleted file]
.emacs.d/elisp/org/ob-groovy.el [deleted file]
.emacs.d/elisp/org/ob-haskell.el [deleted file]
.emacs.d/elisp/org/ob-io.el [deleted file]
.emacs.d/elisp/org/ob-java.el [deleted file]
.emacs.d/elisp/org/ob-js.el [deleted file]
.emacs.d/elisp/org/ob-keys.el [deleted file]
.emacs.d/elisp/org/ob-latex.el [deleted file]
.emacs.d/elisp/org/ob-ledger.el [deleted file]
.emacs.d/elisp/org/ob-lilypond.el [deleted file]
.emacs.d/elisp/org/ob-lisp.el [deleted file]
.emacs.d/elisp/org/ob-lob.el [deleted file]
.emacs.d/elisp/org/ob-makefile.el [deleted file]
.emacs.d/elisp/org/ob-matlab.el [deleted file]
.emacs.d/elisp/org/ob-maxima.el [deleted file]
.emacs.d/elisp/org/ob-mscgen.el [deleted file]
.emacs.d/elisp/org/ob-ocaml.el [deleted file]
.emacs.d/elisp/org/ob-octave.el [deleted file]
.emacs.d/elisp/org/ob-org.el [deleted file]
.emacs.d/elisp/org/ob-perl.el [deleted file]
.emacs.d/elisp/org/ob-picolisp.el [deleted file]
.emacs.d/elisp/org/ob-plantuml.el [deleted file]
.emacs.d/elisp/org/ob-processing.el [deleted file]
.emacs.d/elisp/org/ob-python.el [deleted file]
.emacs.d/elisp/org/ob-ref.el [deleted file]
.emacs.d/elisp/org/ob-ruby.el [deleted file]
.emacs.d/elisp/org/ob-sass.el [deleted file]
.emacs.d/elisp/org/ob-scala.el [deleted file]
.emacs.d/elisp/org/ob-scheme.el [deleted file]
.emacs.d/elisp/org/ob-screen.el [deleted file]
.emacs.d/elisp/org/ob-sed.el [deleted file]
.emacs.d/elisp/org/ob-shell.el [deleted file]
.emacs.d/elisp/org/ob-shen.el [deleted file]
.emacs.d/elisp/org/ob-sql.el [deleted file]
.emacs.d/elisp/org/ob-sqlite.el [deleted file]
.emacs.d/elisp/org/ob-stan.el [deleted file]
.emacs.d/elisp/org/ob-table.el [deleted file]
.emacs.d/elisp/org/ob-tangle.el [deleted file]
.emacs.d/elisp/org/ob.el [deleted file]
.emacs.d/elisp/org/org-agenda.el [deleted file]
.emacs.d/elisp/org/org-annotate-file.el [deleted file]
.emacs.d/elisp/org/org-archive.el [deleted file]
.emacs.d/elisp/org/org-attach.el [deleted file]
.emacs.d/elisp/org/org-bbdb.el [deleted file]
.emacs.d/elisp/org/org-bibtex-extras.el [deleted file]
.emacs.d/elisp/org/org-bibtex.el [deleted file]
.emacs.d/elisp/org/org-bookmark.el [deleted file]
.emacs.d/elisp/org/org-bullets.el [deleted file]
.emacs.d/elisp/org/org-capture.el [deleted file]
.emacs.d/elisp/org/org-checklist.el [deleted file]
.emacs.d/elisp/org/org-choose.el [deleted file]
.emacs.d/elisp/org/org-clock.el [deleted file]
.emacs.d/elisp/org/org-collector.el [deleted file]
.emacs.d/elisp/org/org-colview-xemacs.el [deleted file]
.emacs.d/elisp/org/org-colview.el [deleted file]
.emacs.d/elisp/org/org-compat.el [deleted file]
.emacs.d/elisp/org/org-contacts.el [deleted file]
.emacs.d/elisp/org/org-contribdir.el [deleted file]
.emacs.d/elisp/org/org-crypt.el [deleted file]
.emacs.d/elisp/org/org-ctags.el [deleted file]
.emacs.d/elisp/org/org-datetree.el [deleted file]
.emacs.d/elisp/org/org-depend.el [deleted file]
.emacs.d/elisp/org/org-docview.el [deleted file]
.emacs.d/elisp/org/org-download.el [deleted file]
.emacs.d/elisp/org/org-drill.el [deleted file]
.emacs.d/elisp/org/org-ebib.el [deleted file]
.emacs.d/elisp/org/org-effectiveness.el [deleted file]
.emacs.d/elisp/org/org-eldoc.el [deleted file]
.emacs.d/elisp/org/org-element.el [deleted file]
.emacs.d/elisp/org/org-elisp-symbol.el [deleted file]
.emacs.d/elisp/org/org-entities.el [deleted file]
.emacs.d/elisp/org/org-eshell.el [deleted file]
.emacs.d/elisp/org/org-eval-light.el [deleted file]
.emacs.d/elisp/org/org-eval.el [deleted file]
.emacs.d/elisp/org/org-eww.el [deleted file]
.emacs.d/elisp/org/org-expiry.el [deleted file]
.emacs.d/elisp/org/org-faces.el [deleted file]
.emacs.d/elisp/org/org-feed.el [deleted file]
.emacs.d/elisp/org/org-footnote.el [deleted file]
.emacs.d/elisp/org/org-git-link.el [deleted file]
.emacs.d/elisp/org/org-gnus.el [deleted file]
.emacs.d/elisp/org/org-habit.el [deleted file]
.emacs.d/elisp/org/org-id.el [deleted file]
.emacs.d/elisp/org/org-indent.el [deleted file]
.emacs.d/elisp/org/org-index.el [deleted file]
.emacs.d/elisp/org/org-info.el [deleted file]
.emacs.d/elisp/org/org-inlinetask.el [deleted file]
.emacs.d/elisp/org/org-install.el [deleted file]
.emacs.d/elisp/org/org-interactive-query.el [deleted file]
.emacs.d/elisp/org/org-invoice.el [deleted file]
.emacs.d/elisp/org/org-irc.el [deleted file]
.emacs.d/elisp/org/org-learn.el [deleted file]
.emacs.d/elisp/org/org-license.el [deleted file]
.emacs.d/elisp/org/org-link-edit.el [deleted file]
.emacs.d/elisp/org/org-lint.el [deleted file]
.emacs.d/elisp/org/org-list.el [deleted file]
.emacs.d/elisp/org/org-loaddefs.el [deleted file]
.emacs.d/elisp/org/org-mac-iCal.el [deleted file]
.emacs.d/elisp/org/org-mac-link.el [deleted file]
.emacs.d/elisp/org/org-macro.el [deleted file]
.emacs.d/elisp/org/org-macs.el [deleted file]
.emacs.d/elisp/org/org-mairix.el [deleted file]
.emacs.d/elisp/org/org-man.el [deleted file]
.emacs.d/elisp/org/org-mew.el [deleted file]
.emacs.d/elisp/org/org-mhe.el [deleted file]
.emacs.d/elisp/org/org-mime.el [deleted file]
.emacs.d/elisp/org/org-mobile.el [deleted file]
.emacs.d/elisp/org/org-mouse.el [deleted file]
.emacs.d/elisp/org/org-notify.el [deleted file]
.emacs.d/elisp/org/org-notmuch.el [deleted file]
.emacs.d/elisp/org/org-panel.el [deleted file]
.emacs.d/elisp/org/org-passwords.el [deleted file]
.emacs.d/elisp/org/org-pcomplete.el [deleted file]
.emacs.d/elisp/org/org-plot.el [deleted file]
.emacs.d/elisp/org/org-protocol.el [deleted file]
.emacs.d/elisp/org/org-registry.el [deleted file]
.emacs.d/elisp/org/org-rmail.el [deleted file]
.emacs.d/elisp/org/org-screen.el [deleted file]
.emacs.d/elisp/org/org-screenshot.el [deleted file]
.emacs.d/elisp/org/org-secretary.el [deleted file]
.emacs.d/elisp/org/org-src.el [deleted file]
.emacs.d/elisp/org/org-static-mathjax.el [deleted file]
.emacs.d/elisp/org/org-sudoku.el [deleted file]
.emacs.d/elisp/org/org-table.el [deleted file]
.emacs.d/elisp/org/org-timer.el [deleted file]
.emacs.d/elisp/org/org-toc.el [deleted file]
.emacs.d/elisp/org/org-track.el [deleted file]
.emacs.d/elisp/org/org-velocity.el [deleted file]
.emacs.d/elisp/org/org-version.el [deleted file]
.emacs.d/elisp/org/org-vm.el [deleted file]
.emacs.d/elisp/org/org-w3m.el [deleted file]
.emacs.d/elisp/org/org-wikinodes.el [deleted file]
.emacs.d/elisp/org/org-wl.el [deleted file]
.emacs.d/elisp/org/org.el [deleted file]
.emacs.d/elisp/org/orgtbl-sqlinsert.el [deleted file]
.emacs.d/elisp/org/ox-ascii.el [deleted file]
.emacs.d/elisp/org/ox-beamer.el [deleted file]
.emacs.d/elisp/org/ox-html.el [deleted file]
.emacs.d/elisp/org/ox-icalendar.el [deleted file]
.emacs.d/elisp/org/ox-latex.el [deleted file]
.emacs.d/elisp/org/ox-man.el [deleted file]
.emacs.d/elisp/org/ox-md.el [deleted file]
.emacs.d/elisp/org/ox-odt.el [deleted file]
.emacs.d/elisp/org/ox-org.el [deleted file]
.emacs.d/elisp/org/ox-publish.el [deleted file]
.emacs.d/elisp/org/ox-texinfo.el [deleted file]
.emacs.d/elisp/org/ox.el [deleted file]

diff --git a/.emacs.d/elisp/org/ob-C.el b/.emacs.d/elisp/org/ob-C.el
deleted file mode 100644 (file)
index f02950a..0000000
+++ /dev/null
@@ -1,439 +0,0 @@
-;;; ob-C.el --- org-babel functions for C and similar languages
-
-;; Copyright (C) 2010-2015 Free Software Foundation, Inc.
-
-;; Author: Eric Schulte
-;;      Thierry Banel
-;; 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, C++, D 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))
-(declare-function org-remove-indentation "org" (code &optional n))
-
-(defvar org-babel-tangle-lang-exts)
-(add-to-list 'org-babel-tangle-lang-exts '("C++" . "cpp"))
-(add-to-list 'org-babel-tangle-lang-exts '("D" . "d"))
-
-(defvar org-babel-default-header-args:C '())
-
-(defcustom org-babel-C-compiler "gcc"
-  "Command used to compile a C source code file into an executable.
-May be either a command in the path, like gcc
-or an absolute path name, like /usr/local/bin/gcc
-parameter may be used, like gcc -v"
-  :group 'org-babel
-  :version "24.3"
-  :type 'string)
-
-(defcustom org-babel-C++-compiler "g++"
-  "Command used to compile a C++ source code file into an executable.
-May be either a command in the path, like g++
-or an absolute path name, like /usr/local/bin/g++
-parameter may be used, like g++ -v"
-  :group 'org-babel
-  :version "24.3"
-  :type 'string)
-
-(defcustom org-babel-D-compiler "rdmd"
-  "Command used to compile and execute a D source code file.
-May be either a command in the path, like rdmd
-or an absolute path name, like /usr/local/bin/rdmd
-parameter may be used, like rdmd --chatty"
-  :group 'org-babel
-  :version "24.3"
-  :type 'string)
-
-(defvar org-babel-c-variant nil
-  "Internal variable used to hold which type of C (e.g. C or C++ or D)
-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-expand-body:cpp (body params)
-  "Expand a block of C++ code with org-babel according to it's
-header arguments."
-  (org-babel-expand-body: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."
-  (let ((org-babel-c-variant 'cpp)) (org-babel-C-expand-C++ body params)))
-
-(defun org-babel-execute:D (body params)
-  "Execute a block of D code with org-babel.
-This function is called by `org-babel-execute-src-block'."
-  (let ((org-babel-c-variant 'd)) (org-babel-C-execute body params)))
-
-(defun org-babel-expand-body:D (body params)
-  "Expand a block of D code with org-babel according to it's
-header arguments."
-  (let ((org-babel-c-variant 'd)) (org-babel-C-expand-D 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."
-  (let ((org-babel-c-variant 'c)) (org-babel-C-expand-C 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++' or `org-babel-execute:D'."
-  (let* ((tmp-src-file (org-babel-temp-file
-                       "C-src-"
-                       (case org-babel-c-variant
-                        (c   ".c"  )
-                        (cpp ".cpp")
-                        (d   ".d"  ))))
-        (tmp-bin-file (org-babel-temp-file "C-bin-" org-babel-exeext)) ;; not used for D
-        (cmdline (cdr (assoc :cmdline params)))
-        (cmdline (if cmdline (concat " " cmdline) ""))
-        (flags (cdr (assoc :flags params)))
-        (flags (mapconcat 'identity
-                          (if (listp flags) flags (list flags)) " "))
-        (full-body
-         (case org-babel-c-variant
-           (c   (org-babel-C-expand-C   body params))
-           (cpp (org-babel-C-expand-C++ body params))
-           (d   (org-babel-C-expand-D   body params)))))
-    (with-temp-file tmp-src-file (insert full-body))
-    (case org-babel-c-variant
-      ((c cpp)
-       (org-babel-eval
-       (format "%s -o %s %s %s"
-               (case org-babel-c-variant
-                (c   org-babel-C-compiler)
-                (cpp org-babel-C++-compiler))
-               (org-babel-process-file-name tmp-bin-file)
-               flags
-               (org-babel-process-file-name tmp-src-file)) ""))
-      (d nil)) ;; no separate compilation for D
-    (let ((results
-          (org-babel-eval
-           (case org-babel-c-variant
-             ((c cpp)
-              (concat tmp-bin-file cmdline))
-             (d
-              (format "%s %s %s %s"
-                      org-babel-D-compiler
-                      flags
-                      (org-babel-process-file-name tmp-src-file)
-                      cmdline)))
-           "")))
-      (when results
-       (setq results (org-babel-trim (org-remove-indentation results)))
-       (org-babel-reassemble-table
-        (org-babel-result-cond (cdr (assoc :result-params params))
-          (org-babel-read results t)
-          (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)))))
-      )))
-
-(defun org-babel-C-expand-C++ (body params)
-  "Expand a block of C or C++ code with org-babel according to
-it's header arguments."
-  (org-babel-C-expand-C body params))
-
-(defun org-babel-C-expand-C (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)))
-       (colnames (cdar (org-babel-get-header params :colname-names)))
-       (main-p (not (string= (cdr (assoc :main params)) "no")))
-       (includes (org-babel-read
-                  (or (cdr (assoc :includes params))
-                      (org-entry-get nil "includes" t))
-                  nil))
-       (defines (org-babel-read
-                 (or (cdr (assoc :defines params))
-                     (org-entry-get nil "defines" t))
-                 nil)))
-    (when (stringp includes)
-      (setq includes (split-string includes)))
-    (when (stringp defines)
-      (let ((y nil)
-           (result (list t)))
-       (dolist (x (split-string defines))
-         (if (null y)
-             (setq y x)
-           (nconc result (list (concat y " " x)))
-           (setq y nil)))
-       (setq defines (cdr result))))
-    (mapconcat 'identity
-              (list
-               ;; includes
-               (mapconcat
-                (lambda (inc) (format "#include %s" inc))
-                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")
-               ;; table sizes
-               (mapconcat 'org-babel-C-table-sizes-to-C vars "\n")
-               ;; tables headers utility
-               (when colnames
-                 (org-babel-C-utility-header-to-C))
-               ;; tables headers
-               (mapconcat 'org-babel-C-header-to-C colnames "\n")
-               ;; body
-               (if main-p
-                   (org-babel-C-ensure-main-wrap body)
-                 body) "\n") "\n")))
-
-(defun org-babel-C-expand-D (body params)
-  "Expand a block of D code with org-babel according to
-it's header arguments."
-  (let ((vars (mapcar #'cdr (org-babel-get-header params :var)))
-       (colnames (cdar (org-babel-get-header params :colname-names)))
-       (main-p (not (string= (cdr (assoc :main params)) "no")))
-       (imports (or (cdr (assoc :imports params))
-                    (org-babel-read (org-entry-get nil "imports" t)))))
-    (when (stringp imports)
-      (setq imports (split-string imports)))
-    (setq imports (append imports '("std.stdio" "std.conv")))
-    (mapconcat 'identity
-              (list
-               "module mmm;"
-               ;; imports
-               (mapconcat
-                (lambda (inc) (format "import %s;" inc))
-                imports "\n")
-               ;; variables
-               (mapconcat 'org-babel-C-var-to-C vars "\n")
-               ;; table sizes
-               (mapconcat 'org-babel-C-table-sizes-to-C vars "\n")
-               ;; tables headers utility
-               (when colnames
-                 (org-babel-C-utility-header-to-C))
-               ;; tables headers
-               (mapconcat 'org-babel-C-header-to-C colnames "\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-format-val (type val)
-  "Handle the FORMAT part of TYPE with the data from VAL."
-  (let ((format-data (cadr type)))
-    (if (stringp format-data)
-       (cons "" (format format-data val))
-      (funcall format-data val))))
-
-(defun org-babel-C-val-to-C-type (val)
-  "Determine the type of VAL.
-Return a list (TYPE-NAME FORMAT).  TYPE-NAME should be the name of the type.
-FORMAT can be either a format string or a function which is called with VAL."
-  (let* ((basetype (org-babel-C-val-to-base-type val))
-        (type
-         (case basetype
-           (integerp '("int" "%d"))
-           (floatp '("double" "%f"))
-           (stringp
-            (list
-             (if (equal org-babel-c-variant 'd) "string" "const char*")
-             "\"%s\""))
-           (t (error "unknown type %S" basetype)))))
-    (cond
-     ((integerp val) type) ;; an integer declared in the #+begin_src line
-     ((floatp val) type) ;; a numeric declared in the #+begin_src line
-     ((and (listp val) (listp (car val))) ;; a table
-      `(,(car type)
-       (lambda (val)
-         (cons
-          (format "[%d][%d]" (length val) (length (car val)))
-          (concat
-           (if (equal org-babel-c-variant 'd) "[\n" "{\n")
-           (mapconcat
-            (lambda (v)
-              (concat
-               (if (equal org-babel-c-variant 'd) " [" " {")
-               (mapconcat (lambda (w) (format ,(cadr type) w)) v ",")
-               (if (equal org-babel-c-variant 'd) "]" "}")))
-            val
-            ",\n")
-           (if (equal org-babel-c-variant 'd) "\n]" "\n}"))))))
-     ((or (listp val) (vectorp val)) ;; a list declared in the #+begin_src line
-      `(,(car type)
-       (lambda (val)
-         (cons
-          (format "[%d]" (length val))
-          (concat
-           (if (equal org-babel-c-variant 'd) "[" "{")
-           (mapconcat (lambda (v) (format ,(cadr type) v)) val ",")
-           (if (equal org-babel-c-variant 'd) "]" "}"))))))
-     (t ;; treat unknown types as string
-      type))))
-
-(defun org-babel-C-val-to-base-type (val)
-  "Determine the base type of VAL which may be
-'integerp if all base values are integers
-'floatp if all base values are either floating points or integers
-'stringp otherwise."
-  (cond
-   ((integerp val) 'integerp)
-   ((floatp val) 'floatp)
-   ((or (listp val) (vectorp val))
-    (let ((type nil))
-      (mapc (lambda (v)
-             (case (org-babel-C-val-to-base-type v)
-               (stringp (setq type 'stringp))
-               (floatp
-                (if (or (not type) (eq type 'integerp))
-                    (setq type 'floatp)))
-               (integerp
-                (unless type (setq type 'integerp)))))
-           val)
-      type))
-   (t 'stringp)))
-
-(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))))
-    (let* ((type-data (org-babel-C-val-to-C-type val))
-          (type (car type-data))
-          (formated (org-babel-C-format-val type-data val))
-          (suffix (car formated))
-          (data (cdr formated)))
-      (format "%s %s%s = %s;"
-             type
-             var
-             suffix
-             data))))
-
-(defun org-babel-C-table-sizes-to-C (pair)
-  "Create constants of table dimensions, if PAIR is a table."
-  (when (listp (cdr pair))
-    (cond
-     ((listp (cadr pair)) ;; a table
-      (concat
-       (format "const int %s_rows = %d;" (car pair) (length (cdr pair)))
-       "\n"
-       (format "const int %s_cols = %d;" (car pair) (length (cadr pair)))))
-     (t ;; a list declared in the #+begin_src line
-      (format "const int %s_cols = %d;" (car pair) (length (cdr pair)))))))
-
-(defun org-babel-C-utility-header-to-C ()
-  "Generate a utility function to convert a column name
-into a column number."
-  (case org-babel-c-variant
-    ((c cpp)
-     "int get_column_num (int nbcols, const char** header, const char* column)
-{
-  int c;
-  for (c=0; c<nbcols; c++)
-    if (strcmp(header[c],column)==0)
-      return c;
-  return -1;
-}
-"
-     )
-    (d
-     "int get_column_num (string[] header, string column)
-{
-  foreach (c, h; header)
-    if (h==column)
-      return to!int(c);
-  return -1;
-}
-"
-     )))
-
-(defun org-babel-C-header-to-C (head)
-  "Convert an elisp list of header table into a C or D vector
-specifying a variable with the name of the table."
-  (let ((table (car head))
-        (headers (cdr head)))
-    (concat
-     (format
-      (case org-babel-c-variant
-       ((c cpp) "const char* %s_header[%d] = {%s};")
-       (d       "string %s_header[%d] = [%s];"))
-      table
-      (length headers)
-      (mapconcat (lambda (h) (format "%S" h)) headers ","))
-     "\n"
-     (case org-babel-c-variant
-       ((c cpp)
-       (format
-        "const char* %s_h (int row, const char* col) { return %s[row][get_column_num(%d,%s_header,col)]; }"
-        table table (length headers) table))
-       (d
-       (format
-        "string %s_h (ulong row, string col) { return %s[row][get_column_num(%s_header,col)]; }"
-        table table table))))))
-
-(provide 'ob-C)
-
-;;; ob-C.el ends here
diff --git a/.emacs.d/elisp/org/ob-J.el b/.emacs.d/elisp/org/ob-J.el
deleted file mode 100644 (file)
index 500ce9e..0000000
+++ /dev/null
@@ -1,179 +0,0 @@
-;;; ob-J.el --- org-babel functions for J evaluation
-
-;; Copyright (C) 2011-2013 Free Software Foundation, Inc.
-
-;; Author: Oleh Krehel
-;; 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 J code.
-;;
-;; Session interaction depends on `j-console' from package `j-mode'
-;; (available in MELPA).
-
-;;; Code:
-(require 'ob)
-
-(declare-function org-trim "org" (S))
-(declare-function j-console-ensure-session "ext:j-console" ())
-
-(defun org-babel-expand-body:J (body params &optional processed-params)
-  "Expand BODY according to PARAMS, return the expanded body.
-PROCESSED-PARAMS isn't used yet."
-  (org-babel-J-interleave-echos-except-functions body))
-
-(defun org-babel-J-interleave-echos (body)
-  "Interleave echo',' between each source line of BODY."
-  (mapconcat #'identity (split-string body "\n") "\necho','\n"))
-
-(defun org-babel-J-interleave-echos-except-functions (body)
-  "Interleave echo',' between source lines of BODY that aren't functions."
-  (if (obj-string-match-m "\\(?:^\\|\n\\)[^\n]*\\(?:0\\|1\\|2\\|3\\|4\\|dyad\\) : 0\n.*\n)\\(?:\n\\|$\\)" body)
-      (let ((s1 (substring body 0 (match-beginning 0)))
-           (s2 (match-string 0 body))
-           (s3 (substring body (match-end 0))))
-       (concat
-        (if (string= s1 "")
-            ""
-          (concat (org-babel-J-interleave-echos s1)
-                  "\necho','\n"))
-        s2
-        "\necho','\n"
-        (org-babel-J-interleave-echos-except-functions s3)))
-    (org-babel-J-interleave-echos body)))
-
-(defun org-babel-execute:J (body params)
-  "Execute a block of J code BODY.
-PARAMS are given by org-babel.
-This function is called by `org-babel-execute-src-block'"
-  (message "executing J source code block")
-  (let* ((processed-params (org-babel-process-params params))
-        (sessionp (cdr (assoc :session params)))
-         (session (org-babel-j-initiate-session sessionp))
-         (vars (nth 2 processed-params))
-         (result-params (nth 3 processed-params))
-         (result-type (nth 4 processed-params))
-         (full-body (org-babel-expand-body:J
-                     body params processed-params))
-        (tmp-script-file (org-babel-temp-file "J-src")))
-    (org-babel-J-strip-whitespace
-     (if (string= sessionp "none")
-        (progn
-          (with-temp-file tmp-script-file
-            (insert full-body))
-          (org-babel-eval (format "jconsole < %s" tmp-script-file) ""))
-       (org-babel-J-eval-string full-body)))))
-
-(defun org-babel-J-eval-string (str)
-  "Sends STR to the `j-console-cmd' session and exectues it."
-  (let ((session (j-console-ensure-session)))
-    (with-current-buffer (process-buffer session)
-      (goto-char (point-max))
-      (insert (format "\n%s\n" str))
-      (let ((beg (point)))
-       (comint-send-input)
-       (sit-for .1)
-       (buffer-substring-no-properties
-        beg (point-max))))))
-
-(defun org-babel-J-strip-whitespace (str)
-  "Remove whitespace from jconsole output STR."
-  (mapconcat
-   #'identity
-   (delete "" (mapcar
-              #'org-babel-J-print-block
-              (split-string str "^ *,\n" t)))
-   "\n\n"))
-
-(defun obj-get-string-alignment (str)
-  "Return a number to describe STR alignment.
-STR represents a table.
-Positive/negative/zero result means right/left/undetermined.
-Don't trust first line."
-  (let* ((str (org-trim str))
-        (lines (split-string str "\n" t))
-        n1 n2)
-    (cond ((<= (length lines) 1)
-          0)
-         ((= (length lines) 2)
-          ;; numbers are right-aligned
-          (if (and
-               (numberp (read (car lines)))
-               (numberp (read (cadr lines)))
-               (setq n1 (obj-match-second-space-right (nth 0 lines)))
-               (setq n2 (obj-match-second-space-right (nth 1 lines))))
-              n2
-            0))
-         ((not (obj-match-second-space-left (nth 0 lines)))
-          0)
-         ((and
-           (setq n1 (obj-match-second-space-left (nth 1 lines)))
-           (setq n2 (obj-match-second-space-left (nth 2 lines)))
-           (= n1 n2))
-          n1)
-         ((and
-           (setq n1 (obj-match-second-space-right (nth 1 lines)))
-           (setq n2 (obj-match-second-space-right (nth 2 lines)))
-           (= n1 n2))
-          (- n1))
-         (t 0))))
-
-(defun org-babel-J-print-block (x)
-  "Prettify jconsole output X."
-  (let* ((x (org-trim x))
-        (a (obj-get-string-alignment x))
-        (lines (split-string x "\n" t))
-        b)
-    (cond ((< a 0)
-          (setq b (obj-match-second-space-right (nth 0 lines)))
-          (concat (make-string (+ a b) ? ) x))
-         ((> a 0)
-          (setq b (obj-match-second-space-left (nth 0 lines)))
-          (concat (make-string (- a b) ? ) x))
-         (t x))))
-
-(defun obj-match-second-space-left (s)
-  "Return position of leftmost space in second space block of S or nil."
-  (and (string-match "^ *[^ ]+\\( \\)" s)
-       (match-beginning 1)))
-
-(defun obj-match-second-space-right (s)
-  "Return position of rightmost space in second space block of S or nil."
-  (and (string-match "^ *[^ ]+ *\\( \\)[^ ]" s)
-       (match-beginning 1)))
-
-(defun obj-string-match-m (regexp string &optional start)
-  "Call (string-match REGEXP STRING START).
-REGEXP is modified so that .* matches newlines as well."
-  (string-match
-   (replace-regexp-in-string "\\.\\*" "[\0-\377[:nonascii:]]*" regexp)
-   string
-   start))
-
-(defun org-babel-j-initiate-session (&optional session)
-  "Initiate a J session.
-SESSION is a parameter given by org-babel."
-  (unless (string= session "none")
-    (require 'j-console)
-    (j-console-ensure-session)))
-
-(provide 'ob-J)
-
-;;; ob-J.el ends here
diff --git a/.emacs.d/elisp/org/ob-R.el b/.emacs.d/elisp/org/ob-R.el
deleted file mode 100644 (file)
index ac84d7d..0000000
+++ /dev/null
@@ -1,469 +0,0 @@
-;;; ob-R.el --- org-babel functions for R code evaluation
-
-;; Copyright (C) 2009-2015 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 ess-wait-for-process "ext:ess-inf"
-                 (proc &optional sec-prompt wait force-redisplay))
-(declare-function org-number-sequence "org-compat" (from &optional to inc))
-(declare-function org-remove-if-not "org" (predicate seq))
-(declare-function org-every "org" (pred 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 html latex org code pp drawer)
-                           (replace silent none append prepend)
-                           (output value graphics))))
-  "R-specific header arguments.")
-
-(defconst ob-R-safe-header-args
-  (append org-babel-safe-header-args
-         '(:width :height :bg :units :pointsize :antialias :quality
-                  :compression :res :type :family :title :fonts
-                  :version :paper :encoding :pagecentre :colormodel
-                  :useDingbats :horizontal))
-  "Header args which are safe for R babel blocks.
-
-See `org-babel-safe-header-args' for documentation of the format of
-this variable.")
-
-(defvar org-babel-default-header-args:R '())
-(put 'org-babel-default-header-args:R 'safe-local-variable
-     (org-babel-header-args-safe-fn ob-R-safe-header-args))
-
-(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-current-process-name) ; dynamically scoped
-(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)))))
-
-;; The usage of utils::read.table() ensures that the command
-;; read.table() can be found even in circumstances when the utils
-;; package is not in the search path from R.
-(defconst ob-R-transfer-variable-table-with-header
-  "%s <- local({
-     con <- textConnection(
-       %S
-     )
-     res <- utils::read.table(
-       con,
-       header    = %s,
-       row.names = %s,
-       sep       = \"\\t\",
-       as.is     = TRUE
-     )
-     close(con)
-     res
-   })"
-  "R code used to transfer a table defined as a variable from org to R.
-
-This function is used when the table contains a header.")
-
-(defconst ob-R-transfer-variable-table-without-header
-  "%s <- local({
-     con <- textConnection(
-       %S
-     )
-     res <- utils::read.table(
-       con,
-       header    = %s,
-       row.names = %s,
-       sep       = \"\\t\",
-       as.is     = TRUE,
-       fill      = TRUE,
-       col.names = paste(\"V\", seq_len(%d), sep =\"\")
-     )
-     close(con)
-     res
-   })"
-  "R code used to transfer a table defined as a variable from org to R.
-
-This function is used when the table does not contain a header.")
-
-(defun org-babel-expand-body:R (body params &optional graphics-file)
-  "Expand BODY according to PARAMS, return the expanded body."
-  (mapconcat 'identity
-            (append
-             (when (cdr (assoc :prologue params))
-               (list (cdr (assoc :prologue params))))
-             (org-babel-variable-assignments:R params)
-             (list body)
-             (when (cdr (assoc :epilogue params))
-               (list (cdr (assoc :epilogue params)))))
-            "\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 (and (member "graphics" (assq :result-params params))
-                              (org-babel-graphical-output-file params)))
-          (full-body
-           (let ((inside
-                  (list (org-babel-expand-body:R body params graphics-file))))
-             (mapconcat 'identity
-                        (if graphics-file
-                            (append
-                             (list (org-babel-R-construct-graphics-device-call
-                                    graphics-file params))
-                             inside
-                             (list "},error=function(e){plot(x=-1:1, y=-1:1, type='n', xlab='', ylab='', axes=FALSE); text(x=0, y=0, labels=e$message, col='red'); paste('ERROR', e$message, sep=' : ')}); dev.off()"))
-                          inside)
-                        "\n")))
-          (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* ((lengths (mapcar 'length (org-remove-if-not 'sequencep value)))
-            (max (if lengths (apply 'max lengths) 0))
-            (min (if lengths (apply 'min lengths) 0)))
-        ;; Ensure VALUE has an orgtbl structure (depth of at least 2).
-        (unless (listp (car value)) (setq value (list value)))
-       (let ((file (orgtbl-to-tsv value '(:fmt org-babel-R-quote-tsv-field)))
-             (header (if (or (eq (nth 1 value) 'hline) colnames-p)
-                         "TRUE" "FALSE"))
-             (row-names (if rownames-p "1" "NULL")))
-         (if (= max min)
-             (format ob-R-transfer-variable-table-with-header
-                     name file header row-names)
-           (format ob-R-transfer-variable-table-without-header
-                   name file header row-names max))))
-    (cond ((integerp value) (format "%s <- %s" name (concat (number-to-string value) "L")))
-         ((floatp   value) (format "%s <- %s" name value))
-         ((stringp  value) (format "%s <- %S" name (org-no-properties value)))
-         (t                (format "%s <- %S" name (prin1-to-string 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 (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
-         (when (get-buffer session)
-           ;; Session buffer exists, but with dead process
-           (set-buffer session))
-         (require 'ess) (R)
-         (let ((R-proc (get-process (or ess-local-process-name
-                                        ess-current-process-name))))
-           (while (process-get R-proc 'callbacks)
-             (ess-wait-for-process R-proc)))
-         (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))
-
-(defvar org-babel-R-graphics-devices
-  '((:bmp "bmp" "filename")
-    (:jpg "jpeg" "filename")
-    (:jpeg "jpeg" "filename")
-    (:tikz "tikz" "file")
-    (:tiff "tiff" "filename")
-    (:png "png" "filename")
-    (:svg "svg" "file")
-    (:pdf "pdf" "file")
-    (:ps "postscript" "file")
-    (:postscript "postscript" "file"))
-  "An alist mapping graphics file types to R functions.
-
-Each member of this list is a list with three members:
-1. the file extension of the graphics file, as an elisp :keyword
-2. the R graphics device function to call to generate such a file
-3. the name of the argument to this function which specifies the
-   file to write to (typically \"file\" or \"filename\")")
-
-(defun org-babel-R-construct-graphics-device-call (out-file params)
-  "Construct the call to the graphics device."
-  (let* ((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)))
-        (device-info (or (assq (intern (concat ":" device))
-                               org-babel-R-graphics-devices)
-                          (assq :png org-babel-R-graphics-devices)))
-        (extra-args (cdr (assq :R-dev-args params))) filearg args)
-    (setq device (nth 1 device-info))
-    (setq filearg (nth 2 device-info))
-    (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); tryCatch({"
-           device filearg out-file args
-           (if extra-args "," "") (or extra-args ""))))
-
-(defconst org-babel-R-eoe-indicator "'org_babel_R_eoe'")
-(defconst org-babel-R-eoe-output "[1] \"org_babel_R_eoe\"")
-
-(defconst 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\")"
-  "A template for an R command to evaluate a block of code and write the result to a file.
-
-Has four %s escapes to be filled in:
-1. Row names, \"TRUE\" or \"FALSE\"
-2. Column names, \"TRUE\" or \"FALSE\"
-3. The code to be run (must be an expression, not a statement)
-4. The name of the file to write to")
-
-(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))))
-
-(defvar ess-eval-visibly-p)
-
-(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/.emacs.d/elisp/org/ob-abc.el b/.emacs.d/elisp/org/ob-abc.el
deleted file mode 100644 (file)
index a980b02..0000000
+++ /dev/null
@@ -1,94 +0,0 @@
-;;; ob-abc.el --- org-babel functions for template evaluation
-
-;; Copyright (C) Free Software Foundation
-
-;; Author: William Waites
-;; Keywords: literate programming, music
-;; Homepage: http://www.tardis.ed.ac.uk/wwaites
-;; Version: 0.01
-
-;;; License:
-
-;; This program is free software; you can redistribute it and/or modify
-;; it under the terms of the GNU General Public License as published by
-;; the Free Software Foundation; either version 3, or (at your option)
-;; any later version.
-;;
-;; This program is distributed in the hope that it will be useful,
-;; but WITHOUT ANY WARRANTY; without even the implied warranty of
-;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-;; GNU General Public License for more details.
-;;
-;; You should have received a copy of the GNU General Public License
-;; along with GNU Emacs; see the file COPYING.  If not, write to the
-;; Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
-;; Boston, MA 02110-1301, USA.
-
-;;; Commentary:
-
-;;; This file adds support to Org Babel for music in ABC notation.
-;;; It requires that the abcm2ps program is installed.
-;;; See http://moinejf.free.fr/
-
-(require 'ob)
-
-;; optionally define a file extension for this language
-(add-to-list 'org-babel-tangle-lang-exts '("abc" . "abc"))
-
-;; optionally declare default header arguments for this language
-(defvar org-babel-default-header-args:abc
-  '((:results . "file") (:exports . "results"))
-  "Default arguments to use when evaluating an ABC source block.")
-
-(defun org-babel-expand-body:abc (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:abc (body params)
-  "Execute a block of ABC code with org-babel.  This function is
-   called by `org-babel-execute-src-block'"
-  (message "executing Abc source code block")
-  (let* ((result-params (split-string (or (cdr (assoc :results params)))))
-        (cmdline (cdr (assoc :cmdline params)))
-        (out-file ((lambda (el)
-                     (or el
-                         (error "abc code block requires :file header argument")))
-                   (replace-regexp-in-string "\.pdf$" ".ps" (cdr (assoc :file params)))))
-        (in-file (org-babel-temp-file "abc-"))
-        (render (concat "abcm2ps" " " cmdline
-                     " -O " (org-babel-process-file-name out-file)
-                     " " (org-babel-process-file-name in-file))))
-    (with-temp-file in-file (insert (org-babel-expand-body:abc body params)))
-    (org-babel-eval render "")
-    ;;; handle where abcm2ps changes the file name (to support multiple files
-    (when (or (string= (file-name-extension out-file) "eps")
-             (string= (file-name-extension out-file) "svg"))
-      (rename-file (concat
-                   (file-name-sans-extension out-file) "001."
-                   (file-name-extension out-file))
-                  out-file t))
-    ;;; if we were asked for a pdf...
-    (when (string= (file-name-extension (cdr (assoc :file params))) "pdf")
-      (org-babel-eval (concat "ps2pdf" " " out-file " " (cdr (assoc :file params))) ""))
-    ;;; indicate that the file has been written
-    nil))
-
-;; This function should be used to assign any variables in params in
-;; the context of the session environment.
-(defun org-babel-prep-session:abc (session params)
-  "Return an error because abc does not support sessions."
-  (error "ABC does not support sessions"))
-
-(provide 'ob-abc)
-;;; ob-abc.el ends here
diff --git a/.emacs.d/elisp/org/ob-asymptote.el b/.emacs.d/elisp/org/ob-asymptote.el
deleted file mode 100644 (file)
index ca58ecb..0000000
+++ /dev/null
@@ -1,147 +0,0 @@
-;;; ob-asymptote.el --- org-babel functions for asymptote evaluation
-
-;; Copyright (C) 2009-2015 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))
-
-(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/.emacs.d/elisp/org/ob-awk.el b/.emacs.d/elisp/org/ob-awk.el
deleted file mode 100644 (file)
index eb03b46..0000000
+++ /dev/null
@@ -1,112 +0,0 @@
-;;; ob-awk.el --- org-babel functions for awk evaluation
-
-;; Copyright (C) 2011-2015 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)
-  "Expand BODY according to PARAMS, return the expanded 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 (let ((file (org-babel-temp-file "awk-")))
-                      (with-temp-file file (insert full-body)) file))
-        (stdin (let ((stdin (cdr (assoc :stdin params))))
-                  (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))))
-         (cmd (mapconcat #'identity
-                        (append
-                         (list org-babel-awk-command
-                               "-f" code-file cmd-line)
-                         (mapcar (lambda (pair)
-                                   (format "-v %s='%s'"
-                                           (cadr pair)
-                                           (org-babel-awk-var-to-awk
-                                            (cddr pair))))
-                                 (org-babel-get-header params :var))
-                         (list in-file))
-                        " ")))
-    (org-babel-reassemble-table
-     (let ((results
-            (cond
-             (stdin (with-temp-buffer
-                      (call-process-shell-command cmd stdin (current-buffer))
-                      (buffer-string)))
-             (t (org-babel-eval cmd "")))))
-       (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)))))
-     (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)))))
-
-(provide 'ob-awk)
-
-
-
-;;; ob-awk.el ends here
diff --git a/.emacs.d/elisp/org/ob-calc.el b/.emacs.d/elisp/org/ob-calc.el
deleted file mode 100644 (file)
index 5dec244..0000000
+++ /dev/null
@@ -1,108 +0,0 @@
-;;; ob-calc.el --- org-babel functions for calc code evaluation
-
-;; Copyright (C) 2010-2015 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)
-
-(defvar org--var-syms) ; Dynamically scoped from org-babel-execute:calc
-
-(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)))
-        (org--var-syms (mapcar #'car vars))
-        (var-names (mapcar #'symbol-name org--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 (let ((res (calc-eval line)))
-                    (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)))))))))
-                  ))))))
-     (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)))))
-
-(defun org-babel-calc-maybe-resolve-var (el)
-  (if (consp el)
-      (if (and (equal 'var (car el)) (member (cadr el) org--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/.emacs.d/elisp/org/ob-clojure.el b/.emacs.d/elisp/org/ob-clojure.el
deleted file mode 100644 (file)
index 68f748c..0000000
+++ /dev/null
@@ -1,115 +0,0 @@
-;;; ob-clojure.el --- org-babel functions for clojure evaluation
-
-;; Copyright (C) 2009-2015 Free Software Foundation, Inc.
-
-;; Author: Joel Boehland, Eric Schulte, Oleh Krehel
-;;
-;; 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
-
-;; Requirements:
-
-;; - clojure (at least 1.2.0)
-;; - clojure-mode
-;; - either cider or SLIME
-
-;; For Cider, see https://github.com/clojure-emacs/cider
-
-;; For SLIME, 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)
-(eval-when-compile
-  (require 'cl))
-
-(declare-function nrepl-dict-get "ext:nrepl-client" (dict key))
-(declare-function nrepl-sync-request:eval "ext:nrepl-client" (input &optional ns session))
-(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)))
-
-(defcustom org-babel-clojure-backend
-  (cond ((featurep 'cider) 'cider)
-       (t 'slime))
-  "Backend used to evaluate Clojure code blocks."
-  :group 'org-babel
-  :type '(choice
-         (const :tag "cider" cider)
-         (const :tag "SLIME" slime)))
-
-(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))))
-    (if (or (member "code" result-params)
-           (member "pp" result-params))
-       (format "(clojure.pprint/pprint (do %s))" body)
-      body)))
-
-(defun org-babel-execute:clojure (body params)
-  "Execute a block of Clojure code with Babel."
-  (let ((expanded (org-babel-expand-body:clojure body params))
-       result)
-    (case org-babel-clojure-backend
-      (cider
-       (require 'cider)
-       (let ((result-params (cdr (assoc :result-params params))))
-        (setq result
-              (nrepl-dict-get
-               (nrepl-sync-request:eval expanded)
-               (if (or (member "output" result-params)
-                       (member "pp" result-params))
-                   "out"
-                 "value")))))
-      (slime
-       (require 'slime)
-       (with-temp-buffer
-        (insert expanded)
-        (setq result
-              (slime-eval
-               `(swank:eval-and-grab-output
-                 ,(buffer-substring-no-properties (point-min) (point-max)))
-               (cdr (assoc :package params)))))))
-    (org-babel-result-cond (cdr (assoc :result-params params))
-      result
-      (condition-case nil (org-babel-script-escape result)
-       (error result)))))
-
-(provide 'ob-clojure)
-
-;;; ob-clojure.el ends here
diff --git a/.emacs.d/elisp/org/ob-comint.el b/.emacs.d/elisp/org/ob-comint.el
deleted file mode 100644 (file)
index afbbf84..0000000
+++ /dev/null
@@ -1,163 +0,0 @@
-;;; ob-comint.el --- org-babel functions for interaction with comint buffers
-
-;; Copyright (C) 2009-2015 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))
-  `(progn
-     (unless (org-babel-comint-buffer-livep ,buffer)
-       (error "Buffer %s does not exist or has no process" ,buffer))
-     (save-match-data
-       (with-current-buffer ,buffer
-        (let ((comint-input-filter (lambda (input) nil)))
-          ,@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 (nth 0 meta))
-       (eoe-indicator (nth 1 meta))
-       (remove-echo (nth 2 meta))
-       (full-body (nth 3 meta)))
-    `(org-babel-comint-in-buffer ,buffer
-       (let* ((string-buffer "")
-             (comint-output-filter-functions
-              (cons (lambda (text) (setq string-buffer (concat string-buffer text)))
-                    comint-output-filter-functions))
-             dangling-text raw)
-        ;; 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 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 (sexp 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 (= (aref string (1- (length string))) ?\n) 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/.emacs.d/elisp/org/ob-coq.el b/.emacs.d/elisp/org/ob-coq.el
deleted file mode 100644 (file)
index 0147786..0000000
+++ /dev/null
@@ -1,77 +0,0 @@
-;;; ob-coq.el --- org-babel functions for Coq
-
-;; Copyright (C) 2010-2015 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:
-
-;; Rudimentary support for evaluating Coq code blocks.  Currently only
-;; session evaluation is supported.  Requires both coq.el and
-;; coq-inferior.el, both of which are distributed with Coq.
-;;
-;; http://coq.inria.fr/
-
-;;; Code:
-(require 'ob)
-
-(declare-function run-coq "ext:coq-inferior.el" (cmd))
-(declare-function coq-proc "ext:coq-inferior.el" ())
-
-(defvar org-babel-coq-buffer "*coq*"
-  "Buffer in which to evaluate coq code blocks.")
-
-(defvar org-babel-coq-eoe "org-babel-coq-eoe")
-
-(defun org-babel-coq-clean-prompt (string)
-  (if (string-match "^[^[:space:]]+ < " string)
-      (substring string 0 (match-beginning 0))
-    string))
-
-(defun org-babel-execute:coq (body params)
-  (let ((full-body (org-babel-expand-body:generic body params))
-       (session (org-babel-coq-initiate-session))
-       (pt (lambda ()
-             (marker-position
-              (process-mark (get-buffer-process (current-buffer)))))))
-    (org-babel-coq-clean-prompt
-     (org-babel-comint-in-buffer session
-       (let ((start (funcall pt)))
-        (with-temp-buffer
-          (insert full-body)
-          (comint-send-region (coq-proc) (point-min) (point-max))
-          (comint-send-string (coq-proc)
-           (if (string= (buffer-substring (- (point-max) 1) (point-max)) ".")
-               "\n"
-             ".\n")))
-        (while (equal start (funcall pt)) (sleep-for 0.1))
-        (buffer-substring start (funcall pt)))))))
-
-(defun org-babel-coq-initiate-session ()
-  "Initiate a coq session.
-If there is not a current inferior-process-buffer in SESSION then
-create one.  Return the initialized session."
-  (unless (fboundp 'run-coq)
-    (error "`run-coq' not defined, load coq-inferior.el"))
-  (save-window-excursion (run-coq "coqtop"))
-  (sit-for 0.1)
-  (get-buffer org-babel-coq-buffer))
-
-(provide 'ob-coq)
diff --git a/.emacs.d/elisp/org/ob-core.el b/.emacs.d/elisp/org/ob-core.el
deleted file mode 100644 (file)
index f642b18..0000000
+++ /dev/null
@@ -1,3102 +0,0 @@
-;;; ob-core.el --- working with code blocks in org-mode
-
-;; Copyright (C) 2009-2015 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))
-;; dynamically scoped for tramp
-(defvar org-babel-call-process-region-original nil)
-(defvar org-src-lang-modes)
-(defvar org-babel-library-of-babel)
-(declare-function show-all "outline" ())
-(declare-function org-every "org" (pred seq))
-(declare-function org-remove-indentation "org" (code &optional n))
-(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 code edit-buffer-name))
-(declare-function org-edit-src-exit "org-src"  ())
-(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))
-(declare-function org-element-context "org-element" (&optional element))
-(declare-function org-element-type "org-element" (element))
-(declare-function org-element-at-point "org-element" ())
-(declare-function org-element-property "org-element" (property element))
-(declare-function org-every "org" (pred seq))
-(declare-function org-macro-escape-arguments "org-macro" (&rest args))
-
-(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.
-It should be \"RESULTS\".  However any capitalization may be
-used."
-  :group 'org-babel
-  :version "24.4"
-  :package-version '(Org . "8.0")
-  :type 'string
-  :safe (lambda (v)
-         (and (stringp v)
-              (eq (compare-strings "RESULTS" nil nil v nil nil t)
-                  t))))
-
-(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)
-
-(defcustom org-babel-inline-result-wrap "=%s="
-  "Format string used to wrap inline results.
-This string must include a \"%s\" which will be replaced by the results."
-  :group 'org-babel
-  :type 'string)
-(put 'org-babel-inline-result-wrap
-     'safe-local-variable
-     (lambda (value)
-       (and (stringp value)
-           (string-match-p "%s" value))))
-
-(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-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)
-   "\\(\\|\\[[ \t]*\\(.*?\\)\\]\\)"
-   ;; (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"
- (save-excursion
-    (let ((datum (org-element-context)))
-      (when (eq (org-element-type datum) 'inline-src-block)
-       (goto-char (org-element-property :begin datum))
-       (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
-    (let ((datum (org-element-context)))
-      (when (eq (org-element-type datum) 'inline-babel-call)
-       (goto-char (org-element-property :begin datum))))
-    (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 block-head)."
-  (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-named-src-block-regexp-for-name))
-           (setq name (org-match-string-no-properties 9))))
-      ;; inline source block
-      (when (org-babel-get-inline-src-block-matches)
-       (setq head (match-beginning 0))
-       (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
-      (setf (nth 2 info) (org-babel-generate-file-param name (nth 2 info))))
-    (when info (append info (list name indent head)))))
-
-(defvar org-babel-exp-reference-buffer nil
-  "Buffer containing original contents of the exported buffer.
-This is used by Babel to resolve references in source blocks.
-Its value is dynamically bound during export.")
-
-(defmacro org-babel-check-confirm-evaluate (info &rest body)
-  "Evaluate BODY with special execution confirmation variables set.
-
-Specifically; NOEVAL will indicate if evaluation is allowed,
-QUERY will indicate if a user query is required, CODE-BLOCK will
-hold the language of the code block, and BLOCK-NAME will hold the
-name of the code block."
-  (declare (indent defun))
-  (org-with-gensyms
-      (lang block-body headers name head eval eval-no export eval-no-export)
-    `(let* ((,lang           (nth 0 ,info))
-           (,block-body     (nth 1 ,info))
-           (,headers        (nth 2 ,info))
-           (,name           (nth 4 ,info))
-           (,head           (nth 6 ,info))
-           (,eval           (or (cdr  (assoc :eval   ,headers))
-                                (when (assoc :noeval ,headers) "no")))
-           (,eval-no        (or (equal ,eval "no")
-                                (equal ,eval "never")))
-           (,export         org-babel-exp-reference-buffer)
-           (,eval-no-export (and ,export (or (equal ,eval "no-export")
-                                             (equal ,eval "never-export"))))
-           (noeval          (or ,eval-no ,eval-no-export))
-           (query           (or (equal ,eval "query")
-                                (and ,export (equal ,eval "query-export"))
-                                (if (functionp org-confirm-babel-evaluate)
-                                    (save-excursion
-                                      (goto-char ,head)
-                                      (funcall org-confirm-babel-evaluate
-                                               ,lang ,block-body))
-                                  org-confirm-babel-evaluate)))
-           (code-block      (if ,info (format  " %s "  ,lang) " "))
-           (block-name      (if ,name (format " (%s) " ,name) " ")))
-       ,@body)))
-
-(defsubst org-babel-check-evaluate (info)
-  "Check if code block INFO should be evaluated.
-Do not query the user."
-  (org-babel-check-confirm-evaluate info
-    (not (when noeval
-          (message "Evaluation of this%scode-block%sis disabled."
-                    code-block block-name)))))
-
- ;; dynamically scoped for asynchronous export
-(defvar org-babel-confirm-evaluate-answer-no)
-
-(defsubst org-babel-confirm-evaluate (info)
-  "Confirm evaluation of the code block INFO.
-
-If the variable `org-babel-confirm-evaluate-answer-no' is bound
-to a non-nil value, auto-answer with \"no\".
-
-This query can also 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."
-  (org-babel-check-confirm-evaluate info
-    (not (when query
-          (unless
-              (and (not (org-bound-and-true-p
-                         org-babel-confirm-evaluate-answer-no))
-                   (yes-or-no-p
-                    (format "Evaluate this%scode block%son your system? "
-                            code-block block-name)))
-            (message "Evaluation of this%scode-block%sis aborted."
-                      code-block block-name))))))
-
-;;;###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)))
-
-(defmacro org-babel-when-in-src-block (&rest body)
-  "Execute BODY if point is in a source block and return t.
-
-Otherwise do nothing and return nil."
-  `(if (or (org-babel-where-is-src-block-head)
-           (org-babel-get-inline-src-block-matches))
-       (progn
-        ,@body
-        t)
-     nil))
-
-(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)
-  (org-babel-when-in-src-block
-   (org-babel-eval-wipe-error-buffer)
-   (org-babel-execute-src-block current-prefix-arg)))
-
-;;;###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))
-         (funcall printf "Properties:\n")
-         (funcall printf "\t:header-args \t%s\n" (org-entry-get (point) "header-args" t))
-         (funcall printf "\t:header-args:%s \t%s\n" lang (org-entry-get (point) (concat "header-args:" lang) t))
-
-         (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 (format "%s" (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)
-  (org-babel-when-in-src-block
-   (org-babel-expand-src-block current-prefix-arg)))
-
-;;;###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)
-  (org-babel-when-in-src-block
-   (org-babel-load-in-session current-prefix-arg)))
-
-(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-switch-to-session'."
-  (interactive)
-  (org-babel-when-in-src-block
-   (org-babel-switch-to-session current-prefix-arg)))
-
-(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      . ((yes no no-export strip-export never-export eval never
-                       query)))
-    (exports   . ((code results both none)))
-    (epilogue   . :any)
-    (file      . :any)
-    (file-desc  . :any)
-    (file-ext   . :any)
-    (hlines    . ((no yes)))
-    (mkdirp    . ((yes no)))
-    (no-expand)
-    (noeval)
-    (noweb     . ((yes no tangle no-export strip-export)))
-    (noweb-ref . :any)
-    (noweb-sep  . :any)
-    (output-dir . :any)
-    (padline   . ((yes no)))
-    (post       . :any)
-    (prologue   . :any)
-    (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)))
-    (tangle-mode . ((#o755 #o555 #o444 :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.")
-
-(defconst org-babel-safe-header-args
-  '(:cache :colnames :comments :exports :epilogue :hlines :noeval
-          :noweb :noweb-ref :noweb-sep :padline :prologue :rownames
-          :sep :session :tangle :wrap
-          (:eval . ("never" "query"))
-          (:results . (lambda (str) (not (string-match "file" str)))))
-  "A list of safe header arguments for babel source blocks.
-
-The list can have entries of the following forms:
-- :ARG                     -> :ARG is always a safe header arg
-- (:ARG . (VAL1 VAL2 ...)) -> :ARG is safe as a header arg if it is
-                              `equal' to one of the VALs.
-- (:ARG . FN)              -> :ARG is safe as a header arg if the function FN
-                              returns non-nil.  FN is passed one
-                              argument, the value of the header arg
-                              (as a string).")
-
-(defmacro org-babel-header-args-safe-fn (safe-list)
-  "Return a function that determines whether a list of header args are safe.
-
-Intended usage is:
-\(put 'org-babel-default-header-args 'safe-local-variable
- (org-babel-header-args-safe-p org-babel-safe-header-args)
-
-This allows org-babel languages to extend the list of safe values for
-their `org-babel-default-header-args:foo' variable.
-
-For the format of SAFE-LIST, see `org-babel-safe-header-args'."
-  `(lambda (value)
-     (and (listp value)
-         (org-every
-          (lambda (pair)
-            (and (consp pair)
-                 (org-babel-one-header-arg-safe-p pair ,safe-list)))
-          value))))
-
-(defvar org-babel-default-header-args
-  '((:session . "none") (:results . "replace") (:exports . "code")
-    (:cache . "no") (:noweb . "no") (:hlines . "no") (:tangle . "no"))
-  "Default arguments to use when evaluating a source block.")
-(put 'org-babel-default-header-args 'safe-local-variable
-     (org-babel-header-args-safe-fn org-babel-safe-header-args))
-
-(defvar org-babel-default-inline-header-args
-  '((:session . "none") (:results . "replace")
-    (:exports . "results") (:hlines . "yes"))
-  "Default arguments to use when evaluating an inline source block.")
-(put 'org-babel-default-inline-header-args 'safe-local-variable
-     (org-babel-header-args-safe-fn org-babel-safe-header-args))
-
-(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-all-langs nil
-  "Raise errors when noweb references don't resolve.
-Also see `org-babel-noweb-error-langs' to control noweb errors on
-a language by language bases.")
-
-(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.  Also see `org-babel-noweb-error-all-langs'
-to raise errors for all languages.")
-
-(defvar org-babel-hash-show 4
-  "Number of initial characters to show of a hidden results hash.")
-
-(defvar org-babel-hash-show-time nil
-  "Non-nil means 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 (&optional name)
-  "This generates a regexp used to match a src block named NAME.
-If NAME is nil, match any name.  Matched name is then put in
-match group 9.  Other match groups are defined in
-`org-babel-src-block-regexp'."
-  (concat org-babel-src-name-regexp
-         (concat (if name (regexp-quote name) "\\(?9:.*?\\)") "[ \t]*" )
-         "\\(?:\n[ \t]*#\\+\\S-+:.*\\)*?"
-         "\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)
-(defvar org-babel-current-src-block-location nil
-  "Marker pointing to the src block currently being executed.
-This may also point to a call line or an inline code block.  If
-multiple blocks are being executed (e.g., in chained execution
-through use of the :var header argument) this marker points to
-the outer-most code block.")
-
-;;;###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* ((org-babel-current-src-block-location
-         (or org-babel-current-src-block-location
-             (nth 6 info)
-             (org-babel-where-is-src-block-head)
-             ;; inline src block
-             (and (org-babel-get-inline-src-block-matches)
-                  (match-beginning 0))))
-        (info (if info
-                  (copy-tree info)
-                (org-babel-get-src-block-info)))
-        (merged-params (org-babel-merge-params (nth 2 info) params)))
-    (when (org-babel-check-evaluate
-          (let ((i info)) (setf (nth 2 i) merged-params) i))
-      (let* ((params (if params
-                        (org-babel-process-params merged-params)
-                      (nth 2 info)))
-            (cachep (and (not arg) (cdr (assoc :cache params))
-                          (string= "yes" (cdr (assoc :cache params)))))
-            (new-hash (when cachep (org-babel-sha1-hash info)))
-            (old-hash (when cachep (org-babel-current-result-hash)))
-            (cache-current-p (and (not arg) new-hash
-                                  (equal new-hash old-hash))))
-       (cond
-        (cache-current-p
-         (save-excursion ;; return cached result
-           (goto-char (org-babel-where-is-src-block-result nil info))
-           (forward-line)
-           (skip-chars-forward " \t")
-           (let ((result (org-babel-read-result)))
-             (message (replace-regexp-in-string
-                       "%" "%%" (format "%S" result))) result)))
-        ((org-babel-confirm-evaluate
-          (let ((i info)) (setf (nth 2 i) merged-params) i))
-         (let* ((lang (nth 0 info))
-                (result-params (cdr (assoc :result-params params)))
-                (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 ;; for tramp handler
-                 (or (org-bound-and-true-p
-                      org-babel-call-process-region-original)
-                     (symbol-function 'call-process-region)))
-                (indent (nth 5 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))))
-                 (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 nil))
-                   (setq result
-                         (let ((result (funcall cmd body params)))
-                            (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)))
-                   ;; 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))))
-                   ;; Possibly perform post process provided its appropriate.
-                   (when (cdr (assoc :post params))
-                     (let ((*this* (if (cdr (assoc :file params))
-                                       (org-babel-result-to-file
-                                        (cdr (assoc :file params))
-                                        (when (assoc :file-desc params)
-                                          (or (cdr (assoc :file-desc params))
-                                              result)))
-                                     result)))
-                       (setq result (org-babel-ref-resolve
-                                     (cdr (assoc :post params))))
-                       (when (cdr (assoc :file params))
-                         (setq result-params
-                               (remove "file" result-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."
-  (let ((pro (cdr (assoc :prologue params)))
-       (epi (cdr (assoc :epilogue params))))
-    (mapconcat #'identity
-              (append (when pro (list pro))
-                      var-lines
-                      (list body)
-                      (when epi (list epi)))
-              "\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 (org-called-interactively-p 'any)
-       (org-edit-src-code
-        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 (&optional header-arg value)
-  "Insert a header argument selecting from lists of common args and values."
-  (interactive)
-  (let* ((info (org-babel-get-src-block-info 'light))
-        (lang (car info))
-        (begin (nth 6 info))
-        (lang-headers (intern (concat "org-babel-header-args:" lang)))
-        (headers (org-babel-combine-header-arg-lists
-                  org-babel-common-header-args-w-values
-                  (when (boundp lang-headers) (eval lang-headers))))
-        (header-arg (or header-arg
-                        (org-icompleting-read
-                         "Header Arg: "
-                         (mapcar
-                          (lambda (header-spec) (symbol-name (car header-spec)))
-                          headers))))
-        (vals (cdr (assoc (intern header-arg) headers)))
-        (value (or value
-                   (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 ""))))))
-    (save-excursion
-      (goto-char begin)
-      (goto-char (point-at-eol))
-      (unless (= (char-before (point)) ?\ ) (insert " "))
-      (insert ":" header-arg) (when value (insert " " value)))))
-
-;; 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 (if (not info)
-                  (user-error "No src code block at point")
-                (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)
-
-(defvar org-src-window-setup)
-
-;;;###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)))
-
-;;;###autoload
-(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))
-       (unwind-protect (progn ,@body)
-        (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)
-
-(defun org-babel-active-location-p ()
-  (memq (org-element-type (save-match-data (org-element-context)))
-       '(babel-call inline-babel-call inline-src-block src-block)))
-
-;;;###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 'light)))
-    (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* ((case-fold-search t)
-           (,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)
-          (when (org-babel-active-location-p)
-            (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* ((case-fold-search t)
-           (,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)
-          (when (org-babel-active-location-p)
-            (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)
-          (when (org-babel-active-location-p)
-            (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)
-          (when (org-babel-active-location-p)
-            (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))))))
-          ;; expanded body
-          (lang (nth 0 info))
-          (params (nth 2 info))
-          (body (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))))))
-      (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))) ":")
-                         expanded))
-             (hash (sha1 it)))
-        (when (org-called-interactively-p 'interactive) (message hash))
-        hash))))
-
-(defun org-babel-current-result-hash (&optional info)
-  "Return the current in-buffer hash."
-  (org-babel-where-is-src-block-result nil info)
-  (org-no-properties (match-string 5)))
-
-(defun org-babel-set-current-result-hash (hash info)
-  "Set the current in-buffer hash to HASH."
-  (org-babel-where-is-src-block-result nil info)
-  (save-excursion (goto-char (match-beginning 5))
-                 (mapc #'delete-overlay (overlays-at (point)))
-                 (forward-char org-babel-hash-show)
-                 (mapc #'delete-overlay (overlays-at (point)))
-                 (replace-match hash nil nil nil 5)
-                 (goto-char (point-at-bol))
-                 (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 a list of association lists of source block params
-specified in the properties of the current outline entry."
-  (save-match-data
-    (list
-     ;; DEPRECATED header arguments specified as separate property at
-     ;; point of definition.
-     (org-babel-parse-multiple-vars
-      (delq nil
-           (mapcar
-            (lambda (header)
-              (let* ((arg (symbol-name (car header)))
-                     (val (org-entry-get (point) arg t)))
-                (and val
-                     (cons (intern (concat ":" arg))
-                           (org-babel-read val)))))
-            (org-babel-combine-header-arg-lists
-             org-babel-common-header-args-w-values
-             (let ((sym (intern (concat "org-babel-header-args:" lang))))
-               (and (boundp sym) (symbol-value sym)))))))
-     ;; header arguments specified with the header-args property at
-     ;; point of call.
-     (org-babel-parse-header-arguments
-      (org-entry-get org-babel-current-src-block-location
-                    "header-args"
-                    'inherit))
-     (and lang  ; language-specific header arguments at point of call
-         (org-babel-parse-header-arguments
-          (org-entry-get org-babel-current-src-block-location
-                         (concat "header-args:" lang)
-                         'inherit))))))
-
-(defvar org-src-preserve-indentation) ;; declare defcustom from org-src
-(defun org-babel-parse-src-block-match ()
-  "Parse the results from a match of the `org-babel-src-block-regexp'."
-  (let* ((block-indentation (string-width (match-string 1)))
-        (lang (org-match-string-no-properties 2))
-         (lang-headers (intern (concat "org-babel-default-header-args:" lang)))
-        (switches (match-string 3))
-         (body (let* ((body (org-match-string-no-properties 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)))
-         (apply #'org-babel-merge-params
-                org-babel-default-header-args
-                (when (boundp lang-headers) (eval lang-headers))
-                (append
-                 (org-babel-params-from-properties lang)
-                 (list (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)))
-          (apply #'org-babel-merge-params
-                org-babel-default-inline-header-args
-                (if (boundp lang-headers) (eval lang-headers) nil)
-                (append
-                 (org-babel-params-from-properties lang)
-                 (list (org-babel-parse-header-arguments
-                        (org-no-properties (or (match-string 4) ""))))))
-         nil)))
-
-(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)))
-           (let ((raw (org-babel-balanced-split arg-string '((32 9) . 58))))
-              (cons (car raw) (mapcar (lambda (r) (concat ":" r)) (cdr raw)))))))))
-
-(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."
-  (remq '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
-rownames, and the `cdr' of which contains a list of the rownames.
-Note: this function removes any hlines in TABLE."
-  (let* ((table (org-babel-del-hlines table))
-        (rownames (funcall (lambda ()
-                             (let ((tp table))
-                               (mapcar
-                                (lambda (row)
-                                  (prog1
-                                      (pop (car tp))
-                                    (setq tp (cdr tp))))
-                                table))))))
-    (cons table rownames)))
-
-(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)
-      (let ((table (if (and rownames (= (length table) (length rownames)))
-                       (org-babel-put-rownames table rownames) table)))
-        (if (and colnames (listp (car table)) (= (length (car table))
-                                                 (length colnames)))
-            (org-babel-put-colnames table colnames) 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.  Also set
-match-data relatively to `org-babel-src-block-regexp', which see.
-If the point is not on a source block then return nil."
-  (let ((element (org-element-at-point)))
-    (when (eq (org-element-type element) 'src-block)
-      (let ((end (org-element-property :end element)))
-       (org-with-wide-buffer
-        ;; Ensure point is not on a blank line after the block.
-        (beginning-of-line)
-        (skip-chars-forward " \r\t\n" end)
-        (when (< (point) end)
-          (prog1 (goto-char (org-element-property :post-affiliated element))
-            (looking-at org-babel-src-block-regexp))))))))
-
-;;;###autoload
-(defun org-babel-goto-src-block-head ()
-  "Go to the beginning of the current code block."
-  (interactive)
-  (let ((head (org-babel-where-is-src-block-head)))
-     (if head (goto-char head) (error "Not currently in a code block"))))
-
-;;;###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
-    (goto-char (point-min))
-    (ignore-errors
-      (org-next-block 1 nil (org-babel-named-src-block-regexp-for-name name)))))
-
-(defun org-babel-src-block-names (&optional file)
-  "Returns the names of source blocks in FILE or the current buffer."
-  (when file (find-file file))
-  (save-excursion
-    (goto-char (point-min))
-    (let ((re (org-babel-named-src-block-regexp-for-name))
-         names)
-      (while (ignore-errors (org-next-block 1 nil re))
-       (push (org-match-string-no-properties 9) 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)
-                        (looking-at org-babel-lob-one-liner-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)
-  (let ((head (org-babel-where-is-src-block-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)))))
-
-(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))
-        (start (org-babel-where-is-src-block-head))
-        (block (and start (match-string 0)))
-        (headers (and start (match-string 4)))
-        (stars (concat (make-string (or (org-current-level) 1) ?*) " "))
-        (lower-case-p (and block
-                           (let (case-fold-search)
-                             (org-string-match-p "#\\+begin_src" block)))))
-    (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 (funcall (if lower-case-p 'downcase 'upcase) "#+end_src\n")
-                       (if arg stars indent) "\n"
-                       indent (funcall (if lower-case-p 'downcase 'upcase) "#+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 #'symbol-name
-                          (delete-dups
-                           (append (mapcar #'car org-babel-load-languages)
-                                   (mapcar (lambda (el) (intern (car el)))
-                                           org-src-lang-modes))))))
-           (body (delete-and-extract-region
-                  (if (org-region-active-p) (mark) (point)) (point))))
-       (insert (concat (if (looking-at "^") "" "\n")
-                       (if arg (concat stars "\n") "")
-                       (funcall (if lower-case-p 'downcase 'upcase) "#+begin_src ")
-                       lang "\n"
-                       body
-                       (if (or (= (length body) 0)
-                               (string-match "[\r\n]$" body)) "" "\n")
-                       (funcall (if lower-case-p 'downcase 'upcase) "#+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 (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))
-                (and
-                 (not name)
-                 (progn ;; unnamed results line already exists
-                   (catch 'non-comment
-                     (while (re-search-forward "[^ \f\t\n\r\v]" nil t)
-                       (beginning-of-line 1)
-                       (cond
-                        ((looking-at (concat org-babel-result-regexp "\n"))
-                         (throw 'non-comment t))
-                        ((and (looking-at "^[ \t]*#")
-                              (not (looking-at
-                                    org-babel-lob-one-liner-regexp)))
-                         (end-of-line 1))
-                        (t (throw 'non-comment nil))))))
-                 (let ((this-hash (match-string 5)))
-                   (prog1 (point)
-                     ;; must remove and rebuild if hash!=old-hash
-                     (if (and hash (not (string= hash this-hash)))
-                         (progn
-                           (setq end (point-at-bol))
-                           (forward-line 1)
-                           (delete-region end (org-babel-result-end))
-                           (setq beg 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")))
-       (when (wholenump indent) (indent-to indent))
-       (insert (concat
-                "#+" 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)
-       (when 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-remove-indentation (match-string 4)))
-     ((or (looking-at "^[ \t]*: ") (looking-at "^[ \t]*:$"))
-      (setq result-string
-           (org-babel-trim
-            (mapconcat (lambda (line)
-                          (or (and (> (length line) 1)
-                                  (string-match "^[ \t]*: ?\\(.+\\)" line)
-                                  (match-string 1 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.  The RESULT of an inline source block usually will be
-wrapped inside a `results' macro and placed on the same line as
-the inline source block.  The macro is stripped upon export.
-Multiline and non-scalar RESULTS from inline source blocks are
-not allowed.  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
-          or inline 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 or results
-          macro, allowing them to later be replaced or removed
-          automatically.
-
-org ----- results are added inside of a \"src_org{}\" or \"#+BEGIN_SRC
-          org\" block depending on whether the current source block is
-          inline or not.  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 or
-          html export snippet depending on whether the current
-          source block is inline or not.  This is a good option
-          if your code block will output html formatted text.
-
-latex --- results are added inside of a #+BEGIN_LATEX block or
-          latex export snippet depending on whether the current
-          source block is inline or not.  This is a good option
-          if your 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 source block with the source-code language
-          set appropriately.  Also, source block inlining is
-          preserved in this case.  Note this relies on the
-          optional LANG argument.
-
-list ---- the results are rendered as a list.  This option not
-          allowed for inline src blocks.
-
-table --- the results are rendered as a table.  This option not
-          allowed for inline src blocks.
-
-INFO may provide the values of these header arguments (in the
-`header-arguments-alist' see the docstring for
-`org-babel-get-src-block-info'):
-
-:file --- the name of the file to which output should be written.
-
-:wrap --- the effect is similar to `latex' in RESULT-PARAMS but
-          using the argument supplied to specify the export block
-          or snippet type."
-
-  (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))
-                 (org-babel-remove-inline-result)
-                 (insert " ")
-                 (point))))
-            (existing-result
-             (unless inlinep
-               (org-babel-where-is-src-block-result t info hash indent)))
-            (bad-inline-p
-             (when inlinep
-               (or
-                (and (member "table" result-params) "`:results table'")
-                (and (listp result) "list result")
-                (and (org-string-match-p "\n." result) "multiline result")
-                (and (member "list" result-params) "`:results list'"))))
-            (results-switches
-             (cdr (assoc :results_switches (nth 2 info))))
-            (visible-beg (point-min-marker))
-            (visible-end (point-max-marker))
-            ;; 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 no-newlines
-                                   inline-start inline-finish)
-                           (when inlinep
-                             (setq start inline-start)
-                             (setq finish inline-finish)
-                             (setq no-newlines t))
-                           (goto-char end)
-                           (insert (concat finish (unless no-newlines "\n")))
-                           (goto-char beg)
-                           (insert (concat start (unless no-newlines "\n")))
-                           (unless no-escape
-                             (org-escape-code-in-region (min (point) end) end))
-                           (goto-char end)
-                           (unless no-newlines (goto-char (point-at-eol)))
-                           (setq end (point-marker))))
-                   (tabulablep
-                    (lambda (r)
-                      ;; Non-nil when result R can be turned into
-                      ;; a table.
-                      (and (listp r)
-                           (null (cdr (last r)))
-                           (org-every
-                            (lambda (e) (or (atom e) (null (cdr (last e)))))
-                            result)))))
-               ;; insert results based on type
-               (cond
-                ;; Do nothing for an empty result.
-                ((null result))
-                ;; Illegal inline result or params.
-                (bad-inline-p
-                 (error "Inline error: %s cannot be used" bad-inline-p))
-                ;; 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 (split-string result "\n" t))))
-                    '(:splicep nil :istart "- " :iend "\n")))
-                  "\n"))
-                ;; Try hard to print RESULT as a table.  Give up if
-                ;; it contains an improper list.
-                ((funcall tabulablep result)
-                 (goto-char beg)
-                 (insert (concat (orgtbl-to-orgtbl
-                                  (if (org-every
-                                       (lambda (e)
-                                         (or (eq e 'hline) (listp e)))
-                                       result)
-                                      result
-                                    (list result))
-                                  nil)
-                                 "\n"))
-                 (goto-char beg)
-                 (when (org-at-table-p) (org-table-align))
-                 (goto-char (org-table-end)))
-                ;; Print verbatim a list that cannot be turned into
-                ;; a table.
-                ((listp result) (insert (format "%s\n" result)))
-                ((member "file" result-params)
-                 (when inlinep
-                   (goto-char inlinep)
-                   (setq result (org-macro-escape-arguments result)))
-                 (insert result))
-                ((and inlinep
-                      (not (member "raw" result-params)))
-                 (goto-char inlinep)
-                 (insert (org-macro-escape-arguments
-                          (org-babel-chomp result "\n"))))
-                (t (goto-char beg) (insert result)))
-               (setq end (point-marker))
-               ;; possibly wrap result
-               (cond
-                (bad-inline-p)         ; Do nothing.
-                ((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)))
-                            nil nil (concat "{{{results(@@" name ":") "@@)}}}")))
-                ((member "html" result-params)
-                 (funcall wrap "#+BEGIN_HTML" "#+END_HTML" nil nil
-                          "{{{results(@@html:" "@@)}}}"))
-                ((member "latex" result-params)
-                 (funcall wrap "#+BEGIN_LaTeX" "#+END_LaTeX" nil nil
-                          "{{{results(@@latex:" "@@)}}}"))
-                ((member "org" result-params)
-                 (goto-char beg) (if (org-at-table-p) (org-cycle))
-                 (funcall wrap "#+BEGIN_SRC org" "#+END_SRC" nil nil
-                          "{{{results(src_org{" "})}}}"))
-                ((member "code" result-params)
-                 (let ((lang (or lang "none")))
-                   (funcall wrap (format "#+BEGIN_SRC %s%s" lang results-switches)
-                            "#+END_SRC" nil nil
-                            (format "{{{results(src_%s[%s]{" lang results-switches)
-                            "})}}}")))
-                ((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))
-                 (goto-char beg) (if (org-at-table-p) (org-cycle))
-                 (funcall wrap ":RESULTS:" ":END:" 'no-escape nil
-                          "{{{results(" ")}}}"))
-                ((and inlinep (member "file" result-params))
-                 (funcall wrap nil nil nil nil "{{{results(" ")}}}"))
-                ((and (not (funcall tabulablep result))
-                      (not (member "file" result-params)))
-                 (let ((org-babel-inline-result-wrap
-                        ;; Hard code {{{results(...)}}} on top of customization.
-                        (format "{{{results(%s)}}}" org-babel-inline-result-wrap)))
-                   (org-babel-examplify-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 keep-keyword)
-  "Remove the result of the current source block."
-  (interactive)
-  (let ((location (org-babel-where-is-src-block-result nil info)))
-    (when location
-      (save-excursion
-        (goto-char location)
-       (when (looking-at (concat org-babel-result-regexp ".*$"))
-         (delete-region
-          (if keep-keyword (1+ (match-end 0)) (1- (match-beginning 0)))
-          (progn (forward-line 1) (org-babel-result-end))))))))
-
-(defun org-babel-remove-inline-result ()
-  "Remove the result of the current inline-src-block or babel call.
-The result must be wrapped in a `results' macro to be removed.
-Leading whitespace is trimmed."
-  (interactive)
-  (let* ((el (org-element-context))
-        (post-blank (org-element-property :post-blank el)))
-    (when (memq (org-element-type el) '(inline-src-block inline-babel-call))
-      (org-with-wide-buffer
-        (goto-char (org-element-property :end el))
-        (let ((el (org-element-context)))
-         (when (and (eq (org-element-type el) 'macro)
-                    (string= (org-element-property :key el) "results"))
-           (delete-region ; And leading whitespace.
-            (- (org-element-property :begin el) post-blank)
-            (- (org-element-property :end el)
-               (org-element-property :post-blank el)))))))))
-
-(defun org-babel-remove-result-one-or-many (x)
-  "Remove the result of the current source block.
-If called with a prefix argument, remove all result blocks
-in the buffer."
-  (interactive "P")
-  (if x
-      (org-babel-map-src-blocks nil (org-babel-remove-result))
-    (org-babel-remove-result)))
-
-(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-example-region-markers nil
-  "Make true to capitalize begin/end example markers inserted by code blocks.")
-
-(define-obsolete-function-alias
-  'org-babel-examplize-region
-  'org-babel-examplify-region "25.1")
-
-(defun org-babel-examplify-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-example-region-markers
-                               (upcase str) str)))
-       (beg-bol (save-excursion (goto-char beg) (point-at-bol)))
-       (end-bol (save-excursion (goto-char end) (point-at-bol)))
-       (end-eol (save-excursion (goto-char end) (point-at-eol))))
-    (if (and (not (= end end-bol))
-            (or (funcall chars-between beg-bol beg)
-                (funcall chars-between end end-eol)))
-       (save-excursion
-         (goto-char beg)
-         (insert (format org-babel-inline-result-wrap
-                         (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 (org-remove-indentation 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
-        clearnames)
-
-    (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))
-                             (progn
-                               (push name clearnames)
-                               (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))
-                    (let ((name (car (nth variable-index vars))))
-                      (push name clearnames) ; clear out colnames
-                                             ; and rownames
-                                             ; for replace vars
-                      (prog1 (setf (cddr (nth variable-index vars))
-                                   (concat (symbol-name name) "=" (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)))))
-           (:file-ext
-            (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)))
-    ;; clear out col-names and row-names for replaced variables
-    (mapc
-     (lambda (name)
-       (mapc
-       (lambda (param)
-         (when (assoc param params)
-           (setf (cdr (assoc param params))
-                 (org-remove-if (lambda (pair) (equal (car pair) name))
-                                (cdr (assoc param params))))
-           (setf params (org-remove-if (lambda (pair) (and (equal (car pair) param)
-                                                      (null (cdr pair))))
-                                       params))))
-       (list :colname-names :rowname-names)))
-     clearnames)
-    (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 'light)))
-         (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)
-    (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
-                                             (let ((cs (org-babel-tangle-comment-links i)))
-                                                (concat (funcall c-wrap (car cs)) "\n"
-                                                        body "\n"
-                                                        (funcall c-wrap (cadr cs))))
-                                           body)))
-                              (setq expansion (cons sep (cons full expansion)))))
-                        (org-babel-map-src-blocks nil
-                         (let ((i (org-babel-get-src-block-info 'light)))
-                            (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
-                                               (let ((cs (org-babel-tangle-comment-links i)))
-                                                  (concat (funcall c-wrap (car cs)) "\n"
-                                                          body "\n"
-                                                          (funcall c-wrap (cadr cs))))
-                                             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 (or org-babel-noweb-error-all-langs
-                         (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-inner (str)
-  (let (in-single in-double backslash out)
-    (mapc
-     (lambda (ch)
-       (setq
-       out
-       (if backslash
-           (progn
-             (setq backslash nil)
-             (cond
-              ((and in-single (eq ch ?'))
-               ;; Escaped single quote inside single quoted string:
-               ;; emit just a single quote, since we've changed the
-               ;; outer quotes to double.
-               (cons ch out))
-              ((eq ch ?\")
-               ;; Escaped double quote
-               (if in-single
-                   ;; This should be interpreted as backslash+quote,
-                   ;; not an escape.  Emit a three backslashes
-                   ;; followed by a quote (because one layer of
-                   ;; quoting will be stripped by `org-babel-read').
-                   (append (list ch ?\\ ?\\ ?\\) out)
-                 ;; Otherwise we are in a double-quoted string.  Emit
-                 ;; a single escaped quote
-                 (append (list ch ?\\) out)))
-              ((eq ch ?\\)
-               ;; Escaped backslash: emit a single escaped backslash
-               (append (list ?\\ ?\\) out))
-              ;; Other: emit a quoted backslash followed by whatever
-              ;; the character was (because one layer of quoting will
-              ;; be stripped by `org-babel-read').
-              (t (append (list ch ?\\ ?\\) out))))
-         (case ch
-           (?\[ (if (or in-double in-single)
-                    (cons ?\[ out)
-                  (cons ?\( out)))
-           (?\] (if (or in-double in-single)
-                    (cons ?\] out)
-                  (cons ?\) out)))
-           (?\{ (if (or in-double in-single)
-                    (cons ?\{ out)
-                  (cons ?\( out)))
-           (?\} (if (or in-double in-single)
-                    (cons ?\} out)
-                  (cons ?\) out)))
-           (?, (if (or in-double in-single)
-                   (cons ?, out) (cons ?\s out)))
-           (?\' (if in-double
-                    (cons ?\' out)
-                  (setq in-single (not in-single)) (cons ?\" out)))
-           (?\" (if in-single
-                    (append (list ?\" ?\\) out)
-                  (setq in-double (not in-double)) (cons ?\" out)))
-           (?\\ (unless (or in-single in-double)
-                  (error "Can't handle backslash outside string in `org-babel-script-escape'"))
-                (setq backslash t)
-                out)
-           (t  (cons ch out))))))
-     (string-to-list str))
-    (when (or in-single in-double)
-      (error "Unterminated string in `org-babel-script-escape'"))
-    (apply #'string (reverse out))))
-
-(defun org-babel-script-escape (str &optional force)
-  "Safely convert tables into elisp lists."
-  (unless (stringp str)
-    (error "`org-babel-script-escape' expects a string"))
-  (let ((escaped
-        (cond
-         ((and (> (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)))))
-
-          (concat "'" (org-babel--script-escape-inner str)))
-         ((or force
-              (and (> (length str) 2)
-                   (or (and (string-equal "'" (substring str 0 1))
-                            (string-equal "'" (substring str -1)))
-                       ;; We need to pass double-quoted strings
-                       ;; through the backslash-twiddling bits, even
-                       ;; though we don't need to change their
-                       ;; delimiters.
-                       (and (string-equal "\"" (substring str 0 1))
-                            (string-equal "\"" (substring str -1))))))
-          (org-babel--script-escape-inner str))
-         (t str))))
-    (condition-case nil (org-babel-read escaped) (error escaped))))
-
-(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 and evaluate it as
-lisp, otherwise return it unmodified as a string.  Optional
-argument INHIBIT-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)
-                  (or (member (substring cell 0 1) '("(" "'" "`" "["))
-                      (string= cell "*this*")))
-              (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]+" string)
-          (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 a trailing space or carriage return from STRING.
-The default regexp used is \"[ \\f\\t\\n\\r\\v]\" but another one
-can be specified as the REGEXP 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 a leading and trailing space or carriage return from STRING.
-Like `org-babel-chomp', but run on both the first and last
-character of the string."
-  (org-babel-chomp
-   (org-reverse-string
-    (org-babel-chomp (org-reverse-string string) regexp)) regexp))
-
-(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."
-  (or (file-remote-p file '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'"
-  (let ((f (org-babel-local-file-name (expand-file-name name))))
-    (if no-quote-p f (shell-quote-argument f))))
-
-(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."))
-
-(defcustom org-babel-remote-temporary-directory "/tmp/"
-  "Directory to hold temporary files on remote hosts."
-  :group 'org-babel
-  :type 'string)
-
-(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)))
-  (org-with-gensyms (params)
-    `(let ((,params ,result-params))
-       (unless (member "none" ,params)
-        (if (or (member "scalar" ,params)
-                (member "verbatim" ,params)
-                (member "html" ,params)
-                (member "code" ,params)
-                (member "pp" ,params)
-                (member "file" ,params)
-                (and (or (member "output" ,params)
-                         (member "raw"    ,params)
-                         (member "org"    ,params)
-                         (member "drawer" ,params))
-                     (not (member "table" ,params))))
-            ,scalar-form
-          ,@table-forms)))))
-(def-edebug-spec org-babel-result-cond (form form body))
-
-(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'."
-  (if (file-remote-p default-directory)
-      (let ((prefix
-             (concat (file-remote-p default-directory)
-                     (expand-file-name
-                     prefix org-babel-remote-temporary-directory))))
-        (make-temp-file prefix nil suffix))
-    (let ((temporary-file-directory
-          (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)
-
-(defun org-babel-one-header-arg-safe-p (pair safe-list)
-  "Determine if the PAIR is a safe babel header arg according to SAFE-LIST.
-
-For the format of SAFE-LIST, see `org-babel-safe-header-args'."
-  (and (consp pair)
-       (keywordp (car pair))
-       (stringp (cdr pair))
-       (or
-       (memq (car pair) safe-list)
-       (let ((entry (assq (car pair) safe-list)))
-         (and entry
-              (consp entry)
-              (cond ((functionp (cdr entry))
-                      (funcall (cdr entry) (cdr pair)))
-                    ((listp (cdr entry))
-                     (member (cdr pair) (cdr entry)))
-                    (t nil)))))))
-
-(defun org-babel-generate-file-param (src-name params)
-  "Calculate the filename for source block results.
-
-The directory is calculated from the :output-dir property of the
-source block; if not specified, use the current directory.
-
-If the source block has a #+NAME and the :file parameter does not
-contain any period characters, then the :file parameter is
-treated as an extension, and the output file name is the
-concatenation of the directory (as calculated above), the block
-name, a period, and the parameter value as a file extension.
-Otherwise, the :file parameter is treated as a full file name,
-and the output file name is the directory (as calculated above)
-plus the parameter value."
-  (let* ((file-cons (assq :file params))
-          (file-ext-cons (assq :file-ext params))
-          (file-ext (cdr-safe file-ext-cons))
-          (dir (cdr-safe (assq :output-dir params)))
-          fname)
-    ;; create the output-dir if it does not exist
-    (when dir
-      (make-directory dir t))
-    (if file-cons
-       ;; :file given; add :output-dir if given
-       (when dir
-         (setcdr file-cons (concat (file-name-as-directory dir) (cdr file-cons))))
-      ;; :file not given; compute from name and :file-ext if possible
-      (when (and src-name file-ext)
-       (if dir
-           (setq fname (concat (file-name-as-directory (or dir ""))
-                               src-name "." file-ext))
-         (setq fname (concat src-name "." file-ext)))
-       (setq params (cons (cons :file fname) params))))
-    params))
-
-;;; Used by backends: R, Maxima, Octave.
-(defun org-babel-graphical-output-file (params)
-  "File where a babel block should send graphical output, per PARAMS."
-  (unless (assq :file params)
-    (if (assq :file-ext params)
-       (user-error ":file-ext given but no :file generated; did you forget to give a block a #+NAME?")
-      (user-error "No :file header argument given; cannot create graphical result.")))
-  (and (member "graphics" (cdr (assq :result-params params)))
-       (cdr (assq :file params))))
-
-(provide 'ob-core)
-
-;; Local variables:
-;; generated-autoload-file: "org-loaddefs.el"
-;; End:
-
-;;; ob-core.el ends here
diff --git a/.emacs.d/elisp/org/ob-css.el b/.emacs.d/elisp/org/ob-css.el
deleted file mode 100644 (file)
index a0f0ad1..0000000
+++ /dev/null
@@ -1,48 +0,0 @@
-;;; ob-css.el --- org-babel functions for css evaluation
-
-;; Copyright (C) 2009-2015 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/.emacs.d/elisp/org/ob-ditaa.el b/.emacs.d/elisp/org/ob-ditaa.el
deleted file mode 100644 (file)
index 081cddf..0000000
+++ /dev/null
@@ -1,126 +0,0 @@
-;;; ob-ditaa.el --- org-babel functions for ditaa evaluation
-
-;; Copyright (C) 2009-2015 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-babel-ditaa-java-cmd "java"
-  "Java executable to use when evaluating ditaa blocks."
-  :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
-  :version "24.4"
-  :package-version '(Org . "8.0")
-  :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 (let ((el (cdr (assoc :file params))))
-                     (or el
-                         (error
-                          "ditaa code block requires :file header argument"))))
-        (cmdline (cdr (assoc :cmdline params)))
-        (java (cdr (assoc :java params)))
-        (in-file (org-babel-temp-file "ditaa-"))
-        (eps (cdr (assoc :eps params)))
-        (eps-file (when eps
-                    (org-babel-process-file-name (concat in-file ".eps"))))
-        (pdf-cmd (when (and (or (string= (file-name-extension out-file) "pdf")
-                                (cdr (assoc :pdf params))))
-                   (concat
-                    "epstopdf"
-                    " " eps-file
-                    " -o=" (org-babel-process-file-name out-file))))
-        (cmd (concat org-babel-ditaa-java-cmd
-                     " " 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)
-                     " " (if pdf-cmd
-                             eps-file
-                           (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/.emacs.d/elisp/org/ob-dot.el b/.emacs.d/elisp/org/ob-dot.el
deleted file mode 100644 (file)
index 2f56208..0000000
+++ /dev/null
@@ -1,91 +0,0 @@
-;;; ob-dot.el --- org-babel functions for dot evaluation
-
-;; Copyright (C) 2009-2015 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
-               t
-               t))))
-     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/.emacs.d/elisp/org/ob-ebnf.el b/.emacs.d/elisp/org/ob-ebnf.el
deleted file mode 100644 (file)
index 8c98d30..0000000
+++ /dev/null
@@ -1,85 +0,0 @@
-;;; ob-ebnf.el --- org-babel functions for ebnf evaluation
-
-;; Copyright (C) 2013 Free Software Foundation, Inc.
-
-;; Author: Michael Gauland
-;; Keywords: literate programming, reproducible research
-;; Homepage: http://orgmode.org
-;; Version: 1.00
-
-;;; License:
-
-;; This program is free software; you can redistribute it and/or modify
-;; it under the terms of the GNU General Public License as published by
-;; the Free Software Foundation; either version 3, or (at your option)
-;; any later version.
-;;
-;; This program is distributed in the hope that it will be useful,
-;; but WITHOUT ANY WARRANTY; without even the implied warranty of
-;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-;; GNU General Public License for more details.
-;;
-;; You should have received a copy of the GNU General Public License
-;; along with GNU Emacs; see the file COPYING.  If not, write to the
-;; Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
-;; Boston, MA 02110-1301, USA.
-
-;;; Commentary:
-
-;;; Org-Babel support for using ebnf2ps to generate encapsulated postscript
-;;; railroad diagrams. It recogises these arguments:
-;;;
-;;;     :file is required; it must include the extension '.eps.' All the rules
-;;;           in the block will be drawn in the same file. This is done by
-;;;           inserting a '[<file>' comment at the start of the block (see the
-;;;           documentation for ebnf-eps-buffer for more information).
-;;;
-;;;     :style specifies a value in ebnf-style-database. This provides the
-;;;            ability to customise the output. The style can also specify the
-;;;            grammar syntax (by setting ebnf-syntax); note that only ebnf,
-;;;            iso-ebnf, and yacc are supported by this file.
-
-;;; Requirements:
-
-;;; Code:
-(require 'ob)
-(require 'ebnf2ps)
-
-;; optionally declare default header arguments for this language
-(defvar org-babel-default-header-args:ebnf '((:style . nil)))
-
-;; Use ebnf-eps-buffer to produce an encapsulated postscript file.
-;;
-(defun org-babel-execute:ebnf (body params)
-  "Execute a block of Ebnf code with org-babel.  This function is
-called by `org-babel-execute-src-block'"
-  (save-excursion
-    (let* ((dest-file (cdr (assoc :file params)))
-          (dest-dir (file-name-directory dest-file))
-          (dest-root (file-name-sans-extension
-                      (file-name-nondirectory dest-file)))
-           (dest-ext  (file-name-extension dest-file))
-          (style (cdr (assoc :style params)))
-          (current-dir default-directory)
-          (result nil))
-      (with-temp-buffer
-       (when style (ebnf-push-style style))
-       (let ((comment-format
-              (cond ((string= ebnf-syntax 'yacc) "/*%s*/")
-                    ((string= ebnf-syntax 'ebnf) ";%s")
-                    ((string= ebnf-syntax 'iso-ebnf) "(*%s*)")
-                    (t (setq result
-                             (format "EBNF error: format %s not supported."
-                                     ebnf-syntax))))))
-         (setq ebnf-eps-prefix dest-dir)
-         (insert (format comment-format (format "[%s" dest-root)))
-         (newline)
-         (insert body)
-         (newline)
-         (insert (format comment-format (format "]%s" dest-root)))
-         (ebnf-eps-buffer)
-         (when style (ebnf-pop-style))))
-      result)))
-
-(provide 'ob-ebnf)
-;;; ob-ebnf.el ends here
diff --git a/.emacs.d/elisp/org/ob-emacs-lisp.el b/.emacs.d/elisp/org/ob-emacs-lisp.el
deleted file mode 100644 (file)
index 5eb7003..0000000
+++ /dev/null
@@ -1,79 +0,0 @@
-;;; ob-emacs-lisp.el --- org-babel functions for emacs-lisp code evaluation
-
-;; Copyright (C) 2009-2015 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 nil
-  "Default arguments for evaluating an emacs-lisp source block.")
-
-(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
-    (let ((result
-           (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))))))
-      (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))))))))
-
-(provide 'ob-emacs-lisp)
-
-
-
-;;; ob-emacs-lisp.el ends here
diff --git a/.emacs.d/elisp/org/ob-eval.el b/.emacs.d/elisp/org/ob-eval.el
deleted file mode 100644 (file)
index d94b695..0000000
+++ /dev/null
@@ -1,150 +0,0 @@
-;;; ob-eval.el --- org-babel functions for external code evaluation
-
-;; Copyright (C) 2009-2015 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:
-(require 'org-macs)
-(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 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)))
-           (save-excursion
-             (when (get-buffer org-babel-error-buffer-name)
-               (with-current-buffer org-babel-error-buffer-name
-                 (unless (derived-mode-p 'compilation-mode)
-                   (compilation-mode))
-                 ;; Compilation-mode enforces read-only, but Babel expects the buffer modifiable.
-                 (setq buffer-read-only nil))))
-           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 error-buffer)
-  "Execute COMMAND in an inferior shell with region as input.
-
-Stripped down version of shell-command-on-region for internal use
-in Babel only.  This lets us work around errors in the original
-function in various versions of Emacs.
-"
-  (let ((input-file (org-babel-temp-file "ob-input-"))
-       (error-file (if error-buffer (org-babel-temp-file "ob-error-") 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))
-    ;; we always call this with 'replace, remove conditional
-    ;; Replace specified region with output from command.
-    (let ((swap (< start end)))
-      (goto-char start)
-      (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 t error-file)
-                           t)
-                         nil shell-command-switch command))
-      (when swap (exchange-point-and-mark)))
-
-    (when (and input-file (file-exists-p input-file)
-              ;; bind org-babel--debug-input around the call to keep
-              ;; the temporary input files available for inspection
-              (not (when (boundp 'org-babel--debug-input)
-                     org-babel--debug-input)))
-      (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)))
-           (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/.emacs.d/elisp/org/ob-exp.el b/.emacs.d/elisp/org/ob-exp.el
deleted file mode 100644 (file)
index 1f01973..0000000
+++ /dev/null
@@ -1,449 +0,0 @@
-;;; ob-exp.el --- Exportation of org-babel source blocks
-
-;; Copyright (C) 2009-2015 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)
-(require 'org-src)
-(eval-when-compile
-  (require 'cl))
-
-(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-commented-heading-p "org" (&optional no-inheritance))
-(declare-function org-in-block-p "org" (names))
-(declare-function org-in-verbatim-emphasis "org" ())
-(declare-function org-link-search "org" (s &optional 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" ())
-(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-id-get "org-id" (&optional pom create prefix))
-(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.  When set to 'inline-only, only inline code blocks will
-be executed."
-  :group 'org-babel
-  :version "24.1"
-  :type '(choice (const :tag "Never" nil)
-                (const :tag "Only inline code" inline-only)
-                (const :tag "Always" t)))
-(put 'org-export-babel-evaluate 'safe-local-variable (lambda (x) (eq x nil)))
-
-(defvar org-link-search-inhibit-query)
-(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-query (or (org-id-get)
-                            ;; CUSTOM_IDs don't work, maybe they are
-                            ;; stripped, or maybe they resolve too
-                            ;; late in `org-link-search'.
-                            ;; (org-entry-get nil "CUSTOM_ID")
-                            (nth 4 (ignore-errors (org-heading-components)))))
-         (export-buffer (current-buffer))
-         results)
-     (when org-babel-exp-reference-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 org-babel-exp-reference-buffer)
-       (save-restriction
-        (when heading-query
-          (condition-case nil
-              (let ((org-link-search-inhibit-query t))
-                ;; TODO: When multiple headings have the same title,
-                ;;       this returns the first, which is not always
-                ;;       the right heading.  Consider a better way to
-                ;;       find the proper heading.
-                (org-link-search heading-query))
-            (error (when heading-query
-                     (goto-char (point-min))
-                     (re-search-forward (regexp-quote heading-query) 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, replace the source
-code block like this:
-
-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)
-  (save-excursion
-    (let* ((info (org-babel-get-src-block-info 'light))
-          (line (org-current-line))
-          (lang (nth 0 info))
-          (raw-params (nth 2 info)) hash)
-      ;; bail if we couldn't get any info from the block
-      (unless noninteractive
-       (message "org-babel-exp process %s at line %d..." lang line))
-      (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
-                  (apply #'org-babel-merge-params
-                         org-babel-default-header-args
-                         (if (boundp lang-headers) (eval lang-headers) nil)
-                         (append (org-babel-params-from-properties lang)
-                                 (list 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-process-buffer (reference-buffer)
-  "Execute all Babel blocks in current buffer.
-REFERENCE-BUFFER is the buffer containing a pristine copy of the
-buffer being processed.  It is used to properly resolve
-references in source blocks, as modifications in current buffer
-may make them unreachable."
-  (interactive)
-  (save-window-excursion
-    (save-excursion
-      (let ((case-fold-search t)
-           (org-babel-exp-reference-buffer reference-buffer)
-           (regexp (concat org-babel-inline-src-block-regexp "\\|"
-                           org-babel-lob-one-liner-regexp "\\|"
-                           "^[ \t]*#\\+BEGIN_SRC")))
-       (goto-char (point-min))
-       (while (re-search-forward regexp nil t)
-         (unless (save-match-data (org-in-commented-heading-p))
-           (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))
-                  (begin (copy-marker (org-element-property :begin element)))
-                  (end (copy-marker
-                        (save-excursion
-                          (goto-char (org-element-property :end element))
-                          (skip-chars-backward " \r\t\n")
-                          (point)))))
-             (case type
-               (inline-src-block
-                (let* ((head (match-beginning 0))
-                       (info (append (org-babel-parse-inline-src-block-match)
-                                     (list nil nil head)))
-                       (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-reference-buffer)
-                          (nth 1 info)))
-                  (goto-char begin)
-                  (let ((replacement (org-babel-exp-do-export info 'inline)))
-                    (if (equal replacement "")
-                        ;; Replacement code is empty: remove inline
-                        ;; source block, including extra white space
-                        ;; that might have been created when
-                        ;; inserting results.
-                        (delete-region begin
-                                       (progn (goto-char end)
-                                              (skip-chars-forward " \t")
-                                              (point)))
-                      ;; Otherwise: remove inline src block but
-                      ;; preserve following white spaces.  Then
-                      ;; insert value.
-                      (delete-region begin end)
-                      (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"
-                               (apply #'org-babel-merge-params
-                                      org-babel-default-header-args
-                                      org-babel-default-lob-header-args
-                                      (append
-                                       (org-babel-params-from-properties)
-                                       (list
-                                        (org-babel-parse-header-arguments
-                                         (org-no-properties
-                                          (concat
-                                           ":var results="
-                                           (mapconcat 'identity
-                                                      (butlast lob-info 2)
-                                                      " ")))))))
-                               "" (nth 3 lob-info) (nth 2 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
-                       begin
-                       (progn (goto-char end)
-                              (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 begin)
-                    (delete-region begin end)
-                    (insert rep))))
-               (src-block
-                (let* ((match-start (copy-marker (match-beginning 0)))
-                       (ind (org-get-indentation))
-                       (lang (or (org-element-property :language element)
-                                 (user-error
-                                  "No language for src block: %s"
-                                  (or (org-element-property :name element)
-                                      "(unnamed)"))))
-                       (headers
-                        (cons lang
-                              (let ((params
-                                     (org-element-property
-                                      :parameters element)))
-                                (and params (org-split-string params))))))
-                  ;; 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 end))
-                          ((equal replacement "")
-                           (goto-char end)
-                           (skip-chars-forward " \r\t\n")
-                           (beginning-of-line)
-                           (delete-region begin (point)))
-                          (t
-                           (goto-char match-start)
-                           (delete-region (point)
-                                          (save-excursion (goto-char end)
-                                                          (line-end-position)))
-                           (insert replacement)
-                           (if (or org-src-preserve-indentation
-                                   (org-element-property :preserve-indent
-                                                         element))
-                               ;; 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)))))
-                  (set-marker match-start nil))))
-             (set-marker begin nil)
-             (set-marker end nil))))))))
-
-(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 () (if (eq type 'inline)
-                             (org-babel-remove-inline-result)
-                           (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 type))
-      ('results (org-babel-exp-results info type nil hash) "")
-      ('both (org-babel-exp-results info type nil hash)
-            (org-babel-exp-code info type)))))
-
-(defcustom org-babel-exp-code-template
-  "#+BEGIN_SRC %lang%switches%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
- switches -- the switches associated to 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)
-
-(defcustom org-babel-exp-inline-code-template
-  "src_%lang[%switches%flags]{%body}"
-  "Template used to export the body of inline 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
- switches -- the switches associated to 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
-  :version "25.1"
-  :package-version '(Org . "8.3"))
-
-(defun org-babel-exp-code (info type)
-  "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-reference-buffer)
-           (nth 1 info))))
-  (org-fill-template
-   (if (eq type 'inline)
-       org-babel-exp-inline-code-template 
-       org-babel-exp-code-template)
-   `(("lang"  . ,(nth 0 info))
-     ("body"  . ,(org-escape-code-in-string (nth 1 info)))
-     ("switches" . ,(let ((f (nth 3 info)))
-                     (and (org-string-nw-p f) (concat " " f))))
-     ("flags" . ,(let ((f (assq :flags (nth 2 info))))
-                  (and f (concat " " (cdr f)))))
-     ,@(mapcar (lambda (pair)
-                (cons (substring (symbol-name (car pair)) 1)
-                      (format "%S" (cdr pair))))
-              (nth 2 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 (or (eq org-export-babel-evaluate t)
-                (and (eq type 'inline)
-                     (eq org-export-babel-evaluate 'inline-only)))
-            (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-reference-buffer)
-                 (nth 1 info)))
-         (info (copy-sequence info))
-         (org-babel-current-src-block-location (point-marker)))
-      ;; 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)
-             (let (org-confirm-babel-evaluate)
-               (org-babel-execute-src-block nil info))))))))))
-
-
-(provide 'ob-exp)
-
-;;; ob-exp.el ends here
diff --git a/.emacs.d/elisp/org/ob-forth.el b/.emacs.d/elisp/org/ob-forth.el
deleted file mode 100644 (file)
index cc2795a..0000000
+++ /dev/null
@@ -1,86 +0,0 @@
-;;; ob-forth.el --- org-babel functions for Forth
-
-;; Copyright (C) 2014 Free Software Foundation, Inc.
-
-;; Author: Eric Schulte
-;; Keywords: literate programming, reproducible research, forth
-;; 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:
-
-;; Requires the gforth forth compiler and `forth-mode' (see below).
-;; https://www.gnu.org/software/gforth/
-
-;;; Requirements:
-
-;; Session evaluation requires the gforth forth compiler as well as
-;; `forth-mode' which is distributed with gforth (in gforth.el).
-
-;;; Code:
-(require 'ob)
-
-(declare-function forth-proc "ext:gforth" ())
-
-(defvar org-babel-default-header-args:forth '((:session . "yes"))
-  "Default header arguments for forth code blocks.")
-
-(defun org-babel-execute:forth (body params)
-  "Execute a block of Forth code with org-babel.
-This function is called by `org-babel-execute-src-block'"
-  (if (string= "none" (cdr (assoc :session params)))
-      (error "Non-session evaluation not supported for Forth code blocks")
-    (let ((all-results (org-babel-forth-session-execute body params)))
-      (if (member "output" (cdr (assoc :result-params params)))
-         (mapconcat #'identity all-results "\n")
-       (car (last all-results))))))
-
-(defun org-babel-forth-session-execute (body params)
-  (require 'forth-mode)
-  (let ((proc (forth-proc))
-       (rx " \\(\n:\\|compiled\n\\\|ok\n\\)")
-       (result-start))
-    (with-current-buffer (process-buffer (forth-proc))
-      (mapcar (lambda (line)
-               (setq result-start (progn (goto-char (process-mark proc))
-                                         (point)))
-               (comint-send-string proc (concat line "\n"))
-               ;; wait for forth to say "ok"
-               (while (not (progn (goto-char result-start)
-                                  (re-search-forward rx nil t)))
-                 (accept-process-output proc 0.01))
-               (let ((case (match-string 1)))
-                 (cond
-                  ((string= "ok\n" case)
-                   ;; Collect intermediate output.
-                   (buffer-substring (+ result-start 1 (length line))
-                                     (match-beginning 0)))
-                  ((string= "compiled\n" case))
-                  ;; Ignore partial compilation.
-                  ((string= "\n:" case)
-                   ;; Report errors.
-                   (org-babel-eval-error-notify 1
-                    (buffer-substring
-                     (+ (match-beginning 0) 1) (point-max))) nil))))
-             (split-string (org-babel-trim
-                            (org-babel-expand-body:generic
-                             body params))
-                           "\n" 'omit-nulls)))))
-
-(provide 'ob-forth)
-
-;;; ob-forth.el ends here
diff --git a/.emacs.d/elisp/org/ob-fortran.el b/.emacs.d/elisp/org/ob-fortran.el
deleted file mode 100644 (file)
index d32092a..0000000
+++ /dev/null
@@ -1,169 +0,0 @@
-;;; ob-fortran.el --- org-babel functions for fortran
-
-;; Copyright (C) 2011-2015 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))
-(declare-function org-every "org" (pred seq))
-(declare-function org-remove-indentation "org" (code &optional n))
-
-(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)) ""))))
-    (let ((results
-           (org-babel-trim
-            (org-remove-indentation
-            (org-babel-eval
-             (concat tmp-bin-file (if cmdline (concat " " cmdline) "")) "")))))
-      (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)))))))
-
-(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))
-     ;; val is a matrix
-     ((and (listp val) (org-every #'listp val))
-      (format "real, parameter :: %S(%d,%d) = transpose( reshape( %s , (/ %d, %d /) ) )\n"
-             var (length val) (length (car val))
-             (org-babel-fortran-transform-list val)
-             (length (car val)) (length val)))
-     ((listp val)
-      (format "real, parameter :: %S(%d) = %s\n"
-             var (length val) (org-babel-fortran-transform-list val)))
-     (t
-      (error "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/.emacs.d/elisp/org/ob-gnuplot.el b/.emacs.d/elisp/org/ob-gnuplot.el
deleted file mode 100644 (file)
index 8490b16..0000000
+++ /dev/null
@@ -1,280 +0,0 @@
-;;; ob-gnuplot.el --- org-babel functions for gnuplot evaluation
-
-;; Copyright (C) 2009-2015 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-header-args:gnuplot
-  '((title     . :any)
-    (lines     . :any)
-    (sets      . :any)
-    (x-labels  . :any)
-    (y-labels  . :any)
-    (timefmt   . :any)
-    (time-ind  . :any)
-    (missing   . :any)
-    (term       . :any))
-  "Gnuplot specific header args.")
-
-(defvar org-babel-gnuplot-timestamp-fmt nil) ; Dynamically scoped.
-
-(defvar *org-babel-gnuplot-missing* nil)
-
-(defcustom *org-babel-gnuplot-terms*
-  '((eps . "postscript eps"))
-  "List of file extensions and the associated gnuplot terminal."
-  :group 'org-babel
-  :type '(repeat (cons (symbol :tag "File extension")
-                      (string :tag "Gnuplot terminal"))))
-
-(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."
-  (let ((*org-babel-gnuplot-missing* (cdr (assoc :missing params))))
-    (mapcar
-     (lambda (pair)
-       (cons
-       (car pair) ;; variable name
-       (let* ((val (cdr pair)) ;; variable value
-              (lp  (listp val)))
-         (if lp
-             (org-babel-gnuplot-table-to-data
-              (let* ((first  (car val))
-                     (tablep (or (listp first) (symbolp first))))
-                (if tablep val (mapcar 'list val)))
-              (org-babel-temp-file "gnuplot-") params)
-         val))))
-     (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)))
-          (prologue (cdr (assoc :prologue params)))
-          (epilogue (cdr (assoc :epilogue params)))
-          (term (or (cdr (assoc :term params))
-                     (when out-file
-                      (let ((ext (file-name-extension out-file)))
-                        (or (cdr (assoc (intern (downcase ext))
-                                        *org-babel-gnuplot-terms*))
-                            ext)))))
-           (cmdline (cdr (assoc :cmdline params)))
-           (title (cdr (assoc :title params)))
-           (lines (cdr (assoc :line params)))
-           (sets (cdr (assoc :set params)))
-           (x-labels (cdr (assoc :xlabels params)))
-           (y-labels (cdr (assoc :ylabels params)))
-           (timefmt (cdr (assoc :timefmt params)))
-           (time-ind (or (cdr (assoc :timeind params))
-                         (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)))
-      (when lines (mapc (lambda (el) (funcall add-to-body el)) lines))
-      (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
-       ;; set the terminal at the top of the block
-       (funcall add-to-body (format "set output \"%s\"" out-file))
-       ;; and close the terminal at the bottom of the block
-       (setq body (concat body "\nset output\n")))
-      (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)
-      (when prologue (funcall add-to-body prologue))
-      (when epilogue (setq body (concat body "\n" epilogue))))
-    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)
-      (if (zerop (length s))
-         (or *org-babel-gnuplot-missing* s)
-       (if (string-match "[ \"]" s)
-           (concat "\"" (mapconcat 'identity (split-string s "\"") "\"\"")
-                   "\"")
-         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
-    (insert (let ((org-babel-gnuplot-timestamp-fmt
-                  (or (plist-get params :timefmt) "%Y-%m-%d-%H:%M:%S")))
-             (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/.emacs.d/elisp/org/ob-groovy.el b/.emacs.d/elisp/org/ob-groovy.el
deleted file mode 100644 (file)
index 91100d2..0000000
+++ /dev/null
@@ -1,118 +0,0 @@
-;;; ob-groovy.el --- org-babel functions for Groovy evaluation
-
-;; Copyright (C) 2013-2015 Free Software Foundation, Inc.
-
-;; Author: Miro Bezjak
-;; 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.
-
-;;; Requirements:
-;; - Groovy language :: http://groovy.codehaus.org
-;; - Groovy major mode :: Can be installed from MELPA or
-;;   https://github.com/russel/Emacs-Groovy-Mode
-
-;;; Code:
-(require 'ob)
-(eval-when-compile (require 'cl))
-
-(defvar org-babel-tangle-lang-exts) ;; Autoloaded
-(add-to-list 'org-babel-tangle-lang-exts '("groovy" . "groovy"))
-(defvar org-babel-default-header-args:groovy '())
-(defcustom org-babel-groovy-command "groovy"
-  "Name of the command to use for executing Groovy code.
-May be either a command in the path, like groovy
-or an absolute path name, like /usr/local/bin/groovy
-parameters may be used, like groovy -v"
-  :group 'org-babel
-  :version "24.3"
-  :type 'string)
-
-(defun org-babel-execute:groovy (body params)
-  "Execute a block of Groovy code with org-babel.  This function is
-called by `org-babel-execute-src-block'"
-  (message "executing Groovy source code block")
-  (let* ((processed-params (org-babel-process-params params))
-         (session (org-babel-groovy-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-groovy-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))))))
-
-(defvar org-babel-groovy-wrapper-method
-
-  "class Runner extends Script {
-    def out = new PrintWriter(new ByteArrayOutputStream())
-    def run() { %s }
-}
-
-println(new Runner().run())
-")
-
-
-(defun org-babel-groovy-evaluate
-  (session body &optional result-type result-params)
-  "Evaluate BODY in external Groovy 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 Groovy"))
-  (case result-type
-    (output
-     (let ((src-file (org-babel-temp-file "groovy-")))
-       (progn (with-temp-file src-file (insert body))
-              (org-babel-eval
-               (concat org-babel-groovy-command " " src-file) ""))))
-    (value
-     (let* ((src-file (org-babel-temp-file "groovy-"))
-            (wrapper (format org-babel-groovy-wrapper-method body)))
-       (with-temp-file src-file (insert wrapper))
-       (let ((raw (org-babel-eval
-                   (concat org-babel-groovy-command " " src-file) "")))
-         (org-babel-result-cond result-params
-          raw
-           (org-babel-script-escape raw)))))))
-
-
-(defun org-babel-prep-session:groovy (session params)
-  "Prepare SESSION according to the header arguments specified in PARAMS."
-  (error "Sessions are not (yet) supported for Groovy"))
-
-(defun org-babel-groovy-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 Groovy."
-  nil)
-
-(provide 'ob-groovy)
-
-
-
-;;; ob-groovy.el ends here
diff --git a/.emacs.d/elisp/org/ob-haskell.el b/.emacs.d/elisp/org/ob-haskell.el
deleted file mode 100644 (file)
index e7e9cb4..0000000
+++ /dev/null
@@ -1,219 +0,0 @@
-;;; ob-haskell.el --- org-babel functions for haskell evaluation
-
-;; Copyright (C) 2009-2015 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
-  '((:padlines . "no")))
-
-(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
-     (let ((result
-            (case result-type
-              (output (mapconcat #'identity (reverse (cdr results)) "\n"))
-              (value (car results)))))
-       (org-babel-result-cond (cdr (assoc :result-params params))
-        result (org-babel-script-escape result)))
-     (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-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-export-copy-to-kill-ring)
-(declare-function org-export-to-file "ox"
-                 (backend file
-                          &optional async 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/.emacs.d/elisp/org/ob-io.el b/.emacs.d/elisp/org/ob-io.el
deleted file mode 100644 (file)
index a5e5cda..0000000
+++ /dev/null
@@ -1,110 +0,0 @@
-;;; ob-io.el --- org-babel functions for Io evaluation
-
-;; Copyright (C) 2012-2015 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)