Parser

Parser for the Loreline scripting language. Converts a stream of tokens into an Abstract Syntax Tree (AST).

Instance Members #

Main parsing entry point. Parses the entire script into an AST.

Gets the array of parsing errors encountered.

Creates a new Parser instance.

Private Members #

Array of tokens to parse

Current position in the token stream

Collection of parsing errors encountered

Comments waiting to be attached to nodes

Position of the last processed token

Position of the last encountered line break

Flag indicating if a line break follows the current token

Node id counter, to ensure each parsed node has a unique id

Root beat, when adding narrative flow directly at the script root

Context of this parser that contains info like what is the path of the tokens being parsed, as well as a repository of tokens matching file paths that could be imported.

Looks ahead at the next token without consuming it.

Advances to the next token, handling comments and line breaks.

Gets the previously consumed token.

Gets the previously consumed token.

Gets the previously consumed token that was an identifier.

Gets the previously consumed token that was not a white space or comment.

Gets the next token that is not a white space or comment.

Gets the next token that is not a line break or comment.

Checks if the current token matches the expected type.

Checks if the current token is a string literal.

Checks if we've reached the end of the token stream.

Determines if a token type represents a comment.

Parses a single node based on the current token.

Parses an import statement (import "file.lor")

Parses a dialogue statement (character: "text")

Parses a block of statements enclosed in braces.

Parses a state declaration, which can be temporary or permanent.

Parses a single field in an object literal.

Parses a beat declaration, which represents a story segment.

Parses a character declaration with its fields.

Parses a text statement (direct string literal).

Parses a choice statement with its options.

Parses a single choice option with its condition and consequences.

Checks if the current token can start an expression.

Parses an expression statement (expression followed by optional assignment).

Checks if the current token starts a known node type.

Parses an if statement with optional else branch.

Parses a transition statement (-> target).

Parses an insertion statement (+ target).

Parses a function definition.

Parses an expression, including assignments.

Parses logical OR expressions (expr || expr).

Parses logical AND expressions (expr && expr).

Parses equality expressions (expr == expr, expr != expr).

Parses comparison expressions (>, >=, <, <=).

Parses additive expressions (+ and -).

Parses multiplicative expressions (* and /).

Parses unary expressions (!expr, -expr).

Parses primary expressions (literals, identifiers, parenthesized expressions).

Parses string literals, handling interpolation and tags.

Creates a Position object for a part of a string literal.

Creates an access expression node.

Parses string interpolation expressions (both simple and complex).

Parses string tags ( or ).

Parses identifier-based expressions (field access, array access, function calls).

Parses array literals ([expr, expr, ...]).

Parses object literals ({key: value, ...}).

Parses function call arguments.

Parses a condition expression.

Attempts to match and consume a token of the given type.

Checks if we're at a line break in the source.

Expects a token of the given type, throws error if not found.

Check if next token is an identifier token.

Expects and consumes an identifier token.

Attaches pending comments to a node.

Attaches pending comments to an else clause of an if statement.

Synchronizes the parser state after an error. Advances until a safe point is found to continue parsing.

Checks if the current construct requires a new line.