Re: Bug: Exception when trying to export inlined-code [8.3.4 (8.3.4-9-gfda14f-elpa @ ~/.emacs.d/elpa/org-20160307/)]

[Shlomi Vaknin <shlomivaknin@gmail.com>]

[-- Attachment #1: Type: text/plain, Size: 65032 bytes --]

Hey Nicholas,

Thanks for trying to help! Setting org-element-use-cache to nil did the
trick, it now export just fine in both elpa version of org and on master,
thanks!

Without setting it to nil, here is the complete backtrace of an uncompiled
org (I simply erased all elc files, that sufficient, right?)

Debugger entered--Lisp error: (wrong-type-argument integer-or-marker-p nil)
  goto-char(nil)
  (progn (goto-char contents-end) (skip-chars-forward "
\n" limit) (if (= (point) limit) limit (line-beginning-position)))
  (let* ((struct (or structure (org-element--list-struct limit))) (type
(cond ((org-looking-at-p "[ ]*[A-Za-z0-9]") (quote ordered)) ((nth 5 (assq
(point) struct)) (quote descriptive)) (t (quote unordered))))
(contents-begin (point)) (begin (car affiliated)) (contents-end (let*
((item (assq contents-begin struct)) (ind (nth 1 item)) (pos (nth 6 item)))
(while (and (setq item (assq pos struct)) (= (nth 1 item) ind)) (setq pos
(nth 6 item))) pos)) (end (progn (goto-char contents-end)
(skip-chars-forward "
\n" limit) (if (= (point) limit) limit (line-beginning-position))))) (list
(quote plain-list) (nconc (list :type type :begin begin :end end
:contents-begin contents-begin :contents-end contents-end :structure struct
:post-blank (count-lines contents-end end) :post-affiliated contents-begin)
(cdr affiliated))))
  (save-excursion (let* ((struct (or structure (org-element--list-struct
limit))) (type (cond ((org-looking-at-p "[ ]*[A-Za-z0-9]") (quote ordered))
((nth 5 (assq ... struct)) (quote descriptive)) (t (quote unordered))))
(contents-begin (point)) (begin (car affiliated)) (contents-end (let*
((item (assq contents-begin struct)) (ind (nth 1 item)) (pos (nth 6 item)))
(while (and (setq item ...) (= ... ind)) (setq pos (nth 6 item))) pos))
(end (progn (goto-char contents-end) (skip-chars-forward "
\n" limit) (if (= (point) limit) limit (line-beginning-position))))) (list
(quote plain-list) (nconc (list :type type :begin begin :end end
:contents-begin contents-begin :contents-end contents-end :structure struct
:post-blank (count-lines contents-end end) :post-affiliated contents-begin)
(cdr affiliated)))))
  org-element-plain-list-parser(122 (86) ((28 2 "- " nil nil nil 51) (51 2
"-" nil nil nil 55) (55 2 "-" nil nil nil 59) (59 2 "-" nil nil nil 63) (63
2 "- " nil nil nil 99) (99 2 "- " nil nil nil 135) (135 2 "- " nil nil nil
158)))
  (cond ((and (cdr affiliated) (>= (point) limit)) (goto-char (car
affiliated)) (org-element-keyword-parser limit nil)) ((looking-at
org-element--latex-begin-environment) (org-element-latex-environment-parser
limit affiliated)) ((looking-at org-drawer-regexp)
(org-element-drawer-parser limit affiliated)) ((looking-at "[ ]*:\\(
\\|$\\)") (org-element-fixed-width-parser limit affiliated)) ((looking-at
"[ ]*#") (goto-char (match-end 0)) (cond ((looking-at "\\(?: \\|$\\)")
(beginning-of-line) (org-element-comment-parser limit affiliated))
((looking-at "\\+BEGIN_\\(\\S-+\\)") (beginning-of-line) (funcall (let*
((val ...)) (cond (... ...) (... ...) (... ...) (... ...) (... ...) (...
...) (... ...) (t ...))) limit affiliated)) ((looking-at "\\+CALL:")
(beginning-of-line) (org-element-babel-call-parser limit affiliated))
((looking-at "\\+BEGIN:? ") (beginning-of-line)
(org-element-dynamic-block-parser limit affiliated)) ((looking-at
"\\+\\S-+:") (beginning-of-line) (org-element-keyword-parser limit
affiliated)) (t (beginning-of-line) (org-element-paragraph-parser limit
affiliated)))) ((looking-at org-footnote-definition-re)
(org-element-footnote-definition-parser limit affiliated))
((looking-at "[ ]*-\\{5,\\}[
]*$") (org-element-horizontal-rule-parser limit affiliated)) ((looking-at
"%%(") (org-element-diary-sexp-parser limit affiliated)) ((looking-at
"[ ]*\\(|\\|\\+\\(-+\\+\\)+[
]*$\\)") (org-element-table-parser limit affiliated)) ((looking-at
(org-item-re)) (org-element-plain-list-parser limit affiliated (or
structure (org-element--list-struct limit)))) (t
(org-element-paragraph-parser limit affiliated)))
  (let ((affiliated (org-element--collect-affiliated-keywords limit)))
(cond ((and (cdr affiliated) (>= (point) limit)) (goto-char (car
affiliated)) (org-element-keyword-parser limit nil)) ((looking-at
org-element--latex-begin-environment) (org-element-latex-environment-parser
limit affiliated)) ((looking-at org-drawer-regexp)
(org-element-drawer-parser limit affiliated)) ((looking-at "[ ]*:\\(
\\|$\\)") (org-element-fixed-width-parser limit affiliated)) ((looking-at
"[ ]*#") (goto-char (match-end 0)) (cond ((looking-at "\\(?: \\|$\\)")
(beginning-of-line) (org-element-comment-parser limit affiliated))
((looking-at "\\+BEGIN_\\(\\S-+\\)") (beginning-of-line) (funcall (let*
(...) (cond ... ... ... ... ... ... ... ...)) limit affiliated))
((looking-at "\\+CALL:") (beginning-of-line) (org-element-babel-call-parser
limit affiliated)) ((looking-at "\\+BEGIN:? ") (beginning-of-line)
(org-element-dynamic-block-parser limit affiliated)) ((looking-at
"\\+\\S-+:") (beginning-of-line) (org-element-keyword-parser limit
affiliated)) (t (beginning-of-line) (org-element-paragraph-parser limit
affiliated)))) ((looking-at org-footnote-definition-re)
(org-element-footnote-definition-parser limit affiliated))
((looking-at "[ ]*-\\{5,\\}[
]*$") (org-element-horizontal-rule-parser limit affiliated)) ((looking-at
"%%(") (org-element-diary-sexp-parser limit affiliated)) ((looking-at
"[ ]*\\(|\\|\\+\\(-+\\+\\)+[
]*$\\)") (org-element-table-parser limit affiliated)) ((looking-at
(org-item-re)) (org-element-plain-list-parser limit affiliated (or
structure (org-element--list-struct limit)))) (t
(org-element-paragraph-parser limit affiliated))))
  (cond ((eq mode (quote item)) (org-element-item-parser limit structure
raw-secondary-p)) ((eq mode (quote table-row))
(org-element-table-row-parser limit)) ((eq mode (quote node-property))
(org-element-node-property-parser limit)) ((progn (defvar
org-called-with-limited-levels) (defvar org-outline-regexp) (defvar
outline-regexp) (defvar org-outline-regexp-bol) (let*
((org-called-with-limited-levels t) (org-outline-regexp
(org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp)
(org-outline-regexp-bol (concat "^" org-outline-regexp)))
(org-at-heading-p))) (org-element-headline-parser limit raw-secondary-p))
((eq mode (quote section)) (org-element-section-parser limit)) ((eq mode
(quote first-section)) (org-element-section-parser (or (save-excursion
(progn (defvar org-called-with-limited-levels) (defvar org-outline-regexp)
(defvar outline-regexp) (defvar org-outline-regexp-bol) (let* (... ... ...
...) (outline-next-heading)))) limit))) ((and (eq mode (quote planning))
(looking-at org-planning-line-re)) (org-element-planning-parser limit))
((and (memq mode (quote (planning property-drawer))) (looking-at
org-property-drawer-re)) (org-element-property-drawer-parser limit)) ((not
(bolp)) (org-element-paragraph-parser limit (list (point)))) ((looking-at
org-clock-line-re) (org-element-clock-parser limit)) ((org-at-heading-p)
(org-element-inlinetask-parser limit raw-secondary-p)) (t (let ((affiliated
(org-element--collect-affiliated-keywords limit))) (cond ((and (cdr
affiliated) (>= (point) limit)) (goto-char (car affiliated))
(org-element-keyword-parser limit nil)) ((looking-at
org-element--latex-begin-environment) (org-element-latex-environment-parser
limit affiliated)) ((looking-at org-drawer-regexp)
(org-element-drawer-parser limit affiliated)) ((looking-at "[ ]*:\\(
\\|$\\)") (org-element-fixed-width-parser limit affiliated)) ((looking-at
"[ ]*#") (goto-char (match-end 0)) (cond ((looking-at "\\(?: \\|$\\)")
(beginning-of-line) (org-element-comment-parser limit affiliated))
((looking-at "\\+BEGIN_\\(\\S-+\\)") (beginning-of-line) (funcall ... limit
affiliated)) ((looking-at "\\+CALL:") (beginning-of-line)
(org-element-babel-call-parser limit affiliated)) ((looking-at "\\+BEGIN:?
") (beginning-of-line) (org-element-dynamic-block-parser limit affiliated))
((looking-at "\\+\\S-+:") (beginning-of-line) (org-element-keyword-parser
limit affiliated)) (t (beginning-of-line) (org-element-paragraph-parser
limit affiliated)))) ((looking-at org-footnote-definition-re)
(org-element-footnote-definition-parser limit affiliated))
((looking-at "[ ]*-\\{5,\\}[
]*$") (org-element-horizontal-rule-parser limit affiliated)) ((looking-at
"%%(") (org-element-diary-sexp-parser limit affiliated)) ((looking-at
"[ ]*\\(|\\|\\+\\(-+\\+\\)+[
]*$\\)") (org-element-table-parser limit affiliated)) ((looking-at
(org-item-re)) (org-element-plain-list-parser limit affiliated (or
structure (org-element--list-struct limit)))) (t
(org-element-paragraph-parser limit affiliated))))))
  (let ((case-fold-search t) (raw-secondary-p (and granularity (not (eq
granularity (quote object)))))) (cond ((eq mode (quote item))
(org-element-item-parser limit structure raw-secondary-p)) ((eq mode (quote
table-row)) (org-element-table-row-parser limit)) ((eq mode (quote
node-property)) (org-element-node-property-parser limit)) ((progn (defvar
org-called-with-limited-levels) (defvar org-outline-regexp) (defvar
outline-regexp) (defvar org-outline-regexp-bol) (let*
((org-called-with-limited-levels t) (org-outline-regexp
(org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp)
(org-outline-regexp-bol (concat "^" org-outline-regexp)))
(org-at-heading-p))) (org-element-headline-parser limit raw-secondary-p))
((eq mode (quote section)) (org-element-section-parser limit)) ((eq mode
(quote first-section)) (org-element-section-parser (or (save-excursion
(progn (defvar org-called-with-limited-levels) (defvar org-outline-regexp)
(defvar outline-regexp) (defvar org-outline-regexp-bol) (let* ... ...)))
limit))) ((and (eq mode (quote planning)) (looking-at
org-planning-line-re)) (org-element-planning-parser limit)) ((and (memq
mode (quote (planning property-drawer))) (looking-at
org-property-drawer-re)) (org-element-property-drawer-parser limit)) ((not
(bolp)) (org-element-paragraph-parser limit (list (point)))) ((looking-at
org-clock-line-re) (org-element-clock-parser limit)) ((org-at-heading-p)
(org-element-inlinetask-parser limit raw-secondary-p)) (t (let ((affiliated
(org-element--collect-affiliated-keywords limit))) (cond ((and (cdr
affiliated) (>= ... limit)) (goto-char (car affiliated))
(org-element-keyword-parser limit nil)) ((looking-at
org-element--latex-begin-environment) (org-element-latex-environment-parser
limit affiliated)) ((looking-at org-drawer-regexp)
(org-element-drawer-parser limit affiliated)) ((looking-at "[ ]*:\\(
\\|$\\)") (org-element-fixed-width-parser limit affiliated)) ((looking-at
"[ ]*#") (goto-char (match-end 0)) (cond (... ... ...) (... ... ...) (...
... ...) (... ... ...) (... ... ...) (t ... ...))) ((looking-at
org-footnote-definition-re) (org-element-footnote-definition-parser limit
affiliated)) ((looking-at "[ ]*-\\{5,\\}[ ]*$")
(org-element-horizontal-rule-parser limit affiliated)) ((looking-at "%%(")
(org-element-diary-sexp-parser limit affiliated)) ((looking-at "[
]*\\(|\\|\\+\\(-+\\+\\)+[
]*$\\)") (org-element-table-parser limit affiliated)) ((looking-at
(org-item-re)) (org-element-plain-list-parser limit affiliated (or
structure ...))) (t (org-element-paragraph-parser limit affiliated)))))))
  (save-excursion (let ((case-fold-search t) (raw-secondary-p (and
granularity (not (eq granularity (quote object)))))) (cond ((eq mode (quote
item)) (org-element-item-parser limit structure raw-secondary-p)) ((eq mode
(quote table-row)) (org-element-table-row-parser limit)) ((eq mode (quote
node-property)) (org-element-node-property-parser limit)) ((progn (defvar
org-called-with-limited-levels) (defvar org-outline-regexp) (defvar
outline-regexp) (defvar org-outline-regexp-bol) (let*
((org-called-with-limited-levels t) (org-outline-regexp ...)
(outline-regexp org-outline-regexp) (org-outline-regexp-bol ...))
(org-at-heading-p))) (org-element-headline-parser limit raw-secondary-p))
((eq mode (quote section)) (org-element-section-parser limit)) ((eq mode
(quote first-section)) (org-element-section-parser (or (save-excursion
(progn ... ... ... ... ...)) limit))) ((and (eq mode (quote planning))
(looking-at org-planning-line-re)) (org-element-planning-parser limit))
((and (memq mode (quote (planning property-drawer))) (looking-at
org-property-drawer-re)) (org-element-property-drawer-parser limit)) ((not
(bolp)) (org-element-paragraph-parser limit (list (point)))) ((looking-at
org-clock-line-re) (org-element-clock-parser limit)) ((org-at-heading-p)
(org-element-inlinetask-parser limit raw-secondary-p)) (t (let ((affiliated
(org-element--collect-affiliated-keywords limit))) (cond ((and ... ...)
(goto-char ...) (org-element-keyword-parser limit nil)) ((looking-at
org-element--latex-begin-environment) (org-element-latex-environment-parser
limit affiliated)) ((looking-at org-drawer-regexp)
(org-element-drawer-parser limit affiliated)) ((looking-at "[ ]*:\\(
\\|$\\)") (org-element-fixed-width-parser limit affiliated)) ((looking-at
"[ ]*#") (goto-char ...) (cond ... ... ... ... ... ...)) ((looking-at
org-footnote-definition-re) (org-element-footnote-definition-parser limit
affiliated)) ((looking-at "[ ]*-\\{5,\\}[ ]*$")
(org-element-horizontal-rule-parser limit affiliated)) ((looking-at "%%(")
(org-element-diary-sexp-parser limit affiliated)) ((looking-at "[
]*\\(|\\|\\+\\(-+\\+\\)+[
]*$\\)") (org-element-table-parser limit affiliated)) ((looking-at ...)
(org-element-plain-list-parser limit affiliated ...)) (t
(org-element-paragraph-parser limit affiliated))))))))
  org-element--current-element(122 element nil ((28 2 "- " nil nil nil 51)
(51 2 "-" nil nil nil 55) (55 2 "-" nil nil nil 59) (59 2 "-" nil nil nil
63) (63 2 "- " nil nil nil 99) (99 2 "- " nil nil nil 135) (135 2 "- " nil
nil nil 158)))
  (setq element (org-element--current-element end (quote element) mode
(org-element-property :structure parent)))
  (if element nil (setq element (org-element--current-element end (quote
element) mode (org-element-property :structure parent)))
(org-element-put-property element :parent parent) (org-element--cache-put
element))
  (while t (if syncp (progn (cond ((= (point) pos) (throw (quote exit)
parent)) ((org-element--cache-interrupt-p time-limit) (throw (quote
interrupt) nil))))) (if element nil (setq element
(org-element--current-element end (quote element) mode
(org-element-property :structure parent))) (org-element-put-property
element :parent parent) (org-element--cache-put element)) (let ((elem-end
(org-element-property :end element)) (type (org-element-type element)))
(cond ((and (<= elem-end pos) (/= (point-max) elem-end)) (goto-char
elem-end) (setq mode (org-element--next-mode type nil))) ((not (memq type
org-element-greater-elements)) (throw (quote exit) element)) ((let ((cbeg
(org-element-property :contents-begin element)) (cend (org-element-property
:contents-end element))) (if (or syncp (and cbeg cend ... ...)) (progn
(goto-char ...) (setq next nil mode ... parent element end cend))))) (t
(throw (quote exit) element)))) (setq element nil))
  (let ((end (or (org-element-property :end element) (save-excursion (progn
(defvar org-called-with-limited-levels) (defvar org-outline-regexp) (defvar
outline-regexp) (defvar org-outline-regexp-bol) (let* (... ... ... ...)
(outline-next-heading))) (point)))) (parent element)) (while t (if syncp
(progn (cond ((= (point) pos) (throw (quote exit) parent))
((org-element--cache-interrupt-p time-limit) (throw (quote interrupt)
nil))))) (if element nil (setq element (org-element--current-element end
(quote element) mode (org-element-property :structure parent)))
(org-element-put-property element :parent parent) (org-element--cache-put
element)) (let ((elem-end (org-element-property :end element)) (type
(org-element-type element))) (cond ((and (<= elem-end pos) (/= (point-max)
elem-end)) (goto-char elem-end) (setq mode (org-element--next-mode type
nil))) ((not (memq type org-element-greater-elements)) (throw (quote exit)
element)) ((let ((cbeg ...) (cend ...)) (if (or syncp ...) (progn ...
...)))) (t (throw (quote exit) element)))) (setq element nil)))
  (let* ((cached (and (org-element--cache-active-p)
(org-element--cache-find pos nil))) (begin (org-element-property :begin
cached)) element next mode) (cond ((not cached) (if (progn (defvar
org-called-with-limited-levels) (defvar org-outline-regexp) (defvar
outline-regexp) (defvar org-outline-regexp-bol) (let*
((org-called-with-limited-levels t) (org-outline-regexp ...)
(outline-regexp org-outline-regexp) (org-outline-regexp-bol ...))
(outline-previous-heading))) (progn (setq mode (quote planning))
(forward-line))) (skip-chars-forward "
\n") (beginning-of-line)) ((= pos begin) (throw (quote exit) (if syncp
(org-element-property :parent cached) cached))) ((re-search-backward (progn
(defvar org-called-with-limited-levels) (defvar org-outline-regexp) (defvar
outline-regexp) (defvar org-outline-regexp-bol) (let*
((org-called-with-limited-levels t) (org-outline-regexp ...)
(outline-regexp org-outline-regexp) (org-outline-regexp-bol ...))
org-outline-regexp-bol)) begin t) (forward-line) (skip-chars-forward "
\n") (beginning-of-line) (setq mode (quote planning))) (t (let ((up cached)
(pos (if (= ... pos) (1- pos) pos))) (goto-char (or (org-element-property
:contents-begin cached) begin)) (while (let ((end ...)) (and (<= end pos)
(goto-char end) (setq up ...)))) (cond ((not up)) ((eobp) (setq element
up)) (t (setq element up next (point))))))) (let ((end (or
(org-element-property :end element) (save-excursion (progn (defvar
org-called-with-limited-levels) (defvar org-outline-regexp) (defvar
outline-regexp) (defvar org-outline-regexp-bol) (let* ... ...)) (point))))
(parent element)) (while t (if syncp (progn (cond ((= ... pos) (throw ...
parent)) ((org-element--cache-interrupt-p time-limit) (throw ... nil)))))
(if element nil (setq element (org-element--current-element end (quote
element) mode (org-element-property :structure parent)))
(org-element-put-property element :parent parent) (org-element--cache-put
element)) (let ((elem-end (org-element-property :end element)) (type
(org-element-type element))) (cond ((and (<= elem-end pos) (/= ...
elem-end)) (goto-char elem-end) (setq mode (org-element--next-mode type
nil))) ((not (memq type org-element-greater-elements)) (throw (quote exit)
element)) ((let (... ...) (if ... ...))) (t (throw (quote exit) element))))
(setq element nil))))
  (save-restriction (widen) (goto-char pos) (let* ((cached (and
(org-element--cache-active-p) (org-element--cache-find pos nil))) (begin
(org-element-property :begin cached)) element next mode) (cond ((not
cached) (if (progn (defvar org-called-with-limited-levels) (defvar
org-outline-regexp) (defvar outline-regexp) (defvar org-outline-regexp-bol)
(let* (... ... ... ...) (outline-previous-heading))) (progn (setq mode
(quote planning)) (forward-line))) (skip-chars-forward "
\n") (beginning-of-line)) ((= pos begin) (throw (quote exit) (if syncp
(org-element-property :parent cached) cached))) ((re-search-backward (progn
(defvar org-called-with-limited-levels) (defvar org-outline-regexp) (defvar
outline-regexp) (defvar org-outline-regexp-bol) (let* (... ... ... ...)
org-outline-regexp-bol)) begin t) (forward-line) (skip-chars-forward "
\n") (beginning-of-line) (setq mode (quote planning))) (t (let ((up cached)
(pos (if ... ... pos))) (goto-char (or (org-element-property
:contents-begin cached) begin)) (while (let (...) (and ... ... ...))) (cond
((not up)) ((eobp) (setq element up)) (t (setq element up next ...))))))
(let ((end (or (org-element-property :end element) (save-excursion (progn
... ... ... ... ...) (point)))) (parent element)) (while t (if syncp (progn
(cond (... ...) (... ...)))) (if element nil (setq element
(org-element--current-element end (quote element) mode
(org-element-property :structure parent))) (org-element-put-property
element :parent parent) (org-element--cache-put element)) (let ((elem-end
(org-element-property :end element)) (type (org-element-type element)))
(cond ((and ... ...) (goto-char elem-end) (setq mode ...)) ((not ...)
(throw ... element)) ((let ... ...)) (t (throw ... element)))) (setq
element nil)))))
  (save-excursion (save-restriction (widen) (goto-char pos) (let* ((cached
(and (org-element--cache-active-p) (org-element--cache-find pos nil)))
(begin (org-element-property :begin cached)) element next mode) (cond ((not
cached) (if (progn (defvar org-called-with-limited-levels) (defvar
org-outline-regexp) (defvar outline-regexp) (defvar org-outline-regexp-bol)
(let* ... ...)) (progn (setq mode ...) (forward-line))) (skip-chars-forward
"
\n") (beginning-of-line)) ((= pos begin) (throw (quote exit) (if syncp
(org-element-property :parent cached) cached))) ((re-search-backward (progn
(defvar org-called-with-limited-levels) (defvar org-outline-regexp) (defvar
outline-regexp) (defvar org-outline-regexp-bol) (let* ...
org-outline-regexp-bol)) begin t) (forward-line) (skip-chars-forward "
\n") (beginning-of-line) (setq mode (quote planning))) (t (let ((up cached)
(pos ...)) (goto-char (or ... begin)) (while (let ... ...)) (cond (...)
(... ...) (t ...))))) (let ((end (or (org-element-property :end element)
(save-excursion ... ...))) (parent element)) (while t (if syncp (progn
(cond ... ...))) (if element nil (setq element
(org-element--current-element end ... mode ...)) (org-element-put-property
element :parent parent) (org-element--cache-put element)) (let ((elem-end
...) (type ...)) (cond (... ... ...) (... ...) (...) (t ...))) (setq
element nil))))))
  (catch (quote exit) (save-excursion (save-restriction (widen) (goto-char
pos) (let* ((cached (and (org-element--cache-active-p)
(org-element--cache-find pos nil))) (begin (org-element-property :begin
cached)) element next mode) (cond ((not cached) (if (progn ... ... ... ...
...) (progn ... ...)) (skip-chars-forward "
\n") (beginning-of-line)) ((= pos begin) (throw (quote exit) (if syncp ...
cached))) ((re-search-backward (progn ... ... ... ... ...) begin t)
(forward-line) (skip-chars-forward "
\n") (beginning-of-line) (setq mode (quote planning))) (t (let (... ...)
(goto-char ...) (while ...) (cond ... ... ...)))) (let ((end (or ... ...))
(parent element)) (while t (if syncp (progn ...)) (if element nil (setq
element ...) (org-element-put-property element :parent parent)
(org-element--cache-put element)) (let (... ...) (cond ... ... ... ...))
(setq element nil)))))))
  org-element--parse-to(94)
  (cond ((bobp) nil) ((progn (defvar org-called-with-limited-levels)
(defvar org-outline-regexp) (defvar outline-regexp) (defvar
org-outline-regexp-bol) (let* ((org-called-with-limited-levels t)
(org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp
org-outline-regexp) (org-outline-regexp-bol (concat "^"
org-outline-regexp))) (org-at-heading-p))) (beginning-of-line)
(org-element-headline-parser (point-max) t)) (t (if
(org-element--cache-active-p) (progn (if (not org-element--cache)
(org-element-cache-reset) (org-element--cache-sync (current-buffer)
origin)))) (org-element--parse-to origin)))
  (let ((origin (point))) (end-of-line) (skip-chars-backward "
\n") (cond ((bobp) nil) ((progn (defvar org-called-with-limited-levels)
(defvar org-outline-regexp) (defvar outline-regexp) (defvar
org-outline-regexp-bol) (let* ((org-called-with-limited-levels t)
(org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp
org-outline-regexp) (org-outline-regexp-bol (concat "^"
org-outline-regexp))) (org-at-heading-p))) (beginning-of-line)
(org-element-headline-parser (point-max) t)) (t (if
(org-element--cache-active-p) (progn (if (not org-element--cache)
(org-element-cache-reset) (org-element--cache-sync (current-buffer)
origin)))) (org-element--parse-to origin))))
  (save-restriction (widen) (let ((origin (point))) (end-of-line)
(skip-chars-backward "
\n") (cond ((bobp) nil) ((progn (defvar org-called-with-limited-levels)
(defvar org-outline-regexp) (defvar outline-regexp) (defvar
org-outline-regexp-bol) (let* ((org-called-with-limited-levels t)
(org-outline-regexp ...) (outline-regexp org-outline-regexp)
(org-outline-regexp-bol ...)) (org-at-heading-p))) (beginning-of-line)
(org-element-headline-parser (point-max) t)) (t (if
(org-element--cache-active-p) (progn (if (not org-element--cache)
(org-element-cache-reset) (org-element--cache-sync ... origin))))
(org-element--parse-to origin)))))
  (save-excursion (save-restriction (widen) (let ((origin (point)))
(end-of-line) (skip-chars-backward "
\n") (cond ((bobp) nil) ((progn (defvar org-called-with-limited-levels)
(defvar org-outline-regexp) (defvar outline-regexp) (defvar
org-outline-regexp-bol) (let* (... ... ... ...) (org-at-heading-p)))
(beginning-of-line) (org-element-headline-parser (point-max) t)) (t (if
(org-element--cache-active-p) (progn (if ... ... ...)))
(org-element--parse-to origin))))))
  org-element-at-point()
  (or element (org-element-at-point))
  (let* ((pos (point)) (element (or element (org-element-at-point))) (type
(org-element-type element)) (post (org-element-property :post-affiliated
element))) (cond ((and post (< pos post)) (beginning-of-line) (let
((case-fold-search t)) (looking-at org-element--affiliated-re)) (cond ((not
(member-ignore-case (match-string 1) org-element-parsed-keywords)) (throw
(quote objects-forbidden) element)) ((< (match-end 0) pos)
(narrow-to-region (match-end 0) (line-end-position))) ((and
(match-beginning 2) (>= pos (match-beginning 2)) (< pos (match-end 2)))
(narrow-to-region (match-beginning 2) (match-end 2))) (t (throw (quote
objects-forbidden) element))) (setq type (quote keyword))) ((eq type (quote
item)) (let ((tag (org-element-property :tag element))) (if (or (not tag)
(/= (line-beginning-position) post)) (throw (quote objects-forbidden)
element) (beginning-of-line) (search-forward tag (line-end-position))
(goto-char (match-beginning 0)) (if (and (>= pos ...) (< pos ...))
(narrow-to-region (point) (match-end 0)) (throw (quote objects-forbidden)
element))))) ((memq type (quote (headline inlinetask))) (goto-char
(org-element-property :begin element)) (looking-at
org-complex-heading-regexp) (let ((end (match-end 4))) (if (not end) (throw
(quote objects-forbidden) element) (goto-char (match-beginning 4)) (if (let
(case-fold-search) (looking-at org-comment-string)) (progn (goto-char
...))) (if (>= (point) end) (throw (quote objects-forbidden) element)
(narrow-to-region (point) end))))) ((memq type (quote (paragraph table-row
verse-block))) (let ((cbeg (org-element-property :contents-begin element))
(cend (org-element-property :contents-end element))) (if (and cbeg cend (>=
pos cbeg) (or (< pos cend) (and ... ...))) (narrow-to-region cbeg cend)
(throw (quote objects-forbidden) element)))) ((eq type (quote planning))
(let ((--dolist-tail-- (quote (:closed :deadline :scheduled)))) (while
--dolist-tail-- (let ((p ...)) (let (...) (if ... ...)) (setq
--dolist-tail-- (cdr --dolist-tail--))))) (throw (quote objects-forbidden)
element)) (t (throw (quote objects-forbidden) element))) (goto-char
(point-min)) (let ((restriction (org-element-restriction type)) (parent
element) (cache (cond ((not (org-element--cache-active-p)) nil)
(org-element--cache-objects (gethash element org-element--cache-objects))
(t (org-element-cache-reset) nil))) next object-data last) (prog1 (catch
(quote exit) (while t (if next nil (let (...) (if data ... ...))) (catch
(quote found) (if next (setq next ...) (let ... ...)) (if next (progn ...
...) (setcar ... t))) (if (or (not next) (> ... pos)) (throw (quote exit)
(or last parent)) (let (... ... ...) (cond ... ... ...)))))
(org-element--cache-put element cache))))
  (save-restriction (widen) (let* ((pos (point)) (element (or element
(org-element-at-point))) (type (org-element-type element)) (post
(org-element-property :post-affiliated element))) (cond ((and post (< pos
post)) (beginning-of-line) (let ((case-fold-search t)) (looking-at
org-element--affiliated-re)) (cond ((not (member-ignore-case ...
org-element-parsed-keywords)) (throw (quote objects-forbidden) element))
((< (match-end 0) pos) (narrow-to-region (match-end 0)
(line-end-position))) ((and (match-beginning 2) (>= pos ...) (< pos ...))
(narrow-to-region (match-beginning 2) (match-end 2))) (t (throw (quote
objects-forbidden) element))) (setq type (quote keyword))) ((eq type (quote
item)) (let ((tag (org-element-property :tag element))) (if (or (not tag)
(/= ... post)) (throw (quote objects-forbidden) element)
(beginning-of-line) (search-forward tag (line-end-position)) (goto-char
(match-beginning 0)) (if (and ... ...) (narrow-to-region ... ...) (throw
... element))))) ((memq type (quote (headline inlinetask))) (goto-char
(org-element-property :begin element)) (looking-at
org-complex-heading-regexp) (let ((end (match-end 4))) (if (not end) (throw
(quote objects-forbidden) element) (goto-char (match-beginning 4)) (if (let
... ...) (progn ...)) (if (>= ... end) (throw ... element)
(narrow-to-region ... end))))) ((memq type (quote (paragraph table-row
verse-block))) (let ((cbeg (org-element-property :contents-begin element))
(cend (org-element-property :contents-end element))) (if (and cbeg cend (>=
pos cbeg) (or ... ...)) (narrow-to-region cbeg cend) (throw (quote
objects-forbidden) element)))) ((eq type (quote planning)) (let
((--dolist-tail-- (quote ...))) (while --dolist-tail-- (let (...) (let ...
...) (setq --dolist-tail-- ...)))) (throw (quote objects-forbidden)
element)) (t (throw (quote objects-forbidden) element))) (goto-char
(point-min)) (let ((restriction (org-element-restriction type)) (parent
element) (cache (cond ((not ...) nil) (org-element--cache-objects (gethash
element org-element--cache-objects)) (t (org-element-cache-reset) nil)))
next object-data last) (prog1 (catch (quote exit) (while t (if next nil
(let ... ...)) (catch (quote found) (if next ... ...) (if next ... ...))
(if (or ... ...) (throw ... ...) (let ... ...)))) (org-element--cache-put
element cache)))))
  (save-excursion (save-restriction (widen) (let* ((pos (point)) (element
(or element (org-element-at-point))) (type (org-element-type element))
(post (org-element-property :post-affiliated element))) (cond ((and post (<
pos post)) (beginning-of-line) (let ((case-fold-search t)) (looking-at
org-element--affiliated-re)) (cond ((not ...) (throw ... element)) ((< ...
pos) (narrow-to-region ... ...)) ((and ... ... ...) (narrow-to-region ...
...)) (t (throw ... element))) (setq type (quote keyword))) ((eq type
(quote item)) (let ((tag ...)) (if (or ... ...) (throw ... element)
(beginning-of-line) (search-forward tag ...) (goto-char ...) (if ... ...
...)))) ((memq type (quote (headline inlinetask))) (goto-char
(org-element-property :begin element)) (looking-at
org-complex-heading-regexp) (let ((end ...)) (if (not end) (throw ...
element) (goto-char ...) (if ... ...) (if ... ... ...)))) ((memq type
(quote (paragraph table-row verse-block))) (let ((cbeg ...) (cend ...)) (if
(and cbeg cend ... ...) (narrow-to-region cbeg cend) (throw ... element))))
((eq type (quote planning)) (let ((--dolist-tail-- ...)) (while
--dolist-tail-- (let ... ... ...))) (throw (quote objects-forbidden)
element)) (t (throw (quote objects-forbidden) element))) (goto-char
(point-min)) (let ((restriction (org-element-restriction type)) (parent
element) (cache (cond (... nil) (org-element--cache-objects ...) (t ...
nil))) next object-data last) (prog1 (catch (quote exit) (while t (if next
nil ...) (catch ... ... ...) (if ... ... ...))) (org-element--cache-put
element cache))))))
  (catch (quote objects-forbidden) (save-excursion (save-restriction
(widen) (let* ((pos (point)) (element (or element (org-element-at-point)))
(type (org-element-type element)) (post (org-element-property
:post-affiliated element))) (cond ((and post (< pos post))
(beginning-of-line) (let (...) (looking-at org-element--affiliated-re))
(cond (... ...) (... ...) (... ...) (t ...)) (setq type (quote keyword)))
((eq type (quote item)) (let (...) (if ... ... ... ... ... ...))) ((memq
type (quote ...)) (goto-char (org-element-property :begin element))
(looking-at org-complex-heading-regexp) (let (...) (if ... ... ... ...
...))) ((memq type (quote ...)) (let (... ...) (if ... ... ...))) ((eq type
(quote planning)) (let (...) (while --dolist-tail-- ...)) (throw (quote
objects-forbidden) element)) (t (throw (quote objects-forbidden) element)))
(goto-char (point-min)) (let ((restriction (org-element-restriction type))
(parent element) (cache (cond ... ... ...)) next object-data last) (prog1
(catch (quote exit) (while t ... ... ...)) (org-element--cache-put element
cache)))))))
  org-element-context()
  (progn (org-element-context))
  (unwind-protect (progn (org-element-context)) (set-match-data
save-match-data-internal (quote evaporate)))
  (let ((save-match-data-internal (match-data))) (unwind-protect (progn
(org-element-context)) (set-match-data save-match-data-internal (quote
evaporate))))
  (let* ((element (let ((save-match-data-internal (match-data)))
(unwind-protect (progn (org-element-context)) (set-match-data
save-match-data-internal (quote evaporate))))) (type (org-element-type
element)) (begin (copy-marker (org-element-property :begin element))) (end
(copy-marker (save-excursion (goto-char (org-element-property :end
element)) (skip-chars-backward "
\n") (point))))) (cond ((eql type (quote inline-src-block)) (let* ((info
(org-babel-get-src-block-info nil element)) (params (nth 2 info))) (let*
((c (nthcdr 1 info))) (setcar c (if (and ... ...)
(org-babel-expand-noweb-references info org-babel-exp-reference-buffer)
(nth 1 info)))) (goto-char begin) (let ((replacement
(org-babel-exp-do-export info ...))) (if (equal replacement "")
(delete-region begin (progn ... ... ...)) (delete-region begin end) (insert
replacement))))) ((memql type (quote (babel-call inline-babel-call))) (let*
((lob-info (org-babel-lob-get-info element)) (results
(org-babel-exp-do-export (list "emacs-lisp" "results" ... "" ... ...)
(quote lob))) (rep (org-fill-template org-babel-exp-call-line-template
(list ...)))) (if (equal rep "") (delete-region begin (progn (goto-char
end) (if ... ... ... ...))) (goto-char begin) (delete-region begin end)
(insert rep)))) ((eql type (quote src-block)) (let* ((match-start
(copy-marker (match-beginning 0))) (ind (org-get-indentation)) (lang (or
(org-element-property :language element) (user-error "No language for src
block: %s" ...))) (headers (cons lang (let ... ...)))) (let ((replacement
(progn ... ...))) (cond ((not replacement) (goto-char end)) ((equal
replacement "") (goto-char end) (skip-chars-forward "
\n") (beginning-of-line) (delete-region begin ...)) (t (goto-char
match-start) (delete-region ... ...) (insert replacement) (if ... ...
...)))) (set-marker match-start nil)))) (set-marker begin nil) (set-marker
end nil))
  (if (let ((save-match-data-internal (match-data))) (unwind-protect (progn
(org-in-commented-heading-p)) (set-match-data save-match-data-internal
(quote evaporate)))) nil (let* ((element (let ((save-match-data-internal
(match-data))) (unwind-protect (progn (org-element-context))
(set-match-data save-match-data-internal (quote evaporate))))) (type
(org-element-type element)) (begin (copy-marker (org-element-property
:begin element))) (end (copy-marker (save-excursion (goto-char
(org-element-property :end element)) (skip-chars-backward "
\n") (point))))) (cond ((eql type (quote inline-src-block)) (let* ((info
(org-babel-get-src-block-info nil element)) (params (nth 2 info))) (let*
((c ...)) (setcar c (if ... ... ...))) (goto-char begin) (let ((replacement
...)) (if (equal replacement "") (delete-region begin ...) (delete-region
begin end) (insert replacement))))) ((memql type (quote (babel-call
inline-babel-call))) (let* ((lob-info (org-babel-lob-get-info element))
(results (org-babel-exp-do-export ... ...)) (rep (org-fill-template
org-babel-exp-call-line-template ...))) (if (equal rep "") (delete-region
begin (progn ... ...)) (goto-char begin) (delete-region begin end) (insert
rep)))) ((eql type (quote src-block)) (let* ((match-start (copy-marker
...)) (ind (org-get-indentation)) (lang (or ... ...)) (headers (cons lang
...))) (let ((replacement ...)) (cond (... ...) (... ... ... ... ...) (t
... ... ... ...))) (set-marker match-start nil)))) (set-marker begin nil)
(set-marker end nil)))
  (while (re-search-forward regexp nil t) (if (let
((save-match-data-internal (match-data))) (unwind-protect (progn
(org-in-commented-heading-p)) (set-match-data save-match-data-internal
(quote evaporate)))) nil (let* ((element (let ((save-match-data-internal
...)) (unwind-protect (progn ...) (set-match-data save-match-data-internal
...)))) (type (org-element-type element)) (begin (copy-marker
(org-element-property :begin element))) (end (copy-marker (save-excursion
(goto-char ...) (skip-chars-backward "
\n") (point))))) (cond ((eql type (quote inline-src-block)) (let* ((info
...) (params ...)) (let* (...) (setcar c ...)) (goto-char begin) (let (...)
(if ... ... ... ...)))) ((memql type (quote (babel-call
inline-babel-call))) (let* ((lob-info ...) (results ...) (rep ...)) (if
(equal rep "") (delete-region begin ...) (goto-char begin) (delete-region
begin end) (insert rep)))) ((eql type (quote src-block)) (let*
((match-start ...) (ind ...) (lang ...) (headers ...)) (let (...) (cond ...
... ...)) (set-marker match-start nil)))) (set-marker begin nil)
(set-marker end nil))))
  (let ((case-fold-search t) (org-babel-exp-reference-buffer
reference-buffer) (regexp "\\(call\\|src\\)_\\|^[
]*#\\+\\(BEGIN_SRC\\|CALL:\\)"))
(goto-char (point-min)) (while (re-search-forward regexp nil t) (if (let
((save-match-data-internal (match-data))) (unwind-protect (progn
(org-in-commented-heading-p)) (set-match-data save-match-data-internal
(quote evaporate)))) nil (let* ((element (let (...) (unwind-protect ...
...))) (type (org-element-type element)) (begin (copy-marker
(org-element-property :begin element))) (end (copy-marker (save-excursion
... ... ...)))) (cond ((eql type (quote inline-src-block)) (let* (... ...)
(let* ... ...) (goto-char begin) (let ... ...))) ((memql type (quote ...))
(let* (... ... ...) (if ... ... ... ... ...))) ((eql type (quote
src-block)) (let* (... ... ... ...) (let ... ...) (set-marker match-start
nil)))) (set-marker begin nil) (set-marker end nil)))))
  (save-excursion (let ((case-fold-search t)
(org-babel-exp-reference-buffer reference-buffer) (regexp
"\\(call\\|src\\)_\\|^[ ]*#\\+\\(BEGIN_SRC\\|CALL:\\)")) (goto-char
(point-min)) (while (re-search-forward regexp nil t) (if (let
((save-match-data-internal (match-data))) (unwind-protect (progn
(org-in-commented-heading-p)) (set-match-data save-match-data-internal
(quote evaporate)))) nil (let* ((element (let ... ...)) (type
(org-element-type element)) (begin (copy-marker ...)) (end (copy-marker
...))) (cond ((eql type ...) (let* ... ... ... ...)) ((memql type ...)
(let* ... ...)) ((eql type ...) (let* ... ... ...))) (set-marker begin nil)
(set-marker end nil))))))
  (progn (save-excursion (let ((case-fold-search t)
(org-babel-exp-reference-buffer reference-buffer) (regexp
"\\(call\\|src\\)_\\|^[ ]*#\\+\\(BEGIN_SRC\\|CALL:\\)")) (goto-char
(point-min)) (while (re-search-forward regexp nil t) (if (let
((save-match-data-internal ...)) (unwind-protect (progn ...)
(set-match-data save-match-data-internal ...))) nil (let* ((element ...)
(type ...) (begin ...) (end ...)) (cond (... ...) (... ...) (... ...))
(set-marker begin nil) (set-marker end nil)))))))
  (unwind-protect (progn (save-excursion (let ((case-fold-search t)
(org-babel-exp-reference-buffer reference-buffer) (regexp
"\\(call\\|src\\)_\\|^[ ]*#\\+\\(BEGIN_SRC\\|CALL:\\)")) (goto-char
(point-min)) (while (re-search-forward regexp nil t) (if (let (...)
(unwind-protect ... ...)) nil (let* (... ... ... ...) (cond ... ... ...)
(set-marker begin nil) (set-marker end nil))))))) (set-window-configuration
wconfig))
  (let ((wconfig (current-window-configuration))) (unwind-protect (progn
(save-excursion (let ((case-fold-search t) (org-babel-exp-reference-buffer
reference-buffer) (regexp "\\(call\\|src\\)_\\|^[
]*#\\+\\(BEGIN_SRC\\|CALL:\\)"))
(goto-char (point-min)) (while (re-search-forward regexp nil t) (if (let
... ...) nil (let* ... ... ... ...)))))) (set-window-configuration
wconfig)))
  org-babel-exp-process-buffer(#<buffer org-bug2.org<2><2>>)
  (unwind-protect (org-babel-exp-process-buffer reference) (kill-buffer
reference))
  (let ((reference (org-export-copy-buffer))) (unwind-protect
(org-babel-exp-process-buffer reference) (kill-buffer reference)))
  org-export-execute-babel-code()
  (progn (run-hook-with-args (quote org-export-before-processing-hook)
(progn nil (or (progn nil (and (vectorp backend) (>= (length backend) 8)
(memq (aref backend 0) cl-struct-org-export-backend-tags) t)) (signal
(quote wrong-type-argument) (list (quote org-export-backend) backend)))
(aref backend 1))) (org-export-expand-include-keyword)
(org-export--delete-comments) (org-macro-initialize-templates)
(org-macro-replace-all org-macro-templates nil parsed-keywords)
(org-set-regexps-and-options) (org-update-radio-target-regexp)
(org-export-execute-babel-code) (org-set-regexps-and-options)
(org-update-radio-target-regexp) (goto-char (point-min)) (save-excursion
(run-hook-with-args (quote org-export-before-parsing-hook) (progn nil (or
(progn nil (and (vectorp backend) (>= ... 8) (memq ...
cl-struct-org-export-backend-tags) t)) (signal (quote wrong-type-argument)
(list (quote org-export-backend) backend))) (aref backend 1))))
(org-set-regexps-and-options) (org-update-radio-target-regexp) (setq info
(org-export-install-filters (org-combine-plists info
(org-export-get-environment backend subtreep ext-plist)))) (let
((backend-name (progn nil (or (progn nil (and ... ... ... t)) (signal
(quote wrong-type-argument) (list ... backend))) (aref backend 1)))) (let
((--dolist-tail-- (plist-get info :filter-options))) (while --dolist-tail--
(let ((filter (car --dolist-tail--))) (let ((result ...)) (if result (progn
...))) (setq --dolist-tail-- (cdr --dolist-tail--))))))
(org-macro-replace-all (list (cons "author" (org-element-interpret-data
(plist-get info :author))) (cons "date" (let* ((date (plist-get info
:date)) (value (or ... ""))) (if (and (consp date) (not ...) (eq ... ...))
(format "(eval (if (org-string-nw-p \"$1\") %s %S))" (format
"(org-timestamp-format '%S \"$1\")" ...) value) value))) (cons "email"
(org-element-interpret-data (plist-get info :email))) (cons "title"
(org-element-interpret-data (plist-get info :title))) (cons "results"
"$1")) (quote finalize) parsed-keywords) (setq tree
(org-element-parse-buffer nil visible-only))
(org-export--merge-external-footnote-definitions tree)
(org-export--prune-tree tree info) (org-export--remove-uninterpreted-data
tree info) (setq tree (org-export-filter-apply-functions (plist-get info
:filter-parse-tree) tree info)) (setq info
(org-export--collect-tree-properties tree info)) (let* ((body
(org-element-normalize-string (or (org-export-data tree info) "")))
(inner-template (cdr (assq (quote inner-template) (plist-get info
:translate-alist)))) (full-body (org-export-filter-apply-functions
(plist-get info :filter-body) (if (not (functionp inner-template)) body
(funcall inner-template body info)) info)) (template (cdr (assq (quote
template) (plist-get info :translate-alist))))) (org-no-properties
(org-export-filter-apply-functions (plist-get info :filter-final-output)
(if (or (not (functionp template)) body-only) full-body (funcall template
full-body info)) info))))
  (save-current-buffer (set-buffer --buf-copy) (goto-char (point-min))
(progn (run-hook-with-args (quote org-export-before-processing-hook) (progn
nil (or (progn nil (and (vectorp backend) (>= ... 8) (memq ...
cl-struct-org-export-backend-tags) t)) (signal (quote wrong-type-argument)
(list (quote org-export-backend) backend))) (aref backend 1)))
(org-export-expand-include-keyword) (org-export--delete-comments)
(org-macro-initialize-templates) (org-macro-replace-all org-macro-templates
nil parsed-keywords) (org-set-regexps-and-options)
(org-update-radio-target-regexp) (org-export-execute-babel-code)
(org-set-regexps-and-options) (org-update-radio-target-regexp) (goto-char
(point-min)) (save-excursion (run-hook-with-args (quote
org-export-before-parsing-hook) (progn nil (or (progn nil (and ... ... ...
t)) (signal (quote wrong-type-argument) (list ... backend))) (aref backend
1)))) (org-set-regexps-and-options) (org-update-radio-target-regexp) (setq
info (org-export-install-filters (org-combine-plists info
(org-export-get-environment backend subtreep ext-plist)))) (let
((backend-name (progn nil (or (progn nil ...) (signal ... ...)) (aref
backend 1)))) (let ((--dolist-tail-- (plist-get info :filter-options)))
(while --dolist-tail-- (let ((filter ...)) (let (...) (if result ...))
(setq --dolist-tail-- (cdr --dolist-tail--)))))) (org-macro-replace-all
(list (cons "author" (org-element-interpret-data (plist-get info :author)))
(cons "date" (let* ((date ...) (value ...)) (if (and ... ... ...) (format
"(eval (if (org-string-nw-p \"$1\") %s %S))" ... value) value))) (cons
"email" (org-element-interpret-data (plist-get info :email))) (cons "title"
(org-element-interpret-data (plist-get info :title))) (cons "results"
"$1")) (quote finalize) parsed-keywords) (setq tree
(org-element-parse-buffer nil visible-only))
(org-export--merge-external-footnote-definitions tree)
(org-export--prune-tree tree info) (org-export--remove-uninterpreted-data
tree info) (setq tree (org-export-filter-apply-functions (plist-get info
:filter-parse-tree) tree info)) (setq info
(org-export--collect-tree-properties tree info)) (let* ((body
(org-element-normalize-string (or (org-export-data tree info) "")))
(inner-template (cdr (assq (quote inner-template) (plist-get info
:translate-alist)))) (full-body (org-export-filter-apply-functions
(plist-get info :filter-body) (if (not ...) body (funcall inner-template
body info)) info)) (template (cdr (assq (quote template) (plist-get info
:translate-alist))))) (org-no-properties (org-export-filter-apply-functions
(plist-get info :filter-final-output) (if (or (not ...) body-only)
full-body (funcall template full-body info)) info)))))
  (unwind-protect (save-current-buffer (set-buffer --buf-copy) (goto-char
(point-min)) (progn (run-hook-with-args (quote
org-export-before-processing-hook) (progn nil (or (progn nil (and ... ...
... t)) (signal (quote wrong-type-argument) (list ... backend))) (aref
backend 1))) (org-export-expand-include-keyword)
(org-export--delete-comments) (org-macro-initialize-templates)
(org-macro-replace-all org-macro-templates nil parsed-keywords)
(org-set-regexps-and-options) (org-update-radio-target-regexp)
(org-export-execute-babel-code) (org-set-regexps-and-options)
(org-update-radio-target-regexp) (goto-char (point-min)) (save-excursion
(run-hook-with-args (quote org-export-before-parsing-hook) (progn nil (or
(progn nil ...) (signal ... ...)) (aref backend 1))))
(org-set-regexps-and-options) (org-update-radio-target-regexp) (setq info
(org-export-install-filters (org-combine-plists info
(org-export-get-environment backend subtreep ext-plist)))) (let
((backend-name (progn nil (or ... ...) (aref backend 1)))) (let
((--dolist-tail-- (plist-get info :filter-options))) (while --dolist-tail--
(let (...) (let ... ...) (setq --dolist-tail-- ...)))))
(org-macro-replace-all (list (cons "author" (org-element-interpret-data
(plist-get info :author))) (cons "date" (let* (... ...) (if ... ...
value))) (cons "email" (org-element-interpret-data (plist-get info
:email))) (cons "title" (org-element-interpret-data (plist-get info
:title))) (cons "results" "$1")) (quote finalize) parsed-keywords) (setq
tree (org-element-parse-buffer nil visible-only))
(org-export--merge-external-footnote-definitions tree)
(org-export--prune-tree tree info) (org-export--remove-uninterpreted-data
tree info) (setq tree (org-export-filter-apply-functions (plist-get info
:filter-parse-tree) tree info)) (setq info
(org-export--collect-tree-properties tree info)) (let* ((body
(org-element-normalize-string (or ... ""))) (inner-template (cdr (assq ...
...))) (full-body (org-export-filter-apply-functions (plist-get info
:filter-body) (if ... body ...) info)) (template (cdr (assq ... ...))))
(org-no-properties (org-export-filter-apply-functions (plist-get info
:filter-final-output) (if (or ... body-only) full-body (funcall template
full-body info)) info))))) (and (buffer-live-p --buf-copy) (progn
(save-current-buffer (set-buffer --buf-copy) (restore-buffer-modified-p
nil)) (kill-buffer --buf-copy))))
  (let ((--buf-copy (org-export-copy-buffer))) (unwind-protect
(save-current-buffer (set-buffer --buf-copy) (goto-char (point-min)) (progn
(run-hook-with-args (quote org-export-before-processing-hook) (progn nil
(or (progn nil ...) (signal ... ...)) (aref backend 1)))
(org-export-expand-include-keyword) (org-export--delete-comments)
(org-macro-initialize-templates) (org-macro-replace-all org-macro-templates
nil parsed-keywords) (org-set-regexps-and-options)
(org-update-radio-target-regexp) (org-export-execute-babel-code)
(org-set-regexps-and-options) (org-update-radio-target-regexp) (goto-char
(point-min)) (save-excursion (run-hook-with-args (quote
org-export-before-parsing-hook) (progn nil (or ... ...) (aref backend 1))))
(org-set-regexps-and-options) (org-update-radio-target-regexp) (setq info
(org-export-install-filters (org-combine-plists info
(org-export-get-environment backend subtreep ext-plist)))) (let
((backend-name (progn nil ... ...))) (let ((--dolist-tail-- ...)) (while
--dolist-tail-- (let ... ... ...)))) (org-macro-replace-all (list (cons
"author" (org-element-interpret-data ...)) (cons "date" (let* ... ...))
(cons "email" (org-element-interpret-data ...)) (cons "title"
(org-element-interpret-data ...)) (cons "results" "$1")) (quote finalize)
parsed-keywords) (setq tree (org-element-parse-buffer nil visible-only))
(org-export--merge-external-footnote-definitions tree)
(org-export--prune-tree tree info) (org-export--remove-uninterpreted-data
tree info) (setq tree (org-export-filter-apply-functions (plist-get info
:filter-parse-tree) tree info)) (setq info
(org-export--collect-tree-properties tree info)) (let* ((body
(org-element-normalize-string ...)) (inner-template (cdr ...)) (full-body
(org-export-filter-apply-functions ... ... info)) (template (cdr ...)))
(org-no-properties (org-export-filter-apply-functions (plist-get info
:filter-final-output) (if ... full-body ...) info))))) (and (buffer-live-p
--buf-copy) (progn (save-current-buffer (set-buffer --buf-copy)
(restore-buffer-modified-p nil)) (kill-buffer --buf-copy)))))
  (let* ((org-export-current-backend (progn nil (or (progn nil (and
(vectorp backend) (>= ... 8) (memq ... cl-struct-org-export-backend-tags)
t)) (signal (quote wrong-type-argument) (list (quote org-export-backend)
backend))) (aref backend 1))) (info (org-combine-plists
(org-export--get-export-attributes backend subtreep visible-only body-only)
(org-export--get-buffer-attributes))) (parsed-keywords (delq nil (mapcar
(function (lambda (o) (and ... ...))) (append (org-export-get-all-options
backend) org-export-options-alist)))) tree) (let ((--buf-copy
(org-export-copy-buffer))) (unwind-protect (save-current-buffer (set-buffer
--buf-copy) (goto-char (point-min)) (progn (run-hook-with-args (quote
org-export-before-processing-hook) (progn nil (or ... ...) (aref backend
1))) (org-export-expand-include-keyword) (org-export--delete-comments)
(org-macro-initialize-templates) (org-macro-replace-all org-macro-templates
nil parsed-keywords) (org-set-regexps-and-options)
(org-update-radio-target-regexp) (org-export-execute-babel-code)
(org-set-regexps-and-options) (org-update-radio-target-regexp) (goto-char
(point-min)) (save-excursion (run-hook-with-args (quote
org-export-before-parsing-hook) (progn nil ... ...)))
(org-set-regexps-and-options) (org-update-radio-target-regexp) (setq info
(org-export-install-filters (org-combine-plists info ...))) (let
((backend-name ...)) (let (...) (while --dolist-tail-- ...)))
(org-macro-replace-all (list (cons "author" ...) (cons "date" ...) (cons
"email" ...) (cons "title" ...) (cons "results" "$1")) (quote finalize)
parsed-keywords) (setq tree (org-element-parse-buffer nil visible-only))
(org-export--merge-external-footnote-definitions tree)
(org-export--prune-tree tree info) (org-export--remove-uninterpreted-data
tree info) (setq tree (org-export-filter-apply-functions (plist-get info
:filter-parse-tree) tree info)) (setq info
(org-export--collect-tree-properties tree info)) (let* ((body ...)
(inner-template ...) (full-body ...) (template ...)) (org-no-properties
(org-export-filter-apply-functions ... ... info))))) (and (buffer-live-p
--buf-copy) (progn (save-current-buffer (set-buffer --buf-copy)
(restore-buffer-modified-p nil)) (kill-buffer --buf-copy))))))
  (save-restriction (cond ((org-region-active-p) (narrow-to-region
(region-beginning) (region-end))) (subtreep (org-narrow-to-subtree)
(goto-char (point-min)) (forward-line) (narrow-to-region (point)
(point-max)))) (let* ((org-export-current-backend (progn nil (or (progn nil
(and ... ... ... t)) (signal (quote wrong-type-argument) (list ...
backend))) (aref backend 1))) (info (org-combine-plists
(org-export--get-export-attributes backend subtreep visible-only body-only)
(org-export--get-buffer-attributes))) (parsed-keywords (delq nil (mapcar
(function (lambda ... ...)) (append (org-export-get-all-options backend)
org-export-options-alist)))) tree) (let ((--buf-copy
(org-export-copy-buffer))) (unwind-protect (save-current-buffer (set-buffer
--buf-copy) (goto-char (point-min)) (progn (run-hook-with-args (quote
org-export-before-processing-hook) (progn nil ... ...))
(org-export-expand-include-keyword) (org-export--delete-comments)
(org-macro-initialize-templates) (org-macro-replace-all org-macro-templates
nil parsed-keywords) (org-set-regexps-and-options)
(org-update-radio-target-regexp) (org-export-execute-babel-code)
(org-set-regexps-and-options) (org-update-radio-target-regexp) (goto-char
(point-min)) (save-excursion (run-hook-with-args ... ...))
(org-set-regexps-and-options) (org-update-radio-target-regexp) (setq info
(org-export-install-filters ...)) (let (...) (let ... ...))
(org-macro-replace-all (list ... ... ... ... ...) (quote finalize)
parsed-keywords) (setq tree (org-element-parse-buffer nil visible-only))
(org-export--merge-external-footnote-definitions tree)
(org-export--prune-tree tree info) (org-export--remove-uninterpreted-data
tree info) (setq tree (org-export-filter-apply-functions ... tree info))
(setq info (org-export--collect-tree-properties tree info)) (let* (... ...
... ...) (org-no-properties ...)))) (and (buffer-live-p --buf-copy) (progn
(save-current-buffer (set-buffer --buf-copy) (restore-buffer-modified-p
nil)) (kill-buffer --buf-copy)))))))
  (save-excursion (save-restriction (cond ((org-region-active-p)
(narrow-to-region (region-beginning) (region-end))) (subtreep
(org-narrow-to-subtree) (goto-char (point-min)) (forward-line)
(narrow-to-region (point) (point-max)))) (let* ((org-export-current-backend
(progn nil (or (progn nil ...) (signal ... ...)) (aref backend 1))) (info
(org-combine-plists (org-export--get-export-attributes backend subtreep
visible-only body-only) (org-export--get-buffer-attributes)))
(parsed-keywords (delq nil (mapcar (function ...) (append ...
org-export-options-alist)))) tree) (let ((--buf-copy
(org-export-copy-buffer))) (unwind-protect (save-current-buffer (set-buffer
--buf-copy) (goto-char (point-min)) (progn (run-hook-with-args ... ...)
(org-export-expand-include-keyword) (org-export--delete-comments)
(org-macro-initialize-templates) (org-macro-replace-all org-macro-templates
nil parsed-keywords) (org-set-regexps-and-options)
(org-update-radio-target-regexp) (org-export-execute-babel-code)
(org-set-regexps-and-options) (org-update-radio-target-regexp) (goto-char
...) (save-excursion ...) (org-set-regexps-and-options)
(org-update-radio-target-regexp) (setq info ...) (let ... ...)
(org-macro-replace-all ... ... parsed-keywords) (setq tree ...)
(org-export--merge-external-footnote-definitions tree)
(org-export--prune-tree tree info) (org-export--remove-uninterpreted-data
tree info) (setq tree ...) (setq info ...) (let* ... ...))) (and
(buffer-live-p --buf-copy) (progn (save-current-buffer ... ...)
(kill-buffer --buf-copy))))))))
  org-export-as(html nil nil nil (:output-file "./org-bug2.html"))
  (let ((output (org-export-as backend subtreep visible-only body-only
ext-plist))) (let ((temp-buffer (generate-new-buffer " *temp*")))
(save-current-buffer (set-buffer temp-buffer) (unwind-protect (progn
(insert output) (let ((coding-system-for-write encoding)) (write-file
file))) (and (buffer-name temp-buffer) (kill-buffer temp-buffer))))) (if
(and (org-export--copy-to-kill-ring-p) (org-string-nw-p output)) (progn
(org-kill-new output))) (or (and (functionp post-process) (funcall
post-process file)) file))
  (if async (let ((with-temp-message "Initializing asynchronous export
process") (current-message)) (unwind-protect (progn (if with-temp-message
(progn (setq current-message (current-message)) (message "%s"
with-temp-message))) (let ((--copy-fun (org-export--generate-copy-script
...)) (--temp-file (make-temp-file "org-export-process")) (--coding
buffer-file-coding-system)) (let ((temp-file --temp-file) (temp-buffer
...)) (unwind-protect (prog1 ... ...) (and ... ...))) (let*
((process-connection-type nil) (--proc-buffer ...) (--process ...))
(org-export-add-to-stack (get-buffer --proc-buffer) nil --process) (let
(...) (set-process-sentinel --process ...))))) (and with-temp-message (if
current-message (message "%s" current-message) (message nil))))) (let
((output (org-export-as backend subtreep visible-only body-only
ext-plist))) (let ((temp-buffer (generate-new-buffer " *temp*")))
(save-current-buffer (set-buffer temp-buffer) (unwind-protect (progn
(insert output) (let (...) (write-file file))) (and (buffer-name
temp-buffer) (kill-buffer temp-buffer))))) (if (and
(org-export--copy-to-kill-ring-p) (org-string-nw-p output)) (progn
(org-kill-new output))) (or (and (functionp post-process) (funcall
post-process file)) file)))
  (let ((ext-plist (org-combine-plists (list (quote :output-file) file)
ext-plist)) (encoding (or org-export-coding-system
buffer-file-coding-system))) (if async (let ((with-temp-message
"Initializing asynchronous export process") (current-message))
(unwind-protect (progn (if with-temp-message (progn (setq current-message
...) (message "%s" with-temp-message))) (let ((--copy-fun ...) (--temp-file
...) (--coding buffer-file-coding-system)) (let (... ...) (unwind-protect
... ...)) (let* (... ... ...) (org-export-add-to-stack ... nil --process)
(let ... ...)))) (and with-temp-message (if current-message (message "%s"
current-message) (message nil))))) (let ((output (org-export-as backend
subtreep visible-only body-only ext-plist))) (let ((temp-buffer
(generate-new-buffer " *temp*"))) (save-current-buffer (set-buffer
temp-buffer) (unwind-protect (progn (insert output) (let ... ...)) (and
(buffer-name temp-buffer) (kill-buffer temp-buffer))))) (if (and
(org-export--copy-to-kill-ring-p) (org-string-nw-p output)) (progn
(org-kill-new output))) (or (and (functionp post-process) (funcall
post-process file)) file))))
  (if (not (file-writable-p file)) (error "Output file not writable") (let
((ext-plist (org-combine-plists (list (quote :output-file) file)
ext-plist)) (encoding (or org-export-coding-system
buffer-file-coding-system))) (if async (let ((with-temp-message
"Initializing asynchronous export process") (current-message))
(unwind-protect (progn (if with-temp-message (progn ... ...)) (let (... ...
...) (let ... ...) (let* ... ... ...))) (and with-temp-message (if
current-message (message "%s" current-message) (message nil))))) (let
((output (org-export-as backend subtreep visible-only body-only
ext-plist))) (let ((temp-buffer (generate-new-buffer " *temp*")))
(save-current-buffer (set-buffer temp-buffer) (unwind-protect (progn ...
...) (and ... ...)))) (if (and (org-export--copy-to-kill-ring-p)
(org-string-nw-p output)) (progn (org-kill-new output))) (or (and
(functionp post-process) (funcall post-process file)) file)))))
  org-export-to-file(html "./org-bug2.html" nil nil nil nil nil)
  (let* ((extension (concat "." (or (plist-get ext-plist :html-extension)
org-html-extension "html"))) (file (org-export-output-file-name extension
subtreep)) (org-export-coding-system org-html-coding-system))
(org-export-to-file (quote html) file async subtreep visible-only body-only
ext-plist))
  org-html-export-to-html(nil nil nil nil)
  funcall(org-html-export-to-html nil nil nil nil)
  (save-excursion (if arg (progn (if (eq (marker-buffer
org-export-dispatch-last-position) (org-base-buffer (current-buffer)))
(goto-char org-export-dispatch-last-position) (move-marker
org-export-dispatch-last-position nil)))) (funcall action (and (memq (quote
async) optns) t) (and (memq (quote subtree) optns) t) (and (memq (quote
visible) optns) t) (and (memq (quote body) optns) t)))
  (cond ((eql action (quote template)) (org-export-insert-default-template
nil optns)) ((eql action (quote stack)) (org-export-stack)) ((eql action
(quote publish-current-file)) (org-publish-current-file (memq (quote force)
optns) (memq (quote async) optns))) ((eql action (quote
publish-current-project)) (org-publish-current-project (memq (quote force)
optns) (memq (quote async) optns))) ((eql action (quote
publish-choose-project)) (org-publish (assoc (completing-read "Publish
project: " org-publish-project-alist nil t) org-publish-project-alist)
(memq (quote force) optns) (memq (quote async) optns))) ((eql action (quote
publish-all)) (org-publish-all (memq (quote force) optns) (memq (quote
async) optns))) (t (save-excursion (if arg (progn (if (eq (marker-buffer
org-export-dispatch-last-position) (org-base-buffer ...)) (goto-char
org-export-dispatch-last-position) (move-marker
org-export-dispatch-last-position nil)))) (funcall action (and (memq (quote
async) optns) t) (and (memq (quote subtree) optns) t) (and (memq (quote
visible) optns) t) (and (memq (quote body) optns) t)))))
  (let* ((input (cond ((equal arg (quote (16))) (quote (stack))) ((and arg
org-export-dispatch-last-action)) (t (let ((wconfig ...)) (unwind-protect
(progn ...) (set-window-configuration wconfig)))))) (action (car input))
(optns (cdr input))) (if (memq (quote subtree) optns) nil (move-marker
org-export-dispatch-last-position nil)) (cond ((eql action (quote
template)) (org-export-insert-default-template nil optns)) ((eql action
(quote stack)) (org-export-stack)) ((eql action (quote
publish-current-file)) (org-publish-current-file (memq (quote force) optns)
(memq (quote async) optns))) ((eql action (quote publish-current-project))
(org-publish-current-project (memq (quote force) optns) (memq (quote async)
optns))) ((eql action (quote publish-choose-project)) (org-publish (assoc
(completing-read "Publish project: " org-publish-project-alist nil t)
org-publish-project-alist) (memq (quote force) optns) (memq (quote async)
optns))) ((eql action (quote publish-all)) (org-publish-all (memq (quote
force) optns) (memq (quote async) optns))) (t (save-excursion (if arg
(progn (if (eq ... ...) (goto-char org-export-dispatch-last-position)
(move-marker org-export-dispatch-last-position nil)))) (funcall action (and
(memq (quote async) optns) t) (and (memq (quote subtree) optns) t) (and
(memq (quote visible) optns) t) (and (memq (quote body) optns) t))))))
  org-export-dispatch(nil)
  funcall-interactively(org-export-dispatch nil)
  #<subr call-interactively>(org-export-dispatch nil nil)
  ad-Advice-call-interactively(#<subr call-interactively>
org-export-dispatch nil nil)
  apply(ad-Advice-call-interactively #<subr call-interactively>
(org-export-dispatch nil nil))
  call-interactively(org-export-dispatch nil nil)
  command-execute(org-export-dispatch)

Thanks a lot!!


On Thu, Mar 10, 2016 at 1:19 AM Nicolas Goaziou <mail@nicolasgoaziou.fr>
wrote:

> Hello,
>
> Shlomi Vaknin <shlomivaknin@gmail.com> writes:
>
> > I managed to make another non-working example (should I make
> > a gif showing what I see?):
> >
> > ---------------------------------------
> >  - src_elisp{3} {{{results(=3=)}}}
> >
> > * B
> >   - src_elisp{3} {{{results(=3=)}}}
> >   -
> >   -
> >   -
> >   - src_elisp{3} {{{results(=3=)}}}
> >   - src_elisp{2} {{{results(=2=)}}}
> >   - {{{results(=2=)}}}
> > ---------------------------------------
> >
> > again, removing any line from this makes export work again. Otherwise I
> get
> > =org-element--current-element: Wrong type argument: integer-or-marker-p,
> > nil=
>
> I cannot reproduce the problem. Could you send a complete backtrace with
> un-compiled Org?
>
> Also, could you try setting `org-element-use-cache' to nil?
>
> Regards,
>
> --
> Nicolas Goaziou
>

[-- Attachment #2: Type: text/html, Size: 71854 bytes --]