babel: bringing languages closer to compilability

  removing un-needed 'cl functions from language files, and generally
  cleaning them up as if they were going to be compiled.

lisp/babel/langs/ob-C.el

@@ -32,8 +32,11 @@
 
 ;;; 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 '())
@@ -46,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'."
@@ -54,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'
@@ -77,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)))
@@ -93,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)) " ")
@@ -123,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

@@ -41,12 +41,12 @@
   "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") "")
@@ -64,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)))
@@ -124,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

@@ -270,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."
@@ -278,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-haskell.el

@@ -54,7 +54,7 @@
 
 (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)))
@@ -65,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-ocaml.el

@@ -48,7 +48,7 @@
 
 (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)))
@@ -58,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

@@ -40,7 +40,7 @@
 
 (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)
@@ -58,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

@@ -35,7 +35,7 @@
 
 (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)
@@ -50,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

@@ -44,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)
@@ -53,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

@@ -46,7 +46,7 @@
 
 (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)
@@ -61,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-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)))