The esrap-liquid Reference Manual

Table of Contents

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

The esrap-liquid Reference Manual

This is the esrap-liquid Reference Manual, version 2.3, generated automatically by Declt version 2.4 "Will Decker" on Wed Jun 20 11:44:40 2018 GMT+0.


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

1 Introduction

ESRAP-LIQUID

MAJOR API CHANGE IN VERSIONS 2.*: we no longer use codewalker, hence rule definitions now compile much faster. The price to pay is that sometimes you need to specify manually, that something is a sub-rule (see V-macrolet in source and section "API Change" in this README).

Packrat parser generator, with possibility to use full Common Lisp when defining parsing rules.

It started as a fork of ESRAP by Nikodemus Siivola (https://github.com/nikodemus/esrap), which is a DSL with (somewhat) more rigid syntax, but (as of now) nicer error reports.

Original idea of a packrat parser generator is described in this article:

Operates both on strings and streams -- see section "Streaming" below.

Examples:

; plain characters match to precisely that character in text
ESRAP-LIQUID> (parse '#\a "a")
#\a
1
ESRAP-LIQUID> (parse '#\a "b")
#<ESRAP-LIQUID::SIMPLE-ESRAP-ERROR "~a~%">.
; same goes for plain strings
ESRAP-LIQUID> (parse '"foo" "foo")
"foo"
3
ESRAP-LIQUID> (parse '"foo" "bar")
#<ESRAP-LIQUID::SIMPLE-ESRAP-ERROR "~a~%">.
; CHARACTER matches any single character
ESRAP-LIQUID> (parse 'character "a")
#\a
1
ESRAP-LIQUID> (parse 'character "b")
#\b
1
; (ANY-STRING <LENGTH>) matches any string of a given length character
ESRAP-LIQUID> (parse '(any-string 3) "foo")
"foo"
3
ESRAP-LIQUID> (parse '(any-string 3) "bar")
"bar"
3
ESRAP-LIQUID> (parse '(any-string 3) "caboom!")
#<ESRAP-LIQUID::SIMPLE-ESRAP-ERROR "~a~%">.
; (!! <EXPR>) matches, whenever EXPR fails and consumes one character
ESRAP-LIQUID> (parse '(!! "foo") "bar" :junk-allowed t)
#\b
1
ESRAP-LIQUID> (parse '(!! "foo") "foo")
#<ESRAP-LIQUID::SIMPLE-ESRAP-ERROR "~a~%">.
; (|| &rest <EXPRS>) is an ordered choice, matches, whenever one of EXPRS succeeds, and outputs it
ESRAP-LIQUID> (parse '(|| #\a #\b) "a")
#\a
1
ESRAP-LIQUID> (parse '(|| #\a #\b) "b")
#\b
1
ESRAP-LIQUID> (parse '(|| #\a #\b) "c")
#<ESRAP-LIQUID::SIMPLE-ESRAP-ERROR "~a~%">.
; (times <EXPR> &key from upto exactly) greedy matches expression multiple times, returns values as a list.
; If :UPTO or :EXACTLY is given, then consumes only that much exprs, even if there are more
; if :FROM is given, fails if consumed less than :FROM expressions
ESRAP-LIQUID> (parse '(times #\a) "")
NIL
0
ESRAP-LIQUID> (parse '(times #\a) "aaa")
(#\a #\a #\a)
3
ESRAP-LIQUID> (parse '(times #\a :exactly 6) "aaaaaa")
(#\a #\a #\a #\a #\a #\a)
6
ESRAP-LIQUID> (parse '(times #\a :exactly 6) "aaa")
#<ESRAP-LIQUID::SIMPLE-ESRAP-ERROR "~a~%">.
; (postimes <EXPR>) is an alias for (times <EXPR> :from 1)
ESRAP-LIQUID> (parse '(postimes #\a) "")
#<ESRAP-LIQUID::SIMPLE-ESRAP-ERROR "~a~%">.
ESRAP-LIQUID> (parse '(postimes #\a) "aaa")
(#\a #\a #\a)
3
; (? <EXPR>) returns result of parsing of EXPR, when parsing succeeds, and NIL otherwise, does not fail
ESRAP-LIQUID> (parse '(? #\a) "")
NIL
0
ESRAP-LIQUID> (parse '(? #\a) "a")
#\a
1

Other operators, defined by ESRAP-LIQUID, include:

Typical idioms:

; succeed, when all subexpressions succeed, return list of those subexpressions
; Note that now you need to explicitly write (V ...) in order to indicate that
; character means "try to parse this character"
ESRAP-LIQUID> (parse '(list (v #\a) (v #\b) (v #\c)) "abc")
(#\a #\b #\c)
3
; succeed, when all subexpression succeed, return only last subexpression
ESRAP-LIQUID> (parse '(progn (v #\a) (v #\b) (v #\c)) "abc")
#\c
3
; succeed, when all subexpression succeed, return only first subexpression
ESRAP-LIQUID> (parse '(prog1 (v #\a) (v #\b) (v #\c)) "abc")
#\a
3

For more examples, see example-sexp.lisp, example-symbol-table.lisp, example-very-context-sensitive.lisp. For more real-life examples see my YAML parser https://github.com/mabragor/cl-yaclyaml. The parsing part uses ESRAP-LIQUID extensively, in particular, in ways different from traditional ESRAP.

Defining rules

Of course, if you could only write one-liners with PARSE, it won't be interesting at all So, you can define new rules using DEFRULE macro.

ESRAP-LIQUID> (defrule foo+ ()
                (postimes "foo"))
ESRAP-LIQUID> (parse 'foo+ "foofoofoo")
("foo" "foo" "foo")
; simple arguments to rules are also possible
ESRAP-LIQUID> (defrule foo-times (times)
                (times "foo" :exactly times))
ESRAP-LIQUID> (parse '(v foo-times 3) "foofoofoo")
("foo" "foo" "foo")
ESRAP-LIQUID> (parse '(v foo-times 4) "foofoofoo")
#<ESRAP-LIQUID::SIMPLE-ESRAP-ERROR "~a~%">.

Defining esrap-environments

Usually you don't want to mix parsing rules for different projects -- you want a mechanism to scope your rules in some way. For that you can use DEFINE-ESRAP-ENV macro.

(define-esrap-env foobar)

;; Now we can define rules in 'foobar' scope
(define-foobar-rule asdf ()
   ... ; rule definition here)

DEFINE-ESRAP-ENV has a MAINLY-NON-CONTEXT key. If it's T, then DEFINE-$(NAME)-RULE expands into DEF-NOCONTEXT-RULE, rather than DEFRULE. It's still possible to get context-sensitive rules by using DEFINE-C-$(NAME)-RULE. Vice versa, if MAINLY-NON-CONTEXT key is NIL (default), then non-context-sensitive rules can be defined using DEFINE-NC-$(NAME)-RULE.

Capturing-variables : CAP, RECAP, RECAP?

Analogously to capturing groups in regexps, it is possible to capture results of parsing of named rules, to aid destructuring.

Example: instead of clumsy

(define-rule dressed-rule-clumsy ()
  (prog1 (progn (v "foo") (v "bar") (v "baz")
                (v meat))
         (v "rest1") (v "rest2") (v "rest3")))

you may write something like

(define-rule dressed-rule-elegant ()
  (v "foo") (v "bar") (v "baz") (cap 1 meat) (v "rest1") (v "rest2") (v "rest3")
  (recap 1))

I.e. result of parsing of rule with name MEAT is stashed with CAP macro and then accessed using RECAP macro.

Difference between RECAP and RECAP? is that while the former fails parsing if the requested key was not captured, the latter just produces NIL.

See tests for examples of usage. Also see CL-MIZAR parsing.lisp, where this is used a lot.

Streaming

It's possible to parse both strings and streams. Main function for parsing streams is PARSE-STREAM.

Example of usage:

(parse-stream 'some-rule (make-string-input-stream "foobar") :junk-allowed t)

In general, both PARSE and PARSE-STREAMS are just wrappers around more general PARSE-TOKEN-ITER -- which accepts an iterator of tokens. Here, iterators are implemented "pythonic way", i.e. they are classes with NEXT-ITER method (the next method in Python), that throw STOP-ITERATION condition (the StopIteration exception in Python) when there are no more values.

Thus, if you want ESRAP-LIQUID to parse something other than string or stream, just grep for how PARSE-TOKEN-ITER is used.

Change : PARSE-TOKEN-ITER now wraps the iterator into esrap caching iterator, so you don't have to do it manually. Also now ESRAP-ENV makes $(ENVNAME)-PARSE-TOKEN-ITER function accessible.

Gotchas!

-- Since Lisp streams only allow to unread one character, and ESRAP-LIQUID in general does quite a lot of look-ahead, it's not safe to use a stream somewhere else after it was fed to PARSE-STREAM (even when :junk-allowed is set to T). This is because you don't know, what state the stream ends up in.

When you define esrap environment using DEFINE-ESRAP-ENV, say, like

(define-esrap-env foo)

you get both FOO-PARSE and FOO-PARSE-STREAM -- environment versions of main parsing functions.

API Change

In versions 1.* of ESRAP-LIQUID, we used the following implicit conventions, when defining rules:

These conventions are very handy when defining rules. However, the way they were implemented, is not optimal:

So now these conventions are not valid in the whole scope of DEFRULE, but only inside special macrolets. This allowed not to depend on codewalker and on special reader conventions. Now conventions are like this:

Update: it turned out that in practice one most commonly uses V-macrolet inside PROGN, LIST and PROG1 forms. So now ESRAP-LIQUID defines PROGN-V, LIST-V and PROG1-V versions, which work exactly as their non-V analogs, but wrap their sub-forms in DESCEND-WITH-RULE, where needed.

Thus, to make a transition of your ESRAP-LIQUID-using code to 2.* API, you need:


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-liquid

License

GPL

Description

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

Version

2.3

Dependencies
Source

esrap-liquid.asd (file)

Components

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

3 Modules

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


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

3.1 esrap-liquid/src

Parent

esrap-liquid (system)

Location

src/

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-liquid.asd

Location

esrap-liquid.asd

Systems

esrap-liquid (system)

Packages

esrap-liquid-system


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

4.1.2 esrap-liquid/src/package.lisp

Parent

src (module)

Location

src/package.lisp

Packages

esrap-liquid


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

4.1.3 esrap-liquid/src/conditions.lisp

Dependency

package.lisp (file)

Parent

src (module)

Location

src/conditions.lisp

Exported Definitions
Internal Definitions

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

4.1.4 esrap-liquid/src/miscellany.lisp

Dependency

conditions.lisp (file)

Parent

src (module)

Location

src/miscellany.lisp

Exported Definitions

text (function)


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

4.1.5 esrap-liquid/src/iterators.lisp

Dependency

miscellany.lisp (file)

Parent

src (module)

Location

src/iterators.lisp

Internal Definitions

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

4.1.6 esrap-liquid/src/rule-storage.lisp

Dependency

iterators.lisp (file)

Parent

src (module)

Location

src/rule-storage.lisp

Internal Definitions

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

4.1.7 esrap-liquid/src/memoization.lisp

Dependency

rule-storage.lisp (file)

Parent

src (module)

Location

src/memoization.lisp

Exported Definitions

register-context (macro)

Internal Definitions

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

4.1.8 esrap-liquid/src/macro.lisp

Dependency

memoization.lisp (file)

Parent

src (module)

Location

src/macro.lisp

Exported Definitions
Internal Definitions

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

4.1.9 esrap-liquid/src/esrap.lisp

Dependency

macro.lisp (file)

Parent

src (module)

Location

src/esrap.lisp

Exported Definitions
Internal Definitions

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

4.1.10 esrap-liquid/src/basic-rules.lisp

Dependency

esrap.lisp (file)

Parent

src (module)

Location

src/basic-rules.lisp

Exported Definitions

any-string (macro)

Internal Definitions

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

4.1.11 esrap-liquid/src/esrap-env.lisp

Dependency

basic-rules.lisp (file)

Parent

src (module)

Location

src/esrap-env.lisp

Exported Definitions
Internal Definitions

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

4.1.12 esrap-liquid/src/iter-extensions.lisp

Dependency

esrap-env.lisp (file)

Parent

src (module)

Location

src/iter-extensions.lisp

Internal Definitions

mk-tokenizer (function)


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

4.2 Other


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

4.2.1 esrap-liquid/example-sexp.lisp

Dependency

src (module)

Parent

esrap-liquid (system)

Location

example-sexp.lisp


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

4.2.2 esrap-liquid/example-symbol-table.lisp

Dependency

example-sexp.lisp (file)

Parent

esrap-liquid (system)

Location

example-symbol-table.lisp


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

4.2.3 esrap-liquid/README

Dependency

example-symbol-table.lisp (file)

Parent

esrap-liquid (system)

Location

/home/quickref/quicklisp/dists/quicklisp/software/esrap-liquid-20161031-git/README (not found)


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

5 Packages

Packages are listed by definition order.


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

5.1 esrap-liquid-system

Source

esrap-liquid.asd

Use List

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

5.2 esrap-liquid

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 Macros

Macro: &rest CLAUSES
Package

esrap-liquid

Source

macro.lisp (file)

Macro: ! EXPR

Succeeds, whenever parsing of EXPR fails. Does not consume, returns NIL, for compatibility with TEXT

Package

esrap-liquid

Source

macro.lisp (file)

Macro: !! EXPR

Succeeds, whenever parsing of EXPR fails. Consumes, assumes than EXPR parses just one character.

Package

esrap-liquid

Source

macro.lisp (file)

Macro: & SUBEXPR
Package

esrap-liquid

Source

macro.lisp (file)

Macro: -> SUBEXPR
Package

esrap-liquid

Source

macro.lisp (file)

Macro: <- SUBEXPR
Package

esrap-liquid

Source

macro.lisp (file)

Macro: ? SUBEXPR
Package

esrap-liquid

Source

macro.lisp (file)

Macro: any-string LENGTH
Package

esrap-liquid

Source

basic-rules.lisp (file)

Macro: character-ranges &rest CHAR-SPECS
Package

esrap-liquid

Source

esrap.lisp (file)

Macro: cond-parse &rest CLAUSES
Package

esrap-liquid

Source

macro.lisp (file)

Macro: define-esrap-env SYMBOL &key MAINLY-NON-CONTEXT
Package

esrap-liquid

Source

esrap-env.lisp (file)

Macro: defrule NAME ARGS &body BODY
Package

esrap-liquid

Source

macro.lisp (file)

Macro: descend-with-rule O!-SYM &rest ARGS
Package

esrap-liquid

Source

macro.lisp (file)

Macro: fail-parse &optional REASON
Package

esrap-liquid

Source

conditions.lisp (file)

Macro: fail-parse-format &optional REASON &rest ARGS
Package

esrap-liquid

Source

conditions.lisp (file)

Macro: in-esrap-env SYMBOL
Package

esrap-liquid

Source

esrap-env.lisp (file)

Macro: list-v &rest ARGS

LIST with automatic descent wrapping.

Package

esrap-liquid

Source

macro.lisp (file)

Macro: most-full-parse &rest CLAUSES
Package

esrap-liquid

Source

macro.lisp (file)

Macro: postimes SUBEXPR
Package

esrap-liquid

Source

macro.lisp (file)

Macro: pred PREDICATE SUBEXPR
Package

esrap-liquid

Source

macro.lisp (file)

Macro: prog1-v &rest FORMS

PROG1 with automatic descent wrapping.

Package

esrap-liquid

Source

macro.lisp (file)

Macro: progm START MEAT END

Prog Middle.

Package

esrap-liquid

Source

macro.lisp (file)

Macro: progn-v &rest FORMS

PROGN with automatic descent wrapping.

Package

esrap-liquid

Source

macro.lisp (file)

Macro: register-context CONTEXT-SYM
Package

esrap-liquid

Source

memoization.lisp (file)

Macro: times SUBEXPR &key FROM UPTO EXACTLY
Package

esrap-liquid

Source

macro.lisp (file)


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

6.1.2 Functions

Function: maybe-wrap-in-descent THING
Package

esrap-liquid

Source

macro.lisp (file)

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

Parses TEXT using EXPRESSION from START to END. Incomplete parses are allowed only if JUNK-ALLOWED is true.

Package

esrap-liquid

Source

esrap.lisp (file)

Function: parse-stream EXPRESSION STREAM &key JUNK-ALLOWED

Parses STREAM using EXPRESSION. Incomplete parses are allowed if JUNK-ALLOWED is true.

Package

esrap-liquid

Source

esrap.lisp (file)

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-liquid

Source

miscellany.lisp (file)


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

6.2 Internal definitions


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

6.2.1 Special variables

Special Variable: *cache*
Package

esrap-liquid

Source

memoization.lisp (file)

Special Variable: *cap-stash*

Assoc list used to capture temporary variables

Package

esrap-liquid

Source

macro.lisp (file)

Special Variable: *debug*
Package

esrap-liquid

Source

conditions.lisp (file)

Special Variable: *indentation-hint-table*
Package

esrap-liquid

Source

esrap.lisp (file)

Special Variable: *nonterminal-stack*
Package

esrap-liquid

Source

memoization.lisp (file)

Special Variable: *rule-context-sensitivity*
Package

esrap-liquid

Source

rule-storage.lisp (file)

Special Variable: *rule-stack*
Package

esrap-liquid

Source

macro.lisp (file)

Special Variable: *rules*
Package

esrap-liquid

Source

rule-storage.lisp (file)

Special Variable: *tracing-indent*
Package

esrap-liquid

Source

conditions.lisp (file)

Special Variable: buffer-vector-start-length
Package

esrap-liquid

Source

iterators.lisp (file)

Special Variable: contexts
Package

esrap-liquid

Source

memoization.lisp (file)

Special Variable: max-failed-position
Package

esrap-liquid

Source

esrap.lisp (file)

Special Variable: max-message
Package

esrap-liquid

Source

esrap.lisp (file)

Special Variable: max-rule-stack
Package

esrap-liquid

Source

esrap.lisp (file)

Special Variable: positive-mood
Package

esrap-liquid

Source

esrap.lisp (file)

Special Variable: the-iter
Package

esrap-liquid

Source

iterators.lisp (file)

Special Variable: the-length
Package

esrap-liquid

Source

iterators.lisp (file)

Special Variable: the-position
Package

esrap-liquid

Source

iterators.lisp (file)


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

6.2.2 Macros

Macro: %defrule NAME ARGS &body BODY
Package

esrap-liquid

Source

macro.lisp (file)

Macro: clause-for-in-iter-1 &key (FOR VAR) (IN-ITER ITER) GENERATE
Package

esrap-liquid

Source

iterators.lisp (file)

Macro: def-nocontext-rule NAME ARGS &body BODY
Package

esrap-liquid

Source

macro.lisp (file)

Macro: if-debug FORMAT-STR &rest ARGS
Package

esrap-liquid

Source

conditions.lisp (file)

Macro: make-result RESULT &optional LENGTH BEGINNING
Package

esrap-liquid

Source

macro.lisp (file)

Macro: the-position-boundary &body BODY
Package

esrap-liquid

Source

macro.lisp (file)

Macro: tracing-init &body BODY
Package

esrap-liquid

Source

conditions.lisp (file)

Macro: tracing-level &body BODY
Package

esrap-liquid

Source

conditions.lisp (file)

Macro: with-cached-result (SYMBOL &rest ARGS) &body FORMS
Package

esrap-liquid

Source

memoization.lisp (file)

Macro: with-fresh-cap-stash &body BODY

Extra level of indirection in *CAP-STASH* is needed to be able to insert new values in it

Package

esrap-liquid

Source

macro.lisp (file)

Macro: with-saved-iter-state (ITER) &body BODY
Package

esrap-liquid

Source

iterators.lisp (file)

Macro: with-sub-cap-stash &body BODY
Package

esrap-liquid

Source

macro.lisp (file)

Macro: with-tmp-rule (VAR EXPRESSION) &body BODY
Package

esrap-liquid

Source

esrap.lisp (file)


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

6.2.3 Functions

Function: %parse-token-iter EXPRESSION TOKEN-ITER &key JUNK-ALLOWED
Package

esrap-liquid

Source

esrap.lisp (file)

Function: buffer-error STR &rest ARGS
Package

esrap-liquid

Source

iterators.lisp (file)

Function: calc-new-buffer-length OLD-BUFFER-VECTOR START-POINTER

If we actually only use half of the buffer, shrink it in half.

Package

esrap-liquid

Source

iterators.lisp (file)

Function: clear-rules ()
Package

esrap-liquid

Source

rule-storage.lisp (file)

Function: context-sensitive-rule-p SYMBOL
Package

esrap-liquid

Source

rule-storage.lisp (file)

Function: ensure-subpos-hash! POS-HASH POS
Package

esrap-liquid

Source

memoization.lisp (file)

Function: eof-error-p ()
Package

esrap-liquid

Source

basic-rules.lisp (file)

Function: eof-p ()
Package

esrap-liquid

Source

basic-rules.lisp (file)

Function: failed-parse-p E
Package

esrap-liquid

Source

memoization.lisp (file)

Function: fast-forward CACHE-ITERATOR &optional DELTA

Relative fast-forward

Package

esrap-liquid

Source

iterators.lisp (file)

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

esrap-liquid

Source

memoization.lisp (file)

Reader

get-cached (generic function)

Function: hash->assoc HASH
Package

esrap-liquid

Source

memoization.lisp (file)

Function: hint-slime-indentation ()
Package

esrap-liquid

Source

esrap.lisp (file)

Function: if-debug-fun FORMAT-STR &rest ARGS
Package

esrap-liquid

Source

conditions.lisp (file)

Function: install-common-rules HASH-TABLE
Package

esrap-liquid

Source

esrap-env.lisp (file)

Function: iter-last-text POSITION
Package

esrap-liquid

Source

esrap.lisp (file)

Function: join JOINEE &rest LST
Package

esrap-liquid

Source

conditions.lisp (file)

Function: joinl JOINEE LST
Package

esrap-liquid

Source

conditions.lisp (file)

Function: make-cache ()
Package

esrap-liquid

Source

memoization.lisp (file)

Function: make-rule-lambda NAME ARGS BODY
Package

esrap-liquid

Source

macro.lisp (file)

Function: mk-cache-iter SUB-ITER
Package

esrap-liquid

Source

iterators.lisp (file)

Function: mk-esrap-iter-from-stream STREAM
Package

esrap-liquid

Source

esrap.lisp (file)

Function: mk-esrap-iter-from-string STR START END
Package

esrap-liquid

Source

esrap.lisp (file)

Function: mk-stream-iter STREAM
Package

esrap-liquid

Source

iterators.lisp (file)

Function: mk-string-iter STRING &key START
Package

esrap-liquid

Source

iterators.lisp (file)

Function: mk-tokenizer EXPRESSION TOKEN-ITER &key JUNK-ALLOWED
Package

esrap-liquid

Source

iter-extensions.lisp (file)

Function: parse-token-iter EXPRESSION TOKEN-ITER &key JUNK-ALLOWED
Package

esrap-liquid

Source

esrap.lisp (file)

Function: print-buffer-vector VEC
Package

esrap-liquid

Source

iterators.lisp (file)

Function: print-cache-iterator ITER
Package

esrap-liquid

Source

iterators.lisp (file)

Function: print-esrap-cache CACHE
Package

esrap-liquid

Source

memoization.lisp (file)

Function: print-iter-state &optional CACHED-ITER
Package

esrap-liquid

Source

iterators.lisp (file)

Function: propagate-cap-stash-upwards UP-VAR DOWN-VAR BODY
Package

esrap-liquid

Source

macro.lisp (file)

Function: reintern-to-right-package EXPRESSION PACKAGE
Package

esrap-liquid

Source

esrap-env.lisp (file)

Function: rel-rewind CACHE-ITERATOR &optional DELTA

Relative rewind

Package

esrap-liquid

Source

iterators.lisp (file)

Function: rewind CACHE-ITERATOR &optional NEW-POS
Package

esrap-liquid

Source

iterators.lisp (file)

Function: simple-esrap-error TEXT RULE-STACK POSITION REASON
Package

esrap-liquid

Source

conditions.lisp (file)

Function: wrap-with-esrap-macrolets BODY
Package

esrap-liquid

Source

macro.lisp (file)


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

6.2.4 Generic functions

Generic Function: buffer-pop OBJ

Pop the last element of the buffer, but not before the start pointer

Package

esrap-liquid

Source

iterators.lisp (file)

Methods
Method: buffer-pop (OBJ buffer-vector)
Generic Function: buffer-push ELT OBJ

Place object in the end of the buffer, necessarily increasing its size

Package

esrap-liquid

Source

iterators.lisp (file)

Methods
Method: buffer-push ELT (OBJ buffer-vector)
Generic Function: esrap-error-position CONDITION
Package

esrap-liquid

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

conditions.lisp (file)

Generic Function: esrap-error-reason CONDITION
Package

esrap-liquid

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

conditions.lisp (file)

Generic Function: esrap-error-text CONDITION
Package

esrap-liquid

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

conditions.lisp (file)

Generic Function: get-cached SYMBOL POSITION ARGS CACHE

Accessor for cached parsing results.

Package

esrap-liquid

Source

memoization.lisp (file)

Writer

(setf get-cached) (function)

Methods
Method: get-cached SYMBOL POSITION ARGS (CACHE esrap-cache)
Generic Function: hard-shrink OBJ NUM-ELTS-DISCARDED

Shrink buffer (and cache) the hard way, actually reallocating the buffer and cleaning up cache

Package

esrap-liquid

Source

iterators.lisp (file)

Methods
Method: hard-shrink (OBJ esrap-cache) NUM-ELTS-DISCARDED
Source

memoization.lisp (file)

Method: hard-shrink (OBJ cache-iterator) NUM-ELTS-DISCARDED
Method: hard-shrink (OBJ buffer-vector) (NUM-ELTS-DISCARDED integer)
Generic Function: left-recursion-nonterminal CONDITION
Package

esrap-liquid

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

conditions.lisp (file)

Generic Function: left-recursion-path CONDITION
Package

esrap-liquid

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

conditions.lisp (file)

Generic Function: next-iter ITER

Main method of iteration protocol

Package

esrap-liquid

Source

iterators.lisp (file)

Methods
Method: next-iter (ITER cache-iterator)
Method: next-iter (ITER stream-iter)
Method: next-iter (ITER string-iter)
Generic Function: rule-stack CONDITION
Generic Function: (setf rule-stack) NEW-VALUE CONDITION
Package

esrap-liquid

Methods
Method: rule-stack (CONDITION simple-esrap-error)
Method: (setf rule-stack) NEW-VALUE (CONDITION simple-esrap-error)
Source

conditions.lisp (file)

Generic Function: soft-shrink OBJ NUM-ELTS-DISCARDED

Shrink buffer (and cache) the soft way, just moving the start pointer

Package

esrap-liquid

Source

iterators.lisp (file)

Methods
Method: soft-shrink (OBJ esrap-cache) NUM-ELTS-DISCARDED
Source

memoization.lisp (file)

Method: soft-shrink (OBJ buffer-vector) (NUM-ELTS-DISCARDED integer)
Generic Function: start-of-iter-p ITER

T if the given iter is at the start. True by default.

Package

esrap-liquid

Source

iterators.lisp (file)

Methods
Method: start-of-iter-p (ITER cache-iterator)
Method: start-of-iter-p ITER

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

6.2.5 Conditions

Condition: buffer-error ()
Package

esrap-liquid

Source

iterators.lisp (file)

Direct superclasses

error (condition)

Direct slots
Slot: msg
Initargs

:msg

Initform

(quote nil)

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-liquid

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)

Slot: position
Initargs

:position

Initform

(quote nil)

Readers

esrap-error-position (generic function)

Slot: reason
Initargs

:reason

Initform

(quote nil)

Readers

esrap-error-reason (generic function)

Condition: internal-esrap-error ()
Package

esrap-liquid

Source

conditions.lisp (file)

Direct superclasses

esrap-error (condition)

Condition: left-recursion ()

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.

Package

esrap-liquid

Source

conditions.lisp (file)

Direct superclasses

esrap-error (condition)

Direct methods
Direct slots
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: simple-esrap-error ()
Package

esrap-liquid

Source

conditions.lisp (file)

Direct superclasses
Direct methods
  • print-object (method)
  • rule-stack (method)
  • rule-stack (method)
Direct slots
Slot: rule-stack
Initargs

:rule-stack

Readers

rule-stack (generic function)

Writers

(setf rule-stack) (generic function)

Condition: stop-iteration ()
Package

esrap-liquid

Source

iterators.lisp (file)

Direct superclasses

error (condition)


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

6.2.6 Classes

Class: buffer-vector ()
Package

esrap-liquid

Source

iterators.lisp (file)

Direct superclasses

standard-object (class)

Direct methods
Direct slots
Slot: vector
Slot: start-pointer
Initform

0

Class: cache-iterator ()
Package

esrap-liquid

Source

iterators.lisp (file)

Direct superclasses

standard-object (class)

Direct methods
Direct slots
Slot: cached-vals
Slot: cached-pos
Initform

0

Slot: sub-iter
Initargs

:sub-iter

Initform

(error "please, specify underlying iterator")

Class: esrap-cache ()
Package

esrap-liquid

Source

memoization.lisp (file)

Direct superclasses

standard-object (class)

Direct methods
Direct slots
Slot: pos-hashtable
Initform

(make-hash-table :test (function equal))

Slot: start-pos
Initform

0

Class: stream-iter ()
Package

esrap-liquid

Source

iterators.lisp (file)

Direct superclasses

standard-object (class)

Direct methods

next-iter (method)

Direct slots
Slot: stream
Initargs

:stream

Initform

(error "steam is required argument")

Class: string-iter ()
Package

esrap-liquid

Source

iterators.lisp (file)

Direct superclasses

standard-object (class)

Direct methods

next-iter (method)

Direct slots
Slot: pos
Initargs

:start

Initform

0

Slot: str
Initargs

:string

Initform

""


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-liquid.asd: The esrap-liquid<dot>asd file
esrap-liquid/example-sexp.lisp: The esrap-liquid/example-sexp<dot>lisp file
esrap-liquid/example-symbol-table.lisp: The esrap-liquid/example-symbol-table<dot>lisp file
esrap-liquid/README: The esrap-liquid/readme file
esrap-liquid/src: The esrap-liquid/src module
esrap-liquid/src/basic-rules.lisp: The esrap-liquid/src/basic-rules<dot>lisp file
esrap-liquid/src/conditions.lisp: The esrap-liquid/src/conditions<dot>lisp file
esrap-liquid/src/esrap-env.lisp: The esrap-liquid/src/esrap-env<dot>lisp file
esrap-liquid/src/esrap.lisp: The esrap-liquid/src/esrap<dot>lisp file
esrap-liquid/src/iter-extensions.lisp: The esrap-liquid/src/iter-extensions<dot>lisp file
esrap-liquid/src/iterators.lisp: The esrap-liquid/src/iterators<dot>lisp file
esrap-liquid/src/macro.lisp: The esrap-liquid/src/macro<dot>lisp file
esrap-liquid/src/memoization.lisp: The esrap-liquid/src/memoization<dot>lisp file
esrap-liquid/src/miscellany.lisp: The esrap-liquid/src/miscellany<dot>lisp file
esrap-liquid/src/package.lisp: The esrap-liquid/src/package<dot>lisp file
esrap-liquid/src/rule-storage.lisp: The esrap-liquid/src/rule-storage<dot>lisp file

F
File, Lisp, esrap-liquid.asd: The esrap-liquid<dot>asd file
File, Lisp, esrap-liquid/src/basic-rules.lisp: The esrap-liquid/src/basic-rules<dot>lisp file
File, Lisp, esrap-liquid/src/conditions.lisp: The esrap-liquid/src/conditions<dot>lisp file
File, Lisp, esrap-liquid/src/esrap-env.lisp: The esrap-liquid/src/esrap-env<dot>lisp file
File, Lisp, esrap-liquid/src/esrap.lisp: The esrap-liquid/src/esrap<dot>lisp file
File, Lisp, esrap-liquid/src/iter-extensions.lisp: The esrap-liquid/src/iter-extensions<dot>lisp file
File, Lisp, esrap-liquid/src/iterators.lisp: The esrap-liquid/src/iterators<dot>lisp file
File, Lisp, esrap-liquid/src/macro.lisp: The esrap-liquid/src/macro<dot>lisp file
File, Lisp, esrap-liquid/src/memoization.lisp: The esrap-liquid/src/memoization<dot>lisp file
File, Lisp, esrap-liquid/src/miscellany.lisp: The esrap-liquid/src/miscellany<dot>lisp file
File, Lisp, esrap-liquid/src/package.lisp: The esrap-liquid/src/package<dot>lisp file
File, Lisp, esrap-liquid/src/rule-storage.lisp: The esrap-liquid/src/rule-storage<dot>lisp file
File, other, esrap-liquid/example-sexp.lisp: The esrap-liquid/example-sexp<dot>lisp file
File, other, esrap-liquid/example-symbol-table.lisp: The esrap-liquid/example-symbol-table<dot>lisp file
File, other, esrap-liquid/README: The esrap-liquid/readme file

L
Lisp File, esrap-liquid.asd: The esrap-liquid<dot>asd file
Lisp File, esrap-liquid/src/basic-rules.lisp: The esrap-liquid/src/basic-rules<dot>lisp file
Lisp File, esrap-liquid/src/conditions.lisp: The esrap-liquid/src/conditions<dot>lisp file
Lisp File, esrap-liquid/src/esrap-env.lisp: The esrap-liquid/src/esrap-env<dot>lisp file
Lisp File, esrap-liquid/src/esrap.lisp: The esrap-liquid/src/esrap<dot>lisp file
Lisp File, esrap-liquid/src/iter-extensions.lisp: The esrap-liquid/src/iter-extensions<dot>lisp file
Lisp File, esrap-liquid/src/iterators.lisp: The esrap-liquid/src/iterators<dot>lisp file
Lisp File, esrap-liquid/src/macro.lisp: The esrap-liquid/src/macro<dot>lisp file
Lisp File, esrap-liquid/src/memoization.lisp: The esrap-liquid/src/memoization<dot>lisp file
Lisp File, esrap-liquid/src/miscellany.lisp: The esrap-liquid/src/miscellany<dot>lisp file
Lisp File, esrap-liquid/src/package.lisp: The esrap-liquid/src/package<dot>lisp file
Lisp File, esrap-liquid/src/rule-storage.lisp: The esrap-liquid/src/rule-storage<dot>lisp file

M
Module, esrap-liquid/src: The esrap-liquid/src module

O
Other File, esrap-liquid/example-sexp.lisp: The esrap-liquid/example-sexp<dot>lisp file
Other File, esrap-liquid/example-symbol-table.lisp: The esrap-liquid/example-symbol-table<dot>lisp file
Other File, esrap-liquid/README: The esrap-liquid/readme file

Jump to:   E   F   L   M   O  

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

A.2 Functions

Jump to:   !   %   &   (   -   <   ?  
A   B   C   D   E   F   G   H   I   J   L   M   N   P   R   S   T   W  
Index Entry  Section

!
!: Exported macros
!!: Exported macros

%
%defrule: Internal macros
%parse-token-iter: Internal functions

&
&: Exported macros

(
(setf get-cached): Internal functions
(setf rule-stack): Internal generic functions
(setf rule-stack): Internal generic functions

-
->: Exported macros

<
<-: Exported macros

?
?: Exported macros

A
any-string: Exported macros

B
buffer-error: Internal functions
buffer-pop: Internal generic functions
buffer-pop: Internal generic functions
buffer-push: Internal generic functions
buffer-push: Internal generic functions

C
calc-new-buffer-length: Internal functions
character-ranges: Exported macros
clause-for-in-iter-1: Internal macros
clear-rules: Internal functions
cond-parse: Exported macros
context-sensitive-rule-p: Internal functions

D
def-nocontext-rule: Internal macros
define-esrap-env: Exported macros
defrule: Exported macros
descend-with-rule: Exported macros

E
ensure-subpos-hash!: Internal functions
eof-error-p: Internal functions
eof-p: Internal functions
esrap-error-position: Internal generic functions
esrap-error-position: Internal generic functions
esrap-error-reason: Internal generic functions
esrap-error-reason: Internal generic functions
esrap-error-text: Internal generic functions
esrap-error-text: Internal generic functions

F
fail-parse: Exported macros
fail-parse-format: Exported macros
failed-parse-p: Internal functions
fast-forward: Internal functions
Function, %parse-token-iter: Internal functions
Function, (setf get-cached): Internal functions
Function, buffer-error: Internal functions
Function, calc-new-buffer-length: Internal functions
Function, clear-rules: Internal functions
Function, context-sensitive-rule-p: Internal functions
Function, ensure-subpos-hash!: Internal functions
Function, eof-error-p: Internal functions
Function, eof-p: Internal functions
Function, failed-parse-p: Internal functions
Function, fast-forward: Internal functions
Function, hash->assoc: Internal functions
Function, hint-slime-indentation: Internal functions
Function, if-debug-fun: Internal functions
Function, install-common-rules: Internal functions
Function, iter-last-text: Internal functions
Function, join: Internal functions
Function, joinl: Internal functions
Function, make-cache: Internal functions
Function, make-rule-lambda: Internal functions
Function, maybe-wrap-in-descent: Exported functions
Function, mk-cache-iter: Internal functions
Function, mk-esrap-iter-from-stream: Internal functions
Function, mk-esrap-iter-from-string: Internal functions
Function, mk-stream-iter: Internal functions
Function, mk-string-iter: Internal functions
Function, mk-tokenizer: Internal functions
Function, parse: Exported functions
Function, parse-stream: Exported functions
Function, parse-token-iter: Internal functions
Function, print-buffer-vector: Internal functions
Function, print-cache-iterator: Internal functions
Function, print-esrap-cache: Internal functions
Function, print-iter-state: Internal functions
Function, propagate-cap-stash-upwards: Internal functions
Function, reintern-to-right-package: Internal functions
Function, rel-rewind: Internal functions
Function, rewind: Internal functions
Function, simple-esrap-error: Internal functions
Function, text: Exported functions
Function, wrap-with-esrap-macrolets: Internal functions

G
Generic Function, (setf rule-stack): Internal generic functions
Generic Function, buffer-pop: Internal generic functions
Generic Function, buffer-push: Internal generic functions
Generic Function, esrap-error-position: Internal generic functions
Generic Function, esrap-error-reason: Internal generic functions
Generic Function, esrap-error-text: Internal generic functions
Generic Function, get-cached: Internal generic functions
Generic Function, hard-shrink: Internal generic functions
Generic Function, left-recursion-nonterminal: Internal generic functions
Generic Function, left-recursion-path: Internal generic functions
Generic Function, next-iter: Internal generic functions
Generic Function, rule-stack: Internal generic functions
Generic Function, soft-shrink: Internal generic functions
Generic Function, start-of-iter-p: Internal generic functions
get-cached: Internal generic functions
get-cached: Internal generic functions

H
hard-shrink: Internal generic functions
hard-shrink: Internal generic functions
hard-shrink: Internal generic functions
hard-shrink: Internal generic functions
hash->assoc: Internal functions
hint-slime-indentation: Internal functions

I
if-debug: Internal macros
if-debug-fun: Internal functions
in-esrap-env: Exported macros
install-common-rules: Internal functions
iter-last-text: Internal functions

J
join: Internal functions
joinl: Internal functions

L
left-recursion-nonterminal: Internal generic functions
left-recursion-nonterminal: Internal generic functions
left-recursion-path: Internal generic functions
left-recursion-path: Internal generic functions
list-v: Exported macros

M
Macro, : Exported macros
Macro, !: Exported macros
Macro, !!: Exported macros
Macro, %defrule: Internal macros
Macro, &: Exported macros
Macro, ->: Exported macros
Macro, <-: Exported macros
Macro, ?: Exported macros
Macro, any-string: Exported macros
Macro, character-ranges: Exported macros
Macro, clause-for-in-iter-1: Internal macros
Macro, cond-parse: Exported macros
Macro, def-nocontext-rule: Internal macros
Macro, define-esrap-env: Exported macros
Macro, defrule: Exported macros
Macro, descend-with-rule: Exported macros
Macro, fail-parse: Exported macros
Macro, fail-parse-format: Exported macros
Macro, if-debug: Internal macros
Macro, in-esrap-env: Exported macros
Macro, list-v: Exported macros
Macro, make-result: Internal macros
Macro, most-full-parse: Exported macros
Macro, postimes: Exported macros
Macro, pred: Exported macros
Macro, prog1-v: Exported macros
Macro, progm: Exported macros
Macro, progn-v: Exported macros
Macro, register-context: Exported macros
Macro, the-position-boundary: Internal macros
Macro, times: Exported macros
Macro, tracing-init: Internal macros
Macro, tracing-level: Internal macros
Macro, with-cached-result: Internal macros
Macro, with-fresh-cap-stash: Internal macros
Macro, with-saved-iter-state: Internal macros
Macro, with-sub-cap-stash: Internal macros
Macro, with-tmp-rule: Internal macros
make-cache: Internal functions
make-result: Internal macros
make-rule-lambda: Internal functions
maybe-wrap-in-descent: Exported functions
Method, (setf rule-stack): Internal generic functions
Method, buffer-pop: Internal generic functions
Method, buffer-push: Internal generic functions
Method, esrap-error-position: Internal generic functions
Method, esrap-error-reason: Internal generic functions
Method, esrap-error-text: Internal generic functions
Method, get-cached: Internal generic functions
Method, hard-shrink: Internal generic functions
Method, hard-shrink: Internal generic functions
Method, hard-shrink: Internal generic functions
Method, left-recursion-nonterminal: Internal generic functions
Method, left-recursion-path: Internal generic functions
Method, next-iter: Internal generic functions
Method, next-iter: Internal generic functions
Method, next-iter: Internal generic functions
Method, rule-stack: Internal generic functions
Method, soft-shrink: Internal generic functions
Method, soft-shrink: Internal generic functions
Method, start-of-iter-p: Internal generic functions
Method, start-of-iter-p: Internal generic functions
mk-cache-iter: Internal functions
mk-esrap-iter-from-stream: Internal functions
mk-esrap-iter-from-string: Internal functions
mk-stream-iter: Internal functions
mk-string-iter: Internal functions
mk-tokenizer: Internal functions
most-full-parse: Exported macros

N
next-iter: Internal generic functions
next-iter: Internal generic functions
next-iter: Internal generic functions
next-iter: Internal generic functions

P
parse: Exported functions
parse-stream: Exported functions
parse-token-iter: Internal functions
postimes: Exported macros
pred: Exported macros
print-buffer-vector: Internal functions
print-cache-iterator: Internal functions
print-esrap-cache: Internal functions
print-iter-state: Internal functions
prog1-v: Exported macros
progm: Exported macros
progn-v: Exported macros
propagate-cap-stash-upwards: Internal functions

R
register-context: Exported macros
reintern-to-right-package: Internal functions
rel-rewind: Internal functions
rewind: Internal functions
rule-stack: Internal generic functions
rule-stack: Internal generic functions

S
simple-esrap-error: Internal functions
soft-shrink: Internal generic functions
soft-shrink: Internal generic functions
soft-shrink: Internal generic functions
start-of-iter-p: Internal generic functions
start-of-iter-p: Internal generic functions
start-of-iter-p: Internal generic functions

T
text: Exported functions
the-position-boundary: Internal macros
times: Exported macros
tracing-init: Internal macros
tracing-level: Internal macros

W
with-cached-result: Internal macros
with-fresh-cap-stash: Internal macros
with-saved-iter-state: Internal macros
with-sub-cap-stash: Internal macros
with-tmp-rule: Internal macros
wrap-with-esrap-macrolets: Internal functions

Jump to:   !   %   &   (   -   <   ?  
A   B   C   D   E   F   G   H   I   J   L   M   N   P   R   S   T   W  

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

A.3 Variables

Jump to:   *  
B   C   M   N   P   R   S   T   V  
Index Entry  Section

*
*cache*: Internal special variables
*cap-stash*: Internal special variables
*debug*: Internal special variables
*indentation-hint-table*: Internal special variables
*nonterminal-stack*: Internal special variables
*rule-context-sensitivity*: Internal special variables
*rule-stack*: Internal special variables
*rules*: Internal special variables
*tracing-indent*: Internal special variables

B
buffer-vector-start-length: Internal special variables

C
cached-pos: Internal classes
cached-vals: Internal classes
contexts: Internal special variables

M
max-failed-position: Internal special variables
max-message: Internal special variables
max-rule-stack: Internal special variables
msg: Internal conditions

N
nonterminal: Internal conditions

P
path: Internal conditions
pos: Internal classes
pos-hashtable: Internal classes
position: Internal conditions
positive-mood: Internal special variables

R
reason: Internal conditions
rule-stack: Internal conditions

S
Slot, cached-pos: Internal classes
Slot, cached-vals: Internal classes
Slot, msg: Internal conditions
Slot, nonterminal: Internal conditions
Slot, path: Internal conditions
Slot, pos: Internal classes
Slot, pos-hashtable: Internal classes
Slot, position: Internal conditions
Slot, reason: Internal conditions
Slot, rule-stack: Internal conditions
Slot, start-pointer: Internal classes
Slot, start-pos: Internal classes
Slot, str: Internal classes
Slot, stream: Internal classes
Slot, sub-iter: Internal classes
Slot, text: Internal conditions
Slot, vector: Internal classes
Special Variable, *cache*: Internal special variables
Special Variable, *cap-stash*: Internal special variables
Special Variable, *debug*: Internal special variables
Special Variable, *indentation-hint-table*: Internal special variables
Special Variable, *nonterminal-stack*: Internal special variables
Special Variable, *rule-context-sensitivity*: Internal special variables
Special Variable, *rule-stack*: Internal special variables
Special Variable, *rules*: Internal special variables
Special Variable, *tracing-indent*: Internal special variables
Special Variable, buffer-vector-start-length: Internal special variables
Special Variable, contexts: Internal special variables
Special Variable, max-failed-position: Internal special variables
Special Variable, max-message: Internal special variables
Special Variable, max-rule-stack: Internal special variables
Special Variable, positive-mood: Internal special variables
Special Variable, the-iter: Internal special variables
Special Variable, the-length: Internal special variables
Special Variable, the-position: Internal special variables
start-pointer: Internal classes
start-pos: Internal classes
str: Internal classes
stream: Internal classes
sub-iter: Internal classes

T
text: Internal conditions
the-iter: Internal special variables
the-length: Internal special variables
the-position: Internal special variables

V
vector: Internal classes

Jump to:   *  
B   C   M   N   P   R   S   T   V  

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

A.4 Data types

Jump to:   B   C   E   I   L   P   S  
Index Entry  Section

B
buffer-error: Internal conditions
buffer-vector: Internal classes

C
cache-iterator: Internal classes
Class, buffer-vector: Internal classes
Class, cache-iterator: Internal classes
Class, esrap-cache: Internal classes
Class, stream-iter: Internal classes
Class, string-iter: Internal classes
Condition, buffer-error: Internal conditions
Condition, esrap-error: Internal conditions
Condition, internal-esrap-error: Internal conditions
Condition, left-recursion: Internal conditions
Condition, simple-esrap-error: Internal conditions
Condition, stop-iteration: Internal conditions

E
esrap-cache: Internal classes
esrap-error: Internal conditions
esrap-liquid: The esrap-liquid system
esrap-liquid: The esrap-liquid package
esrap-liquid-system: The esrap-liquid-system package

I
internal-esrap-error: Internal conditions

L
left-recursion: Internal conditions

P
Package, esrap-liquid: The esrap-liquid package
Package, esrap-liquid-system: The esrap-liquid-system package

S
simple-esrap-error: Internal conditions
stop-iteration: Internal conditions
stream-iter: Internal classes
string-iter: Internal classes
System, esrap-liquid: The esrap-liquid system

Jump to:   B   C   E   I   L   P   S