tegral-niwen-parser/guru.zoroark.tegral.niwen.parser.dsl

Package-level declarations

Types

class ComposableStateCallbackBuilder<T, R, U>(current: StateCallback<T, R, U>) : StateCallbackBuilder<T, U> , Buildable<StateCallback<T, R, *>>

Implementation of StateCallbackBuilder that recursively composes itself to build a StateCallback

DescribedTypeBuilder

class DescribedTypeBuilder<T>(typeDeclaration: ParserNodeDeclaration<T>) : ExpectationReceiver<T> , Buildable<DescribedType<T>>

Builder for the description of a node. This typically should be used like this:

EitherBranchBuilder

class EitherBranchBuilder<T> : ExpectationReceiver<T> , Buildable<EitherBranch<T>>

The builder for a single branch. This is the receiver type of every either branch.

EitherBuilder

class EitherBuilder<T> : Buildable<ExpectedEither<T>>

The builder for the entire either construct. This is different from a single branch.

ExpectationReceiver

interface ExpectationReceiver<T>

An expectation receiver is the receiver type for all expect DSL constructs. Use this if you want your own DSL to be able to have expect called on it.

ExpectationStateCallbackBuilder

class ExpectationStateCallbackBuilder<T, R>(builderFunc: (StateCallback<T, R, *>?) -> Expectation<T, R>) : Buildable<Expectation<T, R>> , StateCallbackBuilder<T, R>

A builder for state callbacks that get added to an expectation.

ItemExpectationBuilder

class ItemExpectationBuilder<R> : ExpectationReceiver<RepeatedItemReceiver<R>> , Buildable<List<Expectation<RepeatedItemReceiver<R>, *>>>

Builder class for the content of a repeated block

LookaheadBuilder

class LookaheadBuilder<T> : ExpectationReceiver<Nothing> , Buildable<ExpectedLookahead<T>>

A DSL builder for ExpectedLookahead. Used by lookahead.

NiwenParserBuilder

class NiwenParserBuilder<T> : Buildable<NiwenParser<T>>

DSL builder for a Niwen parser.

OptionalBranchBuilder

class OptionalBranchBuilder<T> : ExpectationReceiver<T> , Buildable<Expectation<T, *>>

Builder class for an optional expectation.

RepeatedBuilder

class RepeatedBuilder<T, R>(minIterations: Int?, maxIterations: Int?, itemExpectationBuilder: ItemExpectationBuilder<R>, callback: StateCallback<T, List<R>, *>?) : Buildable<ExpectedRepeated<T, R>>

Builder class for ExpectedRepeated.

StateCallbackBuilder

interface StateCallbackBuilder<T, R>

A builder for composing StateCallbacks.

Functions

addBranch

inline fun <T> EitherBuilder<T>.addBranch(branchInit: EitherBranchBuilder<T>.() -> Unit)

Add a branch to this builder. The branch is first initialized through the branchInit argument.

either

fun <T> ExpectationReceiver<T>.either(branchBuilder: EitherBranchBuilder<T>.() -> Unit): EitherBuilder<T>

Build an "either" construct, with different branches the parsing process can take.

emit

fun <T, R> ExpectationReceiver<T>.emit(value: R): ExpectationStateCallbackBuilder<T, R>

Adds an expectation that always succeeds and emits the provided value.

expect

infix fun <T, R> ExpectationReceiver<T>.expect(node: ParserNodeDeclaration<R>): ExpectationStateCallbackBuilder<T, R>

Adds an expectation to this node descriptor based on a node

fun <T> ExpectationReceiver<T>.expect(tokenType: TokenType, withValue: String? = null): ExpectationStateCallbackBuilder<T, String>

Adds an expectation to this node descriptor based on a token type.

expectEof

fun <T> ExpectationReceiver<T>.expectEof()

Expect the end-of-file to be reached at this point.

lookahead

fun <T> ExpectationReceiver<T>.lookahead(builder: ExpectationReceiver<Nothing>.() -> Unit)

Create a lookahead expectation.

niwenParser

fun <T> niwenParser(block: NiwenParserBuilder<T>.() -> Unit): NiwenParser<T>

Main entry-point for the Niwen Parser DSL. A parser might typically look like this

optional

fun <T> ExpectationReceiver<T>.optional(optionalBlock: OptionalBranchBuilder<T>.() -> Unit)

Create an optional branch. If the optional branch matches, what it stores will is passed transparently, just like if the optional { } was not there. If the optional branch does not match, nothing happens, just like if the entire optional branch was not there.

infix inline fun <T> EitherBuilder<T>.or(branchInit: EitherBranchBuilder<T>.() -> Unit): EitherBuilder<T>

Adds a branch to the either construct. or can be used multiple times to get more than two branches, like so:

plusAssign

operator fun <T, R> ExpectationReceiver<T>.plusAssign(expectation: Expectation<T, R>)

Add an expectation directly instead of a builder. This is a shortcut for this += Buildable.of(expectation)

repeated

fun <T, R> ExpectationReceiver<T>.repeated(min: Int? = null, max: Int? = null, itemBuilder: ItemExpectationBuilder<R>.() -> Unit): ExpectationStateCallbackBuilder<T, List<R>>

Repeatedly runs the provided expectations until they no longer match, then collects the items (specified via storeIn item in one of the expectations in the repeated block) into a list that you can then store.

repeatedIgnore

fun <T> ExpectationReceiver<T>.repeatedIgnore(min: Int? = null, max: Int? = null, itemBuilder: ItemExpectationBuilder<Nothing>.() -> Unit): ExpectationStateCallbackBuilder<T, List<Nothing>>

Repeatedly runs the provided expectations without storing anything.

self

inline fun <T, R : T> ExpectationReceiver<T>.self(): NodeParameterKey<T, R>

Used with storeIn self(), provides the actual value of a node declaration that is implemented with by subtype()

selfKeyFor

fun <T, R : T> selfKeyFor(type: KType): NodeParameterKey<T, R>

Returns a key for self and subtype.

subtype

inline fun <T> subtype(): ParserNodeDeclaration<T>

When paired with sealed classes and self, allows defining abstract nodes that only exist via their subtypes.

Properties

item

val <R> ExpectationReceiver<RepeatedItemReceiver<R>>.item: NodeParameterKey<RepeatedItemReceiver<R>, R>

Used with storeIn, allows placing some state as the item of the output list.