circuitscript 0.0.24 → 0.0.26

package/dist/esm/SymbolValidatorVisitor.mjs

@@ -0,0 +1,222 @@
+import { BaseVisitor } from "./BaseVisitor.mjs";
+import { ParseSymbolType } from "./objects/types.mjs";
+export class SymbolValidatorVisitor extends BaseVisitor {
+    symbolTable = new SymbolTable();
+    addSymbolVariable(name, value, executor = null) {
+        const useExecutor = executor === null ? this.getExecutor() : executor;
+        this.symbolTable.addVariable(useExecutor, name, value);
+        this.log2('add symbol variable: ' + name);
+    }
+    addSymbolFunction(functionName, funcDefinedParameters) {
+        if (!this.symbolTable.exists(this.getExecutor(), functionName)) {
+            this.symbolTable.addFunction(this.getExecutor(), functionName, funcDefinedParameters);
+            this.log2('add symbol function: ' + functionName);
+        }
+    }
+    handleAtomSymbol(atom) {
+        const atomId = atom.getText();
+        const executor = this.getExecutor();
+        let tmpSymbol;
+        if (this.symbolTable.exists(executor, atomId)) {
+            tmpSymbol = this.symbolTable.get(executor, atomId);
+        }
+        else {
+            const foundContext = this.symbolTable.searchParentContext(executor, atomId);
+            if (foundContext === null) {
+                tmpSymbol = this.symbolTable.addUndefined(executor, atomId, atom);
+                this.log2('symbol not found: ' + atomId);
+            }
+            else {
+                tmpSymbol = this.symbolTable.get(foundContext, atomId);
+            }
+        }
+        return tmpSymbol;
+    }
+    setSymbols(symbolTable) {
+        this.symbolTable = symbolTable;
+    }
+    visitImport_expr = (ctx) => {
+        const ID = ctx.ID().toString();
+        const { pathExists } = this.handleImportFile(ID, false);
+        if (!pathExists) {
+            this.symbolTable.addUndefined(this.getExecutor(), ID, ctx.ID());
+        }
+    };
+    visitAssignment_expr = (ctx) => {
+        const atomStr = ctx.atom_expr().getText();
+        const ctxDataExpr = ctx.data_expr();
+        this.visit(ctxDataExpr);
+        const value = this.getResult(ctxDataExpr);
+        this.addSymbolVariable(atomStr, value);
+        return null;
+    };
+    visitAtom_expr = (ctx) => {
+        const tmpSymbol = this.handleAtomSymbol(ctx.ID(0));
+        this.setResult(ctx, tmpSymbol);
+    };
+    visitFunction_call_expr = (ctx) => {
+        this.handleAtomSymbol(ctx.ID());
+        if (ctx.trailer_expr().length > 0) {
+            ctx.trailer_expr().forEach(item => {
+                if (item.OPEN_PAREN() && item.CLOSE_PAREN()) {
+                    const params = item.parameters();
+                    if (params) {
+                        this.visit(params);
+                    }
+                }
+            });
+        }
+    };
+    visitValueAtomExpr = (ctx) => {
+        let value = null;
+        const ctxValueExpr = ctx.value_expr();
+        const cxtAtomExpr = ctx.atom_expr();
+        if (ctxValueExpr) {
+            this.visit(ctxValueExpr);
+            value = this.getResult(ctxValueExpr);
+        }
+        else if (cxtAtomExpr) {
+            this.visit(cxtAtomExpr);
+            value = this.getResult(cxtAtomExpr);
+        }
+        this.setResult(ctx, value);
+    };
+    visitUnaryOperatorExpr = (ctx) => {
+        this.visit(ctx.data_expr());
+    };
+    visitMultiplyExpr = (ctx) => {
+        this.visit(ctx.data_expr(0));
+        this.visit(ctx.data_expr(1));
+    };
+    visitAdditionExpr = (ctx) => {
+        this.visit(ctx.data_expr(0));
+        this.visit(ctx.data_expr(1));
+    };
+    visitBinaryOperatorExpr = (ctx) => {
+        this.visit(ctx.data_expr(0));
+        this.visit(ctx.data_expr(1));
+    };
+    visitDataExpr = (ctx) => {
+        return;
+    };
+    visitFunction_def_expr = (ctx) => {
+        const functionName = ctx.ID().getText();
+        let funcDefinedParameters = [];
+        const ctxFunctionArgsExpr = ctx.function_args_expr();
+        if (ctxFunctionArgsExpr) {
+            this.visit(ctxFunctionArgsExpr);
+            funcDefinedParameters = this.getResult(ctxFunctionArgsExpr);
+        }
+        this.addSymbolFunction(functionName, funcDefinedParameters);
+        const executionContextName = functionName + '_validate';
+        const passedInParamsNull = funcDefinedParameters.map((param, index) => {
+            return ['position', index, null];
+        });
+        const newExecutor = this.enterNewChildContext(this.executionStack, this.getExecutor(), executionContextName, { netNamespace: "" }, funcDefinedParameters, passedInParamsNull);
+        funcDefinedParameters.forEach(param => {
+            this.addSymbolVariable(param[0], null, newExecutor);
+        });
+        this.runExpressions(newExecutor, ctx.function_expr());
+        this.executionStack.pop();
+    };
+    getSymbols() {
+        return this.symbolTable;
+    }
+    dumpSymbols() {
+        this.symbolTable.dumpSymbols();
+    }
+}
+export class SymbolValidatorResolveVisitor extends SymbolValidatorVisitor {
+    addSymbolVariable(name, value) {
+    }
+    addSymbolFunction(functionName, funcDefinedParameters) {
+        if (this.symbolTable.exists(this.getExecutor(), functionName)) {
+            this.symbolTable.addFunction(this.getExecutor(), functionName, funcDefinedParameters);
+        }
+    }
+}
+export class SymbolTable {
+    symbols = new Map();
+    executonContextsNamespaces = [];
+    getSymbols() {
+        return this.symbols;
+    }
+    addFunction(executionContext, id, funcDefinedParameters) {
+        return this.add(executionContext, id, ParseSymbolType.Function, {
+            funcDefinedParameters
+        });
+    }
+    addVariable(executionContext, id, variableValue) {
+        return this.add(executionContext, id, ParseSymbolType.Variable, {
+            variableValue
+        });
+    }
+    addUndefined(executionContext, id, node) {
+        return this.add(executionContext, id, ParseSymbolType.Undefined, {
+            node
+        });
+    }
+    add(executionContext, id, type, extra) {
+        if (this.executonContextsNamespaces.indexOf(executionContext.namespace) === -1) {
+            this.executonContextsNamespaces.push(executionContext.namespace);
+        }
+        const item = {
+            id,
+            type,
+            context: executionContext,
+            extra
+        };
+        this.symbols.set(this.idName(executionContext, id), item);
+        return item;
+    }
+    idName(executionContext, id) {
+        return executionContext.namespace + id;
+    }
+    dumpSymbols() {
+        for (const [key, value] of this.symbols) {
+            console.log(value.type.padEnd(10, " "), key);
+        }
+    }
+    exists(executionContext, id) {
+        const name = this.idName(executionContext, id);
+        return this.symbols.has(name);
+    }
+    existsAny(executionContext, id) {
+        if (this.exists(executionContext, id)) {
+            return true;
+        }
+        else {
+            return this.searchParentContext(executionContext, id) !== null;
+        }
+    }
+    get(executionContext, id) {
+        const name = this.idName(executionContext, id);
+        return this.symbols.get(name);
+    }
+    getParentContexts(executionContext, contextsNamespace) {
+        if (executionContext.parentContext !== null) {
+            contextsNamespace.push(executionContext.parentContext.namespace);
+            this.getParentContexts(executionContext.parentContext, contextsNamespace);
+        }
+        return contextsNamespace;
+    }
+    searchParentContext(executionContext, id) {
+        const contextNames = this.getParentContexts(executionContext, []);
+        for (const [key,] of this.symbols) {
+            if (key.endsWith(`.${id}`)) {
+                const { context } = this.symbols.get(key);
+                if (contextNames.indexOf(context.namespace) !== -1) {
+                    return context;
+                }
+            }
+        }
+        return null;
+    }
+    clearUndefined() {
+        for (const [key, value] of this.symbols) {
+            if (value.type === ParseSymbolType.Undefined) {
+                this.symbols.delete(key);
+            }
+        }
+    }
+}