@galacean/engine-shaderlab 1.6.8 → 1.6.10

package/types/macroProcessor/MacroParser.d.ts

@@ -0,0 +1,7 @@
+import { ShaderRange } from "../common";
+import { BlockInfo } from "./sourceMap";
+export interface ExpandSegment {
+    block?: BlockInfo;
+    rangeInBlock: ShaderRange;
+    replace: string;
+}

package/types/macroProcessor/MacroParserLexer.d.ts

@@ -0,0 +1,32 @@
+import { ShaderPosition, ShaderRange } from "../common";
+import PpSourceMap from "./sourceMap";
+import { BaseLexer } from "../common/BaseLexer";
+import { BaseToken } from "../common/BaseToken";
+import { MacroParserToken } from "./constants";
+export type OnToken = (token: BaseToken, scanner: MacroParserLexer) => void;
+export default class MacroParserLexer extends BaseLexer {
+    private static _isPpCharacters;
+    private static _lexemeTable;
+    private macroLvl;
+    readonly sourceMap: PpSourceMap;
+    readonly file: string;
+    readonly blockRange?: ShaderRange;
+    constructor(source: string, file?: string, blockRange?: ShaderRange);
+    scanWordsUntilTerminator(terminatorChar: string): BaseToken[];
+    scanWord(): BaseToken;
+    scanToken(): BaseToken | undefined;
+    scanQuotedString(): BaseToken<MacroParserToken.string_const>;
+    scanToChar(char: string): void;
+    scanMacroBranchBody(): {
+        body: BaseToken<MacroParserToken.chunk>;
+        nextDirective: BaseToken;
+    };
+    scanPairedBlock(lc: string, rc: string): void;
+    /**
+     * @returns end ShaderPosition
+     */
+    scanRemainMacro(): ShaderPosition;
+    peekNonSpace(): string;
+    scanInteger(): BaseToken<number>;
+    scanMacroBody(): BaseToken<MacroParserToken.line_remain>;
+}

package/types/macroProcessor/Utils.d.ts

@@ -0,0 +1,5 @@
+import { ExpandSegment } from "./MacroParser";
+import PpSourceMap from "./sourceMap";
+export declare class PpUtils {
+    static expand(segments: ExpandSegment[], source: string, sourceMap?: PpSourceMap): string;
+}

package/types/macroProcessor/constants.d.ts

@@ -0,0 +1,54 @@
+export declare enum MacroParserToken {
+    id = 0,
+    line_remain = 1,
+    chunk = 2,
+    int_constant = 3,
+    string_const = 4,
+    /** \>> */
+    right_op = 5,
+    /** << */
+    left_op = 6,
+    left_paren = 7,
+    right_paren = 8,
+    /** \>= */
+    ge = 9,
+    /** <= */
+    le = 10,
+    /** == */
+    eq = 11,
+    /** != */
+    neq = 12,
+    /** && */
+    and = 13,
+    /** || */
+    or = 14,
+    /** < */
+    left_angle = 15,
+    /** \> */
+    right_angle = 16,
+    /** \* */
+    star = 17,
+    /** + */
+    plus = 18,
+    /** \- */
+    dash = 19,
+    /** ! */
+    bang = 20,
+    /** \/ */
+    slash = 21,
+    /** % */
+    percent = 22,
+    EOF = 100
+}
+export declare enum MacroParserKeyword {
+    define = 101,
+    undef = 102,
+    if = 103,
+    ifdef = 104,
+    ifndef = 105,
+    else = 106,
+    elif = 107,
+    endif = 108,
+    defined = 109
+}
+export type MacroParserConstant = boolean | number;

package/types/macroProcessor/index.d.ts

@@ -0,0 +1 @@
+export * from "./MacroParser";

package/types/macroProcessor/sourceMap/index.d.ts

@@ -0,0 +1,37 @@
+import { ShaderRange } from "../../common/ShaderRange";
+export declare class BlockInfo {
+    readonly sourceFile: string;
+    readonly rangeInFile?: ShaderRange;
+    readonly sourceMap?: PpSourceMap;
+    constructor(sourceFile?: string, rangeInFile?: ShaderRange, sourceMap?: PpSourceMap);
+}
+export declare class MapRange {
+    sourceLoc: {
+        block: BlockInfo;
+        rangeInBlock: ShaderRange;
+    };
+    generatedLoc: {
+        start: number;
+        end: number;
+    };
+    constructor(sourceBlock: BlockInfo, rangeInBlock: ShaderRange, generatedLoc: {
+        start: number;
+        end: number;
+    });
+    getSourceIndex(generatedIdx: number): {
+        sourceFile: string;
+        index: number;
+    };
+}
+export default class PpSourceMap {
+    readonly mapRanges: MapRange[];
+    static rangeContains(range: MapRange["generatedLoc"], index: number): boolean;
+    addMapRange(mapRange: MapRange): void;
+    /**
+     * @returns index
+     */
+    map(index: number): {
+        sourceFile: string;
+        index: number;
+    };
+}

package/types/parser/AST.d.ts

@@ -0,0 +1,448 @@
+import { ClearableObjectPool, IPoolElement } from "@galacean/engine";
+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 | 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;
+        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;
+        init(): void;
+        semanticAnalyze(sa: SemanticAnalyzer): void;
+    }
+    export class MacroCallFunction extends TreeNode {
+        referenceSymbolNames: string[];
+        macroName: string;
+        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;
+}