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* #x30200043A81D>
|
*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 <a> 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 <a> 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 <abbr> 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 <abbr> 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 <acronym> 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 <acronym> 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 <address> 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 <address> 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 <applet> 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 <applet> 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 <area> 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 <area> 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 <b> 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 <b> 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 <base> 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 <base> 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 <basefont> 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 <basefont> 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 <bdo> 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 <bdo> 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 <big> 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 <big> 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 <blockquote> 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 <blockquote> 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 <body> 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 <body> 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 <br> 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 <br> 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 <button> 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 <button> 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 <caption> 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 <caption> 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 x) |
generic-function |
The CDATA text.
|
(center &optional attributes &body body) |
macro |
DO: Generate a <center> 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 <center> 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 <cite> 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 <cite> 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 <code> 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 <code> 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 <col> 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 <col> 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 <colgroup> 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 <colgroup> 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 <dd> 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 <dd> 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 <del> 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 <del> 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 <dfn> 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 <dfn> 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 <dir> 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 <dir> 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 <div> 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 <div> 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 <dl> 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 <dl> 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 <dt> 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 <dt> 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 x) |
generic-function |
RETURN: The body of the ELEMENT.
|
(element-tag x) |
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 <em> 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 <em> 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 <fieldset> 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 <fieldset> 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 <font> 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 <font> 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 <form> 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 <form> 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 <frame> 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 <frame> 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 <frameset> 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 <frameset> 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 <h1> 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 <h1> 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 <h2> 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 <h2> 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 <h3> 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 <h3> 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 <h4> 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 <h4> 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 <h5> 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 <h5> 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 <h6> 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 <h6> 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 <head> 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 <head> 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 <hr> 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 <hr> 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 <html> 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 <html> 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 x) |
generic-function |
RETURN: The string text of the element.
|
(i &optional attributes &body body) |
macro |
DO: Generate a <i> 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 <i> 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 <iframe> 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 <iframe> 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 <img> 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 <img> 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 <input> 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 <input> 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 <ins> 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 <ins> 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 <isindex> 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 <isindex> 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 <kbd> 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 <kbd> 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 <label> 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 <label> 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 <legend> 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 <legend> 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 <li> 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 <li> 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 <link> 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 <link> 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 <map> 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 <map> 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 <menu> 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 <menu> 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 <meta> 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 <meta> 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 <noframes> 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 <noframes> 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 <noscript> 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 <noscript> 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 <object> 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 <object> 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 <ol> 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 <ol> 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 <optgroup> 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 <optgroup> 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 <option> 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 <option> 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 <p> 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 <p> 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 <param> 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 <param> 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 x) |
generic-function |
The PCDATA text.
|
(pre &optional attributes &body body) |
macro |
DO: Generate a <pre> 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 <pre> 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 <q> 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 <q> 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 <s> 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 <s> 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 <samp> 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 <samp> 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 <script> 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 <script> 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 <select> 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 <select> 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 <small> 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 <small> 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 <span> 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 <span> 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 <strike> 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 <strike> 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 <strong> 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 <strong> 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 <style> 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 <style> 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 <sub> 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 <sub> 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 <sup> 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 <sup> 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 <table> 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 <table> 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 <tbody> 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 <tbody> 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 <td> 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 <td> 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 <textarea> 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 <textarea> 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 <tfoot> 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 <tfoot> 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 <th> 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 <th> 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 <thead> 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 <thead> 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 <title> 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 <title> 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 <tr> 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 <tr> 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 <tt> 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 <tt> 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 <u> 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 <u> 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 <ul> 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 <ul> 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 <var> 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 <var> 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 &#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.