The esrap Reference Manual

Table of Contents

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

The esrap Reference Manual

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.


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

1 Introduction

#+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 Siivola 
    Copyright (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: , Previous: , Up: Top   [Contents][Index]

2 Systems

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


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

2.1 esrap

Maintainer

Jan Moringen <jmoringe@techfak.uni-bielefeld.de>

Authors

Nikodemus Siivola <nikodemus@random-state.net>
Jan Moringen <jmoringe@techfak.uni-bielefeld.de>

Home Page

https://scymtym.github.io/esrap

Source Control

(:git "https://github.com/scymtym/esrap.git")

Bug Tracker

https://github.com/scymtym/esrap/issues

License

MIT

Description

A Packrat / Parsing Grammar / TDPL parser for Common Lisp.

Long Description

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.

Version

0.17

Dependency

alexandria

Source

esrap.asd (file)

Components

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

3 Modules

Modules are listed depth-first from the system components tree.


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

3.1 esrap/src

Parent

esrap (system)

Location

src/

Components

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

3.2 esrap/examples

Parent

esrap (system)

Location

examples/

Components

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

4 Files

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


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

4.1 Lisp


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

4.1.1 esrap.asd

Location

esrap.asd

Systems

esrap (system)


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

4.1.2 esrap/src/package.lisp

Parent

src (module)

Location

src/package.lisp

Packages

esrap


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

4.1.3 esrap/src/types.lisp

Dependency

package.lisp (file)

Parent

src (module)

Location

src/types.lisp

Internal Definitions

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

4.1.4 esrap/src/protocol.lisp

Dependency

types.lisp (file)

Parent

src (module)

Location

src/protocol.lisp

Exported Definitions

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

4.1.5 esrap/src/variables.lisp

Dependency

protocol.lisp (file)

Parent

src (module)

Location

src/variables.lisp

Exported Definitions

*on-left-recursion* (special variable)

Internal Definitions

*eval-nonterminals* (special variable)


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

4.1.6 esrap/src/conditions.lisp

Dependency

variables.lisp (file)

Parent

src (module)

Location

src/conditions.lisp

Exported Definitions
Internal Definitions

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

4.1.7 esrap/src/expressions.lisp

Dependency

conditions.lisp (file)

Parent

src (module)

Location

src/expressions.lisp

Exported Definitions
Internal Definitions

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

4.1.8 esrap/src/rule.lisp

Dependency

expressions.lisp (file)

Parent

src (module)

Location

src/rule.lisp

Exported Definitions
Internal Definitions

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

4.1.9 esrap/src/results.lisp

Dependency

rule.lisp (file)

Parent

src (module)

Location

src/results.lisp

Internal Definitions

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

4.1.10 esrap/src/cache.lisp

Dependency

results.lisp (file)

Parent

src (module)

Location

src/cache.lisp

Internal Definitions

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

4.1.11 esrap/src/evaluator.lisp

Dependency

cache.lisp (file)

Parent

src (module)

Location

src/evaluator.lisp

Internal Definitions

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

4.1.12 esrap/src/macros.lisp

Dependency

evaluator.lisp (file)

Parent

src (module)

Location

src/macros.lisp

Exported Definitions

text (function)

Internal Definitions

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

4.1.13 esrap/src/interface.lisp

Dependency

macros.lisp (file)

Parent

src (module)

Location

src/interface.lisp

Exported Definitions
Internal Definitions

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

4.1.14 esrap/src/editor-support.lisp

Dependency

interface.lisp (file)

Parent

src (module)

Location

src/editor-support.lisp

Internal Definitions

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

4.2 Other


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

4.2.1 esrap/examples/sexp.lisp

Parent

examples (module)

Location

examples/sexp.lisp


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

4.2.2 esrap/examples/symbol-table.lisp

Parent

examples (module)

Location

examples/symbol-table.lisp


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

4.2.3 esrap/examples/left-recursion.lisp

Parent

examples (module)

Location

examples/left-recursion.lisp


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

4.2.4 esrap/examples/function-terminals.lisp

Parent

examples (module)

Location

examples/function-terminals.lisp


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

4.2.5 esrap/README.org

Parent

esrap (system)

Location

README.org


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

5 Packages

Packages are listed by definition order.


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

5.1 esrap

Source

package.lisp (file)

Use List
Exported Definitions
Internal Definitions

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

6 Definitions

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


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

6.1 Exported definitions


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

6.1.1 Special variables

Special Variable: *on-left-recursion*

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.

Package

esrap

Source

variables.lisp (file)


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

6.1.2 Macros

Macro: defrule SYMBOL EXPRESSION &body OPTIONS

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.

Package

esrap

Source

interface.lisp (file)


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

6.1.3 Compiler macros

Compiler Macro: parse EXPRESSION TEXT &rest ARGUMENTS &key &allow-other-keys
Package

esrap

Source

interface.lisp (file)


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

6.1.4 Functions

Function: add-rule SYMBOL RULE

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.

Package

esrap

Source

interface.lisp (file)

Function: change-rule SYMBOL EXPRESSION

Modifies the nonterminal SYMBOL to use EXPRESSION instead. Temporarily removes the rule while it is being modified.

Package

esrap

Source

interface.lisp (file)

Function: describe-grammar SYMBOL &optional STREAM

Prints the grammar tree rooted at nonterminal SYMBOL to STREAM for human inspection.

Package

esrap

Source

interface.lisp (file)

Function: describe-terminal TERMINAL &optional STREAM

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

Package

esrap

Source

expressions.lisp (file)

Function: esrap-parse-error TEXT RESULT
Package

esrap

Source

conditions.lisp (file)

Function: expression-start-terminals EXPRESSION &key WHEN-RULE-ERROR-REPORT

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.

Package

esrap

Source

expressions.lisp (file)

Function: find-rule SYMBOL

Returns rule designated by SYMBOL, if any. Symbol must be a nonterminal symbol.

Package

esrap

Source

interface.lisp (file)

Function: invalid-expression-error EXPRESSION
Package

esrap

Source

conditions.lisp (file)

Function: left-recursion TEXT POSITION NONTERMINAL PATH-BUTLAST
Package

esrap

Source

conditions.lisp (file)

Function: parse EXPRESSION TEXT &key START END JUNK-ALLOWED RAW

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.

Package

esrap

Source

interface.lisp (file)

Function: remove-rule SYMBOL &key FORCE

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.

Package

esrap

Source

interface.lisp (file)

Function: rule-dependencies RULE

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.

Package

esrap

Source

rule.lisp (file)

Function: rule-expression RULE

Return the parsing expression associated with the RULE.

Package

esrap

Source

interface.lisp (file)

Writer

(setf rule-expression) (function)

Function: (setf rule-expression) EXPRESSION RULE

Modify RULE to use EXPRESSION as the parsing expression. The rule must be detached beforehand.

Package

esrap

Source

interface.lisp (file)

Reader

rule-expression (function)

Function: text &rest ARGUMENTS

Arguments must be strings, or lists whose leaves are strings. Catenates all the strings in arguments into a single string.

Package

esrap

Source

macros.lisp (file)

Function: trace-rule SYMBOL &key RECURSIVE BREAK CONDITION

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.

Package

esrap

Source

interface.lisp (file)

Function: untrace-rule SYMBOL &key RECURSIVE BREAK CONDITION

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.

Package

esrap

Source

interface.lisp (file)


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

6.1.5 Generic functions

Generic Function: esrap-error-position CONDITION

Return the input position at which the parse failure represented by CONDITION occurred.

Package

esrap

Source

protocol.lisp (file)

Methods
Method: esrap-error-position (CONDITION left-recursion)
Source

conditions.lisp (file)

Method: esrap-error-position (CONDITION esrap-parse-error)
Source

conditions.lisp (file)

Generic Function: esrap-error-text CONDITION
Package

esrap

Methods
Method: esrap-error-text (CONDITION esrap-error)
Source

conditions.lisp (file)

Generic Function: esrap-parse-error-context CONDITION

Return the context result associated to the parse error represented by CONDITION.

Package

esrap

Source

protocol.lisp (file)

Methods
Method: esrap-parse-error-context (CONDITION esrap-parse-error)
Source

conditions.lisp (file)

Generic Function: esrap-parse-error-result CONDITION

Return the result associated to the parse error represented by CONDITION.

Package

esrap

Source

protocol.lisp (file)

Methods
Method: esrap-parse-error-result (CONDITION esrap-parse-error)
Source

conditions.lisp (file)

Generic Function: invalid-expression-error-expression CONDITION
Package

esrap

Methods
Method: invalid-expression-error-expression (CONDITION invalid-expression-error)
Source

conditions.lisp (file)

Generic Function: left-recursion-nonterminal CONDITION
Package

esrap

Methods
Method: left-recursion-nonterminal (CONDITION left-recursion)
Source

conditions.lisp (file)

Generic Function: left-recursion-path CONDITION
Package

esrap

Methods
Method: left-recursion-path (CONDITION left-recursion)
Source

conditions.lisp (file)

Generic Function: rule-symbol OBJECT

Returns the nonterminal associated with the RULE, or NIL if the rule is not attached to any nonterminal.

Package

esrap

Methods
Method: rule-symbol (RULE rule)

automatically generated reader method

Source

rule.lisp (file)

Generic Function: undefined-rule-symbol CONDITION
Package

esrap

Methods
Method: undefined-rule-symbol (CONDITION undefined-rule)
Source

conditions.lisp (file)


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

6.1.6 Conditions

Condition: esrap-error ()

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.

Package

esrap

Source

conditions.lisp (file)

Direct superclasses

parse-error (condition)

Direct subclasses
Direct methods
Direct slots
Slot: text
Initargs

:text

Initform

(quote nil)

Readers

esrap-error-text (generic function)

Condition: esrap-parse-error ()

This error is signaled when a parse attempt fails in a way that .

Package

esrap

Source

conditions.lisp (file)

Direct superclasses

esrap-error (condition)

Direct methods
Direct slots
Slot: result
Initargs

:result

Readers

esrap-parse-error-result (generic function)

Slot: %context
Initform

(quote nil)

Readers

esrap-parse-error-%context (generic function)

Writers

(setf esrap-parse-error-%context) (generic function)

Direct Default Initargs
InitargValue
:result(alexandria.0.dev:required-argument :result)
Condition: invalid-expression-error ()

Signaled when an invalid expression is encountered.

Package

esrap

Source

conditions.lisp (file)

Direct superclasses

error (condition)

Direct methods
Direct slots
Slot: expression
Initargs

:expression

Readers

invalid-expression-error-expression (generic function)

Direct Default Initargs
InitargValue
:expression(alexandria.0.dev:required-argument :expression)
Condition: left-recursion ()

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.

Package

esrap

Source

conditions.lisp (file)

Direct superclasses

esrap-error (condition)

Direct methods
Direct slots
Slot: position
Initargs

:position

Initform

(quote nil)

Readers

esrap-error-position (generic function)

Slot: nonterminal
Initargs

:nonterminal

Initform

(quote nil)

Readers

left-recursion-nonterminal (generic function)

Slot: path
Initargs

:path

Initform

(quote nil)

Readers

left-recursion-path (generic function)

Condition: undefined-rule-error ()

Signaled when an undefined rule is encountered.

Package

esrap

Source

conditions.lisp (file)

Direct superclasses

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

6.1.7 Classes

Class: rule ()
Package

esrap

Source

rule.lisp (file)

Direct superclasses

standard-object (class)

Direct methods
Direct slots
Slot: %symbol
Readers

rule-symbol (generic function)

Slot: %expression
Initargs

:expression

Initform

(alexandria.0.dev:required-argument :expression)

Slot: %guard-expression
Initargs

:guard-expression

Initform

t

Readers

rule-guard-expression (generic function)

Slot: %condition
Initargs

:condition

Initform

t

Readers

rule-condition (generic function)

Slot: %transform
Initargs

:transform

Readers

rule-transform (generic function)

Slot: %around
Initargs

:around

Readers

rule-around (generic function)

Slot: %error-report
Type

esrap::rule-error-report

Initargs

:error-report

Initform

t

Readers

rule-error-report (generic function)


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

6.2 Internal definitions


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

6.2.1 Special variables

Special Variable: *context*
Package

esrap

Source

cache.lisp (file)

Special Variable: *current-rule*
Package

esrap

Source

evaluator.lisp (file)

Special Variable: *eval-nonterminals*
Package

esrap

Source

variables.lisp (file)

Special Variable: *expression-kinds*

Names and corresponding types of acceptable expression constructors.

Package

esrap

Source

expressions.lisp (file)

Special Variable: *indentation-hint-table*
Package

esrap

Source

editor-support.lisp (file)

Special Variable: *result-pprint-dispatch*
Package

esrap

Source

results.lisp (file)

Special Variable: *rules*
Package

esrap

Source

rule.lisp (file)

Special Variable: *trace-level*
Package

esrap

Source

interface.lisp (file)


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

6.2.2 Macros

Macro: expression-case EXPRESSION &body CLAUSES

Similar to

(cl:typecase EXPRESSION CLAUSES)

but clause heads designate kinds of expressions instead of types. See *EXPRESSION-KINDS*.

Package

esrap

Source

expressions.lisp (file)

Macro: expression-lambda NAME ARGS &body BODY
Package

esrap

Source

evaluator.lisp (file)

Macro: make-successful-parse EXPRESSION POSITION DETAIL PRODUCTION
Package

esrap

Source

results.lisp (file)

Macro: with-cached-result (SYMBOL POSITION &optional TEXT) &body FORMS
Package

esrap

Source

cache.lisp (file)

Macro: with-current-source-form (&rest FORMS) &body BODY
Package

esrap

Source

macros.lisp (file)

Macro: with-expression (EXPR SPEC) &body BODY
Package

esrap

Source

expressions.lisp (file)

Macro: with-pushed-nonterminal (SYMBOL CONTEXT) &body BODY
Package

esrap

Source

cache.lisp (file)


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

6.2.3 Functions

Function: %expression-dependencies EXPRESSION
Package

esrap

Source

expressions.lisp (file)

Function: %expression-direct-dependencies EXPRESSION
Package

esrap

Source

expressions.lisp (file)

Function: %make-successful-parse EXPRESSION %POSITION DETAIL %PRODUCTION
Package

esrap

Source

results.lisp (file)

Function: %rule-direct-dependencies RULE
Package

esrap

Source

rule.lisp (file)

Function: analyze-ordered-choise SUB-EXPRESSIONS
Package

esrap

Source

evaluator.lisp (file)

Function: cell-%info INSTANCE
Function: (setf cell-%info) VALUE INSTANCE
Package

esrap

Source

rule.lisp (file)

Function: cell-function CELL
Package

esrap

Source

rule.lisp (file)

Function: cell-referents INSTANCE
Function: (setf cell-referents) VALUE INSTANCE
Package

esrap

Source

rule.lisp (file)

Function: cell-rule CELL
Package

esrap

Source

rule.lisp (file)

Function: cell-trace-info INSTANCE
Function: (setf cell-trace-info) VALUE INSTANCE
Package

esrap

Source

rule.lisp (file)

Function: check-expression EXPRESSION
Package

esrap

Source

expressions.lisp (file)

Function: check-function-reference NAME EXPRESSION
Package

esrap

Source

expressions.lisp (file)

Function: check-lambda-list LAMBDA-LIST SPEC &key REPORT-LAMBDA-LIST
Package

esrap

Source

macros.lisp (file)

Function: check-ordered-choise-prefix STRING PREVIOUS-STRINGS
Package

esrap

Source

evaluator.lisp (file)

Function: clear-rules ()
Package

esrap

Source

rule.lisp (file)

Function: compile-character ()
Package

esrap

Source

evaluator.lisp (file)

Function: compile-character-ranges EXPRESSION
Package

esrap

Source

evaluator.lisp (file)

Function: compile-expression EXPRESSION
Package

esrap

Source

evaluator.lisp (file)

Function: compile-followed-by EXPRESSION
Package

esrap

Source

evaluator.lisp (file)

Function: compile-greedy-positive-repetition EXPRESSION
Package

esrap

Source

evaluator.lisp (file)

Function: compile-greedy-repetition EXPRESSION
Package

esrap

Source

evaluator.lisp (file)

Function: compile-look-ahead EXPRESSION
Package

esrap

Source

evaluator.lisp (file)

Function: compile-look-behind EXPRESSION
Package

esrap

Source

evaluator.lisp (file)

Function: compile-negation EXPRESSION
Package

esrap

Source

evaluator.lisp (file)

Function: compile-nonterminal SYMBOL
Package

esrap

Source

evaluator.lisp (file)

Function: compile-not-followed-by EXPRESSION
Package

esrap

Source

evaluator.lisp (file)

Function: compile-optional EXPRESSION
Package

esrap

Source

evaluator.lisp (file)

Function: compile-ordered-choise EXPRESSION
Package

esrap

Source

evaluator.lisp (file)

Function: compile-rule SYMBOL EXPRESSION CONDITION TRANSFORM AROUND
Package

esrap

Source

evaluator.lisp (file)

Function: compile-semantic-predicate EXPRESSION
Package

esrap

Source

evaluator.lisp (file)

Function: compile-sequence EXPRESSION
Package

esrap

Source

evaluator.lisp (file)

Function: compile-string EXPRESSION
Package

esrap

Source

evaluator.lisp (file)

Function: compile-terminal STRING CASE-SENSITIVE-P
Package

esrap

Source

evaluator.lisp (file)

Function: compile-terminal-function EXPRESSION
Package

esrap

Source

evaluator.lisp (file)

Function: context-cache INSTANCE
Package

esrap

Source

cache.lisp (file)

Function: context-heads INSTANCE
Package

esrap

Source

cache.lisp (file)

Function: context-nonterminal-stack INSTANCE
Function: (setf context-nonterminal-stack) VALUE INSTANCE
Package

esrap

Source

cache.lisp (file)

Function: context-p OBJECT
Package

esrap

Source

cache.lisp (file)

Function: copy-context INSTANCE
Package

esrap

Source

cache.lisp (file)

Function: delete-rule-cell SYMBOL
Package

esrap

Source

rule.lisp (file)

Function: dereference-rule-cell SYMBOL REFERENT
Package

esrap

Source

rule.lisp (file)

Function: detach-rule RULE
Package

esrap

Source

rule.lisp (file)

Function: ensure-rule-cell SYMBOL
Package

esrap

Source

rule.lisp (file)

Function: error-report CONTEXT STREAM
Package

esrap

Source

results.lisp (file)

Function: error-report-behavior-suitable-for-report-part-p QUERY PART-OR-PARTS

Return true if QUERY is suitable for PART-OR-PARTS.

Package

esrap

Source

types.lisp (file)

Function: error-result-%position INSTANCE
Function: (setf error-result-%position) VALUE INSTANCE
Package

esrap

Source

results.lisp (file)

Function: error-result-detail INSTANCE
Package

esrap

Source

results.lisp (file)

Function: error-result-expression INSTANCE
Package

esrap

Source

results.lisp (file)

Function: error-result-p OBJECT
Package

esrap

Source

results.lisp (file)

Function: eval-character TEXT POSITION END
Package

esrap

Source

evaluator.lisp (file)

Function: eval-character-ranges EXPRESSION TEXT POSITION END
Package

esrap

Source

evaluator.lisp (file)

Function: eval-expression EXPRESSION TEXT POSITION END
Package

esrap

Source

evaluator.lisp (file)

Function: eval-followed-by EXPRESSION TEXT POSITION END
Package

esrap

Source

evaluator.lisp (file)

Function: eval-greedy-positive-repetition EXPRESSION TEXT POSITION END
Package

esrap

Source

evaluator.lisp (file)

Function: eval-greedy-repetition EXPRESSION TEXT POSITION END
Package

esrap

Source

evaluator.lisp (file)

Function: eval-look-ahead EXPRESSION TEXT POSITION END
Package

esrap

Source

evaluator.lisp (file)

Function: eval-look-behind EXPRESSION TEXT POSITION END
Package

esrap

Source

evaluator.lisp (file)

Function: eval-negation EXPRESSION TEXT POSITION END
Package

esrap

Source

evaluator.lisp (file)

Function: eval-nonterminal SYMBOL TEXT POSITION END
Package

esrap

Source

evaluator.lisp (file)

Function: eval-not-followed-by EXPRESSION TEXT POSITION END
Package

esrap

Source

evaluator.lisp (file)

Function: eval-optional EXPRESSION TEXT POSITION END
Package

esrap

Source

evaluator.lisp (file)

Function: eval-ordered-choise EXPRESSION TEXT POSITION END
Package

esrap

Source

evaluator.lisp (file)

Function: eval-semantic-predicate EXPRESSION TEXT POSITION END
Package

esrap

Source

evaluator.lisp (file)

Function: eval-sequence EXPRESSION TEXT POSITION END
Package

esrap

Source

evaluator.lisp (file)

Function: eval-string EXPRESSION TEXT POSITION END
Package

esrap

Source

evaluator.lisp (file)

Function: eval-terminal STRING TEXT POSITION END CASE-SENSITIVE-P
Package

esrap

Source

evaluator.lisp (file)

Function: eval-terminal-function EXPRESSION TEXT POSITION END
Package

esrap

Source

evaluator.lisp (file)

Function: exec-character-ranges EXPRESSION RANGES TEXT POSITION END
Package

esrap

Source

evaluator.lisp (file)

Function: exec-negation FUN EXPR TEXT POSITION END
Package

esrap

Source

evaluator.lisp (file)

Function: exec-nonterminal SYMBOL TEXT POSITION END
Package

esrap

Source

evaluator.lisp (file)

Function: exec-string EXPRESSION LENGTH TEXT POSITION END
Package

esrap

Source

evaluator.lisp (file)

Function: exec-terminal-function EXPRESSION FUNCTION TEXT POSITION END
Package

esrap

Source

evaluator.lisp (file)

Function: expand-transforms TRANSFORMS
Package

esrap

Source

macros.lisp (file)

Function: expression-equal-p LEFT RIGHT
Package

esrap

Source

expressions.lisp (file)

Function: expression< LEFT RIGHT
Package

esrap

Source

expressions.lisp (file)

Function: failed-parse-%position INSTANCE
Function: (setf failed-parse-%position) VALUE INSTANCE
Package

esrap

Source

results.lisp (file)

Function: failed-parse-detail INSTANCE
Package

esrap

Source

results.lisp (file)

Function: failed-parse-expression INSTANCE
Package

esrap

Source

results.lisp (file)

Function: failed-parse-p OBJECT
Package

esrap

Source

results.lisp (file)

Function: find-rule-cell SYMBOL
Package

esrap

Source

rule.lisp (file)

Function: flattened-children RECURSE
Package

esrap

Source

results.lisp (file)

Function: get-cached SYMBOL POSITION CACHE
Function: (setf get-cached) RESULT SYMBOL POSITION CACHE
Package

esrap

Source

cache.lisp (file)

Function: get-head POSITION HEADS
Function: (setf get-head) HEAD POSITION HEADS
Package

esrap

Source

cache.lisp (file)

Function: head-eval-set INSTANCE
Function: (setf head-eval-set) VALUE INSTANCE
Package

esrap

Source

cache.lisp (file)

Function: head-involved-set INSTANCE
Function: (setf head-involved-set) VALUE INSTANCE
Package

esrap

Source

cache.lisp (file)

Function: head-rule INSTANCE
Function: (setf head-rule) VALUE INSTANCE
Package

esrap

Source

cache.lisp (file)

Function: hint-slime-indentation ()
Package

esrap

Source

editor-support.lisp (file)

Function: inactive-rule-%position INSTANCE
Function: (setf inactive-rule-%position) VALUE INSTANCE
Package

esrap

Source

results.lisp (file)

Function: inactive-rule-detail INSTANCE
Package

esrap

Source

results.lisp (file)

Function: inactive-rule-expression INSTANCE
Package

esrap

Source

results.lisp (file)

Function: inactive-rule-p OBJECT
Package

esrap

Source

results.lisp (file)

Function: inactive-rule-rule RESULT
Package

esrap

Source

results.lisp (file)

Function: left-recursion-result-%position INSTANCE
Function: (setf left-recursion-result-%position) VALUE INSTANCE
Package

esrap

Source

results.lisp (file)

Function: left-recursion-result-detail INSTANCE
Package

esrap

Source

results.lisp (file)

Function: left-recursion-result-expression INSTANCE
Package

esrap

Source

results.lisp (file)

Function: left-recursion-result-head INSTANCE
Function: (setf left-recursion-result-head) VALUE INSTANCE
Package

esrap

Source

results.lisp (file)

Function: left-recursion-result-p OBJECT
Package

esrap

Source

results.lisp (file)

Function: left-recursion-result-rule RESULT
Package

esrap

Source

results.lisp (file)

Function: list-of-result-productions RESULTS
Package

esrap

Source

results.lisp (file)

Function: list-of-result-productions/butlast RESULTS
Package

esrap

Source

results.lisp (file)

Function: make-cache ()
Package

esrap

Source

cache.lisp (file)

Function: make-context ()
Package

esrap

Source

cache.lisp (file)

Function: make-failed-parse EXPRESSION %POSITION DETAIL
Package

esrap

Source

results.lisp (file)

Function: make-failed-parse/no-position EXPRESSION DETAIL
Package

esrap

Source

results.lisp (file)

Function: make-head &key (RULE RULE) (INVOLVED-SET INVOLVED-SET) (EVAL-SET EVAL-SET)
Package

esrap

Source

cache.lisp (file)

Function: make-heads ()
Package

esrap

Source

cache.lisp (file)

Function: make-inactive-rule EXPRESSION %POSITION
Package

esrap

Source

results.lisp (file)

Function: make-left-recursion-result EXPRESSION
Package

esrap

Source

results.lisp (file)

Function: make-ordered-choise-result EXPRESSION RESULT ERRORS
Package

esrap

Source

evaluator.lisp (file)

Function: make-rule-cell SYMBOL &aux %INFO
Package

esrap

Source

rule.lisp (file)

Function: map-max-leaf-results FUNCTION RESULT &rest ARGS &key WHEN-ERROR-REPORT
Package

esrap

Source

results.lisp (file)

Function: map-max-results FUNCTION RESULT &key WHEN-ERROR-REPORT
Package

esrap

Source

results.lisp (file)

Function: map-results FUNCTION RESULT &key AUGMENT-INACTIVE-RULES
Package

esrap

Source

results.lisp (file)

Function: match-terminal/1/case-insensitive-p CHAR TEXT POSITION END
Package

esrap

Source

evaluator.lisp (file)

Function: match-terminal/1/case-sensitive-p CHAR TEXT POSITION END
Package

esrap

Source

evaluator.lisp (file)

Function: match-terminal/case-insensitive-p STRING LENGTH TEXT POSITION END
Package

esrap

Source

evaluator.lisp (file)

Function: match-terminal/case-sensitive-p STRING LENGTH TEXT POSITION END
Package

esrap

Source

evaluator.lisp (file)

Function: max-of-result-positions RESULTS &optional START
Package

esrap

Source

results.lisp (file)

Function: maybe-augment-inactive-rules RESULTS
Package

esrap

Source

results.lisp (file)

Function: parse-defrule-options OPTIONS FORM
Package

esrap

Source

macros.lisp (file)

Function: parse-lambda-list-maybe-containing-&bounds LAMBDA-LIST

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.

Package

esrap

Source

macros.lisp (file)

Function: partition-results RESULT
Package

esrap

Source

results.lisp (file)

Function: print-result STREAM RESULT &optional COLON? AT?
Package

esrap

Source

results.lisp (file)

Function: print-terminal STREAM TERMINAL &optional COLONP ATP
Package

esrap

Source

expressions.lisp (file)

Function: process-parse-result RESULT TEXT START END JUNK-ALLOWED
Package

esrap

Source

interface.lisp (file)

Function: recall RULE POSITION CACHE HEADS THUNK
Package

esrap

Source

cache.lisp (file)

Function: reference-rule-cell SYMBOL REFERENT
Package

esrap

Source

rule.lisp (file)

Function: resolve-function NAME ARGUMENTS EXPRESSION
Package

esrap

Source

evaluator.lisp (file)

Function: result-%position INSTANCE
Function: (setf result-%position) VALUE INSTANCE
Package

esrap

Source

results.lisp (file)

Function: result-context RESULT
Package

esrap

Source

results.lisp (file)

Function: result-detail INSTANCE
Package

esrap

Source

results.lisp (file)

Function: result-expected-input RESULT
Package

esrap

Source

results.lisp (file)

Function: result-expression INSTANCE
Package

esrap

Source

results.lisp (file)

Function: result-nonterminal-p RESULT
Package

esrap

Source

results.lisp (file)

Function: result-p OBJECT
Package

esrap

Source

results.lisp (file)

Function: result-position RESULT
Package

esrap

Source

results.lisp (file)

Function: result-root-cause RESULT
Package

esrap

Source

results.lisp (file)

Function: result-suitable-for-report-part-p RESULT PART
Package

esrap

Source

results.lisp (file)

Function: result-trivial-predicate-p RESULT
Package

esrap

Source

results.lisp (file)

Function: result-unsatisfied-predicate-p RESULT
Package

esrap

Source

results.lisp (file)

Function: rule-direct-dependencies RULE
Package

esrap

Source

rule.lisp (file)

Function: rule-suitable-for-report-part-p SYMBOL PART-OR-PARTS
Package

esrap

Source

rule.lisp (file)

Function: set-cell-info CELL FUNCTION RULE
Package

esrap

Source

rule.lisp (file)

Function: singleton-option CONTEXT FORM KEYWORD TYPE &key DEFAULT
Package

esrap

Source

macros.lisp (file)

Function: sort-dependencies SYMBOL DEPENDENCIES
Package

esrap

Source

rule.lisp (file)

Function: successful-parse-%position INSTANCE
Function: (setf successful-parse-%position) VALUE INSTANCE
Package

esrap

Source

results.lisp (file)

Function: successful-parse-%production INSTANCE
Function: (setf successful-parse-%production) VALUE INSTANCE
Package

esrap

Source

results.lisp (file)

Function: successful-parse-detail INSTANCE
Package

esrap

Source

results.lisp (file)

Function: successful-parse-expression INSTANCE
Package

esrap

Source

results.lisp (file)

Function: successful-parse-p OBJECT
Package

esrap

Source

results.lisp (file)

Function: successful-parse-production RESULT
Package

esrap

Source

results.lisp (file)

Function: undefined-rule SYMBOL
Package

esrap

Source

conditions.lisp (file)

Function: undefined-rule-function SYMBOL
Package

esrap

Source

rule.lisp (file)


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

6.2.4 Generic functions

Generic Function: esrap-parse-error-%context CONDITION
Generic Function: (setf esrap-parse-error-%context) NEW-VALUE CONDITION
Package

esrap

Methods
Method: esrap-parse-error-%context (CONDITION esrap-parse-error)
Method: (setf esrap-parse-error-%context) NEW-VALUE (CONDITION esrap-parse-error)
Source

conditions.lisp (file)

Generic Function: rule-around OBJECT
Package

esrap

Methods
Method: rule-around (RULE rule)

automatically generated reader method

Source

rule.lisp (file)

Generic Function: rule-condition OBJECT
Package

esrap

Methods
Method: rule-condition (RULE rule)

automatically generated reader method

Source

rule.lisp (file)

Generic Function: rule-error-report OBJECT
Package

esrap

Methods
Method: rule-error-report (RULE rule)

automatically generated reader method

Source

rule.lisp (file)

Generic Function: rule-guard-expression OBJECT
Package

esrap

Methods
Method: rule-guard-expression (RULE rule)

automatically generated reader method

Source

rule.lisp (file)

Generic Function: rule-transform OBJECT
Package

esrap

Methods
Method: rule-transform (RULE rule)

automatically generated reader method

Source

rule.lisp (file)


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

6.2.5 Conditions

Condition: undefined-rule ()
Package

esrap

Source

conditions.lisp (file)

Direct superclasses

condition (condition)

Direct subclasses

undefined-rule-error (condition)

Direct methods
Direct slots
Slot: symbol
Initargs

:symbol

Readers

undefined-rule-symbol (generic function)


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

6.2.6 Structures

Structure: context ()
Package

esrap

Source

cache.lisp (file)

Direct superclasses

structure-object (structure)

Direct slots
Slot: cache
Type

hash-table

Initform

(esrap::make-cache)

Readers

context-cache (function)

Writers

(setf context-cache) (function)

Slot: heads
Type

hash-table

Initform

(esrap::make-heads)

Readers

context-heads (function)

Writers

(setf context-heads) (function)

Slot: nonterminal-stack
Type

list

Initform

(quote nil)

Readers

context-nonterminal-stack (function)

Writers

(setf context-nonterminal-stack) (function)

Structure: error-result ()
Package

esrap

Source

results.lisp (file)

Direct superclasses

result (structure)

Direct subclasses
Structure: failed-parse ()
Package

esrap

Source

results.lisp (file)

Direct superclasses

error-result (structure)

Structure: head ()
Package

esrap

Source

cache.lisp (file)

Direct superclasses

structure-object (structure)

Direct slots
Slot: rule
Type

symbol

Initform

(alexandria.0.dev:required-argument :rule)

Readers

head-rule (function)

Writers

(setf head-rule) (function)

Slot: involved-set
Type

list

Initform

(quote nil)

Readers

head-involved-set (function)

Writers

(setf head-involved-set) (function)

Slot: eval-set
Type

list

Initform

(quote nil)

Readers

head-eval-set (function)

Writers

(setf head-eval-set) (function)

Structure: inactive-rule ()
Package

esrap

Source

results.lisp (file)

Direct superclasses

error-result (structure)

Structure: left-recursion-result ()
Package

esrap

Source

results.lisp (file)

Direct superclasses

error-result (structure)

Direct slots
Slot: head
Type

(or null esrap::head)

Readers

left-recursion-result-head (function)

Writers

(setf left-recursion-result-head) (function)

Structure: result ()
Package

esrap

Source

results.lisp (file)

Direct superclasses

structure-object (structure)

Direct subclasses
Direct methods

print-object (method)

Direct slots
Slot: expression
Readers

result-expression (function)

Writers

(setf result-expression) (function)

Slot: %position
Type

(or function esrap::input-position)

Initform

(function esrap::max-of-result-positions)

Readers

result-%position (function)

Writers

(setf result-%position) (function)

Slot: detail
Type

(or structure-object list string condition)

Readers

result-detail (function)

Writers

(setf result-detail) (function)

Structure: rule-cell ()
Package

esrap

Source

rule.lisp (file)

Direct superclasses

structure-object (structure)

Direct slots
Slot: %info
Type

(cons function t)

Initform

(alexandria.0.dev:required-argument :%info)

Readers

cell-%info (function)

Writers

(setf cell-%info) (function)

Slot: trace-info
Readers

cell-trace-info (function)

Writers

(setf cell-trace-info) (function)

Slot: referents
Type

list

Readers

cell-referents (function)

Writers

(setf cell-referents) (function)

Structure: successful-parse ()
Package

esrap

Source

results.lisp (file)

Direct superclasses

result (structure)

Direct slots
Slot: %production
Type

(or list function)

Readers

successful-parse-%production (function)

Writers

(setf successful-parse-%production) (function)


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

6.2.7 Types

Type: character-range ()

A character range is either a single character or a list of two characters.

Package

esrap

Source

types.lisp (file)

Type: error-report-part ()

Named part of a parse error report.

Package

esrap

Source

types.lisp (file)

Type: input-length ()
Package

esrap

Source

types.lisp (file)

Type: input-position ()
Package

esrap

Source

types.lisp (file)

Type: left-recursion-policy ()
Package

esrap

Source

types.lisp (file)

Type: nonterminal ()

Any symbol except CHARACTER and NIL can be used as a nonterminal symbol.

Package

esrap

Source

types.lisp (file)

Type: predicate ()
Package

esrap

Source

types.lisp (file)

Type: predicate-name ()
Package

esrap

Source

types.lisp (file)

Type: rule-error-report ()

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.

Package

esrap

Source

types.lisp (file)

Type: rule-error-report-pattern ()

ERROR-REPORT-PART or a list thereof.

Package

esrap

Source

types.lisp (file)

Type: terminal ()

Literal strings and characters are used as case-sensitive terminal symbols, and expressions of the form (~ <literal>) denote case-insensitive terminals.

Package

esrap

Source

types.lisp (file)


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

Appendix A Indexes


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

A.1 Concepts

Jump to:   E   F   L   M   O  
Index Entry  Section

E
esrap.asd: The esrap<dot>asd file
esrap/examples: The esrap/examples module
esrap/examples/function-terminals.lisp: The esrap/examples/function-terminals<dot>lisp file
esrap/examples/left-recursion.lisp: The esrap/examples/left-recursion<dot>lisp file
esrap/examples/sexp.lisp: The esrap/examples/sexp<dot>lisp file
esrap/examples/symbol-table.lisp: The esrap/examples/symbol-table<dot>lisp file
esrap/README.org: The esrap/readme<dot>org file
esrap/src: The esrap/src module
esrap/src/cache.lisp: The esrap/src/cache<dot>lisp file
esrap/src/conditions.lisp: The esrap/src/conditions<dot>lisp file
esrap/src/editor-support.lisp: The esrap/src/editor-support<dot>lisp file
esrap/src/evaluator.lisp: The esrap/src/evaluator<dot>lisp file
esrap/src/expressions.lisp: The esrap/src/expressions<dot>lisp file
esrap/src/interface.lisp: The esrap/src/interface<dot>lisp file
esrap/src/macros.lisp: The esrap/src/macros<dot>lisp file
esrap/src/package.lisp: The esrap/src/package<dot>lisp file
esrap/src/protocol.lisp: The esrap/src/protocol<dot>lisp file
esrap/src/results.lisp: The esrap/src/results<dot>lisp file
esrap/src/rule.lisp: The esrap/src/rule<dot>lisp file
esrap/src/types.lisp: The esrap/src/types<dot>lisp file
esrap/src/variables.lisp: The esrap/src/variables<dot>lisp file

F
File, Lisp, esrap.asd: The esrap<dot>asd file
File, Lisp, esrap/src/cache.lisp: The esrap/src/cache<dot>lisp file
File, Lisp, esrap/src/conditions.lisp: The esrap/src/conditions<dot>lisp file
File, Lisp, esrap/src/editor-support.lisp: The esrap/src/editor-support<dot>lisp file
File, Lisp, esrap/src/evaluator.lisp: The esrap/src/evaluator<dot>lisp file
File, Lisp, esrap/src/expressions.lisp: The esrap/src/expressions<dot>lisp file
File, Lisp, esrap/src/interface.lisp: The esrap/src/interface<dot>lisp file
File, Lisp, esrap/src/macros.lisp: The esrap/src/macros<dot>lisp file
File, Lisp, esrap/src/package.lisp: The esrap/src/package<dot>lisp file
File, Lisp, esrap/src/protocol.lisp: The esrap/src/protocol<dot>lisp file
File, Lisp, esrap/src/results.lisp: The esrap/src/results<dot>lisp file
File, Lisp, esrap/src/rule.lisp: The esrap/src/rule<dot>lisp file
File, Lisp, esrap/src/types.lisp: The esrap/src/types<dot>lisp file
File, Lisp, esrap/src/variables.lisp: The esrap/src/variables<dot>lisp file
File, other, esrap/examples/function-terminals.lisp: The esrap/examples/function-terminals<dot>lisp file
File, other, esrap/examples/left-recursion.lisp: The esrap/examples/left-recursion<dot>lisp file
File, other, esrap/examples/sexp.lisp: The esrap/examples/sexp<dot>lisp file
File, other, esrap/examples/symbol-table.lisp: The esrap/examples/symbol-table<dot>lisp file
File, other, esrap/README.org: The esrap/readme<dot>org file

L
Lisp File, esrap.asd: The esrap<dot>asd file
Lisp File, esrap/src/cache.lisp: The esrap/src/cache<dot>lisp file
Lisp File, esrap/src/conditions.lisp: The esrap/src/conditions<dot>lisp file
Lisp File, esrap/src/editor-support.lisp: The esrap/src/editor-support<dot>lisp file
Lisp File, esrap/src/evaluator.lisp: The esrap/src/evaluator<dot>lisp file
Lisp File, esrap/src/expressions.lisp: The esrap/src/expressions<dot>lisp file
Lisp File, esrap/src/interface.lisp: The esrap/src/interface<dot>lisp file
Lisp File, esrap/src/macros.lisp: The esrap/src/macros<dot>lisp file
Lisp File, esrap/src/package.lisp: The esrap/src/package<dot>lisp file
Lisp File, esrap/src/protocol.lisp: The esrap/src/protocol<dot>lisp file
Lisp File, esrap/src/results.lisp: The esrap/src/results<dot>lisp file
Lisp File, esrap/src/rule.lisp: The esrap/src/rule<dot>lisp file
Lisp File, esrap/src/types.lisp: The esrap/src/types<dot>lisp file
Lisp File, esrap/src/variables.lisp: The esrap/src/variables<dot>lisp file

M
Module, esrap/examples: The esrap/examples module
Module, esrap/src: The esrap/src module

O
Other File, esrap/examples/function-terminals.lisp: The esrap/examples/function-terminals<dot>lisp file
Other File, esrap/examples/left-recursion.lisp: The esrap/examples/left-recursion<dot>lisp file
Other File, esrap/examples/sexp.lisp: The esrap/examples/sexp<dot>lisp file
Other File, esrap/examples/symbol-table.lisp: The esrap/examples/symbol-table<dot>lisp file
Other File, esrap/README.org: The esrap/readme<dot>org file

Jump to:   E   F   L   M   O  

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

A.2 Functions

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

%
%expression-dependencies: Internal functions
%expression-direct-dependencies: Internal functions
%make-successful-parse: Internal functions
%rule-direct-dependencies: Internal functions

(
(setf cell-%info): Internal functions
(setf cell-referents): Internal functions
(setf cell-trace-info): Internal functions
(setf context-nonterminal-stack): Internal functions
(setf error-result-%position): Internal functions
(setf esrap-parse-error-%context): Internal generic functions
(setf esrap-parse-error-%context): Internal generic functions
(setf failed-parse-%position): Internal functions
(setf get-cached): Internal functions
(setf get-head): Internal functions
(setf head-eval-set): Internal functions
(setf head-involved-set): Internal functions
(setf head-rule): Internal functions
(setf inactive-rule-%position): Internal functions
(setf left-recursion-result-%position): Internal functions
(setf left-recursion-result-head): Internal functions
(setf result-%position): Internal functions
(setf rule-expression): Exported functions
(setf successful-parse-%position): Internal functions
(setf successful-parse-%production): Internal functions

A
add-rule: Exported functions
analyze-ordered-choise: Internal functions

C
cell-%info: Internal functions
cell-function: Internal functions
cell-referents: Internal functions
cell-rule: Internal functions
cell-trace-info: Internal functions
change-rule: Exported functions
check-expression: Internal functions
check-function-reference: Internal functions
check-lambda-list: Internal functions
check-ordered-choise-prefix: Internal functions
clear-rules: Internal functions
compile-character: Internal functions
compile-character-ranges: Internal functions
compile-expression: Internal functions
compile-followed-by: Internal functions
compile-greedy-positive-repetition: Internal functions
compile-greedy-repetition: Internal functions
compile-look-ahead: Internal functions
compile-look-behind: Internal functions
compile-negation: Internal functions
compile-nonterminal: Internal functions
compile-not-followed-by: Internal functions
compile-optional: Internal functions
compile-ordered-choise: Internal functions
compile-rule: Internal functions
compile-semantic-predicate: Internal functions
compile-sequence: Internal functions
compile-string: Internal functions
compile-terminal: Internal functions
compile-terminal-function: Internal functions
Compiler Macro, parse: Exported compiler macros
context-cache: Internal functions
context-heads: Internal functions
context-nonterminal-stack: Internal functions
context-p: Internal functions
copy-context: Internal functions

D
defrule: Exported macros
delete-rule-cell: Internal functions
dereference-rule-cell: Internal functions
describe-grammar: Exported functions
describe-terminal: Exported functions
detach-rule: Internal functions

E
ensure-rule-cell: Internal functions
error-report: Internal functions
error-report-behavior-suitable-for-report-part-p: Internal functions
error-result-%position: Internal functions
error-result-detail: Internal functions
error-result-expression: Internal functions
error-result-p: Internal functions
esrap-error-position: Exported generic functions
esrap-error-position: Exported generic functions
esrap-error-position: Exported generic functions
esrap-error-text: Exported generic functions
esrap-error-text: Exported generic functions
esrap-parse-error: Exported functions
esrap-parse-error-%context: Internal generic functions
esrap-parse-error-%context: Internal generic functions
esrap-parse-error-context: Exported generic functions
esrap-parse-error-context: Exported generic functions
esrap-parse-error-result: Exported generic functions
esrap-parse-error-result: Exported generic functions
eval-character: Internal functions
eval-character-ranges: Internal functions
eval-expression: Internal functions
eval-followed-by: Internal functions
eval-greedy-positive-repetition: Internal functions
eval-greedy-repetition: Internal functions
eval-look-ahead: Internal functions
eval-look-behind: Internal functions
eval-negation: Internal functions
eval-nonterminal: Internal functions
eval-not-followed-by: Internal functions
eval-optional: Internal functions
eval-ordered-choise: Internal functions
eval-semantic-predicate: Internal functions
eval-sequence: Internal functions
eval-string: Internal functions
eval-terminal: Internal functions
eval-terminal-function: Internal functions
exec-character-ranges: Internal functions
exec-negation: Internal functions
exec-nonterminal: Internal functions
exec-string: Internal functions
exec-terminal-function: Internal functions
expand-transforms: Internal functions
expression-case: Internal macros
expression-equal-p: Internal functions
expression-lambda: Internal macros
expression-start-terminals: Exported functions
expression<: Internal functions

F
failed-parse-%position: Internal functions
failed-parse-detail: Internal functions
failed-parse-expression: Internal functions
failed-parse-p: Internal functions
find-rule: Exported functions
find-rule-cell: Internal functions
flattened-children: Internal functions
Function, %expression-dependencies: Internal functions
Function, %expression-direct-dependencies: Internal functions
Function, %make-successful-parse: Internal functions
Function, %rule-direct-dependencies: Internal functions
Function, (setf cell-%info): Internal functions
Function, (setf cell-referents): Internal functions
Function, (setf cell-trace-info): Internal functions
Function, (setf context-nonterminal-stack): Internal functions
Function, (setf error-result-%position): Internal functions
Function, (setf failed-parse-%position): Internal functions
Function, (setf get-cached): Internal functions
Function, (setf get-head): Internal functions
Function, (setf head-eval-set): Internal functions
Function, (setf head-involved-set): Internal functions
Function, (setf head-rule): Internal functions
Function, (setf inactive-rule-%position): Internal functions
Function, (setf left-recursion-result-%position): Internal functions
Function, (setf left-recursion-result-head): Internal functions
Function, (setf result-%position): Internal functions
Function, (setf rule-expression): Exported functions
Function, (setf successful-parse-%position): Internal functions
Function, (setf successful-parse-%production): Internal functions
Function, add-rule: Exported functions
Function, analyze-ordered-choise: Internal functions
Function, cell-%info: Internal functions
Function, cell-function: Internal functions
Function, cell-referents: Internal functions
Function, cell-rule: Internal functions
Function, cell-trace-info: Internal functions
Function, change-rule: Exported functions
Function, check-expression: Internal functions
Function, check-function-reference: Internal functions
Function, check-lambda-list: Internal functions
Function, check-ordered-choise-prefix: Internal functions
Function, clear-rules: Internal functions
Function, compile-character: Internal functions
Function, compile-character-ranges: Internal functions
Function, compile-expression: Internal functions
Function, compile-followed-by: Internal functions
Function, compile-greedy-positive-repetition: Internal functions
Function, compile-greedy-repetition: Internal functions
Function, compile-look-ahead: Internal functions
Function, compile-look-behind: Internal functions
Function, compile-negation: Internal functions
Function, compile-nonterminal: Internal functions
Function, compile-not-followed-by: Internal functions
Function, compile-optional: Internal functions
Function, compile-ordered-choise: Internal functions
Function, compile-rule: Internal functions
Function, compile-semantic-predicate: Internal functions
Function, compile-sequence: Internal functions
Function, compile-string: Internal functions
Function, compile-terminal: Internal functions
Function, compile-terminal-function: Internal functions
Function, context-cache: Internal functions
Function, context-heads: Internal functions
Function, context-nonterminal-stack: Internal functions
Function, context-p: Internal functions
Function, copy-context: Internal functions
Function, delete-rule-cell: Internal functions
Function, dereference-rule-cell: Internal functions
Function, describe-grammar: Exported functions
Function, describe-terminal: Exported functions
Function, detach-rule: Internal functions
Function, ensure-rule-cell: Internal functions
Function, error-report: Internal functions
Function, error-report-behavior-suitable-for-report-part-p: Internal functions
Function, error-result-%position: Internal functions
Function, error-result-detail: Internal functions
Function, error-result-expression: Internal functions
Function, error-result-p: Internal functions
Function, esrap-parse-error: Exported functions
Function, eval-character: Internal functions
Function, eval-character-ranges: Internal functions
Function, eval-expression: Internal functions
Function, eval-followed-by: Internal functions
Function, eval-greedy-positive-repetition: Internal functions
Function, eval-greedy-repetition: Internal functions
Function, eval-look-ahead: Internal functions
Function, eval-look-behind: Internal functions
Function, eval-negation: Internal functions
Function, eval-nonterminal: Internal functions
Function, eval-not-followed-by: Internal functions
Function, eval-optional: Internal functions
Function, eval-ordered-choise: Internal functions
Function, eval-semantic-predicate: Internal functions
Function, eval-sequence: Internal functions
Function, eval-string: Internal functions
Function, eval-terminal: Internal functions
Function, eval-terminal-function: Internal functions
Function, exec-character-ranges: Internal functions
Function, exec-negation: Internal functions
Function, exec-nonterminal: Internal functions
Function, exec-string: Internal functions
Function, exec-terminal-function: Internal functions
Function, expand-transforms: Internal functions
Function, expression-equal-p: Internal functions
Function, expression-start-terminals: Exported functions
Function, expression<: Internal functions
Function, failed-parse-%position: Internal functions
Function, failed-parse-detail: Internal functions
Function, failed-parse-expression: Internal functions
Function, failed-parse-p: Internal functions
Function, find-rule: Exported functions
Function, find-rule-cell: Internal functions
Function, flattened-children: Internal functions
Function, get-cached: Internal functions
Function, get-head: Internal functions
Function, head-eval-set: Internal functions
Function, head-involved-set: Internal functions
Function, head-rule: Internal functions
Function, hint-slime-indentation: Internal functions
Function, inactive-rule-%position: Internal functions
Function, inactive-rule-detail: Internal functions
Function, inactive-rule-expression: Internal functions
Function, inactive-rule-p: Internal functions
Function, inactive-rule-rule: Internal functions
Function, invalid-expression-error: Exported functions
Function, left-recursion: Exported functions
Function, left-recursion-result-%position: Internal functions
Function, left-recursion-result-detail: Internal functions
Function, left-recursion-result-expression: Internal functions
Function, left-recursion-result-head: Internal functions
Function, left-recursion-result-p: Internal functions
Function, left-recursion-result-rule: Internal functions
Function, list-of-result-productions: Internal functions
Function, list-of-result-productions/butlast: Internal functions
Function, make-cache: Internal functions
Function, make-context: Internal functions
Function, make-failed-parse: Internal functions
Function, make-failed-parse/no-position: Internal functions
Function, make-head: Internal functions
Function, make-heads: Internal functions
Function, make-inactive-rule: Internal functions
Function, make-left-recursion-result: Internal functions
Function, make-ordered-choise-result: Internal functions
Function, make-rule-cell: Internal functions
Function, map-max-leaf-results: Internal functions
Function, map-max-results: Internal functions
Function, map-results: Internal functions
Function, match-terminal/1/case-insensitive-p: Internal functions
Function, match-terminal/1/case-sensitive-p: Internal functions
Function, match-terminal/case-insensitive-p: Internal functions
Function, match-terminal/case-sensitive-p: Internal functions
Function, max-of-result-positions: Internal functions
Function, maybe-augment-inactive-rules: Internal functions
Function, parse: Exported functions
Function, parse-defrule-options: Internal functions
Function, parse-lambda-list-maybe-containing-&bounds: Internal functions
Function, partition-results: Internal functions
Function, print-result: Internal functions
Function, print-terminal: Internal functions
Function, process-parse-result: Internal functions
Function, recall: Internal functions
Function, reference-rule-cell: Internal functions
Function, remove-rule: Exported functions
Function, resolve-function: Internal functions
Function, result-%position: Internal functions
Function, result-context: Internal functions
Function, result-detail: Internal functions
Function, result-expected-input: Internal functions
Function, result-expression: Internal functions
Function, result-nonterminal-p: Internal functions
Function, result-p: Internal functions
Function, result-position: Internal functions
Function, result-root-cause: Internal functions
Function, result-suitable-for-report-part-p: Internal functions
Function, result-trivial-predicate-p: Internal functions
Function, result-unsatisfied-predicate-p: Internal functions
Function, rule-dependencies: Exported functions
Function, rule-direct-dependencies: Internal functions
Function, rule-expression: Exported functions
Function, rule-suitable-for-report-part-p: Internal functions
Function, set-cell-info: Internal functions
Function, singleton-option: Internal functions
Function, sort-dependencies: Internal functions
Function, successful-parse-%position: Internal functions
Function, successful-parse-%production: Internal functions
Function, successful-parse-detail: Internal functions
Function, successful-parse-expression: Internal functions
Function, successful-parse-p: Internal functions
Function, successful-parse-production: Internal functions
Function, text: Exported functions
Function, trace-rule: Exported functions
Function, undefined-rule: Internal functions
Function, undefined-rule-function: Internal functions
Function, untrace-rule: Exported functions

G
Generic Function, (setf esrap-parse-error-%context): Internal generic functions
Generic Function, esrap-error-position: Exported generic functions
Generic Function, esrap-error-text: Exported generic functions
Generic Function, esrap-parse-error-%context: Internal generic functions
Generic Function, esrap-parse-error-context: Exported generic functions
Generic Function, esrap-parse-error-result: Exported generic functions
Generic Function, invalid-expression-error-expression: Exported generic functions
Generic Function, left-recursion-nonterminal: Exported generic functions
Generic Function, left-recursion-path: Exported generic functions
Generic Function, rule-around: Internal generic functions
Generic Function, rule-condition: Internal generic functions
Generic Function, rule-error-report: Internal generic functions
Generic Function, rule-guard-expression: Internal generic functions
Generic Function, rule-symbol: Exported generic functions
Generic Function, rule-transform: Internal generic functions
Generic Function, undefined-rule-symbol: Exported generic functions
get-cached: Internal functions
get-head: Internal functions

H
head-eval-set: Internal functions
head-involved-set: Internal functions
head-rule: Internal functions
hint-slime-indentation: Internal functions

I
inactive-rule-%position: Internal functions
inactive-rule-detail: Internal functions
inactive-rule-expression: Internal functions
inactive-rule-p: Internal functions
inactive-rule-rule: Internal functions
invalid-expression-error: Exported functions
invalid-expression-error-expression: Exported generic functions
invalid-expression-error-expression: Exported generic functions

L
left-recursion: Exported functions
left-recursion-nonterminal: Exported generic functions
left-recursion-nonterminal: Exported generic functions
left-recursion-path: Exported generic functions
left-recursion-path: Exported generic functions
left-recursion-result-%position: Internal functions
left-recursion-result-detail: Internal functions
left-recursion-result-expression: Internal functions
left-recursion-result-head: Internal functions
left-recursion-result-p: Internal functions
left-recursion-result-rule: Internal functions
list-of-result-productions: Internal functions
list-of-result-productions/butlast: Internal functions

M
Macro, defrule: Exported macros
Macro, expression-case: Internal macros
Macro, expression-lambda: Internal macros
Macro, make-successful-parse: Internal macros
Macro, with-cached-result: Internal macros
Macro, with-current-source-form: Internal macros
Macro, with-expression: Internal macros
Macro, with-pushed-nonterminal: Internal macros
make-cache: Internal functions
make-context: Internal functions
make-failed-parse: Internal functions
make-failed-parse/no-position: Internal functions
make-head: Internal functions
make-heads: Internal functions
make-inactive-rule: Internal functions
make-left-recursion-result: Internal functions
make-ordered-choise-result: Internal functions
make-rule-cell: Internal functions
make-successful-parse: Internal macros
map-max-leaf-results: Internal functions
map-max-results: Internal functions
map-results: Internal functions
match-terminal/1/case-insensitive-p: Internal functions
match-terminal/1/case-sensitive-p: Internal functions
match-terminal/case-insensitive-p: Internal functions
match-terminal/case-sensitive-p: Internal functions
max-of-result-positions: Internal functions
maybe-augment-inactive-rules: Internal functions
Method, (setf esrap-parse-error-%context): Internal generic functions
Method, esrap-error-position: Exported generic functions
Method, esrap-error-position: Exported generic functions
Method, esrap-error-text: Exported generic functions
Method, esrap-parse-error-%context: Internal generic functions
Method, esrap-parse-error-context: Exported generic functions
Method, esrap-parse-error-result: Exported generic functions
Method, invalid-expression-error-expression: Exported generic functions
Method, left-recursion-nonterminal: Exported generic functions
Method, left-recursion-path: Exported generic functions
Method, rule-around: Internal generic functions
Method, rule-condition: Internal generic functions
Method, rule-error-report: Internal generic functions
Method, rule-guard-expression: Internal generic functions
Method, rule-symbol: Exported generic functions
Method, rule-transform: Internal generic functions
Method, undefined-rule-symbol: Exported generic functions

P
parse: Exported compiler macros
parse: Exported functions
parse-defrule-options: Internal functions
parse-lambda-list-maybe-containing-&bounds: Internal functions
partition-results: Internal functions
print-result: Internal functions
print-terminal: Internal functions
process-parse-result: Internal functions

R
recall: Internal functions
reference-rule-cell: Internal functions
remove-rule: Exported functions
resolve-function: Internal functions
result-%position: Internal functions
result-context: Internal functions
result-detail: Internal functions
result-expected-input: Internal functions
result-expression: Internal functions
result-nonterminal-p: Internal functions
result-p: Internal functions
result-position: Internal functions
result-root-cause: Internal functions
result-suitable-for-report-part-p: Internal functions
result-trivial-predicate-p: Internal functions
result-unsatisfied-predicate-p: Internal functions
rule-around: Internal generic functions
rule-around: Internal generic functions
rule-condition: Internal generic functions
rule-condition: Internal generic functions
rule-dependencies: Exported functions
rule-direct-dependencies: Internal functions
rule-error-report: Internal generic functions
rule-error-report: Internal generic functions
rule-expression: Exported functions
rule-guard-expression: Internal generic functions
rule-guard-expression: Internal generic functions
rule-suitable-for-report-part-p: Internal functions
rule-symbol: Exported generic functions
rule-symbol: Exported generic functions
rule-transform: Internal generic functions
rule-transform: Internal generic functions

S
set-cell-info: Internal functions
singleton-option: Internal functions
sort-dependencies: Internal functions
successful-parse-%position: Internal functions
successful-parse-%production: Internal functions
successful-parse-detail: Internal functions
successful-parse-expression: Internal functions
successful-parse-p: Internal functions
successful-parse-production: Internal functions

T
text: Exported functions
trace-rule: Exported functions

U
undefined-rule: Internal functions
undefined-rule-function: Internal functions
undefined-rule-symbol: Exported generic functions
undefined-rule-symbol: Exported generic functions
untrace-rule: Exported functions

W
with-cached-result: Internal macros
with-current-source-form: Internal macros
with-expression: Internal macros
with-pushed-nonterminal: Internal macros

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

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

A.3 Variables

Jump to:   %   *  
C   D   E   H   I   N   P   R   S   T  
Index Entry  Section

%
%around: Exported classes
%condition: Exported classes
%context: Exported conditions
%error-report: Exported classes
%expression: Exported classes
%guard-expression: Exported classes
%info: Internal structures
%position: Internal structures
%production: Internal structures
%symbol: Exported classes
%transform: Exported classes

*
*context*: Internal special variables
*current-rule*: Internal special variables
*eval-nonterminals*: Internal special variables
*expression-kinds*: Internal special variables
*indentation-hint-table*: Internal special variables
*on-left-recursion*: Exported special variables
*result-pprint-dispatch*: Internal special variables
*rules*: Internal special variables
*trace-level*: Internal special variables

C
cache: Internal structures

D
detail: Internal structures

E
eval-set: Internal structures
expression: Exported conditions
expression: Internal structures

H
head: Internal structures
heads: Internal structures

I
involved-set: Internal structures

N
nonterminal: Exported conditions
nonterminal-stack: Internal structures

P
path: Exported conditions
position: Exported conditions

R
referents: Internal structures
result: Exported conditions
rule: Internal structures

S
Slot, %around: Exported classes
Slot, %condition: Exported classes
Slot, %context: Exported conditions
Slot, %error-report: Exported classes
Slot, %expression: Exported classes
Slot, %guard-expression: Exported classes
Slot, %info: Internal structures
Slot, %position: Internal structures
Slot, %production: Internal structures
Slot, %symbol: Exported classes
Slot, %transform: Exported classes
Slot, cache: Internal structures
Slot, detail: Internal structures
Slot, eval-set: Internal structures
Slot, expression: Exported conditions
Slot, expression: Internal structures
Slot, head: Internal structures
Slot, heads: Internal structures
Slot, involved-set: Internal structures
Slot, nonterminal: Exported conditions
Slot, nonterminal-stack: Internal structures
Slot, path: Exported conditions
Slot, position: Exported conditions
Slot, referents: Internal structures
Slot, result: Exported conditions
Slot, rule: Internal structures
Slot, symbol: Internal conditions
Slot, text: Exported conditions
Slot, trace-info: Internal structures
Special Variable, *context*: Internal special variables
Special Variable, *current-rule*: Internal special variables
Special Variable, *eval-nonterminals*: Internal special variables
Special Variable, *expression-kinds*: Internal special variables
Special Variable, *indentation-hint-table*: Internal special variables
Special Variable, *on-left-recursion*: Exported special variables
Special Variable, *result-pprint-dispatch*: Internal special variables
Special Variable, *rules*: Internal special variables
Special Variable, *trace-level*: Internal special variables
symbol: Internal conditions

T
text: Exported conditions
trace-info: Internal structures

Jump to:   %   *  
C   D   E   H   I   N   P   R   S   T  

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

A.4 Data types

Jump to:   C   E   F   H   I   L   N   P   R   S   T   U  
Index Entry  Section

C
character-range: Internal types
Class, rule: Exported classes
Condition, esrap-error: Exported conditions
Condition, esrap-parse-error: Exported conditions
Condition, invalid-expression-error: Exported conditions
Condition, left-recursion: Exported conditions
Condition, undefined-rule: Internal conditions
Condition, undefined-rule-error: Exported conditions
context: Internal structures

E
error-report-part: Internal types
error-result: Internal structures
esrap: The esrap system
esrap: The esrap package
esrap-error: Exported conditions
esrap-parse-error: Exported conditions

F
failed-parse: Internal structures

H
head: Internal structures

I
inactive-rule: Internal structures
input-length: Internal types
input-position: Internal types
invalid-expression-error: Exported conditions

L
left-recursion: Exported conditions
left-recursion-policy: Internal types
left-recursion-result: Internal structures

N
nonterminal: Internal types

P
Package, esrap: The esrap package
predicate: Internal types
predicate-name: Internal types

R
result: Internal structures
rule: Exported classes
rule-cell: Internal structures
rule-error-report: Internal types
rule-error-report-pattern: Internal types

S
Structure, context: Internal structures
Structure, error-result: Internal structures
Structure, failed-parse: Internal structures
Structure, head: Internal structures
Structure, inactive-rule: Internal structures
Structure, left-recursion-result: Internal structures
Structure, result: Internal structures
Structure, rule-cell: Internal structures
Structure, successful-parse: Internal structures
successful-parse: Internal structures
System, esrap: The esrap system

T
terminal: Internal types
Type, character-range: Internal types
Type, error-report-part: Internal types
Type, input-length: Internal types
Type, input-position: Internal types
Type, left-recursion-policy: Internal types
Type, nonterminal: Internal types
Type, predicate: Internal types
Type, predicate-name: Internal types
Type, rule-error-report: Internal types
Type, rule-error-report-pattern: Internal types
Type, terminal: Internal types

U
undefined-rule: Internal conditions
undefined-rule-error: Exported conditions

Jump to:   C   E   F   H   I   L   N   P   R   S   T   U