@galacean/engine-shaderlab 0.0.0-experimental-1.4-small-language.4 → 0.0.0-experimental-backup.0

package/types/parser/AST.d.ts

@@ -1,347 +0,0 @@
-import { BuiltinVariable } from "./builtin";
-import { ClearableObjectPool, IPoolElement } from "@galacean/engine";
-import { CodeGenVisitor } from "../codeGen";
-import { EKeyword, GalaceanDataType, ShaderRange, TokenType } from "../common";
-import { BaseToken, BaseToken as Token } from "../common/BaseToken";
-import { NoneTerminal } from "./GrammarSymbol";
-import SemanticAnalyzer from "./SemanticAnalyzer";
-import { ShaderData } from "./ShaderInfo";
-import { FnSymbol, StructSymbol, VarSymbol } 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 _location;
-    get children(): NodeChild[];
-    get location(): ShaderRange;
-    set(loc: ShaderRange, children: NodeChild[]): void;
-    init(): void;
-    dispose(): void;
-    codeGen(visitor: CodeGenVisitor): string;
-    /**
-     * Do semantic analyze right after the ast node is generated.
-     */
-    semanticAnalyze(sa: SemanticAnalyzer): void;
-}
-export declare namespace ASTNode {
-    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: EKeyword;
-        lexeme: string;
-        semanticAnalyze(sa: SemanticAnalyzer): void;
-    }
-    abstract class BasicTypeQualifier extends TreeNode {
-        qualifier: EKeyword;
-        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: Token[];
-        init(): void;
-        semanticAnalyze(sa: SemanticAnalyzer): void;
-    }
-    export class Declaration extends TreeNode {
-        codeGen(visitor: CodeGenVisitor): string;
-    }
-    export class FunctionProtoType extends TreeNode {
-        ident: Token;
-        returnType: FullySpecifiedType;
-        parameterList: IParamInfo[];
-        paramSig: GalaceanDataType[];
-        semanticAnalyze(sa: SemanticAnalyzer): void;
-        codeGen(visitor: CodeGenVisitor): string;
-    }
-    export class FunctionDeclarator extends TreeNode {
-        ident: Token;
-        returnType: FullySpecifiedType;
-        parameterInfoList: IParamInfo[] | undefined;
-        paramSig: GalaceanDataType[] | undefined;
-        semanticAnalyze(sa: SemanticAnalyzer): void;
-    }
-    export class FunctionHeader extends TreeNode {
-        ident: Token;
-        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 ParameterDeclaration extends TreeNode {
-        typeQualifier: TypeQualifier | undefined;
-        typeInfo: SymbolType;
-        ident: Token;
-        init(): void;
-        semanticAnalyze(sa: SemanticAnalyzer): void;
-    }
-    export class ParameterDeclarator extends TreeNode {
-        ident: Token;
-        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;
-        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: AssignmentExpression[];
-        init(): void;
-        semanticAnalyze(sa: SemanticAnalyzer): void;
-    }
-    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?: Token;
-        propList: StructProp[];
-        init(): void;
-        semanticAnalyze(sa: SemanticAnalyzer): void;
-    }
-    export class StructDeclarationList extends TreeNode {
-        propList: StructProp[];
-        init(): void;
-        semanticAnalyze(sa: SemanticAnalyzer): void;
-    }
-    export class StructDeclaration extends TreeNode {
-        typeSpecifier: TypeSpecifier;
-        declaratorList: StructDeclaratorList;
-        props: StructProp[];
-        init(): void;
-        semanticAnalyze(sa: SemanticAnalyzer): 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: Token;
-        arraySpecifier: ArraySpecifier | undefined;
-        init(): void;
-        semanticAnalyze(sa: SemanticAnalyzer): void;
-    }
-    export class VariableDeclaration extends TreeNode {
-        type: FullySpecifiedType;
-        semanticAnalyze(sa: SemanticAnalyzer): void;
-        codeGen(visitor: CodeGenVisitor): string;
-    }
-    export class VariableDeclarationList extends TreeNode {
-        type: FullySpecifiedType;
-        semanticAnalyze(sa: SemanticAnalyzer): void;
-    }
-    export class VariableIdentifier extends TreeNode {
-        symbolInfo: VarSymbol | BuiltinVariable | null;
-        lexeme: string;
-        typeInfo: GalaceanDataType;
-        semanticAnalyze(sa: SemanticAnalyzer): void;
-        codeGen(visitor: CodeGenVisitor): string;
-    }
-    export class GLShaderProgram extends TreeNode {
-        shaderData: ShaderData;
-        semanticAnalyze(sa: SemanticAnalyzer): void;
-    }
-    export {};
-}

package/types/parser/Grammar.d.ts

@@ -1,11 +0,0 @@
-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

@@ -1,107 +0,0 @@
-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,
-    _ignore = 2100
-}
-export type GrammarSymbol = Terminal | NoneTerminal;
-export type Derivation = GrammarSymbol[];

package/types/parser/SemanticAnalyzer.d.ts

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

package/types/parser/ShaderInfo.d.ts

@@ -1,8 +0,0 @@
-import { ASTNode } from "./AST";
-import { TargetSymbolTable } from "../parser/symbolTable";
-export declare class ShaderData {
-    symbolTable: TargetSymbolTable;
-    vertexMain: ASTNode.FunctionDefinition;
-    fragmentMain: ASTNode.FunctionDefinition;
-    globalPrecisions: ASTNode.PrecisionSpecifier[];
-}

package/types/parser/ShaderTargetParser.d.ts

@@ -1,23 +0,0 @@
-import { Grammar } from "./Grammar";
-import { BaseToken } from "../common/BaseToken";
-import { StateActionTable, StateGotoTable } from "../lalr/types";
-import { ASTNode } from "./AST";
-import SematicAnalyzer from "./SemanticAnalyzer";
-/**
- * The syntax parser and sematic analyzer of `ShaderLab` 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>): ASTNode.GLShaderProgram | null;
-    private _printStack;
-}

package/types/parser/builtin/functions.d.ts

@@ -1,34 +0,0 @@
-import { GalaceanDataType } from "../../common";
-import { EShaderStage } from "../../common/Enums";
-export declare enum EGenType {
-    GenType = 200,
-    GenIntType = 201,
-    GenUintType = 202,
-    GenBoolType = 203,
-    Mat = 204,
-    BoolVec = 205,
-    IntVec = 206,
-    UintVec = 207,
-    Vec = 208,
-    GVec4 = 209,
-    GSampler2D = 210,
-    GSampler3D = 211,
-    GSamplerCube = 212,
-    GSampler2DArray = 213
-}
-export type NonGenericGalaceanType = Exclude<GalaceanDataType, string>;
-type BuiltinType = NonGenericGalaceanType | EGenType;
-export declare class BuiltinFunction {
-    ident: string;
-    readonly args: BuiltinType[];
-    readonly scope: EShaderStage;
-    private _returnType;
-    private _realReturnType;
-    get realReturnType(): NonGenericGalaceanType;
-    private constructor();
-    static getReturnType(fn: BuiltinFunction, genType?: NonGenericGalaceanType): NonGenericGalaceanType;
-    static _create(ident: string, returnType: BuiltinType, ...args: BuiltinType[]): void;
-    static _createWithScop(ident: string, returnType: BuiltinType, scope: EShaderStage, ...args: BuiltinType[]): void;
-    static getFn(ident: string, parameterTypes: NonGenericGalaceanType[]): BuiltinFunction | undefined;
-}
-export {};

package/types/parser/builtin/index.d.ts

@@ -1,2 +0,0 @@
-export * from "./functions";
-export * from "./variables";

package/types/parser/builtin/variables.d.ts

@@ -1,11 +0,0 @@
-import { GalaceanDataType } from "../../common";
-import { EShaderStage } from "../../common/Enums";
-export declare const BuiltinVariableTable: Map<string, BuiltinVariable>;
-export declare class BuiltinVariable {
-    type: GalaceanDataType;
-    lexeme: string;
-    scope: EShaderStage;
-    private constructor();
-    static createVariable(lexeme: string, type: GalaceanDataType, scope?: EShaderStage): void;
-    static getVar(ident: string): BuiltinVariable;
-}

package/types/parser/index.d.ts

@@ -1,2 +0,0 @@
-export { ShaderTargetParser } from "./ShaderTargetParser";
-export { Grammar } from "./Grammar";

package/types/parser/symbolTable/FnSymbol.d.ts

@@ -1,6 +0,0 @@
-import { ASTNode } from "../AST";
-import { SymbolInfo } from "./SymbolInfo";
-export declare class FnSymbol extends SymbolInfo {
-    astNode: ASTNode.FunctionDefinition;
-    constructor(lexeme: string, astNode: ASTNode.FunctionDefinition);
-}

package/types/parser/symbolTable/StructSymbol.d.ts

@@ -1,6 +0,0 @@
-import { ASTNode } from "../AST";
-import { SymbolInfo } from "./SymbolInfo";
-export declare class StructSymbol extends SymbolInfo {
-    astNode: ASTNode.StructSpecifier;
-    constructor(lexeme: string, astNode: ASTNode.StructSpecifier);
-}

package/types/parser/symbolTable/SymbolDataType.d.ts

@@ -1,8 +0,0 @@
-import { GalaceanDataType } from "../../common";
-import { ASTNode } from "../AST";
-export declare class SymbolDataType {
-    type: GalaceanDataType;
-    typeLexeme: string;
-    arraySpecifier?: ASTNode.ArraySpecifier;
-    constructor(type: GalaceanDataType, typeLexeme: string, arraySpecifier?: ASTNode.ArraySpecifier);
-}

package/types/parser/symbolTable/SymbolInfo.d.ts

@@ -1,18 +0,0 @@
-import { IBaseSymbol } from "../../common/BaseSymbolTable";
-import { GalaceanDataType } from "../../common/types";
-import { ASTNode } from "../AST";
-import { SymbolDataType } from "./SymbolDataType";
-export declare enum ESymbolType {
-    VAR = 0,
-    FN = 1,
-    STRUCT = 2
-}
-export type SymbolAstNode = ASTNode.Initializer | ASTNode.StructSpecifier | ASTNode.FunctionDefinition | ASTNode.ParameterDeclarator | ASTNode.InitDeclaratorList | ASTNode.VariableDeclaration;
-export declare class SymbolInfo implements IBaseSymbol {
-    readonly ident: string;
-    readonly symbolType: ESymbolType;
-    readonly astNode?: SymbolAstNode;
-    readonly dataType?: SymbolDataType;
-    readonly signature?: GalaceanDataType[];
-    constructor(ident: string, symbolType: ESymbolType, astNode?: SymbolAstNode, dataType?: SymbolDataType, signature?: GalaceanDataType[]);
-}

package/types/parser/symbolTable/TargetSymbolTable.d.ts

@@ -1,13 +0,0 @@
-import { GalaceanDataType } from "../../common";
-import { BaseSymbolTable } from "../../common/BaseSymbolTable";
-import { ASTNode } from "../AST";
-import { FnSymbol } from "./FnSymbol";
-import { StructSymbol } from "./StructSymbol";
-import { ESymbolType, SymbolInfo } from "./SymbolInfo";
-import { VarSymbol } from "./VarSymbol";
-export declare class TargetSymbolTable extends BaseSymbolTable<SymbolInfo> {
-    insert(sm: SymbolInfo): void;
-    lookup<T extends ESymbolType>(ident: string, symbolType: T, signature?: GalaceanDataType[], astNode?: ASTNode.FunctionDefinition): T extends ESymbolType.FN ? FnSymbol : T extends ESymbolType.STRUCT ? StructSymbol : T extends ESymbolType.VAR ? VarSymbol : SymbolInfo;
-    getAllFnSymbols(fnIdent: string): FnSymbol[];
-    private _compareWith;
-}

package/types/parser/symbolTable/VarSymbol.d.ts

@@ -1,8 +0,0 @@
-import { ASTNode } from "../AST";
-import { SymbolDataType } from "./SymbolDataType";
-import { SymbolInfo } from "./SymbolInfo";
-export declare class VarSymbol extends SymbolInfo {
-    astNode: ASTNode.Initializer | ASTNode.ParameterDeclarator | ASTNode.InitDeclaratorList | ASTNode.VariableDeclaration;
-    readonly isGlobalVariable: boolean;
-    constructor(ident: string, dataType: SymbolDataType, isGlobalVariable: boolean, initAst: ASTNode.Initializer | ASTNode.ParameterDeclarator | ASTNode.InitDeclaratorList | ASTNode.VariableDeclaration);
-}

package/types/parser/symbolTable/index.d.ts

@@ -1,6 +0,0 @@
-export * from "./FnSymbol";
-export * from "./StructSymbol";
-export * from "./SymbolDataType";
-export * from "./SymbolInfo";
-export * from "./TargetSymbolTable";
-export * from "./VarSymbol";

package/types/parser/types.d.ts

@@ -1,23 +0,0 @@
-import { NoneTerminal } from "./GrammarSymbol";
-import { BaseToken } from "../common/BaseToken";
-import { GalaceanDataType } from "../common";
-import { ASTNode, TreeNode } from "./AST";
-export type TraceStackItem = NoneTerminal | BaseToken;
-export declare class SymbolType {
-    type: GalaceanDataType;
-    typeLexeme: string;
-    arraySpecifier?: ASTNode.ArraySpecifier;
-    constructor(type: GalaceanDataType, typeLexeme: string, arraySpecifier?: ASTNode.ArraySpecifier);
-}
-export declare class StructProp implements IParamInfo {
-    typeInfo: SymbolType;
-    ident: BaseToken;
-    mrtIndex?: number;
-    constructor(typeInfo: SymbolType, ident: BaseToken, mrtIndex?: number);
-}
-export type NodeChild = TreeNode | BaseToken;
-export type IParamInfo = {
-    ident: BaseToken;
-    typeInfo: SymbolType;
-    astNode?: TreeNode;
-};

package/types/preprocessor/MacroDefine.d.ts

@@ -1,13 +0,0 @@
-import { BaseToken } from "../common/BaseToken";
-import { ShaderRange } from "../common";
-export declare class MacroDefine {
-    readonly macro: BaseToken;
-    readonly body?: BaseToken;
-    readonly location?: ShaderRange;
-    readonly args?: BaseToken[];
-    private _replaceRegex?;
-    private readonly _argsLexemes;
-    get isFunction(): boolean;
-    constructor(macro: BaseToken, body?: BaseToken, location?: ShaderRange, args?: BaseToken[]);
-    expandFunctionBody(args: string[]): string;
-}