1 ;;; org-lparse.el --- Line-oriented parser-exporter for Org-mode
3 ;; Copyright (C) 2010-2011 Jambunathan <kjambunathan at gmail dot com>
5 ;; Author: Jambunathan K <kjambunathan at gmail dot com>
6 ;; Keywords: outlines, hypermedia, calendar, wp
7 ;; Homepage: http://orgmode.org
10 ;; This file is not (yet) part of GNU Emacs.
11 ;; However, it is distributed under the same license.
13 ;; GNU Emacs is free software: you can redistribute it and/or modify
14 ;; it under the terms of the GNU General Public License as published by
15 ;; the Free Software Foundation, either version 3 of the License, or
16 ;; (at your option) any later version.
18 ;; GNU Emacs is distributed in the hope that it will be useful,
19 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
20 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 ;; GNU General Public License for more details.
23 ;; You should have received a copy of the GNU General Public License
24 ;; along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>.
25 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
29 ;; `org-lparse' is the entry point for the generic line-oriented
30 ;; exporter. `org-do-lparse' is the genericized version of the
31 ;; original `org-export-as-html' routine.
33 ;; `org-lparse-native-backends' is a good starting point for
34 ;; exploring the generic exporter.
36 ;; Following new interactive commands are provided by this library.
37 ;; `org-lparse', `org-lparse-and-open', `org-lparse-to-buffer'
38 ;; `org-replace-region-by', `org-lparse-region'.
40 ;; Note that the above routines correspond to the following routines
41 ;; in the html exporter `org-export-as-html',
42 ;; `org-export-as-html-and-open', `org-export-as-html-to-buffer',
43 ;; `org-replace-region-by-html' and `org-export-region-as-html'.
45 ;; The new interactive command `org-lparse-convert' can be used to
46 ;; convert documents between various formats. Use this to command,
47 ;; for example, to convert odt file to doc or pdf format.
49 ;; See README.org file that comes with this library for answers to
50 ;; FAQs and more information on using this library.
58 (defun org-lparse-and-open (target-backend native-backend arg
)
59 "Export outline to TARGET-BACKEND via NATIVE-BACKEND and open exported file.
60 If there is an active region, export only the region. The prefix
61 ARG specifies how many levels of the outline should become
62 headlines. The default is 3. Lower levels will become bulleted
64 ;; (interactive "Mbackend: \nP")
66 (let* ((input (if (featurep 'ido
) 'ido-completing-read
'completing-read
))
67 (all-backends (org-lparse-all-backends))
69 (funcall input
"Export to: " all-backends nil t nil
))
72 ;; (and (org-lparse-backend-is-native-p target-backend)
74 (funcall input
"Use Native backend: "
75 (cdr (assoc target-backend all-backends
)) nil t nil
))))
76 (list target-backend native-backend current-prefix-arg
)))
77 (let (f (file-or-buf (org-lparse target-backend native-backend
81 ((bufferp file-or-buf
) buffer-file-name
)
82 ((file-exists-p file-or-buf
) file-or-buf
)
83 (t (error "org-lparse-and-open: This shouldn't happen"))))
84 (message "Opening file %s" f
)
86 (when org-export-kill-product-buffer-when-displayed
87 (kill-buffer (current-buffer))))))
90 (defun org-lparse-batch (target-backend &optional native-backend
)
91 "Call the function `org-lparse'.
92 This function can be used in batch processing as:
94 --load=$HOME/lib/emacs/org.el
95 --eval \"(setq org-export-headline-levels 2)\"
96 --visit=MyFile --funcall org-lparse-batch"
97 (setq native-backend
(or native-backend target-backend
))
98 (org-lparse target-backend native-backend
99 org-export-headline-levels
'hidden
))
102 (defun org-lparse-to-buffer (backend arg
)
103 "Call `org-lparse' with output to a temporary buffer.
104 No file is created. The prefix ARG is passed through to
106 (interactive "Mbackend: \nP")
107 (let ((tempbuf (format "*Org %s Export*" (upcase backend
))))
108 (org-lparse backend backend arg nil nil tempbuf
)
109 (when org-export-show-temporary-export-buffer
110 (switch-to-buffer-other-window tempbuf
))))
113 (defun org-replace-region-by (backend beg end
)
114 "Assume the current region has org-mode syntax, and convert it to HTML.
115 This can be used in any buffer. For example, you could write an
116 itemized list in org-mode syntax in an HTML buffer and then use
117 this command to convert it."
118 (interactive "Mbackend: \nr")
119 (let (reg backend-string buf pop-up-frames
)
120 (save-window-excursion
122 (setq backend-string
(org-lparse-region backend beg end t
'string
))
123 (setq reg
(buffer-substring beg end
)
124 buf
(get-buffer-create "*Org tmp*"))
125 (with-current-buffer buf
129 (setq backend-string
(org-lparse-region backend
(point-min)
130 (point-max) t
'string
)))
132 (delete-region beg end
)
133 (insert backend-string
)))
136 (defun org-lparse-region (backend beg end
&optional body-only buffer
)
137 "Convert region from BEG to END in org-mode buffer to HTML.
138 If prefix arg BODY-ONLY is set, omit file header, footer, and table of
139 contents, and only produce the region of converted text, useful for
140 cut-and-paste operations.
141 If BUFFER is a buffer or a string, use/create that buffer as a target
142 of the converted HTML. If BUFFER is the symbol `string', return the
143 produced HTML as a string and leave not buffer behind. For example,
144 a Lisp program could call this function in the following way:
146 (setq html (org-lparse-region \"html\" beg end t 'string))
148 When called interactively, the output buffer is selected, and shown
149 in a window. A non-interactive call will only return the buffer."
150 (interactive "Mbackend: \nr\nP")
151 (when (org-called-interactively-p 'any
)
152 (setq buffer
(format "*Org %s Export*" (upcase backend
))))
153 (let ((transient-mark-mode t
) (zmacs-regions t
)
155 (setq ext-plist
(plist-put ext-plist
:ignore-subtree-p t
))
157 (set-mark (point)) ;; to activate the region
159 (setq rtn
(org-lparse backend backend nil nil ext-plist buffer body-only
))
160 (if (fboundp 'deactivate-mark
) (deactivate-mark))
161 (if (and (org-called-interactively-p 'any
) (bufferp rtn
))
162 (switch-to-buffer-other-window rtn
)
165 (defvar org-lparse-par-open nil
)
167 (defun org-lparse-should-inline-p (filename descp
)
168 "Return non-nil if link FILENAME should be inlined.
169 The decision to inline the FILENAME link is based on the current
170 settings. DESCP is the boolean of whether there was a link
171 description. See variables `org-export-html-inline-images' and
172 `org-export-html-inline-image-extensions'."
173 (let ((inline-images (org-lparse-get 'INLINE-IMAGES
))
174 (inline-image-extensions
175 (org-lparse-get 'INLINE-IMAGE-EXTENSIONS
)))
176 (and (or (eq t inline-images
) (and inline-images
(not descp
)))
177 (org-file-image-p filename inline-image-extensions
))))
179 (defun org-lparse-format-org-link (line opt-plist
)
180 "Return LINE with markup of Org mode links.
181 OPT-PLIST is the export options list."
183 (current-dir (if buffer-file-name
184 (file-name-directory buffer-file-name
)
186 (link-validate (plist-get opt-plist
:link-validation-function
))
188 rpl path attr desc descp desc1 desc2 link
189 org-lparse-link-description-is-image
)
190 (while (string-match org-bracket-link-analytic-regexp
++ line start
)
191 (setq org-lparse-link-description-is-image nil
)
192 (setq start
(match-beginning 0))
193 (setq path
(save-match-data (org-link-unescape
194 (match-string 3 line
))))
196 ((match-end 2) (match-string 2 line
))
198 (or (file-name-absolute-p path
)
199 (string-match "^\\.\\.?/" path
)))
202 (setq path
(org-extract-attributes (org-link-unescape path
)))
203 (setq attr
(get-text-property 0 'org-attributes path
))
204 (setq desc1
(if (match-end 5) (match-string 5 line
))
205 desc2
(if (match-end 2) (concat type
":" path
) path
)
206 descp
(and desc1
(not (equal desc1 desc2
)))
207 desc
(or desc1 desc2
))
208 ;; Make an image out of the description if that is so wanted
209 (when (and descp
(org-file-image-p
210 desc
(org-lparse-get 'INLINE-IMAGE-EXTENSIONS
)))
211 (setq org-lparse-link-description-is-image t
)
213 (if (string-match "^file:" desc
)
214 (setq desc
(substring desc
(match-end 0)))))
216 (setq desc
(org-add-props
217 (org-lparse-format 'INLINE-IMAGE desc
)
218 '(org-protected t
)))))
220 ((equal type
"internal")
223 (if (= (string-to-char path
) ?
#)
228 'ORG-LINK opt-plist
"" "" (org-solidify-link-text
230 (org-link-unescape frag-0
))
231 nil
) desc attr descp
))))
232 ((and (equal type
"id")
233 (setq id-file
(org-id-find-id-file path
)))
234 ;; This is an id: link to another file (if it was the same file,
235 ;; it would have become an internal link...)
237 (setq id-file
(file-relative-name
239 (file-name-directory org-current-export-file
)))
242 'ORG-LINK opt-plist type id-file
243 (concat (if (org-uuidgen-p path
) "ID-") path
)
245 ((member type
'("http" "https"))
246 ;; standard URL, can inline as image
249 'ORG-LINK opt-plist type path nil desc attr descp
)))
250 ((member type
'("ftp" "mailto" "news"))
251 ;; standard URL, can't inline as image
254 'ORG-LINK opt-plist type path nil desc attr descp
)))
256 ((string= type
"coderef")
259 'ORG-LINK opt-plist type
"" (format "coderef-%s" path
)
261 (org-export-get-coderef-format
264 (cdr (assoc path org-export-code-refs
))) nil descp
)))
266 ((functionp (setq fnc
(nth 2 (assoc type org-link-protocols
))))
267 ;; The link protocol has a function for format the link
270 (funcall fnc
(org-link-unescape path
) desc1
'html
))))
272 ((string= type
"file")
278 (string-match "::\\(.*\\)" path
)
280 (replace-match "" t nil path
)
281 (match-string 1 path
))
284 ;;The proper path, without a fragment
292 ;;Check the fragment. If it can't be used as
293 ;;target fragment we'll pass nil instead.
297 (not (string-match "^[0-9]*$" fragment-0
))
298 (not (string-match "^\\*" fragment-0
))
299 (not (string-match "^/.*/$" fragment-0
)))
300 (org-solidify-link-text
301 (org-link-unescape fragment-0
))
304 ;;Description minus "file:" and ".org"
305 (if (string-match "^file:" desc
)
307 ((desc-1 (replace-match "" t t desc
)))
308 (if (string-match "\\.org$" desc-1
)
309 (replace-match "" t t desc-1
)
316 (functionp link-validate
)
317 (not (funcall link-validate path-1 current-dir
)))
320 'ORG-LINK opt-plist
"file" path-1 fragment-1
321 desc-2 attr descp
))))))
324 ;; just publish the path, as default
325 (setq rpl
(concat "<i><" type
":"
326 (save-match-data (org-link-unescape path
))
328 (setq line
(replace-match rpl t t line
)
329 start
(+ start
(length rpl
))))
332 (defmacro with-org-lparse-preserve-paragraph-state
(&rest body
)
333 `(let ((org-lparse-do-open-par org-lparse-par-open
))
334 (org-lparse-end-paragraph)
336 (when org-lparse-do-open-par
337 (org-lparse-begin-paragraph))))
339 (defvar org-lparse-native-backends nil
340 "List of native backends registered with `org-lparse'.
341 A backend can use `org-lparse-register-backend' to add itself to
344 All native backends must implement a get routine and a mandatory
345 set of callback routines.
347 The get routine must be named as org-<backend>-get where backend
348 is the name of the backend. The exporter uses `org-lparse-get'
349 and retrieves the backend-specific callback by querying for
350 ENTITY-CONTROL and ENTITY-FORMAT variables.
352 For the sake of illustration, the html backend implements
353 `org-xhtml-get'. It returns
354 `org-xhtml-entity-control-callbacks-alist' and
355 `org-xhtml-entity-format-callbacks-alist' as the values of
356 ENTITY-CONTROL and ENTITY-FORMAT settings.")
358 (defun org-lparse-register-backend (backend)
359 "Make BACKEND known to `org-lparse' library.
360 Add BACKEND to `org-lparse-native-backends'."
363 ((symbolp backend
) (symbol-name backend
))
364 ((stringp backend
) backend
)
365 (t (error "Error while registering backend: %S" backend
))))
366 (add-to-list 'org-lparse-native-backends backend
)))
368 (defun org-lparse-unregister-backend (backend)
369 (setq org-lparse-native-backends
371 ((symbolp backend
) (symbol-name backend
))
372 ((stringp backend
) backend
))
373 org-lparse-native-backends
))
374 (message "Unregistered backend %S" backend
))
376 (defun org-lparse-get-other-backends (in-fmt)
377 "Return OUTPUT-FMT-ALIST corresponding to IN-FMT.
378 See `org-lparse-convert-capabilities' for definition of
380 (when (org-lparse-get-converter in-fmt
)
381 (or (ignore-errors (org-lparse-backend-get in-fmt
'OTHER-BACKENDS
) )
383 (dolist (c org-lparse-convert-capabilities
)
384 (when (member in-fmt
(nth 1 c
))
385 (throw 'out-fmts
(nth 2 c
))))))))
387 (defun org-lparse-get-converter (in-fmt)
388 "Return converter associated with IN-FMT.
389 See `org-lparse-convert-capabilities' for further information."
390 (or (ignore-errors (org-lparse-backend-get in-fmt
'CONVERT-METHOD
))
391 org-lparse-convert-process
))
393 (defun org-lparse-all-backends ()
394 "Return all formats to which `org-lparse' could export to.
395 The return value is an alist of the form (TARGET-BACKEND
396 NATIVE-BACKEND-1 NATIVE-BACKEND-2 ...) with the condition that
397 the org file can be exported to TARGET-BACKEND via any one of
398 NATIVE-BACKEND-1, NATIVE-BACKEND-2 etc.
400 For example, an entry of the form \"(\"pdf\" \"odt\" \"xhtml\")\"
401 would mean that the org file could be exported to \"pdf\" format
402 by exporting natively either to \"xhtml\" or \"odt\" backends."
404 (flet ((add (other native
)
405 (let ((val (assoc-string other all-backends t
)))
406 (if val
(setcdr val
(nconc (list native
) (cdr val
)))
407 (push (cons other
(list native
)) all-backends
)))))
408 (loop for backend in org-lparse-native-backends
409 do
(loop for other in
410 (mapcar #'car
(org-lparse-get-other-backends backend
))
411 do
(add other backend
))))
414 (defun org-lparse-backend-is-native-p (backend)
415 (member backend org-lparse-native-backends
))
417 (defun org-lparse (target-backend native-backend arg
418 &optional hidden ext-plist
419 to-buffer body-only pub-dir
)
420 "Export the outline to various formats.
421 If there is an active region, export only the region. The
422 outline is first exported to NATIVE-BACKEND and optionally
423 converted to TARGET-BACKEND. See `org-lparse-native-backends'
424 for list of known native backends. Each native backend can
425 specify a converter and list of target backends it exports to
426 using the CONVERT-PROCESS and OTHER-BACKENDS settings of it's get
427 method. See `org-xhtml-get' for an illustrative example.
429 ARG is a prefix argument that specifies how many levels of
430 outline should become headlines. The default is 3. Lower levels
431 will become bulleted lists.
433 HIDDEN is obsolete and does nothing.
435 EXT-PLIST is a property list that controls various aspects of
436 export. The settings here override org-mode's default settings
437 and but are inferior to file-local settings.
439 TO-BUFFER dumps the exported lines to a buffer or a string
440 instead of a file. If TO-BUFFER is the symbol `string' return the
441 exported lines as a string. If TO-BUFFER is non-nil, create a
442 buffer with that name and export to that buffer.
444 BODY-ONLY controls the presence of header and footer lines in
445 exported text. If BODY-ONLY is non-nil, don't produce the file
446 header and footer, simply return the content of <body>...</body>,
447 without even the body tags themselves.
449 PUB-DIR specifies the publishing directory."
451 (let* ((input (if (featurep 'ido
) 'ido-completing-read
'completing-read
))
452 (all-backends (org-lparse-all-backends))
455 (funcall input
"Export to: " all-backends nil t nil
)))
457 (let ((choices (if target-backend
458 (cdr (assoc target-backend all-backends
))
459 (or org-lparse-native-backends
460 (error "No registered backends")))))
461 (funcall input
"Use Native backend: " choices nil t nil
))))
462 (list target-backend native-backend current-prefix-arg
)))
463 (let* ((org-lparse-backend (intern native-backend
))
464 (org-lparse-other-backend (and target-backend
465 (intern target-backend
))))
466 (unless (org-lparse-backend-is-native-p native-backend
)
467 (error "Don't know how to export natively to backend %s" native-backend
))
468 (unless (or (not target-backend
)
469 (equal target-backend native-backend
)
470 (assoc target-backend
(org-lparse-get-other-backends
472 (error "Don't know how to export to backend %s %s" target-backend
473 (format "via %s" native-backend
)))
474 (run-hooks 'org-export-first-hook
)
475 (org-do-lparse arg hidden ext-plist to-buffer body-only pub-dir
)))
477 (defcustom org-lparse-convert-processes
478 '(("BasicODConverter"
479 ("soffice" "-norestore" "-invisible" "-headless"
480 "\"macro:///BasicODConverter.Main.Convert(%I,%f,%O)\""))
482 ("unoconv" "-f" "%f" "-o" "%d" "%i")))
483 "Specify a list of document converters and their usage.
484 The converters in this list are offered as choices while
485 customizing `org-lparse-convert-process'.
487 This variable is an alist where each element is of the
488 form (CONVERTER-NAME (CONVERTER-PROGRAM ARG1 ARG2 ...)).
489 CONVERTER-NAME is name of the converter. CONVERTER-PROGRAM is
490 the name of the executable. ARG1, ARG2 etc are command line
491 options that are passed to CONVERTER-PROGRAM. Format specifiers
492 can be used in the ARGs and they are interpreted as below:
494 %i input file name in full
495 %I input file name as a URL
496 %f format of the output file
497 %o output file name in full
498 %O output file name as a URL
499 %d output dir in full
500 %D output dir as a URL."
504 (const :tag
"None" nil
)
505 (alist :tag
"Converters"
506 :key-type
(string :tag
"Converter Name")
507 :value-type
(group (cons (string :tag
"Executable")
508 (repeat (string :tag
"Command line args")))))))
509 (defcustom org-lparse-convert-process nil
510 "Command to convert from an Org exported format to other formats.
511 During customization, the list of choices are populated from
512 `org-lparse-convert-processes'. Refer afore-mentioned variable
513 for further information."
515 :type
'(choice :convert-widget
517 (apply 'widget-convert
(widget-type w
)
518 (eval (car (widget-get w
:args
)))))
519 `((const :tag
"None" nil
)
520 ,@(mapcar (lambda (c)
521 `(const :tag
,(car c
) ,(cadr c
)))
522 org-lparse-convert-processes
))))
524 (defcustom org-lparse-convert-capabilities
526 ("odt" "ott" "doc" "rtf")
527 (("pdf" "pdf") ("odt" "odt") ("xhtml" "html") ("rtf" "rtf")
528 ("ott" "ott") ("doc" "doc") ("ooxml" "xml") ("html" "html")))
530 ("html" "xhtml") (("pdf" "pdf") ("odt" "txt") ("html" "html")))
532 ("ods" "ots" "xls" "csv")
533 (("pdf" "pdf") ("ots" "ots") ("html" "html") ("csv" "csv")
534 ("ods" "ods") ("xls" "xls") ("xhtml" "xhtml") ("ooxml" "xml")))
537 (("pdf" "pdf") ("swf" "swf") ("odp" "odp") ("xhtml" "xml")
538 ("otp" "otp") ("ppt" "ppt") ("odg" "odg") ("html" "html"))))
539 "Specify input and output formats of `org-lparse-convert-process'.
540 More correctly, specify the set of input and output formats that
541 the user is actually interested in.
543 This variable is an alist where each element is of the
544 form (DOCUMENT-CLASS INPUT-FMT-LIST OUTPUT-FMT-ALIST).
545 INPUT-FMT-LIST is a list of INPUT-FMTs. OUTPUT-FMT-ALIST is an
546 alist where each element is of the form (OUTPUT-FMT
547 OUTPUT-FILE-EXTENSION).
549 The variable is interpreted as follows:
550 `org-lparse-convert-process' can take any document that is in
551 INPUT-FMT-LIST and produce any document that is in the
552 OUTPUT-FMT-LIST. A document converted to OUTPUT-FMT will have
553 OUTPUT-FILE-EXTENSION as the file name extension. OUTPUT-FMT
554 serves dual purposes:
555 - It is used for populating completion candidates during
556 `org-lparse' and `org-lparse-convert' commands.
558 - It is used as the value of \"%f\" specifier in
559 `org-lparse-convert-process'.
561 DOCUMENT-CLASS is used to group a set of file formats in
562 INPUT-FMT-LIST in to a single class.
564 Note that this variable inherently captures how LibreOffice based
565 converters work. LibreOffice maps documents of various formats
566 to classes like Text, Web, Spreadsheet, Presentation etc and
567 allow document of a given class (irrespective of it's source
568 format) to be converted to any of the export formats associated
571 See default setting of this variable for an typical
576 (const :tag
"None" nil
)
577 (alist :key-type
(string :tag
"Document Class")
579 (group (repeat :tag
"Input formats" (string :tag
"Input format"))
580 (alist :tag
"Output formats"
581 :key-type
(string :tag
"Output format")
583 (group (string :tag
"Output file extension")))))))
585 (defcustom org-lparse-use-flashy-warning nil
586 "Control flashing of messages logged with `org-lparse-warn'.
587 When non-nil, messages are fontified with warning face and the
588 exporter lingers for a while to catch user's attention."
592 (defun org-lparse-convert (&optional in-file out-fmt prefix-arg
)
593 "Convert IN-FILE to format OUT-FMT using a command line converter.
594 IN-FILE is the file to be converted. If unspecified, it defaults
595 to variable `buffer-file-name'. OUT-FMT is the desired output
596 format. If the backend has registered a CONVERT-METHOD as part
597 of it's get function then that converter is used. Otherwise
598 `org-lparse-convert-process' is used. If PREFIX-ARG is non-nil
599 then the newly converted file is opened using `org-open-file'."
601 (let* ((input (if (featurep 'ido
) 'ido-completing-read
'completing-read
))
602 (in-file (read-file-name "File to be converted: "
603 nil buffer-file-name t
))
604 (in-fmt (file-name-extension in-file
))
605 (out-fmt-choices (org-lparse-get-other-backends in-fmt
))
607 (or (and out-fmt-choices
608 (funcall input
"Output format: "
609 out-fmt-choices nil nil nil
))
611 "No known converter or no known output formats for %s files"
613 (list in-file out-fmt current-prefix-arg
)))
614 (require 'browse-url
)
615 (let* ((in-file (expand-file-name (or in-file buffer-file-name
)))
616 (dummy (or (file-readable-p in-file
)
617 (error "Cannot read %s" in-file
)))
618 (in-fmt (file-name-extension in-file
))
619 (out-fmt (or out-fmt
(error "Output format unspecified")))
620 (convert-process (org-lparse-get-converter in-fmt
))
621 (program (car convert-process
))
622 (dummy (and (or program
(error "Converter not configured"))
623 (or (executable-find program
)
624 (error "Cannot find converter %s" program
))))
626 (or (assoc out-fmt
(org-lparse-get-other-backends in-fmt
))
627 (error "Cannot convert from %s to %s format" in-fmt out-fmt
)))
628 (out-file (concat (file-name-sans-extension in-file
) "."
629 (nth 1 out-fmt-alist
)))
630 (out-dir (file-name-directory in-file
))
631 (arglist (mapcar (lambda (arg)
633 arg
`((?i .
,in-file
)
634 (?I .
,(browse-url-file-url in-file
))
637 (?O .
,(browse-url-file-url out-file
))
639 (?D .
,(browse-url-file-url out-dir
)))))
640 (cdr convert-process
))))
641 (when (file-exists-p out-file
)
642 (delete-file out-file
))
644 (message "Executing %s %s" program
(mapconcat 'identity arglist
" "))
645 (apply 'call-process program nil nil nil arglist
)
647 ((file-exists-p out-file
)
648 (message "Exported to %s using %s" out-file program
)
650 (message "Opening %s..." out-file
)
651 (org-open-file out-file
))
653 ;; (set-buffer (find-file-noselect out-file))
656 (message "Export to %s failed" out-file
)
659 (defvar org-lparse-insert-tag-with-newlines
'both
)
661 ;; Following variables are let-bound during `org-lparse'
662 (defvar org-lparse-dyn-first-heading-pos
)
663 (defvar org-lparse-toc
)
664 (defvar org-lparse-entity-control-callbacks-alist
)
665 (defvar org-lparse-entity-format-callbacks-alist
)
666 (defvar org-lparse-backend nil
667 "The native backend to which the document is currently exported.
668 This variable is let bound during `org-lparse'. Valid values are
669 one of the symbols corresponding to `org-lparse-native-backends'.
671 Compare this variable with `org-export-current-backend' which is
672 bound only during `org-export-preprocess-string' stage of the
675 See also `org-lparse-other-backend'.")
677 (defvar org-lparse-other-backend nil
678 "The target backend to which the document is currently exported.
679 This variable is let bound during `org-lparse'. This variable is
680 set to either `org-lparse-backend' or one of the symbols
681 corresponding to OTHER-BACKENDS specification of the
684 For example, if a document is exported to \"odt\" then both
685 org-lparse-backend and org-lparse-other-backend are bound to
686 'odt. On the other hand, if a document is exported to \"odt\"
687 and then converted to \"doc\" then org-lparse-backend is set to
688 'odt and org-lparse-other-backend is set to 'doc.")
690 (defvar org-lparse-body-only nil
691 "Bind this to BODY-ONLY arg of `org-lparse'.")
693 (defvar org-lparse-to-buffer nil
694 "Bind this to TO-BUFFER arg of `org-lparse'.")
696 (defvar org-lparse-current-paragraph-style nil
697 "Default paragraph style to use.
698 Exporter sets or resets this as it enters and leaves special
699 contexts. Currently this is used for formatting of paragraphs
700 that are part of table-cells created from list-tables.")
702 (defun org-do-lparse (arg &optional hidden ext-plist
703 to-buffer body-only pub-dir
)
704 "Export the outline to various formats.
705 See `org-lparse' for more information. This function is a
706 html-agnostic version of the `org-export-as-html' function in 7.5
708 ;; Make sure we have a file name when we need it.
709 (when (and (not (or to-buffer body-only
))
710 (not buffer-file-name
))
711 (if (buffer-base-buffer)
712 (org-set-local 'buffer-file-name
713 (with-current-buffer (buffer-base-buffer)
715 (error "Need a file name to be able to export")))
718 (format "Exporting to %s using org-lparse..."
720 (or org-lparse-backend org-lparse-other-backend
)))))
722 (setq-default org-todo-line-regexp org-todo-line-regexp
)
723 (setq-default org-deadline-line-regexp org-deadline-line-regexp
)
724 (setq-default org-done-keywords org-done-keywords
)
725 (setq-default org-maybe-keyword-time-regexp org-maybe-keyword-time-regexp
)
726 (let* (hfy-user-sheet-assoc ; let `htmlfontify' know that
727 ; we are interested in
729 org-lparse-encode-pending
731 org-lparse-current-paragraph-style
732 org-lparse-list-table-p
733 (org-lparse-list-level 0) ; list level starts at 1. A
734 ; value of 0 implies we are
735 ; outside of any list
736 org-lparse-outline-text-open
737 (org-lparse-latex-fragment-fallback ; currently used only by
739 (or (ignore-errors (org-lparse-get 'LATEX-FRAGMENT-FALLBACK
))
740 (if (and (org-check-external-command "latex" "" t
)
741 (org-check-external-command "dvipng" "" t
))
744 (org-lparse-insert-tag-with-newlines 'both
)
745 (org-lparse-to-buffer to-buffer
)
746 (org-lparse-body-only body-only
)
747 (org-lparse-entity-control-callbacks-alist
748 (org-lparse-get 'ENTITY-CONTROL
))
749 (org-lparse-entity-format-callbacks-alist
750 (org-lparse-get 'ENTITY-FORMAT
))
752 (org-export-process-option-filters
753 (org-combine-plists (org-default-export-plist)
755 (org-infile-export-plist))))
756 (body-only (or body-only
(plist-get opt-plist
:body-only
)))
757 valid org-lparse-dyn-first-heading-pos
758 (odd org-odd-levels-only
)
759 (region-p (org-region-active-p))
760 (rbeg (and region-p
(region-beginning)))
761 (rend (and region-p
(region-end)))
763 (if (plist-get opt-plist
:ignore-subtree-p
)
768 (and (org-at-heading-p)
769 (>= (org-end-of-subtree t t
) rend
))))))
770 (level-offset (if subtree-p
773 (+ (funcall outline-level
)
774 (if org-odd-levels-only
1 0)))
776 (opt-plist (setq org-export-opt-plist
778 (org-export-add-subtree-options opt-plist rbeg
)
780 ;; The following two are dynamically scoped into other
782 (org-current-export-dir
783 (or pub-dir
(org-lparse-get 'EXPORT-DIR opt-plist
)))
784 (org-current-export-file buffer-file-name
)
785 (level 0) (line "") (origline "") txt todo
788 (filename (if to-buffer nil
791 (file-name-sans-extension
793 (org-entry-get (region-beginning)
794 "EXPORT_FILE_NAME" t
))
795 (file-name-nondirectory buffer-file-name
)))
796 "." (org-lparse-get 'FILE-NAME-EXTENSION opt-plist
))
797 (file-name-as-directory
798 (or pub-dir
(org-lparse-get 'EXPORT-DIR opt-plist
))))))
799 (current-dir (if buffer-file-name
800 (file-name-directory buffer-file-name
)
802 (buffer (if to-buffer
804 ((eq to-buffer
'string
)
805 (get-buffer-create (org-lparse-get 'EXPORT-BUFFER-NAME
)))
806 (t (get-buffer-create to-buffer
)))
808 (or (let ((f (org-lparse-get 'INIT-METHOD
)))
809 (and f
(functionp f
) (funcall f filename
)))
811 (org-levels-open (make-vector org-level-max nil
))
812 (date (plist-get opt-plist
:date
))
814 ((and date
(string-match "%" date
))
815 (format-time-string date
))
817 (t (format-time-string "%Y-%m-%d %T %Z"))))
818 (dummy (setq opt-plist
(plist-put opt-plist
:effective-date date
)))
819 (title (org-xml-encode-org-text-skip-links
820 (or (and subtree-p
(org-export-get-title-from-subtree))
821 (plist-get opt-plist
:title
)
824 (plist-get opt-plist
:skip-before-1st-heading
))
825 (org-export-grab-title-from-buffer))
826 (and buffer-file-name
827 (file-name-sans-extension
828 (file-name-nondirectory buffer-file-name
)))
830 (dummy (setq opt-plist
(plist-put opt-plist
:title title
)))
831 (html-table-tag (plist-get opt-plist
:html-table-tag
))
832 (quote-re0 (concat "^[ \t]*" org-quote-string
"\\>"))
833 (quote-re (concat "^\\(\\*+\\)\\([ \t]+" org-quote-string
"\\>\\)"))
834 (org-lparse-dyn-current-environment nil
)
835 ;; Get the language-dependent settings
836 (lang-words (or (assoc (plist-get opt-plist
:language
)
837 org-export-language-setup
)
838 (assoc "en" org-export-language-setup
)))
839 (dummy (setq opt-plist
(plist-put opt-plist
:lang-words lang-words
)))
842 (coding-system-for-write
843 (or (ignore-errors (org-lparse-get 'CODING-SYSTEM-FOR-WRITE
))
844 (and (boundp 'buffer-file-coding-system
)
845 buffer-file-coding-system
)))
846 (save-buffer-coding-system
847 (or (ignore-errors (org-lparse-get 'CODING-SYSTEM-FOR-SAVE
))
848 (and (boundp 'buffer-file-coding-system
)
849 buffer-file-coding-system
)))
852 (if region-p
(region-beginning) (point-min))
853 (if region-p
(region-end) (point-max))))
854 (org-export-have-math nil
)
855 (org-export-footnotes-seen nil
)
856 (org-export-footnotes-data (org-footnote-all-labels 'with-defs
))
857 (org-footnote-insert-pos-for-preprocessor 'point-min
)
858 (org-lparse-opt-plist opt-plist
)
861 (org-export-preprocess-string
864 :for-backend
(if (equal org-lparse-backend
'xhtml
) ; hack
867 :skip-before-1st-heading
868 (plist-get opt-plist
:skip-before-1st-heading
)
869 :drawers
(plist-get opt-plist
:drawers
)
870 :todo-keywords
(plist-get opt-plist
:todo-keywords
)
871 :tasks
(plist-get opt-plist
:tasks
)
872 :tags
(plist-get opt-plist
:tags
)
873 :priority
(plist-get opt-plist
:priority
)
874 :footnotes
(plist-get opt-plist
:footnotes
)
875 :timestamps
(plist-get opt-plist
:timestamps
)
877 (plist-get opt-plist
:archived-trees
)
878 :select-tags
(plist-get opt-plist
:select-tags
)
879 :exclude-tags
(plist-get opt-plist
:exclude-tags
)
881 (plist-get opt-plist
:text
)
883 (plist-get opt-plist
:LaTeX-fragments
))
886 table-buffer table-orig-buffer
888 rpl path attr desc descp desc1 desc2 link
890 footnotes footref-seen
891 org-lparse-output-buffer
892 org-lparse-footnote-definitions
893 org-lparse-footnote-number
895 org-lparse-collect-buffer
896 (org-lparse-collect-count 0) ; things will get haywire if
897 ; collections are chained. Use
898 ; this variable to assert this
904 (let ((inhibit-read-only t
))
906 (remove-text-properties (point-min) (point-max)
907 '(:org-license-to-kill t
))))
909 (message "Exporting...")
910 (org-init-section-numbers)
912 ;; Switch to the output buffer
913 (setq org-lparse-output-buffer buffer
)
914 (set-buffer org-lparse-output-buffer
)
915 (let ((inhibit-read-only t
)) (erase-buffer))
917 (org-install-letbind)
919 (and (fboundp 'set-buffer-file-coding-system
)
920 (set-buffer-file-coding-system coding-system-for-write
))
922 (let ((case-fold-search nil
)
923 (org-odd-levels-only odd
))
924 ;; create local variables for all options, to make sure all called
925 ;; functions get the correct information
927 (set (make-local-variable (nth 2 x
))
928 (plist-get opt-plist
(car x
))))
929 org-export-plist-vars
)
930 (setq umax
(if arg
(prefix-numeric-value arg
)
931 org-export-headline-levels
))
932 (setq umax-toc
(if (integerp org-export-with-toc
)
933 (min org-export-with-toc umax
)
936 (when (and org-export-with-toc
(not body-only
))
937 (setq lines
(org-lparse-prepare-toc
938 lines level-offset opt-plist umax-toc
)))
941 (org-lparse-begin 'DOCUMENT-CONTENT opt-plist
)
942 (org-lparse-begin 'DOCUMENT-BODY opt-plist
))
945 (org-init-section-numbers)
947 (org-lparse-begin-paragraph)
949 (while (setq line
(pop lines
) origline line
)
951 (when (and (org-lparse-current-environment-p 'quote
)
952 (string-match org-outline-regexp-bol line
))
953 (org-lparse-end-environment 'quote
))
955 (when (org-lparse-current-environment-p 'quote
)
956 (org-lparse-insert 'LINE line
)
957 (throw 'nextline nil
))
959 ;; Fixed-width, verbatim lines (examples)
960 (when (and org-export-with-fixed-width
961 (string-match "^[ \t]*:\\(\\([ \t]\\|$\\)\\(.*\\)\\)" line
))
962 (when (not (org-lparse-current-environment-p 'fixedwidth
))
963 (org-lparse-begin-environment 'fixedwidth
))
964 (org-lparse-insert 'LINE
(match-string 3 line
))
965 (when (or (not lines
)
966 (not (string-match "^[ \t]*:\\(\\([ \t]\\|$\\)\\(.*\\)\\)"
968 (org-lparse-end-environment 'fixedwidth
))
969 (throw 'nextline nil
))
971 ;; Notes: The baseline version of org-html.el (git commit
972 ;; 3d802e), while encoutering a *line-long* protected text,
973 ;; does one of the following two things based on the state
974 ;; of the export buffer.
976 ;; 1. If a paragraph element has just been opened and
977 ;; contains only whitespace as content, insert the
978 ;; protected text as part of the previous paragraph.
980 ;; 2. If the paragraph element has already been opened and
981 ;; contains some valid content insert the protected text
982 ;; as part of the current paragraph.
986 ;; Scenario 1 mentioned above kicks in when a block of
987 ;; protected text has to be inserted enbloc. For example,
988 ;; this happens, when inserting an source or example block
989 ;; or preformatted content enclosed in #+backend,
990 ;; #+begin_bakend ... #+end_backend)
992 ;; Scenario 2 mentioned above kicks in when the protected
993 ;; text is part of a running sentence. For example this
994 ;; happens in the case of an *multiline* LaTeX equation that
995 ;; needs to be inserted verbatim.
997 ;; org-html.el in the master branch seems to do some
998 ;; jugglery by moving paragraphs around. Inorder to make
999 ;; these changes backend-agnostic introduce a new text
1000 ;; property org-native-text and impose the added semantics
1001 ;; that these protected blocks appear outside of a
1002 ;; conventional paragraph element.
1004 ;; Extra Note: Check whether org-example and org-native-text
1005 ;; are entirely equivalent.
1007 ;; Fixes bug reported by Christian Moe concerning verbatim
1009 ;; on git commit 533ba3f90250a1f25f494c390d639ea6274f235c
1010 ;; http://repo.or.cz/w/org-mode/org-jambu.git/shortlog/refs/heads/staging
1011 ;; See http://lists.gnu.org/archive/html/emacs-orgmode/2011-03/msg01379.html
1014 (when (and (get-text-property 0 'org-native-text line
)
1015 ;; Make sure it is the entire line that is protected
1016 (not (< (or (next-single-property-change
1017 0 'org-native-text line
) 10000)
1019 (let ((ind (get-text-property 0 'original-indentation line
)))
1020 (org-lparse-begin-environment 'native
)
1021 (org-lparse-insert 'LINE line
)
1023 (or (= (length (car lines
)) 0)
1025 (equal ind
(get-text-property
1026 0 'original-indentation
(car lines
))))
1027 (or (= (length (car lines
)) 0)
1028 (get-text-property 0 'org-native-text
(car lines
))))
1029 (org-lparse-insert 'LINE
(pop lines
)))
1030 (org-lparse-end-environment 'native
))
1031 (throw 'nextline nil
))
1034 (when (and (get-text-property 0 'org-protected line
)
1035 ;; Make sure it is the entire line that is protected
1036 (not (< (or (next-single-property-change
1037 0 'org-protected line
) 10000)
1039 (let ((ind (get-text-property 0 'original-indentation line
)))
1040 (org-lparse-insert 'LINE line
)
1042 (or (= (length (car lines
)) 0)
1044 (equal ind
(get-text-property
1045 0 'original-indentation
(car lines
))))
1046 (or (= (length (car lines
)) 0)
1047 (get-text-property 0 'org-protected
(car lines
))))
1048 (org-lparse-insert 'LINE
(pop lines
))))
1049 (throw 'nextline nil
))
1051 ;; Blockquotes, verse, and center
1052 (when (string-match "^ORG-\\(.+\\)-\\(START\\|END\\)$" line
)
1053 (let* ((style (intern (downcase (match-string 1 line
))))
1054 (f (cdr (assoc (match-string 2 line
)
1055 '(("START" . org-lparse-begin-environment
)
1056 ("END" . org-lparse-end-environment
))))))
1057 (when (memq style
'(blockquote verse center list-table
))
1059 (throw 'nextline nil
))))
1061 (run-hooks 'org-export-html-after-blockquotes-hook
)
1062 (when (org-lparse-current-environment-p 'verse
)
1063 (let ((i (org-get-string-indentation line
)))
1066 (let ((org-lparse-encode-pending t
))
1067 (org-lparse-format 'SPACES
(* 2 i
)))
1068 " " (org-trim line
))))
1069 (unless (string-match "\\\\\\\\[ \t]*$" line
)
1070 (setq line
(concat line
"\\\\")))))
1072 ;; make targets to anchors
1074 (while (string-match
1075 "<<<?\\([^<>]*\\)>>>?\\((INVISIBLE)\\)?[ \t]*\n?" line start
)
1077 ((get-text-property (match-beginning 1) 'org-protected line
)
1078 (setq start
(match-end 1)))
1080 (setq line
(replace-match
1081 (let ((org-lparse-encode-pending t
))
1083 'ANCHOR
"" (org-solidify-link-text
1084 (match-string 1 line
))))
1086 ((and org-export-with-toc
(equal (string-to-char line
) ?
*))
1087 ;; FIXME: NOT DEPENDENT on TOC?????????????????????
1088 (setq line
(replace-match
1089 (let ((org-lparse-encode-pending t
))
1091 'FONTIFY
(match-string 1 line
) "target"))
1092 ;; (concat "@<i>" (match-string 1 line) "@</i> ")
1095 (setq line
(replace-match
1097 (let ((org-lparse-encode-pending t
))
1099 'ANCHOR
(match-string 1 line
)
1100 (org-solidify-link-text (match-string 1 line
))
1104 (let ((org-lparse-encode-pending t
))
1105 (setq line
(org-lparse-handle-time-stamps line
)))
1107 ;; replace "&" by "&", "<" and ">" by "<" and ">"
1108 ;; handle @<..> HTML tags (replace "@>..<" by "<..>")
1109 ;; Also handle sub_superscripts and checkboxes
1110 (or (string-match org-table-hline-regexp line
)
1111 (string-match "^[ \t]*\\([+]-\\||[ ]\\)[-+ |]*[+|][ \t]*$" line
)
1112 (setq line
(org-xml-encode-org-text-skip-links line
)))
1114 (setq line
(org-lparse-format-org-link line opt-plist
))
1117 (if (and (string-match org-todo-line-regexp line
)
1118 (match-beginning 2))
1120 (substring line
0 (match-beginning 2))
1121 (org-lparse-format 'TODO
(match-string 2 line
))
1122 (substring line
(match-end 2)))))
1124 ;; Does this contain a reference to a footnote?
1125 (when org-export-with-footnotes
1127 (while (string-match "\\([^* \t].*?\\)[ \t]*\\[\\([0-9]+\\)\\]" line start
)
1128 ;; Discard protected matches not clearly identified as
1129 ;; footnote markers.
1130 (if (or (get-text-property (match-beginning 2) 'org-protected line
)
1131 (not (get-text-property (match-beginning 2) 'org-footnote line
)))
1132 (setq start
(match-end 2))
1133 (let ((n (match-string 2 line
)) refcnt a
)
1134 (if (setq a
(assoc n footref-seen
))
1136 (setcdr a
(1+ (cdr a
)))
1137 (setq refcnt
(cdr a
)))
1139 (push (cons n
1) footref-seen
))
1143 (or (match-string 1 line
) "")
1146 n
(cdr (assoc n org-lparse-footnote-definitions
))
1148 ;; If another footnote is following the
1149 ;; current one, add a separator.
1150 (if (save-match-data
1151 (string-match "\\`\\[[0-9]+\\]"
1152 (substring line
(match-end 0))))
1154 (org-lparse-get 'FOOTNOTE-SEPARATOR
))
1159 ((string-match "^\\(\\*+\\)[ \t]+\\(.*\\)" line
)
1160 ;; This is a headline
1161 (setq level
(org-tr-level (- (match-end 1) (match-beginning 1)
1163 txt
(match-string 2 line
))
1164 (if (string-match quote-re0 txt
)
1165 (setq txt
(replace-match "" t t txt
)))
1166 (if (<= level
(max umax umax-toc
))
1167 (setq head-count
(+ head-count
1)))
1168 (unless org-lparse-dyn-first-heading-pos
1169 (setq org-lparse-dyn-first-heading-pos
(point)))
1170 (org-lparse-begin-level level txt umax head-count
)
1173 (when (string-match quote-re line
)
1174 (org-lparse-begin-environment 'quote
)))
1176 ((and org-export-with-tables
1177 (string-match "^\\([ \t]*\\)\\(|\\|\\+-+\\+\\)" line
))
1178 (when (not table-open
)
1180 (setq table-open t table-buffer nil table-orig-buffer nil
))
1183 (setq table-buffer
(cons line table-buffer
)
1184 table-orig-buffer
(cons origline table-orig-buffer
))
1185 (when (or (not lines
)
1186 (not (string-match "^\\([ \t]*\\)\\(|\\|\\+-+\\+\\)"
1188 (setq table-open nil
1189 table-buffer
(nreverse table-buffer
)
1190 table-orig-buffer
(nreverse table-orig-buffer
))
1191 (org-lparse-end-paragraph)
1192 (org-lparse-insert 'TABLE table-buffer table-orig-buffer
)))
1197 ;; This line either is list item or end a list.
1198 (when (get-text-property 0 'list-item line
)
1199 (setq line
(org-lparse-export-list-line
1201 (get-text-property 0 'list-item line
)
1202 (get-text-property 0 'list-struct line
)
1203 (get-text-property 0 'list-prevs line
))))
1206 (when (string-match "^[ \t]*-\\{5,\\}[ \t]*$" line
)
1207 (with-org-lparse-preserve-paragraph-state
1208 (org-lparse-insert 'HORIZONTAL-LINE
))
1209 (throw 'nextline nil
))
1211 ;; Empty lines start a new paragraph. If hand-formatted lists
1212 ;; are not fully interpreted, lines starting with "-", "+", "*"
1213 ;; also start a new paragraph.
1214 (when (string-match "^ [-+*]-\\|^[ \t]*$" line
)
1215 (when org-lparse-footnote-number
1216 (org-lparse-end-footnote-definition org-lparse-footnote-number
)
1217 (setq org-lparse-footnote-number nil
))
1218 (org-lparse-begin-paragraph))
1220 ;; Is this the start of a footnote?
1221 (when org-export-with-footnotes
1222 (when (and (boundp 'footnote-section-tag-regexp
)
1223 (string-match (concat "^" footnote-section-tag-regexp
)
1226 (throw 'nextline nil
))
1227 (when (string-match "^[ \t]*\\[\\([0-9]+\\)\\]" line
)
1228 (org-lparse-end-paragraph)
1229 (setq org-lparse-footnote-number
(match-string 1 line
))
1230 (setq line
(replace-match "" t t line
))
1231 (org-lparse-begin-footnote-definition org-lparse-footnote-number
)))
1232 ;; Check if the line break needs to be conserved
1234 ((string-match "\\\\\\\\[ \t]*$" line
)
1235 (setq line
(replace-match
1236 (org-lparse-format 'LINE-BREAK
)
1238 (org-export-preserve-breaks
1239 (setq line
(concat line
(org-lparse-format 'LINE-BREAK
)))))
1241 ;; Check if a paragraph should be started
1243 (while (and org-lparse-par-open
1244 (string-match "\\\\par\\>" line start
))
1246 ;; Leave a space in the </p> so that the footnote matcher
1247 ;; does not see this.
1248 (if (not (get-text-property (match-beginning 0)
1249 'org-protected line
))
1250 (setq line
(replace-match "</p ><p >" t t line
)))
1251 (setq start
(match-end 0))))
1253 (org-lparse-insert 'LINE line
)))))
1255 ;; Properly close all local lists and other lists
1256 (when (org-lparse-current-environment-p 'quote
)
1257 (org-lparse-end-environment 'quote
))
1259 (org-lparse-end-level 1 umax
)
1261 ;; the </div> to close the last text-... div.
1262 (when (and (> umax
0) org-lparse-dyn-first-heading-pos
)
1263 (org-lparse-end-outline-text-or-outline))
1265 (org-lparse-end 'DOCUMENT-BODY opt-plist
)
1267 (org-lparse-end 'DOCUMENT-CONTENT
))
1269 (unless (plist-get opt-plist
:buffer-will-be-killed
)
1272 (org-lparse-end 'EXPORT
)
1274 ;; kill collection buffer
1275 (when org-lparse-collect-buffer
1276 (kill-buffer org-lparse-collect-buffer
))
1278 (goto-char (point-min))
1279 (or (org-export-push-to-kill-ring
1280 (upcase (symbol-name org-lparse-backend
)))
1281 (message "Exporting... done"))
1285 (let ((f (org-lparse-get 'SAVE-METHOD
)))
1286 (or (and f
(functionp f
) (funcall f filename opt-plist
))
1288 (or (when (and (boundp 'org-lparse-other-backend
)
1289 org-lparse-other-backend
1290 (not (equal org-lparse-backend org-lparse-other-backend
)))
1291 (let ((org-lparse-convert-process
1292 (org-lparse-get-converter org-lparse-backend
)))
1293 (when org-lparse-convert-process
1294 (org-lparse-convert buffer-file-name
1295 (symbol-name org-lparse-other-backend
)))))
1297 ((eq to-buffer
'string
)
1298 (prog1 (buffer-substring (point-min) (point-max))
1299 (kill-buffer (current-buffer))))
1300 (t (current-buffer))))))
1302 (defun org-lparse-format-table (lines olines
)
1303 "Retuns backend-specific code for org-type and table-type tables."
1305 (setq lines
(org-split-string lines
"\n")))
1306 (if (string-match "^[ \t]*|" (car lines
))
1307 ;; A normal org table
1308 (org-lparse-format-org-table lines nil
)
1309 ;; Table made by table.el
1310 (or (org-lparse-format-table-table-using-table-generate-source
1311 ;; FIXME: Need to take care of this during merge
1312 (if (eq org-lparse-backend
'xhtml
) 'html org-lparse-backend
)
1314 (not org-export-prefer-native-exporter-for-tables
))
1315 ;; We are here only when table.el table has NO col or row
1316 ;; spanning and the user prefers using org's own converter for
1317 ;; exporting of such simple table.el tables.
1318 (org-lparse-format-table-table lines
))))
1320 (defun org-lparse-table-get-colalign-info (lines)
1321 (let ((forced-aligns (org-find-text-property-in-string
1322 'org-forced-aligns
(car lines
))))
1323 (when (and forced-aligns org-table-clean-did-remove-column
)
1325 (mapcar (lambda (x) (cons (1- (car x
)) (cdr x
))) forced-aligns
)))
1329 (defvar org-lparse-table-style
)
1330 (defvar org-lparse-table-ncols
)
1331 (defvar org-lparse-table-rownum
)
1332 (defvar org-lparse-table-is-styled
)
1333 (defvar org-lparse-table-begin-marker
)
1334 (defvar org-lparse-table-num-numeric-items-per-column
)
1335 (defvar org-lparse-table-colalign-info
)
1336 (defvar org-lparse-table-colalign-vector
)
1338 ;; Following variables are defined in org-table.el
1339 (defvar org-table-number-fraction
)
1340 (defvar org-table-number-regexp
)
1341 (defun org-lparse-org-table-to-list-table (lines &optional splice
)
1342 "Convert org-table to list-table.
1343 LINES is a list of the form (ROW1 ROW2 ROW3 ...) where each
1344 element is a `string' representing a single row of org-table.
1345 Thus each ROW has vertical separators \"|\" separating the table
1346 fields. A ROW could also be a row-group separator of the form
1347 \"|---...|\". Return a list of the form (ROW1 ROW2 ROW3
1348 ...). ROW could either be symbol `:hrule' or a list of the
1349 form (FIELD1 FIELD2 FIELD3 ...) as appropriate."
1353 (while (setq line
(pop lines
))
1354 (unless (string-match "^[ \t]*|-" line
)
1355 (push (org-split-string line
"[ \t]*|[ \t]*") lines-1
))))
1357 (while (setq line
(pop lines
))
1359 ((string-match "^[ \t]*|-" line
)
1361 (push :hrule lines-1
)))
1363 (push (org-split-string line
"[ \t]*|[ \t]*") lines-1
))))))
1364 (nreverse lines-1
)))
1366 (defun org-lparse-do-format-org-table (lines &optional splice
)
1367 "Format a org-type table into backend-specific code.
1368 LINES is a list of lines. Optional argument SPLICE means, do not
1369 insert header and surrounding <table> tags, just format the lines.
1370 Optional argument NO-CSS means use XHTML attributes instead of CSS
1371 for formatting. This is required for the DocBook exporter."
1372 (require 'org-table
)
1373 ;; Get rid of hlines at beginning and end
1374 (if (string-match "^[ \t]*|-" (car lines
)) (setq lines
(cdr lines
)))
1375 (setq lines
(nreverse lines
))
1376 (if (string-match "^[ \t]*|-" (car lines
)) (setq lines
(cdr lines
)))
1377 (setq lines
(nreverse lines
))
1378 (when org-export-table-remove-special-lines
1379 ;; Check if the table has a marking column. If yes remove the
1380 ;; column and the special lines
1381 (setq lines
(org-table-clean-before-export lines
)))
1382 (let* ((caption (org-find-text-property-in-string 'org-caption
(car lines
)))
1383 (caption (and caption
(org-xml-encode-org-text caption
)))
1384 (label (org-find-text-property-in-string 'org-label
(car lines
)))
1385 (org-lparse-table-colalign-info (org-lparse-table-get-colalign-info lines
))
1386 (attributes (org-find-text-property-in-string 'org-attributes
1388 (head (and org-export-highlight-first-table-line
1390 (lambda (x) (string-match "^[ \t]*|-" x
))
1392 (setq lines
(org-lparse-org-table-to-list-table lines splice
))
1393 (org-lparse-do-format-list-table
1394 lines splice caption label attributes head org-lparse-table-colalign-info
)))
1396 (defun org-lparse-do-format-list-table (lines &optional splice
1397 caption label attributes head
1398 org-lparse-table-colalign-info
)
1399 (let* ((org-lparse-table-rownum -
1) org-lparse-table-ncols i
(cnt 0)
1401 org-lparse-table-cur-rowgrp-is-hdr
1402 org-lparse-table-rowgrp-open
1403 org-lparse-table-num-numeric-items-per-column
1404 org-lparse-table-colalign-vector n
1405 org-lparse-table-rowgrp-info
1406 org-lparse-table-begin-marker
1407 (org-lparse-table-style 'org-table
)
1408 org-lparse-table-is-styled
)
1411 (setq org-lparse-table-is-styled nil
)
1412 (while (setq line
(pop lines
))
1413 (insert (org-lparse-format-table-row line
) "\n")))
1415 (setq org-lparse-table-is-styled t
)
1416 (org-lparse-begin 'TABLE caption label attributes
)
1417 (setq org-lparse-table-begin-marker
(point))
1418 (org-lparse-begin-table-rowgroup head
)
1419 (while (setq line
(pop lines
))
1421 ((equal line
:hrule
)
1422 (org-lparse-begin-table-rowgroup))
1424 (insert (org-lparse-format-table-row line
) "\n"))))
1425 (org-lparse-end 'TABLE-ROWGROUP
)
1426 (org-lparse-end-table)))))
1428 (defun org-lparse-format-org-table (lines &optional splice
)
1430 (org-lparse-do-format-org-table lines splice
)
1431 (buffer-substring-no-properties (point-min) (point-max))))
1433 (defun org-lparse-format-list-table (lines &optional splice
)
1435 (org-lparse-do-format-list-table lines splice
)
1436 (buffer-substring-no-properties (point-min) (point-max))))
1438 (defun org-lparse-do-format-table-table (lines)
1439 "Format a table generated by table.el into backend-specific code.
1440 This conversion does *not* use `table-generate-source' from table.el.
1441 This has the advantage that Org-mode's HTML conversions can be used.
1442 But it has the disadvantage, that no cell- or row-spanning is allowed."
1443 (let (line field-buffer
1444 (org-lparse-table-cur-rowgrp-is-hdr
1445 org-export-highlight-first-table-line
)
1449 (org-lparse-table-style 'table-table
)
1450 (org-lparse-table-is-styled nil
)
1451 fields org-lparse-table-ncols i
(org-lparse-table-rownum -
1)
1452 (empty (org-lparse-format 'SPACES
1)))
1453 (org-lparse-begin 'TABLE caption label attributes
)
1454 (while (setq line
(pop lines
))
1456 ((string-match "^[ \t]*\\+-" line
)
1458 (let ((org-export-table-row-tags '("<tr>" .
"</tr>"))
1459 ;; (org-export-html-table-use-header-tags-for-first-column nil)
1461 (insert (org-lparse-format-table-row field-buffer empty
)))
1462 (setq org-lparse-table-cur-rowgrp-is-hdr nil
)
1463 (setq field-buffer nil
)))
1465 ;; Break the line into fields and store the fields
1466 (setq fields
(org-split-string line
"[ \t]*|[ \t]*"))
1468 (setq field-buffer
(mapcar
1470 (concat x
(org-lparse-format 'LINE-BREAK
)
1473 (setq field-buffer fields
)))))
1474 (org-lparse-end-table)))
1476 (defun org-lparse-format-table-table (lines)
1478 (org-lparse-do-format-table-table lines
)
1479 (buffer-substring-no-properties (point-min) (point-max))))
1481 (defvar table-source-languages
) ; defined in table.el
1482 (defun org-lparse-format-table-table-using-table-generate-source (backend
1486 "Format a table into BACKEND, using `table-generate-source' from table.el.
1487 Use SPANNED-ONLY to suppress exporting of simple table.el tables.
1489 When SPANNED-ONLY is nil, all table.el tables are exported. When
1490 SPANNED-ONLY is non-nil, only tables with either row or column
1493 This routine returns the generated source or nil as appropriate.
1495 Refer docstring of `org-export-prefer-native-exporter-for-tables'
1496 for further information."
1498 (with-current-buffer (get-buffer-create " org-tmp1 ")
1500 (insert (mapconcat 'identity lines
"\n"))
1501 (goto-char (point-min))
1502 (if (not (re-search-forward "|[^+]" nil t
))
1503 (error "Error processing table"))
1504 (table-recognize-table)
1505 (when (or (not spanned-only
)
1506 (let* ((dim (table-query-dimension))
1507 (c (nth 4 dim
)) (r (nth 5 dim
)) (cells (nth 6 dim
)))
1508 (not (= (* c r
) cells
))))
1509 (with-current-buffer (get-buffer-create " org-tmp2 ") (erase-buffer))
1511 ((member backend table-source-languages
)
1512 (table-generate-source backend
" org-tmp2 ")
1513 (set-buffer " org-tmp2 ")
1514 (buffer-substring (point-min) (point-max)))
1516 ;; table.el doesn't support the given backend. Currently this
1517 ;; happens in case of odt export. Strip the table from the
1518 ;; generated document. A better alternative would be to embed
1519 ;; the table as ascii text in the output document.
1522 "Found table.el-type table in the source org file. "
1523 (format "table.el doesn't support %s backend. "
1524 (upcase (symbol-name backend
)))
1525 "Skipping ahead ..."))
1528 (defun org-lparse-handle-time-stamps (s)
1529 "Format time stamps in string S, or remove them."
1532 (while (string-match org-maybe-keyword-time-regexp s
)
1533 (or b
(setq b
(substring s
0 (match-beginning 0))))
1535 r
(substring s
0 (match-beginning 0)) " "
1542 (match-string 1 s
) "timestamp-kwd"))
1546 (substring (org-translate-time (match-string 3 s
)) 1 -
1)
1548 "timestamp-wrapper"))
1549 s
(substring s
(match-end 0))))
1550 ;; Line break if line started and ended with time stamp stuff
1553 (setq r
(concat r s
))
1554 (unless (string-match "\\S-" (concat b s
))
1555 (setq r
(concat r
(org-lparse-format 'LINE-BREAK
))))
1558 (defun org-xml-encode-plain-text (s)
1559 "Convert plain text characters to HTML equivalent.
1560 Possible conversions are set in `org-export-html-protect-char-alist'."
1561 (let ((cl (org-lparse-get 'PLAIN-TEXT-MAP
)) c
)
1562 (while (setq c
(pop cl
))
1564 (while (string-match (car c
) s start
)
1565 (setq s
(replace-match (cdr c
) t t s
)
1566 start
(1+ (match-beginning 0))))))
1569 (defun org-xml-encode-org-text-skip-links (string)
1570 "Prepare STRING for HTML export. Apply all active conversions.
1571 If there are links in the string, don't modify these."
1572 (let* ((re (concat org-bracket-link-regexp
"\\|"
1573 (org-re "[ \t]+\\(:[[:alnum:]_@#%:]+:\\)[ \t]*$")))
1575 (while (setq m
(string-match re string
))
1576 (setq s
(substring string
0 m
)
1577 l
(match-string 0 string
)
1578 string
(substring string
(match-end 0)))
1579 (push (org-xml-encode-org-text s
) res
)
1581 (push (org-xml-encode-org-text string
) res
)
1582 (apply 'concat
(nreverse res
))))
1584 (defun org-xml-encode-org-text (s)
1585 "Apply all active conversions to translate special ASCII to HTML."
1586 (setq s
(org-xml-encode-plain-text s
))
1587 (if org-export-html-expand
1588 (while (string-match "@<\\([^&]*\\)>" s
)
1589 (setq s
(replace-match "<\\1>" t nil s
))))
1590 (if org-export-with-emphasize
1591 (setq s
(org-lparse-apply-char-styles s
)))
1592 (if org-export-with-special-strings
1593 (setq s
(org-lparse-convert-special-strings s
)))
1594 (if org-export-with-sub-superscripts
1595 (setq s
(org-lparse-apply-sub-superscript-styles s
)))
1596 (if org-export-with-TeX-macros
1597 (let ((start 0) wd rep
)
1598 (while (setq start
(string-match "\\\\\\([a-zA-Z]+[0-9]*\\)\\({}\\)?"
1600 (if (get-text-property (match-beginning 0) 'org-protected s
)
1601 (setq start
(match-end 0))
1602 (setq wd
(match-string 1 s
))
1603 (if (setq rep
(org-lparse-format 'ORG-ENTITY wd
))
1604 (setq s
(replace-match rep t t s
))
1605 (setq start
(+ start
(length wd
))))))))
1608 (defun org-lparse-convert-special-strings (string)
1609 "Convert special characters in STRING to HTML."
1610 (let ((all (org-lparse-get 'SPECIAL-STRING-REGEXPS
))
1612 (while (setq a
(pop all
))
1613 (setq re
(car a
) rpl
(cdr a
) start
0)
1614 (while (string-match re string start
)
1615 (if (get-text-property (match-beginning 0) 'org-protected string
)
1616 (setq start
(match-end 0))
1617 (setq string
(replace-match rpl t nil string
)))))
1620 (defun org-lparse-apply-sub-superscript-styles (string)
1621 "Apply subscript and superscript styles to STRING.
1622 Use `org-export-with-sub-superscripts' to control application of
1623 sub and superscript styles."
1624 (let (key c
(s 0) (requireb (eq org-export-with-sub-superscripts
'{})))
1625 (while (string-match org-match-substring-regexp string s
)
1627 ((and requireb
(match-end 8)) (setq s
(match-end 2)))
1628 ((get-text-property (match-beginning 2) 'org-protected string
)
1629 (setq s
(match-end 2)))
1631 (setq s
(match-end 1)
1632 key
(if (string= (match-string 2 string
) "_")
1633 'subscript
'superscript
)
1634 c
(or (match-string 8 string
)
1635 (match-string 6 string
)
1636 (match-string 5 string
))
1637 string
(replace-match
1638 (concat (match-string 1 string
)
1639 (org-lparse-format 'FONTIFY c key
))
1641 (while (string-match "\\\\\\([_^]\\)" string
)
1642 (setq string
(replace-match (match-string 1 string
) t t string
)))
1645 (defvar org-lparse-char-styles
1652 "Map Org emphasis markers to char styles.
1653 This is an alist where each element is of the
1654 form (ORG-EMPHASIS-CHAR . CHAR-STYLE).")
1656 (defun org-lparse-apply-char-styles (string)
1657 "Apply char styles to STRING.
1658 The variable `org-lparse-char-styles' controls how the Org
1659 emphasis markers are interpreted."
1661 (while (string-match org-emph-re string s
)
1663 (substring string
(match-beginning 3) (1+ (match-beginning 3)))
1664 (substring string
(match-beginning 4) (1+ (match-beginning 4)))))
1665 (setq s
(match-beginning 0)
1668 (match-string 1 string
)
1670 'FONTIFY
(match-string 4 string
)
1671 (nth 1 (assoc (match-string 3 string
)
1672 org-lparse-char-styles
)))
1673 (match-string 5 string
))
1674 string
(replace-match rpl t t string
)
1675 s
(+ s
(- (length rpl
) 2)))
1679 (defun org-lparse-export-list-line (line pos struct prevs
)
1680 "Insert list syntax in export buffer. Return LINE, maybe modified.
1682 POS is the item position or line position the line had before
1683 modifications to buffer. STRUCT is the list structure. PREVS is
1684 the alist of previous items."
1687 ;; Translate type of list containing POS to "d", "o" or
1689 (lambda (pos struct prevs
)
1690 (let ((type (org-list-get-list-type pos struct prevs
)))
1692 ((eq 'ordered type
) "o")
1693 ((eq 'descriptive type
) "d")
1697 ;; Return list of all items and sublists ending at POS, in
1703 (let ((end (nth 6 e
))
1706 ((= end pos
) (push item out
))
1707 ((>= item pos
) (throw 'exit nil
)))))
1710 ;; First close any previous item, or list, ending at POS.
1712 (let* ((lastp (= (org-list-get-last-item e struct prevs
) e
))
1713 (first-item (org-list-get-list-begin e struct prevs
))
1714 (type (funcall get-type first-item struct prevs
)))
1715 (org-lparse-end-paragraph)
1716 ;; Ending for every item
1717 (org-lparse-end-list-item-1 type
)
1718 ;; We're ending last item of the list: end list.
1720 (org-lparse-end-list type
)
1721 (org-lparse-begin-paragraph))))
1722 (funcall get-closings pos
))
1724 ;; At an item: insert appropriate tags in export buffer.
1727 (concat "[ \t]*\\(\\S-+[ \t]*\\)"
1728 "\\(?:\\[@\\(?:start:\\)?\\([0-9]+\\|[A-Za-z]\\)\\][ \t]*\\)?"
1729 "\\(?:\\(\\[[ X-]\\]\\)[ \t]+\\)?"
1730 "\\(?:\\(.*\\)[ \t]+::\\(?:[ \t]+\\|$\\)\\)?"
1732 (let* ((checkbox (match-string 3 line
))
1733 (desc-tag (or (match-string 4 line
) "???"))
1734 (body (or (match-string 5 line
) ""))
1735 (list-beg (org-list-get-list-begin pos struct prevs
))
1736 (firstp (= list-beg pos
))
1737 ;; Always refer to first item to determine list type, in
1738 ;; case list is ill-formed.
1739 (type (funcall get-type list-beg struct prevs
))
1740 (counter (let ((count-tmp (org-list-get-counter pos struct
)))
1742 ((not count-tmp
) nil
)
1743 ((string-match "[A-Za-z]" count-tmp
)
1744 (- (string-to-char (upcase count-tmp
)) 64))
1745 ((string-match "[0-9]+" count-tmp
)
1748 (org-lparse-end-paragraph)
1749 (org-lparse-begin-list type
))
1751 (let ((arg (cond ((equal type
"d") desc-tag
)
1752 ((equal type
"o") counter
))))
1753 (org-lparse-begin-list-item type arg
))
1755 ;; If line had a checkbox, some additional modification is required.
1763 ((string-match "X" checkbox
) "X")
1764 ((string-match " " checkbox
)
1765 (org-lparse-format 'SPACES
1))
1771 ;; Return modified line
1773 ;; At a list ender: go to next line (side-effects only).
1774 ((equal "ORG-LIST-END-MARKER" line
) (throw 'nextline nil
))
1775 ;; Not at an item: return line unchanged (side-effects only).
1778 (defun org-lparse-bind-local-variables (opt-plist)
1780 (set (make-local-variable (nth 2 x
))
1781 (plist-get opt-plist
(car x
))))
1782 org-export-plist-vars
))
1784 (defvar org-lparse-table-rowgrp-open
)
1785 (defvar org-lparse-table-cur-rowgrp-is-hdr
)
1786 (defvar org-lparse-footnote-number
)
1787 (defvar org-lparse-footnote-definitions
)
1788 (defvar org-lparse-output-buffer nil
1789 "Buffer to which `org-do-lparse' writes to.
1790 This buffer contains the contents of the to-be-created exported
1793 (defcustom org-lparse-debug nil
1794 "Enable or Disable logging of `org-lparse' callbacks.
1795 The parameters passed to the backend-registered ENTITY-CONTROL
1796 and ENTITY-FORMAT callbacks are logged as comment strings in the
1797 exported buffer. (org-lparse-format 'COMMENT fmt args) is used
1798 for logging. Customize this variable only if you are an expert
1799 user. Valid values of this variable are:
1800 nil : Disable logging
1801 control : Log all invocations of `org-lparse-begin' and
1802 `org-lparse-end' callbacks.
1803 format : Log invocations of `org-lparse-format' callbacks.
1804 t : Log all invocations of `org-lparse-begin', `org-lparse-end'
1805 and `org-lparse-format' callbacks,"
1808 (const :tag
"Disable" nil
)
1809 (const :tag
"Format callbacks" format
)
1810 (const :tag
"Control callbacks" control
)
1811 (const :tag
"Format and Control callbacks" t
)))
1813 (defun org-lparse-begin (entity &rest args
)
1814 "Begin ENTITY in current buffer. ARGS is entity specific.
1815 ENTITY can be one of PARAGRAPH, LIST, LIST-ITEM etc.
1817 Use (org-lparse-begin 'LIST \"o\") to begin a list in current
1820 See `org-xhtml-entity-control-callbacks-alist' for more
1822 (when (and (member org-lparse-debug
'(t control
))
1823 (not (eq entity
'DOCUMENT-CONTENT
)))
1824 (insert (org-lparse-format 'COMMENT
"%s BEGIN %S" entity args
)))
1826 (let ((f (cadr (assoc entity org-lparse-entity-control-callbacks-alist
))))
1827 (unless f
(error "Unknown entity: %s" entity
))
1830 (defun org-lparse-end (entity &rest args
)
1831 "Close ENTITY in current buffer. ARGS is entity specific.
1832 ENTITY can be one of PARAGRAPH, LIST, LIST-ITEM
1835 Use (org-lparse-end 'LIST \"o\") to close a list in current
1838 See `org-xhtml-entity-control-callbacks-alist' for more
1840 (when (and (member org-lparse-debug
'(t control
))
1841 (not (eq entity
'DOCUMENT-CONTENT
)))
1842 (insert (org-lparse-format 'COMMENT
"%s END %S" entity args
)))
1844 (let ((f (caddr (assoc entity org-lparse-entity-control-callbacks-alist
))))
1845 (unless f
(error "Unknown entity: %s" entity
))
1848 (defun org-lparse-begin-paragraph (&optional style
)
1849 "Insert <p>, but first close previous paragraph if any."
1850 (org-lparse-end-paragraph)
1851 (org-lparse-begin 'PARAGRAPH style
)
1852 (setq org-lparse-par-open t
))
1854 (defun org-lparse-end-paragraph ()
1855 "Close paragraph if there is one open."
1856 (when org-lparse-par-open
1857 (org-lparse-end 'PARAGRAPH
)
1858 (setq org-lparse-par-open nil
)))
1860 (defun org-lparse-end-list-item-1 (&optional type
)
1861 "Close <li> if necessary."
1862 (org-lparse-end-paragraph)
1863 (org-lparse-end-list-item (or type
"u")))
1865 (defcustom org-lparse-list-table-enable nil
1866 "Specify whether a list be exported as a table.
1867 When this option is enabled, lists that are enclosed in
1868 \"#+begin_list-table...#+end_list-table\" are exported as
1869 tables. Otherwise they are exported normally."
1873 (defun org-lparse-preprocess-after-blockquote-hook ()
1874 "Treat #+begin_list-table...#+end_list-table blocks specially.
1875 When `org-lparse-list-table-enable' is non-nil, enclose these
1876 blocks within ORG-LIST-TABLE-START...ORG-LIST-TABLE-END."
1877 (when org-lparse-list-table-enable
1878 (goto-char (point-min))
1879 (while (re-search-forward "^[ \t]*#\\+\\(begin\\|end\\)_\\(.*\\)$" nil t
)
1880 (when (string= (downcase (match-string 2)) "list-table")
1881 (replace-match (if (equal (downcase (match-string 1)) "begin")
1882 "ORG-LIST-TABLE-START"
1883 "ORG-LIST-TABLE-END") t t
)))))
1885 (add-hook 'org-export-preprocess-after-blockquote-hook
1886 'org-lparse-preprocess-after-blockquote-hook
)
1888 (defvar org-lparse-list-table-p nil
1889 "Non-nil if `org-do-lparse' is within a list-table.
1890 See `org-lparse-list-table-enable'.")
1892 (defvar org-lparse-dyn-current-environment nil
)
1893 (defun org-lparse-begin-environment (style)
1896 (setq org-lparse-list-table-p org-lparse-list-table-enable
))
1898 (setq org-lparse-dyn-current-environment style
)
1899 (org-lparse-begin 'ENVIRONMENT style
))))
1901 (defun org-lparse-end-environment (style)
1904 (setq org-lparse-list-table-p nil
))
1906 (org-lparse-end 'ENVIRONMENT style
)
1907 (setq org-lparse-dyn-current-environment nil
))))
1909 (defun org-lparse-current-environment-p (style)
1910 (eq org-lparse-dyn-current-environment style
))
1912 (defun org-lparse-begin-footnote-definition (n)
1913 (org-lparse-begin-collect)
1914 (setq org-lparse-insert-tag-with-newlines nil
)
1915 (org-lparse-begin 'FOOTNOTE-DEFINITION n
))
1917 (defun org-lparse-end-footnote-definition (n)
1918 (org-lparse-end 'FOOTNOTE-DEFINITION n
)
1919 (setq org-lparse-insert-tag-with-newlines
'both
)
1920 (let ((footnote-def (org-lparse-end-collect)))
1921 (push (cons n footnote-def
) org-lparse-footnote-definitions
)))
1923 (defvar org-lparse-collect-buffer nil
1924 "An auxiliary buffer named \"*Org Lparse Collect*\".
1925 `org-do-lparse' uses this as output buffer while collecting
1926 footnote definitions and table-cell contents of list-tables. See
1927 `org-lparse-begin-collect' and `org-lparse-end-collect'.")
1929 (defvar org-lparse-collect-count nil
1930 "Count number of calls to `org-lparse-begin-collect'.
1931 Use this counter to catch chained collections if they ever
1934 (defun org-lparse-begin-collect ()
1935 "Temporarily switch to `org-lparse-collect-buffer'.
1936 Also erase it's contents."
1937 (unless (zerop org-lparse-collect-count
)
1938 (error "FIXME (org-lparse.el): Encountered chained collections"))
1939 (incf org-lparse-collect-count
)
1940 (unless org-lparse-collect-buffer
1941 (setq org-lparse-collect-buffer
1942 (get-buffer-create "*Org Lparse Collect*")))
1943 (set-buffer org-lparse-collect-buffer
)
1946 (defun org-lparse-end-collect ()
1947 "Switch to `org-lparse-output-buffer'.
1948 Return contents of `org-lparse-collect-buffer' as a `string'."
1949 (assert (> org-lparse-collect-count
0))
1950 (decf org-lparse-collect-count
)
1951 (prog1 (buffer-string)
1953 (set-buffer org-lparse-output-buffer
)))
1955 (defun org-lparse-format (entity &rest args
)
1956 "Format ENTITY in backend-specific way and return it.
1957 ARGS is specific to entity being formatted.
1959 Use (org-lparse-format 'HEADING \"text\" 1) to format text as
1962 See `org-xhtml-entity-format-callbacks-alist' for more information."
1963 (when (and (member org-lparse-debug
'(t format
))
1964 (not (equal entity
'COMMENT
)))
1965 (insert (org-lparse-format 'COMMENT
"%s: %S" entity args
)))
1968 (let ((text (pop args
)))
1969 (apply 'org-lparse-format
'TAGS entity text args
)))
1971 (let ((f (cdr (assoc entity org-lparse-entity-format-callbacks-alist
))))
1972 (unless f
(error "Unknown entity: %s" entity
))
1975 (defun org-lparse-insert (entity &rest args
)
1976 (insert (apply 'org-lparse-format entity args
)))
1978 (defun org-lparse-prepare-toc (lines level-offset opt-plist umax-toc
)
1979 (let* ((quote-re0 (concat "^[ \t]*" org-quote-string
"\\>"))
1980 (org-min-level (org-get-min-level lines level-offset
))
1981 (org-last-level org-min-level
)
1984 (org-lparse-bind-local-variables opt-plist
)
1986 (org-lparse-begin 'TOC
(nth 3 (plist-get opt-plist
:lang-words
)))
1991 (when (and (string-match org-todo-line-regexp line
)
1992 (not (get-text-property 0 'org-protected line
))
1993 (<= (setq level
(org-tr-level
1994 (- (match-end 1) (match-beginning 1)
1997 (let ((txt (save-match-data
1998 (org-xml-encode-org-text-skip-links
1999 (org-export-cleanup-toc-line
2000 (match-string 3 line
)))))
2002 org-export-mark-todo-in-toc
2003 (or (and (match-beginning 2)
2004 (not (member (match-string 2 line
)
2005 org-done-keywords
)))
2006 (and (= level umax-toc
)
2007 (org-search-todo-below
2008 line lines level
)))))
2010 ;; Check for targets
2011 (while (string-match org-any-target-regexp line
)
2014 (let ((org-lparse-encode-pending t
))
2015 (org-lparse-format 'FONTIFY
2016 (match-string 1 line
) "target"))
2019 (org-re "[ \t]+:\\([[:alnum:]_@:]+\\):[ \t]*$") txt
)
2020 (setq tags
(match-string 1 txt
)
2021 txt
(replace-match "" t nil txt
)))
2022 (when (string-match quote-re0 txt
)
2023 (setq txt
(replace-match "" t t txt
)))
2024 (while (string-match "<\\(<\\)+\\|>\\(>\\)+" txt
)
2025 (setq txt
(replace-match "" t t txt
)))
2028 (let* ((snumber (org-section-number level
))
2029 (href (replace-regexp-in-string
2030 "\\." "-" (format "sec-%s" snumber
)))
2034 href org-export-preferred-target-alist
))
2036 (href (org-solidify-link-text href
)))
2037 (org-lparse-format 'TOC-ENTRY snumber todo txt tags href
))
2038 level org-last-level
)
2039 (setq org-last-level level
)))
2042 (org-lparse-end 'TOC
)
2043 (setq org-lparse-toc
(buffer-string))))
2046 (defun org-lparse-format-table-row (fields &optional text-for-empty-fields
)
2047 (unless org-lparse-table-ncols
2048 ;; first row of the table
2049 (setq org-lparse-table-ncols
(length fields
))
2050 (when org-lparse-table-is-styled
2051 (setq org-lparse-table-num-numeric-items-per-column
2052 (make-vector org-lparse-table-ncols
0))
2053 (setq org-lparse-table-colalign-vector
2054 (make-vector org-lparse-table-ncols nil
))
2056 (while (< (incf c
) org-lparse-table-ncols
)
2057 (let ((cookie (cdr (assoc (1+ c
) org-lparse-table-colalign-info
))))
2058 (setf (aref org-lparse-table-colalign-vector c
)
2060 ((string= cookie
"l") "left")
2061 ((string= cookie
"r") "right")
2062 ((string= cookie
"c") "center")
2064 (incf org-lparse-table-rownum
)
2070 (when (and (string= x
"") text-for-empty-fields
)
2071 (setq x text-for-empty-fields
))
2073 (and org-lparse-table-is-styled
2074 (< i org-lparse-table-ncols
)
2075 (string-match org-table-number-regexp x
)
2076 (incf (aref org-lparse-table-num-numeric-items-per-column i
)))
2077 (org-lparse-format 'TABLE-CELL x org-lparse-table-rownum i
))
2080 (defun org-lparse-get (what &optional opt-plist
)
2081 "Query for value of WHAT for the current backend `org-lparse-backend'.
2082 See also `org-lparse-backend-get'."
2083 (if (boundp 'org-lparse-backend
)
2084 (org-lparse-backend-get (symbol-name org-lparse-backend
) what opt-plist
)
2085 (error "org-lparse-backend is not bound yet")))
2087 (defun org-lparse-backend-get (backend what
&optional opt-plist
)
2088 "Query BACKEND for value of WHAT.
2089 Dispatch the call to `org-<backend>-user-get'. If that throws an
2090 error, dispatch the call to `org-<backend>-get'. See
2091 `org-xhtml-get' for all known settings queried for by
2092 `org-lparse' during the course of export."
2093 (assert (stringp backend
) t
)
2094 (unless (org-lparse-backend-is-native-p backend
)
2095 (error "Unknown native backend %s" backend
))
2096 (let ((backend-get-method (intern (format "org-%s-get" backend
)))
2097 (backend-user-get-method (intern (format "org-%s-user-get" backend
))))
2099 ((functionp backend-get-method
)
2101 (funcall backend-user-get-method what opt-plist
)
2102 (error (funcall backend-get-method what opt-plist
))))
2104 (error "Native backend %s doesn't define %s" backend backend-get-method
)))))
2106 (defun org-lparse-insert-tag (tag &rest args
)
2107 (when (member org-lparse-insert-tag-with-newlines
'(lead both
))
2109 (insert (apply 'format tag args
))
2110 (when (member org-lparse-insert-tag-with-newlines
'(trail both
))
2113 (defun org-lparse-get-targets-from-title (title)
2114 (let* ((target (org-get-text-property-any 0 'target title
))
2115 (extra-targets (assoc target org-export-target-aliases
))
2116 (target (or (cdr (assoc target org-export-preferred-target-alist
))
2118 (cons target
(remove target extra-targets
))))
2120 (defun org-lparse-suffix-from-snumber (snumber)
2121 (let* ((snu (replace-regexp-in-string "\\." "-" snumber
))
2122 (href (cdr (assoc (concat "sec-" snu
)
2123 org-export-preferred-target-alist
))))
2124 (org-solidify-link-text (or href snu
))))
2126 (defun org-lparse-begin-level (level title umax head-count
)
2127 "Insert a new LEVEL in HTML export.
2128 When TITLE is nil, just close all open levels."
2129 (org-lparse-end-level level umax
)
2130 (unless title
(error "Why is heading nil"))
2131 (let* ((targets (org-lparse-get-targets-from-title title
))
2132 (target (car targets
)) (extra-targets (cdr targets
))
2133 (target (and target
(org-solidify-link-text target
)))
2134 (extra-class (org-get-text-property-any 0 'html-container-class title
))
2135 snumber tags level1 class
)
2136 (when (string-match (org-re "\\(:[[:alnum:]_@#%:]+:\\)[ \t]*$") title
)
2137 (setq tags
(and org-export-with-tags
(match-string 1 title
)))
2138 (setq title
(replace-match "" t t title
)))
2141 (if (aref org-levels-open
(1- level
))
2142 (org-lparse-end-list-item-1)
2143 (aset org-levels-open
(1- level
) t
)
2144 (org-lparse-end-paragraph)
2145 (org-lparse-begin-list 'unordered
))
2146 (org-lparse-begin-list-item
2147 'unordered target
(org-lparse-format
2148 'HEADLINE title extra-targets tags
)))
2149 (aset org-levels-open
(1- level
) t
)
2150 (setq snumber
(org-section-number level
))
2151 (setq level1
(+ level
(or (org-lparse-get 'TOPLEVEL-HLEVEL
) 1) -
1))
2152 (unless (= head-count
1)
2153 (org-lparse-end-outline-text-or-outline))
2154 (org-lparse-begin-outline-and-outline-text
2155 level1 snumber title tags target extra-targets extra-class
)
2156 (org-lparse-begin-paragraph))))
2158 (defun org-lparse-end-level (level umax
)
2159 (org-lparse-end-paragraph)
2160 (loop for l from org-level-max downto level
2161 do
(when (aref org-levels-open
(1- l
))
2162 ;; Terminate one level in HTML export
2164 (org-lparse-end-outline-text-or-outline)
2165 (org-lparse-end-list-item-1)
2166 (org-lparse-end-list 'unordered
))
2167 (aset org-levels-open
(1- l
) nil
))))
2169 (defvar org-lparse-outline-text-open
)
2170 (defun org-lparse-begin-outline-and-outline-text (level1 snumber title tags
2171 target extra-targets
2174 'OUTLINE level1 snumber title tags target extra-targets extra-class
)
2175 (org-lparse-begin-outline-text level1 snumber extra-class
))
2177 (defun org-lparse-end-outline-text-or-outline ()
2179 (org-lparse-outline-text-open
2180 (org-lparse-end 'OUTLINE-TEXT
)
2181 (setq org-lparse-outline-text-open nil
))
2182 (t (org-lparse-end 'OUTLINE
))))
2184 (defun org-lparse-begin-outline-text (level1 snumber extra-class
)
2185 (assert (not org-lparse-outline-text-open
) t
)
2186 (setq org-lparse-outline-text-open t
)
2187 (org-lparse-begin 'OUTLINE-TEXT level1 snumber extra-class
))
2189 (defun org-lparse-html-list-type-to-canonical-list-type (ltype)
2190 (cdr (assoc ltype
'(("o" . ordered
)
2192 ("d" . description
)))))
2194 (defvar org-lparse-list-level
) ; dynamically bound in org-do-lparse
2195 (defun org-lparse-begin-list (ltype)
2196 (incf org-lparse-list-level
)
2197 (org-lparse-begin 'LIST ltype
))
2199 (defun org-lparse-end-list (ltype)
2200 (decf org-lparse-list-level
)
2201 (org-lparse-end 'LIST ltype
))
2203 (defun org-lparse-begin-list-item (ltype &optional arg headline
)
2204 (org-lparse-begin 'LIST-ITEM ltype arg headline
))
2206 (defun org-lparse-end-list-item (ltype)
2207 (org-lparse-end 'LIST-ITEM ltype
))
2209 (defvar org-lparse-table-rowgrp-info
)
2210 (defun org-lparse-begin-table-rowgroup (&optional is-header-row
)
2211 (push (cons (1+ org-lparse-table-rownum
) :start
) org-lparse-table-rowgrp-info
)
2212 (org-lparse-begin 'TABLE-ROWGROUP is-header-row
))
2214 (defun org-lparse-end-table ()
2215 (when org-lparse-table-is-styled
2217 (unless (car org-table-colgroup-info
)
2218 (setq org-table-colgroup-info
2219 (cons :start
(cdr org-table-colgroup-info
))))
2226 (setf (aref org-lparse-table-colalign-vector c
)
2227 (or (aref org-lparse-table-colalign-vector c
)
2228 (if (> (/ (float x
) (1+ org-lparse-table-rownum
))
2229 org-table-number-fraction
)
2231 org-lparse-table-num-numeric-items-per-column
)))
2232 (org-lparse-end 'TABLE
))
2234 (defvar org-lparse-encode-pending nil
)
2236 (defun org-lparse-format-tags (tag text prefix suffix
&rest args
)
2239 (concat prefix
(apply 'format
(car tag
) args
) text suffix
2240 (format (cdr tag
))))
2241 ((stringp tag
) ; singleton tag
2242 (concat prefix
(apply 'format tag args
) text
))))
2244 (defun org-xml-fix-class-name (kwd) ; audit callers of this function
2245 "Turn todo keyword into a valid class name.
2246 Replaces invalid characters with \"_\"."
2248 (while (string-match "[^a-zA-Z0-9_]" kwd
)
2249 (setq kwd
(replace-match "_" t t kwd
))))
2252 (defun org-lparse-format-todo (todo)
2253 (org-lparse-format 'FONTIFY
2255 (ignore-errors (org-lparse-get 'TODO-KWD-CLASS-PREFIX
))
2256 (org-xml-fix-class-name todo
))
2257 (list (if (member todo org-done-keywords
) "done" "todo")
2260 (defun org-lparse-format-extra-targets (extra-targets)
2261 (if (not extra-targets
) ""
2262 (mapconcat (lambda (x)
2263 (setq x
(org-solidify-link-text
2264 (if (org-uuidgen-p x
) (concat "ID-" x
) x
)))
2265 (org-lparse-format 'ANCHOR
"" x
))
2268 (defun org-lparse-format-org-tags (tags)
2276 (ignore-errors (org-lparse-get 'TAG-CLASS-PREFIX
))
2277 (org-xml-fix-class-name x
))))
2278 (org-split-string tags
":")
2279 (org-lparse-format 'SPACES
1)) "tag")))
2281 (defun org-lparse-format-section-number (&optional snumber level
)
2282 (and org-export-with-section-numbers
2283 (not org-lparse-body-only
) snumber level
2284 (org-lparse-format 'FONTIFY snumber
(format "section-number-%d" level
))))
2286 (defun org-lparse-warn (msg)
2287 (if (not org-lparse-use-flashy-warning
)
2289 (put-text-property 0 (length msg
) 'face
'font-lock-warning-face msg
)
2293 (defun org-xml-format-href (s)
2294 "Make sure the S is valid as a href reference in an XHTML document."
2297 (while (string-match "&" s start
)
2298 (setq start
(+ (match-beginning 0) 3)
2299 s
(replace-match "&" t t s
)))))
2302 (defun org-xml-format-desc (s)
2303 "Make sure the S is valid as a description in a link."
2304 (if (and s
(not (get-text-property 1 'org-protected s
)))
2306 (org-xml-encode-org-text s
))
2309 (provide 'org-lparse
)
2311 ;;; org-lparse.el ends here
