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

package/types/common/types.d.ts

@@ -0,0 +1,101 @@
+import { Keyword } from "./enums/Keyword";
+export declare enum ETokenType {
+    ID = 1000,
+    FLOAT_CONSTANT = 1001,
+    INT_CONSTANT = 1002,
+    STRING_CONST = 1003,
+    /** << */
+    LEFT_OP = 1004,
+    /** \>> */
+    RIGHT_OP = 1005,
+    /** ++ */
+    INC_OP = 1006,
+    /** -- */
+    DEC_OP = 1007,
+    /** <= */
+    LE_OP = 1008,
+    /** \>= */
+    GE_OP = 1009,
+    /** == */
+    EQ_OP = 1010,
+    /** != */
+    NE_OP = 1011,
+    /** && */
+    AND_OP = 1012,
+    /** || */
+    OR_OP = 1013,
+    /** ^^ */
+    XOR_OP = 1014,
+    /** *= */
+    MUL_ASSIGN = 1015,
+    /** /= */
+    DIV_ASSIGN = 1016,
+    /** += */
+    ADD_ASSIGN = 1017,
+    /** -= */
+    SUB_ASSIGN = 1018,
+    /** %= */
+    MOD_ASSIGN = 1019,
+    /** <<= */
+    LEFT_ASSIGN = 1020,
+    /** >>= */
+    RIGHT_ASSIGN = 1021,
+    /** &= */
+    AND_ASSIGN = 1022,
+    /** ^= */
+    XOR_ASSIGN = 1023,
+    /** |= */
+    OR_ASSIGN = 1024,
+    /** ( */
+    LEFT_PAREN = 1025,
+    /** ) */
+    RIGHT_PAREN = 1026,
+    /** [ */
+    LEFT_BRACKET = 1027,
+    /** ] */
+    RIGHT_BRACKET = 1028,
+    /** { */
+    LEFT_BRACE = 1029,
+    /** } */
+    RIGHT_BRACE = 1030,
+    /** . */
+    DOT = 1031,
+    /** , */
+    COMMA = 1032,
+    COLON = 1033,
+    /** = */
+    EQUAL = 1034,
+    /** ; */
+    SEMICOLON = 1035,
+    /** ! */
+    BANG = 1036,
+    /** \- */
+    DASH = 1037,
+    /** ~ */
+    TILDE = 1038,
+    PLUS = 1039,
+    /** \* */
+    STAR = 1040,
+    /** / */
+    SLASH = 1041,
+    /** % */
+    PERCENT = 1042,
+    /** < */
+    LEFT_ANGLE = 1043,
+    /** \> */
+    RIGHT_ANGLE = 1044,
+    VERTICAL_BAR = 1045,
+    /** ^ */
+    CARET = 1046,
+    /** & */
+    AMPERSAND = 1047,
+    /** ? */
+    QUESTION = 1048,
+    NotWord = 1049,
+    /** ε */
+    EPSILON = 1998,
+    EOF = 1999
+}
+export declare const TypeAny = 3000;
+export type GalaceanDataType = Keyword.VOID | Keyword.FLOAT | Keyword.BOOL | Keyword.INT | Keyword.UINT | Keyword.VEC2 | Keyword.VEC3 | Keyword.VEC4 | Keyword.BVEC2 | Keyword.BVEC3 | Keyword.BVEC4 | Keyword.IVEC2 | Keyword.IVEC3 | Keyword.IVEC4 | Keyword.UVEC2 | Keyword.UVEC3 | Keyword.UVEC4 | Keyword.MAT2 | Keyword.MAT3 | Keyword.MAT4 | Keyword.MAT2X3 | Keyword.MAT2X4 | Keyword.MAT3X2 | Keyword.MAT3X4 | Keyword.MAT4X2 | Keyword.MAT4X3 | Keyword.SAMPLER2D | Keyword.SAMPLER3D | Keyword.SAMPLER_CUBE | Keyword.SAMPLER2D_SHADOW | Keyword.SAMPLER_CUBE_SHADOW | Keyword.SAMPLER2D_ARRAY | Keyword.SAMPLER2D_ARRAY_SHADOW | Keyword.I_SAMPLER2D | Keyword.I_SAMPLER3D | Keyword.I_SAMPLER_CUBE | Keyword.I_SAMPLER2D_ARRAY | Keyword.U_SAMPLER2D | Keyword.U_SAMPLER3D | Keyword.U_SAMPLER_CUBE | Keyword.U_SAMPLER2D_ARRAY | Keyword.VEC4_ARRAY | typeof TypeAny | string;
+export type TokenType = ETokenType | Keyword;

package/types/index.d.ts

@@ -0,0 +1,3 @@
+export { ShaderCompiler } from "./ShaderCompiler";
+export * from "./GSError";
+export declare const version = "__buildVersion";

package/types/lalr/CFG.d.ts

@@ -0,0 +1,5 @@
+import { Grammar } from "../parser/Grammar";
+import SemanticAnalyzer from "../parser/SemanticAnalyzer";
+declare const createGrammar: () => Grammar;
+declare const addTranslationRule: (sa: SemanticAnalyzer) => void;
+export { addTranslationRule, createGrammar };

package/types/lalr/LALR1.d.ts

@@ -0,0 +1,27 @@
+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 static _isKnownShiftPreferred;
+    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,143 @@
+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 _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 _currentMacroName;
+    private _currentMacroParamsLexeme;
+    private _currentMacroValueStart;
+    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;
+    /**
+     * Walk a `#define` directive head once and produce everything both routing
+     * and registration need: name range, optional params range, value range,
+     * and whether the value parses as an `expression`.
+     *
+     * The replacement list is split three ways:
+     *
+     *  - **AST path** (`isExpression = true`): value parses as `expression`.
+     *    Covers identifiers, literals, parenthesized sub-expressions, operator
+     *    expressions, function calls, top-level comma lists (per C99 §6.10.3).
+     *
+     *  - **Legacy opaque path** (`isExpression = false`, no throw): the three
+     *    GLSL-ES-§3.4-legal-but-not-an-expression shapes with real-world use —
+     *      1. empty value                       e.g. `#define COMMON_INCLUDED`
+     *      2. single type/qualifier keyword     e.g. `#define FxaaFloat float`
+     *      3. type-qualifier list               e.g. `#define TEX_PARAM(s) mediump sampler2D s`
+     *
+     *    Note on X-macro support: the classical C X-macro pattern (a list
+     *    macro re-expanded with redefined `X(...)`) works fine — it uses
+     *    function-like macros + `\` line-continuation + `#undef`, all of
+     *    which Galacean supports. It does NOT require unbalanced parens.
+     *
+     *  - **Authoring error** (throws): every other shape that's not a valid
+     *    `expression`. Legal token sequences in theory but not used in real
+     *    GLSL — almost always author mistakes. We surface one uniform
+     *    diagnostic with the macro name and value text and let the user fix
+     *    their code instead of routing politely.
+     *
+     *    Unsupported shapes that throw (non-exhaustive — the predicate is
+     *    "the value doesn't reduce as `expression` and isn't one of the three
+     *    legacy shapes above"):
+     *      - leading bare punctuation       `,` `;` `:` `?` `)` `]`
+     *      - trailing `,` or `;`            e.g. `#define X a, b,`
+     *      - trailing binary / unary op     `+` `-` `*` `/` `%` `&` `|` `^`
+     *                                       `<` `>` `=` `!` `~`
+     *      - trailing ternary fragment      `?` or `:`
+     *      - unbalanced `[` / `]`           e.g. `#define X a[b`
+     *      - unbalanced `(` / `)`           e.g. `#define PAREN (`
+     *
+     * Returns `null` if the directive is malformed before the name. `cursor` is
+     * the position past the last non-newline char (caller advances from there).
+     */
+    private _peekMacroDefine;
+    /** GLSL type / qualifier keywords that aren't expression starters when standing alone.
+     *  `true` / `false` are excluded — they're `primary_expression` literals.
+     *  `#`-prefixed entries are excluded — they're preprocessor directive names. */
+    private static _isNonExpressionLeadingKeyword;
+    /**
+     * 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.
+     */
+    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;
+    /** Render a `[start, end)` value range as space-separated significant chars,
+     *  using the same comment / line-continuation rules `_skipNonSemantic`
+     *  applies on the token-stream path. Used as the dedup key body. */
+    private static _normalizeValueText;
+    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";