The plump Reference Manual

Table of Contents

The plump Reference Manual

This is the plump Reference Manual, version 2.0.0, generated automatically by Declt version 3.0 "Montgomery Scott" on Mon Apr 19 17:24:41 2021 GMT+0.

1 Introduction

What is Plump?

Plump is a parser for HTML/XML like documents, focusing on being lenient towards invalid markup. It can handle things like invalid attributes, bad closing tag order, unencoded entities, inexistent tag types, self-closing tags and so on. It parses documents to a class representation and offers a small set of DOM functions to manipulate it. You are free to change it to parse to your own classes though.

How To

Load Plump through Quicklisp or ASDF:

(ql:quickload :plump)

Using the PARSE function, plump will transform a string, pathname or stream into a document:

(plump:parse "<foo><bar this is=\"a thing\">baz</bar><span id=\"test\">oh my")

This returns a root node. If you want to append a document to a root node (or any other node that accepts children) that you've made, you can pass it into the parse function. To return the document into a readable form, you can call SERIALIZE:

(plump:serialize *)

Using the DOM you can easily traverse the document and change it:

(plump:remove-child (plump:get-element-by-id ** "test"))
(plump:serialize ***)

By default plump includes a few special tag dispatchers to catch HTML oddities like self-closing tags and fulltext-nodes. Especially the self-closing tags can lead to problems in XML documents. In order to parse without any HTML "tricks", you can simply do:

(let ((plump:*tag-dispatchers* plump:*xml-tags*)) (plump:parse "<link>foo</link>"))

This will also influence the serialization. By default self-closing tags will be printed in "HTML-fashion," but if you require full XML support, the above should be the way to go. This behaviour is new in Plump2, as previously everything was always serialized in XML mode.

Extending Plump

If you want to handle a certain tag in a special way, you can write your own tag-dispatcher. For example comments, the doctype and self-closing tags are handled in this fashion. In order to properly hook in, you will have to learn to use Plump's lexer (see next section).

(plump:define-tag-dispatcher (my-dispatcher *tag-dispatchers*) (name)
  (string-equal name "my-tag"))

(plump:define-tag-parser my-dispatcher (name)
  (let ((attrs (plump:read-attributes)))
    (when (char= (plump:consume) #\/)
      (plump:consume)) ;; Consume closing
    (make-instance 'my-tag :parent plump:*root* :attributes attrs)))

If you don't want to disturb the standard Plump tag dispatchers list, you can define your own special variable to contain the dispatchers and bind *tag-dispatchers* to that during parsing, as shown for the XML example above. Shorthand macros exist to define self-closing or full-text tags:

(plump:define-self-closing-element img *tag-dispatchers* *html-tags*)
(plump:define-fulltext-element style *tag-dispatchers* *html-tags*)

You can also define a wild card dispatcher for your own special variable that will dispatch on any tag that doesn't match another dispatcher:

(plump:define-wildcard-dispatcher your-default *your-special-variable*)

XML allows for script tags (like <?php ?>). By default Plump does not specify any special reading for any script tag. If an unhandled script tag is encountered, a warning is emitted and Plump will try to just read anything until ?> is encountered. For most script tags this probably will not suffice, as they might contain some form of escaped ?>. If you do want to use Plump to process script tags properly as well, you will have to define your own reader with define-processing-parser. You can also use that macro to define a reader that outputs a more suitable format than a text tag.

During parsing, all elements are created through MAKE-* functions like MAKE-ROOT, MAKE-ELEMENT, MAKE-TEXT-NODE, and so on. By overriding these functions you can instead delegate the parsing to your own DOM.

If you subclass the DOM classes, you might want to define a method on SERIALIZE-OBJECT to produce the right output.

Plump's Lexer

Since parser generators are good for strict grammars and Plump needed to be fast and lenient, it comes with its own primitive reading/lexing mechanisms. All the lexer primitives are defined in lexer.lisp and you can leverage them for your own projects as well, if you so desire.

In order to allow the lexing to work, you'll have to wrap your processing code in with-lexer-environment. You can then use functions like consume, advance, unread, peek and consume-until to process the input.

make-matcher allows you to use a very simple language to define matching operations. This will evaluate to a function with no arguments that should return T if it matches and NIL otherwise. Combining matchers with consume-until allows you to easily make sequence readers:

(plump:with-lexer-environment ("<foo>")
  (when (char= #\< (plump:consume))
    (plump:consume-until (plump:make-matcher (is #\>)))))

Available matcher constructs are not, and, or, is, in, next, prev, any, and find. define-matcher allows you to associate keywords to matchers, which you can then use as a matcher rule in make-matcher. Regular symbols act as variables:

(let ((find "baz"))
  (plump:with-lexer-environment ("foo bar baz")
     (plump:consume-until (plump:make-matcher (is find)))))

Speed

If you know of other native-lisp libraries that beat Plump, please do let me know, I would be very interested!

See Also

• lQuery Dissect and manipulate the DOM with jQuery-like commands.
• CLSS Traverse the DOM by CSS selectors.
• plump-tex Serialize between TeX and the Plump DOM.
• plump-sexp Serialize between SEXPrs and the Plump DOM.

2 Systems

The main system appears first, followed by any subsystem dependency.

2.1 plump

Maintainer

Nicolas Hafner <shinmera@tymoon.eu>

Author

Nicolas Hafner <shinmera@tymoon.eu>

Home Page

https://Shinmera.github.io/plump/

Source Control

(:git "https://github.com/shinmera/plump.git")

Bug Tracker

https://github.com/Shinmera/plump/issues

License

zlib

Description

An XML / XHTML / HTML parser that aims to be as lenient as possible.

Version

2.0.0

Dependencies

• array-utils
• documentation-utils

Source

plump.asd (file)

Components

• package.lisp (file)
• entities.lisp (file)
• lexer.lisp (file)
• tag-dispatcher.lisp (file)
• dom.lisp (file)
• parser.lisp (file)
• processing.lisp (file)
• special-tags.lisp (file)
• documentation.lisp (file)

3 Files

Files are sorted by type and then listed depth-first from the systems components trees.

3.1 Lisp

3.1.1 plump.asd

Location

plump.asd

Systems

plump (system)

3.1.2 plump/package.lisp

Parent

plump (system)

Location

package.lisp

Packages

• plump
• plump-lexer
• plump-dom
• plump-parser

3.1.3 plump/entities.lisp

Dependency

package.lisp (file)

Parent

plump (system)

Location

entities.lisp

Exported Definitions

• *entity-map* (special variable)
• allowed-char-p (function)
• decode-entities (function)
• discouraged-char-p (function)
• discouraged-xml-character (condition)
• encode-entities (function)
• faulty-char (method)
• (setf faulty-char) (method)
• faulty-char (method)
• (setf faulty-char) (method)
• invalid-xml-character (condition)
• translate-entity (function)
• write-encode-char (function)

Internal Definitions

*alpha-chars* (special variable)

3.1.4 plump/lexer.lisp

Dependency

entities.lisp (file)

Parent

plump (system)

Location

lexer.lisp

Exported Definitions

• *index* (special variable)
• *length* (special variable)
• *string* (special variable)
• advance (function)
• advance-n (function)
• consume (function)
• consume-until (function)
• define-matcher (macro)
• make-matcher (macro)
• matcher-and (function)
• matcher-any (macro)
• matcher-character (function)
• matcher-find (function)
• matcher-next (function)
• matcher-not (function)
• matcher-or (function)
• matcher-prev (function)
• matcher-range (function)
• matcher-string (function)
• peek (function)
• unread (function)
• unread-n (function)
• with-lexer-environment (macro)

Internal Definitions

*matchers* (special variable)

3.1.5 plump/tag-dispatcher.lisp

Dependency

lexer.lisp (file)

Parent

plump (system)

Location

tag-dispatcher.lisp

Exported Definitions

• *all-tag-dispatchers* (special variable)
• *html-tags* (special variable)
• *tag-dispatchers* (special variable)
• *xml-tags* (special variable)
• define-tag-dispatcher (macro)
• define-tag-parser (macro)
• define-tag-printer (macro)
• define-wildcard-dispatcher (macro)
• do-tag-parsers (macro)
• do-tag-printers (macro)
• remove-tag-dispatcher (function)
• tag-dispatcher (function)
• (setf tag-dispatcher) (setf expander)
• tag-dispatcher (structure)

Internal Definitions

• copy-tag-dispatcher (function)
• make-tag-dispatcher (function)
• tag-dispatcher-name (function)
• (setf tag-dispatcher-name) (function)
• tag-dispatcher-p (function)
• tag-dispatcher-parser (function)
• (setf tag-dispatcher-parser) (function)
• tag-dispatcher-printer (function)
• (setf tag-dispatcher-printer) (function)
• tag-dispatcher-test (function)
• (setf tag-dispatcher-test) (function)

3.1.6 plump/dom.lisp

Dependency

tag-dispatcher.lisp (file)

Parent

plump (system)

Location

dom.lisp

Exported Definitions

• *stream* (special variable)
• append-child (function)
• attribute (function)
• (setf attribute) (function)
• attributes (method)
• (setf attributes) (method)
• attributes (method)
• (setf attributes) (method)
• cdata (class)
• cdata-p (function)
• child-elements (function)
• child-node (class)
• child-node-p (function)
• child-position (function)
• children (method)
• (setf children) (method)
• clear (function)
• clone-attributes (function)
• clone-children (function)
• clone-node (generic function)
• clone-node (method)
• clone-node (method)
• clone-node (method)
• clone-node (method)
• clone-node (method)
• clone-node (method)
• clone-node (method)
• clone-node (method)
• clone-node (method)
• clone-node (method)
• clone-node (method)
• clone-node (method)
• clone-node (method)
• comment (class)
• comment-p (function)
• doctype (method)
• (setf doctype) (method)
• doctype (class)
• doctype-p (function)
• element (class)
• element-p (function)
• element-position (function)
• ensure-attribute-map (function)
• ensure-child-array (function)
• family (function)
• family-elements (function)
• first-child (function)
• first-element (function)
• fulltext-element (class)
• fulltext-element-p (function)
• get-attribute (function)
• get-element-by-id (function)
• get-elements-by-tag-name (function)
• has-attribute (function)
• has-child-nodes (function)
• insert-after (function)
• insert-before (function)
• last-child (function)
• last-element (function)
• make-attribute-map (function)
• make-cdata (function)
• make-child-array (function)
• make-comment (function)
• make-doctype (function)
• make-element (function)
• make-fulltext-element (function)
• make-processing-instruction (function)
• make-root (function)
• make-text-node (function)
• make-xml-header (function)
• nesting-node (class)
• nesting-node-p (function)
• next-element (function)
• next-sibling (function)
• node (class)
• node-p (function)
• parent (method)
• (setf parent) (method)
• prepend-child (function)
• previous-element (function)
• previous-sibling (function)
• processing-instruction (class)
• processing-instruction-p (function)
• remove-attribute (function)
• remove-child (function)
• render-text (function)
• replace-child (function)
• root (class)
• root-p (function)
• serialize (function)
• serialize-object (generic function)
• serialize-object (method)
• serialize-object (method)
• serialize-object (method)
• serialize-object (method)
• serialize-object (method)
• serialize-object (method)
• serialize-object (method)
• serialize-object (method)
• serialize-object (method)
• serialize-object (method)
• serialize-object (method)
• set-attribute (function)
• sibling-elements (function)
• siblings (function)
• splice (function)
• strip (function)
• tag-name (method)
• (setf tag-name) (method)
• tag-name (method)
• (setf tag-name) (method)
• text (method)
• text (method)
• (setf text) (method)
• text-node (class)
• text-node-p (function)
• textual-node (class)
• textual-node-p (function)
• traverse (generic function)
• traverse (method)
• traverse (method)
• trim (function)
• xml-header (class)
• xml-header-p (function)

Internal Definitions

• define-predicates (macro)
• make-appending (macro)
• vec-remove-if (function)
• wrs (macro)

3.1.7 plump/parser.lisp

Dependency

dom.lisp (file)

Parent

plump (system)

Location

parser.lisp

Exported Definitions

• *root* (special variable)
• parse (generic function)
• parse (method)
• parse (method)
• parse (method)
• read-attribute (function)
• read-attribute-name (function)
• read-attribute-value (function)
• read-attributes (function)
• read-children (function)
• read-name (function)
• read-root (function)
• read-standard-tag (function)
• read-tag (function)
• read-tag-contents (function)
• read-text (function)
• slurp-stream (function)

Internal Definitions

• *tagstack* (special variable)
• *whitespace* (special variable)
• skip-whitespace (function)

3.1.8 plump/processing.lisp

Dependency

parser.lisp (file)

Parent

plump (system)

Location

processing.lisp

Exported Definitions

• define-processing-parser (macro)
• processing-parser (function)
• (setf processing-parser) (function)
• remove-processing-parser (function)

Internal Definitions

*processing-parsers* (special variable)

3.1.9 plump/special-tags.lisp

Dependency

processing.lisp (file)

Parent

plump (system)

Location

special-tags.lisp

Exported Definitions

• define-fulltext-element (macro)
• define-self-closing-element (macro)

Internal Definitions

• ends-with (function)
• read-fulltext-element-content (function)
• starts-with (function)

3.1.10 plump/documentation.lisp

Dependency

special-tags.lisp (file)

Parent

plump (system)

Location

documentation.lisp

4 Packages

Packages are listed by definition order.

4.1 plump

Source

package.lisp (file)

Nickname

org.shirakumo.plump

Use List

• plump-parser
• plump-lexer
• plump-dom
• common-lisp

4.2 plump-lexer

Source

package.lisp (file)

Nickname

org.shirakumo.plump.lexer

Use List

common-lisp

Used By List

• plump
• plump-parser

Exported Definitions

• *index* (special variable)
• *length* (special variable)
• *string* (special variable)
• advance (function)
• advance-n (function)
• consume (function)
• consume-until (function)
• define-matcher (macro)
• make-matcher (macro)
• matcher-and (function)
• matcher-any (macro)
• matcher-character (function)
• matcher-find (function)
• matcher-next (function)
• matcher-not (function)
• matcher-or (function)
• matcher-prev (function)
• matcher-range (function)
• matcher-string (function)
• peek (function)
• unread (function)
• unread-n (function)
• with-lexer-environment (macro)

Internal Definitions

*matchers* (special variable)

4.3 plump-dom

Source

package.lisp (file)

Nickname

org.shirakumo.plump.dom

Use List

• array-utils
• common-lisp

Used By List

• plump
• plump-parser

Exported Definitions

• *entity-map* (special variable)
• *stream* (special variable)
• allowed-char-p (function)
• append-child (function)
• attribute (function)
• (setf attribute) (function)
• attributes (generic function)
• attributes (method)
• (setf attributes) (method)
• attributes (method)
• (setf attributes) (method)
• (setf attributes) (generic function)
• cdata (class)
• cdata-p (function)
• child-elements (function)
• child-node (class)
• child-node-p (function)
• child-position (function)
• children (generic function)
• children (method)
• (setf children) (method)
• (setf children) (generic function)
• clear (function)
• clone-attributes (function)
• clone-children (function)
• clone-node (generic function)
• clone-node (method)
• clone-node (method)
• clone-node (method)
• clone-node (method)
• clone-node (method)
• clone-node (method)
• clone-node (method)
• clone-node (method)
• clone-node (method)
• clone-node (method)
• clone-node (method)
• clone-node (method)
• clone-node (method)
• comment (class)
• comment-p (function)
• decode-entities (function)
• discouraged-char-p (function)
• discouraged-xml-character (condition)
• doctype (generic function)
• doctype (method)
• (setf doctype) (method)
• (setf doctype) (generic function)
• doctype (class)
• doctype-p (function)
• element (class)
• element-p (function)
• element-position (function)
• encode-entities (function)
• ensure-attribute-map (function)
• ensure-child-array (function)
• family (function)
• family-elements (function)
• faulty-char (generic function)
• faulty-char (method)
• (setf faulty-char) (method)
• faulty-char (method)
• (setf faulty-char) (method)
• (setf faulty-char) (generic function)
• first-child (function)
• first-element (function)
• fulltext-element (class)
• fulltext-element-p (function)
• get-attribute (function)
• get-element-by-id (function)
• get-elements-by-tag-name (function)
• has-attribute (function)
• has-child-nodes (function)
• insert-after (function)
• insert-before (function)
• invalid-xml-character (condition)
• last-child (function)
• last-element (function)
• make-attribute-map (function)
• make-cdata (function)
• make-child-array (function)
• make-comment (function)
• make-doctype (function)
• make-element (function)
• make-fulltext-element (function)
• make-processing-instruction (function)
• make-root (function)
• make-text-node (function)
• make-xml-header (function)
• nesting-node (class)
• nesting-node-p (function)
• next-element (function)
• next-sibling (function)
• node (class)
• node-p (function)
• parent (generic function)
• parent (method)
• (setf parent) (method)
• (setf parent) (generic function)
• prepend-child (function)
• previous-element (function)
• previous-sibling (function)
• processing-instruction (class)
• processing-instruction-p (function)
• remove-attribute (function)
• remove-child (function)
• render-text (function)
• replace-child (function)
• root (class)
• root-p (function)
• serialize (function)
• serialize-object (generic function)
• serialize-object (method)
• serialize-object (method)
• serialize-object (method)
• serialize-object (method)
• serialize-object (method)
• serialize-object (method)
• serialize-object (method)
• serialize-object (method)
• serialize-object (method)
• serialize-object (method)
• serialize-object (method)
• set-attribute (function)
• sibling-elements (function)
• siblings (function)
• splice (function)
• strip (function)
• tag-name (generic function)
• tag-name (method)
• (setf tag-name) (method)
• tag-name (method)
• (setf tag-name) (method)
• (setf tag-name) (generic function)
• text (generic function)
• text (method)
• text (method)
• (setf text) (method)
• (setf text) (generic function)
• text-node (class)
• text-node-p (function)
• textual-node (class)
• textual-node-p (function)
• translate-entity (function)
• traverse (generic function)
• traverse (method)
• traverse (method)
• trim (function)
• write-encode-char (function)
• xml-header (class)
• xml-header-p (function)

Internal Definitions

• *alpha-chars* (special variable)
• define-predicates (macro)
• make-appending (macro)
• vec-remove-if (function)
• wrs (macro)

4.4 plump-parser

Source

package.lisp (file)

Nickname

org.shirakumo.plump.parser

Use List

• plump-dom
• plump-lexer
• common-lisp

Used By List

plump

Exported Definitions

• *all-tag-dispatchers* (special variable)
• *html-tags* (special variable)
• *root* (special variable)
• *tag-dispatchers* (special variable)
• *xml-tags* (special variable)
• define-fulltext-element (macro)
• define-processing-parser (macro)
• define-self-closing-element (macro)
• define-tag-dispatcher (macro)
• define-tag-parser (macro)
• define-tag-printer (macro)
• define-wildcard-dispatcher (macro)
• do-tag-parsers (macro)
• do-tag-printers (macro)
• parse (generic function)
• parse (method)
• parse (method)
• parse (method)
• processing-parser (function)
• (setf processing-parser) (function)
• read-attribute (function)
• read-attribute-name (function)
• read-attribute-value (function)
• read-attributes (function)
• read-children (function)
• read-name (function)
• read-root (function)
• read-standard-tag (function)
• read-tag (function)
• read-tag-contents (function)
• read-text (function)
• remove-processing-parser (function)
• remove-tag-dispatcher (function)
• slurp-stream (function)
• tag-dispatcher (function)
• (setf tag-dispatcher) (setf expander)
• tag-dispatcher (structure)

Internal Definitions

• *processing-parsers* (special variable)
• *tagstack* (special variable)
• *whitespace* (special variable)
• copy-tag-dispatcher (function)
• ends-with (function)
• make-tag-dispatcher (function)
• read-fulltext-element-content (function)
• skip-whitespace (function)
• starts-with (function)
• tag-dispatcher-name (function)
• (setf tag-dispatcher-name) (function)
• tag-dispatcher-p (function)
• tag-dispatcher-parser (function)
• (setf tag-dispatcher-parser) (function)
• tag-dispatcher-printer (function)
• (setf tag-dispatcher-printer) (function)
• tag-dispatcher-test (function)
• (setf tag-dispatcher-test) (function)

5 Definitions

Definitions are sorted by export status, category, package, and then by lexicographic order.

5.1 Exported definitions

5.1.1 Special variables

Special Variable: *all-tag-dispatchers*

All defined tag dispatchers

Package

plump-parser

Source

tag-dispatcher.lisp (file)

Special Variable: *entity-map*

String hash-table containing the entity names and mapping them to their respective characters.

Package

plump-dom

Source

entities.lisp (file)

Special Variable: *html-tags*

List of HTML tag dispatchers

Package

plump-parser

Source

tag-dispatcher.lisp (file)

Special Variable: *index*

Set to the current reading index.

Package

plump-lexer

Source

lexer.lisp (file)

Special Variable: *length*

Set to the length of the string for bounds checking.

Package

plump-lexer

Source

lexer.lisp (file)

Special Variable: *root*

Object containing the current node to set as parent.

Package

plump-parser

Source

parser.lisp (file)

Special Variable: *stream*

The stream to serialize to during SERIALIZE-OBJECT.

Package

plump-dom

Source

dom.lisp (file)

Special Variable: *string*

Contains the current string to lex.

Package

plump-lexer

Source

lexer.lisp (file)

Special Variable: *tag-dispatchers*

Active tag dispatcher functions

Package

plump-parser

Source

tag-dispatcher.lisp (file)

Special Variable: *xml-tags*

List of XML tag dispatchers

Package

plump-parser

Source

tag-dispatcher.lisp (file)

5.1.2 Macros

Macro: define-fulltext-element TAG &rest LISTS

Defines an element to be read as a full-text element.
This means that it cannot contain any child-nodes and everything up until its closing tag is used as its text.

Package

plump-parser

Source

special-tags.lisp (file)

Macro: define-matcher NAME FORM

Associates NAME as a keyword to the matcher form. You can then use the keyword in further matcher rules.

Package

plump-lexer

Source

lexer.lisp (file)

Macro: define-processing-parser PROCESS-NAME () &body BODY

Defines a new processing-instruction parser.
It is invoked if a processing-instruction (<?) with PROCESS-NAME is encountered. The lexer will be at the point straight after reading in the PROCESS-NAME. Expected return value is a string to use as the processing-instructions’ TEXT. The closing tag (?>) should NOT be consumed by a processing-parser.

Package

plump-parser

Source

processing.lisp (file)

Macro: define-self-closing-element TAG &rest LISTS

Defines an element that does not need to be closed with /> and cannot contain child nodes.

Package

plump-parser

Source

special-tags.lisp (file)

Macro: define-tag-dispatcher (NAME &rest LISTS) (TAGVAR) &body BODY

Defines a new tag dispatcher. It is invoked if TEST-FORM passes.

NAME — Name to discern the dispatcher with.
LISTS — Symbols of lists to which the dispatcher should be added. TAGVAR — Symbol bound to the tag name.
BODY — Body forms describing the test to match the tag.

Package

plump-parser

Source

tag-dispatcher.lisp (file)

Macro: define-tag-parser NAME (TAGVAR) &body BODY

Defines the parser function for a tag dispatcher.

NAME — The name of the tag dispatcher. If one with this name cannot be found, an error is signalled.
TAGVAR — Symbol bound to the tag name.
BODY — Body forms describing the tag parsing behaviour.

Package

plump-parser

Source

tag-dispatcher.lisp (file)

Macro: define-tag-printer NAME (NODEVAR) &body BODY

Defines the printer function for a tag dispatcher.

NAME — The name of the tag dispatcher. If one with this name cannot be found, an error is signalled.
TAGVAR — Symbol bound to the tag name.
BODY — Body forms describing the printing behaviour. Write to the stream bound to PLUMP-DOM:*STREAM*.

Package

plump-parser

Source

tag-dispatcher.lisp (file)

Macro: define-wildcard-dispatcher NAME &rest LISTS

Package

plump-parser

Source

tag-dispatcher.lisp (file)

Macro: do-tag-parsers (TEST PARSER &optional RESULT-FORM) &body BODY

Iterates over the current *TAG-DISPATCHERS*, binding the TEST and PARSER functions. Returns RESULT-FORM’s evaluated value.

Package

plump-parser

Source

tag-dispatcher.lisp (file)

Macro: do-tag-printers (TEST PRINTER &optional RESULT-FORM) &body BODY

Iterates over the current *TAG-DISPATCHERS*, binding the TEST and PRINTER functions. Returns RESULT-FORM’s evaluated value.

Package

plump-parser

Source

tag-dispatcher.lisp (file)

Macro: make-matcher FORM

Macro to create a matcher chain.

Package

plump-lexer

Source

lexer.lisp (file)

Macro: matcher-any &rest IS

Shorthand for (or (is a) (is b)..)

Package

plump-lexer

Source

lexer.lisp (file)

Macro: with-lexer-environment (STRING) &body BODY

Sets up the required lexing environment for the given string.

Package

plump-lexer

Source

lexer.lisp (file)

5.1.3 Functions

Function: advance ()

Skips a chracter if possible. Returns the new index or NIL.

Package

plump-lexer

Source

lexer.lisp (file)

Function: advance-n N

Advances by N characters if possible. Returns the new *INDEX*.

Package

plump-lexer

Source

lexer.lisp (file)

Function: allowed-char-p CHAR

Returns T if the character is a permitted XML character.

Package

plump-dom

Source

entities.lisp (file)

Function: append-child PARENT CHILD

Appends the given child onto the parent’s child list. Returns the child.

Package

plump-dom

Source

dom.lisp (file)

Function: attribute ELEMENT ATTRIBUTE

Returns the asked attribute from the element or NIL. If the attribute could not be found, the second return value is set to NIL.

Package

plump-dom

Source

dom.lisp (file)

Writer

(setf attribute) (function)

Function: (setf attribute) VALUE ELEMENT ATTRIBUTE

Set an attribute on an element to the given value.

Package

plump-dom

Source

dom.lisp (file)

Reader

attribute (function)

Function: cdata-p OBJECT

Returns T if the given OBJECT is of type CDATA

Package

plump-dom

Source

dom.lisp (file)

Function: child-elements NESTING-NODE

Returns a new vector of children of the given node, filtered to elements.

Package

plump-dom

Source

dom.lisp (file)

Function: child-node-p OBJECT

Returns T if the given OBJECT is of type CHILD-NODE

Package

plump-dom

Source

dom.lisp (file)

Function: child-position CHILD

Returns the index of the child within its parent.

Package

plump-dom

Source

dom.lisp (file)

Function: clear NESTING-NODE

Clears all children from the node.

Noe that the PARENT of all child elements is set to NIL.

Package

plump-dom

Source

dom.lisp (file)

Function: clone-attributes NODE

Clone the attribute map.
Note that keys and values are NOT copied/cloned.

Package

plump-dom

Source

dom.lisp (file)

Function: clone-children NODE &optional DEEP NEW-PARENT

Clone the array of children.
If DEEP is non-NIL, each child is cloned as per (CLONE-NODE NODE T). When copying deeply, you can also pass a NEW-PARENT to set on each child.

Package

plump-dom

Source

dom.lisp (file)

Function: comment-p OBJECT

Returns T if the given OBJECT is of type COMMENT

Package

plump-dom

Source

dom.lisp (file)

Function: consume ()

Consumes a single character if possible and returns it. Otherwise returns NIL.

Package

plump-lexer

Source

lexer.lisp (file)

Function: consume-until MATCHER

Consumes until the provided matcher function returns positively. Returns the substring that was consumed.

Package

plump-lexer

Source

lexer.lisp (file)

Function: decode-entities TEXT &optional REMOVE-INVALID

Translates all entities in the text into their character counterparts if possible. If an entity does not match, it is left in place unless REMOVE-INVALID is non-NIL.

Package

plump-dom

Source

entities.lisp (file)

Function: discouraged-char-p CHAR

Returns T if the character is a discouraged XML character.

Package

plump-dom

Source

entities.lisp (file)

Function: doctype-p OBJECT

Returns T if the given OBJECT is of type DOCTYPE

Package

plump-dom

Source

dom.lisp (file)

Function: element-p OBJECT

Returns T if the given OBJECT is of type ELEMENT

Package

plump-dom

Source

dom.lisp (file)

Function: element-position CHILD

Returns the index of the child within its parent, counting only elements. This excludes comments, text-nodes and the like.

Package

plump-dom

Source

dom.lisp (file)

Function: encode-entities TEXT &optional STREAM

Encodes the characters < > & " with their XML entity equivalents.

If no STREAM is given, it encodes to a new string.

Package

plump-dom

Source

entities.lisp (file)

Function: ensure-attribute-map TABLE

Ensures that the TABLE is suitable as an attribute-map.
If it is not, the table is copied into a proper attribute-map.

Package

plump-dom

Source

dom.lisp (file)

Function: ensure-child-array ARRAY

If the ARRAY is suitable as a child-array, it is returned. Otherwise the array’s elements are copied over into a proper child-array.

Package

plump-dom

Source

dom.lisp (file)

Function: family CHILD

Returns the direct array of children of the parent of the given child. Note that modifying this array directly modifies that of the parent.

Package

plump-dom

Source

dom.lisp (file)

Function: family-elements CHILD

Returns the direct array of children elements of the parent of the given child. Note that this is a copy of the array, modifying it is safe.
This excludes comments, text-nodes and the like.

Package

plump-dom

Source

dom.lisp (file)

Function: first-child ELEMENT

Returns the first child within the parent or NIL if the parent is empty.

Package

plump-dom

Source

dom.lisp (file)

Function: first-element ELEMENT

Returns the first child element within the parent or NIL
if the parent is empty. This excludes comments, text-nodes and the like.

Package

plump-dom

Source

dom.lisp (file)

Function: fulltext-element-p OBJECT

Returns T if the given OBJECT is of type FULLTEXT-ELEMENT

Package

plump-dom

Source

dom.lisp (file)

Function: get-attribute ELEMENT ATTRIBUTE

Synonymous to ATTRIBUTE.

Package

plump-dom

Source

dom.lisp (file)

Function: get-element-by-id NODE ID

Searches the given node and returns the first node at arbitrary depth that matches the given ID attribute.

Package

plump-dom

Source

dom.lisp (file)

Function: get-elements-by-tag-name NODE TAG

Searches the given node and returns an unordered list of child nodes at arbitrary depth that match the given tag.

Package

plump-dom

Source

dom.lisp (file)

Function: has-attribute ELEMENT ATTRIBUTE

Returns T if the provided attribute exists.

Package

plump-dom

Source

dom.lisp (file)

Function: has-child-nodes NODE

Returns T if the node can contain children and the child array is not empty.

Package

plump-dom

Source

dom.lisp (file)

Function: insert-after ELEMENT NEW-CHILD

Inserts the new-child after the given element in the parent’s list. Returns the new child.

Note that this operation is potentially very costly.
See VECTOR-PUSH-EXTEND-POSITION

Package

plump-dom

Source

dom.lisp (file)

Function: insert-before ELEMENT NEW-CHILD

Inserts the new-child before the given element in the parent’s list. Returns the new child.

Note that this operation is potentially very costly.
See VECTOR-PUSH-EXTEND-POSITION

Package

plump-dom

Source

dom.lisp (file)

Function: last-child ELEMENT

Returns the last child within the parent or NIL if the parent is empty.

Package

plump-dom

Source

dom.lisp (file)

Function: last-element ELEMENT

Returns the last child element within the parent or NIL
if the parent is empty. This excludes comments, text-nodes and the like.

Package

plump-dom

Source

dom.lisp (file)

Function: make-attribute-map &optional SIZE

Creates a map to contain attributes.

Package

plump-dom

Source

dom.lisp (file)

Function: make-cdata PARENT &key TEXT

Creates an XML CDATA section under the parent.

Note that the element is automatically appended to the parent’s child list.

Package

plump-dom

Source

dom.lisp (file)

Function: make-child-array &optional SIZE

Creates an array to contain child elements

Package

plump-dom

Source

dom.lisp (file)

Function: make-comment PARENT &optional TEXT

Creates a new comment node under the parent.

Note that the node is automatically appended to the parent’s child list.

Package

plump-dom

Source

dom.lisp (file)

Function: make-doctype PARENT DOCTYPE

Creates a new doctype node under the parent.

Note that the node is automatically appended to the parent’s child list.

Package

plump-dom

Source

dom.lisp (file)

Function: make-element PARENT TAG &key CHILDREN ATTRIBUTES

Creates a standard DOM element with the given tag name and parent. Optionally a vector (with fill-pointer) containing children and an attribute-map (a hash-table with equalp test) can be supplied.

Note that the element is automatically appended to the parent’s child list.

Package

plump-dom

Source

dom.lisp (file)

Function: make-fulltext-element PARENT TAG &key TEXT ATTRIBUTES

Creates a fulltext element under the parent.
Optionally a text and an attribute-map (a hash-table with equalp test) can be supplied.

Note that the element is automatically appended to the parent’s child list.

Package

plump-dom

Source

dom.lisp (file)

Function: make-processing-instruction PARENT &key NAME TEXT

Creates an XML processing instruction under the parent.

Note that the element is automatically appended to the parent’s child list.

Package

plump-dom

Source

dom.lisp (file)

Function: make-root &optional CHILDREN

Creates a root node with the given children. Children should be a vector with fill-pointer.

Package

plump-dom

Source

dom.lisp (file)

Function: make-text-node PARENT &optional TEXT

Creates a new text node under the parent.

Note that the node is automatically appended to the parent’s child list.

Package

plump-dom

Source

dom.lisp (file)

Function: make-xml-header PARENT &key ATTRIBUTES

Creates an XML header object under the parent.

Note that the element is automatically appended to the parent’s child list.

Package

plump-dom

Source

dom.lisp (file)

Function: matcher-and &rest MATCHERS

Creates a matcher function that returns if all of the sub-expressions return successfully. The last match is returned, if all.

Package

plump-lexer

Source

lexer.lisp (file)

Function: matcher-character CHARACTER

Creates a matcher function that attempts to match the given character.

Package

plump-lexer

Source

lexer.lisp (file)

Function: matcher-find LIST

Creates a matcher function that returns T if the character is found in the given list.

Package

plump-lexer

Source

lexer.lisp (file)

Function: matcher-next MATCHER

Creates a matcher environment that peeks ahead one farther.

Package

plump-lexer

Source

lexer.lisp (file)

Function: matcher-not MATCHER

Creates a matcher function that inverts the result of the sub-expression.

Package

plump-lexer

Source

lexer.lisp (file)

Function: matcher-or &rest MATCHERS

Creates a matcher function that returns successfully if any of the sub-expressions return successfully. The first match is returned, if any.

Package

plump-lexer

Source

lexer.lisp (file)

Function: matcher-prev MATCHER

Creates a matcher environment that peeks behind.

Package

plump-lexer

Source

lexer.lisp (file)

Function: matcher-range FROM TO

Creates a matcher that checks a range according to the next character’s CHAR-CODE.

Package

plump-lexer

Source

lexer.lisp (file)

Function: matcher-string STRING

Creates a matcher function that attempts to match the given string.

Package

plump-lexer

Source

lexer.lisp (file)

Function: nesting-node-p OBJECT

Returns T if the given OBJECT is of type NESTING-NODE

Package

plump-dom

Source

dom.lisp (file)

Function: next-element CHILD

Returns the sibling element next to this one or NIL if
it is already last. This excludes comments, text-nodes and the like.

Package

plump-dom

Source

dom.lisp (file)

Function: next-sibling CHILD

Returns the sibling next to this one or NIL if it is already the last.

Package

plump-dom

Source

dom.lisp (file)

Function: node-p OBJECT

Returns T if the given OBJECT is of type NODE

Package

plump-dom

Source

dom.lisp (file)

Function: peek ()

Returns the next character, if any.

Package

plump-lexer

Source

lexer.lisp (file)

Function: prepend-child PARENT CHILD

Prepends the given child onto the parent’s child list. Returns the child.

Note that this operation is costly, see VECTOR-PUSH-EXTEND-FRONT

Package

plump-dom

Source

dom.lisp (file)

Function: previous-element CHILD

Returns the sibling element before this one or NIL if
it is already the first. This excludes comments, text-nodes and the like.

Package

plump-dom

Source

dom.lisp (file)

Function: previous-sibling CHILD

Returns the sibling before this one or NIL if it is already the first.

Package

plump-dom

Source

dom.lisp (file)

Function: processing-instruction-p OBJECT

Returns T if the given OBJECT is of type PROCESSING-INSTRUCTION

Package

plump-dom

Source

dom.lisp (file)

Function: processing-parser PROCESS-NAME

Return the processing-parser function for PROCESS-NAME. SETF-able.

Package

plump-parser

Source

processing.lisp (file)

Writer

(setf processing-parser) (function)

Function: (setf processing-parser) FUNC PROCESS-NAME

Set the processing-parser function for PROCESS-NAME.

Package

plump-parser

Source

processing.lisp (file)

Reader

processing-parser (function)

Function: read-attribute ()

Reads an attribute and returns it as a key value cons.

Package

plump-parser

Source

parser.lisp (file)

Function: read-attribute-name ()

Reads an attribute name.

Package

plump-parser

Source

parser.lisp (file)

Function: read-attribute-value ()

Reads an attribute value, either enclosed in quotation marks or until a space or tag end.

Package

plump-parser

Source

parser.lisp (file)

Function: read-attributes ()

Reads as many attributes as possible from a tag and returns them as an attribute map.

Package

plump-parser

Source

parser.lisp (file)

Function: read-children ()

Read all children of the current *root* until the closing tag for *root* is encountered.

Package

plump-parser

Source

parser.lisp (file)

Function: read-name ()

Reads and returns a tag name.

Package

plump-parser

Source

parser.lisp (file)

Function: read-root &optional ROOT

Creates a root element and reads nodes into it. Optionally uses the specified root to append child nodes to. Returns the root.

Package

plump-parser

Source

parser.lisp (file)

Function: read-standard-tag NAME

Reads an arbitrary tag and returns it. This recurses with READ-CHILDREN.

Package

plump-parser

Source

parser.lisp (file)

Function: read-tag ()

Attempts to read a tag and dispatches or defaults to READ-STANDARD-TAG. Returns the completed node if one can be read.

Package

plump-parser

Source

parser.lisp (file)

Function: read-tag-contents ()

Reads and returns all tag contents. E.g. <foo bar baz> => bar baz

Package

plump-parser

Source

parser.lisp (file)

Function: read-text ()

Reads and returns a text-node.

Package

plump-parser

Source

parser.lisp (file)

Function: remove-attribute ELEMENT ATTRIBUTE

Remove the specified attribute if it exists. Returns NIL.

Package

plump-dom

Source

dom.lisp (file)

Function: remove-child CHILD

Removes the child from its parent.
Returns the child.

Note that this operation is potentially very costly. See VECTOR-POP-POSITION

Package

plump-dom

Source

dom.lisp (file)

Function: remove-processing-parser PROCESS-NAME

Remove the processing-parser for PROCESS-NAME.

Package

plump-parser

Source

processing.lisp (file)

Function: remove-tag-dispatcher NAME &optional LIST

Removes the tag-dispatcher of the given name from the list.

Package

plump-parser

Source

tag-dispatcher.lisp (file)

Function: render-text NODE

"Renders" the text of this element and its children.

In effect the text is gathered from the component and all of
its children, but transforming the text in such a way that:
- All ASCII white space (Space, Tab, CR, LF) is converted into spaces. - There are no consecutive spaces.
- There are no spaces at the beginning or end.

This is somewhat analogous to how the text will be shown to
the user when rendered by a browser. Hence, render-text.

Package

plump-dom

Source

dom.lisp (file)

Function: replace-child OLD-CHILD NEW-CHILD

Replace the old child with a new one. Returns the old child.

Package

plump-dom

Source

dom.lisp (file)

Function: root-p OBJECT

Returns T if the given OBJECT is of type ROOT

Package

plump-dom

Source

dom.lisp (file)

Function: serialize NODE &optional STREAM

Serializes NODE to STREAM.
STREAM can be a stream, T for *standard-output* or NIL to serialize to string.

Package

plump-dom

Source

dom.lisp (file)

Function: set-attribute ELEMENT ATTRIBUTE VALUE

Synonymous to (SETF (ATTIBUTE ..) ..)

Package

plump-dom

Source

dom.lisp (file)

Function: sibling-elements CHILD

Returns the array of sibling elements of the given child. Note that this is a copy of the array, modifying it is safe. This excludes comments, text-nodes and the like.

Package

plump-dom

Source

dom.lisp (file)

Function: siblings CHILD

Returns the array of siblings of the given child.
Note that this is a copy of the array, modifying it is safe.

Package

plump-dom

Source

dom.lisp (file)

Function: slurp-stream STREAM

Quickly slurps the stream’s contents into an array with fill pointer.

Package

plump-parser

Source

parser.lisp (file)

Function: splice ELEMENT

Splices the contents of element into the position of the element in its parent. Returns the parent.

Note that this operation is potentially very costly.
See ARRAY-SHIFT

Package

plump-dom

Source

dom.lisp (file)

Function: strip NODE

Trim all text-nodes within NODE (at any depth) of leading and trailing whitespace. If their TEXT should be an empty string after trimming, remove them.

Package

plump-dom

Source

dom.lisp (file)

Function: tag-dispatcher NAME &optional LIST

Accessor to the tag-dispatcher of the given name.

Package

plump-parser

Source

tag-dispatcher.lisp (file)

Setf Expander

(setf tag-dispatcher) (setf expander)

Setf Expander: (setf tag-dispatcher) NAME &optional LIST

Package

plump-parser

Source

tag-dispatcher.lisp (file)

Reader

tag-dispatcher (function)

Function: text-node-p OBJECT

Returns T if the given OBJECT is of type TEXT-NODE

Package

plump-dom

Source

dom.lisp (file)

Function: textual-node-p OBJECT

Returns T if the given OBJECT is of type TEXTUAL-NODE

Package

plump-dom

Source

dom.lisp (file)

Function: translate-entity TEXT &key START END

Translates the given entity identifier (a name, #Dec or #xHex) into their respective strings if possible. Otherwise returns NIL.

Package

plump-dom

Source

entities.lisp (file)

Function: trim NODE

Trim all text-nodes within NODE (at any depth) of leading and trailing whitespace.

Package

plump-dom

Source

dom.lisp (file)

Function: unread ()

Steps back a single character if possible. Returns the new *INDEX*.

Package

plump-lexer

Source

lexer.lisp (file)

Function: unread-n N

Steps back by N characters if possible. Returns the new *INDEX*.

Package

plump-lexer

Source

lexer.lisp (file)

Function: write-encode-char CHAR STREAM

Write and possibly encode the CHAR to STREAM.
This also properly handles detection of invalid or discouraged XML characters.

The following restarts are available in the case of a faulty character: ABORT Do not output the faulty character at all. USE-NEW-CHARACTER Output a replacement character instead.
CONTINUE Continue and output the faulty character anyway.

See INVALID-XML-CHARACTER
See DISCOURAGED-XML-CHARACTER

Package

plump-dom

Source

entities.lisp (file)

Function: xml-header-p OBJECT

Returns T if the given OBJECT is of type XML-HEADER

Package

plump-dom

Source

dom.lisp (file)

5.1.4 Generic functions

Generic Function: attributes OBJECT

Returns an EQUALP hash-table of the element’s attributes.

Package

plump-dom

Writer

(setf attributes) (generic function)

Methods

Method: attributes (XML-HEADER xml-header)

automatically generated reader method

Source

dom.lisp (file)

Method: attributes (ELEMENT element)

automatically generated reader method

Source

dom.lisp (file)

Generic Function: (setf attributes) NEW-VALUE OBJECT

Package

plump-dom

Reader

attributes (generic function)

Methods

Method: (setf attributes) NEW-VALUE (XML-HEADER xml-header)

automatically generated writer method

Source

dom.lisp (file)

Method: (setf attributes) NEW-VALUE (ELEMENT element)

automatically generated writer method

Source

dom.lisp (file)

Generic Function: children OBJECT

Returns a vector of child-nodes that are contained within the node.

Package

plump-dom

Writer

(setf children) (generic function)

Methods

Method: children (NESTING-NODE nesting-node)

automatically generated reader method

Source

dom.lisp (file)

Generic Function: (setf children) NEW-VALUE OBJECT

Package

plump-dom

Reader

children (generic function)

Methods

Method: (setf children) NEW-VALUE (NESTING-NODE nesting-node)

automatically generated writer method

Source

dom.lisp (file)

Generic Function: clone-node NODE &optional DEEP

Clone the given node, creating a new instance with the same contents. If DEEP is non-NIL, the following applies:
The text of COMMENT and TEXT-NODEs is copied as per COPY-SEQ.
The children of NESTING-NODEs are copied as per (CLONE-CHILDREN CHILD T)

Package

plump-dom

Source

dom.lisp (file)

Methods

Method: clone-node (VECTOR vector) &optional DEEP

Method: clone-node (TABLE hash-table) &optional DEEP

Method: clone-node (NODE node) &optional DEEP

Method: clone-node (NODE nesting-node) &optional DEEP

Method: clone-node (NODE child-node) &optional DEEP

Method: clone-node (NODE textual-node) &optional DEEP

Method: clone-node (NODE text-node) &optional DEEP

Method: clone-node (NODE comment) &optional DEEP

Method: clone-node (NODE element) &optional DEEP

Method: clone-node (NODE doctype) &optional DEEP

Method: clone-node (NODE xml-header) &optional DEEP

Method: clone-node (NODE cdata) &optional DEEP

Method: clone-node (NODE processing-instruction) &optional DEEP

Generic Function: doctype OBJECT

Returns the doctype node’s actual doctype string.

Package

plump-dom

Writer

(setf doctype) (generic function)

Methods

Method: doctype (DOCTYPE doctype)

automatically generated reader method

Source

dom.lisp (file)

Generic Function: (setf doctype) NEW-VALUE OBJECT

Package

plump-dom

Reader

doctype (generic function)

Methods

Method: (setf doctype) NEW-VALUE (DOCTYPE doctype)

automatically generated writer method

Source

dom.lisp (file)

Generic Function: faulty-char CONDITION

Returns the faulty char that caused the signal.

Package

plump-dom

Writer

(setf faulty-char) (generic function)

Methods

Method: faulty-char (CONDITION discouraged-xml-character)

Source

entities.lisp (file)

Method: faulty-char (CONDITION invalid-xml-character)

Source

entities.lisp (file)

Generic Function: (setf faulty-char) NEW-VALUE CONDITION

Package

plump-dom

Reader

faulty-char (generic function)

Methods

Method: (setf faulty-char) NEW-VALUE (CONDITION discouraged-xml-character)

Source

entities.lisp (file)

Method: (setf faulty-char) NEW-VALUE (CONDITION invalid-xml-character)

Source

entities.lisp (file)

Generic Function: parent OBJECT

Returns the node’s parent that should contain this element as a child.

Package

plump-dom

Writer

(setf parent) (generic function)

Methods

Method: parent (CHILD-NODE child-node)

automatically generated reader method

Source

dom.lisp (file)

Generic Function: (setf parent) NEW-VALUE OBJECT

Package

plump-dom

Reader

parent (generic function)

Methods

Method: (setf parent) NEW-VALUE (CHILD-NODE child-node)

automatically generated writer method

Source

dom.lisp (file)

Generic Function: parse INPUT &key ROOT

Parses the given input into a DOM representation.
By default, methods for STRING, PATHNAME and STREAM are defined.
If supplied, the given root is used to append children to as per READ-ROOT. Returns the root.

Package

plump-parser

Source

parser.lisp (file)

Methods

Method: parse (INPUT string) &key ROOT

Method: parse (INPUT pathname) &key ROOT

Method: parse (INPUT stream) &key ROOT

Generic Function: serialize-object NODE

Serialize the given node and print it to *stream*.

Package

plump-dom

Source

dom.lisp (file)

Methods

Method: serialize-object (NODE text-node)

Method: serialize-object (NODE doctype)

Method: serialize-object (NODE comment)

Method: serialize-object (NODE element)

Method: serialize-object (NODE fulltext-element)

Method: serialize-object (NODE xml-header)

Method: serialize-object (NODE cdata)

Method: serialize-object (NODE processing-instruction)

Method: serialize-object (TABLE hash-table)

Method: serialize-object (NODE nesting-node)

Method: serialize-object (NODES vector)

Generic Function: tag-name OBJECT

Returns the element’s tag name.

Package

plump-dom

Writer

(setf tag-name) (generic function)

Methods

Method: tag-name (PROCESSING-INSTRUCTION processing-instruction)

automatically generated reader method

Source

dom.lisp (file)

Method: tag-name (ELEMENT element)

automatically generated reader method

Source

dom.lisp (file)

Generic Function: (setf tag-name) NEW-VALUE OBJECT

Package

plump-dom

Reader

tag-name (generic function)

Methods

Method: (setf tag-name) NEW-VALUE (PROCESSING-INSTRUCTION processing-instruction)

automatically generated writer method

Source

dom.lisp (file)

Method: (setf tag-name) NEW-VALUE (ELEMENT element)

automatically generated writer method

Source

dom.lisp (file)

Generic Function: text OBJECT

Returns the node’s textual content.

Package

plump-dom

Writer

(setf text) (generic function)

Methods

Method: text (NODE nesting-node)

Compiles all text nodes within the nesting-node into one string.

Source

dom.lisp (file)

Method: text (TEXTUAL-NODE textual-node)

automatically generated reader method

Source

dom.lisp (file)

Generic Function: (setf text) NEW-VALUE OBJECT

Package

plump-dom

Reader

text (generic function)

Methods

Method: (setf text) NEW-VALUE (TEXTUAL-NODE textual-node)

automatically generated writer method

Source

dom.lisp (file)

Generic Function: traverse NODE FUNCTION &key TEST

Traverse the NODE and all its children recursively,
calling FUNCTION on the current node if calling TEST on the current node returns a non-NIL value. It is safe to modify the child array of the parent of each node passed to FUNCTION.

NODE is returned.

Package

plump-dom

Source

dom.lisp (file)

Methods

Method: traverse (NODE node) FUNCTION &key TEST

Method: traverse (NODE nesting-node) FUNCTION &key TEST

5.1.5 Conditions

Condition: discouraged-xml-character ()

Warning signalled when a discouraged XML character is encountered during WRITE-ENCODE-CHAR.

Package

plump-dom

Source

entities.lisp (file)

Direct superclasses

warning (condition)

Direct methods

• faulty-char (method)
• faulty-char (method)

Direct slots

Slot: faulty-char

Initargs

:faulty-char

Readers

faulty-char (generic function)

Writers

(setf faulty-char) (generic function)

Condition: invalid-xml-character ()

Error signalled when an invalid XML character is encountered during WRITE-ENCODE-CHAR.

Package

plump-dom

Source

entities.lisp (file)

Direct superclasses

error (condition)

Direct methods

• faulty-char (method)
• faulty-char (method)

Direct slots

Slot: faulty-char

Initargs

:faulty-char

Readers

faulty-char (generic function)

Writers

(setf faulty-char) (generic function)

5.1.6 Structures

Structure: tag-dispatcher ()

Encapsulates the processing for a given tag.

See TAG-DISPATCHER-NAME
See TAG-DISPATCHER-TEST
See TAG-DISPATCHER-PARSER
See TAG-DISPATCHER-PRINTER

Package

plump-parser

Source

tag-dispatcher.lisp (file)

Direct superclasses

structure-object (structure)

Direct slots

Slot: name

Type

symbol

Initform

(error "name required")

Readers

tag-dispatcher-name (function)

Writers

(setf tag-dispatcher-name) (function)

Slot: test

Type

(function (string) boolean)

Initform

(lambda (plump-parser::a) (declare (ignore plump-parser::a)) nil)

Readers

tag-dispatcher-test (function)

Writers

(setf tag-dispatcher-test) (function)

Slot: parser

Type

(function (string) (or null plump-dom:node))

Initform

(lambda (plump-parser::a) (declare (ignore plump-parser::a)) nil)

Readers

tag-dispatcher-parser (function)

Writers

(setf tag-dispatcher-parser) (function)

Slot: printer

Type

(function (t) boolean)

Initform

(lambda (plump-parser::a) (declare (ignore plump-parser::a)) nil)

Readers

tag-dispatcher-printer (function)

Writers

(setf tag-dispatcher-printer) (function)

5.1.7 Classes

Class: cdata ()

XML CDATA section node.

Package

plump-dom

Source

dom.lisp (file)

Direct superclasses

• textual-node (class)
• child-node (class)

Direct methods

• serialize-object (method)
• clone-node (method)
• print-object (method)

Class: child-node ()

Node class that is a child and thus has a parent.

Package

plump-dom

Source

dom.lisp (file)

Direct superclasses

node (class)

Direct subclasses

• text-node (class)
• comment (class)
• element (class)
• doctype (class)
• xml-header (class)
• cdata (class)
• processing-instruction (class)

Direct methods

• clone-node (method)
• parent (method)
• parent (method)

Direct slots

Slot: %parent

Type

(or null plump-dom:nesting-node)

Initargs

:parent

Initform

(error "parent required.")

Readers

parent (generic function)

Writers

(setf parent) (generic function)

Class: comment ()

Comment node that can only contain a single comment string.

Package

plump-dom

Source

dom.lisp (file)

Direct superclasses

• textual-node (class)
• child-node (class)

Direct methods

• serialize-object (method)
• clone-node (method)

Class: doctype ()

Special DOM node for the doctype declaration.

Package

plump-dom

Source

dom.lisp (file)

Direct superclasses

child-node (class)

Direct methods

• serialize-object (method)
• clone-node (method)
• print-object (method)
• doctype (method)
• doctype (method)

Direct slots

Slot: %doctype

Type

string

Initargs

:doctype

Initform

(error "doctype declaration required.")

Readers

doctype (generic function)

Writers

(setf doctype) (generic function)

Class: element ()

Standard DOM element/block including attributes, tag-name, parent and children.

Package

plump-dom

Source

dom.lisp (file)

Direct superclasses

• child-node (class)
• nesting-node (class)

Direct subclasses

fulltext-element (class)

Direct methods

• serialize-object (method)
• clone-node (method)
• print-object (method)
• attributes (method)
• attributes (method)
• tag-name (method)
• tag-name (method)

Direct slots

Slot: %tag-name

Type

string

Initargs

:tag-name

Initform

(error "tag name required.")

Readers

tag-name (generic function)

Writers

(setf tag-name) (generic function)

Slot: %attributes

Type

hash-table

Initargs

:attributes

Initform

(plump-dom:make-attribute-map)

Readers

attributes (generic function)

Writers

(setf attributes) (generic function)

Class: fulltext-element ()

Special DOM element that contains full, un-entitied text like SCRIPT and STYLE.

Package

plump-dom

Source

dom.lisp (file)

Direct superclasses

element (class)

Direct methods

serialize-object (method)

Class: nesting-node ()

Node class that can contain child nodes.

Package

plump-dom

Source

dom.lisp (file)

Direct superclasses

node (class)

Direct subclasses

• root (class)
• element (class)

Direct methods

• traverse (method)
• serialize-object (method)
• text (method)
• clone-node (method)
• children (method)
• children (method)

Direct slots

Slot: %children

Type

(and (vector plump-dom:child-node) (not simple-array))

Initargs

:children

Initform

(plump-dom:make-child-array)

Readers

children (generic function)

Writers

(setf children) (generic function)

Class: node ()

Base DOM node class.

Package

plump-dom

Source

dom.lisp (file)

Direct superclasses

standard-object (class)

Direct subclasses

• nesting-node (class)
• child-node (class)
• textual-node (class)

Direct methods

• traverse (method)
• clone-node (method)

Class: processing-instruction ()

XML processing instruction node.

Package

plump-dom

Source

dom.lisp (file)

Direct superclasses

• textual-node (class)
• child-node (class)

Direct methods

• serialize-object (method)
• clone-node (method)
• print-object (method)
• tag-name (method)
• tag-name (method)

Direct slots

Slot: %tag-name

Type

(or null string)

Initargs

:tag-name

Readers

tag-name (generic function)

Writers

(setf tag-name) (generic function)

Class: root ()

Root DOM node, practically equivalent to a "document".

Package

plump-dom

Source

dom.lisp (file)

Direct superclasses

nesting-node (class)

Class: text-node ()

Text node that can only contain a single text string.

Package

plump-dom

Source

dom.lisp (file)

Direct superclasses

• textual-node (class)
• child-node (class)

Direct methods

• serialize-object (method)
• clone-node (method)

Class: textual-node ()

Node class that represents a textual node and thus contains a TEXT field.

Package

plump-dom

Source

dom.lisp (file)

Direct superclasses

node (class)

Direct subclasses

• text-node (class)
• comment (class)
• cdata (class)
• processing-instruction (class)

Direct methods

• clone-node (method)
• text (method)
• text (method)

Direct slots

Slot: %text

Type

string

Initargs

:text

Initform

""

Readers

text (generic function)

Writers

(setf text) (generic function)

Class: xml-header ()

XML header element

Package

plump-dom

Source

dom.lisp (file)

Direct superclasses

child-node (class)

Direct methods

• serialize-object (method)
• clone-node (method)
• print-object (method)
• attributes (method)
• attributes (method)

Direct slots

Slot: %attributes

Type

hash-table

Initargs

:attributes

Initform

(plump-dom:make-attribute-map)

Readers

attributes (generic function)

Writers

(setf attributes) (generic function)

5.2 Internal definitions

5.2.1 Special variables

Special Variable: *alpha-chars*

All alphabetic characters and #

Package

plump-dom

Source

entities.lisp (file)

Special Variable: *matchers*

Hash table containing matching rules.

Package

plump-lexer

Source

lexer.lisp (file)

Special Variable: *processing-parsers*

Package

plump-parser

Source

processing.lisp (file)

Special Variable: *tagstack*

Package

plump-parser

Source

parser.lisp (file)

Special Variable: *whitespace*

List containing all whitespace characters.

Package

plump-parser

Source

parser.lisp (file)

5.2.2 Macros

Macro: define-predicates &rest CLASSES

Package

plump-dom

Source

dom.lisp (file)

Macro: make-appending (CLASS PARENT) &body PROPERTIES

Package

plump-dom

Source

dom.lisp (file)

Macro: wrs &rest STRINGS

Package

plump-dom

Source

dom.lisp (file)

5.2.3 Functions

Function: copy-tag-dispatcher INSTANCE

Package

plump-parser

Source

tag-dispatcher.lisp (file)

Function: ends-with FIND STRING

Package

plump-parser

Source

special-tags.lisp (file)

Function: make-tag-dispatcher &key (NAME NAME) (TEST TEST) (PARSER PARSER) (PRINTER PRINTER)

Package

plump-parser

Source

tag-dispatcher.lisp (file)

Function: read-fulltext-element-content NAME

Reads the contents of a fulltext element. This slurps everything until the matching closing tag is encountered.

Package

plump-parser

Source

special-tags.lisp (file)

Function: skip-whitespace ()

Package

plump-parser

Source

parser.lisp (file)

Function: starts-with FIND STRING

Package

plump-parser

Source

special-tags.lisp (file)

Function: tag-dispatcher-name INSTANCE

Returns the name of the tag dispatcher.

Package

plump-parser

Source

tag-dispatcher.lisp (file)

Writer

(setf tag-dispatcher-name) (function)

Function: (setf tag-dispatcher-name) VALUE INSTANCE

Package

plump-parser

Source

tag-dispatcher.lisp (file)

Reader

tag-dispatcher-name (function)

Function: tag-dispatcher-p OBJECT

Package

plump-parser

Source

tag-dispatcher.lisp (file)

Function: tag-dispatcher-parser INSTANCE

Parses the node for the given tag.

The function takes one argument, a string, denoting the tag name. It returns a node, or NIL, if the matching was refused for some reason.

Package

plump-parser

Source

tag-dispatcher.lisp (file)

Writer

(setf tag-dispatcher-parser) (function)

Function: (setf tag-dispatcher-parser) VALUE INSTANCE

Package

plump-parser

Source

tag-dispatcher.lisp (file)

Reader

tag-dispatcher-parser (function)

Function: tag-dispatcher-printer INSTANCE

Prints the node for the given tag.

The function takes one argument, a node, the element to print.
It returns the same node, or NIL, if the printing was refused for some reason.

Package

plump-parser

Source

tag-dispatcher.lisp (file)

Writer

(setf tag-dispatcher-printer) (function)

Function: (setf tag-dispatcher-printer) VALUE INSTANCE

Package

plump-parser

Source

tag-dispatcher.lisp (file)

Reader

tag-dispatcher-printer (function)