@bikky/replication 1.0.1

package/Expressions/Compiler/BuiltinGrammar.js

@@ -0,0 +1,446 @@
+import { Versions } from "../../Constants/Versions.js";
+import { ExpressionGrammar } from "./ExpressionGrammar.js";
+import { EAST_Tokens, TokenType } from "./Tokenizer.js";
+export var ExpressionAST;
+(function (ExpressionAST) {
+    var NodeType = ExpressionGrammar.NodeType;
+    var SpecialType = ExpressionGrammar.SpecialType;
+    const CONTROL_FLOW_STATEMENTS = [NodeType.FOR_LOOP, NodeType.WHILE_LOOP, NodeType.DOWHILE_LOOP, NodeType.IF];
+    const CONTROL_FLOW_LOOP = [NodeType.BREAK, NodeType.CONTINUE];
+    const CONTROL_FLOW_FUNCTION = [NodeType.RETURN];
+    //-------------------------------------------------LOOPS-----------------------------------------------
+    function IsLoopNode(node) {
+        return node.type === NodeType.FOR_LOOP || node.type === NodeType.WHILE_LOOP || node.type === NodeType.DOWHILE_LOOP;
+    }
+    ExpressionAST.IsLoopNode = IsLoopNode;
+    function IsControlFlowNode(node) {
+        return node.type === NodeType.CONTINUE || node.type === NodeType.BREAK || node.type === NodeType.RETURN;
+    }
+    ExpressionAST.IsControlFlowNode = IsControlFlowNode;
+    function IsContinueNode(node) {
+        return node.type === NodeType.CONTINUE;
+    }
+    ExpressionAST.IsContinueNode = IsContinueNode;
+    ExpressionGrammar.AddRule(Versions.v1_0_0, NodeType.CONTINUE, [
+        { type: TokenType.KEYWORD, value: "continue" },
+        { type: TokenType.OPERATOR, value: ";" }
+    ]);
+    function IsBreakNode(node) {
+        return node.type === NodeType.BREAK;
+    }
+    ExpressionAST.IsBreakNode = IsBreakNode;
+    ExpressionGrammar.AddRule(Versions.v1_0_0, NodeType.BREAK, [
+        { type: TokenType.KEYWORD, value: "break" },
+        { type: TokenType.OPERATOR, value: ";" }
+    ]);
+    function IsWhileNode(node) {
+        return node.type === NodeType.WHILE_LOOP;
+    }
+    ExpressionAST.IsWhileNode = IsWhileNode;
+    ExpressionGrammar.AddRule(Versions.v1_0_0, NodeType.WHILE_LOOP, [
+        { type: TokenType.KEYWORD, value: "while" },
+        { type: TokenType.OPERATOR, value: "(" },
+        { type: ExpressionGrammar.NodeType.EXPRESSION, name: "test" },
+        { type: TokenType.OPERATOR, value: ")" },
+        {
+            type: [ExpressionGrammar.NodeType.BLOCK, ExpressionGrammar.NodeType.STATEMENT],
+            input: [...CONTROL_FLOW_LOOP, ExpressionGrammar.SpecialType.INPUT_TYPES],
+            name: "body"
+        }
+    ]);
+    function IsForNode(node) {
+        return node.type === NodeType.FOR_LOOP;
+    }
+    ExpressionAST.IsForNode = IsForNode;
+    ExpressionGrammar.AddRule(Versions.v1_0_0, NodeType.FOR_LOOP, [
+        { type: TokenType.KEYWORD, value: "for" },
+        { type: TokenType.OPERATOR, value: "(" },
+        { type: NodeType.EXPRESSION, name: "initialiser" },
+        { type: TokenType.OPERATOR, value: ";" },
+        { type: NodeType.EXPRESSION, name: "test" },
+        { type: TokenType.OPERATOR, value: ";" },
+        { type: NodeType.EXPRESSION, name: "incrementer" },
+        { type: TokenType.OPERATOR, value: ")" },
+        {
+            type: [NodeType.BLOCK, NodeType.STATEMENT],
+            input: [...CONTROL_FLOW_LOOP, SpecialType.INPUT_TYPES],
+            name: "body"
+        }
+    ]);
+    function IsStatementNode(node) {
+        return node.type === NodeType.STATEMENT;
+    }
+    ExpressionAST.IsStatementNode = IsStatementNode;
+    ExpressionGrammar.AddRule(Versions.v1_0_0, NodeType.STATEMENT, [
+        { type: NodeType.EXPRESSION, unroll: true },
+        { type: TokenType.OPERATOR, value: ";" }
+    ]);
+    function IsExpressionNode(node) {
+        return node.type === NodeType.EXPRESSION;
+    }
+    ExpressionAST.IsExpressionNode = IsExpressionNode;
+    ExpressionGrammar.AddRule(Versions.v1_0_0, NodeType.EXPRESSION, [
+        {
+            type: [
+                NodeType.MEMBER_ACCESS,
+                NodeType.FORCE_CAST,
+                NodeType.ARRAY_ACCESS_SEQUENCE,
+                NodeType.FUNCTION_CALL,
+                NodeType.CAST,
+                NodeType.BINARY_EXPRESSION,
+                NodeType.PARENTHETISED_EXPRESSION,
+                NodeType.UNARY_EXPRESSION,
+                NodeType.ASSIGNMENT,
+                TokenType.BUILTIN,
+                NodeType.LITERAL,
+                TokenType.IDENTIFIER,
+            ],
+            name: "expression"
+        }
+    ]);
+    function IsMemberAccessNode(node) {
+        return node.type === NodeType.MEMBER_ACCESS;
+    }
+    ExpressionAST.IsMemberAccessNode = IsMemberAccessNode;
+    ExpressionGrammar.AddRule(Versions.v1_0_0, NodeType.MEMBER_ACCESS, [
+        {
+            type: [
+                NodeType.PARENTHETISED_EXPRESSION,
+                NodeType.FUNCTION_CALL,
+                NodeType.ARRAY_ACCESS_SEQUENCE,
+                NodeType.FORCE_CAST,
+                NodeType.CAST,
+                TokenType.IDENTIFIER
+            ],
+            name: "context"
+        },
+        { type: [TokenType.OPERATOR], value: "." },
+        {
+            type: [NodeType.MEMBER_ACCESS, NodeType.FORCE_CAST, NodeType.CAST, TokenType.IDENTIFIER],
+            name: "memberName"
+        }
+    ]);
+    function IsArrayAccessorNode(node) {
+        return node.type === NodeType.ARRAY_ACCESSOR;
+    }
+    ExpressionAST.IsArrayAccessorNode = IsArrayAccessorNode;
+    ExpressionGrammar.AddRule(Versions.v1_0_0, NodeType.ARRAY_ACCESSOR, [
+        { type: [TokenType.OPERATOR], value: "[" },
+        {
+            type: [NodeType.LITERAL, NodeType.EXPRESSION, TokenType.IDENTIFIER],
+            name: "index"
+        },
+        { type: [TokenType.OPERATOR], value: "]" }
+    ]);
+    function IsArrayAccessSequenceNode(node) {
+        return node.type === NodeType.ARRAY_ACCESS_SEQUENCE;
+    }
+    ExpressionAST.IsArrayAccessSequenceNode = IsArrayAccessSequenceNode;
+    ExpressionGrammar.AddRule(Versions.v1_0_0, NodeType.ARRAY_ACCESS_SEQUENCE, [
+        {
+            type: [TokenType.IDENTIFIER, NodeType.PARENTHETISED_EXPRESSION],
+            name: "identifier"
+        },
+        {
+            type: [NodeType.ARRAY_ACCESSOR],
+            name: "accessor",
+            repeat: [1, Number.POSITIVE_INFINITY]
+        }
+    ]);
+    function IsParenthetisedExpressionNode(node) {
+        return node.type === NodeType.PARENTHETISED_EXPRESSION;
+    }
+    ExpressionAST.IsParenthetisedExpressionNode = IsParenthetisedExpressionNode;
+    ExpressionGrammar.AddRule(Versions.v1_0_0, NodeType.PARENTHETISED_EXPRESSION, [
+        { type: TokenType.OPERATOR, value: "(" },
+        { type: NodeType.EXPRESSION, unroll: true },
+        { type: TokenType.OPERATOR, value: ")" }
+    ]);
+    function IsBinaryExpressionNode(node) {
+        return node.type === NodeType.BINARY_EXPRESSION;
+    }
+    ExpressionAST.IsBinaryExpressionNode = IsBinaryExpressionNode;
+    ExpressionGrammar.AddRule(Versions.v1_0_0, NodeType.BINARY_EXPRESSION, [
+        {
+            type: [
+                /* no recursion or assignments on the lhs */
+                NodeType.ARRAY_ACCESS_SEQUENCE,
+                NodeType.FUNCTION_CALL,
+                NodeType.PARENTHETISED_EXPRESSION,
+                NodeType.UNARY_EXPRESSION,
+                TokenType.BUILTIN,
+                NodeType.LITERAL,
+                TokenType.IDENTIFIER
+            ],
+            name: "lhs"
+        },
+        {
+            type: TokenType.OPERATOR,
+            values: ["==", "!=", ">", "<", ">=", "<=", "-", "+", "/", "*"],
+            name: "operator"
+        },
+        { type: NodeType.EXPRESSION, name: "rhs" }
+    ]);
+    function IsUnaryExpressionNode(node) {
+        return node.type === NodeType.UNARY_EXPRESSION;
+    }
+    ExpressionAST.IsUnaryExpressionNode = IsUnaryExpressionNode;
+    ExpressionGrammar.AddRule(Versions.v1_0_0, NodeType.UNARY_EXPRESSION, [
+        { type: TokenType.OPERATOR, values: ["!", "-"], name: "operator" },
+        { type: NodeType.EXPRESSION, name: "value" }
+    ]);
+    function IsLiteralNode(node) {
+        return node.type === NodeType.LITERAL;
+    }
+    ExpressionAST.IsLiteralNode = IsLiteralNode;
+    ExpressionGrammar.AddRule(Versions.v1_0_0, NodeType.LITERAL, [
+        {
+            type: [TokenType.FLOAT, TokenType.INTEGER, TokenType.HEX],
+            name: "value"
+        }
+    ]);
+    function IsAssignmentNode(node) {
+        return node.type === NodeType.ASSIGNMENT;
+    }
+    ExpressionAST.IsAssignmentNode = IsAssignmentNode;
+    ExpressionGrammar.AddRule(Versions.v1_0_0, NodeType.ASSIGNMENT, [
+        { type: [TokenType.IDENTIFIER, TokenType.BUILTIN], name: "lhs" },
+        { type: TokenType.OPERATOR, value: "=" },
+        { type: NodeType.EXPRESSION, name: "rhs" }
+    ]);
+    function IsStructNode(node) {
+        return node.type === NodeType.STRUCT;
+    }
+    ExpressionAST.IsStructNode = IsStructNode;
+    ExpressionGrammar.AddRule(Versions.v1_0_0, NodeType.STRUCT, [
+        { type: TokenType.KEYWORD, value: "struct" },
+        { type: TokenType.IDENTIFIER, name: "name" },
+        { type: TokenType.OPERATOR, value: "{" },
+        {
+            type: NodeType.PROPERTY_SIGNATURE,
+            name: "members",
+            repeat: [1, Number.POSITIVE_INFINITY],
+            repeatSeparator: { type: TokenType.OPERATOR, value: "," }
+        },
+        { type: TokenType.OPERATOR, value: "}" }
+    ]);
+    //------------------------------------------------DECLARATION--------------------------------------------
+    function IsIdentifierDeclarationNode(node) {
+        return node.type === NodeType.DECLARATION || node.type === NodeType.PROPERTY_SIGNATURE;
+    }
+    ExpressionAST.IsIdentifierDeclarationNode = IsIdentifierDeclarationNode;
+    function IsDeclarationTypeQualifierListNode(node) {
+        return node.type === NodeType.DECLARATION_ENTRY;
+    }
+    ExpressionAST.IsDeclarationTypeQualifierListNode = IsDeclarationTypeQualifierListNode;
+    {
+        let qualifiers = EAST_Tokens["Qualifiers"];
+        ExpressionGrammar.AddRule(Versions.v1_0_0, NodeType.DECLARATION_TYPE_QUALIFIER_LIST, [
+            {
+                type: TokenType.VAR_QUAL,
+                values: qualifiers ? [qualifiers] : [],
+                name: "qualifiers",
+                repeat: [1, Number.POSITIVE_INFINITY]
+            }
+        ]);
+    }
+    function IsDeclarationTypeNode(node) {
+        return node.type === NodeType.DECLARATION_TYPE;
+    }
+    ExpressionAST.IsDeclarationTypeNode = IsDeclarationTypeNode;
+    {
+        let types = EAST_Tokens["Types"];
+        ExpressionGrammar.AddRule(Versions.v1_0_0, NodeType.DECLARATION_TYPE, [
+            {
+                type: NodeType.DECLARATION_TYPE_QUALIFIER_LIST,
+                unroll: true,
+                optional: true
+            },
+            {
+                type: TokenType.VAR_TYPE,
+                values: types ? [types] : [],
+                name: "type"
+            }
+        ]);
+    }
+    function IsPropertySignatureNode(node) {
+        return node.type === NodeType.PROPERTY_SIGNATURE;
+    }
+    ExpressionAST.IsPropertySignatureNode = IsPropertySignatureNode;
+    ExpressionGrammar.AddRule(Versions.v1_0_0, NodeType.PROPERTY_SIGNATURE, [
+        { type: NodeType.DECLARATION_TYPE, unroll: true },
+        { type: TokenType.IDENTIFIER, value: "identifier" }
+    ]);
+    function IsDeclarationEntryNode(node) {
+        return node.type === NodeType.DECLARATION_ENTRY;
+    }
+    ExpressionAST.IsDeclarationEntryNode = IsDeclarationEntryNode;
+    ExpressionGrammar.AddRule(Versions.v1_0_0, NodeType.DECLARATION_ENTRY, [
+        { type: TokenType.IDENTIFIER, name: "name" },
+        { type: TokenType.OPERATOR, value: "=", optional: true },
+        { type: NodeType.EXPRESSION, name: "initialiser", optional: "previous" }
+    ]);
+    function IsDeclarationNode(node) {
+        return node.type === NodeType.DECLARATION;
+    }
+    ExpressionAST.IsDeclarationNode = IsDeclarationNode;
+    ExpressionGrammar.AddRule(Versions.v1_0_0, NodeType.DECLARATION, [
+        { type: NodeType.DECLARATION_TYPE, unroll: true },
+        {
+            type: NodeType.DECLARATION_ENTRY,
+            name: "declarations",
+            repeat: [1, Number.POSITIVE_INFINITY],
+            repeatSeparator: { type: TokenType.OPERATOR, value: "," }
+        },
+        { type: TokenType.OPERATOR, value: ";" }
+    ]);
+    function IsFileNode(node) {
+        return node.type === NodeType.FILE;
+    }
+    ExpressionAST.IsFileNode = IsFileNode;
+    ExpressionGrammar.AddRule(Versions.v1_0_0, NodeType.FILE, [
+        {
+            type: [NodeType.COMMENT, NodeType.PREPROCESSOR_COMMAND, NodeType.FUNCTION_DECLARATION, NodeType.DECLARATION, NodeType.EXPRESSION],
+            name: "lines",
+            repeat: [0, Number.POSITIVE_INFINITY]
+        }
+    ]);
+    function IsBlockNode(node) {
+        return node.type === NodeType.BLOCK;
+    }
+    ExpressionAST.IsBlockNode = IsBlockNode;
+    ExpressionGrammar.AddRule(Versions.v1_0_0, NodeType.BLOCK, [
+        { type: TokenType.OPERATOR, value: "{" },
+        {
+            type: [
+                NodeType.COMMENT,
+                NodeType.DECLARATION,
+                NodeType.STATEMENT,
+                ...CONTROL_FLOW_STATEMENTS,
+                SpecialType.INPUT_TYPES
+            ],
+            input: [SpecialType.INPUT_TYPES],
+            name: "lines",
+            repeat: [0, Number.POSITIVE_INFINITY]
+        },
+        { type: TokenType.OPERATOR, value: "}" }
+    ]);
+    function IsReturnNode(node) {
+        return node.type === NodeType.RETURN;
+    }
+    ExpressionAST.IsReturnNode = IsReturnNode;
+    ExpressionGrammar.AddRule(Versions.v1_0_0, NodeType.RETURN, [
+        { type: TokenType.KEYWORD, value: "return" },
+        { type: NodeType.EXPRESSION, unroll: true },
+        { type: TokenType.OPERATOR, value: ";" }
+    ]);
+    function IsCommentNode(node) {
+        return node.type === NodeType.COMMENT;
+    }
+    ExpressionAST.IsCommentNode = IsCommentNode;
+    ExpressionGrammar.AddRule(Versions.v1_0_0, NodeType.COMMENT, [
+        {
+            type: [TokenType.BLOCK_COMMENT, TokenType.LINE_COMMENT],
+            name: "comment",
+            repeat: [1, Number.POSITIVE_INFINITY]
+        }
+    ]);
+    function IsPreprocessorCommandNode(node) {
+        return node.type === NodeType.PREPROCESSOR_COMMAND;
+    }
+    ExpressionAST.IsPreprocessorCommandNode = IsPreprocessorCommandNode;
+    ExpressionGrammar.AddRule(Versions.v1_0_0, NodeType.PREPROCESSOR_COMMAND, [
+        {
+            type: [TokenType.PREPROCESSOR /*, NodeType.PRECISION_STATEMENT*/],
+            name: "command"
+        }
+    ]);
+    function IsFunctionParameterNode(node) {
+        return node.type === NodeType.FUNCTION_PARAMETER;
+    }
+    ExpressionAST.IsFunctionParameterNode = IsFunctionParameterNode;
+    ExpressionGrammar.AddRule(Versions.v1_0_0, NodeType.FUNCTION_PARAMETER, [
+        { type: NodeType.DECLARATION_TYPE, unroll: true },
+        { type: TokenType.IDENTIFIER, name: "identifier" }
+    ]);
+    function IsFunctionDeclarationNode(node) {
+        return node.type === NodeType.FUNCTION_DECLARATION;
+    }
+    ExpressionAST.IsFunctionDeclarationNode = IsFunctionDeclarationNode;
+    ExpressionGrammar.AddRule(Versions.v1_0_0, NodeType.FUNCTION_DECLARATION, [
+        { type: TokenType.VAR_TYPE, name: "returnType" },
+        { type: TokenType.IDENTIFIER, name: "name" },
+        { type: TokenType.OPERATOR, value: "(" },
+        {
+            type: NodeType.FUNCTION_PARAMETER,
+            name: "parameters",
+            repeat: [0, Number.POSITIVE_INFINITY],
+            repeatSeparator: { type: TokenType.OPERATOR, value: "," }
+        },
+        //Weird thing about glsl functions is that you can just pass void in for parameters instead, so... let's hack a way of doing that here!
+        { type: TokenType.VAR_TYPE, value: "void", optional: true },
+        { type: TokenType.OPERATOR, value: ")" },
+        { type: NodeType.BLOCK, input: [NodeType.RETURN], name: "body" }
+    ]);
+    function IsFunctionCallNode(node) {
+        return node.type === NodeType.FUNCTION_CALL;
+    }
+    ExpressionAST.IsFunctionCallNode = IsFunctionCallNode;
+    ExpressionGrammar.AddRule(Versions.v1_0_0, NodeType.FUNCTION_CALL, [
+        {
+            type: [TokenType.BUILTIN, TokenType.VAR_TYPE, NodeType.PARENTHETISED_EXPRESSION, TokenType.IDENTIFIER],
+            name: "name"
+        },
+        { type: TokenType.OPERATOR, value: "(" },
+        {
+            type: NodeType.EXPRESSION,
+            name: "arguments",
+            repeat: [0, Number.POSITIVE_INFINITY],
+            repeatSeparator: { type: TokenType.OPERATOR, value: "," }
+        },
+        { type: TokenType.OPERATOR, value: ")" }
+    ]);
+    function IsCastNode(node) {
+        return node.type === NodeType.CAST;
+    }
+    ExpressionAST.IsCastNode = IsCastNode;
+    ExpressionGrammar.AddRule(Versions.v1_0_0, NodeType.CAST, [
+        {
+            type: [
+                NodeType.ARRAY_ACCESS_SEQUENCE,
+                NodeType.FUNCTION_CALL,
+                NodeType.PARENTHETISED_EXPRESSION,
+                TokenType.BUILTIN,
+                NodeType.LITERAL,
+                TokenType.IDENTIFIER,
+            ],
+            name: "expression"
+        },
+        { type: TokenType.OPERATOR, value: ":" },
+        { type: [TokenType.IDENTIFIER],
+            name: "castType"
+        }
+    ]);
+    function IsForceCastNode(node) {
+        return node.type === NodeType.FORCE_CAST;
+    }
+    ExpressionAST.IsForceCastNode = IsForceCastNode;
+    ExpressionGrammar.AddRule(Versions.v1_0_0, NodeType.FORCE_CAST, [
+        {
+            type: [
+                NodeType.ARRAY_ACCESS_SEQUENCE,
+                NodeType.FUNCTION_CALL,
+                NodeType.PARENTHETISED_EXPRESSION,
+                TokenType.BUILTIN,
+                NodeType.LITERAL,
+                TokenType.IDENTIFIER
+            ],
+            name: "expression"
+        },
+        { type: TokenType.OPERATOR, value: ":" },
+        { type: TokenType.OPERATOR, value: "=" },
+        { type: [TokenType.IDENTIFIER],
+            name: "castType"
+        }
+    ]);
+})(ExpressionAST || (ExpressionAST = {}));

package/Expressions/Compiler/ExpressionGrammar.d.ts

@@ -0,0 +1,89 @@
+import { ExpressionAST } from "./BuiltinGrammar.js";
+import { Token, TokenCategory, TokenType } from "./Tokenizer.js";
+export declare namespace ExpressionGrammar {
+    /**
+     * EAST = Expression AST.
+     */
+    interface EAST_Complex_Node {
+        type: NodeType;
+        file: ExpressionAST.FileNode;
+        position: number;
+        length: number;
+        line: number;
+        column: number;
+        values?: {
+            [name: string]: Token | EAST_Complex_Node | (Token | EAST_Complex_Node)[];
+        } | Token | EAST_Complex_Node | (Token | EAST_Complex_Node)[];
+    }
+    type Node = EAST_Complex_Node | EAST_Token;
+    enum NodeType {
+        COMMENT = 100,
+        PREPROCESSOR_COMMAND = 101,
+        PRECISION_STATEMENT = 102,
+        IDENTIFIER = 110,
+        LITERAL = 111,
+        DECLARATION = 112,
+        DECLARATION_ENTRY = 113,
+        DECLARATION_TYPE = 114,
+        DECLARATION_TYPE_QUALIFIER_LIST = 115,
+        STRUCT = 120,
+        PROPERTY_SIGNATURE = 121,
+        CAST = 122,
+        FORCE_CAST = 123,
+        MEMBER_ACCESS = 124,
+        FUNCTION_DECLARATION = 130,
+        FUNCTION_PARAMETER = 131,
+        FUNCTION_CALL = 132,
+        FUNCTION_ARGUMENT = 133,
+        FOR_LOOP = 140,
+        WHILE_LOOP = 141,
+        DOWHILE_LOOP = 142,
+        IF = 143,
+        ARRAY_TYPE = 150,
+        ARRAY_ACCESS_SEQUENCE = 151,
+        ARRAY_ACCESSOR = 152,
+        RETURN = 153,
+        BREAK = 154,
+        CONTINUE = 155,
+        DISCARD = 156,
+        EXPRESSION = 157,
+        STATEMENT = 158,
+        PARENTHETISED_EXPRESSION = 159,
+        BINARY_EXPRESSION = 160,
+        UNARY_EXPRESSION = 161,
+        ASSIGNMENT = 162,
+        BLOCK = 163,
+        FILE = 400
+    }
+    enum SpecialType {
+        /**
+         * Allow extra types to be input by the parent. Used as a placeholder for blocks so that the expression
+         * lines from the parent are used in the evaluation of this grammar rule.
+         **/
+        INPUT_TYPES = 1000
+    }
+    type NodeNames = keyof typeof NodeType;
+    interface Rule {
+        type: TokenType | NodeType | SpecialType | (TokenType | NodeType | SpecialType)[];
+        debug_name?: string;
+        value?: string;
+        values?: (TokenCategory | string)[];
+        name?: string;
+        excludeValues?: string[];
+        input?: (TokenType | NodeType | SpecialType)[];
+        repeat?: [number, number];
+        repeatSeparator?: Rule;
+        unroll?: boolean;
+        optional?: boolean | "previous";
+    }
+    type NodeDefinition = {
+        ID: NodeType;
+        debugName: string;
+        rules: Rule[];
+    };
+    function AddRule(version: string, name: (typeof NodeType)[NodeNames], rules: Rule[]): void;
+    function getRule(versionIdx: number, name: (typeof NodeType)[NodeNames]): NodeDefinition;
+}
+export interface EAST_Token extends Token {
+    file: ExpressionAST.FileNode;
+}

package/Expressions/Compiler/ExpressionGrammar.js

@@ -0,0 +1,70 @@
+import { GetVersionIndex } from "../../Constants/Versions.js";
+const grammar = [];
+export var ExpressionGrammar;
+(function (ExpressionGrammar) {
+    let NodeType;
+    (function (NodeType) {
+        NodeType[NodeType["COMMENT"] = 100] = "COMMENT";
+        NodeType[NodeType["PREPROCESSOR_COMMAND"] = 101] = "PREPROCESSOR_COMMAND";
+        NodeType[NodeType["PRECISION_STATEMENT"] = 102] = "PRECISION_STATEMENT";
+        NodeType[NodeType["IDENTIFIER"] = 110] = "IDENTIFIER";
+        NodeType[NodeType["LITERAL"] = 111] = "LITERAL";
+        NodeType[NodeType["DECLARATION"] = 112] = "DECLARATION";
+        NodeType[NodeType["DECLARATION_ENTRY"] = 113] = "DECLARATION_ENTRY";
+        NodeType[NodeType["DECLARATION_TYPE"] = 114] = "DECLARATION_TYPE";
+        NodeType[NodeType["DECLARATION_TYPE_QUALIFIER_LIST"] = 115] = "DECLARATION_TYPE_QUALIFIER_LIST";
+        NodeType[NodeType["STRUCT"] = 120] = "STRUCT";
+        NodeType[NodeType["PROPERTY_SIGNATURE"] = 121] = "PROPERTY_SIGNATURE";
+        NodeType[NodeType["CAST"] = 122] = "CAST";
+        NodeType[NodeType["FORCE_CAST"] = 123] = "FORCE_CAST";
+        NodeType[NodeType["MEMBER_ACCESS"] = 124] = "MEMBER_ACCESS";
+        NodeType[NodeType["FUNCTION_DECLARATION"] = 130] = "FUNCTION_DECLARATION";
+        NodeType[NodeType["FUNCTION_PARAMETER"] = 131] = "FUNCTION_PARAMETER";
+        NodeType[NodeType["FUNCTION_CALL"] = 132] = "FUNCTION_CALL";
+        NodeType[NodeType["FUNCTION_ARGUMENT"] = 133] = "FUNCTION_ARGUMENT";
+        NodeType[NodeType["FOR_LOOP"] = 140] = "FOR_LOOP";
+        NodeType[NodeType["WHILE_LOOP"] = 141] = "WHILE_LOOP";
+        NodeType[NodeType["DOWHILE_LOOP"] = 142] = "DOWHILE_LOOP";
+        NodeType[NodeType["IF"] = 143] = "IF";
+        NodeType[NodeType["ARRAY_TYPE"] = 150] = "ARRAY_TYPE";
+        NodeType[NodeType["ARRAY_ACCESS_SEQUENCE"] = 151] = "ARRAY_ACCESS_SEQUENCE";
+        NodeType[NodeType["ARRAY_ACCESSOR"] = 152] = "ARRAY_ACCESSOR";
+        NodeType[NodeType["RETURN"] = 153] = "RETURN";
+        NodeType[NodeType["BREAK"] = 154] = "BREAK";
+        NodeType[NodeType["CONTINUE"] = 155] = "CONTINUE";
+        NodeType[NodeType["DISCARD"] = 156] = "DISCARD";
+        NodeType[NodeType["EXPRESSION"] = 157] = "EXPRESSION";
+        NodeType[NodeType["STATEMENT"] = 158] = "STATEMENT";
+        NodeType[NodeType["PARENTHETISED_EXPRESSION"] = 159] = "PARENTHETISED_EXPRESSION";
+        NodeType[NodeType["BINARY_EXPRESSION"] = 160] = "BINARY_EXPRESSION";
+        NodeType[NodeType["UNARY_EXPRESSION"] = 161] = "UNARY_EXPRESSION";
+        NodeType[NodeType["ASSIGNMENT"] = 162] = "ASSIGNMENT";
+        NodeType[NodeType["BLOCK"] = 163] = "BLOCK";
+        NodeType[NodeType["FILE"] = 400] = "FILE";
+    })(NodeType = ExpressionGrammar.NodeType || (ExpressionGrammar.NodeType = {}));
+    let SpecialType;
+    (function (SpecialType) {
+        /**
+         * Allow extra types to be input by the parent. Used as a placeholder for blocks so that the expression
+         * lines from the parent are used in the evaluation of this grammar rule.
+         **/
+        SpecialType[SpecialType["INPUT_TYPES"] = 1000] = "INPUT_TYPES";
+    })(SpecialType = ExpressionGrammar.SpecialType || (ExpressionGrammar.SpecialType = {}));
+    function AddRule(version, name, rules) {
+        let index = GetVersionIndex(version);
+        if (index < 0)
+            throw new Error(`Can't add grammar rule for syntax version that hasn't been defined ${version}.`);
+        if (!grammar[index])
+            grammar[index] = {};
+        grammar[index][name] = {
+            ID: name,
+            debugName: NodeType[name],
+            rules
+        };
+    }
+    ExpressionGrammar.AddRule = AddRule;
+    function getRule(versionIdx, name) {
+        return grammar[versionIdx][name];
+    }
+    ExpressionGrammar.getRule = getRule;
+})(ExpressionGrammar || (ExpressionGrammar = {}));

package/Expressions/Compiler/Parser.d.ts

@@ -0,0 +1,56 @@
+import { ExpressionAST } from "./BuiltinGrammar.js";
+import { EAST_Token, ExpressionGrammar } from "./ExpressionGrammar.js";
+import { Token, TokenType } from "./Tokenizer.js";
+import FileNode = ExpressionAST.FileNode;
+import Node = ExpressionGrammar.EAST_Complex_Node;
+import NodeDefinition = ExpressionGrammar.NodeDefinition;
+import { Versions } from "../../Main.js";
+export interface PartialEASTNode {
+    type: ExpressionGrammar.NodeType;
+    debugName: string;
+    values: {
+        [name: string]: EAST_Token | ExpressionGrammar.EAST_Complex_Node | (EAST_Token | ExpressionGrammar.EAST_Complex_Node)[];
+    };
+}
+export interface NextMatchDetails {
+    parser: ExpressionParser;
+    extraTypes: (TokenType | ExpressionGrammar.NodeType | ExpressionGrammar.SpecialType)[];
+    debugTabs: string;
+}
+export declare function CheckRuleDone(grammar: NodeDefinition, currentRuleIndex: number): boolean;
+export declare function IsRuleSkippable(rule: ExpressionGrammar.Rule, previousRuleMatched: boolean): boolean;
+export declare function ComputeValidTypes(rule: ExpressionGrammar.Rule, extraTypes: (TokenType | ExpressionGrammar.NodeType | ExpressionGrammar.SpecialType)[]): (TokenType | ExpressionGrammar.NodeType | ExpressionGrammar.SpecialType)[];
+export declare function ComputeChildInputs(rule: ExpressionGrammar.Rule, extraTypes: (TokenType | ExpressionGrammar.NodeType | ExpressionGrammar.SpecialType)[]): (TokenType | ExpressionGrammar.NodeType | ExpressionGrammar.SpecialType)[];
+export declare function TokenDataMatchesRule(version: Versions | string, gram: ExpressionGrammar.Rule, token: Token): boolean;
+export declare function PrintNodeName(value: Token | Node | PartialEASTNode): string;
+export declare function PrintTokenText(token: Token): string;
+export declare function MakeNewNodeFrom(details: NextMatchDetails, value: Token | Node): ExpressionGrammar.EAST_Complex_Node | {
+    file: FileNode;
+    type: TokenType;
+    data: string;
+    position: number;
+    length: number;
+    line: number;
+    column: number;
+};
+export declare function AddToPartialEASTNode(details: NextMatchDetails, rule: ExpressionGrammar.Rule, progress: PartialEASTNode, value: Token | (Node & {
+    values?: any;
+})): void;
+export declare function MatchRule(details: NextMatchDetails, rule: ExpressionGrammar.Rule, progress: PartialEASTNode, historicalMatches: ExpressionGrammar.NodeType[]): null | PartialEASTNode;
+export declare function MatchRepeatingRule(details: NextMatchDetails, rule: ExpressionGrammar.Rule, progress: PartialEASTNode, historicalMatches: ExpressionGrammar.NodeType[]): null | PartialEASTNode;
+export declare function MatchGrammar(details: NextMatchDetails, grammarType: ExpressionGrammar.NodeType, historicalMatches: ExpressionGrammar.NodeType[]): ExpressionGrammar.EAST_Complex_Node | null;
+export declare class ExpressionParser {
+    tokens: Token[];
+    version: string;
+    versionIndex: number;
+    currentNodeIndex: number;
+    done: boolean;
+    token: Token;
+    file: Partial<FileNode>;
+    sourceLocation: string;
+    constructor(version: string, lines: string, sourceLocation: string);
+    consumeToken(): void;
+    resetToken(index: number): void;
+    run(): ExpressionAST.FileNode | null;
+}
+export declare function CreateASTFromString(version: string, lines: string, sourceLocation: string): ExpressionAST.FileNode | null;