Merge branch 'master' of git.ganneff.de:emacs
authorJoerg Jaspert <joerg@debian.org>
Sun, 3 May 2015 21:03:58 +0000 (23:03 +0200)
committerJoerg Jaspert <joerg@debian.org>
Sun, 3 May 2015 21:03:58 +0000 (23:03 +0200)
* 'master' of git.ganneff.de:emacs:
  new user format functions
  Updates
  No longer protect gnus buffer
  Update solarized theme

125 files changed:
.emacs.d/elisp/icicle/icicles-autoloads.el [deleted file]
.emacs.d/elisp/icicle/icicles-chg.el
.emacs.d/elisp/icicle/icicles-cmd1.el
.emacs.d/elisp/icicle/icicles-fn.el
.emacs.d/elisp/icicle/icicles-pkg.el [deleted file]
.emacs.d/elisp/org/ob-C.el
.emacs.d/elisp/org/ob-J.el [new file with mode: 0644]
.emacs.d/elisp/org/ob-R.el
.emacs.d/elisp/org/ob-abc.el [new file with mode: 0644]
.emacs.d/elisp/org/ob-asymptote.el
.emacs.d/elisp/org/ob-awk.el
.emacs.d/elisp/org/ob-clojure.el
.emacs.d/elisp/org/ob-comint.el
.emacs.d/elisp/org/ob-coq.el [new file with mode: 0644]
.emacs.d/elisp/org/ob-core.el
.emacs.d/elisp/org/ob-ditaa.el
.emacs.d/elisp/org/ob-dot.el
.emacs.d/elisp/org/ob-ebnf.el [new file with mode: 0644]
.emacs.d/elisp/org/ob-emacs-lisp.el
.emacs.d/elisp/org/ob-eval.el
.emacs.d/elisp/org/ob-exp.el
.emacs.d/elisp/org/ob-forth.el [new file with mode: 0644]
.emacs.d/elisp/org/ob-fortran.el
.emacs.d/elisp/org/ob-gnuplot.el
.emacs.d/elisp/org/ob-groovy.el [new file with mode: 0644]
.emacs.d/elisp/org/ob-haskell.el
.emacs.d/elisp/org/ob-io.el
.emacs.d/elisp/org/ob-java.el
.emacs.d/elisp/org/ob-js.el
.emacs.d/elisp/org/ob-keys.el
.emacs.d/elisp/org/ob-latex.el
.emacs.d/elisp/org/ob-lilypond.el
.emacs.d/elisp/org/ob-lisp.el
.emacs.d/elisp/org/ob-lob.el
.emacs.d/elisp/org/ob-maxima.el
.emacs.d/elisp/org/ob-ocaml.el
.emacs.d/elisp/org/ob-octave.el
.emacs.d/elisp/org/ob-python.el
.emacs.d/elisp/org/ob-ref.el
.emacs.d/elisp/org/ob-ruby.el
.emacs.d/elisp/org/ob-scala.el
.emacs.d/elisp/org/ob-scheme.el
.emacs.d/elisp/org/ob-shell.el [moved from .emacs.d/elisp/org/ob-sh.el with 67% similarity]
.emacs.d/elisp/org/ob-sql.el
.emacs.d/elisp/org/ob-table.el
.emacs.d/elisp/org/ob-tangle.el
.emacs.d/elisp/org/org-agenda.el
.emacs.d/elisp/org/org-annotate-file.el
.emacs.d/elisp/org/org-archive.el
.emacs.d/elisp/org/org-attach.el
.emacs.d/elisp/org/org-bibtex-extras.el
.emacs.d/elisp/org/org-bibtex.el
.emacs.d/elisp/org/org-capture.el
.emacs.d/elisp/org/org-clock.el
.emacs.d/elisp/org/org-collector.el
.emacs.d/elisp/org/org-colview-xemacs.el
.emacs.d/elisp/org/org-colview.el
.emacs.d/elisp/org/org-compat.el
.emacs.d/elisp/org/org-contacts.el
.emacs.d/elisp/org/org-docview.el
.emacs.d/elisp/org/org-download.el [new file with mode: 0644]
.emacs.d/elisp/org/org-drill.el
.emacs.d/elisp/org/org-ebib.el [new file with mode: 0644]
.emacs.d/elisp/org/org-effectiveness.el [new file with mode: 0644]
.emacs.d/elisp/org/org-eldoc.el [new file with mode: 0644]
.emacs.d/elisp/org/org-element.el
.emacs.d/elisp/org/org-entities.el
.emacs.d/elisp/org/org-eww.el [new file with mode: 0644]
.emacs.d/elisp/org/org-expiry.el
.emacs.d/elisp/org/org-faces.el
.emacs.d/elisp/org/org-favtable.el [deleted file]
.emacs.d/elisp/org/org-feed.el
.emacs.d/elisp/org/org-footnote.el
.emacs.d/elisp/org/org-git-link.el
.emacs.d/elisp/org/org-gnus.el
.emacs.d/elisp/org/org-habit.el
.emacs.d/elisp/org/org-index.el [new file with mode: 0644]
.emacs.d/elisp/org/org-info.el
.emacs.d/elisp/org/org-inlinetask.el
.emacs.d/elisp/org/org-jira.el [new file with mode: 0644]
.emacs.d/elisp/org/org-license.el [new file with mode: 0644]
.emacs.d/elisp/org/org-list.el
.emacs.d/elisp/org/org-loaddefs.el
.emacs.d/elisp/org/org-mac-link.el
.emacs.d/elisp/org/org-macro.el
.emacs.d/elisp/org/org-macs.el
.emacs.d/elisp/org/org-mew.el
.emacs.d/elisp/org/org-mime.el
.emacs.d/elisp/org/org-mobile.el
.emacs.d/elisp/org/org-mouse.el
.emacs.d/elisp/org/org-mtags.el [deleted file]
.emacs.d/elisp/org/org-notmuch.el
.emacs.d/elisp/org/org-passwords.el [new file with mode: 0644]
.emacs.d/elisp/org/org-pcomplete.el
.emacs.d/elisp/org/org-plot.el
.emacs.d/elisp/org/org-rmail.el
.emacs.d/elisp/org/org-src.el
.emacs.d/elisp/org/org-table.el
.emacs.d/elisp/org/org-timer.el
.emacs.d/elisp/org/org-toc.el
.emacs.d/elisp/org/org-velocity.el
.emacs.d/elisp/org/org-version.el
.emacs.d/elisp/org/org-wikinodes.el
.emacs.d/elisp/org/org.el
.emacs.d/elisp/org/ox-ascii.el
.emacs.d/elisp/org/ox-beamer.el
.emacs.d/elisp/org/ox-bibtex.el [deleted file]
.emacs.d/elisp/org/ox-confluence.el [deleted file]
.emacs.d/elisp/org/ox-deck.el [deleted file]
.emacs.d/elisp/org/ox-freemind.el [deleted file]
.emacs.d/elisp/org/ox-groff.el [deleted file]
.emacs.d/elisp/org/ox-html.el
.emacs.d/elisp/org/ox-icalendar.el
.emacs.d/elisp/org/ox-koma-letter.el [deleted file]
.emacs.d/elisp/org/ox-latex.el
.emacs.d/elisp/org/ox-man.el
.emacs.d/elisp/org/ox-md.el
.emacs.d/elisp/org/ox-odt.el
.emacs.d/elisp/org/ox-org.el
.emacs.d/elisp/org/ox-publish.el
.emacs.d/elisp/org/ox-rss.el [deleted file]
.emacs.d/elisp/org/ox-s5.el [deleted file]
.emacs.d/elisp/org/ox-taskjuggler.el [deleted file]
.emacs.d/elisp/org/ox-texinfo.el
.emacs.d/elisp/org/ox.el

diff --git a/.emacs.d/elisp/icicle/icicles-autoloads.el b/.emacs.d/elisp/icicle/icicles-autoloads.el
deleted file mode 100644 (file)
index bb9b7e2..0000000
+++ /dev/null
@@ -1,41 +0,0 @@
-;;; icicles-autoloads.el --- automatically extracted autoloads
-;;
-;;; Code:
-(add-to-list 'load-path (or (file-name-directory #$) (car load-path)))
-\f
-;;;### (autoloads nil "icicles" "icicles.el" (21728 41268 575536
-;;;;;;  178000))
-;;; Generated autoloads from icicles.el
- (autoload 'icy-mode    "icicles" "Toggle Icicle mode - see `icicle-mode'." t nil)
- (autoload 'icicle-mode "icicles"
-"Icicle mode: Toggle minibuffer input completion and cycling.
- Non-nil prefix ARG turns mode on if ARG > 0, else turns it off.
- Icicle mode is a global minor mode.  It binds keys in the minibuffer.
- \
- For more information, use `\\<minibuffer-local-completion-map>\\[icicle-minibuffer-help]' \
- when the minibuffer is active.
- \
- Depending on your platform, if you use Icicles in a text terminal
- \(that is, without a window system/manager), you might need to change
- some of the key bindings if some of the default bindings are not
- available to you.
- \
- Icicle mode defines many top-level commands.  For a list, see the
- Commentary headers of files `icicles-cmd1.el' and `icicles-cmd2.el'."
- t nil)
-
-;;;***
-\f
-;;;### (autoloads nil nil ("icicles-chg.el" "icicles-cmd1.el" "icicles-cmd2.el"
-;;;;;;  "icicles-doc1.el" "icicles-doc2.el" "icicles-face.el" "icicles-fn.el"
-;;;;;;  "icicles-mac.el" "icicles-mcmd.el" "icicles-mode.el" "icicles-opt.el"
-;;;;;;  "icicles-pkg.el" "icicles-var.el") (21728 41269 252628 217000))
-
-;;;***
-\f
-;; Local Variables:
-;; version-control: never
-;; no-byte-compile: t
-;; no-update-autoloads: t
-;; End:
-;;; icicles-autoloads.el ends here
index a77ae12..48df0d4 100644 (file)
@@ -6,9 +6,9 @@
 ;; Maintainer: Drew Adams (concat "drew.adams" "@" "oracle" ".com")
 ;; Copyright (C) 2007-2015, Drew Adams, all rights reserved.
 ;; Created: Tue Nov 27 07:47:53 2007
-;; Last-Updated: Sun Feb  8 09:10:13 2015 (-0800)
+;; Last-Updated: Wed Jan 21 09:13:40 2015 (-0800)
 ;;           By: dradams
-;;     Update #: 11394
+;;     Update #: 11389
 ;; URL: http://www.emacswiki.org/icicles-chg.el
 ;; Doc URL: http://www.emacswiki.org/Icicles
 ;; Keywords: extensions, help, abbrev, local, minibuffer,
@@ -85,9 +85,6 @@
  
 ;;;(@* "CHANGE LOG FOR `icicles-cmd1.el'")
 ;;
-;; 2015/02/08 dadams
-;;     icicle-bookmark-set: Soft-require Bookmark+ - don't test with featurep.
-;;                          Do not overwrite properties listed in option bmkp-properties-to-keep.
 ;; 2014/12/15 dadams
 ;;     Added: icicle-bookmark(-local|-remote)-non-dir-file(-other-window).
 ;;     Added (commented out - not used yet): icicle-bookmark-non-dir-file-narrow.
  
 ;;;(@* "CHANGE LOG FOR `icicles-fn.el'")
 ;;
-;; 2015/02/07 dadams
-;;     icicle-unsorted-file-name-prefix-candidates: For proxy cands and extra cands, use relative name.
 ;; 2015/01/21 dadams
 ;;     icicle-choose-completion-string (Emacs 23.2+): Delete region even for INSERT-FUNCTION case.
 ;; 2015/01/20 dadams
index b7013a6..3a08e9a 100644 (file)
@@ -6,9 +6,9 @@
 ;; Maintainer: Drew Adams (concat "drew.adams" "@" "oracle" ".com")
 ;; Copyright (C) 1996-2015, Drew Adams, all rights reserved.
 ;; Created: Mon Feb 27 09:25:04 2006
-;; Last-Updated: Sun Feb  8 09:08:07 2015 (-0800)
+;; Last-Updated: Mon Jan  5 13:47:54 2015 (-0800)
 ;;           By: dradams
-;;     Update #: 27383
+;;     Update #: 27373
 ;; URL: http://www.emacswiki.org/icicles-cmd1.el
 ;; Doc URL: http://www.emacswiki.org/Icicles
 ;; Keywords: extensions, help, abbrev, local, minibuffer,
@@ -5089,7 +5089,7 @@ Note: You can use command `icicle-bookmark-set' with a numeric
 prefix arg if you want to complete against all bookmark names,
 instead of those for the current buffer."
   (interactive (list nil current-prefix-arg t))
-  (if (not (require 'bookmark+ nil t))
+  (if (not (featurep 'bookmark+))
       (bookmark-set name parg)
     (unwind-protect
          (let ((enable-recursive-minibuffers           t) ; In case read input, e.g. File changed...
@@ -5149,9 +5149,11 @@ instead of those for the current buffer."
                                 icicle-alpha-p)))
                         '(("by previous use alphabetically" . icicle-historical-alphabetic-p)
                           ("case insensitive" . icicle-case-insensitive-string-less-p)))))
-           ;; Bind keys to narrow bookmark candidates by type.  Lax is for multi-completion case.
-           (dolist (map  '(minibuffer-local-must-match-map minibuffer-local-completion-map))
-             (icicle-bookmark-bind-narrow-commands map))
+           (require 'bookmark)
+           (when (featurep 'bookmark+)
+             ;; Bind keys to narrow bookmark candidates by type.  Lax is for multi-completion case.
+             (dolist (map  '(minibuffer-local-must-match-map minibuffer-local-completion-map))
+               (icicle-bookmark-bind-narrow-commands map)))
            (setq bookmark-current-point   (point)
                  bookmark-current-buffer  (current-buffer))
            (save-excursion (skip-chars-forward " ") (setq bookmark-yank-point  (point)))
@@ -5175,17 +5177,11 @@ instead of those for the current buffer."
                                                                          'bookmark-history
                                                                        'icicle-bookmark-history))))))
              (when (string-equal bname "") (setq bname  defname))
-             (let ((old-bmk  (bmkp-get-bookmark-in-alist bname 'NOERROR))
-                   old-prop)
-               (when (and interactivep  (boundp 'bmkp-bookmark-set-confirms-overwrite-p)
-                          bmkp-bookmark-set-confirms-overwrite-p  (atom parg)  old-bmk
-                          (not (y-or-n-p (format "Overwrite bookmark `%s'? " bname))))
-                 (error "OK, canceled"))
-               (when old-bmk            ; Restore props of existing bookmark per `bmkp-properties-to-keep'.
-                 (if (boundp 'bmkp-properties-to-keep)
-                     (dolist (prop  bmkp-properties-to-keep)
-                       (bookmark-prop-set record prop (bookmark-prop-get old-bmk prop)))
-                   (message "You should UPDATE to the latest version of Bookmark+") (sit-for 2)))) ; $$$$$$
+             (when (and interactivep  (boundp 'bmkp-bookmark-set-confirms-overwrite-p)
+                        bmkp-bookmark-set-confirms-overwrite-p  (atom parg)
+                        (bmkp-get-bookmark-in-alist bname 'NOERROR)
+                        (not (y-or-n-p (format "Overwirte bookmark `%s'? " bname))))
+               (error "OK, canceled"))
              (bookmark-store bname (cdr record) (consp parg))
              (when (and interactivep  bmkp-prompt-for-tags-flag)
                (bmkp-add-tags bname (bmkp-read-tags-completing))) ; Don't bother to refresh tags. (?)
index ef4e53d..86c9108 100644 (file)
@@ -6,9 +6,9 @@
 ;; Maintainer: Drew Adams (concat "drew.adams" "@" "oracle" ".com")
 ;; Copyright (C) 1996-2015, Drew Adams, all rights reserved.
 ;; Created: Mon Feb 27 09:25:53 2006
-;; Last-Updated: Sat Feb  7 14:17:40 2015 (-0800)
+;; Last-Updated: Wed Jan 21 08:19:51 2015 (-0800)
 ;;           By: dradams
-;;     Update #: 15075
+;;     Update #: 15071
 ;; URL: http://www.emacswiki.org/icicles-fn.el
 ;; Doc URL: http://www.emacswiki.org/Icicles
 ;; Keywords: internal, extensions, help, abbrev, local, minibuffer,
@@ -3894,15 +3894,13 @@ over all candidates."
                           (completion--field-metadata (field-beginning))))
                   (icicle-all-completions input minibuffer-completion-table pred)))
                (icicle-extra-candidates
-                (let ((relname  (file-name-nondirectory input)))
-                  (icicle-remove-if-not
-                   (lambda (cand) (save-match-data (string-match (concat "^" (regexp-quote relname)) cand)))
-                   icicle-extra-candidates)))
+                (icicle-remove-if-not
+                 (lambda (cand) (save-match-data (string-match (concat "^" (regexp-quote input)) cand)))
+                 icicle-extra-candidates))
                (icicle-proxy-candidates
-                (let ((relname  (file-name-nondirectory input)))
-                  (icicle-remove-if-not
-                   (lambda (cand) (save-match-data (string-match (concat "^" (regexp-quote relname)) cand)))
-                   icicle-proxy-candidates)))
+                (icicle-remove-if-not
+                 (lambda (cand) (save-match-data (string-match (concat "^" (regexp-quote input)) cand)))
+                 icicle-proxy-candidates))
                (filtered-candidates
                 (icicle-transform-candidates
                  (append icicle-extra-candidates icicle-proxy-candidates
diff --git a/.emacs.d/elisp/icicle/icicles-pkg.el b/.emacs.d/elisp/icicle/icicles-pkg.el
deleted file mode 100644 (file)
index 4c6b807..0000000
+++ /dev/null
@@ -1,5 +0,0 @@
-(define-package "icicles" "20150208.1710" "Minibuffer input completion and cycling." 'nil :url "http://www.emacswiki.org/icicles.el" :keywords
-  '("extensions" "help" "abbrev" "local" "minibuffer" "keys" "apropos" "completion" "matching" "regexp" "command"))
-;; Local Variables:
-;; no-byte-compile: t
-;; End:
index 2fcec79..0857795 100644 (file)
@@ -3,6 +3,7 @@
 ;; Copyright (C) 2010-2014 Free Software Foundation, Inc.
 
 ;; Author: Eric Schulte
+;;      Thierry Banel
 ;; Keywords: literate programming, reproducible research
 ;; Homepage: http://orgmode.org
 
 
 ;;; Commentary:
 
-;; Org-Babel support for evaluating C code.
+;; 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:
-(eval-when-compile
-  (require 'cl))
 (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 '())
 
-(defvar org-babel-C-compiler "gcc"
-  "Command used to compile a C source code file into an
-executable.")
-
-(defvar org-babel-C++-compiler "g++"
-  "Command used to compile a C++ source code file into an
-executable.")
+(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++)
+  "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)
@@ -61,6 +80,11 @@ is currently being evaluated.")
 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'."
@@ -68,81 +92,169 @@ This function is called by `org-babel-execute-src-block'."
 
 (defun org-babel-expand-body:C++ (body params)
   "Expand a block of C++ code with org-babel according to it's
-header arguments (calls `org-babel-C-expand')."
-  (let ((org-babel-c-variant 'cpp)) (org-babel-C-expand body params)))
+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)
+(defun org-babel-expand-body:C (body params)
   "Expand a block of C code with org-babel according to it's
-header arguments (calls `org-babel-C-expand')."
-  (let ((org-babel-c-variant 'c)) (org-babel-C-expand body params)))
+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:C++' or `org-babel-execute:D'."
   (let* ((tmp-src-file (org-babel-temp-file
                        "C-src-"
-                       (cond
-                        ((equal org-babel-c-variant 'c) ".c")
-                        ((equal org-babel-c-variant 'cpp) ".cpp"))))
-         (tmp-bin-file (org-babel-temp-file "C-bin-" org-babel-exeext))
-         (cmdline (cdr (assoc :cmdline params)))
-         (flags (cdr (assoc :flags params)))
-         (full-body (org-babel-C-expand body params))
-         (compile
-         (progn
-           (with-temp-file tmp-src-file (insert full-body))
-           (org-babel-eval
-            (format "%s -o %s %s %s"
-                    (cond
-                     ((equal org-babel-c-variant 'c) org-babel-C-compiler)
-                     ((equal org-babel-c-variant 'cpp) org-babel-C++-compiler))
-                    (org-babel-process-file-name tmp-bin-file)
-                    (mapconcat 'identity
-                               (if (listp flags) flags (list flags)) " ")
-                    (org-babel-process-file-name tmp-src-file)) ""))))
+                       (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-trim
-            (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 "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 (body params)
+          (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)))
-        (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))))))
+       (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)))
+    (setq includes (append includes '("<string.h>" "<stdio.h>" "<stdlib.h>")))
+    (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))
-                (if (listp includes) includes (list includes)) "\n")
+                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)
@@ -177,58 +289,79 @@ support for sessions"
   "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) '("int" "%d"))
-   ((floatp val) '("double" "%f"))
+   ((integerp val) 'integerp)
+   ((floatp val) 'floatp)
    ((or (listp val) (vectorp val))
-    (lexical-let ((type (org-babel-C-val-to-C-list-type val)))
-      (list (car type)
-           (lambda (val)
-             (cons
-              (format "[%d]%s"
-                      (length val)
-                      (car (org-babel-C-format-val type (elt val 0))))
-              (concat "{ "
-                      (mapconcat (lambda (v)
-                                   (cdr (org-babel-C-format-val type v)))
-                                 val
-                                 ", ")
-                      " }"))))))
-   (t ;; treat unknown types as string
-    '("char" (lambda (val)
-              (let ((s (format "%s" val))) ;; convert to string for unknown types
-                (cons (format "[%d]" (1+ (length s)))
-                      (concat "\"" s "\""))))))))
-
-(defun org-babel-C-val-to-C-list-type (val)
-  "Determine the C array type of a VAL."
-  (let (type)
-    (mapc
-     #'(lambda (i)
-        (let* ((tmp-type (org-babel-C-val-to-C-type i))
-               (type-name (car type))
-               (tmp-type-name (car tmp-type)))
-          (when (and type (not (string= type-name tmp-type-name)))
-            (if (and (member type-name '("int" "double" "int32_t"))
-                     (member tmp-type-name '("int" "double" "int32_t")))
-                (setq tmp-type '("double" "" "%f"))
-              (error "Only homogeneous lists are supported by C.  You can not mix %s and %s"
-                     type-name
-                     tmp-type-name)))
-          (setq type tmp-type)))
-     val)
-    type))
+    (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)))
+       (val (cdr pair)))
     (when (symbolp val)
       (setq val (symbol-name val))
       (when (= (length val) 1)
-        (setq val (string-to-char val))))
+       (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))
@@ -240,6 +373,68 @@ of the same value."
              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
new file mode 100644 (file)
index 0000000..500ce9e
--- /dev/null
@@ -0,0 +1,179 @@
+;;; 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
index b97fd91..c10224a 100644 (file)
@@ -1,6 +1,6 @@
 ;;; ob-R.el --- org-babel functions for R code evaluation
 
-;; Copyright (C) 2009-2014 Free Software Foundation, Inc.
+;; Copyright (C) 2009-2015 Free Software Foundation, Inc.
 
 ;; Author: Eric Schulte
 ;;     Dan Davison
 (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)
                            (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."
   :version "24.1"
   :type 'string)
 
-(defvar ess-local-process-name) ; dynamically scoped
+(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."
-  (let ((graphics-file
-        (or graphics-file (org-babel-R-graphical-output-file params))))
-    (mapconcat
-     #'identity
-     (let ((inside
-            (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)))))))
-       (if graphics-file
-           (append
-            (list (org-babel-R-construct-graphics-device-call
-                   graphics-file params))
-            inside
-            (list "dev.off()"))
-         inside))
-     "\n")))
+  (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.
@@ -112,8 +161,20 @@ This function is called by `org-babel-execute-src-block'."
                     (cdr (assoc :session params)) params))
           (colnames-p (cdr (assoc :colnames params)))
           (rownames-p (cdr (assoc :rownames params)))
-          (graphics-file (org-babel-R-graphical-output-file params))
-          (full-body (org-babel-expand-body:R body params graphics-file))
+          (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
@@ -148,7 +209,7 @@ This function is called by `org-babel-execute-src-block'."
 
 (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))))
+  (let ((vars (mapcar 'cdr (org-babel-get-header params :var))))
     (mapcar
      (lambda (pair)
        (org-babel-R-assign-elisp
@@ -175,33 +236,23 @@ This function is called by `org-babel-execute-src-block'."
   (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))
-            (transition-file (org-babel-temp-file "R-import-")))
+            (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)))
-        (with-temp-file transition-file
-          (insert
-          (orgtbl-to-tsv value '(:fmt org-babel-R-quote-tsv-field))
-          "\n"))
-       (let ((file (org-babel-process-file-name transition-file 'noquote))
+       (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 "%s <- read.table(\"%s\",
-                      header=%s,
-                      row.names=%s,
-                      sep=\"\\t\",
-                      as.is=TRUE)" name file header row-names)
-           (format "%s <- read.table(\"%s\",
-                   header=%s,
-                   row.names=%s,
-                   sep=\"\\t\",
-                   as.is=TRUE,
-                   fill=TRUE,
-                   col.names = paste(\"V\", seq_len(%d), sep =\"\"))"
+             (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))))
-    (format "%s <- %s" name (org-babel-R-quote-tsv-field value))))
+    (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)
@@ -209,7 +260,8 @@ This function is called by `org-babel-execute-src-block'."
   (unless (string= session "none")
     (let ((session (or session "*R*"))
          (ess-ask-for-ess-directory
-          (and (and (boundp 'ess-ask-for-ess-directory) ess-ask-for-ess-directory)
+          (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
@@ -218,6 +270,10 @@ This function is called by `org-babel-execute-src-block'."
            ;; 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)
@@ -234,11 +290,6 @@ current code buffer."
        (process-name (get-buffer-process session)))
   (ess-make-buffer-current))
 
-(defun org-babel-R-graphical-output-file (params)
-  "Name of file to which R should send graphical output."
-  (and (member "graphics" (cdr (assq :result-params params)))
-       (cdr (assq :file params))))
-
 (defvar org-babel-R-graphics-devices
   '((:bmp "bmp" "filename")
     (:jpg "jpeg" "filename")
@@ -280,14 +331,43 @@ Each member of this list is a list with three members:
                              (substring (symbol-name (car pair)) 1)
                              (cdr pair)) ""))
                params ""))
-    (format "%s(%s=\"%s\"%s%s%s)"
+    (format "%s(%s=\"%s\"%s%s%s); tryCatch({"
            device filearg out-file args
            (if extra-args "," "") (or extra-args ""))))
 
-(defvar org-babel-R-eoe-indicator "'org_babel_R_eoe'")
-(defvar org-babel-R-eoe-output "[1] \"org_babel_R_eoe\"")
-
-(defvar org-babel-R-write-object-command "{function(object,transfer.file){object;invisible(if(inherits(try({tfile<-tempfile();write.table(object,file=tfile,sep=\"\\t\",na=\"nil\",row.names=%s,col.names=%s,quote=FALSE);file.rename(tfile,transfer.file)},silent=TRUE),\"try-error\")){if(!file.exists(transfer.file))file.create(transfer.file)})}}(object=%s,transfer.file=\"%s\")")
+(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)
@@ -358,7 +438,7 @@ last statement in BODY, as elisp."
        column-names-p)))
     (output
      (mapconcat
-      #'org-babel-chomp
+      'org-babel-chomp
       (butlast
        (delq nil
             (mapcar
@@ -370,7 +450,7 @@ last statement in BODY, as elisp."
                     (substring line (match-end 1))
                   line))
               (org-babel-comint-with-output (session org-babel-R-eoe-output)
-                (insert (mapconcat #'org-babel-chomp
+                (insert (mapconcat 'org-babel-chomp
                                    (list body org-babel-R-eoe-indicator)
                                    "\n"))
                 (inferior-ess-send-input)))))) "\n"))))
diff --git a/.emacs.d/elisp/org/ob-abc.el b/.emacs.d/elisp/org/ob-abc.el
new file mode 100644 (file)
index 0000000..a980b02
--- /dev/null
@@ -0,0 +1,94 @@
+;;; 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
index 21c0a17..ca58ecb 100644 (file)
@@ -1,6 +1,6 @@
 ;;; ob-asymptote.el --- org-babel functions for asymptote evaluation
 
-;; Copyright (C) 2009-2014 Free Software Foundation, Inc.
+;; Copyright (C) 2009-2015 Free Software Foundation, Inc.
 
 ;; Author: Eric Schulte
 ;; Keywords: literate programming, reproducible research
@@ -45,9 +45,6 @@
 (require 'ob)
 (eval-when-compile (require 'cl))
 
-(declare-function orgtbl-to-generic "org-table" (table params))
-(declare-function org-combine-plists "org" (&rest plists))
-
 (defvar org-babel-tangle-lang-exts)
 (add-to-list 'org-babel-tangle-lang-exts '("asymptote" . "asy"))
 
index ed98afd..a96ba1a 100644 (file)
@@ -46,9 +46,6 @@
 
 (defun org-babel-expand-body:awk (body params)
   "Expand BODY according to PARAMS, return the expanded body."
-  (dolist (pair (mapcar #'cdr (org-babel-get-header params :var)))
-    (setf body (replace-regexp-in-string
-                (regexp-quote (format "$%s" (car pair))) (cdr pair) body)))
   body)
 
 (defun org-babel-execute:awk (body params)
@@ -68,10 +65,17 @@ called by `org-babel-execute-src-block'"
                       (with-temp-file tmp
                         (insert (org-babel-awk-var-to-awk res)))
                       tmp))))
-         (cmd (mapconcat #'identity (remove nil (list org-babel-awk-command
-                                                     "-f" code-file
-                                                     cmd-line
-                                                     in-file))
+         (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
@@ -101,11 +105,6 @@ called by `org-babel-execute-src-block'"
       (mapconcat echo-var var "\n"))
      (t (funcall echo-var var)))))
 
-(defun org-babel-awk-table-or-string (results)
-  "If the results look like a table, then convert them into an
-Emacs-lisp table, otherwise return the results as a string."
-  (org-babel-script-escape results))
-
 (provide 'ob-awk)
 
 
index 78f3c6d..21a3ef8 100644 (file)
@@ -2,8 +2,8 @@
 
 ;; Copyright (C) 2009-2014 Free Software Foundation, Inc.
 
-;; Author: Joel Boehland
-;;     Eric Schulte
+;; Author: Joel Boehland, Eric Schulte, Oleh Krehel
+;;
 ;; Keywords: literate programming, reproducible research
 ;; Homepage: http://orgmode.org
 
 
 ;;; Commentary:
 
-;; Support for evaluating clojure code, relies on slime for all eval.
+;; Support for evaluating clojure code
 
-;;; Requirements:
+;; Requirements:
 
 ;; - clojure (at least 1.2.0)
 ;; - clojure-mode
-;; - slime
+;; - either cider or SLIME
 
-;; By far, the best way to install these components is by following
+;; 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)
 (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)))
                             vars "\n      ")
                            "]\n" body ")")
                  body))))
-    (cond ((or (member "code" result-params) (member "pp" result-params))
-          (format (concat "(let [org-mode-print-catcher (java.io.StringWriter.)] "
-                          "(clojure.pprint/with-pprint-dispatch clojure.pprint/%s-dispatch "
-                          "(clojure.pprint/pprint (do %s) org-mode-print-catcher) "
-                          "(str org-mode-print-catcher)))")
-                  (if (member "code" result-params) "code" "simple") body))
-         ;; if (:results output), collect printed output
-         ((member "output" result-params)
-          (format "(clojure.core/with-out-str %s)" body))
-         (t body))))
+    (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."
-  (require 'slime)
-  (with-temp-buffer
-    (insert (org-babel-expand-body:clojure body params))
-    (let ((result
-           (slime-eval
-            `(swank:eval-and-grab-output
-              ,(buffer-substring-no-properties (point-min) (point-max)))
-            (cdr (assoc :package params)))))
-      (let ((result-params (cdr (assoc :result-params params))))
-        (org-babel-result-cond result-params
-          result
-          (condition-case nil (org-babel-script-escape result)
-            (error result)))))))
+  (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
index 40bfaf7..7c768d3 100644 (file)
@@ -48,12 +48,13 @@ BUFFER is checked with `org-babel-comint-buffer-livep'.  BODY is
 executed inside the protection of `save-excursion' and
 `save-match-data'."
   (declare (indent 1))
-  `(save-excursion
+  `(progn
+     (unless (org-babel-comint-buffer-livep ,buffer)
+       (error "Buffer %s does not exist or has no process" ,buffer))
      (save-match-data
-       (unless (org-babel-comint-buffer-livep ,buffer)
-         (error "Buffer %s does not exist or has no process" ,buffer))
-       (set-buffer ,buffer)
-       ,@body)))
+       (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)
@@ -69,46 +70,42 @@ elements are optional.
 This macro ensures that the filter is removed in case of an error
 or user `keyboard-quit' during execution of body."
   (declare (indent 1))
-  (let ((buffer (car meta))
-       (eoe-indicator (cadr meta))
-       (remove-echo (cadr (cdr meta)))
-       (full-body (cadr (cdr (cdr meta)))))
+  (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 "") dangling-text raw)
-        ;; setup filter
-        (setq comint-output-filter-functions
+       (let* ((string-buffer "")
+             (comint-output-filter-functions
               (cons (lambda (text) (setq string-buffer (concat string-buffer text)))
                     comint-output-filter-functions))
-        (unwind-protect
-            (progn
-              ;; got located, and save dangling text
-              (goto-char (process-mark (get-buffer-process (current-buffer))))
-              (let ((start (point))
-                    (end (point-max)))
-                (setq dangling-text (buffer-substring start end))
-                (delete-region start end))
-              ;; pass FULL-BODY to process
-              ,@body
-              ;; wait for end-of-evaluation indicator
-              (while (progn
-                       (goto-char comint-last-input-end)
-                       (not (save-excursion
-                              (and (re-search-forward
-                                    (regexp-quote ,eoe-indicator) nil t)
-                                   (re-search-forward
-                                    comint-prompt-regexp nil t)))))
-                (accept-process-output (get-buffer-process (current-buffer)))
-                ;; thought the following this would allow async
-                ;; background running, but I was wrong...
-                ;; (run-with-timer .5 .5 'accept-process-output
-                ;;              (get-buffer-process (current-buffer)))
-                )
-              ;; replace cut dangling text
-              (goto-char (process-mark (get-buffer-process (current-buffer))))
-              (insert dangling-text))
-          ;; remove filter
-          (setq comint-output-filter-functions
-                (cdr comint-output-filter-functions)))
+             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
@@ -151,7 +148,7 @@ FILE exists at end of evaluation."
   (if (file-exists-p file) (delete-file file))
   (process-send-string
    (get-buffer-process buffer)
-   (if (string-match "\n$" string) string (concat string "\n")))
+   (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)
diff --git a/.emacs.d/elisp/org/ob-coq.el b/.emacs.d/elisp/org/ob-coq.el
new file mode 100644 (file)
index 0000000..b6ebcff
--- /dev/null
@@ -0,0 +1,77 @@
+;;; ob-coq.el --- org-babel functions for Coq
+
+;; Copyright (C) 2010-2014 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)
index eef408f..971cb64 100644 (file)
@@ -1,6 +1,6 @@
 ;;; ob-core.el --- working with code blocks in org-mode
 
-;; Copyright (C) 2009-2014 Free Software Foundation, Inc.
+;; Copyright (C) 2009-2015 Free Software Foundation, Inc.
 
 ;; Authors: Eric Schulte
 ;;     Dan Davison
@@ -39,6 +39,7 @@
 (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"
@@ -48,9 +49,8 @@
 (declare-function tramp-file-name-host "tramp" (vec))
 (declare-function with-parsed-tramp-file-name "tramp" (filename var &rest body))
 (declare-function org-icompleting-read "org" (&rest args))
-(declare-function org-edit-src-code "org-src"
-                  (&optional context code edit-buffer-name quietp))
-(declare-function org-edit-src-exit "org-src"  (&optional context))
+(declare-function org-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-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-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."
@@ -135,12 +140,16 @@ remove code block execution from the C-c C-c keybinding."
 
 (defcustom org-babel-results-keyword "RESULTS"
   "Keyword used to name results generated by code blocks.
-Should be either RESULTS or NAME however any capitalization may
-be used."
+It should be \"RESULTS\".  However any capitalization may be
+used."
   :group 'org-babel
   :version "24.4"
   :package-version '(Org . "8.0")
-  :type 'string)
+  :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.
@@ -159,6 +168,11 @@ See also `org-babel-noweb-wrap-start'."
 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
@@ -178,7 +192,7 @@ This string must include a \"%s\" which will be replaced by the results."
          "\\("
          org-babel-multi-line-header-regexp
          "\\)*"
-         "\\([^ ()\f\t\n\r\v]+\\)")
+         "\\([^()\f\t\n\r\v]+\\)")
   "Regular expression matching source name lines with a name.")
 
 (defvar org-babel-src-block-regexp
@@ -196,9 +210,9 @@ This string must include a \"%s\" which will be replaced by the results."
 (defvar org-babel-inline-src-block-regexp
   (concat
    ;; (1) replacement target (2) lang
-   "\\(?:^\\|[^-[:alnum:]]\\)\\(src_\\([^ \f\t\n\r\v]+\\)"
+   "\\(?:^\\|[^-[: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.")
@@ -212,35 +226,24 @@ not match KEY should be returned."
         (lambda (p) (when (funcall (if others #'not #'identity) (eq (car p) key)) p))
         params)))
 
-(defun org-babel-get-inline-src-block-matches()
+(defun org-babel-get-inline-src-block-matches ()
   "Set match data if within body of an inline source block.
 Returns non-nil if match-data set"
-  (let ((src-at-0-p (save-excursion
-                     (beginning-of-line 1)
-                     (string= "src" (thing-at-point 'word))))
-       (first-line-p (= (line-beginning-position) (point-min)))
-       (orig (point)))
-    (let ((search-for (cond ((and src-at-0-p first-line-p  "src_"))
-                           (first-line-p "[[:punct:] \t]src_")
-                           (t "[[:punct:] \f\t\n\r\v]src_")))
-         (lower-limit (if first-line-p
-                          nil
-                        (- (point-at-bol) 1))))
-      (save-excursion
-       (when (or (and src-at-0-p (bobp))
-                 (and (re-search-forward "}" (point-at-eol) t)
-                      (re-search-backward search-for lower-limit t)
-                      (> orig (point))))
-         (when (looking-at org-babel-inline-src-block-regexp)
-           t ))))))
+ (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()
+(defun org-babel-get-lob-one-liner-matches ()
   "Set match data if on line of an lob one liner.
 Returns non-nil if match-data set"
   (save-excursion
-    (unless (= (point) (point-at-bol)) ;; move before inline block
-      (re-search-backward "[ \f\t\n\r\v]" nil t))
+    (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)))
@@ -272,13 +275,20 @@ Returns a list
            (setq name (org-no-properties (match-string 3)))))
       ;; 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-current-export-file) ; dynamically bound
+(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.
 
@@ -288,24 +298,27 @@ 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 eval eval-no export eval-no-export)
+      (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-bound-and-true-p org-current-export-file))
+           (,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)
-                                    (funcall org-confirm-babel-evaluate
-                                             ,lang ,block-body)
+                                    (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) " ")))
@@ -396,12 +409,16 @@ a window into the `org-babel-get-src-block-info' function."
              (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 (cdr pair))
+           (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")
@@ -456,6 +473,7 @@ then run `org-babel-switch-to-session'."
     (noweb     . ((yes no tangle no-export strip-export)))
     (noweb-ref . :any)
     (noweb-sep  . :any)
+    (output-dir . :any)
     (padline   . ((yes no)))
     (post       . :any)
     (prologue   . :any)
@@ -478,14 +496,55 @@ then run `org-babel-switch-to-session'."
 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"))
+  '((: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"))
 
@@ -512,11 +571,17 @@ 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.")
+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.")
@@ -530,7 +595,7 @@ can not be resolved.")
 (defun org-babel-named-src-block-regexp-for-name (name)
   "This generates a regexp used to match a src block named NAME."
   (concat org-babel-src-name-regexp (regexp-quote name)
-         "[ \t(]*[\r\n]\\(?:^#.*[\r\n]\\)*"
+         "[ \t(]*[\r\n]\\(?:^[[:space:]]*#.*[\r\n]\\)*"
          (substring org-babel-src-block-regexp 1)))
 
 (defun org-babel-named-data-regexp-for-name (name)
@@ -566,7 +631,10 @@ block."
   (let* ((org-babel-current-src-block-location
          (or org-babel-current-src-block-location
              (nth 6 info)
-             (org-babel-where-is-src-block-head)))
+             (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)))
@@ -709,8 +777,7 @@ arguments and pop open the results in a preview buffer."
                              (funcall assignments-cmd params))))))
     (if (org-called-interactively-p 'any)
        (org-edit-src-code
-        nil expanded
-        (concat "*Org-Babel Preview " (buffer-name) "[ " lang " ]*"))
+        expanded (concat "*Org-Babel Preview " (buffer-name) "[ " lang " ]*"))
       expanded)))
 
 (defun org-babel-edit-distance (s1 s2)
@@ -770,37 +837,43 @@ arguments and pop open the results in a preview buffer."
     (message "No suspicious header arguments found.")))
 
 ;;;###autoload
-(defun org-babel-insert-header-arg ()
+(defun org-babel-insert-header-arg (&optional header-arg value)
   "Insert a header argument selecting from lists of common args and values."
   (interactive)
-  (let* ((lang (car (org-babel-get-src-block-info 'light)))
+  (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))))
-        (arg (org-icompleting-read
-              "Header Arg: "
-              (mapcar
-               (lambda (header-spec) (symbol-name (car header-spec)))
-               headers))))
-    (insert ":" arg)
-    (let ((vals (cdr (assoc (intern arg) headers))))
-      (when vals
-       (insert
-        " "
-        (cond
-         ((eq vals :any)
-          (read-from-minibuffer "value: "))
-         ((listp vals)
-          (mapconcat
-           (lambda (group)
-             (let ((arg (org-icompleting-read
-                         "value: "
-                         (cons "default" (mapcar #'symbol-name group)))))
-               (if (and arg (not (string= "default" arg)))
-                   (concat arg " ")
-                 "")))
-           vals ""))))))))
+        (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 ()
@@ -912,15 +985,15 @@ with a prefix argument then this is passed on to
     (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 nil nil nil))
+               (org-edit-src-code))
        (unwind-protect (progn ,@body)
-        (if (org-bound-and-true-p org-edit-src-from-org-mode)
-            (org-edit-src-exit)))
+        (org-edit-src-exit))
        t)))
 (def-edebug-spec org-babel-do-in-edit-buffer (body))
 
@@ -941,7 +1014,7 @@ evaluation mechanisms."
 (defvar org-bracket-link-regexp)
 
 (defun org-babel-active-location-p ()
-  (memq (car (save-match-data (org-element-context)))
+  (memq (org-element-type (save-match-data (org-element-context)))
        '(babel-call inline-babel-call inline-src-block src-block)))
 
 ;;;###autoload
@@ -995,7 +1068,8 @@ beg-body --------- point at the beginning of the body
 end-body --------- point at the end of the body"
   (declare (indent 1))
   (let ((tempvar (make-symbol "file")))
-    `(let* ((,tempvar ,file)
+    `(let* ((case-fold-search t)
+           (,tempvar ,file)
            (visited-p (or (null ,tempvar)
                           (get-file-buffer (expand-file-name ,tempvar))))
            (point (point)) to-be-removed)
@@ -1034,7 +1108,8 @@ If FILE is nil evaluate BODY forms on source blocks in current
 buffer."
   (declare (indent 1))
   (let ((tempvar (make-symbol "file")))
-    `(let* ((,tempvar ,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)
@@ -1158,7 +1233,20 @@ the current subtree."
                              (member (car arg) '(:results :exports)))
                         (mapconcat #'identity (sort (funcall rm (split-string v))
                                                     #'string<) " "))
-                       (t v)))))))
+                       (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
@@ -1167,19 +1255,19 @@ the current subtree."
                                                 (when normalized
                                                   (format "%S" normalized))))
                                             (nth 2 info))) ":")
-                         (nth 1 info)))
+                         expanded))
              (hash (sha1 it)))
         (when (org-called-interactively-p 'interactive) (message hash))
         hash))))
 
-(defun org-babel-current-result-hash ()
+(defun org-babel-current-result-hash (&optional info)
   "Return the current in-buffer hash."
-  (org-babel-where-is-src-block-result)
+  (org-babel-where-is-src-block-result nil info)
   (org-no-properties (match-string 5)))
 
-(defun org-babel-set-current-result-hash (hash)
+(defun org-babel-set-current-result-hash (hash info)
   "Set the current in-buffer hash to HASH."
-  (org-babel-where-is-src-block-result)
+  (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)
@@ -1395,7 +1483,8 @@ specified in the properties of the current outline entry."
                 (append
                  (org-babel-params-from-properties lang)
                  (list (org-babel-parse-header-arguments
-                        (org-no-properties (or (match-string 4) "")))))))))
+                        (org-no-properties (or (match-string 4) ""))))))
+         nil)))
 
 (defun org-babel-balanced-split (string alts)
   "Split STRING on instances of ALTS.
@@ -1512,7 +1601,7 @@ shown below.
 ;; row and column names
 (defun org-babel-del-hlines (table)
   "Remove all 'hlines from TABLE."
-  (remove 'hline table))
+  (remq 'hline table))
 
 (defun org-babel-get-colnames (table)
   "Return the column names of TABLE.
@@ -1608,33 +1697,20 @@ to the table for reinsertion to org-mode."
 
 (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.
+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 ((initial (point)) (case-fold-search t) top bottom)
-    (or
-     (save-excursion ;; on a source name line or a #+header line
-       (beginning-of-line 1)
-       (and (or (looking-at org-babel-src-name-regexp)
-               (looking-at org-babel-multi-line-header-regexp))
-           (progn
-             (while (and (forward-line 1)
-                         (or (looking-at org-babel-src-name-regexp)
-                             (looking-at org-babel-multi-line-header-regexp))))
-             (looking-at org-babel-src-block-regexp))
-            (point)))
-     (save-excursion ;; on a #+begin_src line
-       (beginning-of-line 1)
-       (and (looking-at org-babel-src-block-regexp)
-            (point)))
-     (save-excursion ;; inside a src block
-       (and
-        (re-search-backward "^[ \t]*#\\+begin_src" nil t) (setq top (point))
-        (re-search-forward "^[ \t]*#\\+end_src" nil t) (setq bottom (point))
-        (< top initial) (< initial bottom)
-        (progn (goto-char top) (beginning-of-line 1)
-              (looking-at org-babel-src-block-regexp))
-        (point-marker))))))
+  (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 ()
@@ -1777,10 +1853,14 @@ split.  When called from outside of a code block a new code block
 is created.  In both cases if the region is demarcated and if the
 region is not active then the point is demarcated."
   (interactive "P")
-  (let ((info (org-babel-get-src-block-info 'light))
-       (headers (progn (org-babel-where-is-src-block-head)
-                       (match-string 4)))
-       (stars (concat (make-string (or (org-current-level) 1) ?*) " ")))
+  (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)
@@ -1794,9 +1874,10 @@ region is not active then the point is demarcated."
                 (delete-region (point-at-bol) (point-at-eol)))
                (insert (concat
                        (if (looking-at "^") "" "\n")
-                       indent "#+end_src\n"
+                       indent (funcall (if lower-case-p 'downcase 'upcase) "#+end_src\n")
                        (if arg stars indent) "\n"
-                       indent "#+begin_src " lang
+                       indent (funcall (if lower-case-p 'downcase 'upcase) "#+begin_src ")
+                       lang
                        (if (> (length headers) 1)
                            (concat " " headers) headers)
                        (if (looking-at "[\n\r]")
@@ -1816,11 +1897,12 @@ region is not active then the point is demarcated."
                   (if (org-region-active-p) (mark) (point)) (point))))
        (insert (concat (if (looking-at "^") "" "\n")
                        (if arg (concat stars "\n") "")
-                       "#+begin_src " lang "\n"
+                       (funcall (if lower-case-p 'downcase 'upcase) "#+begin_src ")
+                       lang "\n"
                        body
                        (if (or (= (length body) 0)
                                (string-match "[\r\n]$" body)) "" "\n")
-                       "#+end_src\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)
@@ -1865,26 +1947,30 @@ following the source block."
          (progn (end-of-line 1)
                 (if (eobp) (insert "\n") (forward-char 1))
                 (setq end (point))
-                (or (and
-                     (not name)
-                     (progn ;; unnamed results line already exists
-                       (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))
-                            ((looking-at "^[ \t]*#") (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)))
-                             (prog1 nil
-                               (forward-line 1)
-                               (delete-region
-                                end (org-babel-result-end)))
-                           (setq end nil)))))))))))
+                (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
@@ -1912,7 +1998,7 @@ following the source block."
      ((org-at-table-p) (org-babel-read-table))
      ((org-at-item-p) (org-babel-read-list))
      ((looking-at org-bracket-link-regexp) (org-babel-read-link))
-     ((looking-at org-block-regexp) (org-babel-trim (match-string 4)))
+     ((looking-at org-block-regexp) (org-remove-indentation (match-string 4)))
      ((or (looking-at "^[ \t]*: ") (looking-at "^[ \t]*:$"))
       (setq result-string
            (org-babel-trim
@@ -1969,23 +2055,29 @@ If the path of the link is a file path it is expanded using
       (funcall echo-res result))))
 
 (defun org-babel-insert-result
-  (result &optional result-params info hash indent lang)
+    (result &optional result-params info hash indent lang)
   "Insert RESULT into the current buffer.
-By default RESULT is inserted after the end of the
-current source block.  With optional argument RESULT-PARAMS
-controls insertion of results in the org-mode file.
-RESULT-PARAMS can take the following values:
+
+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
-          replacing any previously inserted results
+          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)
+          process).
 
 file ---- the results are interpreted as a file path, and are
-          inserted into the buffer using the Org-mode file syntax
+          inserted into the buffer using the Org-mode file syntax.
 
 list ---- the results are interpreted as an Org-mode list.
 
@@ -1994,26 +2086,49 @@ raw ----- results are added directly to the Org-mode file.  This
           formatted text.
 
 drawer -- results are added directly to the Org-mode file as with
-          \"raw\", but are wrapped in a RESULTS drawer, allowing
-          them to later be replaced or removed automatically.
+          \"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.
 
-org ----- results are added inside of a \"#+BEGIN_SRC org\" block.
-          They are not comma-escaped when inserted, but Org syntax
-          here will be discarded when exporting the file.
+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.
 
-html ---- results are added inside of a #+BEGIN_HTML block.  This
-          is a good option if you code block will output html
-          formatted text.
+list ---- the results are rendered as a list.  This option not
+          allowed for inline src blocks.
 
-latex --- results are added inside of a #+BEGIN_LATEX block.
-          This is a good option if you code block will output
-          latex formatted text.
+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."
 
-code ---- the results are extracted in the syntax of the source
-          code of the language being evaluated and are added
-          inside of a #+BEGIN_SRC block with the source-code
-          language set appropriately.  Note this relies on the
-          optional LANG argument."
   (if (stringp result)
       (progn
         (setq result (org-no-properties result))
@@ -2033,11 +2148,19 @@ code ---- the results are extracted in the syntax of the source
                (when (or (org-babel-get-inline-src-block-matches)
                          (org-babel-get-lob-one-liner-matches))
                  (goto-char (match-end 0))
-                 (insert (if (listp result) "\n" " "))
+                 (org-babel-remove-inline-result)
+                 (insert " ")
                  (point))))
-            (existing-result (unless inlinep
-                               (org-babel-where-is-src-block-result
-                                t info hash indent)))
+            (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 (copy-marker (point-min)))
@@ -2074,18 +2197,37 @@ code ---- the results are extracted in the syntax of the source
                 ((member "prepend" result-params)))) ; already there
              (setq results-switches
                    (if results-switches (concat " " results-switches) ""))
-             (let ((wrap (lambda (start finish &optional no-escape)
-                           (goto-char end) (insert (concat finish "\n"))
-                           (goto-char beg) (insert (concat start "\n"))
+             (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) (goto-char (point-at-eol))
+                           (goto-char end)
+                           (unless no-newlines (goto-char (point-at-eol)))
                            (setq end (point-marker))))
-                   (proper-list-p (lambda (it) (and (listp it) (null (cdr (last it)))))))
+                   (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
+                ;; 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
@@ -2097,51 +2239,78 @@ code ---- the results are extracted in the syntax of the source
                            (if (listp result) result (split-string result "\n" t))))
                     '(:splicep nil :istart "- " :iend "\n")))
                   "\n"))
-                ;; assume the result is a table if it's not a string
-                ((funcall proper-list-p result)
+                ;; 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 (el) (or (listp el) (eq el 'hline)))
+                                       (lambda (e)
+                                         (or (eq e 'hline) (listp e)))
                                        result)
-                                      result (list result))
-                                  '(:fmt (lambda (cell) (format "%s" cell)))) "\n"))
-                 (goto-char beg) (when (org-at-table-p) (org-table-align)))
-                ((and (listp result) (not (funcall proper-list-p result)))
-                 (insert (format "%s\n" result)))
+                                      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))
+                 (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)))
-               (when (funcall proper-list-p result) (goto-char (org-table-end)))
                (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))))))
+                            (concat "#+END_" (car (org-split-string name)))
+                            nil nil (concat "{{{results(@@" name ":") "@@)}}}")))
                 ((member "html" result-params)
-                 (funcall wrap "#+BEGIN_HTML" "#+END_HTML"))
+                 (funcall wrap "#+BEGIN_HTML" "#+END_HTML" nil nil
+                          "{{{results(@@html:" "@@)}}}"))
                 ((member "latex" result-params)
-                 (funcall wrap "#+BEGIN_LaTeX" "#+END_LaTeX"))
+                 (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"))
+                 (funcall wrap "#+BEGIN_SRC org" "#+END_SRC" nil nil
+                          "{{{results(src_org{" "})}}}"))
                 ((member "code" result-params)
-                 (funcall wrap (format "#+BEGIN_SRC %s%s" (or lang "none") results-switches)
-                          "#+END_SRC"))
+                 (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))
-                ((and (not (funcall proper-list-p result))
+                 (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)))
-                 (org-babel-examplize-region beg end results-switches)
-                 (setq end (point)))))
+                 (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
@@ -2157,15 +2326,44 @@ code ---- the results are extracted in the syntax of the source
          (set-marker visible-beg nil)
          (set-marker visible-end nil))))))
 
-(defun org-babel-remove-result (&optional info)
+(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)) start)
+  (let ((location (org-babel-where-is-src-block-result nil info)))
     (when location
-      (setq start (- location 1))
       (save-excursion
-        (goto-char location) (forward-line 1)
-        (delete-region start (org-babel-result-end))))))
+        (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."
@@ -2203,18 +2401,27 @@ file's directory then expand relative links."
              result)
            (if description (concat "[" description "]") ""))))
 
-(defvar org-babel-capitalize-examplize-region-markers nil
+(defvar org-babel-capitalize-example-region-markers nil
   "Make true to capitalize begin/end example markers inserted by code blocks.")
 
-(defun org-babel-examplize-region (beg end &optional results-switches)
+(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-examplize-region-markers
-                                    (upcase str) str))))
-    (if (or (funcall chars-between (save-excursion (goto-char beg) (point-at-bol)) beg)
-           (funcall chars-between end (save-excursion (goto-char end) (point-at-eol))))
+                        (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
@@ -2242,7 +2449,8 @@ file's directory then expand relative links."
   (if (not (org-babel-where-is-src-block-head))
       (error "Not in a source block")
     (save-match-data
-      (replace-match (concat (org-babel-trim new-body) "\n") nil t nil 5))
+      (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)
@@ -2331,6 +2539,16 @@ parameters when merging lists."
                 (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)))))
@@ -2523,7 +2741,8 @@ block but are passed literally to the \"example-block\"."
                     (and expansion
                          (mapconcat #'identity (nreverse (cdr expansion)) "")))
                   ;; Possibly raise an error if named block doesn't exist.
-                  (if (member lang org-babel-noweb-error-langs)
+                  (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 "
@@ -2533,60 +2752,106 @@ block but are passed literally to the \"example-block\"."
       (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
-          (if (or force
-                  (and (stringp str)
-                       (> (length str) 2)
-                       (or (and (string-equal "[" (substring str 0 1))
-                                (string-equal "]" (substring str -1)))
-                           (and (string-equal "{" (substring str 0 1))
-                                (string-equal "}" (substring str -1)))
-                           (and (string-equal "(" (substring str 0 1))
-                                (string-equal ")" (substring str -1))))))
-              (org-babel-read
-               (concat
-                "'"
-                (let (in-single in-double out)
-                  (mapc
-                   (lambda (ch)
-                     (setq
-                      out
-                      (case ch
-                        (91 (if (or in-double in-single) ; [
-                                (cons 91 out)
-                              (cons 40 out)))
-                        (93 (if (or in-double in-single) ; ]
-                                (cons 93 out)
-                              (cons 41 out)))
-                        (123 (if (or in-double in-single) ; {
-                                 (cons 123 out)
-                               (cons 40 out)))
-                        (125 (if (or in-double in-single) ; }
-                                 (cons 125 out)
-                               (cons 41 out)))
-                        (44 (if (or in-double in-single) ; ,
-                                (cons 44 out) (cons 32 out)))
-                        (39 (if in-double ; '
-                                (cons 39 out)
-                              (setq in-single (not in-single)) (cons 34 out)))
-                        (34 (if in-single ; "
-                                (append (list 34 32) out)
-                              (setq in-double (not in-double)) (cons 34 out)))
-                        (t  (cons ch out)))))
-                   (string-to-list str))
-                  (apply #'string (reverse out)))))
-            str)))
+        (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 it as lisp,
-otherwise return it unmodified as a string.  Optional argument
-NO-LISP-EVAL inhibits lisp evaluation for situations in which is
-it not appropriate."
+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)
@@ -2637,9 +2902,9 @@ If the table is trivial, then return it as a scalar."
                       cell) t))
 
 (defun org-babel-chomp (string &optional regexp)
-  "Strip trailing spaces and carriage returns from STRING.
-Default regexp used is \"[ \f\t\n\r\v]\" but can be
-overwritten by specifying a regexp as a second argument."
+  "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)))
@@ -2647,12 +2912,12 @@ overwritten by specifying a regexp as a second argument."
     string))
 
 (defun org-babel-trim (string &optional regexp)
-  "Strip leading and trailing spaces and carriage returns from STRING.
-Like `org-babel-chomp' only it runs on both the front and back
-of the string."
-  (org-babel-chomp (org-reverse-string
-                    (org-babel-chomp (org-reverse-string string) regexp))
-                   regexp))
+  "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)
@@ -2675,11 +2940,7 @@ Fixes a bug in `tramp-handle-call-process-region'."
 
 (defun org-babel-local-file-name (file)
   "Return the local name component of FILE."
-  (if (file-remote-p file)
-      (let (localname)
-       (with-parsed-tramp-file-name file nil
-                                    localname))
-    file))
+  (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.
@@ -2688,7 +2949,7 @@ 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 (expand-file-name (org-babel-local-file-name name))))
+  (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)
@@ -2702,6 +2963,11 @@ additionally processed by `shell-quote-argument'"
 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)
@@ -2731,7 +2997,8 @@ of `org-babel-temporary-directory'."
   (if (file-remote-p default-directory)
       (let ((prefix
              (concat (file-remote-p default-directory)
-                     (expand-file-name prefix temporary-file-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)
@@ -2766,6 +3033,69 @@ of `org-babel-temporary-directory'."
 
 (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:
index 26f0e4f..888cafc 100644 (file)
@@ -90,6 +90,14 @@ This function is called by `org-babel-execute-src-block'."
         (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
@@ -97,13 +105,9 @@ This function is called by `org-babel-execute-src-block'."
                        (if eps org-ditaa-eps-jar-path org-ditaa-jar-path)))
                      " " cmdline
                      " " (org-babel-process-file-name in-file)
-                     " " (org-babel-process-file-name out-file)))
-        (pdf-cmd (when (and (or (string= (file-name-extension out-file) "pdf")
-                                (cdr (assoc :pdf params))))
-                   (concat
-                    "epstopdf"
-                    " " (org-babel-process-file-name (concat in-file ".eps"))
-                    " -o=" (org-babel-process-file-name out-file)))))
+                     " " (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))
index b35d7bb..1e399e7 100644 (file)
@@ -55,7 +55,9 @@
               (replace-regexp-in-string
                (concat "\$" (regexp-quote name))
                (if (stringp value) value (format "%S" value))
-               body))))
+               body
+               t
+               t))))
      vars)
     body))
 
diff --git a/.emacs.d/elisp/org/ob-ebnf.el b/.emacs.d/elisp/org/ob-ebnf.el
new file mode 100644 (file)
index 0000000..8c98d30
--- /dev/null
@@ -0,0 +1,85 @@
+;;; 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
index 3219344..f9f3671 100644 (file)
 ;;; Code:
 (require 'ob)
 
-(defvar org-babel-default-header-args:emacs-lisp
-  '((:hlines . "yes") (:colnames . "no"))
+(defvar org-babel-default-header-args:emacs-lisp nil
   "Default arguments for evaluating an emacs-lisp source block.")
 
-(declare-function orgtbl-to-generic "org-table" (table params))
-
 (defun org-babel-expand-body:emacs-lisp (body params)
   "Expand BODY according to PARAMS, return the expanded body."
   (let* ((vars (mapcar #'cdr (org-babel-get-header params :var)))
index 057590f..b3ce2af 100644 (file)
@@ -57,6 +57,13 @@ STDERR with `org-babel-eval-error-notify'."
          (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)))))
 
index 761c9f1..decdb8e 100644 (file)
@@ -28,7 +28,6 @@
 (eval-when-compile
   (require 'cl))
 
-(defvar org-current-export-file)
 (defvar org-babel-lob-one-liner-regexp)
 (defvar org-babel-ref-split-regexp)
 (defvar org-list-forbidden-blocks)
                  (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 type avoid-pos stealth))
 (declare-function org-fill-template "org" (template alist))
 (declare-function org-split-string "org" (string &optional separators))
-(declare-function org-element-at-point "org-element" (&optional keep-trail))
+(declare-function org-element-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
@@ -62,35 +63,35 @@ be executed."
                 (const :tag "Always" t)))
 (put 'org-export-babel-evaluate 'safe-local-variable (lambda (x) (eq x nil)))
 
-(defun org-babel-exp-get-export-buffer ()
-  "Return the current export buffer if possible."
-  (cond
-   ((bufferp org-current-export-file) org-current-export-file)
-   (org-current-export-file (get-file-buffer org-current-export-file))
-   ('otherwise
-    (error "Requested export buffer when `org-current-export-file' is nil"))))
-
 (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 (nth 4 (ignore-errors (org-heading-components))))
+         (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))
-         (original-buffer (org-babel-exp-get-export-buffer)) results)
-     (when original-buffer
-       ;; resolve parameters in the original file so that
-       ;; headline and file-wide parameters are included, attempt
-       ;; to go to the same heading in the original file
-       (set-buffer original-buffer)
+         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
+        (when heading-query
           (condition-case nil
               (let ((org-link-search-inhibit-query t))
-                (org-link-search heading))
-            (error (when heading
+                ;; 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) nil t)))))
+                     (re-search-forward (regexp-quote heading-query) nil t)))))
         (setq results ,@body))
        (set-buffer export-buffer)
        results)))
@@ -113,12 +114,14 @@ none ---- do not display either code or results upon export
 
 Assume point is at the beginning of block's starting line."
   (interactive)
-  (unless noninteractive (message "org-babel-exp processing..."))
   (save-excursion
     (let* ((info (org-babel-get-src-block-info 'light))
+          (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"))
@@ -151,138 +154,152 @@ this template."
   :type 'string)
 
 (defvar org-babel-default-lob-header-args)
-(defun org-babel-exp-process-buffer ()
-  "Execute all Babel blocks in current buffer."
+(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)
-         (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* ((info (org-babel-parse-inline-src-block-match))
-                     (params (nth 2 info)))
-                (setf (nth 1 info)
-                      (if (and (cdr (assoc :noweb params))
-                               (string= "yes" (cdr (assoc :noweb params))))
-                          (org-babel-expand-noweb-references
-                           info (org-babel-exp-get-export-buffer))
-                        (nth 1 info)))
-                (goto-char begin)
-                (let ((replacement (org-babel-exp-do-export info 'inline)))
-                  (if (equal replacement "")
-                      ;; Replacement code is empty: remove inline src
-                      ;; 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.
+         (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)
-                  (delete-region begin end)
-                  (insert rep))))
-             (src-block
-              (let* ((match-start (copy-marker (match-beginning 0)))
-                     (ind (org-get-indentation))
-                     (headers
-                      (cons
-                       (org-element-property :language element)
-                       (let ((params (org-element-property :parameters
-                                                           element)))
-                         (and params (org-split-string params "[ \t]+"))))))
-                ;; 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)))))))
+                  (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.
@@ -303,13 +320,15 @@ The function respects the value of the :exports header argument."
   (let ((silently (lambda () (let ((session (cdr (assoc :session (nth 2 info)))))
                               (when (not (and session (equal "none" session)))
                                 (org-babel-exp-results info type 'silent)))))
-       (clean (lambda () (unless (eq type 'inline) (org-babel-remove-result info)))))
+       (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))
+      ('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)))))
+            (org-babel-exp-code info type)))))
 
 (defcustom org-babel-exp-code-template
   "#+BEGIN_SRC %lang%switches%flags\n%body\n#+END_SRC"
@@ -331,7 +350,29 @@ replaced with its value."
   :group 'org-babel
   :type 'string)
 
-(defun org-babel-exp-code (info)
+(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))))
@@ -339,10 +380,12 @@ replaced with its value."
             (org-babel-noweb-wrap) "" (nth 1 info))
          (if (org-babel-noweb-p (nth 2 info) :export)
              (org-babel-expand-noweb-references
-              info (org-babel-exp-get-export-buffer))
+              info org-babel-exp-reference-buffer)
            (nth 1 info))))
   (org-fill-template
-   org-babel-exp-code-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)))
@@ -368,7 +411,7 @@ inhibit insertion of results into the buffer."
     (let ((lang (nth 0 info))
          (body (if (org-babel-noweb-p (nth 2 info) :eval)
                    (org-babel-expand-noweb-references
-                    info (org-babel-exp-get-export-buffer))
+                    info org-babel-exp-reference-buffer)
                  (nth 1 info)))
          (info (copy-sequence info))
          (org-babel-current-src-block-location (point-marker)))
diff --git a/.emacs.d/elisp/org/ob-forth.el b/.emacs.d/elisp/org/ob-forth.el
new file mode 100644 (file)
index 0000000..cc2795a
--- /dev/null
@@ -0,0 +1,86 @@
+;;; 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
index 0211fda..baeb4ba 100644 (file)
@@ -33,6 +33,7 @@
 (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"))
@@ -62,8 +63,9 @@
                     (org-babel-process-file-name tmp-src-file)) ""))))
     (let ((results
            (org-babel-trim
-            (org-babel-eval
-             (concat tmp-bin-file (if cmdline (concat " " cmdline) "")) ""))))
+            (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)
index ffe5dcf..a350186 100644 (file)
@@ -64,7 +64,7 @@
     (term       . :any))
   "Gnuplot specific header args.")
 
-(defvar org-babel-gnuplot-timestamp-fmt nil)
+(defvar org-babel-gnuplot-timestamp-fmt nil) ; Dynamically scoped.
 
 (defvar *org-babel-gnuplot-missing* nil)
 
@@ -118,14 +118,11 @@ code."
            (timefmt (cdr (assoc :timefmt params)))
            (time-ind (or (cdr (assoc :timeind params))
                          (when timefmt 1)))
-          (missing (cdr (assoc :missing params)))
           (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 missing
-       (funcall add-to-body (format "set datafile missing '%s'" missing)))
       (when sets
        (mapc (lambda (el) (funcall add-to-body (format "set %s" el))) sets))
       (when x-labels
@@ -267,15 +264,13 @@ then create one.  Return the initialized session.  The current
   "Export TABLE to DATA-FILE in a format readable by gnuplot.
 Pass PARAMS through to `orgtbl-to-generic' when exporting TABLE."
   (with-temp-file data-file
-    (make-local-variable 'org-babel-gnuplot-timestamp-fmt)
-    (setq org-babel-gnuplot-timestamp-fmt (or
-                                           (plist-get params :timefmt)
-                                           "%Y-%m-%d-%H:%M:%S"))
-    (insert (orgtbl-to-generic
-            table
-            (org-combine-plists
-             '(:sep "\t" :fmt org-babel-gnuplot-quote-tsv-field)
-             params))))
+    (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)
diff --git a/.emacs.d/elisp/org/ob-groovy.el b/.emacs.d/elisp/org/ob-groovy.el
new file mode 100644 (file)
index 0000000..8797ec9
--- /dev/null
@@ -0,0 +1,118 @@
+;;; ob-groovy.el --- org-babel functions for Groovy evaluation
+
+;; Copyright (C) 2013-2014 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
index 0006670..2e1d390 100644 (file)
@@ -84,7 +84,7 @@
               (output (mapconcat #'identity (reverse (cdr results)) "\n"))
               (value (car results)))))
        (org-babel-result-cond (cdr (assoc :result-params params))
-        result (org-babel-haskell-table-or-string result)))
+        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))
@@ -133,12 +133,6 @@ then create one.  Return the initialized session."
                    (org-babel-haskell-var-to-haskell (cdr pair))))
          (mapcar #'cdr (org-babel-get-header params :var))))
 
-(defun org-babel-haskell-table-or-string (results)
-  "Convert RESULTS to an Emacs-lisp table or string.
-If RESULTS look like a table, then convert them into an
-Emacs-lisp table, otherwise return the results as a string."
-  (org-babel-script-escape results))
-
 (defun org-babel-haskell-var-to-haskell (var)
   "Convert an elisp value VAR into a haskell variable.
 The elisp VAR is converted to a string of haskell source code
index 971b37f..c309b88 100644 (file)
@@ -62,14 +62,6 @@ called by `org-babel-execute-src-block'"
      (org-babel-pick-name
       (cdr (assoc :rowname-names params)) (cdr (assoc :rownames params))))))
 
-
-(defun org-babel-io-table-or-string (results)
-  "Convert RESULTS into an appropriate elisp value.
-If RESULTS look like a table, then convert them into an
-Emacs-lisp table, otherwise return the results as a string."
-  (org-babel-script-escape results))
-
-
 (defvar org-babel-io-wrapper-method
   "(
 %s
@@ -98,7 +90,7 @@ in BODY as elisp."
                          (concat org-babel-io-command " " src-file) "")))
                (org-babel-result-cond result-params
                 raw
-                 (org-babel-io-table-or-string raw)))))))
+                 (org-babel-script-escape raw)))))))
 
 
 (defun org-babel-prep-session:io (session params)
index 22f8785..8c64171 100644 (file)
 (defvar org-babel-tangle-lang-exts)
 (add-to-list 'org-babel-tangle-lang-exts '("java" . "java"))
 
-(defvar org-babel-java-command "java"
-  "Name of the java command.")
-
-(defvar org-babel-java-compiler "javac"
-  "Name of the java compiler.")
+(defcustom org-babel-java-command "java"
+  "Name of the java command.
+May be either a command in the path, like java
+or an absolute path name, like /usr/local/bin/java
+parameters may be used, like java -verbose"
+  :group 'org-babel
+  :version "24.3"
+  :type 'string)
+
+(defcustom org-babel-java-compiler "javac"
+  "Name of the java compiler.
+May be either a command in the path, like javac
+or an absolute path name, like /usr/local/bin/javac
+parameters may be used, like javac -verbose"
+  :group 'org-babel
+  :version "24.3"
+  :type 'string)
 
 (defun org-babel-execute:java (body params)
   (let* ((classname (or (cdr (assoc :classname params))
index 7789449..e126787 100644 (file)
@@ -97,14 +97,15 @@ This function is called by `org-babel-execute-src-block'"
 If RESULTS look like a table, then convert them into an
 Emacs-lisp table, otherwise return the results as a string."
   (org-babel-read
-   (if (and (stringp results) (string-match "^\\[.+\\]$" results))
+   (if (and (stringp results) (string-match "^\\[[^\000]+\\]$" results))
        (org-babel-read
         (concat "'"
                 (replace-regexp-in-string
                  "\\[" "(" (replace-regexp-in-string
                             "\\]" ")" (replace-regexp-in-string
-                                       ", " " " (replace-regexp-in-string
-                                                "'" "\"" results))))))
+                                       ",[[:space:]]" " "
+                                      (replace-regexp-in-string
+                                       "'" "\"" results))))))
      results)))
 
 (defun org-babel-js-var-to-js (var)
@@ -113,7 +114,7 @@ Convert an elisp value into a string of js source code
 specifying a variable of the same value."
   (if (listp var)
       (concat "[" (mapconcat #'org-babel-js-var-to-js var ", ") "]")
-    (format "%S" var)))
+    (replace-regexp-in-string "\n" "\\\\n" (format "%S" var))))
 
 (defun org-babel-prep-session:js (session params)
   "Prepare SESSION according to the header arguments specified in PARAMS."
index 90b5196..dc1f437 100644 (file)
@@ -89,6 +89,7 @@ functions which are assigned key bindings, and see
     ("h" . org-babel-describe-bindings)
     ("\C-x" . org-babel-do-key-sequence-in-edit-buffer)
     ("x" . org-babel-do-key-sequence-in-edit-buffer)
+    ("k" . org-babel-remove-result-one-or-many)
     ("\C-\M-h" . org-babel-mark-block))
   "Alist of key bindings and interactive Babel functions.
 This list associates interactive Babel functions
index 35b6650..2727a2a 100644 (file)
@@ -50,7 +50,7 @@
   '((:results . "latex") (:exports . "results"))
   "Default arguments to use when evaluating a LaTeX source block.")
 
-(defcustom org-babel-latex-htlatex ""
+(defcustom org-babel-latex-htlatex "htlatex"
   "The htlatex command to enable conversion of latex to SVG or HTML."
   :group 'org-babel
   :type 'string)
@@ -99,6 +99,51 @@ This function is called by `org-babel-execute-src-block'."
          (when (file-exists-p out-file) (delete-file out-file))
          (with-temp-file out-file
            (insert body)))
+        ((and (or (string-match "\\.svg$" out-file)
+                  (string-match "\\.html$" out-file))
+              (executable-find org-babel-latex-htlatex))
+         ;; TODO: this is a very different way of generating the
+         ;; frame latex document than in the pdf case.  Ideally, both
+         ;; would be unified.  This would prevent bugs creeping in
+         ;; such as the one fixed on Aug 16 2014 whereby :headers was
+         ;; not included in the SVG/HTML case.
+         (with-temp-file tex-file
+           (insert (concat
+                    "\\documentclass[preview]{standalone}
+\\def\\pgfsysdriver{pgfsys-tex4ht.def}
+"
+                    (mapconcat (lambda (pkg)
+                                 (concat "\\usepackage" pkg))
+                               org-babel-latex-htlatex-packages
+                               "\n")
+                    (if headers
+                        (concat "\n"
+                                (if (listp headers)
+                                    (mapconcat #'identity headers "\n")
+                                  headers) "\n")
+                      "")
+                    "\\begin{document}"
+                    body
+                    "\\end{document}")))
+         (when (file-exists-p out-file) (delete-file out-file))
+         (let ((default-directory (file-name-directory tex-file)))
+           (shell-command (format "%s %s" org-babel-latex-htlatex tex-file)))
+         (cond
+          ((file-exists-p (concat (file-name-sans-extension tex-file) "-1.svg"))
+           (if (string-match "\\.svg$" out-file)
+               (progn
+                 (shell-command "pwd")
+                 (shell-command (format "mv %s %s"
+                                        (concat (file-name-sans-extension tex-file) "-1.svg")
+                                        out-file)))
+             (error "SVG file produced but HTML file requested")))
+          ((file-exists-p (concat (file-name-sans-extension tex-file) ".html"))
+           (if (string-match "\\.html$" out-file)
+               (shell-command "mv %s %s"
+                              (concat (file-name-sans-extension tex-file)
+                                      ".html")
+                              out-file)
+             (error "HTML file produced but SVG file requested")))))
         ((or (string-match "\\.pdf$" out-file) imagemagick)
          (with-temp-file tex-file
            (require 'ox-latex)
@@ -135,51 +180,17 @@ This function is called by `org-babel-execute-src-block'."
             ((string-match "\\.pdf$" out-file)
              (rename-file transient-pdf-file out-file))
             (imagemagick
-             (convert-pdf
+             (org-babel-latex-convert-pdf
               transient-pdf-file out-file im-in-options im-out-options)
              (when (file-exists-p transient-pdf-file)
                (delete-file transient-pdf-file))))))
-        ((and (or (string-match "\\.svg$" out-file)
-                  (string-match "\\.html$" out-file))
-              (not (string= "" org-babel-latex-htlatex)))
-         (with-temp-file tex-file
-           (insert (concat
-                    "\\documentclass[preview]{standalone}
-\\def\\pgfsysdriver{pgfsys-tex4ht.def}
-"
-                    (mapconcat (lambda (pkg)
-                                 (concat "\\usepackage" pkg))
-                               org-babel-latex-htlatex-packages
-                               "\n")
-                    "\\begin{document}"
-                    body
-                    "\\end{document}")))
-         (when (file-exists-p out-file) (delete-file out-file))
-         (let ((default-directory (file-name-directory tex-file)))
-           (shell-command (format "%s %s" org-babel-latex-htlatex tex-file)))
-         (cond
-          ((file-exists-p (concat (file-name-sans-extension tex-file) "-1.svg"))
-           (if (string-match "\\.svg$" out-file)
-               (progn
-                 (shell-command "pwd")
-                 (shell-command (format "mv %s %s"
-                                        (concat (file-name-sans-extension tex-file) "-1.svg")
-                                        out-file)))
-             (error "SVG file produced but HTML file requested.")))
-          ((file-exists-p (concat (file-name-sans-extension tex-file) ".html"))
-           (if (string-match "\\.html$" out-file)
-               (shell-command "mv %s %s"
-                              (concat (file-name-sans-extension tex-file)
-                                      ".html")
-                              out-file)
-             (error "HTML file produced but SVG file requested.")))))
          ((string-match "\\.\\([^\\.]+\\)$" out-file)
           (error "Can not create %s files, please specify a .png or .pdf file or try the :imagemagick header argument"
                 (match-string 1 out-file))))
         nil) ;; signal that output has already been written to file
     body))
 
-(defun convert-pdf (pdffile out-file im-in-options im-out-options)
+(defun org-babel-latex-convert-pdf (pdffile out-file im-in-options im-out-options)
   "Generate a file from a pdf file using imagemagick."
   (let ((cmd (concat "convert " im-in-options " " pdffile " "
                     im-out-options " " out-file)))
index 9b57546..43433a3 100644 (file)
@@ -28,6 +28,8 @@
 ;;
 ;; Lilypond documentation can be found at
 ;; http://lilypond.org/manuals.html
+;;
+;; This depends on epstopdf --- See http://www.ctan.org/pkg/epstopdf.
 
 ;;; Code:
 (require 'ob)
 (defvar org-babel-default-header-args:lilypond '()
   "Default header arguments for lilypond code blocks.
 NOTE: The arguments are determined at lilypond compile time.
-See (ly-set-header-args)")
+See (org-babel-lilypond-set-header-args)")
 
-(defvar ly-compile-post-tangle t
+(defvar org-babel-lilypond-compile-post-tangle t
   "Following the org-babel-tangle (C-c C-v t) command,
-ly-compile-post-tangle determines whether ob-lilypond should
+org-babel-lilypond-compile-post-tangle determines whether ob-lilypond should
 automatically attempt to compile the resultant tangled file.
 If the value is nil, no automated compilation takes place.
 Default value is t")
 
-(defvar ly-display-pdf-post-tangle t
+(defvar org-babel-lilypond-display-pdf-post-tangle t
   "Following a successful LilyPond compilation
-ly-display-pdf-post-tangle determines whether to automate the
+org-babel-lilypond-display-pdf-post-tangle determines whether to automate the
 drawing / redrawing of the resultant pdf.  If the value is nil,
 the pdf is not automatically redrawn.  Default value is t")
 
-(defvar ly-play-midi-post-tangle t
+(defvar org-babel-lilypond-play-midi-post-tangle t
   "Following a successful LilyPond compilation
-ly-play-midi-post-tangle determines whether to automate the
+org-babel-lilypond-play-midi-post-tangle determines whether to automate the
 playing of the resultant midi file.  If the value is nil,
 the midi file is not automatically played.  Default value is t")
 
-(defvar ly-OSX-ly-path
-  "/Applications/lilypond.app/Contents/Resources/bin/lilypond")
-(defvar ly-OSX-pdf-path "open")
-(defvar ly-OSX-midi-path "open")
-
-(defvar ly-nix-ly-path "/usr/bin/lilypond")
-(defvar ly-nix-pdf-path "evince")
-(defvar ly-nix-midi-path "timidity")
-
-(defvar ly-w32-ly-path "lilypond")
-(defvar ly-w32-pdf-path "")
-(defvar ly-w32-midi-path "")
-
-(defvar ly-gen-png nil
+(defconst org-babel-lilypond-ly-command
+  "Command to execute lilypond on your system.")
+(defconst org-babel-lilypond-pdf-command
+  "Command to show a PDF file on your system.")
+(defconst org-babel-lilypond-midi-command
+  "Command to play a MIDI file on your system.")
+(defcustom org-babel-lilypond-commands
+  (cond
+   ((eq system-type 'darwin)
+    '("/Applications/lilypond.app/Contents/Resources/bin/lilypond" "open" "open"))
+   ((eq system-type 'windows-nt)
+    '("lilypond" "" ""))
+   (t
+    '("lilypond" "xdg-open" "xdg-open")))
+  "Commands to run lilypond and view or play the results.
+These should be executables that take a filename as an argument.
+On some system it is possible to specify the filename directly
+and the viewer or player will be determined from the file type;
+you can leave the string empty on this case."
+  :group 'org-babel
+  :type '(list
+         (string :tag "Lilypond   ")
+         (string :tag "PDF Viewer ")
+         (string :tag "MIDI Player"))
+  :version "24.3"
+  :package-version '(Org . "8.2.7")
+  :set
+  (lambda (symbol value)
+    (setq
+     org-babel-lilypond-ly-command   (nth 0 value)
+     org-babel-lilypond-pdf-command  (nth 1 value)
+     org-babel-lilypond-midi-command (nth 2 value))))
+
+(defvar org-babel-lilypond-gen-png nil
   "Image generation (png) can be turned on by default by setting
-LY-GEN-PNG to t")
+ORG-BABEL-LILYPOND-GEN-PNG to t")
 
-(defvar ly-gen-svg nil
+(defvar org-babel-lilypond-gen-svg nil
   "Image generation (SVG) can be turned on by default by setting
-LY-GEN-SVG to t")
+ORG-BABEL-LILYPOND-GEN-SVG to t")
 
-(defvar ly-gen-html nil
+(defvar org-babel-lilypond-gen-html nil
   "HTML generation can be turned on by default by setting
-LY-GEN-HTML to t")
+ORG-BABEL-LILYPOND-GEN-HTML to t")
 
-(defvar ly-gen-pdf nil
+(defvar org-babel-lilypond-gen-pdf nil
   "PDF generation can be turned on by default by setting
-LY-GEN-PDF to t")
+ORG-BABEL-LILYPOND-GEN-PDF to t")
 
-(defvar ly-use-eps nil
+(defvar org-babel-lilypond-use-eps nil
   "You can force the compiler to use the EPS backend by setting
-LY-USE-EPS to t")
+ORG-BABEL-LILYPOND-USE-EPS to t")
 
-(defvar ly-arrange-mode nil
-  "Arrange mode is turned on by setting LY-ARRANGE-MODE
+(defvar org-babel-lilypond-arrange-mode nil
+  "Arrange mode is turned on by setting ORG-BABEL-LILYPOND-ARRANGE-MODE
 to t.  In Arrange mode the following settings are altered
 from default...
 :tangle yes,    :noweb yes
@@ -123,20 +145,20 @@ Depending on whether we are in arrange mode either:
 1. Attempt to execute lilypond block according to header settings
   (This is the default basic mode)
 2. Tangle all lilypond blocks and process the result (arrange mode)"
-  (ly-set-header-args ly-arrange-mode)
-  (if ly-arrange-mode
-      (ly-tangle)
-    (ly-process-basic body params)))
+  (org-babel-lilypond-set-header-args org-babel-lilypond-arrange-mode)
+  (if org-babel-lilypond-arrange-mode
+      (org-babel-lilypond-tangle)
+    (org-babel-lilypond-process-basic body params)))
 
-(defun ly-tangle ()
+(defun org-babel-lilypond-tangle ()
   "ob-lilypond specific tangle, attempts to invoke
 =ly-execute-tangled-ly= if tangle is successful.  Also passes
 specific arguments to =org-babel-tangle="
   (interactive)
   (if (org-babel-tangle nil "yes" "lilypond")
-      (ly-execute-tangled-ly) nil))
+      (org-babel-lilypond-execute-tangled-ly) nil))
 
-(defun ly-process-basic (body params)
+(defun org-babel-lilypond-process-basic (body params)
   "Execute a lilypond block in basic mode."
   (let* ((result-params (cdr (assoc :result-params params)))
         (out-file (cdr (assoc :file params)))
@@ -148,7 +170,7 @@ specific arguments to =org-babel-tangle="
       (insert (org-babel-expand-body:generic body params)))
     (org-babel-eval
      (concat
-      (ly-determine-ly-path)
+      org-babel-lilypond-ly-command
       " -dbackend=eps "
       "-dno-gs-load-fonts "
       "-dinclude-eps-fonts "
@@ -167,45 +189,43 @@ specific arguments to =org-babel-tangle="
   "Return an error because LilyPond exporter does not support sessions."
   (error "Sorry, LilyPond does not currently support sessions!"))
 
-(defun ly-execute-tangled-ly ()
+(defun org-babel-lilypond-execute-tangled-ly ()
   "Compile result of block tangle with lilypond.
 If error in compilation, attempt to mark the error in lilypond org file"
-  (when ly-compile-post-tangle
-    (let ((ly-tangled-file (ly-switch-extension
+  (when org-babel-lilypond-compile-post-tangle
+    (let ((org-babel-lilypond-tangled-file (org-babel-lilypond-switch-extension
                             (buffer-file-name) ".lilypond"))
-          (ly-temp-file (ly-switch-extension
+          (org-babel-lilypond-temp-file (org-babel-lilypond-switch-extension
                          (buffer-file-name) ".ly")))
-      (if (file-exists-p ly-tangled-file)
-          (progn
-            (when (file-exists-p ly-temp-file)
-              (delete-file ly-temp-file))
-            (rename-file ly-tangled-file
-                         ly-temp-file))
-        (error "Error: Tangle Failed!") t)
+      (if (not (file-exists-p org-babel-lilypond-tangled-file))
+         (error "Error: Tangle Failed!")
+       (when (file-exists-p org-babel-lilypond-temp-file)
+         (delete-file org-babel-lilypond-temp-file))
+       (rename-file org-babel-lilypond-tangled-file
+                    org-babel-lilypond-temp-file))
       (switch-to-buffer-other-window "*lilypond*")
       (erase-buffer)
-      (ly-compile-lilyfile ly-temp-file)
+      (org-babel-lilypond-compile-lilyfile org-babel-lilypond-temp-file)
       (goto-char (point-min))
-      (if (not (ly-check-for-compile-error ly-temp-file))
-          (progn
-            (other-window -1)
-            (ly-attempt-to-open-pdf ly-temp-file)
-            (ly-attempt-to-play-midi ly-temp-file))
-        (error "Error in Compilation!")))) nil)
-
-(defun ly-compile-lilyfile (file-name &optional test)
+      (if (org-babel-lilypond-check-for-compile-error org-babel-lilypond-temp-file)
+         (error "Error in Compilation!")
+       (other-window -1)
+       (org-babel-lilypond-attempt-to-open-pdf org-babel-lilypond-temp-file)
+       (org-babel-lilypond-attempt-to-play-midi org-babel-lilypond-temp-file)))))
+
+(defun org-babel-lilypond-compile-lilyfile (file-name &optional test)
   "Compile lilypond file and check for compile errors
 FILE-NAME is full path to lilypond (.ly) file"
   (message "Compiling LilyPond...")
-  (let ((arg-1 (ly-determine-ly-path)) ;program
+  (let ((arg-1 org-babel-lilypond-ly-command) ;program
         (arg-2 nil)                    ;infile
         (arg-3 "*lilypond*")           ;buffer
        (arg-4 t)                      ;display
-       (arg-5 (if ly-gen-png  "--png"  "")) ;&rest...
-       (arg-6 (if ly-gen-html "--html" ""))
-        (arg-7 (if ly-gen-pdf "--pdf" ""))
-        (arg-8 (if ly-use-eps  "-dbackend=eps" ""))
-        (arg-9 (if ly-gen-svg  "-dbackend=svg" ""))
+       (arg-5 (if org-babel-lilypond-gen-png  "--png"  "")) ;&rest...
+       (arg-6 (if org-babel-lilypond-gen-html "--html" ""))
+        (arg-7 (if org-babel-lilypond-gen-pdf "--pdf" ""))
+        (arg-8 (if org-babel-lilypond-use-eps  "-dbackend=eps" ""))
+        (arg-9 (if org-babel-lilypond-gen-svg  "-dbackend=svg" ""))
         (arg-10 (concat "--output=" (file-name-sans-extension file-name)))
         (arg-11 file-name))
     (if test
@@ -215,7 +235,7 @@ FILE-NAME is full path to lilypond (.ly) file"
        arg-1 arg-2 arg-3 arg-4 arg-5 arg-6
        arg-7 arg-8 arg-9 arg-10 arg-11))))
 
-(defun ly-check-for-compile-error (file-name &optional test)
+(defun org-babel-lilypond-check-for-compile-error (file-name &optional test)
   "Check for compile error.
 This is performed by parsing the *lilypond* buffer
 containing the output message from the compilation.
@@ -223,27 +243,26 @@ FILE-NAME is full path to lilypond file.
 If TEST is t just return nil if no error found, and pass
 nil as file-name since it is unused in this context"
   (let ((is-error (search-forward "error:" nil t)))
-    (if (not test)
-        (if (not is-error)
-            nil
-          (ly-process-compile-error file-name))
-      is-error)))
+    (if test
+       is-error
+      (when is-error
+       (org-babel-lilypond-process-compile-error file-name)))))
 
-(defun ly-process-compile-error (file-name)
+(defun org-babel-lilypond-process-compile-error (file-name)
   "Process the compilation error that has occurred.
 FILE-NAME is full path to lilypond file"
-  (let ((line-num (ly-parse-line-num)))
-    (let ((error-lines (ly-parse-error-line file-name line-num)))
-      (ly-mark-error-line file-name error-lines)
+  (let ((line-num (org-babel-lilypond-parse-line-num)))
+    (let ((error-lines (org-babel-lilypond-parse-error-line file-name line-num)))
+      (org-babel-lilypond-mark-error-line file-name error-lines)
       (error "Error: Compilation Failed!"))))
 
-(defun ly-mark-error-line (file-name line)
+(defun org-babel-lilypond-mark-error-line (file-name line)
   "Mark the erroneous lines in the lilypond org buffer.
 FILE-NAME is full path to lilypond file.
 LINE is the erroneous line"
   (switch-to-buffer-other-window
    (concat (file-name-nondirectory
-            (ly-switch-extension file-name ".org"))))
+            (org-babel-lilypond-switch-extension file-name ".org"))))
   (let ((temp (point)))
     (goto-char (point-min))
     (setq case-fold-search nil)
@@ -254,7 +273,7 @@ LINE is the erroneous line"
           (goto-char (- (point) (length line))))
       (goto-char temp))))
 
-(defun ly-parse-line-num (&optional buffer)
+(defun org-babel-lilypond-parse-line-num (&optional buffer)
   "Extract error line number."
   (when buffer
     (set-buffer buffer))
@@ -276,12 +295,12 @@ LINE is the erroneous line"
               nil)))
       nil)))
 
-(defun ly-parse-error-line (file-name lineNo)
+(defun org-babel-lilypond-parse-error-line (file-name lineNo)
   "Extract the erroneous line from the tangled .ly file
 FILE-NAME is full path to lilypond file.
 LINENO is the number of the erroneous line"
   (with-temp-buffer
-    (insert-file-contents (ly-switch-extension file-name ".ly")
+    (insert-file-contents (org-babel-lilypond-switch-extension file-name ".ly")
                          nil nil nil t)
     (if (> lineNo 0)
        (progn
@@ -290,128 +309,95 @@ LINENO is the number of the erroneous line"
          (buffer-substring (point) (point-at-eol)))
       nil)))
 
-(defun ly-attempt-to-open-pdf (file-name &optional test)
+(defun org-babel-lilypond-attempt-to-open-pdf (file-name &optional test)
   "Attempt to display the generated pdf file
 FILE-NAME is full path to lilypond file
 If TEST is non-nil, the shell command is returned and is not run"
-  (when ly-display-pdf-post-tangle
-    (let ((pdf-file (ly-switch-extension file-name ".pdf")))
+  (when org-babel-lilypond-display-pdf-post-tangle
+    (let ((pdf-file (org-babel-lilypond-switch-extension file-name ".pdf")))
       (if (file-exists-p pdf-file)
           (let ((cmd-string
-                 (concat (ly-determine-pdf-path) " " pdf-file)))
+                 (concat org-babel-lilypond-pdf-command " " pdf-file)))
             (if test
                 cmd-string
              (start-process
               "\"Audition pdf\""
               "*lilypond*"
-              (ly-determine-pdf-path)
+              org-babel-lilypond-pdf-command
               pdf-file)))
        (message  "No pdf file generated so can't display!")))))
 
-(defun ly-attempt-to-play-midi (file-name &optional test)
+(defun org-babel-lilypond-attempt-to-play-midi (file-name &optional test)
   "Attempt to play the generated MIDI file
 FILE-NAME is full path to lilypond file
 If TEST is non-nil, the shell command is returned and is not run"
-  (when ly-play-midi-post-tangle
-    (let ((midi-file (ly-switch-extension file-name ".midi")))
+  (when org-babel-lilypond-play-midi-post-tangle
+    (let ((midi-file (org-babel-lilypond-switch-extension file-name ".midi")))
       (if (file-exists-p midi-file)
           (let ((cmd-string
-                 (concat (ly-determine-midi-path) " " midi-file)))
+                 (concat org-babel-lilypond-midi-command " " midi-file)))
             (if test
                 cmd-string
               (start-process
                "\"Audition midi\""
                "*lilypond*"
-               (ly-determine-midi-path)
+               org-babel-lilypond-midi-command
                midi-file)))
         (message "No midi file generated so can't play!")))))
 
-(defun ly-determine-ly-path (&optional test)
-  "Return correct path to ly binary depending on OS
-If TEST is non-nil, it contains a simulation of the OS for test purposes"
-  (let ((sys-type
-         (or test system-type)))
-    (cond ((string= sys-type  "darwin")
-           ly-OSX-ly-path)
-          ((string= sys-type "windows-nt")
-           ly-w32-ly-path)
-          (t ly-nix-ly-path))))
-
-(defun ly-determine-pdf-path (&optional test)
-  "Return correct path to pdf viewer depending on OS
-If TEST is non-nil, it contains a simulation of the OS for test purposes"
-  (let ((sys-type
-         (or test system-type)))
-    (cond ((string= sys-type  "darwin")
-           ly-OSX-pdf-path)
-          ((string= sys-type "windows-nt")
-           ly-w32-pdf-path)
-          (t ly-nix-pdf-path))))
-
-(defun ly-determine-midi-path (&optional test)
-  "Return correct path to midi player depending on OS
-If TEST is non-nil, it contains a simulation of the OS for test purposes"
-  (let ((sys-type
-         (or test test system-type)))
-    (cond ((string= sys-type  "darwin")
-           ly-OSX-midi-path)
-          ((string= sys-type "windows-nt")
-           ly-w32-midi-path)
-          (t ly-nix-midi-path))))
-
-(defun ly-toggle-midi-play ()
+(defun org-babel-lilypond-toggle-midi-play ()
   "Toggle whether midi will be played following a successful compilation."
   (interactive)
-  (setq ly-play-midi-post-tangle
-        (not ly-play-midi-post-tangle))
+  (setq org-babel-lilypond-play-midi-post-tangle
+        (not org-babel-lilypond-play-midi-post-tangle))
   (message (concat "Post-Tangle MIDI play has been "
-                   (if ly-play-midi-post-tangle
+                   (if org-babel-lilypond-play-midi-post-tangle
                        "ENABLED." "DISABLED."))))
 
-(defun ly-toggle-pdf-display ()
+(defun org-babel-lilypond-toggle-pdf-display ()
   "Toggle whether pdf will be displayed following a successful compilation."
   (interactive)
-  (setq ly-display-pdf-post-tangle
-        (not ly-display-pdf-post-tangle))
+  (setq org-babel-lilypond-display-pdf-post-tangle
+        (not org-babel-lilypond-display-pdf-post-tangle))
   (message (concat "Post-Tangle PDF display has been "
-                   (if ly-display-pdf-post-tangle
+                   (if org-babel-lilypond-display-pdf-post-tangle
                        "ENABLED." "DISABLED."))))
 
-(defun ly-toggle-png-generation ()
+(defun org-babel-lilypond-toggle-png-generation ()
   "Toggle whether png image will be generated by compilation."
   (interactive)
-  (setq ly-gen-png (not ly-gen-png))
+  (setq org-babel-lilypond-gen-png (not org-babel-lilypond-gen-png))
   (message (concat "PNG image generation has been "
-                   (if ly-gen-png "ENABLED." "DISABLED."))))
+                   (if org-babel-lilypond-gen-png "ENABLED." "DISABLED."))))
 
-(defun ly-toggle-html-generation ()
+(defun org-babel-lilypond-toggle-html-generation ()
   "Toggle whether html will be generated by compilation."
   (interactive)
-  (setq ly-gen-html (not ly-gen-html))
+  (setq org-babel-lilypond-gen-html (not org-babel-lilypond-gen-html))
   (message (concat "HTML generation has been "
-                   (if ly-gen-html "ENABLED." "DISABLED."))))
+                   (if org-babel-lilypond-gen-html "ENABLED." "DISABLED."))))
 
-(defun ly-toggle-pdf-generation ()
+(defun org-babel-lilypond-toggle-pdf-generation ()
   "Toggle whether pdf will be generated by compilation."
   (interactive)
-  (setq ly-gen-pdf (not ly-gen-pdf))
+  (setq org-babel-lilypond-gen-pdf (not org-babel-lilypond-gen-pdf))
   (message (concat "PDF generation has been "
-                   (if ly-gen-pdf "ENABLED." "DISABLED."))))
+                   (if org-babel-lilypond-gen-pdf "ENABLED." "DISABLED."))))
 
-(defun ly-toggle-arrange-mode ()
+(defun org-babel-lilypond-toggle-arrange-mode ()
   "Toggle whether in Arrange mode or Basic mode."
   (interactive)
-  (setq ly-arrange-mode
-        (not ly-arrange-mode))
+  (setq org-babel-lilypond-arrange-mode
+        (not org-babel-lilypond-arrange-mode))
   (message (concat "Arrange mode has been "
-                   (if ly-arrange-mode "ENABLED." "DISABLED."))))
+                   (if org-babel-lilypond-arrange-mode "ENABLED." "DISABLED."))))
 
-(defun ly-switch-extension (file-name ext)
+(defun org-babel-lilypond-switch-extension (file-name ext)
   "Utility command to swap current FILE-NAME extension with EXT"
   (concat (file-name-sans-extension
            file-name) ext))
 
-(defun ly-get-header-args (mode)
+(defun org-babel-lilypond-get-header-args (mode)
   "Default arguments to use when evaluating a lilypond
 source block.  These depend upon whether we are in arrange
 mode i.e.  ARRANGE-MODE is t"
@@ -425,11 +411,11 @@ mode i.e.  ARRANGE-MODE is t"
          '((:results . "file")
            (:exports . "results")))))
 
-(defun ly-set-header-args (mode)
+(defun org-babel-lilypond-set-header-args (mode)
   "Set org-babel-default-header-args:lilypond
-dependent on LY-ARRANGE-MODE"
+dependent on ORG-BABEL-LILYPOND-ARRANGE-MODE"
   (setq org-babel-default-header-args:lilypond
-        (ly-get-header-args mode)))
+        (org-babel-lilypond-get-header-args mode)))
 
 (provide 'ob-lilypond)
 
index 6bddd61..a59dab3 100644 (file)
@@ -44,7 +44,7 @@
 (defvar org-babel-header-args:lisp '((package . :any)))
 
 (defcustom org-babel-lisp-dir-fmt
-  "(let ((*default-pathname-defaults* #P%S)) %%s)"
+  "(let ((*default-pathname-defaults* #P%S\n)) %%s\n)"
   "Format string used to wrap code bodies to set the current directory.
 For example a value of \"(progn ;; %s\\n   %%s)\" would ignore the
 current directory string."
@@ -76,23 +76,25 @@ current directory string."
   (require 'slime)
   (org-babel-reassemble-table
    (let ((result
-          (with-temp-buffer
-            (insert (org-babel-expand-body:lisp body params))
-            (slime-eval `(swank:eval-and-grab-output
-                          ,(let ((dir (if (assoc :dir params)
-                                          (cdr (assoc :dir params))
-                                        default-directory)))
-                             (format
-                              (if dir (format org-babel-lisp-dir-fmt dir)
-                                "(progn %s)")
-                              (buffer-substring-no-properties
-                               (point-min) (point-max)))))
-                        (cdr (assoc :package params))))))
+         (funcall (if (member "output" (cdr (assoc :result-params params)))
+                      #'car #'cadr)
+                  (with-temp-buffer
+                    (insert (org-babel-expand-body:lisp body params))
+                    (slime-eval `(swank:eval-and-grab-output
+                                  ,(let ((dir (if (assoc :dir params)
+                                                  (cdr (assoc :dir params))
+                                                default-directory)))
+                                     (format
+                                      (if dir (format org-babel-lisp-dir-fmt dir)
+                                        "(progn %s\n)")
+                                      (buffer-substring-no-properties
+                                       (point-min) (point-max)))))
+                                (cdr (assoc :package params)))))))
      (org-babel-result-cond (cdr (assoc :result-params params))
-       (car result)
+       result
        (condition-case nil
-           (read (org-babel-lisp-vector-to-list (cadr result)))
-         (error (cadr result)))))
+           (read (org-babel-lisp-vector-to-list result))
+         (error result))))
    (org-babel-pick-name (cdr (assoc :colname-names params))
                        (cdr (assoc :colnames params)))
    (org-babel-pick-name (cdr (assoc :rowname-names params))
index 4e635da..0267f44 100644 (file)
@@ -1,6 +1,6 @@
 ;;; ob-lob.el --- functions supporting the Library of Babel
 
-;; Copyright (C) 2009-2014 Free Software Foundation, Inc.
+;; Copyright (C) 2009-2015 Free Software Foundation, Inc.
 
 ;; Authors: Eric Schulte
 ;;      Dan Davison
@@ -70,8 +70,8 @@ To add files to this list use the `org-babel-lob-ingest' command."
 
 (defconst org-babel-inline-lob-one-liner-regexp
   (concat
-   "\\([^\n]*?\\)call_\\([^\(\)\n]+?\\)\\(\\[\\(.*?\\)\\]\\|\\(\\)\\)"
-   "\(\\([^\n]*?\\)\)\\(\\[\\(.*?\\)\\]\\)?")
+   "\\([^\n]*?\\)call_\\([^\(\)[:space:]\n]+?\\)\\(\\[\\(.*?\\)\\]\\|\\(\\)\\)"
+   "\(\\(.*?\\)\)\\(\\[\\(.*?\\)\\]\\)?")
   "Regexp to match inline calls to predefined source block functions.")
 
 (defconst org-babel-lob-one-liner-regexp
@@ -116,9 +116,10 @@ if so then run the appropriate source block from the Library."
                           (match-string 2) (match-string 11)))
               (save-excursion
                 (forward-line -1)
-                (and (looking-at (concat org-babel-src-name-regexp
-                                         "\\([^\n]*\\)$"))
-                     (org-no-properties (match-string 1))))))))))
+                (save-match-data
+                  (and (looking-at (concat org-babel-src-name-regexp
+                                           "\\([^\n]*\\)$"))
+                       (org-no-properties (match-string 1)))))))))))
 
 (defvar org-babel-default-header-args:emacs-lisp) ; Defined in ob-emacs-lisp.el
 (defun org-babel-lob-execute (info)
@@ -142,18 +143,32 @@ if so then run the appropriate source block from the Library."
         (pre-info (funcall mkinfo pre-params))
         (cache-p (and (cdr (assoc :cache pre-params))
                       (string= "yes" (cdr (assoc :cache pre-params)))))
-        (new-hash (when cache-p (org-babel-sha1-hash pre-info)))
-        (old-hash (when cache-p (org-babel-current-result-hash)))
+        (new-hash (when cache-p
+                    (org-babel-sha1-hash
+                     ;; Do *not* pre-process params for call line
+                     ;; hash evaluation, since for a call line :var
+                     ;; extension *is* execution.
+                     (let* ((params (nth 2 pre-info))
+                            (sha1-nth2 (list
+                                   (cons
+                                    (cons :c-var (cdr (assoc :var params)))
+                                    (assq-delete-all :var (copy-tree params)))))
+                            (sha1-info (copy-tree pre-info)))
+                       (prog1 sha1-info
+                         (setcar (cddr sha1-info) sha1-nth2))))))
+        (old-hash (when cache-p (org-babel-current-result-hash pre-info)))
         (org-babel-current-src-block-location (point-marker)))
     (if (and cache-p (equal new-hash old-hash))
-       (save-excursion (goto-char (org-babel-where-is-src-block-result))
+       (save-excursion (goto-char (org-babel-where-is-src-block-result
+                                   nil pre-info))
                        (forward-line 1)
                        (message "%S" (org-babel-read-result)))
       (prog1 (let* ((proc-params (org-babel-process-params pre-params))
                     org-confirm-babel-evaluate)
               (org-babel-execute-src-block nil (funcall mkinfo proc-params)))
        ;; update the hash
-       (when new-hash (org-babel-set-current-result-hash new-hash))))))
+       (when new-hash
+         (org-babel-set-current-result-hash new-hash pre-info))))))
 
 (provide 'ob-lob)
 
index 7435f1d..4e559d1 100644 (file)
@@ -52,7 +52,7 @@
     (mapconcat 'identity
               (list
                ;; graphic output
-               (let ((graphic-file (org-babel-maxima-graphical-output-file params)))
+               (let ((graphic-file (ignore-errors (org-babel-graphical-output-file params))))
                  (if graphic-file
                      (format
                       "set_plot_option ([gnuplot_term, png]); set_plot_option ([gnuplot_out_file, %S]);"
@@ -89,7 +89,7 @@ This function is called by `org-babel-execute-src-block'."
                                           (= 0 (length line)))
                                 line))
                             (split-string raw "[\r\n]"))) "\n")))))
-    (if (org-babel-maxima-graphical-output-file params)
+    (if (ignore-errors (org-babel-graphical-output-file params))
        nil
       (org-babel-result-cond result-params
        result
@@ -113,11 +113,6 @@ of the same value."
     (format "%S: %s$" var
            (org-babel-maxima-elisp-to-maxima val))))
 
-(defun org-babel-maxima-graphical-output-file (params)
-  "Name of file to which maxima should send graphical output."
-  (and (member "graphics" (cdr (assq :result-params params)))
-       (cdr (assq :file params))))
-
 (defun org-babel-maxima-elisp-to-maxima (val)
   "Return a string of maxima code which evaluates to VAL."
   (if (listp val)
index 1f29a25..9cd72b3 100644 (file)
@@ -1,6 +1,6 @@
 ;;; ob-ocaml.el --- org-babel functions for ocaml evaluation
 
-;; Copyright (C) 2009-2014 Free Software Foundation, Inc.
+;; Copyright (C) 2009-2015 Free Software Foundation, Inc.
 
 ;; Author: Eric Schulte
 ;; Keywords: literate programming, reproducible research
@@ -70,7 +70,8 @@
                  (session org-babel-ocaml-eoe-output t full-body)
                (insert
                 (concat
-                 (org-babel-chomp full-body)";;\n"org-babel-ocaml-eoe-indicator))
+                 (org-babel-chomp full-body) ";;\n"
+                 org-babel-ocaml-eoe-indicator))
                (tuareg-interactive-send-input)))
         (clean
          (car (let ((re (regexp-quote org-babel-ocaml-eoe-output)) out)
                                         (progn (setq out nil) line)
                                       (when (string-match re line)
                                         (progn (setq out t) nil))))
-                                  (mapcar #'org-babel-trim (reverse raw))))))))
+                                  (mapcar #'org-babel-trim (reverse raw)))))))
+        (raw (org-babel-trim clean))
+        (result-params (cdr (assoc :result-params params)))
+        (parsed 
+         (string-match 
+          "\\(\\(.*\n\\)*\\)[^:\n]+ : \\([^=\n]+\\) =\\(\n\\| \\)\\(.+\\)$" 
+          raw))
+        (output (match-string 1 raw))
+        (type (match-string 3 raw))
+        (value (match-string 5 raw)))
     (org-babel-reassemble-table
-     (let ((raw (org-babel-trim clean))
-          (result-params (cdr (assoc :result-params params))))
-       (org-babel-result-cond result-params
-        ;; strip type information from output unless verbatim is specified
-        (if (and (not (member "verbatim" result-params))
-                 (string-match "= \\(.+\\)$" raw))
-            (match-string 1 raw) raw)
-        (org-babel-ocaml-parse-output raw)))
+     (org-babel-result-cond result-params
+       (cond
+       ((member "verbatim" result-params) raw)
+       ((member "output" result-params) output)
+       (t raw))
+       (if (and value type)
+          (org-babel-ocaml-parse-output value type)
+        raw))
      (org-babel-pick-name
       (cdr (assoc :colname-names params)) (cdr (assoc :colnames params)))
      (org-babel-pick-name
       (concat "[|" (mapconcat #'org-babel-ocaml-elisp-to-ocaml val "; ") "|]")
     (format "%S" val)))
 
-(defun org-babel-ocaml-parse-output (output)
-  "Parse OUTPUT.
-OUTPUT is string output from an ocaml process."
-  (let ((regexp "[^:]+ : %s = \\(.+\\)$"))
-    (cond
-     ((string-match (format regexp "string") output)
-      (org-babel-read (match-string 1 output)))
-     ((or (string-match (format regexp "int") output)
-          (string-match (format regexp "float") output))
-      (string-to-number (match-string 1 output)))
-     ((string-match (format regexp "list") output)
-      (org-babel-ocaml-read-list (match-string 1 output)))
-     ((string-match (format regexp "array") output)
-      (org-babel-ocaml-read-array (match-string 1 output)))
-     (t (message "don't recognize type of %s" output) output))))
+(defun org-babel-ocaml-parse-output (value type)
+  "Parse VALUE of type TYPE.
+VALUE and TYPE are string output from an ocaml process."
+  (cond
+   ((string= "string" type)
+    (org-babel-read value))
+   ((or (string= "int" type)
+       (string= "float" type))
+    (string-to-number value))
+   ((string-match "list" type)
+    (org-babel-ocaml-read-list value))
+   ((string-match "array" type)
+    (org-babel-ocaml-read-array value))
+   (t (message "don't recognize type %s" type) value)))
 
 (defun org-babel-ocaml-read-list (results)
   "Convert RESULTS into an elisp table or string.
 If the results look like a table, then convert them into an
 Emacs-lisp table, otherwise return the results as a string."
+  ;; XXX: This probably does not behave as expected when a semicolon
+  ;; is in a string in a list.  The same comment applies to
+  ;; `org-babel-ocaml-read-array' below (with even more failure
+  ;; modes).
   (org-babel-script-escape (replace-regexp-in-string ";" "," results)))
 
 (defun org-babel-ocaml-read-array (results)
index 8cc66b6..14b55d2 100644 (file)
@@ -82,18 +82,19 @@ end")
         (full-body
          (org-babel-expand-body:generic
           body params (org-babel-variable-assignments:octave params)))
+        (gfx-file (ignore-errors (org-babel-graphical-output-file params)))
         (result (org-babel-octave-evaluate
                  session
-                 (if (org-babel-octave-graphical-output-file params)
+                 (if gfx-file
                      (mapconcat 'identity
                                 (list
                                  "set (0, \"defaultfigurevisible\", \"off\");"
                                  full-body
-                                 (format "print -dpng %s" (org-babel-octave-graphical-output-file params)))
+                                 (format "print -dpng %s" gfx-file))
                                 "\n")
                    full-body)
                  result-type matlabp)))
-    (if (org-babel-octave-graphical-output-file params)
+    (if gfx-file
        nil
       (org-babel-reassemble-table
        result
@@ -268,11 +269,6 @@ This removes initial blank and comment lines and then calls
       (match-string 1 string)
     string))
 
-(defun org-babel-octave-graphical-output-file (params)
-  "Name of file to which maxima should send graphical output."
-  (and (member "graphics" (cdr (assq :result-params params)))
-       (cdr (assq :file params))))
-
 (provide 'ob-octave)
 
 
index 7cee104..dd3cc66 100644 (file)
@@ -1,6 +1,6 @@
 ;;; ob-python.el --- org-babel functions for python evaluation
 
-;; Copyright (C) 2009-2014 Free Software Foundation, Inc.
+;; Copyright (C) 2009-2015 Free Software Foundation, Inc.
 
 ;; Authors: Eric Schulte
 ;;      Dan Davison
@@ -80,6 +80,8 @@ This function is called by `org-babel-execute-src-block'."
         (return-val (when (and (eq result-type 'value) (not session))
                       (cdr (assoc :return params))))
         (preamble (cdr (assoc :preamble params)))
+        (org-babel-python-command
+         (or (cdr (assoc :python params)) org-babel-python-command))
          (full-body
          (org-babel-expand-body:generic
           (concat body (if return-val (format "\nreturn %s" return-val) ""))
@@ -222,13 +224,13 @@ then create.  Return the initialized session."
 
 (defvar org-babel-python-eoe-indicator "'org_babel_python_eoe'"
   "A string to indicate that evaluation has completed.")
-(defvar org-babel-python-wrapper-method
+(defconst org-babel-python-wrapper-method
   "
 def main():
 %s
 
 open('%s', 'w').write( str(main()) )")
-(defvar org-babel-python-pp-wrapper-method
+(defconst org-babel-python-pp-wrapper-method
   "
 import pprint
 def main():
index 152af86..6172895 100644 (file)
@@ -63,6 +63,8 @@
 (declare-function org-show-context "org" (&optional key))
 (declare-function org-pop-to-buffer-same-window
                  "org-compat" (&optional buffer-or-name norecord label))
+(declare-function org-babel-lob-execute "ob-lob" (info))
+(declare-function org-babel-lob-get-info "ob-lob" nil)
 
 (defvar org-babel-ref-split-regexp
   "[ \f\t\n\r\v]*\\(.+?\\)[ \f\t\n\r\v]*=[ \f\t\n\r\v]*\\(.+\\)[ \f\t\n\r\v]*")
@@ -122,93 +124,104 @@ the variable."
                     (point))
      (point-max))))
 
+(defvar org-babel-lob-one-liner-regexp)
 (defvar org-babel-library-of-babel)
 (defun org-babel-ref-resolve (ref)
   "Resolve the reference REF and return its value."
   (save-window-excursion
-    (save-excursion
-      (let ((case-fold-search t)
-           type args new-refere new-header-args new-referent result
-           lob-info split-file split-ref index index-row index-col id)
-       ;; if ref is indexed grab the indices -- beware nested indices
-       (when (and (string-match "\\[\\([^\\[]+\\)\\]$" ref)
-                  (let ((str (substring ref 0 (match-beginning 0))))
-                    (= (org-count ?( str) (org-count ?) str))))
-         (setq index (match-string 1 ref))
-         (setq ref (substring ref 0 (match-beginning 0))))
-       ;; assign any arguments to pass to source block
-       (when (string-match
-              "^\\(.+?\\)\\(\\[\\(.*\\)\\]\\|\\(\\)\\)\(\\(.*\\)\)$" ref)
-         (setq new-refere      (match-string 1 ref))
-         (setq new-header-args (match-string 3 ref))
-         (setq new-referent    (match-string 5 ref))
-         (when (> (length new-refere) 0)
-           (when (> (length new-referent) 0)
-             (setq args (mapcar (lambda (ref) (cons :var ref))
-                                (org-babel-ref-split-args new-referent))))
-           (when (> (length new-header-args) 0)
-             (setq args (append (org-babel-parse-header-arguments
-                                 new-header-args) args)))
-           (setq ref new-refere)))
-       (when (string-match "^\\(.+\\):\\(.+\\)$" ref)
-         (setq split-file (match-string 1 ref))
-         (setq split-ref (match-string 2 ref))
-         (find-file split-file) (setq ref split-ref))
-       (save-restriction
-         (widen)
-         (goto-char (point-min))
-         (if (let ((src-rx (org-babel-named-src-block-regexp-for-name ref))
-                   (res-rx (org-babel-named-data-regexp-for-name ref)))
-               ;; goto ref in the current buffer
-               (or
-                ;; check for code blocks
-                (re-search-forward src-rx nil t)
-                ;; check for named data
-                (re-search-forward res-rx nil t)
-                ;; check for local or global headlines by id
-                (setq id (org-babel-ref-goto-headline-id ref))
-                ;; check the Library of Babel
-                (setq lob-info (cdr (assoc (intern ref)
-                                           org-babel-library-of-babel)))))
-             (unless (or lob-info id) (goto-char (match-beginning 0)))
-           ;; ;; TODO: allow searching for names in other buffers
-           ;; (setq id-loc (org-id-find ref 'marker)
-           ;;       buffer (marker-buffer id-loc)
-           ;;       loc (marker-position id-loc))
-           ;; (move-marker id-loc nil)
-           (error "Reference '%s' not found in this buffer" ref))
-         (cond
-          (lob-info (setq type 'lob))
-          (id (setq type 'id))
-          ((and (looking-at org-babel-src-name-regexp)
-                (save-excursion
-                  (forward-line 1)
-                  (or (looking-at org-babel-src-block-regexp)
-                      (looking-at org-babel-multi-line-header-regexp))))
-           (setq type 'source-block))
-          (t (while (not (setq type (org-babel-ref-at-ref-p)))
-               (forward-line 1)
-               (beginning-of-line)
-               (if (or (= (point) (point-min)) (= (point) (point-max)))
-                   (error "Reference not found")))))
-         (let ((params (append args '((:results . "silent")))))
-           (setq result
-                 (case type
-                   (results-line (org-babel-read-result))
-                   (table        (org-babel-read-table))
-                   (list         (org-babel-read-list))
-                   (file         (org-babel-read-link))
-                   (source-block (org-babel-execute-src-block
-                                  nil nil (if org-babel-update-intermediate
-                                              nil params)))
-                   (lob          (org-babel-execute-src-block
-                                  nil lob-info params))
-                   (id           (org-babel-ref-headline-body)))))
-         (if (symbolp result)
-             (format "%S" result)
-           (if (and index (listp result))
-               (org-babel-ref-index-list index result)
-             result)))))))
+    (with-current-buffer (or org-babel-exp-reference-buffer (current-buffer))
+      (save-excursion
+       (let ((case-fold-search t)
+             type args new-refere new-header-args new-referent result
+             lob-info split-file split-ref index index-row index-col id)
+         ;; if ref is indexed grab the indices -- beware nested indices
+         (when (and (string-match "\\[\\([^\\[]+\\)\\]$" ref)
+                    (let ((str (substring ref 0 (match-beginning 0))))
+                      (= (org-count ?( str) (org-count ?) str))))
+           (setq index (match-string 1 ref))
+           (setq ref (substring ref 0 (match-beginning 0))))
+         ;; assign any arguments to pass to source block
+         (when (string-match
+                "^\\(.+?\\)\\(\\[\\(.*\\)\\]\\|\\(\\)\\)\(\\(.*\\)\)$" ref)
+           (setq new-refere      (match-string 1 ref))
+           (setq new-header-args (match-string 3 ref))
+           (setq new-referent    (match-string 5 ref))
+           (when (> (length new-refere) 0)
+             (when (> (length new-referent) 0)
+               (setq args (mapcar (lambda (ref) (cons :var ref))
+                                  (org-babel-ref-split-args new-referent))))
+             (when (> (length new-header-args) 0)
+               (setq args (append (org-babel-parse-header-arguments
+                                   new-header-args) args)))
+             (setq ref new-refere)))
+         (when (string-match "^\\(.+\\):\\(.+\\)$" ref)
+           (setq split-file (match-string 1 ref))
+           (setq split-ref (match-string 2 ref))
+           (find-file split-file) (setq ref split-ref))
+         (save-restriction
+           (widen)
+           (goto-char (point-min))
+           (if (let ((src-rx (org-babel-named-src-block-regexp-for-name ref))
+                     (res-rx (org-babel-named-data-regexp-for-name ref)))
+                 ;; goto ref in the current buffer
+                 (or
+                  ;; check for code blocks
+                  (re-search-forward src-rx nil t)
+                  ;; check for named data
+                  (re-search-forward res-rx nil t)
+                  ;; check for local or global headlines by id
+                  (setq id (org-babel-ref-goto-headline-id ref))
+                  ;; check the Library of Babel
+                  (setq lob-info (cdr (assoc (intern ref)
+                                             org-babel-library-of-babel)))))
+               (unless (or lob-info id) (goto-char (match-beginning 0)))
+             ;; ;; TODO: allow searching for names in other buffers
+             ;; (setq id-loc (org-id-find ref 'marker)
+             ;;       buffer (marker-buffer id-loc)
+             ;;       loc (marker-position id-loc))
+             ;; (move-marker id-loc nil)
+             (error "Reference '%s' not found in this buffer" ref))
+           (cond
+            (lob-info (setq type 'lob))
+            (id (setq type 'id))
+            ((and (looking-at org-babel-src-name-regexp)
+                  (save-excursion
+                    (forward-line 1)
+                    (or (looking-at org-babel-src-block-regexp)
+                        (looking-at org-babel-multi-line-header-regexp))))
+             (setq type 'source-block))
+            ((and (looking-at org-babel-src-name-regexp)
+                  (save-excursion
+                    (forward-line 1)
+                    (looking-at org-babel-lob-one-liner-regexp)))
+             (setq type 'call-line))
+            (t (while (not (setq type (org-babel-ref-at-ref-p)))
+                 (forward-line 1)
+                 (beginning-of-line)
+                 (if (or (= (point) (point-min)) (= (point) (point-max)))
+                     (error "Reference not found")))))
+           (let ((params (append args '((:results . "silent")))))
+             (setq result
+                   (case type
+                     (results-line (org-babel-read-result))
+                     (table        (org-babel-read-table))
+                     (list         (org-babel-read-list))
+                     (file         (org-babel-read-link))
+                     (source-block (org-babel-execute-src-block
+                                    nil nil (if org-babel-update-intermediate
+                                                nil params)))
+                     (call-line (save-excursion
+                                  (forward-line 1)
+                                  (org-babel-lob-execute
+                                   (org-babel-lob-get-info))))
+                     (lob          (org-babel-execute-src-block
+                                    nil lob-info params))
+                     (id           (org-babel-ref-headline-body)))))
+           (if (symbolp result)
+               (format "%S" result)
+             (if (and index (listp result))
+                 (org-babel-ref-index-list index result)
+               result))))))))
 
 (defun org-babel-ref-index-list (index lis)
   "Return the subset of LIS indexed by INDEX.
index 5b31247..26285eb 100644 (file)
@@ -209,21 +209,32 @@ return the value of the last statement in BODY, as elisp."
     ;; comint session evaluation
     (case result-type
       (output
-       (mapconcat
-       #'identity
-       (butlast
-        (split-string
-         (mapconcat
-          #'org-babel-trim
-          (butlast
-           (org-babel-comint-with-output
-               (buffer org-babel-ruby-eoe-indicator t body)
-             (mapc
-              (lambda (line)
-                (insert (org-babel-chomp line)) (comint-send-input nil t))
-              (list body org-babel-ruby-eoe-indicator))
-             (comint-send-input nil t)) 2)
-          "\n") "[\r\n]")) "\n"))
+       (let ((eoe-string (format "puts \"%s\"" org-babel-ruby-eoe-indicator)))
+        ;; Force the session to be ready before the actual session
+        ;; code is run.  There is some problem in comint that will
+        ;; sometimes show the prompt after the the input has already
+        ;; been inserted and that throws off the extraction of the
+        ;; result for Babel.
+        (org-babel-comint-with-output
+            (buffer org-babel-ruby-eoe-indicator t eoe-string)
+          (insert eoe-string) (comint-send-input nil t))
+        ;; Now we can start the evaluation.
+        (mapconcat
+         #'identity
+         (butlast
+          (split-string
+           (mapconcat
+            #'org-babel-trim
+            (org-babel-comint-with-output
+                (buffer org-babel-ruby-eoe-indicator t body)
+              (mapc
+               (lambda (line)
+                 (insert (org-babel-chomp line)) (comint-send-input nil t))
+               (list "conf.echo=false;_org_prompt_mode=conf.prompt_mode;conf.prompt_mode=:NULL"
+                     body
+                     "conf.prompt_mode=_org_prompt_mode;conf.echo=true"
+                     eoe-string)))
+            "\n") "[\r\n]") 4) "\n")))
       (value
        (let* ((tmp-file (org-babel-temp-file "ruby-"))
              (ppp (or (member "code" result-params)
index 0584342..838bc8f 100644 (file)
@@ -60,14 +60,6 @@ called by `org-babel-execute-src-block'"
      (org-babel-pick-name
       (cdr (assoc :rowname-names params)) (cdr (assoc :rownames params))))))
 
-
-(defun org-babel-scala-table-or-string (results)
-  "Convert RESULTS into an appropriate elisp value.
-If RESULTS look like a table, then convert them into an
-Emacs-lisp table, otherwise return the results as a string."
-  (org-babel-script-escape results))
-
-
 (defvar org-babel-scala-wrapper-method
 
 "var str_result :String = null;
@@ -104,7 +96,7 @@ in BODY as elisp."
                    (concat org-babel-scala-command " " src-file) "")))
          (org-babel-result-cond result-params
           raw
-           (org-babel-scala-table-or-string raw)))))))
+           (org-babel-script-escape raw)))))))
 
 
 (defun org-babel-prep-session:scala (session params)
index b7117e9..2095534 100644 (file)
@@ -118,6 +118,22 @@ org-babel-scheme-execute-with-geiser will use a temporary session."
               (name))))
     result))
 
+(defmacro org-babel-scheme-capture-current-message (&rest body)
+  "Capture current message in both interactive and noninteractive mode"
+  `(if noninteractive
+       (let ((original-message (symbol-function 'message))
+             (current-message nil))
+         (unwind-protect
+             (progn
+               (defun message (&rest args)
+                 (setq current-message (apply original-message args)))
+               ,@body
+               current-message)
+           (fset 'message original-message)))
+     (progn
+       ,@body
+       (current-message))))
+
 (defun org-babel-scheme-execute-with-geiser (code output impl repl)
   "Execute code in specified REPL. If the REPL doesn't exist, create it
 using the given scheme implementation.
@@ -142,10 +158,11 @@ is true; otherwise returns the last value."
                             (current-buffer)))))
        (setq geiser-repl--repl repl-buffer)
        (setq geiser-impl--implementation nil)
-       (geiser-eval-region (point-min) (point-max))
+       (setq result (org-babel-scheme-capture-current-message
+                     (geiser-eval-region (point-min) (point-max))))
        (setq result
-             (if (equal (substring (current-message) 0 3) "=> ")
-                 (replace-regexp-in-string "^=> " "" (current-message))
+             (if (and (stringp result) (equal (substring result 0 3) "=> "))
+                 (replace-regexp-in-string "^=> " "" result)
                "\"An error occurred.\""))
        (when (not repl)
          (save-current-buffer (set-buffer repl-buffer)
similarity index 67%
rename from .emacs.d/elisp/org/ob-sh.el
rename to .emacs.d/elisp/org/ob-shell.el
index 96f275b..4d6d7c4 100644 (file)
@@ -1,4 +1,4 @@
-;;; ob-sh.el --- org-babel functions for shell evaluation
+;;; ob-shell.el --- org-babel functions for shell evaluation
 
 ;; Copyright (C) 2009-2014 Free Software Foundation, Inc.
 
 
 (defvar org-babel-default-header-args:sh '())
 
-(defvar org-babel-sh-command "sh"
-  "Command used to invoke a shell.
-This will be passed to  `shell-command-on-region'")
-
-(defcustom org-babel-sh-var-quote-fmt
-  "$(cat <<'BABEL_TABLE'\n%s\nBABEL_TABLE\n)"
-  "Format string used to escape variables when passed to shell scripts."
+(defcustom org-babel-shell-names
+  '("sh" "bash" "csh" "ash" "dash" "ksh" "mksh" "posh")
+  "List of names of shell supported by babel shell code blocks."
   :group 'org-babel
-  :type 'string)
+  :type 'string
+  :initialize
+  (lambda (symbol value)
+    (set-default symbol (second value))
+    (mapc
+     (lambda (name)
+       (eval `(defun ,(intern (concat "org-babel-execute:" name)) (body params)
+               ,(format "Execute a block of %s commands with Babel." name)
+               (let ((shell-file-name ,name))
+                 (org-babel-execute:shell body params)))))
+     (second value))))
 
-(defun org-babel-execute:sh (body params)
+(defun org-babel-execute:shell (body params)
   "Execute a block of Shell commands with Babel.
 This function is called by `org-babel-execute-src-block'."
   (let* ((session (org-babel-sh-initiate-session
@@ -56,10 +62,11 @@ This function is called by `org-babel-execute-src-block'."
         (stdin (let ((stdin (cdr (assoc :stdin params))))
                   (when stdin (org-babel-sh-var-to-string
                                (org-babel-ref-resolve stdin)))))
+        (cmdline (cdr (assoc :cmdline params)))
          (full-body (org-babel-expand-body:generic
                     body params (org-babel-variable-assignments:sh params))))
     (org-babel-reassemble-table
-     (org-babel-sh-evaluate session full-body params stdin)
+     (org-babel-sh-evaluate session full-body params stdin cmdline)
      (org-babel-pick-name
       (cdr (assoc :colname-names params)) (cdr (assoc :colnames params)))
      (org-babel-pick-name
@@ -85,59 +92,104 @@ This function is called by `org-babel-execute-src-block'."
       buffer)))
 
 ;; helper functions
+(defun org-babel-variable-assignments:sh-generic
+    (varname values &optional sep hline)
+  "Returns a list of statements declaring the values as a generic variable."
+  (format "%s=%s" varname (org-babel-sh-var-to-sh values sep hline)))
+
+(defun org-babel-variable-assignments:bash_array
+    (varname values &optional sep hline)
+  "Returns a list of statements declaring the values as a bash array."
+  (format "unset %s\ndeclare -a %s=( %s )"
+         varname varname
+         (mapconcat
+          (lambda (value) (org-babel-sh-var-to-sh value sep hline))
+          values
+          " ")))
+
+(defun org-babel-variable-assignments:bash_assoc
+    (varname values &optional sep hline)
+  "Returns a list of statements declaring the values as bash associative array."
+  (format "unset %s\ndeclare -A %s\n%s"
+    varname varname
+    (mapconcat
+     (lambda (items)
+       (format "%s[%s]=%s"
+              varname
+              (org-babel-sh-var-to-sh (car items) sep hline)
+              (org-babel-sh-var-to-sh (cdr items) sep hline)))
+     values
+     "\n")))
+
+(defun org-babel-variable-assignments:bash (varname values &optional sep hline)
+  "Represents the parameters as useful Bash shell variables."
+  (if (listp values)
+      (if (and (listp (car values)) (= 1 (length (car values))))
+         (org-babel-variable-assignments:bash_array varname values sep hline)
+       (org-babel-variable-assignments:bash_assoc varname values sep hline))
+    (org-babel-variable-assignments:sh-generic varname values sep hline)))
 
 (defun org-babel-variable-assignments:sh (params)
   "Return list of shell statements assigning the block's variables."
-  (let ((sep (cdr (assoc :separator params))))
+  (let ((sep (cdr (assoc :separator params)))
+       (hline (when (string= "yes" (cdr (assoc :hlines params)))
+                (or (cdr (assoc :hline-string params))
+                    "hline"))))
     (mapcar
      (lambda (pair)
-       (format "%s=%s"
-              (car pair)
-              (org-babel-sh-var-to-sh (cdr pair) sep)))
+       (if (string-match "bash$" shell-file-name)
+          (org-babel-variable-assignments:bash
+            (car pair) (cdr pair) sep hline)
+         (org-babel-variable-assignments:sh-generic
+         (car pair) (cdr pair) sep hline)))
      (mapcar #'cdr (org-babel-get-header params :var)))))
 
-(defun org-babel-sh-var-to-sh (var &optional sep)
+(defun org-babel-sh-var-to-sh (var &optional sep hline)
   "Convert an elisp value to a shell variable.
 Convert an elisp var into a string of shell commands specifying a
 var of the same value."
-  (format org-babel-sh-var-quote-fmt (org-babel-sh-var-to-string var sep)))
+  (concat "'" (replace-regexp-in-string
+              "'" "'\"'\"'"
+              (org-babel-sh-var-to-string var sep hline))
+         "'"))
 
-(defun org-babel-sh-var-to-string (var &optional sep)
+(defun org-babel-sh-var-to-string (var &optional sep hline)
   "Convert an elisp value to a string."
   (let ((echo-var (lambda (v) (if (stringp v) v (format "%S" v)))))
     (cond
      ((and (listp var) (or (listp (car var)) (equal (car var) 'hline)))
-      (orgtbl-to-generic var  (list :sep (or sep "\t") :fmt echo-var)))
+      (orgtbl-to-generic var  (list :sep (or sep "\t") :fmt echo-var
+                                   :hline hline)))
      ((listp var)
       (mapconcat echo-var var "\n"))
      (t (funcall echo-var var)))))
 
-(defun org-babel-sh-table-or-results (results)
-  "Convert RESULTS to an appropriate elisp value.
-If the results look like a table, then convert them into an
-Emacs-lisp table, otherwise return the results as a string."
-  (org-babel-script-escape results))
-
 (defun org-babel-sh-initiate-session (&optional session params)
   "Initiate a session named SESSION according to PARAMS."
   (when (and session (not (string= session "none")))
     (save-window-excursion
       (or (org-babel-comint-buffer-livep session)
-          (progn (shell session) (get-buffer (current-buffer)))))))
+          (progn
+           (shell session)
+           ;; Needed for Emacs 23 since the marker is initially
+           ;; undefined and the filter functions try to use it without
+           ;; checking.
+           (set-marker comint-last-output-start (point))
+           (get-buffer (current-buffer)))))))
 
 (defvar org-babel-sh-eoe-indicator "echo 'org_babel_sh_eoe'"
   "String to indicate that evaluation has completed.")
 (defvar org-babel-sh-eoe-output "org_babel_sh_eoe"
   "String to indicate that evaluation has completed.")
 
-(defun org-babel-sh-evaluate (session body &optional params stdin)
+(defun org-babel-sh-evaluate (session body &optional params stdin cmdline)
   "Pass BODY to the Shell process in BUFFER.
 If RESULT-TYPE equals 'output then return a list of the outputs
 of the statements in BODY, if RESULT-TYPE equals 'value then
 return the value of the last statement in BODY."
   (let ((results
          (cond
-          (stdin                        ; external shell script w/STDIN
+          ((or stdin cmdline)         ; external shell script w/STDIN
            (let ((script-file (org-babel-temp-file "sh-script-"))
                  (stdin-file (org-babel-temp-file "sh-stdin-"))
                  (shebang (cdr (assoc :shebang params)))
@@ -147,14 +199,14 @@ return the value of the last statement in BODY."
                (when padline (insert "\n"))
                (insert body))
              (set-file-modes script-file #o755)
-             (with-temp-file stdin-file (insert stdin))
+             (with-temp-file stdin-file (insert (or stdin "")))
              (with-temp-buffer
                (call-process-shell-command
                 (if shebang
                     script-file
-                  (format "%s %s" org-babel-sh-command script-file))
+                  (format "%s %s" shell-file-name script-file))
                 stdin-file
-                (current-buffer))
+                (current-buffer) nil cmdline)
                (buffer-string))))
           (session                      ; session evaluation
            (mapconcat
@@ -190,7 +242,7 @@ return the value of the last statement in BODY."
                    (insert body))
                  (set-file-modes script-file #o755)
                  (org-babel-eval script-file ""))
-             (org-babel-eval org-babel-sh-command (org-babel-trim body)))))))
+             (org-babel-eval shell-file-name (org-babel-trim body)))))))
     (when results
       (let ((result-params (cdr (assoc :result-params params))))
         (org-babel-result-cond result-params
@@ -205,8 +257,8 @@ return the value of the last statement in BODY."
     (setq string (substring string (match-end 0))))
   string)
 
-(provide 'ob-sh)
+(provide 'ob-shell)
 
 
 
-;;; ob-sh.el ends here
+;;; ob-shell.el ends here
index 08d4419..493b3dc 100644 (file)
   (org-babel-sql-expand-vars
    body (mapcar #'cdr (org-babel-get-header params :var))))
 
-(defun dbstring-mysql (host user password database)
+(defun org-babel-sql-dbstring-mysql (host user password database)
   "Make MySQL cmd line args for database connection.  Pass nil to omit that arg."
   (combine-and-quote-strings
-   (remq nil
+   (delq nil
         (list (when host     (concat "-h" host))
               (when user     (concat "-u" user))
               (when password (concat "-p" password))
               (when database (concat "-D" database))))))
 
+(defun org-babel-sql-dbstring-postgresql (host user database)
+  "Make PostgreSQL command line args for database connection.
+Pass nil to omit that arg."
+  (combine-and-quote-strings
+   (delq nil
+        (list (when host (concat "-h" host))
+              (when user (concat "-U" user))
+              (when database (concat "-d" database))))))
+
 (defun org-babel-execute:sql (body params)
   "Execute a block of Sql code with Babel.
 This function is called by `org-babel-execute-src-block'."
@@ -117,13 +126,15 @@ This function is called by `org-babel-execute-src-block'."
                                      (org-babel-process-file-name in-file)
                                      (org-babel-process-file-name out-file)))
                     ('mysql (format "mysql %s %s %s < %s > %s"
-                                   (dbstring-mysql dbhost dbuser dbpassword database)
+                                   (org-babel-sql-dbstring-mysql dbhost dbuser dbpassword database)
                                    (if colnames-p "" "-N")
                                     (or cmdline "")
                                    (org-babel-process-file-name in-file)
                                    (org-babel-process-file-name out-file)))
                    ('postgresql (format
-                                 "psql -A -P footer=off -F \"\t\"  -f %s -o %s %s"
+                                 "psql --set=\"ON_ERROR_STOP=1\" %s -A -P footer=off -F \"\t\"  %s -f %s -o %s %s"
+                                 (if colnames-p "" "-t")
+                                 (org-babel-sql-dbstring-postgresql dbhost dbuser database)
                                  (org-babel-process-file-name in-file)
                                  (org-babel-process-file-name out-file)
                                  (or cmdline "")))
index 831e352..b2a8da6 100644 (file)
 ;; |        7 |        |
 ;; |        8 |        |
 ;; |        9 |        |
-;; #+TBLFM: $2='(org-sbe 'fibbd (n $1))
+;; #+TBLFM: $2='(org-sbe "fibbd" (n $1))
+
+;; NOTE: The quotation marks around the function name, 'fibbd' here,
+;; are optional.
 
 ;;; Code:
 (require 'ob-core)
@@ -62,23 +65,30 @@ character and replace it with ellipses."
 
 (defmacro org-sbe (source-block &rest variables)
   "Return the results of calling SOURCE-BLOCK with VARIABLES.
-Each element of VARIABLES should be a two
-element list, whose first element is the name of the variable and
-second element is a string of its value.  The following call to
-`org-sbe' would be equivalent to the following source code block.
 
- (org-sbe 'source-block (n $2) (m 3))
+Each element of VARIABLES should be a list of two elements: the
+first element is the name of the variable and second element is a
+string of its value.
+
+So this `org-sbe' construct
+
+ (org-sbe \"source-block\" (n $2) (m 3))
+
+is the equivalent of the following source code block:
+
+ #+begin_src emacs-lisp :var results=source-block(n=val_at_col_2, m=3) :results silent
+ results
+ #+end_src
 
-#+begin_src emacs-lisp :var results=source-block(n=val_at_col_2, m=3) :results silent
-results
-#+end_src
+NOTE: The quotation marks around the function name,
+'source-block', are optional.
 
-NOTE: by default string variable names are interpreted as
+NOTE: By default, string variable names are interpreted as
 references to source-code blocks, to force interpretation of a
 cell's value as a string, prefix the identifier a \"$\" (e.g.,
 \"$$2\" instead of \"$2\" or \"$@2$2\" instead of \"@2$2\").
 
-NOTE: it is also possible to pass header arguments to the code
+NOTE: It is also possible to pass header arguments to the code
 block.  In this case a table cell should hold the string value of
 the header argument which can then be passed before all variables
 as shown in the example below.
index 3a43b42..1c159a5 100644 (file)
@@ -27,8 +27,6 @@
 
 ;;; Code:
 (require 'org-src)
-(eval-when-compile
-  (require 'cl))
 
 (declare-function org-edit-special "org" (&optional arg))
 (declare-function org-link-escape "org" (text &optional table))
 (declare-function org-back-to-heading "org" (invisible-ok))
 (declare-function org-fill-template "org" (template alist))
 (declare-function org-babel-update-block-body "org" (new-body))
+(declare-function org-up-heading-safe "org" ())
+(declare-function org-in-commented-heading-p "org" (&optional no-inheritance))
 (declare-function make-directory "files" (dir &optional parents))
+(declare-function org-before-first-heading-p "org" ())
 
 (defcustom org-babel-tangle-lang-exts
-  '(("emacs-lisp" . "el"))
+  '(("emacs-lisp" . "el")
+    ("elisp" . "el"))
   "Alist mapping languages to their file extensions.
 The key is the language name, the value is the string that should
 be inserted as the extension commonly used to identify files
@@ -54,6 +56,11 @@ then the name of the language is used."
           (string "Language name")
           (string "File Extension"))))
 
+(defcustom org-babel-tangle-use-relative-file-links t
+  "Use relative path names in links from tangled source back the Org-mode file."
+  :group 'org-babel-tangle
+  :type 'boolean)
+
 (defcustom org-babel-post-tangle-hook nil
   "Hook run in code files tangled by `org-babel-tangle'."
   :group 'org-babel
@@ -81,6 +88,11 @@ information into the output using `org-fill-template'.
 %link --------- Org-mode style link to the code block
 %source-name -- name of the code block
 
+Upon insertion the formatted comment will be commented out, and
+followed by a newline.  To inhibit this post-insertion processing
+set the `org-babel-tangle-uncomment-comments' variable to a
+non-nil value.
+
 Whether or not comments are inserted during tangling is
 controlled by the :comments header argument."
   :group 'org-babel
@@ -96,17 +108,30 @@ information into the output using `org-fill-template'.
 %link --------- Org-mode style link to the code block
 %source-name -- name of the code block
 
+Upon insertion the formatted comment will be commented out, and
+followed by a newline.  To inhibit this post-insertion processing
+set the `org-babel-tangle-uncomment-comments' variable to a
+non-nil value.
+
 Whether or not comments are inserted during tangling is
 controlled by the :comments header argument."
   :group 'org-babel
   :version "24.1"
   :type 'string)
 
-(defcustom org-babel-process-comment-text #'org-babel-trim
+(defcustom org-babel-tangle-uncomment-comments nil
+  "Inhibits automatic commenting and addition of trailing newline
+of tangle comments.  Use `org-babel-tangle-comment-format-beg'
+and `org-babel-tangle-comment-format-end' to customize the format
+of tangled comments."
+  :group 'org-babel
+  :type 'boolean)
+
+(defcustom org-babel-process-comment-text #'org-remove-indentation
   "Function called to process raw Org-mode text collected to be
 inserted as comments in tangled source-code files.  The function
 should take a single string argument and return a string
-result.  The default value is `org-babel-trim'."
+result.  The default value is `org-remove-indentation'."
   :group 'org-babel
   :version "24.1"
   :type 'function)
@@ -176,12 +201,12 @@ used to limit the exported source code blocks by language."
   (run-hooks 'org-babel-pre-tangle-hook)
   ;; Possibly Restrict the buffer to the current code block
   (save-restriction
-    (when (equal arg '(4))
-      (let ((head (org-babel-where-is-src-block-head)))
+    (save-excursion
+      (when (equal arg '(4))
+       (let ((head (org-babel-where-is-src-block-head)))
          (if head
              (goto-char head)
            (user-error "Point is not in a source code block"))))
-    (save-excursion
       (let ((block-counter 0)
            (org-babel-default-header-args
             (if target-file
@@ -246,6 +271,10 @@ used to limit the exported source code blocks by language."
                            (if (file-exists-p file-name)
                                (insert-file-contents file-name))
                            (goto-char (point-max))
+                           ;; Handle :padlines unless first line in file
+                           (unless (or (string= "no" (cdr (assoc :padline (nth 4 spec))))
+                                       (= (point) (point-min)))
+                             (insert "\n"))
                            (insert content)
                            (write-region nil nil file-name))))
                      ;; if files contain she-bangs, then make the executable
@@ -304,13 +333,23 @@ that the appropriate major-mode is set.  SPEC has the form:
 
   \(start-line file link source-name params body comment)"
   (let* ((start-line (nth 0 spec))
-        (file (nth 1 spec))
-        (link (nth 2 spec))
+        (file (if org-babel-tangle-use-relative-file-links
+                  (file-relative-name (nth 1 spec))
+                (nth 1 spec)))
+        (link (let ((link (nth 2 spec)))
+                (if org-babel-tangle-use-relative-file-links
+                    (when (string-match "^\\(file:\\|docview:\\)\\(.*\\)" link)
+                      (let* ((type (match-string 1 link))
+                             (path (match-string 2 link))
+                             (origpath path)
+                             (case-fold-search nil))
+                        (setq path (file-relative-name path))
+                        (concat type path)))
+                  link)))
         (source-name (nth 3 spec))
         (body (nth 5 spec))
         (comment (nth 6 spec))
         (comments (cdr (assoc :comments (nth 4 spec))))
-        (padline (not (string= "no" (cdr (assoc :padline (nth 4 spec))))))
         (link-p (or (string= comments "both") (string= comments "link")
                     (string= comments "yes") (string= comments "noweb")))
         (link-data (mapcar (lambda (el)
@@ -321,15 +360,20 @@ that the appropriate major-mode is set.  SPEC has the form:
         (insert-comment (lambda (text)
                           (when (and comments (not (string= comments "no"))
                                      (> (length text) 0))
-                            (when padline (insert "\n"))
-                            (comment-region (point) (progn (insert text) (point)))
-                            (end-of-line nil) (insert "\n")))))
+                            (if org-babel-tangle-uncomment-comments
+                                ;; just plain comments with no processing
+                                (insert text)
+                              ;; ensure comments are made to be
+                              ;; comments, and add a trailing newline
+                              (comment-region
+                               (point) (progn (insert text) (point)))
+                              (end-of-line nil)
+                              (insert "\n"))))))
     (when comment (funcall insert-comment comment))
     (when link-p
       (funcall
        insert-comment
        (org-fill-template org-babel-tangle-comment-format-beg link-data)))
-    (when padline (insert "\n"))
     (insert
      (format
       "%s\n"
@@ -340,7 +384,6 @@ that the appropriate major-mode is set.  SPEC has the form:
        insert-comment
        (org-fill-template org-babel-tangle-comment-format-end link-data)))))
 
-(defvar org-comment-string) ;; Defined in org.el
 (defun org-babel-tangle-collect-blocks (&optional language tangle-file)
   "Collect source blocks in the current Org-mode file.
 Return an association list of source-code block specifications of
@@ -350,21 +393,21 @@ source code blocks by language.  Optional argument TANGLE-FILE
 can be used to limit the collected code blocks by target file."
   (let ((block-counter 1) (current-heading "") blocks by-lang)
     (org-babel-map-src-blocks (buffer-file-name)
-      (lambda (new-heading)
-       (if (not (string= new-heading current-heading))
-           (progn
-             (setq block-counter 1)
-             (setq current-heading new-heading))
-         (setq block-counter (+ 1 block-counter))))
-      (replace-regexp-in-string "[ \t]" "-"
-                               (condition-case nil
-                                   (or (nth 4 (org-heading-components))
-                                       "(dummy for heading without text)")
-                                 (error (buffer-file-name))))
+      ((lambda (new-heading)
+        (if (not (string= new-heading current-heading))
+            (progn
+              (setq block-counter 1)
+              (setq current-heading new-heading))
+          (setq block-counter (+ 1 block-counter))))
+       (replace-regexp-in-string "[ \t]" "-"
+                                (condition-case nil
+                                    (or (nth 4 (org-heading-components))
+                                        "(dummy for heading without text)")
+                                  (error (buffer-file-name)))))
       (let* ((info (org-babel-get-src-block-info 'light))
             (src-lang (nth 0 info))
             (src-tfile (cdr (assoc :tangle (nth 2 info)))))
-        (unless (or (string-match (concat "^" org-comment-string) current-heading)
+        (unless (or (org-in-commented-heading-p)
                    (string= (cdr (assoc :tangle (nth 2 info))) "no")
                    (and tangle-file (not (equal tangle-file src-tfile))))
           (unless (and language (not (string= language src-lang)))
index 0067165..9d39ef1 100644 (file)
@@ -1,6 +1,6 @@
 ;;; org-agenda.el --- Dynamic task and appointment lists for Org
 
-;; Copyright (C) 2004-2014 Free Software Foundation, Inc.
+;; Copyright (C) 2004-2015 Free Software Foundation, Inc.
 
 ;; Author: Carsten Dominik <carsten at orgmode dot org>
 ;; Keywords: outlines, hypermedia, calendar, wp
@@ -52,7 +52,7 @@
 
 (declare-function diary-add-to-list "diary-lib"
                   (date string specifier &optional marker globcolor literal))
-(declare-function calendar-absolute-from-iso    "cal-iso"    (date))
+(declare-function calendar-iso-to-absolute      "cal-iso"    (date))
 (declare-function calendar-astro-date-string    "cal-julian" (&optional date))
 (declare-function calendar-bahai-date-string    "cal-bahai"  (&optional date))
 (declare-function calendar-chinese-date-string  "cal-china"  (&optional date))
@@ -69,6 +69,7 @@
 (declare-function calendar-persian-date-string  "cal-persia" (&optional date))
 (declare-function calendar-check-holidays       "holidays" (date))
 
+(declare-function org-columns-remove-overlays "org-colview" ())
 (declare-function org-datetree-find-date-create "org-datetree"
                  (date &optional keep-restriction))
 (declare-function org-columns-quit              "org-colview" ())
@@ -360,6 +361,12 @@ the daily/weekly agenda, see `org-agenda-skip-function'.")
                          (const :format "" quote)
                          (repeat
                           (string :tag "+tag or -tag"))))
+                  (list :tag "Effort filter preset"
+                        (const org-agenda-effort-filter-preset)
+                        (list
+                         (const :format "" quote)
+                         (repeat
+                          (string :tag "+=10 or -=10 or +<10 or ->10"))))
                   (list :tag "Regexp filter preset"
                         (const org-agenda-regexp-filter-preset)
                         (list
@@ -610,15 +617,6 @@ or `C-c a #' to produce the list."
          (repeat :tag "Projects are *not* stuck if they have an entry with TAG being any of" (string))
          (regexp :tag "Projects are *not* stuck if this regexp matches inside the subtree")))
 
-(defcustom org-agenda-filter-effort-default-operator "<"
-  "The default operator for effort estimate filtering.
-If you select an effort estimate limit without first pressing an operator,
-this one will be used."
-  :group 'org-agenda-custom-commands
-  :type '(choice (const :tag "less or equal" "<")
-                (const :tag "greater or equal"">")
-                (const :tag "equal" "=")))
-
 (defgroup org-agenda-skip nil
   "Options concerning skipping parts of agenda files."
   :tag "Org Agenda Skip"
@@ -1097,6 +1095,7 @@ Possible values for this option are:
 
 current-window    Show agenda in the current window, keeping all other windows.
 other-window      Use `switch-to-buffer-other-window' to display agenda.
+only-window       Show agenda, deleting all other windows.
 reorganize-frame  Show only two windows on the current frame, the current
                   window and the agenda.
 other-frame       Use `switch-to-buffer-other-frame' to display agenda.
@@ -1107,6 +1106,7 @@ See also the variable `org-agenda-restore-windows-after-quit'."
          (const current-window)
          (const other-frame)
          (const other-window)
+         (const only-window)
          (const reorganize-frame)))
 
 (defcustom org-agenda-window-frame-fractions '(0.5 . 0.75)
@@ -1472,6 +1472,7 @@ symbols specifying conditions when the grid should be displayed:
  weekly        if the agenda shows an entire week
  today         show grid on current date, independent of daily/weekly display
  require-timed show grid only if at least one item has a time specification
+ remove-match  skip grid times already present in an entry
 
 The second item is a string which will be placed behind the grid time.
 
@@ -2079,6 +2080,8 @@ When nil, `q' will kill the single agenda buffer."
 (defvar org-agenda-this-buffer-name nil)
 (defvar org-agenda-doing-sticky-redo nil)
 (defvar org-agenda-this-buffer-is-sticky nil)
+(defvar org-agenda-last-indirect-buffer nil
+  "Last buffer loaded by `org-agenda-tree-to-indirect-buffer'.")
 
 (defconst org-agenda-local-vars
   '(org-agenda-this-buffer-name
@@ -2100,8 +2103,10 @@ When nil, `q' will kill the single agenda buffer."
     org-agenda-category-filter
     org-agenda-top-headline-filter
     org-agenda-regexp-filter
+    org-agenda-effort-filter
     org-agenda-markers
     org-agenda-last-search-view-search-was-boolean
+    org-agenda-last-indirect-buffer
     org-agenda-filtered-by-category
     org-agenda-filter-form
     org-agenda-cycle-counter
@@ -2308,6 +2313,7 @@ The following commands are available:
 (org-defkey org-agenda-mode-map "{" 'org-agenda-manipulate-query-add-re)
 (org-defkey org-agenda-mode-map "}" 'org-agenda-manipulate-query-subtract-re)
 (org-defkey org-agenda-mode-map "/" 'org-agenda-filter-by-tag)
+(org-defkey org-agenda-mode-map "_" 'org-agenda-filter-by-effort)
 (org-defkey org-agenda-mode-map "=" 'org-agenda-filter-by-regexp)
 (org-defkey org-agenda-mode-map "|" 'org-agenda-filter-remove-all)
 (org-defkey org-agenda-mode-map "\\" 'org-agenda-filter-by-tag-refine)
@@ -2321,6 +2327,10 @@ The following commands are available:
 
 (org-defkey org-agenda-mode-map [mouse-2] 'org-agenda-goto-mouse)
 (org-defkey org-agenda-mode-map [mouse-3] 'org-agenda-show-mouse)
+
+(define-key org-agenda-mode-map [remap forward-paragraph] 'org-agenda-forward-block)
+(define-key org-agenda-mode-map [remap backward-paragraph] 'org-agenda-backward-block)
+
 (when org-agenda-mouse-1-follows-link
   (org-defkey org-agenda-mode-map [follow-link] 'mouse-face))
 (easy-menu-define org-agenda-menu org-agenda-mode-map "Agenda menu"
@@ -2537,7 +2547,7 @@ For example, if you have a custom agenda command \"p\" and you
 want this command to be accessible only from plain text files,
 use this:
 
-   '((\"p\" ((in-file . \"\\.txt\"))))
+   '((\"p\" ((in-file . \"\\\\.txt\\\\'\"))))
 
 Here are the available contexts definitions: