Re: Invalid read syntax "#"?

[Nick Dokos <nicholas.dokos@hp.com>]

Alan Schmitt <alan.schmitt@polytechnique.org> wrote:

> Hello,
> 
> I'm trying this example to export nicely formatted code in LaTeX:
> http://orgmode.org/worg/org-tutorials/org-latex-export.html#sec-12-3
> 
> Unfortunately it fails with an error 'Invalid read syntax "#"'. If I
> delete the second code block (the python one), it works.
> 
> Is there something wrong in the example or in my setup (org-mode from
> yesterday's git, Aquamacs 3 from two days ago, Pygments easy-installed
> today)?
> 

I got the same thing, so it's probably not a setup problem. Here's
a backtrace - looks like a babel problem.

Nick

Org-mode version 7.8.03 (release_7.8.03.241.g043d)
GNU Emacs 24.0.92.1 (x86_64-unknown-linux-gnu, GTK+ Version 2.24.4) of 2012-01-24

Debugger entered--Lisp error: (invalid-read-syntax "#")
  read("(progn #+end_src\n#+name: another-listing\n#+begin_src python :exports code\n)")
  (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))))
  ((lambda (result) (if (or (member "scalar" (cdr (assoc :result-params params))) (member "verbatim" (cdr (assoc :result-params params)))) (let ((print-level nil) (print-length nil)) (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)))))
  (progn ((lambda (result) (if (or (member "scalar" (cdr (assoc :result-params params))) (member "verbatim" (cdr (assoc :result-params params)))) (let ((print-level nil) (print-length nil)) (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 ...)) "(with-output-to-string %s)" "(progn %s)") (org-babel-expand-body:emacs-lisp body params))))))
  (unwind-protect (progn ((lambda (result) (if (or (member "scalar" (cdr ...)) (member "verbatim" (cdr ...))) (let ((print-level nil) (print-length nil)) (format "%S" result)) (org-babel-reassemble-table result (org-babel-pick-name (cdr ...) (cdr ...)) (org-babel-pick-name (cdr ...) (cdr ...))))) (eval (read (format (if (member "output" ...) "(with-output-to-string %s)" "(progn %s)") (org-babel-expand-body:emacs-lisp body params)))))) (set-window-configuration wconfig))
  (let ((wconfig (current-window-configuration))) (unwind-protect (progn ((lambda (result) (if (or (member "scalar" ...) (member "verbatim" ...)) (let (... ...) (format "%S" result)) (org-babel-reassemble-table result (org-babel-pick-name ... ...) (org-babel-pick-name ... ...)))) (eval (read (format (if ... "(with-output-to-string %s)" "(progn %s)") (org-babel-expand-body:emacs-lisp body params)))))) (set-window-configuration wconfig)))
  (save-window-excursion ((lambda (result) (if (or (member "scalar" (cdr (assoc :result-params params))) (member "verbatim" (cdr (assoc :result-params params)))) (let ((print-level nil) (print-length nil)) (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 ...)) "(with-output-to-string %s)" "(progn %s)") (org-babel-expand-body:emacs-lisp body params))))))
  org-babel-execute:emacs-lisp("#+end_src\n#+name: another-listing\n#+begin_src python :exports code" ((:comments . "") (:shebang . "") (:cache . "no") (:padline . "") (:noweb . "no") (:tangle . "no") (:exports . "both") (:results . "replace") (:colname-names) (:colnames . "no") (:hlines . "yes") (:padnewline . "yes") (:result-params "silent") (:result-type . value) (:rowname-names) (:session . "none")))
  funcall(org-babel-execute:emacs-lisp "#+end_src\n#+name: another-listing\n#+begin_src python :exports code" ((:comments . "") (:shebang . "") (:cache . "no") (:padline . "") (:noweb . "no") (:tangle . "no") (:exports . "both") (:results . "replace") (:colname-names) (:colnames . "no") (:hlines . "yes") (:padnewline . "yes") (:result-params "silent") (:result-type . value) (:rowname-names) (:session . "none")))
  ((lambda (result) (if (and (eq (cdr (assoc :result-type params)) (quote value)) (or (member "vector" result-params) (member "table" result-params)) (not (listp result))) (list (list result)) result)) (funcall cmd body params))
  (setq result ((lambda (result) (if (and (eq (cdr (assoc :result-type params)) (quote value)) (or (member "vector" result-params) (member "table" result-params)) (not (listp result))) (list (list result)) result)) (funcall cmd body params)))
  (if (and (not arg) new-hash (equal new-hash old-hash)) (save-excursion (goto-char (org-babel-where-is-src-block-result nil info)) (end-of-line 1) (forward-char 1) (setq result (org-babel-read-result)) (message (replace-regexp-in-string "%" "%%" (format "%S" result))) result) (message "executing %s code block%s..." (capitalize lang) (if (nth 4 info) (format " (%s)" (nth 4 info)) "")) (setq result ((lambda (result) (if (and (eq (cdr ...) (quote value)) (or (member "vector" result-params) (member "table" result-params)) (not (listp result))) (list (list result)) result)) (funcall cmd body params))) (when (cdr (assoc :file params)) (when result (with-temp-file (cdr (assoc :file params)) (insert (org-babel-format-result result (cdr (assoc :sep ...)))))) (setq result (cdr (assoc :file params))
 )) (org-babel-insert-result result result-params info new-hash indent lang) (run-hooks (quote org-babel-after-execute-hook)) result)
  (progn (fset (quote call-process-region) (function* (lambda (&rest args) (block call-process-region (apply (quote org-babel-tramp-handle-call-process-region) args))))) (flet ((lang-check (f) (let ((f (intern ...))) (when (fboundp f) f)))) (setq cmd (or (lang-check lang) (lang-check (symbol-name (cdr (assoc lang org-src-lang-modes)))) (error "No org-babel-execute function for %s!" lang)))) (if (and (not arg) new-hash (equal new-hash old-hash)) (save-excursion (goto-char (org-babel-where-is-src-block-result nil info)) (end-of-line 1) (forward-char 1) (setq result (org-babel-read-result)) (message (replace-regexp-in-string "%" "%%" (format "%S" result))) result) (message "executing %s code block%s..." (capitalize lang) (if (nth 4 info) (format " (%s)" (nth 4 info)) "")) (setq result ((lambd
 a (result) (if (and (eq ... ...) (or ... ...) (not ...)) (list (list result)) result)) (funcall cmd body params))) (when (cdr (assoc :file params)) (when result (with-temp-file (cdr (assoc :
 file params)) (insert (org-babel-format-result result (cdr ...))))) (setq result (cdr (assoc :file params)))) (org-babel-insert-result result result-params info new-hash indent lang) (run-hooks (quote org-babel-after-execute-hook)) result))
  (unwind-protect (progn (fset (quote call-process-region) (function* (lambda (&rest args) (block call-process-region (apply (quote org-babel-tramp-handle-call-process-region) args))))) (flet ((lang-check (f) (let ((f ...)) (when (fboundp f) f)))) (setq cmd (or (lang-check lang) (lang-check (symbol-name (cdr ...))) (error "No org-babel-execute function for %s!" lang)))) (if (and (not arg) new-hash (equal new-hash old-hash)) (save-excursion (goto-char (org-babel-where-is-src-block-result nil info)) (end-of-line 1) (forward-char 1) (setq result (org-babel-read-result)) (message (replace-regexp-in-string "%" "%%" (format "%S" result))) result) (message "executing %s code block%s..." (capitalize lang) (if (nth 4 info) (format " (%s)" (nth 4 info)) "")) (setq result ((lambda (result) (if (and .
 .. ... ...) (list ...) result)) (funcall cmd body params))) (when (cdr (assoc :file params)) (when result (with-temp-file (cdr (assoc :file params)) (insert (org-babel-format-result result .
 ..)))) (setq result (cdr (assoc :file params)))) (org-babel-insert-result result result-params info new-hash indent lang) (run-hooks (quote org-babel-after-execute-hook)) result)) (if --cl-letf-bound-- (fset (quote call-process-region) --cl-letf-save--) (fmakunbound (quote call-process-region))))
  (let* ((--cl-letf-bound-- (fboundp (quote call-process-region))) (--cl-letf-save-- (and --cl-letf-bound-- (symbol-function (quote call-process-region))))) (unwind-protect (progn (fset (quote call-process-region) (function* (lambda (&rest args) (block call-process-region (apply ... args))))) (flet ((lang-check (f) (let (...) (when ... f)))) (setq cmd (or (lang-check lang) (lang-check (symbol-name ...)) (error "No org-babel-execute function for %s!" lang)))) (if (and (not arg) new-hash (equal new-hash old-hash)) (save-excursion (goto-char (org-babel-where-is-src-block-result nil info)) (end-of-line 1) (forward-char 1) (setq result (org-babel-read-result)) (message (replace-regexp-in-string "%" "%%" (format "%S" result))) result) (message "executing %s code block%s..." (capitalize lang) (if
  (nth 4 info) (format " (%s)" (nth 4 info)) "")) (setq result ((lambda (result) (if ... ... result)) (funcall cmd body params))) (when (cdr (assoc :file params)) (when result (with-temp-file
  (cdr ...) (insert ...))) (setq result (cdr (assoc :file params)))) (org-babel-insert-result result result-params info new-hash indent lang) (run-hooks (quote org-babel-after-execute-hook)) result)) (if --cl-letf-bound-- (fset (quote call-process-region) --cl-letf-save--) (fmakunbound (quote call-process-region)))))
  (letf (((symbol-function (quote call-process-region)) (function* (lambda (&rest args) (block call-process-region (apply (quote org-babel-tramp-handle-call-process-region) args)))))) (flet ((lang-check (f) (let ((f (intern ...))) (when (fboundp f) f)))) (setq cmd (or (lang-check lang) (lang-check (symbol-name (cdr (assoc lang org-src-lang-modes)))) (error "No org-babel-execute function for %s!" lang)))) (if (and (not arg) new-hash (equal new-hash old-hash)) (save-excursion (goto-char (org-babel-where-is-src-block-result nil info)) (end-of-line 1) (forward-char 1) (setq result (org-babel-read-result)) (message (replace-regexp-in-string "%" "%%" (format "%S" result))) result) (message "executing %s code block%s..." (capitalize lang) (if (nth 4 info) (format " (%s)" (nth 4 info)) "")) (setq 
 result ((lambda (result) (if (and (eq ... ...) (or ... ...) (not ...)) (list (list result)) result)) (funcall cmd body params))) (when (cdr (assoc :file params)) (when result (with-temp-file
  (cdr (assoc :file params)) (insert (org-babel-format-result result (cdr ...))))) (setq result (cdr (assoc :file params)))) (org-babel-insert-result result result-params info new-hash indent lang) (run-hooks (quote org-babel-after-execute-hook)) result))
  (letf* (((symbol-function (quote call-process-region)) (function* (lambda (&rest args) (block call-process-region (apply (quote org-babel-tramp-handle-call-process-region) args)))))) (flet ((lang-check (f) (let ((f (intern ...))) (when (fboundp f) f)))) (setq cmd (or (lang-check lang) (lang-check (symbol-name (cdr (assoc lang org-src-lang-modes)))) (error "No org-babel-execute function for %s!" lang)))) (if (and (not arg) new-hash (equal new-hash old-hash)) (save-excursion (goto-char (org-babel-where-is-src-block-result nil info)) (end-of-line 1) (forward-char 1) (setq result (org-babel-read-result)) (message (replace-regexp-in-string "%" "%%" (format "%S" result))) result) (message "executing %s code block%s..." (capitalize lang) (if (nth 4 info) (format " (%s)" (nth 4 info)) "")) (setq
  result ((lambda (result) (if (and (eq ... ...) (or ... ...) (not ...)) (list (list result)) result)) (funcall cmd body params))) (when (cdr (assoc :file params)) (when result (with-temp-fil
 e (cdr (assoc :file params)) (insert (org-babel-format-result result (cdr ...))))) (setq result (cdr (assoc :file params)))) (org-babel-insert-result result result-params info new-hash indent lang) (run-hooks (quote org-babel-after-execute-hook)) result))
  (flet ((call-process-region (&rest args) (apply (quote org-babel-tramp-handle-call-process-region) args))) (flet ((lang-check (f) (let ((f (intern ...))) (when (fboundp f) f)))) (setq cmd (or (lang-check lang) (lang-check (symbol-name (cdr (assoc lang org-src-lang-modes)))) (error "No org-babel-execute function for %s!" lang)))) (if (and (not arg) new-hash (equal new-hash old-hash)) (save-excursion (goto-char (org-babel-where-is-src-block-result nil info)) (end-of-line 1) (forward-char 1) (setq result (org-babel-read-result)) (message (replace-regexp-in-string "%" "%%" (format "%S" result))) result) (message "executing %s code block%s..." (capitalize lang) (if (nth 4 info) (format " (%s)" (nth 4 info)) "")) (setq result ((lambda (result) (if (and (eq ... ...) (or ... ...) (not ...)) (lis
 t (list result)) result)) (funcall cmd body params))) (when (cdr (assoc :file params)) (when result (with-temp-file (cdr (assoc :file params)) (insert (org-babel-format-result result (cdr ..
 .))))) (setq result (cdr (assoc :file params)))) (org-babel-insert-result result result-params info new-hash indent lang) (run-hooks (quote org-babel-after-execute-hook)) result))
  (unwind-protect (flet ((call-process-region (&rest args) (apply (quote org-babel-tramp-handle-call-process-region) args))) (flet ((lang-check (f) (let ((f ...)) (when (fboundp f) f)))) (setq cmd (or (lang-check lang) (lang-check (symbol-name (cdr ...))) (error "No org-babel-execute function for %s!" lang)))) (if (and (not arg) new-hash (equal new-hash old-hash)) (save-excursion (goto-char (org-babel-where-is-src-block-result nil info)) (end-of-line 1) (forward-char 1) (setq result (org-babel-read-result)) (message (replace-regexp-in-string "%" "%%" (format "%S" result))) result) (message "executing %s code block%s..." (capitalize lang) (if (nth 4 info) (format " (%s)" (nth 4 info)) "")) (setq result ((lambda (result) (if (and ... ... ...) (list ...) result)) (funcall cmd body params))) (
 when (cdr (assoc :file params)) (when result (with-temp-file (cdr (assoc :file params)) (insert (org-babel-format-result result ...)))) (setq result (cdr (assoc :file params)))) (org-babel-i
 nsert-result result result-params info new-hash indent lang) (run-hooks (quote org-babel-after-execute-hook)) result)) (setq call-process-region (quote org-babel-call-process-region-original)))
  (let* ((lang (nth 0 info)) (params (if params (org-babel-process-params (org-babel-merge-params (nth 2 info) params)) (nth 2 info))) (cache\? (and (not arg) (cdr (assoc :cache params)) (string= "yes" (cdr (assoc :cache params))))) (result-params (cdr (assoc :result-params params))) (new-hash (when cache\? (org-babel-sha1-hash info))) (old-hash (when cache\? (org-babel-current-result-hash))) (body (setf (nth 1 info) (if (org-babel-noweb-p params :eval) (org-babel-expand-noweb-references info) (nth 1 info)))) (dir (cdr (assoc :dir params))) (default-directory (or (and dir (file-name-as-directory dir)) default-directory)) (org-babel-call-process-region-original (if (boundp (quote org-babel-call-process-region-original)) org-babel-call-process-region-original (symbol-function (quote call-pro
 cess-region)))) (indent (car (last info))) result cmd) (unwind-protect (flet ((call-process-region (&rest args) (apply (quote org-babel-tramp-handle-call-process-region) args))) (flet ((lang
 -check (f) (let (...) (when ... f)))) (setq cmd (or (lang-check lang) (lang-check (symbol-name ...)) (error "No org-babel-execute function for %s!" lang)))) (if (and (not arg) new-hash (equal new-hash old-hash)) (save-excursion (goto-char (org-babel-where-is-src-block-result nil info)) (end-of-line 1) (forward-char 1) (setq result (org-babel-read-result)) (message (replace-regexp-in-string "%" "%%" (format "%S" result))) result) (message "executing %s code block%s..." (capitalize lang) (if (nth 4 info) (format " (%s)" (nth 4 info)) "")) (setq result ((lambda (result) (if ... ... result)) (funcall cmd body params))) (when (cdr (assoc :file params)) (when result (with-temp-file (cdr ...) (insert ...))) (setq result (cdr (assoc :file params)))) (org-babel-insert-result result result-params i
 nfo new-hash indent lang) (run-hooks (quote org-babel-after-execute-hook)) result)) (setq call-process-region (quote org-babel-call-process-region-original))))
  (progn (let* ((lang (nth 0 info)) (params (if params (org-babel-process-params (org-babel-merge-params (nth 2 info) params)) (nth 2 info))) (cache\? (and (not arg) (cdr (assoc :cache params)) (string= "yes" (cdr (assoc :cache params))))) (result-params (cdr (assoc :result-params params))) (new-hash (when cache\? (org-babel-sha1-hash info))) (old-hash (when cache\? (org-babel-current-result-hash))) (body (setf (nth 1 info) (if (org-babel-noweb-p params :eval) (org-babel-expand-noweb-references info) (nth 1 info)))) (dir (cdr (assoc :dir params))) (default-directory (or (and dir (file-name-as-directory dir)) default-directory)) (org-babel-call-process-region-original (if (boundp (quote org-babel-call-process-region-original)) org-babel-call-process-region-original (symbol-function (quote c
 all-process-region)))) (indent (car (last info))) result cmd) (unwind-protect (flet ((call-process-region (&rest args) (apply (quote org-babel-tramp-handle-call-process-region) args))) (flet
  ((lang-check (f) (let ... ...))) (setq cmd (or (lang-check lang) (lang-check ...) (error "No org-babel-execute function for %s!" lang)))) (if (and (not arg) new-hash (equal new-hash old-hash)) (save-excursion (goto-char (org-babel-where-is-src-block-result nil info)) (end-of-line 1) (forward-char 1) (setq result (org-babel-read-result)) (message (replace-regexp-in-string "%" "%%" ...)) result) (message "executing %s code block%s..." (capitalize lang) (if (nth 4 info) (format " (%s)" ...) "")) (setq result ((lambda ... ...) (funcall cmd body params))) (when (cdr (assoc :file params)) (when result (with-temp-file ... ...)) (setq result (cdr ...))) (org-babel-insert-result result result-params info new-hash indent lang) (run-hooks (quote org-babel-after-execute-hook)) result)) (setq call-pr
 ocess-region (quote org-babel-call-process-region-original)))))
  (if (org-babel-confirm-evaluate (let ((i info)) (setf (nth 2 i) (org-babel-merge-params (nth 2 info) params)) i)) (progn (let* ((lang (nth 0 info)) (params (if params (org-babel-process-params (org-babel-merge-params ... params)) (nth 2 info))) (cache\? (and (not arg) (cdr (assoc :cache params)) (string= "yes" (cdr ...)))) (result-params (cdr (assoc :result-params params))) (new-hash (when cache\? (org-babel-sha1-hash info))) (old-hash (when cache\? (org-babel-current-result-hash))) (body (setf (nth 1 info) (if (org-babel-noweb-p params :eval) (org-babel-expand-noweb-references info) (nth 1 info)))) (dir (cdr (assoc :dir params))) (default-directory (or (and dir (file-name-as-directory dir)) default-directory)) (org-babel-call-process-region-original (if (boundp (quote org-babel-call-pro
 cess-region-original)) org-babel-call-process-region-original (symbol-function (quote call-process-region)))) (indent (car (last info))) result cmd) (unwind-protect (flet ((call-process-regi
 on (&rest args) (apply ... args))) (flet ((lang-check ... ...)) (setq cmd (or ... ... ...))) (if (and (not arg) new-hash (equal new-hash old-hash)) (save-excursion (goto-char ...) (end-of-line 1) (forward-char 1) (setq result ...) (message ...) result) (message "executing %s code block%s..." (capitalize lang) (if ... ... "")) (setq result (... ...)) (when (cdr ...) (when result ...) (setq result ...)) (org-babel-insert-result result result-params info new-hash indent lang) (run-hooks (quote org-babel-after-execute-hook)) result)) (setq call-process-region (quote org-babel-call-process-region-original))))))
  (when (org-babel-confirm-evaluate (let ((i info)) (setf (nth 2 i) (org-babel-merge-params (nth 2 info) params)) i)) (let* ((lang (nth 0 info)) (params (if params (org-babel-process-params (org-babel-merge-params (nth 2 info) params)) (nth 2 info))) (cache\? (and (not arg) (cdr (assoc :cache params)) (string= "yes" (cdr (assoc :cache params))))) (result-params (cdr (assoc :result-params params))) (new-hash (when cache\? (org-babel-sha1-hash info))) (old-hash (when cache\? (org-babel-current-result-hash))) (body (setf (nth 1 info) (if (org-babel-noweb-p params :eval) (org-babel-expand-noweb-references info) (nth 1 info)))) (dir (cdr (assoc :dir params))) (default-directory (or (and dir (file-name-as-directory dir)) default-directory)) (org-babel-call-process-region-original (if (boundp (qu
 ote org-babel-call-process-region-original)) org-babel-call-process-region-original (symbol-function (quote call-process-region)))) (indent (car (last info))) result cmd) (unwind-protect (fl
 et ((call-process-region (&rest args) (apply (quote org-babel-tramp-handle-call-process-region) args))) (flet ((lang-check (f) (let ... ...))) (setq cmd (or (lang-check lang) (lang-check ...) (error "No org-babel-execute function for %s!" lang)))) (if (and (not arg) new-hash (equal new-hash old-hash)) (save-excursion (goto-char (org-babel-where-is-src-block-result nil info)) (end-of-line 1) (forward-char 1) (setq result (org-babel-read-result)) (message (replace-regexp-in-string "%" "%%" ...)) result) (message "executing %s code block%s..." (capitalize lang) (if (nth 4 info) (format " (%s)" ...) "")) (setq result ((lambda ... ...) (funcall cmd body params))) (when (cdr (assoc :file params)) (when result (with-temp-file ... ...)) (setq result (cdr ...))) (org-babel-insert-result result res
 ult-params info new-hash indent lang) (run-hooks (quote org-babel-after-execute-hook)) result)) (setq call-process-region (quote org-babel-call-process-region-original)))))
  (let ((info (or info (org-babel-get-src-block-info)))) (when (org-babel-confirm-evaluate (let ((i info)) (setf (nth 2 i) (org-babel-merge-params (nth 2 info) params)) i)) (let* ((lang (nth 0 info)) (params (if params (org-babel-process-params (org-babel-merge-params ... params)) (nth 2 info))) (cache\? (and (not arg) (cdr (assoc :cache params)) (string= "yes" (cdr ...)))) (result-params (cdr (assoc :result-params params))) (new-hash (when cache\? (org-babel-sha1-hash info))) (old-hash (when cache\? (org-babel-current-result-hash))) (body (setf (nth 1 info) (if (org-babel-noweb-p params :eval) (org-babel-expand-noweb-references info) (nth 1 info)))) (dir (cdr (assoc :dir params))) (default-directory (or (and dir (file-name-as-directory dir)) default-directory)) (org-babel-call-process-reg
 ion-original (if (boundp (quote org-babel-call-process-region-original)) org-babel-call-process-region-original (symbol-function (quote call-process-region)))) (indent (car (last info))) res
 ult cmd) (unwind-protect (flet ((call-process-region (&rest args) (apply ... args))) (flet ((lang-check ... ...)) (setq cmd (or ... ... ...))) (if (and (not arg) new-hash (equal new-hash old-hash)) (save-excursion (goto-char ...) (end-of-line 1) (forward-char 1) (setq result ...) (message ...) result) (message "executing %s code block%s..." (capitalize lang) (if ... ... "")) (setq result (... ...)) (when (cdr ...) (when result ...) (setq result ...)) (org-babel-insert-result result result-params info new-hash indent lang) (run-hooks (quote org-babel-after-execute-hook)) result)) (setq call-process-region (quote org-babel-call-process-region-original))))))
  org-babel-execute-src-block(nil ("emacs-lisp" "#+end_src\n#+name: another-listing\n#+begin_src python :exports code" ((:comments . "") (:shebang . "") (:cache . "no") (:padline . "") (:noweb . "no") (:tangle . "no") (:exports . "both") (:results . "replace") (:colname-names) (:colnames . "no") (:hlines . "yes") (:padnewline . "yes") (:result-params "silent") (:result-type . value) (:rowname-names) (:session . "none")) "" "setup-minted" 0))
  (cond ((equal type (quote block)) (org-babel-execute-src-block nil info)) ((equal type (quote inline)) (re-search-backward "[ \f	\n\v]" nil t) (re-search-forward org-babel-inline-src-block-regexp nil t) (re-search-backward "src_" nil t) (org-babel-execute-src-block nil info)) ((equal type (quote lob)) (save-excursion (re-search-backward org-babel-lob-one-liner-regexp nil t) (org-babel-execute-src-block nil info))))
  (prog1 nil (setf (nth 2 info) (org-babel-exp-in-export-file lang (org-babel-process-params (org-babel-merge-params (nth 2 info) (\` ((:results \, ...))))))) (cond ((equal type (quote block)) (org-babel-execute-src-block nil info)) ((equal type (quote inline)) (re-search-backward "[ \f	\n\v]" nil t) (re-search-forward org-babel-inline-src-block-regexp nil t) (re-search-backward "src_" nil t) (org-babel-execute-src-block nil info)) ((equal type (quote lob)) (save-excursion (re-search-backward org-babel-lob-one-liner-regexp nil t) (org-babel-execute-src-block nil info)))))
  (progn (org-babel-eval-wipe-error-buffer) (prog1 nil (setf (nth 2 info) (org-babel-exp-in-export-file lang (org-babel-process-params (org-babel-merge-params (nth 2 info) (\` (...)))))) (cond ((equal type (quote block)) (org-babel-execute-src-block nil info)) ((equal type (quote inline)) (re-search-backward "[ \f	\n\v]" nil t) (re-search-forward org-babel-inline-src-block-regexp nil t) (re-search-backward "src_" nil t) (org-babel-execute-src-block nil info)) ((equal type (quote lob)) (save-excursion (re-search-backward org-babel-lob-one-liner-regexp nil t) (org-babel-execute-src-block nil info))))))
  (if (fboundp (intern (concat "org-babel-execute:" lang))) (progn (org-babel-eval-wipe-error-buffer) (prog1 nil (setf (nth 2 info) (org-babel-exp-in-export-file lang (org-babel-process-params (org-babel-merge-params (nth 2 info) (\` ...))))) (cond ((equal type (quote block)) (org-babel-execute-src-block nil info)) ((equal type (quote inline)) (re-search-backward "[ \f	\n\v]" nil t) (re-search-forward org-babel-inline-src-block-regexp nil t) (re-search-backward "src_" nil t) (org-babel-execute-src-block nil info)) ((equal type (quote lob)) (save-excursion (re-search-backward org-babel-lob-one-liner-regexp nil t) (org-babel-execute-src-block nil info)))))))
  (when (fboundp (intern (concat "org-babel-execute:" lang))) (org-babel-eval-wipe-error-buffer) (prog1 nil (setf (nth 2 info) (org-babel-exp-in-export-file lang (org-babel-process-params (org-babel-merge-params (nth 2 info) (\` (...)))))) (cond ((equal type (quote block)) (org-babel-execute-src-block nil info)) ((equal type (quote inline)) (re-search-backward "[ \f	\n\v]" nil t) (re-search-forward org-babel-inline-src-block-regexp nil t) (re-search-backward "src_" nil t) (org-babel-execute-src-block nil info)) ((equal type (quote lob)) (save-excursion (re-search-backward org-babel-lob-one-liner-regexp nil t) (org-babel-execute-src-block nil info))))))
  (let ((lang (nth 0 info)) (body (nth 1 info)) (info (copy-sequence info))) (when (fboundp (intern (concat "org-babel-execute:" lang))) (org-babel-eval-wipe-error-buffer) (prog1 nil (setf (nth 2 info) (org-babel-exp-in-export-file lang (org-babel-process-params (org-babel-merge-params (nth 2 info) (\` ...))))) (cond ((equal type (quote block)) (org-babel-execute-src-block nil info)) ((equal type (quote inline)) (re-search-backward "[ \f	\n\v]" nil t) (re-search-forward org-babel-inline-src-block-regexp nil t) (re-search-backward "src_" nil t) (org-babel-execute-src-block nil info)) ((equal type (quote lob)) (save-excursion (re-search-backward org-babel-lob-one-liner-regexp nil t) (org-babel-execute-src-block nil info)))))))
  (progn (let ((lang (nth 0 info)) (body (nth 1 info)) (info (copy-sequence info))) (when (fboundp (intern (concat "org-babel-execute:" lang))) (org-babel-eval-wipe-error-buffer) (prog1 nil (setf (nth 2 info) (org-babel-exp-in-export-file lang (org-babel-process-params (org-babel-merge-params ... ...)))) (cond ((equal type (quote block)) (org-babel-execute-src-block nil info)) ((equal type (quote inline)) (re-search-backward "[ \f	\n\v]" nil t) (re-search-forward org-babel-inline-src-block-regexp nil t) (re-search-backward "src_" nil t) (org-babel-execute-src-block nil info)) ((equal type (quote lob)) (save-excursion (re-search-backward org-babel-lob-one-liner-regexp nil t) (org-babel-execute-src-block nil info))))))))
  (if (and org-export-babel-evaluate (not (and hash (equal hash (org-babel-current-result-hash))))) (progn (let ((lang (nth 0 info)) (body (nth 1 info)) (info (copy-sequence info))) (when (fboundp (intern (concat "org-babel-execute:" lang))) (org-babel-eval-wipe-error-buffer) (prog1 nil (setf (nth 2 info) (org-babel-exp-in-export-file lang (org-babel-process-params ...))) (cond ((equal type ...) (org-babel-execute-src-block nil info)) ((equal type ...) (re-search-backward "[ \f	\n\v]" nil t) (re-search-forward org-babel-inline-src-block-regexp nil t) (re-search-backward "src_" nil t) (org-babel-execute-src-block nil info)) ((equal type ...) (save-excursion ... ...))))))))
  (when (and org-export-babel-evaluate (not (and hash (equal hash (org-babel-current-result-hash))))) (let ((lang (nth 0 info)) (body (nth 1 info)) (info (copy-sequence info))) (when (fboundp (intern (concat "org-babel-execute:" lang))) (org-babel-eval-wipe-error-buffer) (prog1 nil (setf (nth 2 info) (org-babel-exp-in-export-file lang (org-babel-process-params (org-babel-merge-params ... ...)))) (cond ((equal type (quote block)) (org-babel-execute-src-block nil info)) ((equal type (quote inline)) (re-search-backward "[ \f	\n\v]" nil t) (re-search-forward org-babel-inline-src-block-regexp nil t) (re-search-backward "src_" nil t) (org-babel-execute-src-block nil info)) ((equal type (quote lob)) (save-excursion (re-search-backward org-babel-lob-one-liner-regexp nil t) (org-babel-execute-src-bl
 ock nil info))))))))
  org-babel-exp-results(("emacs-lisp" "#+end_src\n#+name: another-listing\n#+begin_src python :exports code" ((:cache . "no") (:colname-names) (:colnames . "no") (:comments . "") (:exports . "both") (:hlines . "yes") (:noweb . "no") (:padline . "") (:padnewline . "yes") (:result-params "silent") (:result-type . value) (:results . "silent") (:rowname-names) (:session . "none") (:shebang . "") (:tangle . "no")) "" "setup-minted" 0) block nil "2a39b675a6bec8c15b0ed8928d030e836ddd17d5")
  (cond ((member* --cl-var-- (quote (quote none))) (silently) (clean) "") ((member* --cl-var-- (quote (quote code))) (silently) (clean) (org-babel-exp-code info)) ((member* --cl-var-- (quote (quote results))) (org-babel-exp-results info type nil hash) "") ((member* --cl-var-- (quote (quote both))) (org-babel-exp-results info type nil hash) (org-babel-exp-code info)))
  (let ((--cl-var-- (intern (or (cdr (assoc :exports (nth 2 info))) "code")))) (cond ((member* --cl-var-- (quote (quote none))) (silently) (clean) "") ((member* --cl-var-- (quote (quote code))) (silently) (clean) (org-babel-exp-code info)) ((member* --cl-var-- (quote (quote results))) (org-babel-exp-results info type nil hash) "") ((member* --cl-var-- (quote (quote both))) (org-babel-exp-results info type nil hash) (org-babel-exp-code info))))
  (case (intern (or (cdr (assoc :exports (nth 2 info))) "code")) ((quote none) (silently) (clean) "") ((quote code) (silently) (clean) (org-babel-exp-code info)) ((quote results) (org-babel-exp-results info type nil hash) "") ((quote both) (org-babel-exp-results info type nil hash) (org-babel-exp-code info)))
  (progn (fset (quote clean) (function* (lambda nil (block clean (unless (eq type (quote inline)) (org-babel-remove-result info)))))) (case (intern (or (cdr (assoc :exports (nth 2 info))) "code")) ((quote none) (silently) (clean) "") ((quote code) (silently) (clean) (org-babel-exp-code info)) ((quote results) (org-babel-exp-results info type nil hash) "") ((quote both) (org-babel-exp-results info type nil hash) (org-babel-exp-code info))))
  (unwind-protect (progn (fset (quote clean) (function* (lambda nil (block clean (unless (eq type ...) (org-babel-remove-result info)))))) (case (intern (or (cdr (assoc :exports (nth 2 info))) "code")) ((quote none) (silently) (clean) "") ((quote code) (silently) (clean) (org-babel-exp-code info)) ((quote results) (org-babel-exp-results info type nil hash) "") ((quote both) (org-babel-exp-results info type nil hash) (org-babel-exp-code info)))) (if --cl-letf-bound-- (fset (quote clean) --cl-letf-save--) (fmakunbound (quote clean))))
  (let* ((--cl-letf-bound-- (fboundp (quote clean))) (--cl-letf-save-- (and --cl-letf-bound-- (symbol-function (quote clean))))) (unwind-protect (progn (fset (quote clean) (function* (lambda nil (block clean (unless ... ...))))) (case (intern (or (cdr (assoc :exports ...)) "code")) ((quote none) (silently) (clean) "") ((quote code) (silently) (clean) (org-babel-exp-code info)) ((quote results) (org-babel-exp-results info type nil hash) "") ((quote both) (org-babel-exp-results info type nil hash) (org-babel-exp-code info)))) (if --cl-letf-bound-- (fset (quote clean) --cl-letf-save--) (fmakunbound (quote clean)))))
  (letf (((symbol-function (quote clean)) (function* (lambda nil (block clean (unless (eq type ...) (org-babel-remove-result info))))))) (case (intern (or (cdr (assoc :exports (nth 2 info))) "code")) ((quote none) (silently) (clean) "") ((quote code) (silently) (clean) (org-babel-exp-code info)) ((quote results) (org-babel-exp-results info type nil hash) "") ((quote both) (org-babel-exp-results info type nil hash) (org-babel-exp-code info))))
  (progn (fset (quote silently) (function* (lambda nil (block silently (let ((session ...)) (when (not ...) (org-babel-exp-results info type ...))))))) (letf (((symbol-function (quote clean)) (function* (lambda nil (block clean (unless ... ...)))))) (case (intern (or (cdr (assoc :exports (nth 2 info))) "code")) ((quote none) (silently) (clean) "") ((quote code) (silently) (clean) (org-babel-exp-code info)) ((quote results) (org-babel-exp-results info type nil hash) "") ((quote both) (org-babel-exp-results info type nil hash) (org-babel-exp-code info)))))
  (unwind-protect (progn (fset (quote silently) (function* (lambda nil (block silently (let (...) (when ... ...)))))) (letf (((symbol-function (quote clean)) (function* (lambda nil (block clean ...))))) (case (intern (or (cdr (assoc :exports ...)) "code")) ((quote none) (silently) (clean) "") ((quote code) (silently) (clean) (org-babel-exp-code info)) ((quote results) (org-babel-exp-results info type nil hash) "") ((quote both) (org-babel-exp-results info type nil hash) (org-babel-exp-code info))))) (if --cl-letf-bound-- (fset (quote silently) --cl-letf-save--) (fmakunbound (quote silently))))
  (let* ((--cl-letf-bound-- (fboundp (quote silently))) (--cl-letf-save-- (and --cl-letf-bound-- (symbol-function (quote silently))))) (unwind-protect (progn (fset (quote silently) (function* (lambda nil (block silently (let ... ...))))) (letf (((symbol-function (quote clean)) (function* (lambda nil ...)))) (case (intern (or (cdr ...) "code")) ((quote none) (silently) (clean) "") ((quote code) (silently) (clean) (org-babel-exp-code info)) ((quote results) (org-babel-exp-results info type nil hash) "") ((quote both) (org-babel-exp-results info type nil hash) (org-babel-exp-code info))))) (if --cl-letf-bound-- (fset (quote silently) --cl-letf-save--) (fmakunbound (quote silently)))))
  (letf (((symbol-function (quote silently)) (function* (lambda nil (block silently (let (...) (when ... ...))))))) (letf (((symbol-function (quote clean)) (function* (lambda nil (block clean (unless ... ...)))))) (case (intern (or (cdr (assoc :exports (nth 2 info))) "code")) ((quote none) (silently) (clean) "") ((quote code) (silently) (clean) (org-babel-exp-code info)) ((quote results) (org-babel-exp-results info type nil hash) "") ((quote both) (org-babel-exp-results info type nil hash) (org-babel-exp-code info)))))
  (letf* (((symbol-function (quote silently)) (function* (lambda nil (block silently (let (...) (when ... ...)))))) ((symbol-function (quote clean)) (function* (lambda nil (block clean (unless (eq type ...) (org-babel-remove-result info))))))) (case (intern (or (cdr (assoc :exports (nth 2 info))) "code")) ((quote none) (silently) (clean) "") ((quote code) (silently) (clean) (org-babel-exp-code info)) ((quote results) (org-babel-exp-results info type nil hash) "") ((quote both) (org-babel-exp-results info type nil hash) (org-babel-exp-code info))))
  (flet ((silently nil (let ((session (cdr (assoc :session ...)))) (when (not (and session (equal "none" session))) (org-babel-exp-results info type (quote silent))))) (clean nil (unless (eq type (quote inline)) (org-babel-remove-result info)))) (case (intern (or (cdr (assoc :exports (nth 2 info))) "code")) ((quote none) (silently) (clean) "") ((quote code) (silently) (clean) (org-babel-exp-code info)) ((quote results) (org-babel-exp-results info type nil hash) "") ((quote both) (org-babel-exp-results info type nil hash) (org-babel-exp-code info))))
  org-babel-exp-do-export(("emacs-lisp" "#+end_src\n#+name: another-listing\n#+begin_src python :exports code" ((:cache . "no") (:colname-names) (:colnames . "no") (:comments . "") (:exports . "both") (:hlines . "yes") (:noweb . "no") (:padline . "") (:padnewline . "yes") (:result-params "silent") (:result-type . value) (:results . "silent") (:rowname-names) (:session . "none") (:shebang . "") (:tangle . "no")) "" "setup-minted" 0) block "2a39b675a6bec8c15b0ed8928d030e836ddd17d5")
  (progn (when (member (cdr (assoc :exports (nth 2 info))) (quote ("both" "results"))) (org-babel-exp-in-export-file lang (setf (nth 2 info) (org-babel-process-params (org-babel-merge-params org-babel-default-header-args (org-babel-params-from-properties lang) (if (boundp lang-headers) (eval lang-headers) nil) raw-params)))) (setf hash (org-babel-sha1-hash info))) (setf (nth 1 info) (if (org-babel-noweb-p (nth 2 info) :export) (org-babel-expand-noweb-references info (get-file-buffer org-current-export-file)) (nth 1 info))) (org-babel-exp-do-export info (quote block) hash))
  (if info (progn (when (member (cdr (assoc :exports (nth 2 info))) (quote ("both" "results"))) (org-babel-exp-in-export-file lang (setf (nth 2 info) (org-babel-process-params (org-babel-merge-params org-babel-default-header-args (org-babel-params-from-properties lang) (if ... ... nil) raw-params)))) (setf hash (org-babel-sha1-hash info))) (setf (nth 1 info) (if (org-babel-noweb-p (nth 2 info) :export) (org-babel-expand-noweb-references info (get-file-buffer org-current-export-file)) (nth 1 info))) (org-babel-exp-do-export info (quote block) hash)))
  (when info (when (member (cdr (assoc :exports (nth 2 info))) (quote ("both" "results"))) (org-babel-exp-in-export-file lang (setf (nth 2 info) (org-babel-process-params (org-babel-merge-params org-babel-default-header-args (org-babel-params-from-properties lang) (if (boundp lang-headers) (eval lang-headers) nil) raw-params)))) (setf hash (org-babel-sha1-hash info))) (setf (nth 1 info) (if (org-babel-noweb-p (nth 2 info) :export) (org-babel-expand-noweb-references info (get-file-buffer org-current-export-file)) (nth 1 info))) (org-babel-exp-do-export info (quote block) hash))
  (let* ((info (org-babel-get-src-block-info (quote light))) (lang (nth 0 info)) (raw-params (nth 2 info)) hash) (when info (when (member (cdr (assoc :exports (nth 2 info))) (quote ("both" "results"))) (org-babel-exp-in-export-file lang (setf (nth 2 info) (org-babel-process-params (org-babel-merge-params org-babel-default-header-args (org-babel-params-from-properties lang) (if ... ... nil) raw-params)))) (setf hash (org-babel-sha1-hash info))) (setf (nth 1 info) (if (org-babel-noweb-p (nth 2 info) :export) (org-babel-expand-noweb-references info (get-file-buffer org-current-export-file)) (nth 1 info))) (org-babel-exp-do-export info (quote block) hash)))
  (save-excursion (goto-char (match-beginning 0)) (let* ((info (org-babel-get-src-block-info (quote light))) (lang (nth 0 info)) (raw-params (nth 2 info)) hash) (when info (when (member (cdr (assoc :exports (nth 2 info))) (quote ("both" "results"))) (org-babel-exp-in-export-file lang (setf (nth 2 info) (org-babel-process-params (org-babel-merge-params org-babel-default-header-args ... ... raw-params)))) (setf hash (org-babel-sha1-hash info))) (setf (nth 1 info) (if (org-babel-noweb-p (nth 2 info) :export) (org-babel-expand-noweb-references info (get-file-buffer org-current-export-file)) (nth 1 info))) (org-babel-exp-do-export info (quote block) hash))))
  org-babel-exp-src-block("" #("emacs-lisp" 0 10 (font-lock-fontified t fontified t)) #(":exports" 0 8 (font-lock-fontified t fontified t)) #("both" 0 4 (font-lock-fontified t fontified t)) #(":results" 0 8 (font-lock-fontified t fontified t)) #("silent" 0 6 (font-lock-fontified t fontified t)))
  apply(org-babel-exp-src-block "" (#("emacs-lisp" 0 10 (font-lock-fontified t fontified t)) #(":exports" 0 8 (font-lock-fontified t fontified t)) #("both" 0 4 (font-lock-fontified t fontified t)) #(":results" 0 8 (font-lock-fontified t fontified t)) #("silent" 0 6 (font-lock-fontified t fontified t))))
  (if (memq type org-export-blocks-witheld) "" (apply func body headers))
  (progn (if (memq type org-export-blocks-witheld) "" (apply func body headers)))
  (unwind-protect (progn (if (memq type org-export-blocks-witheld) "" (apply func body headers))) (set-match-data save-match-data-internal (quote evaporate)))
  (let ((save-match-data-internal (match-data))) (unwind-protect (progn (if (memq type org-export-blocks-witheld) "" (apply func body headers))) (set-match-data save-match-data-internal (quote evaporate))))
  (save-match-data (if (memq type org-export-blocks-witheld) "" (apply func body headers)))
  (let ((replacement (save-match-data (if (memq type org-export-blocks-witheld) "" (apply func body headers))))) (when replacement (delete-region match-start match-end) (goto-char match-start) (insert replacement) (unless preserve-indent (indent-code-rigidly match-start (point) indentation))))
  (progn (let ((replacement (save-match-data (if (memq type org-export-blocks-witheld) "" (apply func body headers))))) (when replacement (delete-region match-start match-end) (goto-char match-start) (insert replacement) (unless preserve-indent (indent-code-rigidly match-start (point) indentation)))))
  (if (setq func (cadr (assoc type org-export-blocks))) (progn (let ((replacement (save-match-data (if (memq type org-export-blocks-witheld) "" (apply func body headers))))) (when replacement (delete-region match-start match-end) (goto-char match-start) (insert replacement) (unless preserve-indent (indent-code-rigidly match-start (point) indentation))))))
  (when (setq func (cadr (assoc type org-export-blocks))) (let ((replacement (save-match-data (if (memq type org-export-blocks-witheld) "" (apply func body headers))))) (when replacement (delete-region match-start match-end) (goto-char match-start) (insert replacement) (unless preserve-indent (indent-code-rigidly match-start (point) indentation)))))
  (let* ((match-start (copy-marker (match-beginning 0))) (body-start (copy-marker (match-end 0))) (indentation (length (match-string 1))) (inner-re (format "^[ 	]*#\\+\\(begin\\|end\\)_%s" (regexp-quote (downcase (match-string 2))))) (type (intern (downcase (match-string 2)))) (headers (save-match-data (org-split-string (match-string 3) "[ 	]+"))) (balanced 1) (preserve-indent (or org-src-preserve-indentation (member "-i" headers))) match-end) (while (and (not (zerop balanced)) (re-search-forward inner-re nil t)) (if (string= (downcase (match-string 1)) "end") (decf balanced) (incf balanced))) (when (not (zerop balanced)) (error "unbalanced begin/end_%s blocks with %S" type (buffer-substring match-start (point)))) (setq match-end (copy-marker (match-end 0))) (unless preserve-indent (setq b
 ody (save-match-data (org-remove-indentation (buffer-substring body-start (match-beginning 0)))))) (unless (memq type types) (setq types (cons type types))) (save-match-data (interblock star
 t match-start)) (when (setq func (cadr (assoc type org-export-blocks))) (let ((replacement (save-match-data (if (memq type org-export-blocks-witheld) "" (apply func body headers))))) (when replacement (delete-region match-start match-end) (goto-char match-start) (insert replacement) (unless preserve-indent (indent-code-rigidly match-start (point) indentation))))) (set-marker match-start nil) (set-marker body-start nil) (set-marker match-end nil))
  (while (re-search-forward beg-re nil t) (let* ((match-start (copy-marker (match-beginning 0))) (body-start (copy-marker (match-end 0))) (indentation (length (match-string 1))) (inner-re (format "^[ 	]*#\\+\\(begin\\|end\\)_%s" (regexp-quote (downcase (match-string 2))))) (type (intern (downcase (match-string 2)))) (headers (save-match-data (org-split-string (match-string 3) "[ 	]+"))) (balanced 1) (preserve-indent (or org-src-preserve-indentation (member "-i" headers))) match-end) (while (and (not (zerop balanced)) (re-search-forward inner-re nil t)) (if (string= (downcase (match-string 1)) "end") (decf balanced) (incf balanced))) (when (not (zerop balanced)) (error "unbalanced begin/end_%s blocks with %S" type (buffer-substring match-start (point)))) (setq match-end (copy-marker (match-
 end 0))) (unless preserve-indent (setq body (save-match-data (org-remove-indentation (buffer-substring body-start (match-beginning 0)))))) (unless (memq type types) (setq types (cons type ty
 pes))) (save-match-data (interblock start match-start)) (when (setq func (cadr (assoc type org-export-blocks))) (let ((replacement (save-match-data (if ... "" ...)))) (when replacement (delete-region match-start match-end) (goto-char match-start) (insert replacement) (unless preserve-indent (indent-code-rigidly match-start (point) indentation))))) (set-marker match-start nil) (set-marker body-start nil) (set-marker match-end nil)) (setq start (point)))
  (let ((beg-re "^\\([ 	]*\\)#\\+begin_\\(\\S-+\\)[ 	]*\\(.*\\)?[\n]")) (while (re-search-forward beg-re nil t) (let* ((match-start (copy-marker (match-beginning 0))) (body-start (copy-marker (match-end 0))) (indentation (length (match-string 1))) (inner-re (format "^[ 	]*#\\+\\(begin\\|end\\)_%s" (regexp-quote (downcase ...)))) (type (intern (downcase (match-string 2)))) (headers (save-match-data (org-split-string (match-string 3) "[ 	]+"))) (balanced 1) (preserve-indent (or org-src-preserve-indentation (member "-i" headers))) match-end) (while (and (not (zerop balanced)) (re-search-forward inner-re nil t)) (if (string= (downcase (match-string 1)) "end") (decf balanced) (incf balanced))) (when (not (zerop balanced)) (error "unbalanced begin/end_%s blocks with %S" type (buffer-substring ma
 tch-start (point)))) (setq match-end (copy-marker (match-end 0))) (unless preserve-indent (setq body (save-match-data (org-remove-indentation (buffer-substring body-start ...))))) (unless (
 memq type types) (setq types (cons type types))) (save-match-data (interblock start match-start)) (when (setq func (cadr (assoc type org-export-blocks))) (let ((replacement (save-match-data ...))) (when replacement (delete-region match-start match-end) (goto-char match-start) (insert replacement) (unless preserve-indent (indent-code-rigidly match-start ... indentation))))) (set-marker match-start nil) (set-marker body-start nil) (set-marker match-end nil)) (setq start (point))))
  (progn (fset (quote interblock) (function* (lambda (start end) (block interblock (mapcar (lambda (pair) (funcall ... start end)) org-export-interblocks))))) (goto-char (point-min)) (setq start (point)) (let ((beg-re "^\\([ 	]*\\)#\\+begin_\\(\\S-+\\)[ 	]*\\(.*\\)?[\n]")) (while (re-search-forward beg-re nil t) (let* ((match-start (copy-marker (match-beginning 0))) (body-start (copy-marker (match-end 0))) (indentation (length (match-string 1))) (inner-re (format "^[ 	]*#\\+\\(begin\\|end\\)_%s" (regexp-quote ...))) (type (intern (downcase ...))) (headers (save-match-data (org-split-string ... "[ 	]+"))) (balanced 1) (preserve-indent (or org-src-preserve-indentation (member "-i" headers))) match-end) (while (and (not (zerop balanced)) (re-search-forward inner-re nil t)) (if (string= (downc
 ase ...) "end") (decf balanced) (incf balanced))) (when (not (zerop balanced)) (error "unbalanced begin/end_%s blocks with %S" type (buffer-substring match-start (point)))) (setq match-end 
 (copy-marker (match-end 0))) (unless preserve-indent (setq body (save-match-data (org-remove-indentation ...)))) (unless (memq type types) (setq types (cons type types))) (save-match-data (interblock start match-start)) (when (setq func (cadr (assoc type org-export-blocks))) (let ((replacement ...)) (when replacement (delete-region match-start match-end) (goto-char match-start) (insert replacement) (unless preserve-indent ...)))) (set-marker match-start nil) (set-marker body-start nil) (set-marker match-end nil)) (setq start (point)))) (interblock start (point-max)) (run-hooks (quote org-export-blocks-postblock-hook)))
  (unwind-protect (progn (fset (quote interblock) (function* (lambda (start end) (block interblock (mapcar (lambda ... ...) org-export-interblocks))))) (goto-char (point-min)) (setq start (point)) (let ((beg-re "^\\([ 	]*\\)#\\+begin_\\(\\S-+\\)[ 	]*\\(.*\\)?[\n]")) (while (re-search-forward beg-re nil t) (let* ((match-start (copy-marker ...)) (body-start (copy-marker ...)) (indentation (length ...)) (inner-re (format "^[ 	]*#\\+\\(begin\\|end\\)_%s" ...)) (type (intern ...)) (headers (save-match-data ...)) (balanced 1) (preserve-indent (or org-src-preserve-indentation ...)) match-end) (while (and (not ...) (re-search-forward inner-re nil t)) (if (string= ... "end") (decf balanced) (incf balanced))) (when (not (zerop balanced)) (error "unbalanced begin/end_%s blocks with %S" type (buffer-s
 ubstring match-start ...))) (setq match-end (copy-marker (match-end 0))) (unless preserve-indent (setq body (save-match-data ...))) (unless (memq type types) (setq types (cons type types)))
  (save-match-data (interblock start match-start)) (when (setq func (cadr ...)) (let (...) (when replacement ... ... ... ...))) (set-marker match-start nil) (set-marker body-start nil) (set-marker match-end nil)) (setq start (point)))) (interblock start (point-max)) (run-hooks (quote org-export-blocks-postblock-hook))) (if --cl-letf-bound-- (fset (quote interblock) --cl-letf-save--) (fmakunbound (quote interblock))))
  (let* ((--cl-letf-bound-- (fboundp (quote interblock))) (--cl-letf-save-- (and --cl-letf-bound-- (symbol-function (quote interblock))))) (unwind-protect (progn (fset (quote interblock) (function* (lambda (start end) (block interblock (mapcar ... org-export-interblocks))))) (goto-char (point-min)) (setq start (point)) (let ((beg-re "^\\([ 	]*\\)#\\+begin_\\(\\S-+\\)[ 	]*\\(.*\\)?[\n]")) (while (re-search-forward beg-re nil t) (let* ((match-start ...) (body-start ...) (indentation ...) (inner-re ...) (type ...) (headers ...) (balanced 1) (preserve-indent ...) match-end) (while (and ... ...) (if ... ... ...)) (when (not ...) (error "unbalanced begin/end_%s blocks with %S" type ...)) (setq match-end (copy-marker ...)) (unless preserve-indent (setq body ...)) (unless (memq type types) (setq t
 ypes ...)) (save-match-data (interblock start match-start)) (when (setq func ...) (let ... ...)) (set-marker match-start nil) (set-marker body-start nil) (set-marker match-end nil)) (setq s
 tart (point)))) (interblock start (point-max)) (run-hooks (quote org-export-blocks-postblock-hook))) (if --cl-letf-bound-- (fset (quote interblock) --cl-letf-save--) (fmakunbound (quote interblock)))))
  (letf (((symbol-function (quote interblock)) (function* (lambda (start end) (block interblock (mapcar (lambda ... ...) org-export-interblocks)))))) (goto-char (point-min)) (setq start (point)) (let ((beg-re "^\\([ 	]*\\)#\\+begin_\\(\\S-+\\)[ 	]*\\(.*\\)?[\n]")) (while (re-search-forward beg-re nil t) (let* ((match-start (copy-marker (match-beginning 0))) (body-start (copy-marker (match-end 0))) (indentation (length (match-string 1))) (inner-re (format "^[ 	]*#\\+\\(begin\\|end\\)_%s" (regexp-quote ...))) (type (intern (downcase ...))) (headers (save-match-data (org-split-string ... "[ 	]+"))) (balanced 1) (preserve-indent (or org-src-preserve-indentation (member "-i" headers))) match-end) (while (and (not (zerop balanced)) (re-search-forward inner-re nil t)) (if (string= (downcase ...) 
 "end") (decf balanced) (incf balanced))) (when (not (zerop balanced)) (error "unbalanced begin/end_%s blocks with %S" type (buffer-substring match-start (point)))) (setq match-end (copy-mar
 ker (match-end 0))) (unless preserve-indent (setq body (save-match-data (org-remove-indentation ...)))) (unless (memq type types) (setq types (cons type types))) (save-match-data (interblock start match-start)) (when (setq func (cadr (assoc type org-export-blocks))) (let ((replacement ...)) (when replacement (delete-region match-start match-end) (goto-char match-start) (insert replacement) (unless preserve-indent ...)))) (set-marker match-start nil) (set-marker body-start nil) (set-marker match-end nil)) (setq start (point)))) (interblock start (point-max)) (run-hooks (quote org-export-blocks-postblock-hook)))
  (letf* (((symbol-function (quote interblock)) (function* (lambda (start end) (block interblock (mapcar (lambda ... ...) org-export-interblocks)))))) (goto-char (point-min)) (setq start (point)) (let ((beg-re "^\\([ 	]*\\)#\\+begin_\\(\\S-+\\)[ 	]*\\(.*\\)?[\n]")) (while (re-search-forward beg-re nil t) (let* ((match-start (copy-marker (match-beginning 0))) (body-start (copy-marker (match-end 0))) (indentation (length (match-string 1))) (inner-re (format "^[ 	]*#\\+\\(begin\\|end\\)_%s" (regexp-quote ...))) (type (intern (downcase ...))) (headers (save-match-data (org-split-string ... "[ 	]+"))) (balanced 1) (preserve-indent (or org-src-preserve-indentation (member "-i" headers))) match-end) (while (and (not (zerop balanced)) (re-search-forward inner-re nil t)) (if (string= (downcase ...)
  "end") (decf balanced) (incf balanced))) (when (not (zerop balanced)) (error "unbalanced begin/end_%s blocks with %S" type (buffer-substring match-start (point)))) (setq match-end (copy-ma
 rker (match-end 0))) (unless preserve-indent (setq body (save-match-data (org-remove-indentation ...)))) (unless (memq type types) (setq types (cons type types))) (save-match-data (interblock start match-start)) (when (setq func (cadr (assoc type org-export-blocks))) (let ((replacement ...)) (when replacement (delete-region match-start match-end) (goto-char match-start) (insert replacement) (unless preserve-indent ...)))) (set-marker match-start nil) (set-marker body-start nil) (set-marker match-end nil)) (setq start (point)))) (interblock start (point-max)) (run-hooks (quote org-export-blocks-postblock-hook)))
  (flet ((interblock (start end) (mapcar (lambda (pair) (funcall (second pair) start end)) org-export-interblocks))) (goto-char (point-min)) (setq start (point)) (let ((beg-re "^\\([ 	]*\\)#\\+begin_\\(\\S-+\\)[ 	]*\\(.*\\)?[\n]")) (while (re-search-forward beg-re nil t) (let* ((match-start (copy-marker (match-beginning 0))) (body-start (copy-marker (match-end 0))) (indentation (length (match-string 1))) (inner-re (format "^[ 	]*#\\+\\(begin\\|end\\)_%s" (regexp-quote ...))) (type (intern (downcase ...))) (headers (save-match-data (org-split-string ... "[ 	]+"))) (balanced 1) (preserve-indent (or org-src-preserve-indentation (member "-i" headers))) match-end) (while (and (not (zerop balanced)) (re-search-forward inner-re nil t)) (if (string= (downcase ...) "end") (decf balanced) (incf bala
 nced))) (when (not (zerop balanced)) (error "unbalanced begin/end_%s blocks with %S" type (buffer-substring match-start (point)))) (setq match-end (copy-marker (match-end 0))) (unless prese
 rve-indent (setq body (save-match-data (org-remove-indentation ...)))) (unless (memq type types) (setq types (cons type types))) (save-match-data (interblock start match-start)) (when (setq func (cadr (assoc type org-export-blocks))) (let ((replacement ...)) (when replacement (delete-region match-start match-end) (goto-char match-start) (insert replacement) (unless preserve-indent ...)))) (set-marker match-start nil) (set-marker body-start nil) (set-marker match-end nil)) (setq start (point)))) (interblock start (point-max)) (run-hooks (quote org-export-blocks-postblock-hook)))
  (let ((case-fold-search t) (types (quote nil)) matched indentation type func start end body headers preserve-indent progress-marker) (flet ((interblock (start end) (mapcar (lambda (pair) (funcall (second pair) start end)) org-export-interblocks))) (goto-char (point-min)) (setq start (point)) (let ((beg-re "^\\([ 	]*\\)#\\+begin_\\(\\S-+\\)[ 	]*\\(.*\\)?[\n]")) (while (re-search-forward beg-re nil t) (let* ((match-start (copy-marker ...)) (body-start (copy-marker ...)) (indentation (length ...)) (inner-re (format "^[ 	]*#\\+\\(begin\\|end\\)_%s" ...)) (type (intern ...)) (headers (save-match-data ...)) (balanced 1) (preserve-indent (or org-src-preserve-indentation ...)) match-end) (while (and (not ...) (re-search-forward inner-re nil t)) (if (string= ... "end") (decf balanced) (incf balan
 ced))) (when (not (zerop balanced)) (error "unbalanced begin/end_%s blocks with %S" type (buffer-substring match-start ...))) (setq match-end (copy-marker (match-end 0))) (unless preserve-i
 ndent (setq body (save-match-data ...))) (unless (memq type types) (setq types (cons type types))) (save-match-data (interblock start match-start)) (when (setq func (cadr ...)) (let (...) (when replacement ... ... ... ...))) (set-marker match-start nil) (set-marker body-start nil) (set-marker match-end nil)) (setq start (point)))) (interblock start (point-max)) (run-hooks (quote org-export-blocks-postblock-hook))))
  (progn (let ((case-fold-search t) (types (quote nil)) matched indentation type func start end body headers preserve-indent progress-marker) (flet ((interblock (start end) (mapcar (lambda (pair) (funcall ... start end)) org-export-interblocks))) (goto-char (point-min)) (setq start (point)) (let ((beg-re "^\\([ 	]*\\)#\\+begin_\\(\\S-+\\)[ 	]*\\(.*\\)?[\n]")) (while (re-search-forward beg-re nil t) (let* ((match-start ...) (body-start ...) (indentation ...) (inner-re ...) (type ...) (headers ...) (balanced 1) (preserve-indent ...) match-end) (while (and ... ...) (if ... ... ...)) (when (not ...) (error "unbalanced begin/end_%s blocks with %S" type ...)) (setq match-end (copy-marker ...)) (unless preserve-indent (setq body ...)) (unless (memq type types) (setq types ...)) (save-match-data (
 interblock start match-start)) (when (setq func ...) (let ... ...)) (set-marker match-start nil) (set-marker body-start nil) (set-marker match-end nil)) (setq start (point)))) (interblock s
 tart (point-max)) (run-hooks (quote org-export-blocks-postblock-hook)))))
  (unwind-protect (progn (let ((case-fold-search t) (types (quote nil)) matched indentation type func start end body headers preserve-indent progress-marker) (flet ((interblock (start end) (mapcar (lambda ... ...) org-export-interblocks))) (goto-char (point-min)) (setq start (point)) (let ((beg-re "^\\([ 	]*\\)#\\+begin_\\(\\S-+\\)[ 	]*\\(.*\\)?[\n]")) (while (re-search-forward beg-re nil t) (let* (... ... ... ... ... ... ... ... match-end) (while ... ...) (when ... ...) (setq match-end ...) (unless preserve-indent ...) (unless ... ...) (save-match-data ...) (when ... ...) (set-marker match-start nil) (set-marker body-start nil) (set-marker match-end nil)) (setq start (point)))) (interblock start (point-max)) (run-hooks (quote org-export-blocks-postblock-hook))))) (set-window-configuration
  wconfig))
  (let ((wconfig (current-window-configuration))) (unwind-protect (progn (let ((case-fold-search t) (types (quote nil)) matched indentation type func start end body headers preserve-indent progress-marker) (flet ((interblock (start end) (mapcar ... org-export-interblocks))) (goto-char (point-min)) (setq start (point)) (let ((beg-re "^\\([ 	]*\\)#\\+begin_\\(\\S-+\\)[ 	]*\\(.*\\)?[\n]")) (while (re-search-forward beg-re nil t) (let* ... ... ... ... ... ... ... ... ... ... ...) (setq start ...))) (interblock start (point-max)) (run-hooks (quote org-export-blocks-postblock-hook))))) (set-window-configuration wconfig)))
  (save-window-excursion (let ((case-fold-search t) (types (quote nil)) matched indentation type func start end body headers preserve-indent progress-marker) (flet ((interblock (start end) (mapcar (lambda (pair) (funcall ... start end)) org-export-interblocks))) (goto-char (point-min)) (setq start (point)) (let ((beg-re "^\\([ 	]*\\)#\\+begin_\\(\\S-+\\)[ 	]*\\(.*\\)?[\n]")) (while (re-search-forward beg-re nil t) (let* ((match-start ...) (body-start ...) (indentation ...) (inner-re ...) (type ...) (headers ...) (balanced 1) (preserve-indent ...) match-end) (while (and ... ...) (if ... ... ...)) (when (not ...) (error "unbalanced begin/end_%s blocks with %S" type ...)) (setq match-end (copy-marker ...)) (unless preserve-indent (setq body ...)) (unless (memq type types) (setq types ...)) (s
 ave-match-data (interblock start match-start)) (when (setq func ...) (let ... ...)) (set-marker match-start nil) (set-marker body-start nil) (set-marker match-end nil)) (setq start (point))
 )) (interblock start (point-max)) (run-hooks (quote org-export-blocks-postblock-hook)))))
  org-export-blocks-preprocess()
  (progn (erase-buffer) (insert string) (setq case-fold-search t) (let ((inhibit-read-only t)) (remove-text-properties (point-min) (point-max) (quote (read-only t)))) (org-export-kill-licensed-text) (let ((org-inhibit-startup t)) (org-mode)) (setq case-fold-search t) (org-clone-local-variables source-buffer "^\\(org-\\|orgtbl-\\)") (org-install-letbind) (run-hooks (quote org-export-preprocess-hook)) (untabify (point-min) (point-max)) (org-export-handle-include-files-recurse) (run-hooks (quote org-export-preprocess-after-include-files-hook)) (org-export-remove-archived-trees archived-trees) (org-export-remove-comment-blocks-and-subtrees) (org-export-handle-export-tags (plist-get parameters :select-tags) (plist-get parameters :exclude-tags)) (run-hooks (quote org-export-preprocess-after-tree
 -selection-hook)) (org-export-remove-tasks (plist-get parameters :tasks)) (when (plist-get parameters :footnotes) (org-footnote-normalize nil parameters)) (org-export-mark-list-end) (org-exp
 ort-preprocess-apply-macros) (run-hooks (quote org-export-preprocess-after-macros-hook)) (org-export-blocks-preprocess) (org-export-mark-list-properties) (org-export-replace-src-segments-and-examples) (org-export-protect-colon-examples) (org-export-convert-protected-spaces) (setq target-alist (org-export-define-heading-targets target-alist)) (run-hooks (quote org-export-preprocess-after-headline-targets-hook)) (org-export-remember-html-container-classes) (org-export-remove-or-extract-drawers drawers (plist-get parameters :drawers)) (when (plist-get parameters :skip-before-1st-heading) (goto-char (point-min)) (when (re-search-forward "^\\(#.*\n\\)?\\*+[ 	]" nil t) (delete-region (point-min) (match-beginning 0)) (goto-char (point-min)) (insert "\n"))) (when (plist-get parameters :add-text) 
 (goto-char (point-min)) (insert (plist-get parameters :add-text) "\n")) (org-export-remove-headline-metadata parameters) (setq target-alist (org-export-handle-invisible-targets target-alist)
 ) (run-hooks (quote org-export-preprocess-before-selecting-backend-code-hook)) (org-export-select-backend-specific-text) (org-export-protect-quoted-subtrees) (org-export-remove-clock-lines) (org-export-protect-verbatim) (org-export-mark-blockquote-verse-center) (run-hooks (quote org-export-preprocess-after-blockquote-hook)) (unless (plist-get parameters :timestamps) (org-export-remove-timestamps)) (setq target-alist (org-export-attach-captions-and-attributes target-alist)) (org-export-mark-radio-links) (run-hooks (quote org-export-preprocess-after-radio-targets-hook)) (org-export-concatenate-multiline-links) (run-hooks (quote org-export-preprocess-before-normalizing-links-hook)) (org-export-normalize-links) ...)
  (unwind-protect (progn (erase-buffer) (insert string) (setq case-fold-search t) (let ((inhibit-read-only t)) (remove-text-properties (point-min) (point-max) (quote (read-only t)))) (org-export-kill-licensed-text) (let ((org-inhibit-startup t)) (org-mode)) (setq case-fold-search t) (org-clone-local-variables source-buffer "^\\(org-\\|orgtbl-\\)") (org-install-letbind) (run-hooks (quote org-export-preprocess-hook)) (untabify (point-min) (point-max)) (org-export-handle-include-files-recurse) (run-hooks (quote org-export-preprocess-after-include-files-hook)) (org-export-remove-archived-trees archived-trees) (org-export-remove-comment-blocks-and-subtrees) (org-export-handle-export-tags (plist-get parameters :select-tags) (plist-get parameters :exclude-tags)) (run-hooks (quote org-export-prepr
 ocess-after-tree-selection-hook)) (org-export-remove-tasks (plist-get parameters :tasks)) (when (plist-get parameters :footnotes) (org-footnote-normalize nil parameters)) (org-export-mark-li
 st-end) (org-export-preprocess-apply-macros) (run-hooks (quote org-export-preprocess-after-macros-hook)) (org-export-blocks-preprocess) (org-export-mark-list-properties) (org-export-replace-src-segments-and-examples) (org-export-protect-colon-examples) (org-export-convert-protected-spaces) (setq target-alist (org-export-define-heading-targets target-alist)) (run-hooks (quote org-export-preprocess-after-headline-targets-hook)) (org-export-remember-html-container-classes) (org-export-remove-or-extract-drawers drawers (plist-get parameters :drawers)) (when (plist-get parameters :skip-before-1st-heading) (goto-char (point-min)) (when (re-search-forward "^\\(#.*\n\\)?\\*+[ 	]" nil t) (delete-region (point-min) (match-beginning 0)) (goto-char (point-min)) (insert "\n"))) (when (plist-get parame
 ters :add-text) (goto-char (point-min)) (insert (plist-get parameters :add-text) "\n")) (org-export-remove-headline-metadata parameters) (setq target-alist (org-export-handle-invisible-targe
 ts target-alist)) (run-hooks (quote org-export-preprocess-before-selecting-backend-code-hook)) (org-export-select-backend-specific-text) (org-export-protect-quoted-subtrees) (org-export-remove-clock-lines) (org-export-protect-verbatim) (org-export-mark-blockquote-verse-center) (run-hooks (quote org-export-preprocess-after-blockquote-hook)) (unless (plist-get parameters :timestamps) (org-export-remove-timestamps)) (setq target-alist (org-export-attach-captions-and-attributes target-alist)) (org-export-mark-radio-links) (run-hooks (quote org-export-preprocess-after-radio-targets-hook)) (org-export-concatenate-multiline-links) (run-hooks (quote org-export-preprocess-before-normalizing-links-hook)) (org-export-normalize-links) ...) (and (buffer-name temp-buffer) (kill-buffer temp-buffer)))
  (save-current-buffer (set-buffer temp-buffer) (unwind-protect (progn (erase-buffer) (insert string) (setq case-fold-search t) (let ((inhibit-read-only t)) (remove-text-properties (point-min) (point-max) (quote (read-only t)))) (org-export-kill-licensed-text) (let ((org-inhibit-startup t)) (org-mode)) (setq case-fold-search t) (org-clone-local-variables source-buffer "^\\(org-\\|orgtbl-\\)") (org-install-letbind) (run-hooks (quote org-export-preprocess-hook)) (untabify (point-min) (point-max)) (org-export-handle-include-files-recurse) (run-hooks (quote org-export-preprocess-after-include-files-hook)) (org-export-remove-archived-trees archived-trees) (org-export-remove-comment-blocks-and-subtrees) (org-export-handle-export-tags (plist-get parameters :select-tags) (plist-get parameters :exc
 lude-tags)) (run-hooks (quote org-export-preprocess-after-tree-selection-hook)) (org-export-remove-tasks (plist-get parameters :tasks)) (when (plist-get parameters :footnotes) (org-footnote-
 normalize nil parameters)) (org-export-mark-list-end) (org-export-preprocess-apply-macros) (run-hooks (quote org-export-preprocess-after-macros-hook)) (org-export-blocks-preprocess) (org-export-mark-list-properties) (org-export-replace-src-segments-and-examples) (org-export-protect-colon-examples) (org-export-convert-protected-spaces) (setq target-alist (org-export-define-heading-targets target-alist)) (run-hooks (quote org-export-preprocess-after-headline-targets-hook)) (org-export-remember-html-container-classes) (org-export-remove-or-extract-drawers drawers (plist-get parameters :drawers)) (when (plist-get parameters :skip-before-1st-heading) (goto-char (point-min)) (when (re-search-forward "^\\(#.*\n\\)?\\*+[ 	]" nil t) (delete-region (point-min) (match-beginning 0)) (goto-char (point
 -min)) (insert "\n"))) (when (plist-get parameters :add-text) (goto-char (point-min)) (insert (plist-get parameters :add-text) "\n")) (org-export-remove-headline-metadata parameters) (setq t
 arget-alist (org-export-handle-invisible-targets target-alist)) (run-hooks (quote org-export-preprocess-before-selecting-backend-code-hook)) (org-export-select-backend-specific-text) (org-export-protect-quoted-subtrees) (org-export-remove-clock-lines) (org-export-protect-verbatim) (org-export-mark-blockquote-verse-center) (run-hooks (quote org-export-preprocess-after-blockquote-hook)) (unless (plist-get parameters :timestamps) (org-export-remove-timestamps)) (setq target-alist (org-export-attach-captions-and-attributes target-alist)) (org-export-mark-radio-links) (run-hooks (quote org-export-preprocess-after-radio-targets-hook)) (org-export-concatenate-multiline-links) (run-hooks (quote org-export-preprocess-before-normalizing-links-hook)) (org-export-normalize-links) ...) (and (buffer-na
 me temp-buffer) (kill-buffer temp-buffer))))
  (with-current-buffer temp-buffer (unwind-protect (progn (erase-buffer) (insert string) (setq case-fold-search t) (let ((inhibit-read-only t)) (remove-text-properties (point-min) (point-max) (quote (read-only t)))) (org-export-kill-licensed-text) (let ((org-inhibit-startup t)) (org-mode)) (setq case-fold-search t) (org-clone-local-variables source-buffer "^\\(org-\\|orgtbl-\\)") (org-install-letbind) (run-hooks (quote org-export-preprocess-hook)) (untabify (point-min) (point-max)) (org-export-handle-include-files-recurse) (run-hooks (quote org-export-preprocess-after-include-files-hook)) (org-export-remove-archived-trees archived-trees) (org-export-remove-comment-blocks-and-subtrees) (org-export-handle-export-tags (plist-get parameters :select-tags) (plist-get parameters :exclude-tags)) (
 run-hooks (quote org-export-preprocess-after-tree-selection-hook)) (org-export-remove-tasks (plist-get parameters :tasks)) (when (plist-get parameters :footnotes) (org-footnote-normalize nil
  parameters)) (org-export-mark-list-end) (org-export-preprocess-apply-macros) (run-hooks (quote org-export-preprocess-after-macros-hook)) (org-export-blocks-preprocess) (org-export-mark-list-properties) (org-export-replace-src-segments-and-examples) (org-export-protect-colon-examples) (org-export-convert-protected-spaces) (setq target-alist (org-export-define-heading-targets target-alist)) (run-hooks (quote org-export-preprocess-after-headline-targets-hook)) (org-export-remember-html-container-classes) (org-export-remove-or-extract-drawers drawers (plist-get parameters :drawers)) (when (plist-get parameters :skip-before-1st-heading) (goto-char (point-min)) (when (re-search-forward "^\\(#.*\n\\)?\\*+[ 	]" nil t) (delete-region (point-min) (match-beginning 0)) (goto-char (point-min)) (inser
 t "\n"))) (when (plist-get parameters :add-text) (goto-char (point-min)) (insert (plist-get parameters :add-text) "\n")) (org-export-remove-headline-metadata parameters) (setq target-alist (
 org-export-handle-invisible-targets target-alist)) (run-hooks (quote org-export-preprocess-before-selecting-backend-code-hook)) (org-export-select-backend-specific-text) (org-export-protect-quoted-subtrees) (org-export-remove-clock-lines) (org-export-protect-verbatim) (org-export-mark-blockquote-verse-center) (run-hooks (quote org-export-preprocess-after-blockquote-hook)) (unless (plist-get parameters :timestamps) (org-export-remove-timestamps)) (setq target-alist (org-export-attach-captions-and-attributes target-alist)) (org-export-mark-radio-links) (run-hooks (quote org-export-preprocess-after-radio-targets-hook)) (org-export-concatenate-multiline-links) (run-hooks (quote org-export-preprocess-before-normalizing-links-hook)) (org-export-normalize-links) ...) (and (buffer-name temp-buffe
 r) (kill-buffer temp-buffer))))
  (let ((temp-buffer (generate-new-buffer " *temp*"))) (with-current-buffer temp-buffer (unwind-protect (progn (erase-buffer) (insert string) (setq case-fold-search t) (let ((inhibit-read-only t)) (remove-text-properties (point-min) (point-max) (quote (read-only t)))) (org-export-kill-licensed-text) (let ((org-inhibit-startup t)) (org-mode)) (setq case-fold-search t) (org-clone-local-variables source-buffer "^\\(org-\\|orgtbl-\\)") (org-install-letbind) (run-hooks (quote org-export-preprocess-hook)) (untabify (point-min) (point-max)) (org-export-handle-include-files-recurse) (run-hooks (quote org-export-preprocess-after-include-files-hook)) (org-export-remove-archived-trees archived-trees) (org-export-remove-comment-blocks-and-subtrees) (org-export-handle-export-tags (plist-get parameters 
 :select-tags) (plist-get parameters :exclude-tags)) (run-hooks (quote org-export-preprocess-after-tree-selection-hook)) (org-export-remove-tasks (plist-get parameters :tasks)) (when (plist-g
 et parameters :footnotes) (org-footnote-normalize nil parameters)) (org-export-mark-list-end) (org-export-preprocess-apply-macros) (run-hooks (quote org-export-preprocess-after-macros-hook)) (org-export-blocks-preprocess) (org-export-mark-list-properties) (org-export-replace-src-segments-and-examples) (org-export-protect-colon-examples) (org-export-convert-protected-spaces) (setq target-alist (org-export-define-heading-targets target-alist)) (run-hooks (quote org-export-preprocess-after-headline-targets-hook)) (org-export-remember-html-container-classes) (org-export-remove-or-extract-drawers drawers (plist-get parameters :drawers)) (when (plist-get parameters :skip-before-1st-heading) (goto-char (point-min)) (when (re-search-forward "^\\(#.*\n\\)?\\*+[ 	]" nil t) (delete-region (point-min
 ) (match-beginning 0)) (goto-char (point-min)) (insert "\n"))) (when (plist-get parameters :add-text) (goto-char (point-min)) (insert (plist-get parameters :add-text) "\n")) (org-export-remo
 ve-headline-metadata parameters) (setq target-alist (org-export-handle-invisible-targets target-alist)) (run-hooks (quote org-export-preprocess-before-selecting-backend-code-hook)) (org-export-select-backend-specific-text) (org-export-protect-quoted-subtrees) (org-export-remove-clock-lines) (org-export-protect-verbatim) (org-export-mark-blockquote-verse-center) (run-hooks (quote org-export-preprocess-after-blockquote-hook)) (unless (plist-get parameters :timestamps) (org-export-remove-timestamps)) (setq target-alist (org-export-attach-captions-and-attributes target-alist)) (org-export-mark-radio-links) (run-hooks (quote org-export-preprocess-after-radio-targets-hook)) (org-export-concatenate-multiline-links) (run-hooks (quote org-export-preprocess-before-normalizing-links-hook)) (org-expo
 rt-normalize-links) ...) (and (buffer-name temp-buffer) (kill-buffer temp-buffer)))))
  (with-temp-buffer (erase-buffer) (insert string) (setq case-fold-search t) (let ((inhibit-read-only t)) (remove-text-properties (point-min) (point-max) (quote (read-only t)))) (org-export-kill-licensed-text) (let ((org-inhibit-startup t)) (org-mode)) (setq case-fold-search t) (org-clone-local-variables source-buffer "^\\(org-\\|orgtbl-\\)") (org-install-letbind) (run-hooks (quote org-export-preprocess-hook)) (untabify (point-min) (point-max)) (org-export-handle-include-files-recurse) (run-hooks (quote org-export-preprocess-after-include-files-hook)) (org-export-remove-archived-trees archived-trees) (org-export-remove-comment-blocks-and-subtrees) (org-export-handle-export-tags (plist-get parameters :select-tags) (plist-get parameters :exclude-tags)) (run-hooks (quote org-export-preprocess
 -after-tree-selection-hook)) (org-export-remove-tasks (plist-get parameters :tasks)) (when (plist-get parameters :footnotes) (org-footnote-normalize nil parameters)) (org-export-mark-list-en
 d) (org-export-preprocess-apply-macros) (run-hooks (quote org-export-preprocess-after-macros-hook)) (org-export-blocks-preprocess) (org-export-mark-list-properties) (org-export-replace-src-segments-and-examples) (org-export-protect-colon-examples) (org-export-convert-protected-spaces) (setq target-alist (org-export-define-heading-targets target-alist)) (run-hooks (quote org-export-preprocess-after-headline-targets-hook)) (org-export-remember-html-container-classes) (org-export-remove-or-extract-drawers drawers (plist-get parameters :drawers)) (when (plist-get parameters :skip-before-1st-heading) (goto-char (point-min)) (when (re-search-forward "^\\(#.*\n\\)?\\*+[ 	]" nil t) (delete-region (point-min) (match-beginning 0)) (goto-char (point-min)) (insert "\n"))) (when (plist-get parameters 
 :add-text) (goto-char (point-min)) (insert (plist-get parameters :add-text) "\n")) (org-export-remove-headline-metadata parameters) (setq target-alist (org-export-handle-invisible-targets ta
 rget-alist)) (run-hooks (quote org-export-preprocess-before-selecting-backend-code-hook)) (org-export-select-backend-specific-text) (org-export-protect-quoted-subtrees) (org-export-remove-clock-lines) (org-export-protect-verbatim) (org-export-mark-blockquote-verse-center) (run-hooks (quote org-export-preprocess-after-blockquote-hook)) (unless (plist-get parameters :timestamps) (org-export-remove-timestamps)) (setq target-alist (org-export-attach-captions-and-attributes target-alist)) (org-export-mark-radio-links) (run-hooks (quote org-export-preprocess-after-radio-targets-hook)) (org-export-concatenate-multiline-links) (run-hooks (quote org-export-preprocess-before-normalizing-links-hook)) (org-export-normalize-links) ...)
  (let* ((org-export-current-backend (or (plist-get parameters :for-backend) org-export-current-backend)) (archived-trees (plist-get parameters :archived-trees)) (inhibit-read-only t) (drawers org-drawers) (source-buffer (current-buffer)) target-alist rtn) (setq org-export-target-aliases nil org-export-preferred-target-alist nil org-export-id-target-alist nil org-export-code-refs nil) (with-temp-buffer (erase-buffer) (insert string) (setq case-fold-search t) (let ((inhibit-read-only t)) (remove-text-properties (point-min) (point-max) (quote (read-only t)))) (org-export-kill-licensed-text) (let ((org-inhibit-startup t)) (org-mode)) (setq case-fold-search t) (org-clone-local-variables source-buffer "^\\(org-\\|orgtbl-\\)") (org-install-letbind) (run-hooks (quote org-export-preprocess-hook)) 
 (untabify (point-min) (point-max)) (org-export-handle-include-files-recurse) (run-hooks (quote org-export-preprocess-after-include-files-hook)) (org-export-remove-archived-trees archived-tre
 es) (org-export-remove-comment-blocks-and-subtrees) (org-export-handle-export-tags (plist-get parameters :select-tags) (plist-get parameters :exclude-tags)) (run-hooks (quote org-export-preprocess-after-tree-selection-hook)) (org-export-remove-tasks (plist-get parameters :tasks)) (when (plist-get parameters :footnotes) (org-footnote-normalize nil parameters)) (org-export-mark-list-end) (org-export-preprocess-apply-macros) (run-hooks (quote org-export-preprocess-after-macros-hook)) (org-export-blocks-preprocess) (org-export-mark-list-properties) (org-export-replace-src-segments-and-examples) (org-export-protect-colon-examples) (org-export-convert-protected-spaces) (setq target-alist (org-export-define-heading-targets target-alist)) (run-hooks (quote org-export-preprocess-after-headline-tar
 gets-hook)) (org-export-remember-html-container-classes) (org-export-remove-or-extract-drawers drawers (plist-get parameters :drawers)) (when (plist-get parameters :skip-before-1st-heading) 
 (goto-char (point-min)) (when (re-search-forward "^\\(#.*\n\\)?\\*+[ 	]" nil t) (delete-region (point-min) (match-beginning 0)) (goto-char (point-min)) (insert "\n"))) (when (plist-get parameters :add-text) (goto-char (point-min)) (insert (plist-get parameters :add-text) "\n")) (org-export-remove-headline-metadata parameters) (setq target-alist (org-export-handle-invisible-targets target-alist)) (run-hooks (quote org-export-preprocess-before-selecting-backend-code-hook)) (org-export-select-backend-specific-text) (org-export-protect-quoted-subtrees) (org-export-remove-clock-lines) (org-export-protect-verbatim) (org-export-mark-blockquote-verse-center) (run-hooks (quote org-export-preprocess-after-blockquote-hook)) (unless (plist-get parameters :timestamps) (org-export-remove-timestamps)) (
 setq target-alist (org-export-attach-captions-and-attributes target-alist)) (org-export-mark-radio-links) (run-hooks (quote org-export-preprocess-after-radio-targets-hook)) (org-export-conca
 tenate-multiline-links) (run-hooks (quote org-export-preprocess-before-normalizing-links-hook)) (org-export-normalize-links) ...) rtn)
  org-export-preprocess-string(#("#+LATEX_CLASS: article\n#+LaTeX_HEADER: \\usepackage{minted}\n#+LaTeX_HEADER: \\usemintedstyle{emacs}\n#+LaTeX_HEADER: \\newminted{common-lisp}{fontsize=\\footnotesize}\n\n#+name: setup-minted\n#+begin_src emacs-lisp :exports both :results silent\n     (setq org-export-latex-listings 'minted)\n     (setq org-export-latex-custom-lang-environments\n           '(\n            (emacs-lisp \"common-lispcode\")\n             ))\n     (setq org-export-latex-minted-options\n           '((\"frame\" \"lines\")\n             (\"fontsize\" \"\\\\scriptsize\")\n             (\"linenos\" \"\")))\n     (setq org-latex-to-pdf-process\n           '(\"pdflatex -shell-escape -interaction nonstopmode -output-directory %o %f\"\n             \"pdflatex -shell-escape -interactio
 n nonstopmode -output-directory %o %f\"\n             \"pdflatex -shell-escape -interaction nonstopmode -output-directory %o %f\"))\n#+end_src\n\n#+name: another-listing\n#+begin_src python 
 :exports code\n   x = str(y)\n#+end_src\n" 0 22 (fontified t font-lock-fontified t face org-meta-line) 22 23 (fontified t font-lock-fontified t face org-meta-line) 23 58 (fontified t font-lock-fontified t face org-meta-line) 58 59 (fontified t font-lock-fontified t face org-meta-line) 59 97 (fontified t font-lock-fontified t face org-meta-line) 97 98 (fontified t font-lock-fontified t face org-meta-line) 98 161 (fontified t font-lock-fontified t face org-meta-line) 161 162 (fontified t font-lock-fontified t face org-meta-line) 162 163 (fontified t :org-license-to-kill t) 163 183 (fontified t font-lock-fontified t face org-meta-line) 183 184 (fontified t font-lock-fontified t face org-meta-line) 184 236 (fontified t font-lock-fontified t face org-block-begin-line font-lock-multiline t) 236
  237 (fontified t font-lock-fontified t font-lock-multiline t face org-block-begin-line) 237 524 (fontified t font-lock-fontified t font-lock-multiline t face org-block :org-license-to-kill 
 t) 524 764 (fontified t font-lock-fontified t font-lock-multiline t face org-block :org-license-to-kill t) 764 852 (fontified t font-lock-fontified t font-lock-multiline t face org-block :org-license-to-kill t) 852 853 (fontified t font-lock-fontified t font-lock-multiline t face org-block :org-license-to-kill t) 853 862 (fontified t font-lock-fontified t face org-block-end-line font-lock-multiline t) 862 863 (fontified t font-lock-fontified t face org-block-end-line) 863 864 (fontified t :org-license-to-kill t) 864 887 (fontified t font-lock-fontified t face org-meta-line) 887 888 (fontified t font-lock-fontified t face org-meta-line) 888 920 (fontified t font-lock-fontified t face org-block-begin-line font-lock-multiline t) 920 921 (fontified t font-lock-fontified t font-lock-multiline 
 t face org-block-begin-line) 921 934 (fontified t font-lock-fontified t font-lock-multiline t face org-block :org-license-to-kill t) 934 935 (fontified t font-lock-fontified t font-lock-mult
 iline t face org-block :org-license-to-kill t) 935 944 (fontified t font-lock-fontified t face org-block-end-line font-lock-multiline t) 944 945 (fontified t rear-nonsticky t face org-block-end-line)) :emph-multiline t :for-backend latex :comments nil :tags t :priority nil :footnotes t :drawers t :timestamps t :todo-keywords t :tasks t :add-text nil :skip-before-1st-heading nil :select-tags ("export") :exclude-tags ("noexport") :LaTeX-fragments nil)
  (let* ((wcf (current-window-configuration)) (opt-plist (org-export-process-option-filters org-export-latex-options-plist)) (region-p (org-region-active-p)) (rbeg (and region-p (region-beginning))) (rend (and region-p (region-end))) (subtree-p (if (plist-get opt-plist :ignore-subtree-p) nil (when region-p (save-excursion (goto-char rbeg) (and (org-at-heading-p) (>= ... rend)))))) (opt-plist (setq org-export-opt-plist (if subtree-p (org-export-add-subtree-options opt-plist rbeg) opt-plist))) (org-export-latex-options-plist (setq org-export-opt-plist opt-plist)) (org-current-export-dir (or pub-dir (org-export-directory :html opt-plist))) (org-current-export-file buffer-file-name) (title (or (and subtree-p (org-export-get-title-from-subtree)) (plist-get opt-plist :title) (and (not (plist-get
  opt-plist :skip-before-1st-heading)) (org-export-grab-title-from-buffer)) (and buffer-file-name (file-name-sans-extension (file-name-nondirectory buffer-file-name))) "No Title")) (filename 
 (and (not to-buffer) (concat (file-name-as-directory (or pub-dir (org-export-directory :LaTeX ext-plist))) (file-name-sans-extension (or (and subtree-p ...) (file-name-nondirectory ...))) ".tex"))) (filename (and filename (if (equal (file-truename filename) (file-truename (or buffer-file-name "dummy.org"))) (concat filename ".tex") filename))) (auto-insert nil) (TeX-master t) (buffer (if to-buffer (cond ((eq to-buffer (quote string)) (get-buffer-create "*Org LaTeX Export*")) (t (get-buffer-create to-buffer))) (find-file-noselect filename))) (odd org-odd-levels-only) (header (org-export-latex-make-header title opt-plist)) (skip (cond (subtree-p nil) (region-p nil) (t (plist-get opt-plist :skip-before-1st-heading)))) (text (plist-get opt-plist :text)) (org-export-preprocess-hook (cons (\` (
 lambda nil (org-set-local (quote org-complex-heading-regexp) (\, org-export-latex-complex-heading-re)))) org-export-preprocess-hook)) (first-lines (if skip "" (org-export-latex-first-lines o
 pt-plist (if subtree-p (save-excursion (goto-char rbeg) (point-at-bol 2)) rbeg) (if region-p rend)))) (coding-system (and (boundp (quote buffer-file-coding-system)) buffer-file-coding-system)) (coding-system-for-write (or org-export-latex-coding-system coding-system)) (save-buffer-coding-system (or org-export-latex-coding-system coding-system)) (region (buffer-substring (if region-p (region-beginning) (point-min)) (if region-p (region-end) (point-max)))) (text (and text (string-match "\\S-" text) (org-export-preprocess-string text :emph-multiline t :for-backend (quote latex) :comments nil :tags (plist-get opt-plist :tags) :priority (plist-get opt-plist :priority) :footnotes (plist-get opt-plist :footnotes) :drawers (plist-get opt-plist :drawers) :timestamps (plist-get opt-plist :timestamp
 s) :todo-keywords (plist-get opt-plist :todo-keywords) :tasks (plist-get opt-plist :tasks) :add-text nil :skip-before-1st-heading skip :select-tags nil :exclude-tags nil :LaTeX-fragments nil
 ))) (string-for-export (org-export-preprocess-string region :emph-multiline t :for-backend (quote latex) :comments nil :tags (plist-get opt-plist :tags) :priority (plist-get opt-plist :priority) :footnotes (plist-get opt-plist :footnotes) :drawers (plist-get opt-plist :drawers) :timestamps (plist-get opt-plist :timestamps) :todo-keywords (plist-get opt-plist :todo-keywords) :tasks (plist-get opt-plist :tasks) :add-text (if (eq to-buffer (quote string)) nil text) :skip-before-1st-heading skip :select-tags (plist-get opt-plist :select-tags) :exclude-tags (plist-get opt-plist :exclude-tags) :LaTeX-fragments nil))) (set-buffer buffer) (erase-buffer) (org-install-letbind) (and (fboundp (quote set-buffer-file-coding-system)) (set-buffer-file-coding-system coding-system-for-write)) (unless (or (
 eq to-buffer (quote string)) body-only) (insert header)) (when (and text (not (eq to-buffer (quote string)))) (insert (org-export-latex-content text (quote (lists tables fixed-width keywords
 ))) "\n\n")) (unless (or skip (string-match "^\\*" first-lines)) (insert first-lines)) (org-export-latex-global (with-temp-buffer (insert string-for-export) (goto-char (point-min)) (when (re-search-forward "^\\(\\*+\\) " nil t) (let* ((asters (length ...)) (level (if odd ... ...))) (setq org-export-latex-add-level (if odd (1- ...) (1- asters))) (org-export-latex-parse-global level odd))))) (unless body-only (insert "\n\\end{document}")) (goto-char (point-min)) (while (re-search-forward "^[ 	]*\\\\item\\([ 	]+\\)\\[" nil t) (delete-region (match-beginning 1) (match-end 1))) (goto-char (point-min)) (when (re-search-forward "\\[TABLE-OF-CONTENTS\\]" nil t) (goto-char (point-min)) (while (re-search-forward "\\\\tableofcontents\\>[ 	]*\n?" nil t) (replace-match "")) (goto-char (point-min)) (an
 d (re-search-forward "\\[TABLE-OF-CONTENTS\\]" nil t) (replace-match "\\tableofcontents" t t))) (goto-char (point-min)) (while (re-search-forward "^[ 	]*\\\\item\\>.*\\(\\\\\\\\\\)[ 	]*\\(\n
 \\\\label.*\\)*\n\\\\begin" nil t) (delete-region (match-beginning 1) (match-end 1))) (goto-char (point-min)) (while (re-search-forward "^[ 	]*\\\\item\\>.*\\(\\\\\\\\\\)[ 	]*\\(\n\\\\label.*\\)*" nil t) (if (looking-at "[\n 	]+") (replace-match "\n"))) (run-hooks (quote org-export-latex-final-hook)) (if to-buffer (unless (eq major-mode (quote latex-mode)) (latex-mode)) (save-buffer)) (org-export-latex-fix-inputenc) (run-hooks (quote org-export-latex-after-save-hook)) (goto-char (point-min)) (or (org-export-push-to-kill-ring "LaTeX") (message "Exporting to LaTeX...done")) (prog1 (if (eq to-buffer (quote string)) (prog1 (buffer-substring (point-min) (point-max)) (kill-buffer (current-buffer))) (current-buffer)) (set-window-configuration wcf)))
  org-export-as-latex(nil nil nil nil nil nil)
  (let* ((wconfig (current-window-configuration)) (lbuf (org-export-as-latex arg hidden ext-plist to-buffer body-only pub-dir)) (file (buffer-file-name lbuf)) (base (file-name-sans-extension (buffer-file-name lbuf))) (pdffile (concat base ".pdf")) (cmds org-latex-to-pdf-process) (outbuf (get-buffer-create "*Org PDF LaTeX Output*")) (bibtex-p (with-current-buffer lbuf (save-excursion (goto-char (point-min)) (re-search-forward "\\\\bibliography{" nil t)))) cmd output-dir errors) (with-current-buffer outbuf (erase-buffer)) (message (concat "Processing LaTeX file " file "...")) (setq output-dir (file-name-directory file)) (with-current-buffer lbuf (save-excursion (if (and cmds (symbolp cmds)) (funcall cmds (shell-quote-argument file)) (while cmds (setq cmd (pop cmds)) (while (string-match "%b"
  cmd) (setq cmd (replace-match ... t t cmd))) (while (string-match "%f" cmd) (setq cmd (replace-match ... t t cmd))) (while (string-match "%o" cmd) (setq cmd (replace-match ... t t cmd))) (s
 hell-command cmd outbuf))))) (message (concat "Processing LaTeX file " file "...done")) (setq errors (org-export-latex-get-error outbuf)) (if (not (file-exists-p pdffile)) (error (concat "PDF file " pdffile " was not produced" (if errors (concat ":" errors "") ""))) (set-window-configuration wconfig) (when org-export-pdf-remove-logfiles (dolist (ext org-export-pdf-logfiles) (setq file (concat base "." ext)) (and (file-exists-p file) (delete-file file)))) (message (concat "Exporting to PDF...done" (if errors (concat ", with some errors:" errors) ""))) pdffile))
  org-export-as-pdf(nil)
  (let ((pdffile (org-export-as-pdf arg))) (if pdffile (progn (org-open-file pdffile) (when org-export-kill-product-buffer-when-displayed (kill-buffer (find-buffer-visiting (concat (file-name-sans-extension ...) ".tex"))))) (error "PDF file was not produced")))
  org-export-as-pdf-and-open(nil)
  call-interactively(org-export-as-pdf-and-open)
  (if (and bg (nth 2 ass) (not (buffer-base-buffer)) (not (org-region-active-p))) (let ((p (start-process (concat "Exporting " (file-name-nondirectory (buffer-file-name))) "*Org Processes*" (expand-file-name invocation-name invocation-directory) "-batch" "-l" user-init-file "--eval" "(require 'org-exp)" "--eval" "(setq org-wait .2)" (buffer-file-name) "-f" (symbol-name (nth 1 ass))))) (set-process-sentinel p (quote org-export-process-sentinel)) (message "Background process \"%s\": started" p)) (if subtree-p (progn (org-mark-subtree) (org-activate-mark))) (call-interactively (nth 1 ass)) (when (and bpos (get-buffer-window cbuf)) (let ((cw (selected-window))) (select-window (get-buffer-window cbuf)) (goto-char cpos) (deactivate-mark) (select-window cw))))
  (let* ((bg (org-xor (equal arg (quote (16))) org-export-run-in-background)) (subtree-p (or (org-region-active-p) (eq org-export-initial-scope (quote subtree)))) (help "[t]   insert the export option template\n[v]   limit export to visible part of outline tree\n[1]   switch buffer/subtree export\n[SPC] publish enclosing subtree (with LaTeX_CLASS or EXPORT_FILE_NAME prop)\n\n[a/n/u] export as ASCII/Latin-1/UTF-8         [A/N/U] to temporary buffer\n\n[h] export as HTML      [H] to temporary buffer   [R] export region\n[b] export as HTML and open in browser\n\n[l] export as LaTeX     [L] to temporary buffer\n[p] export as LaTeX and process to PDF            [d] ... and open PDF file\n\n[D] export as DocBook   [V] export as DocBook, process to PDF, and open\n\n[o] export as OpenDocument Text
                    [O] ... and open\n\n[j] export as TaskJuggler                         [J] ... and open\n\n[m] export as Freemind mind map\n[x] export as XOXO\n[g] export using Wes Hardake
 r's generic exporter\n\n[i] export current file as iCalendar file\n[I] export all agenda files as iCalendar files   [c] ...as one combined file\n\n[F] publish current file          [P] publish current project\n[X] publish a project...          [E] publish every projects") (cmds (quote ((116 org-insert-export-options-template nil) (118 org-export-visible nil) (97 org-export-as-ascii t) (65 org-export-as-ascii-to-buffer t) (110 org-export-as-latin1 t) (78 org-export-as-latin1-to-buffer t) (117 org-export-as-utf8 t) (85 org-export-as-utf8-to-buffer t) (104 org-export-as-html t) (98 org-export-as-html-and-open t) (72 org-export-as-html-to-buffer nil) (82 org-export-region-as-html nil) (120 org-export-as-xoxo t) (103 org-export-generic t) (68 org-export-as-docbook t) (86 org-export-as-docbook-
 pdf-and-open t) (111 org-export-as-odt t) (79 org-export-as-odt-and-open t) (106 org-export-as-taskjuggler t) (74 org-export-as-taskjuggler-and-open t) (109 org-export-as-freemind t) (108 or
 g-export-as-latex t) (112 org-export-as-pdf t) (100 org-export-as-pdf-and-open t) (76 org-export-as-latex-to-buffer nil) (105 org-export-icalendar-this-file t) (73 org-export-icalendar-all-agenda-files t) (99 org-export-icalendar-combine-agenda-files t) (70 org-publish-current-file t) (80 org-publish-current-project t) (88 org-publish t) (69 org-publish-all t)))) r1 r2 ass (cpos (point)) (cbuf (current-buffer)) bpos) (save-excursion (save-window-excursion (if subtree-p (message "Export subtree: ") (message "Export buffer: ")) (delete-other-windows) (with-output-to-temp-buffer "*Org Export/Publishing Help*" (princ help)) (org-fit-window-to-buffer (get-buffer-window "*Org Export/Publishing Help*")) (while (eq (setq r1 (read-char-exclusive)) 49) (cond (subtree-p (setq subtree-p nil) (message
  "Export buffer: ")) ((not subtree-p) (setq subtree-p t) (setq bpos (point)) (message "Export subtree: ")))) (when (eq r1 32) (let ((case-fold-search t) (end (save-excursion ... ...))) (outl
 ine-next-heading) (if (re-search-backward "^[ 	]+\\(:latex_class:\\|:export_title:\\|:export_file_name:\\)[ 	]+\\S-" end t) (progn (org-back-to-heading t) (setq subtree-p t) (setq bpos ...) (message "Select command (for subtree): ") (setq r1 ...)) (error "No enclosing node with LaTeX_CLASS or EXPORT_TITLE or EXPORT_FILE_NAME")))))) (if (fboundp (quote redisplay)) (redisplay)) (and bpos (goto-char bpos)) (setq r2 (if (< r1 27) (+ r1 96) r1)) (unless (setq ass (assq r2 cmds)) (error "No command associated with key %c" r1)) (if (and bg (nth 2 ass) (not (buffer-base-buffer)) (not (org-region-active-p))) (let ((p (start-process (concat "Exporting " (file-name-nondirectory ...)) "*Org Processes*" (expand-file-name invocation-name invocation-directory) "-batch" "-l" user-init-file "--eval" "(req
 uire 'org-exp)" "--eval" "(setq org-wait .2)" (buffer-file-name) "-f" (symbol-name (nth 1 ass))))) (set-process-sentinel p (quote org-export-process-sentinel)) (message "Background process \
 "%s\": started" p)) (if subtree-p (progn (org-mark-subtree) (org-activate-mark))) (call-interactively (nth 1 ass)) (when (and bpos (get-buffer-window cbuf)) (let ((cw (selected-window))) (select-window (get-buffer-window cbuf)) (goto-char cpos) (deactivate-mark) (select-window cw)))))
  org-export(nil)
  call-interactively(org-export nil nil)