+;;; ox.el --- Export Framework for Org Mode -*- lexical-binding: t; -*-

+;; - The communication channel consists of a property list, which is

+;; or contextual data, all in a single place.

+;; The core functions is `org-export-as'. It returns the transcoded

+;; buffer as a string. Its derivatives are `org-export-to-buffer' and

+;; `org-export-to-file'.

+;; Eventually, a dispatcher (`org-export-dispatch') is provided in the

+;; last one.

+;; See <http://orgmode.org/worg/dev/org-export-reference.html> for

+;; more information.

+(require 'cl-lib)

+(require 'ob-exp)

+(require 'tabulated-list)

+(declare-function org-src-coderef-format "org-src" (&optional element))

+(declare-function org-src-coderef-regexp "org-src" (fmt &optional label))

+(declare-function org-publish-current-file "ox-publish" (&optional force async))

+(declare-function org-publish-current-project "ox-publish" (&optional force async))

+ '((:title "TITLE" nil nil parse)

+ (:date "DATE" nil nil parse)

+ (:author "AUTHOR" nil user-full-name parse)

+ (:language "LANGUAGE" nil org-export-default-language t)

+ (:select-tags "SELECT_TAGS" nil org-export-select-tags split)

+ (:creator "CREATOR" nil org-export-creator-string)

+ (:with-broken-links nil "broken-links" org-export-with-broken-links)

+ (:with-properties nil "prop" org-export-with-properties)

+ (:with-title nil "title" org-export-with-title)

+The key of the alist is the property name, and the value is a list

+ `parse' Parse value as a list of strings and Org objects,

+ which can then be transcoded with, e.g.,

+ `org-export-data'. It implies `space' behavior.

+ '((:filter-body . org-export-filter-body-functions)

+ (:filter-bold . org-export-filter-bold-functions)

+(defconst org-export-ignored-local-variables

+ '(org-font-lock-keywords

+ org-element--cache org-element--cache-objects org-element--cache-sync-keys

+ org-element--cache-sync-requests org-element--cache-sync-timer)

+ "List of variables not copied through upon buffer duplication.

+Export process takes place on a copy of the original buffer.

+When this copy is created, all Org related local variables not in

+this list are copied to the new buffer. Variables with an

+unreadable value are also ignored.")

+

+(defvar org-export-registered-backends nil

+

+ (const :tag "Entirely" t))

+ :safe (lambda (x) (memq x '(t nil headline))))

+ :type 'boolean

+ :safe #'booleanp)

+ :type 'boolean

+ :safe #'booleanp)

+(defcustom org-export-with-creator nil

+The sentence can be set in `org-export-creator-string', which

+see.

+This option can also be set with the OPTIONS keyword, e.g.,

+\"creator:t\"."

+ :version "26.1"

+ :package-version '(Org . "8.3")

+ :type 'boolean

+ :safe #'booleanp)

+ :type 'boolean

+ :safe #'booleanp)

+ (const :tag "No format string" nil))

+ :safe (lambda (x) (or (null x) (stringp x))))

+ :type '(string :tag "Creator string")

+ :safe #'stringp)

+drawer names to export, as strings. If that list starts with

+`not', only drawers with such names will be ignored.

+This variable doesn't apply to properties drawers. See

+`org-export-with-properties' instead.

+ (string :tag "Drawer name"))))

+ :safe (lambda (x) (or (booleanp x)

+ (and (listp x)

+ (or (cl-every #'stringp x)

+ (and (eq (nth 0 x) 'not)

+ (cl-every #'stringp (cdr x))))))))

+ :type 'boolean

+ :safe #'booleanp)

+ :type 'boolean

+ :safe #'booleanp)

+ :type '(repeat (string :tag "Tag"))

+ :safe (lambda (x) (and (listp x) (cl-every #'stringp x))))

+ "Non-nil means export lines starting with \":\".

+ :version "24.4"

+ :package-version '(Org . "8.0")

+ :type 'boolean

+ :safe #'booleanp)

+ :type 'boolean

+ :safe #'booleanp)

+ (const :tag "Leave math verbatim" verbatim))

+ :safe (lambda (x) (memq x '(t nil verbatim))))

+ :type 'integer

+ :safe #'integerp)

+ :type '(string :tag "Language")

+ :safe #'stringp)

+ :type 'boolean

+ :safe #'booleanp)

+ :type 'boolean

+ :safe #'booleanp)

+ :type 'boolean

+ :safe #'booleanp)

+ :type 'boolean

+ :safe #'booleanp)

+ :type 'boolean

+ :safe #'booleanp)

+

+(defcustom org-export-with-properties nil

+ "Non-nil means export contents of properties drawers.

+

+When t, all properties are exported. This may also be a list of

+properties to export, as strings.

+

+This option can also be set with the OPTIONS keyword,

+e.g. \"prop:t\"."

+ :group 'org-export-general

+ :version "24.4"

+ :package-version '(Org . "8.3")

+ :type '(choice

+ (const :tag "All properties" t)

+ (const :tag "None" nil)

+ (repeat :tag "Selected properties"

+ (string :tag "Property name")))

+ :safe (lambda (x) (or (booleanp x)

+ (and (listp x) (cl-every #'stringp x)))))

+ :type 'boolean

+ :safe #'booleanp)

+ :type '(repeat (string :tag "Tag"))

+ :safe (lambda (x) (and (listp x) (cl-every #'stringp x))))

+ :type 'boolean

+ :safe #'booleanp)

+ :type 'boolean

+ :safe #'booleanp)

+ :type 'boolean

+ :safe #'booleanp)

+ (const :tag "Do not interpret them" nil))

+ :safe (lambda (x) (memq x '(t nil {}))))

+ (integer :tag "TOC to level"))

+ :safe (lambda (x) (or (booleanp x)

+ (integerp x))))

+ "Non-nil means export tables.

+ :version "24.4"

+ :package-version '(Org . "8.0")

+ :type 'boolean

+ :safe #'booleanp)

+ (const :tag "On" t))

+ :safe (lambda (x) (memq x '(t nil not-in-toc))))

+ (string :tag "Keyword")))

+ :safe (lambda (x) (or (memq x '(nil t todo done))

+ (and (listp x)

+ (cl-every #'stringp x)))))

+

+(defcustom org-export-with-title t

+ "Non-nil means print title into the exported file.

+This option can also be set with the OPTIONS keyword,

+e.g. \"title:nil\"."

+ :group 'org-export-general

+ :version "26.1"

+ :package-version '(Org . "8.3")

+ :type 'boolean

+ :safe #'booleanp)

+The time stamp shows when the file was created. This option can

+ :type 'boolean

+ :safe #'booleanp)

+ (const :tag "No timestamp" nil))

+ :safe (lambda (x) (memq x '(t nil active inactive))))

+(defcustom org-export-with-broken-links nil

+ "Non-nil means do not raise an error on broken links.

+

+When this variable is non-nil, broken links are ignored, without

+stopping the export process. If it is set to `mark', broken

+links are marked as such in the output, with a string like

+

+ [BROKEN LINK: path]

+

+where PATH is the un-resolvable reference.

+

+This option can also be set with the OPTIONS keyword, e.g.,

+\"broken-links:mark\"."

+ :group 'org-export-general

+ :version "26.1"

+ :package-version '(Org . "9.0")

+ :type '(choice

+ (const :tag "Ignore broken links" t)

+ (const :tag "Mark broken links in output" mark)

+ (const :tag "Raise an error" nil)))

+

+For example, with a value of \\='((\"h\" . \"html\")), the

+ (string :tag "Back-end")))

+ :safe (lambda (x)

+ (and (listp x)

+ (cl-every #'consp x)

+ (cl-every #'stringp (mapcar #'car x))

+ (cl-every #'stringp (mapcar #'cdr x)))))

+(defcustom org-export-copy-to-kill-ring nil

+ :version "26.1"

+ :package-version '(Org . "8.3")

+automatically. But you can retrieve them with `\\[org-export-stack]'."

+(defcustom org-export-async-init-file nil

+

+Value must be either nil or an absolute file name. When nil, the

+external process is launched like a regular Emacs session,

+loading user's initialization file and any site specific

+configuration. If a file is provided, it, and only it, is loaded

+at start-up.

+

+Therefore, using a specific configuration makes the process to

+load faster and the export more portable."

+ :type '(choice

+ (const :tag "Regular startup" nil)

+ (file :tag "Specific start-up file" :must-match t)))

+(cl-defstruct (org-export-backend (:constructor org-export-create-backend)

+ (:copier nil))

+;;;###autoload

+ (cl-find-if (lambda (b) (and (eq name (org-export-backend-name b))))

+ org-export-registered-backends))

+ (if old (setcar (memq old org-export-registered-backends) backend)

+ (push backend org-export-registered-backends))))

+returns options inherited from parent back-ends, if any.

+

+Return nil if BACKEND is unknown."

+ \\='(KEY DESCRIPTION-OR-ORDINAL ACTION-OR-MENU)

+ \\='(KEY DESCRIPTION ACTION)

+ \\='(?m \"My Special Back-end\" my-special-export-function)

+ \\='(?l \"Export to LaTeX\"

+ \\='(?l 1

+ (let (filters menu-entry options)

+ (let ((keyword (pop body)))

+ (pcase keyword

+ (:filters-alist (setq filters (pop body)))

+ (:menu-entry (setq menu-entry (pop body)))

+ (:options-alist (setq options (pop body)))

+ (_ (error "Unknown keyword: %s" keyword)))))

+ (let (filters menu-entry options transcoders)

+ (let ((keyword (pop body)))

+ (pcase keyword

+ (:filters-alist (setq filters (pop body)))

+ (:menu-entry (setq menu-entry (pop body)))

+ (:options-alist (setq options (pop body)))

+ (:translate-alist (setq transcoders (pop body)))

+ (_ (error "Unknown keyword: %s" keyword)))))

+;; just before export, by `org-export--collect-tree-properties'.

+;;;###autoload

+ (set (make-local-variable (car pair)) (nth 1 pair)))

+ (and subtreep (org-export--get-subtree-options backend))))

+ (let ((line

+ (let ((s 0) alist)

+ (while (string-match "\\(.+?\\):\\((.*?)\\|\\S-*\\)[ \t]*" options s)

+ (setq s (match-end 0))

+ (push (cons (match-string 1 options)

+ (read (match-string 2 options)))

+ alist))

+ alist))

+ ;; Priority is given to back-end specific options.

+ (all (append (org-export-get-all-options backend)

+ org-export-options-alist))

+ (plist))

+ (when line

+ (dolist (entry all plist)

+ (let ((item (nth 2 entry)))

+ (when item

+ (let ((v (assoc-string item line t)))

+ (when v (setq plist (plist-put plist (car entry) (cdr v)))))))))))

+ ;; same property in communication channel. The name for the

+ ;; property is the keyword with "EXPORT_" appended to it.

+ ;; Make sure point is at a heading.

+ (if (org-at-heading-p) (org-up-heading-safe) (org-back-to-heading t))

+ (let ((plist

+ ;; EXPORT_OPTIONS are parsed in a non-standard way. Take

+ ;; care of them right from the start.

+ (let ((o (org-entry-get (point) "EXPORT_OPTIONS" 'selective)))

+ (and o (org-export--parse-option-keyword o backend))))

+ ;; Take care of EXPORT_TITLE. If it isn't defined, use

+ ;; headline's title (with no todo keyword, priority cookie or

+ ;; tag) as its fallback value.

+ (cache (list

+ (cons "TITLE"

+ (or (org-entry-get (point) "EXPORT_TITLE" 'selective)

+ (let ((case-fold-search nil))

+ (looking-at org-complex-heading-regexp)

+ (match-string-no-properties 4))))))

+ ;; Look for both general keywords and back-end specific

+ ;; options, with priority given to the latter.

+ (options (append (org-export-get-all-options backend)

+ org-export-options-alist)))

+ ;; Handle other keywords. Then return PLIST.

+ (dolist (option options plist)

+ (let ((property (car option))

+ (keyword (nth 1 option)))

+ (when keyword

+ (let ((value

+ (or (cdr (assoc keyword cache))

+ (let ((v (org-entry-get (point)

+ (concat "EXPORT_" keyword)

+ 'selective)))

+ (push (cons keyword v) cache) v))))

+ (when value

+ (setq plist

+ (plist-put plist

+ property

+ (cl-case (nth 4 option)

+ (parse

+ (org-element-parse-secondary-string

+ value (org-element-restriction 'keyword)))

+ (split (org-split-string value))

+ (t value))))))))))))

+ (let* ((case-fold-search t)

+ (org-export-get-all-options backend)

+ (regexp-opt (nconc (delq nil (mapcar #'cadr options))

+ plist to-parse)

+ (letrec ((find-properties

+ (lambda (keyword)

+ ;; Return all properties associated to KEYWORD.

+ (let (properties)

+ (dolist (option options properties)

+ (when (equal (nth 1 option) keyword)

+ (cl-pushnew (car option) properties))))))

+ (get-options

+ (lambda (&optional files)

+ ;; Recursively read keywords in buffer. FILES is

+ ;; a list of files read so far. PLIST is the current

+ ;; property list obtained.

+ (org-with-wide-buffer

+ (goto-char (point-min))

+ (while (re-search-forward regexp nil t)

+ (let ((element (org-element-at-point)))

+ (when (eq (org-element-type element) 'keyword)

+ (let ((key (org-element-property :key element))

+ (val (org-element-property :value element)))

+ (cond

+ ;; Options in `org-export-special-keywords'.

+ ((equal key "SETUPFILE")

+ (let ((file

+ (expand-file-name

+ (org-unbracket-string "\"" "\"" (org-trim val)))))

+ ;; Avoid circular dependencies.

+ (unless (member file files)

+ (with-temp-buffer

+ (setq default-directory

+ (file-name-directory file))

+ (insert (org-file-contents file 'noerror))

+ (let ((org-inhibit-startup t)) (org-mode))

+ (funcall get-options (cons file files))))))

+ ((equal key "OPTIONS")

+ (org-combine-plists

+ plist

+ (org-export--parse-option-keyword

+ val backend))))

+ ((equal key "FILETAGS")

+ (setq plist

+ (org-combine-plists

+ plist

+ (list :filetags

+ (org-uniquify

+ (append

+ (org-split-string val ":")

+ (plist-get plist :filetags)))))))

+ (t

+ ;; Options in `org-export-options-alist'.

+ (dolist (property (funcall find-properties key))

+ (setq

+ plist

+ (plist-put

+ plist property

+ ;; Handle value depending on specified

+ ;; BEHAVIOR.

+ (cl-case (nth 4 (assq property options))

+ (parse

+ (unless (memq property to-parse)

+ (push property to-parse))

+ ;; Even if `parse' implies `space'

+ ;; behavior, we separate line with

+ ;; "\n" so as to preserve

+ ;; line-breaks. However, empty

+ ;; lines are forbidden since `parse'

+ ;; doesn't allow more than one

+ ;; paragraph.

+ (let ((old (plist-get plist property)))

+ (cond ((not (org-string-nw-p val)) old)

+ (old (concat old "\n" val))

+ (t val))))

+ (space

+ (if (not (plist-get plist property))

+ (org-trim val)

+ (concat (plist-get plist property)

+ " "

+ (org-trim val))))

+ (newline

+ (org-trim

+ (concat (plist-get plist property)

+ "\n"

+ (org-trim val))))

+ (split `(,@(plist-get plist property)

+ ,@(org-split-string val)))

+ ((t) val)

+ (otherwise

+ (if (not (plist-member plist property)) val

+ (plist-get plist property)))))))))))))))))

+ ;; Read options in the current buffer and return value.

+ (funcall get-options (and buffer-file-name (list buffer-file-name)))

+ ;; Parse properties in TO-PARSE. Remove newline characters not

+ ;; involved in line breaks to simulate `space' behavior.

+ ;; Finally return options.

+ (dolist (p to-parse plist)

+ (let ((value (org-element-parse-secondary-string

+ (plist-get plist p)

+ (org-element-restriction 'keyword))))

+ (org-element-map value 'plain-text

+ (lambda (s)

+ (org-element-set-element

+ s (replace-regexp-in-string "\n" " " s))))

+ (setq plist (plist-put plist p value)))))))

+

+(defun org-export--get-export-attributes

+ (&optional backend subtreep visible-only body-only)

+ "Return properties related to export process, as a plist.

+Optional arguments BACKEND, SUBTREEP, VISIBLE-ONLY and BODY-ONLY

+are like the arguments with the same names of function

+`org-export-as'."

+ (list :export-options (delq nil

+ (list (and subtreep 'subtree)

+ (and visible-only 'visible-only)

+ (and body-only 'body-only)))

+ :back-end backend

+ :translate-alist (org-export-get-all-transcoders backend)

+ :exported-data (make-hash-table :test #'eq :size 4001)))

+ (list :input-buffer (buffer-name (buffer-base-buffer))

+ :input-file (buffer-file-name (buffer-base-buffer))))

+ (all (append (org-export-get-all-options backend)

+ ;; Evaluate default value provided.

+ (if (eq (nth 4 cell) 'parse)

+ (letrec ((collect-bind

+ (lambda (files alist)

+ ;; Return an alist between variable names and their

+ ;; value. FILES is a list of setup files names read

+ ;; so far, used to avoid circular dependencies. ALIST

+ ;; is the alist collected so far.

+ (let ((case-fold-search t))

+ (org-with-wide-buffer

+ (goto-char (point-min))

+ (while (re-search-forward

+ "^[ \t]*#\\+\\(BIND\\|SETUPFILE\\):" nil t)

+ (let ((element (org-element-at-point)))

+ (when (eq (org-element-type element) 'keyword)

+ (let ((val (org-element-property :value element)))

+ (if (equal (org-element-property :key element)

+ "BIND")

+ (push (read (format "(%s)" val)) alist)

+ ;; Enter setup file.

+ (let ((file (expand-file-name

+ (org-unbracket-string "\"" "\"" val))))

+ (unless (member file files)

+ (with-temp-buffer

+ (setq default-directory

+ (file-name-directory file))

+ (let ((org-inhibit-startup t)) (org-mode))

+ (insert (org-file-contents file 'noerror))

+ (setq alist

+ (funcall collect-bind

+ (cons file files)

+ alist))))))))))

+ alist)))))

+;; `org-export--collect-tree-properties'.

+(defun org-export--collect-tree-properties (data info)

+`:headline-numbering' Alist of all headlines as key and the

+`:id-alist' Alist of all ID references as key and associated file

+ as value.

+ ;; Install the parse tree in the communication channel.

+ ;; From now on, properties order doesn't matter: get the rest of the

+ ;; tree properties.

+ (org-combine-plists

+ info

+ (list :headline-numbering (org-export--collect-headline-numbering data info)

+ :id-alist

+ (org-element-map data 'link

+ (lambda (l)

+ (and (string= (org-element-property :type l) "id")

+ (let* ((id (org-element-property :path l))

+ (file (car (org-id-find id))))

+ (and file (cons id (file-relative-name file))))))))))

+ (dolist (datum (org-element-contents data))

+ (when (and (eq (org-element-type datum) 'headline)

+ (not (org-element-property :footnote-section-p datum))

+ (not (memq datum (plist-get options :ignore-list))))

+ (setq min-level (min (org-element-property :level datum) min-level))

+ (when (= min-level 1) (throw 'exit 1))))

+ "Return numbering of all exportable, numbered headlines in a parse tree.

+ (when (and (org-export-numbered-headline-p headline options)

+ (not (org-element-property :footnote-section-p headline)))

+ (cl-loop

+ for n across numbering

+ for idx from 0 to org-export-max-depth

+ when (< idx relative-level) collect n

+ when (= idx relative-level) collect (aset numbering idx (1+ n))

+ when (> idx relative-level) do (aset numbering idx 0))))))

+ "List headlines and inlinetasks with a select tag in their tree.

+ (let ((select (plist-get info :select-tags)))

+ (if (cl-some (lambda (tag) (member tag select)) (plist-get info :filetags))

+ ;; If FILETAGS contains a select tag, every headline or

+ ;; inlinetask is returned.

+ (org-element-map data '(headline inlinetask) #'identity)

+ (letrec ((selected-trees nil)

+ (walk-data

+ (lambda (data genealogy)

+ (let ((type (org-element-type data)))

+ (cond

+ ((memq type '(headline inlinetask))

+ (let ((tags (org-element-property :tags data)))

+ (if (cl-some (lambda (tag) (member tag select)) tags)

+ ;; When a select tag is found, mark full

+ ;; genealogy and every headline within the

+ ;; tree as acceptable.

+ (setq selected-trees

+ (append

+ genealogy

+ (org-element-map data '(headline inlinetask)

+ #'identity)

+ selected-trees))

+ ;; If at a headline, continue searching in

+ ;; tree, recursively.

+ (when (eq type 'headline)

+ (dolist (el (org-element-contents data))

+ (funcall walk-data el (cons data genealogy)))))))

+ ((or (eq type 'org-data)

+ (memq type org-element-greater-elements))

+ (dolist (el (org-element-contents data))

+ (funcall walk-data el genealogy))))))))

+ (funcall walk-data data nil)

+ selected-trees))))

+

+(defun org-export--skip-p (datum options selected)

+ "Non-nil when element or object DATUM should be skipped during export.

+ (cl-case (org-element-type datum)

+ ((comment comment-block)

+ ;; Skip all comments and comment blocks. Make to keep maximum

+ ;; number of blank lines around the comment so as to preserve

+ ;; local structure of the document upon interpreting it back into

+ ;; Org syntax.

+ (let* ((previous (org-export-get-previous-element datum options))

+ (before (or (org-element-property :post-blank previous) 0))

+ (after (or (org-element-property :post-blank datum) 0)))

+ (when previous

+ (org-element-put-property previous :post-blank (max before after 1))))

+ t)

+ (let ((name (org-element-property :drawer-name datum)))

+ (fixed-width (not (plist-get options :with-fixed-width)))

+ (todo (org-element-property :todo-keyword datum))

+ (todo-type (org-element-property :todo-type datum))

+ (tags (org-export-get-tags datum options nil t)))

+ (and (eq (org-element-type datum) 'inlinetask)

+ (cl-loop for k in (plist-get options :exclude-tags)

+ thereis (member k tags))

+ (and selected (not (memq datum selected)))

+ (org-element-property :commentedp datum)

+ (and (not archived) (org-element-property :archivedp datum))

+ (node-property

+ (let ((properties-set (plist-get options :with-properties)))

+ (cond ((null properties-set) t)

+ ((consp properties-set)

+ (not (member-ignore-case (org-element-property :key datum)

+ properties-set))))))

+ (property-drawer (not (plist-get options :with-properties)))

+ (table (not (plist-get options :with-tables)))

+ (org-export-get-parent-table datum))

+ (org-export-first-sibling-p datum options)))

+ (table-row (org-export-table-row-is-special-p datum options))

+ (when (let ((parent (org-export-get-parent-element datum)))

+ (cl-case (plist-get options :with-timestamps)

+ ((nil) t)

+ (not (memq (org-element-property :type datum) '(active active-range))))

+ (not (memq (org-element-property :type datum)

+ (if (eq type 'org-data) (lambda (_datum contents _info) contents)

+ ;; Handle broken links according to

+ ;; `org-export-with-broken-links'.

+ (cl-macrolet

+ ((broken-link-handler

+ (&rest body)

+ `(condition-case err

+ (progn ,@body)

+ (org-link-broken

+ (pcase (plist-get info :with-broken-links)

+ (`nil (user-error "Unable to resolve link: %S" (nth 1 err)))

+ (`mark (org-export-data

+ (format "[BROKEN LINK: %s]" (nth 1 err)) info))

+ (_ nil))))))

+ (let* ((type (org-element-type data))

+ (parent (org-export-get-parent data))

+ (results

+ (cond

+ ;; Ignored element/object.

+ ((memq data (plist-get info :ignore-list)) nil)

+ ;; Plain text.

+ ((eq type 'plain-text)

+ (org-export-filter-apply-functions

+ (plist-get info :filter-plain-text)

+ (let ((transcoder (org-export-transcoder data info)))

+ (if transcoder (funcall transcoder data info) data))

+ info))

+ ;; Secondary string.

+ ((not type)

+ (mapconcat (lambda (obj) (org-export-data obj info)) data ""))

+ ;; Element/Object without contents or, as a special

+ ;; case, headline with archive tag and archived trees

+ ;; restricted to title only.

+ ((or (not (org-element-contents data))

+ (and (eq type 'headline)

+ (eq (plist-get info :with-archived-trees) 'headline)

+ (org-element-property :archivedp data)))

+ (let ((transcoder (org-export-transcoder data info)))

+ (or (and (functionp transcoder)

+ (broken-link-handler

+ (funcall transcoder data nil info)))

+ ;; Export snippets never return a nil value so

+ ;; that white spaces following them are never

+ ;; ignored.

+ (and (eq type 'export-snippet) ""))))

+ ;; Element/Object with contents.

+ (t

+ (let ((transcoder (org-export-transcoder data info)))

+ (when transcoder

+ (let* ((greaterp (memq type org-element-greater-elements))

+ (objectp

+ (and (not greaterp)

+ (memq type org-element-recursive-objects)))

+ (contents

+ (mapconcat

+ (lambda (element) (org-export-data element info))

+ (org-element-contents

+ (if (or greaterp objectp) data

+ ;; Elements directly containing

+ ;; objects must have their indentation

+ ;; normalized first.

+ (org-element-normalize-contents

+ data

+ ;; When normalizing contents of the

+ ;; first paragraph in an item or

+ ;; a footnote definition, ignore

+ ;; first line's indentation: there is

+ ;; none and it might be misleading.

+ (when (eq type 'paragraph)

+ '(footnote-definition item)))))))

+ "")))

+ (broken-link-handler

+ (funcall transcoder data

+ (if (not greaterp) contents

+ (org-element-normalize-string contents))

+ info)))))))))

+ ;; Final result will be memoized before being returned.

+ (puthash

+ data

+ (cond

+ ((not results) "")

+ ((memq type '(org-data plain-text nil)) results)

+ ;; Append the same white space between elements or objects

+ ;; as in the original buffer, and call appropriate filters.

+ (t

+ (org-export-filter-apply-functions

+ (plist-get info (intern (format ":filter-%s" type)))

+ (let ((blank (or (org-element-property :post-blank data) 0)))

+ (if (eq (org-element-class data parent) 'object)

+ (concat results (make-string blank ?\s))

+ (concat (org-element-normalize-string results)

+ (make-string blank ?\n))))

+ info)))

+ (plist-get info :exported-data))))))

+ ;; Set-up a new communication channel with translations defined in

+ ;; BACKEND as the translate table and a new hash table for

+ ;; memoization.

+ (let ((new-info

+ (org-combine-plists

+ info

+ (list :back-end backend

+ :translate-alist (org-export-get-all-transcoders backend)

+ ;; Size of the hash table is reduced since this

+ ;; function will probably be used on small trees.

+ :exported-data (make-hash-table :test 'eq :size 401)))))

+ (prog1 (org-export-data data new-info)

+ ;; Preserve `:internal-references', as those do not depend on

+ ;; the back-end used; we need to make sure that any new

+ ;; reference when the temporary back-end was active gets through

+ ;; the default one.

+ (plist-put info :internal-references

+ (plist-get new-info :internal-references)))))

+ (concat (and with-affiliated

+ (eq (org-element-class blob) 'element)

+;; - `:filter-body' applies to the body of the output, before template

+;; translator chimes in. Users can set it through

+;; `org-export-filter-body-functions' variable.

+;;

+;; variable.

+;; `org-export-filter-TYPE-functions' to install these filters.

+(defvar org-export-filter-body-functions nil

+ "List of functions applied to transcoded body.

+Each filter is called with three arguments: a string which

+contains no Org syntax, the back-end, as a symbol, and the

+communication channel, as a plist. It must return a string or

+nil.")

+

+Functions are called with three arguments: a value, the export

+back-end name and the communication channel. First function in

+FILTERS is called with VALUE as its first argument. Second

+function in FILTERS is called with the previous result as its

+value, etc.

+

+Functions returning nil are skipped. Any function returning the

+empty string ends the process, which returns the empty string.

+ (catch :exit

+ (cond ((not result))

+ ((equal result "") (throw :exit ""))

+ (dolist (p org-export-filters-alist)

+ (let* ((prop (car p))

+ (info-value (plist-get info prop))

+ (default-value (symbol-value (cdr p))))

+ (setq plist

+ (plist-put plist prop

+ ;; Filters in INFO will be called

+ ;; before those user provided.

+ (append (if (listp info-value) info-value

+ (list info-value))

+ default-value)))))

+ (dolist (p (org-export-get-all-filters (plist-get info :back-end)))

+ ;; Single values get consed, lists are appended.

+ (let ((key (car p)) (value (cdr p)))

+ (when value

+ (setq plist

+ (plist-put

+ plist key

+ (if (atom value) (cons value (plist-get plist key))

+ (append value (plist-get plist key))))))))

+ (and (not (memq var org-export-ignored-local-variables))

+ (dolist (ov (overlays-in (point-min) (point-max)) ov-set)

+ (let ((invis-prop (overlay-get ov 'invisible)))

+ (when invis-prop

+ (push `(overlay-put

+ (make-overlay ,(overlay-start ov)

+ ,(overlay-end ov))

+ 'invisible (quote ,invis-prop))

+ ov-set)))))))))

+

+(defun org-export--delete-comment-trees ()

+ "Delete commented trees and commented inlinetasks in the buffer.

+Narrowing, if any, is ignored."

+ (org-with-wide-buffer

+ (goto-char (point-min))

+ (let* ((case-fold-search t)

+ (regexp (concat org-outline-regexp-bol ".*" org-comment-string)))

+ (while (re-search-forward regexp nil t)

+ (let ((element (org-element-at-point)))

+ (when (org-element-property :commentedp element)

+ (delete-region (org-element-property :begin element)

+ (org-element-property :end element))))))))

+

+(defun org-export--prune-tree (data info)

+ "Prune non exportable elements from DATA.

+DATA is the parse tree to traverse. INFO is the plist holding

+export info. Also set `:ignore-list' in INFO to a list of

+objects which should be ignored during export, but not removed

+from tree."

+ (letrec ((ignore nil)

+ ;; First find trees containing a select tag, if any.

+ (selected (org-export--selected-trees data info))

+ (walk-data

+ (lambda (data)

+ ;; Prune non-exportable elements and objects from tree.

+ ;; As a special case, special rows and cells from tables

+ ;; are stored in IGNORE, as they still need to be

+ ;; accessed during export.

+ (when data

+ (let ((type (org-element-type data)))

+ (if (org-export--skip-p data info selected)

+ (if (memq type '(table-cell table-row)) (push data ignore)

+ (org-element-extract-element data))

+ (if (and (eq type 'headline)

+ (eq (plist-get info :with-archived-trees)

+ 'headline)

+ (org-element-property :archivedp data))

+ ;; If headline is archived but tree below has

+ ;; to be skipped, remove contents.

+ (org-element-set-contents data)

+ ;; Move into recursive objects/elements.

+ (mapc walk-data (org-element-contents data)))

+ ;; Move into secondary string, if any.

+ (dolist (p (cdr (assq type

+ org-element-secondary-value-alist)))

+ (mapc walk-data (org-element-property p data))))))))

+ (definitions

+ ;; Collect definitions before possibly pruning them so as

+ ;; to avoid parsing them again if they are required.

+ (org-element-map data '(footnote-definition footnote-reference)

+ (lambda (f)

+ (cond

+ ((eq (org-element-type f) 'footnote-definition) f)

+ ((eq (org-element-property :type f) 'standard) nil)

+ (t (let ((label (org-element-property :label f)))

+ (when label ;Skip anonymous references.

+ (apply

+ #'org-element-create

+ 'footnote-definition `(:label ,label :post-blank 1)

+ (org-element-contents f))))))))))

+ ;; If a select tag is active, also ignore the section before the

+ ;; first headline, if any.

+ (when selected

+ (let ((first-element (car (org-element-contents data))))

+ (when (eq (org-element-type first-element) 'section)

+ (org-element-extract-element first-element))))

+ ;; Prune tree and communication channel.

+ (funcall walk-data data)

+ (dolist (entry (append

+ ;; Priority is given to back-end specific options.

+ (org-export-get-all-options (plist-get info :back-end))

+ org-export-options-alist))

+ (when (eq (nth 4 entry) 'parse)

+ (funcall walk-data (plist-get info (car entry)))))

+ (let ((missing (org-export--missing-definitions data definitions)))

+ (funcall walk-data missing)

+ (org-export--install-footnote-definitions missing data))

+ ;; Eventually set `:ignore-list'.

+ (plist-put info :ignore-list ignore)))

+

+(defun org-export--missing-definitions (tree definitions)

+ "List footnote definitions missing from TREE.

+Missing definitions are searched within DEFINITIONS, which is

+a list of footnote definitions or in the widened buffer."

+ (let* ((list-labels

+ (lambda (data)

+ ;; List all footnote labels encountered in DATA. Inline

+ ;; footnote references are ignored.

+ (org-element-map data 'footnote-reference

+ (lambda (reference)

+ (and (eq (org-element-property :type reference) 'standard)

+ (org-element-property :label reference))))))

+ defined undefined missing-definitions)

+ ;; Partition DIRECT-REFERENCES between DEFINED and UNDEFINED

+ ;; references.

+ (let ((known-definitions

+ (org-element-map tree '(footnote-reference footnote-definition)

+ (lambda (f)

+ (and (or (eq (org-element-type f) 'footnote-definition)

+ (eq (org-element-property :type f) 'inline))

+ (org-element-property :label f)))))

+ seen)

+ (dolist (l (funcall list-labels tree))

+ (cond ((member l seen))

+ ((member l known-definitions) (push l defined))

+ (t (push l undefined)))))

+ ;; Complete MISSING-DEFINITIONS by finding the definition of every

+ ;; undefined label, first by looking into DEFINITIONS, then by

+ ;; searching the widened buffer. This is a recursive process

+ ;; since definitions found can themselves contain an undefined

+ ;; reference.

+ (while undefined

+ (let* ((label (pop undefined))

+ (definition

+ (cond

+ ((cl-some

+ (lambda (d) (and (equal (org-element-property :label d) label)

+ d))

+ definitions))

+ ((pcase (org-footnote-get-definition label)

+ (`(,_ ,beg . ,_)

+ (org-with-wide-buffer

+ (goto-char beg)

+ (let ((datum (org-element-context)))

+ (if (eq (org-element-type datum) 'footnote-reference)

+ datum

+ ;; Parse definition with contents.

+ (save-restriction

+ (narrow-to-region

+ (org-element-property :begin datum)

+ (org-element-property :end datum))

+ (org-element-map (org-element-parse-buffer)

+ 'footnote-definition #'identity nil t))))))

+ (_ nil)))

+ (t (user-error "Definition not found for footnote %s" label)))))

+ (push label defined)

+ (push definition missing-definitions)

+ ;; Look for footnote references within DEFINITION, since

+ ;; we may need to also find their definition.

+ (dolist (l (funcall list-labels definition))

+ (unless (or (member l defined) ;Known label

+ (member l undefined)) ;Processed later

+ (push l undefined)))))

+ ;; MISSING-DEFINITIONS may contain footnote references with inline

+ ;; definitions. Make sure those are changed into real footnote

+ ;; definitions.

+ (mapcar (lambda (d)

+ (if (eq (org-element-type d) 'footnote-definition) d

+ (let ((label (org-element-property :label d)))

+ (apply #'org-element-create

+ 'footnote-definition `(:label ,label :post-blank 1)

+ (org-element-contents d)))))

+ missing-definitions)))

+

+(defun org-export--install-footnote-definitions (definitions tree)

+ "Install footnote definitions in tree.

+

+DEFINITIONS is the list of footnote definitions to install. TREE

+is the parse tree.

+

+If there is a footnote section in TREE, definitions found are

+appended to it. If `org-footnote-section' is non-nil, a new

+footnote section containing all definitions is inserted in TREE.

+Otherwise, definitions are appended at the end of the section

+containing their first reference."

+ (cond

+ ((null definitions))

+ ;; If there is a footnote section, insert definitions there.

+ ((let ((footnote-section

+ (org-element-map tree 'headline

+ (lambda (h) (and (org-element-property :footnote-section-p h) h))

+ nil t)))

+ (and footnote-section

+ (apply #'org-element-adopt-elements

+ footnote-section

+ (nreverse definitions)))))

+ ;; If there should be a footnote section, create one containing all

+ ;; the definitions at the end of the tree.

+ (org-footnote-section

+ (org-element-adopt-elements

+ tree

+ (org-element-create 'headline

+ (list :footnote-section-p t

+ :level 1

+ :title org-footnote-section

+ :raw-value org-footnote-section)

+ (apply #'org-element-create

+ 'section

+ nil

+ (nreverse definitions)))))

+ ;; Otherwise add each definition at the end of the section where it

+ ;; is first referenced.

+ (t

+ (letrec ((seen nil)

+ (insert-definitions

+ (lambda (data)

+ ;; Insert footnote definitions in the same section as

+ ;; their first reference in DATA.

+ (org-element-map data 'footnote-reference

+ (lambda (reference)

+ (when (eq (org-element-property :type reference) 'standard)

+ (let ((label (org-element-property :label reference)))

+ (unless (member label seen)

+ (push label seen)

+ (let ((definition

+ (cl-some

+ (lambda (d)

+ (and (equal (org-element-property :label d)

+ label)

+ d))

+ definitions)))

+ (org-element-adopt-elements

+ (org-element-lineage reference '(section))

+ definition)

+ ;; Also insert definitions for nested

+ ;; references, if any.

+ (funcall insert-definitions definition))))))))))

+ (funcall insert-definitions tree)))))

+

+(defun org-export--remove-uninterpreted-data (data info)

+ "Change uninterpreted elements back into Org syntax.

+DATA is a parse tree or a secondary string. INFO is a plist

+containing export options. It is modified by side effect and

+returned by the function."

+ (org-element-map data

+ '(entity bold italic latex-environment latex-fragment strike-through

+ subscript superscript underline)

+ (lambda (datum)

+ (let ((new

+ (cl-case (org-element-type datum)

+ ;; ... entities...

+ (entity

+ (and (not (plist-get info :with-entities))

+ (list (concat

+ (org-export-expand datum nil)

+ (make-string

+ (or (org-element-property :post-blank datum) 0)

+ ?\s)))))

+ ;; ... emphasis...

+ ((bold italic strike-through underline)

+ (and (not (plist-get info :with-emphasize))

+ (let ((marker (cl-case (org-element-type datum)

+ (bold "*")

+ (italic "/")

+ (strike-through "+")

+ (underline "_"))))

+ (append

+ (list marker)

+ (org-element-contents datum)

+ (list (concat

+ marker

+ (make-string

+ (or (org-element-property :post-blank datum)

+ 0)

+ ?\s)))))))

+ ;; ... LaTeX environments and fragments...

+ ((latex-environment latex-fragment)

+ (and (eq (plist-get info :with-latex) 'verbatim)

+ (list (org-export-expand datum nil))))

+ ;; ... sub/superscripts...

+ ((subscript superscript)

+ (let ((sub/super-p (plist-get info :with-sub-superscript))

+ (bracketp (org-element-property :use-brackets-p datum)))

+ (and (or (not sub/super-p)

+ (and (eq sub/super-p '{}) (not bracketp)))

+ (append

+ (list (concat

+ (if (eq (org-element-type datum) 'subscript)

+ "_"

+ "^")

+ (and bracketp "{")))

+ (org-element-contents datum)

+ (list (concat

+ (and bracketp "}")

+ (and (org-element-property :post-blank datum)

+ (make-string

+ (org-element-property :post-blank datum)

+ ?\s)))))))))))

+ (when new

+ ;; Splice NEW at DATUM location in parse tree.

+ (dolist (e new (org-element-extract-element datum))

+ (unless (equal e "") (org-element-insert-before e datum))))))

+ info nil nil t)

+ ;; Return modified parse tree.

+ data)

+ (backend &optional subtreep visible-only body-only ext-plist)

+ ;; parsing. If parsing subtree, be sure to remove main

+ ;; headline, planning data and property drawer.

+ (org-end-of-meta-data)

+ (org-export--get-export-attributes

+ backend subtreep visible-only body-only)

+ (parsed-keywords

+ (delq nil

+ (mapcar (lambda (o) (and (eq (nth 4 o) 'parse) (nth 1 o)))

+ (append (org-export-get-all-options backend)

+ org-export-options-alist))))

+ ;; isn't parsed directly. Instead, all buffer modifications

+ ;; and consequent parsing are undertaken in a temporary copy.

+ ;; Include files, delete comments and expand macros.

+ (org-export--delete-comment-trees)

+ (org-macro-replace-all org-macro-templates nil parsed-keywords)

+ ;; Refresh buffer properties and radio targets after

+ ;; potentially invasive previous changes. Likewise, do it

+ ;; again after executing Babel code.

+ (org-set-regexps-and-options)

+ (when org-export-babel-evaluate

+ (org-babel-exp-process-buffer)

+ (org-set-regexps-and-options)

+ (org-update-radio-target-regexp))

+ ;; Update buffer properties and radio targets one last time

+ ;; before parsing.

+ (org-set-regexps-and-options)

+ (org-update-radio-target-regexp)

+ ;; Update communication channel with environment.

+ (org-combine-plists

+ info (org-export-get-environment backend subtreep ext-plist)))

+ ;; De-activate uninterpreted data from parsed keywords.

+ (dolist (entry (append (org-export-get-all-options backend)

+ org-export-options-alist))

+ (pcase entry

+ (`(,p ,_ ,_ ,_ parse)

+ (let ((value (plist-get info p)))

+ (plist-put info

+ p

+ (org-export--remove-uninterpreted-data value info))))

+ (_ nil)))

+ ;; Install user's and developer's filters.

+ (setq info (org-export-install-filters info))

+ ;; Expand export-specific set of macros: {{{author}}},

+ ;; {{{date(FORMAT)}}}, {{{email}}} and {{{title}}}. It must

+ ;; be done once regular macros have been expanded, since

+ ;; parsed keywords may contain one of them.

+ (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 (org-element-interpret-data date) "")))

+ (if (and (consp date)

+ (not (cdr date))

+ (eq (org-element-type (car date)) 'timestamp))

+ (format "(eval (if (org-string-nw-p \"$1\") %s %S))"

+ (format "(org-timestamp-format '%S \"$1\")"

+ (org-element-copy (car date)))

+ 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"))

+ 'finalize

+ parsed-keywords)

+ ;; Parse buffer.

+ (setq tree (org-element-parse-buffer nil visible-only))

+ ;; Prune tree from non-exported elements and transform

+ ;; uninterpreted elements or objects in both parse tree and

+ ;; communication channel.

+ (org-export--prune-tree tree info)

+ (org-export--remove-uninterpreted-data tree info)

+ ;; Call parse tree filters.

+ (plist-get info :filter-parse-tree) tree info))

+ (setq info (org-export--collect-tree-properties tree info))

+ (full-body (org-export-filter-apply-functions

+ (plist-get info :filter-body)

+ (if (not (functionp inner-template)) body

+ (funcall inner-template body info))

+ info))

+ (unless (org-region-active-p) (user-error "No active region to replace"))

+ (insert

+ (org-export-string-as

+ (delete-and-extract-region (region-beginning) (region-end)) backend t)))

+ org-export-registered-backends))

+ nil t))))

+ (mapconcat #'identity (eval (nth 3 entry)) " ")

+ ;; First (multiple) OPTIONS lines. Never go past fill-column.

+ (cl-incf width (1+ (length item))))))

+ ;; Then the rest of keywords, in the order specified in either

+ ;; `org-export-options-alist' or respective export back-ends.

+ (dolist (key (nreverse keywords))

+ (let ((val (cond ((equal (car key) "DATE")

+ (or (cdr key)

+ (with-temp-buffer

+ (org-insert-time-stamp (current-time)))))

+ ((equal (car key) "TITLE")

+ (or (let ((visited-file

+ (buffer-file-name (buffer-base-buffer))))

+ (and visited-file

+ (file-name-sans-extension

+ (file-name-nondirectory visited-file))))

+ (buffer-name (buffer-base-buffer))))

+ (t (cdr key)))))

+ (if subtreep (org-entry-put node (concat "EXPORT_" (car key)) val)

+ (insert

+ (format "#+%s:%s\n"

+ (car key)

+ (if (org-string-nw-p val) (format " %s" val) ""))))))))

+

+(defun org-export-expand-include-keyword (&optional included dir footnotes)

+paths. Optional argument FOOTNOTES is a hash-table used for

+storing and resolving footnotes. It is created automatically."

+ (let ((case-fold-search t)

+ (file-prefix (make-hash-table :test #'equal))

+ (current-prefix 0)

+ (footnotes (or footnotes (make-hash-table :test #'equal)))

+ (include-re "^[ \t]*#\\+INCLUDE:"))

+ ;; If :minlevel is not set the text-property

+ ;; `:org-include-induced-level' will be used to determine the

+ ;; relative level when expanding INCLUDE.

+ ;; Only affects included Org documents.

+ (goto-char (point-min))

+ (while (re-search-forward include-re nil t)

+ (put-text-property (line-beginning-position) (line-end-position)

+ :org-include-induced-level

+ (1+ (org-reduced-level (or (org-current-level) 0)))))

+ ;; Expand INCLUDE keywords.

+ (while (re-search-forward include-re nil t)

+ location

+ (file

+ (and (string-match

+ "^\\(\".+?\"\\|\\S-+\\)\\(?:\\s-+\\|$\\)" value)

+ (prog1

+ (save-match-data

+ (let ((matched (match-string 1 value)))

+ (when (string-match "\\(::\\(.*?\\)\\)\"?\\'"

+ matched)

+ (setq location (match-string 2 matched))

+ (setq matched

+ (replace-match "" nil nil matched 1)))

+ (expand-file-name

+ (org-unbracket-string "\"" "\"" matched)

+ dir)))

+ (setq value (replace-match "" nil nil value)))))

+ (only-contents

+ (and (string-match ":only-contents *\\([^: \r\t\n]\\S-*\\)?"

+ value)

+ (prog1 (org-not-nil (match-string 1 value))

+ (setq value (replace-match "" nil nil value)))))

+ (env (cond

+ ((string-match "\\<example\\>" value) 'literal)

+ ((string-match "\\<export\\(?: +\\(.*\\)\\)?" value)

+ 'literal)

+ ((string-match "\\<src\\(?: +\\(.*\\)\\)?" value)

+ 'literal)))

+ (get-text-property (point)

+ :org-include-induced-level))))

+ (args (and (eq env 'literal) (match-string 1 value)))

+ (block (and (string-match "\\<\\(\\S-+\\)\\>" value)

+ (match-string 1 value))))

+ (delete-region (point) (line-beginning-position 2))

+ ((eq env 'literal)

+ (let ((ind-str (make-string ind ?\s))

+ (arg-str (if (stringp args) (format " %s" args) ""))

+ (format "%s#+BEGIN_%s%s\n%s%s#+END_%s\n"

+ ind-str block arg-str contents ind-str block))))

+ ((stringp block)

+ (let ((ind-str (make-string ind ?\s))

+ (org-export--prepare-file-contents file lines)))

+ (format "%s#+BEGIN_%s\n%s%s#+END_%s\n"

+ ind-str block contents ind-str block))))

+ (let ((org-inhibit-startup t)

+ (lines

+ (if location

+ (org-export--inclusion-absolute-lines

+ file location only-contents lines)

+ lines)))

+ (org-mode)

+ (insert

+ (org-export--prepare-file-contents

+ file lines ind minlevel

+ (or (gethash file file-prefix)

+ (puthash file (cl-incf current-prefix) file-prefix))

+ footnotes)))

+ (file-name-directory file)

+ footnotes)

+ (buffer-string)))))

+ ;; Expand footnotes after all files have been included.

+ ;; Footnotes are stored at end of buffer.

+ (unless included

+ (org-with-wide-buffer

+ (goto-char (point-max))

+ (maphash (lambda (k v) (insert (format "\n[fn:%s] %s\n" k v)))

+ footnotes)))))))))))

+

+(defun org-export--inclusion-absolute-lines (file location only-contents lines)

+ "Resolve absolute lines for an included file with file-link.

+FILE is string file-name of the file to include. LOCATION is a

+string name within FILE to be included (located via

+`org-link-search'). If ONLY-CONTENTS is non-nil only the

+contents of the named element will be included, as determined

+Org-Element. If LINES is non-nil only those lines are included.

+

+Return a string of lines to be included in the format expected by

+`org-export--prepare-file-contents'."

+ (with-temp-buffer

+ (insert-file-contents file)

+ (unless (eq major-mode 'org-mode)

+ (let ((org-inhibit-startup t)) (org-mode)))

+ (condition-case err

+ ;; Enforce consistent search.

+ (let ((org-link-search-must-match-exact-headline nil))

+ (org-link-search location))

+ (error

+ (error "%s for %s::%s" (error-message-string err) file location)))

+ (let* ((element (org-element-at-point))

+ (contents-begin

+ (and only-contents (org-element-property :contents-begin element))))

+ (narrow-to-region

+ (or contents-begin (org-element-property :begin element))

+ (org-element-property (if contents-begin :contents-end :end) element))

+ (when (and only-contents

+ (memq (org-element-type element) '(headline inlinetask)))

+ ;; Skip planning line and property-drawer.

+ (goto-char (point-min))

+ (when (looking-at-p org-planning-line-re) (forward-line))

+ (when (looking-at org-property-drawer-re) (goto-char (match-end 0)))

+ (unless (bolp) (forward-line))

+ (narrow-to-region (point) (point-max))))

+ (when lines

+ (org-skip-whitespace)

+ (beginning-of-line)

+ (let* ((lines (split-string lines "-"))

+ (lbeg (string-to-number (car lines)))

+ (lend (string-to-number (cadr lines)))

+ (beg (if (zerop lbeg) (point-min)

+ (goto-char (point-min))

+ (forward-line (1- lbeg))

+ (point)))

+ (end (if (zerop lend) (point-max)

+ (goto-char beg)

+ (forward-line (1- lend))

+ (point))))

+ (narrow-to-region beg end)))

+ (let ((end (point-max)))

+ (goto-char (point-min))

+ (widen)

+ (let ((start-line (line-number-at-pos)))

+ (format "%d-%d"

+ start-line

+ (save-excursion

+ (+ start-line

+ (let ((counter 0))

+ (while (< (point) end) (cl-incf counter) (forward-line))

+ counter))))))))

+

+(defun org-export--prepare-file-contents

+ (file &optional lines ind minlevel id footnotes)

+ "Prepare contents of FILE for inclusion and return it as a string.

+created (e.g., a list item), it doesn't apply past the first

+file should have.

+

+Optional argument ID is an integer that will be inserted before

+each footnote definition and reference if FILE is an Org file.

+This is useful to avoid conflicts when more than one Org file

+with footnotes is included in a document.

+

+Optional argument FOOTNOTES is a hash-table to store footnotes in

+the included document."

+ (when (and ind (> ind 0))

+ (let ((ind-str (make-string ind ?\s)))

+ (let ((offset (- minlevel (apply #'min levels))))

+ (lambda ()

+ (if (< offset 0) (delete-char (abs offset))

+ (insert (make-string offset ?*)))))))))))

+ ;; Append ID to all footnote references and definitions, so they

+ ;; become file specific and cannot collide with footnotes in other

+ ;; included files. Further, collect relevant footnote definitions

+ ;; outside of LINES, in order to reintroduce them later.

+ (when id

+ (let ((marker-min (point-min-marker))

+ (marker-max (point-max-marker))

+ (get-new-label

+ (lambda (label)

+ ;; Generate new label from LABEL by prefixing it with

+ ;; "-ID-".

+ (format "-%d-%s" id label)))

+ (set-new-label

+ (lambda (f old new)

+ ;; Replace OLD label with NEW in footnote F.

+ (save-excursion

+ (goto-char (+ (org-element-property :begin f) 4))

+ (looking-at (regexp-quote old))

+ (replace-match new))))

+ (seen-alist))

+ (goto-char (point-min))

+ (while (re-search-forward org-footnote-re nil t)

+ (let ((footnote (save-excursion

+ (backward-char)

+ (org-element-context))))

+ (when (memq (org-element-type footnote)

+ '(footnote-definition footnote-reference))

+ (let* ((label (org-element-property :label footnote)))

+ ;; Update the footnote-reference at point and collect

+ ;; the new label, which is only used for footnotes

+ ;; outsides LINES.

+ (when label

+ (let ((seen (cdr (assoc label seen-alist))))

+ (if seen (funcall set-new-label footnote label seen)

+ (let ((new (funcall get-new-label label)))

+ (push (cons label new) seen-alist)

+ (org-with-wide-buffer

+ (let* ((def (org-footnote-get-definition label))

+ (beg (nth 1 def)))

+ (when (and def

+ (or (< beg marker-min)

+ (>= beg marker-max)))

+ ;; Store since footnote-definition is

+ ;; outside of LINES.

+ (puthash new

+ (org-element-normalize-string (nth 3 def))

+ footnotes))))

+ (funcall set-new-label footnote label new)))))))))

+ (set-marker marker-min nil)

+ (set-marker marker-max nil)))

+ (when (memq type '(nil org-data)) (error "No foreign transcoder available"))

+ (let* ((all-transcoders (org-export-get-all-transcoders backend))

+ (transcoder (cdr (assq type all-transcoders))))

+ (unless (functionp transcoder) (error "No foreign transcoder available"))

+ (let ((new-info

+ (org-combine-plists

+ info (list

+ :back-end backend

+ :translate-alist all-transcoders

+ :exported-data (make-hash-table :test #'eq :size 401)))))

+ ;; `:internal-references' are shared across back-ends.

+ (prog1 (funcall transcoder data contents new-info)

+ (plist-put info :internal-references

+ (plist-get new-info :internal-references)))))))

+(defun org-export-get-footnote-definition (footnote-reference info)

+ "Return definition of FOOTNOTE-REFERENCE as parsed data.

+INFO is the plist used as a communication channel. If no such

+definition can be found, raise an error."

+ (let ((label (org-element-property :label footnote-reference)))

+ (if (not label) (org-element-contents footnote-reference)

+ (let ((cache (or (plist-get info :footnote-definition-cache)

+ (let ((hash (make-hash-table :test #'equal)))

+ (plist-put info :footnote-definition-cache hash)

+ hash))))

+ (or

+ (gethash label cache)

+ (puthash label

+ (org-element-map (plist-get info :parse-tree)

+ '(footnote-definition footnote-reference)

+ (lambda (f)

+ (cond

+ ;; Skip any footnote with a different label.

+ ;; Also skip any standard footnote reference

+ ;; with the same label since those cannot

+ ;; contain a definition.

+ ((not (equal (org-element-property :label f) label)) nil)

+ ((eq (org-element-property :type f) 'standard) nil)

+ ((org-element-contents f))

+ ;; Even if the contents are empty, we can not

+ ;; return nil since that would eventually raise

+ ;; the error. Instead, return the equivalent

+ ;; empty string.

+ (t "")))

+ info t)

+ cache)

+ (error "Definition not found for footnote %s" label))))))

+

+(defun org-export--footnote-reference-map

+ (function data info &optional body-first)

+ "Apply FUNCTION on every footnote reference in DATA.

+INFO is a plist containing export state. By default, as soon as

+a new footnote reference is encountered, FUNCTION is called onto

+its definition. However, if BODY-FIRST is non-nil, this step is

+delayed until the end of the process."

+ (letrec ((definitions nil)

+ (seen-refs nil)

+ (search-ref

+ (lambda (data delayp)

+ ;; Search footnote references through DATA, filling

+ ;; SEEN-REFS along the way. When DELAYP is non-nil,

+ ;; store footnote definitions so they can be entered

+ ;; later.

+ (org-element-map data 'footnote-reference

+ (lambda (f)

+ (funcall function f)

+ (let ((--label (org-element-property :label f)))

+ (unless (and --label (member --label seen-refs))

+ (when --label (push --label seen-refs))

+ ;; Search for subsequent references in footnote

+ ;; definition so numbering follows reading

+ ;; logic, unless DELAYP in non-nil.

+ (cond

+ (delayp

+ (push (org-export-get-footnote-definition f info)

+ definitions))

+ ;; Do not force entering inline definitions,

+ ;; since `org-element-map' already traverses

+ ;; them at the right time.

+ ((eq (org-element-property :type f) 'inline))

+ (t (funcall search-ref

+ (org-export-get-footnote-definition f info)

+ nil))))))

+ info nil

+ ;; Don't enter footnote definitions since it will

+ ;; happen when their first reference is found.

+ ;; Moreover, if DELAYP is non-nil, make sure we

+ ;; postpone entering definitions of inline references.

+ (if delayp '(footnote-definition footnote-reference)

+ 'footnote-definition)))))

+ (funcall search-ref data body-first)

+ (funcall search-ref (nreverse definitions) nil)))

+

+(defun org-export-collect-footnote-definitions (info &optional data body-first)

+INFO is the current export state, as a plist.

+

+Definitions are collected throughout the whole parse tree, or

+DATA when non-nil.

+

+Sorting is done by order of references. As soon as a new

+reference is encountered, other references are searched within

+its definition. However, if BODY-FIRST is non-nil, this step is

+delayed after the whole tree is checked. This alters results

+when references are found in footnote definitions.

+

+Definitions either appear as Org data or as a secondary string

+for inlined footnotes. Unreferenced definitions are ignored."

+ (let ((n 0) labels alist)

+ (org-export--footnote-reference-map

+ (lambda (f)

+ ;; Collect footnote number, label and definition.

+ (let ((l (org-element-property :label f)))

+ (unless (and l (member l labels))

+ (cl-incf n)

+ (push (list n l (org-export-get-footnote-definition f info)) alist))

+ (when l (push l labels))))

+ (or data (plist-get info :parse-tree)) info body-first)

+ (nreverse alist)))

+

+(defun org-export-footnote-first-reference-p

+ (footnote-reference info &optional data body-first)

+INFO is a plist containing current export state.

+Search is done throughout the whole parse tree, or DATA when

+non-nil.

+By default, as soon as a new footnote reference is encountered,

+other references are searched within its definition. However, if

+BODY-FIRST is non-nil, this step is delayed after the whole tree

+is checked. This alters results when references are found in

+footnote definitions."

+ (let ((label (org-element-property :label footnote-reference)))

+ ;; Anonymous footnotes are always a first reference.

+ (or (not label)

+ (catch 'exit

+ (org-export--footnote-reference-map

+ (lambda (f)

+ (let ((l (org-element-property :label f)))

+ (when (and l label (string= label l))

+ (throw 'exit (eq footnote-reference f)))))

+ (or data (plist-get info :parse-tree)) info body-first)))))

+

+(defun org-export-get-footnote-number (footnote info &optional data body-first)

+INFO is the plist containing export state.

+

+Number is unique throughout the whole parse tree, or DATA, when

+non-nil.

+

+By default, as soon as a new footnote reference is encountered,

+counting process moves into its definition. However, if

+BODY-FIRST is non-nil, this step is delayed until the end of the

+process, leading to a different order when footnotes are nested."

+ (let ((count 0)

+ (seen)

+ (label (org-element-property :label footnote)))

+ (catch 'exit

+ (org-export--footnote-reference-map

+ (lambda (f)

+ (let ((l (org-element-property :label f)))

+ (cond

+ ;; Anonymous footnote match: return number.

+ ((and (not l) (not label) (eq footnote f)) (throw 'exit (1+ count)))

+ ;; Labels match: return number.

+ ((and label l (string= label l)) (throw 'exit (1+ count)))

+ ;; Otherwise store label and increase counter if label

+ ;; wasn't encountered yet.

+ ((not l) (cl-incf count))

+ ((not (member l seen)) (push l seen) (cl-incf count)))))

+ (or data (plist-get info :parse-tree)) info body-first))))

+;; `org-export-get-headline-number' returns the section number of an

+;; converted to roman numbers. With an optional argument,

+;; `org-export-get-headline-number' returns a number to unnumbered

+;; headlines (used for internal id).

+ "Return numbered HEADLINE numbering as a list of numbers.

+ (and (org-export-numbered-headline-p headline info)

+ (cdr (assq headline (plist-get info :headline-numbering)))))

+ (unless (cl-some

+ (lambda (head) (org-not-nil (org-element-property :UNNUMBERED head)))

+ (org-element-lineage headline nil t))

+ (let ((sec-num (plist-get info :section-numbers))

+ (level (org-export-get-relative-level headline info)))

+ (if (wholenump sec-num) (<= level sec-num) sec-num))))

+ (cl-remove-if

+ (lambda (tag) (member tag tags))

+ (dolist (parent (org-element-lineage element))

+ (dolist (tag (org-element-property :tags parent))

+ (when (and (memq (org-element-type parent) '(headline inlinetask))

+ (not (member tag current-tag-list)))

+ (push tag current-tag-list))))

+ (let ((parent headline))

+ (or (org-export-get-node-property :CATEGORY blob t)

+(defun org-export-get-alt-title (headline _)

+If no optional title is defined, fall-back to the regular title."

+ (let ((alt (org-element-property :ALT_TITLE headline)))

+ (if alt (org-element-parse-secondary-string

+ alt (org-element-restriction 'headline) headline)

+ (org-element-property :title headline))))

+

+(defun org-export-first-sibling-p (blob info)

+ "Non-nil when BLOB is the first sibling in its parent.

+BLOB is an element or an object. If BLOB is a headline, non-nil

+means it is the first sibling in the sub-tree. INFO is a plist

+used as a communication channel."

+ (memq (org-element-type (org-export-get-previous-element blob info))

+ '(nil section)))

+

+(defun org-export-last-sibling-p (blob info)

+ "Non-nil when BLOB is the last sibling in its parent.

+BLOB is an element or an object. INFO is a plist used as

+a communication channel."

+ (not (org-export-get-next-element blob info)))

+;; `org-export-custom-protocol-maybe' handles custom protocol defined

+;; in `org-link-parameters'.

+;; returns an appropriate unique identifier.

+;; file with the id.

+;;

+;; `org-export-file-uri' expands a filename as stored in :path value

+;; of a "file" link into a file URI.

+;;

+;; Broken links raise a `org-link-broken' error, which is caught by

+;; `org-export-data' for further processing, depending on

+;; `org-export-with-broken-links' value.

+(org-define-error 'org-link-broken "Unable to resolve link; aborting")

+

+(defun org-export-custom-protocol-maybe (link desc backend)

+ "Try exporting LINK with a dedicated function.

+

+DESC is its description, as a string, or nil. BACKEND is the

+back-end used for export, as a symbol.

+

+Return output as a string, or nil if no protocol handles LINK.

+

+A custom protocol has precedence over regular back-end export.

+The function ignores links with an implicit type (e.g.,

+\"custom-id\")."

+ (let ((type (org-element-property :type link)))

+ (unless (or (member type '("coderef" "custom-id" "fuzzy" "radio"))

+ (not backend))

+ (let ((protocol (org-link-get-parameter type :export)))

+ (and (functionp protocol)

+ (funcall protocol

+ (org-link-unescape (org-element-property :path link))

+ desc

+ backend))))))

+ (let ((case-fold-search t))

+ (dolist (rule (or rules org-export-default-inline-image-rule))

+ (and (string= (org-element-property :type link) (car rule))

+ (string-match-p (cdr rule)

+ (org-element-property :path link))

+ (throw 'exit t)))))))

+depending on src-block or example element's switches. Throw an

+error if no block contains REF."

+ (or (org-element-map (plist-get info :parse-tree) '(example-block src-block)

+ (lambda (el)

+ (with-temp-buffer

+ (insert (org-trim (org-element-property :value el)))

+ (let* ((label-fmt (or (org-element-property :label-fmt el)

+ org-coderef-label-format))

+ (ref-re (org-src-coderef-regexp label-fmt ref)))

+ ;; Element containing REF is found. Resolve it to

+ ;; either a label or a line number, as needed.

+ (when (re-search-backward ref-re nil t)

+ (if (org-element-property :use-labels el) ref

+ (+ (or (org-export-get-loc el info) 0)

+ (line-number-at-pos)))))))

+ info 'first-match)

+ (signal 'org-link-broken (list ref))))

+

+(defun org-export-search-cells (datum)

+ "List search cells for element or object DATUM.

+

+A search cell follows the pattern (TYPE . SEARCH) where

+

+ TYPE is a symbol among `headline', `custom-id', `target' and

+ `other'.

+

+ SEARCH is the string a link is expected to match. More

+ accurately, it is

+

+ - headline's title, as a list of strings, if TYPE is

+ `headline'.

+

+ - CUSTOM_ID value, as a string, if TYPE is `custom-id'.

+

+ - target's or radio-target's name as a list of strings if

+ TYPE is `target'.

+

+ - NAME affiliated keyword is TYPE is `other'.

+

+A search cell is the internal representation of a fuzzy link. It

+ignores white spaces and statistics cookies, if applicable."

+ (pcase (org-element-type datum)

+ (`headline

+ (let ((title (split-string

+ (replace-regexp-in-string

+ "\\[[0-9]*\\(?:%\\|/[0-9]*\\)\\]" ""

+ (org-element-property :raw-value datum)))))

+ (delq nil

+ (list

+ (cons 'headline title)

+ (cons 'other title)

+ (let ((custom-id (org-element-property :custom-id datum)))

+ (and custom-id (cons 'custom-id custom-id)))))))

+ (`target

+ (list (cons 'target (split-string (org-element-property :value datum)))))

+ ((and (let name (org-element-property :name datum))

+ (guard name))

+ (list (cons 'other (split-string name))))

+ (_ nil)))

+

+(defun org-export-string-to-search-cell (s)

+ "Return search cells associated to string S.

+S is either the path of a fuzzy link or a search option, i.e., it

+tries to match either a headline (through custom ID or title),

+a target or a named element."

+ (pcase (string-to-char s)

+ (?* (list (cons 'headline (split-string (substring s 1)))))

+ (?# (list (cons 'custom-id (substring s 1))))

+ ((let search (split-string s))

+ (list (cons 'target search) (cons 'other search)))))

+

+(defun org-export-match-search-cell-p (datum cells)

+ "Non-nil when DATUM matches search cells CELLS.

+DATUM is an element or object. CELLS is a list of search cells,

+as returned by `org-export-search-cells'."

+ (let ((targets (org-export-search-cells datum)))

+ (and targets (cl-some (lambda (cell) (member cell targets)) cells))))

+Return value can be an object or an element:

+ element.

+- Otherwise, throw an error.

+ (let* ((search-cells (org-export-string-to-search-cell

+ (org-link-unescape (org-element-property :path link))))

+ (plist-get (plist-put info

+ :resolve-fuzzy-link-cache

+ (make-hash-table :test #'equal))

+ (cached (gethash search-cells link-cache 'not-found)))

+ (if (not (eq cached 'not-found)) cached

+ (let ((matches

+ (org-element-map (plist-get info :parse-tree)

+ (cons 'target org-element-all-elements)

+ (lambda (datum)

+ (and (org-export-match-search-cell-p datum search-cells)

+ datum)))))

+ (unless matches

+ (signal 'org-link-broken (list (org-element-property :path link))))

+ (puthash

+ search-cells

+ ;; There can be multiple matches for un-typed searches, i.e.,

+ ;; for searches not starting with # or *. In this case,

+ ;; prioritize targets and names over headline titles.

+ ;; Matching both a name and a target is not valid, and

+ ;; therefore undefined.

+ (or (cl-some (lambda (datum)

+ (and (not (eq (org-element-type datum) 'headline))

+ datum))

+ matches)

+ (car matches))

+ link-cache)))))

+tree or a file name. Assume LINK type is either \"id\" or

+\"custom-id\". Throw an error if no match is found."

+ (when (or (equal (org-element-property :ID headline) id)

+ (equal (org-element-property :CUSTOM_ID headline) id))

+ (cdr (assoc id (plist-get info :id-alist)))

+ (signal 'org-link-broken (list id)))))

+(defun org-export-file-uri (filename)

+ "Return file URI associated to FILENAME."

+ (cond ((string-prefix-p "//" filename) (concat "file:" filename))

+ ((not (file-name-absolute-p filename)) filename)

+ ((org-file-remote-p filename) (concat "file:/" filename))

+ (t

+ (let ((fullname (expand-file-name filename)))

+ (concat (if (string-prefix-p "/" fullname) "file://" "file:///")

+ fullname)))))

+;; `org-export-get-reference' associate a unique reference for any

+;; object or element. It uses `org-export-new-reference' and

+;; `org-export-format-reference' to, respectively, generate new

+;; internal references and turn them into a string suitable for

+;; output.

+;;

+(defun org-export-new-reference (references)

+ "Return a unique reference, among REFERENCES.

+REFERENCES is an alist whose values are in-use references, as

+numbers. Returns a number, which is the internal representation

+of a reference. See also `org-export-format-reference'."

+ ;; Generate random 7 digits hexadecimal numbers. Collisions

+ ;; increase exponentially with the numbers of references. However,

+ ;; the odds for encountering at least one collision with 1000 active

+ ;; references in the same document are roughly 0.2%, so this

+ ;; shouldn't be the bottleneck.

+ (let ((new (random #x10000000)))

+ (while (rassq new references) (setq new (random #x10000000)))

+ new))

+

+(defun org-export-format-reference (reference)

+ "Format REFERENCE into a string.

+REFERENCE is a number representing a reference, as returned by

+`org-export-new-reference', which see."

+ (format "org%07x" reference))

+

+(defun org-export-get-reference (datum info)

+ "Return a unique reference for DATUM, as a string.

+

+DATUM is either an element or an object. INFO is the current

+export state, as a plist.

+

+This function checks `:crossrefs' property in INFO for search

+cells matching DATUM before creating a new reference. Returned

+reference consists of alphanumeric characters only."

+ (let ((cache (plist-get info :internal-references)))

+ (or (car (rassq datum cache))

+ (let* ((crossrefs (plist-get info :crossrefs))

+ (cells (org-export-search-cells datum))

+ ;; Preserve any pre-existing association between

+ ;; a search cell and a reference, i.e., when some

+ ;; previously published document referenced a location

+ ;; within current file (see

+ ;; `org-publish-resolve-external-link').

+ ;;

+ ;; However, there is no guarantee that search cells are

+ ;; unique, e.g., there might be duplicate custom ID or

+ ;; two headings with the same title in the file.

+ ;;

+ ;; As a consequence, before re-using any reference to

+ ;; an element or object, we check that it doesn't refer

+ ;; to a previous element or object.

+ (new (or (cl-some

+ (lambda (cell)

+ (let ((stored (cdr (assoc cell crossrefs))))

+ (when stored

+ (let ((old (org-export-format-reference stored)))

+ (and (not (assoc old cache)) stored)))))

+ cells)

+ (org-export-new-reference cache)))

+ (reference-string (org-export-format-reference new)))

+ ;; Cache contains both data already associated to

+ ;; a reference and in-use internal references, so as to make

+ ;; unique references.

+ (dolist (cell cells) (push (cons cell new) cache))

+ ;; Retain a direct association between reference string and

+ ;; DATUM since (1) not every object or element can be given

+ ;; a search cell (2) it permits quick lookup.

+ (push (cons reference-string datum) cache)

+ (plist-put info :internal-references cache)

+ reference-string))))

+

+ (org-element-lineage

+ element

+ '(footnote-definition footnote-reference headline item table))))

+ (cl-case (org-element-type element)

+ ((not predicate) (cl-incf counter) nil)

+ ((funcall predicate el info) (cl-incf counter) nil)))

+ "Return count of lines of code before ELEMENT.

+

+ELEMENT is an example-block or src-block element. INFO is the

+plist used as a communication channel.

+

+Count includes every line of code in example-block or src-block

+with a \"+n\" or \"-n\" switch before block. Return nil if

+ELEMENT doesn't allow line numbering."

+ (pcase (org-element-property :number-lines element)

+ (`(new . ,n) n)

+ (`(continued . ,n)

+ (let ((loc 0))

+ (org-element-map (plist-get info :parse-tree) '(src-block example-block)

+ (lambda (el)

+ ;; ELEMENT is reached: Quit loop and return locs.

+ (if (eq el element) (+ loc n)

+ ;; Only count lines from src-block and example-block

+ ;; elements with a "+n" or "-n" switch.

+ (let ((linum (org-element-property :number-lines el)))

+ (when linum

+ (let ((lines (org-count-lines

+ (org-element-property :value el))))

+ ;; Accumulate locs or reset them.

+ (pcase linum

+ (`(new . ,n) (setq loc (+ n lines)))

+ (`(continued . ,n) (cl-incf loc (+ n lines)))))))

+ nil)) ;Return nil to stay in the loop.

+ info 'first-match)))))

+reference, protective commas and spurious indentation, and CDR is

+an alist between relative line number (integer) and name of code

+reference on that line (string)."

+ (value (org-element-property :value element))

+ ;; Remove global indentation from code, if necessary. Also

+ ;; remove final newline character, since it doesn't belongs

+ ;; to the code proper.

+ "\n\\'" ""

+ (if (or org-src-preserve-indentation

+ (org-element-property :preserve-indent element))

+ value

+ (org-remove-indentation value))))

+ (ref-re (org-src-coderef-regexp (org-src-coderef-format element))))

+ (mapconcat

+ (lambda (loc)

+ (cl-incf line)

+ (if (not (string-match ref-re loc)) loc

+ ;; Ref line: remove ref, and add its position in REFS.

+ (push (cons line (match-string 3 loc)) refs)

+ (replace-match "" nil nil loc 1)))

+ (split-string code "\n") "\n")

+ (let ((--locs (split-string code "\n"))

+ (concat

+ (cl-incf --line)

+ --locs "\n")

+ "\n")))

+ (code-lines (split-string code "\n")))

+ (num-start (org-export-get-loc element info))

+ (concat (make-string (- (+ 6 max-width)

+ (+ (length loc) (length number-str)))

+ ?\s)

+;; `org-export-table-row-starts-header-p',

+;; `org-export-table-row-ends-header-p' and

+;; `org-export-table-row-in-header-p' indicate position of current row

+;; or cell within the table.

+ (dolist (row (org-element-contents table))

+ (when (eq (org-element-property :type row) 'standard)

+ (let ((value (org-element-contents

+ (car (org-element-contents row)))))

+ (cond ((member value '(("/") ("#") ("!") ("$") ("*") ("_") ("^")))

+ (setq special-column-p 'special))

+ ((not value))

+ (t (throw 'exit nil))))))

+ (cl-incf rowgroup) (setq row-flag nil))

+(defun org-export-table-row-is-special-p (table-row _)

+ (dolist (cell (org-element-contents table-row))

+ (let ((value (org-element-contents cell)))

+ ;; Since VALUE is a secondary string, the following

+ ;; checks avoid expanding it with `org-export-data'.

+ (cond ((not value))

+ ((and (not (cdr value))

+ (stringp (car value))

+ (string-match "\\`<[lrc]?\\([0-9]+\\)?>\\'"

+ (car value)))

+ (setq special-row-p 'cookie))

+ (t (throw 'exit nil)))))

+ (unless row-flag (cl-incf group) (setq row-flag t)))

+ (cl-incf total-cells)

+ (cl-incf number-cells))))))

+ ;; Look at every row before the current one.

+ (dolist (row (cdr (memq row (reverse (org-element-contents table)))))

+ (cond ((eq (org-element-property :type row) 'rule)

+ (setq rule-flag t))

+ ((not (org-export-table-row-is-special-p row info))

+ (if rule-flag (throw 'exit (push 'above borders))

+ (throw 'exit nil)))))

+ ;; Look at every row after the current one.

+ (dolist (row (cdr (memq row (org-element-contents table))))

+ (cond ((eq (org-element-property :type row) 'rule)

+ (setq rule-flag t))

+ ((not (org-export-table-row-is-special-p row info))

+ (if rule-flag (throw 'exit (push 'below borders))

+ (throw 'exit nil)))))

+ ;; Table rows are read in reverse order so last column groups

+ ;; row has precedence over any previous one.

+ (dolist (row (reverse (org-element-contents table)))

+ (unless (eq (org-element-property :type row) 'rule)

+ (when (equal (org-element-contents

+ (car (org-element-contents row)))

+ '("/"))

+ (let ((column-groups

+ (mapcar

+ (lambda (cell)

+ (let ((value (org-element-contents cell)))

+ (when (member value '(("<") ("<>") (">") nil))

+ (car value))))

+ (org-element-contents row))))

+ ;; There's a left border when previous cell, if

+ ;; any, ends a group, or current one starts one.

+ (when (or (and (not (zerop column))

+ (member (elt column-groups (1- column))

+ '(">" "<>")))

+ (member (elt column-groups column) '("<" "<>")))

+ (push 'left borders))

+ ;; There's a right border when next cell, if any,

+ ;; starts a group, or current one ends one.

+ (when (or (and (/= (1+ column) (length column-groups))

+ (member (elt column-groups (1+ column))

+ '("<" "<>")))

+ (member (elt column-groups column) '(">" "<>")))

+ (push 'right borders))

+ (throw 'exit nil)))))))

+ "Non-nil when TABLE-CELL is at the beginning of a column group.

+ "Non-nil when TABLE-CELL is at the end of a column group.

+ "Non-nil when TABLE-ROW is at the beginning of a row group.

+ "Non-nil when TABLE-ROW is at the end of a row group.

+(defun org-export-table-row-in-header-p (table-row info)

+ "Non-nil when TABLE-ROW is located within table's header.

+INFO is a plist used as a communication channel. Always return

+nil for special rows and rows separators."

+ (and (org-export-table-has-header-p

+ (org-export-get-parent-table table-row) info)

+ (eql (org-export-table-row-group table-row info) 1)))

+

+ (and (org-export-table-row-in-header-p table-row info)

+ (org-export-table-row-starts-rowgroup-p table-row info)))

+ (and (org-export-table-row-in-header-p table-row info)

+ (org-export-table-row-ends-rowgroup-p table-row info)))

+ (cl-incf number) nil)))

+ (cl-incf rows)

+ (org-element-map first-row 'table-cell (lambda (_) (cl-incf columns)) info)

+ (if (eq cell table-cell) col-count (cl-incf col-count) nil))

+ (t (cl-incf row-count) nil)))

+ (cl-incf column-count) nil))

+(defun org-export-collect-headlines (info &optional n scope)

+Optional argument SCOPE, when non-nil, is an element. If it is

+a headline, only children of SCOPE are collected. Otherwise,

+collect children of the headline containing provided element. If

+there is no such headline, collect all headlines. In any case,

+argument N becomes relative to the level of that headline.

+

+Footnote sections are ignored."

+ (let* ((scope (cond ((not scope) (plist-get info :parse-tree))

+ ((eq (org-element-type scope) 'headline) scope)

+ ((org-export-get-parent-headline scope))

+ (t (plist-get info :parse-tree))))

+ (limit (plist-get info :headline-levels))

+ (n (if (not (wholenump n)) limit

+ (min (if (eq (org-element-type scope) 'org-data) n

+ (+ (org-export-get-relative-level scope info) n))

+ limit))))

+ (org-element-map (org-element-contents scope) 'headline

+ (lambda (headline)

+ (unless (org-element-property :footnote-section-p headline)

+ (let ((level (org-export-get-relative-level headline info)))

+ (and (<= level n) headline))))

+ (primary-opening

+ :utf-8 "»" :html "&raquo;" :latex ">>" :texinfo "@guillemetright{}")

+ (primary-closing

+ :utf-8 "«" :html "&laquo;" :latex "<<" :texinfo "@guillemetleft{}")

+ (secondary-opening

+ :utf-8 "›" :html "&rsaquo;" :latex "\\frq{}" :texinfo "@guilsinglright{}")

+ (secondary-closing

+ :utf-8 "‹" :html "&lsaquo;" :latex "\\flq{}" :texinfo "@guilsingleft{}")

+ (primary-opening

+ :utf-8 "„" :html "&bdquo;" :latex "\"`" :texinfo "@quotedblbase{}")

+ (primary-closing

+ :utf-8 "“" :html "&ldquo;" :latex "\"'" :texinfo "@quotedblleft{}")

+ (secondary-opening

+ :utf-8 "‚" :html "&sbquo;" :latex "\\glq{}" :texinfo "@quotesinglbase{}")

+ (secondary-closing

+ :utf-8 "‘" :html "&lsquo;" :latex "\\grq{}" :texinfo "@quoteleft{}")

+ (primary-opening :utf-8 "“" :html "&ldquo;" :latex "``" :texinfo "``")

+ (primary-closing :utf-8 "”" :html "&rdquo;" :latex "''" :texinfo "''")

+ (secondary-opening :utf-8 "‘" :html "&lsquo;" :latex "`" :texinfo "`")

+ (secondary-closing :utf-8 "’" :html "&rsquo;" :latex "'" :texinfo "'")

+ (primary-opening

+ :utf-8 "«" :html "&laquo;" :latex "\\guillemotleft{}"

+ :texinfo "@guillemetleft{}")

+ (primary-closing

+ :utf-8 "»" :html "&raquo;" :latex "\\guillemotright{}"

+ :texinfo "@guillemetright{}")

+ (secondary-opening :utf-8 "“" :html "&ldquo;" :latex "``" :texinfo "``")

+ (secondary-closing :utf-8 "”" :html "&rdquo;" :latex "''" :texinfo "''")

+ (primary-opening

+ :utf-8 "« " :html "&laquo;&nbsp;" :latex "\\og "

+ :texinfo "@guillemetleft{}@tie{}")

+ (primary-closing

+ :utf-8 " »" :html "&nbsp;&raquo;" :latex "\\fg{}"

+ :texinfo "@tie{}@guillemetright{}")

+ (secondary-opening

+ :utf-8 "« " :html "&laquo;&nbsp;" :latex "\\og "

+ :texinfo "@guillemetleft{}@tie{}")

+ (secondary-closing :utf-8 " »" :html "&nbsp;&raquo;" :latex "\\fg{}"

+ :texinfo "@tie{}@guillemetright{}")

+ (apostrophe :utf-8 "’" :html "&rsquo;"))

+ ("is"

+ (primary-opening

+ :utf-8 "„" :html "&bdquo;" :latex "\"`" :texinfo "@quotedblbase{}")

+ (primary-closing

+ :utf-8 "“" :html "&ldquo;" :latex "\"'" :texinfo "@quotedblleft{}")

+ (secondary-opening

+ :utf-8 "‚" :html "&sbquo;" :latex "\\glq{}" :texinfo "@quotesinglbase{}")

+ (secondary-closing

+ :utf-8 "‘" :html "&lsquo;" :latex "\\grq{}" :texinfo "@quoteleft{}")

+ (primary-opening

+ :utf-8 "«" :html "&laquo;" :latex "\\guillemotleft{}"

+ :texinfo "@guillemetleft{}")

+ (primary-closing

+ :utf-8 "»" :html "&raquo;" :latex "\\guillemotright{}"

+ :texinfo "@guillemetright{}")

+ (secondary-opening :utf-8 "‘" :html "&lsquo;" :latex "`" :texinfo "`")

+ (secondary-closing :utf-8 "’" :html "&rsquo;" :latex "'" :texinfo "'")

+ (primary-opening

+ :utf-8 "«" :html "&laquo;" :latex "\\guillemotleft{}"

+ :texinfo "@guillemetleft{}")

+ (primary-closing

+ :utf-8 "»" :html "&raquo;" :latex "\\guillemotright{}"

+ :texinfo "@guillemetright{}")

+ (secondary-opening :utf-8 "‘" :html "&lsquo;" :latex "`" :texinfo "`")

+ (secondary-closing :utf-8 "’" :html "&rsquo;" :latex "'" :texinfo "'")

+ (primary-opening

+ :utf-8 "«" :html "&laquo;" :latex "\\guillemotleft{}"

+ :texinfo "@guillemetleft{}")

+ (primary-closing

+ :utf-8 "»" :html "&raquo;" :latex "\\guillemotright{}"

+ :texinfo "@guillemetright{}")

+ (secondary-opening :utf-8 "‘" :html "&lsquo;" :latex "`" :texinfo "`")

+ (secondary-closing :utf-8 "’" :html "&rsquo;" :latex "'" :texinfo "'")

+ ("ru"

+ ;; http://ru.wikipedia.org/wiki/%D0%9A%D0%B0%D0%B2%D1%8B%D1%87%D0%BA%D0%B8#.D0.9A.D0.B0.D0.B2.D1.8B.D1.87.D0.BA.D0.B8.2C_.D0.B8.D1.81.D0.BF.D0.BE.D0.BB.D1.8C.D0.B7.D1.83.D0.B5.D0.BC.D1.8B.D0.B5_.D0.B2_.D1.80.D1.83.D1.81.D1.81.D0.BA.D0.BE.D0.BC_.D1.8F.D0.B7.D1.8B.D0.BA.D0.B5

+ ;; http://www.artlebedev.ru/kovodstvo/sections/104/

+ (primary-opening :utf-8 "«" :html "&laquo;" :latex "{}<<"

+ :texinfo "@guillemetleft{}")

+ (primary-closing :utf-8 "»" :html "&raquo;" :latex ">>{}"

+ :texinfo "@guillemetright{}")

+ (secondary-opening

+ :utf-8 "„" :html "&bdquo;" :latex "\\glqq{}" :texinfo "@quotedblbase{}")

+ (secondary-closing

+ :utf-8 "“" :html "&ldquo;" :latex "\\grqq{}" :texinfo "@quotedblleft{}")

+ (apostrophe :utf-8 "’" :html: "&#39;"))

+ (primary-opening :utf-8 "”" :html "&rdquo;" :latex "’’" :texinfo "’’")

+ (primary-closing :utf-8 "”" :html "&rdquo;" :latex "’’" :texinfo "’’")

+ (secondary-opening :utf-8 "’" :html "&rsquo;" :latex "’" :texinfo "`")

+ (secondary-closing :utf-8 "’" :html "&rsquo;" :latex "’" :texinfo "'")

+ (apostrophe :utf-8 "’" :html "&rsquo;")))

+A quote type can be any symbol among `primary-opening',

+`primary-closing', `secondary-opening', `secondary-closing' and

+`apostrophe'.

+(defun org-export--smart-quote-status (s info)

+ "Return smart quote status at the beginning of string S.

+INFO is the current export state, as a plist."

+ (let* ((parent (org-element-property :parent s))

+ (cache (or (plist-get info :smart-quote-cache)

+ (let ((table (make-hash-table :test #'eq)))

+ (plist-put info :smart-quote-cache table)

+ table)))

+ (value (gethash parent cache 'missing-data)))

+ (if (not (eq value 'missing-data)) (cdr (assq s value))

+ (let (level1-open full-status)

+ (org-element-map

+ (let ((secondary (org-element-secondary-p s)))

+ (if secondary (org-element-property secondary parent)

+ (org-element-contents parent)))

+ 'plain-text

+ (lambda (text)

+ (let ((start 0) current-status)

+ (while (setq start (string-match "['\"]" text start))

+ (push

+ (cond

+ ((equal (match-string 0 text) "\"")

+ (setf level1-open (not level1-open))

+ (if level1-open 'primary-opening 'primary-closing))

+ ;; Not already in a level 1 quote: this is an

+ ;; apostrophe.

+ ((not level1-open) 'apostrophe)

+ ;; Extract previous char and next char. As

+ ;; a special case, they can also be set to `blank',

+ ;; `no-blank' or nil. Then determine if current

+ ;; match is allowed as an opening quote or a closing

+ ;; quote.

+ (t

+ (let* ((previous

+ (if (> start 0) (substring text (1- start) start)

+ (let ((p (org-export-get-previous-element

+ text info)))

+ (cond ((not p) nil)

+ ((stringp p) (substring p -1))

+ ((memq (org-element-property :post-blank p)

+ '(0 nil))

+ 'no-blank)

+ (t 'blank)))))

+ (next

+ (if (< (1+ start) (length text))

+ (substring text (1+ start) (+ start 2))

+ (let ((n (org-export-get-next-element text info)))

+ (cond ((not n) nil)

+ ((stringp n) (substring n 0 1))

+ (t 'no-blank)))))

+ (allow-open

+ (and (if (stringp previous)

+ (string-match "\\s\"\\|\\s-\\|\\s("

+ previous)

+ (memq previous '(blank nil)))

+ (if (stringp next)

+ (string-match "\\w\\|\\s.\\|\\s_" next)

+ (eq next 'no-blank))))

+ (allow-close

+ (and (if (stringp previous)

+ (string-match "\\w\\|\\s.\\|\\s_" previous)

+ (eq previous 'no-blank))

+ (if (stringp next)

+ (string-match "\\s-\\|\\s)\\|\\s.\\|\\s\""

+ next)

+ (memq next '(blank nil))))))

+ (cond

+ ((and allow-open allow-close) (error "Should not happen"))

+ (allow-open 'secondary-opening)

+ (allow-close 'secondary-closing)

+ (t 'apostrophe)))))

+ current-status)

+ (cl-incf start))

+ (when current-status

+ (push (cons text (nreverse current-status)) full-status))))

+ info nil org-element-recursive-objects)

+ (puthash parent full-status cache)

+ (cdr (assq s full-status))))))

+ (let ((quote-status

+ (copy-sequence (org-export--smart-quote-status (or original s) info))))

+ (replace-regexp-in-string

+ "['\"]"

+ (lambda (match)

+ (or (plist-get

+ (cdr (assq (pop quote-status)

+ (cdr (assoc (plist-get info :language)

+ org-export-smart-quotes-alist))))

+ encoding)

+ match))

+ s nil t)))

+ (org-element-lineage blob '(headline)))

+ (org-element-lineage object org-element-all-elements))

+ (org-element-lineage object '(table)))

+ (let* ((secondary (org-element-secondary-p blob))

+ (parent (org-export-get-parent blob))

+ (siblings

+ (if secondary (org-element-property secondary parent)

+ (org-element-contents parent)))

+ prev)

+ (dolist (obj (cdr (memq blob (reverse siblings))) prev)

+ (cond ((memq obj (plist-get info :ignore-list)))

+ ((null n) (throw 'exit obj))

+ ((not (wholenump n)) (push obj prev))

+ ((zerop n) (throw 'exit prev))

+ (t (cl-decf n) (push obj prev)))))))

+ (let* ((secondary (org-element-secondary-p blob))

+ (parent (org-export-get-parent blob))

+ (siblings

+ (cdr (memq blob

+ (if secondary (org-element-property secondary parent)

+ (org-element-contents parent)))))

+ next)

+ (dolist (obj siblings (nreverse next))

+ (cond ((memq obj (plist-get info :ignore-list)))

+ ((null n) (throw 'exit obj))

+ ((not (wholenump n)) (push obj next))

+ ((zerop n) (throw 'exit (nreverse next)))

+ (t (cl-decf n) (push obj next)))))))

+ ("et" :default "Autor")

+ ("ja" :default "著者" :html "&#33879;&#32773;")

+ ("pt_BR" :default "Autor")

+ ("Continued from previous page"

+ ("de" :default "Fortsetzung von vorheriger Seite")

+ ("es" :html "Contin&uacute;a de la p&aacute;gina anterior" :ascii "Continua de la pagina anterior" :default "Continúa de la página anterior")

+ ("fr" :default "Suite de la page précédente")

+ ("it" :default "Continua da pagina precedente")

+ ("ja" :default "前ページからの続き")

+ ("nl" :default "Vervolg van vorige pagina")

+ ("pt" :default "Continuação da página anterior")

+ ("ru" :html "(&#1055;&#1088;&#1086;&#1076;&#1086;&#1083;&#1078;&#1077;&#1085;&#1080;&#1077;)"

+ :utf-8 "(Продолжение)"))

+ ("Continued on next page"

+ ("de" :default "Fortsetzung nächste Seite")

+ ("es" :html "Contin&uacute;a en la siguiente p&aacute;gina" :ascii "Continua en la siguiente pagina" :default "Continúa en la siguiente página")

+ ("fr" :default "Suite page suivante")

+ ("it" :default "Continua alla pagina successiva")

+ ("ja" :default "次ページに続く")

+ ("nl" :default "Vervolg op volgende pagina")

+ ("pt" :default "Continua na página seguinte")

+ ("ru" :html "(&#1055;&#1088;&#1086;&#1076;&#1086;&#1083;&#1078;&#1077;&#1085;&#1080;&#1077; &#1089;&#1083;&#1077;&#1076;&#1091;&#1077;&#1090;)"

+ :utf-8 "(Продолжение следует)"))

+ ("et" :html "Kuup&#228;ev" :utf-8 "Kuupäev")

+ ("ja" :default "日付" :html "&#26085;&#20184;")

+ ("pt_BR" :default "Data")

+ ("es" :ascii "Ecuacion" :html "Ecuaci&oacute;n" :default "Ecuación")

+ ("et" :html "V&#245;rrand" :utf-8 "Võrrand")

+ ("is" :default "Jafna")

+ ("ja" :default "方程式")

+ ("pt_BR" :html "Equa&ccedil;&atilde;o" :default "Equação" :ascii "Equacao")

+ ("ru" :html "&#1059;&#1088;&#1072;&#1074;&#1085;&#1077;&#1085;&#1080;&#1077;"

+ :utf-8 "Уравнение")

+ ("et" :default "Joonis")

+ ("is" :default "Mynd")

+ ("ja" :default "図" :html "&#22259;")

+ ("pt_BR" :default "Figura")

+ ("ru" :html "&#1056;&#1080;&#1089;&#1091;&#1085;&#1086;&#1082;" :utf-8 "Рисунок")

+ ("et" :default "Joonis %d:")

+ ("is" :default "Mynd %d")

+ ("ja" :default "図%d: " :html "&#22259;%d: ")

+ ("pt_BR" :default "Figura %d:")

+ ("ru" :html "&#1056;&#1080;&#1089;. %d.:" :utf-8 "Рис. %d.:")

+ ("es" :ascii "Nota al pie de pagina" :html "Nota al pie de p&aacute;gina" :default "Nota al pie de página")

+ ("et" :html "Allm&#228;rkused" :utf-8 "Allmärkused")

+ ("ja" :default "脚注" :html "&#33050;&#27880;")

+ ("pt_BR" :html "Notas de Rodap&eacute;" :default "Notas de Rodapé" :ascii "Notas de Rodape")

+ ("es" :ascii "Indice de Listados de programas" :html "&Iacute;ndice de Listados de programas" :default "Índice de Listados de programas")

+ ("et" :default "Loendite nimekiri")

+ ("ja" :default "ソースコード目次")

+ ("ru" :html "&#1057;&#1087;&#1080;&#1089;&#1086;&#1082; &#1088;&#1072;&#1089;&#1087;&#1077;&#1095;&#1072;&#1090;&#1086;&#1082;"

+ :utf-8 "Список распечаток")

+ ("es" :ascii "Indice de tablas" :html "&Iacute;ndice de tablas" :default "Índice de tablas")

+ ("et" :default "Tabelite nimekiri")

+ ("is" :default "Töfluskrá" :html "T&ouml;fluskr&aacute;")

+ ("ja" :default "表目次")

+ ("pt_BR" :default "Índice de Tabelas" :ascii "Indice de Tabelas")

+ ("ru" :html "&#1057;&#1087;&#1080;&#1089;&#1086;&#1082; &#1090;&#1072;&#1073;&#1083;&#1080;&#1094;"

+ :utf-8 "Список таблиц")

+ ("Listing"

+ ("da" :default "Program")

+ ("de" :default "Programmlisting")

+ ("es" :default "Listado de programa")

+ ("et" :default "Loend")

+ ("fr" :default "Programme" :html "Programme")

+ ("ja" :default "ソースコード")

+ ("no" :default "Dataprogram")

+ ("nb" :default "Dataprogram")

+ ("pt_BR" :default "Listagem")

+ ("ru" :html "&#1056;&#1072;&#1089;&#1087;&#1077;&#1095;&#1072;&#1090;&#1082;&#1072;"

+ :utf-8 "Распечатка")

+ ("zh-CN" :html "&#20195;&#30721;" :utf-8 "代码"))

+ ("et" :default "Loend %d")

+ ("ja" :default "ソースコード%d:")

+ ("no" :default "Dataprogram %d")

+ ("nb" :default "Dataprogram %d")

+ ("pt_BR" :default "Listagem %d")

+ ("ru" :html "&#1056;&#1072;&#1089;&#1087;&#1077;&#1095;&#1072;&#1090;&#1082;&#1072; %d.:"

+ :utf-8 "Распечатка %d.:")

+ ("References"

+ ("fr" :ascii "References" :default "Références")

+ ("de" :default "Quellen")

+ ("es" :default "Referencias"))

+ ("See figure %s"

+ ("fr" :default "cf. figure %s"

+ :html "cf.&nbsp;figure&nbsp;%s" :latex "cf.~figure~%s"))

+ ("See listing %s"

+ ("fr" :default "cf. programme %s"

+ :html "cf.&nbsp;programme&nbsp;%s" :latex "cf.~programme~%s"))

+ ("es" :ascii "Vea seccion %s" :html "Vea secci&oacute;n %s" :default "Vea sección %s")

+ ("et" :html "Vaata peat&#252;kki %s" :utf-8 "Vaata peatükki %s")

+ ("ja" :default "セクション %s を参照")

+ ("pt_BR" :html "Veja a se&ccedil;&atilde;o %s" :default "Veja a seção %s"

+ :ascii "Veja a secao %s")

+ ("ru" :html "&#1057;&#1084;. &#1088;&#1072;&#1079;&#1076;&#1077;&#1083; %s"

+ :utf-8 "См. раздел %s")

+ ("zh-CN" :html "&#21442;&#35265;&#31532;%s&#33410;" :utf-8 "参见第%s节"))

+ ("See table %s"

+ ("fr" :default "cf. tableau %s"

+ :html "cf.&nbsp;tableau&nbsp;%s" :latex "cf.~tableau~%s"))

+ ("et" :default "Tabel")

+ ("is" :default "Tafla")

+ ("ja" :default "表" :html "&#34920;")

+ ("pt_BR" :default "Tabela")

+ ("ru" :html "&#1058;&#1072;&#1073;&#1083;&#1080;&#1094;&#1072;"

+ :utf-8 "Таблица")

+ ("et" :default "Tabel %d")

+ ("is" :default "Tafla %d")

+ ("ja" :default "表%d:" :html "&#34920;%d:")

+ ("pt_BR" :default "Tabela %d")

+ ("ru" :html "&#1058;&#1072;&#1073;&#1083;&#1080;&#1094;&#1072; %d.:"

+ :utf-8 "Таблица %d.:")

+ ("es" :ascii "Indice" :html "&Iacute;ndice" :default "Índice")

+ ("et" :default "Sisukord")

+ ("ja" :default "目次" :html "&#30446;&#27425;")

+ ("pt_BR" :html "&Iacute;ndice" :utf8 "Índice" :ascii "Indice")

+ ("es" :default "Referencia desconocida")

+ ("et" :default "Tundmatu viide")

+ ("ja" :default "不明な参照先")

+ ("pt_BR" :default "Referência desconhecida"

+ :ascii "Referencia desconhecida")

+ ("ru" :html "&#1053;&#1077;&#1080;&#1079;&#1074;&#1077;&#1089;&#1090;&#1085;&#1072;&#1103; &#1089;&#1089;&#1099;&#1083;&#1082;&#1072;"

+ :utf-8 "Неизвестная ссылка")

+Alist whose car is the string to translate and cdr is an alist

+whose car is the language string and cdr is a plist whose

+It is used as a database for `org-export-translate'. Since this

+Translation depends on `:language' property. Return the

+translated string. If no translation is found, try to fall back

+to `:default' encoding. If it fails, return S."

+ (apply

+ #'start-process

+ (append

+ (list "org-export-process"

+ ,proc-buffer

+ (expand-file-name invocation-name invocation-directory)

+ "--batch")

+ (if org-export-async-init-file

+ (list "-Q" "-l" org-export-async-init-file)

+ (list "-l" user-init-file))

+ (list "-l" ,temp-file)))))

+ ;; property.

+ (or (and subtreep (org-entry-get nil "EXPORT_FILE_NAME" 'selective))

+ (read-file-name

+ "Output file: " pub-dir nil nil nil

+ (lambda (name)

+ (string= (file-name-extension name t) extension))))))

+ (if (and visited-file (file-equal-p visited-file output-file))

+ (with-current-buffer buffer

+ (org-export-stack-mode)

+ (tabulated-list-print t))

+(defun org-export-stack-refresh ()

+ "Refresh the export stack."

+ (interactive)

+ (tabulated-list-print t))

+ (cl-remove-if (lambda (el) (equal (car el) source))

+ (set-keymap-parent km tabulated-list-mode-map)

+(define-derived-mode org-export-stack-mode tabulated-list-mode "Org-Stack"

+Type `\\[org-export-stack]' to visualize the asynchronous export

+In an Org Export Stack buffer, use \

+\\<org-export-stack-mode-map>`\\[org-export-stack-view]' to view export output

+on current line, `\\[org-export-stack-remove]' to remove it from the stack and \

+`\\[org-export-stack-clear]' to clear

+Removing entries in a stack buffer does not affect files

+or buffers, only display.

+ (setq tabulated-list-format

+ (vector (list "#" 4 #'org-export--stack-num-predicate)

+ (list "Back-End" 12 t)

+ (list "Age" 6 nil)

+ (list "Source" 0 nil)))

+ (setq tabulated-list-sort-key (cons "#" nil))

+ (setq tabulated-list-entries #'org-export--stack-generate)

+ (add-hook 'tabulated-list-revert-hook #'org-export--stack-generate nil t)

+ (add-hook 'post-command-hook #'org-export-stack-refresh nil t)

+ (tabulated-list-init-header))

+

+(defun org-export--stack-generate ()

+ "Generate the asynchronous export stack for display.

+Unavailable sources are removed from the list. Return a list

+appropriate for `tabulated-list-print'."

+ ;; Clear stack from exited processes, dead buffers or non-existent

+ ;; files.

+ (setq org-export-stack-contents

+ (cl-remove-if-not

+ (lambda (el)

+ (if (processp (nth 2 el))

+ (buffer-live-p (process-buffer (nth 2 el)))

+ (let ((source (car el)))

+ (if (bufferp source) (buffer-live-p source)

+ (file-exists-p source)))))

+ org-export-stack-contents))

+ ;; Update `tabulated-list-entries'.

+ (let ((counter 0))

+ (mapcar

+ (lambda (entry)

+ (let ((source (car entry)))

+ (list source

+ (vector

+ ;; Counter.

+ (number-to-string (cl-incf counter))

+ ;; Back-End.

+ (if (nth 1 entry) (symbol-name (nth 1 entry)) "")

+ ;; Age.

+ (let ((info (nth 2 entry)))

+ (if (processp info) (symbol-name (process-status info))

+ (format-seconds "%h:%.2m" (float-time (time-since info)))))

+ ;; Source.

+ (if (stringp source) source (buffer-name source))))))

+ org-export-stack-contents)))

+

+(defun org-export--stack-num-predicate (a b)

+ (< (string-to-number (aref (nth 1 a) 0))

+ (string-to-number (aref (nth 1 b) 0))))

+

+(defun org-export--stack-source-at-point ()

+ "Return source from export results at point in stack."

+ (let ((source (car (nth (1- (org-current-line)) org-export-stack-contents))))

+ (if (not source) (error "Source unavailable, please refresh buffer")

+ (let ((source-name (if (stringp source) source (buffer-name source))))

+ (if (save-excursion

+ (beginning-of-line)

+ (looking-at-p (concat ".* +" (regexp-quote source-name) "$")))

+ source

+ ;; SOURCE is not consistent with current line. The stack

+ ;; view is outdated.

+ (error (substitute-command-keys

+ "Source unavailable; type `\\[org-export-stack-refresh]' \

+to refresh buffer")))))))

+When ARG is `\\[universal-argument]', repeat the last export action, with the\

+ same

+set of options used back then, on the current buffer.

+When ARG is `\\[universal-argument] \\[universal-argument]', display the \

+asynchronous export stack."

+ (cl-case action

+ (org-publish (assoc (completing-read

+ (propertize key 'face 'org-warning)

+ (propertize value 'face 'font-lock-variable-name-face)))

+ (mapcar #'org-export-backend-menu

+ org-export-registered-backends))

+\[%s] Export scope: %s [%s] Force publishing: %s

+\[%s] Async export: %s\n\n"

+ (cl-incf index)

+ (prompt allowed-keys entries options first-key expertp)

+ (cl-case key

+ (let ((option (cl-case key (2 'body) (22 'visible) (19 'subtree)

+ (6 'force) (1 'async))))

+ (cl-case key

+ (dolist (entry (member (assq first-key entries) entries))

+ (let ((match (assq key (nth 2 entry))))

+ (when match (throw 'found (nth 2 match))))))))