[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[Emacs-diffs] trunk r115082: Address some byte-compiler warnings.
From: |
Stefan Monnier |
Subject: |
[Emacs-diffs] trunk r115082: Address some byte-compiler warnings. |
Date: |
Tue, 12 Nov 2013 19:11:37 +0000 |
User-agent: |
Bazaar (2.6b2) |
------------------------------------------------------------
revno: 115082
revision-id: address@hidden
parent: address@hidden
committer: Stefan Monnier <address@hidden>
branch nick: trunk
timestamp: Tue 2013-11-12 14:11:22 -0500
message:
Address some byte-compiler warnings.
* lisp/org/ob-abc.el (org-babel-expand-body:abc): Use dolist.
(org-babel-execute:abc): Fix regexp quoting.
* lisp/org/ob-calc.el (org--var-syms): Rename from `var-syms'.
* lisp/org/ob-lilypond.el (ly-compile-lilyfile): Remove redundant let-binding.
* lisp/org/ob-table.el (sbe): Move debug declaration.
* lisp/org/org-clock.el (org--msg-extra): Rename from `msg-extra'.
* lisp/org/org.el (org-version): Avoid var name starting with _.
(org-inhibit-startup, org-called-with-limited-levels)
(org-link-search-inhibit-query, org-time-was-given)
(org-end-time-was-given, org-def, org-defdecode, org-with-time):
* lisp/org/org-colview.el (org-agenda-overriding-columns-format):
* lisp/org/org-agenda.el (org-agenda-multi, org-depend-tag-blocked)
(org-agenda-show-log-scoped):
* lisp/org/ob-python.el (py-which-bufname, python-shell-buffer-name):
* lisp/org/ob-haskell.el (org-export-copy-to-kill-ring):
* lisp/org/ob-exp.el (org-link-search-inhibit-query):
* lisp/org/ob-R.el (ess-eval-visibly-p):
* lisp/org/ob-core.el (org-src-window-setup): Declare before use.
(org-babel-expand-noweb-references): Remove unused `blocks-in-buffer'.
* lisp/org/ox-odt.el (org-odt-hfy-face-to-css):
* lisp/org/org-src.el (org-src-associate-babel-session,
org-src-get-lang-mode):
* lisp/org/org-bibtex.el (org-bibtex-get, org-bibtex-ask, org-bibtex)
(org-bibtex-check):
* lisp/org/ob-tangle.el (org-babel-tangle, org-babel-spec-to-string)
(org-babel-tangle-single-block, org-babel-tangle-comment-links):
* ob-table.el (sbe):
* lisp/org/ob-sqlite.el (org-babel-sqlite-expand-vars):
* lisp/org/ob-sql.el (org-babel-sql-expand-vars):
* lisp/org/ob-shen.el (org-babel-execute:shen):
* lisp/org/ob-sh.el (org-babel-execute:sh, org-babel-sh-evaluate):
* lisp/org/ob-scala.el (org-babel-scala-evaluate):
* lisp/org/ob-ruby.el (org-babel-ruby-table-or-string)
(org-babel-ruby-evaluate):
* ob-python.el (org-babel-python-table-or-string)
(org-babel-python-evaluate-external-process)
(org-babel-python-evaluate-session):
* lisp/org/ob-picolisp.el (org-babel-execute:picolisp):
* lisp/org/ob-perl.el (org-babel-perl-evaluate):
* lisp/org/ob-maxima.el (org-babel-execute:maxima):
* lisp/org/ob-lisp.el (org-babel-execute:lisp):
* lisp/org/ob-java.el (org-babel-execute:java):
* lisp/org/ob-io.el (org-babel-io-evaluate):
* ob-haskell.el (org-babel-execute:haskell):
* lisp/org/ob-fortran.el (org-babel-execute:fortran):
* ob-exp.el (org-babel-exp-code):
* lisp/org/ob-emacs-lisp.el (org-babel-execute:emacs-lisp):
* lisp/org/ob-ditaa.el (org-babel-execute:ditaa):
* ob-core.el (org-babel-execute-src-block, org-babel-sha1-hash)
(org-babel-parse-header-arguments, org-babel-reassemble-table)
(org-babel-goto-src-block-head, org-babel-mark-block)
(org-babel-expand-noweb-references, org-babel-script-escape)
(org-babel-process-file-name):
* lisp/org/ob-clojure.el (org-babel-execute:clojure):
* ob-calc.el (org-babel-execute:calc):
* lisp/org/ob-awk.el (org-babel-execute:awk):
* ob-abc.el (org-babel-execute:abc):
* ob-R.el (org-babel-expand-body:R):
* lisp/org/ob-C.el (org-babel-C-execute): Avoid deprecated ((lambda) ...).
modified:
lisp/org/ChangeLog changelog-20091113204419-o5vbwnq5f7feedwu-8688
lisp/org/ob-C.el obc.el-20100719092623-qqnigi7w9j01gc4a-1
lisp/org/ob-R.el obr.el-20100719092623-qqnigi7w9j01gc4a-2
lisp/org/ob-abc.el obabc.el-20131112130502-8825zrk0dp6b9sq5-1
lisp/org/ob-awk.el obawk.el-20110728151247-eso0s650t3voqmp2-1
lisp/org/ob-calc.el obcalc.el-20101112040732-apqfq2vpif3tntlx-1
lisp/org/ob-clojure.el obclojure.el-20100719092623-qqnigi7w9j01gc4a-4
lisp/org/ob-core.el obcore.el-20131112130502-8825zrk0dp6b9sq5-2
lisp/org/ob-ditaa.el obditaa.el-20100719092623-qqnigi7w9j01gc4a-7
lisp/org/ob-emacs-lisp.el
obemacslisp.el-20100719092623-qqnigi7w9j01gc4a-9
lisp/org/ob-exp.el obexp.el-20100719092623-qqnigi7w9j01gc4a-11
lisp/org/ob-fortran.el obfortran.el-20120103172612-0q0mibxixas6mmn4-1
lisp/org/ob-haskell.el obhaskell.el-20100719092623-qqnigi7w9j01gc4a-13
lisp/org/ob-io.el obio.el-20120930151232-4h74n9a4qnern8xn-1
lisp/org/ob-java.el objava.el-20110728151250-qzv1pjpcqzd74fyc-1
lisp/org/ob-lilypond.el oblilypond.el-20110728151254-1s914ce601jqtlky-1
lisp/org/ob-lisp.el oblisp.el-20101112040752-kipqhnpx8gebyqjq-1
lisp/org/ob-maxima.el obmaxima.el-20110728151306-g5f886j8plknc2p2-1
lisp/org/ob-perl.el obperl.el-20100719092623-qqnigi7w9j01gc4a-21
lisp/org/ob-picolisp.el obpicolisp.el-20120103172612-0q0mibxixas6mmn4-2
lisp/org/ob-python.el obpython.el-20100719092623-qqnigi7w9j01gc4a-22
lisp/org/ob-ruby.el obruby.el-20100719092623-qqnigi7w9j01gc4a-24
lisp/org/ob-scala.el obscala.el-20120930151224-4xltuxacl8tl3iq8-1
lisp/org/ob-sh.el obsh.el-20100719092623-qqnigi7w9j01gc4a-27
lisp/org/ob-shen.el obshen.el-20120103172612-0q0mibxixas6mmn4-3
lisp/org/ob-sql.el obsql.el-20100719092623-qqnigi7w9j01gc4a-28
lisp/org/ob-sqlite.el obsqlite.el-20100719092623-qqnigi7w9j01gc4a-29
lisp/org/ob-table.el obtable.el-20100719092623-qqnigi7w9j01gc4a-30
lisp/org/ob-tangle.el obtangle.el-20100719092623-qqnigi7w9j01gc4a-31
lisp/org/org-agenda.el
orgagenda.el-20091113204419-o5vbwnq5f7feedwu-8640
lisp/org/org-bibtex.el
orgbibtex.el-20091113204419-o5vbwnq5f7feedwu-8643
lisp/org/org-clock.el
orgclock.el-20091113204419-o5vbwnq5f7feedwu-8644
lisp/org/org-colview.el
orgcolview.el-20091113204419-o5vbwnq5f7feedwu-8645
lisp/org/org-src.el orgsrc.el-20091113204419-o5vbwnq5f7feedwu-10913
lisp/org/org.el org.el-20091113204419-o5vbwnq5f7feedwu-8617
lisp/org/ox-odt.el oxodt.el-20131112130502-8825zrk0dp6b9sq5-14
=== modified file 'lisp/org/ChangeLog'
--- a/lisp/org/ChangeLog 2013-11-12 17:04:19 +0000
+++ b/lisp/org/ChangeLog 2013-11-12 19:11:22 +0000
@@ -1,3 +1,65 @@
+2013-11-12 Stefan Monnier <address@hidden>
+
+ Address some byte-compiler warnings.
+ * ob-abc.el (org-babel-expand-body:abc): Use dolist.
+ (org-babel-execute:abc): Fix regexp quoting.
+ * ob-calc.el (org--var-syms): Rename from `var-syms'.
+ * ob-lilypond.el (ly-compile-lilyfile): Remove redundant let-binding.
+ * ob-table.el (sbe): Move debug declaration.
+ * org-clock.el (org--msg-extra): Rename from `msg-extra'.
+ * org.el (org-version): Avoid var name starting with _.
+ (org-inhibit-startup, org-called-with-limited-levels)
+ (org-link-search-inhibit-query, org-time-was-given)
+ (org-end-time-was-given, org-def, org-defdecode, org-with-time):
+ * org-colview.el (org-agenda-overriding-columns-format):
+ * org-agenda.el (org-agenda-multi, org-depend-tag-blocked)
+ (org-agenda-show-log-scoped):
+ * ob-python.el (py-which-bufname, python-shell-buffer-name):
+ * ob-haskell.el (org-export-copy-to-kill-ring):
+ * ob-exp.el (org-link-search-inhibit-query):
+ * ob-R.el (ess-eval-visibly-p):
+ * ob-core.el (org-src-window-setup): Declare before use.
+ (org-babel-expand-noweb-references): Remove unused `blocks-in-buffer'.
+ * ox-odt.el (org-odt-hfy-face-to-css):
+ * org-src.el (org-src-associate-babel-session, org-src-get-lang-mode):
+ * org-bibtex.el (org-bibtex-get, org-bibtex-ask, org-bibtex)
+ (org-bibtex-check):
+ * ob-tangle.el (org-babel-tangle, org-babel-spec-to-string)
+ (org-babel-tangle-single-block, org-babel-tangle-comment-links):
+ * ob-table.el (sbe):
+ * ob-sqlite.el (org-babel-sqlite-expand-vars):
+ * ob-sql.el (org-babel-sql-expand-vars):
+ * ob-shen.el (org-babel-execute:shen):
+ * ob-sh.el (org-babel-execute:sh, org-babel-sh-evaluate):
+ * ob-scala.el (org-babel-scala-evaluate):
+ * ob-ruby.el (org-babel-ruby-table-or-string)
+ (org-babel-ruby-evaluate):
+ * ob-python.el (org-babel-python-table-or-string)
+ (org-babel-python-evaluate-external-process)
+ (org-babel-python-evaluate-session):
+ * ob-picolisp.el (org-babel-execute:picolisp):
+ * ob-perl.el (org-babel-perl-evaluate):
+ * ob-maxima.el (org-babel-execute:maxima):
+ * ob-lisp.el (org-babel-execute:lisp):
+ * ob-java.el (org-babel-execute:java):
+ * ob-io.el (org-babel-io-evaluate):
+ * ob-haskell.el (org-babel-execute:haskell):
+ * ob-fortran.el (org-babel-execute:fortran):
+ * ob-exp.el (org-babel-exp-code):
+ * ob-emacs-lisp.el (org-babel-execute:emacs-lisp):
+ * ob-ditaa.el (org-babel-execute:ditaa):
+ * ob-core.el (org-babel-execute-src-block, org-babel-sha1-hash)
+ (org-babel-parse-header-arguments, org-babel-reassemble-table)
+ (org-babel-goto-src-block-head, org-babel-mark-block)
+ (org-babel-expand-noweb-references, org-babel-script-escape)
+ (org-babel-process-file-name):
+ * ob-clojure.el (org-babel-execute:clojure):
+ * ob-calc.el (org-babel-execute:calc):
+ * ob-awk.el (org-babel-execute:awk):
+ * ob-abc.el (org-babel-execute:abc):
+ * ob-R.el (org-babel-expand-body:R):
+ * ob-C.el (org-babel-C-execute): Avoid deprecated ((lambda) ...).
+
2013-11-12 Glenn Morris <address@hidden>
* ox-html.el (org-html-scripts): Add 2013 to copyright years.
@@ -14,7 +76,7 @@
* ob-python.el: Update the arglist passed to `declare-function'
for `run-python'.
- * ob-tangle.el (org-babel-tangle): Use 'light argument to
+ * ob-tangle.el (org-babel-tangle): Use `light' argument to
`org-babel-get-src-block-info'.
* ob-core.el (org-babel-execute-src-block): Return nil in case of
@@ -5191,7 +5253,7 @@
* org-clock.el (org-clock-notify-once-if-expired): Honor
`org-clock-sound'.
-2013-11-12 Rasmus Pank <address@hidden>
+2013-11-12 Rasmus Pank <address@hidden>
* org.el (org-format-latex-header): Remove eucal and amsmath.
(org-latex-default-packages-alist): Remove amstext and add
=== modified file 'lisp/org/ob-C.el'
--- a/lisp/org/ob-C.el 2013-11-12 13:06:26 +0000
+++ b/lisp/org/ob-C.el 2013-11-12 19:11:22 +0000
@@ -103,20 +103,21 @@
(mapconcat 'identity
(if (listp flags) flags (list flags)) " ")
(org-babel-process-file-name tmp-src-file)) ""))))
- ((lambda (results)
- (org-babel-reassemble-table
- (org-babel-result-cond (cdr (assoc :result-params params))
- (org-babel-read results)
- (let ((tmp-file (org-babel-temp-file "c-")))
- (with-temp-file tmp-file (insert results))
- (org-babel-import-elisp-from-file tmp-file)))
- (org-babel-pick-name
- (cdr (assoc :colname-names params)) (cdr (assoc :colnames params)))
- (org-babel-pick-name
- (cdr (assoc :rowname-names params)) (cdr (assoc :rownames params)))))
- (org-babel-trim
- (org-babel-eval
- (concat tmp-bin-file (if cmdline (concat " " cmdline) "")) "")))))
+ (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)
"Expand a block of C or C++ code with org-babel according to
=== modified file 'lisp/org/ob-R.el'
--- a/lisp/org/ob-R.el 2013-11-12 13:06:26 +0000
+++ b/lisp/org/ob-R.el 2013-11-12 19:11:22 +0000
@@ -85,21 +85,22 @@
(or graphics-file (org-babel-R-graphical-output-file params))))
(mapconcat
#'identity
- ((lambda (inside)
- (if graphics-file
- (append
- (list (org-babel-R-construct-graphics-device-call
- graphics-file params))
- inside
- (list "dev.off()"))
- inside))
- (append
- (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")))
+ (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")))
(defun org-babel-execute:R (body params)
"Execute a block of R code.
@@ -324,6 +325,8 @@
column-names-p)))
(output (org-babel-eval org-babel-R-command body))))
+(defvar ess-eval-visibly-p)
+
(defun org-babel-R-evaluate-session
(session body result-type result-params column-names-p row-names-p)
"Evaluate BODY in SESSION.
=== modified file 'lisp/org/ob-abc.el'
--- a/lisp/org/ob-abc.el 2013-11-12 17:03:46 +0000
+++ b/lisp/org/ob-abc.el 2013-11-12 19:11:22 +0000
@@ -24,9 +24,11 @@
;;; 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/
+;; 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/
+
+;;; Code:
(require 'ob)
@@ -40,18 +42,15 @@
(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))
+ (dolist (pair (mapcar #'cdr (org-babel-get-header params :var)))
+ (let ((name (symbol-name (car pair)))
+ (value (cdr pair)))
+ (setq body
+ (replace-regexp-in-string
+ (concat "\$" (regexp-quote name)) ;FIXME: "\$" == "$"!
+ (if (stringp value) value (format "%S" value))
+ body))))
+ body)
(defun org-babel-execute:abc (body params)
"Execute a block of ABC code with org-babel. This function is
@@ -59,10 +58,10 @@
(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)))))
+ (out-file
+ (let ((el (cdr (assoc :file params))))
+ (if el (replace-regexp-in-string "\\.pdf\\'" ".ps" el)
+ (error "abc code block requires :file header argument"))))
(in-file (org-babel-temp-file "abc-"))
(render (concat "abcm2ps" " " cmdline
" -O " (org-babel-process-file-name out-file)
=== modified file 'lisp/org/ob-awk.el'
--- a/lisp/org/ob-awk.el 2013-11-12 13:06:26 +0000
+++ b/lisp/org/ob-awk.el 2013-11-12 19:11:22 +0000
@@ -59,34 +59,33 @@
(cmd-line (cdr (assoc :cmd-line params)))
(in-file (cdr (assoc :in-file params)))
(full-body (org-babel-expand-body:awk body params))
- (code-file ((lambda (file) (with-temp-file file (insert full-body))
file)
- (org-babel-temp-file "awk-")))
- (stdin ((lambda (stdin)
+ (code-file (let ((file (org-babel-temp-file "awk-")))
+ (with-temp-file file (insert full-body)) file))
+ (stdin (let ((stdin (cdr (assoc :stdin params))))
(when stdin
(let ((tmp (org-babel-temp-file "awk-stdin-"))
(res (org-babel-ref-resolve stdin)))
(with-temp-file tmp
(insert (org-babel-awk-var-to-awk res)))
- tmp)))
- (cdr (assoc :stdin params))))
+ tmp))))
(cmd (mapconcat #'identity (remove nil (list org-babel-awk-command
"-f" code-file
cmd-line
in-file))
" ")))
(org-babel-reassemble-table
- ((lambda (results)
- (when results
- (org-babel-result-cond result-params
- results
- (let ((tmp (org-babel-temp-file "awk-results-")))
- (with-temp-file tmp (insert results))
- (org-babel-import-elisp-from-file tmp)))))
- (cond
- (stdin (with-temp-buffer
- (call-process-shell-command cmd stdin (current-buffer))
- (buffer-string)))
- (t (org-babel-eval cmd ""))))
+ (let ((results
+ (cond
+ (stdin (with-temp-buffer
+ (call-process-shell-command cmd stdin (current-buffer))
+ (buffer-string)))
+ (t (org-babel-eval cmd "")))))
+ (when results
+ (org-babel-result-cond result-params
+ results
+ (let ((tmp (org-babel-temp-file "awk-results-")))
+ (with-temp-file tmp (insert results))
+ (org-babel-import-elisp-from-file tmp)))))
(org-babel-pick-name
(cdr (assoc :colname-names params)) (cdr (assoc :colnames params)))
(org-babel-pick-name
=== modified file 'lisp/org/ob-calc.el'
--- a/lisp/org/ob-calc.el 2013-11-12 13:06:26 +0000
+++ b/lisp/org/ob-calc.el 2013-11-12 19:11:22 +0000
@@ -42,13 +42,15 @@
(defun org-babel-expand-body:calc (body params)
"Expand BODY according to PARAMS, return the expanded body." body)
+(defvar org--var-syms) ; Dynamically scoped from org-babel-execute:calc
+
(defun org-babel-execute:calc (body params)
"Execute a block of calc code with Babel."
(unless (get-buffer "*Calculator*")
(save-window-excursion (calc) (calc-quit)))
(let* ((vars (mapcar #'cdr (org-babel-get-header params :var)))
- (var-syms (mapcar #'car vars))
- (var-names (mapcar #'symbol-name var-syms)))
+ (org--var-syms (mapcar #'car vars))
+ (var-names (mapcar #'symbol-name org--var-syms)))
(mapc
(lambda (pair)
(calc-push-list (list (cdr pair)))
@@ -66,33 +68,32 @@
;; complex expression
(t
(calc-push-list
- (list ((lambda (res)
- (cond
- ((numberp res) res)
- ((math-read-number res) (math-read-number res))
- ((listp res) (error "Calc error \"%s\" on input \"%s\""
- (cadr res) line))
- (t (replace-regexp-in-string
- "'" ""
- (calc-eval
- (math-evaluate-expr
- ;; resolve user variables, calc built in
- ;; variables are handled automatically
- ;; upstream by calc
- (mapcar #'org-babel-calc-maybe-resolve-var
- ;; parse line into calc objects
- (car (math-read-exprs line)))))))))
- (calc-eval line))))))))
+ (list (let ((res (calc-eval line)))
+ (cond
+ ((numberp res) res)
+ ((math-read-number res) (math-read-number res))
+ ((listp res) (error "Calc error \"%s\" on input \"%s\""
+ (cadr res) line))
+ (t (replace-regexp-in-string
+ "'" ""
+ (calc-eval
+ (math-evaluate-expr
+ ;; resolve user variables, calc built in
+ ;; variables are handled automatically
+ ;; upstream by calc
+ (mapcar #'org-babel-calc-maybe-resolve-var
+ ;; parse line into calc objects
+ (car (math-read-exprs line)))))))))
+ ))))))
(mapcar #'org-babel-trim
(split-string (org-babel-expand-body:calc body params) "[\n\r]"))))
(save-excursion
(with-current-buffer (get-buffer "*Calculator*")
(calc-eval (calc-top 1)))))
-(defvar var-syms) ; Dynamically scoped from org-babel-execute:calc
(defun org-babel-calc-maybe-resolve-var (el)
(if (consp el)
- (if (and (equal 'var (car el)) (member (cadr el) var-syms))
+ (if (and (equal 'var (car el)) (member (cadr el) org--var-syms))
(progn
(calc-recall (cadr el))
(prog1 (calc-top 1)
=== modified file 'lisp/org/ob-clojure.el'
--- a/lisp/org/ob-clojure.el 2013-11-12 13:06:26 +0000
+++ b/lisp/org/ob-clojure.el 2013-11-12 19:11:22 +0000
@@ -24,17 +24,17 @@
;;; Commentary:
-;;; support for evaluating clojure code, relies on slime for all eval
+;; Support for evaluating clojure code, relies on slime for all eval.
;;; Requirements:
-;;; - clojure (at least 1.2.0)
-;;; - clojure-mode
-;;; - slime
+;; - clojure (at least 1.2.0)
+;; - clojure-mode
+;; - slime
-;;; By far, the best way to install these components is by following
-;;; the directions as set out by Phil Hagelberg (Technomancy) on the
-;;; web page: http://technomancy.us/126
+;; By far, the best way to install these components is by following
+;; the directions as set out by Phil Hagelberg (Technomancy) on the
+;; web page: http://technomancy.us/126
;;; Code:
(require 'ob)
@@ -77,16 +77,16 @@
(require 'slime)
(with-temp-buffer
(insert (org-babel-expand-body:clojure body params))
- ((lambda (result)
- (let ((result-params (cdr (assoc :result-params params))))
- (org-babel-result-cond result-params
- result
- (condition-case nil (org-babel-script-escape result)
- (error result)))))
- (slime-eval
- `(swank:eval-and-grab-output
- ,(buffer-substring-no-properties (point-min) (point-max)))
- (cdr (assoc :package params))))))
+ (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)))))))
(provide 'ob-clojure)
=== modified file 'lisp/org/ob-core.el'
--- a/lisp/org/ob-core.el 2013-11-12 13:06:26 +0000
+++ b/lisp/org/ob-core.el 2013-11-12 19:11:22 +0000
@@ -632,15 +632,14 @@
(message "result silenced")
(setq result nil))
(setq result
- ((lambda (result)
- (if (and (eq (cdr (assoc :result-type params))
- 'value)
- (or (member "vector" result-params)
- (member "table" result-params))
- (not (listp result)))
- (list (list result)) result))
- (funcall cmd body params)))
- ;; if non-empty result and :file then write to :file
+ (let ((result (funcall cmd body params)))
+ (if (and (eq (cdr (assoc :result-type params))
+ 'value)
+ (or (member "vector" result-params)
+ (member "table" result-params))
+ (not (listp result)))
+ (list (list result)) result)))
+ ;; If non-empty result and :file then write to :file.
(when (cdr (assoc :file params))
(when result
(with-temp-file (cdr (assoc :file params))
@@ -648,7 +647,7 @@
(org-babel-format-result
result (cdr (assoc :sep (nth 2 info)))))))
(setq result (cdr (assoc :file params))))
- ;; possibly perform post process provided its appropriate
+ ;; Possibly perform post process provided its appropriate.
(when (cdr (assoc :post params))
(let ((*this* (if (cdr (assoc :file params))
(org-babel-result-to-file
@@ -893,6 +892,8 @@
(defalias 'org-babel-pop-to-session 'org-babel-switch-to-session)
+(defvar org-src-window-setup)
+
;;;###autoload
(defun org-babel-switch-to-session-with-code (&optional arg info)
"Switch to code buffer and display session."
@@ -1157,18 +1158,18 @@
(mapconcat #'identity (sort (funcall rm (split-string
v))
#'string<) " "))
(t v)))))))
- ((lambda (hash)
- (when (org-called-interactively-p 'interactive) (message hash)) hash)
- (let ((it (format "%s-%s"
- (mapconcat
- #'identity
- (delq nil (mapcar (lambda (arg)
- (let ((normalized (funcall norm
arg)))
- (when normalized
- (format "%S" normalized))))
- (nth 2 info))) ":")
- (nth 1 info))))
- (sha1 it))))))
+ (let* ((it (format "%s-%s"
+ (mapconcat
+ #'identity
+ (delq nil (mapcar (lambda (arg)
+ (let ((normalized (funcall norm
arg)))
+ (when normalized
+ (format "%S" normalized))))
+ (nth 2 info))) ":")
+ (nth 1 info)))
+ (hash (sha1 it)))
+ (when (org-called-interactively-p 'interactive) (message hash))
+ hash))))
(defun org-babel-current-result-hash ()
"Return the current in-buffer hash."
@@ -1453,9 +1454,8 @@
(cons (intern (match-string 1 arg))
(org-babel-read (org-babel-chomp (match-string 2 arg))))
(cons (intern (org-babel-chomp arg)) nil)))
- ((lambda (raw)
- (cons (car raw) (mapcar (lambda (r) (concat ":" r)) (cdr raw))))
- (org-babel-balanced-split arg-string '((32 9) . 58))))))))
+ (let ((raw (org-babel-balanced-split arg-string '((32 9) . 58))))
+ (cons (car raw) (mapcar (lambda (r) (concat ":" r)) (cdr
raw)))))))))
(defun org-babel-parse-multiple-vars (header-arguments)
"Expand multiple variable assignments behind a single :var keyword.
@@ -1598,12 +1598,11 @@
Given a TABLE and set of COLNAMES and ROWNAMES add the names
to the table for reinsertion to org-mode."
(if (listp table)
- ((lambda (table)
- (if (and colnames (listp (car table)) (= (length (car table))
- (length colnames)))
- (org-babel-put-colnames table colnames) table))
- (if (and rownames (= (length table) (length rownames)))
- (org-babel-put-rownames table rownames) table))
+ (let ((table (if (and rownames (= (length table) (length rownames)))
+ (org-babel-put-rownames table rownames) table)))
+ (if (and colnames (listp (car table)) (= (length (car table))
+ (length colnames)))
+ (org-babel-put-colnames table colnames) table))
table))
(defun org-babel-where-is-src-block-head ()
@@ -1640,9 +1639,8 @@
(defun org-babel-goto-src-block-head ()
"Go to the beginning of the current code block."
(interactive)
- ((lambda (head)
- (if head (goto-char head) (error "Not currently in a code block")))
- (org-babel-where-is-src-block-head)))
+ (let ((head (org-babel-where-is-src-block-head)))
+ (if head (goto-char head) (error "Not currently in a code block"))))
;;;###autoload
(defun org-babel-goto-named-src-block (name)
@@ -1763,14 +1761,13 @@
(defun org-babel-mark-block ()
"Mark current src block."
(interactive)
- ((lambda (head)
- (when head
- (save-excursion
- (goto-char head)
- (looking-at org-babel-src-block-regexp))
- (push-mark (match-end 5) nil t)
- (goto-char (match-beginning 5))))
- (org-babel-where-is-src-block-head)))
+ (let ((head (org-babel-where-is-src-block-head)))
+ (when head
+ (save-excursion
+ (goto-char head)
+ (looking-at org-babel-src-block-regexp))
+ (push-mark (match-end 5) nil t)
+ (goto-char (match-beginning 5)))))
(defun org-babel-demarcate-block (&optional arg)
"Wrap or split the code in the region or on the point.
@@ -2450,7 +2447,7 @@
(funcall (intern (concat lang "-mode")))
(comment-region (point) (progn (insert text) (point)))
(org-babel-trim (buffer-string)))))
- index source-name evaluate prefix blocks-in-buffer)
+ index source-name evaluate prefix)
(with-temp-buffer
(org-set-local 'org-babel-noweb-wrap-start ob-nww-start)
(org-set-local 'org-babel-noweb-wrap-end ob-nww-end)
@@ -2469,119 +2466,118 @@
(funcall nb-add (buffer-substring index (point)))
(goto-char (match-end 0))
(setq index (point))
- (funcall nb-add
- (with-current-buffer parent-buffer
- (save-restriction
- (widen)
- (mapconcat ;; interpose PREFIX between every line
- #'identity
- (split-string
- (if evaluate
- (let ((raw (org-babel-ref-resolve source-name)))
- (if (stringp raw) raw (format "%S" raw)))
- (or
- ;; retrieve from the library of babel
- (nth 2 (assoc (intern source-name)
- org-babel-library-of-babel))
- ;; return the contents of headlines literally
- (save-excursion
- (when (org-babel-ref-goto-headline-id source-name)
+ (funcall
+ nb-add
+ (with-current-buffer parent-buffer
+ (save-restriction
+ (widen)
+ (mapconcat ;; Interpose PREFIX between every line.
+ #'identity
+ (split-string
+ (if evaluate
+ (let ((raw (org-babel-ref-resolve source-name)))
+ (if (stringp raw) raw (format "%S" raw)))
+ (or
+ ;; Retrieve from the library of babel.
+ (nth 2 (assoc (intern source-name)
+ org-babel-library-of-babel))
+ ;; Return the contents of headlines literally.
+ (save-excursion
+ (when (org-babel-ref-goto-headline-id source-name)
(org-babel-ref-headline-body)))
- ;; find the expansion of reference in this buffer
- (let ((rx (concat rx-prefix source-name "[ \t\n]"))
- expansion)
- (save-excursion
- (goto-char (point-min))
- (if org-babel-use-quick-and-dirty-noweb-expansion
- (while (re-search-forward rx nil t)
- (let* ((i (org-babel-get-src-block-info
'light))
- (body
(org-babel-expand-noweb-references i))
- (sep (or (cdr (assoc :noweb-sep (nth
2 i)))
- "\n"))
- (full (if comment
- ((lambda (cs)
- (concat (funcall c-wrap
(car cs)) "\n"
- body "\n"
- (funcall c-wrap
(cadr cs))))
-
(org-babel-tangle-comment-links i))
- body)))
- (setq expansion (cons sep (cons full
expansion)))))
- (org-babel-map-src-blocks nil
- (let ((i (org-babel-get-src-block-info
'light)))
- (when (equal (or (cdr (assoc :noweb-ref
(nth 2 i)))
- (nth 4 i))
- source-name)
- (let* ((body
(org-babel-expand-noweb-references i))
- (sep (or (cdr (assoc :noweb-sep
(nth 2 i)))
- "\n"))
- (full (if comment
- ((lambda (cs)
- (concat (funcall
c-wrap (car cs)) "\n"
- body "\n"
- (funcall
c-wrap (cadr cs))))
-
(org-babel-tangle-comment-links i))
- body)))
- (setq expansion
- (cons sep (cons full
expansion)))))))))
- (and expansion
- (mapconcat #'identity (nreverse (cdr
expansion)) "")))
- ;; possibly raise an error if named block doesn't
exist
- (if (member lang org-babel-noweb-error-langs)
- (error "%s" (concat
- (org-babel-noweb-wrap source-name)
- "could not be resolved (see "
- "`org-babel-noweb-error-langs')"))
- "")))
- "[\n\r]") (concat "\n" prefix))))))
+ ;; Find the expansion of reference in this buffer.
+ (let ((rx (concat rx-prefix source-name "[ \t\n]"))
+ expansion)
+ (save-excursion
+ (goto-char (point-min))
+ (if org-babel-use-quick-and-dirty-noweb-expansion
+ (while (re-search-forward rx nil t)
+ (let* ((i (org-babel-get-src-block-info 'light))
+ (body (org-babel-expand-noweb-references i))
+ (sep (or (cdr (assoc :noweb-sep (nth 2 i)))
+ "\n"))
+ (full (if comment
+ (let ((cs
(org-babel-tangle-comment-links i)))
+ (concat (funcall c-wrap (car
cs)) "\n"
+ body "\n"
+ (funcall c-wrap (cadr
cs))))
+ body)))
+ (setq expansion (cons sep (cons full
expansion)))))
+ (org-babel-map-src-blocks nil
+ (let ((i (org-babel-get-src-block-info 'light)))
+ (when (equal (or (cdr (assoc :noweb-ref (nth 2 i)))
+ (nth 4 i))
+ source-name)
+ (let* ((body (org-babel-expand-noweb-references
i))
+ (sep (or (cdr (assoc :noweb-sep (nth 2
i)))
+ "\n"))
+ (full (if comment
+ (let ((cs
(org-babel-tangle-comment-links i)))
+ (concat (funcall c-wrap (car
cs)) "\n"
+ body "\n"
+ (funcall c-wrap
(cadr cs))))
+ body)))
+ (setq expansion
+ (cons sep (cons full expansion)))))))))
+ (and expansion
+ (mapconcat #'identity (nreverse (cdr expansion)) "")))
+ ;; Possibly raise an error if named block doesn't exist.
+ (if (member lang org-babel-noweb-error-langs)
+ (error "%s" (concat
+ (org-babel-noweb-wrap source-name)
+ "could not be resolved (see "
+ "`org-babel-noweb-error-langs')"))
+ "")))
+ "[\n\r]") (concat "\n" prefix))))))
(funcall nb-add (buffer-substring index (point-max))))
new-body))
(defun org-babel-script-escape (str &optional force)
"Safely convert tables into elisp lists."
- (let (in-single in-double out)
- ((lambda (escaped) (condition-case nil (org-babel-read escaped) (error
escaped)))
- (if (or force
- (and (stringp str)
- (> (length str) 2)
- (or (and (string-equal "[" (substring str 0 1))
- (string-equal "]" (substring str -1)))
- (and (string-equal "{" (substring str 0 1))
- (string-equal "}" (substring str -1)))
- (and (string-equal "(" (substring str 0 1))
- (string-equal ")" (substring str -1))))))
- (org-babel-read
- (concat
- "'"
- (progn
- (mapc
- (lambda (ch)
- (setq
- out
- (case ch
- (91 (if (or in-double in-single) ; [
- (cons 91 out)
- (cons 40 out)))
- (93 (if (or in-double in-single) ; ]
- (cons 93 out)
- (cons 41 out)))
- (123 (if (or in-double in-single) ; {
- (cons 123 out)
- (cons 40 out)))
- (125 (if (or in-double in-single) ; }
- (cons 125 out)
- (cons 41 out)))
- (44 (if (or in-double in-single) ; ,
- (cons 44 out) (cons 32 out)))
- (39 (if in-double ; '
- (cons 39 out)
- (setq in-single (not in-single)) (cons 34 out)))
- (34 (if in-single ; "
- (append (list 34 32) out)
- (setq in-double (not in-double)) (cons 34 out)))
- (t (cons ch out)))))
- (string-to-list str))
- (apply #'string (reverse out)))))
- str))))
+ (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)))
+ (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.
@@ -2691,8 +2687,8 @@
remotely. The file name is then processed by `expand-file-name'.
Unless second argument NO-QUOTE-P is non-nil, the file name is
additionally processed by `shell-quote-argument'"
- ((lambda (f) (if no-quote-p f (shell-quote-argument f)))
- (expand-file-name (org-babel-local-file-name name))))
+ (let ((f (expand-file-name (org-babel-local-file-name name))))
+ (if no-quote-p f (shell-quote-argument f))))
(defvar org-babel-temporary-directory)
(unless (or noninteractive (boundp 'org-babel-temporary-directory))
=== modified file 'lisp/org/ob-ditaa.el'
--- a/lisp/org/ob-ditaa.el 2013-11-12 13:06:26 +0000
+++ b/lisp/org/ob-ditaa.el 2013-11-12 19:11:22 +0000
@@ -82,11 +82,10 @@
"Execute a block of Ditaa code with org-babel.
This function is called by `org-babel-execute-src-block'."
(let* ((result-params (split-string (or (cdr (assoc :results params)) "")))
- (out-file ((lambda (el)
- (or el
- (error
- "ditaa code block requires :file header argument")))
- (cdr (assoc :file params))))
+ (out-file (let ((el (cdr (assoc :file params))))
+ (or el
+ (error
+ "ditaa code block requires :file header argument"))))
(cmdline (cdr (assoc :cmdline params)))
(java (cdr (assoc :java params)))
(in-file (org-babel-temp-file "ditaa-"))
=== modified file 'lisp/org/ob-emacs-lisp.el'
--- a/lisp/org/ob-emacs-lisp.el 2013-11-12 13:06:26 +0000
+++ b/lisp/org/ob-emacs-lisp.el 2013-11-12 19:11:22 +0000
@@ -54,25 +54,26 @@
(defun org-babel-execute:emacs-lisp (body params)
"Execute a block of emacs-lisp code with Babel."
(save-window-excursion
- ((lambda (result)
- (org-babel-result-cond (cdr (assoc :result-params params))
- (let ((print-level nil)
- (print-length nil))
- (if (or (member "scalar" (cdr (assoc :result-params params)))
- (member "verbatim" (cdr (assoc :result-params params))))
- (format "%S" result)
- (format "%s" result)))
- (org-babel-reassemble-table
- result
- (org-babel-pick-name (cdr (assoc :colname-names params))
- (cdr (assoc :colnames params)))
- (org-babel-pick-name (cdr (assoc :rowname-names params))
- (cdr (assoc :rownames params))))))
- (eval (read (format (if (member "output"
- (cdr (assoc :result-params params)))
- "(with-output-to-string %s)"
- "(progn %s)")
- (org-babel-expand-body:emacs-lisp body params)))))))
+ (let ((result
+ (eval (read (format (if (member "output"
+ (cdr (assoc :result-params params)))
+ "(with-output-to-string %s)"
+ "(progn %s)")
+ (org-babel-expand-body:emacs-lisp
+ body params))))))
+ (org-babel-result-cond (cdr (assoc :result-params params))
+ (let ((print-level nil)
+ (print-length nil))
+ (if (or (member "scalar" (cdr (assoc :result-params params)))
+ (member "verbatim" (cdr (assoc :result-params params))))
+ (format "%S" result)
+ (format "%s" result)))
+ (org-babel-reassemble-table
+ result
+ (org-babel-pick-name (cdr (assoc :colname-names params))
+ (cdr (assoc :colnames params)))
+ (org-babel-pick-name (cdr (assoc :rowname-names params))
+ (cdr (assoc :rownames params))))))))
(provide 'ob-emacs-lisp)
=== modified file 'lisp/org/ob-exp.el'
--- a/lisp/org/ob-exp.el 2013-11-12 13:06:26 +0000
+++ b/lisp/org/ob-exp.el 2013-11-12 19:11:22 +0000
@@ -69,6 +69,8 @@
('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)))
@@ -372,7 +374,7 @@
(cons (substring (symbol-name (car pair)) 1)
(format "%S" (cdr pair))))
(nth 2 info))
- ("flags" . ,((lambda (f) (when f (concat " " f))) (nth 3 info)))
+ ("flags" . ,(let ((f (nth 3 info))) (when f (concat " " f))))
("name" . ,(or (nth 4 info) "")))))
(defun org-babel-exp-results (info type &optional silent hash)
=== modified file 'lisp/org/ob-fortran.el'
--- a/lisp/org/ob-fortran.el 2013-11-12 13:06:26 +0000
+++ b/lisp/org/ob-fortran.el 2013-11-12 19:11:22 +0000
@@ -60,20 +60,20 @@
(mapconcat 'identity
(if (listp flags) flags (list flags)) " ")
(org-babel-process-file-name tmp-src-file)) ""))))
- ((lambda (results)
- (org-babel-reassemble-table
- (org-babel-result-cond (cdr (assoc :result-params params))
- (org-babel-read results)
- (let ((tmp-file (org-babel-temp-file "f-")))
- (with-temp-file tmp-file (insert results))
- (org-babel-import-elisp-from-file tmp-file)))
- (org-babel-pick-name
- (cdr (assoc :colname-names params)) (cdr (assoc :colnames params)))
- (org-babel-pick-name
- (cdr (assoc :rowname-names params)) (cdr (assoc :rownames params)))))
- (org-babel-trim
- (org-babel-eval
- (concat tmp-bin-file (if cmdline (concat " " cmdline) "")) "")))))
+ (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 "f-")))
+ (with-temp-file tmp-file (insert results))
+ (org-babel-import-elisp-from-file tmp-file)))
+ (org-babel-pick-name
+ (cdr (assoc :colname-names params)) (cdr (assoc :colnames params)))
+ (org-babel-pick-name
+ (cdr (assoc :rowname-names params)) (cdr (assoc :rownames params)))))))
(defun org-babel-expand-body:fortran (body params)
"Expand a block of fortran or fortran code with org-babel according to
=== modified file 'lisp/org/ob-haskell.el'
--- a/lisp/org/ob-haskell.el 2013-11-12 13:06:26 +0000
+++ b/lisp/org/ob-haskell.el 2013-11-12 19:11:22 +0000
@@ -79,12 +79,12 @@
(cdr (member org-babel-haskell-eoe
(reverse (mapcar #'org-babel-trim raw)))))))
(org-babel-reassemble-table
- ((lambda (result)
- (org-babel-result-cond (cdr (assoc :result-params params))
- result (org-babel-haskell-table-or-string result)))
- (case result-type
- ('output (mapconcat #'identity (reverse (cdr results)) "\n"))
- ('value (car results))))
+ (let ((result
+ (case result-type
+ (output (mapconcat #'identity (reverse (cdr results)) "\n"))
+ (value (car results)))))
+ (org-babel-result-cond (cdr (assoc :result-params params))
+ result (org-babel-haskell-table-or-string result)))
(org-babel-pick-name (cdr (assoc :colname-names params))
(cdr (assoc :colname-names params)))
(org-babel-pick-name (cdr (assoc :rowname-names params))
@@ -148,6 +148,7 @@
(format "%S" var)))
(defvar org-src-preserve-indentation)
+(defvar org-export-copy-to-kill-ring)
(declare-function org-export-to-file "ox"
(backend file
&optional async subtreep visible-only body-only
ext-plist))
=== modified file 'lisp/org/ob-io.el'
--- a/lisp/org/ob-io.el 2013-11-12 13:06:26 +0000
+++ b/lisp/org/ob-io.el 2013-11-12 19:11:22 +0000
@@ -94,12 +94,11 @@
(value (let* ((src-file (org-babel-temp-file "io-"))
(wrapper (format org-babel-io-wrapper-method body)))
(with-temp-file src-file (insert wrapper))
- ((lambda (raw)
- (org-babel-result-cond result-params
- raw
- (org-babel-io-table-or-string raw)))
- (org-babel-eval
- (concat org-babel-io-command " " src-file) ""))))))
+ (let ((raw (org-babel-eval
+ (concat org-babel-io-command " " src-file) "")))
+ (org-babel-result-cond result-params
+ raw
+ (org-babel-io-table-or-string raw)))))))
(defun org-babel-prep-session:io (session params)
=== modified file 'lisp/org/ob-java.el'
--- a/lisp/org/ob-java.el 2013-11-12 13:06:26 +0000
+++ b/lisp/org/ob-java.el 2013-11-12 19:11:22 +0000
@@ -55,19 +55,18 @@
;; created package-name directories if missing
(unless (or (not packagename) (file-exists-p packagename))
(make-directory packagename 'parents))
- ((lambda (results)
- (org-babel-reassemble-table
- (org-babel-result-cond (cdr (assoc :result-params params))
- (org-babel-read results)
- (let ((tmp-file (org-babel-temp-file "c-")))
- (with-temp-file tmp-file (insert results))
- (org-babel-import-elisp-from-file tmp-file)))
- (org-babel-pick-name
- (cdr (assoc :colname-names params)) (cdr (assoc :colnames params)))
- (org-babel-pick-name
- (cdr (assoc :rowname-names params)) (cdr (assoc :rownames params)))))
- (org-babel-eval (concat org-babel-java-command
- " " cmdline " " classname) ""))))
+ (let ((results (org-babel-eval (concat org-babel-java-command
+ " " cmdline " " classname) "")))
+ (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)))))))
(provide 'ob-java)
=== modified file 'lisp/org/ob-lilypond.el'
--- a/lisp/org/ob-lilypond.el 2013-11-12 13:06:26 +0000
+++ b/lisp/org/ob-lilypond.el 2013-11-12 19:11:22 +0000
@@ -200,7 +200,6 @@
(let ((arg-1 (ly-determine-ly-path)) ;program
(arg-2 nil) ;infile
(arg-3 "*lilypond*") ;buffer
- (arg-4 t) ;display
(arg-4 t) ;display
(arg-5 (if ly-gen-png "--png" "")) ;&rest...
(arg-6 (if ly-gen-html "--html" ""))
=== modified file 'lisp/org/ob-lisp.el'
--- a/lisp/org/ob-lisp.el 2013-11-12 13:06:26 +0000
+++ b/lisp/org/ob-lisp.el 2013-11-12 19:11:22 +0000
@@ -75,23 +75,24 @@
"Execute a block of Common Lisp code with Babel."
(require 'slime)
(org-babel-reassemble-table
- ((lambda (result)
- (org-babel-result-cond (cdr (assoc :result-params params))
- (car result)
- (condition-case nil
- (read (org-babel-lisp-vector-to-list (cadr result)))
- (error (cadr result)))))
- (with-temp-buffer
- (insert (org-babel-expand-body:lisp body params))
- (slime-eval `(swank:eval-and-grab-output
- ,(let ((dir (if (assoc :dir params)
- (cdr (assoc :dir params))
- default-directory)))
- (format
- (if dir (format org-babel-lisp-dir-fmt dir) "(progn
%s)")
- (buffer-substring-no-properties
- (point-min) (point-max)))))
- (cdr (assoc :package params)))))
+ (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))))))
+ (org-babel-result-cond (cdr (assoc :result-params params))
+ (car result)
+ (condition-case nil
+ (read (org-babel-lisp-vector-to-list (cadr result)))
+ (error (cadr result)))))
(org-babel-pick-name (cdr (assoc :colname-names params))
(cdr (assoc :colnames params)))
(org-babel-pick-name (cdr (assoc :rowname-names params))
=== modified file 'lisp/org/ob-maxima.el'
--- a/lisp/org/ob-maxima.el 2013-11-12 13:06:26 +0000
+++ b/lisp/org/ob-maxima.el 2013-11-12 19:11:22 +0000
@@ -65,8 +65,8 @@
"\n")))
(defun org-babel-execute:maxima (body params)
- "Execute a block of Maxima entries with org-babel. This function is
-called by `org-babel-execute-src-block'."
+ "Execute a block of Maxima entries with org-babel.
+This function is called by `org-babel-execute-src-block'."
(message "executing Maxima source code block")
(let ((result-params (split-string (or (cdr (assoc :results params)) "")))
(result
@@ -76,18 +76,18 @@
org-babel-maxima-command in-file cmdline)))
(with-temp-file in-file (insert (org-babel-maxima-expand body
params)))
(message cmd)
- ((lambda (raw) ;; " | grep -v batch | grep -v 'replaced' | sed
'/^$/d' "
- (mapconcat
- #'identity
- (delq nil
- (mapcar (lambda (line)
- (unless (or (string-match "batch" line)
- (string-match "^rat: replaced .*$"
line)
- (string-match "^;;; Loading #P" line)
- (= 0 (length line)))
- line))
- (split-string raw "[\r\n]"))) "\n"))
- (org-babel-eval cmd "")))))
+ ;; " | grep -v batch | grep -v 'replaced' | sed '/^$/d' "
+ (let ((raw (org-babel-eval cmd "")))
+ (mapconcat
+ #'identity
+ (delq nil
+ (mapcar (lambda (line)
+ (unless (or (string-match "batch" line)
+ (string-match "^rat: replaced .*$"
line)
+ (string-match "^;;; Loading #P" line)
+ (= 0 (length line)))
+ line))
+ (split-string raw "[\r\n]"))) "\n")))))
(if (org-babel-maxima-graphical-output-file params)
nil
(org-babel-result-cond result-params
=== modified file 'lisp/org/ob-perl.el'
--- a/lisp/org/ob-perl.el 2013-11-12 13:06:26 +0000
+++ b/lisp/org/ob-perl.el 2013-11-12 19:11:22 +0000
@@ -135,21 +135,21 @@
(tmp-file (org-babel-temp-file "perl-"))
(tmp-babel-file (org-babel-process-file-name
tmp-file 'noquote)))
- ((lambda (results)
- (when results
- (org-babel-result-cond result-params
- (org-babel-eval-read-file tmp-file)
- (org-babel-import-elisp-from-file tmp-file '(16)))))
- (case result-type
- (output
- (with-temp-file tmp-file
- (insert
- (org-babel-eval org-babel-perl-command body))
- (buffer-string)))
- (value
- (org-babel-eval org-babel-perl-command
- (format org-babel-perl-wrapper-method
- body tmp-babel-file)))))))
+ (let ((results
+ (case result-type
+ (output
+ (with-temp-file tmp-file
+ (insert
+ (org-babel-eval org-babel-perl-command body))
+ (buffer-string)))
+ (value
+ (org-babel-eval org-babel-perl-command
+ (format org-babel-perl-wrapper-method
+ body tmp-babel-file))))))
+ (when results
+ (org-babel-result-cond result-params
+ (org-babel-eval-read-file tmp-file)
+ (org-babel-import-elisp-from-file tmp-file '(16)))))))
(provide 'ob-perl)
=== modified file 'lisp/org/ob-picolisp.el'
--- a/lisp/org/ob-picolisp.el 2013-11-12 13:06:26 +0000
+++ b/lisp/org/ob-picolisp.el 2013-11-12 19:11:22 +0000
@@ -99,16 +99,16 @@
called by `org-babel-execute-src-block'"
(message "executing Picolisp source code block")
(let* (
- ;; name of the session or "none"
+ ;; Name of the session or "none".
(session-name (cdr (assoc :session params)))
- ;; set the session if the session variable is non-nil
+ ;; Set the session if the session variable is non-nil.
(session (org-babel-picolisp-initiate-session session-name))
- ;; either OUTPUT or VALUE which should behave as described above
+ ;; Either OUTPUT or VALUE which should behave as described above.
(result-type (cdr (assoc :result-type params)))
(result-params (cdr (assoc :result-params params)))
- ;; expand the body with `org-babel-expand-body:picolisp'
+ ;; Expand the body with `org-babel-expand-body:picolisp'.
(full-body (org-babel-expand-body:picolisp body params))
- ;; wrap body appropriately for the type of evaluation and results
+ ;; Wrap body appropriately for the type of evaluation and results.
(wrapped-body
(cond
((or (member "code" result-params)
@@ -118,53 +118,54 @@
(format "(print (out \"/dev/null\" %s))" full-body))
((member "value" result-params)
(format "(out \"/dev/null\" %s)" full-body))
- (t full-body))))
-
- ((lambda (result)
- (org-babel-result-cond result-params
- result
- (read result)))
- (if (not (string= session-name "none"))
- ;; session based evaluation
- (mapconcat ;; <- joins the list back together into a single string
- #'identity
- (butlast ;; <- remove the org-babel-picolisp-eoe line
- (delq nil
- (mapcar
- (lambda (line)
- (org-babel-chomp ;; remove trailing newlines
- (when (> (length line) 0) ;; remove empty lines
- (cond
- ;; remove leading "-> " from return values
- ((and (>= (length line) 3)
- (string= "-> " (substring line 0 3)))
- (substring line 3))
- ;; remove trailing "-> <<return-value>>" on the
- ;; last line of output
- ((and (member "output" result-params)
- (string-match-p "->" line))
- (substring line 0 (string-match "->" line)))
- (t line)
- )
- ;; (if (and (>= (length line) 3) ;; remove leading "<- "
- ;; (string= "-> " (substring line 0 3)))
- ;; (substring line 3)
- ;; line)
- )))
- ;; returns a list of the output of each evaluated expression
- (org-babel-comint-with-output (session
org-babel-picolisp-eoe)
- (insert wrapped-body) (comint-send-input)
- (insert "'" org-babel-picolisp-eoe) (comint-send-input)))))
- "\n")
- ;; external evaluation
- (let ((script-file (org-babel-temp-file "picolisp-script-")))
- (with-temp-file script-file
- (insert (concat wrapped-body "(bye)")))
- (org-babel-eval
- (format "%s %s"
- org-babel-picolisp-cmd
- (org-babel-process-file-name script-file))
- ""))))))
+ (t full-body)))
+ (result
+ (if (not (string= session-name "none"))
+ ;; Session based evaluation.
+ (mapconcat ;; <- joins the list back into a single string
+ #'identity
+ (butlast ;; <- remove the org-babel-picolisp-eoe line
+ (delq nil
+ (mapcar
+ (lambda (line)
+ (org-babel-chomp ;; Remove trailing newlines.
+ (when (> (length line) 0) ;; Remove empty lines.
+ (cond
+ ;; Remove leading "-> " from return values.
+ ((and (>= (length line) 3)
+ (string= "-> " (substring line 0 3)))
+ (substring line 3))
+ ;; Remove trailing "-> <<return-value>>" on the
+ ;; last line of output.
+ ((and (member "output" result-params)
+ (string-match-p "->" line))
+ (substring line 0 (string-match "->" line)))
+ (t line)
+ )
+ ;;(if (and (>= (length line) 3);Remove leading "<-"
+ ;; (string= "-> " (substring line 0 3)))
+ ;; (substring line 3)
+ ;; line)
+ )))
+ ;; Returns a list of the output of each evaluated exp.
+ (org-babel-comint-with-output
+ (session org-babel-picolisp-eoe)
+ (insert wrapped-body) (comint-send-input)
+ (insert "'" org-babel-picolisp-eoe)
+ (comint-send-input)))))
+ "\n")
+ ;; external evaluation
+ (let ((script-file (org-babel-temp-file "picolisp-script-")))
+ (with-temp-file script-file
+ (insert (concat wrapped-body "(bye)")))
+ (org-babel-eval
+ (format "%s %s"
+ org-babel-picolisp-cmd
+ (org-babel-process-file-name script-file))
+ "")))))
+ (org-babel-result-cond result-params
+ result
+ (read result))))
(defun org-babel-picolisp-initiate-session (&optional session-name)
"If there is not a current inferior-process-buffer in SESSION
=== modified file 'lisp/org/ob-python.el'
--- a/lisp/org/ob-python.el 2013-11-12 13:06:26 +0000
+++ b/lisp/org/ob-python.el 2013-11-12 19:11:22 +0000
@@ -143,13 +143,12 @@
"Convert RESULTS into an appropriate elisp value.
If the results look like a list or tuple, then convert them into an
Emacs-lisp table, otherwise return the results as a string."
- ((lambda (res)
- (if (listp res)
- (mapcar (lambda (el) (if (equal el 'None)
- org-babel-python-None-to el))
- res)
- res))
- (org-babel-script-escape results)))
+ (let ((res (org-babel-script-escape results)))
+ (if (listp res)
+ (mapcar (lambda (el) (if (equal el 'None)
+ org-babel-python-None-to el))
+ res)
+ res)))
(defvar org-babel-python-buffers '((:default . "*Python*")))
@@ -172,6 +171,8 @@
name)))
(defvar py-default-interpreter)
+(defvar py-which-bufname)
+(defvar python-shell-buffer-name)
(defun org-babel-python-initiate-session-by-key (&optional session)
"Initiate a python session.
If there is not a current inferior-process-buffer in SESSION
@@ -252,34 +253,34 @@
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."
- ((lambda (raw)
- (org-babel-result-cond result-params
- raw
- (org-babel-python-table-or-string (org-babel-trim raw))))
- (case result-type
- (output (org-babel-eval org-babel-python-command
- (concat (if preamble (concat preamble "\n") "")
- body)))
- (value (let ((tmp-file (org-babel-temp-file "python-")))
- (org-babel-eval
- org-babel-python-command
- (concat
- (if preamble (concat preamble "\n") "")
- (format
- (if (member "pp" result-params)
- org-babel-python-pp-wrapper-method
- org-babel-python-wrapper-method)
- (mapconcat
- (lambda (line) (format "\t%s" line))
- (split-string
- (org-remove-indentation
- (org-babel-trim body))
- "[\r\n]") "\n")
- (org-babel-process-file-name tmp-file 'noquote))))
- (org-babel-eval-read-file tmp-file))))))
+ (let ((raw
+ (case result-type
+ (output (org-babel-eval org-babel-python-command
+ (concat (if preamble (concat preamble "\n"))
+ body)))
+ (value (let ((tmp-file (org-babel-temp-file "python-")))
+ (org-babel-eval
+ org-babel-python-command
+ (concat
+ (if preamble (concat preamble "\n") "")
+ (format
+ (if (member "pp" result-params)
+ org-babel-python-pp-wrapper-method
+ org-babel-python-wrapper-method)
+ (mapconcat
+ (lambda (line) (format "\t%s" line))
+ (split-string
+ (org-remove-indentation
+ (org-babel-trim body))
+ "[\r\n]") "\n")
+ (org-babel-process-file-name tmp-file 'noquote))))
+ (org-babel-eval-read-file tmp-file))))))
+ (org-babel-result-cond result-params
+ raw
+ (org-babel-python-table-or-string (org-babel-trim raw)))))
(defun org-babel-python-evaluate-session
- (session body &optional result-type result-params)
+ (session body &optional result-type result-params)
"Pass BODY to the Python process in SESSION.
If RESULT-TYPE equals 'output then return standard output as a
string. If RESULT-TYPE equals 'value then return the value of the
@@ -296,39 +297,41 @@
(format "open('%s', 'w').write(pprint.pformat(_))"
(org-babel-process-file-name tmp-file 'noquote)))
(list (format "open('%s', 'w').write(str(_))"
- (org-babel-process-file-name tmp-file
'noquote)))))))
+ (org-babel-process-file-name tmp-file
+ 'noquote)))))))
(input-body (lambda (body)
(mapc (lambda (line) (insert line) (funcall send-wait))
(split-string body "[\r\n]"))
- (funcall send-wait))))
- ((lambda (results)
- (unless (string= (substring org-babel-python-eoe-indicator 1 -1)
results)
- (org-babel-result-cond result-params
- results
- (org-babel-python-table-or-string results))))
- (case result-type
- (output
- (mapconcat
- #'org-babel-trim
- (butlast
- (org-babel-comint-with-output
- (session org-babel-python-eoe-indicator t body)
- (funcall input-body body)
- (funcall send-wait) (funcall send-wait)
- (insert org-babel-python-eoe-indicator)
- (funcall send-wait))
- 2) "\n"))
- (value
- (let ((tmp-file (org-babel-temp-file "python-")))
- (org-babel-comint-with-output
- (session org-babel-python-eoe-indicator nil body)
- (let ((comint-process-echoes nil))
- (funcall input-body body)
- (funcall dump-last-value tmp-file (member "pp" result-params))
- (funcall send-wait) (funcall send-wait)
- (insert org-babel-python-eoe-indicator)
- (funcall send-wait)))
- (org-babel-eval-read-file tmp-file)))))))
+ (funcall send-wait)))
+ (results
+ (case result-type
+ (output
+ (mapconcat
+ #'org-babel-trim
+ (butlast
+ (org-babel-comint-with-output
+ (session org-babel-python-eoe-indicator t body)
+ (funcall input-body body)
+ (funcall send-wait) (funcall send-wait)
+ (insert org-babel-python-eoe-indicator)
+ (funcall send-wait))
+ 2) "\n"))
+ (value
+ (let ((tmp-file (org-babel-temp-file "python-")))
+ (org-babel-comint-with-output
+ (session org-babel-python-eoe-indicator nil body)
+ (let ((comint-process-echoes nil))
+ (funcall input-body body)
+ (funcall dump-last-value tmp-file
+ (member "pp" result-params))
+ (funcall send-wait) (funcall send-wait)
+ (insert org-babel-python-eoe-indicator)
+ (funcall send-wait)))
+ (org-babel-eval-read-file tmp-file))))))
+ (unless (string= (substring org-babel-python-eoe-indicator 1 -1) results)
+ (org-babel-result-cond result-params
+ results
+ (org-babel-python-table-or-string results)))))
(defun org-babel-python-read-string (string)
"Strip 's from around Python string."
=== modified file 'lisp/org/ob-ruby.el'
--- a/lisp/org/ob-ruby.el 2013-11-12 13:06:26 +0000
+++ b/lisp/org/ob-ruby.el 2013-11-12 19:11:22 +0000
@@ -139,13 +139,12 @@
"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."
- ((lambda (res)
- (if (listp res)
- (mapcar (lambda (el) (if (equal el 'nil)
- org-babel-ruby-nil-to el))
- res)
- res))
- (org-babel-script-escape results)))
+ (let ((res (org-babel-script-escape results)))
+ (if (listp res)
+ (mapcar (lambda (el) (if (equal el 'nil)
+ org-babel-ruby-nil-to el))
+ res)
+ res)))
(defun org-babel-ruby-initiate-session (&optional session params)
"Initiate a ruby session.
@@ -204,12 +203,11 @@
org-babel-ruby-pp-wrapper-method
org-babel-ruby-wrapper-method)
body (org-babel-process-file-name tmp-file 'noquote)))
- ((lambda (raw)
- (if (or (member "code" result-params)
- (member "pp" result-params))
- raw
- (org-babel-ruby-table-or-string raw)))
- (org-babel-eval-read-file tmp-file)))))
+ (let ((raw (org-babel-eval-read-file tmp-file)))
+ (if (or (member "code" result-params)
+ (member "pp" result-params))
+ raw
+ (org-babel-ruby-table-or-string raw))))))
;; comint session evaluation
(case result-type
(output
=== modified file 'lisp/org/ob-scala.el'
--- a/lisp/org/ob-scala.el 2013-11-12 13:06:26 +0000
+++ b/lisp/org/ob-scala.el 2013-11-12 19:11:22 +0000
@@ -100,12 +100,11 @@
(let* ((src-file (org-babel-temp-file "scala-"))
(wrapper (format org-babel-scala-wrapper-method body)))
(with-temp-file src-file (insert wrapper))
- ((lambda (raw)
- (org-babel-result-cond result-params
- raw
- (org-babel-scala-table-or-string raw)))
- (org-babel-eval
- (concat org-babel-scala-command " " src-file) ""))))))
+ (let ((raw (org-babel-eval
+ (concat org-babel-scala-command " " src-file) "")))
+ (org-babel-result-cond result-params
+ raw
+ (org-babel-scala-table-or-string raw)))))))
(defun org-babel-prep-session:scala (session params)
=== modified file 'lisp/org/ob-sh.el'
--- a/lisp/org/ob-sh.el 2013-11-12 13:06:26 +0000
+++ b/lisp/org/ob-sh.el 2013-11-12 19:11:22 +0000
@@ -53,9 +53,9 @@
This function is called by `org-babel-execute-src-block'."
(let* ((session (org-babel-sh-initiate-session
(cdr (assoc :session params))))
- (stdin ((lambda (stdin) (when stdin (org-babel-sh-var-to-string
- (org-babel-ref-resolve stdin))))
- (cdr (assoc :stdin params))))
+ (stdin (let ((stdin (cdr (assoc :stdin params))))
+ (when stdin (org-babel-sh-var-to-string
+ (org-babel-ref-resolve stdin)))))
(full-body (org-babel-expand-body:generic
body params (org-babel-variable-assignments:sh params))))
(org-babel-reassemble-table
@@ -135,68 +135,69 @@
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."
- ((lambda (results)
- (when results
- (let ((result-params (cdr (assoc :result-params params))))
- (org-babel-result-cond result-params
- results
- (let ((tmp-file (org-babel-temp-file "sh-")))
- (with-temp-file tmp-file (insert results))
- (org-babel-import-elisp-from-file tmp-file))))))
- (cond
- (stdin ; 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)))
- (padline (not (string= "no" (cdr (assoc :padline params))))))
- (with-temp-file script-file
- (when shebang (insert (concat shebang "\n")))
- (when padline (insert "\n"))
- (insert body))
- (set-file-modes script-file #o755)
- (with-temp-file stdin-file (insert stdin))
- (with-temp-buffer
- (call-process-shell-command
- (if shebang
- script-file
- (format "%s %s" org-babel-sh-command script-file))
- stdin-file
- (current-buffer))
- (buffer-string))))
- (session ; session evaluation
- (mapconcat
- #'org-babel-sh-strip-weird-long-prompt
- (mapcar
- #'org-babel-trim
- (butlast
- (org-babel-comint-with-output
- (session org-babel-sh-eoe-output t body)
- (mapc
- (lambda (line)
- (insert line)
- (comint-send-input nil t)
- (while (save-excursion
- (goto-char comint-last-input-end)
- (not (re-search-forward
- comint-prompt-regexp nil t)))
- (accept-process-output (get-buffer-process (current-buffer)))))
- (append
- (split-string (org-babel-trim body) "\n")
- (list org-babel-sh-eoe-indicator))))
- 2)) "\n"))
- ('otherwise ; external shell script
- (if (and (cdr (assoc :shebang params))
- (> (length (cdr (assoc :shebang params))) 0))
- (let ((script-file (org-babel-temp-file "sh-script-"))
- (shebang (cdr (assoc :shebang params)))
- (padline (not (string= "no" (cdr (assoc :padline params))))))
- (with-temp-file script-file
- (when shebang (insert (concat shebang "\n")))
- (when padline (insert "\n"))
- (insert body))
- (set-file-modes script-file #o755)
- (org-babel-eval script-file ""))
- (org-babel-eval org-babel-sh-command (org-babel-trim body)))))))
+ (let ((results
+ (cond
+ (stdin ; 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)))
+ (padline (not (string= "no" (cdr (assoc :padline params))))))
+ (with-temp-file script-file
+ (when shebang (insert (concat shebang "\n")))
+ (when padline (insert "\n"))
+ (insert body))
+ (set-file-modes script-file #o755)
+ (with-temp-file stdin-file (insert stdin))
+ (with-temp-buffer
+ (call-process-shell-command
+ (if shebang
+ script-file
+ (format "%s %s" org-babel-sh-command script-file))
+ stdin-file
+ (current-buffer))
+ (buffer-string))))
+ (session ; session evaluation
+ (mapconcat
+ #'org-babel-sh-strip-weird-long-prompt
+ (mapcar
+ #'org-babel-trim
+ (butlast
+ (org-babel-comint-with-output
+ (session org-babel-sh-eoe-output t body)
+ (mapc
+ (lambda (line)
+ (insert line)
+ (comint-send-input nil t)
+ (while (save-excursion
+ (goto-char comint-last-input-end)
+ (not (re-search-forward
+ comint-prompt-regexp nil t)))
+ (accept-process-output
+ (get-buffer-process (current-buffer)))))
+ (append
+ (split-string (org-babel-trim body) "\n")
+ (list org-babel-sh-eoe-indicator))))
+ 2)) "\n"))
+ ('otherwise ; external shell script
+ (if (and (cdr (assoc :shebang params))
+ (> (length (cdr (assoc :shebang params))) 0))
+ (let ((script-file (org-babel-temp-file "sh-script-"))
+ (shebang (cdr (assoc :shebang params)))
+ (padline (not (equal "no" (cdr (assoc :padline
params))))))
+ (with-temp-file script-file
+ (when shebang (insert (concat shebang "\n")))
+ (when padline (insert "\n"))
+ (insert body))
+ (set-file-modes script-file #o755)
+ (org-babel-eval script-file ""))
+ (org-babel-eval org-babel-sh-command (org-babel-trim body)))))))
+ (when results
+ (let ((result-params (cdr (assoc :result-params params))))
+ (org-babel-result-cond result-params
+ results
+ (let ((tmp-file (org-babel-temp-file "sh-")))
+ (with-temp-file tmp-file (insert results))
+ (org-babel-import-elisp-from-file tmp-file)))))))
(defun org-babel-sh-strip-weird-long-prompt (string)
"Remove prompt cruft from a string of shell output."
=== modified file 'lisp/org/ob-shen.el'
--- a/lisp/org/ob-shen.el 2013-11-12 13:06:26 +0000
+++ b/lisp/org/ob-shen.el 2013-11-12 19:11:22 +0000
@@ -66,14 +66,14 @@
(let* ((result-type (cdr (assoc :result-type params)))
(result-params (cdr (assoc :result-params params)))
(full-body (org-babel-expand-body:shen body params)))
- ((lambda (results)
- (org-babel-result-cond result-params
- results
- (condition-case nil (org-babel-script-escape results)
- (error results))))
- (with-temp-buffer
- (insert full-body)
- (call-interactively #'shen-eval-defun)))))
+ (let ((results
+ (with-temp-buffer
+ (insert full-body)
+ (call-interactively #'shen-eval-defun))))
+ (org-babel-result-cond result-params
+ results
+ (condition-case nil (org-babel-script-escape results)
+ (error results))))))
(provide 'ob-shen)
;;; ob-shen.el ends here
=== modified file 'lisp/org/ob-sql.el'
--- a/lisp/org/ob-sql.el 2013-11-12 13:06:26 +0000
+++ b/lisp/org/ob-sql.el 2013-11-12 19:11:22 +0000
@@ -186,19 +186,17 @@
(lambda (pair)
(setq body
(replace-regexp-in-string
- (format "\$%s" (car pair))
- ((lambda (val)
- (if (listp val)
- ((lambda (data-file)
- (with-temp-file data-file
- (insert (orgtbl-to-csv
- val '(:fmt (lambda (el) (if (stringp el)
- el
- (format "%S"
el)))))))
- data-file)
- (org-babel-temp-file "sql-data-"))
- (if (stringp val) val (format "%S" val))))
- (cdr pair))
+ (format "\$%s" (car pair)) ;FIXME: "\$" == "$"!
+ (let ((val (cdr pair)))
+ (if (listp val)
+ (let ((data-file (org-babel-temp-file "sql-data-")))
+ (with-temp-file data-file
+ (insert (orgtbl-to-csv
+ val '(:fmt (lambda (el) (if (stringp el)
+ el
+ (format "%S" el)))))))
+ data-file)
+ (if (stringp val) val (format "%S" val))))
body)))
vars)
body)
=== modified file 'lisp/org/ob-sqlite.el'
--- a/lisp/org/ob-sqlite.el 2013-11-12 13:06:26 +0000
+++ b/lisp/org/ob-sqlite.el 2013-11-12 19:11:22 +0000
@@ -114,23 +114,22 @@
(defun org-babel-sqlite-expand-vars (body vars)
"Expand the variables held in VARS in BODY."
+ ;; FIXME: Redundancy with org-babel-sql-expand-vars!
(mapc
(lambda (pair)
(setq body
(replace-regexp-in-string
- (format "\$%s" (car pair))
- ((lambda (val)
- (if (listp val)
- ((lambda (data-file)
- (with-temp-file data-file
- (insert (orgtbl-to-csv
- val '(:fmt (lambda (el) (if (stringp el)
- el
- (format "%S"
el)))))))
- data-file)
- (org-babel-temp-file "sqlite-data-"))
- (if (stringp val) val (format "%S" val))))
- (cdr pair))
+ (format "\$%s" (car pair)) ;FIXME: "\$" == "$"!
+ (let ((val (cdr pair)))
+ (if (listp val)
+ (let ((data-file (org-babel-temp-file "sqlite-data-")))
+ (with-temp-file data-file
+ (insert (orgtbl-to-csv
+ val '(:fmt (lambda (el) (if (stringp el)
+ el
+ (format "%S" el)))))))
+ data-file)
+ (if (stringp val) val (format "%S" val))))
body)))
vars)
body)
=== modified file 'lisp/org/ob-table.el'
--- a/lisp/org/ob-table.el 2013-11-12 13:06:26 +0000
+++ b/lisp/org/ob-table.el 2013-11-12 19:11:22 +0000
@@ -60,7 +60,7 @@
(concat (substring string 0 (match-beginning 0))
(if (match-string 1 string) "...")) string))
-(defmacro sbe (source-block &rest variables)
+(defmacro sbe (source-block &rest variables) ;FIXME: Namespace prefix!
"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
@@ -85,6 +85,7 @@
| 1 | 2 | :file nothing.png | nothing.png |
#+TBLFM: @1$4='(sbe test-sbe $3 (x $1) (y $2))"
+ (declare (debug (form form)))
(let* ((header-args (if (stringp (car variables)) (car variables) ""))
(variables (if (stringp (car variables)) (cdr variables) variables)))
(let* (quote
@@ -107,31 +108,31 @@
variables)))
(unless (stringp source-block)
(setq source-block (symbol-name source-block)))
- ((lambda (result)
- (org-babel-trim (if (stringp result) result (format "%S" result))))
- (if (and source-block (> (length source-block) 0))
- (let ((params
- (eval `(org-babel-parse-header-arguments
- (concat
- ":var results="
- ,source-block
- "[" ,header-args "]"
- "("
- (mapconcat
- (lambda (var-spec)
- (if (> (length (cdr var-spec)) 1)
- (format "%S='%S"
- (car var-spec)
- (mapcar #'read (cdr var-spec)))
- (format "%S=%s"
- (car var-spec) (cadr var-spec))))
- ',variables ", ")
- ")")))))
- (org-babel-execute-src-block
- nil (list "emacs-lisp" "results" params)
- '((:results . "silent"))))
- "")))))
-(def-edebug-spec sbe (form form))
+ (let ((result
+ (if (and source-block (> (length source-block) 0))
+ (let ((params
+ ;; FIXME: Why `eval'?!?!?
+ (eval `(org-babel-parse-header-arguments
+ (concat
+ ":var results="
+ ,source-block
+ "[" ,header-args "]"
+ "("
+ (mapconcat
+ (lambda (var-spec)
+ (if (> (length (cdr var-spec)) 1)
+ (format "%S='%S"
+ (car var-spec)
+ (mapcar #'read (cdr var-spec)))
+ (format "%S=%s"
+ (car var-spec) (cadr var-spec))))
+ ',variables ", ")
+ ")")))))
+ (org-babel-execute-src-block
+ nil (list "emacs-lisp" "results" params)
+ '((:results . "silent"))))
+ "")))
+ (org-babel-trim (if (stringp result) result (format "%S" result)))))))
(provide 'ob-table)
=== modified file 'lisp/org/ob-tangle.el'
--- a/lisp/org/ob-tangle.el 2013-11-12 13:06:26 +0000
+++ b/lisp/org/ob-tangle.el 2013-11-12 19:11:22 +0000
@@ -210,8 +210,8 @@
(lambda (spec)
(let ((get-spec (lambda (name) (cdr (assoc name (nth 4
spec))))))
(let* ((tangle (funcall get-spec :tangle))
- (she-bang ((lambda (sheb) (when (> (length sheb) 0)
sheb))
- (funcall get-spec :shebang)))
+ (she-bang (let ((sheb (funcall get-spec :shebang)))
+ (when (> (length sheb) 0) sheb)))
(tangle-mode (funcall get-spec :tangle-mode))
(base-name (cond
((string= "yes" tangle)
@@ -224,9 +224,9 @@
(if (and ext (string= "yes" tangle))
(concat base-name "." ext)
base-name))))
(when file-name
- ;; possibly create the parent directories for file
- (when ((lambda (m) (and m (not (string= m "no"))))
- (funcall get-spec :mkdirp))
+ ;; Possibly create the parent directories for file.
+ (when (let ((m (funcall get-spec :mkdirp)))
+ (and m (not (string= m "no"))))
(make-directory (file-name-directory file-name)
'parents))
;; delete any old versions of file
(when (and (file-exists-p file-name)
@@ -314,9 +314,8 @@
(string= comments "yes") (string= comments "noweb")))
(link-data (mapcar (lambda (el)
(cons (symbol-name el)
- ((lambda (le)
- (if (stringp le) le (format "%S" le)))
- (eval el))))
+ (let ((le (eval el)))
+ (if (stringp le) le (format "%S" le)))))
'(start-line file link source-name)))
(insert-comment (lambda (text)
(when (and comments (not (string= comments "no"))
@@ -402,11 +401,10 @@
(cref-fmt (or (and (string-match "-l \"\\(.+\\)\"" extra)
(match-string 1 extra))
org-coderef-label-format))
- (link ((lambda (link)
- (and (string-match org-bracket-link-regexp link)
- (match-string 1 link)))
- (org-no-properties
- (org-store-link nil))))
+ (link (let ((link (org-no-properties
+ (org-store-link nil))))
+ (and (string-match org-bracket-link-regexp link)
+ (match-string 1 link))))
(source-name
(intern (or (nth 4 info)
(format "%s:%d"
@@ -418,28 +416,29 @@
(assignments-cmd
(intern (concat "org-babel-variable-assignments:" src-lang)))
(body
- ((lambda (body) ;; Run the tangle-body-hook
- (with-temp-buffer
- (insert body)
- (when (string-match "-r" extra)
- (goto-char (point-min))
- (while (re-search-forward
- (replace-regexp-in-string "%s" ".+" cref-fmt) nil t)
- (replace-match "")))
- (run-hooks 'org-babel-tangle-body-hook)
- (buffer-string)))
- ((lambda (body) ;; Expand the body in language specific manner
- (if (assoc :no-expand params)
- body
- (if (fboundp expand-cmd)
- (funcall expand-cmd body params)
- (org-babel-expand-body:generic
- body params
- (and (fboundp assignments-cmd)
- (funcall assignments-cmd params))))))
- (if (org-babel-noweb-p params :tangle)
- (org-babel-expand-noweb-references info)
- (nth 1 info)))))
+ ;; Run the tangle-body-hook.
+ (let* ((body ;; Expand the body in language specific manner.
+ (if (org-babel-noweb-p params :tangle)
+ (org-babel-expand-noweb-references info)
+ (nth 1 info)))
+ (body
+ (if (assoc :no-expand params)
+ body
+ (if (fboundp expand-cmd)
+ (funcall expand-cmd body params)
+ (org-babel-expand-body:generic
+ body params
+ (and (fboundp assignments-cmd)
+ (funcall assignments-cmd params)))))))
+ (with-temp-buffer
+ (insert body)
+ (when (string-match "-r" extra)
+ (goto-char (point-min))
+ (while (re-search-forward
+ (replace-regexp-in-string "%s" ".+" cref-fmt) nil t)
+ (replace-match "")))
+ (run-hooks 'org-babel-tangle-body-hook)
+ (buffer-string))))
(comment
(when (or (string= "both" (cdr (assoc :comments params)))
(string= "org" (cdr (assoc :comments params))))
@@ -474,9 +473,8 @@
(source-name (nth 4 (or info (org-babel-get-src-block-info 'light))))
(link-data (mapcar (lambda (el)
(cons (symbol-name el)
- ((lambda (le)
- (if (stringp le) le (format "%S" le)))
- (eval el))))
+ (let ((le (eval el)))
+ (if (stringp le) le (format "%S" le)))))
'(start-line file link source-name))))
(list (org-fill-template org-babel-tangle-comment-format-beg link-data)
(org-fill-template org-babel-tangle-comment-format-end link-data))))
=== modified file 'lisp/org/org-agenda.el'
--- a/lisp/org/org-agenda.el 2013-11-12 13:06:26 +0000
+++ b/lisp/org/org-agenda.el 2013-11-12 19:11:22 +0000
@@ -2840,6 +2840,8 @@
((equal org-keys "!") (customize-variable 'org-stuck-projects))
(t (user-error "Invalid agenda key"))))))
+(defvar org-agenda-multi)
+
(defun org-agenda-append-agenda ()
"Append another agenda view to the current one.
This function allows interactive building of block agendas.
@@ -3814,6 +3816,8 @@
'org-priority))
(overlay-put ov 'org-type 'org-priority)))))
+(defvar org-depend-tag-blocked)
+
(defun org-agenda-dim-blocked-tasks (&optional invisible)
"Dim currently blocked TODO's in the agenda display.
When INVISIBLE is non-nil, hide currently blocked TODO instead of
@@ -3982,6 +3986,7 @@
;;; Agenda timeline
(defvar org-agenda-only-exact-dates nil) ; dynamically scoped
+(defvar org-agenda-show-log-scoped) ;; dynamically scope in `org-timeline' or
`org-agenda-list'
(defun org-timeline (&optional dotodo)
"Show a time-sorted view of the entries in the current org file.
@@ -5762,7 +5767,6 @@
dayname skip-weeks)))
(make-obsolete 'org-diary-class 'org-class "")
-(defvar org-agenda-show-log-scoped) ;; dynamically scope in `org-timeline' or
`org-agenda-list'
(defalias 'org-get-closed 'org-agenda-get-progress)
(defun org-agenda-get-progress ()
"Return the logged TODO entries for agenda display."
=== modified file 'lisp/org/org-bibtex.el'
--- a/lisp/org/org-bibtex.el 2013-11-12 13:06:26 +0000
+++ b/lisp/org/org-bibtex.el 2013-11-12 19:11:22 +0000
@@ -293,12 +293,13 @@
;;; Utility functions
(defun org-bibtex-get (property)
- ((lambda (it) (when it (org-babel-trim it)))
- (let ((org-special-properties
- (delete "FILE" (copy-sequence org-special-properties))))
- (or
- (org-entry-get (point) (upcase property))
- (org-entry-get (point) (concat org-bibtex-prefix (upcase property)))))))
+ (let ((it (let ((org-special-properties
+ (delete "FILE" (copy-sequence org-special-properties))))
+ (or
+ (org-entry-get (point) (upcase property))
+ (org-entry-get (point) (concat org-bibtex-prefix
+ (upcase property)))))))
+ (when it (org-babel-trim it))))
(defun org-bibtex-put (property value)
(let ((prop (upcase (if (keywordp property)
@@ -384,8 +385,8 @@
(princ (cdr (assoc field org-bibtex-fields))))
(with-current-buffer buf-name (visual-line-mode 1))
(org-fit-window-to-buffer (get-buffer-window buf-name))
- ((lambda (result) (when (> (length result) 0) result))
- (read-from-minibuffer (format "%s: " name))))))
+ (let ((result (read-from-minibuffer (format "%s: " name))))
+ (when (> (length result) 0) result)))))
(defun org-bibtex-autokey ()
"Generate an autokey for the current headline."
@@ -539,20 +540,21 @@
"Bibtex file: " nil nil nil
(file-name-nondirectory
(concat (file-name-sans-extension (buffer-file-name)) ".bib")))))
- ((lambda (error-point)
- (when error-point
- (goto-char error-point)
- (message "Bibtex error at %S" (nth 4 (org-heading-components)))))
- (catch 'bib
- (let ((bibtex-entries (remove nil (org-map-entries
- (lambda ()
- (condition-case foo
- (org-bibtex-headline)
- (error (throw 'bib (point)))))))))
- (with-temp-file filename
- (insert (mapconcat #'identity bibtex-entries "\n")))
- (message "Successfully exported %d BibTeX entries to %s"
- (length bibtex-entries) filename) nil))))
+ (let ((error-point
+ (catch 'bib
+ (let ((bibtex-entries
+ (remove nil (org-map-entries
+ (lambda ()
+ (condition-case foo
+ (org-bibtex-headline)
+ (error (throw 'bib (point)))))))))
+ (with-temp-file filename
+ (insert (mapconcat #'identity bibtex-entries "\n")))
+ (message "Successfully exported %d BibTeX entries to %s"
+ (length bibtex-entries) filename) nil))))
+ (when error-point
+ (goto-char error-point)
+ (message "Bibtex error at %S" (nth 4 (org-heading-components))))))
(defun org-bibtex-check (&optional optional)
"Check the current headline for required fields.
@@ -560,8 +562,8 @@
(interactive "P")
(save-restriction
(org-narrow-to-subtree)
- (let ((type ((lambda (name) (when name (intern (concat ":" name))))
- (org-bibtex-get org-bibtex-type-property-name))))
+ (let ((type (let ((name (org-bibtex-get org-bibtex-type-property-name)))
+ (when name (intern (concat ":" name))))))
(when type (org-bibtex-fleshout type optional)))))
(defun org-bibtex-check-all (&optional optional)
=== modified file 'lisp/org/org-clock.el'
--- a/lisp/org/org-clock.el 2013-11-12 13:06:26 +0000
+++ b/lisp/org/org-clock.el 2013-11-12 19:11:22 +0000
@@ -1114,6 +1114,7 @@
(defvar org-clock-current-task nil "Task currently clocked in.")
(defvar org-clock-out-time nil) ; store the time of the last clock-out
+(defvar org--msg-extra)
;;;###autoload
(defun org-clock-in (&optional select start-time)
@@ -1133,7 +1134,7 @@
(catch 'abort
(let ((interrupting (and (not org-clock-resolving-clocks-due-to-idleness)
(org-clocking-p)))
- ts selected-task target-pos (msg-extra "")
+ ts selected-task target-pos (org--msg-extra "")
(leftover (and (not org-clock-resolving-clocks)
org-clock-leftover-time)))
@@ -1305,7 +1306,7 @@
(setq org-clock-idle-timer nil))
(setq org-clock-idle-timer
(run-with-timer 60 60 'org-resolve-clocks-if-idle))
- (message "Clock starts at %s - %s" ts msg-extra)
+ (message "Clock starts at %s - %s" ts org--msg-extra)
(run-hooks 'org-clock-in-hook)))))))
;;;###autoload
@@ -1351,7 +1352,6 @@
(org-back-to-heading t)
(move-marker org-clock-default-task (point))))
-(defvar msg-extra)
(defun org-clock-get-sum-start ()
"Return the time from which clock times should be counted.
This is for the currently running clock as it is displayed
@@ -1364,10 +1364,10 @@
(lr (org-entry-get nil "LAST_REPEAT")))
(cond
((equal cmt "current")
- (setq msg-extra "showing time in current clock instance")
+ (setq org--msg-extra "showing time in current clock instance")
(current-time))
((equal cmt "today")
- (setq msg-extra "showing today's task time.")
+ (setq org--msg-extra "showing today's task time.")
(let* ((dt (decode-time (current-time))))
(setq dt (append (list 0 0 0) (nthcdr 3 dt)))
(if org-extend-today-until
@@ -1376,12 +1376,12 @@
((or (equal cmt "all")
(and (or (not cmt) (equal cmt "auto"))
(not lr)))
- (setq msg-extra "showing entire task time.")
+ (setq org--msg-extra "showing entire task time.")
nil)
((or (equal cmt "repeat")
(and (or (not cmt) (equal cmt "auto"))
lr))
- (setq msg-extra "showing task time since last repeat.")
+ (setq org--msg-extra "showing task time since last repeat.")
(if (not lr)
nil
(org-time-string-to-time lr)))
=== modified file 'lisp/org/org-colview.el'
--- a/lisp/org/org-colview.el 2013-11-12 13:06:26 +0000
+++ b/lisp/org/org-colview.el 2013-11-12 19:11:22 +0000
@@ -416,6 +416,10 @@
(org-columns-next-allowed-value)
(org-columns-edit-value "TAGS")))
+(defvar org-agenda-overriding-columns-format nil
+ "When set, overrides any other format definition for the agenda.
+Don't set this, this is meant for dynamic scoping.")
+
(defun org-columns-edit-value (&optional key)
"Edit the value of the property at point in column view.
Where possible, use the standard interface for changing this line."
@@ -901,10 +905,6 @@
(insert-before-markers "#+COLUMNS: " fmt "\n")))
(org-set-local 'org-columns-default-format fmt))))))
-(defvar org-agenda-overriding-columns-format nil
- "When set, overrides any other format definition for the agenda.
-Don't set this, this is meant for dynamic scoping.")
-
(defun org-columns-get-autowidth-alist (s cache)
"Derive the maximum column widths from the format and the cache."
(let ((start 0) rtn)
=== modified file 'lisp/org/org-src.el'
--- a/lisp/org/org-src.el 2013-11-12 13:06:26 +0000
+++ b/lisp/org/org-src.el 2013-11-12 19:11:22 +0000
@@ -844,8 +844,9 @@
(let ((session (cdr (assoc :session (nth 2 info)))))
(and session (not (string= session "none"))
(org-babel-comint-buffer-livep session)
- ((lambda (f) (and (fboundp f) (funcall f session)))
- (intern (format "org-babel-%s-associate-session" (nth 0 info)))))))
+ (let ((f (intern (format "org-babel-%s-associate-session"
+ (nth 0 info)))))
+ (and (fboundp f) (funcall f session))))))
(defun org-src-babel-configure-edit-buffer ()
(when org-src-babel-info
@@ -953,8 +954,9 @@
LANG is a string, and the returned major mode is a symbol."
(intern
(concat
- ((lambda (l) (if (symbolp l) (symbol-name l) l))
- (or (cdr (assoc lang org-src-lang-modes)) lang)) "-mode")))
+ (let ((l (or (cdr (assoc lang org-src-lang-modes)) lang)))
+ (if (symbolp l) (symbol-name l) l))
+ "-mode")))
(provide 'org-src)
=== modified file 'lisp/org/org.el'
--- a/lisp/org/org.el 2013-11-12 13:06:26 +0000
+++ b/lisp/org/org.el 2013-11-12 19:11:22 +0000
@@ -82,7 +82,7 @@
(require 'org-macs)
(require 'org-compat)
-;; `org-outline-regexp' ought to be a defconst but is let-binding in
+;; `org-outline-regexp' ought to be a defconst but is let-bound in
;; some places -- e.g. see the macro `org-with-limited-levels'.
;;
;; In Org buffers, the value of `outline-regexp' is that of
@@ -304,13 +304,13 @@
org-install-dir
(concat "mixed installation! " org-install-dir
" and " org-dir))
"org-loaddefs.el can not be found!")))
- (_version (if full version org-version)))
+ (version1 (if full version org-version)))
(if (org-called-interactively-p 'interactive)
(if here
(insert version)
(message version))
(if message (message _version))
- _version)))
+ version1)))
(defconst org-version (org-version))
@@ -4804,6 +4804,8 @@
:group 'org-startup
:type 'boolean)
+(defvar org-inhibit-startup nil) ; Dynamically-scoped param.
+
(defun org-toggle-tags-groups ()
"Toggle support for group tags.
Support for group tags is controlled by the option
@@ -5264,7 +5266,6 @@
"Every change indicates that a table might need an update."
(setq org-table-may-need-update t))
(defvar org-mode-map)
-(defvar org-inhibit-startup nil) ; Dynamically-scoped param.
(defvar org-inhibit-startup-visibility-stuff nil) ; Dynamically-scoped param.
(defvar org-agenda-keep-modes nil) ; Dynamically-scoped param.
(defvar org-inhibit-logging nil) ; Dynamically-scoped param.
@@ -6714,6 +6715,8 @@
(setq org-cycle-global-status 'overview)
(run-hook-with-args 'org-cycle-hook 'overview)))))
+(defvar org-called-with-limited-levels);Dyn-bound in ̀org-with-limited-levels'.
+
(defun org-cycle-internal-local ()
"Do the local cycling action."
(let ((goal-column 0) eoh eol eos has-children children-skipped struct)
@@ -7944,8 +7947,6 @@
(define-obsolete-function-alias 'org-get-legal-level
'org-get-valid-level "23.1")))
-(defvar org-called-with-limited-levels nil) ;; Dynamically bound in
-;; ̀org-with-limited-levels'
(defun org-promote ()
"Promote the current heading higher up the tree.
If the region is active in `transient-mark-mode', promote all headings
@@ -10321,6 +10322,7 @@
a link at point. If they don't find anything interesting at point,
they must return nil.")
+(defvar org-link-search-inhibit-query nil) ;; dynamically scoped
(defvar clean-buffer-list-kill-buffer-names) ; Defined in midnight.el
(defun org-open-at-point (&optional arg reference-buffer)
"Open link at or after point.
@@ -10696,7 +10698,6 @@
(set-window-configuration org-window-config-before-follow-link)")
-(defvar org-link-search-inhibit-query nil) ;; dynamically scoped
(defun org-link-search (s &optional type avoid-pos stealth)
"Search for a link search option.
If S is surrounded by forward slashes, it is interpreted as a
@@ -13104,6 +13105,9 @@
(delete-region (point-at-bol)
(min (point-max) (1+ (point-at-eol))))))))))
+(defvar org-time-was-given) ; dynamically scoped parameter
+(defvar org-end-time-was-given) ; dynamically scoped parameter
+
(defun org-add-planning-info (what &optional time &rest remove)
"Insert new timestamp with keyword in the line directly after the headline.
WHAT indicates what kind of time stamp to add. TIME indicates the time to use.
@@ -16035,8 +16039,6 @@
(defvar org-last-changed-timestamp nil)
(defvar org-last-inserted-timestamp nil
"The last time stamp inserted with `org-insert-time-stamp'.")
-(defvar org-time-was-given) ; dynamically scoped parameter
-(defvar org-end-time-was-given) ; dynamically scoped parameter
(defvar org-ts-what) ; dynamically scoped parameter
(defun org-time-stamp (arg &optional inactive)
@@ -16225,6 +16227,10 @@
map)
"Keymap for minibuffer commands when using `org-read-date'.")
+(defvar org-def)
+(defvar org-defdecode)
+(defvar org-with-time)
+
(defun org-read-date (&optional org-with-time to-time from-string prompt
default-time default-input inactive)
"Read a date, possibly a time, and make things smooth for the user.
@@ -16371,9 +16377,6 @@
(nth 2 final) (nth 1 final))
(format "%04d-%02d-%02d" (nth 5 final) (nth 4 final) (nth 3 final))))))
-(defvar org-def)
-(defvar org-defdecode)
-(defvar org-with-time)
(defun org-read-date-display ()
"Display the current date prompt interpretation in the minibuffer."
(when org-read-date-display-live
=== modified file 'lisp/org/ox-odt.el'
--- a/lisp/org/ox-odt.el 2013-11-12 13:06:26 +0000
+++ b/lisp/org/ox-odt.el 2013-11-12 19:11:22 +0000
@@ -3113,12 +3113,11 @@
`font-lock-function-name-face' is associated with
\"OrgSrcFontLockFunctionNameFace\"."
(let* ((css-list (hfy-face-to-style fn))
- (style-name ((lambda (fn)
- (concat "OrgSrc"
- (mapconcat
- 'capitalize (split-string
- (hfy-face-or-def-to-name fn) "-")
- ""))) fn))
+ (style-name (concat "OrgSrc"
+ (mapconcat
+ 'capitalize (split-string
+ (hfy-face-or-def-to-name fn) "-")
+ "")))
(color-val (cdr (assoc "color" css-list)))
(background-color-val (cdr (assoc "background" css-list)))
(style (and org-odt-create-custom-styles-for-srcblocks
[Prev in Thread] |
Current Thread |
[Next in Thread] |
- [Emacs-diffs] trunk r115082: Address some byte-compiler warnings.,
Stefan Monnier <=