The esrap Reference Manual

Table of Contents

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.

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

2 Systems

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

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

• src (module)
• examples (module)
• readme.org (file)

3 Modules

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

3.1 esrap/src

Parent

esrap (system)

Location

src/

Components

• package.lisp (file)
• types.lisp (file)
• protocol.lisp (file)
• variables.lisp (file)
• conditions.lisp (file)
• expressions.lisp (file)
• rule.lisp (file)
• results.lisp (file)
• cache.lisp (file)
• evaluator.lisp (file)
• macros.lisp (file)
• interface.lisp (file)
• editor-support.lisp (file)

3.2 esrap/examples

Parent

esrap (system)

Location

examples/

Components

• sexp.lisp (file)
• symbol-table.lisp (file)
• left-recursion.lisp (file)
• function-terminals.lisp (file)

4 Files

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

4.1 Lisp

4.1.1 esrap.asd

Location

esrap.asd

Systems

esrap (system)

4.1.2 esrap/src/package.lisp

Parent

src (module)

Location

src/package.lisp

Packages

esrap

4.1.3 esrap/src/types.lisp

Dependency

package.lisp (file)

Parent

src (module)

Location

src/types.lisp

Internal Definitions

• character-range (type)
• error-report-behavior-suitable-for-report-part-p (function)
• error-report-part (type)
• input-length (type)
• input-position (type)
• left-recursion-policy (type)
• nonterminal (type)
• predicate (type)
• predicate-name (type)
• rule-error-report (type)
• rule-error-report-pattern (type)
• terminal (type)

4.1.4 esrap/src/protocol.lisp

Dependency

types.lisp (file)

Parent

src (module)

Location

src/protocol.lisp

Exported Definitions

• esrap-error-position (generic function)
• esrap-parse-error-context (generic function)
• esrap-parse-error-result (generic function)

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)

4.1.6 esrap/src/conditions.lisp

Dependency

variables.lisp (file)

Parent

src (module)

Location

src/conditions.lisp

Exported Definitions

• esrap-error (condition)
• esrap-error-position (method)
• esrap-error-position (method)
• esrap-error-text (method)
• esrap-parse-error (function)
• esrap-parse-error (condition)
• esrap-parse-error-context (method)
• esrap-parse-error-result (method)
• invalid-expression-error (function)
• invalid-expression-error (condition)
• invalid-expression-error-expression (method)
• left-recursion (function)
• left-recursion (condition)
• left-recursion-nonterminal (method)
• left-recursion-path (method)
• undefined-rule-error (condition)
• undefined-rule-symbol (method)

Internal Definitions

• esrap-parse-error-%context (method)
• (setf esrap-parse-error-%context) (method)
• undefined-rule (function)
• undefined-rule (condition)

4.1.7 esrap/src/expressions.lisp

Dependency

conditions.lisp (file)

Parent

src (module)

Location

src/expressions.lisp

Exported Definitions

• describe-terminal (function)
• expression-start-terminals (function)

Internal Definitions

• %expression-dependencies (function)
• %expression-direct-dependencies (function)
• *expression-kinds* (special variable)
• check-expression (function)
• check-function-reference (function)
• expression-case (macro)
• expression-equal-p (function)
• expression< (function)
• print-terminal (function)
• with-expression (macro)

4.1.8 esrap/src/rule.lisp

Dependency

expressions.lisp (file)

Parent

src (module)

Location

src/rule.lisp

Exported Definitions

• rule (class)
• rule-dependencies (function)
• rule-symbol (method)

Internal Definitions

• %rule-direct-dependencies (function)
• *rules* (special variable)
• cell-%info (function)
• (setf cell-%info) (function)
• cell-function (function)
• cell-referents (function)
• (setf cell-referents) (function)
• cell-rule (function)
• cell-trace-info (function)
• (setf cell-trace-info) (function)
• clear-rules (function)
• delete-rule-cell (function)
• dereference-rule-cell (function)
• detach-rule (function)
• ensure-rule-cell (function)
• find-rule-cell (function)
• make-rule-cell (function)
• reference-rule-cell (function)
• rule-around (method)
• rule-cell (structure)
• rule-condition (method)
• rule-direct-dependencies (function)
• rule-error-report (method)
• rule-guard-expression (method)
• rule-suitable-for-report-part-p (function)
• rule-transform (method)
• set-cell-info (function)
• sort-dependencies (function)
• undefined-rule-function (function)

4.1.9 esrap/src/results.lisp

Dependency

rule.lisp (file)

Parent

src (module)

Location

src/results.lisp

Internal Definitions

• %make-successful-parse (function)
• *result-pprint-dispatch* (special variable)
• error-report (function)
• error-result (structure)
• error-result-%position (function)
• (setf error-result-%position) (function)
• error-result-detail (function)
• error-result-expression (function)
• error-result-p (function)
• failed-parse (structure)
• failed-parse-%position (function)
• (setf failed-parse-%position) (function)
• failed-parse-detail (function)
• failed-parse-expression (function)
• failed-parse-p (function)
• flattened-children (function)
• inactive-rule (structure)
• inactive-rule-%position (function)
• (setf inactive-rule-%position) (function)
• inactive-rule-detail (function)
• inactive-rule-expression (function)
• inactive-rule-p (function)
• inactive-rule-rule (function)
• left-recursion-result (structure)
• left-recursion-result-%position (function)
• (setf left-recursion-result-%position) (function)
• left-recursion-result-detail (function)
• left-recursion-result-expression (function)
• left-recursion-result-head (function)
• (setf left-recursion-result-head) (function)
• left-recursion-result-p (function)
• left-recursion-result-rule (function)
• list-of-result-productions (function)
• list-of-result-productions/butlast (function)
• make-failed-parse (function)
• make-failed-parse/no-position (function)
• make-inactive-rule (function)
• make-left-recursion-result (function)
• make-successful-parse (macro)
• map-max-leaf-results (function)
• map-max-results (function)
• map-results (function)
• max-of-result-positions (function)
• maybe-augment-inactive-rules (function)
• partition-results (function)
• print-result (function)
• result (structure)
• result-%position (function)
• (setf result-%position) (function)
• result-context (function)
• result-detail (function)
• result-expected-input (function)
• result-expression (function)
• result-nonterminal-p (function)
• result-p (function)
• result-position (function)
• result-root-cause (function)
• result-suitable-for-report-part-p (function)
• result-trivial-predicate-p (function)
• result-unsatisfied-predicate-p (function)
• successful-parse (structure)
• successful-parse-%position (function)
• (setf successful-parse-%position) (function)
• successful-parse-%production (function)
• (setf successful-parse-%production) (function)
• successful-parse-detail (function)
• successful-parse-expression (function)
• successful-parse-p (function)
• successful-parse-production (function)

4.1.10 esrap/src/cache.lisp

Dependency

results.lisp (file)

Parent

src (module)

Location

src/cache.lisp

Internal Definitions

• *context* (special variable)
• context (structure)
• context-cache (function)
• context-heads (function)
• context-nonterminal-stack (function)
• (setf context-nonterminal-stack) (function)
• context-p (function)
• copy-context (function)
• get-cached (function)
• (setf get-cached) (function)
• get-head (function)
• (setf get-head) (function)
• head (structure)
• head-eval-set (function)
• (setf head-eval-set) (function)
• head-involved-set (function)
• (setf head-involved-set) (function)
• head-rule (function)
• (setf head-rule) (function)
• make-cache (function)
• make-context (function)
• make-head (function)
• make-heads (function)
• recall (function)
• with-cached-result (macro)
• with-pushed-nonterminal (macro)

4.1.11 esrap/src/evaluator.lisp

Dependency

cache.lisp (file)

Parent

src (module)

Location

src/evaluator.lisp

Internal Definitions

• *current-rule* (special variable)
• analyze-ordered-choise (function)
• check-ordered-choise-prefix (function)
• compile-character (function)
• compile-character-ranges (function)
• compile-expression (function)
• compile-followed-by (function)
• compile-greedy-positive-repetition (function)
• compile-greedy-repetition (function)
• compile-look-ahead (function)
• compile-look-behind (function)
• compile-negation (function)
• compile-nonterminal (function)
• compile-not-followed-by (function)
• compile-optional (function)
• compile-ordered-choise (function)
• compile-rule (function)
• compile-semantic-predicate (function)
• compile-sequence (function)
• compile-string (function)
• compile-terminal (function)
• compile-terminal-function (function)
• eval-character (function)
• eval-character-ranges (function)
• eval-expression (function)
• eval-followed-by (function)
• eval-greedy-positive-repetition (function)
• eval-greedy-repetition (function)
• eval-look-ahead (function)
• eval-look-behind (function)
• eval-negation (function)
• eval-nonterminal (function)
• eval-not-followed-by (function)
• eval-optional (function)
• eval-ordered-choise (function)
• eval-semantic-predicate (function)
• eval-sequence (function)
• eval-string (function)
• eval-terminal (function)
• eval-terminal-function (function)
• exec-character-ranges (function)
• exec-negation (function)
• exec-nonterminal (function)
• exec-string (function)
• exec-terminal-function (function)
• expression-lambda (macro)
• make-ordered-choise-result (function)
• match-terminal/1/case-insensitive-p (function)
• match-terminal/1/case-sensitive-p (function)
• match-terminal/case-insensitive-p (function)
• match-terminal/case-sensitive-p (function)
• resolve-function (function)

4.1.12 esrap/src/macros.lisp

Dependency

evaluator.lisp (file)

Parent

src (module)

Location

src/macros.lisp

Exported Definitions

text (function)

Internal Definitions

• check-lambda-list (function)
• expand-transforms (function)
• parse-defrule-options (function)
• parse-lambda-list-maybe-containing-&bounds (function)
• singleton-option (function)
• with-current-source-form (macro)

4.1.13 esrap/src/interface.lisp

Dependency

macros.lisp (file)

Parent

src (module)

Location

src/interface.lisp

Exported Definitions

• add-rule (function)
• change-rule (function)
• defrule (macro)
• describe-grammar (function)
• find-rule (function)
• parse (compiler macro)
• parse (function)
• remove-rule (function)
• rule-expression (function)
• (setf rule-expression) (function)
• trace-rule (function)
• untrace-rule (function)

Internal Definitions

• *trace-level* (special variable)
• process-parse-result (function)

4.1.14 esrap/src/editor-support.lisp

Dependency

interface.lisp (file)

Parent

src (module)

Location

src/editor-support.lisp

Internal Definitions

• *indentation-hint-table* (special variable)
• hint-slime-indentation (function)

4.2 Other

4.2.1 esrap/examples/sexp.lisp

Parent

examples (module)

Location

examples/sexp.lisp

4.2.2 esrap/examples/symbol-table.lisp

Parent

examples (module)

Location

examples/symbol-table.lisp

4.2.3 esrap/examples/left-recursion.lisp

Parent

examples (module)

Location

examples/left-recursion.lisp

4.2.4 esrap/examples/function-terminals.lisp

Parent

examples (module)

Location

examples/function-terminals.lisp

4.2.5 esrap/README.org

Parent

esrap (system)

Location

README.org

5 Packages

Packages are listed by definition order.

5.1 esrap

Source

package.lisp (file)

Use List

• alexandria.0.dev
• common-lisp

Exported Definitions

• *on-left-recursion* (special variable)
• add-rule (function)
• change-rule (function)
• defrule (macro)
• describe-grammar (function)
• describe-terminal (function)
• esrap-error (condition)
• esrap-error-position (generic function)
• esrap-error-position (method)
• esrap-error-position (method)
• esrap-error-text (generic function)
• esrap-error-text (method)
• esrap-parse-error (function)
• esrap-parse-error (condition)
• esrap-parse-error-context (generic function)
• esrap-parse-error-context (method)
• esrap-parse-error-result (generic function)
• esrap-parse-error-result (method)
• expression-start-terminals (function)
• find-rule (function)
• invalid-expression-error (function)
• invalid-expression-error (condition)
• invalid-expression-error-expression (generic function)
• invalid-expression-error-expression (method)
• left-recursion (function)
• left-recursion (condition)
• left-recursion-nonterminal (generic function)
• left-recursion-nonterminal (method)
• left-recursion-path (generic function)
• left-recursion-path (method)
• parse (compiler macro)
• parse (function)
• remove-rule (function)
• rule (class)
• rule-dependencies (function)
• rule-expression (function)
• (setf rule-expression) (function)
• rule-symbol (generic function)
• rule-symbol (method)
• text (function)
• trace-rule (function)
• undefined-rule-error (condition)
• undefined-rule-symbol (generic function)
• undefined-rule-symbol (method)
• untrace-rule (function)

Internal Definitions

• %expression-dependencies (function)
• %expression-direct-dependencies (function)
• %make-successful-parse (function)
• %rule-direct-dependencies (function)
• *context* (special variable)
• *current-rule* (special variable)
• *eval-nonterminals* (special variable)
• *expression-kinds* (special variable)
• *indentation-hint-table* (special variable)
• *result-pprint-dispatch* (special variable)
• *rules* (special variable)
• *trace-level* (special variable)
• analyze-ordered-choise (function)
• cell-%info (function)
• (setf cell-%info) (function)
• cell-function (function)
• cell-referents (function)
• (setf cell-referents) (function)
• cell-rule (function)
• cell-trace-info (function)
• (setf cell-trace-info) (function)
• character-range (type)
• check-expression (function)
• check-function-reference (function)
• check-lambda-list (function)
• check-ordered-choise-prefix (function)
• clear-rules (function)
• compile-character (function)
• compile-character-ranges (function)
• compile-expression (function)
• compile-followed-by (function)
• compile-greedy-positive-repetition (function)
• compile-greedy-repetition (function)
• compile-look-ahead (function)
• compile-look-behind (function)
• compile-negation (function)
• compile-nonterminal (function)
• compile-not-followed-by (function)
• compile-optional (function)
• compile-ordered-choise (function)
• compile-rule (function)
• compile-semantic-predicate (function)
• compile-sequence (function)
• compile-string (function)
• compile-terminal (function)
• compile-terminal-function (function)
• context (structure)
• context-cache (function)
• context-heads (function)
• context-nonterminal-stack (function)
• (setf context-nonterminal-stack) (function)
• context-p (function)
• copy-context (function)
• delete-rule-cell (function)
• dereference-rule-cell (function)
• detach-rule (function)
• ensure-rule-cell (function)
• error-report (function)
• error-report-behavior-suitable-for-report-part-p (function)
• error-report-part (type)
• error-result (structure)
• error-result-%position (function)
• (setf error-result-%position) (function)
• error-result-detail (function)
• error-result-expression (function)
• error-result-p (function)
• esrap-parse-error-%context (generic function)
• esrap-parse-error-%context (method)
• (setf esrap-parse-error-%context) (method)
• (setf esrap-parse-error-%context) (generic function)
• eval-character (function)
• eval-character-ranges (function)
• eval-expression (function)
• eval-followed-by (function)
• eval-greedy-positive-repetition (function)
• eval-greedy-repetition (function)
• eval-look-ahead (function)
• eval-look-behind (function)
• eval-negation (function)
• eval-nonterminal (function)
• eval-not-followed-by (function)
• eval-optional (function)
• eval-ordered-choise (function)
• eval-semantic-predicate (function)
• eval-sequence (function)
• eval-string (function)
• eval-terminal (function)
• eval-terminal-function (function)
• exec-character-ranges (function)
• exec-negation (function)
• exec-nonterminal (function)
• exec-string (function)
• exec-terminal-function (function)
• expand-transforms (function)
• expression-case (macro)
• expression-equal-p (function)
• expression-lambda (macro)
• expression< (function)
• failed-parse (structure)
• failed-parse-%position (function)
• (setf failed-parse-%position) (function)
• failed-parse-detail (function)
• failed-parse-expression (function)
• failed-parse-p (function)
• find-rule-cell (function)
• flattened-children (function)
• get-cached (function)
• (setf get-cached) (function)
• get-head (function)
• (setf get-head) (function)
• head (structure)
• head-eval-set (function)
• (setf head-eval-set) (function)
• head-involved-set (function)
• (setf head-involved-set) (function)
• head-rule (function)
• (setf head-rule) (function)
• hint-slime-indentation (function)
• inactive-rule (structure)
• inactive-rule-%position (function)
• (setf inactive-rule-%position) (function)
• inactive-rule-detail (function)
• inactive-rule-expression (function)
• inactive-rule-p (function)
• inactive-rule-rule (function)
• input-length (type)
• input-position (type)
• left-recursion-policy (type)
• left-recursion-result (structure)
• left-recursion-result-%position (function)
• (setf left-recursion-result-%position) (function)
• left-recursion-result-detail (function)
• left-recursion-result-expression (function)
• left-recursion-result-head (function)
• (setf left-recursion-result-head) (function)
• left-recursion-result-p (function)
• left-recursion-result-rule (function)
• list-of-result-productions (function)
• list-of-result-productions/butlast (function)
• make-cache (function)
• make-context (function)
• make-failed-parse (function)
• make-failed-parse/no-position (function)
• make-head (function)
• make-heads (function)
• make-inactive-rule (function)
• make-left-recursion-result (function)
• make-ordered-choise-result (function)
• make-rule-cell (function)
• make-successful-parse (macro)
• map-max-leaf-results (function)
• map-max-results (function)
• map-results (function)
• match-terminal/1/case-insensitive-p (function)
• match-terminal/1/case-sensitive-p (function)
• match-terminal/case-insensitive-p (function)
• match-terminal/case-sensitive-p (function)
• max-of-result-positions (function)
• maybe-augment-inactive-rules (function)
• nonterminal (type)
• parse-defrule-options (function)
• parse-lambda-list-maybe-containing-&bounds (function)
• partition-results (function)
• predicate (type)
• predicate-name (type)
• print-result (function)
• print-terminal (function)
• process-parse-result (function)
• recall (function)
• reference-rule-cell (function)
• resolve-function (function)
• result (structure)
• result-%position (function)
• (setf result-%position) (function)
• result-context (function)
• result-detail (function)
• result-expected-input (function)
• result-expression (function)
• result-nonterminal-p (function)
• result-p (function)
• result-position (function)
• result-root-cause (function)
• result-suitable-for-report-part-p (function)
• result-trivial-predicate-p (function)
• result-unsatisfied-predicate-p (function)
• rule-around (generic function)
• rule-around (method)
• rule-cell (structure)
• rule-condition (generic function)
• rule-condition (method)
• rule-direct-dependencies (function)
• rule-error-report (generic function)
• rule-error-report (method)
• rule-error-report (type)
• rule-error-report-pattern (type)
• rule-guard-expression (generic function)
• rule-guard-expression (method)
• rule-suitable-for-report-part-p (function)
• rule-transform (generic function)
• rule-transform (method)
• set-cell-info (function)
• singleton-option (function)
• sort-dependencies (function)
• successful-parse (structure)
• successful-parse-%position (function)
• (setf successful-parse-%position) (function)
• successful-parse-%production (function)
• (setf successful-parse-%production) (function)
• successful-parse-detail (function)
• successful-parse-expression (function)
• successful-parse-p (function)
• successful-parse-production (function)
• terminal (type)
• undefined-rule (function)
• undefined-rule (condition)
• undefined-rule-function (function)
• with-cached-result (macro)
• with-current-source-form (macro)
• with-expression (macro)
• with-pushed-nonterminal (macro)

6 Definitions

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

6.1 Exported definitions

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)

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)

6.1.3 Compiler macros

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

Package

esrap

Source

interface.lisp (file)

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)

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)

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

• esrap-parse-error (condition)
• left-recursion (condition)

Direct methods

• print-object (method)
• esrap-error-text (method)

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

• print-object (method)
• esrap-parse-error-context (method)
• esrap-error-position (method)
• esrap-parse-error-%context (method)
• esrap-parse-error-%context (method)
• esrap-parse-error-result (method)

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

Initarg	Value
: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

• print-object (method)
• invalid-expression-error-expression (method)

Direct slots

Slot: expression

Initargs

:expression

Readers

invalid-expression-error-expression (generic function)

Direct Default Initargs

Initarg	Value
: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

• print-object (method)
• left-recursion-path (method)
• left-recursion-nonterminal (method)
• esrap-error-position (method)

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

• error (condition)
• undefined-rule (condition)

6.1.7 Classes

Class: rule ()

Package

esrap

Source

rule.lisp (file)

Direct superclasses

standard-object (class)

Direct methods

• print-object (method)
• shared-initialize (method)
• rule-error-report (method)
• rule-around (method)
• rule-transform (method)
• rule-condition (method)
• rule-guard-expression (method)
• rule-symbol (method)

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)

6.2 Internal definitions

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)

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)

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)