instaparse.gll — cc.artifice/instaparse 1.4.11

The heart of the parsing mechanism. Contains the trampoline structure, the parsing dispatch function, the nodes where listeners are stored, the different types of listeners, and the loop for executing the various listeners and parse commands that are on the stack.

*diagnostic-char-lookahead* clj/s

*trace* clj

-full-parse clj/s

(-full-parse parser index tramp)

-parse clj/s

(-parse parser index tramp)

alt-full-parse clj/s

(alt-full-parse this index tramp)

alt-parse clj/s

(alt-parse this index tramp)

attach-diagnostic-meta clj/s macro

(attach-diagnostic-meta f metadata)

bind-trace clj/s macro

(bind-trace trace? body)

build-node-with-meta clj/s

(build-node-with-meta node-builder tag content start end)

build-total-failure-node clj/s

(build-total-failure-node node-builder start text)

cat-full-parse clj/s

(cat-full-parse this index tramp)

cat-parse clj/s

(cat-parse this index tramp)

CatFullListener clj/s

(CatFullListener results-so-far parser-sequence node-key tramp)

CatListener clj/s

(CatListener results-so-far parser-sequence node-key tramp)

char-range-full-parse clj/s

(char-range-full-parse this index tramp)

char-range-parse clj/s

(char-range-parse this index tramp)

code-point->chars clj/s≠

(code-point->chars code-point)

clj

Takes a Unicode code point, and returns a string of one or two chars.

dpprint clj/s macro

(dpprint & body)

dprintln clj/s macro

(dprintln & body)

epsilon-full-parse clj/s

(epsilon-full-parse this index tramp)

epsilon-parse clj/s

(epsilon-parse this index tramp)

equals-ignore-case clj/s

(equals-ignore-case s1 s2)

fail clj/s

(fail tramp node-key index reason)

Failure clj/s

failure-type clj/s

full-listener-exists? clj/s

(full-listener-exists? tramp node-key)

Tests whether node already has a listener or full-listener

full-result-exists? clj/s

(full-result-exists? tramp node-key)

Tests whether node has a full-result

get-parser clj/s

(get-parser grammar p)

listener-exists? clj/s

(listener-exists? tramp node-key)

Tests whether node already has a listener

log clj/s macro

(log tramp & body)

lookahead-full-parse clj/s

(lookahead-full-parse this index tramp)

lookahead-parse clj/s

(lookahead-parse this index tramp)

LookListener clj/s

(LookListener node-key tramp)

make-node clj/s

(make-node)

make-success clj/s

(make-success result index)

make-tramp clj/s

(make-tramp grammar text)

(make-tramp grammar text segment)

(make-tramp grammar text fail-index node-builder)

(make-tramp grammar text segment fail-index node-builder)

merge-meta clj/s

(merge-meta obj metamap)

A variation on with-meta that merges the existing metamap into the new metamap, rather than overwriting the metamap entirely.

merge-negative-listeners clj/s

negative-lookahead-parse clj/s

(negative-lookahead-parse this index tramp)

Node clj/s

node-get clj/s

(node-get tramp node-key)

Gets node if already exists, otherwise creates one

NodeListener clj/s

(NodeListener node-key tramp)

non-terminal-full-parse clj/s

(non-terminal-full-parse this index tramp)

non-terminal-parse clj/s

(non-terminal-parse this index tramp)

opt-full-parse clj/s

(opt-full-parse this index tramp)

opt-parse clj/s

(opt-parse this index tramp)

ordered-alt-full-parse clj/s

(ordered-alt-full-parse this index tramp)

ordered-alt-parse clj/s

(ordered-alt-parse this index tramp)

parse clj/s

(parse grammar start text partial?)

parse-total clj/s

(parse-total grammar start text partial? node-builder)

parse-total-after-fail clj/s

(parse-total-after-fail grammar start text fail-index partial? node-builder)

parses clj/s

(parses grammar start text partial?)

parses-total clj/s

(parses-total grammar start text partial? node-builder)

parses-total-after-fail clj/s

(parses-total-after-fail grammar start text fail-index partial? node-builder)

plus-full-parse clj/s

(plus-full-parse this index tramp)

plus-parse clj/s

(plus-parse this index tramp)

PlusFullListener clj/s

(PlusFullListener results-so-far parser prev-index node-key tramp)

PlusListener clj/s

(PlusListener results-so-far parser prev-index node-key tramp)

PRINT clj

PROFILE clj

profile clj/s macro

(profile & body)

push-full-listener clj/s

(push-full-listener tramp node-key listener)

Pushes a listener into the trampoline's node. Schedules notification to listener of all existing full results.

push-listener clj/s

(push-listener tramp node-key listener)

Pushes a listener into the trampoline's node. Schedules notification to listener of all existing results. Initiates parse if necessary

push-message clj/s

(push-message tramp listener result)

Pushes onto stack a message to a given listener about a result

push-negative-listener clj/s

(push-negative-listener tramp creator negative-listener)

Pushes a thunk onto the trampoline's negative-listener stack.

push-result clj/s

(push-result tramp node-key result)

Pushes a result into the trampoline's node. Categorizes as either result or full-result. Schedules notification to all existing listeners of result (Full listeners only get notified about full results)

push-stack clj/s

(push-stack tramp item)

Pushes an item onto the trampoline's stack

re-match-at-front clj/s

(re-match-at-front regexp text)

regexp-full-parse clj/s

(regexp-full-parse this index tramp)

regexp-parse clj/s

(regexp-parse this index tramp)

rep-full-parse clj/s

(rep-full-parse this index tramp)

rep-parse clj/s

(rep-parse this index tramp)

RepFullListener clj/s

(RepFullListener results-so-far
                 n-results-so-far
                 parser
                 m
                 n
                 prev-index
                 node-key
                 tramp)

RepListener clj/s

(RepListener results-so-far
             n-results-so-far
             parser
             m
             n
             prev-index
             node-key
             tramp)

result-exists? clj/s

(result-exists? tramp node-key)

Tests whether node has a result or full-result

run clj/s

(run tramp)

(run tramp found-result?)

Executes the stack until exhausted

safe-with-meta clj/s

(safe-with-meta obj metamap)

single-char-code-at clj/s≠

(single-char-code-at text index)

clj

Returns the int value of a single char at the given index, assuming we're looking for up to 0xFFFF (the maximum value for a UTF-16 single char).

star-full-parse clj/s

(star-full-parse this index tramp)

star-parse clj/s

(star-parse this index tramp)

start-parser clj/s

(start-parser tramp parser partial?)

step clj/s

(step stack)

Executes one thing on the stack (not threadsafe)

string-case-insensitive-full-parse clj/s

(string-case-insensitive-full-parse this index tramp)

string-case-insensitive-parse clj/s

(string-case-insensitive-parse this index tramp)

string-context clj/s≠

clj

(string-context text index)

cljs

string-full-parse clj/s

(string-full-parse this index tramp)

string-parse clj/s

(string-parse this index tramp)

sub-sequence clj/s≠

clj

(sub-sequence text start)

(sub-sequence text start end)

Like clojure.core/subs but consumes and returns a CharSequence

cljs

success clj/s macro

(success tramp node-key result end)

text->segment clj/s≠

(text->segment text)

clj

Converts text to a Segment, which has fast subsequencing

TopListener clj/s

(TopListener tramp)

total-success? clj/s

(total-success? tramp s)

TRACE clj

trace-or-false clj/s macro

(trace-or-false)

Tramp clj/s

unicode-code-point-at clj/s≠

(unicode-code-point-at text index)

clj

Returns the unicode code point representing one or two chars at the given index.