Imported Upstream version 7.9.2

1 files changed, 2752 insertions, 0 deletions

diff --git a/lisp/org-html.el b/lisp/org-html.el
new file mode 100644
index 0000000..79b0286
--- /dev/null
+++ b/lisp/org-html.el
@@ -0,0 +1,2752 @@
+;;; org-html.el --- HTML export for Org-mode
+
+;; Copyright (C) 2004-2012 Free Software Foundation, Inc.
+
+;; Author: Carsten Dominik <carsten at orgmode dot org>
+;; Keywords: outlines, hypermedia, calendar, wp
+;; Homepage: http://orgmode.org
+;;
+;; This file is part of GNU Emacs.
+;;
+;; GNU Emacs is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;;; Commentary:
+
+;;; Code:
+
+(require 'org-exp)
+(require 'format-spec)
+
+(eval-when-compile (require 'cl))
+
+(declare-function org-id-find-id-file "org-id" (id))
+(declare-function htmlize-region "ext:htmlize" (beg end))
+(declare-function org-pop-to-buffer-same-window
+		  "org-compat" (&optional buffer-or-name norecord label))
+
+(defgroup org-export-html nil
+  "Options specific for HTML export of Org-mode files."
+  :tag "Org Export HTML"
+  :group 'org-export)
+
+(defcustom org-export-html-footnotes-section "<div id=\"footnotes\">
+<h2 class=\"footnotes\">%s: </h2>
+<div id=\"text-footnotes\">
+%s
+</div>
+</div>"
+  "Format for the footnotes section.
+Should contain a two instances of %s.  The first will be replaced with the
+language-specific word for \"Footnotes\", the second one will be replaced
+by the footnotes themselves."
+  :group 'org-export-html
+  :type 'string)
+
+(defcustom org-export-html-footnote-format "<sup>%s</sup>"
+  "The format for the footnote reference.
+%s will be replaced by the footnote reference itself."
+  :group 'org-export-html
+  :type 'string)
+
+
+(defcustom org-export-html-footnote-separator "<sup>, </sup>"
+  "Text used to separate footnotes."
+  :group 'org-export-html
+  :version "24.1"
+  :type 'string)
+
+(defcustom org-export-html-coding-system nil
+  "Coding system for HTML export, defaults to `buffer-file-coding-system'."
+  :group 'org-export-html
+  :type 'coding-system)
+
+(defcustom org-export-html-extension "html"
+  "The extension for exported HTML files."
+  :group 'org-export-html
+  :type 'string)
+
+(defcustom org-export-html-xml-declaration
+  '(("html" . "<?xml version=\"1.0\" encoding=\"%s\"?>")
+    ("php" . "<?php echo \"<?xml version=\\\"1.0\\\" encoding=\\\"%s\\\" ?>\"; ?>"))
+  "The extension for exported HTML files.
+%s will be replaced with the charset of the exported file.
+This may be a string, or an alist with export extensions
+and corresponding declarations."
+  :group 'org-export-html
+  :type '(choice
+	  (string :tag "Single declaration")
+	  (repeat :tag "Dependent on extension"
+		  (cons (string :tag "Extension")
+			(string :tag "Declaration")))))
+
+(defcustom org-export-html-style-include-scripts t
+  "Non-nil means include the JavaScript snippets in exported HTML files.
+The actual script is defined in `org-export-html-scripts' and should
+not be modified."
+  :group 'org-export-html
+  :type 'boolean)
+
+(defvar org-export-html-scripts
+  "<script type=\"text/javascript\">
+/*
+@licstart  The following is the entire license notice for the
+JavaScript code in this tag.
+
+Copyright (C) 2012  Free Software Foundation, Inc.
+
+The JavaScript code in this tag is free software: you can
+redistribute it and/or modify it under the terms of the GNU
+General Public License (GNU GPL) as published by the Free Software
+Foundation, either version 3 of the License, or (at your option)
+any later version.  The code is distributed WITHOUT ANY WARRANTY;
+without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU GPL for more details.
+
+As additional permission under GNU GPL version 3 section 7, you
+may distribute non-source (e.g., minimized or compacted) forms of
+that code without the copy of the GNU GPL normally required by
+section 4, provided you include this license notice and a URL
+through which recipients can access the Corresponding Source.
+
+
+@licend  The above is the entire license notice
+for the JavaScript code in this tag.
+*/
+<!--/*--><![CDATA[/*><!--*/
+ function CodeHighlightOn(elem, id)
+ {
+   var target = document.getElementById(id);
+   if(null != target) {
+     elem.cacheClassElem = elem.className;
+     elem.cacheClassTarget = target.className;
+     target.className = \"code-highlighted\";
+     elem.className   = \"code-highlighted\";
+   }
+ }
+ function CodeHighlightOff(elem, id)
+ {
+   var target = document.getElementById(id);
+   if(elem.cacheClassElem)
+     elem.className = elem.cacheClassElem;
+   if(elem.cacheClassTarget)
+     target.className = elem.cacheClassTarget;
+ }
+/*]]>*///-->
+</script>"
+  "Basic JavaScript that is needed by HTML files produced by Org-mode.")
+
+(defconst org-export-html-style-default
+  "<style type=\"text/css\">
+ <!--/*--><![CDATA[/*><!--*/
+  html { font-family: Times, serif; font-size: 12pt; }
+  .title  { text-align: center; }
+  .todo   { color: red; }
+  .done   { color: green; }
+  .tag    { background-color: #add8e6; font-weight:normal }
+  .target { }
+  .timestamp { color: #bebebe; }
+  .timestamp-kwd { color: #5f9ea0; }
+  .right  {margin-left:auto; margin-right:0px;  text-align:right;}
+  .left   {margin-left:0px;  margin-right:auto; text-align:left;}
+  .center {margin-left:auto; margin-right:auto; text-align:center;}
+  p.verse { margin-left: 3% }
+  pre {
+	border: 1pt solid #AEBDCC;
+	background-color: #F3F5F7;
+	padding: 5pt;
+	font-family: courier, monospace;
+        font-size: 90%;
+        overflow:auto;
+  }
+  table { border-collapse: collapse; }
+  td, th { vertical-align: top;  }
+  th.right  { text-align:center;  }
+  th.left   { text-align:center;   }
+  th.center { text-align:center; }
+  td.right  { text-align:right;  }
+  td.left   { text-align:left;   }
+  td.center { text-align:center; }
+  dt { font-weight: bold; }
+  div.figure { padding: 0.5em; }
+  div.figure p { text-align: center; }
+  div.inlinetask {
+    padding:10px;
+    border:2px solid gray;
+    margin:10px;
+    background: #ffffcc;
+  }
+  textarea { overflow-x: auto; }
+  .linenr { font-size:smaller }
+  .code-highlighted {background-color:#ffff00;}
+  .org-info-js_info-navigation { border-style:none; }
+  #org-info-js_console-label { font-size:10px; font-weight:bold;
+                               white-space:nowrap; }
+  .org-info-js_search-highlight {background-color:#ffff00; color:#000000;
+                                 font-weight:bold; }
+  /*]]>*/-->
+</style>"
+  "The default style specification for exported HTML files.
+Please use the variables `org-export-html-style' and
+`org-export-html-style-extra' to add to this style.  If you wish to not
+have the default style included, customize the variable
+`org-export-html-style-include-default'.")
+
+(defcustom org-export-html-style-include-default t
+  "Non-nil means include the default style in exported HTML files.
+The actual style is defined in `org-export-html-style-default' and should
+not be modified.  Use the variables `org-export-html-style' to add
+your own style information."
+  :group 'org-export-html
+  :type 'boolean)
+;;;###autoload
+(put 'org-export-html-style-include-default 'safe-local-variable 'booleanp)
+
+(defcustom org-export-html-style ""
+  "Org-wide style definitions for exported HTML files.
+
+This variable needs to contain the full HTML structure to provide a style,
+including the surrounding HTML tags.  If you set the value of this variable,
+you should consider to include definitions for the following classes:
+ title, todo, done, timestamp, timestamp-kwd, tag, target.
+
+For example, a valid value would be:
+
+   <style type=\"text/css\">
+    <![CDATA[
+       p { font-weight: normal; color: gray; }
+       h1 { color: black; }
+      .title { text-align: center; }
+      .todo, .timestamp-kwd { color: red; }
+      .done { color: green; }
+    ]]>
+   </style>
+
+If you'd like to refer to an external style file, use something like
+
+   <link rel=\"stylesheet\" type=\"text/css\" href=\"mystyles.css\">
+
+As the value of this option simply gets inserted into the HTML <head> header,
+you can \"misuse\" it to add arbitrary text to the header.
+See also the variable `org-export-html-style-extra'."
+  :group 'org-export-html
+  :type 'string)
+;;;###autoload
+(put 'org-export-html-style 'safe-local-variable 'stringp)
+
+(defcustom org-export-html-style-extra ""
+  "Additional style information for HTML export.
+The value of this variable is inserted into the HTML buffer right after
+the value of `org-export-html-style'.  Use this variable for per-file
+settings of style information, and do not forget to surround the style
+settings with <style>...</style> tags."
+  :group 'org-export-html
+  :type 'string)
+;;;###autoload
+(put 'org-export-html-style-extra 'safe-local-variable 'stringp)
+
+(defcustom org-export-html-mathjax-options
+  '((path  "http://orgmode.org/mathjax/MathJax.js")
+    (scale "100")
+    (align "center")
+    (indent "2em")
+    (mathml nil))
+  "Options for MathJax setup.
+
+path        The path where to find MathJax
+scale       Scaling for the HTML-CSS backend, usually between 100 and 133
+align       How to align display math: left, center, or right
+indent      If align is not center, how far from the left/right side?
+mathml      Should a MathML player be used if available?
+            This is faster and reduces bandwidth use, but currently
+            sometimes has lower spacing quality.  Therefore, the default is
+            nil.  When browsers get better, this switch can be flipped.
+
+You can also customize this for each buffer, using something like
+
+#+MATHJAX: scale:\"133\" align:\"right\" mathml:t path:\"/MathJax/\""
+  :group 'org-export-html
+  :version "24.1"
+  :type '(list :greedy t
+	       (list :tag "path   (the path from where to load MathJax.js)"
+		     (const :format "       " path) (string))
+	       (list :tag "scale  (scaling for the displayed math)"
+		     (const :format "       " scale) (string))
+	       (list :tag "align  (alignment of displayed equations)"
+		     (const :format "       " align) (string))
+	       (list :tag "indent (indentation with left or right alignment)"
+		     (const :format "       " indent) (string))
+	       (list :tag "mathml (should MathML display be used is possible)"
+		     (const :format "       " mathml) (boolean))))
+
+(defun org-export-html-mathjax-config (template options in-buffer)
+  "Insert the user setup into the matchjax template."
+  (let (name val (yes "   ") (no "// ") x)
+    (mapc
+     (lambda (e)
+       (setq name (car e) val (nth 1 e))
+       (if (string-match (concat "\\<" (symbol-name name) ":") in-buffer)
+	   (setq val (car (read-from-string
+			   (substring in-buffer (match-end 0))))))
+       (if (not (stringp val)) (setq val (format "%s" val)))
+       (setq template
+	     (replace-regexp-in-string
+	      (concat "%" (upcase (symbol-name name))) val template t t)))
+     options)
+    (setq val (nth 1 (assq 'mathml options)))
+    (if (string-match (concat "\\<mathml:") in-buffer)
+	(setq val (car (read-from-string
+			(substring in-buffer (match-end 0))))))
+    ;; Exchange prefixes depending on mathml setting
+    (if (not val) (setq x yes yes no no x))
+    ;; Replace cookies to turn on or off the config/jax lines
+    (if (string-match ":MMLYES:" template)
+	(setq template (replace-match yes t t template)))
+    (if (string-match ":MMLNO:" template)
+	(setq template (replace-match no t t template)))
+    ;; Return the modified template
+    template))
+
+(defcustom org-export-html-mathjax-template
+  "<script type=\"text/javascript\" src=\"%PATH\">
+/**
+ *
+ * @source: %PATH
+ *
+ * @licstart  The following is the entire license notice for the
+ *  JavaScript code in %PATH.
+ *
+ * Copyright (C) 2012  MathJax
+ *
+ * Licensed under the Apache License, Version 2.0 (the \"License\");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an \"AS IS\" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * @licend  The above is the entire license notice
+ * for the JavaScript code in %PATH.
+ *
+ */
+
+/*
+@licstart  The following is the entire license notice for the
+JavaScript code below.
+
+Copyright (C) 2012  Free Software Foundation, Inc.
+
+The JavaScript code below is free software: you can
+redistribute it and/or modify it under the terms of the GNU
+General Public License (GNU GPL) as published by the Free Software
+Foundation, either version 3 of the License, or (at your option)
+any later version.  The code is distributed WITHOUT ANY WARRANTY;
+without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE.  See the GNU GPL for more details.
+
+As additional permission under GNU GPL version 3 section 7, you
+may distribute non-source (e.g., minimized or compacted) forms of
+that code without the copy of the GNU GPL normally required by
+section 4, provided you include this license notice and a URL
+through which recipients can access the Corresponding Source.
+
+
+@licend  The above is the entire license notice
+for the JavaScript code below.
+*/
+<!--/*--><![CDATA[/*><!--*/
+    MathJax.Hub.Config({
+        // Only one of the two following lines, depending on user settings
+        // First allows browser-native MathML display, second forces HTML/CSS
+        :MMLYES: config: [\"MMLorHTML.js\"], jax: [\"input/TeX\"],
+        :MMLNO: jax: [\"input/TeX\", \"output/HTML-CSS\"],
+        extensions: [\"tex2jax.js\",\"TeX/AMSmath.js\",\"TeX/AMSsymbols.js\",
+                     \"TeX/noUndefined.js\"],
+        tex2jax: {
+            inlineMath: [ [\"\\\\(\",\"\\\\)\"] ],
+            displayMath: [ ['$$','$$'], [\"\\\\[\",\"\\\\]\"], [\"\\\\begin{displaymath}\",\"\\\\end{displaymath}\"] ],
+            skipTags: [\"script\",\"noscript\",\"style\",\"textarea\",\"pre\",\"code\"],
+            ignoreClass: \"tex2jax_ignore\",
+            processEscapes: false,
+            processEnvironments: true,
+            preview: \"TeX\"
+        },
+        showProcessingMessages: true,
+        displayAlign: \"%ALIGN\",
+        displayIndent: \"%INDENT\",
+
+        \"HTML-CSS\": {
+             scale: %SCALE,
+             availableFonts: [\"STIX\",\"TeX\"],
+             preferredFont: \"TeX\",
+             webFont: \"TeX\",
+             imageFont: \"TeX\",
+             showMathMenu: true,
+        },
+        MMLorHTML: {
+             prefer: {
+                 MSIE:    \"MML\",
+                 Firefox: \"MML\",
+                 Opera:   \"HTML\",
+                 other:   \"HTML\"
+             }
+        }
+    });
+/*]]>*///-->
+</script>"
+  "The MathJax setup for XHTML files."
+  :group 'org-export-html
+  :version "24.1"
+  :type 'string)
+
+(defcustom org-export-html-tag-class-prefix ""
+  "Prefix to class names for TODO keywords.
+Each tag gets a class given by the tag itself, with this prefix.
+The default prefix is empty because it is nice to just use the keyword
+as a class name.  But if you get into conflicts with other, existing
+CSS classes, then this prefix can be very useful."
+  :group 'org-export-html
+  :type 'string)
+
+(defcustom org-export-html-todo-kwd-class-prefix ""
+  "Prefix to class names for TODO keywords.
+Each TODO keyword gets a class given by the keyword itself, with this prefix.
+The default prefix is empty because it is nice to just use the keyword
+as a class name.  But if you get into conflicts with other, existing
+CSS classes, then this prefix can be very useful."
+  :group 'org-export-html
+  :type 'string)
+
+(defcustom org-export-html-headline-anchor-format "<a name=\"%s\" id=\"%s\"></a>"
+  "Format for anchors in HTML headlines.
+It requires to %s: both will be replaced by the anchor referring
+to the headline (e.g. \"sec-2\").  When set to `nil', don't insert
+HTML anchors in headlines."
+  :group 'org-export-html
+  :version "24.1"
+  :type 'string)
+
+(defcustom org-export-html-preamble t
+  "Non-nil means insert a preamble in HTML export.
+
+When `t', insert a string as defined by one of the formatting
+strings in `org-export-html-preamble-format'.  When set to a
+string, this string overrides `org-export-html-preamble-format'.
+When set to a function, apply this function and insert the
+returned string.  The function takes no argument, but you can
+use `opt-plist' to access the current export options.
+
+Setting :html-preamble in publishing projects will take
+precedence over this variable."
+  :group 'org-export-html
+  :type '(choice (const :tag "No preamble" nil)
+		 (const :tag "Default preamble" t)
+		 (string :tag "Custom format string")
+		 (function :tag "Function (must return a string)")))
+
+(defcustom org-export-html-preamble-format '(("en" ""))
+  "Alist of languages and format strings for the HTML preamble.
+
+The first element of each list is the language code, as used for
+the #+LANGUAGE keyword.
+
+The second element of each list is a format string to format the
+preamble itself.  This format string can contain these elements:
+
+%t stands for the title.
+%a stands for the author's name.
+%e stands for the author's email.
+%d stands for the date.
+
+If you need to use a \"%\" character, you need to escape it
+like that: \"%%\"."
+  :group 'org-export-html
+  :version "24.1"
+  :type 'string)
+
+(defcustom org-export-html-postamble 'auto
+  "Non-nil means insert a postamble in HTML export.
+
+When `t', insert a string as defined by the format string in
+`org-export-html-postamble-format'.  When set to a string, this
+string overrides `org-export-html-postamble-format'.  When set to
+'auto, discard `org-export-html-postamble-format' and honor
+`org-export-author/email/creator-info' variables.  When set to a
+function, apply this function and insert the returned string.
+The function takes no argument, but you can use `opt-plist' to
+access the current export options.
+
+Setting :html-postamble in publishing projects will take
+precedence over this variable."
+  :group 'org-export-html
+  :type '(choice (const :tag "No postamble" nil)
+		 (const :tag "Auto preamble" 'auto)
+		 (const :tag "Default format string" t)
+		 (string :tag "Custom format string")
+		 (function :tag "Function (must return a string)")))
+
+(defcustom org-export-html-postamble-format
+  '(("en" "<p class=\"author\">Author: %a (%e)</p>
+<p class=\"date\">Date: %d</p>
+<p class=\"creator\">Generated by %c</p>
+<p class=\"xhtml-validation\">%v</p>
+"))
+  "Alist of languages and format strings for the HTML postamble.
+
+The first element of each list is the language code, as used for
+the #+LANGUAGE keyword.
+
+The second element of each list is a format string to format the
+postamble itself.  This format string can contain these elements:
+
+%a stands for the author's name.
+%e stands for the author's email.
+%d stands for the date.
+%c will be replaced by information about Org/Emacs versions.
+%v will be replaced by `org-export-html-validation-link'.
+
+If you need to use a \"%\" character, you need to escape it
+like that: \"%%\"."
+  :group 'org-export-html
+  :version "24.1"
+  :type 'string)
+
+(defcustom org-export-html-home/up-format
+  "<div id=\"org-div-home-and-up\" style=\"text-align:right;font-size:70%%;white-space:nowrap;\">
+ <a accesskey=\"h\" href=\"%s\"> UP </a>
+ |
+ <a accesskey=\"H\" href=\"%s\"> HOME </a>
+</div>"
+  "Snippet used to insert the HOME and UP links.
+This is a format string, the first %s will receive the UP link,
+the second the HOME link.  If both `org-export-html-link-up' and
+`org-export-html-link-home' are empty, the entire snippet will be
+ignored."
+  :group 'org-export-html
+  :type 'string)
+
+(defcustom org-export-html-toplevel-hlevel 2
+  "The <H> level for level 1 headings in HTML export.
+This is also important for the classes that will be wrapped around headlines
+and outline structure.  If this variable is 1, the top-level headlines will
+be <h1>, and the corresponding classes will be outline-1, section-number-1,
+and outline-text-1.  If this is 2, all of these will get a 2 instead.
+The default for this variable is 2, because we use <h1> for formatting the
+document title."
+  :group 'org-export-html
+  :type 'string)
+
+(defcustom org-export-html-link-org-files-as-html t
+  "Non-nil means make file links to `file.org' point to `file.html'.
+When org-mode is exporting an org-mode file to HTML, links to
+non-html files are directly put into a href tag in HTML.
+However, links to other Org-mode files (recognized by the
+extension `.org.) should become links to the corresponding html
+file, assuming that the linked org-mode file will also be
+converted to HTML.
+When nil, the links still point to the plain `.org' file."
+  :group 'org-export-html
+  :type 'boolean)
+
+(defcustom org-export-html-inline-images 'maybe
+  "Non-nil means inline images into exported HTML pages.
+This is done using an <img> tag.  When nil, an anchor with href is used to
+link to the image.  If this option is `maybe', then images in links with
+an empty description will be inlined, while images with a description will
+be linked only."
+  :group 'org-export-html
+  :type '(choice (const :tag "Never" nil)
+		 (const :tag "Always" t)
+		 (const :tag "When there is no description" maybe)))
+
+(defcustom org-export-html-inline-image-extensions
+  '("png" "jpeg" "jpg" "gif" "svg")
+  "Extensions of image files that can be inlined into HTML."
+  :group 'org-export-html
+  :type '(repeat (string :tag "Extension")))
+
+(defcustom org-export-html-table-tag
+  "<table border=\"2\" cellspacing=\"0\" cellpadding=\"6\" rules=\"groups\" frame=\"hsides\">"
+  "The HTML tag that is used to start a table.
+This must be a <table> tag, but you may change the options like
+borders and spacing."
+  :group 'org-export-html
+  :type 'string)
+
+(defcustom org-export-table-header-tags '("<th scope=\"%s\"%s>" . "</th>")
+  "The opening tag for table header fields.
+This is customizable so that alignment options can be specified.
+The first %s will be filled with the scope of the field, either row or col.
+The second %s will be replaced by a style entry to align the field.
+See also the variable `org-export-html-table-use-header-tags-for-first-column'.
+See also the variable `org-export-html-table-align-individual-fields'."
+  :group 'org-export-tables
+  :type '(cons (string :tag "Opening tag") (string :tag "Closing tag")))
+
+(defcustom org-export-table-data-tags '("<td%s>" . "</td>")
+  "The opening tag for table data fields.
+This is customizable so that alignment options can be specified.
+The first %s will be filled with the scope of the field, either row or col.
+The second %s will be replaced by a style entry to align the field.
+See also the variable `org-export-html-table-align-individual-fields'."
+  :group 'org-export-tables
+  :type '(cons (string :tag "Opening tag") (string :tag "Closing tag")))
+
+(defcustom org-export-table-row-tags '("<tr>" . "</tr>")
+  "The opening tag for table data fields.
+This is customizable so that alignment options can be specified.
+Instead of strings, these can be Lisp forms that will be evaluated
+for each row in order to construct the table row tags.  During evaluation,
+the variable `head' will be true when this is a header line, nil when this
+is a body line.  And the variable `nline' will contain the line number,
+starting from 1 in the first header line.  For example
+
+  (setq org-export-table-row-tags
+        (cons '(if head
+                   \"<tr>\"
+                 (if (= (mod nline 2) 1)
+                     \"<tr class=\\\"tr-odd\\\">\"
+                   \"<tr class=\\\"tr-even\\\">\"))
+              \"</tr>\"))
+
+will give even lines the class \"tr-even\" and odd lines the class \"tr-odd\"."
+  :group 'org-export-tables
+  :type '(cons
+	  (choice :tag "Opening tag"
+		  (string :tag "Specify")
+		  (sexp))
+	  (choice :tag "Closing tag"
+		  (string :tag "Specify")
+		  (sexp))))
+
+(defcustom org-export-html-table-align-individual-fields t
+  "Non-nil means attach style attributes for alignment to each table field.
+When nil, alignment will only be specified in the column tags, but this
+is ignored by some browsers (like Firefox, Safari).  Opera does it right
+though."
+  :group 'org-export-tables
+  :version "24.1"
+  :type 'boolean)
+
+(defcustom org-export-html-table-use-header-tags-for-first-column nil
+  "Non-nil means format column one in tables with header tags.
+When nil, also column one will use data tags."
+  :group 'org-export-tables
+  :type 'boolean)
+
+(defcustom org-export-html-validation-link
+  "<a href=\"http://validator.w3.org/check?uri=referer\">Validate XHTML 1.0</a>"
+  "Link to HTML validation service."
+  :group 'org-export-html
+  :type 'string)
+
+;; FIXME Obsolete since Org 7.7
+;; Use the :timestamp option or `org-export-time-stamp-file' instead
+(defvar org-export-html-with-timestamp nil
+  "If non-nil, write container for HTML-helper-mode timestamp.")
+
+;; FIXME Obsolete since Org 7.7
+(defvar org-export-html-html-helper-timestamp
+  "\n<p><br/><br/>\n<!-- hhmts start --> <!-- hhmts end --></p>\n"
+  "The HTML tag used as timestamp delimiter for HTML-helper-mode.")
+
+(defcustom org-export-html-protect-char-alist
+  '(("&" . "&amp;")
+    ("<" . "&lt;")
+    (">" . "&gt;"))
+  "Alist of characters to be converted by `org-html-protect'."
+  :group 'org-export-html
+  :version "24.1"
+  :type '(repeat (cons (string :tag "Character")
+		       (string :tag "HTML equivalent"))))
+
+(defgroup org-export-htmlize nil
+  "Options for processing examples with htmlize.el."
+  :tag "Org Export Htmlize"
+  :group 'org-export-html)
+
+(defcustom org-export-htmlize-output-type 'inline-css
+  "Output type to be used by htmlize when formatting code snippets.
+Choices are `css', to export the CSS selectors only, or `inline-css', to
+export the CSS attribute values inline in the HTML.  We use as default
+`inline-css', in order to make the resulting HTML self-containing.
+
+However, this will fail when using Emacs in batch mode for export, because
+then no rich font definitions are in place.  It will also not be good if
+people with different Emacs setup contribute HTML files to a website,
+because the fonts will represent the individual setups.  In these cases,
+it is much better to let Org/Htmlize assign classes only, and to use
+a style file to define the look of these classes.
+To get a start for your css file, start Emacs session and make sure that
+all the faces you are interested in are defined, for example by loading files
+in all modes you want.  Then, use the command
+\\[org-export-htmlize-generate-css] to extract class definitions."
+  :group 'org-export-htmlize
+  :type '(choice (const css) (const inline-css)))
+
+(defcustom org-export-htmlize-css-font-prefix "org-"
+  "The prefix for CSS class names for htmlize font specifications."
+  :group 'org-export-htmlize
+  :type 'string)
+
+(defcustom org-export-htmlized-org-css-url nil
+  "URL pointing to a CSS file defining text colors for htmlized Emacs buffers.
+Normally when creating an htmlized version of an Org buffer, htmlize will
+create CSS to define the font colors.  However, this does not work when
+converting in batch mode, and it also can look bad if different people
+with different fontification setup work on the same website.
+When this variable is non-nil, creating an htmlized version of an Org buffer
+using `org-export-as-org' will remove the internal CSS section and replace it
+with a link to this URL."
+  :group 'org-export-htmlize
+  :type '(choice
+	  (const :tag "Keep internal css" nil)
+	  (string :tag "URL or local href")))
+
+;; FIXME: The following variable is obsolete since Org 7.7 but is
+;; still declared and checked within code for compatibility reasons.
+;; Use the custom variables `org-export-html-divs' instead.
+(defvar org-export-html-content-div "content"
+  "The name of the container DIV that holds all the page contents.
+
+This variable is obsolete since Org version 7.7.
+Please set `org-export-html-divs' instead.")
+
+(defcustom org-export-html-divs '("preamble" "content" "postamble")
+  "The name of the main divs for HTML export.
+This is a list of three strings, the first one for the preamble
+DIV, the second one for the content DIV and the third one for the
+postamble DIV."
+  :group 'org-export-html
+  :version "24.1"
+  :type '(list
+	  (string :tag " Div for the preamble:")
+	  (string :tag "  Div for the content:")
+	  (string :tag "Div for the postamble:")))
+
+(defcustom org-export-html-date-format-string "%Y-%m-%dT%R%z"
+  "Format string to format the date and time.
+
+The default is an extended format of the ISO 8601 specification."
+  :group 'org-export-html
+  :version "24.1"
+  :type 'string)
+
+;;; Hooks
+
+(defvar org-export-html-after-blockquotes-hook nil
+  "Hook run during HTML export, after blockquote, verse, center are done.")
+
+(defvar org-export-html-final-hook nil
+  "Hook run at the end of HTML export, in the new buffer.")
+
+;;; HTML export
+
+(defun org-export-html-preprocess (parameters)
+  "Convert LaTeX fragments to images."
+  (when (and org-current-export-file
+	     (plist-get parameters :LaTeX-fragments))
+    (org-format-latex
+     (concat org-latex-preview-ltxpng-directory (file-name-sans-extension
+			(file-name-nondirectory
+			 org-current-export-file)))
+     org-current-export-dir nil "Creating LaTeX image %s"
+     nil nil
+     (cond
+      ((eq (plist-get parameters :LaTeX-fragments) 'verbatim) 'verbatim)
+      ((eq (plist-get parameters :LaTeX-fragments) 'mathjax ) 'mathjax)
+      ((eq (plist-get parameters :LaTeX-fragments) t        ) 'mathjax)
+      ((eq (plist-get parameters :LaTeX-fragments) 'imagemagick) 'imagemagick)
+      ((eq (plist-get parameters :LaTeX-fragments) 'dvipng  ) 'dvipng))))
+  (goto-char (point-min))
+  (let (label l1)
+    (while (re-search-forward "\\\\ref{\\([^{}\n]+\\)}" nil t)
+      (org-if-unprotected-at (match-beginning 1)
+	(setq label (match-string 1))
+	(save-match-data
+	  (if (string-match "\\`[a-z]\\{1,10\\}:\\(.+\\)" label)
+	      (setq l1 (substring label (match-beginning 1)))
+	    (setq l1 label)))
+	(replace-match (format "[[#%s][%s]]" label l1) t t)))))
+
+;;;###autoload
+(defun org-export-as-html-and-open (arg)
+  "Export the outline as HTML and immediately open it with a browser.
+If there is an active region, export only the region.
+The prefix ARG specifies how many levels of the outline should become
+headlines.  The default is 3.  Lower levels will become bulleted lists."
+  (interactive "P")
+  (org-export-as-html arg 'hidden)
+  (org-open-file buffer-file-name)
+  (when org-export-kill-product-buffer-when-displayed
+    (kill-buffer (current-buffer))))
+
+;;;###autoload
+(defun org-export-as-html-batch ()
+  "Call the function `org-export-as-html'.
+This function can be used in batch processing as:
+emacs   --batch
+        --load=$HOME/lib/emacs/org.el
+        --eval \"(setq org-export-headline-levels 2)\"
+        --visit=MyFile --funcall org-export-as-html-batch"
+  (org-export-as-html org-export-headline-levels 'hidden))
+
+;;;###autoload
+(defun org-export-as-html-to-buffer (arg)
+  "Call `org-export-as-html` with output to a temporary buffer.
+No file is created.  The prefix ARG is passed through to `org-export-as-html'."
+  (interactive "P")
+  (org-export-as-html arg nil nil "*Org HTML Export*")
+  (when org-export-show-temporary-export-buffer
+    (switch-to-buffer-other-window "*Org HTML Export*")))
+
+;;;###autoload
+(defun org-replace-region-by-html (beg end)
+  "Assume the current region has org-mode syntax, and convert it to HTML.
+This can be used in any buffer.  For example, you could write an
+itemized list in org-mode syntax in an HTML buffer and then use this
+command to convert it."
+  (interactive "r")
+  (let (reg html buf pop-up-frames)
+    (save-window-excursion
+      (if (derived-mode-p 'org-mode)
+	  (setq html (org-export-region-as-html
+		      beg end t 'string))
+	(setq reg (buffer-substring beg end)
+	      buf (get-buffer-create "*Org tmp*"))
+	(with-current-buffer buf
+	  (erase-buffer)
+	  (insert reg)
+	  (org-mode)
+	  (setq html (org-export-region-as-html
+		      (point-min) (point-max) t 'string)))
+	(kill-buffer buf)))
+    (delete-region beg end)
+    (insert html)))
+
+;;;###autoload
+(defun org-export-region-as-html (beg end &optional body-only buffer)
+  "Convert region from BEG to END in org-mode buffer to HTML.
+If prefix arg BODY-ONLY is set, omit file header, footer, and table of
+contents, and only produce the region of converted text, useful for
+cut-and-paste operations.
+If BUFFER is a buffer or a string, use/create that buffer as a target
+of the converted HTML.  If BUFFER is the symbol `string', return the
+produced HTML as a string and leave not buffer behind.  For example,
+a Lisp program could call this function in the following way:
+
+  (setq html (org-export-region-as-html beg end t 'string))
+
+When called interactively, the output buffer is selected, and shown
+in a window.  A non-interactive call will only return the buffer."
+  (interactive "r\nP")
+  (when (org-called-interactively-p 'any)
+    (setq buffer "*Org HTML Export*"))
+  (let ((transient-mark-mode t) (zmacs-regions t)
+	ext-plist rtn)
+    (setq ext-plist (plist-put ext-plist :ignore-subtree-p t))
+    (goto-char end)
+    (set-mark (point)) ;; to activate the region
+    (goto-char beg)
+    (setq rtn (org-export-as-html
+	       nil nil ext-plist
+	       buffer body-only))
+    (if (fboundp 'deactivate-mark) (deactivate-mark))
+    (if (and (org-called-interactively-p 'any) (bufferp rtn))
+	(switch-to-buffer-other-window rtn)
+      rtn)))
+
+(defvar html-table-tag nil) ; dynamically scoped into this.
+(defvar org-par-open nil)
+
+;;; org-html-cvt-link-fn
+(defconst org-html-cvt-link-fn
+  nil
+  "Function to convert link URLs to exportable URLs.
+Takes two arguments, TYPE and PATH.
+Returns exportable url as (TYPE PATH), or nil to signal that it
+didn't handle this case.
+Intended to be locally bound around a call to `org-export-as-html'." )
+
+(defun org-html-cvt-org-as-html (opt-plist type path)
+  "Convert an org filename to an equivalent html filename.
+If TYPE is not file, just return `nil'.
+See variable `org-export-html-link-org-files-as-html'"
+
+  (save-match-data
+    (and
+     org-export-html-link-org-files-as-html
+     (string= type "file")
+     (string-match "\\.org$" path)
+     (progn
+       (list
+	"file"
+	(concat
+	 (substring path 0 (match-beginning 0))
+	 "."
+	 (plist-get opt-plist :html-extension)))))))
+
+
+;;; org-html-should-inline-p
+(defun org-html-should-inline-p (filename descp)
+  "Return non-nil if link FILENAME should be inlined.
+The decision to inline the FILENAME link is based on the current
+settings.  DESCP is the boolean of whether there was a link
+description.  See variables `org-export-html-inline-images' and
+`org-export-html-inline-image-extensions'."
+  (declare (special
+	    org-export-html-inline-images
+	    org-export-html-inline-image-extensions))
+  (and (or (eq t org-export-html-inline-images)
+	   (and org-export-html-inline-images (not descp)))
+       (org-file-image-p
+	filename org-export-html-inline-image-extensions)))
+
+;;; org-html-make-link
+(defun org-html-make-link (opt-plist type path fragment desc attr
+				     may-inline-p)
+  "Make an HTML link.
+OPT-PLIST is an options list.
+TYPE is the device-type of the link (THIS://foo.html).
+PATH is the path of the link (http://THIS#location).
+FRAGMENT is the fragment part of the link, if any (foo.html#THIS).
+DESC is the link description, if any.
+ATTR is a string of other attributes of the \"a\" element.
+MAY-INLINE-P allows inlining it as an image."
+
+  (declare (special org-par-open))
+  (save-match-data
+    (let* ((filename path)
+	   ;;First pass.  Just sanity stuff.
+	   (components-1
+	    (cond
+	     ((string= type "file")
+	      (list
+	       type
+	       ;;Substitute just if original path was absolute.
+	       ;;(Otherwise path must remain relative)
+	       (if (file-name-absolute-p path)
+		   (concat "file://" (expand-file-name path))
+		 path)))
+	     ((string= type "")
+	      (list nil path))
+	     (t (list type path))))
+
+	   ;;Second pass.  Components converted so they can refer
+	   ;;to a remote site.
+	   (components-2
+	    (or
+	     (and org-html-cvt-link-fn
+		  (apply org-html-cvt-link-fn
+			 opt-plist components-1))
+	     (apply #'org-html-cvt-org-as-html
+		    opt-plist components-1)
+	     components-1))
+	   (type    (first  components-2))
+	   (thefile (second components-2)))
+
+
+      ;;Third pass.  Build final link except for leading type
+      ;;spec.
+      (cond
+       ((or
+	 (not type)
+	 (string= type "http")
+	 (string= type "https")
+	 (string= type "file")
+	 (string= type "coderef"))
+	(if fragment
+	    (setq thefile (concat thefile "#" fragment))))
+
+       (t))
+
+      ;;Final URL-build, for all types.
+      (setq thefile
+	    (let
+		((str (org-export-html-format-href thefile)))
+	      (if (and type (not (or (string= "file" type)
+				     (string= "coderef" type))))
+		  (concat type ":" str)
+		str)))
+
+      (if (and
+	   may-inline-p
+	   ;;Can't inline a URL with a fragment.
+	   (not fragment))
+	  (progn
+	    (message "image %s %s" thefile org-par-open)
+	    (org-export-html-format-image thefile org-par-open))
+	(concat
+	 "<a href=\"" thefile "\"" (if attr (concat " " attr)) ">"
+	 (org-export-html-format-desc desc)
+	 "</a>")))))
+
+(defun org-html-handle-links (org-line opt-plist)
+  "Return ORG-LINE with markup of Org mode links.
+OPT-PLIST is the export options list."
+  (let ((start 0)
+	(current-dir (if buffer-file-name
+			 (file-name-directory buffer-file-name)
+		       default-directory))
+	(link-validate (plist-get opt-plist :link-validation-function))
+	type id-file fnc
+	rpl path attr desc descp desc1 desc2 link)
+    (while (string-match org-bracket-link-analytic-regexp++ org-line start)
+      (setq start (match-beginning 0))
+      (setq path (save-match-data (org-link-unescape
+				   (match-string 3 org-line))))
+      (setq type (cond
+		  ((match-end 2) (match-string 2 org-line))
+		  ((save-match-data
+		     (or (file-name-absolute-p path)
+			 (string-match "^\\.\\.?/" path)))
+		   "file")
+		  (t "internal")))
+      (setq path (org-extract-attributes path))
+      (setq attr (get-text-property 0 'org-attributes path))
+      (setq desc1 (if (match-end 5) (match-string 5 org-line))
+	    desc2 (if (match-end 2) (concat type ":" path) path)
+	    descp (and desc1 (not (equal desc1 desc2)))
+	    desc (or desc1 desc2))
+      ;; Make an image out of the description if that is so wanted
+      (when (and descp (org-file-image-p
+			desc org-export-html-inline-image-extensions))
+	(save-match-data
+	  (if (string-match "^file:" desc)
+	      (setq desc (substring desc (match-end 0)))))
+	(setq desc (org-add-props
+		       (concat "<img src=\"" desc "\" alt=\""
+			       (file-name-nondirectory desc) "\"/>")
+		       '(org-protected t))))
+      (cond
+       ((equal type "internal")
+	(let
+	    ((frag-0
+	      (if (= (string-to-char path) ?#)
+		  (substring path 1)
+		path)))
+	  (setq rpl
+		(org-html-make-link
+		 opt-plist
+		 ""
+		 ""
+		 (org-solidify-link-text
+		  (save-match-data (org-link-unescape frag-0))
+		  nil)
+		 desc attr nil))))
+       ((and (equal type "id")
+	     (setq id-file (org-id-find-id-file path)))
+	;; This is an id: link to another file (if it was the same file,
+	;; it would have become an internal link...)
+	(save-match-data
+	  (setq id-file (file-relative-name
+			 id-file
+			 (file-name-directory org-current-export-file)))
+	  (setq rpl
+		(org-html-make-link opt-plist
+				    "file" id-file
+				    (concat (if (org-uuidgen-p path) "ID-") path)
+				    desc
+				    attr
+				    nil))))
+       ((member type '("http" "https"))
+	;; standard URL, can inline as image
+	(setq rpl
+	      (org-html-make-link opt-plist
+				  type path nil
+				  desc
+				  attr
+				  (org-html-should-inline-p path descp))))
+       ((member type '("ftp" "mailto" "news"))
+	;; standard URL, can't inline as image
+	(setq rpl
+	      (org-html-make-link opt-plist
+				  type path nil
+				  desc
+				  attr
+				  nil)))
+
+       ((string= type "coderef")
+	(let*
+	    ((coderef-str (format "coderef-%s" path))
+	     (attr-1
+	      (format "class=\"coderef\" onmouseover=\"CodeHighlightOn(this, '%s');\" onmouseout=\"CodeHighlightOff(this, '%s');\""
+		      coderef-str coderef-str)))
+	  (setq rpl
+		(org-html-make-link opt-plist
+				    type "" coderef-str
+				    (format
+				     (org-export-get-coderef-format
+				      path
+				      (and descp desc))
+				     (cdr (assoc path org-export-code-refs)))
+				    attr-1
+				    nil))))
+
+       ((functionp (setq fnc (nth 2 (assoc type org-link-protocols))))
+	;; The link protocol has a function for format the link
+	(setq rpl
+	      (save-match-data
+		(funcall fnc (org-link-unescape path) desc1 'html))))
+
+       ((string= type "file")
+	;; FILE link
+	(save-match-data
+	  (let*
+	      ((components
+		(if
+		    (string-match "::\\(.*\\)" path)
+		    (list
+		     (replace-match "" t nil path)
+		     (match-string 1 path))
+		  (list path nil)))
+
+	       ;;The proper path, without a fragment
+	       (path-1
+		(first components))
+
+	       ;;The raw fragment
+	       (fragment-0
+		(second components))
+
+	       ;;Check the fragment.  If it can't be used as
+	       ;;target fragment we'll pass nil instead.
+	       (fragment-1
+		(if
+		    (and fragment-0
+			 (not (string-match "^[0-9]*$" fragment-0))
+			 (not (string-match "^\\*" fragment-0))
+			 (not (string-match "^/.*/$" fragment-0)))
+		    (org-solidify-link-text
+		     (org-link-unescape fragment-0))
+		  nil))
+	       (desc-2
+		;;Description minus "file:" and ".org"
+		(if (string-match "^file:" desc)
+		    (let
+			((desc-1 (replace-match "" t t desc)))
+		      (if (string-match "\\.org$" desc-1)
+			  (replace-match "" t t desc-1)
+			desc-1))
+		  desc)))
+
+	    (setq rpl
+		  (if
+		      (and
+		       (functionp link-validate)
+		       (not (funcall link-validate path-1 current-dir)))
+		      desc
+		    (org-html-make-link opt-plist
+					"file" path-1 fragment-1 desc-2 attr
+					(org-html-should-inline-p path-1 descp)))))))
+
+       (t
+	;; just publish the path, as default
+	(setq rpl (concat "<i>&lt;" type ":"
+			  (save-match-data (org-link-unescape path))
+			  "&gt;</i>"))))
+      (setq org-line (replace-match rpl t t org-line)
+	    start (+ start (length rpl))))
+    org-line))
+
+;;; org-export-as-html
+
+(defvar org-heading-keyword-regexp-format) ; defined in org.el
+
+;;;###autoload
+(defun org-export-as-html (arg &optional hidden ext-plist
+			       to-buffer body-only pub-dir)
+  "Export the outline as a pretty HTML file.
+If there is an active region, export only the region.  The prefix
+ARG specifies how many levels of the outline should become
+headlines.  The default is 3.  Lower levels will become bulleted
+lists.  HIDDEN is obsolete and does nothing.
+EXT-PLIST is a property list with external parameters overriding
+org-mode's default settings, but still inferior to file-local
+settings.  When TO-BUFFER is non-nil, create a buffer with that
+name and export to that buffer.  If TO-BUFFER is the symbol
+`string', don't leave any buffer behind but just return the
+resulting HTML as a string.  When BODY-ONLY is set, don't produce
+the file header and footer, simply return the content of
+<body>...</body>, without even the body tags themselves.  When
+PUB-DIR is set, use this as the publishing directory."
+  (interactive "P")
+  (run-hooks 'org-export-first-hook)
+
+  ;; Make sure we have a file name when we need it.
+  (when (and (not (or to-buffer body-only))
+	     (not buffer-file-name))
+    (if (buffer-base-buffer)
+	(org-set-local 'buffer-file-name
+		       (with-current-buffer (buffer-base-buffer)
+			 buffer-file-name))
+      (error "Need a file name to be able to export")))
+
+  (message "Exporting...")
+  (setq-default org-todo-line-regexp org-todo-line-regexp)
+  (setq-default org-deadline-line-regexp org-deadline-line-regexp)
+  (setq-default org-done-keywords org-done-keywords)
+  (setq-default org-maybe-keyword-time-regexp org-maybe-keyword-time-regexp)
+  (let* ((opt-plist
+	  (org-export-process-option-filters
+	   (org-combine-plists (org-default-export-plist)
+			       ext-plist
+			       (org-infile-export-plist))))
+	 (body-only (or body-only (plist-get opt-plist :body-only)))
+	 (style (concat (if (plist-get opt-plist :style-include-default)
+			    org-export-html-style-default)
+			(plist-get opt-plist :style)
+			(plist-get opt-plist :style-extra)
+			"\n"
+			(if (plist-get opt-plist :style-include-scripts)
+			    org-export-html-scripts)))
+	 (html-extension (plist-get opt-plist :html-extension))
+	 valid thetoc have-headings first-heading-pos
+	 (odd org-odd-levels-only)
+	 (region-p (org-region-active-p))
+	 (rbeg (and region-p (region-beginning)))
+	 (rend (and region-p (region-end)))
+	 (subtree-p
+	  (if (plist-get opt-plist :ignore-subtree-p)
+	      nil
+	    (when region-p
+	      (save-excursion
+		(goto-char rbeg)
+		(and (org-at-heading-p)
+		     (>= (org-end-of-subtree t t) rend))))))
+	 (level-offset (if subtree-p
+			   (save-excursion
+			     (goto-char rbeg)
+			     (+ (funcall outline-level)
+				(if org-odd-levels-only 1 0)))
+			 0))
+	 (opt-plist (setq org-export-opt-plist
+			  (if subtree-p
+			      (org-export-add-subtree-options opt-plist rbeg)
+			    opt-plist)))
+	 ;; The following two are dynamically scoped into other
+	 ;; routines below.
+	 (org-current-export-dir
+	  (or pub-dir (org-export-directory :html opt-plist)))
+	 (org-current-export-file buffer-file-name)
+	 (level 0) (org-line "") (origline "") txt todo
+	 (umax nil)
+	 (umax-toc nil)
+	 (filename (if to-buffer nil
+		     (expand-file-name
+		      (concat
+		       (file-name-sans-extension
+			(or (and subtree-p
+				 (org-entry-get (region-beginning)
+						"EXPORT_FILE_NAME" t))
+			    (file-name-nondirectory buffer-file-name)))
+		       "." html-extension)
+		      (file-name-as-directory
+		       (or pub-dir (org-export-directory :html opt-plist))))))
+	 (current-dir (if buffer-file-name
+			  (file-name-directory buffer-file-name)
+			default-directory))
+	 (auto-insert nil); Avoid any auto-insert stuff for the new file
+	 (buffer (if to-buffer
+		     (cond
+		      ((eq to-buffer 'string) (get-buffer-create "*Org HTML Export*"))
+		      (t (get-buffer-create to-buffer)))
+		   (find-file-noselect filename)))
+	 (org-levels-open (make-vector org-level-max nil))
+	 (date        (org-html-expand (plist-get opt-plist :date)))
+	 (author      (org-html-expand (plist-get opt-plist :author)))
+	 (html-validation-link (or org-export-html-validation-link ""))
+	 (title       (org-html-expand
+		       (or (and subtree-p (org-export-get-title-from-subtree))
+			   (plist-get opt-plist :title)
+			   (and (not body-only)
+				(not
+				 (plist-get opt-plist :skip-before-1st-heading))
+				(org-export-grab-title-from-buffer))
+			   (and buffer-file-name
+				(file-name-sans-extension
+				 (file-name-nondirectory buffer-file-name)))
+			   "UNTITLED")))
+	 (link-up (and (plist-get opt-plist :link-up)
+		       (string-match "\\S-" (plist-get opt-plist :link-up))
+		       (plist-get opt-plist :link-up)))
+	 (link-home (and (plist-get opt-plist :link-home)
+			 (string-match "\\S-" (plist-get opt-plist :link-home))
+			 (plist-get opt-plist :link-home)))
+	 (dummy (setq opt-plist (plist-put opt-plist :title title)))
+	 (html-table-tag (plist-get opt-plist :html-table-tag))
+	 (quote-re0   (concat "^ *" org-quote-string "\\( +\\|[ \t]*$\\)"))
+	 (quote-re    (format org-heading-keyword-regexp-format
+			      org-quote-string))
+	 (inquote     nil)
+	 (infixed     nil)
+	 (inverse     nil)
+	 (email       (plist-get opt-plist :email))
+	 (language    (plist-get opt-plist :language))
+	 (keywords    (org-html-expand (plist-get opt-plist :keywords)))
+	 (description (org-html-expand (plist-get opt-plist :description)))
+	 (num         (plist-get opt-plist :section-numbers))
+	 (lang-words  nil)
+	 (head-count  0) cnt
+	 (start       0)
+	 (coding-system (and (boundp 'buffer-file-coding-system)
+			     buffer-file-coding-system))
+	 (coding-system-for-write (or org-export-html-coding-system
+				      coding-system))
+	 (save-buffer-coding-system (or org-export-html-coding-system
+					coding-system))
+	 (charset (and coding-system-for-write
+		       (fboundp 'coding-system-get)
+		       (coding-system-get coding-system-for-write
+					  'mime-charset)))
+	 (region
+	  (buffer-substring
+	   (if region-p (region-beginning) (point-min))
+	   (if region-p (region-end) (point-max))))
+	 (org-export-have-math nil)
+	 (org-export-footnotes-seen nil)
+	 (org-export-footnotes-data (org-footnote-all-labels 'with-defs))
+	 (custom-id (or (org-entry-get nil "CUSTOM_ID" t) ""))
+	 (footnote-def-prefix (format "fn-%s" custom-id))
+	 (footnote-ref-prefix (format "fnr-%s" custom-id))
+	 (lines
+	  (org-split-string
+	   (org-export-preprocess-string
+	    region
+	    :emph-multiline t
+	    :for-backend 'html
+	    :skip-before-1st-heading
+	    (plist-get opt-plist :skip-before-1st-heading)
+	    :drawers (plist-get opt-plist :drawers)
+	    :todo-keywords (plist-get opt-plist :todo-keywords)
+	    :tasks (plist-get opt-plist :tasks)
+	    :tags (plist-get opt-plist :tags)
+	    :priority (plist-get opt-plist :priority)
+	    :footnotes (plist-get opt-plist :footnotes)
+	    :timestamps (plist-get opt-plist :timestamps)
+	    :archived-trees
+	    (plist-get opt-plist :archived-trees)
+	    :select-tags (plist-get opt-plist :select-tags)
+	    :exclude-tags (plist-get opt-plist :exclude-tags)
+	    :add-text
+	    (plist-get opt-plist :text)
+	    :LaTeX-fragments
+	    (plist-get opt-plist :LaTeX-fragments))
+	   "[\r\n]"))
+	 (mathjax
+	  (if (or (eq (plist-get opt-plist :LaTeX-fragments) 'mathjax)
+		  (and org-export-have-math
+		       (eq (plist-get opt-plist :LaTeX-fragments) t)))
+
+	      (org-export-html-mathjax-config
+	       org-export-html-mathjax-template
+	       org-export-html-mathjax-options
+	       (or (plist-get opt-plist :mathjax) ""))
+	    ""))
+	 table-open
+	 table-buffer table-orig-buffer
+	 ind
+	 rpl path attr desc descp desc1 desc2 link
+	 snumber fnc
+	 footnotes footref-seen
+	 href)
+
+    (let ((inhibit-read-only t))
+      (org-unmodified
+       (remove-text-properties (point-min) (point-max)
+			       '(:org-license-to-kill t))))
+
+    (message "Exporting...")
+
+    (setq org-min-level (org-get-min-level lines level-offset))
+    (setq org-last-level org-min-level)
+    (org-init-section-numbers)
+
+    (cond
+     ((and date (string-match "%" date))
+      (setq date (format-time-string date)))
+     (date)
+     (t (setq date (format-time-string org-export-html-date-format-string))))
+
+    ;; Get the language-dependent settings
+    (setq lang-words (or (assoc language org-export-language-setup)
+			 (assoc "en" org-export-language-setup)))
+
+    ;; Switch to the output buffer
+    (set-buffer buffer)
+    (let ((inhibit-read-only t)) (erase-buffer))
+    (fundamental-mode)
+    (org-install-letbind)
+
+    (and (fboundp 'set-buffer-file-coding-system)
+	 (set-buffer-file-coding-system coding-system-for-write))
+
+    (let ((case-fold-search nil)
+	  (org-odd-levels-only odd))
+      ;; create local variables for all options, to make sure all called
+      ;; functions get the correct information
+      (mapc (lambda (x)
+	      (set (make-local-variable (nth 2 x))
+		   (plist-get opt-plist (car x))))
+	    org-export-plist-vars)
+      (setq umax (if arg (prefix-numeric-value arg)
+		   org-export-headline-levels))
+      (setq umax-toc (if (integerp org-export-with-toc)
+			 (min org-export-with-toc umax)
+		       umax))
+      (unless body-only
+	;; File header
+	(insert (format
+		 "%s
+<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Strict//EN\"
+               \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\">
+<html xmlns=\"http://www.w3.org/1999/xhtml\" lang=\"%s\" xml:lang=\"%s\">
+<head>
+<title>%s</title>
+<meta http-equiv=\"Content-Type\" content=\"text/html;charset=%s\"/>
+<meta name=\"title\" content=\"%s\"/>
+<meta name=\"generator\" content=\"Org-mode\"/>
+<meta name=\"generated\" content=\"%s\"/>
+<meta name=\"author\" content=\"%s\"/>
+<meta name=\"description\" content=\"%s\"/>
+<meta name=\"keywords\" content=\"%s\"/>
+%s
+%s
+</head>
+<body>
+%s
+"
+		 (format
+		  (or (and (stringp org-export-html-xml-declaration)
+			   org-export-html-xml-declaration)
+		      (cdr (assoc html-extension org-export-html-xml-declaration))
+		      (cdr (assoc "html" org-export-html-xml-declaration))
+
+		      "")
+		  (or charset "iso-8859-1"))
+		 language language
+		 title
+		 (or charset "iso-8859-1")
+		 title date author description keywords
+		 style
+		 mathjax
+		 (if (or link-up link-home)
+		     (concat
+		      (format org-export-html-home/up-format
+			      (or link-up link-home)
+			      (or link-home link-up))
+		      "\n")
+		   "")))
+
+	;; insert html preamble
+	(when (plist-get opt-plist :html-preamble)
+	  (let ((html-pre (plist-get opt-plist :html-preamble))
+		(html-pre-real-contents ""))
+	    (cond ((stringp html-pre)
+		   (setq html-pre-real-contents
+			 (format-spec html-pre `((?t . ,title) (?a . ,author)
+						 (?d . ,date) (?e . ,email)))))
+		  ((functionp html-pre)
+		   (insert "<div id=\"" (nth 0 org-export-html-divs) "\">\n")
+		   (if (stringp (funcall html-pre)) (insert (funcall html-pre)))
+		   (insert "\n</div>\n"))
+		  (t
+		   (setq html-pre-real-contents
+			 (format-spec
+			  (or (cadr (assoc (nth 0 lang-words)
+					   org-export-html-preamble-format))
+			      (cadr (assoc "en" org-export-html-preamble-format)))
+			  `((?t . ,title) (?a . ,author)
+			    (?d . ,date) (?e . ,email))))))
+	    ;; don't output an empty preamble DIV
+	    (unless (and (functionp html-pre)
+			 (equal html-pre-real-contents ""))
+	      (insert "<div id=\"" (nth 0 org-export-html-divs) "\">\n")
+	      (insert html-pre-real-contents)
+	      (insert "\n</div>\n"))))
+
+	;; begin wrap around body
+	(insert (format "\n<div id=\"%s\">"
+			;; FIXME org-export-html-content-div is obsolete since 7.7
+			(or org-export-html-content-div
+			    (nth 1 org-export-html-divs)))
+		;; FIXME this should go in the preamble but is here so
+		;; that org-infojs can still find it
+		"\n<h1 class=\"title\">" title "</h1>\n"))
+
+      ;; insert body
+      (if org-export-with-toc
+	  (progn
+	    (push (format "<h%d>%s</h%d>\n"
+			  org-export-html-toplevel-hlevel
+			  (nth 3 lang-words)
+			  org-export-html-toplevel-hlevel)
+		  thetoc)
+	    (push "<div id=\"text-table-of-contents\">\n" thetoc)
+	    (push "<ul>\n<li>" thetoc)
+	    (setq lines
+		  (mapcar
+		   #'(lambda (org-line)
+		       (if (and (string-match org-todo-line-regexp org-line)
+				(not (get-text-property 0 'org-protected org-line)))
+			   ;; This is a headline
+			   (progn
+			     (setq have-headings t)
+			     (setq level (- (match-end 1) (match-beginning 1)
+					    level-offset)
+				   level (org-tr-level level)
+				   txt (save-match-data
+					 (org-html-expand
+					  (org-export-cleanup-toc-line
+					   (match-string 3 org-line))))
+				   todo
+				   (or (and org-export-mark-todo-in-toc
+					    (match-beginning 2)
+					    (not (member (match-string 2 org-line)
+							 org-done-keywords)))
+					; TODO, not DONE
+				       (and org-export-mark-todo-in-toc
+					    (= level umax-toc)
+					    (org-search-todo-below
+					     org-line lines level))))
+			     (if (string-match
+				  (org-re "[ \t]+:\\([[:alnum:]_@:]+\\):[ \t]*$") txt)
+				 (setq txt (replace-match
+					    "&nbsp;&nbsp;&nbsp;<span class=\"tag\">\\1</span>" t nil txt)))
+			     (if (string-match quote-re0 txt)
+				 (setq txt (replace-match "" t t txt)))
+			     (setq snumber (org-section-number level))
+			     (if (and num (if (integerp num)
+					      (>= num level)
+					    num))
+				 (setq txt (concat snumber " " txt)))
+			     (if (<= level (max umax umax-toc))
+				 (setq head-count (+ head-count 1)))
+			     (if (<= level umax-toc)
+				 (progn
+				   (if (> level org-last-level)
+				       (progn
+					 (setq cnt (- level org-last-level))
+					 (while (>= (setq cnt (1- cnt)) 0)
+					   (push "\n<ul>\n<li>" thetoc))
+					 (push "\n" thetoc)))
+				   (if (< level org-last-level)
+				       (progn
+					 (setq cnt (- org-last-level level))
+					 (while (>= (setq cnt (1- cnt)) 0)
+					   (push "</li>\n</ul>" thetoc))
+					 (push "\n" thetoc)))
+				   ;; Check for targets
+				   (while (string-match org-any-target-regexp org-line)
+				     (setq org-line (replace-match
+						     (concat "@<span class=\"target\">"
+							     (match-string 1 org-line) "@</span> ")
+						     t t org-line)))
+				   (while (string-match "&lt;\\(&lt;\\)+\\|&gt;\\(&gt;\\)+" txt)
+				     (setq txt (replace-match "" t t txt)))
+				   (setq href
+					 (replace-regexp-in-string
+					  "\\." "-" (format "sec-%s" snumber)))
+				   (setq href (org-solidify-link-text
+					       (or (cdr (assoc href
+							       org-export-preferred-target-alist)) href)))
+				   (push
+				    (format
+				     (if todo
+					 "</li>\n<li><a href=\"#%s\"><span class=\"todo\">%s</span></a>"
+				       "</li>\n<li><a href=\"#%s\">%s</a>")
+				     href txt) thetoc)
+
+				   (setq org-last-level level)))))
+		       org-line)
+		   lines))
+	    (while (> org-last-level (1- org-min-level))
+	      (setq org-last-level (1- org-last-level))
+	      (push "</li>\n</ul>\n" thetoc))
+	    (push "</div>\n" thetoc)
+	    (setq thetoc (if have-headings (nreverse thetoc) nil))))
+
+      (setq head-count 0)
+      (org-init-section-numbers)
+
+      (org-open-par)
+
+      (while (setq org-line (pop lines) origline org-line)
+	(catch 'nextline
+
+	  ;; end of quote section?
+	  (when (and inquote (string-match org-outline-regexp-bol org-line))
+	    (insert "</pre>\n")
+	    (org-open-par)
+	    (setq inquote nil))
+	  ;; inside a quote section?
+	  (when inquote
+	    (insert (org-html-protect org-line) "\n")
+	    (throw 'nextline nil))
+
+	  ;; Fixed-width, verbatim lines (examples)
+	  (when (and org-export-with-fixed-width
+		     (string-match "^[ \t]*:\\(\\([ \t]\\|$\\)\\(.*\\)\\)" org-line))
+	    (when (not infixed)
+	      (setq infixed t)
+	      (org-close-par-maybe)
+
+	      (insert "<pre class=\"example\">\n"))
+	    (insert (org-html-protect (match-string 3 org-line)) "\n")
+	    (when (or (not lines)
+		      (not (string-match "^[ \t]*:\\(\\([ \t]\\|$\\)\\(.*\\)\\)"
+					 (car lines))))
+	      (setq infixed nil)
+	      (insert "</pre>\n")
+	      (org-open-par))
+	    (throw 'nextline nil))
+
+	  ;; Protected HTML
+	  (when (and (get-text-property 0 'org-protected org-line)
+		     ;; Make sure it is the entire line that is protected
+		     (not (< (or (next-single-property-change
+				  0 'org-protected org-line) 10000)
+			     (length org-line))))
+	    (let (par (ind (get-text-property 0 'original-indentation org-line)))
+	      (when (re-search-backward
+		     "\\(<p>\\)\\([ \t\r\n]*\\)\\=" (- (point) 100) t)
+		(setq par (match-string 1))
+		(replace-match "\\2\n"))
+	      (insert org-line "\n")
+	      (while (and lines
+			  (or (= (length (car lines)) 0)
+			      (not ind)
+			      (equal ind (get-text-property 0 'original-indentation (car lines))))
+			  (or (= (length (car lines)) 0)
+			      (get-text-property 0 'org-protected (car lines))))
+		(insert (pop lines) "\n"))
+	      (and par (insert "<p>\n")))
+	    (throw 'nextline nil))
+
+	  ;; Blockquotes, verse, and center
+	  (when (equal "ORG-BLOCKQUOTE-START" org-line)
+	    (org-close-par-maybe)
+	    (insert "<blockquote>\n")
+	    (org-open-par)
+	    (throw 'nextline nil))
+	  (when (equal "ORG-BLOCKQUOTE-END" org-line)
+	    (org-close-par-maybe)
+	    (insert "\n</blockquote>\n")
+	    (org-open-par)
+	    (throw 'nextline nil))
+	  (when (equal "ORG-VERSE-START" org-line)
+	    (org-close-par-maybe)
+	    (insert "\n<p class=\"verse\">\n")
+	    (setq org-par-open t)
+	    (setq inverse t)
+	    (throw 'nextline nil))
+	  (when (equal "ORG-VERSE-END" org-line)
+	    (insert "</p>\n")
+	    (setq org-par-open nil)
+	    (org-open-par)
+	    (setq inverse nil)
+	    (throw 'nextline nil))
+	  (when (equal "ORG-CENTER-START" org-line)
+	    (org-close-par-maybe)
+	    (insert "\n<div style=\"text-align: center\">")
+	    (org-open-par)
+	    (throw 'nextline nil))
+	  (when (equal "ORG-CENTER-END" org-line)
+	    (org-close-par-maybe)
+	    (insert "\n</div>")
+	    (org-open-par)
+	    (throw 'nextline nil))
+	  (run-hooks 'org-export-html-after-blockquotes-hook)
+	  (when inverse
+	    (let ((i (org-get-string-indentation org-line)))
+	      (if (> i 0)
+		  (setq org-line (concat (mapconcat 'identity
+						    (make-list (* 2 i) "\\nbsp") "")
+					 " " (org-trim org-line))))
+	      (unless (string-match "\\\\\\\\[ \t]*$" org-line)
+		(setq org-line (concat org-line "\\\\")))))
+
+	  ;; make targets to anchors
+	  (setq start 0)
+	  (while (string-match
+		  "<<<?\\([^<>]*\\)>>>?\\((INVISIBLE)\\)?[ \t]*\n?" org-line start)
+	    (cond
+	     ((get-text-property (match-beginning 1) 'org-protected org-line)
+	      (setq start (match-end 1)))
+	     ((match-end 2)
+	      (setq org-line (replace-match
+			      (format
+			       "@<a name=\"%s\" id=\"%s\">@</a>"
+			       (org-solidify-link-text (match-string 1 org-line))
+			       (org-solidify-link-text (match-string 1 org-line)))
+			      t t org-line)))
+	     ((and org-export-with-toc (equal (string-to-char org-line) ?*))
+	      ;; FIXME: NOT DEPENDENT on TOC?????????????????????
+	      (setq org-line (replace-match
+			      (concat "@<span class=\"target\">"
+				      (match-string 1 org-line) "@</span> ")
+			      ;; (concat "@<i>" (match-string 1 org-line) "@</i> ")
+			      t t org-line)))
+	     (t
+	      (setq org-line (replace-match
+			      (concat "@<a name=\""
+				      (org-solidify-link-text (match-string 1 org-line))
+				      "\" class=\"target\">" (match-string 1 org-line)
+				      "@</a> ")
+			      t t org-line)))))
+
+	  (setq org-line (org-html-handle-time-stamps org-line))
+
+	  ;; replace "&" by "&amp;", "<" and ">" by "&lt;" and "&gt;"
+	  ;; handle @<..> HTML tags (replace "@&gt;..&lt;" by "<..>")
+	  ;; Also handle sub_superscripts and checkboxes
+	  (or (string-match org-table-hline-regexp org-line)
+	      (string-match "^[ \t]*\\([+]-\\||[ ]\\)[-+ |]*[+|][ \t]*$" org-line)
+	      (setq org-line (org-html-expand org-line)))
+
+	  ;; Format the links
+	  (setq org-line (org-html-handle-links org-line opt-plist))
+
+	  ;; TODO items
+	  (if (and org-todo-line-regexp
+		   (string-match org-todo-line-regexp org-line)
+		   (match-beginning 2))
+
+	      (setq org-line
+		    (concat (substring org-line 0 (match-beginning 2))
+			    "<span class=\""
+			    (if (member (match-string 2 org-line)
+					org-done-keywords)
+				"done" "todo")
+			    " " (org-export-html-get-todo-kwd-class-name
+				 (match-string 2 org-line))
+			    "\">" (match-string 2 org-line)
+			    "</span>" (substring org-line (match-end 2)))))
+
+	  ;; Does this contain a reference to a footnote?
+	  (when org-export-with-footnotes
+	    (setq start 0)
+	    (while (string-match "\\([^* \t].*?\\)\\[\\([0-9]+\\)\\]" org-line start)
+	      ;; Discard protected matches not clearly identified as
+	      ;; footnote markers.
+	      (if (or (get-text-property (match-beginning 2) 'org-protected org-line)
+		      (not (get-text-property (match-beginning 2) 'org-footnote org-line)))
+		  (setq start (match-end 2))
+		(let ((n (match-string 2 org-line)) extra a)
+		  (if (setq a (assoc n footref-seen))
+		      (progn
+			(setcdr a (1+ (cdr a)))
+			(setq extra (format ".%d" (cdr a))))
+		    (setq extra "")
+		    (push (cons n 1) footref-seen))
+		  (setq org-line
+			(replace-match
+			 (concat
+			  (format
+			   (concat "%s"
+				   (format org-export-html-footnote-format
+					   (concat "<a class=\"footref\" name=\"" footnote-ref-prefix ".%s%s\" href=\"#" footnote-def-prefix ".%s\">%s</a>")))
+			   (or (match-string 1 org-line) "") n extra n n)
+			  ;; If another footnote is following the
+			  ;; current one, add a separator.
+			  (if (save-match-data
+				(string-match "\\`\\[[0-9]+\\]"
+					      (substring org-line (match-end 0))))
+			      org-export-html-footnote-separator
+			    ""))
+			 t t org-line))))))
+
+	  (cond
+	   ((string-match "^\\(\\*+\\)\\(?: +\\(.*?\\)\\)?[ \t]*$" org-line)
+	    ;; This is a headline
+	    (setq level (org-tr-level (- (match-end 1) (match-beginning 1)
+					 level-offset))
+		  txt (or (match-string 2 org-line) ""))
+	    (if (string-match quote-re0 txt)
+		(setq txt (replace-match "" t t txt)))
+	    (if (<= level (max umax umax-toc))
+		(setq head-count (+ head-count 1)))
+	    (setq first-heading-pos (or first-heading-pos (point)))
+	    (org-html-level-start level txt umax
+				  (and org-export-with-toc (<= level umax))
+				  head-count opt-plist)
+
+	    ;; QUOTES
+	    (when (string-match quote-re org-line)
+	      (org-close-par-maybe)
+	      (insert "<pre>")
+	      (setq inquote t)))
+
+	   ((and org-export-with-tables
+		 (string-match "^\\([ \t]*\\)\\(|\\|\\+-+\\+\\)" org-line))
+	    (when (not table-open)
+	      ;; New table starts
+	      (setq table-open t table-buffer nil table-orig-buffer nil))
+
+	    ;; Accumulate lines
+	    (setq table-buffer (cons org-line table-buffer)
+		  table-orig-buffer (cons origline table-orig-buffer))
+	    (when (or (not lines)
+		      (not (string-match "^\\([ \t]*\\)\\(|\\|\\+-+\\+\\)"
+					 (car lines))))
+	      (setq table-open nil
+		    table-buffer (nreverse table-buffer)
+		    table-orig-buffer (nreverse table-orig-buffer))
+	      (org-close-par-maybe)
+	      (insert (org-format-table-html table-buffer table-orig-buffer))))
+
+	   ;; Normal lines
+
+	   (t
+	    ;; This line either is list item or end a list.
+	    (when (get-text-property 0 'list-item org-line)
+	      (setq org-line (org-html-export-list-line
+			      org-line
+			      (get-text-property 0 'list-item org-line)
+			      (get-text-property 0 'list-struct org-line)
+			      (get-text-property 0 'list-prevs org-line))))
+
+	    ;; Horizontal line
+	    (when (string-match "^[ \t]*-\\{5,\\}[ \t]*$" org-line)
+	      (if org-par-open
+		  (insert "\n</p>\n<hr/>\n<p>\n")
+		(insert "\n<hr/>\n"))
+	      (throw 'nextline nil))
+
+	    ;; Empty lines start a new paragraph.  If hand-formatted lists
+	    ;; are not fully interpreted, lines starting with "-", "+", "*"
+	    ;; also start a new paragraph.
+	    (if (string-match "^ [-+*]-\\|^[ \t]*$" org-line) (org-open-par))
+
+	    ;; Is this the start of a footnote?
+	    (when org-export-with-footnotes
+	      (when (and (boundp 'footnote-section-tag-regexp)
+			 (string-match (concat "^" footnote-section-tag-regexp)
+				       org-line))
+		;; ignore this line
+		(throw 'nextline nil))
+	      (when (string-match "^[ \t]*\\[\\([0-9]+\\)\\]" org-line)
+		(org-close-par-maybe)
+		(let ((n (match-string 1 org-line)))
+		  (setq org-par-open t
+			org-line (replace-match
+				  (format
+				   (concat "<p class=\"footnote\">"
+					   (format org-export-html-footnote-format
+						   (concat
+						    "<a class=\"footnum\" name=\"" footnote-def-prefix ".%s\" href=\"#" footnote-ref-prefix ".%s\">%s</a>")))
+				   n n n) t t org-line)))))
+	    ;; Check if the line break needs to be conserved
+	    (cond
+	     ((string-match "\\\\\\\\[ \t]*$" org-line)
+	      (setq org-line (replace-match "<br/>" t t org-line)))
+	     (org-export-preserve-breaks
+	      (setq org-line (concat org-line "<br/>"))))
+
+	    ;; Check if a paragraph should be started
+	    (let ((start 0))
+	      (while (and org-par-open
+			  (string-match "\\\\par\\>" org-line start))
+		;; Leave a space in the </p> so that the footnote matcher
+		;; does not see this.
+		(if (not (get-text-property (match-beginning 0)
+					    'org-protected org-line))
+		    (setq org-line (replace-match "</p ><p >" t t org-line)))
+		(setq start (match-end 0))))
+
+	    (insert org-line "\n")))))
+
+      ;; Properly close all local lists and other lists
+      (when inquote
+	(insert "</pre>\n")
+	(org-open-par))
+
+      (org-html-level-start 1 nil umax
+			    (and org-export-with-toc (<= level umax))
+			    head-count opt-plist)
+      ;; the </div> to close the last text-... div.
+      (when (and (> umax 0) first-heading-pos) (insert "</div>\n"))
+
+      (save-excursion
+	(goto-char (point-min))
+	(while (re-search-forward
+		"\\(\\(<p class=\"footnote\">\\)[^\000]*?\\)\\(\\(\\2\\)\\|\\'\\)"
+		nil t)
+	  (push (match-string 1) footnotes)
+	  (replace-match "\\4" t nil)
+	  (goto-char (match-beginning 0))))
+      (when footnotes
+	(insert (format org-export-html-footnotes-section
+			(nth 4 lang-words)
+			(mapconcat 'identity (nreverse footnotes) "\n"))
+		"\n"))
+      (let ((bib (org-export-html-get-bibliography)))
+	(when bib
+	  (insert "\n" bib "\n")))
+
+      (unless body-only
+	;; end wrap around body
+	(insert "</div>\n")
+
+	;; export html postamble
+	(let ((html-post (plist-get opt-plist :html-postamble))
+	      (email
+	       (mapconcat (lambda(e)
+			    (format "<a href=\"mailto:%s\">%s</a>" e e))
+			  (split-string email ",+ *")
+			  ", "))
+	      (creator-info
+	       (concat "<a href=\"http://orgmode.org\">Org</a> version "
+		       (org-version) " with <a href=\"http://www.gnu.org/software/emacs/\">Emacs</a> version "
+		       (number-to-string emacs-major-version))))
+
+	  (when (plist-get opt-plist :html-postamble)
+	    (insert "\n<div id=\"" (nth 2 org-export-html-divs) "\">\n")
+	    (cond ((stringp html-post)
+		   (insert (format-spec html-post
+					`((?a . ,author) (?e . ,email)
+					  (?d . ,date)   (?c . ,creator-info)
+					  (?v . ,html-validation-link)))))
+		  ((functionp html-post)
+		   (if (stringp (funcall html-post)) (insert (funcall html-post))))
+		  ((eq html-post 'auto)
+		   ;; fall back on default postamble
+		   (when (plist-get opt-plist :time-stamp-file)
+		     (insert "<p class=\"date\">" (nth 2 lang-words) ": " date "</p>\n"))
+		   (when (and (plist-get opt-plist :author-info) author)
+		     (insert "<p class=\"author\">" (nth 1 lang-words) ": " author "</p>\n"))
+		   (when (and (plist-get opt-plist :email-info) email)
+		     (insert "<p class=\"email\">" email "</p>\n"))
+		   (when (plist-get opt-plist :creator-info)
+		     (insert "<p class=\"creator\">"
+			     (concat "<a href=\"http://orgmode.org\">Org</a> version "
+			             (org-version) " with <a href=\"http://www.gnu.org/software/emacs/\">Emacs</a> version "
+				     (number-to-string emacs-major-version) "</p>\n")))
+		   (insert html-validation-link "\n"))
+		  (t
+		   (insert (format-spec
+			    (or (cadr (assoc (nth 0 lang-words)
+					     org-export-html-postamble-format))
+				(cadr (assoc "en" org-export-html-postamble-format)))
+			    `((?a . ,author) (?e . ,email)
+			      (?d . ,date)   (?c . ,creator-info)
+			      (?v . ,html-validation-link))))))
+	    (insert "\n</div>"))))
+
+      ;; FIXME `org-export-html-with-timestamp' has been declared
+      ;; obsolete since Org 7.7 -- don't forget to remove this.
+      (if org-export-html-with-timestamp
+	  (insert org-export-html-html-helper-timestamp))
+
+      (unless body-only (insert "\n</body>\n</html>\n"))
+
+      (unless (plist-get opt-plist :buffer-will-be-killed)
+	(normal-mode)
+	(if (eq major-mode (default-value 'major-mode))
+	    (html-mode)))
+
+      ;; insert the table of contents
+      (goto-char (point-min))
+      (when thetoc
+	(if (or (re-search-forward
+		 "<p>\\s-*\\[TABLE-OF-CONTENTS\\]\\s-*</p>" nil t)
+		(re-search-forward
+		 "\\[TABLE-OF-CONTENTS\\]" nil t))
+	    (progn
+	      (goto-char (match-beginning 0))
+	      (replace-match ""))
+	  (goto-char first-heading-pos)
+	  (when (looking-at "\\s-*</p>")
+	    (goto-char (match-end 0))
+	    (insert "\n")))
+	(insert "<div id=\"table-of-contents\">\n")
+	(let ((beg (point)))
+	  (mapc 'insert thetoc)
+	  (insert "</div>\n")
+	  (while (re-search-backward "<li>[ \r\n\t]*</li>\n?" beg t)
+	    (replace-match ""))))
+      ;; remove empty paragraphs
+      (goto-char (point-min))
+      (while (re-search-forward "<p>[ \r\n\t]*</p>" nil t)
+	(replace-match ""))
+      (goto-char (point-min))
+      ;; Convert whitespace place holders
+      (goto-char (point-min))
+      (let (beg end n)
+	(while (setq beg (next-single-property-change (point) 'org-whitespace))
+	  (setq n (get-text-property beg 'org-whitespace)
+		end (next-single-property-change beg 'org-whitespace))
+	  (goto-char beg)
+	  (delete-region beg end)
+	  (insert (format "<span style=\"visibility:hidden;\">%s</span>"
+			  (make-string n ?x)))))
+      ;; Remove empty lines at the beginning of the file.
+      (goto-char (point-min))
+      (when (looking-at "\\s-+\n") (replace-match ""))
+      ;; Remove display properties
+      (remove-text-properties (point-min) (point-max) '(display t))
+      ;; Run the hook
+      (run-hooks 'org-export-html-final-hook)
+      (or to-buffer (save-buffer))
+      (goto-char (point-min))
+      (or (org-export-push-to-kill-ring "HTML")
+	  (message "Exporting... done"))
+      (if (eq to-buffer 'string)
+	  (prog1 (buffer-substring (point-min) (point-max))
+	    (kill-buffer (current-buffer)))
+	(current-buffer)))))
+
+(defun org-export-html-format-href (s)
+  "Make sure the S is valid as a href reference in an XHTML document."
+  (save-match-data
+    (let ((start 0))
+      (while (string-match "&" s start)
+	(setq start (+ (match-beginning 0) 3)
+	      s (replace-match "&amp;" t t s)))))
+  s)
+
+(defun org-export-html-format-desc (s)
+  "Make sure the S is valid as a description in a link."
+  (if (and s (not (get-text-property 1 'org-protected s)))
+      (save-match-data
+	(org-html-do-expand s))
+    s))
+
+(defun org-export-html-format-image (src par-open)
+  "Create image tag with source and attributes."
+  (save-match-data
+    (if (string-match (regexp-quote org-latex-preview-ltxpng-directory) src)
+	(format "<img src=\"%s\" alt=\"%s\"/>"
+                src (org-find-text-property-in-string 'org-latex-src src))
+      (let* ((caption (org-find-text-property-in-string 'org-caption src))
+	     (attr (org-find-text-property-in-string 'org-attributes src))
+	     (label (org-find-text-property-in-string 'org-label src)))
+	(setq caption (and caption (org-html-do-expand caption)))
+	(concat
+	 (if caption
+	     (format "%s<div %sclass=\"figure\">
+<p>"
+		     (if org-par-open "</p>\n" "")
+		     (if label (format "id=\"%s\" " (org-solidify-link-text label)) "")))
+	 (format "<img src=\"%s\"%s />"
+		 src
+		 (if (string-match "\\<alt=" (or attr ""))
+		     (concat " " attr )
+		   (concat " " attr " alt=\"" src "\"")))
+	 (if caption
+	     (format "</p>%s
+</div>%s"
+		     (concat "\n<p>" caption "</p>")
+		     (if org-par-open "\n<p>" ""))))))))
+
+(defun org-export-html-get-bibliography ()
+  "Find bibliography, cut it out and return it."
+  (catch 'exit
+    (let (beg end (cnt 1) bib)
+      (save-excursion
+	(goto-char (point-min))
+	(when (re-search-forward "^[ \t]*<div \\(id\\|class\\)=\"bibliography\"" nil t)
+	  (setq beg (match-beginning 0))
+	  (while (re-search-forward "</?div\\>" nil t)
+	    (setq cnt (+ cnt (if (string= (match-string 0) "<div") +1 -1)))
+	    (when (= cnt 0)
+	      (and (looking-at ">") (forward-char 1))
+	      (setq bib (buffer-substring beg (point)))
+	      (delete-region beg (point))
+	      (throw 'exit bib))))
+	nil))))
+
+(defvar org-table-number-regexp) ; defined in org-table.el
+(defun org-format-table-html (lines olines &optional no-css)
+  "Find out which HTML converter to use and return the HTML code.
+NO-CSS is passed to the exporter."
+  (if (stringp lines)
+      (setq lines (org-split-string lines "\n")))
+  (if (string-match "^[ \t]*|" (car lines))
+      ;; A normal org table
+      (org-format-org-table-html lines nil no-css)
+    ;; Table made by table.el
+    (or (org-format-table-table-html-using-table-generate-source
+	 olines (not org-export-prefer-native-exporter-for-tables))
+	;; We are here only when table.el table has NO col or row
+	;; spanning and the user prefers using org's own converter for
+	;; exporting of such simple table.el tables.
+	(org-format-table-table-html lines))))
+
+(defvar org-table-number-fraction) ; defined in org-table.el
+(defun org-format-org-table-html (lines &optional splice no-css)
+  "Format a table into HTML.
+LINES is a list of lines.  Optional argument SPLICE means, do not
+insert header and surrounding <table> tags, just format the lines.
+Optional argument NO-CSS means use XHTML attributes instead of CSS
+for formatting.  This is required for the DocBook exporter."
+  (require 'org-table)
+  ;; Get rid of hlines at beginning and end
+  (if (string-match "^[ \t]*|-" (car lines)) (setq lines (cdr lines)))
+  (setq lines (nreverse lines))
+  (if (string-match "^[ \t]*|-" (car lines)) (setq lines (cdr lines)))
+  (setq lines (nreverse lines))
+  (when org-export-table-remove-special-lines
+    ;; Check if the table has a marking column.  If yes remove the
+    ;; column and the special lines
+    (setq lines (org-table-clean-before-export lines)))
+
+  (let* ((caption (org-find-text-property-in-string 'org-caption (car lines)))
+	 (label (org-find-text-property-in-string 'org-label (car lines)))
+	 (col-cookies (org-find-text-property-in-string 'org-col-cookies
+							(car lines)))
+	 (attributes (org-find-text-property-in-string 'org-attributes
+						       (car lines)))
+	 (html-table-tag (org-export-splice-attributes
+			  html-table-tag attributes))
+	 (head (and org-export-highlight-first-table-line
+		    (delq nil (mapcar
+			       (lambda (x) (string-match "^[ \t]*|-" x))
+			       (cdr lines)))))
+	 (nline 0) fnum nfields i (cnt 0)
+	 tbopen org-line fields html gr colgropen rowstart rowend
+	 ali align aligns n)
+    (setq caption (and caption (org-html-do-expand caption)))
+    (when (and col-cookies org-table-clean-did-remove-column)
+      (setq col-cookies
+	    (mapcar (lambda (x) (cons (1- (car x)) (cdr x))) col-cookies)))
+    (if splice (setq head nil))
+    (unless splice (push (if head "<thead>" "<tbody>") html))
+    (setq tbopen t)
+    (while (setq org-line (pop lines))
+      (catch 'next-line
+	(if (string-match "^[ \t]*|-" org-line)
+	    (progn
+	      (unless splice
+		(push (if head "</thead>" "</tbody>") html)
+		(if lines (push "<tbody>" html) (setq tbopen nil)))
+	      (setq head nil)   ;; head ends here, first time around
+	      ;; ignore this line
+	      (throw 'next-line t)))
+	;; Break the line into fields
+	(setq fields (org-split-string org-line "[ \t]*|[ \t]*"))
+	(unless fnum (setq fnum (make-vector (length fields) 0)
+			   nfields (length fnum)))
+	(setq nline (1+ nline) i -1
+	      rowstart (eval (car org-export-table-row-tags))
+	      rowend (eval (cdr org-export-table-row-tags)))
+	(push (concat rowstart
+		      (mapconcat
+		       (lambda (x)
+			 (setq i (1+ i) ali (format "@@class%03d@@" i))
+			 (if (and (< i nfields) ; make sure no rogue line causes an error here
+				  (string-match org-table-number-regexp x))
+			     (incf (aref fnum i)))
+			 (cond
+			  (head
+			   (concat
+			    (format (car org-export-table-header-tags)
+				    "col" ali)
+			    x
+			    (cdr org-export-table-header-tags)))
+			  ((and (= i 0) org-export-html-table-use-header-tags-for-first-column)
+			   (concat
+			    (format (car org-export-table-header-tags)
+				    "row" ali)
+			    x
+			    (cdr org-export-table-header-tags)))
+			  (t
+			   (concat (format (car org-export-table-data-tags) ali)
+				   x
+				   (cdr org-export-table-data-tags)))))
+		       fields "")
+		      rowend)
+	      html)))
+    (unless splice (if tbopen (push "</tbody>" html)))
+    (unless splice (push "</table>\n" html))
+    (setq html (nreverse html))
+    (unless splice
+      ;; Put in col tags with the alignment (unfortunately often ignored...)
+      (unless (car org-table-colgroup-info)
+	(setq org-table-colgroup-info
+	      (cons :start (cdr org-table-colgroup-info))))
+      (setq i 0)
+      (push (mapconcat
+	     (lambda (x)
+	       (setq gr (pop org-table-colgroup-info)
+		     i (1+ i)
+		     align (if (nth 1 (assoc i col-cookies))
+			       (cdr (assoc (nth 1 (assoc i col-cookies))
+					   '(("l" . "left") ("r" . "right")
+					     ("c" . "center"))))
+			     (if (> (/ (float x) nline)
+				    org-table-number-fraction)
+				 "right" "left")))
+	       (push align aligns)
+	       (format (if no-css
+			   "%s<col align=\"%s\" />%s"
+			 "%s<col class=\"%s\" />%s")
+		       (if (memq gr '(:start :startend))
+			   (prog1
+			       (if colgropen
+				   "</colgroup>\n<colgroup>"
+				 "<colgroup>")
+			     (setq colgropen t))
+			 "")
+		       align
+		       (if (memq gr '(:end :startend))
+			   (progn (setq colgropen nil) "</colgroup>")
+			 "")))
+	     fnum "")
+	    html)
+      (setq aligns (nreverse aligns))
+      (if colgropen (setq html (cons (car html)
+				     (cons "</colgroup>" (cdr html)))))
+      ;; Since the output of HTML table formatter can also be used in
+      ;; DocBook document, include empty captions for the DocBook
+      ;; export only so that it produces valid XML.
+      (when (or caption (eq org-export-current-backend 'docbook))
+	(push (format "<caption>%s</caption>" (or caption "")) html))
+      (when label
+	(setq html-table-tag (org-export-splice-attributes html-table-tag (format "id=\"%s\"" (org-solidify-link-text label)))))
+      (push html-table-tag html))
+    (setq html (mapcar
+		(lambda (x)
+		  (replace-regexp-in-string
+		   "@@class\\([0-9]+\\)@@"
+		   (lambda (txt)
+		     (if (not org-export-html-table-align-individual-fields)
+			 ""
+		       (setq n (string-to-number (match-string 1 txt)))
+		       (format (if no-css " align=\"%s\"" " class=\"%s\"")
+			       (or (nth n aligns) "left"))))
+		   x))
+		html))
+    (concat (mapconcat 'identity html "\n") "\n")))
+
+(defun org-export-splice-attributes (tag attributes)
+  "Read attributes in string ATTRIBUTES, add and replace in HTML tag TAG."
+  (if (not attributes)
+      tag
+    (let (oldatt newatt)
+      (setq oldatt (org-extract-attributes-from-string tag)
+	    tag (pop oldatt)
+	    newatt (cdr (org-extract-attributes-from-string attributes)))
+      (while newatt
+	(setq oldatt (plist-put oldatt (pop newatt) (pop newatt))))
+      (if (string-match ">" tag)
+	  (setq tag
+		(replace-match (concat (org-attributes-to-string oldatt) ">")
+			       t t tag)))
+      tag)))
+
+(defun org-format-table-table-html (lines)
+  "Format a table generated by table.el into HTML.
+This conversion does *not* use `table-generate-source' from table.el.
+This has the advantage that Org-mode's HTML conversions can be used.
+But it has the disadvantage, that no cell- or row-spanning is allowed."
+  (let (org-line field-buffer
+		 (head org-export-highlight-first-table-line)
+		 fields html empty i)
+    (setq html (concat html-table-tag "\n"))
+    (while (setq org-line (pop lines))
+      (setq empty "&nbsp;")
+      (catch 'next-line
+	(if (string-match "^[ \t]*\\+-" org-line)
+	    (progn
+	      (if field-buffer
+		  (progn
+		    (setq
+		     html
+		     (concat
+		      html
+		      "<tr>"
+		      (mapconcat
+		       (lambda (x)
+			 (if (equal x "") (setq x empty))
+			 (if head
+			     (concat
+			      (format (car org-export-table-header-tags) "col" "")
+			      x
+			      (cdr org-export-table-header-tags))
+			   (concat (format (car org-export-table-data-tags) "") x
+				   (cdr org-export-table-data-tags))))
+		       field-buffer "\n")
+		      "</tr>\n"))
+		    (setq head nil)
+		    (setq field-buffer nil)))
+	      ;; Ignore this line
+	      (throw 'next-line t)))
+	;; Break the line into fields and store the fields
+	(setq fields (org-split-string org-line "[ \t]*|[ \t]*"))
+	(if field-buffer
+	    (setq field-buffer (mapcar
+				(lambda (x)
+				  (concat x "<br/>" (pop fields)))
+				field-buffer))
+	  (setq field-buffer fields))))
+    (setq html (concat html "</table>\n"))
+    html))
+
+(defun org-format-table-table-html-using-table-generate-source (lines
+								&optional
+								spanned-only)
+  "Format a table into html, using `table-generate-source' from table.el.
+Use SPANNED-ONLY to suppress exporting of simple table.el tables.
+
+When SPANNED-ONLY is nil, all table.el tables are exported.  When
+SPANNED-ONLY is non-nil, only tables with either row or column
+spans are exported.
+
+This routine returns the generated source or nil as appropriate.
+
+Refer docstring of `org-export-prefer-native-exporter-for-tables'
+for further information."
+  (require 'table)
+  (with-current-buffer (get-buffer-create " org-tmp1 ")
+    (erase-buffer)
+    (insert (mapconcat 'identity lines "\n"))
+    (goto-char (point-min))
+    (if (not (re-search-forward "|[^+]" nil t))
+	(error "Error processing table"))
+    (table-recognize-table)
+    (when (or (not spanned-only)
+	      (let* ((dim (table-query-dimension))
+		     (c (nth 4 dim)) (r (nth 5 dim)) (cells (nth 6 dim)))
+		(not (= (* c r) cells))))
+      (with-current-buffer (get-buffer-create " org-tmp2 ") (erase-buffer))
+      (table-generate-source 'html " org-tmp2 ")
+      (set-buffer " org-tmp2 ")
+      (buffer-substring (point-min) (point-max)))))
+
+(defun org-export-splice-style (style extra)
+  "Splice EXTRA into STYLE, just before \"</style>\"."
+  (if (and (stringp extra)
+	   (string-match "\\S-" extra)
+	   (string-match "</style>" style))
+      (concat (substring style 0 (match-beginning 0))
+	      "\n" extra "\n"
+	      (substring style (match-beginning 0)))
+    style))
+
+(defun org-html-handle-time-stamps (s)
+  "Format time stamps in string S, or remove them."
+  (catch 'exit
+    (let (r b)
+      (when org-maybe-keyword-time-regexp
+	(while (string-match org-maybe-keyword-time-regexp s)
+	  (or b (setq b (substring s 0 (match-beginning 0))))
+	  (setq r (concat
+		   r (substring s 0 (match-beginning 0))
+		   " @<span class=\"timestamp-wrapper\">"
+		   (if (match-end 1)
+		       (format "@<span class=\"timestamp-kwd\">%s @</span>"
+			       (match-string 1 s)))
+		   (format " @<span class=\"timestamp\">%s@</span>"
+			   (substring
+			    (org-translate-time (match-string 3 s)) 1 -1))
+		   "@</span>")
+		s (substring s (match-end 0)))))
+      ;; Line break if line started and ended with time stamp stuff
+      (if (not r)
+	  s
+	(setq r (concat r s))
+	(unless (string-match "\\S-" (concat b s))
+	  (setq r (concat r "@<br/>")))
+	r))))
+
+(defvar htmlize-buffer-places)  ; from htmlize.el
+(defun org-export-htmlize-region-for-paste (beg end)
+  "Convert the region to HTML, using htmlize.el.
+This is much like `htmlize-region-for-paste', only that it uses
+the settings define in the org-... variables."
+  (let* ((htmlize-output-type org-export-htmlize-output-type)
+	 (htmlize-css-name-prefix org-export-htmlize-css-font-prefix)
+	 (htmlbuf (htmlize-region beg end)))
+    (unwind-protect
+	(with-current-buffer htmlbuf
+	  (buffer-substring (plist-get htmlize-buffer-places 'content-start)
+			    (plist-get htmlize-buffer-places 'content-end)))
+      (kill-buffer htmlbuf))))
+
+;;;###autoload
+(defun org-export-htmlize-generate-css ()
+  "Create the CSS for all font definitions in the current Emacs session.
+Use this to create face definitions in your CSS style file that can then
+be used by code snippets transformed by htmlize.
+This command just produces a buffer that contains class definitions for all
+faces used in the current Emacs session.  You can copy and paste the ones you
+need into your CSS file.
+
+If you then set `org-export-htmlize-output-type' to `css', calls to
+the function `org-export-htmlize-region-for-paste' will produce code
+that uses these same face definitions."
+  (interactive)
+  (require 'htmlize)
+  (and (get-buffer "*html*") (kill-buffer "*html*"))
+  (with-temp-buffer
+    (let ((fl (face-list))
+	  (htmlize-css-name-prefix "org-")
+	  (htmlize-output-type 'css)
+	  f i)
+      (while (setq f (pop fl)
+		   i (and f (face-attribute f :inherit)))
+	(when (and (symbolp f) (or (not i) (not (listp i))))
+	  (insert (org-add-props (copy-sequence "1") nil 'face f))))
+      (htmlize-region (point-min) (point-max))))
+  (org-pop-to-buffer-same-window "*html*")
+  (goto-char (point-min))
+  (if (re-search-forward "<style" nil t)
+      (delete-region (point-min) (match-beginning 0)))
+  (if (re-search-forward "</style>" nil t)
+      (delete-region (1+ (match-end 0)) (point-max)))
+  (beginning-of-line 1)
+  (if (looking-at " +") (replace-match ""))
+  (goto-char (point-min)))
+
+(defun org-html-protect (s)
+  "Convert characters to HTML equivalent.
+Possible conversions are set in `org-export-html-protect-char-alist'."
+  (let ((cl org-export-html-protect-char-alist) c)
+    (while (setq c (pop cl))
+      (let ((start 0))
+	(while (string-match (car c) s start)
+	  (setq s (replace-match (cdr c) t t s)
+		start (1+ (match-beginning 0))))))
+    s))
+
+(defun org-html-expand (string)
+  "Prepare STRING for HTML export.  Apply all active conversions.
+If there are links in the string, don't modify these.  If STRING
+is nil, return nil."
+  (when string
+    (let* ((re (concat org-bracket-link-regexp "\\|"
+		       (org-re "[ \t]+\\(:[[:alnum:]_@#%:]+:\\)[ \t]*$")))
+	   m s l res)
+      (while (setq m (string-match re string))
+	(setq s (substring string 0 m)
+	      l (match-string 0 string)
+	      string (substring string (match-end 0)))
+	(push (org-html-do-expand s) res)
+	(push l res))
+      (push (org-html-do-expand string) res)
+      (apply 'concat (nreverse res)))))
+
+(defun org-html-do-expand (s)
+  "Apply all active conversions to translate special ASCII to HTML."
+  (setq s (org-html-protect s))
+  (if org-export-html-expand
+      (while (string-match "@&lt;\\([^&]*\\)&gt;" s)
+	(setq s (replace-match "<\\1>" t nil s))))
+  (if org-export-with-emphasize
+      (setq s (org-export-html-convert-emphasize s)))
+  (if org-export-with-special-strings
+      (setq s (org-export-html-convert-special-strings s)))
+  (if org-export-with-sub-superscripts
+      (setq s (org-export-html-convert-sub-super s)))
+  (if org-export-with-TeX-macros
+      (let ((start 0) wd rep)
+	(while (setq start (string-match "\\\\\\([a-zA-Z]+[0-9]*\\)\\({}\\)?"
+					 s start))
+	  (if (get-text-property (match-beginning 0) 'org-protected s)
+	      (setq start (match-end 0))
+	    (setq wd (match-string 1 s))
+	    (if (setq rep (org-entity-get-representation wd 'html))
+		(setq s (replace-match rep t t s))
+	      (setq start (+ start (length wd))))))))
+  s)
+
+(defun org-export-html-convert-special-strings (string)
+  "Convert special characters in STRING to HTML."
+  (let ((all org-export-html-special-string-regexps)
+	e a re rpl start)
+    (while (setq a (pop all))
+      (setq re (car a) rpl (cdr a) start 0)
+      (while (string-match re string start)
+	(if (get-text-property (match-beginning 0) 'org-protected string)
+	    (setq start (match-end 0))
+	  (setq string (replace-match rpl t nil string)))))
+    string))
+
+(defun org-export-html-convert-sub-super (string)
+  "Convert sub- and superscripts in STRING to HTML."
+  (let (key c (s 0) (requireb (eq org-export-with-sub-superscripts '{})))
+    (while (string-match org-match-substring-regexp string s)
+      (cond
+       ((and requireb (match-end 8)) (setq s (match-end 2)))
+       ((get-text-property  (match-beginning 2) 'org-protected string)
+	(setq s (match-end 2)))
+       (t
+	(setq s (match-end 1)
+	      key (if (string= (match-string 2 string) "_") "sub" "sup")
+	      c (or (match-string 8 string)
+		    (match-string 6 string)
+		    (match-string 5 string))
+	      string (replace-match
+		      (concat (match-string 1 string)
+			      "<" key ">" c "</" key ">")
+		      t t string)))))
+    (while (string-match "\\\\\\([_^]\\)" string)
+      (setq string (replace-match (match-string 1 string) t t string)))
+    string))
+
+(defun org-export-html-convert-emphasize (string)
+  "Apply emphasis."
+  (let ((s 0) rpl)
+    (while (string-match org-emph-re string s)
+      (if (not (equal
+		(substring string (match-beginning 3) (1+ (match-beginning 3)))
+		(substring string (match-beginning 4) (1+ (match-beginning 4)))))
+	  (setq s (match-beginning 0)
+		rpl
+		(concat
+		 (match-string 1 string)
+		 (nth 2 (assoc (match-string 3 string) org-emphasis-alist))
+		 (match-string 4 string)
+		 (nth 3 (assoc (match-string 3 string)
+			       org-emphasis-alist))
+		 (match-string 5 string))
+		string (replace-match rpl t t string)
+		s (+ s (- (length rpl) 2)))
+	(setq s (1+ s))))
+    string))
+
+(defun org-open-par ()
+  "Insert <p>, but first close previous paragraph if any."
+  (org-close-par-maybe)
+  (insert "\n<p>")
+  (setq org-par-open t))
+(defun org-close-par-maybe ()
+  "Close paragraph if there is one open."
+  (when org-par-open
+    (insert "</p>")
+    (setq org-par-open nil)))
+(defun org-close-li (&optional type)
+  "Close <li> if necessary."
+  (org-close-par-maybe)
+  (insert (if (equal type "d") "</dd>\n" "</li>\n")))
+
+(defvar body-only) ; dynamically scoped into this.
+(defun org-html-level-start (level title umax with-toc head-count &optional opt-plist)
+  "Insert a new level in HTML export.
+When TITLE is nil, just close all open levels."
+  (org-close-par-maybe)
+  (let* ((target (and title (org-get-text-property-any 0 'target title)))
+	 (extra-targets (and target
+			     (assoc target org-export-target-aliases)))
+	 (extra-class (and title (org-get-text-property-any 0 'html-container-class title)))
+	 (preferred (and target
+			 (cdr (assoc target org-export-preferred-target-alist))))
+	 (l org-level-max)
+	 (num (plist-get opt-plist :section-numbers))
+	 snumber snu href suffix)
+    (setq extra-targets (remove (or preferred target) extra-targets))
+    (setq extra-targets
+	  (mapconcat (lambda (x)
+		       (setq x (org-solidify-link-text
+				(if (org-uuidgen-p x) (concat "ID-" x) x)))
+		       (if (stringp org-export-html-headline-anchor-format)
+			   (format org-export-html-headline-anchor-format x x)
+			 ""))
+		     extra-targets
+		     ""))
+    (while (>= l level)
+      (if (aref org-levels-open (1- l))
+	  (progn
+	    (org-html-level-close l umax)
+	    (aset org-levels-open (1- l) nil)))
+      (setq l (1- l)))
+    (when title
+      ;; If title is nil, this means this function is called to close
+      ;; all levels, so the rest is done only if title is given
+      (when (string-match (org-re "\\(:[[:alnum:]_@#%:]+:\\)[ \t]*$") title)
+	(setq title (replace-match
+		     (if org-export-with-tags
+			 (save-match-data
+			   (concat
+			    "&nbsp;&nbsp;&nbsp;<span class=\"tag\">"
+			    (mapconcat
+			     (lambda (x)
+			       (format "<span class=\"%s\">%s</span>"
+				       (org-export-html-get-tag-class-name x)
+				       x))
+			     (org-split-string (match-string 1 title) ":")
+			     "&nbsp;")
+			    "</span>"))
+		       "")
+		     t t title)))
+      (if (> level umax)
+	  (progn
+	    (if (aref org-levels-open (1- level))
+		(progn
+		  (org-close-li)
+		  (if target
+		      (insert (format "<li id=\"%s\">" (org-solidify-link-text (or preferred target)))
+			      extra-targets title "<br/>\n")
+		    (insert "<li>" title "<br/>\n")))
+	      (aset org-levels-open (1- level) t)
+	      (org-close-par-maybe)
+	      (if target
+		  (insert (format "<ul>\n<li id=\"%s\">" (org-solidify-link-text (or preferred target)))
+			  extra-targets title "<br/>\n")
+		(insert "<ul>\n<li>" title "<br/>\n"))))
+	(aset org-levels-open (1- level) t)
+	(setq snumber (org-section-number level)
+	      snu (replace-regexp-in-string "\\." "-" snumber))
+	(setq level (+ level org-export-html-toplevel-hlevel -1))
+	(if (and num (not body-only))
+	    (setq title (concat
+			 (format "<span class=\"section-number-%d\">%s</span>"
+				 level
+				 (if (and num
+					  (if (integerp num)
+					      ;; fix up num to take into
+					      ;; account the top-level
+					      ;; heading value
+					      (>= (+ num org-export-html-toplevel-hlevel -1)
+						  level)
+					    num))
+				     snumber
+				   ""))
+			 " " title)))
+	(unless (= head-count 1) (insert "\n</div>\n"))
+	(setq href (cdr (assoc (concat "sec-" snu) org-export-preferred-target-alist)))
+	(setq suffix (org-solidify-link-text (or href snu)))
+	(setq href (org-solidify-link-text (or href (concat "sec-" snu))))
+	(insert (format "\n<div id=\"outline-container-%s\" class=\"outline-%d%s\">\n<h%d id=\"%s\">%s%s</h%d>\n<div class=\"outline-text-%d\" id=\"text-%s\">\n"
+			suffix level (if extra-class (concat " " extra-class) "")
+			level href
+			extra-targets
+			title level level suffix))
+	(org-open-par)))))
+
+(defun org-export-html-get-tag-class-name (tag)
+  "Turn tag into a valid class name.
+Replaces invalid characters with \"_\" and then prepends a prefix."
+  (save-match-data
+    (while (string-match "[^a-zA-Z0-9_]" tag)
+      (setq tag (replace-match "_" t t tag))))
+  (concat org-export-html-tag-class-prefix tag))
+
+(defun org-export-html-get-todo-kwd-class-name (kwd)
+  "Turn todo keyword into a valid class name.
+Replaces invalid characters with \"_\" and then prepends a prefix."
+  (save-match-data
+    (while (string-match "[^a-zA-Z0-9_]" kwd)
+      (setq kwd (replace-match "_" t t kwd))))
+  (concat org-export-html-todo-kwd-class-prefix kwd))
+
+(defun org-html-level-close (level max-outline-level)
+  "Terminate one level in HTML export."
+  (if (<= level max-outline-level)
+      (insert "</div>\n")
+    (org-close-li)
+    (insert "</ul>\n")))
+
+(defun org-html-export-list-line (org-line pos struct prevs)
+  "Insert list syntax in export buffer.  Return ORG-LINE, maybe modified.
+
+POS is the item position or org-line position the org-line had before
+modifications to buffer.  STRUCT is the list structure.  PREVS is
+the alist of previous items."
+  (let* ((get-type
+	  (function
+	   ;; Translate type of list containing POS to "d", "o" or
+	   ;; "u".
+	   (lambda (pos struct prevs)
+	     (let ((type (org-list-get-list-type pos struct prevs)))
+	       (cond
+		((eq 'ordered type) "o")
+		((eq 'descriptive type) "d")
+		(t "u"))))))
+	 (get-closings
+	  (function
+	   ;; Return list of all items and sublists ending at POS, in
+	   ;; reverse order.
+	   (lambda (pos)
+	     (let (out)
+	       (catch 'exit
+		 (mapc (lambda (e)
+			 (let ((end (nth 6 e))
+			       (item (car e)))
+			   (cond
+			    ((= end pos) (push item out))
+			    ((>= item pos) (throw 'exit nil)))))
+		       struct))
+	       out)))))
+    ;; First close any previous item, or list, ending at POS.
+    (mapc (lambda (e)
+	    (let* ((lastp (= (org-list-get-last-item e struct prevs) e))
+		   (first-item (org-list-get-list-begin e struct prevs))
+		   (type (funcall get-type first-item struct prevs)))
+	      (org-close-par-maybe)
+	      ;; Ending for every item
+	      (org-close-li type)
+	      ;; We're ending last item of the list: end list.
+	      (when lastp
+		(insert (format "</%sl>\n" type))
+		(org-open-par))))
+	  (funcall get-closings pos))
+    (cond
+     ;; At an item: insert appropriate tags in export buffer.
+     ((assq pos struct)
+      (string-match
+       (concat "[ \t]*\\(\\S-+[ \t]*\\)"
+	       "\\(?:\\[@\\(?:start:\\)?\\([0-9]+\\|[A-Za-z]\\)\\][ \t]*\\)?"
+	       "\\(?:\\(\\[[ X-]\\]\\)[ \t]+\\)?"
+	       "\\(?:\\(.*\\)[ \t]+::\\(?:[ \t]+\\|$\\)\\)?"
+	       "\\(.*\\)") org-line)
+      (let* ((checkbox (match-string 3 org-line))
+	     (desc-tag (or (match-string 4 org-line) "???"))
+	     (body (or (match-string 5 org-line) ""))
+	     (list-beg (org-list-get-list-begin pos struct prevs))
+	     (firstp (= list-beg pos))
+	     ;; Always refer to first item to determine list type, in
+	     ;; case list is ill-formed.
+	     (type (funcall get-type list-beg struct prevs))
+	     (counter (let ((count-tmp (org-list-get-counter pos struct)))
+			(cond
+			 ((not count-tmp) nil)
+			 ((string-match "[A-Za-z]" count-tmp)
+			  (- (string-to-char (upcase count-tmp)) 64))
+			 ((string-match "[0-9]+" count-tmp)
+			  count-tmp)))))
+	(when firstp
+	  (org-close-par-maybe)
+	  (insert (format "<%sl>\n" type)))
+	(insert (cond
+		 ((equal type "d")
+		  (format "<dt>%s</dt><dd>" desc-tag))
+		 ((and (equal type "o") counter)
+		  (format "<li value=\"%s\">" counter))
+		 (t "<li>")))
+	;; If line had a checkbox, some additional modification is required.
+	(when checkbox
+	  (setq body
+		(concat
+		 (cond
+		  ((string-match "X" checkbox) "<code>[X]</code> ")
+		  ((string-match " " checkbox) "<code>[&nbsp;]</code> ")
+		  (t "<code>[-]</code> "))
+		 body)))
+	;; Return modified line
+	body))
+     ;; At a list ender: go to next line (side-effects only).
+     ((equal "ORG-LIST-END-MARKER" org-line) (throw 'nextline nil))
+     ;; Not at an item: return line unchanged (side-effects only).
+     (t org-line))))
+
+(provide 'org-html)
+
+;;; org-html.el ends here