Merge branch 'master' of git+ssh://repo.or.cz/srv/git/org-mode

lisp/babel/langs/ob-C.el

@@ -32,10 +32,15 @@
 
 ;;; Code:
 (require 'ob)
+(require 'org)
 (require 'cc-mode)
 
+(declare-function org-entry-get "org" (&optional inherit))
+
 (add-to-list 'org-babel-tangle-lang-exts '("c++" . "cpp"))
 
+(defvar org-babel-default-header-args:C '())
+
 (defvar org-babel-C-compiler "gcc"
   "Command used to compile a C source code file into an
   executable.")
@@ -44,6 +49,10 @@
   "Command used to compile a c++ source code file into an
   executable.")
 
+(defvar org-babel-c-variant nil
+  "Internal variable used to hold which type of C (e.g. C or C++)
+is currently being evaluated.")
+
 (defun org-babel-execute:cpp (body params)
   "Execute BODY according to PARAMS.  This function calls
 `org-babel-execute:C'."
@@ -52,22 +61,22 @@
 (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 ((c-variant 'cpp)) (org-babel-C-execute body params)))
+  (let ((org-babel-c-variant 'cpp)) (org-babel-C-execute body params)))
 
 (defun org-babel-expand-body:c++ (body params &optional processed-params)
   "Expand a block of C++ code with org-babel according to it's
 header arguments (calls `org-babel-C-expand')."
-  (let ((c-variant 'cpp)) (org-babel-C-expand body params processed-params)))
+  (let ((org-babel-c-variant 'cpp)) (org-babel-C-expand body params processed-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 ((c-variant 'c)) (org-babel-C-execute body params)))
+  (let ((org-babel-c-variant 'c)) (org-babel-C-execute body params)))
 
 (defun org-babel-expand-body:c (body params &optional processed-params)
   "Expand a block of C code with org-babel according to it's
 header arguments (calls `org-babel-C-expand')."
-  (let ((c-variant 'c)) (org-babel-C-expand body params processed-params)))
+  (let ((org-babel-c-variant 'c)) (org-babel-C-expand body params processed-params)))
 
 (defun org-babel-C-execute (body params)
   "This function should only be called by `org-babel-execute:C'
@@ -75,9 +84,9 @@ or `org-babel-execute:c++'."
   (message "executing C source code block")
   (let* ((processed-params (org-babel-process-params params))
          (tmp-src-file (make-temp-file "org-babel-C-src" nil
-                                       (case c-variant
-                                         ('c ".c")
-                                         ('cpp ".cpp"))))
+                                       (cond
+                                         ((equal org-babel-c-variant 'c) ".c")
+                                         ((equal org-babel-c-variant 'cpp) ".cpp"))))
          (tmp-bin-file (make-temp-file "org-babel-C-bin"))
          (tmp-out-file (make-temp-file "org-babel-C-out"))
          (cmdline (cdr (assoc :cmdline params)))
@@ -91,9 +100,9 @@ or `org-babel-execute:c++'."
               (org-babel-shell-command-on-region
                (point-min) (point-max)
                (format "%s -o %s %s %s"
-                       (case c-variant
-                         ('c org-babel-C-compiler)
-                         ('cpp org-babel-c++-compiler))
+		       (cond
+			((equal org-babel-c-variant 'c) org-babel-C-compiler)
+			((equal org-babel-c-variant 'cpp) org-babel-c++-compiler))
                        tmp-bin-file
                        (mapconcat 'identity
                                   (if (listp flags) flags (list flags)) " ")
@@ -121,7 +130,7 @@ or `org-babel-execute:c++'."
 (defun org-babel-C-expand (body params &optional processed-params)
   "Expand a block of C or C++ code with org-babel according to
 it's header arguments."
-  (let ((vars (second (or processed-params
+  (let ((vars (nth 1 (or processed-params
                           (org-babel-process-params params))))
         (main-p (not (string= (cdr (assoc :main params)) "no")))
         (includes (or (cdr (assoc :includes params))

lisp/babel/langs/ob-R.el

@@ -35,16 +35,18 @@
 	  pagecentre colormodel useDingbats horizontal)
   "R-specific header arguments.")
 
+(defvar org-babel-default-header-args:R '())
+
 (defun org-babel-expand-body:R (body params &optional processed-params)
   "Expand BODY according to PARAMS, return the expanded body."
   (let* ((processed-params (or processed-params
                                (org-babel-process-params params)))
-	 (vars (mapcar (lambda (i) (cons (car (nth i (second processed-params)))
+	 (vars (mapcar (lambda (i) (cons (car (nth i (nth 1 processed-params)))
 					 (org-babel-reassemble-table
-					  (cdr (nth i (second processed-params)))
-					  (cdr (nth i (fifth processed-params)))
-					  (cdr (nth i (sixth processed-params))))))
-		       (number-sequence 0 (1- (length (second processed-params))))))
+					  (cdr (nth i (nth 1 processed-params)))
+					  (cdr (nth i (nth 4 processed-params)))
+					  (cdr (nth i (nth 5 processed-params))))))
+		       (number-sequence 0 (1- (length (nth 1 processed-params))))))
          (out-file (cdr (assoc :file params))))
     (concat
      (if out-file (concat (org-babel-R-construct-graphics-device-call out-file params) "\n") "")
@@ -62,7 +64,7 @@ called by `org-babel-execute-src-block'."
   (message "executing R source code block...")
   (save-excursion
     (let* ((processed-params (org-babel-process-params params))
-           (result-type (fourth processed-params))
+           (result-type (nth 3 processed-params))
            (session (org-babel-R-initiate-session (first processed-params) params))
 	   (colnames-p (cdr (assoc :colnames params)))
 	   (rownames-p (cdr (assoc :rownames params)))
@@ -122,7 +124,7 @@ called by `org-babel-execute-src-block'."
           (insert "\n"))
         (format "%s <- read.table(\"%s\", header=%s, row.names=%s, sep=\"\\t\", as.is=TRUE)"
                 name transition-file
-		(if (or (eq (second value) 'hline) colnames-p) "TRUE" "FALSE")
+		(if (or (eq (nth 1 value) 'hline) colnames-p) "TRUE" "FALSE")
 		(if rownames-p "1" "NULL")))
     (format "%s <- %s" name (org-babel-R-quote-tsv-field value))))
 

lisp/babel/langs/ob-asymptote.el

@@ -44,6 +44,7 @@
 
 ;;; Code:
 (require 'ob)
+(eval-when-compile (require 'cl))
 
 (add-to-list 'org-babel-tangle-lang-exts '("asymptote" . "asy"))
 
@@ -53,7 +54,7 @@
 
 (defun org-babel-expand-body:asymptote (body params &optional processed-params)
   "Expand BODY according to PARAMS, return the expanded body."
-  (let ((vars (second (or processed-params
+  (let ((vars (nth 1 (or processed-params
                           (org-babel-process-params params)))))
     (concat (mapconcat 'org-babel-asymptote-var-to-asymptote vars "\n")
 	    "\n" body "\n")))

lisp/babel/langs/ob-clojure.el

@@ -45,6 +45,8 @@
 
 (add-to-list 'org-babel-tangle-lang-exts '("clojure" . "clj"))
 
+(defvar org-babel-default-header-args:clojure '())
+
 (defvar org-babel-clojure-wrapper-method
   "
 (defn spit
@@ -268,7 +270,7 @@ last statement in BODY, as elisp."
 (defun org-babel-expand-body:clojure (body params &optional processed-params)
   "Expand BODY according to PARAMS, return the expanded body."
   (org-babel-clojure-build-full-form
-   body (second (or processed-params (org-babel-process-params params)))))
+   body (nth 1 (or processed-params (org-babel-process-params params)))))
 
 (defun org-babel-execute:clojure (body params)
   "Execute a block of Clojure code with org-babel."
@@ -276,7 +278,7 @@ last statement in BODY, as elisp."
          (body (org-babel-expand-body:clojure body params processed-params))
          (session (org-babel-clojure-initiate-session (first processed-params))))
     (org-babel-reassemble-table
-     (org-babel-clojure-evaluate session body (fourth processed-params))
+     (org-babel-clojure-evaluate session body (nth 3 processed-params))
      (org-babel-pick-name (nth 4 processed-params) (cdr (assoc :colnames params)))
      (org-babel-pick-name (nth 5 processed-params) (cdr (assoc :rownames params))))))
 

lisp/babel/langs/ob-css.el

@@ -30,6 +30,8 @@
 ;;; Code:
 (require 'ob)
 
+(defvar org-babel-default-header-args:css '())
+
 (defun org-babel-expand-body:css (body params &optional processed-params)
   "Expand BODY according to PARAMS, return the expanded body." body)
 

lisp/babel/langs/ob-haskell.el

@@ -46,13 +46,15 @@
 
 (add-to-list 'org-babel-tangle-lang-exts '("haskell" . "hs"))
 
+(defvar org-babel-default-header-args:haskell '())
+
 (defvar org-babel-haskell-lhs2tex-command "lhs2tex")
 
 (defvar org-babel-haskell-eoe "\"org-babel-haskell-eoe\"")
 
 (defun org-babel-expand-body:haskell (body params &optional processed-params)
   "Expand BODY according to PARAMS, return the expanded body."
-  (let (vars (second (or processed-params (org-babel-process-params params))))
+  (let (vars (nth 1 (or processed-params (org-babel-process-params params))))
     (concat
      (mapconcat
       (lambda (pair) (format "let %s = %s;" (car pair) (cdr pair)))
@@ -63,8 +65,8 @@
   (message "executing haskell source code block")
   (let* ((processed-params (org-babel-process-params params))
          (session (first processed-params))
-         (vars (second processed-params))
-         (result-type (fourth processed-params))
+         (vars (nth 1 processed-params))
+         (result-type (nth 3 processed-params))
          (full-body (org-babel-expand-body:haskell body params processed-params))
          (session (org-babel-prep-session:haskell session params))
          (raw (org-babel-comint-with-output

lisp/babel/langs/ob-latex.el

@@ -47,7 +47,7 @@
                  (regexp-quote (format "%S" (car pair)))
                  (if (stringp (cdr pair))
                      (cdr pair) (format "%S" (cdr pair)))
-                 body))) (second (org-babel-process-params params)))
+                 body))) (nth 1 (org-babel-process-params params)))
   body)
 
 (defun org-babel-execute:latex (body params)

lisp/babel/langs/ob-matlab.el

@@ -39,6 +39,8 @@
 (require 'matlab)
 (require 'ob-octave)
 
+(defvar org-babel-default-header-args:matlab '())
+
 (defvar org-babel-matlab-shell-command "matlab -nosplash"
   "Shell command to use to run matlab as an external process.")
 

lisp/babel/langs/ob-ocaml.el

@@ -41,12 +41,14 @@
 
 (add-to-list 'org-babel-tangle-lang-exts '("ocaml" . "ml"))
 
+(defvar org-babel-default-header-args:ocaml '())
+
 (defvar org-babel-ocaml-eoe-indicator "\"org-babel-ocaml-eoe\";;")
 (defvar org-babel-ocaml-eoe-output "org-babel-ocaml-eoe")
 
 (defun org-babel-expand-body:ocaml (body params &optional processed-params)
   "Expand BODY according to PARAMS, return the expanded body."
-  (let ((vars (second (or processed-params (org-babel-process-params params)))))
+  (let ((vars (nth 1 (or processed-params (org-babel-process-params params)))))
     (concat
      (mapconcat
       (lambda (pair) (format "let %s = %s;" (car pair) (cdr pair)))
@@ -56,7 +58,7 @@
   "Execute a block of Ocaml code with org-babel."
   (message "executing ocaml source code block")
   (let* ((processed-params (org-babel-process-params params))
-         (vars (second processed-params))
+         (vars (nth 1 processed-params))
          (full-body (org-babel-expand-body:ocaml body params processed-params))
          (session (org-babel-prep-session:ocaml session params))
          (raw (org-babel-comint-with-output

lisp/babel/langs/ob-octave.el

@@ -33,12 +33,14 @@
 (require 'ob)
 (require 'octave-inf)
 
+(defvar org-babel-default-header-args:octave '())
+
 (defvar org-babel-octave-shell-command "octave -q"
   "Shell command to use to run octave as an external process.")
 
 (defun org-babel-expand-body:octave (body params &optional processed-params)
   "Expand BODY according to PARAMS, return the expanded body."
-  (let ((vars (second (or processed-params (org-babel-process-params params)))))
+  (let ((vars (nth 1 (or processed-params (org-babel-process-params params)))))
     (concat
      ;; prepend code to define all arguments passed to the code block
      ;; (may not be appropriate for all languages)
@@ -56,9 +58,9 @@
          ;; set the session if the session variable is non-nil
          (session (funcall (intern (format "org-babel-%s-initiate-session" lang))
 			   (first processed-params) params))
-         (vars (second processed-params))
-         (result-params (third processed-params))
-         (result-type (fourth processed-params))
+         (vars (nth 1 processed-params))
+         (result-params (nth 2 processed-params))
+         (result-type (nth 3 processed-params))
 	 (out-file (cdr (assoc :file params)))
 	 (augmented-body (org-babel-expand-body:octave body params processed-params))
 	 (result (org-babel-octave-evaluate session augmented-body result-type matlabp)))

lisp/babel/langs/ob-perl.el

@@ -31,9 +31,11 @@
 
 (add-to-list 'org-babel-tangle-lang-exts '("perl" . "pl"))
 
+(defvar org-babel-default-header-args:perl '())
+
 (defun org-babel-expand-body:perl (body params &optional processed-params)
   "Expand BODY according to PARAMS, return the expanded body."
-  (let ((vars (second (or processed-params (org-babel-process-params params)))))
+  (let ((vars (nth 1 (or processed-params (org-babel-process-params params)))))
     (concat
      (mapconcat ;; define any variables
       (lambda (pair)
@@ -48,9 +50,9 @@ called by `org-babel-execute-src-block'."
   (message "executing Perl source code block")
   (let* ((processed-params (org-babel-process-params params))
          (session (first processed-params))
-         (vars (second processed-params))
-         (result-params (third processed-params))
-         (result-type (fourth processed-params))
+         (vars (nth 1 processed-params))
+         (result-params (nth 2 processed-params))
+         (result-type (nth 3 processed-params))
          (full-body (org-babel-expand-body:perl
                      body params processed-params)) ;; then the source block body
 	(session (org-babel-perl-initiate-session session)))

lisp/babel/langs/ob-python.el

@@ -34,6 +34,8 @@
 
 (add-to-list 'org-babel-tangle-lang-exts '("python" . "py"))
 
+(defvar org-babel-default-header-args:python '())
+
 (defun org-babel-expand-body:python (body params &optional processed-params)
   "Expand BODY according to PARAMS, return the expanded body."
   (concat
@@ -42,7 +44,7 @@
       (format "%s=%s"
               (car pair)
               (org-babel-python-var-to-python (cdr pair))))
-    (second (or processed-params (org-babel-process-params params))) "\n")
+    (nth 1 (or processed-params (org-babel-process-params params))) "\n")
    "\n" (org-babel-trim body) "\n"))
 
 (defun org-babel-execute:python (body params)
@@ -51,8 +53,8 @@ called by `org-babel-execute-src-block'."
   (message "executing Python source code block")
   (let* ((processed-params (org-babel-process-params params))
          (session (org-babel-python-initiate-session (first processed-params)))
-         (result-params (third processed-params))
-         (result-type (fourth processed-params))
+         (result-params (nth 2 processed-params))
+         (result-type (nth 3 processed-params))
          (full-body (org-babel-expand-body:python
                      body params processed-params)) ;; then the source block body
          (result (org-babel-python-evaluate session full-body result-type)))

lisp/babel/langs/ob-ruby.el

@@ -42,9 +42,11 @@
 
 (add-to-list 'org-babel-tangle-lang-exts '("ruby" . "rb"))
 
+(defvar org-babel-default-header-args:ruby '())
+
 (defun org-babel-expand-body:ruby (body params &optional processed-params)
   "Expand BODY according to PARAMS, return the expanded body."
-  (let ((vars (second (or processed-params (org-babel-process-params params)))))
+  (let ((vars (nth 1 (or processed-params (org-babel-process-params params)))))
     (concat
      (mapconcat ;; define any variables
       (lambda (pair)
@@ -59,8 +61,8 @@ called by `org-babel-execute-src-block'."
   (message "executing Ruby source code block")
   (let* ((processed-params (org-babel-process-params params))
          (session (org-babel-ruby-initiate-session (first processed-params)))
-         (result-params (third processed-params))
-         (result-type (fourth processed-params))
+         (result-params (nth 2 processed-params))
+         (result-type (nth 3 processed-params))
          (full-body (org-babel-expand-body:ruby
                      body params processed-params))
          (result (org-babel-ruby-evaluate session full-body result-type)))

lisp/babel/langs/ob-sass.el

@@ -42,6 +42,8 @@
 (require 'ob)
 (require 'sass-mode)
 
+(defvar org-babel-default-header-args:sass '())
+
 (defun org-babel-expand-body:sass (body params &optional processed-params)
   "Expand BODY according to PARAMS, return the expanded body." body)
 

lisp/babel/langs/ob-screen.el

@@ -63,7 +63,7 @@ In case you want to use a different screen than one selected by your $PATH")
   "Prepare SESSION according to the header arguments specified in PARAMS."
   (let* ((processed-params (org-babel-process-params params))
          (session (first processed-params))
-         (vars (second processed-params))
+         (vars (nth 1 processed-params))
          (socket (org-babel-screen-session-socketname session))
          (vars (org-babel-ref-variables params))
          (cmd (cdr (assoc :cmd params)))

lisp/babel/langs/ob-sh.el

@@ -1,28 +1,26 @@
 ;;; ob-sh.el --- org-babel functions for shell evaluation
 
-;; Copyright (C) 2009 Eric Schulte
+;; Copyright (C) 2009, 2010  Free Software Foundation, Inc.
 
 ;; Author: Eric Schulte
 ;; Keywords: literate programming, reproducible research
 ;; Homepage: http://orgmode.org
 ;; Version: 0.01
 
-;;; License:
+;; This file is part of GNU Emacs.
 
-;; This program is free software; you can redistribute it and/or modify
+;; 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, or (at your option)
-;; any later version.
-;;
-;; This program is distributed in the hope that it will be useful,
+;; 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; see the file COPYING.  If not, write to the
-;; Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
-;; Boston, MA 02110-1301, USA.
+;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
 
 ;;; Commentary:
 
@@ -41,6 +39,8 @@
 (declare-function org-babel-comint-with-output "ob-comint" (meta &rest body))
 (declare-function orgtbl-to-generic "org-table" (table params))
 
+(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'")
@@ -196,4 +196,7 @@ last statement in BODY."
   string)
 
 (provide 'ob-sh)
+
+;; arch-tag: 416dd531-c230-4b0a-a5bf-8d948f990f2d
+
 ;;; ob-sh.el ends here

lisp/babel/langs/ob-sql.el

@@ -45,6 +45,8 @@
 ;;; Code:
 (require 'ob)
 
+(defvar org-babel-default-header-args:sql '())
+
 (defun org-babel-expand-body:sql (body params &optional processed-params)
   "Expand BODY according to PARAMS, return the expanded body." body)
 

lisp/babel/langs/ob-sqlite.el

@@ -29,6 +29,8 @@
 ;;; Code:
 (require 'ob)
 
+(defvar org-babel-default-header-args:sqlite '())
+
 (defun org-babel-expand-body:sqlite
   (body params &optional processed-params) body)