Package COM.INFORMATIMAGO.COMMON-LISP.HTML-GENERATOR.HTML

Nicknames: HTML
This package exports macros and functions to generate HTML pages.

See also: <http://www.cliki.net/HTML-from-sexpr>
          html-generators-in-lisp.txt


EXAMPLES:


    With macros, issuing static html; the pcdata must be tagged with the
    PCDATA macro:

        (with-html-output ()
          (doctype :loose
                   (html -
                         (head -
                               (title - (pcdata "title")))
                         (body (:color "#123456" "background-color" "red")
                               (p - (pcdata "para") (pcdata "var")))))
          (values))

    prints:


        <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
        <html>
        <head>
        <title>title </title></head>
        <body color="#123456" background-color="red">
        <p>para var </p></body></html>




    With functions the lists of attributes and body elements can be built
    dynamically.  The strings are automatically converted to pcdata:

        (progn
          (write-html (doctype* :loose))
          (write-html
           (html* '()
                  (list 
                   (head* '()
                          (list (title* '() (list (pcdata* "title")))))
                   (body* (list :color "#123456" "background-color" "red")
                          (list (p* '() (list "para" (pcdata "variable"))))))))
          (values))

    prints:


        <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
        <html>
        <head>
        <title>title </title></head>
        <body color="#123456" background-color="red">
        <p>para variable </p></body></html>



License:

    AGPL3
    
    Copyright Pascal J. Bourguignon 2003 - 2012
    
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU Affero General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.
    
    This program 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 Affero General Public License for more details.
    
    You should have received a copy of the GNU Affero General Public License
    along with this program.
    If not, see <http://www.gnu.org/licenses/>

*doctype*
variable
The DOCTYPE of HTML document being generated.
   May be a token: :STRICT, :TRANSITIONAL, :LOOSE or :FRAMESET.
Initial value: STRICT
*html-character-set*
variable
The encoding used to write the HTML code. By default it's ASCII,
even if ISO-8859-1 is the default for HTML, since ASCII is the intersection with
the Common Lisp standard character set and HTML default character set.
Initial value: #S(CHARACTER-SET :MIB-ENUM 3 :NAME ANSI_X3.4-1968 :ALIASES (csASCII cp367 IBM367 us US-ASCII ISO646-US ASCII ISO_646.irv:1991 ANSI_X3.4-1986 iso-ir-6) :SOURCE ECMA registry :COMMENTS ...)
*html-output-stream*
variable
The stream used by WITH-HTML-OUTPUT and WRITE-HTML by default.
Initial value: #<SYNONYM-STREAM to *TERMINAL-IO* #x30200036D69D>
*html-version*
variable
The HTML version of the document being generated.
Initial value: 4.01
*html-xhtml-mode-p*
variable
Set to true when the elements must be written in XHTML 1.0 variant.
Initial value: NIL
(a &optional attributes &body body)
macro
DO:          Generate a &lt;a&gt; HTML element: anchor.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(a* &optional attributes body)
function
DO:          Generate a &lt;a&gt; HTML element: anchor.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(abbr &optional attributes &body body)
macro
DO:          Generate a &lt;abbr&gt; HTML element: abbreviated form (e.g., WWW, HTTP, etc.).
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(abbr* &optional attributes body)
function
DO:          Generate a &lt;abbr&gt; HTML element: abbreviated form (e.g., WWW, HTTP, etc.).
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(acronym &optional attributes &body body)
macro
DO:          Generate a &lt;acronym&gt; HTML element.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(acronym* &optional attributes body)
function
DO:          Generate a &lt;acronym&gt; HTML element.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(address &optional attributes &body body)
macro
DO:          Generate a &lt;address&gt; HTML element: information on author.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(address* &optional attributes body)
function
DO:          Generate a &lt;address&gt; HTML element: information on author.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(applet &optional attributes &body body)
macro
DO:          Generate a &lt;applet&gt; HTML element: Java applet.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(applet* &optional attributes body)
function
DO:          Generate a &lt;applet&gt; HTML element: Java applet.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(area &optional attributes &body body)
macro
DO:          Generate a &lt;area&gt; HTML element: client-side image map area.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(area* &optional attributes body)
function
DO:          Generate a &lt;area&gt; HTML element: client-side image map area.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(b &optional attributes &body body)
macro
DO:          Generate a &lt;b&gt; HTML element: bold text style.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(b* &optional attributes body)
function
DO:          Generate a &lt;b&gt; HTML element: bold text style.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(base &optional attributes &body body)
macro
DO:          Generate a &lt;base&gt; HTML element: document base URI.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(base* &optional attributes body)
function
DO:          Generate a &lt;base&gt; HTML element: document base URI.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(basefont &optional attributes &body body)
macro
DO:          Generate a &lt;basefont&gt; HTML element: base font size.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(basefont* &optional attributes body)
function
DO:          Generate a &lt;basefont&gt; HTML element: base font size.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(bdo &optional attributes &body body)
macro
DO:          Generate a &lt;bdo&gt; HTML element: I18N BiDi over-ride.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(bdo* &optional attributes body)
function
DO:          Generate a &lt;bdo&gt; HTML element: I18N BiDi over-ride.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(big &optional attributes &body body)
macro
DO:          Generate a &lt;big&gt; HTML element: large text style.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(big* &optional attributes body)
function
DO:          Generate a &lt;big&gt; HTML element: large text style.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(blockquote &optional attributes &body body)
macro
DO:          Generate a &lt;blockquote&gt; HTML element: long quotation.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(blockquote* &optional attributes body)
function
DO:          Generate a &lt;blockquote&gt; HTML element: long quotation.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(body &optional attributes &body body)
macro
DO:          Generate a &lt;body&gt; HTML element: document body.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(body* &optional attributes body)
function
DO:          Generate a &lt;body&gt; HTML element: document body.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(br &optional attributes &body body)
macro
DO:          Generate a &lt;br&gt; HTML element: forced line break.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(br* &optional attributes body)
function
DO:          Generate a &lt;br&gt; HTML element: forced line break.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(button &optional attributes &body body)
macro
DO:          Generate a &lt;button&gt; HTML element: push button.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(button* &optional attributes body)
function
DO:          Generate a &lt;button&gt; HTML element: push button.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(caption &optional attributes &body body)
macro
DO:          Generate a &lt;caption&gt; HTML element: table caption.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(caption* &optional attributes body)
function
DO:          Generate a &lt;caption&gt; HTML element: table caption.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
cdata
class
Represents CDATA text.
Class precedence list: CDATA ELEMENT STANDARD-OBJECT T
Class init args: DATA
(cdata* control &rest arguments)
function
RETURN:  An element storing the result of formating the CONTROL string
         with the ARGUMENTS as CDATA (ie. post-processed to quote special
         HTML characters (&,").
(cdata-data element)
generic-function
The CDATA text.
(center &optional attributes &body body)
macro
DO:          Generate a &lt;center&gt; HTML element: shorthand for DIV align=center.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(center* &optional attributes body)
function
DO:          Generate a &lt;center&gt; HTML element: shorthand for DIV align=center.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(cite &optional attributes &body body)
macro
DO:          Generate a &lt;cite&gt; HTML element: citation.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(cite* &optional attributes body)
function
DO:          Generate a &lt;cite&gt; HTML element: citation.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(code &optional attributes &body body)
macro
DO:          Generate a &lt;code&gt; HTML element: computer code fragment.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(code* &optional attributes body)
function
DO:          Generate a &lt;code&gt; HTML element: computer code fragment.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(col &optional attributes &body body)
macro
DO:          Generate a &lt;col&gt; HTML element: table column.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(col* &optional attributes body)
function
DO:          Generate a &lt;col&gt; HTML element: table column.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(colgroup &optional attributes &body body)
macro
DO:          Generate a &lt;colgroup&gt; HTML element: table column group.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(colgroup* &optional attributes body)
function
DO:          Generate a &lt;colgroup&gt; HTML element: table column group.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(collect-element element)
function
DO:     Collect the ELEMENT into the current *HTML-OUTPUT-ELEMENTS*.
RETURN: ELEMENT.
(collect-elements elements)
function
DO:     Collect the ELEMENTS into the current *HTML-OUTPUT-ELEMENTS*.
RETURN: ELEMENTS.
(comment control &rest arguments)
function
RETURN:  An element storing the result of formating the CONTROL string
         with the ARGUMENTS as a HTML comment.
(comment* control &rest arguments)
function
RETURN:  An element storing the result of formating the CONTROL string
         with the ARGUMENTS as a HTML comment.
(dd &optional attributes &body body)
macro
DO:          Generate a &lt;dd&gt; HTML element: defelementinition description.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(dd* &optional attributes body)
function
DO:          Generate a &lt;dd&gt; HTML element: defelementinition description.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(del &optional attributes &body body)
macro
DO:          Generate a &lt;del&gt; HTML element: deleted text.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(del* &optional attributes body)
function
DO:          Generate a &lt;del&gt; HTML element: deleted text.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(dfn &optional attributes &body body)
macro
DO:          Generate a &lt;dfn&gt; HTML element: instance defelementinition.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(dfn* &optional attributes body)
function
DO:          Generate a &lt;dfn&gt; HTML element: instance defelementinition.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(dir &optional attributes &body body)
macro
DO:          Generate a &lt;dir&gt; HTML element: directory list.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(dir* &optional attributes body)
function
DO:          Generate a &lt;dir&gt; HTML element: directory list.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(div &optional attributes &body body)
macro
DO:          Generate a &lt;div&gt; HTML element: generic language/style container.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(div* &optional attributes body)
function
DO:          Generate a &lt;div&gt; HTML element: generic language/style container.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(dl &optional attributes &body body)
macro
DO:          Generate a &lt;dl&gt; HTML element: defelementinition list.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(dl* &optional attributes body)
function
DO:          Generate a &lt;dl&gt; HTML element: defelementinition list.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(doctype kind &body body)
macro
KIND:   one of :STRICT, :TRANSITIONAL, :LOOSE or :FRAMESET.
RETURN: The DOCTYPE tag.
(doctype* kind)
function
KIND:   one of :STRICT, :TRANSITIONAL, :LOOSE or :FRAMESET.
RETURN: The DOCTYPE tag.
(dt &optional attributes &body body)
macro
DO:          Generate a &lt;dt&gt; HTML element: defelementinition term.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(dt* &optional attributes body)
function
DO:          Generate a &lt;dt&gt; HTML element: defelementinition term.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
element
class
Represents an HTML element.
Class precedence list: ELEMENT STANDARD-OBJECT T
(element-body element)
generic-function
RETURN: The body of the ELEMENT.
(element-tag element)
generic-function
RETURN: The tag of the ELEMENT.
element-with-body
class
Represents an HTML tagged element, with a body.
Class precedence list: ELEMENT-WITH-BODY ELEMENT-WITH-TAG ELEMENT STANDARD-OBJECT T
Class init args: TAG ATTRIBUTES BODY
element-with-tag
class
Represents an HTML tagged element.
Class precedence list: ELEMENT-WITH-TAG ELEMENT STANDARD-OBJECT T
Class init args: TAG ATTRIBUTES
element-without-end
class
Represents an HTML tagged element, without a closing tag.
Class precedence list: ELEMENT-WITHOUT-END ELEMENT-WITH-TAG ELEMENT STANDARD-OBJECT T
Class init args: TAG ATTRIBUTES
(em &optional attributes &body body)
macro
DO:          Generate a &lt;em&gt; HTML element: emphasis.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(em* &optional attributes body)
function
DO:          Generate a &lt;em&gt; HTML element: emphasis.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(fieldset &optional attributes &body body)
macro
DO:          Generate a &lt;fieldset&gt; HTML element: form control group.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(fieldset* &optional attributes body)
function
DO:          Generate a &lt;fieldset&gt; HTML element: form control group.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(font &optional attributes &body body)
macro
DO:          Generate a &lt;font&gt; HTML element: local change to font.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(font* &optional attributes body)
function
DO:          Generate a &lt;font&gt; HTML element: local change to font.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(form &optional attributes &body body)
macro
DO:          Generate a &lt;form&gt; HTML element: interactive form.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(form* &optional attributes body)
function
DO:          Generate a &lt;form&gt; HTML element: interactive form.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(frame &optional attributes &body body)
macro
DO:          Generate a &lt;frame&gt; HTML element: subwindow.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(frame* &optional attributes body)
function
DO:          Generate a &lt;frame&gt; HTML element: subwindow.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(frameset &optional attributes &body body)
macro
DO:          Generate a &lt;frameset&gt; HTML element: window subdivision.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(frameset* &optional attributes body)
function
DO:          Generate a &lt;frameset&gt; HTML element: window subdivision.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(h1 &optional attributes &body body)
macro
DO:          Generate a &lt;h1&gt; HTML element: Heading.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(h1* &optional attributes body)
function
DO:          Generate a &lt;h1&gt; HTML element: Heading.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(h2 &optional attributes &body body)
macro
DO:          Generate a &lt;h2&gt; HTML element: Heading.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(h2* &optional attributes body)
function
DO:          Generate a &lt;h2&gt; HTML element: Heading.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(h3 &optional attributes &body body)
macro
DO:          Generate a &lt;h3&gt; HTML element: Heading.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(h3* &optional attributes body)
function
DO:          Generate a &lt;h3&gt; HTML element: Heading.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(h4 &optional attributes &body body)
macro
DO:          Generate a &lt;h4&gt; HTML element: Heading.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(h4* &optional attributes body)
function
DO:          Generate a &lt;h4&gt; HTML element: Heading.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(h5 &optional attributes &body body)
macro
DO:          Generate a &lt;h5&gt; HTML element: Heading.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(h5* &optional attributes body)
function
DO:          Generate a &lt;h5&gt; HTML element: Heading.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(h6 &optional attributes &body body)
macro
DO:          Generate a &lt;h6&gt; HTML element: Heading.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(h6* &optional attributes body)
function
DO:          Generate a &lt;h6&gt; HTML element: Heading.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(head &optional attributes &body body)
macro
DO:          Generate a &lt;head&gt; HTML element: document head.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(head* &optional attributes body)
function
DO:          Generate a &lt;head&gt; HTML element: document head.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(hr &optional attributes &body body)
macro
DO:          Generate a &lt;hr&gt; HTML element: horizontal rule.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(hr* &optional attributes body)
function
DO:          Generate a &lt;hr&gt; HTML element: horizontal rule.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(html &optional attributes &body body)
macro
DO:          Generate a &lt;html&gt; HTML element: document root element.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(html* &optional attributes body)
function
DO:          Generate a &lt;html&gt; HTML element: document root element.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
html-string
class
Represents HTML text.
Class precedence list: HTML-STRING ELEMENT STANDARD-OBJECT T
Class init args: TEXT
(html-string* control &rest arguments)
function
RETURN:  An element storing the result of formating the CONTROL string
         with the ARGUMENTS containing HTML code.
EXAMPLE: (HTML-STRING "<P>Some paragraph</P>") --> #<element>
(html-string-text element)
generic-function
RETURN: The string text of the element.
(i &optional attributes &body body)
macro
DO:          Generate a &lt;i&gt; HTML element: italic text style.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(i* &optional attributes body)
function
DO:          Generate a &lt;i&gt; HTML element: italic text style.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(iframe &optional attributes &body body)
macro
DO:          Generate a &lt;iframe&gt; HTML element: inline subwindow.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(iframe* &optional attributes body)
function
DO:          Generate a &lt;iframe&gt; HTML element: inline subwindow.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(img &optional attributes &body body)
macro
DO:          Generate a &lt;img&gt; HTML element: embedded image.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(img* &optional attributes body)
function
DO:          Generate a &lt;img&gt; HTML element: embedded image.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(input &optional attributes &body body)
macro
DO:          Generate a &lt;input&gt; HTML element: form control.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(input* &optional attributes body)
function
DO:          Generate a &lt;input&gt; HTML element: form control.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(ins &optional attributes &body body)
macro
DO:          Generate a &lt;ins&gt; HTML element: inserted text.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(ins* &optional attributes body)
function
DO:          Generate a &lt;ins&gt; HTML element: inserted text.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(isindex &optional attributes &body body)
macro
DO:          Generate a &lt;isindex&gt; HTML element: single line prompt.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(isindex* &optional attributes body)
function
DO:          Generate a &lt;isindex&gt; HTML element: single line prompt.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(kbd &optional attributes &body body)
macro
DO:          Generate a &lt;kbd&gt; HTML element: text to be entered by the user.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(kbd* &optional attributes body)
function
DO:          Generate a &lt;kbd&gt; HTML element: text to be entered by the user.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(label &optional attributes &body body)
macro
DO:          Generate a &lt;label&gt; HTML element: form field label text.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(label* &optional attributes body)
function
DO:          Generate a &lt;label&gt; HTML element: form field label text.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(legend &optional attributes &body body)
macro
DO:          Generate a &lt;legend&gt; HTML element: fieldset legend.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(legend* &optional attributes body)
function
DO:          Generate a &lt;legend&gt; HTML element: fieldset legend.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(li &optional attributes &body body)
macro
DO:          Generate a &lt;li&gt; HTML element: list item.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(li* &optional attributes body)
function
DO:          Generate a &lt;li&gt; HTML element: list item.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(link &optional attributes &body body)
macro
DO:          Generate a &lt;link&gt; HTML element: a media-independent link.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(link* &optional attributes body)
function
DO:          Generate a &lt;link&gt; HTML element: a media-independent link.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(map &optional attributes &body body)
macro
DO:          Generate a &lt;map&gt; HTML element: client-side image map.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(map* &optional attributes body)
function
DO:          Generate a &lt;map&gt; HTML element: client-side image map.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(menu &optional attributes &body body)
macro
DO:          Generate a &lt;menu&gt; HTML element: menu list.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(menu* &optional attributes body)
function
DO:          Generate a &lt;menu&gt; HTML element: menu list.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(meta &optional attributes &body body)
macro
DO:          Generate a &lt;meta&gt; HTML element: generic metainformation.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(meta* &optional attributes body)
function
DO:          Generate a &lt;meta&gt; HTML element: generic metainformation.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(noframes &optional attributes &body body)
macro
DO:          Generate a &lt;noframes&gt; HTML element: alternate content container for non frame-based rendering.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(noframes* &optional attributes body)
function
DO:          Generate a &lt;noframes&gt; HTML element: alternate content container for non frame-based rendering.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(normalize-attribute-name name)
function
NAME:       A string or a symbol.
RETURN:     A string containing the normalized attribute name, ie: downcased.
(noscript &optional attributes &body body)
macro
DO:          Generate a &lt;noscript&gt; HTML element: alternate content container for non script-based rendering.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(noscript* &optional attributes body)
function
DO:          Generate a &lt;noscript&gt; HTML element: alternate content container for non script-based rendering.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(object &optional attributes &body body)
macro
DO:          Generate a &lt;object&gt; HTML element: generic embedded object.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(object* &optional attributes body)
function
DO:          Generate a &lt;object&gt; HTML element: generic embedded object.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(ol &optional attributes &body body)
macro
DO:          Generate a &lt;ol&gt; HTML element: ordered list.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(ol* &optional attributes body)
function
DO:          Generate a &lt;ol&gt; HTML element: ordered list.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(optgroup &optional attributes &body body)
macro
DO:          Generate a &lt;optgroup&gt; HTML element: option group.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(optgroup* &optional attributes body)
function
DO:          Generate a &lt;optgroup&gt; HTML element: option group.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(option &optional attributes &body body)
macro
DO:          Generate a &lt;option&gt; HTML element: selectable choice.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(option* &optional attributes body)
function
DO:          Generate a &lt;option&gt; HTML element: selectable choice.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(p &optional attributes &body body)
macro
DO:          Generate a &lt;p&gt; HTML element: paragraph.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(p* &optional attributes body)
function
DO:          Generate a &lt;p&gt; HTML element: paragraph.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(param &optional attributes &body body)
macro
DO:          Generate a &lt;param&gt; HTML element: named property value.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(param* &optional attributes body)
function
DO:          Generate a &lt;param&gt; HTML element: named property value.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
pcdata
class
Represents PCDATA text.
Class precedence list: PCDATA ELEMENT STANDARD-OBJECT T
Class init args: DATA
(pcdata* control &rest arguments)
function
RETURN:  An element storing the result of formating the CONTROL string
         with the ARGUMENTS as CDATA (ie. post-processed to quote special
         HTML characters (<,>,&,").
(pcdata-data element)
generic-function
The PCDATA text.
(pre &optional attributes &body body)
macro
DO:          Generate a &lt;pre&gt; HTML element: preformatted text.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(pre* &optional attributes body)
function
DO:          Generate a &lt;pre&gt; HTML element: preformatted text.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(q &optional attributes &body body)
macro
DO:          Generate a &lt;q&gt; HTML element: short inline quotation.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(q* &optional attributes body)
function
DO:          Generate a &lt;q&gt; HTML element: short inline quotation.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(s &optional attributes &body body)
macro
DO:          Generate a &lt;s&gt; HTML element: strike-through text style.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(s* &optional attributes body)
function
DO:          Generate a &lt;s&gt; HTML element: strike-through text style.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(samp &optional attributes &body body)
macro
DO:          Generate a &lt;samp&gt; HTML element: sample program output, scripts, etc..
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(samp* &optional attributes body)
function
DO:          Generate a &lt;samp&gt; HTML element: sample program output, scripts, etc..
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(script &optional attributes &body body)
macro
DO:          Generate a &lt;script&gt; HTML element: script statements.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(script* &optional attributes body)
function
DO:          Generate a &lt;script&gt; HTML element: script statements.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(select &optional attributes &body body)
macro
DO:          Generate a &lt;select&gt; HTML element: option selector.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(select* &optional attributes body)
function
DO:          Generate a &lt;select&gt; HTML element: option selector.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(small &optional attributes &body body)
macro
DO:          Generate a &lt;small&gt; HTML element: small text style.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(small* &optional attributes body)
function
DO:          Generate a &lt;small&gt; HTML element: small text style.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(span &optional attributes &body body)
macro
DO:          Generate a &lt;span&gt; HTML element: generic language/style container.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(span* &optional attributes body)
function
DO:          Generate a &lt;span&gt; HTML element: generic language/style container.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(strike &optional attributes &body body)
macro
DO:          Generate a &lt;strike&gt; HTML element: strike-through text.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(strike* &optional attributes body)
function
DO:          Generate a &lt;strike&gt; HTML element: strike-through text.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(strong &optional attributes &body body)
macro
DO:          Generate a &lt;strong&gt; HTML element: strong emphasis.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(strong* &optional attributes body)
function
DO:          Generate a &lt;strong&gt; HTML element: strong emphasis.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(style &optional attributes &body body)
macro
DO:          Generate a &lt;style&gt; HTML element: style info.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(style* &optional attributes body)
function
DO:          Generate a &lt;style&gt; HTML element: style info.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(sub &optional attributes &body body)
macro
DO:          Generate a &lt;sub&gt; HTML element: subscript.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(sub* &optional attributes body)
function
DO:          Generate a &lt;sub&gt; HTML element: subscript.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(sup &optional attributes &body body)
macro
DO:          Generate a &lt;sup&gt; HTML element: superscript.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(sup* &optional attributes body)
function
DO:          Generate a &lt;sup&gt; HTML element: superscript.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(table &optional attributes &body body)
macro
DO:          Generate a &lt;table&gt; HTML element.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(table* &optional attributes body)
function
DO:          Generate a &lt;table&gt; HTML element.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(tbody &optional attributes &body body)
macro
DO:          Generate a &lt;tbody&gt; HTML element: table body.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(tbody* &optional attributes body)
function
DO:          Generate a &lt;tbody&gt; HTML element: table body.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(td &optional attributes &body body)
macro
DO:          Generate a &lt;td&gt; HTML element: table data cell.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(td* &optional attributes body)
function
DO:          Generate a &lt;td&gt; HTML element: table data cell.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(textarea &optional attributes &body body)
macro
DO:          Generate a &lt;textarea&gt; HTML element: multi-line text field.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(textarea* &optional attributes body)
function
DO:          Generate a &lt;textarea&gt; HTML element: multi-line text field.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(tfoot &optional attributes &body body)
macro
DO:          Generate a &lt;tfoot&gt; HTML element: table footer.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(tfoot* &optional attributes body)
function
DO:          Generate a &lt;tfoot&gt; HTML element: table footer.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(th &optional attributes &body body)
macro
DO:          Generate a &lt;th&gt; HTML element: table header cell.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(th* &optional attributes body)
function
DO:          Generate a &lt;th&gt; HTML element: table header cell.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(thead &optional attributes &body body)
macro
DO:          Generate a &lt;thead&gt; HTML element: table header.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(thead* &optional attributes body)
function
DO:          Generate a &lt;thead&gt; HTML element: table header.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(title &optional attributes &body body)
macro
DO:          Generate a &lt;title&gt; HTML element: document title.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(title* &optional attributes body)
function
DO:          Generate a &lt;title&gt; HTML element: document title.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(tr &optional attributes &body body)
macro
DO:          Generate a &lt;tr&gt; HTML element: table row.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(tr* &optional attributes body)
function
DO:          Generate a &lt;tr&gt; HTML element: table row.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(tt &optional attributes &body body)
macro
DO:          Generate a &lt;tt&gt; HTML element: teletype or monospaced text style.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(tt* &optional attributes body)
function
DO:          Generate a &lt;tt&gt; HTML element: teletype or monospaced text style.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(u &optional attributes &body body)
macro
DO:          Generate a &lt;u&gt; HTML element: underlined text style.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(u* &optional attributes body)
function
DO:          Generate a &lt;u&gt; HTML element: underlined text style.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(ul &optional attributes &body body)
macro
DO:          Generate a &lt;ul&gt; HTML element: unordered list.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(ul* &optional attributes body)
function
DO:          Generate a &lt;ul&gt; HTML element: unordered list.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(var &optional attributes &body body)
macro
DO:          Generate a &lt;var&gt; HTML element: instance of a variable or program argument.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(var* &optional attributes body)
function
DO:          Generate a &lt;var&gt; HTML element: instance of a variable or program argument.
ATTRIBUTES:  A P-list of attributes. Attribute names are keywords,
             attribute values are strings.
BODY:        Lisp forms, evaluated between the opening tag of the
             element and the closing tag of the element.
RETURN:      The generated HTML.
(with-html-output (&optional (stream *html-output-stream*) &key (kind html kindp) (encoding us-ascii encodingp)) &body body)
macro
DO:       Execute body (collecting *HTML-TAGS*), and finally writes to
          the STREAM the HTML collected.

KIND:     indicates which kind of is used: :HTML, :XHTML or :XML.
          (tags may be generated differently in HTML 4.01 than in
          XHTML 1.0 or XML).

ENCODING: indicates which character encoding is used to write the
          document.  CDATA and PCDATA may be escaped differently
          depending on the encoding.  (The default is ASCII because
          it's the intersection between the lisp standard character
          set and the default HTML character set (ISO-8859-1).
(write-element element stream)
generic-function
DO:     Write the ELEMENT to the STREAM.
(write-escaping escapes string stream)
function
DO:         Write the STRING to the STREAM, escaping characters found
            in ESCAPES, or not found in the ranges of the
            *HTML-CHARACTER-SET* as &amp;#nn; escapes.
ESCAPES:    An a-list mapping characters to escape strings.
STRING:     A text string.
STREAM:     An output stream.
(write-html element &optional stream)
function
DO:    Write the HTML encoded in the ELEMENT to the output STREAM.