The chtml-matcher Reference Manual

Table of Contents

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

The chtml-matcher Reference Manual

This is the chtml-matcher Reference Manual, version 1.0, generated automatically by Declt version 2.4 "Will Decker" on Wed Jun 20 10:56:02 2018 GMT+0.


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

1 Introduction

chtml-matcher

A simple Lisp-based DSL for extracting information from web pages

chtml-matcher performs pattern-based unification over HTML via a set of compiled nested closures. It uses the closure-html library to parse HTML to lhtml, a lisp form of HTML. A template list is passed to (match-template template lhtml) and returns a bindings object containing an alist of all the extracted information.

The semantics are reasonably intuitive, but might require a little playing around to get a good feel for how to solve most common problems. The API is small and the package.lisp provides pointers to where to look. The whole library is less than 1k lines of code so easy enough to read through.

Download and Dependencies

Clone it from github. The old repository on common-lisp.net is deprecated.

chtml-matcher depends on my home-brew cl-stdutils, closure-html, cl-ppcre, and f-underscore, although all but closure-html could be removed if necessary.

LXML Template Unfication

The DSL provides a light-weight way to extract fields from nested HTML/XML structure represented in LHTML (as produced by closure-html). A template is a declarative representation of substructure with embedded variables that are bound when the substructure matches.

Substructure is loosely matched, such that if any given body element doesn't match, the next child is considered until all the template body elements have matched a lhtml element or the end of the elment has been reached without a match.

Prepending < to a tag enables a depth-first search for that tag so you can avoid specifying the parent path (similar to // in xpath)

Any matching template that consists of a variable reference results in a binding set being created and returned if all elements of the template node successfully match.

Additional reserved operators allow you more flexibility on managing what is matched and how bindings from subtrees are combined

all: match same template multiple times over the children of a given node and store them as a list attached to a fresh bindings list

merge: create a single binding out of each of the sub-bindings. A node body has an implicit merge

nth: find the nth instance that matches the full body of this operator

regex: matches if regex returns register values for a string (as a list)

fn: Run the referenced function symbol on the current parse state and return bindings, t or nil as appropriate.

Example

I've recently been mining some posts from vBulletin sites. I go to the last day's posts, get a list of all the new posts, then go to the thread and grab the post body. The following two templates do 90% of the work. Of course, I have to write code to convert the data I extract to web page fetches, etc.

(defparameter *vbulletin-search-template*
  '(<tbody nil
     (all ?records 
       (tr nil
         (td nil)
	   (td ((class "alt1"))
	     (div nil
	       (a ((href ?thread-uri))
	         ?thread-name)))
         (td ((class "alt2") (title ?activity))
           (div nil ?post-date
	     (span nil ?post-time)
	     (a ((href ?user-uri))
	       ?username)
	     (a ((href ?last-post-uri)))))))))
    =>
    '(:records ((:thread-name . "Thread name")
                (:thread-uri  . "Thread URI")
                (:post-date   . "Date String")
	    (:post-time   . "Time String")
                (:username    . "Username")
                (:user-uri    . "URI String")
                (:last-post-uri . "URI String"))
               ...)

This looks for a table body in the search results page, then gets bindings for all matching elements and puts them within another bindings object bound to :records as specified by 'all'. The pattern pulls out all the user, thread, post and date information for all results. You can match elements on strings, regular expressions and arbitrary function calls as well.

I use subst to customize the following pattern to find a particular post in a page. It replaces 'post_message_?' with a unique id for a post then returns its thread number and the entire post body.

  (defparameter *vbulletin-post-template*
    `(<tbody nil 
   (tr nil (<a ((name ?post-num))))
   (tr nil)
   (tr nil (?post-body <div ((id "post_message_?"))))))

I use Firefox FireBug to inspect the HTML tree, identify the best unique enclosing context I can specify and then provide enough structure to uniquely capture the data I want. This approach is highly robust to many small HTML changes and should be reasonably fast.


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 chtml-matcher

Maintainer

Ian Eslick

Author

Ian Eslick

License

MIT style license

Description

A unifying template matcher based on closure-html for web scraping and extraction

Version

1.0

Dependencies
Source

chtml-matcher.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 chtml-matcher.asd

Location

chtml-matcher.asd

Systems

chtml-matcher (system)

Packages

chtml-matcher-system


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

3.1.2 chtml-matcher/package.lisp

Parent

chtml-matcher (system)

Location

package.lisp

Packages

chtml-matcher


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

3.1.3 chtml-matcher/bindings.lisp

Parent

chtml-matcher (system)

Location

bindings.lisp

Exported Definitions
Internal Definitions

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

3.1.4 chtml-matcher/matcher.lisp

Parent

chtml-matcher (system)

Location

matcher.lisp

Exported Definitions
Internal Definitions

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

4 Packages

Packages are listed by definition order.


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

4.1 chtml-matcher-system

Source

chtml-matcher.asd

Use List

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

4.2 chtml-matcher

Source

package.lisp (file)

Use List
Exported Definitions
Internal Definitions

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 Macros

Macro: with-bindings VARS BINDINGS &body BODY
Package

chtml-matcher

Source

bindings.lisp (file)


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

5.1.2 Functions

Function: clear-bindings DICT

Clear all bindings

Package

chtml-matcher

Source

bindings.lisp (file)

Function: find-in-lhtml LHTML TAG ATTRIBUTES &optional N

Convenience function for generating state from an lhtml tree

Package

chtml-matcher

Source

matcher.lisp (file)

Function: get-binding VAR DICT
Package

chtml-matcher

Source

bindings.lisp (file)

Function: get-bindings DICT

Return an alist of bindings

Package

chtml-matcher

Source

bindings.lisp (file)

Function: html->lhtml HTML
Package

chtml-matcher

Source

matcher.lisp (file)

Function: lhtml->html LHTML
Package

chtml-matcher

Source

matcher.lisp (file)

Function: lhtml-constant-node-p TREE
Package

chtml-matcher

Source

matcher.lisp (file)

Function: lhtml-node-attribute-name ATTR
Package

chtml-matcher

Source

matcher.lisp (file)

Function: lhtml-node-attribute-value ATTR
Package

chtml-matcher

Source

matcher.lisp (file)

Function: lhtml-node-attributes NODE
Package

chtml-matcher

Source

matcher.lisp (file)

Function: lhtml-node-body NODE
Package

chtml-matcher

Source

matcher.lisp (file)

Function: lhtml-node-name NODE
Package

chtml-matcher

Source

matcher.lisp (file)

Function: lhtml-node-string LHTML-NODE
Package

chtml-matcher

Source

matcher.lisp (file)

Function: make-bindings &optional VARIABLE VALUE

Make bindings, optionally with a seed variable and value

Package

chtml-matcher

Source

bindings.lisp (file)

Function: match-template TEMPLATE DATUM

Top level matcher

Package

chtml-matcher

Source

matcher.lisp (file)

Function: set-binding VAR VALUE DICT
Package

chtml-matcher

Source

bindings.lisp (file)


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

5.1.3 Generic functions

Generic Function: set-bindings BIND1 BIND2
Package

chtml-matcher

Methods
Method: set-bindings (DICT1 binding-dictionary) DICT2
Source

bindings.lisp (file)

Method: set-bindings (BINDINGS cons) (DICT binding-dictionary)

Set all bindings in bindings list and return the dict. First argument dominates.

Source

bindings.lisp (file)

Method: set-bindings BINDINGS (DICT binding-dictionary)
Source

bindings.lisp (file)

Method: set-bindings BIND1 BIND2
Source

bindings.lisp (file)


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

5.1.4 Classes

Class: binding-dictionary ()
Package

chtml-matcher

Source

bindings.lisp (file)

Direct superclasses

standard-object (class)

Direct methods
Direct slots
Slot: binds
Initargs

:bindings

Readers

bindings (generic function)

Writers

(setf bindings) (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: *match-logging*
Package

chtml-matcher

Source

matcher.lisp (file)

Special Variable: *match-logging-indent*
Package

chtml-matcher

Source

matcher.lisp (file)

Special Variable: *match-logging-stream*
Package

chtml-matcher

Source

matcher.lisp (file)


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

5.2.2 Macros

Macro: assert-state ()

Test the invariant properties of the state

Package

chtml-matcher

Source

matcher.lisp (file)

Macro: match-log-message OP STATE &rest CRITERION
Package

chtml-matcher

Source

matcher.lisp (file)

Macro: tglambda ARGS MSG &body BODY
Package

chtml-matcher

Source

matcher.lisp (file)

Macro: with-body-binds (VAR STATE FN) &body BODY
Package

chtml-matcher

Source

matcher.lisp (file)

Macro: with-local-parse-state (VAR STATE) &body BODY

Make it easy to perform a non-distructive parse operation over a subtree based on the current parse state

Package

chtml-matcher

Source

matcher.lisp (file)

Macro: with-state (STATE) &body BODY
Package

chtml-matcher

Source

matcher.lisp (file)

Macro: with-template (TAG ARGS BODY) TEMPLATE &body REST

Generate local vars for various for template components

Package

chtml-matcher

Source

matcher.lisp (file)


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

5.2.3 Functions

Function: as-keyword OBJECT

Convert a string or symbol to a keyword symbol

Package

chtml-matcher

Source

matcher.lisp (file)

Function: attributes-equal-p TATTRS NATTRS

Verify that attrs1 is a proper subset of attrs2
under equalp of string form of names. Ignore variable attribute values

Package

chtml-matcher

Source

matcher.lisp (file)

Function: bind-attributes NODE ATTR-TEMPLATE BINDINGS

Given an attribute template and the current node, when bindings exist and a variable occurs in the template attribute value position, add it to the bindings

Package

chtml-matcher

Source

matcher.lisp (file)

Function: bind-node NODE VARIABLE ATTRIBUTES-TEMPLATE BINDINGS

Bind the node to the variable including attributes if wanted

Package

chtml-matcher

Source

matcher.lisp (file)

Function: bind-node-body NODE VARIABLE BINDINGS

Bind the body list to the variable in bindings

Package

chtml-matcher

Source

matcher.lisp (file)

Function: children-done-p STATE

If body is empty or has one element, return t

Package

chtml-matcher

Source

matcher.lisp (file)

Function: clean-var VAR
Package

chtml-matcher

Source

bindings.lisp (file)

Function: copy-parser-state INSTANCE
Package

chtml-matcher

Source

matcher.lisp (file)

Function: copy-state STATE

Make a duplicate of the current state

Package

chtml-matcher

Source

matcher.lisp (file)

Function: current-node STATE

Current node is always first element of the body list (Invariant)

Package

chtml-matcher

Source

matcher.lisp (file)

Function: current-path-tags STATE

List of tags from root to current

Package

chtml-matcher

Source

matcher.lisp (file)

Function: find-all-nodes STATE TAG ATTRIBUTES

Find all matching instances of a node in the tree

Package

chtml-matcher

Source

matcher.lisp (file)

Function: find-and-bind-node STATE TAG ATTRIBUTES VARIABLE BINDINGS &optional N

Find a node and bind it and it’s attributes if provided

Package

chtml-matcher

Source

matcher.lisp (file)

Function: find-child STATE TAG ATTRIBUTES

Walk the child list of the parser until a match is found. If no more children, returns nil.

Package

chtml-matcher

Source

matcher.lisp (file)

Function: find-node STATE TAG ATTRIBUTES &optional N

Find the nth occurance of tag and attributes from current state via next-node

Package

chtml-matcher

Source

matcher.lisp (file)

Function: finish-body STATE

When we’re done with the body, return to prior path, popping as necessary

Package

chtml-matcher

Source

matcher.lisp (file)

Function: get-attribute NAME ATTRIBUTES

Given a name, equalp match string forms of name and attribute nmaes

Package

chtml-matcher

Source

matcher.lisp (file)

Function: instance-variable-p SYMBOL
Package

chtml-matcher

Source

matcher.lisp (file)

Function: log-state STATE
Package

chtml-matcher

Source

matcher.lisp (file)

Function: make-local-state STATE

Make a new state object rooted at the current node

Package

chtml-matcher

Source

matcher.lisp (file)

Function: make-parser-state &key (TREE TREE) (PATH PATH) (BODY BODY)
Package

chtml-matcher

Source

matcher.lisp (file)

Function: make-state LHTML

The initial state consists of a virtual body
of which the current node is the top level node of the tree. We keep track of the root of the tree.

Package

chtml-matcher

Source

matcher.lisp (file)

Function: map-child-bindings FN STATE BODY-FNS &aux COUNT

Map fn across sequential applications of body-fns for the body list of the provided state. Moves state to end of child list and returns bindings if all match

Package

chtml-matcher

Source

matcher.lisp (file)

Function: match-log-end RESULT
Package

chtml-matcher

Source

matcher.lisp (file)

Function: next-child STATE

Linear walk of the current child list, nil on end of list

Package

chtml-matcher

Source

matcher.lisp (file)

Function: next-node STATE

Depth first tree walker. Given the current state, update the state so that (first body) contains the next node in the tree. Returns the side effected state

Package

chtml-matcher

Source

matcher.lisp (file)

Function: node-match-p STATE TAG ATTRIBUTES

Match current node to tag and attributes

Package

chtml-matcher

Source

matcher.lisp (file)

Function: parser-state-body INSTANCE
Function: (setf parser-state-body) VALUE INSTANCE
Package

chtml-matcher

Source

matcher.lisp (file)

Function: parser-state-p OBJECT
Package

chtml-matcher

Source

matcher.lisp (file)

Function: parser-state-path INSTANCE
Function: (setf parser-state-path) VALUE INSTANCE
Package

chtml-matcher

Source

matcher.lisp (file)

Function: parser-state-tree INSTANCE
Function: (setf parser-state-tree) VALUE INSTANCE
Package

chtml-matcher

Source

matcher.lisp (file)

Function: reset-state STATE

Reset state to the initial state

Package

chtml-matcher

Source

matcher.lisp (file)

Function: search-tag-p TAG

Is this tag a search variable?

Package

chtml-matcher

Source

matcher.lisp (file)

Function: start-body STATE NODE-BODY

Modify state to make the first node of the current node’s body the current node and record the state of the current body variable to the path variable. When we pop, we the next node is at the top so we push the rest of the current body

Package

chtml-matcher

Source

matcher.lisp (file)

Function: start-current-body STATE

Modify state to make the current node the first

Package

chtml-matcher

Source

matcher.lisp (file)

Function: state-done-p STATE
Package

chtml-matcher

Source

matcher.lisp (file)

Function: symbol->base VAR

Return a symbol minus the leading character

Package

chtml-matcher

Source

matcher.lisp (file)

Function: symbol->base-keyword VAR

Return a symbol minus the leading character

Package

chtml-matcher

Source

matcher.lisp (file)

Function: symbol-base VAR

Return the base string by stripping the leading character

Package

chtml-matcher

Source

matcher.lisp (file)

Function: tag-equal-p TAG1 TAG2

Ensure that two tags are equal

Package

chtml-matcher

Source

matcher.lisp (file)

Function: tgen-bind-children VARIABLE BODY-FNS

Same as tgen-merge-children but records the list of bindings from the body-fns to variable in a fresh bindings set

Package

chtml-matcher

Source

matcher.lisp (file)

Function: tgen-find TAG ATTRIBUTES BODY-FN

Find a node by tag and attributes and bind via tgen-match. State points to the child node after the bound node

Package

chtml-matcher

Source

matcher.lisp (file)

Function: tgen-find-bind VARIABLE TAG ATTRIBUTES BODY-FN

Like tgen-find, but uses tgen-match-bind

Package

chtml-matcher

Source

matcher.lisp (file)

Function: tgen-match TAG ATTRIBUTES BODY-FN

Try to match the current node to tag & attributes if body-fn is satisfied and return any bound attributes. Moves parse state to the next child node.

Package

chtml-matcher

Source

matcher.lisp (file)

Function: tgen-match-bind VARIABLE TAG ATTRIBUTES BODY-FN

Match node and add a reference to it to the bindings. Parse state is unchanged. Relies on tgen-match debug info

Package

chtml-matcher

Source

matcher.lisp (file)

Function: tgen-match-fn FN

Returns: result from calling function Side Effect: next-child

Package

chtml-matcher

Source

matcher.lisp (file)

Function: tgen-match-nth COUNT BODY-FN

Find the nth match for the provided state assuming body-fn moves the state to the next relevant node to test. Basically it’s a closure that when it’s called, recursively calls body-fn until counter hits zero and returns the last value of body-fn

Package

chtml-matcher

Source

matcher.lisp (file)

Function: tgen-match-regex VARIABLE EXPR

Returns: binding with variable matched to regex register result or nil

Package

chtml-matcher

Source

matcher.lisp (file)

Function: tgen-match-string STRING

Returns: t when it matches

Package

chtml-matcher

Source

matcher.lisp (file)

Function: tgen-match-var VARIABLE

Matches anything and binds it to variable in a fresh binding Returns: bindings

Package

chtml-matcher

Source

matcher.lisp (file)

Function: tgen-merge-children BODY-FNS

Assumes the parse tree is looking at the first element of a tag body
and that the body-fns are required sequential matches. Walks children until (current-node subtree) is null or all body-fns have been processed. Merges all the bindings returned from each body-fn. Each body-fn goes to next-child.

Package

chtml-matcher

Source

matcher.lisp (file)

Function: trace-tgen ()
Package

chtml-matcher

Source

matcher.lisp (file)

Function: variable-p SYMBOL

Identify matching variables by leading #?

Package

chtml-matcher

Source

matcher.lisp (file)


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

5.2.4 Generic functions

Generic Function: bindings OBJECT
Generic Function: (setf bindings) NEW-VALUE OBJECT
Package

chtml-matcher

Methods
Method: bindings (BINDING-DICTIONARY binding-dictionary)

automatically generated reader method

Source

bindings.lisp (file)

Method: (setf bindings) NEW-VALUE (BINDING-DICTIONARY binding-dictionary)

automatically generated writer method

Source

bindings.lisp (file)

Generic Function: gen-template-matcher HEAD TBODY
Package

chtml-matcher

Methods
Method: gen-template-matcher (HEAD symbol) TBODY
Source

matcher.lisp (file)

Method: gen-template-matcher (HEAD (eql merge)) FORMS
Source

matcher.lisp (file)

Method: gen-template-matcher (HEAD (eql all)) TBODY
Source

matcher.lisp (file)

Method: gen-template-matcher (HEAD (eql regex)) TBODY
Source

matcher.lisp (file)

Method: gen-template-matcher (HEAD (eql fn)) TBODY
Source

matcher.lisp (file)

Method: gen-template-matcher (HEAD (eql nth)) TBODY
Source

matcher.lisp (file)

Generic Function: generate-template TEMPLATE
Package

chtml-matcher

Methods
Method: generate-template TEMPLATE

Recursively walk the template, generating nested matcher functions

Source

matcher.lisp (file)


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

5.2.5 Structures

Structure: parser-state ()
Package

chtml-matcher

Source

matcher.lisp (file)

Direct superclasses

structure-object (structure)

Direct methods

print-object (method)

Direct slots
Slot: tree
Readers

parser-state-tree (function)

Writers

(setf parser-state-tree) (function)

Slot: path
Readers

parser-state-path (function)

Writers

(setf parser-state-path) (function)

Slot: body
Readers

parser-state-body (function)

Writers

(setf parser-state-body) (function)


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

Appendix A Indexes


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

A.1 Concepts

Jump to:   C   F   L  
Index Entry  Section

C
chtml-matcher.asd: The chtml-matcher<dot>asd file
chtml-matcher/bindings.lisp: The chtml-matcher/bindings<dot>lisp file
chtml-matcher/matcher.lisp: The chtml-matcher/matcher<dot>lisp file
chtml-matcher/package.lisp: The chtml-matcher/package<dot>lisp file

F
File, Lisp, chtml-matcher.asd: The chtml-matcher<dot>asd file
File, Lisp, chtml-matcher/bindings.lisp: The chtml-matcher/bindings<dot>lisp file
File, Lisp, chtml-matcher/matcher.lisp: The chtml-matcher/matcher<dot>lisp file
File, Lisp, chtml-matcher/package.lisp: The chtml-matcher/package<dot>lisp file

L
Lisp File, chtml-matcher.asd: The chtml-matcher<dot>asd file
Lisp File, chtml-matcher/bindings.lisp: The chtml-matcher/bindings<dot>lisp file
Lisp File, chtml-matcher/matcher.lisp: The chtml-matcher/matcher<dot>lisp file
Lisp File, chtml-matcher/package.lisp: The chtml-matcher/package<dot>lisp file

Jump to:   C   F   L  

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

A.2 Functions

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

(
(setf bindings): Internal generic functions
(setf bindings): Internal generic functions
(setf parser-state-body): Internal functions
(setf parser-state-path): Internal functions
(setf parser-state-tree): Internal functions

A
as-keyword: Internal functions
assert-state: Internal macros
attributes-equal-p: Internal functions

B
bind-attributes: Internal functions
bind-node: Internal functions
bind-node-body: Internal functions
bindings: Internal generic functions
bindings: Internal generic functions

C
children-done-p: Internal functions
clean-var: Internal functions
clear-bindings: Exported functions
copy-parser-state: Internal functions
copy-state: Internal functions
current-node: Internal functions
current-path-tags: Internal functions

F
find-all-nodes: Internal functions
find-and-bind-node: Internal functions
find-child: Internal functions
find-in-lhtml: Exported functions
find-node: Internal functions
finish-body: Internal functions
Function, (setf parser-state-body): Internal functions
Function, (setf parser-state-path): Internal functions
Function, (setf parser-state-tree): Internal functions
Function, as-keyword: Internal functions
Function, attributes-equal-p: Internal functions
Function, bind-attributes: Internal functions
Function, bind-node: Internal functions
Function, bind-node-body: Internal functions
Function, children-done-p: Internal functions
Function, clean-var: Internal functions
Function, clear-bindings: Exported functions
Function, copy-parser-state: Internal functions
Function, copy-state: Internal functions
Function, current-node: Internal functions
Function, current-path-tags: Internal functions
Function, find-all-nodes: Internal functions
Function, find-and-bind-node: Internal functions
Function, find-child: Internal functions
Function, find-in-lhtml: Exported functions
Function, find-node: Internal functions
Function, finish-body: Internal functions
Function, get-attribute: Internal functions
Function, get-binding: Exported functions
Function, get-bindings: Exported functions
Function, html->lhtml: Exported functions
Function, instance-variable-p: Internal functions
Function, lhtml->html: Exported functions
Function, lhtml-constant-node-p: Exported functions
Function, lhtml-node-attribute-name: Exported functions
Function, lhtml-node-attribute-value: Exported functions
Function, lhtml-node-attributes: Exported functions
Function, lhtml-node-body: Exported functions
Function, lhtml-node-name: Exported functions
Function, lhtml-node-string: Exported functions
Function, log-state: Internal functions
Function, make-bindings: Exported functions
Function, make-local-state: Internal functions
Function, make-parser-state: Internal functions
Function, make-state: Internal functions
Function, map-child-bindings: Internal functions
Function, match-log-end: Internal functions
Function, match-template: Exported functions
Function, next-child: Internal functions
Function, next-node: Internal functions
Function, node-match-p: Internal functions
Function, parser-state-body: Internal functions
Function, parser-state-p: Internal functions
Function, parser-state-path: Internal functions
Function, parser-state-tree: Internal functions
Function, reset-state: Internal functions
Function, search-tag-p: Internal functions
Function, set-binding: Exported functions
Function, start-body: Internal functions
Function, start-current-body: Internal functions
Function, state-done-p: Internal functions
Function, symbol->base: Internal functions
Function, symbol->base-keyword: Internal functions
Function, symbol-base: Internal functions
Function, tag-equal-p: Internal functions
Function, tgen-bind-children: Internal functions
Function, tgen-find: Internal functions
Function, tgen-find-bind: Internal functions
Function, tgen-match: Internal functions
Function, tgen-match-bind: Internal functions
Function, tgen-match-fn: Internal functions
Function, tgen-match-nth: Internal functions
Function, tgen-match-regex: Internal functions
Function, tgen-match-string: Internal functions
Function, tgen-match-var: Internal functions
Function, tgen-merge-children: Internal functions
Function, trace-tgen: Internal functions
Function, variable-p: Internal functions

G
gen-template-matcher: Internal generic functions
gen-template-matcher: Internal generic functions
gen-template-matcher: Internal generic functions
gen-template-matcher: Internal generic functions
gen-template-matcher: Internal generic functions
gen-template-matcher: Internal generic functions
gen-template-matcher: Internal generic functions
generate-template: Internal generic functions
generate-template: Internal generic functions
Generic Function, (setf bindings): Internal generic functions
Generic Function, bindings: Internal generic functions
Generic Function, gen-template-matcher: Internal generic functions
Generic Function, generate-template: Internal generic functions
Generic Function, set-bindings: Exported generic functions
get-attribute: Internal functions
get-binding: Exported functions
get-bindings: Exported functions

H
html->lhtml: Exported functions

I
instance-variable-p: Internal functions

L
lhtml->html: Exported functions
lhtml-constant-node-p: Exported functions
lhtml-node-attribute-name: Exported functions
lhtml-node-attribute-value: Exported functions
lhtml-node-attributes: Exported functions
lhtml-node-body: Exported functions
lhtml-node-name: Exported functions
lhtml-node-string: Exported functions
log-state: Internal functions

M
Macro, assert-state: Internal macros
Macro, match-log-message: Internal macros
Macro, tglambda: Internal macros
Macro, with-bindings: Exported macros
Macro, with-body-binds: Internal macros
Macro, with-local-parse-state: Internal macros
Macro, with-state: Internal macros
Macro, with-template: Internal macros
make-bindings: Exported functions
make-local-state: Internal functions
make-parser-state: Internal functions
make-state: Internal functions
map-child-bindings: Internal functions
match-log-end: Internal functions
match-log-message: Internal macros
match-template: Exported functions
Method, (setf bindings): Internal generic functions
Method, bindings: Internal generic functions
Method, gen-template-matcher: Internal generic functions
Method, gen-template-matcher: Internal generic functions
Method, gen-template-matcher: Internal generic functions
Method, gen-template-matcher: Internal generic functions
Method, gen-template-matcher: Internal generic functions
Method, gen-template-matcher: Internal generic functions
Method, generate-template: Internal generic functions
Method, set-bindings: Exported generic functions
Method, set-bindings: Exported generic functions
Method, set-bindings: Exported generic functions
Method, set-bindings: Exported generic functions

N
next-child: Internal functions
next-node: Internal functions
node-match-p: Internal functions

P
parser-state-body: Internal functions
parser-state-p: Internal functions
parser-state-path: Internal functions
parser-state-tree: Internal functions

R
reset-state: Internal functions

S
search-tag-p: Internal functions
set-binding: Exported functions
set-bindings: Exported generic functions
set-bindings: Exported generic functions
set-bindings: Exported generic functions
set-bindings: Exported generic functions
set-bindings: Exported generic functions
start-body: Internal functions
start-current-body: Internal functions
state-done-p: Internal functions
symbol->base: Internal functions
symbol->base-keyword: Internal functions
symbol-base: Internal functions

T
tag-equal-p: Internal functions
tgen-bind-children: Internal functions
tgen-find: Internal functions
tgen-find-bind: Internal functions
tgen-match: Internal functions
tgen-match-bind: Internal functions
tgen-match-fn: Internal functions
tgen-match-nth: Internal functions
tgen-match-regex: Internal functions
tgen-match-string: Internal functions
tgen-match-var: Internal functions
tgen-merge-children: Internal functions
tglambda: Internal macros
trace-tgen: Internal functions

V
variable-p: Internal functions

W
with-bindings: Exported macros
with-body-binds: Internal macros
with-local-parse-state: Internal macros
with-state: Internal macros
with-template: Internal macros

Jump to:   (  
A   B   C   F   G   H   I   L   M   N   P   R   S   T   V   W  

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

A.3 Variables

Jump to:   *  
B   P   S   T  
Index Entry  Section

*
*match-logging*: Internal special variables
*match-logging-indent*: Internal special variables
*match-logging-stream*: Internal special variables

B
binds: Exported classes
body: Internal structures

P
path: Internal structures

S
Slot, binds: Exported classes
Slot, body: Internal structures
Slot, path: Internal structures
Slot, tree: Internal structures
Special Variable, *match-logging*: Internal special variables
Special Variable, *match-logging-indent*: Internal special variables
Special Variable, *match-logging-stream*: Internal special variables

T
tree: Internal structures

Jump to:   *  
B   P   S   T  

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

A.4 Data types

Jump to:   B   C   P   S  
Index Entry  Section

B
binding-dictionary: Exported classes

C
chtml-matcher: The chtml-matcher system
chtml-matcher: The chtml-matcher package
chtml-matcher-system: The chtml-matcher-system package
Class, binding-dictionary: Exported classes

P
Package, chtml-matcher: The chtml-matcher package
Package, chtml-matcher-system: The chtml-matcher-system package
parser-state: Internal structures

S
Structure, parser-state: Internal structures
System, chtml-matcher: The chtml-matcher system

Jump to:   B   C   P   S