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