The chtml-matcher Reference Manual

Table of Contents

The chtml-matcher Reference Manual

This is the chtml-matcher Reference Manual, version 1.0, generated automatically by Declt version 3.0 "Montgomery Scott" on Wed Nov 04 11:52:44 2020 GMT+0.

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.

2 Systems

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

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

• closure-html
• stdutils
• f-underscore
• cl-ppcre

Source

chtml-matcher.asd (file)

Components

• package.lisp (file)
• bindings.lisp (file)
• matcher.lisp (file)

3 Files

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

3.1 Lisp

3.1.1 chtml-matcher.asd

Location

chtml-matcher.asd

Systems

chtml-matcher (system)

Packages

chtml-matcher-system

3.1.2 chtml-matcher/package.lisp

Parent

chtml-matcher (system)

Location

package.lisp

Packages

chtml-matcher

3.1.3 chtml-matcher/bindings.lisp

Parent

chtml-matcher (system)

Location

bindings.lisp

Exported Definitions

• binding-dictionary (class)
• clear-bindings (function)
• get-binding (function)
• get-bindings (function)
• make-bindings (function)
• set-binding (function)
• set-bindings (method)
• set-bindings (method)
• set-bindings (method)
• set-bindings (method)
• with-bindings (macro)

Internal Definitions

• bindings (method)
• (setf bindings) (method)
• clean-var (function)

3.1.4 chtml-matcher/matcher.lisp

Parent

chtml-matcher (system)

Location

matcher.lisp

Exported Definitions

• find-in-lhtml (function)
• html->lhtml (function)
• lhtml->html (function)
• lhtml-constant-node-p (function)
• lhtml-node-attribute-name (function)
• lhtml-node-attribute-value (function)
• lhtml-node-attributes (function)
• lhtml-node-body (function)
• lhtml-node-name (function)
• lhtml-node-string (function)
• match-template (function)

Internal Definitions

• *match-logging* (special variable)
• *match-logging-indent* (special variable)
• *match-logging-stream* (special variable)
• as-keyword (function)
• assert-state (macro)
• attributes-equal-p (function)
• bind-attributes (function)
• bind-node (function)
• bind-node-body (function)
• children-done-p (function)
• copy-parser-state (function)
• copy-state (function)
• current-node (function)
• current-path-tags (function)
• find-all-nodes (function)
• find-and-bind-node (function)
• find-child (function)
• find-node (function)
• finish-body (function)
• gen-template-matcher (method)
• gen-template-matcher (method)
• gen-template-matcher (method)
• gen-template-matcher (method)
• gen-template-matcher (method)
• gen-template-matcher (method)
• generate-template (method)
• get-attribute (function)
• instance-variable-p (function)
• log-state (function)
• make-local-state (function)
• make-parser-state (function)
• make-state (function)
• map-child-bindings (function)
• match-log-end (function)
• match-log-message (macro)
• next-child (function)
• next-node (function)
• node-match-p (function)
• parser-state (structure)
• parser-state-body (function)
• (setf parser-state-body) (function)
• parser-state-p (function)
• parser-state-path (function)
• (setf parser-state-path) (function)
• parser-state-tree (function)
• (setf parser-state-tree) (function)
• reset-state (function)
• search-tag-p (function)
• start-body (function)
• start-current-body (function)
• state-done-p (function)
• symbol->base (function)
• symbol->base-keyword (function)
• symbol-base (function)
• tag-equal-p (function)
• tgen-bind-children (function)
• tgen-find (function)
• tgen-find-bind (function)
• tgen-match (function)
• tgen-match-bind (function)
• tgen-match-fn (function)
• tgen-match-nth (function)
• tgen-match-regex (function)
• tgen-match-string (function)
• tgen-match-var (function)
• tgen-merge-children (function)
• tglambda (macro)
• trace-tgen (function)
• variable-p (function)
• with-body-binds (macro)
• with-local-parse-state (macro)
• with-state (macro)
• with-template (macro)

4 Packages

Packages are listed by definition order.

4.1 chtml-matcher-system

Source

chtml-matcher.asd

Use List

• asdf/interface
• common-lisp

4.2 chtml-matcher

Source

package.lisp (file)

Use List

• f-underscore
• stdutils
• common-lisp

Exported Definitions

• binding-dictionary (class)
• clear-bindings (function)
• find-in-lhtml (function)
• get-binding (function)
• get-bindings (function)
• html->lhtml (function)
• lhtml->html (function)
• lhtml-constant-node-p (function)
• lhtml-node-attribute-name (function)
• lhtml-node-attribute-value (function)
• lhtml-node-attributes (function)
• lhtml-node-body (function)
• lhtml-node-name (function)
• lhtml-node-string (function)
• make-bindings (function)
• match-template (function)
• set-binding (function)
• set-bindings (generic function)
• set-bindings (method)
• set-bindings (method)
• set-bindings (method)
• set-bindings (method)
• with-bindings (macro)

Internal Definitions

• *match-logging* (special variable)
• *match-logging-indent* (special variable)
• *match-logging-stream* (special variable)
• as-keyword (function)
• assert-state (macro)
• attributes-equal-p (function)
• bind-attributes (function)
• bind-node (function)
• bind-node-body (function)
• bindings (generic function)
• bindings (method)
• (setf bindings) (method)
• (setf bindings) (generic function)
• children-done-p (function)
• clean-var (function)
• copy-parser-state (function)
• copy-state (function)
• current-node (function)
• current-path-tags (function)
• find-all-nodes (function)
• find-and-bind-node (function)
• find-child (function)
• find-node (function)
• finish-body (function)
• gen-template-matcher (generic function)
• gen-template-matcher (method)
• gen-template-matcher (method)
• gen-template-matcher (method)
• gen-template-matcher (method)
• gen-template-matcher (method)
• gen-template-matcher (method)
• generate-template (generic function)
• generate-template (method)
• get-attribute (function)
• instance-variable-p (function)
• log-state (function)
• make-local-state (function)
• make-parser-state (function)
• make-state (function)
• map-child-bindings (function)
• match-log-end (function)
• match-log-message (macro)
• next-child (function)
• next-node (function)
• node-match-p (function)
• parser-state (structure)
• parser-state-body (function)
• (setf parser-state-body) (function)
• parser-state-p (function)
• parser-state-path (function)
• (setf parser-state-path) (function)
• parser-state-tree (function)
• (setf parser-state-tree) (function)
• reset-state (function)
• search-tag-p (function)
• start-body (function)
• start-current-body (function)
• state-done-p (function)
• symbol->base (function)
• symbol->base-keyword (function)
• symbol-base (function)
• tag-equal-p (function)
• tgen-bind-children (function)
• tgen-find (function)
• tgen-find-bind (function)
• tgen-match (function)
• tgen-match-bind (function)
• tgen-match-fn (function)
• tgen-match-nth (function)
• tgen-match-regex (function)
• tgen-match-string (function)
• tgen-match-var (function)
• tgen-merge-children (function)
• tglambda (macro)
• trace-tgen (function)
• variable-p (function)
• with-body-binds (macro)
• with-local-parse-state (macro)
• with-state (macro)
• with-template (macro)

5 Definitions

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

5.1 Exported definitions

5.1.1 Macros

Macro: with-bindings VARS BINDINGS &body BODY

Package

chtml-matcher

Source

bindings.lisp (file)

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)

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)

5.1.4 Classes

Class: binding-dictionary ()

Package

chtml-matcher

Source

bindings.lisp (file)

Direct superclasses

standard-object (class)

Direct methods

• set-bindings (method)
• set-bindings (method)
• set-bindings (method)
• print-object (method)
• bindings (method)
• bindings (method)

Direct slots

Slot: binds

Initargs

:bindings

Readers

bindings (generic function)

Writers

(setf bindings) (generic function)

5.2 Internal definitions

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)

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)

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)

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)

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)

Appendix A Indexes

A.1 Concepts

A.2 Functions

A.3 Variables

A.4 Data types