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