@galacean/engine-shader-compiler 2.0.0-alpha.31

package/types/lalr/LALR1.d.ts

@@ -0,0 +1,26 @@
+import { Grammar } from "../parser/Grammar";
+import { NoneTerminal, Terminal } from "../parser/GrammarSymbol";
+import { StateActionTable, StateGotoTable } from "./types";
+/**
+ * The [LALR1](https://web.stanford.edu/class/archive/cs/cs143/cs143.1128/handouts/140%20LALR%20Parsing.pdf) Parser generator
+ */
+export declare class LALR1 {
+    readonly firstSetMap: Map<NoneTerminal, Set<Terminal>>;
+    readonly followSetMap: Map<NoneTerminal, Set<Terminal>>;
+    readonly actionTable: StateActionTable;
+    readonly gotoTable: StateGotoTable;
+    private grammar;
+    /** For circle detect */
+    private _firstSetNTStack;
+    constructor(grammar: Grammar);
+    generate(): void;
+    private buildStateTable;
+    private _extendState;
+    private _closure;
+    private _extendStateItem;
+    private _inferNextState;
+    /** Resolve shift-reduce/reduce-reduce conflict detect */
+    private _addAction;
+    private computeFirstSet;
+    private _computeFirstSetForNT;
+}

package/types/lalr/Production.d.ts

@@ -0,0 +1,9 @@
+import { NoneTerminal, GrammarSymbol } from "../parser/GrammarSymbol";
+export default class Production {
+    private static _id;
+    static pool: Map<number, Production>;
+    readonly goal: NoneTerminal;
+    readonly derivation: GrammarSymbol[];
+    readonly id: number;
+    constructor(goal: NoneTerminal, derivation: GrammarSymbol[]);
+}

package/types/lalr/State.d.ts

@@ -0,0 +1,20 @@
+import { Terminal } from "../parser/GrammarSymbol";
+import Production from "./Production";
+import StateItem from "./StateItem";
+export default class State {
+    static closureMap: Map<string /** state mapKey */, State>;
+    static pool: Map<number, State>;
+    static _id: number;
+    readonly id: number;
+    readonly cores: Set<StateItem>;
+    private _items;
+    get items(): Set<StateItem>;
+    closured: boolean;
+    get needReInfer(): boolean;
+    private _stateItemPool;
+    static create(cores: StateItem[]): State;
+    static getMapKey(cores: StateItem[]): string;
+    private constructor();
+    getStateItemMapKey(production: Production, position: number): string;
+    createStateItem(production: Production, position: number, lookaheadSet?: Iterable<Terminal>): StateItem;
+}

package/types/lalr/StateItem.d.ts

@@ -0,0 +1,20 @@
+import { Terminal } from "../parser/GrammarSymbol";
+import Production from "./Production";
+export default class StateItem {
+    static _id: number;
+    readonly production: Production;
+    readonly position: number;
+    readonly lookaheadSet: Set<Terminal>;
+    readonly id: number;
+    _needReInfer: boolean;
+    get needReInfer(): boolean;
+    set needReInfer(v: boolean);
+    get curSymbol(): import("../parser/GrammarSymbol").GrammarSymbol;
+    get nextSymbol(): import("../parser/GrammarSymbol").GrammarSymbol;
+    constructor(production: Production, position: number, lookahead: Iterable<Terminal>);
+    addLookahead(ts: Iterable<Terminal>): void;
+    symbolByOffset(offset: number): import("../parser/GrammarSymbol").GrammarSymbol;
+    canReduce(): boolean;
+    advance(): StateItem;
+    toString(): string;
+}

package/types/lalr/Utils.d.ts

@@ -0,0 +1,22 @@
+import { ShaderRange } from "../common";
+import { TreeNode } from "../parser/AST";
+import { TranslationRule } from "../parser/SemanticAnalyzer";
+import { NoneTerminal, GrammarSymbol } from "../parser/GrammarSymbol";
+import Production from "./Production";
+import { ActionInfo } from "./types";
+import { ClearableObjectPool, type IPoolElement } from "@galacean/engine-core";
+import { NodeChild } from "../parser/types";
+export default class GrammarUtils {
+    static isTerminal(sm: GrammarSymbol): boolean;
+    static toString(sm: GrammarSymbol): string;
+    static createProductionWithOptions(goal: NoneTerminal, options: GrammarSymbol[][], 
+    /** the ast node */
+    astTypePool?: ClearableObjectPool<{
+        set: (loc: ShaderRange, children: NodeChild[]) => void;
+    } & IPoolElement & TreeNode>): [GrammarSymbol[], TranslationRule][];
+    static addMapSetItem<K, T>(map: Map<K, Set<T>>, k: K, v: T): void;
+    static isSubSet<T>(sa: Set<T>, sb: Set<T>): boolean;
+    static isActionEqual(a: ActionInfo, b: ActionInfo): boolean;
+    static printAction(actionInfo: ActionInfo): string;
+    static printProduction(production: Production): string;
+}

package/types/lalr/index.d.ts

@@ -0,0 +1,2 @@
+export { LALR1 } from "./LALR1";
+export * from "./CFG";

package/types/lalr/types.d.ts

@@ -0,0 +1,14 @@
+import { NoneTerminal, Terminal } from "../parser/GrammarSymbol";
+export type StateActionTable = Map<number /** state ID */, ActionTable>;
+export type ActionTable = Map<Terminal, ActionInfo>;
+export type StateGotoTable = Map<number /** state ID */, GotoTable>;
+export type GotoTable = Map<NoneTerminal, number /** state ID */>;
+export declare enum EAction {
+    Shift = 0,
+    Reduce = 1,
+    Accept = 2
+}
+export interface ActionInfo {
+    action: EAction;
+    target?: number;
+}

package/types/lexer/Lexer.d.ts

@@ -0,0 +1,111 @@
+import { BaseLexer } from "../common/BaseLexer";
+import { BaseToken, BranchSignature } from "../common/BaseToken";
+import { MacroDefineList } from "../Preprocessor";
+/**
+ * The Lexer of Shader Compiler
+ */
+export declare class Lexer extends BaseLexer {
+    macroDefineList: MacroDefineList;
+    private static _lexemeTable;
+    private static readonly _defineDirectiveReg;
+    private static readonly _referenceReg;
+    private static readonly _lineContinuationReg;
+    private static _ifCounter;
+    /** Two branch signatures are equal iff they have the same constraints in the
+     *  same order with the same polarity. Used by `#define` dedup and AST upgrade
+     *  matching. */
+    static sameBranch(a: BranchSignature, b: BranchSignature): boolean;
+    /**
+     * Returns true if a `#define` registered under `defBranch` is reachable from
+     * a call site under `callSiteBranch`. Two signatures are mutually exclusive
+     * iff some flag appears in both with opposite `defined` polarity. Anything
+     * else is compatible — the same flag with the same polarity, or flags that
+     * simply don't intersect.
+     *
+     * Conservative for `#if expr` (not modeled — `tokenize` pushes a sentinel
+     * with `name === ""` to keep the `#endif` stack depth correct; that
+     * sentinel never matches a real flag in the polarity check below, so it
+     * stays visible from everywhere). Exact for the common `#ifdef` /
+     * `#ifndef` / `#else` cases that drive real shader code.
+     */
+    static isVisibleFrom(defBranch: BranchSignature, callSiteBranch: BranchSignature): boolean;
+    private _needScanMacroConditionExpression;
+    private _inMacroDefineValue;
+    private _macroDefineExpectsNameToken;
+    private _macroDefineExpectsParamsToken;
+    private _macroDefineDirectiveStart;
+    private _branchStack;
+    private _pendingBranchPushDefined;
+    tokenize(): Generator<BaseToken<number>, BaseToken<number>, unknown>;
+    constructor(source: string, macroDefineList: MacroDefineList);
+    scanToken(): BaseToken;
+    private _scanStringConst;
+    private _scanNumAfterDot;
+    private _scanUtilBreakLine;
+    private _scanDirectives;
+    /** True if the current char is an unescaped line break (ignoring `\` continuation). */
+    private _isAtLineBreak;
+    /**
+     * Peek forward from `#define` and decide whether this directive should use the
+     * expression-AST path or the legacy opaque path.
+     *
+     * The AST path's only purpose is to enable the shader compiler's structural rewrites
+     * (varying flatten, struct-property reference tracking) on macro values that
+     * mention struct members. Every other shape — bare identifiers, numeric
+     * literals, type-alias keywords (`#define FxaaFloat2 vec2`), constructor
+     * calls, qualifier fragments, `#define COMMA ,` etc. — is correctly handled
+     * by the GLSL driver via textual substitution and needs no AST.
+     *
+     * So the routing rule is positive and information-driven: **AST iff the
+     * replacement list contains a `.` member-access operator**. This is robust
+     * against new GLSL keywords / extensions and incidentally moves all simple
+     * constants and type aliases off the 18-layer expression precedence chain.
+     */
+    private _defineHasValue;
+    /**
+     * If `i` points at a `\` immediately followed by a newline (`\n`, `\r`, or
+     * `\r\n`), return the index just past the pair (a single atom in the C/GLSL
+     * preprocessor view). Otherwise return `i` unchanged. This is the single
+     * source of truth for line-continuation detection — callers along the
+     * directive-scanning path (`_skipNonSemantic`, `_scanUtilBreakLine`,
+     * `_scanMacroDefineParams`) all delegate here so the rule stays in one
+     * place. The string-level `_lineContinuationReg` covers the regex path
+     * used by `_registerMacroDefine` for one-shot folding.
+     */
+    private static _skipLineContinuation;
+    /**
+     * Pure positional version of "skip non-semantic characters within a single
+     * `#define` directive": spaces, tabs, `\` + newline line-continuation, block
+     * comments, line comments. A real `\n` (without preceding `\`) is *not*
+     * consumed — it terminates the directive — so callers can detect
+     * end-of-directive after this returns. Shared by `_defineHasValue` (peek
+     * path) and `_skipInlineSpaceAndComments` (consuming path) so both honor
+     * the same lexical view.
+     */
+    private static _skipNonSemantic;
+    /** Consuming wrapper around `_skipNonSemantic` operating on the lexer's
+     *  current position. Used by the `#define`-value scan state machine. Goes
+     *  through `advance(diff)` so verbose builds keep their line/column counters
+     *  in sync (advance walks the consumed slice and bumps `_line` on `\n`). */
+    private _skipInlineSpaceAndComments;
+    /**
+     * Capture a `(param1, param2, …)` block immediately after the macro name in a
+     * `#define` directive, producing a single `MACRO_DEFINE_PARAMS` token whose lexeme
+     * is the complete `(…)` text (including parens). Balanced parentheses are honored
+     * so the scanner doesn't terminate early on inner `()`. Newlines inside the
+     * parameter list are tolerated (rare; appears when the directive uses `\` line
+     * continuation), but any newline raises no special error here — it simply stops
+     * capture and parser handles the resulting token however it can.
+     */
+    private _scanMacroDefineParams;
+    /** Emit `MACRO_DEFINE_END` at the end of a `#define` value, consuming the newline. */
+    private _emitMacroDefineEnd;
+    private _registerMacroDefine;
+    private _scanMacroConditionExpression;
+    private _scanWord;
+    /** True iff at least one `#define <word>` is reachable from the current branch. */
+    private _isVisibleMacro;
+    private _scanNum;
+    private _scanFloatSuffix;
+    private _scanIntegerSuffix;
+}

package/types/lexer/index.d.ts

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