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

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:

MyNodeType {
    expect(TokenType)
    expect(MyOtherNodeType)
}

Constructors

constructor(typeDeclaration: ParserNodeDeclaration<T>)

Functions

build

open override fun build(): DescribedType<T>

Builds this as a described type

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.

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.

plusAssign

open operator override fun plusAssign(expectationBuilder: Buildable<Expectation<T, *>>)

Add an expectation that will be built when the description gets built.

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()

unaryPlus

open operator fun TokenType.unaryPlus(): ExpectationStateCallbackBuilder<T, String>

open operator fun <R> ParserNodeDeclaration<R>.unaryPlus(): ExpectationStateCallbackBuilder<T, R>

Concise notation for the expect function.

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.