circuitscript 0.0.24 → 0.0.25

package/dist/cjs/SemanticTokenVisitor.js

@@ -0,0 +1,218 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prepareTokens = exports.SemanticTokensVisitor = void 0;
+const CircuitScriptParser_1 = require("./antlr/CircuitScriptParser");
+const BaseVisitor_1 = require("./BaseVisitor");
+class SemanticTokensVisitor extends BaseVisitor_1.BaseVisitor {
+    constructor(silent = false, onErrorHandler = null, currentDirectory, defaultsLibsPath, lexer, script) {
+        super(silent, onErrorHandler, currentDirectory, defaultsLibsPath);
+        this.parsedTokens = [];
+        this.semanticTokens = new Map();
+        this.visitFunction_args_expr = (ctx) => {
+            const IDs = ctx.ID();
+            IDs.map(id => {
+                this.addSemanticToken(id, ['declaration'], 'parameter');
+            });
+        };
+        this.visitFunction_call_expr = (ctx) => {
+            this.addSemanticToken(ctx.ID(), [], 'function');
+        };
+        this.visitFunction_def_expr = (ctx) => {
+            const functionName = ctx.ID().getText();
+            this.addSemanticToken(ctx.ID(), ['declaration'], 'function');
+            const ctxFunctionArgsExpr = ctx.function_args_expr();
+            if (ctxFunctionArgsExpr) {
+                this.visit(ctxFunctionArgsExpr);
+            }
+            const executionContextName = functionName + '_validate';
+            const newExecutor = this.enterNewChildContext(this.executionStack, this.getExecutor(), executionContextName, { netNamespace: "" }, [], []);
+            this.runExpressions(newExecutor, ctx.function_expr());
+            this.executionStack.pop();
+        };
+        this.visitCreate_component_expr = (ctx) => {
+            this.addSemanticToken(ctx.Create(), ['defaultLibrary'], 'function');
+            ctx.property_expr().forEach(property_expr => {
+                this.visit(property_expr);
+            });
+        };
+        this.visitCreate_graphic_expr = (ctx) => {
+            this.addSemanticToken(ctx.Create(), ['defaultLibrary'], 'function');
+            ctx.sub_expr().forEach(sub_expr => {
+                this.visit(sub_expr);
+            });
+        };
+        this.visitProperty_key_expr = (ctx) => {
+            let useValue = null;
+            const ctxId = ctx.ID();
+            const ctxIntegerValue = ctx.INTEGER_VALUE();
+            const ctxStringValue = ctx.STRING_VALUE();
+            if (ctxId) {
+                useValue = ctxId;
+            }
+            else if (ctxIntegerValue) {
+                useValue = ctxIntegerValue;
+            }
+            else if (ctxStringValue) {
+                useValue = ctxStringValue;
+            }
+            if (useValue) {
+                this.addSemanticToken(useValue, [], 'property');
+            }
+        };
+        this.visitSub_expr = (ctx) => {
+            let useValue = null;
+            const ctxId = ctx.ID();
+            const ctxPin = ctx.Pin();
+            if (ctxId) {
+                useValue = ctxId;
+            }
+            else if (ctxPin) {
+                useValue = ctxPin;
+            }
+            if (useValue) {
+                this.addSemanticToken(useValue, [], 'property');
+            }
+        };
+        this.visitValueAtomExpr = (ctx) => {
+            const ctxValueExpr = ctx.value_expr();
+            const ctxAtomExpr = ctx.atom_expr();
+            if (ctxValueExpr) {
+                this.visit(ctxValueExpr);
+            }
+            else if (ctxAtomExpr) {
+                this.visit(ctxAtomExpr);
+            }
+        };
+        this.visitAssignment_expr = (ctx) => {
+            this.visit(ctx.atom_expr());
+            this.visit(ctx.data_expr());
+        };
+        this.visitAtom_expr = (ctx) => {
+            if (ctx.parent instanceof CircuitScriptParser_1.Assignment_exprContext && ctx.ID(0)) {
+                this.addSemanticToken(ctx.ID(0), [], 'variable');
+            }
+        };
+        this.visitImport_expr = (ctx) => {
+            this.addSemanticToken(ctx.ID(), [], 'namespace');
+        };
+        this.lexer = lexer;
+        this.script = script;
+    }
+    addSemanticToken(node, modifiers, tokenType = null) {
+        const parsedToken = this.parseToken(node, modifiers, tokenType);
+        this.semanticTokens.set(parsedToken.line + "_" + parsedToken.column, parsedToken);
+    }
+    parseToken(node, modifiers, tokenType = null) {
+        const token = node.symbol;
+        let stringValue = "";
+        let textPart = "";
+        if (this.lexer.symbolicNames[token.type] !== null && this.lexer.symbolicNames[token.type] !== undefined) {
+            stringValue = this.lexer.symbolicNames[token.type];
+            if (stringValue !== "NEWLINE") {
+                textPart = this.script.substring(token.start, token.stop + 1);
+            }
+            else {
+                textPart = token.text.length - 1;
+            }
+        }
+        else if (this.lexer.literalNames[token.type] !== null && this.lexer.literalNames[token.type] !== undefined) {
+            stringValue = this.lexer.literalNames[token.type];
+            textPart = this.script.substring(token.start, token.stop + 1);
+        }
+        else {
+            stringValue = token._text;
+        }
+        return {
+            line: token.line,
+            column: token.column,
+            length: token.stop - token.start + 1,
+            tokenType: tokenType !== null ? tokenType : stringValue,
+            tokenModifiers: modifiers,
+            textValue: textPart,
+        };
+    }
+    dumpTokens() {
+        for (const [id, value] of this.semanticTokens) {
+            console.log(id, value);
+        }
+    }
+    getTokens() {
+        return this.semanticTokens;
+    }
+}
+exports.SemanticTokensVisitor = SemanticTokensVisitor;
+function prepareTokens(tokens, lexer, script) {
+    const parsedTokens = [];
+    tokens.forEach(item => {
+        if (item.type !== -1) {
+            let stringValue = "";
+            let textPart = "";
+            if (lexer.symbolicNames[item.type] !== null && lexer.symbolicNames[item.type] !== undefined) {
+                stringValue = lexer.symbolicNames[item.type];
+                if (stringValue !== "NEWLINE") {
+                    textPart = script.substring(item.start, item.stop + 1);
+                }
+                else {
+                    textPart = item.text.length - 1;
+                }
+            }
+            else if (lexer.literalNames[item.type] !== null && lexer.literalNames[item.type] !== undefined) {
+                stringValue = lexer.literalNames[item.type];
+                textPart = script.substring(item.start, item.stop + 1);
+            }
+            else {
+                stringValue = item._text;
+            }
+            if (textPart !== 0 && textPart !== '') {
+                parsedTokens.push({
+                    line: item.line,
+                    column: item.column,
+                    length: item.stop - item.start + 1,
+                    tokenType: resolveTokenType(stringValue),
+                    tokenModifiers: resolveTokenModifiers(stringValue),
+                    textValue: textPart,
+                });
+            }
+        }
+    });
+    return parsedTokens;
+}
+exports.prepareTokens = prepareTokens;
+const languageKeywords = [
+    'break', 'branch', 'create', 'component',
+    'graphic', 'wire', 'pin', 'add', 'at', 'to',
+    'point', 'join', 'parallel', 'return', 'def', 'import',
+    'true', 'false', 'nc', 'frame',
+];
+const operatorKeywords = [
+    'at', 'to', 'wire', 'add', 'frame', 'join', 'parallel', 'point'
+];
+function resolveTokenType(tokenType) {
+    if (operatorKeywords.indexOf(tokenType.toLowerCase()) !== -1) {
+        return 'graphKeyword';
+    }
+    else if (languageKeywords.indexOf(tokenType.toLowerCase()) !== -1) {
+        return 'keyword';
+    }
+    else {
+        switch (tokenType) {
+            case 'INTEGER_VALUE':
+            case 'NUMERIC_VALUE':
+            case 'DECIMAL_VALUE':
+            case 'PERCENTAGE_VALUE':
+                return 'number';
+            case 'STRING_VALUE':
+                return 'string';
+            case 'ID':
+                return 'variable';
+            case 'Define':
+                return 'keyword';
+            case 'COMMENT':
+                return 'comment';
+        }
+        return null;
+    }
+}
+function resolveTokenModifiers(tokenType) {
+    return [];
+}

package/dist/cjs/SymbolValidatorVisitor.js

@@ -0,0 +1,233 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SymbolTable = exports.SymbolValidatorResolveVisitor = exports.SymbolValidatorVisitor = void 0;
+const BaseVisitor_js_1 = require("./BaseVisitor.js");
+const types_js_1 = require("./objects/types.js");
+class SymbolValidatorVisitor extends BaseVisitor_js_1.BaseVisitor {
+    constructor() {
+        super(...arguments);
+        this.symbolTable = new SymbolTable();
+        this.visitImport_expr = (ctx) => {
+            const ID = ctx.ID().toString();
+            const { pathExists } = this.handleImportFile(ID, false);
+            if (!pathExists) {
+                this.symbolTable.addUndefined(this.getExecutor(), ID, ctx.ID());
+            }
+        };
+        this.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;
+        };
+        this.visitAtom_expr = (ctx) => {
+            const tmpSymbol = this.handleAtomSymbol(ctx.ID(0));
+            this.setResult(ctx, tmpSymbol);
+        };
+        this.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);
+                        }
+                    }
+                });
+            }
+        };
+        this.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);
+        };
+        this.visitUnaryOperatorExpr = (ctx) => {
+            this.visit(ctx.data_expr());
+        };
+        this.visitMultiplyExpr = (ctx) => {
+            this.visit(ctx.data_expr(0));
+            this.visit(ctx.data_expr(1));
+        };
+        this.visitAdditionExpr = (ctx) => {
+            this.visit(ctx.data_expr(0));
+            this.visit(ctx.data_expr(1));
+        };
+        this.visitBinaryOperatorExpr = (ctx) => {
+            this.visit(ctx.data_expr(0));
+            this.visit(ctx.data_expr(1));
+        };
+        this.visitDataExpr = (ctx) => {
+            return;
+        };
+        this.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();
+        };
+    }
+    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;
+    }
+    getSymbols() {
+        return this.symbolTable;
+    }
+    dumpSymbols() {
+        this.symbolTable.dumpSymbols();
+    }
+}
+exports.SymbolValidatorVisitor = SymbolValidatorVisitor;
+class SymbolValidatorResolveVisitor extends SymbolValidatorVisitor {
+    addSymbolVariable(name, value) {
+    }
+    addSymbolFunction(functionName, funcDefinedParameters) {
+        if (this.symbolTable.exists(this.getExecutor(), functionName)) {
+            this.symbolTable.addFunction(this.getExecutor(), functionName, funcDefinedParameters);
+        }
+    }
+}
+exports.SymbolValidatorResolveVisitor = SymbolValidatorResolveVisitor;
+class SymbolTable {
+    constructor() {
+        this.symbols = new Map();
+        this.executonContextsNamespaces = [];
+    }
+    getSymbols() {
+        return this.symbols;
+    }
+    addFunction(executionContext, id, funcDefinedParameters) {
+        return this.add(executionContext, id, types_js_1.ParseSymbolType.Function, {
+            funcDefinedParameters
+        });
+    }
+    addVariable(executionContext, id, variableValue) {
+        return this.add(executionContext, id, types_js_1.ParseSymbolType.Variable, {
+            variableValue
+        });
+    }
+    addUndefined(executionContext, id, node) {
+        return this.add(executionContext, id, types_js_1.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 === types_js_1.ParseSymbolType.Undefined) {
+                this.symbols.delete(key);
+            }
+        }
+    }
+}
+exports.SymbolTable = SymbolTable;