org-mode/contrib/lisp/org-lparse.el

2179 lines
78 KiB
EmacsLisp
Raw Normal View History

;;; org-lparse.el --- Line-oriented parser-exporter for Org-mode
;; Copyright (C) 2010, 2011
;; Jambunathan <kjambunathan at gmail dot com>
;; Author: Jambunathan K <kjambunathan at gmail dot com>
;; Keywords: outlines, hypermedia, calendar, wp
;; Homepage: http://orgmode.org
;; Version: 0.8
;; This file is not (yet) part of GNU Emacs.
;; However, it is distributed under the same license.
;; GNU Emacs is free software: you can redistribute it and/or modify
;; it under the terms of the GNU General Public License as published by
;; the Free Software Foundation, either version 3 of the License, or
;; (at your option) any later version.
;; GNU Emacs is distributed in the hope that it will be useful,
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;; GNU General Public License for more details.
;; You should have received a copy of the GNU General Public License
;; along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;;; Commentary:
;; `org-lparse' is the entry point for the generic line-oriented
;; exporter. `org-do-lparse' is the genericized version of the
;; original `org-export-as-html' routine.
;; `org-lparse-native-backends' is a good starting point for
;; exploring the generic exporter.
;; Following new interactive commands are provided by this library.
;; `org-lparse', `org-lparse-and-open', `org-lparse-to-buffer'
;; `org-replace-region-by', `org-lparse-region'.
;; Note that the above routines correspond to the following routines
;; in the html exporter `org-export-as-html',
;; `org-export-as-html-and-open', `org-export-as-html-to-buffer',
;; `org-replace-region-by-html' and `org-export-region-as-html'.
;; The new interactive command `org-lparse-convert' can be used to
;; convert documents between various formats. Use this to command,
;; for example, to convert odt file to doc or pdf format.
;; See README.org file that comes with this library for answers to
;; FAQs and more information on using this library.
;;; Code:
(require 'org-exp)
(require 'org-list)
;;;###autoload
(defun org-lparse-and-open (target-backend native-backend arg)
"Export outline to TARGET-BACKEND via NATIVE-BACKEND and open exported file.
If there is an active region, export only the region. The prefix
ARG specifies how many levels of the outline should become
headlines. The default is 3. Lower levels will become bulleted
lists."
;; (interactive "Mbackend: \nP")
(interactive
(let* ((input (if (featurep 'ido) 'ido-completing-read 'completing-read))
(all-backends (org-lparse-all-backends))
(target-backend
(funcall input "Export to: " all-backends nil t nil))
(native-backend
(or
;; (and (org-lparse-backend-is-native-p target-backend)
;; target-backend)
(funcall input "Use Native backend: "
(cdr (assoc target-backend all-backends)) nil t nil))))
(list target-backend native-backend current-prefix-arg)))
(let (f (file-or-buf (org-lparse target-backend native-backend
arg 'hidden)))
(when file-or-buf
(setq f (cond
((bufferp file-or-buf) buffer-file-name)
((file-exists-p file-or-buf) file-or-buf)
(t (error "org-lparse-and-open: This shouldn't happen"))))
(message "Opening file %s" f)
(org-open-file f)
(when org-export-kill-product-buffer-when-displayed
(kill-buffer (current-buffer))))))
;;;###autoload
(defun org-lparse-batch (target-backend &optional native-backend)
"Call the function `org-lparse'.
This function can be used in batch processing as:
emacs --batch
--load=$HOME/lib/emacs/org.el
--eval \"(setq org-export-headline-levels 2)\"
--visit=MyFile --funcall org-lparse-batch"
(setq native-backend (or native-backend target-backend))
(org-lparse target-backend native-backend
org-export-headline-levels 'hidden))
;;;###autoload
(defun org-lparse-to-buffer (backend arg)
"Call `org-lparse' with output to a temporary buffer.
No file is created. The prefix ARG is passed through to
`org-lparse'."
(interactive "Mbackend: \nP")
(let ((tempbuf (format "*Org %s Export*" (upcase backend))))
(org-lparse backend backend arg nil nil tempbuf)
(when org-export-show-temporary-export-buffer
(switch-to-buffer-other-window tempbuf))))
;;;###autoload
(defun org-replace-region-by (backend beg end)
"Assume the current region has org-mode syntax, and convert it to HTML.
This can be used in any buffer. For example, you could write an
itemized list in org-mode syntax in an HTML buffer and then use this
command to convert it."
(interactive "Mbackend: \nr")
(let (reg backend-string buf pop-up-frames)
(save-window-excursion
(if (org-mode-p)
(setq backend-string (org-lparse-region backend beg end t 'string))
(setq reg (buffer-substring beg end)
buf (get-buffer-create "*Org tmp*"))
(with-current-buffer buf
(erase-buffer)
(insert reg)
(org-mode)
(setq backend-string (org-lparse-region backend (point-min)
(point-max) t 'string)))
(kill-buffer buf)))
(delete-region beg end)
(insert backend-string)))
;;;###autoload
(defun org-lparse-region (backend beg end &optional body-only buffer)
"Convert region from BEG to END in org-mode buffer to HTML.
If prefix arg BODY-ONLY is set, omit file header, footer, and table of
contents, and only produce the region of converted text, useful for
cut-and-paste operations.
If BUFFER is a buffer or a string, use/create that buffer as a target
of the converted HTML. If BUFFER is the symbol `string', return the
produced HTML as a string and leave not buffer behind. For example,
a Lisp program could call this function in the following way:
(setq html (org-lparse-region \"html\" beg end t 'string))
When called interactively, the output buffer is selected, and shown
in a window. A non-interactive call will only return the buffer."
(interactive "Mbackend: \nr\nP")
(when (org-called-interactively-p 'any)
(setq buffer (format "*Org %s Export*" (upcase backend))))
(let ((transient-mark-mode t) (zmacs-regions t)
ext-plist rtn)
(setq ext-plist (plist-put ext-plist :ignore-subtree-p t))
(goto-char end)
(set-mark (point)) ;; to activate the region
(goto-char beg)
(setq rtn (org-lparse backend backend nil nil ext-plist buffer body-only))
(if (fboundp 'deactivate-mark) (deactivate-mark))
(if (and (org-called-interactively-p 'any) (bufferp rtn))
(switch-to-buffer-other-window rtn)
rtn)))
(defvar org-lparse-par-open nil)
(defun org-lparse-should-inline-p (filename descp)
"Return non-nil if link FILENAME should be inlined.
The decision to inline the FILENAME link is based on the current
settings. DESCP is the boolean of whether there was a link
description. See variables `org-export-html-inline-images' and
`org-export-html-inline-image-extensions'."
(let ((inline-images (org-lparse-get 'INLINE-IMAGES))
(inline-image-extensions
(org-lparse-get 'INLINE-IMAGE-EXTENSIONS)))
(and (or (eq t inline-images) (and inline-images (not descp)))
(org-file-image-p filename inline-image-extensions))))
(defun org-lparse-format-org-link (line opt-plist)
"Return LINE with markup of Org mode links.
OPT-PLIST is the export options list."
(let ((start 0)
(current-dir (if buffer-file-name
(file-name-directory buffer-file-name)
default-directory))
(link-validate (plist-get opt-plist :link-validation-function))
type id-file fnc
rpl path attr desc descp desc1 desc2 link
org-lparse-link-description-is-image)
(while (string-match org-bracket-link-analytic-regexp++ line start)
(setq org-lparse-link-description-is-image nil)
(setq start (match-beginning 0))
(setq path (save-match-data (org-link-unescape
(match-string 3 line))))
(setq type (cond
((match-end 2) (match-string 2 line))
((save-match-data
(or (file-name-absolute-p path)
(string-match "^\\.\\.?/" path)))
"file")
(t "internal")))
(setq path (org-extract-attributes (org-link-unescape path)))
(setq attr (get-text-property 0 'org-attributes path))
(setq desc1 (if (match-end 5) (match-string 5 line))
desc2 (if (match-end 2) (concat type ":" path) path)
descp (and desc1 (not (equal desc1 desc2)))
desc (or desc1 desc2))
;; Make an image out of the description if that is so wanted
(when (and descp (org-file-image-p
desc (org-lparse-get 'INLINE-IMAGE-EXTENSIONS)))
(setq org-lparse-link-description-is-image t)
(save-match-data
(if (string-match "^file:" desc)
(setq desc (substring desc (match-end 0)))))
(save-match-data
(setq desc (org-add-props
(org-lparse-format 'INLINE-IMAGE desc)
'(org-protected t)))))
(cond
((equal type "internal")
(let
((frag-0
(if (= (string-to-char path) ?#)
(substring path 1)
path)))
(setq rpl
(org-lparse-format
'ORG-LINK opt-plist "" "" (org-solidify-link-text
(save-match-data
(org-link-unescape frag-0))
nil) desc attr descp))))
((and (equal type "id")
(setq id-file (org-id-find-id-file path)))
;; This is an id: link to another file (if it was the same file,
;; it would have become an internal link...)
(save-match-data
(setq id-file (file-relative-name
id-file
(file-name-directory org-current-export-file)))
(setq rpl
(org-lparse-format
'ORG-LINK opt-plist type id-file
(concat (if (org-uuidgen-p path) "ID-") path)
desc attr descp))))
((member type '("http" "https"))
;; standard URL, can inline as image
(setq rpl
(org-lparse-format
'ORG-LINK opt-plist type path nil desc attr descp)))
((member type '("ftp" "mailto" "news"))
;; standard URL, can't inline as image
(setq rpl
(org-lparse-format
'ORG-LINK opt-plist type path nil desc attr descp)))
((string= type "coderef")
(setq rpl
(org-lparse-format
'ORG-LINK opt-plist type "" (format "coderef-%s" path)
(format
(org-export-get-coderef-format
path
(and descp desc))
(cdr (assoc path org-export-code-refs))) nil descp)))
((functionp (setq fnc (nth 2 (assoc type org-link-protocols))))
;; The link protocol has a function for format the link
(setq rpl
(save-match-data
(funcall fnc (org-link-unescape path) desc1 'html))))
((string= type "file")
;; FILE link
(save-match-data
(let*
((components
(if
(string-match "::\\(.*\\)" path)
(list
(replace-match "" t nil path)
(match-string 1 path))
(list path nil)))
;;The proper path, without a fragment
(path-1
(first components))
;;The raw fragment
(fragment-0
(second components))
;;Check the fragment. If it can't be used as
;;target fragment we'll pass nil instead.
(fragment-1
(if
(and fragment-0
(not (string-match "^[0-9]*$" fragment-0))
(not (string-match "^\\*" fragment-0))
(not (string-match "^/.*/$" fragment-0)))
(org-solidify-link-text
(org-link-unescape fragment-0))
nil))
(desc-2
;;Description minus "file:" and ".org"
(if (string-match "^file:" desc)
(let
((desc-1 (replace-match "" t t desc)))
(if (string-match "\\.org$" desc-1)
(replace-match "" t t desc-1)
desc-1))
desc)))
(setq rpl
(if
(and
(functionp link-validate)
(not (funcall link-validate path-1 current-dir)))
desc
(org-lparse-format
'ORG-LINK opt-plist "file" path-1 fragment-1
desc-2 attr descp))))))
(t
;; just publish the path, as default
(setq rpl (concat "<i>&lt;" type ":"
(save-match-data (org-link-unescape path))
"&gt;</i>"))))
(setq line (replace-match rpl t t line)
start (+ start (length rpl))))
line))
(defmacro with-org-lparse-preserve-paragraph-state (&rest body)
`(let ((org-lparse-do-open-par org-lparse-par-open))
(org-lparse-end-paragraph)
,@body
(when org-lparse-do-open-par
(org-lparse-begin-paragraph))))
(defvar org-lparse-native-backends nil
"List of native backends registered with `org-lparse'.
A backend can use `org-lparse-register-backend' to add itself to
this list.
All native backends must implement a get routine and a mandatory
set of callback routines.
The get routine must be named as org-<backend>-get where backend
is the name of the backend. The exporter uses `org-lparse-get'
and retrieves the backend-specific callback by querying for
ENTITY-CONTROL and ENTITY-FORMAT variables.
For the sake of illustration, the html backend implements
`org-xhtml-get'. It returns
`org-xhtml-entity-control-callbacks-alist' and
`org-xhtml-entity-format-callbacks-alist' as the values of
ENTITY-CONTROL and ENTITY-FORMAT settings.")
(defun org-lparse-register-backend (backend)
"Make BACKEND known to `org-lparse' library.
Add BACKEND to `org-lparse-native-backends'."
(when backend
(setq backend (cond
((symbolp backend) (symbol-name backend))
((stringp backend) backend)
(t (error "Error while registering backend: %S" backend))))
(add-to-list 'org-lparse-native-backends backend)))
(defun org-lparse-unregister-backend (backend)
(setq org-lparse-native-backends
(remove (cond
((symbolp backend) (symbol-name backend))
((stringp backend) backend))
org-lparse-native-backends))
(message "Unregistered backend %S" backend))
(defun org-lparse-get-other-backends (in-fmt)
"Return OUTPUT-FMT-ALIST corresponding to IN-FMT.
See `org-lparse-convert-capabilities' for definition of
OUTPUT-FMT-ALIST."
(when (org-lparse-get-converter in-fmt)
(or (ignore-errors (org-lparse-backend-get in-fmt 'OTHER-BACKENDS) )
(catch 'out-fmts
(dolist (c org-lparse-convert-capabilities)
(when (member in-fmt (nth 1 c))
(throw 'out-fmts (nth 2 c))))))))
(defun org-lparse-get-converter (in-fmt)
"Return converter associated with IN-FMT.
See `org-lparse-convert-capabilities' for further information."
(or (ignore-errors (org-lparse-backend-get in-fmt 'CONVERT-METHOD))
org-lparse-convert-process))
(defun org-lparse-all-backends ()
"Return all formats to which `org-lparse' could export to.
The return value is an alist of the form (TARGET-BACKEND
NATIVE-BACKEND-1 NATIVE-BACKEND-2 ...) with the condition that
the org file can be exported to TARGET-BACKEND via any one of
NATIVE-BACKEND-1, NATIVE-BACKEND-2 etc.
For example, an entry of the form \"(\"pdf\" \"odt\" \"xhtml\")\"
would mean that the org file could be exported to \"pdf\" format
by exporting natively either to \"xhtml\" or \"odt\" backends."
(let (all-backends)
(flet ((add (other native)
(let ((val (assoc-string other all-backends t)))
(if val (setcdr val (nconc (list native) (cdr val)))
(push (cons other (list native)) all-backends)))))
(loop for backend in org-lparse-native-backends
do (loop for other in
(mapcar #'car (org-lparse-get-other-backends backend))
do (add other backend))))
all-backends))
(defun org-lparse-backend-is-native-p (backend)
(member backend org-lparse-native-backends))
(defun org-lparse (target-backend native-backend arg
&optional hidden ext-plist
to-buffer body-only pub-dir)
"Export the outline to various formats.
If there is an active region, export only the region. The outline
is first exported to NATIVE-BACKEND and optionally converted to
TARGET-BACKEND. See `org-lparse-native-backends' for list of
known native backends. Each native backend can specify a
converter and list of target backends it exports to using the
CONVERT-PROCESS and OTHER-BACKENDS settings of it's get
method. See `org-xhtml-get' for an illustrative example.
ARG is a prefix argument that specifies how many levels of
outline should become headlines. The default is 3. Lower levels
will become bulleted lists.
HIDDEN is obsolete and does nothing.
EXT-PLIST is a property list that controls various aspects of
export. The settings here override org-mode's default settings
and but are inferior to file-local settings.
TO-BUFFER dumps the exported lines to a buffer or a string
instead of a file. If TO-BUFFER is the symbol `string' return the
exported lines as a string. If TO-BUFFER is non-nil, create a
buffer with that name and export to that buffer.
BODY-ONLY controls the presence of header and footer lines in
exported text. If BODY-ONLY is non-nil, don't produce the file
header and footer, simply return the content of <body>...</body>,
without even the body tags themselves.
PUB-DIR specifies the publishing directory."
(interactive
(let* ((input (if (featurep 'ido) 'ido-completing-read 'completing-read))
(all-backends (org-lparse-all-backends))
(target-backend
(and all-backends
(funcall input "Export to: " all-backends nil t nil)))
(native-backend
(let ((choices (if target-backend
(cdr (assoc target-backend all-backends))
(or org-lparse-native-backends
(error "No registered backends")))))
(funcall input "Use Native backend: " choices nil t nil))))
(list target-backend native-backend current-prefix-arg)))
(let* ((org-lparse-backend (intern native-backend))
(org-lparse-other-backend (and target-backend
(intern target-backend))))
(unless (org-lparse-backend-is-native-p native-backend)
(error "Don't know how to export natively to backend %s" native-backend))
(unless (or (not target-backend)
(equal target-backend native-backend)
(assoc target-backend (org-lparse-get-other-backends
native-backend)))
(error "Don't know how to export to backend %s %s" target-backend
(format "via %s" native-backend)))
(run-hooks 'org-export-first-hook)
(org-do-lparse arg hidden ext-plist to-buffer body-only pub-dir)))
(defcustom org-lparse-convert-processes
'(("BasicODConverter"
("soffice" "-norestore" "-invisible" "-headless"
"\"macro:///BasicODConverter.Main.Convert(%I,%f,%O)\""))
("unoconv"
("unoconv" "-f" "%f" "-o" "%d" "%i")))
"Specify a list of document converters and their usage.
The converters in this list are offered as choices while
customizing `org-lparse-convert-process'.
This variable is an alist where each element is of the
form (CONVERTER-NAME (CONVERTER-PROGRAM ARG1 ARG2 ...)).
CONVERTER-NAME is name of the converter. CONVERTER-PROGRAM is
the name of the executable. ARG1, ARG2 etc are command line
options that are passed to CONVERTER-PROGRAM. Format specifiers
can be used in the ARGs and they are interpreted as below:
%i input file name in full
%I input file name as a URL
%f format of the output file
%o output file name in full
%O output file name as a URL
%d output dir in full
%D output dir as a URL."
:group 'org-lparse
:type
'(choice
(const :tag "None" nil)
(alist :tag "Converters"
:key-type (string :tag "Converter Name")
:value-type (group (cons (string :tag "Executable")
(repeat (string :tag "Command line args")))))))
(defcustom org-lparse-convert-process nil
"Command to convert from an Org exported format to other formats.
During customization, the list of choices are populated from
`org-lparse-convert-processes'. Refer afore-mentioned variable
for further information."
:group 'org-lparse
:type '(choice :convert-widget
(lambda (w)
(apply 'widget-convert (widget-type w)
(eval (car (widget-get w :args)))))
`((const :tag "None" nil)
,@(mapcar (lambda (c)
`(const :tag ,(car c) ,(cadr c)))
org-lparse-convert-processes))))
(defcustom org-lparse-convert-capabilities
'(("Text"
("odt" "ott" "doc" "rtf")
(("pdf" "pdf") ("odt" "odt") ("xhtml" "html") ("rtf" "rtf")
("ott" "ott") ("doc" "doc") ("ooxml" "xml") ("html" "html")))
("Web"
("html" "xhtml") (("pdf" "pdf") ("odt" "txt") ("html" "html")))
("Spreadsheet"
("ods" "ots" "xls" "csv")
(("pdf" "pdf") ("ots" "ots") ("html" "html") ("csv" "csv")
("ods" "ods") ("xls" "xls") ("xhtml" "xhtml") ("ooxml" "xml")))
("Presentation"
("odp" "otp" "ppt")
(("pdf" "pdf") ("swf" "swf") ("odp" "odp") ("xhtml" "xml")
("otp" "otp") ("ppt" "ppt") ("odg" "odg") ("html" "html"))))
"Specify input and output formats of `org-lparse-convert-process'.
More correctly, specify the set of input and output formats that
the user is actually interested in.
This variable is an alist where each element is of the
form (DOCUMENT-CLASS INPUT-FMT-LIST OUTPUT-FMT-ALIST).
INPUT-FMT-LIST is a list of INPUT-FMTs. OUTPUT-FMT-ALIST is an
alist where each element is of the form (OUTPUT-FMT
OUTPUT-FILE-EXTENSION).
The variable is interpreted as follows:
`org-lparse-convert-process' can take any document that is in
INPUT-FMT-LIST and produce any document that is in the
OUTPUT-FMT-LIST. A document converted to OUTPUT-FMT will have
OUTPUT-FILE-EXTENSION as the file name extension. OUTPUT-FMT
serves dual purposes:
- It is used for populating completion candidates during
`org-lparse' and `org-lparse-convert' commands.
- It is used as the value of \"%f\" specifier in
`org-lparse-convert-process'.
DOCUMENT-CLASS is used to group a set of file formats in
INPUT-FMT-LIST in to a single class.
Note that this variable inherently captures how LibreOffice based
converters work. LibreOffice maps documents of various formats
to classes like Text, Web, Spreadsheet, Presentation etc and
allow document of a given class (irrespective of it's source
format) to be converted to any of the export formats associated
with that class.
See default setting of this variable for an typical
configuration."
:group 'org-lparse
:type
'(choice
(const :tag "None" nil)
(alist :key-type (string :tag "Document Class")
:value-type
(group (repeat :tag "Input formats" (string :tag "Input format"))
(alist :tag "Output formats"
:key-type (string :tag "Output format")
:value-type
(group (string :tag "Output file extension")))))))
(defcustom org-lparse-use-flashy-warning nil
"Control flashing of messages logged with `org-lparse-warn'.
When non-nil, messages are fontified with warning face and the
exporter lingers for a while to catch user's attention."
:type 'boolean
:group 'org-lparse)
(defun org-lparse-convert (&optional in-file out-fmt prefix-arg)
"Convert IN-FILE to format OUT-FMT using a command line converter.
IN-FILE is the file to be converted. If unspecified, it defaults
to variable `buffer-file-name'. OUT-FMT is the desired output
format. If the backend has registered a CONVERT-METHOD as part
of it's get function then that converter is used. Otherwise
`org-lparse-convert-process' is used. If PREFIX-ARG is non-nil
then the newly converted file is opened using `org-open-file'."
(interactive
(let* ((input (if (featurep 'ido) 'ido-completing-read 'completing-read))
(in-file (read-file-name "File to be converted: "
nil buffer-file-name t))
(in-fmt (file-name-extension in-file))
(out-fmt-choices (org-lparse-get-other-backends in-fmt))
(out-fmt
(or (and out-fmt-choices
(funcall input "Output format: "
out-fmt-choices nil nil nil))
(error
"No known converter or no known output formats for %s files"
in-fmt))))
(list in-file out-fmt current-prefix-arg)))
(require 'browse-url)
(let* ((in-file (expand-file-name (or in-file buffer-file-name)))
(dummy (or (file-readable-p in-file)
(error "Cannot read %s" in-file)))
(in-fmt (file-name-extension in-file))
(out-fmt (or out-fmt (error "Output format unspecified")))
(convert-process (org-lparse-get-converter in-fmt))
(program (car convert-process))
(dummy (and (or program (error "Converter not configured"))
(or (executable-find program)
(error "Cannot find converter %s" program))))
(out-fmt-alist
(or (assoc out-fmt (org-lparse-get-other-backends in-fmt))
(error "Cannot convert from %s to %s format" in-fmt out-fmt)))
(out-file (concat (file-name-sans-extension in-file) "."
(nth 1 out-fmt-alist)))
(out-dir (file-name-directory in-file))
(arglist (mapcar (lambda (arg)
(format-spec
arg `((?i . ,in-file)
(?I . ,(browse-url-file-url in-file))
(?f . ,out-fmt)
(?o . ,out-file)
(?O . ,(browse-url-file-url out-file))
(?d . ,out-dir)
(?D . ,(browse-url-file-url out-dir)))))
(cdr convert-process))))
(when (file-exists-p out-file)
(delete-file out-file))
(message "Executing %s %s" program (mapconcat 'identity arglist " "))
(apply 'call-process program nil nil nil arglist)
(cond
((file-exists-p out-file)
(message "Exported to %s using %s" out-file program)
(when prefix-arg
(message "Opening %s..." out-file)
(org-open-file out-file))
out-file
;; (set-buffer (find-file-noselect out-file))
)
(t
(message "Export to %s failed" out-file)
nil))))
(defvar org-lparse-insert-tag-with-newlines 'both)
;; Following variables are let-bound during `org-lparse'
(defvar org-lparse-dyn-first-heading-pos)
(defvar org-lparse-toc)
(defvar org-lparse-entity-control-callbacks-alist)
(defvar org-lparse-entity-format-callbacks-alist)
(defvar org-lparse-backend nil
"The native backend to which the document is currently exported.
This variable is let bound during `org-lparse'. Valid values are
one of the symbols corresponding to `org-lparse-native-backends'.
Compare this variable with `org-export-current-backend' which is
bound only during `org-export-preprocess-string' stage of the
export process.
See also `org-lparse-other-backend'.")
(defvar org-lparse-other-backend nil
"The target backend to which the document is currently exported.
This variable is let bound during `org-lparse'. This variable is
set to either `org-lparse-backend' or one of the symbols
corresponding to OTHER-BACKENDS specification of the
org-lparse-backend.
For example, if a document is exported to \"odt\" then both
org-lparse-backend and org-lparse-other-backend are bound to
'odt. On the other hand, if a document is exported to \"odt\"
and then converted to \"doc\" then org-lparse-backend is set to
'odt and org-lparse-other-backend is set to 'doc.")
(defvar org-lparse-body-only nil
"Bind this to BODY-ONLY arg of `org-lparse'.")
(defvar org-lparse-to-buffer nil
"Bind this to TO-BUFFER arg of `org-lparse'.")
(defun org-do-lparse (arg &optional hidden ext-plist
to-buffer body-only pub-dir)
"Export the outline to various formats.
See `org-lparse' for more information. This function is a
html-agnostic version of the `org-export-as-html' function in 7.5
version."
;; Make sure we have a file name when we need it.
(when (and (not (or to-buffer body-only))
(not buffer-file-name))
(if (buffer-base-buffer)
(org-set-local 'buffer-file-name
(with-current-buffer (buffer-base-buffer)
buffer-file-name))
(error "Need a file name to be able to export")))
(org-lparse-warn
(format "Exporting to %s using org-lparse..."
(upcase (symbol-name
(or org-lparse-backend org-lparse-other-backend)))))
(setq-default org-todo-line-regexp org-todo-line-regexp)
(setq-default org-deadline-line-regexp org-deadline-line-regexp)
(setq-default org-done-keywords org-done-keywords)
(setq-default org-maybe-keyword-time-regexp org-maybe-keyword-time-regexp)
(let* (org-lparse-encode-pending
org-lparse-par-open
org-lparse-outline-text-open
(org-lparse-latex-fragment-fallback ; currently used only by
; odt exporter
(or (ignore-errors (org-lparse-get 'LATEX-FRAGMENT-FALLBACK))
(if (and (org-check-external-command "latex" "" t)
(org-check-external-command "dvipng" "" t))
'dvipng
'verbatim)))
(org-lparse-insert-tag-with-newlines 'both)
(org-lparse-to-buffer to-buffer)
(org-lparse-body-only body-only)
(org-lparse-entity-control-callbacks-alist
(org-lparse-get 'ENTITY-CONTROL))
(org-lparse-entity-format-callbacks-alist
(org-lparse-get 'ENTITY-FORMAT))
(opt-plist
(org-export-process-option-filters
(org-combine-plists (org-default-export-plist)
ext-plist
(org-infile-export-plist))))
(body-only (or body-only (plist-get opt-plist :body-only)))
valid org-lparse-dyn-first-heading-pos
(odd org-odd-levels-only)
(region-p (org-region-active-p))
(rbeg (and region-p (region-beginning)))
(rend (and region-p (region-end)))
(subtree-p
(if (plist-get opt-plist :ignore-subtree-p)
nil
(when region-p
(save-excursion
(goto-char rbeg)
(and (org-at-heading-p)
(>= (org-end-of-subtree t t) rend))))))
(level-offset (if subtree-p
(save-excursion
(goto-char rbeg)
(+ (funcall outline-level)
(if org-odd-levels-only 1 0)))
0))
(opt-plist (setq org-export-opt-plist
(if subtree-p
(org-export-add-subtree-options opt-plist rbeg)
opt-plist)))
;; The following two are dynamically scoped into other
;; routines below.
(org-current-export-dir
(or pub-dir (org-lparse-get 'EXPORT-DIR opt-plist)))
(org-current-export-file buffer-file-name)
(level 0) (line "") (origline "") txt todo
(umax nil)
(umax-toc nil)
(filename (if to-buffer nil
(expand-file-name
(concat
(file-name-sans-extension
(or (and subtree-p
(org-entry-get (region-beginning)
"EXPORT_FILE_NAME" t))
(file-name-nondirectory buffer-file-name)))
"." (org-lparse-get 'FILE-NAME-EXTENSION opt-plist))
(file-name-as-directory
(or pub-dir (org-lparse-get 'EXPORT-DIR opt-plist))))))
(current-dir (if buffer-file-name
(file-name-directory buffer-file-name)
default-directory))
(buffer (if to-buffer
(cond
((eq to-buffer 'string)
(get-buffer-create (org-lparse-get 'EXPORT-BUFFER-NAME)))
(t (get-buffer-create to-buffer)))
(find-file-noselect
(or (let ((f (org-lparse-get 'INIT-METHOD)))
(and f (functionp f) (funcall f filename)))
filename))))
(org-levels-open (make-vector org-level-max nil))
(date (plist-get opt-plist :date))
(date (cond
((and date (string-match "%" date))
(format-time-string date))
(date date)
(t (format-time-string "%Y-%m-%d %T %Z"))))
(dummy (setq opt-plist (plist-put opt-plist :effective-date date)))
(title (org-xml-encode-org-text-skip-links
(or (and subtree-p (org-export-get-title-from-subtree))
(plist-get opt-plist :title)
(and (not body-only)
(not
(plist-get opt-plist :skip-before-1st-heading))
(org-export-grab-title-from-buffer))
(and buffer-file-name
(file-name-sans-extension
(file-name-nondirectory buffer-file-name)))
"UNTITLED")))
(dummy (setq opt-plist (plist-put opt-plist :title title)))
(html-table-tag (plist-get opt-plist :html-table-tag))
(quote-re0 (concat "^[ \t]*" org-quote-string "\\>"))
(quote-re (concat "^\\(\\*+\\)\\([ \t]+" org-quote-string "\\>\\)"))
(org-lparse-dyn-current-environment nil)
;; Get the language-dependent settings
(lang-words (or (assoc (plist-get opt-plist :language)
org-export-language-setup)
(assoc "en" org-export-language-setup)))
(dummy (setq opt-plist (plist-put opt-plist :lang-words lang-words)))
(head-count 0) cnt
(start 0)
(coding-system-for-write
(or (ignore-errors (org-lparse-get 'CODING-SYSTEM-FOR-WRITE))
(and (boundp 'buffer-file-coding-system)
buffer-file-coding-system)))
(save-buffer-coding-system
(or (ignore-errors (org-lparse-get 'CODING-SYSTEM-FOR-SAVE))
(and (boundp 'buffer-file-coding-system)
buffer-file-coding-system)))
(region
(buffer-substring
(if region-p (region-beginning) (point-min))
(if region-p (region-end) (point-max))))
(org-export-have-math nil)
(org-export-footnotes-seen nil)
(org-export-footnotes-data (org-footnote-all-labels 'with-defs))
(org-footnote-insert-pos-for-preprocessor 'point-min)
(lines
(org-split-string
(org-export-preprocess-string
region
:emph-multiline t
:for-backend (if (equal org-lparse-backend 'xhtml) ; hack
'html
org-lparse-backend)
:skip-before-1st-heading
(plist-get opt-plist :skip-before-1st-heading)
:drawers (plist-get opt-plist :drawers)
:todo-keywords (plist-get opt-plist :todo-keywords)
:tasks (plist-get opt-plist :tasks)
:tags (plist-get opt-plist :tags)
:priority (plist-get opt-plist :priority)
:footnotes (plist-get opt-plist :footnotes)
:timestamps (plist-get opt-plist :timestamps)
:archived-trees
(plist-get opt-plist :archived-trees)
:select-tags (plist-get opt-plist :select-tags)
:exclude-tags (plist-get opt-plist :exclude-tags)
:add-text
(plist-get opt-plist :text)
:LaTeX-fragments
(plist-get opt-plist :LaTeX-fragments))
"[\r\n]"))
table-open
table-buffer table-orig-buffer
ind
rpl path attr desc descp desc1 desc2 link
snumber fnc
footnotes footref-seen
org-lparse-output-buffer
org-lparse-footnote-definitions
org-lparse-footnote-number
org-lparse-footnote-buffer
org-lparse-toc
href
)
(let ((inhibit-read-only t))
(org-unmodified
(remove-text-properties (point-min) (point-max)
'(:org-license-to-kill t))))
(message "Exporting...")
(org-init-section-numbers)
;; Switch to the output buffer
(setq org-lparse-output-buffer buffer)
(set-buffer org-lparse-output-buffer)
(let ((inhibit-read-only t)) (erase-buffer))
(fundamental-mode)
(org-install-letbind)
(and (fboundp 'set-buffer-file-coding-system)
(set-buffer-file-coding-system coding-system-for-write))
(let ((case-fold-search nil)
(org-odd-levels-only odd))
;; create local variables for all options, to make sure all called
;; functions get the correct information
(mapc (lambda (x)
(set (make-local-variable (nth 2 x))
(plist-get opt-plist (car x))))
org-export-plist-vars)
(setq umax (if arg (prefix-numeric-value arg)
org-export-headline-levels))
(setq umax-toc (if (integerp org-export-with-toc)
(min org-export-with-toc umax)
umax))
(when (and org-export-with-toc (not body-only))
(setq lines (org-lparse-prepare-toc
lines level-offset opt-plist umax-toc)))
(unless body-only
(org-lparse-begin 'DOCUMENT-CONTENT opt-plist)
(org-lparse-begin 'DOCUMENT-BODY opt-plist))
(setq head-count 0)
(org-init-section-numbers)
(org-lparse-begin-paragraph)
(while (setq line (pop lines) origline line)
(catch 'nextline
(when (and (org-lparse-current-environment-p 'quote)
(string-match org-outline-regexp-bol line))
(org-lparse-end-environment 'quote))
(when (org-lparse-current-environment-p 'quote)
(org-lparse-insert 'LINE line)
(throw 'nextline nil))
;; Fixed-width, verbatim lines (examples)
(when (and org-export-with-fixed-width
(string-match "^[ \t]*:\\(\\([ \t]\\|$\\)\\(.*\\)\\)" line))
(when (not (org-lparse-current-environment-p 'fixedwidth))
(org-lparse-begin-environment 'fixedwidth))
(org-lparse-insert 'LINE (match-string 3 line))
(when (or (not lines)
(not (string-match "^[ \t]*:\\(\\([ \t]\\|$\\)\\(.*\\)\\)"
(car lines))))
(org-lparse-end-environment 'fixedwidth))
(throw 'nextline nil))
;; Notes: The baseline version of org-html.el (git commit
;; 3d802e), while encoutering a *line-long* protected text,
;; does one of the following two things based on the state
;; of the export buffer.
;; 1. If a paragraph element has just been opened and
;; contains only whitespace as content, insert the
;; protected text as part of the previous paragraph.
;; 2. If the paragraph element has already been opened and
;; contains some valid content insert the protected text
;; as part of the current paragraph.
;; I think --->
;; Scenario 1 mentioned above kicks in when a block of
;; protected text has to be inserted enbloc. For example,
;; this happens, when inserting an source or example block
;; or preformatted content enclosed in #+backend,
;; #+begin_bakend ... #+end_backend)
;; Scenario 2 mentioned above kicks in when the protected
;; text is part of a running sentence. For example this
;; happens in the case of an *multiline* LaTeX equation that
;; needs to be inserted verbatim.
;; org-html.el in the master branch seems to do some
;; jugglery by moving paragraphs around. Inorder to make
;; these changes backend-agnostic introduce a new text
;; property org-native-text and impose the added semantics
;; that these protected blocks appear outside of a
;; conventional paragraph element.
;;
;; Extra Note: Check whether org-example and org-native-text
;; are entirely equivalent.
;; Fixes bug reported by Christian Moe concerning verbatim
;; LaTeX fragments.
;; on git commit 533ba3f90250a1f25f494c390d639ea6274f235c
;; http://repo.or.cz/w/org-mode/org-jambu.git/shortlog/refs/heads/staging
;; See http://lists.gnu.org/archive/html/emacs-orgmode/2011-03/msg01379.html
;; Native Text
(when (and (get-text-property 0 'org-native-text line)
;; Make sure it is the entire line that is protected
(not (< (or (next-single-property-change
0 'org-native-text line) 10000)
(length line))))
(let ((ind (get-text-property 0 'original-indentation line)))
(org-lparse-begin-environment 'native)
(org-lparse-insert 'LINE line)
(while (and lines
(or (= (length (car lines)) 0)
(not ind)
(equal ind (get-text-property
0 'original-indentation (car lines))))
(or (= (length (car lines)) 0)
(get-text-property 0 'org-native-text (car lines))))
(org-lparse-insert 'LINE (pop lines)))
(org-lparse-end-environment 'native))
(throw 'nextline nil))
;; Protected HTML
(when (and (get-text-property 0 'org-protected line)
;; Make sure it is the entire line that is protected
(not (< (or (next-single-property-change
0 'org-protected line) 10000)
(length line))))
(let ((ind (get-text-property 0 'original-indentation line)))
(org-lparse-insert 'LINE line)
(while (and lines
(or (= (length (car lines)) 0)
(not ind)
(equal ind (get-text-property
0 'original-indentation (car lines))))
(or (= (length (car lines)) 0)
(get-text-property 0 'org-protected (car lines))))
(org-lparse-insert 'LINE (pop lines))))
(throw 'nextline nil))
;; Blockquotes, verse, and center
(when (string-match "^ORG-\\(.+\\)-\\(START\\|END\\)$" line)
(let* ((style (intern (downcase (match-string 1 line))))
(f (cdr (assoc (match-string 2 line)
'(("START" . org-lparse-begin-environment)
("END" . org-lparse-end-environment))))))
(when (memq style '(blockquote verse center))
(funcall f style)
(throw 'nextline nil))))
(run-hooks 'org-export-html-after-blockquotes-hook)
(when (org-lparse-current-environment-p 'verse)
(let ((i (org-get-string-indentation line)))
(if (> i 0)
(setq line (concat
(let ((org-lparse-encode-pending t))
(org-lparse-format 'SPACES (* 2 i)))
" " (org-trim line))))
(unless (string-match "\\\\\\\\[ \t]*$" line)
(setq line (concat line "\\\\")))))
;; make targets to anchors
(setq start 0)
(while (string-match
"<<<?\\([^<>]*\\)>>>?\\((INVISIBLE)\\)?[ \t]*\n?" line start)
(cond
((get-text-property (match-beginning 1) 'org-protected line)
(setq start (match-end 1)))
((match-end 2)
(setq line (replace-match
(let ((org-lparse-encode-pending t))
(org-lparse-format
'ANCHOR "" (org-solidify-link-text
(match-string 1 line))))
t t line)))
((and org-export-with-toc (equal (string-to-char line) ?*))
;; FIXME: NOT DEPENDENT on TOC?????????????????????
(setq line (replace-match
(let ((org-lparse-encode-pending t))
(org-lparse-format
'FONTIFY (match-string 1 line) "target"))
;; (concat "@<i>" (match-string 1 line) "@</i> ")
t t line)))
(t
(setq line (replace-match
(concat
(let ((org-lparse-encode-pending t))
(org-lparse-format
'ANCHOR (match-string 1 line)
(org-solidify-link-text (match-string 1 line))
"target")) " ")
t t line)))))
(let ((org-lparse-encode-pending t))
(setq line (org-lparse-handle-time-stamps line)))
;; replace "&" by "&amp;", "<" and ">" by "&lt;" and "&gt;"
;; handle @<..> HTML tags (replace "@&gt;..&lt;" by "<..>")
;; Also handle sub_superscripts and checkboxes
(or (string-match org-table-hline-regexp line)
(string-match "^[ \t]*\\([+]-\\||[ ]\\)[-+ |]*[+|][ \t]*$" line)
(setq line (org-xml-encode-org-text-skip-links line)))
(setq line (org-lparse-format-org-link line opt-plist))
;; TODO items
(if (and (string-match org-todo-line-regexp line)
(match-beginning 2))
(setq line (concat
(substring line 0 (match-beginning 2))
(org-lparse-format 'TODO (match-string 2 line))
(substring line (match-end 2)))))
;; Does this contain a reference to a footnote?
(when org-export-with-footnotes
(setq start 0)
(while (string-match "\\([^* \t].*?\\)[ \t]*\\[\\([0-9]+\\)\\]" line start)
;; Discard protected matches not clearly identified as
;; footnote markers.
(if (or (get-text-property (match-beginning 2) 'org-protected line)
(not (get-text-property (match-beginning 2) 'org-footnote line)))
(setq start (match-end 2))
(let ((n (match-string 2 line)) refcnt a)
(if (setq a (assoc n footref-seen))
(progn
(setcdr a (1+ (cdr a)))
(setq refcnt (cdr a)))
(setq refcnt 1)
(push (cons n 1) footref-seen))
(setq line
(replace-match
(concat
(or (match-string 1 line) "")
(org-lparse-format
'FOOTNOTE-REFERENCE
n (cdr (assoc n org-lparse-footnote-definitions))
refcnt)
;; If another footnote is following the
;; current one, add a separator.
(if (save-match-data
(string-match "\\`\\[[0-9]+\\]"
(substring line (match-end 0))))
(ignore-errors
(org-lparse-get 'FOOTNOTE-SEPARATOR))
""))
t t line))))))
(cond
((string-match "^\\(\\*+\\)[ \t]+\\(.*\\)" line)
;; This is a headline
(setq level (org-tr-level (- (match-end 1) (match-beginning 1)
level-offset))
txt (match-string 2 line))
(if (string-match quote-re0 txt)
(setq txt (replace-match "" t t txt)))
(if (<= level (max umax umax-toc))
(setq head-count (+ head-count 1)))
(unless org-lparse-dyn-first-heading-pos
(setq org-lparse-dyn-first-heading-pos (point)))
(org-lparse-begin-level level txt umax head-count)
;; QUOTES
(when (string-match quote-re line)
(org-lparse-begin-environment 'quote)))
((and org-export-with-tables
(string-match "^\\([ \t]*\\)\\(|\\|\\+-+\\+\\)" line))
(when (not table-open)
;; New table starts
(setq table-open t table-buffer nil table-orig-buffer nil))
;; Accumulate lines
(setq table-buffer (cons line table-buffer)
table-orig-buffer (cons origline table-orig-buffer))
(when (or (not lines)
(not (string-match "^\\([ \t]*\\)\\(|\\|\\+-+\\+\\)"
(car lines))))
(setq table-open nil
table-buffer (nreverse table-buffer)
table-orig-buffer (nreverse table-orig-buffer))
(org-lparse-end-paragraph)
(org-lparse-insert 'TABLE table-buffer table-orig-buffer)))
;; Normal lines
(t
;; This line either is list item or end a list.
(when (get-text-property 0 'list-item line)
(setq line (org-lparse-export-list-line
line
(get-text-property 0 'list-item line)
(get-text-property 0 'list-struct line)
(get-text-property 0 'list-prevs line))))
;; Horizontal line
(when (string-match "^[ \t]*-\\{5,\\}[ \t]*$" line)
(with-org-lparse-preserve-paragraph-state
(org-lparse-insert 'HORIZONTAL-LINE))
(throw 'nextline nil))
;; Empty lines start a new paragraph. If hand-formatted lists
;; are not fully interpreted, lines starting with "-", "+", "*"
;; also start a new paragraph.
(when (string-match "^ [-+*]-\\|^[ \t]*$" line)
(when org-lparse-footnote-number
(org-lparse-end-footnote-definition org-lparse-footnote-number)
(setq org-lparse-footnote-number nil))
(org-lparse-begin-paragraph))
;; Is this the start of a footnote?
(when org-export-with-footnotes
(when (and (boundp 'footnote-section-tag-regexp)
(string-match (concat "^" footnote-section-tag-regexp)
line))
;; ignore this line
(throw 'nextline nil))
(when (string-match "^[ \t]*\\[\\([0-9]+\\)\\]" line)
(org-lparse-end-paragraph)
(setq org-lparse-footnote-number (match-string 1 line))
(setq line (replace-match "" t t line))
(org-lparse-begin-footnote-definition org-lparse-footnote-number)))
;; Check if the line break needs to be conserved
(cond
((string-match "\\\\\\\\[ \t]*$" line)
(setq line (replace-match
(org-lparse-format 'LINE-BREAK)
t t line)))
(org-export-preserve-breaks
(setq line (concat line (org-lparse-format 'LINE-BREAK)))))
;; Check if a paragraph should be started
(let ((start 0))
(while (and org-lparse-par-open
(string-match "\\\\par\\>" line start))
(error "FIXME")
;; Leave a space in the </p> so that the footnote matcher
;; does not see this.
(if (not (get-text-property (match-beginning 0)
'org-protected line))
(setq line (replace-match "</p ><p >" t t line)))
(setq start (match-end 0))))
(org-lparse-insert 'LINE line)))))
;; Properly close all local lists and other lists
(when (org-lparse-current-environment-p 'quote)
(org-lparse-end-environment 'quote))
(org-lparse-end-level 1 umax)
;; the </div> to close the last text-... div.
(when (and (> umax 0) org-lparse-dyn-first-heading-pos)
(org-lparse-end-outline-text-or-outline))
(org-lparse-end 'DOCUMENT-BODY opt-plist)
(unless body-only
(org-lparse-end 'DOCUMENT-CONTENT))
(unless (plist-get opt-plist :buffer-will-be-killed)
(set-auto-mode t))
(org-lparse-end 'EXPORT)
(goto-char (point-min))
(or (org-export-push-to-kill-ring
(upcase (symbol-name org-lparse-backend)))
(message "Exporting... done"))
(cond
((not to-buffer)
(let ((f (org-lparse-get 'SAVE-METHOD)))
(or (and f (functionp f) (funcall f filename opt-plist))
(save-buffer)))
(or (when (and (boundp 'org-lparse-other-backend)
org-lparse-other-backend
(not (equal org-lparse-backend org-lparse-other-backend)))
(let ((org-lparse-convert-process
(org-lparse-get-converter org-lparse-backend)))
(when org-lparse-convert-process
(org-lparse-convert buffer-file-name
(symbol-name org-lparse-other-backend)))))
(current-buffer)))
((eq to-buffer 'string)
(prog1 (buffer-substring (point-min) (point-max))
(kill-buffer (current-buffer))))
(t (current-buffer))))))
(defun org-lparse-format-table (lines olines)
"Retuns backend-specific code for org-type and table-type tables."
(if (stringp lines)
(setq lines (org-split-string lines "\n")))
(if (string-match "^[ \t]*|" (car lines))
;; A normal org table
(org-lparse-format-org-table lines nil)
;; Table made by table.el
(or (org-lparse-format-table-table-using-table-generate-source
org-lparse-backend olines
(not org-export-prefer-native-exporter-for-tables))
;; We are here only when table.el table has NO col or row
;; spanning and the user prefers using org's own converter for
;; exporting of such simple table.el tables.
(org-lparse-format-table-table lines))))
(defun org-lparse-table-get-colalign-info (lines)
(let ((forced-aligns (org-find-text-property-in-string
'org-forced-aligns (car lines))))
(when (and forced-aligns org-table-clean-did-remove-column)
(setq forced-aligns
(mapcar (lambda (x) (cons (1- (car x)) (cdr x))) forced-aligns)))
forced-aligns))
(defvar org-lparse-table-style)
(defvar org-lparse-table-ncols)
(defvar org-lparse-table-rownum)
(defvar org-lparse-table-is-styled)
(defvar org-lparse-table-begin-marker)
(defvar org-lparse-table-num-numeric-items-per-column)
(defvar org-lparse-table-colalign-info)
(defvar org-lparse-table-colalign-vector)
;; Following variables are defined in org-table.el
(defvar org-table-number-fraction)
(defvar org-table-number-regexp)
(defun org-lparse-do-format-org-table (lines &optional splice)
"Format a org-type table into backend-specific code.
LINES is a list of lines. Optional argument SPLICE means, do not
insert header and surrounding <table> tags, just format the lines.
Optional argument NO-CSS means use XHTML attributes instead of CSS
for formatting. This is required for the DocBook exporter."
(require 'org-table)
;; Get rid of hlines at beginning and end
(if (string-match "^[ \t]*|-" (car lines)) (setq lines (cdr lines)))
(setq lines (nreverse lines))
(if (string-match "^[ \t]*|-" (car lines)) (setq lines (cdr lines)))
(setq lines (nreverse lines))
(when org-export-table-remove-special-lines
;; Check if the table has a marking column. If yes remove the
;; column and the special lines
(setq lines (org-table-clean-before-export lines)))
(let* ((caption (org-find-text-property-in-string 'org-caption (car lines)))
(caption (and caption (org-xml-encode-org-text caption)))
(label (org-find-text-property-in-string 'org-label (car lines)))
(org-lparse-table-colalign-info (org-lparse-table-get-colalign-info lines))
(attributes (org-find-text-property-in-string 'org-attributes
(car lines)))
(head (and org-export-highlight-first-table-line
(delq nil (mapcar
(lambda (x) (string-match "^[ \t]*|-" x))
(cdr lines)))))
(org-lparse-table-rownum -1) org-lparse-table-ncols i (cnt 0)
tbopen line fields
org-lparse-table-cur-rowgrp-is-hdr
org-lparse-table-rowgrp-open
org-lparse-table-num-numeric-items-per-column
org-lparse-table-colalign-vector n
org-lparse-table-rowgrp-info
org-lparse-table-begin-marker
(org-lparse-table-style 'org-table)
org-lparse-table-is-styled)
(cond
(splice
(setq org-lparse-table-is-styled nil)
(while (setq line (pop lines))
(unless (string-match "^[ \t]*|-" line)
(insert
(org-lparse-format-table-row
(org-split-string line "[ \t]*|[ \t]*")) "\n"))))
(t
(setq org-lparse-table-is-styled t)
(org-lparse-begin 'TABLE caption label attributes)
(setq org-lparse-table-begin-marker (point))
(org-lparse-begin-table-rowgroup head)
(while (setq line (pop lines))
(cond
((string-match "^[ \t]*|-" line)
(when lines (org-lparse-begin-table-rowgroup)))
(t
(insert
(org-lparse-format-table-row
(org-split-string line "[ \t]*|[ \t]*")) "\n"))))
(org-lparse-end 'TABLE-ROWGROUP)
(org-lparse-end-table)))))
(defun org-lparse-format-org-table (lines &optional splice)
(with-temp-buffer
(org-lparse-do-format-org-table lines splice)
(buffer-substring-no-properties (point-min) (point-max))))
(defun org-lparse-do-format-table-table (lines)
"Format a table generated by table.el into backend-specific code.
This conversion does *not* use `table-generate-source' from table.el.
This has the advantage that Org-mode's HTML conversions can be used.
But it has the disadvantage, that no cell- or row-spanning is allowed."
(let (line field-buffer
(org-lparse-table-cur-rowgrp-is-hdr
org-export-highlight-first-table-line)
(caption nil)
(attributes nil)
(label nil)
(org-lparse-table-style 'table-table)
(org-lparse-table-is-styled nil)
fields org-lparse-table-ncols i (org-lparse-table-rownum -1)
(empty (org-lparse-format 'SPACES 1)))
(org-lparse-begin 'TABLE caption label attributes)
(while (setq line (pop lines))
(cond
((string-match "^[ \t]*\\+-" line)
(when field-buffer
(let ((org-export-table-row-tags '("<tr>" . "</tr>"))
;; (org-export-html-table-use-header-tags-for-first-column nil)
)
(insert (org-lparse-format-table-row field-buffer empty)))
(setq org-lparse-table-cur-rowgrp-is-hdr nil)
(setq field-buffer nil)))
(t
;; Break the line into fields and store the fields
(setq fields (org-split-string line "[ \t]*|[ \t]*"))
(if field-buffer
(setq field-buffer (mapcar
(lambda (x)
(concat x (org-lparse-format 'LINE-BREAK)
(pop fields)))
field-buffer))
(setq field-buffer fields)))))
(org-lparse-end-table)))
(defun org-lparse-format-table-table (lines)
(with-temp-buffer
(org-lparse-do-format-table-table lines)
(buffer-substring-no-properties (point-min) (point-max))))
(defvar table-source-languages) ; defined in table.el
(defun org-lparse-format-table-table-using-table-generate-source (backend
lines
&optional
spanned-only)
"Format a table into BACKEND, using `table-generate-source' from table.el.
Use SPANNED-ONLY to suppress exporting of simple table.el tables.
When SPANNED-ONLY is nil, all table.el tables are exported. When
SPANNED-ONLY is non-nil, only tables with either row or column
spans are exported.
This routine returns the generated source or nil as appropriate.
Refer docstring of `org-export-prefer-native-exporter-for-tables'
for further information."
(require 'table)
(with-current-buffer (get-buffer-create " org-tmp1 ")
(erase-buffer)
(insert (mapconcat 'identity lines "\n"))
(goto-char (point-min))
(if (not (re-search-forward "|[^+]" nil t))
(error "Error processing table"))
(table-recognize-table)
(when (or (not spanned-only)
(let* ((dim (table-query-dimension))
(c (nth 4 dim)) (r (nth 5 dim)) (cells (nth 6 dim)))
(not (= (* c r) cells))))
(with-current-buffer (get-buffer-create " org-tmp2 ") (erase-buffer))
(cond
((member backend table-source-languages)
(table-generate-source backend " org-tmp2 ")
(set-buffer " org-tmp2 ")
(buffer-substring (point-min) (point-max)))
(t
;; table.el doesn't support the given backend. Currently this
;; happens in case of odt export. Strip the table from the
;; generated document. A better alternative would be to embed
;; the table as ascii text in the output document.
(org-lparse-warn
(concat
"Found table.el-type table in the source org file. "
(format "table.el doesn't support %s backend. "
(upcase (symbol-name backend)))
"Skipping ahead ..."))
"")))))
(defun org-lparse-handle-time-stamps (s)
"Format time stamps in string S, or remove them."
(catch 'exit
(let (r b)
(while (string-match org-maybe-keyword-time-regexp s)
(or b (setq b (substring s 0 (match-beginning 0))))
(setq r (concat
r (substring s 0 (match-beginning 0)) " "
(org-lparse-format
'FONTIFY
(concat
(if (match-end 1)
(org-lparse-format
'FONTIFY
(match-string 1 s) "timestamp-kwd"))
" "
(org-lparse-format
'FONTIFY
(substring (org-translate-time (match-string 3 s)) 1 -1)
"timestamp"))
"timestamp-wrapper"))
s (substring s (match-end 0))))
;; Line break if line started and ended with time stamp stuff
(if (not r)
s
(setq r (concat r s))
(unless (string-match "\\S-" (concat b s))
(setq r (concat r (org-lparse-format 'LINE-BREAK))))
r))))
(defun org-xml-encode-plain-text (s)
"Convert plain text characters to HTML equivalent.
Possible conversions are set in `org-export-html-protect-char-alist'."
(let ((cl (org-lparse-get 'PLAIN-TEXT-MAP)) c)
(while (setq c (pop cl))
(let ((start 0))
(while (string-match (car c) s start)
(setq s (replace-match (cdr c) t t s)
start (1+ (match-beginning 0))))))
s))
(defun org-xml-encode-org-text-skip-links (string)
"Prepare STRING for HTML export. Apply all active conversions.
If there are links in the string, don't modify these."
(let* ((re (concat org-bracket-link-regexp "\\|"
(org-re "[ \t]+\\(:[[:alnum:]_@#%:]+:\\)[ \t]*$")))
m s l res)
(while (setq m (string-match re string))
(setq s (substring string 0 m)
l (match-string 0 string)
string (substring string (match-end 0)))
(push (org-xml-encode-org-text s) res)
(push l res))
(push (org-xml-encode-org-text string) res)
(apply 'concat (nreverse res))))
(defun org-xml-encode-org-text (s)
"Apply all active conversions to translate special ASCII to HTML."
(setq s (org-xml-encode-plain-text s))
(if org-export-html-expand
(while (string-match "@&lt;\\([^&]*\\)&gt;" s)
(setq s (replace-match "<\\1>" t nil s))))
(if org-export-with-emphasize
(setq s (org-lparse-apply-char-styles s)))
(if org-export-with-special-strings
(setq s (org-lparse-convert-special-strings s)))
(if org-export-with-sub-superscripts
(setq s (org-lparse-apply-sub-superscript-styles s)))
(if org-export-with-TeX-macros
(let ((start 0) wd rep)
(while (setq start (string-match "\\\\\\([a-zA-Z]+[0-9]*\\)\\({}\\)?"
s start))
(if (get-text-property (match-beginning 0) 'org-protected s)
(setq start (match-end 0))
(setq wd (match-string 1 s))
(if (setq rep (org-lparse-format 'ORG-ENTITY wd))
(setq s (replace-match rep t t s))
(setq start (+ start (length wd))))))))
s)
(defun org-lparse-convert-special-strings (string)
"Convert special characters in STRING to HTML."
(let ((all (org-lparse-get 'SPECIAL-STRING-REGEXPS))
e a re rpl start)
(while (setq a (pop all))
(setq re (car a) rpl (cdr a) start 0)
(while (string-match re string start)
(if (get-text-property (match-beginning 0) 'org-protected string)
(setq start (match-end 0))
(setq string (replace-match rpl t nil string)))))
string))
(defun org-lparse-apply-sub-superscript-styles (string)
"Apply subscript and superscript styles to STRING.
Use `org-export-with-sub-superscripts' to control application of
sub and superscript styles."
(let (key c (s 0) (requireb (eq org-export-with-sub-superscripts '{})))
(while (string-match org-match-substring-regexp string s)
(cond
((and requireb (match-end 8)) (setq s (match-end 2)))
((get-text-property (match-beginning 2) 'org-protected string)
(setq s (match-end 2)))
(t
(setq s (match-end 1)
key (if (string= (match-string 2 string) "_")
'subscript 'superscript)
c (or (match-string 8 string)
(match-string 6 string)
(match-string 5 string))
string (replace-match
(concat (match-string 1 string)
(org-lparse-format 'FONTIFY c key))
t t string)))))
(while (string-match "\\\\\\([_^]\\)" string)
(setq string (replace-match (match-string 1 string) t t string)))
string))
(defvar org-lparse-char-styles
`(("*" bold)
("/" emphasis)
("_" underline)
("=" code)
("~" verbatim)
("+" strike))
"Map Org emphasis markers to char styles.
This is an alist where each element is of the
form (ORG-EMPHASIS-CHAR . CHAR-STYLE).")
(defun org-lparse-apply-char-styles (string)
"Apply char styles to STRING.
The variable `org-lparse-char-styles' controls how the Org
emphasis markers are interpreted."
(let ((s 0) rpl)
(while (string-match org-emph-re string s)
(if (not (equal
(substring string (match-beginning 3) (1+ (match-beginning 3)))
(substring string (match-beginning 4) (1+ (match-beginning 4)))))
(setq s (match-beginning 0)
rpl
(concat
(match-string 1 string)
(org-lparse-format
'FONTIFY (match-string 4 string)
(nth 1 (assoc (match-string 3 string)
org-lparse-char-styles)))
(match-string 5 string))
string (replace-match rpl t t string)
s (+ s (- (length rpl) 2)))
(setq s (1+ s))))
string))
(defun org-lparse-export-list-line (line pos struct prevs)
"Insert list syntax in export buffer. Return LINE, maybe modified.
POS is the item position or line position the line had before
modifications to buffer. STRUCT is the list structure. PREVS is
the alist of previous items."
(let* ((get-type
(function
;; Translate type of list containing POS to "d", "o" or
;; "u".
(lambda (pos struct prevs)
(let ((type (org-list-get-list-type pos struct prevs)))
(cond
((eq 'ordered type) "o")
((eq 'descriptive type) "d")
(t "u"))))))
(get-closings
(function
;; Return list of all items and sublists ending at POS, in
;; reverse order.
(lambda (pos)
(let (out)
(catch 'exit
(mapc (lambda (e)
(let ((end (nth 6 e))
(item (car e)))
(cond
((= end pos) (push item out))
((>= item pos) (throw 'exit nil)))))
struct))
out)))))
;; First close any previous item, or list, ending at POS.
(mapc (lambda (e)
(let* ((lastp (= (org-list-get-last-item e struct prevs) e))
(first-item (org-list-get-list-begin e struct prevs))
(type (funcall get-type first-item struct prevs)))
(org-lparse-end-paragraph)
;; Ending for every item
(org-lparse-end-list-item type)
;; We're ending last item of the list: end list.
(when lastp
(org-lparse-end 'LIST type)
(org-lparse-begin-paragraph))))
(funcall get-closings pos))
(cond
;; At an item: insert appropriate tags in export buffer.
((assq pos struct)
(string-match
(concat "[ \t]*\\(\\S-+[ \t]*\\)"
"\\(?:\\[@\\(?:start:\\)?\\([0-9]+\\|[A-Za-z]\\)\\][ \t]*\\)?"
"\\(?:\\(\\[[ X-]\\]\\)[ \t]+\\)?"
"\\(?:\\(.*\\)[ \t]+::\\(?:[ \t]+\\|$\\)\\)?"
"\\(.*\\)") line)
(let* ((checkbox (match-string 3 line))
(desc-tag (or (match-string 4 line) "???"))
(body (or (match-string 5 line) ""))
(list-beg (org-list-get-list-begin pos struct prevs))
(firstp (= list-beg pos))
;; Always refer to first item to determine list type, in
;; case list is ill-formed.
(type (funcall get-type list-beg struct prevs))
(counter (let ((count-tmp (org-list-get-counter pos struct)))
(cond
((not count-tmp) nil)
((string-match "[A-Za-z]" count-tmp)
(- (string-to-char (upcase count-tmp)) 64))
((string-match "[0-9]+" count-tmp)
count-tmp)))))
(when firstp
(org-lparse-end-paragraph)
(org-lparse-begin 'LIST type))
(let ((arg (cond ((equal type "d") desc-tag)
((equal type "o") counter))))
(org-lparse-begin 'LIST-ITEM type arg))
;; If line had a checkbox, some additional modification is required.
(when checkbox
(setq body
(concat
(org-lparse-format
'FONTIFY (concat
"["
(cond
((string-match "X" checkbox) "X")
((string-match " " checkbox)
(org-lparse-format 'SPACES 1))
(t "-"))
"]")
'code)
" "
body)))
;; Return modified line
body))
;; At a list ender: go to next line (side-effects only).
((equal "ORG-LIST-END-MARKER" line) (throw 'nextline nil))
;; Not at an item: return line unchanged (side-effects only).
(t line))))
(defun org-lparse-bind-local-variables (opt-plist)
(mapc (lambda (x)
(set (make-local-variable (nth 2 x))
(plist-get opt-plist (car x))))
org-export-plist-vars))
(defvar org-lparse-table-rowgrp-open)
(defvar org-lparse-table-cur-rowgrp-is-hdr)
(defvar org-lparse-footnote-number)
(defvar org-lparse-footnote-definitions)
(defvar org-lparse-footnote-buffer)
(defvar org-lparse-output-buffer)
(defcustom org-lparse-debug nil
"Enable or Disable logging of `org-lparse' callbacks.
The parameters passed to the backend-registered ENTITY-CONTROL
and ENTITY-FORMAT callbacks are logged as comment strings in the
exported buffer. (org-lparse-format 'COMMENT fmt args) is used
for logging. Customize this variable only if you are an expert
user. Valid values of this variable are:
nil : Disable logging
control : Log all invocations of `org-lparse-begin' and
`org-lparse-end' callbacks.
format : Log invocations of `org-lparse-format' callbacks.
t : Log all invocations of `org-lparse-begin', `org-lparse-end'
and `org-lparse-format' callbacks,"
:group 'org-lparse
:type '(choice
(const :tag "Disable" nil)
(const :tag "Format callbacks" format)
(const :tag "Control callbacks" control)
(const :tag "Format and Control callbacks" t)))
(defun org-lparse-begin (entity &rest args)
"Begin ENTITY in current buffer. ARGS is entity specific.
ENTITY can be one of PARAGRAPH, LIST, LIST-ITEM etc.
Use (org-lparse-begin 'LIST \"o\") to begin a list in current
buffer.
See `org-xhtml-entity-control-callbacks-alist' for more
information."
(when (and (member org-lparse-debug '(t control))
(not (eq entity 'DOCUMENT-CONTENT)))
(insert (org-lparse-format 'COMMENT "%s BEGIN %S" entity args)))
(let ((f (cadr (assoc entity org-lparse-entity-control-callbacks-alist))))
(unless f (error "Unknown entity: %s" entity))
(apply f args)))
(defun org-lparse-end (entity &rest args)
"Close ENTITY in current buffer. ARGS is entity specific.
ENTITY can be one of PARAGRAPH, LIST, LIST-ITEM
etc.
Use (org-lparse-end 'LIST \"o\") to close a list in current
buffer.
See `org-xhtml-entity-control-callbacks-alist' for more
information."
(when (and (member org-lparse-debug '(t control))
(not (eq entity 'DOCUMENT-CONTENT)))
(insert (org-lparse-format 'COMMENT "%s END %S" entity args)))
(let ((f (caddr (assoc entity org-lparse-entity-control-callbacks-alist))))
(unless f (error "Unknown entity: %s" entity))
(apply f args)))
(defun org-lparse-begin-paragraph (&optional style)
"Insert <p>, but first close previous paragraph if any."
(org-lparse-end-paragraph)
(org-lparse-begin 'PARAGRAPH style)
(setq org-lparse-par-open t))
(defun org-lparse-end-paragraph ()
"Close paragraph if there is one open."
(when org-lparse-par-open
(org-lparse-end 'PARAGRAPH)
(setq org-lparse-par-open nil)))
(defun org-lparse-end-list-item (&optional type)
"Close <li> if necessary."
(org-lparse-end-paragraph)
(org-lparse-end 'LIST-ITEM (or type "u")))
(defvar org-lparse-dyn-current-environment nil)
(defun org-lparse-begin-environment (style)
(assert (not org-lparse-dyn-current-environment) t)
(setq org-lparse-dyn-current-environment style)
(org-lparse-begin 'ENVIRONMENT style))
(defun org-lparse-end-environment (style)
(org-lparse-end 'ENVIRONMENT style)
(assert (eq org-lparse-dyn-current-environment style) t)
(setq org-lparse-dyn-current-environment nil))
(defun org-lparse-current-environment-p (style)
(eq org-lparse-dyn-current-environment style))
(defun org-lparse-begin-footnote-definition (n)
(unless org-lparse-footnote-buffer
(setq org-lparse-footnote-buffer
(get-buffer-create "*Org HTML Export Footnotes*")))
(set-buffer org-lparse-footnote-buffer)
(erase-buffer)
(setq org-lparse-insert-tag-with-newlines nil)
(org-lparse-begin 'FOOTNOTE-DEFINITION n))
(defun org-lparse-end-footnote-definition (n)
(org-lparse-end 'FOOTNOTE-DEFINITION n)
(setq org-lparse-insert-tag-with-newlines 'both)
(push (cons n (buffer-string)) org-lparse-footnote-definitions)
(set-buffer org-lparse-output-buffer))
(defun org-lparse-format (entity &rest args)
"Format ENTITY in backend-specific way and return it.
ARGS is specific to entity being formatted.
Use (org-lparse-format 'HEADING \"text\" 1) to format text as
level 1 heading.
See `org-xhtml-entity-format-callbacks-alist' for more information."
(when (and (member org-lparse-debug '(t format))
(not (equal entity 'COMMENT)))
(insert (org-lparse-format 'COMMENT "%s: %S" entity args)))
(cond
((consp entity)
(let ((text (pop args)))
(apply 'org-lparse-format 'TAGS entity text args)))
(t
(let ((f (cdr (assoc entity org-lparse-entity-format-callbacks-alist))))
(unless f (error "Unknown entity: %s" entity))
(apply f args)))))
(defun org-lparse-insert (entity &rest args)
(insert (apply 'org-lparse-format entity args)))
(defun org-lparse-prepare-toc (lines level-offset opt-plist umax-toc)
(let* ((quote-re0 (concat "^[ \t]*" org-quote-string "\\>"))
(org-min-level (org-get-min-level lines level-offset))
(org-last-level org-min-level)
level)
(with-temp-buffer
(org-lparse-bind-local-variables opt-plist)
(erase-buffer)
(org-lparse-begin 'TOC (nth 3 (plist-get opt-plist :lang-words)))
(setq
lines
(mapcar
#'(lambda (line)
(when (and (string-match org-todo-line-regexp line)
(not (get-text-property 0 'org-protected line))
(<= (setq level (org-tr-level
(- (match-end 1) (match-beginning 1)
level-offset)))
umax-toc))
(let ((txt (save-match-data
(org-xml-encode-org-text-skip-links
(org-export-cleanup-toc-line
(match-string 3 line)))))
(todo (and
org-export-mark-todo-in-toc
(or (and (match-beginning 2)
(not (member (match-string 2 line)
org-done-keywords)))
(and (= level umax-toc)
(org-search-todo-below
line lines level)))))
tags)
;; Check for targets
(while (string-match org-any-target-regexp line)
(setq line
(replace-match
(let ((org-lparse-encode-pending t))
(org-lparse-format 'FONTIFY
(match-string 1 line) "target"))
t t line)))
(when (string-match
(org-re "[ \t]+:\\([[:alnum:]_@:]+\\):[ \t]*$") txt)
(setq tags (match-string 1 txt)
txt (replace-match "" t nil txt)))
(when (string-match quote-re0 txt)
(setq txt (replace-match "" t t txt)))
(while (string-match "&lt;\\(&lt;\\)+\\|&gt;\\(&gt;\\)+" txt)
(setq txt (replace-match "" t t txt)))
(org-lparse-format
'TOC-ITEM
(let* ((snumber (org-section-number level))
(href (replace-regexp-in-string
"\\." "-" (format "sec-%s" snumber)))
(href
(or
(cdr (assoc
href org-export-preferred-target-alist))
href))
(href (org-solidify-link-text href)))
(org-lparse-format 'TOC-ENTRY snumber todo txt tags href))
level org-last-level)
(setq org-last-level level)))
line)
lines))
(org-lparse-end 'TOC)
(setq org-lparse-toc (buffer-string))))
lines)
(defun org-lparse-format-table-row (fields &optional text-for-empty-fields)
(unless org-lparse-table-ncols
;; first row of the table
(setq org-lparse-table-ncols (length fields))
(when org-lparse-table-is-styled
(setq org-lparse-table-num-numeric-items-per-column
(make-vector org-lparse-table-ncols 0))
(setq org-lparse-table-colalign-vector
(make-vector org-lparse-table-ncols nil))
(let ((c -1))
(while (< (incf c) org-lparse-table-ncols)
(let ((cookie (cdr (assoc (1+ c) org-lparse-table-colalign-info))))
(setf (aref org-lparse-table-colalign-vector c)
(cond
((string= cookie "l") "left")
((string= cookie "r") "right")
((string= cookie "c") "center")
(t nil))))))))
(incf org-lparse-table-rownum)
(let ((i -1))
(org-lparse-format
'TABLE-ROW
(mapconcat
(lambda (x)
(when (and (string= x "") text-for-empty-fields)
(setq x text-for-empty-fields))
(incf i)
(and org-lparse-table-is-styled
(< i org-lparse-table-ncols)
(string-match org-table-number-regexp x)
(incf (aref org-lparse-table-num-numeric-items-per-column i)))
(org-lparse-format 'TABLE-CELL x org-lparse-table-rownum i))
fields "\n"))))
(defun org-lparse-get (what &optional opt-plist)
"Query for value of WHAT for the current backend `org-lparse-backend'.
See also `org-lparse-backend-get'."
(if (boundp 'org-lparse-backend)
(org-lparse-backend-get (symbol-name org-lparse-backend) what opt-plist)
(error "org-lparse-backend is not bound yet")))
(defun org-lparse-backend-get (backend what &optional opt-plist)
"Query BACKEND for value of WHAT.
Dispatch the call to `org-<backend>-user-get'. If that throws an
error, dispatch the call to `org-<backend>-get'. See
`org-xhtml-get' for all known settings queried for by
`org-lparse' during the course of export."
(assert (stringp backend) t)
(unless (org-lparse-backend-is-native-p backend)
(error "Unknown native backend %s" backend))
(let ((backend-get-method (intern (format "org-%s-get" backend)))
(backend-user-get-method (intern (format "org-%s-user-get" backend))))
(cond
((functionp backend-get-method)
(condition-case nil
(funcall backend-user-get-method what opt-plist)
(error (funcall backend-get-method what opt-plist))))
(t
(error "Native backend %s doesn't define %s" backend backend-get-method)))))
(defun org-lparse-insert-tag (tag &rest args)
(when (member org-lparse-insert-tag-with-newlines '(lead both))
(insert "\n"))
(insert (apply 'format tag args))
(when (member org-lparse-insert-tag-with-newlines '(trail both))
(insert "\n")))
(defun org-lparse-get-targets-from-title (title)
(let* ((target (org-get-text-property-any 0 'target title))
(extra-targets (assoc target org-export-target-aliases))
(target (or (cdr (assoc target org-export-preferred-target-alist))
target)))
(cons target (remove target extra-targets))))
(defun org-lparse-suffix-from-snumber (snumber)
(let* ((snu (replace-regexp-in-string "\\." "-" snumber))
(href (cdr (assoc (concat "sec-" snu)
org-export-preferred-target-alist))))
(org-solidify-link-text (or href snu))))
(defun org-lparse-begin-level (level title umax head-count)
"Insert a new LEVEL in HTML export.
When TITLE is nil, just close all open levels."
(org-lparse-end-level level umax)
(unless title (error "Why is heading nil"))
(let* ((targets (org-lparse-get-targets-from-title title))
(target (car targets)) (extra-targets (cdr targets))
(target (and target (org-solidify-link-text target)))
(extra-class (org-get-text-property-any 0 'html-container-class title))
snumber tags level1 class)
(when (string-match (org-re "\\(:[[:alnum:]_@#%:]+:\\)[ \t]*$") title)
(setq tags (and org-export-with-tags (match-string 1 title)))
(setq title (replace-match "" t t title)))
(if (> level umax)
(progn
(if (aref org-levels-open (1- level))
(org-lparse-end-list-item)
(aset org-levels-open (1- level) t)
(org-lparse-end-paragraph)
(org-lparse-begin 'LIST 'unordered))
(org-lparse-begin
'LIST-ITEM 'unordered target
(org-lparse-format 'HEADLINE title extra-targets tags)))
(aset org-levels-open (1- level) t)
(setq snumber (org-section-number level))
(setq level1 (+ level (or (org-lparse-get 'TOPLEVEL-HLEVEL) 1) -1))
(unless (= head-count 1)
(org-lparse-end-outline-text-or-outline))
(org-lparse-begin-outline-and-outline-text
level1 snumber title tags target extra-targets extra-class)
(org-lparse-begin-paragraph))))
(defun org-lparse-end-level (level umax)
(org-lparse-end-paragraph)
(loop for l from org-level-max downto level
do (when (aref org-levels-open (1- l))
;; Terminate one level in HTML export
(if (<= l umax)
(org-lparse-end-outline-text-or-outline)
(org-lparse-end-list-item)
(org-lparse-end 'LIST 'unordered))
(aset org-levels-open (1- l) nil))))
(defvar org-lparse-outline-text-open)
(defun org-lparse-begin-outline-and-outline-text (level1 snumber title tags
target extra-targets
extra-class)
(org-lparse-begin
'OUTLINE level1 snumber title tags target extra-targets extra-class)
(org-lparse-begin-outline-text level1 snumber extra-class))
(defun org-lparse-end-outline-text-or-outline ()
(cond
(org-lparse-outline-text-open
(org-lparse-end 'OUTLINE-TEXT)
(setq org-lparse-outline-text-open nil))
(t (org-lparse-end 'OUTLINE))))
(defun org-lparse-begin-outline-text (level1 snumber extra-class)
(assert (not org-lparse-outline-text-open) t)
(setq org-lparse-outline-text-open t)
(org-lparse-begin 'OUTLINE-TEXT level1 snumber extra-class))
(defun org-lparse-html-list-type-to-canonical-list-type (ltype)
(cdr (assoc ltype '(("o" . ordered)
("u" . unordered)
("d" . description)))))
(defvar org-lparse-table-rowgrp-info)
(defun org-lparse-begin-table-rowgroup (&optional is-header-row)
(push (cons (1+ org-lparse-table-rownum) :start) org-lparse-table-rowgrp-info)
(org-lparse-begin 'TABLE-ROWGROUP is-header-row))
(defun org-lparse-end-table ()
(when org-lparse-table-is-styled
;; column groups
(unless (car org-table-colgroup-info)
(setq org-table-colgroup-info
(cons :start (cdr org-table-colgroup-info))))
;; column alignment
(let ((c -1))
(mapc
(lambda (x)
(incf c)
(setf (aref org-lparse-table-colalign-vector c)
(or (aref org-lparse-table-colalign-vector c)
(if (> (/ (float x) (1+ org-lparse-table-rownum))
org-table-number-fraction)
"right" "left"))))
org-lparse-table-num-numeric-items-per-column)))
(org-lparse-end 'TABLE))
(defvar org-lparse-encode-pending nil)
(defun org-lparse-format-tags (tag text prefix suffix &rest args)
(cond
((consp tag)
(concat prefix (apply 'format (car tag) args) text suffix
(format (cdr tag))))
((stringp tag) ; singleton tag
(concat prefix (apply 'format tag args) text))))
(defun org-xml-fix-class-name (kwd) ; audit callers of this function
"Turn todo keyword into a valid class name.
Replaces invalid characters with \"_\"."
(save-match-data
(while (string-match "[^a-zA-Z0-9_]" kwd)
(setq kwd (replace-match "_" t t kwd))))
kwd)
(defun org-lparse-format-todo (todo)
(org-lparse-format 'FONTIFY
(concat
(ignore-errors (org-lparse-get 'TODO-KWD-CLASS-PREFIX))
(org-xml-fix-class-name todo))
(list (if (member todo org-done-keywords) "done" "todo")
todo)))
(defun org-lparse-format-extra-targets (extra-targets)
(if (not extra-targets) ""
(mapconcat (lambda (x)
(setq x (org-solidify-link-text
(if (org-uuidgen-p x) (concat "ID-" x) x)))
(org-lparse-format 'ANCHOR "" x))
extra-targets "")))
(defun org-lparse-format-org-tags (tags)
(if (not tags) ""
(org-lparse-format
'FONTIFY (mapconcat
(lambda (x)
(org-lparse-format
'FONTIFY x
(concat
(ignore-errors (org-lparse-get 'TAG-CLASS-PREFIX))
(org-xml-fix-class-name x))))
(org-split-string tags ":")
(org-lparse-format 'SPACES 1)) "tag")))
(defun org-lparse-format-section-number (&optional snumber level)
(and org-export-with-section-numbers
(not org-lparse-body-only) snumber level
(org-lparse-format 'FONTIFY snumber (format "section-number-%d" level))))
(defun org-lparse-warn (msg)
(if (not org-lparse-use-flashy-warning)
(message msg)
(put-text-property 0 (length msg) 'face 'font-lock-warning-face msg)
(message msg)
(sleep-for 3)))
(defun org-xml-format-href (s)
"Make sure the S is valid as a href reference in an XHTML document."
(save-match-data
(let ((start 0))
(while (string-match "&" s start)
(setq start (+ (match-beginning 0) 3)
s (replace-match "&amp;" t t s)))))
s)
(defun org-xml-format-desc (s)
"Make sure the S is valid as a description in a link."
(if (and s (not (get-text-property 1 'org-protected s)))
(save-match-data
(org-xml-encode-org-text s))
s))
(provide 'org-lparse)
;;; org-lparse.el ends here