mirror/org-mode
1
0
Fork 0
mirror of https://git.savannah.gnu.org/git/emacs/org-mode.git synced 2025-02-08 21:38:10 +00:00
Code

Eliminating duplicated code (take 2...).

Browse Source 
This proposal for code tidying uses multiple-value-bind to satisfy:

1. The various parsed/resolved components of the param list (session,
   vars, result-type) are available in the org-babel-execute:LANG
   functions.
2. Those functions don't duplicate the code for parsing the params
   list and resolving references
3. The functions still have the params list available to them, should
   they need to implement language-specific behaviour using it.

If the org-babel-execute:LANG functions need to be called directly,
then that would now have to be via
(multiple-value-bind (session vars result-params result-type)
      (org-babel-process-params params) (funcall cmd body params))

as in org-babel-exp.el. (But is it actually necessary to by-pass
org-babel-execute-src-block?)
This commit is contained in:
Dan Davison 2009-07-16 16:21:07 -04:00
parent f74b084d99
commit d128662fa3
7 changed files with 57 additions and 58 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

19
lisp/langs/org-babel-R.el
View File

@ -37,20 +37,15 @@
(defun org-babel-execute:R (body params)
"Execute a block of R code with org-babel. This function is
called by `org-babel-execute-src-block'."
called by `org-babel-execute-src-block' via multiple-value-bind."
(message "executing R source code block...")
(save-window-excursion
(let* ((vars (org-babel-ref-variables params))
(full-body (concat
(mapconcat ;; define any variables
(lambda (pair)
(org-babel-R-assign-elisp (car pair) (cdr pair)))
vars "\n") "\n" body "\n"))
(result-params (split-string (or (cdr (assoc :results params)) "")))
(result-type (cond ((member "output" result-params) 'output)
((member "value" result-params) 'value)
(t 'value)))
(session (org-babel-R-initiate-session (cdr (assoc :session params)))))
(let ((full-body (concat
(mapconcat ;; define any variables
(lambda (pair)
(org-babel-R-assign-elisp (car pair) (cdr pair)))
vars "\n") "\n" body "\n"))
(session (org-babel-R-initiate-session session)))
(org-babel-R-evaluate session full-body result-type))))
(defun org-babel-prep-session:R (session params)

5
lisp/langs/org-babel-lisp.el
View File

@ -37,11 +37,10 @@
(defun org-babel-execute:emacs-lisp (body params)
"Execute a block of emacs-lisp code with org-babel. This
function is called by `org-babel-execute-src-block'."
function is called by `org-babel-execute-src-block' via multiple-value-bind."
(message "executing emacs-lisp code block...")
(save-window-excursion
(let ((vars (org-babel-ref-variables params))
(print-level nil) (print-length nil) results)
(let ((print-level nil) (print-length nil) results)
(setq results
(eval `(let ,(mapcar (lambda (var) `(,(car var) ',(cdr var))) vars)
,(read (concat "(progn " body ")")))))

23
lisp/langs/org-babel-python.el
View File

@ -38,21 +38,16 @@
(defun org-babel-execute:python (body params)
"Execute a block of Python code with org-babel. This function is
called by `org-babel-execute-src-block'."
called by `org-babel-execute-src-block' via multiple-value-bind."
(message "executing Python source code block")
(let* ((vars (org-babel-ref-variables params))
(result-params (split-string (or (cdr (assoc :results params)) "")))
(result-type (cond ((member "output" result-params) 'output)
((member "value" result-params) 'value)
(t 'value)))
(full-body (concat
(mapconcat ;; define any variables
(lambda (pair)
(format "%s=%s"
(car pair)
(org-babel-python-var-to-python (cdr pair))))
vars "\n") "\n" (org-babel-trim body) "\n")) ;; then the source block body
(session (org-babel-python-initiate-session (cdr (assoc :session params)))))
(let ((full-body (concat
(mapconcat ;; define any variables
(lambda (pair)
(format "%s=%s"
(car pair)
(org-babel-python-var-to-python (cdr pair))))
vars "\n") "\n" (org-babel-trim body) "\n")) ;; then the source block body
(session (org-babel-python-initiate-session session)))
(org-babel-python-evaluate session full-body result-type)))
(defun org-babel-prep-session:python (session params)

23
lisp/langs/org-babel-ruby.el
View File

@ -38,21 +38,16 @@
(defun org-babel-execute:ruby (body params)
"Execute a block of Ruby code with org-babel. This function is
called by `org-babel-execute-src-block'."
called by `org-babel-execute-src-block' via multiple-value-bind."
(message "executing Ruby source code block")
(let* ((vars (org-babel-ref-variables params))
(result-params (split-string (or (cdr (assoc :results params)) "")))
(result-type (cond ((member "output" result-params) 'output)
((member "value" result-params) 'value)
(t 'value)))
(full-body (concat
(mapconcat ;; define any variables
(lambda (pair)
(format "%s=%s"
(car pair)
(org-babel-ruby-var-to-ruby (cdr pair))))
vars "\n") "\n" body "\n")) ;; then the source block body
(session (org-babel-ruby-initiate-session (cdr (assoc :session params)))))
(let ((full-body (concat
(mapconcat ;; define any variables
(lambda (pair)
(format "%s=%s"
(car pair)
(org-babel-ruby-var-to-ruby (cdr pair))))
vars "\n") "\n" body "\n")) ;; then the source block body
(session (org-babel-ruby-initiate-session session)))
(org-babel-ruby-evaluate session full-body result-type)))
(defun org-babel-prep-session:ruby (session params)

11
lisp/langs/org-babel-sh.el
View File

@ -38,21 +38,16 @@
(defun org-babel-execute:sh (body params)
"Execute a block of Shell commands with org-babel. This
function is called by `org-babel-execute-src-block'."
function is called by `org-babel-execute-src-block' via multiple-value-bind."
(message "executing Shell source code block")
(let* ((vars (org-babel-ref-variables params))
(result-params (split-string (or (cdr (assoc :results params)) "")))
(result-type (cond ((member "output" result-params) 'output)
((member "value" result-params) 'value)
(t 'value)))
(full-body (concat
(let* ((full-body (concat
(mapconcat ;; define any variables
(lambda (pair)
(format "%s=%s"
(car pair)
(org-babel-sh-var-to-sh (cdr pair))))
vars "\n") "\n" body "\n\n")) ;; then the source block body
(session (org-babel-sh-initiate-session (cdr (assoc :session params)))))
(session (org-babel-sh-initiate-session session)))
(org-babel-sh-evaluate session full-body result-type)))
(defun org-babel-prep-session:sh (session params)

6
lisp/org-babel-exp.el
View File

@ -84,8 +84,12 @@ options and are taken from `org-babel-defualt-inline-header-args'."
(if (string-match "\n$" body) "" "\n"))))
(defun org-babel-exp-results (body lang params &optional inline)
;; I expect there's a good reason why not, but would it be possible
;; to use org-babel-execute-src-block here? [ded]
(let* ((cmd (intern (concat "org-babel-execute:" lang)))
(result (funcall cmd body params))
(result
(multiple-value-bind (session vars result-params result-type)
(org-babel-process-params params) (funcall cmd body params)))
(result-as-org (org-babel-result-to-org-string result)))
(if inline
(format "=%s=" result)

28
lisp/org-babel.el
View File

@ -156,20 +156,22 @@ the header arguments specified at the source code block."
(body (second info))
(params (org-babel-merge-params
(third info) (org-babel-get-src-block-function-args) params))
(result-params (split-string (or (cdr (assoc :results params)) "")))
(result-type (cond ((member "output" result-params) 'output)
((member "value" result-params) 'value)
(t 'value)))
(processed-params (org-babel-process-params params))
(result-params (third processed-params))
(result-type (fourth processed-params))
(cmd (intern (concat "org-babel-execute:" lang)))
result)
;; (message (format "params=%S" params)) ;; debugging
(unless (member lang org-babel-interpreters)
(error "Language is not in `org-babel-interpreters': %s" lang))
(when arg (setq result-params (cons "silent" result-params)))
(setq result (org-babel-process-result (funcall cmd body params) result-type))
(setq result
(org-babel-process-result
(multiple-value-bind (session vars result-params result-type) processed-params
(funcall cmd body params)) result-type))
(org-babel-insert-result result result-params)
(case result-type (output nil) (value result))))
(defun org-babel-process-result (result result-type)
"This doesn't do anything currently.
@ -330,6 +332,20 @@ of the following form. (language body header-arguments-alist)"
(cons (intern (concat ":" arg)) nil)))
(split-string (concat " " arg-string) "[ \f\t\n\r\v]+:" t)))))
(defun org-babel-process-params (params)
"Parse params and resolve references.
Return a list (session vars result-params result-type). These are
made available to the org-babel-execute:LANG functions via
multiple-value-bind."
(let* ((session (cdr (assoc :session params)))
(vars (org-babel-ref-variables params))
(result-params (split-string (or (cdr (assoc :results params)) "")))
(result-type (cond ((member "output" result-params) 'output)
((member "value" result-params) 'value)
(t 'value))))
(list session vars result-params result-type)))
(defun org-babel-where-is-src-block-head ()
"Return the point at the beginning of the current source
block. Specifically at the beginning of the #+BEGIN_SRC line.