The plump Reference Manual

Table of Contents

Next: , Previous: , Up: (dir)   [Contents][Index]

The plump Reference Manual

This is the plump Reference Manual, version 2.0.0, generated automatically by Declt version 2.3 "Robert April" on Tue Feb 20 09:11:06 2018 GMT+0.


Next: , Previous: , Up: Top   [Contents][Index]

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*)

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

benchmark

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

See Also


Next: , Previous: , Up: Top   [Contents][Index]

2 Systems

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


Previous: , Up: Systems   [Contents][Index]

2.1 plump

Maintainer

Nicolas Hafner <shinmera@tymoon.eu>

Author

Nicolas Hafner <shinmera@tymoon.eu>

Home Page

https://github.com/Shinmera/plump

License

Artistic

Description

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

Version

2.0.0

Dependencies
Source

plump.asd (file)

Components

Next: , Previous: , Up: Top   [Contents][Index]

3 Files

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


Previous: , Up: Files   [Contents][Index]

3.1 Lisp


Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.1 plump.asd

Location

plump.asd

Systems

plump (system)


Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.2 plump/package.lisp

Parent

plump (system)

Location

package.lisp

Packages

Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.3 plump/entities.lisp

Dependency

package.lisp (file)

Parent

plump (system)

Location

entities.lisp

Exported Definitions
Internal Definitions

*alpha-chars* (special variable)


Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.4 plump/lexer.lisp

Dependency

entities.lisp (file)

Parent

plump (system)

Location

lexer.lisp

Exported Definitions
Internal Definitions

*matchers* (special variable)


Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.5 plump/tag-dispatcher.lisp

Dependency

lexer.lisp (file)

Parent

plump (system)

Location

tag-dispatcher.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.6 plump/dom.lisp

Dependency

tag-dispatcher.lisp (file)

Parent

plump (system)

Location

dom.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.7 plump/parser.lisp

Dependency

dom.lisp (file)

Parent

plump (system)

Location

parser.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.8 plump/processing.lisp

Dependency

parser.lisp (file)

Parent

plump (system)

Location

processing.lisp

Exported Definitions
Internal Definitions

*processing-parsers* (special variable)


Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.9 plump/special-tags.lisp

Dependency

processing.lisp (file)

Parent

plump (system)

Location

special-tags.lisp

Exported Definitions
Internal Definitions

Previous: , Up: Lisp files   [Contents][Index]

3.1.10 plump/documentation.lisp

Dependency

special-tags.lisp (file)

Parent

plump (system)

Location

documentation.lisp


Next: , Previous: , Up: Top   [Contents][Index]

4 Packages

Packages are listed by definition order.


Next: , Previous: , Up: Packages   [Contents][Index]

4.1 plump

Source

package.lisp (file)

Nickname

org.shirakumo.plump

Use List

Next: , Previous: , Up: Packages   [Contents][Index]

4.2 plump-parser

Source

package.lisp (file)

Nickname

org.shirakumo.plump.parser

Use List
Used By List

plump

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Packages   [Contents][Index]

4.3 plump-dom

Source

package.lisp (file)

Nickname

org.shirakumo.plump.dom

Use List
Used By List
Exported Definitions
Internal Definitions

Previous: , Up: Packages   [Contents][Index]

4.4 plump-lexer

Source

package.lisp (file)

Nickname

org.shirakumo.plump.lexer

Use List

common-lisp

Used By List
Exported Definitions
Internal Definitions

*matchers* (special variable)


Next: , Previous: , Up: Top   [Contents][Index]

5 Definitions

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


Next: , Previous: , Up: Definitions   [Contents][Index]

5.1 Exported definitions


Next: , Previous: , Up: Exported definitions   [Contents][Index]

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)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

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: 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)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

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 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: 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)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

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 (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

Next: , Previous: , Up: Exported definitions   [Contents][Index]

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
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
Direct slots
Slot: faulty-char
Initargs

:faulty-char

Readers

faulty-char (generic function)

Writers

(setf faulty-char) (generic function)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

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 (plump-dom:node) boolean)

Initform

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

Readers

tag-dispatcher-printer (function)

Writers

(setf tag-dispatcher-printer) (function)


Previous: , Up: Exported definitions   [Contents][Index]

5.1.7 Classes

Class: cdata ()

XML CDATA section node.

Package

plump-dom

Source

dom.lisp (file)

Direct superclasses
Direct methods
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
Direct methods
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
Direct methods
Class: doctype ()

Special DOM node for the doctype declaration.

Package

plump-dom

Source

dom.lisp (file)

Direct superclasses

child-node (class)

Direct methods
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
Direct subclasses

fulltext-element (class)

Direct methods
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
Direct methods
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
Direct methods
Class: processing-instruction ()

XML processing instruction node.

Package

plump-dom

Source

dom.lisp (file)

Direct superclasses
Direct methods
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
Direct methods
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
Direct methods
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
Direct slots
Slot: %attributes
Type

hash-table

Initargs

:attributes

Initform

(plump-dom:make-attribute-map)

Readers

attributes (generic function)

Writers

(setf attributes) (generic function)


Previous: , Up: Definitions   [Contents][Index]

5.2 Internal definitions


Next: , Previous: , Up: Internal definitions   [Contents][Index]

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)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

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)


Previous: , Up: Internal definitions   [Contents][Index]

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)

Function: tag-dispatcher-test INSTANCE

Returns the test function of the tag dispatcher.

The function takes one argument, a string, denoting the tag name. It returns a boolean as to whether the tag name matches.

Package

plump-parser

Source

tag-dispatcher.lisp (file)

Writer

(setf tag-dispatcher-test) (function)

Function: (setf tag-dispatcher-test) VALUE INSTANCE
Package

plump-parser

Source

tag-dispatcher.lisp (file)

Reader

tag-dispatcher-test (function)

Function: vec-remove-if PREDICATE SEQUENCE
Package

plump-dom

Source

dom.lisp (file)


Previous: , Up: Top   [Contents][Index]

Appendix A Indexes


Next: , Previous: , Up: Indexes   [Contents][Index]

A.1 Concepts

Jump to:   F   L   P  
Index Entry  Section

F
File, Lisp, plump.asd: The plump<dot>asd file
File, Lisp, plump/documentation.lisp: The plump/documentation<dot>lisp file
File, Lisp, plump/dom.lisp: The plump/dom<dot>lisp file
File, Lisp, plump/entities.lisp: The plump/entities<dot>lisp file
File, Lisp, plump/lexer.lisp: The plump/lexer<dot>lisp file
File, Lisp, plump/package.lisp: The plump/package<dot>lisp file
File, Lisp, plump/parser.lisp: The plump/parser<dot>lisp file
File, Lisp, plump/processing.lisp: The plump/processing<dot>lisp file
File, Lisp, plump/special-tags.lisp: The plump/special-tags<dot>lisp file
File, Lisp, plump/tag-dispatcher.lisp: The plump/tag-dispatcher<dot>lisp file

L
Lisp File, plump.asd: The plump<dot>asd file
Lisp File, plump/documentation.lisp: The plump/documentation<dot>lisp file
Lisp File, plump/dom.lisp: The plump/dom<dot>lisp file
Lisp File, plump/entities.lisp: The plump/entities<dot>lisp file
Lisp File, plump/lexer.lisp: The plump/lexer<dot>lisp file
Lisp File, plump/package.lisp: The plump/package<dot>lisp file
Lisp File, plump/parser.lisp: The plump/parser<dot>lisp file
Lisp File, plump/processing.lisp: The plump/processing<dot>lisp file
Lisp File, plump/special-tags.lisp: The plump/special-tags<dot>lisp file
Lisp File, plump/tag-dispatcher.lisp: The plump/tag-dispatcher<dot>lisp file

P
plump.asd: The plump<dot>asd file
plump/documentation.lisp: The plump/documentation<dot>lisp file
plump/dom.lisp: The plump/dom<dot>lisp file
plump/entities.lisp: The plump/entities<dot>lisp file
plump/lexer.lisp: The plump/lexer<dot>lisp file
plump/package.lisp: The plump/package<dot>lisp file
plump/parser.lisp: The plump/parser<dot>lisp file
plump/processing.lisp: The plump/processing<dot>lisp file
plump/special-tags.lisp: The plump/special-tags<dot>lisp file
plump/tag-dispatcher.lisp: The plump/tag-dispatcher<dot>lisp file

Jump to:   F   L   P  

Next: , Previous: , Up: Indexes   [Contents][Index]

A.2 Functions

Jump to:   (  
A   C   D   E   F   G   H   I   L   M   N   P   R   S   T   U   V   W   X  
Index Entry  Section

(
(setf attribute): Exported functions
(setf attributes): Exported generic functions
(setf attributes): Exported generic functions
(setf attributes): Exported generic functions
(setf children): Exported generic functions
(setf children): Exported generic functions
(setf doctype): Exported generic functions
(setf doctype): Exported generic functions
(setf faulty-char): Exported generic functions
(setf faulty-char): Exported generic functions
(setf faulty-char): Exported generic functions
(setf parent): Exported generic functions
(setf parent): Exported generic functions
(setf processing-parser): Exported functions
(setf tag-dispatcher): Exported functions
(setf tag-dispatcher-name): Internal functions
(setf tag-dispatcher-parser): Internal functions
(setf tag-dispatcher-printer): Internal functions
(setf tag-dispatcher-test): Internal functions
(setf tag-name): Exported generic functions
(setf tag-name): Exported generic functions
(setf tag-name): Exported generic functions
(setf text): Exported generic functions
(setf text): Exported generic functions

A
advance: Exported functions
advance-n: Exported functions
allowed-char-p: Exported functions
append-child: Exported functions
attribute: Exported functions
attributes: Exported generic functions
attributes: Exported generic functions
attributes: Exported generic functions

C
cdata-p: Exported functions
child-elements: Exported functions
child-node-p: Exported functions
child-position: Exported functions
children: Exported generic functions
children: Exported generic functions
clear: Exported functions
clone-attributes: Exported functions
clone-children: Exported functions
clone-node: Exported generic functions
clone-node: Exported generic functions
clone-node: Exported generic functions
clone-node: Exported generic functions
clone-node: Exported generic functions
clone-node: Exported generic functions
clone-node: Exported generic functions
clone-node: Exported generic functions
clone-node: Exported generic functions
clone-node: Exported generic functions
clone-node: Exported generic functions
clone-node: Exported generic functions
comment-p: Exported functions
consume: Exported functions
consume-until: Exported functions
copy-tag-dispatcher: Internal functions

D
decode-entities: Exported functions
define-fulltext-element: Exported macros
define-matcher: Exported macros
define-predicates: Internal macros
define-processing-parser: Exported macros
define-self-closing-element: Exported macros
define-tag-dispatcher: Exported macros
define-tag-parser: Exported macros
define-tag-printer: Exported macros
discouraged-char-p: Exported functions
do-tag-parsers: Exported macros
do-tag-printers: Exported macros
doctype: Exported generic functions
doctype: Exported generic functions
doctype-p: Exported functions

E
element-p: Exported functions
element-position: Exported functions
encode-entities: Exported functions
ends-with: Internal functions
ensure-attribute-map: Exported functions
ensure-child-array: Exported functions

F
family: Exported functions
family-elements: Exported functions
faulty-char: Exported generic functions
faulty-char: Exported generic functions
faulty-char: Exported generic functions
first-child: Exported functions
first-element: Exported functions
fulltext-element-p: Exported functions
Function, (setf attribute): Exported functions
Function, (setf processing-parser): Exported functions
Function, (setf tag-dispatcher-name): Internal functions
Function, (setf tag-dispatcher-parser): Internal functions
Function, (setf tag-dispatcher-printer): Internal functions
Function, (setf tag-dispatcher-test): Internal functions
Function, advance: Exported functions
Function, advance-n: Exported functions
Function, allowed-char-p: Exported functions
Function, append-child: Exported functions
Function, attribute: Exported functions
Function, cdata-p: Exported functions
Function, child-elements: Exported functions
Function, child-node-p: Exported functions
Function, child-position: Exported functions
Function, clear: Exported functions
Function, clone-attributes: Exported functions
Function, clone-children: Exported functions
Function, comment-p: Exported functions
Function, consume: Exported functions
Function, consume-until: Exported functions
Function, copy-tag-dispatcher: Internal functions
Function, decode-entities: Exported functions
Function, discouraged-char-p: Exported functions
Function, doctype-p: Exported functions
Function, element-p: Exported functions
Function, element-position: Exported functions
Function, encode-entities: Exported functions
Function, ends-with: Internal functions
Function, ensure-attribute-map: Exported functions
Function, ensure-child-array: Exported functions
Function, family: Exported functions
Function, family-elements: Exported functions
Function, first-child: Exported functions
Function, first-element: Exported functions
Function, fulltext-element-p: Exported functions
Function, get-attribute: Exported functions
Function, get-element-by-id: Exported functions
Function, get-elements-by-tag-name: Exported functions
Function, has-attribute: Exported functions
Function, has-child-nodes: Exported functions
Function, insert-after: Exported functions
Function, insert-before: Exported functions
Function, last-child: Exported functions
Function, last-element: Exported functions
Function, make-attribute-map: Exported functions
Function, make-cdata: Exported functions
Function, make-child-array: Exported functions
Function, make-comment: Exported functions
Function, make-doctype: Exported functions
Function, make-element: Exported functions
Function, make-fulltext-element: Exported functions
Function, make-processing-instruction: Exported functions
Function, make-root: Exported functions
Function, make-tag-dispatcher: Internal functions
Function, make-text-node: Exported functions
Function, make-xml-header: Exported functions
Function, matcher-and: Exported functions
Function, matcher-character: Exported functions
Function, matcher-find: Exported functions
Function, matcher-next: Exported functions
Function, matcher-not: Exported functions
Function, matcher-or: Exported functions
Function, matcher-prev: Exported functions
Function, matcher-range: Exported functions
Function, matcher-string: Exported functions
Function, nesting-node-p: Exported functions
Function, next-element: Exported functions
Function, next-sibling: Exported functions
Function, node-p: Exported functions
Function, peek: Exported functions
Function, prepend-child: Exported functions
Function, previous-element: Exported functions
Function, previous-sibling: Exported functions
Function, processing-instruction-p: Exported functions
Function, processing-parser: Exported functions
Function, read-attribute: Exported functions
Function, read-attribute-name: Exported functions
Function, read-attribute-value: Exported functions
Function, read-attributes: Exported functions
Function, read-children: Exported functions
Function, read-fulltext-element-content: Internal functions
Function, read-name: Exported functions
Function, read-root: Exported functions
Function, read-standard-tag: Exported functions
Function, read-tag: Exported functions
Function, read-tag-contents: Exported functions
Function, read-text: Exported functions
Function, remove-attribute: Exported functions
Function, remove-child: Exported functions
Function, remove-processing-parser: Exported functions
Function, remove-tag-dispatcher: Exported functions
Function, render-text: Exported functions
Function, replace-child: Exported functions
Function, root-p: Exported functions
Function, serialize: Exported functions
Function, set-attribute: Exported functions
Function, sibling-elements: Exported functions
Function, siblings: Exported functions
Function, skip-whitespace: Internal functions
Function, slurp-stream: Exported functions
Function, splice: Exported functions
Function, starts-with: Internal functions
Function, strip: Exported functions
Function, tag-dispatcher: Exported functions
Function, tag-dispatcher-name: Internal functions
Function, tag-dispatcher-p: Internal functions
Function, tag-dispatcher-parser: Internal functions
Function, tag-dispatcher-printer: Internal functions
Function, tag-dispatcher-test: Internal functions
Function, text-node-p: Exported functions
Function, textual-node-p: Exported functions
Function, translate-entity: Exported functions
Function, trim: Exported functions
Function, unread: Exported functions
Function, unread-n: Exported functions
Function, vec-remove-if: Internal functions
Function, write-encode-char: Exported functions
Function, xml-header-p: Exported functions

G
Generic Function, (setf attributes): Exported generic functions
Generic Function, (setf children): Exported generic functions
Generic Function, (setf doctype): Exported generic functions
Generic Function, (setf faulty-char): Exported generic functions
Generic Function, (setf parent): Exported generic functions
Generic Function, (setf tag-name): Exported generic functions
Generic Function, (setf text): Exported generic functions
Generic Function, attributes: Exported generic functions
Generic Function, children: Exported generic functions
Generic Function, clone-node: Exported generic functions
Generic Function, doctype: Exported generic functions
Generic Function, faulty-char: Exported generic functions
Generic Function, parent: Exported generic functions
Generic Function, parse: Exported generic functions
Generic Function, serialize-object: Exported generic functions
Generic Function, tag-name: Exported generic functions
Generic Function, text: Exported generic functions
Generic Function, traverse: Exported generic functions
get-attribute: Exported functions
get-element-by-id: Exported functions
get-elements-by-tag-name: Exported functions

H
has-attribute: Exported functions
has-child-nodes: Exported functions

I
insert-after: Exported functions
insert-before: Exported functions

L
last-child: Exported functions
last-element: Exported functions

M
Macro, define-fulltext-element: Exported macros
Macro, define-matcher: Exported macros
Macro, define-predicates: Internal macros
Macro, define-processing-parser: Exported macros
Macro, define-self-closing-element: Exported macros
Macro, define-tag-dispatcher: Exported macros
Macro, define-tag-parser: Exported macros
Macro, define-tag-printer: Exported macros
Macro, do-tag-parsers: Exported macros
Macro, do-tag-printers: Exported macros
Macro, make-appending: Internal macros
Macro, make-matcher: Exported macros
Macro, matcher-any: Exported macros
Macro, with-lexer-environment: Exported macros
Macro, wrs: Internal macros
make-appending: Internal macros
make-attribute-map: Exported functions
make-cdata: Exported functions
make-child-array: Exported functions
make-comment: Exported functions
make-doctype: Exported functions
make-element: Exported functions
make-fulltext-element: Exported functions
make-matcher: Exported macros
make-processing-instruction: Exported functions
make-root: Exported functions
make-tag-dispatcher: Internal functions
make-text-node: Exported functions
make-xml-header: Exported functions
matcher-and: Exported functions
matcher-any: Exported macros
matcher-character: Exported functions
matcher-find: Exported functions
matcher-next: Exported functions
matcher-not: Exported functions
matcher-or: Exported functions
matcher-prev: Exported functions
matcher-range: Exported functions
matcher-string: Exported functions
Method, (setf attributes): Exported generic functions
Method, (setf attributes): Exported generic functions
Method, (setf children): Exported generic functions
Method, (setf doctype): Exported generic functions
Method, (setf faulty-char): Exported generic functions
Method, (setf faulty-char): Exported generic functions
Method, (setf parent): Exported generic functions
Method, (setf tag-name): Exported generic functions
Method, (setf tag-name): Exported generic functions
Method, (setf text): Exported generic functions
Method, attributes: Exported generic functions
Method, attributes: Exported generic functions
Method, children: Exported generic functions
Method, clone-node: Exported generic functions
Method, clone-node: Exported generic functions
Method, clone-node: Exported generic functions
Method, clone-node: Exported generic functions
Method, clone-node: Exported generic functions
Method, clone-node: Exported generic functions
Method, clone-node: Exported generic functions
Method, clone-node: Exported generic functions
Method, clone-node: Exported generic functions
Method, clone-node: Exported generic functions
Method, clone-node: Exported generic functions
Method, doctype: Exported generic functions
Method, faulty-char: Exported generic functions
Method, faulty-char: Exported generic functions
Method, parent: Exported generic functions
Method, parse: Exported generic functions
Method, parse: Exported generic functions
Method, parse: Exported generic functions
Method, serialize-object: Exported generic functions
Method, serialize-object: Exported generic functions
Method, serialize-object: Exported generic functions
Method, serialize-object: Exported generic functions
Method, serialize-object: Exported generic functions
Method, serialize-object: Exported generic functions
Method, serialize-object: Exported generic functions
Method, serialize-object: Exported generic functions
Method, serialize-object: Exported generic functions
Method, serialize-object: Exported generic functions
Method, serialize-object: Exported generic functions
Method, tag-name: Exported generic functions
Method, tag-name: Exported generic functions
Method, text: Exported generic functions
Method, text: Exported generic functions
Method, traverse: Exported generic functions
Method, traverse: Exported generic functions

N
nesting-node-p: Exported functions
next-element: Exported functions
next-sibling: Exported functions
node-p: Exported functions

P
parent: Exported generic functions
parent: Exported generic functions
parse: Exported generic functions
parse: Exported generic functions
parse: Exported generic functions
parse: Exported generic functions
peek: Exported functions
prepend-child: Exported functions
previous-element: Exported functions
previous-sibling: Exported functions
processing-instruction-p: Exported functions
processing-parser: Exported functions

R
read-attribute: Exported functions
read-attribute-name: Exported functions
read-attribute-value: Exported functions
read-attributes: Exported functions
read-children: Exported functions
read-fulltext-element-content: Internal functions
read-name: Exported functions
read-root: Exported functions
read-standard-tag: Exported functions
read-tag: Exported functions
read-tag-contents: Exported functions
read-text: Exported functions
remove-attribute: Exported functions
remove-child: Exported functions
remove-processing-parser: Exported functions
remove-tag-dispatcher: Exported functions
render-text: Exported functions
replace-child: Exported functions
root-p: Exported functions

S
serialize: Exported functions
serialize-object: Exported generic functions
serialize-object: Exported generic functions
serialize-object: Exported generic functions
serialize-object: Exported generic functions
serialize-object: Exported generic functions
serialize-object: Exported generic functions
serialize-object: Exported generic functions
serialize-object: Exported generic functions
serialize-object: Exported generic functions
serialize-object: Exported generic functions
serialize-object: Exported generic functions
serialize-object: Exported generic functions
set-attribute: Exported functions
Setf Expander, (setf tag-dispatcher): Exported functions
sibling-elements: Exported functions
siblings: Exported functions
skip-whitespace: Internal functions
slurp-stream: Exported functions
splice: Exported functions
starts-with: Internal functions
strip: Exported functions

T
tag-dispatcher: Exported functions
tag-dispatcher-name: Internal functions
tag-dispatcher-p: Internal functions
tag-dispatcher-parser: Internal functions
tag-dispatcher-printer: Internal functions
tag-dispatcher-test: Internal functions
tag-name: Exported generic functions
tag-name: Exported generic functions
tag-name: Exported generic functions
text: Exported generic functions
text: Exported generic functions
text: Exported generic functions
text-node-p: Exported functions
textual-node-p: Exported functions
translate-entity: Exported functions
traverse: Exported generic functions
traverse: Exported generic functions
traverse: Exported generic functions
trim: Exported functions

U
unread: Exported functions
unread-n: Exported functions

V
vec-remove-if: Internal functions

W
with-lexer-environment: Exported macros
write-encode-char: Exported functions
wrs: Internal macros

X
xml-header-p: Exported functions

Jump to:   (  
A   C   D   E   F   G   H   I   L   M   N   P   R   S   T   U   V   W   X  

Next: , Previous: , Up: Indexes   [Contents][Index]

A.3 Variables

Jump to:   %   *  
F   N   P   S   T  
Index Entry  Section

%
%attributes: Exported classes
%attributes: Exported classes
%children: Exported classes
%doctype: Exported classes
%parent: Exported classes
%tag-name: Exported classes
%tag-name: Exported classes
%text: Exported classes

*
*all-tag-dispatchers*: Exported special variables
*alpha-chars*: Internal special variables
*entity-map*: Exported special variables
*html-tags*: Exported special variables
*index*: Exported special variables
*length*: Exported special variables
*matchers*: Internal special variables
*processing-parsers*: Internal special variables
*root*: Exported special variables
*stream*: Exported special variables
*string*: Exported special variables
*tag-dispatchers*: Exported special variables
*tagstack*: Internal special variables
*whitespace*: Internal special variables
*xml-tags*: Exported special variables

F
faulty-char: Exported conditions
faulty-char: Exported conditions

N
name: Exported structures

P
parser: Exported structures
printer: Exported structures

S
Slot, %attributes: Exported classes
Slot, %attributes: Exported classes
Slot, %children: Exported classes
Slot, %doctype: Exported classes
Slot, %parent: Exported classes
Slot, %tag-name: Exported classes
Slot, %tag-name: Exported classes
Slot, %text: Exported classes
Slot, faulty-char: Exported conditions
Slot, faulty-char: Exported conditions
Slot, name: Exported structures
Slot, parser: Exported structures
Slot, printer: Exported structures
Slot, test: Exported structures
Special Variable, *all-tag-dispatchers*: Exported special variables
Special Variable, *alpha-chars*: Internal special variables
Special Variable, *entity-map*: Exported special variables
Special Variable, *html-tags*: Exported special variables
Special Variable, *index*: Exported special variables
Special Variable, *length*: Exported special variables
Special Variable, *matchers*: Internal special variables
Special Variable, *processing-parsers*: Internal special variables
Special Variable, *root*: Exported special variables
Special Variable, *stream*: Exported special variables
Special Variable, *string*: Exported special variables
Special Variable, *tag-dispatchers*: Exported special variables
Special Variable, *tagstack*: Internal special variables
Special Variable, *whitespace*: Internal special variables
Special Variable, *xml-tags*: Exported special variables

T
test: Exported structures

Jump to:   %   *  
F   N   P   S   T  

Previous: , Up: Indexes   [Contents][Index]

A.4 Data types

Jump to:   C   D   E   F   I   N   P   R   S   T   X  
Index Entry  Section

C
cdata: Exported classes
child-node: Exported classes
Class, cdata: Exported classes
Class, child-node: Exported classes
Class, comment: Exported classes
Class, doctype: Exported classes
Class, element: Exported classes
Class, fulltext-element: Exported classes
Class, nesting-node: Exported classes
Class, node: Exported classes
Class, processing-instruction: Exported classes
Class, root: Exported classes
Class, text-node: Exported classes
Class, textual-node: Exported classes
Class, xml-header: Exported classes
comment: Exported classes
Condition, discouraged-xml-character: Exported conditions
Condition, invalid-xml-character: Exported conditions

D
discouraged-xml-character: Exported conditions
doctype: Exported classes

E
element: Exported classes

F
fulltext-element: Exported classes

I
invalid-xml-character: Exported conditions

N
nesting-node: Exported classes
node: Exported classes

P
Package, plump: The plump package
Package, plump-dom: The plump-dom package
Package, plump-lexer: The plump-lexer package
Package, plump-parser: The plump-parser package
plump: The plump system
plump: The plump package
plump-dom: The plump-dom package
plump-lexer: The plump-lexer package
plump-parser: The plump-parser package
processing-instruction: Exported classes

R
root: Exported classes

S
Structure, tag-dispatcher: Exported structures
System, plump: The plump system

T
tag-dispatcher: Exported structures
text-node: Exported classes
textual-node: Exported classes

X
xml-header: Exported classes

Jump to:   C   D   E   F   I   N   P   R   S   T   X