This is the parser-combinators Reference Manual, version 0, generated automatically by Declt version 4.0 beta 2 "William Riker" on Sun Dec 15 05:15:15 2024 GMT+0.
parser-combinators/parser-combinators.asdparser-combinators/package.lispparser-combinators/queue.lispparser-combinators/contexts.lispparser-combinators/lazy.lispparser-combinators/cache.lispparser-combinators/basic.lispparser-combinators/ensure-parser.lispparser-combinators/combinators.lispparser-combinators/primitives.lispparser-combinators/parsers.lispparser-combinators/memoize.lispparser-combinators/recurse.lispparser-combinators/greedy.lispparser-combinators/token-parsers.lispThe main system appears first, followed by any subsystem dependency.
parser-combinatorsAn implementation of parser combinators for Common Lisp
Jakub Higersberger <ramarren@gmail.com>
Jakub Higersberger <ramarren@gmail.com>
BSD-style
0
iterate (system).
alexandria (system).
package.lisp (file).
queue.lisp (file).
contexts.lisp (file).
lazy.lisp (file).
cache.lisp (file).
basic.lisp (file).
ensure-parser.lisp (file).
combinators.lisp (file).
primitives.lisp (file).
parsers.lisp (file).
memoize.lisp (file).
recurse.lisp (file).
greedy.lisp (file).
token-parsers.lisp (file).
Files are sorted by type and then listed depth-first from the systems components trees.
parser-combinators/parser-combinators.asdparser-combinators/package.lispparser-combinators/queue.lispparser-combinators/contexts.lispparser-combinators/lazy.lispparser-combinators/cache.lispparser-combinators/basic.lispparser-combinators/ensure-parser.lispparser-combinators/combinators.lispparser-combinators/primitives.lispparser-combinators/parsers.lispparser-combinators/memoize.lispparser-combinators/recurse.lispparser-combinators/greedy.lispparser-combinators/token-parsers.lispparser-combinators/parser-combinators.asdparser-combinators (system).
parser-combinators/queue.lisppackage.lisp (file).
parser-combinators (system).
empty-p (generic function).
head-of (reader method).
(setf head-of) (writer method).
make-queue (function).
peek (generic function).
peek-back (generic function).
pop-front (generic function).
push-back (generic function).
push-front (generic function).
queue (class).
queue-to-list (function).
size-of (reader method).
(setf size-of) (writer method).
tail-of (reader method).
(setf tail-of) (writer method).
parser-combinators/contexts.lisppackage.lisp (file).
parser-combinators (system).
*default-context-cache* (special variable).
common-of (reader method).
(setf common-of) (writer method).
context-equal (generic function).
context-interval (generic function).
context-of (reader method).
(setf context-of) (writer method).
copy-context (macro).
end-context (class).
end-context-p (generic function).
initialize-instance (method).
make-context (generic function).
make-context-at-position (generic function).
position-of (method).
position-of (reader method).
(setf position-of) (writer method).
storage-of (method).
storage-of (reader method).
storage-of (reader method).
(setf storage-of) (writer method).
(setf storage-of) (writer method).
tags-of (reader method).
(setf tags-of) (writer method).
vector-context (class).
*tag-stack* (special variable).
cache-of (method).
cache-of (reader method).
(setf cache-of) (writer method).
context (class).
context-common (class).
context-front (class).
context-greater (generic function).
context-next (generic function).
context-peek (generic function).
front-of (method).
front-of (reader method).
(setf front-of) (method).
(setf front-of) (writer method).
length-of (method).
length-of (reader method).
(setf length-of) (writer method).
list-context (class).
make-cache (function).
note-position (function).
seen-positions-of (method).
seen-postions-of (reader method).
(setf seen-postions-of) (writer method).
update-front-context (generic function).
vector-context-common (class).
parser-combinators/lazy.lisppackage.lisp (file).
parser-combinators (system).
delay (macro).
force (function).
promise (class).
thunk-of (reader method).
(setf thunk-of) (writer method).
value-of (reader method).
(setf value-of) (writer method).
parser-combinators/cache.lisppackage.lisp (file).
parser-combinators (system).
cached-arguments? (macro).
cached? (macro).
def-cached-arg-parser (macro).
def-cached-parser (macro).
drop-parser-cache (function).
*parser-cache* (special variable).
parser-combinators/basic.lisppackage.lisp (file).
lazy.lisp (file).
parser-combinators (system).
current-result (function).
gather-results (function).
make-parse-result (function).
mdo (macro).
next-result (function).
parse-sequence (function).
parse-sequence* (function).
parse-string (function).
parse-string* (function).
parser-possibility (class).
storage-of (reader method).
(setf storage-of) (writer method).
suffix-of (reader method).
(setf suffix-of) (writer method).
tree-of (reader method).
(setf tree-of) (writer method).
*memo-table* (special variable).
continuation-of (reader method).
(setf continuation-of) (writer method).
copy-parse-result (function).
counter-of (reader method).
(setf counter-of) (writer method).
current-of (reader method).
(setf current-of) (writer method).
do-notation (function).
nth-result (generic function).
parse-result (class).
parse-result-store (class).
store-of (reader method).
(setf store-of) (writer method).
parser-combinators/ensure-parser.lisppackage.lisp (file).
contexts.lisp (file).
basic.lisp (file).
cache.lisp (file).
parser-combinators (system).
char? (function).
define-oneshot-result (macro).
sat (function).
string? (function).
string?-using-context (generic function).
char-equal? (function).
ensure-parser (function).
with-parsers (macro).
parser-combinators/combinators.lisppackage.lisp (file).
basic.lisp (file).
lazy.lisp (file).
ensure-parser.lisp (file).
parser-combinators (system).
bind (function).
execute-bind (function).
execute-choice (function).
parser-combinators/primitives.lisppackage.lisp (file).
lazy.lisp (file).
basic.lisp (file).
combinators.lisp (file).
contexts.lisp (file).
cache.lisp (file).
parser-combinators (system).
cut? (function).
parser-combinators/parsers.lisppackage.lisp (file).
basic.lisp (file).
primitives.lisp (file).
combinators.lisp (file).
ensure-parser.lisp (file).
cache.lisp (file).
parser-combinators (system).
atleast? (function).
atmost? (function).
between? (function).
bracket? (function).
breadth? (function).
chainl1? (function).
chainl? (function).
chainr1? (function).
chainr? (function).
chook? (function).
chookahead? (function).
context? (function).
cut-tag? (function).
end? (function).
except? (function).
expression? (function).
find-after-collect? (function).
find-after? (function).
find-before? (function).
find? (function).
hook? (function).
many1? (function).
many? (function).
named-seq? (macro).
named? (macro).
nested? (function).
opt? (function).
sepby1-cons? (function).
sepby1? (function).
sepby? (function).
seq-list? (function).
tag? (function).
times? (function).
validate? (function).
%named-seq? (macro).
*cut-tag* (special variable).
count-of (reader method).
(setf count-of) (writer method).
emit-of (reader method).
(setf emit-of) (writer method).
gather-nodes (function).
result-node (class).
suffix-continuation-of (reader method).
(setf suffix-continuation-of) (writer method).
up-of (reader method).
(setf up-of) (writer method).
parser-combinators/memoize.lisppackage.lisp (file).
basic.lisp (file).
ensure-parser.lisp (file).
parser-combinators (system).
memoize? (function).
parser-combinators/recurse.lisppackage.lisp (file).
basic.lisp (file).
ensure-parser.lisp (file).
parser-combinators (system).
curtail? (macro).
*curtail* (special variable).
parser-combinators/greedy.lisppackage.lisp (file).
basic.lisp (file).
primitives.lisp (file).
combinators.lisp (file).
ensure-parser.lisp (file).
cache.lisp (file).
parser-combinators (system).
atleast* (function).
atmost* (function).
before* (function).
between* (function).
chainl* (function).
chainl1* (function).
chainr* (function).
chainr1* (function).
expression* (function).
find* (function).
find-after* (function).
find-after-collect* (function).
find-before* (function).
find-before-token* (function).
gather-before-token* (function).
gather-if-not* (function).
gather-if-not*-using-context (generic function).
int* (function).
many* (function).
many1* (function).
mdo* (macro).
named-seq* (macro).
nat* (function).
opt* (function).
pure-word* (function).
sepby* (function).
sepby1* (function).
seq-list* (function).
whitespace* (function).
word* (function).
gather-if* (function).
times* (function).
parser-combinators/token-parsers.lisppackage.lisp (file).
basic.lisp (file).
primitives.lisp (file).
combinators.lisp (file).
parsers.lisp (file).
greedy.lisp (file).
parser-combinators (system).
Packages are listed by definition order.
parser-combinatorsalexandria.
common-lisp.
iterate.
*default-context-cache* (special variable).
alphanum? (function).
atleast* (function).
atleast? (function).
atmost* (function).
atmost? (function).
before* (function).
between* (function).
between? (function).
bracket? (function).
breadth? (function).
cached-arguments? (macro).
cached? (macro).
chainl* (function).
chainl1* (function).
chainl1? (function).
chainl? (function).
chainr* (function).
chainr1* (function).
chainr1? (function).
chainr? (function).
char? (function).
choice (function).
choice1 (function).
choices (function).
choices1 (function).
chook? (function).
chookahead? (function).
common-of (generic reader).
(setf common-of) (generic writer).
context-equal (generic function).
context-interval (generic function).
context-of (generic reader).
(setf context-of) (generic writer).
context? (function).
copy-context (macro).
current-result (function).
curtail? (macro).
cut-tag? (function).
def-cached-arg-parser (macro).
def-cached-parser (macro).
define-oneshot-result (macro).
delayed? (macro).
digit? (function).
drop-parser-cache (function).
end-context (class).
end-context-p (generic function).
end? (function).
except? (function).
expression* (function).
expression? (function).
find* (function).
find-after* (function).
find-after-collect* (function).
find-after-collect? (function).
find-after? (function).
find-before* (function).
find-before-token* (function).
find-before? (function).
find? (function).
force? (function).
gather-before-token* (function).
gather-if-not* (function).
gather-if-not*-using-context (generic function).
gather-results (function).
hook? (function).
int* (function).
int? (function).
item (function).
letter? (function).
lower? (function).
make-context (generic function).
make-context-at-position (generic function).
make-parse-result (function).
many* (function).
many1* (function).
many1? (function).
many? (function).
mdo (macro).
mdo* (macro).
memoize? (function).
named-seq* (macro).
named-seq? (macro).
named? (macro).
nat* (function).
nat? (function).
nested? (function).
next-result (function).
opt* (function).
opt? (function).
parse-sequence (function).
parse-sequence* (function).
parse-string (function).
parse-string* (function).
parser-possibility (class).
position-of (generic function).
(setf position-of) (generic writer).
pure-word* (function).
pure-word? (function).
quoted? (function).
result (function).
sat (function).
sepby* (function).
sepby1* (function).
sepby1-cons? (function).
sepby1? (function).
sepby? (function).
seq-list* (function).
seq-list? (function).
storage-of (generic function).
(setf storage-of) (generic writer).
string? (function).
string?-using-context (generic function).
suffix-of (generic reader).
(setf suffix-of) (generic writer).
tag? (function).
tags-of (generic reader).
(setf tags-of) (generic writer).
times? (function).
tree-of (generic reader).
(setf tree-of) (generic writer).
upper? (function).
validate? (function).
vector-context (class).
whitespace* (function).
whitespace? (function).
word* (function).
word? (function).
zero (function).
%named-seq? (macro).
*curtail* (special variable).
*cut-tag* (special variable).
*memo-table* (special variable).
*parser-cache* (special variable).
*tag-stack* (special variable).
bind (function).
cache-of (generic function).
(setf cache-of) (generic writer).
char-equal? (function).
context (class).
context-common (class).
context-front (class).
context-greater (generic function).
context-next (generic function).
context-peek (generic function).
continuation-of (generic reader).
(setf continuation-of) (generic writer).
copy-parse-result (function).
count-of (generic reader).
(setf count-of) (generic writer).
counter-of (generic reader).
(setf counter-of) (generic writer).
current-of (generic reader).
(setf current-of) (generic writer).
cut? (function).
delay (macro).
do-notation (function).
emit-of (generic reader).
(setf emit-of) (generic writer).
empty-p (generic function).
ensure-parser (function).
execute-bind (function).
execute-choice (function).
force (function).
front-of (generic function).
(setf front-of) (generic function).
gather-if* (function).
gather-nodes (function).
head-of (generic reader).
(setf head-of) (generic writer).
length-of (generic function).
(setf length-of) (generic writer).
list-context (class).
make-cache (function).
make-queue (function).
note-position (function).
nth-result (generic function).
parse-result (class).
parse-result-store (class).
peek (generic function).
peek-back (generic function).
pop-front (generic function).
promise (class).
push-back (generic function).
push-front (generic function).
queue (class).
queue-to-list (function).
result-node (class).
seen-positions-of (generic function).
seen-postions-of (generic reader).
(setf seen-postions-of) (generic writer).
size-of (generic reader).
(setf size-of) (generic writer).
store-of (generic reader).
(setf store-of) (generic writer).
suffix-continuation-of (generic reader).
(setf suffix-continuation-of) (generic writer).
tail-of (generic reader).
(setf tail-of) (generic writer).
thunk-of (generic reader).
(setf thunk-of) (generic writer).
times* (function).
up-of (generic reader).
(setf up-of) (generic writer).
update-front-context (generic function).
value-of (generic reader).
(setf value-of) (generic writer).
vector-context-common (class).
with-parsers (macro).
Definitions are sorted by export status, category, package, and then by lexicographic order.
Parser modifier macro: cache parser as label with argument list equal under equal in global cache.
Parser modifier macro: cache parser as label in global cache.
Parser modifier: add recursion curtailing to PARSER, naming the curtailed parser NAME. Left recursive parser parser will only be nested once per remaining length of the input string. Note: this is only necessary for a limited class of left recursive parsers. Non-left recursive parsers should be implemented using just ‘named?‘, and most left-recursive parsers using that in combination with ‘chainl1?‘. Also see ‘expression?‘.
Define cached parser with arguments.
Define cached parser of no arguments.
Parser modifier macro: parser will be built when called. This is necessary for left-recursive parsers.
Combinator: use do-like notation to sequentially link parsers. (<- name parser) allows capturing of return values.
Like NAMED-SEQ*, but with MDO syntax: the last element must be a parser.
Non-backtracking parser: This is similar to MDO, except that constructed parsers cannot depend on
the results of previous ones and the final form is not used as a parser, but is automatically used
to construct the result. All names bound using the (<- name parser) construct are only available in
that final form.
This parser generator is useful when full generality of MDO is not necessary, as it is implemented non-recursively and has better memory performance.
Parser: This is similar to MDO, except that constructed parsers cannot depend on the results of previous ones and the final form is not used as a parser, but is automatically used to construct the result. All names bound using the (<- name parser) construct are only available in that final form.
This parser generator is useful when full generality of MDO is not necessary, as it is implemented non-recursively and has better memory performance.
Parser macro: give BODY a NAME, so it can refer to itself without causing generator recursion.
Parser: accept alphanumeric character
Non-backtracking parser: accept as many as possible and at least count of parser
Parser: accept at least count expressions accepted by parser
Non-backtracking parser: accept as many as possible but at most count of parser
Parser: accept at most count expressions accepted by parser
Non-backtracking parser: Find a p before q, doesn’t consume q.
Non-backtracking parser: find the first, longest chain of expression accepted by parser of length between min and max
Parser: accept between min and max expressions accepted by parser
Parser: accept parser-center bracketed by parser-open and parser-close
Parser: like between? but breadth first (shortest matches first)
Non-backtracking parser: like chainl1*, but will return v if no p can be parsed
Non-backtracking parser: accept as many as possible, but at least one of p, reduced by result of op with left associativity
Parser: accept one or more p reduced by result of op with left associativity
Parser: like chainl1?, but will return v if no p can be parsed
Non-backtracking parser: like chainr1*, but will return v if no p can be parsed
Non-backtracking parser: accept as many as possible, but at least one of p, reduced by result of op with right associativity
Parser: accept one or more p reduced by result of op with right associativity
Parser: like chainr1?, but will return v if no p can be parsed
Parser: accept token eql to argument
Combinator: all alternatives from two parsers
Combinator: one alternative from two parsers
Combinator: all alternatives from multiple parsers
Combinator: one alternative from multiple parsers
Parser: return result if p matches
Parser: return result if p matches, but do no advance
Parser: return current context without consuming any input
Parser modifier: add formatted string to tag stack for given parser, suppressing all lower level parsers.
Parser: accept digit character
Parser: matches end of input, returns t
Parser: match p unless q matches.
Non-backtracking parser: Reduce a sequence of terms with unary/binary operators with precedence. OPERATORS is a list of (op-parser :left/:right/:unary), where OP-PARSER is a parser consuming an operator and returning a reduction function. Highest precedence first.
Parser: Reduce a sequence of terms with unary/binary operators with precedence.
OPERATORS is a list of (op-parser :left/:right/:unary), where OP-PARSER is a parser consuming
an operator and returning a reduction function. Highest precedence first.
Non-backtracking parser: Find first q
Non-backtracking parser: Find first q after some sequence of p.
Non-backtracking parser: Find first q after some sequence of p. Return cons of list of p-results and q
Parser: Find q after some sequence of p, earliest match first. Return cons of list of p-results and q
Parser: Find q after some sequence of p, earliest matches first.
Non-backtracking parser: Find a sequence of p terminated by q, doesn’t consume q.
Non-backtracking parser: Find a sequence of p terminated by single token q, which is not consumed.
Parser: Find a sequence of p terminated by q, doesn’t consume q.
Parser: Find q, earliest match first.
Parser modifier: fully realize result from parser
Non-backtracking parser: Find a sequence of tokens terminated by single token, which is not consumed.
Non-backtracking parser: Find a sequence of tokens terminated by one for which predicate returns true, which is not consumed.
Obtain all of the results within PARSE-RESULT, starting with the current one, potentially realising the non-realised ones in the backing store.
Parser: apply function to result of p
Non-backtracking parser: accept integer, consuming as many digits as possible
Parser: accept an integer, return as integer.
Primitive parser: consume item from input and return it.
Parser: accept alphabetic character
Parser: accept lowercase character
Document all potential results of CONTINUATION as a PARSE-RESULT object.
Non-backtracking parser: collect as many of first result of parser as possible
Non-backtracking parser: accept as many as possible, and at least one, of parser
Parser: accept one or more of expression accepted by parser
Parser: accept zero or more repetitions of expression accepted by parser
Parser modifier: memoizes the parser, which if called again at a given position it will return a result immediately. LABEL is used for memoization key, use explicit one if the parser is used in multiple places.
Non-backtracking parser: accept natural number, consuming as many digits as possible
Parser: accept natural numbers
Parser: parse a sequence of p, like between?, but with p possibly nested in brackets.
Non-backtracking parser: result of p or nil
Parser: result of p or nil
Parse a sequence (where a sequence is any object which implementes CONTEXT interface), return a PARSE-RESULT object. All returned values may share structure.
Parse a sequence (where a sequence is any object which implementes CONTEXT interface) and
return as multiple values the first result, whether the parse was incomplete, whether it was
successful, the context front and the position frequency table. The context front is an object
containing the context which most advances the input sequence and a list of lists of parser
tags which were current at that point, which allows approximate error reporting. It will be
NIL if the parse is successful and complete. The position frequency table serves profiling
needs and maps sequence positions to the number of times a new context was created at that
position – which should provide a rough hint at how problematic that particular spot is.
If COMPLETE is T, return the first parse to consume the input
completely. If COMPLETE is :FIRST return the first result only when it the whole input was consumed,
or immediately return nil.
Synonym for parse-sequence. Parse a string, return a PARSE-RESULT object. All returned values may share structure.
Synonym for parse-sequence*. Parse a string and return as multiple values the first result,
whether the parse was incomplete, whether it was successful, the context front, and the
position frequency table. The context front is an object containing the context which most
advances the input sequence and a list of lists of parser tags which were current at that
point, which allows approximate error reporting. It will be NIL if the parse is successful and
complete. The position frequency table serves profiling needs and maps sequence positions to
the number of times a new context was created at that position – which should provide a rough
hint at how problematic that particular spot is.
If COMPLETE is T, return the first parse to consume the input
completely. If COMPLETE is :FIRST return the first result only when it the whole input was consumed,
or immediately return nil.
Parser: accept a string of alphabetic characters
Parser: accept a string of alphabetic characters
Parser: accept a string delimited with quote-char, possibly escaped by escape-char, possibly including quotation chars.
Primitive parser: return v, leaves input unmodified.
Parser: return a token satisfying a predicate.
Non-backtracking parser: accept as many as possible of parser-item separated by parser-separator.
Non-backtracking parser: accept as many as possible of parser-item separated by parser-separator, but at least one.
Parser: as sepby1, but returns a list of a result of p and pairs (op p). Mainly a component parser for chains
Parser: accept at least one of parser-item separated by parser-separator
Parser: accept zero or more of parser-item separated by parser-separator
Non-backtracking parser: Return a list of result of PARSERS.
Parser: Return a list of results of PARSERS.
Non-backtracking parser: accept a sequence of elements with equality tested by TEST.
Parser modifier: add formatted string to tag stack for given parser.
Parser: accept exactly count expressions accepted by parser
Parser: accept uppercase character
Parser: call validation-function on result of (funcall pre-hook p), fail if it returns nil, otherwhise return it as a result
Non-backtracking parser: accept a sequence of whitespace characters.
Parser: accept a sequence of whitespace characters.
Parser: accept a string of alphanumeric characters
Parser: accept a string of alphanumeric characters
Primitive parser: parsing failure
vector-context) (context2 end-context) &optional result-type) ¶vector-context) (context2 vector-context) &optional result-type) ¶context-front)) ¶automatically generated reader method
context-front)) ¶automatically generated writer method
end-context)) ¶Parser gather-if-not* specialized on context type
end-context) predicate accept-end accept-empty) ¶vector-context) predicate accept-end accept-empty) ¶vector-context) position) ¶list-context) position) ¶context-front)) ¶parse-result-store)) ¶automatically generated reader method
vector-context)) ¶vector-context-common)) ¶automatically generated reader method
list-context)) ¶automatically generated reader method
parse-result-store)) ¶automatically generated writer method
vector-context-common)) ¶automatically generated writer method
list-context)) ¶automatically generated writer method
Implementation of string? specialized on context type. Returns as multiple values result and new context or nil on failure.
vector-context) vector test) ¶parser-possibility)) ¶automatically generated reader method
parser-possibility)) ¶automatically generated writer method
context-front)) ¶automatically generated reader method
tags.
context-front)) ¶automatically generated writer method
tags.
parser-possibility)) ¶automatically generated reader method
tree.
parser-possibility)) ¶automatically generated writer method
tree.
context) &rest initargs &key &allow-other-keys) ¶Parser: accept token char-equal to argument
Parser modifier: discard all results but the first
Non-backtracking parser: Find a sequence of tokens for which predicate returns true.
Non-backtracking parser: accept exactly count expressions accepted by parser, without backtracking.
context-common)) ¶automatically generated reader method
context-common)) ¶automatically generated writer method
end-context)) ¶vector-context)) ¶list-context)) ¶end-context)) ¶parse-result-store)) ¶automatically generated reader method
parse-result-store)) ¶automatically generated writer method
result-node)) ¶automatically generated reader method
result-node)) ¶automatically generated writer method
parse-result-store)) ¶automatically generated reader method
parse-result-store)) ¶automatically generated writer method
parse-result)) ¶automatically generated reader method
parse-result)) ¶automatically generated writer method
result-node)) ¶automatically generated reader method
emit.
result-node)) ¶automatically generated writer method
emit.
True if collection is empty
context-common)) ¶automatically generated reader method
context-common)) ¶automatically generated writer method
context-common)) ¶automatically generated reader method
context-common)) ¶automatically generated writer method
Attempt to realise all results within PARSE-RESULT-STORE upto and including the N-th one, and return that upon success. Otherwise return NIL.
null)) ¶parse-result)) ¶parse-result-store)) ¶Return top element without removing it
Return value from the back without removing it
Remove and return value from the front
Push value to the back
Push value to the front
context-common)) ¶automatically generated reader method
context-common)) ¶automatically generated writer method
parse-result)) ¶automatically generated reader method
parse-result)) ¶automatically generated writer method
result-node)) ¶automatically generated reader method
result-node)) ¶automatically generated writer method
result-node)) ¶automatically generated reader method
up.
result-node)) ¶automatically generated writer method
up.
cache-of.
(setf common-of).
common-of.
context-equal.
context-greater.
context-interval.
context-interval.
context-next.
context-peek.
(setf front-of).
front-of.
gather-if-not*-using-context.
initialize-instance.
length-of.
make-context-at-position.
(setf position-of).
position-of.
seen-positions-of.
string?-using-context.
update-front-context.
:common
common-lisp.
0
:position
common-lisp.
0
:length
(make-instance (quote parser-combinators::context-front))
:front
:cache
(make-hash-table)
:seen-position
:storage
Represent a set of parse results, as tracked by STORE, with one of them deemed CURRENT.
Track a set of parse results, of which COUNTER are already computed and placed in STORAGE, and an unknown remainder is to be realised by repetitively calling CONTINUATION.
t
:emit
:up
common-lisp.
0
:count
:suffix-continuation
:storage
| Jump to: | %
(
A B C D E F G H I L M N O P Q R S T U V W Z |
|---|
| Jump to: | %
(
A B C D E F G H I L M N O P Q R S T U V W Z |
|---|
| Jump to: | *
C E F H L P S T U V |
|---|
| Jump to: | *
C E F H L P S T U V |
|---|
| Jump to: | B C E F G L M P Q R S T V |
|---|
| Jump to: | B C E F G L M P Q R S T V |
|---|