Next: Introduction, Previous: (dir), Up: (dir) [Contents][Index]
This is the esrap Reference Manual, version 0.17, generated automatically by Declt version 2.4 "Will Decker" on Wed Jun 20 11:44:37 2018 GMT+0.
• Introduction: | What esrap is all about | |
• Systems: | The systems documentation | |
• Modules: | The modules documentation | |
• Files: | The files documentation | |
• Packages: | The packages documentation | |
• Definitions: | The symbols documentation | |
• Indexes: | Concepts, functions, variables and data types |
#+TITLE: ESRAP -- a packrat parser for Common Lisp * Introduction In addition to regular Packrat / Parsing Grammar / TDPL features ESRAP supports: + dynamic redefinition of nonterminals + inline grammars + semantic predicates + introspective facilities (describing grammars, tracing, setting breaks) + left-recursive grammars + functions as terminals + accurate, customizable parse error reports Homepage & Documentation https://scymtym.github.io/esrap/ #+ATTR_HTML: :alt "build status image" :title Build Status :align right [[https://travis-ci.org/scymtym/esrap][https://travis-ci.org/scymtym/esrap.svg]] References + Bryan Ford, 2002, "Packrat Parsing: a Practical Linear Time Algorithm with Backtracking". http://pdos.csail.mit.edu/~baford/packrat/thesis/ + A. Warth et al, 2008, "Packrat Parsers Can Support Left Recursion". http://www.vpri.org/pdf/tr2007002_packrat.pdf License #+begin_example Copyright (c) 2007-2013 Nikodemus SiivolaCopyright (c) 2012-2017 Jan Moringen Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. #+end_example * Syntax Overview #+begin_example -- case-sensitive terminal (~ ) -- case-insensitive terminal character -- any single character (string ) -- any string of length (character-ranges ) -- character ranges ( ) -- semantic parsing (function ) -- call to parse some text (not ) -- complement of expression (and &rest ) -- sequence (or &rest ) -- ordered-choices (* ) -- greedy-repetition (+ ) -- greedy-positive-repetition (? ) -- optional (& ) -- followed-by; does not consume (! ) -- not-followed-by; does not consume (< ) -- lookbehind characters; does not consume (> ) -- lookahead characters; does not consume #+end_example * Trivial Examples #+begin_src lisp :results none :exports none :session "doc" (ql:quickload :esrap) #+end_src The =parse= function takes an expression: #+begin_src lisp :results value code :exports both :session "doc" (multiple-value-list (esrap:parse '(or "foo" "bar") "foo")) #+end_src #+RESULTS: #+BEGIN_SRC lisp ("foo" NIL T) #+END_SRC New rules can be added. Normally you'd use the declarative =defrule= interface to define new rules, but everything it does can be done directly by building instances of the =rule= class and using =add-rule= to activate them. #+begin_src lisp :results value code :exports both :session "doc" (progn (esrap:add-rule 'foo+ (make-instance 'esrap:rule :expression '(+ "foo"))) (multiple-value-list (esrap:parse 'foo+ "foofoofoo"))) #+end_src #+RESULTS: #+BEGIN_SRC lisp (("foo" "foo" "foo") NIL T) #+END_SRC The equivalent =defrule= form is #+begin_src lisp :results value code :exports code :session "doc" (esrap:defrule foo+ '(+ "foo")) #+end_src Note that rules can be redefined, i.e. this =defrule= form replaces the previous definition of the =foo+= rule. Rules can transform their matches: #+begin_src lisp :results silent :exports code :session "doc" (esrap:add-rule 'decimal (make-instance 'esrap:rule :expression '(+ (or "0" "1" "2" "3" "4" "5" "6" "7" "8" "9")) :transform (lambda (list start end) (declare (ignore start end)) (parse-integer (format nil "~{~A~}" list))))) #+end_src or using =defrule= #+begin_src lisp :results value code :exports code :session "doc" (esrap:defrule decimal (+ (or "0" "1" "2" "3" "4" "5" "6" "7" "8" "9")) (:lambda (list) (parse-integer (format nil "~{~A~}" list)))) #+end_src Any lisp function can be used as a semantic predicate: #+begin_src lisp :results value code :exports both :session "doc" (list (multiple-value-list (esrap:parse '(oddp decimal) "123")) (multiple-value-list (esrap:parse '(evenp decimal) "123" :junk-allowed t))) #+end_src #+RESULTS: #+BEGIN_SRC lisp ((123 NIL T) (NIL 0)) #+END_SRC * Example Files More complete examples can be found in the following self-contained example files: + [[file:examples/sexp.lisp]]: complete sample grammar and usage + [[file:examples/symbol-table.lisp]]: grammar with lexical scope + [[file:examples/left-recursion.lisp]]: multiple grammars with left recursion + [[file:examples/function-terminals.lisp]]: grammars with functions as terminals
Next: Modules, Previous: Introduction, Up: Top [Contents][Index]
The main system appears first, followed by any subsystem dependency.
• The esrap system: |
Jan Moringen <jmoringe@techfak.uni-bielefeld.de>
Nikodemus Siivola <nikodemus@random-state.net>
Jan Moringen <jmoringe@techfak.uni-bielefeld.de>
(:git "https://github.com/scymtym/esrap.git")
MIT
A Packrat / Parsing Grammar / TDPL parser for Common Lisp.
A Packrat / Parsing Grammar / TDPL parser for Common Lisp.
Notable features include
* dynamic redefinition of nonterminals
* inline grammars
* semantic predicates
* introspective facilities (describing grammars,
tracing, setting breaks)
* left-recursive grammars
* functions as terminals
* accurate, customizable parse error reports
See README.org and :homepage for more information.
0.17
alexandria
esrap.asd (file)
Modules are listed depth-first from the system components tree.
• The esrap/src module: | ||
• The esrap/examples module: |
Next: The esrap/examples module, Previous: Modules, Up: Modules [Contents][Index]
esrap (system)
src/
Previous: The esrap/src module, Up: Modules [Contents][Index]
esrap (system)
examples/
Files are sorted by type and then listed depth-first from the systems components trees.
• Lisp files: | ||
• Other files: |
Next: Other files, Previous: Files, Up: Files [Contents][Index]
Next: The esrap/src/package<dot>lisp file, Previous: Lisp files, Up: Lisp files [Contents][Index]
esrap.asd
esrap (system)
Next: The esrap/src/types<dot>lisp file, Previous: The esrap<dot>asd file, Up: Lisp files [Contents][Index]
Next: The esrap/src/protocol<dot>lisp file, Previous: The esrap/src/package<dot>lisp file, Up: Lisp files [Contents][Index]
package.lisp (file)
src (module)
src/types.lisp
Next: The esrap/src/variables<dot>lisp file, Previous: The esrap/src/types<dot>lisp file, Up: Lisp files [Contents][Index]
types.lisp (file)
src (module)
src/protocol.lisp
Next: The esrap/src/conditions<dot>lisp file, Previous: The esrap/src/protocol<dot>lisp file, Up: Lisp files [Contents][Index]
protocol.lisp (file)
src (module)
src/variables.lisp
*on-left-recursion* (special variable)
*eval-nonterminals* (special variable)
Next: The esrap/src/expressions<dot>lisp file, Previous: The esrap/src/variables<dot>lisp file, Up: Lisp files [Contents][Index]
variables.lisp (file)
src (module)
src/conditions.lisp
Next: The esrap/src/rule<dot>lisp file, Previous: The esrap/src/conditions<dot>lisp file, Up: Lisp files [Contents][Index]
conditions.lisp (file)
src (module)
src/expressions.lisp
Next: The esrap/src/results<dot>lisp file, Previous: The esrap/src/expressions<dot>lisp file, Up: Lisp files [Contents][Index]
expressions.lisp (file)
src (module)
src/rule.lisp
Next: The esrap/src/cache<dot>lisp file, Previous: The esrap/src/rule<dot>lisp file, Up: Lisp files [Contents][Index]
rule.lisp (file)
src (module)
src/results.lisp
Next: The esrap/src/evaluator<dot>lisp file, Previous: The esrap/src/results<dot>lisp file, Up: Lisp files [Contents][Index]
results.lisp (file)
src (module)
src/cache.lisp
Next: The esrap/src/macros<dot>lisp file, Previous: The esrap/src/cache<dot>lisp file, Up: Lisp files [Contents][Index]
cache.lisp (file)
src (module)
src/evaluator.lisp
Next: The esrap/src/interface<dot>lisp file, Previous: The esrap/src/evaluator<dot>lisp file, Up: Lisp files [Contents][Index]
evaluator.lisp (file)
src (module)
src/macros.lisp
text (function)
Next: The esrap/src/editor-support<dot>lisp file, Previous: The esrap/src/macros<dot>lisp file, Up: Lisp files [Contents][Index]
macros.lisp (file)
src (module)
src/interface.lisp
Previous: The esrap/src/interface<dot>lisp file, Up: Lisp files [Contents][Index]
interface.lisp (file)
src (module)
src/editor-support.lisp
Previous: Lisp files, Up: Files [Contents][Index]
Next: The esrap/examples/symbol-table<dot>lisp file, Previous: Other files, Up: Other files [Contents][Index]
examples (module)
examples/sexp.lisp
Next: The esrap/examples/left-recursion<dot>lisp file, Previous: The esrap/examples/sexp<dot>lisp file, Up: Other files [Contents][Index]
examples (module)
examples/symbol-table.lisp
Next: The esrap/examples/function-terminals<dot>lisp file, Previous: The esrap/examples/symbol-table<dot>lisp file, Up: Other files [Contents][Index]
examples (module)
examples/left-recursion.lisp
Next: The esrap/readme<dot>org file, Previous: The esrap/examples/left-recursion<dot>lisp file, Up: Other files [Contents][Index]
examples (module)
examples/function-terminals.lisp
Previous: The esrap/examples/function-terminals<dot>lisp file, Up: Other files [Contents][Index]
esrap (system)
README.org
Next: Definitions, Previous: Files, Up: Top [Contents][Index]
Packages are listed by definition order.
• The esrap package: |
package.lisp (file)
Definitions are sorted by export status, category, package, and then by lexicographic order.
• Exported definitions: | ||
• Internal definitions: |
Next: Internal definitions, Previous: Definitions, Up: Definitions [Contents][Index]
• Exported special variables: | ||
• Exported macros: | ||
• Exported compiler macros: | ||
• Exported functions: | ||
• Exported generic functions: | ||
• Exported conditions: | ||
• Exported classes: |
Next: Exported macros, Previous: Exported definitions, Up: Exported definitions [Contents][Index]
This special variable controls Esrap’s behavior with respect to
allowing left recursion.
When :ERROR, PARSE signals a LEFT-RECURSION error when it encounters a
left recursive rule. Otherwise the rule is processed.
Note: when processing left recursive rules, linear-time guarantees generally no longer hold.
variables.lisp (file)
Next: Exported compiler macros, Previous: Exported special variables, Up: Exported definitions [Contents][Index]
Define SYMBOL as a nonterminal, using EXPRESSION as associated the parsing expression.
Multiple OPTIONS specifying transforms are composed in the order of
appearance:
(:text t)
(:function parse-integer)
=>
(alexandria:compose #’parse-integer #’text)
Following OPTIONS can be specified:
* (:WHEN TEST)
The rule is active only when TEST evaluates to true. This can be used
to specify optional extensions to a grammar.
This option can only be supplied once.
* (:CONSTANT CONSTANT)
No matter what input is consumed or what EXPRESSION produces, the production
of the rule is always CONSTANT.
* (:FUNCTION FUNCTION)
If provided the production of the expression is transformed using
FUNCTION. FUNCTION can be a function name or a lambda-expression.
* (:IDENTITY BOOLEAN)
If true, the production of expression is used as-is, as if (:FUNCTION IDENTITY) has been specified. If no production option is specified, this is the default.
* (:TEXT BOOLEAN)
If true, the production of expression is flattened and concatenated into a string
as if by (:FUNCTION TEXT) has been specified.
* (:LAMBDA LAMBDA-LIST &BODY BODY)
If provided, same as using the corresponding lambda-expression with :FUNCTION.
As an extension of the standard lambda list syntax, LAMBDA-LIST accepts
the optional pseudo lambda-list keyword ESRAP:&BOUNDS, which (1) must appear
after all standard lambda list keywords. (2) can be followed by one or two
variables to which bounding indexes of the matching substring are bound.
Therefore:
LAMBDA-LIST ::= (STANDARD-LAMBDA-LIST-ELEMENTS [&BOUNDS START [END]])
* (:DESTRUCTURE DESTRUCTURING-LAMBDA-LIST &BODY BODY)
If provided, same as using a lambda-expression that destructures its argument
using DESTRUCTURING-BIND and the provided lambda-list with :FUNCTION.
DESTRUCTURING-LAMBDA-LIST can use ESRAP:&BOUNDS in the same way
as described for :LAMBDA.
* (:AROUND ([&BOUNDS START [END]]) &BODY BODY)
If provided, execute BODY around the construction of the production of the
rule. BODY has to call ESRAP:CALL-TRANSFORM to trigger the computation of
the production. Any transformation provided via :LAMBDA, :FUNCTION
or :DESTRUCTURE is executed inside the call to ESRAP:CALL-TRANSFORM. As a
result, modification to the dynamic state are visible within the
transform.
ESRAP:&BOUNDS can be used in the same way as described for :LAMBDA
and :DESTRUCTURE.
This option can be used to safely track nesting depth, manage symbol
tables or for other stack-like operations.
* (:ERROR-REPORT ( T | NIL | :CONTEXT | :DETAIL ))
Defaults to T if not provided. Controls whether and how the rule
is used in parse error reports:
* T
The rule is used in parse error reports without
restriction (i.e. when describing the context of a failure as
well as listing failed rules and expected inputs).
* NIL
The rule is not used in parse error reports in any capacity. In
particular, inputs expected by the rule are not mentioned.
This value is useful for things like whitespace rules since
something like "expected space, tab or newline", even if it
would have allowed the parser to continue for one character, is
rarely helpful.
* :CONTEXT
The rule is used in the "context" part of parse error
reports. The rule is neither mentioned in the list of failed
rules nor are inputs expected by it.
* :DETAIL
The rule is not used in the "context" part of parse error
reports, but can appear in the list of failed rules. Inputs
expected by the rule are mentioned as well.
interface.lisp (file)
Next: Exported functions, Previous: Exported macros, Up: Exported definitions [Contents][Index]
interface.lisp (file)
Next: Exported generic functions, Previous: Exported compiler macros, Up: Exported definitions [Contents][Index]
Associates RULE with the nonterminal SYMBOL. Signals an error if the rule is already associated with a nonterminal. If the symbol is already associated with a rule, the old rule is removed first.
interface.lisp (file)
Modifies the nonterminal SYMBOL to use EXPRESSION instead. Temporarily removes the rule while it is being modified.
interface.lisp (file)
Prints the grammar tree rooted at nonterminal SYMBOL to STREAM for human inspection.
interface.lisp (file)
Print a description of TERMINAL onto STREAM.
In additional to actual terminals, TERMINAL can be of the forms
(PREDICATE-NAME TERMINALS)
({not,!} TERMINALS)
({<,>} OFFSET TERMINALS)
(i.e. as produced by EXPRESSION-START-TERMINALS).
expressions.lisp (file)
conditions.lisp (file)
Return a list of terminals or tree of expressions with which a text
parsable by EXPRESSION can start.
A tree instead of a list is returned when EXPRESSION contains
semantic predicates, NOT or !. Elements in the returned list or
tree are
* case (in)sensitive characters, character ranges,
case (in)sensitive strings, function terminals
* semantic predicates represented as
(PREDICATE-NAME NESTED-ELEMENTS)
where NESTED-ELEMENTS is the list of start terminals of the
expression to which PREDICATE-NAME is applied.
* NOT and ! expressions are represented as
({not,!} NESTED-ELEMENTS)
where NESTED-ELEMENTS is the list of start terminals of the
negated expression.
* < and > expressions are represented as
({<,>} OFFSET NESTED-ELEMENTS)
where OFFSET is a positive integer and NESTED-ELEMENTS is the list of start terminals of the expression that should match OFFSET characters backward/forward from the current position.
The (outermost) list is sorted likes this:
1. string terminals
2. character terminals
3. the CHARACTER wildcard terminal
4. semantic predicates
5. everything else
If supplied, WHEN-RULE-ERROR-REPORT restricts processing of nonterminals to rules whose :ERROR-REPORT option is compatible with the value of WHEN-RULE-ERROR-REPORT.
expressions.lisp (file)
Returns rule designated by SYMBOL, if any. Symbol must be a nonterminal symbol.
interface.lisp (file)
conditions.lisp (file)
conditions.lisp (file)
Parses TEXT using EXPRESSION from START to END.
Incomplete parses, that is not consuming the entirety of TEXT, are
allowed only if JUNK-ALLOWED is true.
Returns three values:
1) A production, if the parse succeeded, NIL otherwise.
2) The position up to which TEXT has been consumed or NIL if the
entirety of TEXT has been consumed.
3) If the parse succeeded, even if it did not consume any input, T is
returned as a third value.
The third return value is necessary to distinguish successful and
failed parses for cases like
(parse ’(! #\a) "a" :junk-allowed t)
(parse ’(! #\a) "b" :junk-allowed t)
in which the first two return values cannot indicate failures.
RAW controls whether the parse result is interpreted and translated
into the return values described above. If RAW is true, a parse result
of type RESULT or ERROR-RESULT is returned as a single value.
Note that the combination of arguments :junk-allowed t :raw t does not make sense since the JUNK-ALLOWED parameter is used when parse results are interpreted and translated into return values which does not happen when :raw t.
interface.lisp (file)
Makes the nonterminal SYMBOL undefined. If the nonterminal is defined an already referred to by other rules, an error is signalled unless :FORCE is true.
interface.lisp (file)
Returns the dependencies of the RULE: primary value is a list of defined nonterminal symbols, and secondary value is a list of undefined nonterminal symbols.
Return the parsing expression associated with the RULE.
interface.lisp (file)
(setf rule-expression) (function)
Modify RULE to use EXPRESSION as the parsing expression. The rule must be detached beforehand.
interface.lisp (file)
rule-expression (function)
Arguments must be strings, or lists whose leaves are strings. Catenates all the strings in arguments into a single string.
macros.lisp (file)
Turn on tracing of nonterminal SYMBOL.
If RECURSIVE is true, turn on tracing for the whole grammar rooted at SYMBOL. If RECURSIVE is a positive integer, turn on tracing for all rules reachable from the nonterminal SYMBOL in that number of steps.
If BREAK is true, break is entered when the rule is invoked.
If supplied, CONDITION has to be a function whose lambda-list is
compatible to (symbol text position end). This function is called to
determine whether trace actions should be executed for the traced
rule.
SYMBOL is the name of the rule being executed.
TEXT is the whole text being parsed.
POSITION is the position within TEXT at which the rule is executed.
END is the end position of the portion of TEXT being parsed.
interface.lisp (file)
Turn off tracing of nonterminal SYMBOL.
If RECURSIVE is true, turn off tracing for the whole grammar rooted at SYMBOL. If RECURSIVE is a positive integer, turn off tracing for all rules reachable from the nonterminal SYMBOL in that number of steps.
BREAK and CONDITION are ignored, and are provided only for symmetry with TRACE-RULE.
interface.lisp (file)
Next: Exported conditions, Previous: Exported functions, Up: Exported definitions [Contents][Index]
Return the input position at which the parse failure represented by CONDITION occurred.
protocol.lisp (file)
conditions.lisp (file)
conditions.lisp (file)
conditions.lisp (file)
Return the context result associated to the parse error represented by CONDITION.
protocol.lisp (file)
conditions.lisp (file)
Return the result associated to the parse error represented by CONDITION.
protocol.lisp (file)
conditions.lisp (file)
conditions.lisp (file)
conditions.lisp (file)
conditions.lisp (file)
Returns the nonterminal associated with the RULE, or NIL if the rule is not attached to any nonterminal.
conditions.lisp (file)
Next: Exported classes, Previous: Exported generic functions, Up: Exported definitions [Contents][Index]
Signaled when an Esrap parse fails. Use ESRAP-ERROR-TEXT to obtain the string that was being parsed, and ESRAP-ERROR-POSITION the position at which the error occurred.
conditions.lisp (file)
parse-error (condition)
:text
(quote nil)
esrap-error-text (generic function)
This error is signaled when a parse attempt fails in a way that .
conditions.lisp (file)
esrap-error (condition)
:result
esrap-parse-error-result (generic function)
(quote nil)
esrap-parse-error-%context (generic function)
(setf esrap-parse-error-%context) (generic function)
Initarg | Value |
---|---|
:result | (alexandria.0.dev:required-argument :result) |
Signaled when an invalid expression is encountered.
conditions.lisp (file)
error (condition)
:expression
invalid-expression-error-expression (generic function)
Initarg | Value |
---|---|
:expression | (alexandria.0.dev:required-argument :expression) |
May be signaled when left recursion is detected during Esrap parsing.
LEFT-RECURSION-NONTERMINAL names the symbol for which left recursion
was detected, and LEFT-RECURSION-PATH lists nonterminals of which the
left recursion cycle consists.
Note: This error is only signaled if *ON-LEFT-RECURSION* is bound to :ERROR.
conditions.lisp (file)
esrap-error (condition)
:position
(quote nil)
esrap-error-position (generic function)
:nonterminal
(quote nil)
left-recursion-nonterminal (generic function)
:path
(quote nil)
left-recursion-path (generic function)
Signaled when an undefined rule is encountered.
conditions.lisp (file)
Previous: Exported conditions, Up: Exported definitions [Contents][Index]
rule.lisp (file)
standard-object (class)
rule-symbol (generic function)
:expression
(alexandria.0.dev:required-argument :expression)
:guard-expression
t
rule-guard-expression (generic function)
:condition
t
rule-condition (generic function)
:transform
rule-transform (generic function)
:around
rule-around (generic function)
esrap::rule-error-report
:error-report
t
rule-error-report (generic function)
Previous: Exported definitions, Up: Definitions [Contents][Index]
• Internal special variables: | ||
• Internal macros: | ||
• Internal functions: | ||
• Internal generic functions: | ||
• Internal conditions: | ||
• Internal structures: | ||
• Internal types: |
Next: Internal macros, Previous: Internal definitions, Up: Internal definitions [Contents][Index]
cache.lisp (file)
evaluator.lisp (file)
variables.lisp (file)
Names and corresponding types of acceptable expression constructors.
expressions.lisp (file)
editor-support.lisp (file)
results.lisp (file)
interface.lisp (file)
Next: Internal functions, Previous: Internal special variables, Up: Internal definitions [Contents][Index]
Similar to
(cl:typecase EXPRESSION CLAUSES)
but clause heads designate kinds of expressions instead of types. See *EXPRESSION-KINDS*.
expressions.lisp (file)
evaluator.lisp (file)
results.lisp (file)
cache.lisp (file)
macros.lisp (file)
expressions.lisp (file)
cache.lisp (file)
Next: Internal generic functions, Previous: Internal macros, Up: Internal definitions [Contents][Index]
expressions.lisp (file)
expressions.lisp (file)
results.lisp (file)
evaluator.lisp (file)
expressions.lisp (file)
expressions.lisp (file)
macros.lisp (file)
evaluator.lisp (file)
evaluator.lisp (file)
evaluator.lisp (file)
evaluator.lisp (file)
evaluator.lisp (file)
evaluator.lisp (file)
evaluator.lisp (file)
evaluator.lisp (file)
evaluator.lisp (file)
evaluator.lisp (file)
evaluator.lisp (file)
evaluator.lisp (file)
evaluator.lisp (file)
evaluator.lisp (file)
evaluator.lisp (file)
evaluator.lisp (file)
evaluator.lisp (file)
evaluator.lisp (file)
evaluator.lisp (file)
evaluator.lisp (file)
cache.lisp (file)
cache.lisp (file)
cache.lisp (file)
cache.lisp (file)
cache.lisp (file)
results.lisp (file)
Return true if QUERY is suitable for PART-OR-PARTS.
types.lisp (file)
results.lisp (file)
results.lisp (file)
results.lisp (file)
results.lisp (file)
evaluator.lisp (file)
evaluator.lisp (file)
evaluator.lisp (file)
evaluator.lisp (file)
evaluator.lisp (file)
evaluator.lisp (file)
evaluator.lisp (file)
evaluator.lisp (file)
evaluator.lisp (file)
evaluator.lisp (file)
evaluator.lisp (file)
evaluator.lisp (file)
evaluator.lisp (file)
evaluator.lisp (file)
evaluator.lisp (file)
evaluator.lisp (file)
evaluator.lisp (file)
evaluator.lisp (file)
evaluator.lisp (file)
evaluator.lisp (file)
evaluator.lisp (file)
evaluator.lisp (file)
evaluator.lisp (file)
macros.lisp (file)
expressions.lisp (file)
expressions.lisp (file)
results.lisp (file)
results.lisp (file)
results.lisp (file)
results.lisp (file)
results.lisp (file)
cache.lisp (file)
cache.lisp (file)
cache.lisp (file)
cache.lisp (file)
cache.lisp (file)
editor-support.lisp (file)
results.lisp (file)
results.lisp (file)
results.lisp (file)
results.lisp (file)
results.lisp (file)
results.lisp (file)
results.lisp (file)
results.lisp (file)
results.lisp (file)
results.lisp (file)
results.lisp (file)
results.lisp (file)
results.lisp (file)
cache.lisp (file)
cache.lisp (file)
results.lisp (file)
results.lisp (file)
cache.lisp (file)
cache.lisp (file)
results.lisp (file)
results.lisp (file)
evaluator.lisp (file)
results.lisp (file)
results.lisp (file)
results.lisp (file)
evaluator.lisp (file)
evaluator.lisp (file)
evaluator.lisp (file)
evaluator.lisp (file)
results.lisp (file)
results.lisp (file)
macros.lisp (file)
Parse &BOUNDS section in LAMBDA-LIST and return three values:
1. The standard lambda list sublist of LAMBDA-LIST
2. A symbol that should be bound to the start of a matching substring
3. A symbol that should be bound to the end of a matching substring
4. A list containing symbols that were GENSYM’ed.
The second and/or third values are GENSYMS if LAMBDA-LIST contains a partial or no &BOUNDS section, in which case fourth value contains them for use with IGNORE.
macros.lisp (file)
results.lisp (file)
results.lisp (file)
expressions.lisp (file)
interface.lisp (file)
cache.lisp (file)
evaluator.lisp (file)
results.lisp (file)
results.lisp (file)
results.lisp (file)
results.lisp (file)
results.lisp (file)
results.lisp (file)
results.lisp (file)
results.lisp (file)
results.lisp (file)
results.lisp (file)
results.lisp (file)
results.lisp (file)
macros.lisp (file)
results.lisp (file)
results.lisp (file)
results.lisp (file)
results.lisp (file)
results.lisp (file)
results.lisp (file)
conditions.lisp (file)
Next: Internal conditions, Previous: Internal functions, Up: Internal definitions [Contents][Index]
conditions.lisp (file)
Next: Internal structures, Previous: Internal generic functions, Up: Internal definitions [Contents][Index]
conditions.lisp (file)
condition (condition)
undefined-rule-error (condition)
:symbol
undefined-rule-symbol (generic function)
Next: Internal types, Previous: Internal conditions, Up: Internal definitions [Contents][Index]
cache.lisp (file)
structure-object (structure)
hash-table
(esrap::make-cache)
context-cache (function)
(setf context-cache) (function)
hash-table
(esrap::make-heads)
context-heads (function)
(setf context-heads) (function)
list
(quote nil)
context-nonterminal-stack (function)
(setf context-nonterminal-stack) (function)
results.lisp (file)
result (structure)
results.lisp (file)
error-result (structure)
cache.lisp (file)
structure-object (structure)
symbol
(alexandria.0.dev:required-argument :rule)
head-rule (function)
(setf head-rule) (function)
list
(quote nil)
head-involved-set (function)
(setf head-involved-set) (function)
list
(quote nil)
head-eval-set (function)
(setf head-eval-set) (function)
results.lisp (file)
error-result (structure)
results.lisp (file)
error-result (structure)
(or null esrap::head)
left-recursion-result-head (function)
(setf left-recursion-result-head) (function)
results.lisp (file)
structure-object (structure)
print-object (method)
result-expression (function)
(setf result-expression) (function)
(or function esrap::input-position)
(function esrap::max-of-result-positions)
result-%position (function)
(setf result-%position) (function)
(or structure-object list string condition)
result-detail (function)
(setf result-detail) (function)
rule.lisp (file)
structure-object (structure)
(cons function t)
(alexandria.0.dev:required-argument :%info)
cell-%info (function)
(setf cell-%info) (function)
cell-trace-info (function)
(setf cell-trace-info) (function)
list
cell-referents (function)
(setf cell-referents) (function)
results.lisp (file)
result (structure)
(or list function)
successful-parse-%production (function)
(setf successful-parse-%production) (function)
Previous: Internal structures, Up: Internal definitions [Contents][Index]
A character range is either a single character or a list of two characters.
types.lisp (file)
Named part of a parse error report.
types.lisp (file)
types.lisp (file)
types.lisp (file)
types.lisp (file)
Any symbol except CHARACTER and NIL can be used as a nonterminal symbol.
types.lisp (file)
types.lisp (file)
types.lisp (file)
Suitability of a rule for error report parts.
In addition to the ERROR-REPORT-PART values, NIL indicates unsuitability for all error report parts, while T indicates suitability for all parts.
types.lisp (file)
ERROR-REPORT-PART or a list thereof.
types.lisp (file)
Literal strings and characters are used as case-sensitive terminal symbols, and expressions of the form (~ <literal>) denote case-insensitive terminals.
types.lisp (file)
Previous: Definitions, Up: Top [Contents][Index]
• Concept index: | ||
• Function index: | ||
• Variable index: | ||
• Data type index: |
Next: Function index, Previous: Indexes, Up: Indexes [Contents][Index]
Jump to: | E F L M O |
---|
Jump to: | E F L M O |
---|
Next: Variable index, Previous: Concept index, Up: Indexes [Contents][Index]
Jump to: | %
(
A C D E F G H I L M P R S T U W |
---|
Jump to: | %
(
A C D E F G H I L M P R S T U W |
---|
Next: Data type index, Previous: Function index, Up: Indexes [Contents][Index]
Jump to: | %
*
C D E H I N P R S T |
---|
Jump to: | %
*
C D E H I N P R S T |
---|
Previous: Variable index, Up: Indexes [Contents][Index]
Jump to: | C E F H I L N P R S T U |
---|
Jump to: | C E F H I L N P R S T U |
---|