lisp/org-lparse.el

   1 ;;; org-lparse.el --- Line-oriented parser-exporter for Org-mode
   2
   3 ;; Copyright (C) 2010-2012 Free Software Foundation, Inc.
   4
   5 ;; Author: Jambunathan K <kjambunathan at gmail dot com>
   6 ;; Keywords: outlines, hypermedia, calendar, wp
   7 ;; Homepage: http://orgmode.org
   8
   9 ;; This file is part of GNU Emacs.
  10
  11 ;; GNU Emacs is free software: you can redistribute it and/or modify
  12 ;; it under the terms of the GNU General Public License as published by
  13 ;; the Free Software Foundation, either version 3 of the License, or
  14 ;; (at your option) any later version.
  15
  16 ;; GNU Emacs is distributed in the hope that it will be useful,
  17 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  18 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19 ;; GNU General Public License for more details.
  20
  21 ;; You should have received a copy of the GNU General Public License
  22 ;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
  23
  24 ;;; Commentary:
  25
  26 ;; `org-lparse' is the entry point for the generic line-oriented
  27 ;; exporter.  `org-do-lparse' is the genericized version of the
  28 ;; original `org-export-as-html' routine.
  29
  30 ;; `org-lparse-native-backends' is a good starting point for
  31 ;; exploring the generic exporter.
  32
  33 ;; Following new interactive commands are provided by this library.
  34 ;; `org-lparse', `org-lparse-and-open', `org-lparse-to-buffer'
  35 ;; `org-replace-region-by', `org-lparse-region'.
  36
  37 ;; Note that the above routines correspond to the following routines
  38 ;; in the html exporter `org-export-as-html',
  39 ;; `org-export-as-html-and-open', `org-export-as-html-to-buffer',
  40 ;; `org-replace-region-by-html' and `org-export-region-as-html'.
  41
  42 ;; The new interactive command `org-lparse-convert' can be used to
  43 ;; convert documents between various formats.  Use this to command,
  44 ;; for example, to convert odt file to doc or pdf format.
  45
  46 ;;; Code:
  47 (eval-when-compile
  48   (require 'cl))
  49 (require 'org-exp)
  50 (require 'org-list)
  51 (require 'format-spec)
  52
  53 ;;;###autoload
  54 (defun org-lparse-and-open (target-backend native-backend arg
  55                                            &optional file-or-buf)
  56   "Export outline to TARGET-BACKEND via NATIVE-BACKEND and open exported file.
  57 If there is an active region, export only the region.  The prefix
  58 ARG specifies how many levels of the outline should become
  59 headlines.  The default is 3.  Lower levels will become bulleted
  60 lists."
  61   (let (f (file-or-buf (or file-or-buf
  62                            (org-lparse target-backend native-backend
  63                                        arg 'hidden))))
  64     (when file-or-buf
  65       (setq f (cond
  66                ((bufferp file-or-buf) buffer-file-name)
  67                ((file-exists-p file-or-buf) file-or-buf)
  68                (t (error "org-lparse-and-open: This shouldn't happen"))))
  69       (message "Opening file %s" f)
  70       (org-open-file f 'system)
  71       (when org-export-kill-product-buffer-when-displayed
  72         (kill-buffer (current-buffer))))))
  73
  74 ;;;###autoload
  75 (defun org-lparse-batch (target-backend &optional native-backend)
  76   "Call the function `org-lparse'.
  77 This function can be used in batch processing as:
  78 emacs   --batch
  79         --load=$HOME/lib/emacs/org.el
  80         --eval \"(setq org-export-headline-levels 2)\"
  81         --visit=MyFile --funcall org-lparse-batch"
  82   (setq native-backend (or native-backend target-backend))
  83   (org-lparse target-backend native-backend
  84               org-export-headline-levels 'hidden))
  85
  86 ;;;###autoload
  87 (defun org-lparse-to-buffer (backend arg)
  88   "Call `org-lparse' with output to a temporary buffer.
  89 No file is created.  The prefix ARG is passed through to
  90 `org-lparse'."
  91   (let ((tempbuf (format "*Org %s Export*" (upcase backend))))
  92     (org-lparse backend backend arg nil nil tempbuf)
  93     (when org-export-show-temporary-export-buffer
  94       (switch-to-buffer-other-window tempbuf))))
  95
  96 ;;;###autoload
  97 (defun org-replace-region-by (backend beg end)
  98   "Assume the current region has org-mode syntax, and convert it to HTML.
  99 This can be used in any buffer.  For example, you could write an
 100 itemized list in org-mode syntax in an HTML buffer and then use
 101 this command to convert it."
 102   (let (reg backend-string buf pop-up-frames)
 103     (save-window-excursion
 104       (if (derived-mode-p 'org-mode)
 105           (setq backend-string (org-lparse-region backend beg end t 'string))
 106         (setq reg (buffer-substring beg end)
 107               buf (get-buffer-create "*Org tmp*"))
 108         (with-current-buffer buf
 109           (erase-buffer)
 110           (insert reg)
 111           (org-mode)
 112           (setq backend-string (org-lparse-region backend (point-min)
 113                                                   (point-max) t 'string)))
 114         (kill-buffer buf)))
 115     (delete-region beg end)
 116     (insert backend-string)))
 117
 118 ;;;###autoload
 119 (defun org-lparse-region (backend beg end &optional body-only buffer)
 120   "Convert region from BEG to END in org-mode buffer to HTML.
 121 If prefix arg BODY-ONLY is set, omit file header, footer, and table of
 122 contents, and only produce the region of converted text, useful for
 123 cut-and-paste operations.
 124 If BUFFER is a buffer or a string, use/create that buffer as a target
 125 of the converted HTML.  If BUFFER is the symbol `string', return the
 126 produced HTML as a string and leave not buffer behind.  For example,
 127 a Lisp program could call this function in the following way:
 128
 129   (setq html (org-lparse-region \"html\" beg end t 'string))
 130
 131 When called interactively, the output buffer is selected, and shown
 132 in a window.  A non-interactive call will only return the buffer."
 133   (let ((transient-mark-mode t) (zmacs-regions t)
 134         ext-plist rtn)
 135     (setq ext-plist (plist-put ext-plist :ignore-subtree-p t))
 136     (goto-char end)
 137     (set-mark (point)) ;; to activate the region
 138     (goto-char beg)
 139     (setq rtn (org-lparse backend backend nil nil ext-plist buffer body-only))
 140     (if (fboundp 'deactivate-mark) (deactivate-mark))
 141     (if (and (org-called-interactively-p 'any) (bufferp rtn))
 142         (switch-to-buffer-other-window rtn)
 143       rtn)))
 144
 145 (defvar org-lparse-par-open nil)
 146
 147 (defun org-lparse-should-inline-p (filename descp)
 148   "Return non-nil if link FILENAME should be inlined.
 149 The decision to inline the FILENAME link is based on the current
 150 settings.  DESCP is the boolean of whether there was a link
 151 description.  See variables `org-export-html-inline-images' and
 152 `org-export-html-inline-image-extensions'."
 153   (let ((inline-images (org-lparse-get 'INLINE-IMAGES))
 154         (inline-image-extensions
 155          (org-lparse-get 'INLINE-IMAGE-EXTENSIONS)))
 156     (and (or (eq t inline-images) (and inline-images (not descp)))
 157          (org-file-image-p filename inline-image-extensions))))
 158
 159 (defun org-lparse-format-org-link (line opt-plist)
 160   "Return LINE with markup of Org mode links.
 161 OPT-PLIST is the export options list."
 162   (let ((start 0)
 163         (current-dir (if buffer-file-name
 164                          (file-name-directory buffer-file-name)
 165                        default-directory))
 166         (link-validate (plist-get opt-plist :link-validation-function))
 167         type id-file fnc
 168         rpl path attr desc descp desc1 desc2 link
 169         org-lparse-link-description-is-image)
 170     (while (string-match org-bracket-link-analytic-regexp++ line start)
 171       (setq org-lparse-link-description-is-image nil)
 172       (setq start (match-beginning 0))
 173       (setq path (save-match-data (org-link-unescape
 174                                    (match-string 3 line))))
 175       (setq type (cond
 176                   ((match-end 2) (match-string 2 line))
 177                   ((save-match-data
 178                      (or (file-name-absolute-p path)
 179                          (string-match "^\\.\\.?/" path)))
 180                    "file")
 181                   (t "internal")))
 182       (setq path (org-extract-attributes path))
 183       (setq attr (get-text-property 0 'org-attributes path))
 184       (setq desc1 (if (match-end 5) (match-string 5 line))
 185             desc2 (if (match-end 2) (concat type ":" path) path)
 186             descp (and desc1 (not (equal desc1 desc2)))
 187             desc (or desc1 desc2))
 188       ;; Make an image out of the description if that is so wanted
 189       (when (and descp (org-file-image-p
 190                         desc (org-lparse-get 'INLINE-IMAGE-EXTENSIONS)))
 191         (setq org-lparse-link-description-is-image t)
 192         (save-match-data
 193           (if (string-match "^file:" desc)
 194               (setq desc (substring desc (match-end 0)))))
 195         (save-match-data
 196           (setq desc (org-add-props
 197                          (org-lparse-format 'INLINE-IMAGE desc)
 198                          '(org-protected t)))))
 199       (cond
 200        ((equal type "internal")
 201         (let
 202             ((frag-0
 203               (if (= (string-to-char path) ?#)
 204                   (substring path 1)
 205                 path)))
 206           (setq rpl
 207                 (org-lparse-format
 208                  'ORG-LINK opt-plist "" "" (org-solidify-link-text
 209                                             (save-match-data
 210                                               (org-link-unescape frag-0))
 211                                             nil) desc attr descp))))
 212        ((and (equal type "id")
 213              (setq id-file (org-id-find-id-file path)))
 214         ;; This is an id: link to another file (if it was the same file,
 215         ;; it would have become an internal link...)
 216         (save-match-data
 217           (setq id-file (file-relative-name
 218                          id-file
 219                          (file-name-directory org-current-export-file)))
 220           (setq rpl
 221                 (org-lparse-format
 222                  'ORG-LINK opt-plist type id-file
 223                  (concat (if (org-uuidgen-p path) "ID-") path)
 224                  desc attr descp))))
 225        ((member type '("http" "https"))
 226         ;; standard URL, can inline as image
 227         (setq rpl
 228               (org-lparse-format
 229                'ORG-LINK opt-plist type path nil desc attr descp)))
 230        ((member type '("ftp" "mailto" "news"))
 231         ;; standard URL, can't inline as image
 232         (setq rpl
 233               (org-lparse-format
 234                'ORG-LINK opt-plist type path nil desc attr descp)))
 235
 236        ((string= type "coderef")
 237         (setq rpl (org-lparse-format
 238                    'ORG-LINK opt-plist type "" path desc nil descp)))
 239
 240        ((functionp (setq fnc (nth 2 (assoc type org-link-protocols))))
 241         ;; The link protocol has a function for format the link
 242         (setq rpl (save-match-data
 243                     (funcall fnc (org-link-unescape path)
 244                              desc1 (and (boundp 'org-lparse-backend)
 245                                         (case org-lparse-backend
 246                                           (xhtml 'html)
 247                                           (t org-lparse-backend)))))))
 248        ((string= type "file")
 249         ;; FILE link
 250         (save-match-data
 251           (let*
 252               ((components
 253                 (if
 254                     (string-match "::\\(.*\\)" path)
 255                     (list
 256                      (replace-match "" t nil path)
 257                      (match-string 1 path))
 258                   (list path nil)))
 259
 260                ;;The proper path, without a fragment
 261                (path-1
 262                 (first components))
 263
 264                ;;The raw fragment
 265                (fragment-0
 266                 (second components))
 267
 268                ;;Check the fragment.  If it can't be used as
 269                ;;target fragment we'll pass nil instead.
 270                (fragment-1
 271                 (if
 272                     (and fragment-0
 273                          (not (string-match "^[0-9]*$" fragment-0))
 274                          (not (string-match "^\\*" fragment-0))
 275                          (not (string-match "^/.*/$" fragment-0)))
 276                     (org-solidify-link-text
 277                      (org-link-unescape fragment-0))
 278                   nil))
 279                (desc-2
 280                 ;;Description minus "file:" and ".org"
 281                 (if (string-match "^file:" desc)
 282                     (let
 283                         ((desc-1 (replace-match "" t t desc)))
 284                       (if (string-match "\\.org$" desc-1)
 285                           (replace-match "" t t desc-1)
 286                         desc-1))
 287                   desc)))
 288
 289             (setq rpl
 290                   (if
 291                       (and
 292                        (functionp link-validate)
 293                        (not (funcall link-validate path-1 current-dir)))
 294                       desc
 295                     (org-lparse-format
 296                      'ORG-LINK opt-plist "file" path-1 fragment-1
 297                      desc-2 attr descp))))))
 298
 299        (t
 300         ;; just publish the path, as default
 301         (setq rpl (concat "<i>&lt;" type ":"
 302                           (save-match-data (org-link-unescape path))
 303                           "&gt;</i>"))))
 304       (setq line (replace-match rpl t t line)
 305             start (+ start (length rpl))))
 306     line))
 307
 308 (defvar org-lparse-par-open-stashed)    ; bound during `org-do-lparse'
 309 (defun org-lparse-stash-save-paragraph-state ()
 310   (assert (zerop org-lparse-par-open-stashed))
 311   (setq org-lparse-par-open-stashed org-lparse-par-open)
 312   (setq org-lparse-par-open nil))
 313
 314 (defun org-lparse-stash-pop-paragraph-state ()
 315   (setq org-lparse-par-open org-lparse-par-open-stashed)
 316   (setq org-lparse-par-open-stashed 0))
 317
 318 (defmacro with-org-lparse-preserve-paragraph-state (&rest body)
 319   `(let ((org-lparse-do-open-par org-lparse-par-open))
 320      (org-lparse-end-paragraph)
 321      ,@body
 322      (when org-lparse-do-open-par
 323        (org-lparse-begin-paragraph))))
 324 (def-edebug-spec with-org-lparse-preserve-paragraph-state (body))
 325
 326 (defvar org-lparse-native-backends nil
 327   "List of native backends registered with `org-lparse'.
 328 A backend can use `org-lparse-register-backend' to add itself to
 329 this list.
 330
 331 All native backends must implement a get routine and a mandatory
 332 set of callback routines.
 333
 334 The get routine must be named as org-<backend>-get where backend
 335 is the name of the backend.  The exporter uses `org-lparse-get'
 336 and retrieves the backend-specific callback by querying for
 337 ENTITY-CONTROL and ENTITY-FORMAT variables.
 338
 339 For the sake of illustration, the html backend implements
 340 `org-xhtml-get'.  It returns
 341 `org-xhtml-entity-control-callbacks-alist' and
 342 `org-xhtml-entity-format-callbacks-alist' as the values of
 343 ENTITY-CONTROL and ENTITY-FORMAT settings.")
 344
 345 (defun org-lparse-register-backend (backend)
 346   "Make BACKEND known to `org-lparse' library.
 347 Add BACKEND to `org-lparse-native-backends'."
 348   (when backend
 349     (setq backend (cond
 350                    ((symbolp backend) (symbol-name backend))
 351                    ((stringp backend) backend)
 352                    (t (error "Error while registering backend: %S" backend))))
 353     (add-to-list 'org-lparse-native-backends backend)))
 354
 355 (defun org-lparse-unregister-backend (backend)
 356   (setq org-lparse-native-backends
 357         (remove (cond
 358                  ((symbolp backend) (symbol-name backend))
 359                  ((stringp backend) backend))
 360                 org-lparse-native-backends))
 361   (message "Unregistered backend %S" backend))
 362
 363 (defun org-lparse-do-reachable-formats (in-fmt)
 364   "Return verbose info about formats to which IN-FMT can be converted.
 365 Return a list where each element is of the
 366 form (CONVERTER-PROCESS . OUTPUT-FMT-ALIST).  See
 367 `org-export-odt-convert-processes' for CONVERTER-PROCESS and see
 368 `org-export-odt-convert-capabilities' for OUTPUT-FMT-ALIST."
 369   (let (reachable-formats)
 370     (dolist (backend org-lparse-native-backends reachable-formats)
 371       (let* ((converter (org-lparse-backend-get
 372                          backend 'CONVERT-METHOD))
 373              (capabilities (org-lparse-backend-get
 374                             backend 'CONVERT-CAPABILITIES)))
 375         (when converter
 376           (dolist (c capabilities)
 377             (when (member in-fmt (nth 1 c))
 378               (push (cons converter (nth 2 c)) reachable-formats))))))))
 379
 380 (defun org-lparse-reachable-formats (in-fmt)
 381   "Return list of formats to which IN-FMT can be converted.
 382 The list of the form (OUTPUT-FMT-1 OUTPUT-FMT-2 ...)."
 383   (let (l)
 384     (mapc (lambda (e) (add-to-list 'l e))
 385           (apply 'append (mapcar
 386                           (lambda (e) (mapcar 'car (cdr e)))
 387                           (org-lparse-do-reachable-formats in-fmt))))
 388     l))
 389
 390 (defun org-lparse-reachable-p (in-fmt out-fmt)
 391   "Return non-nil if IN-FMT can be converted to OUT-FMT."
 392   (catch 'done
 393     (let ((reachable-formats (org-lparse-do-reachable-formats in-fmt)))
 394       (dolist (e reachable-formats)
 395         (let ((out-fmt-spec (assoc out-fmt (cdr e))))
 396           (when out-fmt-spec
 397             (throw 'done (cons (car e) out-fmt-spec))))))))
 398
 399 (defun org-lparse-backend-is-native-p (backend)
 400   (member backend org-lparse-native-backends))
 401
 402 (defun org-lparse (target-backend native-backend arg
 403                                   &optional hidden ext-plist
 404                                   to-buffer body-only pub-dir)
 405   "Export the outline to various formats.
 406 If there is an active region, export only the region.  The
 407 outline is first exported to NATIVE-BACKEND and optionally
 408 converted to TARGET-BACKEND.  See `org-lparse-native-backends'
 409 for list of known native backends.  Each native backend can
 410 specify a converter and list of target backends it exports to
 411 using the CONVERT-PROCESS and OTHER-BACKENDS settings of it's get
 412 method.  See `org-xhtml-get' for an illustrative example.
 413
 414 ARG is a prefix argument that specifies how many levels of
 415 outline should become headlines.  The default is 3.  Lower levels
 416 will become bulleted lists.
 417
 418 HIDDEN is obsolete and does nothing.
 419
 420 EXT-PLIST is a property list that controls various aspects of
 421 export.  The settings here override org-mode's default settings
 422 and but are inferior to file-local settings.
 423
 424 TO-BUFFER dumps the exported lines to a buffer or a string
 425 instead of a file.  If TO-BUFFER is the symbol `string' return the
 426 exported lines as a string.  If TO-BUFFER is non-nil, create a
 427 buffer with that name and export to that buffer.
 428
 429 BODY-ONLY controls the presence of header and footer lines in
 430 exported text.  If BODY-ONLY is non-nil, don't produce the file
 431 header and footer, simply return the content of <body>...</body>,
 432 without even the body tags themselves.
 433
 434 PUB-DIR specifies the publishing directory."
 435   (let* ((org-lparse-backend (intern native-backend))
 436          (org-lparse-other-backend (and target-backend
 437                                         (intern target-backend))))
 438     (add-hook 'org-export-preprocess-hook
 439               'org-lparse-strip-experimental-blocks-maybe)
 440     (add-hook 'org-export-preprocess-after-blockquote-hook
 441               'org-lparse-preprocess-after-blockquote)
 442     (unless (org-lparse-backend-is-native-p native-backend)
 443       (error "Don't know how to export natively to backend %s" native-backend))
 444
 445     (unless (or (equal native-backend target-backend)
 446                 (org-lparse-reachable-p native-backend target-backend))
 447       (error "Don't know how to export to backend %s %s" target-backend
 448              (format "via %s" native-backend)))
 449     (run-hooks 'org-export-first-hook)
 450     (org-do-lparse arg hidden ext-plist to-buffer body-only pub-dir)
 451     (remove-hook 'org-export-preprocess-hook
 452                  'org-lparse-strip-experimental-blocks-maybe)
 453     (remove-hook 'org-export-preprocess-after-blockquote-hook
 454                  'org-lparse-preprocess-after-blockquote)))
 455
 456 (defcustom org-lparse-use-flashy-warning nil
 457   "Control flashing of messages logged with `org-lparse-warn'.
 458 When non-nil, messages are fontified with warning face and the
 459 exporter lingers for a while to catch user's attention."
 460   :type 'boolean
 461   :group 'org-lparse)
 462
 463 (defun org-lparse-convert-read-params ()
 464   "Return IN-FILE and OUT-FMT params for `org-lparse-do-convert'.
 465 This is a helper routine for interactive use."
 466   (let* ((input (if (featurep 'ido) 'ido-completing-read 'completing-read))
 467          (in-file (read-file-name "File to be converted: "
 468                                   nil buffer-file-name t))
 469          (in-fmt (file-name-extension in-file))
 470          (out-fmt-choices (org-lparse-reachable-formats in-fmt))
 471          (out-fmt
 472           (or (and out-fmt-choices
 473                    (funcall input "Output format:  "
 474                             out-fmt-choices nil nil nil))
 475               (error
 476                "No known converter or no known output formats for %s files"
 477                in-fmt))))
 478     (list in-file out-fmt)))
 479
 480 (eval-when-compile
 481   (require 'browse-url))
 482
 483 (defun org-lparse-do-convert (in-file out-fmt &optional prefix-arg)
 484   "Workhorse routine for `org-export-odt-convert'."
 485   (require 'browse-url)
 486   (let* ((in-file (expand-file-name (or in-file buffer-file-name)))
 487          (dummy (or (file-readable-p in-file)
 488                     (error "Cannot read %s" in-file)))
 489          (in-fmt (file-name-extension in-file))
 490          (out-fmt (or out-fmt (error "Output format unspecified")))
 491          (how (or (org-lparse-reachable-p in-fmt out-fmt)
 492                   (error "Cannot convert from %s format to %s format?"
 493                          in-fmt out-fmt)))
 494          (convert-process (car how))
 495          (out-file (concat (file-name-sans-extension in-file) "."
 496                            (nth 1 (or (cdr how) out-fmt))))
 497          (extra-options (or (nth 2 (cdr how)) ""))
 498          (out-dir (file-name-directory in-file))
 499          (cmd (format-spec convert-process
 500                            `((?i . ,(shell-quote-argument in-file))
 501                              (?I . ,(browse-url-file-url in-file))
 502                              (?f . ,out-fmt)
 503                              (?o . ,out-file)
 504                              (?O . ,(browse-url-file-url out-file))
 505                              (?d . , (shell-quote-argument out-dir))
 506                              (?D . ,(browse-url-file-url out-dir))
 507                              (?x . ,extra-options)))))
 508     (when (file-exists-p out-file)
 509       (delete-file out-file))
 510
 511     (message "Executing %s" cmd)
 512     (let ((cmd-output (shell-command-to-string cmd)))
 513       (message "%s" cmd-output))
 514
 515     (cond
 516      ((file-exists-p out-file)
 517       (message "Exported to %s" out-file)
 518       (when prefix-arg
 519         (message "Opening %s..."  out-file)
 520         (org-open-file out-file 'system))
 521       out-file)
 522      (t
 523       (message "Export to %s failed" out-file)
 524       nil))))
 525
 526 (defvar org-lparse-insert-tag-with-newlines 'both)
 527
 528 ;; Following variables are let-bound during `org-lparse'
 529 (defvar org-lparse-dyn-first-heading-pos)
 530 (defvar org-lparse-toc)
 531 (defvar org-lparse-entity-control-callbacks-alist)
 532 (defvar org-lparse-entity-format-callbacks-alist)
 533 (defvar org-lparse-backend nil
 534   "The native backend to which the document is currently exported.
 535 This variable is let bound during `org-lparse'.  Valid values are
 536 one of the symbols corresponding to `org-lparse-native-backends'.
 537
 538 Compare this variable with `org-export-current-backend' which is
 539 bound only during `org-export-preprocess-string' stage of the
 540 export process.
 541
 542 See also `org-lparse-other-backend'.")
 543
 544 (defvar org-lparse-other-backend nil
 545   "The target backend to which the document is currently exported.
 546 This variable is let bound during `org-lparse'.  This variable is
 547 set to either `org-lparse-backend' or one of the symbols
 548 corresponding to OTHER-BACKENDS specification of the
 549 org-lparse-backend.
 550
 551 For example, if a document is exported to \"odt\" then both
 552 org-lparse-backend and org-lparse-other-backend are bound to
 553 'odt.  On the other hand, if a document is exported to \"odt\"
 554 and then converted to \"doc\" then org-lparse-backend is set to
 555 'odt and org-lparse-other-backend is set to 'doc.")
 556
 557 (defvar org-lparse-body-only nil
 558   "Bind this to BODY-ONLY arg of `org-lparse'.")
 559
 560 (defvar org-lparse-to-buffer nil
 561   "Bind this to TO-BUFFER arg of `org-lparse'.")
 562
 563 (defun org-lparse-get-block-params (params)
 564   (save-match-data
 565     (when params
 566       (setq params (org-trim params))
 567       (unless (string-match "\\`(.*)\\'" params)
 568         (setq params (format "(%s)" params)))
 569       (ignore-errors (read params)))))
 570
 571 (defvar org-heading-keyword-regexp-format) ; defined in org.el
 572 (defvar org-lparse-special-blocks '("list-table" "annotation"))
 573 (defun org-do-lparse (arg &optional hidden ext-plist
 574                           to-buffer body-only pub-dir)
 575   "Export the outline to various formats.
 576 See `org-lparse' for more information.  This function is a
 577 html-agnostic version of the `org-export-as-html' function in 7.5
 578 version."
 579   ;; Make sure we have a file name when we need it.
 580   (when (and (not (or to-buffer body-only))
 581              (not buffer-file-name))
 582     (if (buffer-base-buffer)
 583         (org-set-local 'buffer-file-name
 584                        (with-current-buffer (buffer-base-buffer)
 585                          buffer-file-name))
 586       (error "Need a file name to be able to export")))
 587
 588   (org-lparse-warn
 589    (format "Exporting to %s using org-lparse..."
 590            (upcase (symbol-name
 591                     (or org-lparse-backend org-lparse-other-backend)))))
 592
 593   (setq-default org-todo-line-regexp org-todo-line-regexp)
 594   (setq-default org-deadline-line-regexp org-deadline-line-regexp)
 595   (setq-default org-done-keywords org-done-keywords)
 596   (setq-default org-maybe-keyword-time-regexp org-maybe-keyword-time-regexp)
 597   (let* (hfy-user-sheet-assoc           ; let `htmlfontify' know that
 598                                         ; we are interested in
 599                                         ; collecting styles
 600          org-lparse-encode-pending
 601          org-lparse-par-open
 602          (org-lparse-par-open-stashed 0)
 603
 604          ;; list related vars
 605          (org-lparse-list-stack '())
 606
 607          ;; list-table related vars
 608          org-lparse-list-table-p
 609          org-lparse-list-table:table-cell-open
 610          org-lparse-list-table:table-row
 611          org-lparse-list-table:lines
 612
 613          org-lparse-outline-text-open
 614          (org-lparse-latex-fragment-fallback ; currently used only by
 615                                         ; odt exporter
 616           (or (ignore-errors (org-lparse-get 'LATEX-FRAGMENT-FALLBACK))
 617               (if (and (org-check-external-command "latex" "" t)
 618                        (org-check-external-command "dvipng" "" t))
 619                   'dvipng
 620                 'verbatim)))
 621          (org-lparse-insert-tag-with-newlines 'both)
 622          (org-lparse-to-buffer to-buffer)
 623          (org-lparse-body-only body-only)
 624          (org-lparse-entity-control-callbacks-alist
 625           (org-lparse-get 'ENTITY-CONTROL))
 626          (org-lparse-entity-format-callbacks-alist
 627           (org-lparse-get 'ENTITY-FORMAT))
 628          (opt-plist
 629           (org-export-process-option-filters
 630            (org-combine-plists (org-default-export-plist)
 631                                ext-plist
 632                                (org-infile-export-plist))))
 633          (body-only (or body-only (plist-get opt-plist :body-only)))
 634          valid org-lparse-dyn-first-heading-pos
 635          (odd org-odd-levels-only)
 636          (region-p (org-region-active-p))
 637          (rbeg (and region-p (region-beginning)))
 638          (rend (and region-p (region-end)))
 639          (subtree-p
 640           (if (plist-get opt-plist :ignore-subtree-p)
 641               nil
 642             (when region-p
 643               (save-excursion
 644                 (goto-char rbeg)
 645                 (and (org-at-heading-p)
 646                      (>= (org-end-of-subtree t t) rend))))))
 647          (level-offset (if subtree-p
 648                            (save-excursion
 649                              (goto-char rbeg)
 650                              (+ (funcall outline-level)
 651                                 (if org-odd-levels-only 1 0)))
 652                          0))
 653          (opt-plist (setq org-export-opt-plist
 654                           (if subtree-p
 655                               (org-export-add-subtree-options opt-plist rbeg)
 656                             opt-plist)))
 657          ;; The following two are dynamically scoped into other
 658          ;; routines below.
 659          (org-current-export-dir
 660           (or pub-dir (org-lparse-get 'EXPORT-DIR opt-plist)))
 661          (org-current-export-file buffer-file-name)
 662          (level 0) (line "") (origline "") txt todo
 663          (umax nil)
 664          (umax-toc nil)
 665          (filename (if to-buffer nil
 666                      (expand-file-name
 667                       (concat
 668                        (file-name-sans-extension
 669                         (or (and subtree-p
 670                                  (org-entry-get (region-beginning)
 671                                                 "EXPORT_FILE_NAME" t))
 672                             (file-name-nondirectory buffer-file-name)))
 673                        "." (org-lparse-get 'FILE-NAME-EXTENSION opt-plist))
 674                       (file-name-as-directory
 675                        (or pub-dir (org-lparse-get 'EXPORT-DIR opt-plist))))))
 676          (current-dir (if buffer-file-name
 677                           (file-name-directory buffer-file-name)
 678                         default-directory))
 679          (auto-insert nil) ; Avoid any auto-insert stuff for the new file
 680          (buffer (if to-buffer
 681                      (cond
 682                       ((eq to-buffer 'string)
 683                        (get-buffer-create (org-lparse-get 'EXPORT-BUFFER-NAME)))
 684                       (t (get-buffer-create to-buffer)))
 685                    (find-file-noselect
 686                     (or (let ((f (org-lparse-get 'INIT-METHOD)))
 687                           (and f (functionp f) (funcall f filename)))
 688                         filename))))
 689          (org-levels-open (make-vector org-level-max nil))
 690          (dummy (mapc
 691                  (lambda(p)
 692                    (let* ((val (plist-get opt-plist p))
 693                           (val (org-xml-encode-org-text-skip-links val)))
 694                      (setq opt-plist (plist-put opt-plist p val))))
 695                  '(:date :author :keywords :description)))
 696          (date (plist-get opt-plist :date))
 697          (date (cond
 698                 ((and date (string-match "%" date))
 699                  (format-time-string date))
 700                 (date date)
 701                 (t (format-time-string "%Y-%m-%d %T %Z"))))
 702          (dummy (setq opt-plist (plist-put opt-plist :effective-date date)))
 703          (title       (org-xml-encode-org-text-skip-links
 704                        (or (and subtree-p (org-export-get-title-from-subtree))
 705                            (plist-get opt-plist :title)
 706                            (and (not body-only)
 707                                 (not
 708                                  (plist-get opt-plist :skip-before-1st-heading))
 709                                 (org-export-grab-title-from-buffer))
 710                            (and buffer-file-name
 711                                 (file-name-sans-extension
 712                                  (file-name-nondirectory buffer-file-name)))
 713                            "UNTITLED")))
 714          (dummy (setq opt-plist (plist-put opt-plist :title title)))
 715          (html-table-tag (plist-get opt-plist :html-table-tag))
 716          (quote-re0 (concat "^ *" org-quote-string "\\( +\\|[ \t]*$\\)"))
 717          (quote-re (format org-heading-keyword-regexp-format
 718                            org-quote-string))
 719          (org-lparse-dyn-current-environment nil)
 720          ;; Get the language-dependent settings
 721          (lang-words (or (assoc (plist-get opt-plist :language)
 722                                 org-export-language-setup)
 723                          (assoc "en" org-export-language-setup)))
 724          (dummy (setq opt-plist (plist-put opt-plist :lang-words lang-words)))
 725          (head-count  0) cnt
 726          (start       0)
 727          (coding-system-for-write
 728           (or (ignore-errors (org-lparse-get 'CODING-SYSTEM-FOR-WRITE))
 729               (and (boundp 'buffer-file-coding-system)
 730                    buffer-file-coding-system)))
 731          (save-buffer-coding-system
 732           (or (ignore-errors (org-lparse-get 'CODING-SYSTEM-FOR-SAVE))
 733               (and (boundp 'buffer-file-coding-system)
 734                    buffer-file-coding-system)))
 735          (region
 736           (buffer-substring
 737            (if region-p (region-beginning) (point-min))
 738            (if region-p (region-end) (point-max))))
 739          (org-export-have-math nil)
 740          (org-export-footnotes-seen nil)
 741          (org-export-footnotes-data (org-footnote-all-labels 'with-defs))
 742          (org-footnote-insert-pos-for-preprocessor 'point-min)
 743          (org-lparse-opt-plist opt-plist)
 744          (lines
 745           (org-split-string
 746            (org-export-preprocess-string
 747             region
 748             :emph-multiline t
 749             :for-backend (if (equal org-lparse-backend 'xhtml) ; hack
 750                              'html
 751                            org-lparse-backend)
 752             :skip-before-1st-heading
 753             (plist-get opt-plist :skip-before-1st-heading)
 754             :drawers (plist-get opt-plist :drawers)
 755             :todo-keywords (plist-get opt-plist :todo-keywords)
 756             :tasks (plist-get opt-plist :tasks)
 757             :tags (plist-get opt-plist :tags)
 758             :priority (plist-get opt-plist :priority)
 759             :footnotes (plist-get opt-plist :footnotes)
 760             :timestamps (plist-get opt-plist :timestamps)
 761             :archived-trees
 762             (plist-get opt-plist :archived-trees)
 763             :select-tags (plist-get opt-plist :select-tags)
 764             :exclude-tags (plist-get opt-plist :exclude-tags)
 765             :add-text
 766             (plist-get opt-plist :text)
 767             :LaTeX-fragments
 768             (plist-get opt-plist :LaTeX-fragments))
 769            "[\r\n]"))
 770          table-open
 771          table-buffer table-orig-buffer
 772          ind
 773          rpl path attr desc descp desc1 desc2 link
 774          snumber fnc
 775          footnotes footref-seen
 776          org-lparse-output-buffer
 777          org-lparse-footnote-definitions
 778          org-lparse-footnote-number
 779          ;; collection
 780          org-lparse-collect-buffer
 781          (org-lparse-collect-count 0)   ; things will get haywire if
 782                                         ; collections are chained.  Use
 783                                         ; this variable to assert this
 784                                         ; pre-requisite
 785          org-lparse-toc
 786          href
 787          )
 788
 789     (let ((inhibit-read-only t))
 790       (org-unmodified
 791        (remove-text-properties (point-min) (point-max)
 792                                '(:org-license-to-kill t))))
 793
 794     (message "Exporting...")
 795     (org-init-section-numbers)
 796
 797     ;; Switch to the output buffer
 798     (setq org-lparse-output-buffer buffer)
 799     (set-buffer org-lparse-output-buffer)
 800     (let ((inhibit-read-only t)) (erase-buffer))
 801     (fundamental-mode)
 802     (org-install-letbind)
 803
 804     (and (fboundp 'set-buffer-file-coding-system)
 805          (set-buffer-file-coding-system coding-system-for-write))
 806
 807     (let ((case-fold-search nil)
 808           (org-odd-levels-only odd))
 809       ;; create local variables for all options, to make sure all called
 810       ;; functions get the correct information
 811       (mapc (lambda (x)
 812               (set (make-local-variable (nth 2 x))
 813                    (plist-get opt-plist (car x))))
 814             org-export-plist-vars)
 815       (setq umax (if arg (prefix-numeric-value arg)
 816                    org-export-headline-levels))
 817       (setq umax-toc (if (integerp org-export-with-toc)
 818                          (min org-export-with-toc umax)
 819                        umax))
 820       (setq org-lparse-opt-plist
 821             (plist-put org-lparse-opt-plist :headline-levels  umax))
 822
 823       (when (and org-export-with-toc (not body-only))
 824         (setq lines (org-lparse-prepare-toc
 825                      lines level-offset opt-plist umax-toc)))
 826
 827       (unless body-only
 828         (org-lparse-begin 'DOCUMENT-CONTENT opt-plist)
 829         (org-lparse-begin 'DOCUMENT-BODY opt-plist))
 830
 831       (setq head-count 0)
 832       (org-init-section-numbers)
 833
 834       (org-lparse-begin-paragraph)
 835
 836       (while (setq line (pop lines) origline line)
 837         (catch 'nextline
 838           (when (and (org-lparse-current-environment-p 'quote)
 839                      (string-match org-outline-regexp-bol line))
 840             (org-lparse-end-environment 'quote))
 841
 842           (when (org-lparse-current-environment-p 'quote)
 843             (org-lparse-insert 'LINE line)
 844             (throw 'nextline nil))
 845
 846           ;; Fixed-width, verbatim lines (examples)
 847           (when (and org-export-with-fixed-width
 848                      (string-match "^[ \t]*:\\(\\([ \t]\\|$\\)\\(.*\\)\\)" line))
 849             (when (not (org-lparse-current-environment-p 'fixedwidth))
 850               (org-lparse-begin-environment 'fixedwidth))
 851             (org-lparse-insert 'LINE (match-string 3 line))
 852             (when (or (not lines)
 853                       (not (string-match "^[ \t]*:\\(\\([ \t]\\|$\\)\\(.*\\)\\)"
 854                                          (car lines))))
 855               (org-lparse-end-environment 'fixedwidth))
 856             (throw 'nextline nil))
 857
 858           ;; Native Text
 859           (when (and (get-text-property 0 'org-native-text line)
 860                      ;; Make sure it is the entire line that is protected
 861                      (not (< (or (next-single-property-change
 862                                   0 'org-native-text line) 10000)
 863                              (length line))))
 864             (let ((ind (get-text-property 0 'original-indentation line)))
 865               (org-lparse-begin-environment 'native)
 866               (org-lparse-insert 'LINE line)
 867               (while (and lines
 868                           (or (= (length (car lines)) 0)
 869                               (not ind)
 870                               (equal ind (get-text-property
 871                                           0 'original-indentation (car lines))))
 872                           (or (= (length (car lines)) 0)
 873                               (get-text-property 0 'org-native-text (car lines))))
 874                 (org-lparse-insert 'LINE (pop lines)))
 875               (org-lparse-end-environment 'native))
 876             (throw 'nextline nil))
 877
 878           ;; Protected HTML
 879           (when (and (get-text-property 0 'org-protected line)
 880                      ;; Make sure it is the entire line that is protected
 881                      (not (< (or (next-single-property-change
 882                                   0 'org-protected line) 10000)
 883                              (length line))))
 884             (let ((ind (get-text-property 0 'original-indentation line)))
 885               (org-lparse-insert 'LINE line)
 886               (while (and lines
 887                           (or (= (length (car lines)) 0)
 888                               (not ind)
 889                               (equal ind (get-text-property
 890                                           0 'original-indentation (car lines))))
 891                           (or (= (length (car lines)) 0)
 892                               (get-text-property 0 'org-protected (car lines))))
 893                 (org-lparse-insert 'LINE (pop lines))))
 894             (throw 'nextline nil))
 895
 896           ;; Blockquotes, verse, and center
 897           (when (string-match
 898                  "^ORG-\\(.+\\)-\\(START\\|END\\)\\([ \t]+.*\\)?$" line)
 899             (let* ((style (intern (downcase (match-string 1 line))))
 900                    (env-options-plist (org-lparse-get-block-params
 901                                        (match-string 3 line)))
 902                    (f (cdr (assoc (match-string 2 line)
 903                                   '(("START" . org-lparse-begin-environment)
 904                                     ("END" . org-lparse-end-environment))))))
 905               (when (memq style
 906                           (append
 907                            '(blockquote verse center)
 908                            (mapcar 'intern org-lparse-special-blocks)))
 909                 (funcall f style env-options-plist)
 910                 (throw 'nextline nil))))
 911
 912           (when (org-lparse-current-environment-p 'verse)
 913             (let ((i (org-get-string-indentation line)))
 914               (if (> i 0)
 915                   (setq line (concat
 916                               (let ((org-lparse-encode-pending t))
 917                                 (org-lparse-format 'SPACES (* 2 i)))
 918                               " " (org-trim line))))
 919               (unless (string-match "\\\\\\\\[ \t]*$" line)
 920                 (setq line (concat line "\\\\")))))
 921
 922           ;; make targets to anchors
 923           (setq start 0)
 924           (while (string-match
 925                   "<<<?\\([^<>]*\\)>>>?\\((INVISIBLE)\\)?[ \t]*\n?" line start)
 926             (cond
 927              ((get-text-property (match-beginning 1) 'org-protected line)
 928               (setq start (match-end 1)))
 929              ((match-end 2)
 930               (setq line (replace-match
 931                           (let ((org-lparse-encode-pending t))
 932                             (org-lparse-format
 933                              'ANCHOR "" (org-solidify-link-text
 934                                          (match-string 1 line))))
 935                           t t line)))
 936              ((and org-export-with-toc (equal (string-to-char line) ?*))
 937               ;; FIXME: NOT DEPENDENT on TOC?????????????????????
 938               (setq line (replace-match
 939                           (let ((org-lparse-encode-pending t))
 940                             (org-lparse-format
 941                              'FONTIFY (match-string 1 line) "target"))
 942                           ;; (concat "@<i>" (match-string 1 line) "@</i> ")
 943                           t t line)))
 944              (t
 945               (setq line (replace-match
 946                           (concat
 947                            (let ((org-lparse-encode-pending t))
 948                              (org-lparse-format
 949                               'ANCHOR (match-string 1 line)
 950                               (org-solidify-link-text (match-string 1 line))
 951                               "target")) " ")
 952                           t t line)))))
 953
 954           (let ((org-lparse-encode-pending t))
 955             (setq line (org-lparse-handle-time-stamps line)))
 956
 957           ;; replace "&" by "&amp;", "<" and ">" by "&lt;" and "&gt;"
 958           ;; handle @<..> HTML tags (replace "@&gt;..&lt;" by "<..>")
 959           ;; Also handle sub_superscripts and checkboxes
 960           (or (string-match org-table-hline-regexp line)
 961               (string-match "^[ \t]*\\([+]-\\||[ ]\\)[-+ |]*[+|][ \t]*$" line)
 962               (setq line (org-xml-encode-org-text-skip-links line)))
 963
 964           (setq line (org-lparse-format-org-link line opt-plist))
 965
 966           ;; TODO items
 967           (if (and org-todo-line-regexp
 968                    (string-match org-todo-line-regexp line)
 969                    (match-beginning 2))
 970               (setq line (concat
 971                           (substring line 0 (match-beginning 2))
 972                           (org-lparse-format 'TODO (match-string 2 line))
 973                           (substring line (match-end 2)))))
 974
 975           ;; Does this contain a reference to a footnote?
 976           (when org-export-with-footnotes
 977             (setq start 0)
 978             (while (string-match "\\([^* \t].*?\\)[ \t]*\\[\\([0-9]+\\)\\]" line start)
 979               ;; Discard protected matches not clearly identified as
 980               ;; footnote markers.
 981               (if (or (get-text-property (match-beginning 2) 'org-protected line)
 982                       (not (get-text-property (match-beginning 2) 'org-footnote line)))
 983                   (setq start (match-end 2))
 984                 (let ((n (match-string 2 line)) refcnt a)
 985                   (if (setq a (assoc n footref-seen))
 986                       (progn
 987                         (setcdr a (1+ (cdr a)))
 988                         (setq refcnt (cdr a)))
 989                     (setq refcnt 1)
 990                     (push (cons n 1) footref-seen))
 991                   (setq line
 992                         (replace-match
 993                          (concat
 994                           (or (match-string 1 line) "")
 995                           (org-lparse-format
 996                            'FOOTNOTE-REFERENCE
 997                            n (cdr (assoc n org-lparse-footnote-definitions))
 998                            refcnt)
 999                           ;; If another footnote is following the
1000                           ;; current one, add a separator.
1001                           (if (save-match-data
1002                                 (string-match "\\`\\[[0-9]+\\]"
1003                                               (substring line (match-end 0))))
1004                               (ignore-errors
1005                                 (org-lparse-get 'FOOTNOTE-SEPARATOR))
1006                             ""))
1007                          t t line))))))
1008
1009           (cond
1010            ((string-match "^\\(\\*+\\)\\(?: +\\(.*?\\)\\)?[ \t]*$" line)
1011             ;; This is a headline
1012             (setq level (org-tr-level (- (match-end 1) (match-beginning 1)
1013                                          level-offset))
1014                   txt (match-string 2 line))
1015             (if (string-match quote-re0 txt)
1016                 (setq txt (replace-match "" t t txt)))
1017             (if (<= level (max umax umax-toc))
1018                 (setq head-count (+ head-count 1)))
1019             (unless org-lparse-dyn-first-heading-pos
1020               (setq org-lparse-dyn-first-heading-pos (point)))
1021             (org-lparse-begin-level level txt umax head-count)
1022
1023             ;; QUOTES
1024             (when (string-match quote-re line)
1025               (org-lparse-begin-environment 'quote)))
1026
1027            ((and org-export-with-tables
1028                  (string-match "^\\([ \t]*\\)\\(|\\|\\+-+\\+\\)" line))
1029             (when (not table-open)
1030               ;; New table starts
1031               (setq table-open t table-buffer nil table-orig-buffer nil))
1032
1033             ;; Accumulate lines
1034             (setq table-buffer (cons line table-buffer)
1035                   table-orig-buffer (cons origline table-orig-buffer))
1036             (when (or (not lines)
1037                       (not (string-match "^\\([ \t]*\\)\\(|\\|\\+-+\\+\\)"
1038                                          (car lines))))
1039               (setq table-open nil
1040                     table-buffer (nreverse table-buffer)
1041                     table-orig-buffer (nreverse table-orig-buffer))
1042               (org-lparse-end-paragraph)
1043               (when org-lparse-list-table-p
1044                 (error "Regular tables are not allowed in a list-table block"))
1045               (org-lparse-insert 'TABLE table-buffer table-orig-buffer)))
1046
1047            ;; Normal lines
1048            (t
1049             ;; This line either is list item or end a list.
1050             (when (get-text-property 0 'list-item line)
1051               (setq line (org-lparse-export-list-line
1052                           line
1053                           (get-text-property 0 'list-item line)
1054                           (get-text-property 0 'list-struct line)
1055                           (get-text-property 0 'list-prevs line))))
1056
1057             ;; Horizontal line
1058             (when (string-match "^[ \t]*-\\{5,\\}[ \t]*$" line)
1059               (with-org-lparse-preserve-paragraph-state
1060                (org-lparse-insert 'HORIZONTAL-LINE))
1061               (throw 'nextline nil))
1062
1063             ;; Empty lines start a new paragraph.  If hand-formatted lists
1064             ;; are not fully interpreted, lines starting with "-", "+", "*"
1065             ;; also start a new paragraph.
1066             (when (string-match "^ [-+*]-\\|^[ \t]*$" line)
1067               (when org-lparse-footnote-number
1068                 (org-lparse-end-footnote-definition org-lparse-footnote-number)
1069                 (setq org-lparse-footnote-number nil))
1070               (org-lparse-begin-paragraph))
1071
1072             ;; Is this the start of a footnote?
1073             (when org-export-with-footnotes
1074               (when (and (boundp 'footnote-section-tag-regexp)
1075                          (string-match (concat "^" footnote-section-tag-regexp)
1076                                        line))
1077                 ;; ignore this line
1078                 (throw 'nextline nil))
1079               (when (string-match "^[ \t]*\\[\\([0-9]+\\)\\]" line)
1080                 (org-lparse-end-paragraph)
1081                 (setq org-lparse-footnote-number (match-string 1 line))
1082                 (setq line (replace-match "" t t line))
1083                 (org-lparse-begin-footnote-definition org-lparse-footnote-number)))
1084             ;; Check if the line break needs to be conserved
1085             (cond
1086              ((string-match "\\\\\\\\[ \t]*$" line)
1087               (setq line (replace-match
1088                           (org-lparse-format 'LINE-BREAK)
1089                           t t line)))
1090              (org-export-preserve-breaks
1091               (setq line (concat line (org-lparse-format 'LINE-BREAK)))))
1092
1093             ;; Check if a paragraph should be started
1094             (let ((start 0))
1095               (while (and org-lparse-par-open
1096                           (string-match "\\\\par\\>" line start))
1097                 (error "FIXME")
1098                 ;; Leave a space in the </p> so that the footnote matcher
1099                 ;; does not see this.
1100                 (if (not (get-text-property (match-beginning 0)
1101                                             'org-protected line))
1102                     (setq line (replace-match "</p ><p >" t t line)))
1103                 (setq start (match-end 0))))
1104
1105             (org-lparse-insert 'LINE line)))))
1106
1107       ;; Properly close all local lists and other lists
1108       (when (org-lparse-current-environment-p 'quote)
1109         (org-lparse-end-environment 'quote))
1110
1111       (org-lparse-end-level 1 umax)
1112
1113       ;; the </div> to close the last text-... div.
1114       (when (and (> umax 0) org-lparse-dyn-first-heading-pos)
1115         (org-lparse-end-outline-text-or-outline))
1116
1117       (org-lparse-end 'DOCUMENT-BODY opt-plist)
1118       (unless body-only
1119         (org-lparse-end 'DOCUMENT-CONTENT))
1120
1121       (org-lparse-end 'EXPORT)
1122
1123       ;; kill collection buffer
1124       (when org-lparse-collect-buffer
1125         (kill-buffer org-lparse-collect-buffer))
1126
1127       (goto-char (point-min))
1128       (or (org-export-push-to-kill-ring
1129            (upcase (symbol-name org-lparse-backend)))
1130           (message "Exporting... done"))
1131
1132       (cond
1133        ((not to-buffer)
1134         (let ((f (org-lparse-get 'SAVE-METHOD)))
1135           (or (and f (functionp f) (funcall f filename opt-plist))
1136               (save-buffer)))
1137         (or (and (boundp 'org-lparse-other-backend)
1138                  org-lparse-other-backend
1139                  (not (equal org-lparse-backend org-lparse-other-backend))
1140                  (org-lparse-do-convert
1141                   buffer-file-name (symbol-name org-lparse-other-backend)))
1142             (current-buffer)))
1143        ((eq to-buffer 'string)
1144         (prog1 (buffer-substring (point-min) (point-max))
1145           (kill-buffer (current-buffer))))
1146        (t (current-buffer))))))
1147
1148 (defun org-lparse-format-table (lines olines)
1149   "Returns backend-specific code for org-type and table-type tables."
1150   (if (stringp lines)
1151       (setq lines (org-split-string lines "\n")))
1152   (if (string-match "^[ \t]*|" (car lines))
1153       ;; A normal org table
1154       (org-lparse-format-org-table lines nil)
1155     ;; Table made by table.el
1156     (or (org-lparse-format-table-table-using-table-generate-source
1157          ;; FIXME: Need to take care of this during merge
1158          (if (eq org-lparse-backend 'xhtml) 'html org-lparse-backend)
1159          olines
1160          (not org-export-prefer-native-exporter-for-tables))
1161         ;; We are here only when table.el table has NO col or row
1162         ;; spanning and the user prefers using org's own converter for
1163         ;; exporting of such simple table.el tables.
1164         (org-lparse-format-table-table lines))))
1165
1166 (defun org-lparse-table-get-colalign-info (lines)
1167   (let ((col-cookies (org-find-text-property-in-string
1168                       'org-col-cookies (car lines))))
1169     (when (and col-cookies org-table-clean-did-remove-column)
1170       (setq col-cookies
1171             (mapcar (lambda (x) (cons (1- (car x)) (cdr x))) col-cookies)))
1172     col-cookies))
1173
1174 (defvar org-lparse-table-style)
1175 (defvar org-lparse-table-ncols)
1176 (defvar org-lparse-table-rownum)
1177 (defvar org-lparse-table-is-styled)
1178 (defvar org-lparse-table-begin-marker)
1179 (defvar org-lparse-table-num-numeric-items-per-column)
1180 (defvar org-lparse-table-colalign-info)
1181 (defvar org-lparse-table-colalign-vector)
1182
1183 ;; Following variables are defined in org-table.el
1184 (defvar org-table-number-fraction)
1185 (defvar org-table-number-regexp)
1186 (defun org-lparse-org-table-to-list-table (lines &optional splice)
1187   "Convert org-table to list-table.
1188 LINES is a list of the form (ROW1 ROW2 ROW3 ...) where each
1189 element is a `string' representing a single row of org-table.
1190 Thus each ROW has vertical separators \"|\" separating the table
1191 fields.  A ROW could also be a row-group separator of the form
1192 \"|---...|\".  Return a list of the form (ROW1 ROW2 ROW3
1193 ...). ROW could either be symbol `:hrule' or a list of the
1194 form (FIELD1 FIELD2 FIELD3 ...) as appropriate."
1195   (let (line lines-1)
1196     (cond
1197      (splice
1198       (while (setq line (pop lines))
1199         (unless (string-match "^[ \t]*|-" line)
1200           (push (org-split-string line "[ \t]*|[ \t]*") lines-1))))
1201      (t
1202       (while (setq line (pop lines))
1203         (cond
1204          ((string-match "^[ \t]*|-" line)
1205           (when lines
1206             (push :hrule lines-1)))
1207          (t
1208           (push (org-split-string line "[ \t]*|[ \t]*") lines-1))))))
1209     (nreverse lines-1)))
1210
1211 (defun org-lparse-insert-org-table (lines &optional splice)
1212   "Format a org-type table into backend-specific code.
1213 LINES is a list of lines.  Optional argument SPLICE means, do not
1214 insert header and surrounding <table> tags, just format the lines.
1215 Optional argument NO-CSS means use XHTML attributes instead of CSS
1216 for formatting.  This is required for the DocBook exporter."
1217   (require 'org-table)
1218   ;; Get rid of hlines at beginning and end
1219   (if (string-match "^[ \t]*|-" (car lines)) (setq lines (cdr lines)))
1220   (setq lines (nreverse lines))
1221   (if (string-match "^[ \t]*|-" (car lines)) (setq lines (cdr lines)))
1222   (setq lines (nreverse lines))
1223   (when org-export-table-remove-special-lines
1224     ;; Check if the table has a marking column.  If yes remove the
1225     ;; column and the special lines
1226     (setq lines (org-table-clean-before-export lines)))
1227   (let* ((caption (org-find-text-property-in-string 'org-caption (car lines)))
1228          (short-caption (or (org-find-text-property-in-string
1229                              'org-caption-shortn (car lines)) caption))
1230          (caption (and caption (org-xml-encode-org-text caption)))
1231          (short-caption (and short-caption
1232                              (org-xml-encode-plain-text short-caption)))
1233          (label (org-find-text-property-in-string 'org-label (car lines)))
1234          (org-lparse-table-colalign-info (org-lparse-table-get-colalign-info lines))
1235          (attributes (org-find-text-property-in-string 'org-attributes
1236                                                        (car lines)))
1237          (head (and org-export-highlight-first-table-line
1238                     (delq nil (mapcar
1239                                (lambda (x) (string-match "^[ \t]*|-" x))
1240                                (cdr lines))))))
1241     (setq lines (org-lparse-org-table-to-list-table lines splice))
1242     (org-lparse-insert-list-table
1243      lines splice caption label attributes head org-lparse-table-colalign-info
1244      short-caption)))
1245
1246 (defun org-lparse-insert-list-table (lines &optional splice
1247                                            caption label attributes head
1248                                            org-lparse-table-colalign-info
1249                                            short-caption)
1250   (or (featurep 'org-table)             ; required for
1251       (require 'org-table))             ; `org-table-number-regexp'
1252   (let* ((org-lparse-table-rownum -1) org-lparse-table-ncols i (cnt 0)
1253          tbopen fields line
1254          org-lparse-table-cur-rowgrp-is-hdr
1255          org-lparse-table-rowgrp-open
1256          org-lparse-table-num-numeric-items-per-column
1257          org-lparse-table-colalign-vector n
1258          org-lparse-table-rowgrp-info
1259          org-lparse-table-begin-marker
1260          (org-lparse-table-style 'org-table)
1261          org-lparse-table-is-styled)
1262     (cond
1263      (splice
1264       (setq org-lparse-table-is-styled nil)
1265       (while (setq line (pop lines))
1266         (insert (org-lparse-format-table-row line) "\n")))
1267      (t
1268       (setq org-lparse-table-is-styled t)
1269       (org-lparse-begin 'TABLE caption label attributes short-caption)
1270       (setq org-lparse-table-begin-marker (point))
1271       (org-lparse-begin-table-rowgroup head)
1272       (while (setq line (pop lines))
1273         (cond
1274          ((equal line :hrule)
1275           (org-lparse-begin-table-rowgroup))
1276          (t
1277           (insert (org-lparse-format-table-row line) "\n"))))
1278       (org-lparse-end 'TABLE-ROWGROUP)
1279       (org-lparse-end-table)))))
1280
1281 (defun org-lparse-format-org-table (lines &optional splice)
1282   (with-temp-buffer
1283     (org-lparse-insert-org-table lines splice)
1284     (buffer-substring-no-properties (point-min) (point-max))))
1285
1286 (defun org-lparse-format-list-table (lines &optional splice)
1287   (with-temp-buffer
1288     (org-lparse-insert-list-table lines splice)
1289     (buffer-substring-no-properties (point-min) (point-max))))
1290
1291 (defun org-lparse-insert-table-table (lines)
1292   "Format a table generated by table.el into backend-specific code.
1293 This conversion does *not* use `table-generate-source' from table.el.
1294 This has the advantage that Org-mode's HTML conversions can be used.
1295 But it has the disadvantage, that no cell- or row-spanning is allowed."
1296   (let (line field-buffer
1297              (org-lparse-table-cur-rowgrp-is-hdr
1298               org-export-highlight-first-table-line)
1299              (caption nil)
1300              (short-caption nil)
1301              (attributes nil)
1302              (label nil)
1303              (org-lparse-table-style 'table-table)
1304              (org-lparse-table-is-styled nil)
1305              fields org-lparse-table-ncols i (org-lparse-table-rownum -1)
1306              (empty (org-lparse-format 'SPACES 1)))
1307     (org-lparse-begin 'TABLE caption label attributes short-caption)
1308     (while (setq line (pop lines))
1309       (cond
1310        ((string-match "^[ \t]*\\+-" line)
1311         (when field-buffer
1312           (let ((org-export-table-row-tags '("<tr>" . "</tr>"))
1313                 ;; (org-export-html-table-use-header-tags-for-first-column nil)
1314                 )
1315             (insert (org-lparse-format-table-row field-buffer empty)))
1316           (setq org-lparse-table-cur-rowgrp-is-hdr nil)
1317           (setq field-buffer nil)))
1318        (t
1319         ;; Break the line into fields and store the fields
1320         (setq fields (org-split-string line "[ \t]*|[ \t]*"))
1321         (if field-buffer
1322             (setq field-buffer (mapcar
1323                                 (lambda (x)
1324                                   (concat x (org-lparse-format 'LINE-BREAK)
1325                                           (pop fields)))
1326                                 field-buffer))
1327           (setq field-buffer fields)))))
1328     (org-lparse-end-table)))
1329
1330 (defun org-lparse-format-table-table (lines)
1331   (with-temp-buffer
1332     (org-lparse-insert-table-table lines)
1333     (buffer-substring-no-properties (point-min) (point-max))))
1334
1335 (defvar table-source-languages)         ; defined in table.el
1336 (defun org-lparse-format-table-table-using-table-generate-source (backend
1337                                                                   lines
1338                                                                   &optional
1339                                                                   spanned-only)
1340   "Format a table into BACKEND, using `table-generate-source' from table.el.
1341 Use SPANNED-ONLY to suppress exporting of simple table.el tables.
1342
1343 When SPANNED-ONLY is nil, all table.el tables are exported.  When
1344 SPANNED-ONLY is non-nil, only tables with either row or column
1345 spans are exported.
1346
1347 This routine returns the generated source or nil as appropriate.
1348
1349 Refer docstring of `org-export-prefer-native-exporter-for-tables'
1350 for further information."
1351   (require 'table)
1352   (with-current-buffer (get-buffer-create " org-tmp1 ")
1353     (erase-buffer)
1354     (insert (mapconcat 'identity lines "\n"))
1355     (goto-char (point-min))
1356     (if (not (re-search-forward "|[^+]" nil t))
1357         (error "Error processing table"))
1358     (table-recognize-table)
1359     (when (or (not spanned-only)
1360               (let* ((dim (table-query-dimension))
1361                      (c (nth 4 dim)) (r (nth 5 dim)) (cells (nth 6 dim)))
1362                 (not (= (* c r) cells))))
1363       (with-current-buffer (get-buffer-create " org-tmp2 ") (erase-buffer))
1364       (cond
1365        ((member backend table-source-languages)
1366         (table-generate-source backend " org-tmp2 ")
1367         (set-buffer " org-tmp2 ")
1368         (buffer-substring (point-min) (point-max)))
1369        (t
1370         ;; table.el doesn't support the given backend.  Currently this
1371         ;; happens in case of odt export.  Strip the table from the
1372         ;; generated document.  A better alternative would be to embed
1373         ;; the table as ascii text in the output document.
1374         (org-lparse-warn
1375          (concat
1376           "Found table.el-type table in the source org file. "
1377           (format "table.el doesn't support %s backend. "
1378                   (upcase (symbol-name backend)))
1379           "Skipping ahead ..."))
1380         "")))))
1381
1382 (defun org-lparse-handle-time-stamps (s)
1383   "Format time stamps in string S, or remove them."
1384   (catch 'exit
1385     (let (r b)
1386       (when org-maybe-keyword-time-regexp
1387         (while (string-match org-maybe-keyword-time-regexp s)
1388           (or b (setq b (substring s 0 (match-beginning 0))))
1389           (setq r (concat
1390                    r (substring s 0 (match-beginning 0)) " "
1391                    (org-lparse-format
1392                     'FONTIFY
1393                     (concat
1394                      (if (match-end 1)
1395                          (org-lparse-format
1396                           'FONTIFY
1397                           (match-string 1 s) "timestamp-kwd"))
1398                      " "
1399                      (org-lparse-format
1400                       'FONTIFY
1401                       (substring (org-translate-time (match-string 3 s)) 1 -1)
1402                       "timestamp"))
1403                     "timestamp-wrapper"))
1404                 s (substring s (match-end 0)))))
1405
1406       ;; Line break if line started and ended with time stamp stuff
1407       (if (not r)
1408           s
1409         (setq r (concat r s))
1410         (unless (string-match "\\S-" (concat b s))
1411           (setq r (concat r (org-lparse-format 'LINE-BREAK))))
1412         r))))
1413
1414 (defun org-xml-encode-plain-text (s)
1415   "Convert plain text characters to HTML equivalent.
1416 Possible conversions are set in `org-export-html-protect-char-alist'."
1417   (let ((cl (org-lparse-get 'PLAIN-TEXT-MAP)) c)
1418     (while (setq c (pop cl))
1419       (let ((start 0))
1420         (while (string-match (car c) s start)
1421           (setq s (replace-match (cdr c) t t s)
1422                 start (1+ (match-beginning 0))))))
1423     s))
1424
1425 (defun org-xml-encode-org-text-skip-links (string)
1426   "Prepare STRING for HTML export.  Apply all active conversions.
1427 If there are links in the string, don't modify these.  If STRING
1428 is nil, return nil."
1429   (when string
1430     (let* ((re (concat org-bracket-link-regexp "\\|"
1431                        (org-re "[ \t]+\\(:[[:alnum:]_@#%:]+:\\)[ \t]*$")))
1432            m s l res)
1433       (while (setq m (string-match re string))
1434         (setq s (substring string 0 m)
1435               l (match-string 0 string)
1436               string (substring string (match-end 0)))
1437         (push (org-xml-encode-org-text s) res)
1438         (push l res))
1439       (push (org-xml-encode-org-text string) res)
1440       (apply 'concat (nreverse res)))))
1441
1442 (defun org-xml-encode-org-text (s)
1443   "Apply all active conversions to translate special ASCII to HTML."
1444   (setq s (org-xml-encode-plain-text s))
1445   (if org-export-html-expand
1446       (while (string-match "@&lt;\\([^&]*\\)&gt;" s)
1447         (setq s (replace-match "<\\1>" t nil s))))
1448   (if org-export-with-emphasize
1449       (setq s (org-lparse-apply-char-styles s)))
1450   (if org-export-with-special-strings
1451       (setq s (org-lparse-convert-special-strings s)))
1452   (if org-export-with-sub-superscripts
1453       (setq s (org-lparse-apply-sub-superscript-styles s)))
1454   (if org-export-with-TeX-macros
1455       (let ((start 0) wd rep)
1456         (while (setq start (string-match "\\\\\\([a-zA-Z]+[0-9]*\\)\\({}\\)?"
1457                                          s start))
1458           (if (get-text-property (match-beginning 0) 'org-protected s)
1459               (setq start (match-end 0))
1460             (setq wd (match-string 1 s))
1461             (if (setq rep (org-lparse-format 'ORG-ENTITY wd))
1462                 (setq s (replace-match rep t t s))
1463               (setq start (+ start (length wd))))))))
1464   s)
1465
1466 (defun org-lparse-convert-special-strings (string)
1467   "Convert special characters in STRING to HTML."
1468   (let ((all (org-lparse-get 'SPECIAL-STRING-REGEXPS))
1469         e a re rpl start)
1470     (while (setq a (pop all))
1471       (setq re (car a) rpl (cdr a) start 0)
1472       (while (string-match re string start)
1473         (if (get-text-property (match-beginning 0) 'org-protected string)
1474             (setq start (match-end 0))
1475           (setq string (replace-match rpl t nil string)))))
1476     string))
1477
1478 (defun org-lparse-apply-sub-superscript-styles (string)
1479   "Apply subscript and superscript styles to STRING.
1480 Use `org-export-with-sub-superscripts' to control application of
1481 sub and superscript styles."
1482   (let (key c (s 0) (requireb (eq org-export-with-sub-superscripts '{})))
1483     (while (string-match org-match-substring-regexp string s)
1484       (cond
1485        ((and requireb (match-end 8)) (setq s (match-end 2)))
1486        ((get-text-property  (match-beginning 2) 'org-protected string)
1487         (setq s (match-end 2)))
1488        (t
1489         (setq s (match-end 1)
1490               key (if (string= (match-string 2 string) "_")
1491                       'subscript 'superscript)
1492               c (or (match-string 8 string)
1493                     (match-string 6 string)
1494                     (match-string 5 string))
1495               string (replace-match
1496                       (concat (match-string 1 string)
1497                               (org-lparse-format 'FONTIFY c key))
1498                       t t string)))))
1499     (while (string-match "\\\\\\([_^]\\)" string)
1500       (setq string (replace-match (match-string 1 string) t t string)))
1501     string))
1502
1503 (defvar org-lparse-char-styles
1504   `(("*" bold)
1505     ("/" emphasis)
1506     ("_" underline)
1507     ("=" code)
1508     ("~" verbatim)
1509     ("+" strike))
1510   "Map Org emphasis markers to char styles.
1511 This is an alist where each element is of the
1512 form (ORG-EMPHASIS-CHAR . CHAR-STYLE).")
1513
1514 (defun org-lparse-apply-char-styles (string)
1515   "Apply char styles to STRING.
1516 The variable `org-lparse-char-styles' controls how the Org
1517 emphasis markers are interpreted."
1518   (let ((s 0) rpl)
1519     (while (string-match org-emph-re string s)
1520       (if (not (equal
1521                 (substring string (match-beginning 3) (1+ (match-beginning 3)))
1522                 (substring string (match-beginning 4) (1+ (match-beginning 4)))))
1523           (setq s (match-beginning 0)
1524                 rpl
1525                 (concat
1526                  (match-string 1 string)
1527                  (org-lparse-format
1528                   'FONTIFY (match-string 4 string)
1529                   (nth 1 (assoc (match-string 3 string)
1530                                 org-lparse-char-styles)))
1531                  (match-string 5 string))
1532                 string (replace-match rpl t t string)
1533                 s (+ s (- (length rpl) 2)))
1534         (setq s (1+ s))))
1535     string))
1536
1537 (defun org-lparse-export-list-line (line pos struct prevs)
1538   "Insert list syntax in export buffer.  Return LINE, maybe modified.
1539
1540 POS is the item position or line position the line had before
1541 modifications to buffer.  STRUCT is the list structure.  PREVS is
1542 the alist of previous items."
1543   (let* ((get-type
1544           (function
1545            ;; Translate type of list containing POS to "d", "o" or
1546            ;; "u".
1547            (lambda (pos struct prevs)
1548              (let ((type (org-list-get-list-type pos struct prevs)))
1549                (cond
1550                 ((eq 'ordered type) "o")
1551                 ((eq 'descriptive type) "d")
1552                 (t "u"))))))
1553          (get-closings
1554           (function
1555            ;; Return list of all items and sublists ending at POS, in
1556            ;; reverse order.
1557            (lambda (pos)
1558              (let (out)
1559                (catch 'exit
1560                  (mapc (lambda (e)
1561                          (let ((end (nth 6 e))
1562                                (item (car e)))
1563                            (cond
1564                             ((= end pos) (push item out))
1565                             ((>= item pos) (throw 'exit nil)))))
1566                        struct))
1567                out)))))
1568     ;; First close any previous item, or list, ending at POS.
1569     (mapc (lambda (e)
1570             (let* ((lastp (= (org-list-get-last-item e struct prevs) e))
1571                    (first-item (org-list-get-list-begin e struct prevs))
1572                    (type (funcall get-type first-item struct prevs)))
1573               (org-lparse-end-paragraph)
1574               ;; Ending for every item
1575               (org-lparse-end-list-item-1 type)
1576               ;; We're ending last item of the list: end list.
1577               (when lastp
1578                 (org-lparse-end-list type)
1579                 (org-lparse-begin-paragraph))))
1580           (funcall get-closings pos))
1581     (cond
1582      ;; At an item: insert appropriate tags in export buffer.
1583      ((assq pos struct)
1584       (string-match
1585        (concat "[ \t]*\\(\\S-+[ \t]*\\)"
1586                "\\(?:\\[@\\(?:start:\\)?\\([0-9]+\\|[A-Za-z]\\)\\][ \t]*\\)?"
1587                "\\(?:\\(\\[[ X-]\\]\\)[ \t]+\\)?"
1588                "\\(?:\\(.*\\)[ \t]+::\\(?:[ \t]+\\|$\\)\\)?"
1589                "\\(.*\\)") line)
1590       (let* ((checkbox (match-string 3 line))
1591              (desc-tag (or (match-string 4 line) "???"))
1592              (body (or (match-string 5 line) ""))
1593              (list-beg (org-list-get-list-begin pos struct prevs))
1594              (firstp (= list-beg pos))
1595              ;; Always refer to first item to determine list type, in
1596              ;; case list is ill-formed.
1597              (type (funcall get-type list-beg struct prevs))
1598              (counter (let ((count-tmp (org-list-get-counter pos struct)))
1599                         (cond
1600                          ((not count-tmp) nil)
1601                          ((string-match "[A-Za-z]" count-tmp)
1602                           (- (string-to-char (upcase count-tmp)) 64))
1603                          ((string-match "[0-9]+" count-tmp)
1604                           count-tmp)))))
1605         (when firstp
1606           (org-lparse-end-paragraph)
1607           (org-lparse-begin-list type))
1608
1609         (let ((arg (cond ((equal type "d") desc-tag)
1610                          ((equal type "o") counter))))
1611           (org-lparse-begin-list-item type arg))
1612
1613         ;; If line had a checkbox, some additional modification is required.
1614         (when checkbox
1615           (setq body
1616                 (concat
1617                  (org-lparse-format
1618                   'FONTIFY (concat
1619                             "["
1620                             (cond
1621                              ((string-match "X" checkbox) "X")
1622                              ((string-match " " checkbox)
1623                               (org-lparse-format 'SPACES 1))
1624                              (t "-"))
1625                             "]")
1626                   'code)
1627                  " "
1628                  body)))
1629         ;; Return modified line
1630         body))
1631      ;; At a list ender: go to next line (side-effects only).
1632      ((equal "ORG-LIST-END-MARKER" line) (throw 'nextline nil))
1633      ;; Not at an item: return line unchanged (side-effects only).
1634      (t line))))
1635
1636 (defun org-lparse-bind-local-variables (opt-plist)
1637   (mapc (lambda (x)
1638           (set (make-local-variable (nth 2 x))
1639                (plist-get opt-plist (car x))))
1640         org-export-plist-vars))
1641
1642 (defvar org-lparse-table-rowgrp-open)
1643 (defvar org-lparse-table-cur-rowgrp-is-hdr)
1644 (defvar org-lparse-footnote-number)
1645 (defvar org-lparse-footnote-definitions)
1646 (defvar org-lparse-output-buffer nil
1647   "Buffer to which `org-do-lparse' writes to.
1648 This buffer contains the contents of the to-be-created exported
1649 document.")
1650
1651 (defcustom org-lparse-debug nil
1652   "Enable or Disable logging of `org-lparse' callbacks.
1653 The parameters passed to the backend-registered ENTITY-CONTROL
1654 and ENTITY-FORMAT callbacks are logged as comment strings in the
1655 exported buffer.  (org-lparse-format 'COMMENT fmt args) is used
1656 for logging.  Customize this variable only if you are an expert
1657 user.  Valid values of this variable are:
1658 nil     : Disable logging
1659 control : Log all invocations of `org-lparse-begin' and
1660           `org-lparse-end' callbacks.
1661 format  : Log invocations of `org-lparse-format' callbacks.
1662 t       : Log all invocations of `org-lparse-begin', `org-lparse-end'
1663           and `org-lparse-format' callbacks,"
1664   :group 'org-lparse
1665   :type '(choice
1666           (const :tag "Disable" nil)
1667           (const :tag "Format callbacks" format)
1668           (const :tag "Control callbacks" control)
1669           (const :tag "Format and Control callbacks" t)))
1670
1671 (defun org-lparse-begin (entity &rest args)
1672   "Begin ENTITY in current buffer.  ARGS is entity specific.
1673 ENTITY can be one of PARAGRAPH, LIST, LIST-ITEM etc.
1674
1675 Use (org-lparse-begin 'LIST \"o\") to begin a list in current
1676 buffer.
1677
1678 See `org-xhtml-entity-control-callbacks-alist' for more
1679 information."
1680   (when (and (member org-lparse-debug '(t control))
1681              (not (eq entity 'DOCUMENT-CONTENT)))
1682     (insert (org-lparse-format 'COMMENT "%s BEGIN %S" entity args)))
1683
1684   (let ((f (cadr (assoc entity org-lparse-entity-control-callbacks-alist))))
1685     (unless f (error "Unknown entity: %s" entity))
1686     (apply f args)))
1687
1688 (defun org-lparse-end (entity &rest args)
1689   "Close ENTITY in current buffer.  ARGS is entity specific.
1690 ENTITY can be one of PARAGRAPH, LIST, LIST-ITEM
1691 etc.
1692
1693 Use (org-lparse-end 'LIST \"o\") to close a list in current
1694 buffer.
1695
1696 See `org-xhtml-entity-control-callbacks-alist' for more
1697 information."
1698   (when (and (member org-lparse-debug '(t control))
1699              (not (eq entity 'DOCUMENT-CONTENT)))
1700     (insert (org-lparse-format 'COMMENT "%s END %S" entity args)))
1701
1702   (let ((f (caddr (assoc entity org-lparse-entity-control-callbacks-alist))))
1703     (unless f (error "Unknown entity: %s" entity))
1704     (apply f args)))
1705
1706 (defun org-lparse-begin-paragraph (&optional style)
1707   "Insert <p>, but first close previous paragraph if any."
1708   (org-lparse-end-paragraph)
1709   (org-lparse-begin 'PARAGRAPH style)
1710   (setq org-lparse-par-open t))
1711
1712 (defun org-lparse-end-paragraph ()
1713   "Close paragraph if there is one open."
1714   (when org-lparse-par-open
1715     (org-lparse-end 'PARAGRAPH)
1716     (setq org-lparse-par-open nil)))
1717
1718 (defun org-lparse-end-list-item-1 (&optional type)
1719   "Close <li> if necessary."
1720   (org-lparse-end-paragraph)
1721   (org-lparse-end-list-item (or type "u")))
1722
1723 (define-obsolete-function-alias
1724   'org-lparse-preprocess-after-blockquote-hook
1725   'org-lparse-preprocess-after-blockquote
1726   "24.3")
1727
1728 (defun org-lparse-preprocess-after-blockquote ()
1729   "Treat `org-lparse-special-blocks' specially."
1730   (goto-char (point-min))
1731   (while (re-search-forward
1732           "^[ \t]*#\\+\\(begin\\|end\\)_\\(\\S-+\\)[ \t]*\\(.*\\)$" nil t)
1733     (when (member (downcase (match-string 2)) org-lparse-special-blocks)
1734       (replace-match
1735        (if (equal (downcase (match-string 1)) "begin")
1736            (format "ORG-%s-START %s" (upcase (match-string 2))
1737                    (match-string 3))
1738          (format "ORG-%s-END %s" (upcase (match-string 2))
1739                  (match-string 3))) t t))))
1740
1741 (define-obsolete-function-alias
1742   'org-lparse-strip-experimental-blocks-maybe-hook
1743   'org-lparse-strip-experimental-blocks-maybe
1744   "24.3")
1745
1746 (defun org-lparse-strip-experimental-blocks-maybe ()
1747   "Strip \"list-table\" and \"annotation\" blocks.
1748 Stripping happens only when the exported backend is not one of
1749 \"odt\" or \"xhtml\"."
1750   (when (not org-lparse-backend)
1751     (message "Stripping following blocks - %S" org-lparse-special-blocks)
1752     (goto-char (point-min))
1753     (let ((case-fold-search t))
1754       (while
1755           (re-search-forward
1756            "^[ \t]*#\\+begin_\\(\\S-+\\)\\([ \t]+.*\\)?\n\\([^\000]*?\\)\n[ \t]*#\\+end_\\1\\>.*"
1757            nil t)
1758         (when (member (match-string 1) org-lparse-special-blocks)
1759           (replace-match "" t t))))))
1760
1761 (defvar org-lparse-list-table-p nil
1762   "Non-nil if `org-do-lparse' is within a list-table.")
1763
1764 (defvar org-lparse-dyn-current-environment nil)
1765 (defun org-lparse-begin-environment (style &optional env-options-plist)
1766   (case style
1767     (list-table
1768      (setq org-lparse-list-table-p t))
1769     (t (setq org-lparse-dyn-current-environment style)
1770        (org-lparse-begin 'ENVIRONMENT  style env-options-plist))))
1771
1772 (defun org-lparse-end-environment (style &optional env-options-plist)
1773   (case style
1774     (list-table
1775      (setq org-lparse-list-table-p nil))
1776     (t (org-lparse-end 'ENVIRONMENT style env-options-plist)
1777        (setq org-lparse-dyn-current-environment nil))))
1778
1779 (defun org-lparse-current-environment-p (style)
1780   (eq org-lparse-dyn-current-environment style))
1781
1782 (defun org-lparse-begin-footnote-definition (n)
1783   (org-lparse-begin-collect)
1784   (setq org-lparse-insert-tag-with-newlines nil)
1785   (org-lparse-begin 'FOOTNOTE-DEFINITION n))
1786
1787 (defun org-lparse-end-footnote-definition (n)
1788   (org-lparse-end 'FOOTNOTE-DEFINITION n)
1789   (setq org-lparse-insert-tag-with-newlines 'both)
1790   (let ((footnote-def (org-lparse-end-collect)))
1791     ;; Cleanup newlines in footnote definition.  This ensures that a
1792     ;; transcoded line is never (wrongly) broken in to multiple lines.
1793     (let ((pos 0))
1794       (while (string-match "[\r\n]+" footnote-def pos)
1795         (setq pos (1+ (match-beginning 0)))
1796         (setq footnote-def (replace-match " " t t footnote-def))))
1797     (push (cons n footnote-def) org-lparse-footnote-definitions)))
1798
1799 (defvar org-lparse-collect-buffer nil
1800   "An auxiliary buffer named \"*Org Lparse Collect*\".
1801 `org-do-lparse' uses this as output buffer while collecting
1802 footnote definitions and table-cell contents of list-tables.  See
1803 `org-lparse-begin-collect' and `org-lparse-end-collect'.")
1804
1805 (defvar org-lparse-collect-count nil
1806   "Count number of calls to `org-lparse-begin-collect'.
1807 Use this counter to catch chained collections if they ever
1808 happen.")
1809
1810 (defun org-lparse-begin-collect ()
1811   "Temporarily switch to `org-lparse-collect-buffer'.
1812 Also erase it's contents."
1813   (unless (zerop org-lparse-collect-count)
1814     (error "FIXME (org-lparse.el): Encountered chained collections"))
1815   (incf org-lparse-collect-count)
1816   (unless org-lparse-collect-buffer
1817     (setq org-lparse-collect-buffer
1818           (get-buffer-create "*Org Lparse Collect*")))
1819   (set-buffer org-lparse-collect-buffer)
1820   (erase-buffer))
1821
1822 (defun org-lparse-end-collect ()
1823   "Switch to `org-lparse-output-buffer'.
1824 Return contents of `org-lparse-collect-buffer' as a `string'."
1825   (assert (> org-lparse-collect-count 0))
1826   (decf org-lparse-collect-count)
1827   (prog1 (buffer-string)
1828     (erase-buffer)
1829     (set-buffer org-lparse-output-buffer)))
1830
1831 (defun org-lparse-format (entity &rest args)
1832   "Format ENTITY in backend-specific way and return it.
1833 ARGS is specific to entity being formatted.
1834
1835 Use (org-lparse-format 'HEADING \"text\" 1) to format text as
1836 level 1 heading.
1837
1838 See `org-xhtml-entity-format-callbacks-alist' for more information."
1839   (when (and (member org-lparse-debug '(t format))
1840              (not (equal entity 'COMMENT)))
1841     (insert (org-lparse-format 'COMMENT "%s: %S" entity args)))
1842   (cond
1843    ((consp entity)
1844     (let ((text (pop args)))
1845       (apply 'org-lparse-format 'TAGS entity text args)))
1846    (t
1847     (let ((f (cdr (assoc entity org-lparse-entity-format-callbacks-alist))))
1848       (unless f (error "Unknown entity: %s" entity))
1849       (apply f args)))))
1850
1851 (defun org-lparse-insert (entity &rest args)
1852   (insert (apply 'org-lparse-format entity args)))
1853
1854 (defun org-lparse-prepare-toc (lines level-offset opt-plist umax-toc)
1855   (let* ((quote-re0 (concat "^[ \t]*" org-quote-string "\\>"))
1856          (org-min-level (org-get-min-level lines level-offset))
1857          (org-last-level org-min-level)
1858          level)
1859     (with-temp-buffer
1860       (org-lparse-bind-local-variables opt-plist)
1861       (erase-buffer)
1862       (org-lparse-begin 'TOC (nth 3 (plist-get opt-plist :lang-words)) umax-toc)
1863       (setq
1864        lines
1865        (mapcar
1866         #'(lambda (line)
1867             (when (and (string-match org-todo-line-regexp line)
1868                        (not (get-text-property 0 'org-protected line))
1869                        (<= (setq level (org-tr-level
1870                                         (- (match-end 1) (match-beginning 1)
1871                                            level-offset)))
1872                            umax-toc))
1873               (let ((txt (save-match-data
1874                            (org-xml-encode-org-text-skip-links
1875                             (org-export-cleanup-toc-line
1876                              (match-string 3 line)))))
1877                     (todo (and
1878                            org-export-mark-todo-in-toc
1879                            (or (and (match-beginning 2)
1880                                     (not (member (match-string 2 line)
1881                                                  org-done-keywords)))
1882                                (and (= level umax-toc)
1883                                     (org-search-todo-below
1884                                      line lines level)))))
1885                     tags)
1886                 ;; Check for targets
1887                 (while (string-match org-any-target-regexp line)
1888                   (setq line
1889                         (replace-match
1890                          (let ((org-lparse-encode-pending t))
1891                            (org-lparse-format 'FONTIFY
1892                                               (match-string 1 line) "target"))
1893                          t t line)))
1894                 (when (string-match
1895                        (org-re "[ \t]+:\\([[:alnum:]_@:]+\\):[ \t]*$") txt)
1896                   (setq tags (match-string 1 txt)
1897                         txt (replace-match "" t nil txt)))
1898                 (when (string-match quote-re0 txt)
1899                   (setq txt (replace-match "" t t txt)))
1900                 (while (string-match "&lt;\\(&lt;\\)+\\|&gt;\\(&gt;\\)+" txt)
1901                   (setq txt (replace-match "" t t txt)))
1902                 (org-lparse-format
1903                  'TOC-ITEM
1904                  (let* ((snumber (org-section-number level))
1905                         (href (replace-regexp-in-string
1906                                "\\." "-" (format "sec-%s" snumber)))
1907                         (href
1908                          (or
1909                           (cdr (assoc
1910                                 href org-export-preferred-target-alist))
1911                           href))
1912                         (href (org-solidify-link-text href)))
1913                    (org-lparse-format 'TOC-ENTRY snumber todo txt tags href))
1914                  level org-last-level)
1915                 (setq org-last-level level)))
1916             line)
1917         lines))
1918       (org-lparse-end 'TOC)
1919       (setq org-lparse-toc (buffer-string))))
1920   lines)
1921
1922 (defun org-lparse-format-table-row (fields &optional text-for-empty-fields)
1923   (if org-lparse-table-ncols
1924       ;; second and subsequent rows of the table
1925       (when (and org-lparse-list-table-p
1926                  (> (length fields) org-lparse-table-ncols))
1927         (error "Table row has %d columns but header row claims %d columns"
1928                (length fields) org-lparse-table-ncols))
1929     ;; first row of the table
1930     (setq org-lparse-table-ncols (length fields))
1931     (when org-lparse-table-is-styled
1932       (setq org-lparse-table-num-numeric-items-per-column
1933             (make-vector org-lparse-table-ncols 0))
1934       (setq org-lparse-table-colalign-vector
1935             (make-vector org-lparse-table-ncols nil))
1936       (let ((c -1))
1937         (while  (< (incf c) org-lparse-table-ncols)
1938           (let* ((col-cookie (cdr (assoc (1+ c) org-lparse-table-colalign-info)))
1939                  (align (nth 0 col-cookie)))
1940             (setf (aref org-lparse-table-colalign-vector c)
1941                   (cond
1942                    ((string= align "l") "left")
1943                    ((string= align "r") "right")
1944                    ((string= align "c") "center"))))))))
1945   (incf org-lparse-table-rownum)
1946   (let ((i -1))
1947     (org-lparse-format
1948      'TABLE-ROW
1949      (mapconcat
1950       (lambda (x)
1951         (when (and (string= x "") text-for-empty-fields)
1952           (setq x text-for-empty-fields))
1953         (incf i)
1954         (let (col-cookie horiz-span)
1955           (when org-lparse-table-is-styled
1956             (when (and (< i org-lparse-table-ncols)
1957                        (string-match org-table-number-regexp x))
1958               (incf (aref org-lparse-table-num-numeric-items-per-column i)))
1959             (setq col-cookie (cdr (assoc (1+ i) org-lparse-table-colalign-info))
1960                   horiz-span (nth 1 col-cookie)))
1961           (org-lparse-format
1962            'TABLE-CELL x org-lparse-table-rownum i (or horiz-span 0))))
1963       fields "\n"))))
1964
1965 (defun org-lparse-get (what &optional opt-plist)
1966   "Query for value of WHAT for the current backend `org-lparse-backend'.
1967 See also `org-lparse-backend-get'."
1968   (if (boundp 'org-lparse-backend)
1969       (org-lparse-backend-get (symbol-name org-lparse-backend) what opt-plist)
1970     (error "org-lparse-backend is not bound yet")))
1971
1972 (defun org-lparse-backend-get (backend what &optional opt-plist)
1973   "Query BACKEND for value of WHAT.
1974 Dispatch the call to `org-<backend>-user-get'.  If that throws an
1975 error, dispatch the call to `org-<backend>-get'.  See
1976 `org-xhtml-get' for all known settings queried for by
1977 `org-lparse' during the course of export."
1978   (assert (stringp backend) t)
1979   (unless (org-lparse-backend-is-native-p backend)
1980     (error "Unknown native backend %s" backend))
1981   (let ((backend-get-method (intern (format "org-%s-get" backend)))
1982         (backend-user-get-method (intern (format "org-%s-user-get" backend))))
1983     (cond
1984      ((functionp backend-get-method)
1985       (condition-case nil
1986           (funcall backend-user-get-method what opt-plist)
1987         (error (funcall backend-get-method what opt-plist))))
1988      (t
1989       (error "Native backend %s doesn't define %s" backend backend-get-method)))))
1990
1991 (defun org-lparse-insert-tag (tag &rest args)
1992   (when (member org-lparse-insert-tag-with-newlines '(lead both))
1993     (insert  "\n"))
1994   (insert (apply 'format tag args))
1995   (when (member org-lparse-insert-tag-with-newlines '(trail both))
1996     (insert  "\n")))
1997
1998 (defun org-lparse-get-targets-from-title (title)
1999   (let* ((target (org-get-text-property-any 0 'target title))
2000          (extra-targets (assoc target org-export-target-aliases))
2001          (target (or (cdr (assoc target org-export-preferred-target-alist))
2002                      target)))
2003     (cons target (remove target extra-targets))))
2004
2005 (defun org-lparse-suffix-from-snumber (snumber)
2006   (let* ((snu (replace-regexp-in-string "\\." "-" snumber))
2007          (href (cdr (assoc (concat "sec-" snu)
2008                            org-export-preferred-target-alist))))
2009     (org-solidify-link-text (or href snu))))
2010
2011 (defun org-lparse-begin-level (level title umax head-count)
2012   "Insert a new LEVEL in HTML export.
2013 When TITLE is nil, just close all open levels."
2014   (org-lparse-end-level level umax)
2015   (unless title (error "Why is heading nil"))
2016   (let* ((targets (org-lparse-get-targets-from-title title))
2017          (target (car targets)) (extra-targets (cdr targets))
2018          (target (and target (org-solidify-link-text target)))
2019          (extra-class (org-get-text-property-any 0 'html-container-class title))
2020          snumber tags level1 class)
2021     (when (string-match (org-re "\\(:[[:alnum:]_@#%:]+:\\)[ \t]*$") title)
2022       (setq tags (and org-export-with-tags (match-string 1 title)))
2023       (setq title (replace-match "" t t title)))
2024     (if (> level umax)
2025         (progn
2026           (if (aref org-levels-open (1- level))
2027               (org-lparse-end-list-item-1)
2028             (aset org-levels-open (1- level) t)
2029             (org-lparse-end-paragraph)
2030             (org-lparse-begin-list 'unordered))
2031           (org-lparse-begin-list-item
2032            'unordered target (org-lparse-format
2033                               'HEADLINE title extra-targets tags)))
2034       (aset org-levels-open (1- level) t)
2035       (setq snumber (org-section-number level))
2036       (setq level1 (+ level (or (org-lparse-get 'TOPLEVEL-HLEVEL) 1) -1))
2037       (unless (= head-count 1)
2038         (org-lparse-end-outline-text-or-outline))
2039       (org-lparse-begin-outline-and-outline-text
2040        level1 snumber title tags target extra-targets extra-class)
2041       (org-lparse-begin-paragraph))))
2042
2043 (defun org-lparse-end-level (level umax)
2044   (org-lparse-end-paragraph)
2045   (loop for l from org-level-max downto level
2046         do (when (aref org-levels-open (1- l))
2047              ;; Terminate one level in HTML export
2048              (if (<= l umax)
2049                  (org-lparse-end-outline-text-or-outline)
2050                (org-lparse-end-list-item-1)
2051                (org-lparse-end-list 'unordered))
2052              (aset org-levels-open (1- l) nil))))
2053
2054 (defvar org-lparse-outline-text-open)
2055 (defun org-lparse-begin-outline-and-outline-text (level1 snumber title tags
2056                                                          target extra-targets
2057                                                          extra-class)
2058   (org-lparse-begin
2059    'OUTLINE level1 snumber title tags target extra-targets extra-class)
2060   (org-lparse-begin-outline-text level1 snumber extra-class))
2061
2062 (defun org-lparse-end-outline-text-or-outline ()
2063   (cond
2064    (org-lparse-outline-text-open
2065     (org-lparse-end 'OUTLINE-TEXT)
2066     (setq org-lparse-outline-text-open nil))
2067    (t (org-lparse-end 'OUTLINE))))
2068
2069 (defun org-lparse-begin-outline-text (level1 snumber extra-class)
2070   (assert (not org-lparse-outline-text-open) t)
2071   (setq org-lparse-outline-text-open t)
2072   (org-lparse-begin 'OUTLINE-TEXT level1 snumber extra-class))
2073
2074 (defun org-lparse-html-list-type-to-canonical-list-type (ltype)
2075   (cdr (assoc ltype '(("o" . ordered)
2076                       ("u" . unordered)
2077                       ("d" . description)))))
2078
2079 ;; following vars are bound during `org-do-lparse'
2080 (defvar org-lparse-list-stack)
2081 (defvar org-lparse-list-table:table-row)
2082 (defvar org-lparse-list-table:lines)
2083
2084 ;; Notes on LIST-TABLES
2085 ;; ====================
2086 ;; Lists withing "list-table" blocks (as shown below)
2087 ;;
2088 ;; #+begin_list-table
2089 ;; - Row 1
2090 ;;   - 1.1
2091 ;;   - 1.2
2092 ;;   - 1.3
2093 ;; - Row 2
2094 ;;   - 2.1
2095 ;;   - 2.2
2096 ;;   - 2.3
2097 ;; #+end_list-table
2098 ;;
2099 ;; will be exported as though it were a table as shown below.
2100 ;;
2101 ;; | Row 1 | 1.1 | 1.2 | 1.3 |
2102 ;; | Row 2 | 2.1 | 2.2 | 2.3 |
2103 ;;
2104 ;; Note that org-tables are NOT multi-line and each line is mapped to
2105 ;; a unique row in the exported document.  So if an exported table
2106 ;; needs to contain a single paragraph (with copious text) it needs to
2107 ;; be typed up in a single line.  Editing such long lines using the
2108 ;; table editor will be a cumbersome task.  Furthermore inclusion of
2109 ;; multi-paragraph text in a table cell is well-nigh impossible.
2110 ;;
2111 ;; LIST-TABLEs are meant to circumvent the above problems with
2112 ;; org-tables.
2113 ;;
2114 ;; Note that in the example above the list items could be paragraphs
2115 ;; themselves and the list can be arbitrarily deep.
2116 ;;
2117 ;; Inspired by following thread:
2118 ;; https://lists.gnu.org/archive/html/emacs-orgmode/2011-03/msg01101.html
2119
2120 (defun org-lparse-begin-list (ltype)
2121   (push ltype org-lparse-list-stack)
2122   (let ((list-level (length org-lparse-list-stack)))
2123     (cond
2124      ((not org-lparse-list-table-p)
2125       (org-lparse-begin 'LIST ltype))
2126      ;; process LIST-TABLE
2127      ((= 1 list-level)
2128       ;; begin LIST-TABLE
2129       (setq org-lparse-list-table:lines nil)
2130       (setq org-lparse-list-table:table-row nil))
2131      ((= 2 list-level)
2132       (ignore))
2133      (t
2134       (org-lparse-begin 'LIST ltype)))))
2135
2136 (defun org-lparse-end-list (ltype)
2137   (pop org-lparse-list-stack)
2138   (let ((list-level (length org-lparse-list-stack)))
2139     (cond
2140      ((not org-lparse-list-table-p)
2141       (org-lparse-end 'LIST ltype))
2142      ;; process LIST-TABLE
2143      ((= 0 list-level)
2144       ;; end LIST-TABLE
2145       (insert (org-lparse-format-list-table
2146                (nreverse org-lparse-list-table:lines))))
2147      ((= 1 list-level)
2148       (ignore))
2149      (t
2150       (org-lparse-end 'LIST ltype)))))
2151
2152 (defun org-lparse-begin-list-item (ltype &optional arg headline)
2153   (let ((list-level (length org-lparse-list-stack)))
2154     (cond
2155      ((not org-lparse-list-table-p)
2156       (org-lparse-begin 'LIST-ITEM ltype arg headline))
2157      ;; process LIST-TABLE
2158      ((= 1 list-level)
2159       ;; begin TABLE-ROW for LIST-TABLE
2160       (setq org-lparse-list-table:table-row nil)
2161       (org-lparse-begin-list-table:table-cell))
2162      ((= 2 list-level)
2163       ;; begin TABLE-CELL for LIST-TABLE
2164       (org-lparse-begin-list-table:table-cell))
2165      (t
2166       (org-lparse-begin 'LIST-ITEM ltype arg headline)))))
2167
2168 (defun org-lparse-end-list-item (ltype)
2169   (let ((list-level (length org-lparse-list-stack)))
2170     (cond
2171      ((not org-lparse-list-table-p)
2172       (org-lparse-end 'LIST-ITEM ltype))
2173      ;; process LIST-TABLE
2174      ((= 1 list-level)
2175       ;; end TABLE-ROW for LIST-TABLE
2176       (org-lparse-end-list-table:table-cell)
2177       (push (nreverse org-lparse-list-table:table-row)
2178             org-lparse-list-table:lines))
2179      ((= 2 list-level)
2180       ;; end TABLE-CELL for LIST-TABLE
2181       (org-lparse-end-list-table:table-cell))
2182      (t
2183       (org-lparse-end 'LIST-ITEM ltype)))))
2184
2185 (defvar org-lparse-list-table:table-cell-open)
2186 (defun org-lparse-begin-list-table:table-cell ()
2187   (org-lparse-end-list-table:table-cell)
2188   (setq org-lparse-list-table:table-cell-open t)
2189   (org-lparse-begin-collect)
2190   (org-lparse-begin-paragraph))
2191
2192 (defun org-lparse-end-list-table:table-cell ()
2193   (when org-lparse-list-table:table-cell-open
2194     (setq org-lparse-list-table:table-cell-open nil)
2195     (org-lparse-end-paragraph)
2196     (push (org-lparse-end-collect)
2197           org-lparse-list-table:table-row)))
2198
2199 (defvar org-lparse-table-rowgrp-info)
2200 (defun org-lparse-begin-table-rowgroup (&optional is-header-row)
2201   (push (cons (1+ org-lparse-table-rownum) :start) org-lparse-table-rowgrp-info)
2202   (org-lparse-begin 'TABLE-ROWGROUP is-header-row))
2203
2204 (defun org-lparse-end-table ()
2205   (when org-lparse-table-is-styled
2206     ;; column groups
2207     (unless (car org-table-colgroup-info)
2208       (setq org-table-colgroup-info
2209             (cons :start (cdr org-table-colgroup-info))))
2210
2211     ;; column alignment
2212     (let ((c -1))
2213       (mapc
2214        (lambda (x)
2215          (incf c)
2216          (setf (aref org-lparse-table-colalign-vector c)
2217                (or (aref org-lparse-table-colalign-vector c)
2218                    (if (> (/ (float x) (1+ org-lparse-table-rownum))
2219                           org-table-number-fraction)
2220                        "right" "left"))))
2221        org-lparse-table-num-numeric-items-per-column)))
2222   (org-lparse-end 'TABLE))
2223
2224 (defvar org-lparse-encode-pending nil)
2225
2226 (defun org-lparse-format-tags (tag text prefix suffix &rest args)
2227   (cond
2228    ((consp tag)
2229     (concat prefix (apply 'format (car tag) args) text suffix
2230             (format (cdr tag))))
2231    ((stringp tag)                       ; singleton tag
2232     (concat prefix (apply 'format tag args) text))))
2233
2234 (defun org-xml-fix-class-name (kwd)     ; audit callers of this function
2235   "Turn todo keyword into a valid class name.
2236 Replaces invalid characters with \"_\"."
2237   (save-match-data
2238     (while (string-match "[^a-zA-Z0-9_]" kwd)
2239       (setq kwd (replace-match "_" t t kwd))))
2240   kwd)
2241
2242 (defun org-lparse-format-todo (todo)
2243   (org-lparse-format 'FONTIFY
2244                      (concat
2245                       (ignore-errors (org-lparse-get 'TODO-KWD-CLASS-PREFIX))
2246                       (org-xml-fix-class-name todo))
2247                      (list (if (member todo org-done-keywords) "done" "todo")
2248                            todo)))
2249
2250 (defun org-lparse-format-extra-targets (extra-targets)
2251   (if (not extra-targets) ""
2252     (mapconcat (lambda (x)
2253                  (setq x (org-solidify-link-text
2254                           (if (org-uuidgen-p x) (concat "ID-" x) x)))
2255                  (org-lparse-format 'ANCHOR "" x))
2256                extra-targets "")))
2257
2258 (defun org-lparse-format-org-tags (tags)
2259   (if (not tags) ""
2260     (org-lparse-format
2261      'FONTIFY (mapconcat
2262                (lambda (x)
2263                  (org-lparse-format
2264                   'FONTIFY x
2265                   (concat
2266                    (ignore-errors (org-lparse-get 'TAG-CLASS-PREFIX))
2267                    (org-xml-fix-class-name x))))
2268                (org-split-string tags ":")
2269                (org-lparse-format 'SPACES 1)) "tag")))
2270
2271 (defun org-lparse-format-section-number (&optional snumber level)
2272   (and org-export-with-section-numbers
2273        (not org-lparse-body-only) snumber level
2274        (org-lparse-format 'FONTIFY snumber (format "section-number-%d" level))))
2275
2276 (defun org-lparse-warn (msg)
2277   (if (not org-lparse-use-flashy-warning)
2278       (message msg)
2279     (put-text-property 0 (length msg) 'face 'font-lock-warning-face msg)
2280     (message msg)
2281     (sleep-for 3)))
2282
2283 (defun org-xml-format-href (s)
2284   "Make sure the S is valid as a href reference in an XHTML document."
2285   (save-match-data
2286     (let ((start 0))
2287       (while (string-match "&" s start)
2288         (setq start (+ (match-beginning 0) 3)
2289               s (replace-match "&amp;" t t s)))))
2290   s)
2291
2292 (defun org-xml-format-desc (s)
2293   "Make sure the S is valid as a description in a link."
2294   (if (and s (not (get-text-property 1 'org-protected s)))
2295       (save-match-data
2296         (org-xml-encode-org-text s))
2297     s))
2298
2299 (provide 'org-lparse)
2300
2301 ;;; org-lparse.el ends here