The closure-html Reference Manual

4.1.1 closure-html/closure-html.asd

Source

closure-html.asd.

Parent Component

closure-html (system).

ASDF Systems

closure-html.

Packages

closure-system.

Public Interface

perform (method).

Internals

closure-source-file (class).

---

4.1.2 closure-html/src/defpack.lisp

Source

closure-html.asd.

Parent Component

src (module).

Packages

• closure-html.
• closure-mime-types.
• sgml.
• html-glisp.

---

4.1.3 closure-html/src/glisp/util.lisp

Source

closure-html.asd.

Parent Component

glisp (module).

Public Interface

• always (function).
• cl-byte-stream (class).
• cl-byte-stream->gstream (function).
• cl-char-stream (class).
• cl-char-stream->gstream (function).
• cl-stream (class).
• compose (function).
• curry (function).
• g/close (method).
• g/finish-output (method).
• g/peek-char (function).
• g/read-byte (method).
• g/read-byte (method).
• g/read-byte-sequence (method).
• g/read-byte-sequence (method).
• g/read-char (method).
• g/read-char (method).
• g/read-char-sequence (method).
• g/read-line (method).
• g/read-line* (method).
• g/unread-byte (method).
• g/unread-byte (method).
• g/unread-char (method).
• g/unread-char (method).
• g/write-byte (method).
• g/write-byte (method).
• g/write-byte-sequence (method).
• g/write-byte-sequence (method).
• g/write-char (method).
• g/write-char (method).
• g/write-string (method).
• gstream (class).
• maybe-parse-integer (function).
• multiple-value-or (macro).
• rcurry (function).
• until (macro).
• use-byte-for-char-stream-flavour (class).
• use-char-for-byte-stream-flavour (class).
• while (macro).
• white-space-p (compiler macro).
• white-space-p (function).

Internals

set-equal (function).

---

4.1.4 closure-html/src/clex/clex.lisp

Source

closure-html.asd.

Parent Component

clex (module).

Packages

clex.

Public Interface

deflexer (macro).

Internals

• *full-table-p* (special variable).
• copy-fsa (function).
• do-bits (macro).
• element-of-set-p (macro).
• frob2 (function).
• fsa (structure).
• fsa-branch (function).
• fsa-concat (function).
• fsa-empty (function).
• fsa-end (reader).
• (setf fsa-end) (writer).
• fsa-epsilon-closure/set (function).
• fsa-iterate (function).
• fsa-p (function).
• fsa-start (reader).
• (setf fsa-start) (writer).
• fsa-trivial (function).
• loadable-states-form (function).
• loose-eq (function).
• make-empty-set (macro).
• make-fsa (function).
• make-state (function).
• mungle-transitions (function).
• ndfsa->dfsa (function).
• nset-put (macro).
• number-states (function).
• old/deflexer (macro).
• over-all-states (function).
• parse-char-set (function).
• regexp->fsa (function).
• regexp-expand-splicing (function).
• regexp/and->fsa (function).
• regexp/or->fsa (function).
• set-size (macro).
• state-add-link (function).
• state-eps-transitions (function).
• (setf state-eps-transitions) (function).
• state-final (function).
• (setf state-final) (function).
• state-id (function).
• (setf state-id) (function).
• state-transitions (function).
• (setf state-transitions) (function).

---

4.1.5 closure-html/src/lalr/lalr.lisp

Source

closure-html.asd.

Parent Component

lalr (module).

Packages

lalr.

Public Interface

define-grammar (macro).

Internals

• *debug-dumping* (special variable).
• *endmarker* (special variable).
• *first-terminals-cache* (special variable).
• *lalr-debug* (special variable).
• *topcat* (constant).
• add-state (function).
• build-parser (function).
• build-state (function).
• build-table (function).
• close-items (function).
• compact-items (function).
• compute-expansion (function).
• copy-item (function).
• copy-rule (function).
• copy-shift (function).
• copy-state (function).
• derives-eps (function).
• derives-epsilon (macro).
• expand (macro).
• expand-citems (macro).
• first-terminals (function).
• first-terminals* (macro).
• first-terms (function).
• fixnum= (macro).
• follow-state (function).
• gcats (special variable).
• gepsilons (special variable).
• get-all-cats (function).
• get-state-name (function).
• gexpansions (special variable).
• gfirsts (special variable).
• glex (special variable).
• grules (special variable).
• gstart (special variable).
• gstarts (special variable).
• item (structure).
• item-core-equal (macro).
• item-daughters (macro).
• item-equal (macro).
• item-la (reader).
• (setf item-la) (writer).
• item-p (function).
• item-pos (reader).
• (setf item-pos) (writer).
• item-right (macro).
• item-rule (reader).
• (setf item-rule) (writer).
• items-right (function).
• lookup (function).
• make-item (function).
• make-parser (function).
• make-rule (function).
• make-shift (function).
• make-state (function).
• merge-citems (function).
• nextstateno (special variable).
• print-table (function).
• rule (structure).
• rule-action (reader).
• (setf rule-action) (writer).
• rule-daughters (reader).
• (setf rule-daughters) (writer).
• rule-mother (reader).
• (setf rule-mother) (writer).
• rule-no (reader).
• (setf rule-no) (writer).
• rule-p (function).
• shift (structure).
• shift-cat (reader).
• (setf shift-cat) (writer).
• shift-items (function).
• shift-p (function).
• shift-where (reader).
• (setf shift-where) (writer).
• state (structure).
• state-citems (reader).
• (setf state-citems) (writer).
• state-conflict (reader).
• (setf state-conflict) (writer).
• state-name (reader).
• (setf state-name) (writer).
• state-p (function).
• state-shifts (reader).
• (setf state-shifts) (writer).
• statelist (special variable).
• subsumes-citems (function).
• transform-rule (function).
• translate-state (function).

---

4.1.6 closure-html/src/net/mime.lisp

Source

closure-html.asd.

Parent Component

net (module).

Public Interface

• find-mime-type (function).
• find-mime-type-from-extension (function).
• mime-type-equal (function).
• mime-type-extensions (reader).
• (setf mime-type-extensions) (writer).
• mime-type-name (reader).
• (setf mime-type-name) (writer).
• parse-mime-content-type (function).

Internals

• *base64-codes* (special variable).
• *mime-types* (special variable).
• compose-multi-part-message (function).
• compose-multipart/form-data (function).
• copy-mime-type (function).
• decode-base64-string (function).
• define-mime-type (function).
• encode-string-base64 (function).
• make-mime-type (function).
• make-simple-disposition (function).
• mime-type (structure).
• mime-type-p (function).
• parse-mime/literal-char-p (function).
• parse-mime/parameter (function).
• parse-mime/parameter-list (function).
• parse-mime/quoted-string (function).
• parse-mime/special (function).
• parse-mime/token (function).
• parse-mime/type-and-subtype (function).
• unparse-content-type (function).
• unparse-parameter-list (function).

---

4.1.7 closure-html/src/parse/pt.lisp

Source

closure-html.asd.

Parent Component

parse (module).

Public Interface

• flat-find-element (function).
• flat-find-elements (function).
• gi (function).
• map-pt (function).
• ppt (function).
• print-object (method).
• pt (structure).
• pt-attr (function).
• (setf pt-attr) (function).
• pt-attrs (reader).
• (setf pt-attrs) (writer).
• pt-cdata (function).
• pt-children (reader).
• (setf pt-children) (writer).
• pt-full-name-path (function).
• pt-name (reader).
• (setf pt-name) (writer).
• pt-parent (reader).
• (setf pt-parent) (writer).
• pt-root (function).

Internals

• ancestorp (function).
• copy-pt (function).
• delete-pt (function).
• make-pt (function).
• make-pt/low (function).
• map-pt-with-pcdata (function).
• print-pt (function).
• pt-access (function).
• pt-cache (reader).
• (setf pt-cache) (writer).
• pt-p (function).
• pt-path (function).
• pt-plist (reader).
• (setf pt-plist) (writer).
• remove-pt (function).

---

4.1.8 closure-html/src/parse/sgml-dtd.lisp

Source

closure-html.asd.

Parent Component

parse (module).

Public Interface

• make-load-form (method).
• make-load-form (method).
• make-load-form (method).
• make-load-form (method).
• make-load-form (method).
• make-load-form (method).
• parse-dtd (function).
• print-object (method).
• print-object (method).
• print-object (method).

Internals

• *dtd* (special variable).
• *entities* (special variable).
• action (macro).
• add-entity (function).
• all-elms (function).
• as-cons (function).
• calculate-resolve-info (function).
• canon-optional-tag-definition (function).
• comment-token (structure).
• comment-token-data (reader).
• (setf comment-token-data) (writer).
• comment-token-p (function).
• copy-comment-token (function).
• copy-dtd (function).
• copy-element (function).
• copy-end-tag (function).
• copy-start-tag (function).
• copy-tag (function).
• copy-token (function).
• dtd (structure).
• dtd-elements (reader).
• (setf dtd-elements) (writer).
• dtd-elm-surclusion-cache (reader).
• (setf dtd-elm-surclusion-cache) (writer).
• dtd-entities (reader).
• (setf dtd-entities) (writer).
• dtd-name (reader).
• (setf dtd-name) (writer).
• dtd-p (function).
• dtd-parser (function).
• dtd-resolve-info (reader).
• (setf dtd-resolve-info) (writer).
• dtd-root-elements (reader).
• (setf dtd-root-elements) (writer).
• dump-dtd (function).
• element (structure).
• element-attlist (reader).
• (setf element-attlist) (writer).
• element-exclude (reader).
• (setf element-exclude) (writer).
• element-include (reader).
• (setf element-include) (writer).
• element-name (reader).
• (setf element-name) (writer).
• element-obegin? (reader).
• (setf element-obegin?) (writer).
• element-oend? (reader).
• (setf element-oend?) (writer).
• element-p (function).
• elm-etag (function).
• elm-inclusion (function).
• elm-oend? (function).
• elm-ostart? (function).
• elm-stag (function).
• elm-surclusion (function).
• elms-eqv (function).
• end-tag (structure).
• end-tag-name (function).
• (setf end-tag-name) (function).
• end-tag-p (function).
• eqv-classes (function).
• find-dtd-top-elements (function).
• find-element (function).
• find-element-attlist (function).
• find-entity (function).
• legal-in-p (function).
• make-comment-token (function).
• make-dtd (function).
• make-dtd-lexer (function).
• make-element (function).
• make-end-tag (function).
• make-start-tag (function).
• make-tag (function).
• make-token (function).
• new-entities (function).
• open-public-resource (function).
• open-sgml-resource (function).
• open-system-resource (function).
• print-dtd (function).
• print-end-tag (function).
• print-start-tag (function).
• process-attribute (function).
• process-def-attlist (function).
• process-def-element (function).
• process-dtd-def (function).
• production->name-list (function).
• production->name-list/2 (function).
• raux (function).
• resolve (function).
• resolve-key (function).
• save-html-dtd (function).
• set-equal (function).
• sgml-resource-as-string (function).
• start-tag (structure).
• start-tag-atts (reader).
• (setf start-tag-atts) (writer).
• start-tag-name (function).
• (setf start-tag-name) (function).
• start-tag-p (function).
• tag (structure).
• tag-name (reader).
• (setf tag-name) (writer).
• tag-p (function).
• token (structure).
• token-p (function).
• undump-dtd (function).

---

4.1.9 closure-html/src/parse/sgml-parse.lisp

Dependencies

• sgml-dtd.lisp (file).
• pt.lisp (file).

Source

closure-html.asd.

Parent Component

parse (module).

Public Interface

• *options/parser-silent-p* (special variable).
• html-parse-file (function).
• sgml-parse (function).

Internals

• *anchor-heuristic-p* (special variable).
• *buf-size* (special variable).
• *font-heuristic-p* (special variable).
• *gt-ends-comment-p* (special variable).
• *line-number* (special variable).
• *parse-warn-level* (special variable).
• *preserves-comments-elements* (special variable).
• *unmungle-attribute-case* (special variable).
• a-peek-byte (macro).
• a-read-byte (macro).
• a-stream-position (macro).
• a-stream-scratch (function).
• (setf a-stream-scratch) (function).
• a-unread-byte (macro).
• alpha-rune-p (function).
• canon-value (function).
• check-saneness (function).
• copy-hetag-node (function).
• copy-hstag-node (function).
• copy-htag-node (function).
• document-action (function).
• empty-element-p (function).
• enlarge-scratch-pad (function).
• equivalence-classes (function).
• find-named-entity (function).
• find-slot-value-pair (function).
• foofoo (function).
• handle-meta-tag-in-parser (function).
• hetag-node (structure).
• hetag-node-attrs (function).
• (setf hetag-node-attrs) (function).
• hetag-node-cache (function).
• (setf hetag-node-cache) (function).
• hetag-node-children (function).
• (setf hetag-node-children) (function).
• hetag-node-name (function).
• (setf hetag-node-name) (function).
• hetag-node-p (function).
• hetag-node-parent (function).
• (setf hetag-node-parent) (function).
• hetag-node-plist (function).
• (setf hetag-node-plist) (function).
• heuristic (function).
• hstag-node (structure).
• hstag-node-attrs (function).
• (setf hstag-node-attrs) (function).
• hstag-node-cache (function).
• (setf hstag-node-cache) (function).
• hstag-node-children (function).
• (setf hstag-node-children) (function).
• hstag-node-name (function).
• (setf hstag-node-name) (function).
• hstag-node-p (function).
• hstag-node-parent (function).
• (setf hstag-node-parent) (function).
• hstag-node-plist (function).
• (setf hstag-node-plist) (function).
• htag-node (structure).
• htag-node-attrs (function).
• (setf htag-node-attrs) (function).
• htag-node-cache (function).
• (setf htag-node-cache) (function).
• htag-node-children (function).
• (setf htag-node-children) (function).
• htag-node-name (function).
• (setf htag-node-name) (function).
• htag-node-p (function).
• htag-node-parent (function).
• (setf htag-node-parent) (function).
• htag-node-plist (function).
• (setf htag-node-plist) (function).
• kintern (function).
• make-a-stream (function).
• make-hetag-node (function).
• make-hstag-node (function).
• make-htag-node (function).
• map-htag-pairs (function).
• mungle (function).
• mungle-attlist (function).
• mungle-font-pair (function).
• name-char-p (function).
• name-rune-p (function).
• name-start-char-p (function).
• name-start-rune-p (function).
• parse-html (function).
• parse-warn (function).
• post-mortem-heuristic (function).
• post-mortem/fix-font (function).
• post-mortem/fix-top-level-structure (function).
• push-on-scratch (function).
• read-attribute (function).
• read-comment (function).
• read-define-tag (function).
• read-define-tag-2 (function).
• read-end-tag (function).
• read-entity-ref (function).
• read-experimental-tag (function).
• read-literal (function).
• read-name (function).
• read-name-and-attributes (function).
• read-named-entity (function).
• read-numeric-entity (function).
• read-numeric-entity-aux (function).
• read-octets (method).
• read-pcdata (function).
• read-sloopy-name (function).
• read-sloopy-value (function).
• read-start-tag (function).
• read-tag (function).
• read-tag-error (function).
• read-token (function).
• read-token* (function).
• read-value (function).
• resolve-entities-in-string (function).
• resolve-hex-entity (function).
• resolve-named-entity (function).
• resolve-numeric-entity (function).
• setup-code-vector (function).
• sgml-parse-file (function).
• shortest-different-beginning (function).
• shortest-path (function).
• shortest-path-to (function).
• shortest-path/aux (function).
• skip-white-space (function).
• sloopy-name-rune-p (function).
• sloopy-value-rune-p (function).
• subseq/rod (function).
• tag-as-marker-p (function).
• tag-exists? (function).
• transition (function).
• upcase-name-rune (function).
• valid-name-string-p (function).
• white-space-token-p (function).
• xstream/close (method).

---

4.1.10 closure-html/src/parse/html-parser.lisp

Dependency

sgml-parse.lisp (file).

Source

closure-html.asd.

Parent Component

parse (module).

Public Interface

• *html-dtd* (special variable).
• characters (method).
• comment (method).
• end-document (method).
• end-element (method).
• make-pt-builder (function).
• parse (function).
• pt-builder (class).
• serialize-pt (function).
• start-document (method).
• start-element (method).

Internals

• *simple-catalog* (special variable).
• current (reader method).
• (setf current) (writer method).
• parse-xstream (function).
• root (reader method).
• (setf root) (writer method).
• serialize-pt-attributes (function).
• unserialize-pt-attributes (function).

---

4.1.11 closure-html/src/parse/lhtml.lisp

Dependency

html-parser.lisp (file).

Source

closure-html.asd.

Parent Component

parse (module).

Public Interface

• characters (method).
• comment (method).
• end-document (method).
• end-element (method).
• lhtml->pt (function).
• lhtml-builder (class).
• make-lhtml-builder (function).
• serialize-lhtml (function).
• start-document (method).
• start-element (method).

Internals

• lhtml-reader (function).
• pt-attributes-to-lhtml (function).
• root (reader method).
• (setf root) (writer method).
• serialize-lhtml-attributes (function).
• stack (reader method).
• (setf stack) (writer method).
• walk-lhtml (function).

---

4.1.12 closure-html/src/parse/unparse.lisp

Dependency

html-parser.lisp (file).

Source

closure-html.asd.

Parent Component

parse (module).

Public Interface

• attribute (function).
• characters (method).
• comment (function).
• comment (method).
• end-document (method).
• end-element (method).
• initialize-instance (method).
• make-character-stream-sink (function).
• make-octet-stream-sink (function).
• make-octet-vector-sink (function).
• make-rod-sink (function).
• make-string-sink (function).
• start-document (method).
• start-element (method).
• text (function).
• unescaped (method).
• with-element (macro).
• with-html-output (macro).
• with-output-sink (macro).

Internals

• *current-element* (special variable).
• *sink* (special variable).
• escape-uri-attribute (function).
• invoke-with-element (function).
• invoke-with-html-output (function).
• invoke-with-output-sink (function).
• maybe-emit-start-tag (function).
• sink (class).
• sink-encoding (reader method).
• sink-write-rod (function).
• sink-write-rune (function).
• sink-ystream (reader method).
• (setf sink-ystream) (writer method).
• stack (reader method).
• (setf stack) (writer method).
• unparse-attribute (generic function).
• unparse-attribute-string (function).
• unparse-datachar (function).
• unparse-datachar-readable (function).
• unparse-dtd-char (function).
• unparse-dtd-string (function).
• unparse-string (function).
• uri-attribute-p (function).

---

4.1.13 closure-html/src/parse/documentation.lisp

Dependency

html-parser.lisp (file).

Source

closure-html.asd.

Parent Component

parse (module).

---

6.1.1 Special variables

Special Variable: *html-dtd* ¶

fixme: exported only for the benefit of Closure

Package

closure-html.

Source

html-parser.lisp.

Special Variable: *options/parser-silent-p* ¶

Package

sgml.

Source

sgml-parse.lisp.

---

6.1.2 Macros

Macro: define-grammar (name lex-forms &rest grammar) ¶

Package

lalr.

Source

lalr.lisp.

Macro: deflexer (name macro-defs &rest rule-defs) ¶

Package

clex.

Source

clex.lisp.

Macro: multiple-value-or (&rest xs) ¶

Package

html-glisp.

Source

util.lisp.

Macro: until (test &body body) ¶

Package

html-glisp.

Source

util.lisp.

Macro: while (test &body body) ¶

Package

html-glisp.

Source

util.lisp.

Macro: with-element (name &body body) ¶

@arg[name]{the element’s name, a string/rod}
@arg[body]{an implicit progn}
@return{the value of @var{body}}
@short{Generate @fun{hax:start-element} and @fun{hax:end-element} events.}

Execute @var{body} as an implicit progn. Send a start-element event to the current sink (before the first child element begins, or the current element ends), including all attributes specified using @fun{attribute} until that point. Send an end-element event after @var{body} is finished.

To be used in the extent of an @fun{with-html-output} invocation.

Package

closure-html.

Source

unparse.lisp.

Macro: with-html-output ((sink &key name public-id system-id) &body body) ¶

@arg[sink]{a HAX/SAX handler}
@arg[name]{root element name, a rod/string}
@arg[public-id]{nil or the Public ID, a rod/string} @arg[system-id]{nil or the System ID/URI, a rod/string} @arg[body]{an implicit progn}
@return{the value of @var{body}}
@short{Generate @fun{hax:start-document} and @fun{hax:end-document} events.}

Send a start-document event to the current sink, then execute @var{body} as an implicit progn. Afterwards, send an end-element event.

@see{with-output-sink}
@see{with-element}
@see{attribute}
@see{text}
@see{comment}

Package

closure-html.

Source

unparse.lisp.

Macro: with-output-sink ((var) &body body) ¶

@arg[var]{the variable name, a symbol}
@arg[body]{an implicit progn}
@return{the value of @var{body}}
@short{Bind a variable to the current serialization sink.}

Execute @var{body} as an implicit progn with @var{var} bound to a serialization sink that @var{body} can safely call HAX functions on.

To be used in the extent of an @fun{with-html-output} invocation.

Package

closure-html.

Source

unparse.lisp.

---

6.1.3 Compiler macros

Compiler Macro: white-space-p (ch) ¶

Package

html-glisp.

Source

util.lisp.

---

6.1.4 Ordinary functions

Function: always (value) ¶

Package

html-glisp.

Source

util.lisp.

Function: attribute (name value) ¶

@arg[name]{a string/rod}
@arg[value]{a string/rod or other object}
@return{the @var{value}}
@short{Add an attribute to the current element.}

To be used in the extent of an @fun{with-element} invocation, this function adds an attribute to the element being serialized.

Package

closure-html.

Source

unparse.lisp.

Function: cl-byte-stream->gstream (stream) ¶

Package

html-glisp.

Source

util.lisp.

Function: cl-char-stream->gstream (stream) ¶

Package

html-glisp.

Source

util.lisp.

Function: comment (data) ¶

@arg[data]{a string/rod}
@return{the @var{data}}
@short{Write a comment node.}

To be used in the extent of an @fun{with-html-output} invocation, this function serializes a comment.

Package

closure-html.

Source

unparse.lisp.

Function: compose (f g) ¶

Package

html-glisp.

Source

util.lisp.

Function: curry (fun &rest args) ¶

Package

html-glisp.

Source

util.lisp.

Function: find-mime-type (name) ¶

Finds a mime type by name, returns NIL, if not found, or the mime type object.

Package

closure-mime-types.

Source

mime.lisp.

Function: find-mime-type-from-extension (extension) ¶

Given a file name extension find the corressponding mime type; returned is either NIL, if not found, or the mime-type object.

Package

closure-mime-types.

Source

mime.lisp.

Function: flat-find-element (gi pt &optional default) ¶

Package

sgml.

Source

pt.lisp.

Function: flat-find-elements (gi pt) ¶

Package

sgml.

Source

pt.lisp.

Function: g/peek-char (&optional peek-type source eof-error-p eof-value) ¶

Package

html-glisp.

Source

util.lisp.

Function: gi (x) ¶

Package

sgml.

Source

pt.lisp.

Function: html-parse-file (filename) ¶

Package

sgml.

Source

sgml-parse.lisp.

Function: lhtml->pt (lhtml) ¶

Package

sgml.

Source

lhtml.lisp.

Function: make-character-stream-sink (stream &rest initargs &key encoding &allow-other-keys) ¶

@return{a HAX handler}
@short{Returns a sink writing to a character stream.}

This function creates a serialization sink. Sinks are HAX handlers that write events in their normal HTML syntax.

This particular kind of sink writen the HTML document to a stream of element-type @code{character}. The characters written are @em{not} encoded into an external-format. Make sure that the stream’s external format agrees with the encoding declared by the document, if any.

@b{Supported only on Lisps with Unicode support.} On Lisps without Unicode characters, try @em{make-character-stream-sink/utf8} as an alternative that has different encoding behaviour, but still uses character streams.

@see{make-octet-stream-sink}
@see{make-octet-vector-sink}
@see{make-rod-sink}
@see{make-string-sink}

Package

closure-html.

Source

unparse.lisp.

Function: make-lhtml-builder () ¶

@return{The @class{lhtml-builder}, a HAX handler.}
@short{Create a HAX handler which builds LHTML list structures.}

Example:
@begin{pre}
(chtml:parse "<p>nada</p>" (chtml:make-lhtml-builder)) @end{pre}
@begin{code}
=> (:HTML NIL (:HEAD NIL) (:BODY NIL (:P NIL "nada"))) @end{code}

@see{parse}
@see{serialize-lhtml}

Package

closure-html.

Source

lhtml.lisp.

Function: make-octet-stream-sink (stream &rest initargs &key encoding &allow-other-keys) ¶

@return{a HAX handler}
@short{Returns a sink writing to an octet stream.}

This function creates a serialization sink. Sinks are HAX handlers that write events in their normal HTML syntax.

This particular kind of sink writen the HTML document to a stream of element-type @code{(unsigned-byte 8)}.

@see{make-character-stream-sink} @see{make-octet-vector-sink}
@see{make-rod-sink}
@see{make-string-sink}

Package

closure-html.

Source

unparse.lisp.

Function: make-octet-vector-sink (&rest initargs &key encoding &allow-other-keys) ¶

@return{a HAX handler}
@short{Returns a sink creating octet vectors.}

This function creates a serialization sink. Sinks are HAX handlers that write events in their normal HTML syntax, and return
the result from @fun{hax:end-document}, if applicable.

This particular kind of sink creates an HTML document in an array of @code{(unsigned-byte 8)}.

@see{make-character-stream-sink} @see{make-octet-stream-sink}
@see{make-rod-sink}
@see{make-string-sink}

Package

closure-html.

Source

unparse.lisp.

Function: make-pt-builder () ¶

@return{The @class{pt-builder}, a HAX handler.}
@short{Create a HAX handler which builds @class{pt} structures.}

Example:
@begin{pre}
(chtml:parse "<p>nada</p>" (chtml:make-pt-builder)) @end{pre}
@begin{code}
=> #<SGML:PT HTML ..>
@end{code}

@see{parse}
@see{serialize-pt}

Package

closure-html.

Source

html-parser.lisp.

Function: make-rod-sink (&rest initargs &key encoding &allow-other-keys) ¶

@return{a HAX handler}
@short{Returns a sink creating rods.}

This function creates a serialization sink. Sinks are HAX handlers that write events in their normal HTML syntax, and return
the result from @fun{hax:end-document}, if applicable.

This particular kind of sink creates an HTML document in a rod.

On Lisps with Unicode support, @code{make-string-sink} is an alias for this function.

@see{make-character-stream-sink} @see{make-octet-stream-sink}
@see{make-octet-vector-sink}
@see{make-string-sink}

Package

closure-html.

Source

unparse.lisp.

Function: make-string-sink (&rest args) ¶

@return{a HAX handler}
@short{Returns a sink creating strings.}

This function creates a serialization sink. Sinks are HAX handlers that write events in their normal HTML syntax, and return
the result from @fun{hax:end-document}, if applicable.

This particular kind of sink creates an HTML document in a string. The string is @em{not} encoded into an external-format. When writing this string to a Lisp character stream at a later point, make sure that the stream’s external format agrees with the encoding declared by the document, if any.

@b{Supported only on Lisps with Unicode support.} On Lisps without Unicode characters, try @em{make-string-sink/utf8} as an alternative that has different encoding behaviour, but still uses strings. Or use @em{make-rod-sink}, which creates arrays of code points.

@see{make-character-stream-sink} @see{make-octet-stream-sink}
@see{make-octet-vector-sink}
@see{make-rod-sink}

Package

closure-html.

Source

unparse.lisp.

Function: map-pt (fun pt) ¶

Apply ’fun’ to all parse tree nodes in ’pt’.

Package

sgml.

Source

pt.lisp.

Function: maybe-parse-integer (string &key radix) ¶

Package

html-glisp.

Source

util.lisp.

Function: mime-type-equal (mime-type type subtype) ¶

Package

closure-mime-types.

Source

mime.lisp.

Reader: mime-type-extensions (instance) ¶

Writer: (setf mime-type-extensions) (instance) ¶

Package

closure-mime-types.

Source

mime.lisp.

Target Slot

extensions.

Reader: mime-type-name (instance) ¶

Writer: (setf mime-type-name) (instance) ¶

Package

closure-mime-types.

Source

mime.lisp.

Target Slot

name.

Function: parse (input handler) ¶

@arg[input]{a pathname, stream, string, or octet array} @arg[handler]{nil, or a HAX/SAX handler}
@return{The return value of this function is determined by the @var{handler} argument; see below.}
@short{Parse the HTML document given as an argument, or referred to using a pathname.}

@var{input} can have one of the following types: @begin{itemize}
@item{pathname – a Common Lisp pathname. Opens the file specified by the pathname parses it as an HTML document.}
@item{stream – a Common Lisp stream that has already been opened.} @item{array – an @code{(unsigned-byte 8)} array. The array is parsed directly, and interpreted according to the encoding it specifies.} @item{string/rod – a rod (or string on unicode-capable implementations). Parses an XML document from the input string that has already undergone external-format decoding.} @end{itemize}

If @var{handler} is @code{nil}, the parser’s internal representation of the document is returned. The result is equivalent to that returned using a PT builder as returned by @fun{make-pt-builder}, but avoids creating the same representation twice.

Alternatively, @var{handler} can be a HAX handler
(see @class{hax:abstract-handler}) or a SAX handler (see the @a[http://common-lisp.net/project/cxml/sax.html#sax]{SAX protocol in cxml}). In this case, the document will be serialized to the specified handler, and the result of @fun{hax:end-document} will be returned from this function. Note that the parser will currently always process the entire document before sending the first HAX event.

Package

closure-html.

Source

html-parser.lisp.

Function: parse-dtd (res-name &optional top-elment) ¶

Package

sgml.

Source

sgml-dtd.lisp.

Function: parse-mime-content-type (string &optional start end) ¶

Package

closure-mime-types.

Source

mime.lisp.

Function: ppt (pt &optional stream prefix barp) ¶

Package

sgml.

Source

pt.lisp.

Function: pt-attr (pt prop &optional default) ¶

Package

sgml.

Source

pt.lisp.

Function: (setf pt-attr) (pt prop) ¶

Package

sgml.

Source

pt.lisp.

Reader: pt-attrs (instance) ¶

@arg[instance]{a @class{pt} node}
@return{a plist}
@short{Returns the element’s attributes as a plist.}

This plist maps attribute names to their values.

Attribute names are symbols in the keyword package with uppercase names. Attribute values are strings/rods.

Package

sgml.

Source

pt.lisp.

Target Slot

attrs.

Writer: (setf pt-attrs) (instance) ¶

Package

sgml.

Source

pt.lisp.

Target Slot

attrs.

Function: pt-cdata (pt) ¶

Package

sgml.

Source

pt.lisp.

Reader: pt-children (instance) ¶

@arg[instance]{a @class{pt} node}
@return{a list}
@short{Returns the element’s children.}

The children of a PT node are strings (rods) for text nodes, or other PT nodes for elements.

@see{pt-parent}

Package

sgml.

Source

pt.lisp.

Target Slot

children.

Writer: (setf pt-children) (instance) ¶

Package

sgml.

Source

pt.lisp.

Target Slot

children.

Function: pt-full-name-path (pt) ¶

Package

sgml.

Source

pt.lisp.

Reader: pt-name (instance) ¶

@arg[instance]{a @class{pt} node}
@return{a keyword symbol}
@short{Returns the element’s name.}

HTML element names are symbols in the keyword package with uppercase names.

Package

sgml.

Source

pt.lisp.

Target Slot

name.

Writer: (setf pt-name) (instance) ¶

Package

sgml.

Source

pt.lisp.

Target Slot

name.

Reader: pt-parent (instance) ¶

@arg[instance]{a @class{pt} node}
@return{nil, or a @class{pt} node}
@short{Returns the element’s parent node.}

This slot should refer to the node’s parent, if it is included in the list of that node’s children.

@see{pt-children}

Package

sgml.

Source

pt.lisp.

Target Slot

parent.

Writer: (setf pt-parent) (instance) ¶

Package

sgml.

Source

pt.lisp.

Target Slot

parent.

Function: pt-root (pt) ¶

Package

sgml.

Source

pt.lisp.

Function: rcurry (fun &rest args) ¶

Package

html-glisp.

Source

util.lisp.

Function: serialize-lhtml (document handler &key name public-id system-id) ¶

@arg[document]{an LHTML list}
@arg[handler]{a HAX/SAX handler}
@arg[name]{root element name, a rod/string}
@arg[public-id]{nil or the Public ID, a rod/string} @arg[system-id]{nil or the System ID/URI, a rod/string} @return{The return value of this function is determined by the @var{handler} argument; see below.}
@short{Serialize the LHTML document into HAX events, sent to the specified HAX handler.}

@var{handler} can be a HAX handler
(see @class{hax:abstract-handler}) or a SAX handler (see the @a[http://common-lisp.net/project/cxml/sax.html#sax]{SAX protocol in cxml}).

The result of calling @fun{hax:end-document} on the handler will be returned from this function.

If @var{system-id} is specified, a doctype will be written according to the arguments @var{name}, @var{public-id}, and @var{system-id}.

Use this function with a serialization sink to get a string or file with a serialized HTML document, or with a HAX/SAX builder to convert LHTML into a different representation, like DOM, PT, or STP.

Example:
@begin{pre}
(let ((x ’(:HTML NIL (:HEAD NIL) (:BODY NIL (:P NIL "nada")))))) (chtml:serialize-lhtml x (chtml:make-string-sink))
@end{pre}
@begin{code}
=> "<HTML><HEAD></HEAD><BODY><P>nada</P></BODY></HTML>" @end{code}

@see{parse}
@see{make-lhtml-builder}

Package

closure-html.

Source

lhtml.lisp.

Function: serialize-pt (document handler &key name public-id system-id documentp) ¶

@arg[document]{an @class{pt} instance}
@arg[handler]{a HAX/SAX handler}
@arg[name]{root element name, a rod/string}
@arg[public-id]{nil or the Public ID, a rod/string} @arg[system-id]{nil or the System ID/URI, a rod/string} @return{The return value of this function is determined by the @var{handler} argument; see below.}
@short{Serialize the PT node into HAX events, sent to the specified HAX handler.}

@var{handler} can be a HAX handler
(see @class{hax:abstract-handler}) or a SAX handler (see the @a[http://common-lisp.net/project/cxml/sax.html#sax]{SAX protocol in cxml}).

The result of calling @fun{hax:end-document} on the handler will be returned from this function.

If @var{system-id} is specified, a doctype will be written according to the arguments @var{name}, @var{public-id}, and @var{system-id}.

Use this function with a serialization sink to get a string or file with a serialized HTML document, or with a HAX/SAX builder to convert PT into a different representation, like DOM, LHTML, or STP.

Example:
@begin{pre}
(let ((x (chtml:parse "<p>nada</p>" (chtml:make-pt-builder))))) (chtml:serialize-pt x (chtml:make-string-sink))
@end{pre}
@begin{code}
=> "<HTML><HEAD></HEAD><BODY><P>nada</P></BODY></HTML>" @end{code}

@see{parse}
@see{make-pt-builder}

Package

closure-html.

Source

html-parser.lisp.

Function: sgml-parse (dtd input) ¶

Package

sgml.

Source

sgml-parse.lisp.

Function: text (data) ¶

@arg[data]{a string/rod}
@return{the @var{data}}
@short{Write a text node.}

To be used in the extent of an @fun{with-html-output} invocation, this function serializes a text node.

Package

closure-html.

Source

unparse.lisp.

Function: white-space-p (ch) ¶

Package

html-glisp.

Source

util.lisp.

---

6.1.5 Generic functions

Generic Function: g/close (self &key abort) ¶

Package

html-glisp.

Methods

Method: g/close ((self cl-stream) &key abort) ¶

Source

util.lisp.

Generic Function: g/finish-output (self) ¶

Package

html-glisp.

Methods

Method: g/finish-output ((self cl-stream)) ¶

Source

util.lisp.

Generic Function: g/read-byte (self &optional eof-error-p eof-value) ¶

Package

html-glisp.

Methods

Method: g/read-byte ((self cl-byte-stream) &optional eof-error-p eof-value) ¶

Source

util.lisp.

Method: g/read-byte ((self use-char-for-byte-stream-flavour) &optional eof-error-p eof-value) ¶

Source

util.lisp.

Generic Function: g/read-byte-sequence (sequence input &key start end) ¶

Package

html-glisp.

Methods

Method: g/read-byte-sequence (sequence input &key start end) ¶

Source

util.lisp.

Method: g/read-byte-sequence (sequence (input cl-byte-stream) &key start end) ¶

Source

util.lisp.

Generic Function: g/read-char (self &optional eof-error-p eof-value) ¶

Package

html-glisp.

Methods

Method: g/read-char ((self cl-char-stream) &optional eof-error-p eof-value) ¶

Source

util.lisp.

Method: g/read-char ((self use-byte-for-char-stream-flavour) &optional eof-error-p eof-value) ¶

Source

util.lisp.

Generic Function: g/read-char-sequence (sequence input &key start end) ¶

Package

html-glisp.

Methods

Method: g/read-char-sequence (sequence input &key start end) ¶

Source

util.lisp.

Generic Function: g/read-line (stream &optional eof-error-p eof-value) ¶

Package

html-glisp.

Methods

Method: g/read-line (stream &optional eof-error-p eof-value) ¶

Source

util.lisp.

Generic Function: g/read-line* (stream &optional eof-error-p eof-value) ¶

Package

html-glisp.

Methods

Method: g/read-line* (stream &optional eof-error-p eof-value) ¶

Source

util.lisp.

Generic Function: g/unread-byte (byte self) ¶

Package

html-glisp.

Methods

Method: g/unread-byte (byte (self cl-byte-stream)) ¶

Source

util.lisp.

Method: g/unread-byte (byte (self use-char-for-byte-stream-flavour)) ¶

Source

util.lisp.

Generic Function: g/unread-char (char self) ¶

Package

html-glisp.

Methods

Method: g/unread-char (char (self cl-char-stream)) ¶

Source

util.lisp.

Method: g/unread-char (char (self use-byte-for-char-stream-flavour)) ¶

Source

util.lisp.

Generic Function: g/write-byte (byte self) ¶

Package

html-glisp.

Methods

Method: g/write-byte (byte (self cl-byte-stream)) ¶

Source

util.lisp.

Method: g/write-byte (byte (self use-char-for-byte-stream-flavour)) ¶

Source

util.lisp.

Generic Function: g/write-byte-sequence (sequence sink &key start end) ¶

Package

html-glisp.

Methods

Method: g/write-byte-sequence (sequence sink &key start end) ¶

Source

util.lisp.

Method: g/write-byte-sequence (sequence (sink cl-byte-stream) &key start end) ¶

Source

util.lisp.

Generic Function: g/write-char (char self) ¶

Package

html-glisp.

Methods

Method: g/write-char (char (self cl-char-stream)) ¶

Source

util.lisp.

Method: g/write-char (char (self use-byte-for-char-stream-flavour)) ¶

Source

util.lisp.

Generic Function: g/write-string (string stream &key start end) ¶

Package

html-glisp.

Methods

Method: g/write-string (string stream &key start end) ¶

Source

util.lisp.

---

6.1.6 Standalone methods

Method: characters ((handler pt-builder) data) ¶

Package

hax.

Source

html-parser.lisp.

Method: characters ((handler lhtml-builder) data) ¶

Package

hax.

Source

lhtml.lisp.

Method: characters ((sink sink) data) ¶

Package

hax.

Source

unparse.lisp.

Method: comment ((handler pt-builder) data) ¶

Package

hax.

Source

html-parser.lisp.

Method: comment ((handler lhtml-builder) data) ¶

Package

hax.

Source

lhtml.lisp.

Method: comment ((sink sink) data) ¶

Package

hax.

Source

unparse.lisp.

Method: end-document ((handler pt-builder)) ¶

Package

hax.

Source

html-parser.lisp.

Method: end-document ((handler lhtml-builder)) ¶

Package

hax.

Source

lhtml.lisp.

Method: end-document ((sink sink)) ¶

Package

hax.

Source

unparse.lisp.

Method: end-element ((handler pt-builder) name) ¶

Package

hax.

Source

html-parser.lisp.

Method: end-element ((handler lhtml-builder) name) ¶

Package

hax.

Source

lhtml.lisp.

Method: end-element ((sink sink) name) ¶

Package

hax.

Source

unparse.lisp.

Method: initialize-instance :after ((instance sink) &key) ¶

Source

unparse.lisp.

Method: make-load-form ((self comment-token) &optional env) ¶

Source

sgml-dtd.lisp.

Method: make-load-form ((self element) &optional env) ¶

Source

sgml-dtd.lisp.

Method: make-load-form ((self start-tag) &optional env) ¶

Source

sgml-dtd.lisp.

Method: make-load-form ((self tag) &optional env) ¶

Source

sgml-dtd.lisp.

Method: make-load-form ((self end-tag) &optional env) ¶

Source

sgml-dtd.lisp.

Method: make-load-form ((self dtd) &optional env) ¶

Source

sgml-dtd.lisp.

Method: perform :around ((o compile-op) (s closure-source-file)) ¶

Package

asdf/action.

Source

closure-html.asd.

Method: print-object ((object pt) stream) ¶

Source

pt.lisp.

Method: print-object ((object start-tag) stream) ¶

Source

sgml-dtd.lisp.

Method: print-object ((object end-tag) stream) ¶

Source

sgml-dtd.lisp.

Method: print-object ((object dtd) stream) ¶

Source

sgml-dtd.lisp.

Method: start-document ((handler pt-builder) name pubid sysid) ¶

Package

hax.

Source

html-parser.lisp.

Method: start-document ((handler lhtml-builder) name pubid sysid) ¶

Package

hax.

Source

lhtml.lisp.

Method: start-document ((sink sink) name public-id system-id) ¶

Package

hax.

Source

unparse.lisp.

Method: start-element ((handler pt-builder) name attrs) ¶

Package

hax.

Source

html-parser.lisp.

Method: start-element ((handler lhtml-builder) name attrs) ¶

Package

hax.

Source

lhtml.lisp.

Method: start-element ((sink sink) name attributes) ¶

Package

hax.

Source

unparse.lisp.

Method: unescaped ((sink sink) data) ¶

Package

hax.

Source

unparse.lisp.

---

6.1.7 Structures

Structure: pt ¶

@short{Represents an HTML element.}

PT represents each HTML element as a structure instance, named by a keyword symbol. The children of a PT node are strings (rods) for text nodes, or other PT nodes for elements.

@see{make-pt-builder}
@see{serialize-pt}
@see-slot{pt-name}
@see-slot{pt-children}
@see-slot{pt-parent}
@see-slot{pt-attrs}

Package

sgml.

Source

pt.lisp.

Direct superclasses

structure-object.

Direct subclasses

htag-node.

Direct methods

print-object.

Direct slots

Slot: name ¶

Readers

pt-name.

Writers

(setf pt-name).

Slot: attrs ¶

Readers

pt-attrs.

Writers

(setf pt-attrs).

Slot: children ¶

Readers

pt-children.

Writers

(setf pt-children).

Slot: parent ¶

Readers

pt-parent.

Writers

(setf pt-parent).

Slot: cache ¶

Readers

pt-cache.

Writers

(setf pt-cache).

Slot: plist ¶

Readers

pt-plist.

Writers

(setf pt-plist).

---