@galacean/engine-shader-compiler 0.0.0-experimental-2.0-spine.0

package/types/parser/AST.d.ts

@@ -0,0 +1,502 @@
+import { ClearableObjectPool, type IPoolElement } from "@galacean/engine-core";
+import { CodeGenVisitor } from "../codeGen";
+import { GalaceanDataType, ShaderRange, TokenType } from "../common";
+import { BaseToken } from "../common/BaseToken";
+import { Keyword } from "../common/enums/Keyword";
+import { NoneTerminal } from "./GrammarSymbol";
+import SemanticAnalyzer from "./SemanticAnalyzer";
+import { ShaderData } from "./ShaderInfo";
+import { FnSymbol, StructSymbol } from "./symbolTable";
+import { IParamInfo, NodeChild, StructProp, SymbolType } from "./types";
+export declare abstract class TreeNode implements IPoolElement {
+    static pool: ClearableObjectPool<TreeNode & {
+        set: (loc: ShaderRange, children: NodeChild[]) => void;
+    }>;
+    /** The non-terminal in grammar. */
+    nt: NoneTerminal;
+    private _children;
+    private _parent;
+    private _location;
+    private _codeCache;
+    /**
+     * Parent pointer for AST traversal.
+     * @remarks
+     * The parent pointer is only reliable after the entire AST has been constructed.
+     * DO NOT rely on `parent` during the `semanticAnalyze` phase, as the AST may still be under construction.
+     * It is safe to use `parent` during code generation or any phase after AST construction.
+     */
+    get parent(): TreeNode;
+    get children(): NodeChild[];
+    get location(): ShaderRange;
+    set(loc: ShaderRange, children: NodeChild[]): void;
+    init(): void;
+    dispose(): void;
+    setCache(code: string): string;
+    getCache(): string;
+    codeGen(visitor: CodeGenVisitor): string;
+    /**
+     * Do semantic analyze right after the ast node is generated.
+     */
+    semanticAnalyze(sa: SemanticAnalyzer): void;
+}
+export declare namespace ASTNode {
+    type MacroExpression = MacroPushContext | MacroPopContext | MacroElseExpression | MacroElifExpression | MacroUndef | MacroDefine | BaseToken;
+    export type ASTNodePool = ClearableObjectPool<{
+        set: (loc: ShaderRange, children: NodeChild[]) => void;
+    } & IPoolElement & TreeNode>;
+    export function _unwrapToken(node: NodeChild): BaseToken<number>;
+    export function get(pool: ASTNodePool, sa: SemanticAnalyzer, loc: ShaderRange, children: NodeChild[]): void;
+    export class TrivialNode extends TreeNode {
+    }
+    export class ScopeBrace extends TreeNode {
+        semanticAnalyze(sa: SemanticAnalyzer): void;
+    }
+    export class ScopeEndBrace extends TreeNode {
+        semanticAnalyze(sa: SemanticAnalyzer): void;
+    }
+    export class JumpStatement extends TreeNode {
+        isFragReturnStatement: boolean;
+        init(): void;
+        semanticAnalyze(sa: SemanticAnalyzer): void;
+        codeGen(visitor: CodeGenVisitor): string;
+    }
+    export class ConditionOpt extends TreeNode {
+    }
+    export class ForRestStatement extends TreeNode {
+    }
+    export class Condition extends TreeNode {
+    }
+    export class ForInitStatement extends TreeNode {
+    }
+    export class IterationStatement extends TreeNode {
+    }
+    export class SelectionStatement extends TreeNode {
+    }
+    export class ExpressionStatement extends TreeNode {
+    }
+    export abstract class ExpressionAstNode extends TreeNode {
+        protected _type?: GalaceanDataType;
+        set type(t: GalaceanDataType | undefined);
+        get type(): GalaceanDataType | undefined;
+        init(): void;
+    }
+    export class InitializerList extends ExpressionAstNode {
+        semanticAnalyze(sa: SemanticAnalyzer): void;
+    }
+    export class Initializer extends ExpressionAstNode {
+        semanticAnalyze(sa: SemanticAnalyzer): void;
+    }
+    export class SingleDeclaration extends TreeNode {
+        typeSpecifier: TypeSpecifier;
+        arraySpecifier?: ArraySpecifier;
+        init(): void;
+        semanticAnalyze(sa: SemanticAnalyzer): void;
+        codeGen(visitor: CodeGenVisitor): string;
+    }
+    export class FullySpecifiedType extends TreeNode {
+        typeSpecifier: TypeSpecifier;
+        type: GalaceanDataType;
+        semanticAnalyze(_: SemanticAnalyzer): void;
+    }
+    export class TypeQualifier extends TreeNode {
+    }
+    export class SingleTypeQualifier extends TreeNode {
+        qualifier: Keyword;
+        lexeme: string;
+        semanticAnalyze(sa: SemanticAnalyzer): void;
+    }
+    abstract class BasicTypeQualifier extends TreeNode {
+        qualifier: Keyword;
+        lexeme: string;
+        semanticAnalyze(sa: SemanticAnalyzer): void;
+    }
+    export class StorageQualifier extends BasicTypeQualifier {
+    }
+    export class PrecisionQualifier extends BasicTypeQualifier {
+    }
+    export class InterpolationQualifier extends BasicTypeQualifier {
+    }
+    export class InvariantQualifier extends BasicTypeQualifier {
+    }
+    export class TypeSpecifier extends TreeNode {
+        type: GalaceanDataType;
+        lexeme: string;
+        arraySize?: number;
+        isCustom: boolean;
+        init(): void;
+        get arraySpecifier(): ArraySpecifier;
+        semanticAnalyze(sa: SemanticAnalyzer): void;
+    }
+    export class ArraySpecifier extends TreeNode {
+        size: number | undefined;
+        semanticAnalyze(sa: SemanticAnalyzer): void;
+    }
+    export class IntegerConstantExpressionOperator extends TreeNode {
+        compute: (a: number, b: number) => number;
+        lexeme: string;
+        semanticAnalyze(sa: SemanticAnalyzer): void;
+    }
+    export class IntegerConstantExpression extends TreeNode {
+        value?: number;
+        init(): void;
+        semanticAnalyze(sa: SemanticAnalyzer): void;
+    }
+    export class TypeSpecifierNonArray extends TreeNode {
+        type: GalaceanDataType;
+        lexeme: string;
+        init(): void;
+    }
+    export class ExtBuiltinTypeSpecifierNonArray extends TreeNode {
+        type: TokenType;
+        lexeme: string;
+        init(): void;
+    }
+    export class InitDeclaratorList extends TreeNode {
+        typeInfo: SymbolType;
+        semanticAnalyze(sa: SemanticAnalyzer): void;
+    }
+    export class IdentifierList extends TreeNode {
+        idList: BaseToken[];
+        init(): void;
+        semanticAnalyze(sa: SemanticAnalyzer): void;
+    }
+    export class Declaration extends TreeNode {
+        codeGen(visitor: CodeGenVisitor): string;
+    }
+    export class FunctionProtoType extends TreeNode {
+        ident: BaseToken;
+        returnType: FullySpecifiedType;
+        parameterList: IParamInfo[];
+        paramSig: GalaceanDataType[] | undefined;
+        semanticAnalyze(sa: SemanticAnalyzer): void;
+    }
+    export class FunctionDeclarator extends TreeNode {
+        ident: BaseToken;
+        returnType: FullySpecifiedType;
+        parameterInfoList: IParamInfo[] | undefined;
+        paramSig: GalaceanDataType[] | undefined;
+        semanticAnalyze(sa: SemanticAnalyzer): void;
+    }
+    export class FunctionHeader extends TreeNode {
+        ident: BaseToken;
+        returnType: FullySpecifiedType;
+        semanticAnalyze(sa: SemanticAnalyzer): void;
+        codeGen(visitor: CodeGenVisitor): string;
+    }
+    export class FunctionParameterList extends TreeNode {
+        parameterInfoList: IParamInfo[];
+        paramSig: GalaceanDataType[];
+        init(): void;
+        semanticAnalyze(sa: SemanticAnalyzer): void;
+        codeGen(visitor: CodeGenVisitor): string;
+    }
+    export class MacroParamCaseList extends TreeNode {
+    }
+    export class MacroParamBlock extends TreeNode {
+    }
+    export class MacroParameterBranch extends TreeNode {
+    }
+    export class ParameterDeclaration extends TreeNode {
+        typeInfo?: SymbolType;
+        ident?: BaseToken;
+        init(): void;
+        semanticAnalyze(sa: SemanticAnalyzer): void;
+    }
+    export class ParameterDeclarator extends TreeNode {
+        ident: BaseToken;
+        typeInfo: SymbolType;
+        semanticAnalyze(sa: SemanticAnalyzer): void;
+    }
+    export class SimpleStatement extends TreeNode {
+    }
+    export class CompoundStatement extends TreeNode {
+    }
+    export class CompoundStatementNoScope extends TreeNode {
+    }
+    export class Statement extends TreeNode {
+    }
+    export class StatementList extends TreeNode {
+        codeGen(visitor: CodeGenVisitor): string;
+    }
+    export class FunctionDefinition extends TreeNode {
+        returnStatement?: ASTNode.JumpStatement;
+        protoType: FunctionProtoType;
+        statements: CompoundStatementNoScope;
+        isInMacroBranch: boolean;
+        init(): void;
+        semanticAnalyze(sa: SemanticAnalyzer): void;
+        codeGen(visitor: CodeGenVisitor): string;
+    }
+    export class FunctionCall extends ExpressionAstNode {
+        semanticAnalyze(sa: SemanticAnalyzer): void;
+        codeGen(visitor: CodeGenVisitor): string;
+    }
+    export class FunctionCallGeneric extends ExpressionAstNode {
+        fnSymbol: FnSymbol | StructSymbol | undefined;
+        init(): void;
+        semanticAnalyze(sa: SemanticAnalyzer): void;
+    }
+    export class FunctionCallParameterList extends TreeNode {
+        paramSig: GalaceanDataType[];
+        paramNodes: Array<AssignmentExpression | MacroCallArgBlock>;
+        init(): void;
+        semanticAnalyze(sa: SemanticAnalyzer): void;
+    }
+    export class MacroCallArgCaseList extends TreeNode {
+    }
+    export class MacroCallArgBlock extends TreeNode {
+    }
+    export class MacroCallArgBranch extends TreeNode {
+    }
+    export class PrecisionSpecifier extends TreeNode {
+        semanticAnalyze(sa: SemanticAnalyzer): void;
+    }
+    export class FunctionIdentifier extends TreeNode {
+        ident: GalaceanDataType;
+        lexeme: string;
+        isBuiltin: boolean;
+        semanticAnalyze(sa: SemanticAnalyzer): void;
+        codeGen(visitor: CodeGenVisitor): string;
+    }
+    export class AssignmentExpression extends ExpressionAstNode {
+        semanticAnalyze(sa: SemanticAnalyzer): void;
+    }
+    export class AssignmentOperator extends TreeNode {
+    }
+    export class Expression extends ExpressionAstNode {
+        semanticAnalyze(sa: SemanticAnalyzer): void;
+    }
+    export class PrimaryExpression extends ExpressionAstNode {
+        semanticAnalyze(sa: SemanticAnalyzer): void;
+    }
+    export class PostfixExpression extends ExpressionAstNode {
+        init(): void;
+        codeGen(visitor: CodeGenVisitor): string;
+    }
+    export class UnaryOperator extends TreeNode {
+    }
+    export class UnaryExpression extends ExpressionAstNode {
+        init(): void;
+    }
+    export class MultiplicativeExpression extends ExpressionAstNode {
+        init(): void;
+    }
+    export class AdditiveExpression extends ExpressionAstNode {
+        init(): void;
+    }
+    export class ShiftExpression extends ExpressionAstNode {
+        semanticAnalyze(sa: SemanticAnalyzer): void;
+    }
+    export class RelationalExpression extends ExpressionAstNode {
+        semanticAnalyze(sa: SemanticAnalyzer): void;
+    }
+    export class EqualityExpression extends ExpressionAstNode {
+        semanticAnalyze(sa: SemanticAnalyzer): void;
+    }
+    export class AndExpression extends ExpressionAstNode {
+        semanticAnalyze(sa: SemanticAnalyzer): void;
+    }
+    export class ExclusiveOrExpression extends ExpressionAstNode {
+        semanticAnalyze(sa: SemanticAnalyzer): void;
+    }
+    export class InclusiveOrExpression extends ExpressionAstNode {
+        semanticAnalyze(sa: SemanticAnalyzer): void;
+    }
+    export class LogicalAndExpression extends ExpressionAstNode {
+        semanticAnalyze(sa: SemanticAnalyzer): void;
+    }
+    export class LogicalXorExpression extends ExpressionAstNode {
+        semanticAnalyze(sa: SemanticAnalyzer): void;
+    }
+    export class LogicalOrExpression extends ExpressionAstNode {
+        semanticAnalyze(sa: SemanticAnalyzer): void;
+    }
+    export class ConditionalExpression extends ExpressionAstNode {
+        semanticAnalyze(sa: SemanticAnalyzer): void;
+    }
+    export class StructSpecifier extends TreeNode {
+        ident?: BaseToken;
+        propList: StructProp[];
+        macroExpressions: MacroExpression[];
+        isInMacroBranch: boolean;
+        init(): void;
+        semanticAnalyze(sa: SemanticAnalyzer): void;
+        codeGen(visitor: CodeGenVisitor): string;
+    }
+    export class StructDeclarationList extends TreeNode {
+        propList: StructProp[];
+        macroExpressions: MacroExpression[];
+        init(): void;
+        semanticAnalyze(sa: SemanticAnalyzer): void;
+    }
+    export class StructDeclaration extends TreeNode {
+        props: StructProp[];
+        macroExpressions: MacroExpression[];
+        private _typeSpecifier?;
+        private _declaratorList?;
+        init(): void;
+        semanticAnalyze(sa: SemanticAnalyzer): void;
+    }
+    export class MacroStructDeclaration extends TreeNode {
+        props: StructProp[];
+        macroExpressions: MacroExpression[];
+        init(): void;
+        semanticAnalyze(): void;
+    }
+    export class MacroStructBranch extends TreeNode {
+        props: StructProp[];
+        macroExpressions: MacroExpression[];
+        init(): void;
+        semanticAnalyze(): void;
+    }
+    export class LayoutQualifier extends TreeNode {
+        index: number;
+        semanticAnalyze(sa: SemanticAnalyzer): void;
+    }
+    export class StructDeclaratorList extends TreeNode {
+        declaratorList: StructDeclarator[];
+        init(): void;
+        semanticAnalyze(sa: SemanticAnalyzer): void;
+    }
+    export class StructDeclarator extends TreeNode {
+        ident: BaseToken;
+        arraySpecifier: ArraySpecifier | undefined;
+        init(): void;
+        semanticAnalyze(sa: SemanticAnalyzer): void;
+    }
+    export class VariableDeclaration extends TreeNode {
+        type: FullySpecifiedType;
+        isStatic: boolean;
+        init(): void;
+        semanticAnalyze(sa: SemanticAnalyzer): void;
+        codeGen(visitor: CodeGenVisitor): string;
+    }
+    export class VariableDeclarationList extends TreeNode {
+        type: FullySpecifiedType;
+        variableDeclarations: VariableDeclaration[];
+        init(): void;
+        semanticAnalyze(sa: SemanticAnalyzer): void;
+    }
+    export class VariableIdentifier extends TreeNode {
+        typeInfo: GalaceanDataType;
+        referenceGlobalSymbolNames: string[];
+        private _symbols;
+        init(): void;
+        semanticAnalyze(sa: SemanticAnalyzer): void;
+        /** Run the cross-arm shadowing probe for a MACRO_CALL site. No-op when the
+         *  probe isn't meaningful: no macro name, name already resolved as a real
+         *  reference, or name is a builtin (builtins can't be shadowed by a
+         *  sibling-arm decl). */
+        private static _probeCrossArmShadowing;
+        /** Look up `name` in the symbol stack and, if a global var/fn declaration
+         *  exists, push it into `referenceGlobalSymbolNames`. Returns `true` iff
+         *  the lookup hit (caller can then derive type info). When `missWarnLoc`
+         *  is non-null, a miss reports a "declared before used" warning; pass
+         *  `null` for silent probes (e.g. FXAA-style cross-arm shadowing).
+         *
+         *  Mutation contract: `symbols` is used as scratch storage — `lookupAll`
+         *  clears and refills it. On hit, the caller may read `symbols[0]` for
+         *  type info before the next call overwrites the contents. */
+        private static _lookupAndMarkGlobalReference;
+        codeGen(visitor: CodeGenVisitor): string;
+        getLexeme(visitor: CodeGenVisitor): string;
+    }
+    export class GLShaderProgram extends TreeNode {
+        shaderData: ShaderData;
+        semanticAnalyze(sa: SemanticAnalyzer): void;
+    }
+    export class GlobalDeclaration extends TreeNode {
+        macroExpressions: Array<MacroExpression | MacroUndef | BaseToken>;
+        init(): void;
+        semanticAnalyze(sa: SemanticAnalyzer): void;
+    }
+    export class MacroUndef extends TreeNode {
+        codeGen(visitor: CodeGenVisitor): string;
+    }
+    export class MacroPushContext extends TreeNode {
+        semanticAnalyze(sa: SemanticAnalyzer): void;
+        codeGen(visitor: CodeGenVisitor): string;
+    }
+    export class MacroPopContext extends TreeNode {
+        semanticAnalyze(sa: SemanticAnalyzer): void;
+        codeGen(visitor: CodeGenVisitor): string;
+    }
+    export class MacroElifExpression extends TreeNode {
+        codeGen(visitor: CodeGenVisitor): string;
+    }
+    export class MacroElseExpression extends TreeNode {
+        codeGen(visitor: CodeGenVisitor): string;
+    }
+    export class GlobalMacroDeclaration extends TreeNode {
+        macroExpressions: MacroExpression[];
+        init(): void;
+        semanticAnalyze(sa: SemanticAnalyzer): void;
+        codeGen(visitor: CodeGenVisitor): string;
+    }
+    export class GlobalMacroIfStatement extends TreeNode {
+        macroExpressions: MacroExpression[];
+        init(): void;
+        semanticAnalyze(sa: SemanticAnalyzer): void;
+    }
+    export class GlobalMacroBranch extends TreeNode {
+        macroExpressions: MacroExpression[];
+        init(): void;
+        semanticAnalyze(sa: SemanticAnalyzer): void;
+    }
+    export class MacroIfStatement extends TreeNode {
+    }
+    export class MacroBranch extends TreeNode {
+    }
+    export class MacroCallSymbol extends TreeNode {
+        referenceSymbolNames: string[];
+        macroName: string;
+        /** True iff every `MacroDefineInfo` visible from this call site's branch
+         *  has a `valueAst` (i.e. was parsed via the `macro_define` CFG rule).
+         *  Call sites use this to skip naive type inference: an AST-form macro
+         *  drives the call site's type through its own value subtree, not through
+         *  a root of `referenceSymbolNames`. Mixed forms across branches → false,
+         *  fall back to legacy inference. */
+        hasAstValue: boolean;
+        /** `#define NAME(params) …` form — drives function-like vs object-like codegen. */
+        isFunctionLikeMacro: boolean;
+        /** Every visible replacement is a non-builtin identifier — assume user fn alias. */
+        aliasesNonBuiltinIdent: boolean;
+        init(): void;
+        semanticAnalyze(sa: SemanticAnalyzer): void;
+        /** Push every leaf `VariableIdentifier`'s lexeme into `out`, skipping
+         *  function-like parameter names (local to the macro, not call-site refs)
+         *  and duplicates. */
+        private static _collectIdentifierRefs;
+    }
+    export class MacroCallFunction extends TreeNode {
+        referenceSymbolNames: string[];
+        macroName: string;
+        hasAstValue: boolean;
+        isFunctionLikeMacro: boolean;
+        aliasesNonBuiltinIdent: boolean;
+        init(): void;
+        semanticAnalyze(sa: SemanticAnalyzer): void;
+        codeGen(visitor: CodeGenVisitor): string;
+    }
+    /**
+     * `#define NAME [(params)] [value]` — expression-style macro.
+     *
+     * Expression-form macros are parsed into AST rather than kept as raw lexemes. The
+     * optional `valueExpression` is an `AssignmentExpression` subtree that participates
+     * in normal codegen — so `v.v_normal.xyz` inside a `#define` flows through
+     * `visitPostfixExpression` just like an inline expression would, and varying
+     * flattening/type inference/reference tracking all come for free.
+     *
+     * Semantic analysis does not resolve symbols inside the value (the definition-site
+     * scope is not the call-site scope). Lookup happens lazily during codegen.
+     */
+    export class MacroDefine extends TreeNode {
+        macroName: string;
+        isFunction: boolean;
+        valueExpression?: Expression;
+        init(): void;
+        semanticAnalyze(sa: SemanticAnalyzer): void;
+        codeGen(visitor: CodeGenVisitor): string;
+    }
+    export {};
+}

package/types/parser/Grammar.d.ts

@@ -0,0 +1,11 @@
+import { NoneTerminal, GrammarSymbol } from "./GrammarSymbol";
+import Production from "../lalr/Production";
+export declare class Grammar {
+    readonly productions: Production[];
+    readonly startSymbol: NoneTerminal;
+    static create(start: NoneTerminal, productions: GrammarSymbol[][]): Grammar;
+    constructor(start: NoneTerminal, productions: Production[]);
+    getProductionList(nonTerminal: NoneTerminal): Production[];
+    isNullableNT(NT: NoneTerminal): Production;
+    getProductionByID(pid: number): Production;
+}

package/types/parser/GrammarSymbol.d.ts

@@ -0,0 +1,128 @@
+import { TokenType } from "../common";
+export type Terminal = TokenType;
+export declare enum NoneTerminal {
+    START = 2000,
+    gs_shader_program = 2001,
+    global_declaration = 2002,
+    variable_declaration = 2003,
+    variable_declaration_list = 2004,
+    variable_declaration_statement = 2005,
+    array_specifier_list = 2006,
+    array_specifier = 2007,
+    ext_builtin_type_specifier_nonarray = 2008,
+    precision_specifier = 2009,
+    variable_identifier = 2010,
+    variable_identifier_node = 2011,
+    primary_expression = 2012,
+    postfix_expression = 2013,
+    integer_expression = 2014,
+    function_call = 2015,
+    function_call_generic = 2016,
+    function_call_header_no_parameters = 2017,
+    function_call_header_with_parameters = 2018,
+    function_call_parameter_list = 2019,
+    function_call_header = 2020,
+    function_identifier = 2021,
+    constructor_identifier = 2022,
+    unary_expression = 2023,
+    unary_operator = 2024,
+    multiplicative_expression = 2025,
+    additive_expression = 2026,
+    shift_expression = 2027,
+    relational_expression = 2028,
+    equality_expression = 2029,
+    and_expression = 2030,
+    inclusive_or_expression = 2031,
+    exclusive_or_expression = 2032,
+    logical_and_expression = 2033,
+    logical_xor_expression = 2034,
+    logical_or_expression = 2035,
+    conditional_expression = 2036,
+    assignment_expression = 2037,
+    assignment_operator = 2038,
+    expression = 2039,
+    integer_constant_expression = 2040,
+    integer_constant_expression_operator = 2041,
+    declaration = 2042,
+    function_prototype = 2043,
+    function_declarator = 2044,
+    function_header_with_parameters = 2045,
+    function_header = 2046,
+    function_parameter_list = 2047,
+    parameter_declarator = 2048,
+    parameter_declaration = 2049,
+    parameter_qualifier = 2050,
+    parameter_type_specifier = 2051,
+    init_declarator_list = 2052,
+    single_declaration = 2053,
+    fully_specified_type = 2054,
+    type_qualifier = 2055,
+    single_type_qualifier = 2056,
+    storage_qualifier = 2057,
+    precision_qualifier = 2058,
+    interpolation_qualifier = 2059,
+    invariant_qualifier = 2060,
+    type_specifier = 2061,
+    type_specifier_nonarray = 2062,
+    type_specifier_no_prec = 2063,
+    basic_type = 2064,
+    struct_specifier = 2065,
+    struct_declaration_list = 2066,
+    struct_declaration = 2067,
+    layout_qualifier = 2068,
+    struct_declarator_list = 2069,
+    struct_declarator = 2070,
+    identifier_list = 2071,
+    decl_identifier = 2072,
+    initializer = 2073,
+    initializer_list = 2074,
+    declaration_statement = 2075,
+    simple_statement = 2076,
+    compound_statement_no_scope = 2077,
+    statement_with_scope = 2078,
+    compound_statement = 2079,
+    statement = 2080,
+    statement_list = 2081,
+    iteration_statement_no_new_scope = 2082,
+    expression_statement = 2083,
+    selection_statement = 2084,
+    selection_rest_statement = 2085,
+    condition = 2086,
+    conditionopt = 2087,
+    iteration_statement = 2088,
+    for_init_statement = 2089,
+    for_rest_statement = 2090,
+    jump_statement = 2091,
+    external_declaration = 2092,
+    function_definition = 2093,
+    field_selection = 2094,
+    bool_constant = 2095,
+    function_identifier_node = 2096,
+    typename_identifier_node = 2097,
+    scope_brace = 2098,
+    scope_end_brace = 2099,
+    macro_undef = 2100,
+    macro_push_context = 2101,
+    macro_pop_context = 2102,
+    macro_elif_expression = 2103,
+    macro_else_expression = 2104,
+    global_macro_if_statement = 2105,
+    global_macro_declaration = 2106,
+    global_macro_branch = 2107,
+    macro_struct_declaration = 2108,
+    macro_struct_branch = 2109,
+    macro_if_statement = 2110,
+    macro_branch = 2111,
+    macro_param_case_list = 2112,
+    macro_param_block = 2113,
+    macro_parameter_branch = 2114,
+    macro_call_arg_case_list = 2115,
+    macro_call_arg_block = 2116,
+    macro_call_arg_branch = 2117,
+    macro_call_symbol = 2118,
+    macro_call_function = 2119,
+    macro_define = 2120,
+    _ignore = 2121
+}
+export type GrammarSymbol = Terminal | NoneTerminal;
+export type Derivation = GrammarSymbol[];

package/types/parser/SemanticAnalyzer.d.ts

@@ -0,0 +1,2 @@
+import { NodeChild } from "./types";
+export type TranslationRule<T = any> = (sa: SemanticAnalyzer, ...tokens: NodeChild[]) => T;

package/types/parser/ShaderInfo.d.ts

@@ -0,0 +1,10 @@
+import { SymbolInfo, SymbolTable } from "../parser/symbolTable";
+import { ASTNode } from "./AST";
+export declare class ShaderData {
+    symbolTable: SymbolTable<SymbolInfo>;
+    vertexMain: ASTNode.FunctionDefinition;
+    fragmentMain: ASTNode.FunctionDefinition;
+    globalPrecisions: ASTNode.PrecisionSpecifier[];
+    globalMacroDeclarations: ASTNode.GlobalDeclaration[];
+    getOuterGlobalMacroDeclarations(): ASTNode.GlobalDeclaration[];
+}

package/types/parser/ShaderTargetParser.d.ts

@@ -0,0 +1,24 @@
+import { BaseToken } from "../common/BaseToken";
+import { StateActionTable, StateGotoTable } from "../lalr/types";
+import { MacroDefineList } from "../Preprocessor";
+import { ASTNode } from "./AST";
+import { Grammar } from "./Grammar";
+import SematicAnalyzer from "./SemanticAnalyzer";
+/**
+ * The syntax parser and sematic analyzer of `ShaderCompiler` compiler
+ */
+export declare class ShaderTargetParser {
+    readonly actionTable: StateActionTable;
+    readonly gotoTable: StateGotoTable;
+    readonly grammar: Grammar;
+    readonly sematicAnalyzer: SematicAnalyzer;
+    private _traceBackStack;
+    private get curState();
+    private get stateActionTable();
+    private get stateGotoTable();
+    static _singleton: ShaderTargetParser;
+    static create(): ShaderTargetParser;
+    private constructor();
+    parse(tokens: Generator<BaseToken, BaseToken>, macroDefineList: MacroDefineList): ASTNode.GLShaderProgram | null;
+    private _printStack;
+}