emerging-ezjson

Search uses release 1.3.0.0 · 381 definitions

Releases (3)

1.3.0.0 indexed
1.2.0.0 unindexed
1.1.0.0 unindexed

Definitions (381)

src/lex.bend

def step.hi.go
def step.hi
def step.hiesc.go
def step.hiesc
def stepone char, by the mode and the char's class
def feedone char into the machine
def runevery char, in order
def finishthe tokens, in order; text that ends inside a string or a word ends in TBad when the string was not closed
def tokens.revthe first n chars of src, reversed, for the escape fallback's buffer
def tokens.push
type Spanwhat the span scanner is inside: nothing, a word, a string, or a rejected text
type Scan`cut` is the suffix where the open word or string began, so closing it does not walk the text again.
def tokens.hit
def tokens.done
def tokens.end
def tokens.feed
def tokens.gomatch only the text, so a literal unrolls.
def tokensa text as tokens.

src/parse.bend

type Slotwhere the next token of an open array or object has to be
type Keyan object key: owned text, or the first `n` chars of a source suffix
type Framean open array (its items, reversed) or an open object (its pairs, reversed, and the key awaiting its value)
type Pthe parser's state: an error was seen, the finished root, the open frames
def word.ok
def worda bare word as a value: null, true, false, else a number kept as text
def step.ready
def put.pair
def put.text
def puta finished value lands in the innermost open frame, or becomes the root
def put.str
def step.open_arr.go
def step.open_arr
def step.open_obj.go
def step.open_obj
def step.comma
def step.colon
def step.word.go
def step.word
def close_arra `]`: the innermost frame must be an array, empty or just after a value
def close_obja `}`: the innermost frame must be an object, empty or just after a value
def step.span.ok
def step.span.use
def step.span.chk
def step.span.go
def step.span.use2
def step.span.open
def step.span
def stepone token
def runevery token, in order
def resultthe root, when nothing went wrong and nothing stayed open
def finishthe value once the tokens are over
def parsea text as a value, or None when it is not JSON

src/print.bend

def escape.nib.go
def escape.nib
def escape.u
def escape.rest.go
def escape.rest
def scalarwhether a code point is a Unicode scalar value: not a surrogate, and not past U+10FFFF.
def escape.plainone scalar value, escaped when JSON requires it
def escape.scalara scalar value as escape.plain writes it; any other code point as U+FFFD, as Go's encoding/json writes invalid UTF-8
def escape.charone char of a string
def escapethe chars of a string with quotes, backslashes, and controls escaped
def quotea string in quotes, escaped
def printa value as compact JSON
def pretty.goa value as indented JSON.
def prettya value as JSON indented two spaces a level, one element or member a line
def maybea parse result: the value, or "<bad>"

src/pull.bend

type Slotwhere the next token of an open array or object has to be
type Framean open array or object.
type Evone event.
type Curthe cursor.
type Goalread the next event, or drop one whole value
type Stopwhat a step hands back: an event, or a finished skip
type Atoma bare word, once it has been classified
type Piecea string's text: a span of the source, or chars decoded from escapes
type Skindwhat one character of a string does.
type Spotwhere a finished value lands, or that the slot cannot take one
type Modewhat the scanner is inside.
type Stthe scanner's state, apart from the unread suffix it is walking
type Outwhat a walk hands back: a finished step, or a budget used up, to resume on `txt` in state `st`
def err.sta failed step.
def bad.cura failed cursor
def copy.revthe first `nn` chars of `src`, reversed, for the escape copier
def expect.val.goa value can start here
def expect.vala value can start here, and the root is not already finished
def expect.str.goa string can start here: a value, or an object key
def expect.stra string can start here, and the root is not already finished
def expect.str.fora string can start here for this goal.
def place.spotthe stack after a value, and whether that value was the root
def place.val.oka value has landed in a slot that can take it
def place.val.ona value has landed.
def place.vala value has landed
def place.keyan object key has landed.
def str.eva string event, span or owned, as a key or a value
def str.cont.ona string value inside a skip, once the slot is known
def str.conta string value inside a skip: keep the slot, not the text
def str.vala string value.
def str.placea finished string.
def str.skipa string a skip will not keep
def place.val.ok.herea value has landed, and the cursor rest is the suffix already in hand
def place.val.on.herea value has landed on the suffix in hand, once the slot is known