@galacean/engine-shaderlab 1.4.8 → 1.4.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@galacean/engine-shaderlab",
-  "version": "1.4.8",
+  "version": "1.4.10",
   "publishConfig": {
     "access": "public",
     "registry": "https://registry.npmjs.org"
@@ -26,11 +26,11 @@
     "verbose/package.json"
   ],
   "devDependencies": {
-    "@galacean/engine-design": "1.4.8",
-    "@galacean/engine": "1.4.8"
+    "@galacean/engine-design": "1.4.10",
+    "@galacean/engine": "1.4.10"
   },
   "peerDependencies": {
-    "@galacean/engine": "1.4.8"
+    "@galacean/engine": "1.4.10"
   },
   "scripts": {
     "b:types": "tsc"

package/types/lalr/CFG.d.ts

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

package/types/lexer/Utils.d.ts

@@ -2,6 +2,6 @@ export default class LexerUtils {
     static isNum(charCode: number): boolean;
     static isLetter(charCode: number): boolean;
     static isAlpha(charCode: number): boolean;
-    static isPpCharactors(charCode: number): boolean;
+    static isPpCharacters(charCode: number): boolean;
     static isSpace(charCode: number): charCode is 9 | 10 | 13 | 32;
 }

package/types/parser/AST.d.ts

@@ -4,7 +4,7 @@ import { CodeGenVisitor } from "../codeGen";
 import { EKeyword, GalaceanDataType, ShaderRange, TokenType } from "../common";
 import { BaseToken, BaseToken as Token } from "../common/BaseToken";
 import { NoneTerminal } from "./GrammarSymbol";
-import SematicAnalyzer from "./SemanticAnalyzer";
+import SemanticAnalyzer from "./SemanticAnalyzer";
 import { ShaderData } from "./ShaderInfo";
 import { FnSymbol, StructSymbol, VarSymbol } from "./symbolTable";
 import { IParamInfo, NodeChild, StructProp, SymbolType } from "./types";
@@ -25,26 +25,26 @@ export declare abstract class TreeNode implements IPoolElement {
     /**
      * Do semantic analyze right after the ast node is generated.
      */
-    semanticAnalyze(sa: SematicAnalyzer): void;
+    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: SematicAnalyzer, loc: ShaderRange, children: NodeChild[]): void;
+    export function get(pool: ASTNodePool, sa: SemanticAnalyzer, loc: ShaderRange, children: NodeChild[]): void;
     export class TrivialNode extends TreeNode {
     }
     export class ScopeBrace extends TreeNode {
-        semanticAnalyze(sa: SematicAnalyzer): void;
+        semanticAnalyze(sa: SemanticAnalyzer): void;
     }
     export class ScopeEndBrace extends TreeNode {
-        semanticAnalyze(sa: SematicAnalyzer): void;
+        semanticAnalyze(sa: SemanticAnalyzer): void;
     }
     export class JumpStatement extends TreeNode {
         isFragReturnStatement: boolean;
         init(): void;
-        semanticAnalyze(sa: SematicAnalyzer): void;
+        semanticAnalyze(sa: SemanticAnalyzer): void;
         codeGen(visitor: CodeGenVisitor): string;
     }
     export class ConditionOpt extends TreeNode {
@@ -68,35 +68,34 @@ export declare namespace ASTNode {
         init(): void;
     }
     export class InitializerList extends ExpressionAstNode {
-        semanticAnalyze(sa: SematicAnalyzer): void;
+        semanticAnalyze(sa: SemanticAnalyzer): void;
     }
     export class Initializer extends ExpressionAstNode {
-        semanticAnalyze(sa: SematicAnalyzer): void;
+        semanticAnalyze(sa: SemanticAnalyzer): void;
     }
     export class SingleDeclaration extends TreeNode {
         typeSpecifier: TypeSpecifier;
         arraySpecifier?: ArraySpecifier;
         init(): void;
-        semanticAnalyze(sa: SematicAnalyzer): void;
+        semanticAnalyze(sa: SemanticAnalyzer): void;
         codeGen(visitor: CodeGenVisitor): string;
     }
     export class FullySpecifiedType extends TreeNode {
-        get qualifierList(): EKeyword[];
-        get typeSpecifier(): TypeSpecifier;
-        get type(): GalaceanDataType;
+        typeSpecifier: TypeSpecifier;
+        type: GalaceanDataType;
+        semanticAnalyze(_: SemanticAnalyzer): void;
     }
     export class TypeQualifier extends TreeNode {
-        qualifierList: EKeyword[];
-        semanticAnalyze(sa: SematicAnalyzer): void;
     }
     export class SingleTypeQualifier extends TreeNode {
         qualifier: EKeyword;
         lexeme: string;
-        semanticAnalyze(sa: SematicAnalyzer): void;
+        semanticAnalyze(sa: SemanticAnalyzer): void;
     }
     abstract class BasicTypeQualifier extends TreeNode {
-        get qualifier(): EKeyword;
-        get lexeme(): string;
+        qualifier: EKeyword;
+        lexeme: string;
+        semanticAnalyze(sa: SemanticAnalyzer): void;
     }
     export class StorageQualifier extends BasicTypeQualifier {
     }
@@ -107,24 +106,27 @@ export declare namespace ASTNode {
     export class InvariantQualifier extends BasicTypeQualifier {
     }
     export class TypeSpecifier extends TreeNode {
-        get type(): GalaceanDataType;
-        get lexeme(): string;
-        get arraySize(): number;
+        type: GalaceanDataType;
+        lexeme: string;
+        arraySize?: number;
+        isCustom: boolean;
+        init(): void;
         get arraySpecifier(): ArraySpecifier;
-        get isCustom(): boolean;
+        semanticAnalyze(sa: SemanticAnalyzer): void;
     }
     export class ArraySpecifier extends TreeNode {
-        get size(): number | undefined;
+        size: number | undefined;
+        semanticAnalyze(sa: SemanticAnalyzer): void;
     }
     export class IntegerConstantExpressionOperator extends TreeNode {
         compute: (a: number, b: number) => number;
-        get lexeme(): string;
-        semanticAnalyze(sa: SematicAnalyzer): void;
+        lexeme: string;
+        semanticAnalyze(sa: SemanticAnalyzer): void;
     }
     export class IntegerConstantExpression extends TreeNode {
         value?: number;
         init(): void;
-        semanticAnalyze(sa: SematicAnalyzer): void;
+        semanticAnalyze(sa: SemanticAnalyzer): void;
     }
     export class TypeSpecifierNonArray extends TreeNode {
         type: GalaceanDataType;
@@ -137,53 +139,56 @@ export declare namespace ASTNode {
         init(): void;
     }
     export class InitDeclaratorList extends TreeNode {
-        get typeInfo(): SymbolType;
-        semanticAnalyze(sa: SematicAnalyzer): void;
+        typeInfo: SymbolType;
+        semanticAnalyze(sa: SemanticAnalyzer): void;
     }
     export class IdentifierList extends TreeNode {
-        get idList(): Token[];
+        idList: Token[];
+        init(): void;
+        semanticAnalyze(sa: SemanticAnalyzer): void;
     }
     export class Declaration extends TreeNode {
         codeGen(visitor: CodeGenVisitor): string;
     }
     export class FunctionProtoType extends TreeNode {
-        private get declarator();
-        get ident(): BaseToken<number>;
-        get returnType(): FullySpecifiedType;
-        get parameterList(): IParamInfo[];
-        get paramSig(): GalaceanDataType[];
+        ident: Token;
+        returnType: FullySpecifiedType;
+        parameterList: IParamInfo[];
+        paramSig: GalaceanDataType[];
+        semanticAnalyze(sa: SemanticAnalyzer): void;
         codeGen(visitor: CodeGenVisitor): string;
     }
     export class FunctionDeclarator extends TreeNode {
-        private get header();
-        private get parameterList();
-        get ident(): BaseToken<number>;
-        get returnType(): FullySpecifiedType;
-        get parameterInfoList(): IParamInfo[];
-        get paramSig(): GalaceanDataType[];
-        semanticAnalyze(sa: SematicAnalyzer): void;
+        ident: Token;
+        returnType: FullySpecifiedType;
+        parameterInfoList: IParamInfo[] | undefined;
+        paramSig: GalaceanDataType[] | undefined;
+        semanticAnalyze(sa: SemanticAnalyzer): void;
     }
     export class FunctionHeader extends TreeNode {
-        get ident(): Token;
-        get returnType(): FullySpecifiedType;
-        semanticAnalyze(sa: SematicAnalyzer): void;
+        ident: Token;
+        returnType: FullySpecifiedType;
+        semanticAnalyze(sa: SemanticAnalyzer): void;
         codeGen(visitor: CodeGenVisitor): string;
     }
     export class FunctionParameterList extends TreeNode {
-        get parameterInfoList(): IParamInfo[];
-        get paramSig(): GalaceanDataType[];
+        parameterInfoList: IParamInfo[];
+        paramSig: GalaceanDataType[];
+        init(): void;
+        semanticAnalyze(sa: SemanticAnalyzer): void;
         codeGen(visitor: CodeGenVisitor): string;
     }
     export class ParameterDeclaration extends TreeNode {
-        get typeQualifier(): TypeQualifier;
-        private get parameterDeclarator();
-        get typeInfo(): SymbolType;
-        get ident(): BaseToken<number>;
-        semanticAnalyze(sa: SematicAnalyzer): void;
+        typeQualifier: TypeQualifier | undefined;
+        typeInfo: SymbolType;
+        ident: Token;
+        init(): void;
+        semanticAnalyze(sa: SemanticAnalyzer): void;
     }
     export class ParameterDeclarator extends TreeNode {
-        get ident(): Token;
-        get typeInfo(): SymbolType;
+        ident: Token;
+        typeInfo: SymbolType;
+        semanticAnalyze(sa: SemanticAnalyzer): void;
     }
     export class SimpleStatement extends TreeNode {
     }
@@ -197,47 +202,48 @@ export declare namespace ASTNode {
         codeGen(visitor: CodeGenVisitor): string;
     }
     export class FunctionDefinition extends TreeNode {
-        private _returnStatement?;
-        get returnStatement(): ASTNode.JumpStatement | undefined;
-        get protoType(): FunctionProtoType;
-        get statements(): CompoundStatementNoScope;
+        returnStatement?: ASTNode.JumpStatement;
+        protoType: FunctionProtoType;
+        statements: CompoundStatementNoScope;
         init(): void;
-        semanticAnalyze(sa: SematicAnalyzer): void;
+        semanticAnalyze(sa: SemanticAnalyzer): void;
         codeGen(visitor: CodeGenVisitor): string;
     }
     export class FunctionCall extends ExpressionAstNode {
-        semanticAnalyze(sa: SematicAnalyzer): void;
+        semanticAnalyze(sa: SemanticAnalyzer): void;
         codeGen(visitor: CodeGenVisitor): string;
     }
     export class FunctionCallGeneric extends ExpressionAstNode {
         fnSymbol: FnSymbol | StructSymbol | undefined;
         init(): void;
-        semanticAnalyze(sa: SematicAnalyzer): void;
+        semanticAnalyze(sa: SemanticAnalyzer): void;
     }
     export class FunctionCallParameterList extends TreeNode {
-        get paramSig(): GalaceanDataType[] | undefined;
-        get paramNodes(): AssignmentExpression[];
+        paramSig: GalaceanDataType[];
+        paramNodes: AssignmentExpression[];
+        init(): void;
+        semanticAnalyze(sa: SemanticAnalyzer): void;
     }
     export class PrecisionSpecifier extends TreeNode {
-        semanticAnalyze(sa: SematicAnalyzer): void;
+        semanticAnalyze(sa: SemanticAnalyzer): void;
     }
     export class FunctionIdentifier extends TreeNode {
-        get ident(): GalaceanDataType;
-        get lexeme(): string;
-        get isBuiltin(): boolean;
-        semanticAnalyze(sa: SematicAnalyzer): void;
+        ident: GalaceanDataType;
+        lexeme: string;
+        isBuiltin: boolean;
+        semanticAnalyze(sa: SemanticAnalyzer): void;
         codeGen(visitor: CodeGenVisitor): string;
     }
     export class AssignmentExpression extends ExpressionAstNode {
-        semanticAnalyze(sa: SematicAnalyzer): void;
+        semanticAnalyze(sa: SemanticAnalyzer): void;
     }
     export class AssignmentOperator extends TreeNode {
     }
     export class Expression extends ExpressionAstNode {
-        semanticAnalyze(sa: SematicAnalyzer): void;
+        semanticAnalyze(sa: SemanticAnalyzer): void;
     }
     export class PrimaryExpression extends ExpressionAstNode {
-        semanticAnalyze(sa: SematicAnalyzer): void;
+        semanticAnalyze(sa: SemanticAnalyzer): void;
     }
     export class PostfixExpression extends ExpressionAstNode {
         init(): void;
@@ -255,77 +261,87 @@ export declare namespace ASTNode {
         init(): void;
     }
     export class ShiftExpression extends ExpressionAstNode {
-        semanticAnalyze(sa: SematicAnalyzer): void;
+        semanticAnalyze(sa: SemanticAnalyzer): void;
     }
     export class RelationalExpression extends ExpressionAstNode {
-        semanticAnalyze(sa: SematicAnalyzer): void;
+        semanticAnalyze(sa: SemanticAnalyzer): void;
     }
     export class EqualityExpression extends ExpressionAstNode {
-        semanticAnalyze(sa: SematicAnalyzer): void;
+        semanticAnalyze(sa: SemanticAnalyzer): void;
     }
     export class AndExpression extends ExpressionAstNode {
-        semanticAnalyze(sa: SematicAnalyzer): void;
+        semanticAnalyze(sa: SemanticAnalyzer): void;
     }
     export class ExclusiveOrExpression extends ExpressionAstNode {
-        semanticAnalyze(sa: SematicAnalyzer): void;
+        semanticAnalyze(sa: SemanticAnalyzer): void;
     }
     export class InclusiveOrExpression extends ExpressionAstNode {
-        semanticAnalyze(sa: SematicAnalyzer): void;
+        semanticAnalyze(sa: SemanticAnalyzer): void;
     }
     export class LogicalAndExpression extends ExpressionAstNode {
-        semanticAnalyze(sa: SematicAnalyzer): void;
+        semanticAnalyze(sa: SemanticAnalyzer): void;
     }
     export class LogicalXorExpression extends ExpressionAstNode {
-        semanticAnalyze(sa: SematicAnalyzer): void;
+        semanticAnalyze(sa: SemanticAnalyzer): void;
     }
     export class LogicalOrExpression extends ExpressionAstNode {
-        semanticAnalyze(sa: SematicAnalyzer): void;
+        semanticAnalyze(sa: SemanticAnalyzer): void;
     }
     export class ConditionalExpression extends ExpressionAstNode {
-        semanticAnalyze(sa: SematicAnalyzer): void;
+        semanticAnalyze(sa: SemanticAnalyzer): void;
     }
     export class StructSpecifier extends TreeNode {
         ident?: Token;
-        get propList(): StructProp[];
-        semanticAnalyze(sa: SematicAnalyzer): void;
+        propList: StructProp[];
+        init(): void;
+        semanticAnalyze(sa: SemanticAnalyzer): void;
     }
     export class StructDeclarationList extends TreeNode {
-        get propList(): StructProp[];
+        propList: StructProp[];
+        init(): void;
+        semanticAnalyze(sa: SemanticAnalyzer): void;
     }
     export class StructDeclaration extends TreeNode {
-        get typeSpecifier(): TypeSpecifier;
-        get declaratorList(): StructDeclaratorList;
-        get propList(): StructProp[];
+        typeSpecifier: TypeSpecifier;
+        declaratorList: StructDeclaratorList;
+        props: StructProp[];
+        init(): void;
+        semanticAnalyze(sa: SemanticAnalyzer): void;
     }
     export class LayoutQualifier extends TreeNode {
-        get index(): number;
+        index: number;
+        semanticAnalyze(sa: SemanticAnalyzer): void;
     }
     export class StructDeclaratorList extends TreeNode {
-        get declaratorList(): StructDeclarator[];
+        declaratorList: StructDeclarator[];
+        init(): void;
+        semanticAnalyze(sa: SemanticAnalyzer): void;
     }
     export class StructDeclarator extends TreeNode {
-        get ident(): Token;
-        get arraySpecifier(): ArraySpecifier | undefined;
+        ident: Token;
+        arraySpecifier: ArraySpecifier | undefined;
+        init(): void;
+        semanticAnalyze(sa: SemanticAnalyzer): void;
     }
     export class VariableDeclaration extends TreeNode {
         type: FullySpecifiedType;
-        semanticAnalyze(sa: SematicAnalyzer): void;
+        semanticAnalyze(sa: SemanticAnalyzer): void;
         codeGen(visitor: CodeGenVisitor): string;
     }
     export class VariableDeclarationList extends TreeNode {
         type: FullySpecifiedType;
-        semanticAnalyze(sa: SematicAnalyzer): void;
+        semanticAnalyze(sa: SemanticAnalyzer): void;
     }
     export class VariableIdentifier extends TreeNode {
         symbolInfo: VarSymbol | BuiltinVariable | null;
-        get lexeme(): string;
-        get typeInfo(): GalaceanDataType;
-        semanticAnalyze(sa: SematicAnalyzer): void;
+        lexeme: string;
+        typeInfo: GalaceanDataType;
+        semanticAnalyze(sa: SemanticAnalyzer): void;
         codeGen(visitor: CodeGenVisitor): string;
     }
     export class GLShaderProgram extends TreeNode {
         shaderData: ShaderData;
-        semanticAnalyze(sa: SematicAnalyzer): void;
+        semanticAnalyze(sa: SemanticAnalyzer): void;
     }
     export {};
 }

package/types/parser/SemanticAnalyzer.d.ts

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