circuitscript 0.0.22 → 0.0.25

package/dist/cjs/BaseVisitor.js

@@ -0,0 +1,487 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseVisitor = void 0;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const CircuitScriptParser_1 = require("./antlr/CircuitScriptParser");
+const CircuitScriptVisitor_1 = require("./antlr/CircuitScriptVisitor");
+const execute_1 = require("./execute");
+const logger_1 = require("./logger");
+const ClassComponent_1 = require("./objects/ClassComponent");
+const ParamDefinition_1 = require("./objects/ParamDefinition");
+const PinTypes_1 = require("./objects/PinTypes");
+const types_1 = require("./objects/types");
+class BaseVisitor extends CircuitScriptVisitor_1.CircuitScriptVisitor {
+    constructor(silent = false, onErrorHandler = null, currentDirectory, defaultLibsPath) {
+        super();
+        this.indentLevel = 0;
+        this.silent = false;
+        this.printStream = [];
+        this.printToConsole = true;
+        this.acceptedDirections = ['left', 'right', 'up', 'down'];
+        this.acceptedFlip = ['flipX', 'flipY'];
+        this.resultData = new Map;
+        this.paramData = new Map;
+        this.pinTypesList = [
+            PinTypes_1.PinTypes.Any,
+            PinTypes_1.PinTypes.Input,
+            PinTypes_1.PinTypes.Output,
+            PinTypes_1.PinTypes.IO,
+            PinTypes_1.PinTypes.Power,
+        ];
+        this.onErrorCallbackHandler = null;
+        this.onImportFile = (visitor, filePath) => {
+            throw "Import file not implemented";
+        };
+        this.visitScript = (ctx) => {
+            this.log('===', 'start', '===');
+            const result = this.visitChildren(ctx);
+            this.log('===', 'end', '===');
+            return result;
+        };
+        this.visitAssignment_expr = (ctx) => {
+            const atomStr = ctx.atom_expr().getText();
+            if (atomStr.indexOf('(') !== -1 || atomStr.indexOf(')') !== -1) {
+                throw "Invalid assignment expression!";
+            }
+            const ctxAtomExpr = ctx.atom_expr();
+            this.visit(ctxAtomExpr);
+            const reference = this.getResult(ctxAtomExpr);
+            const ctxDataExpr = ctx.data_expr();
+            this.visit(ctxDataExpr);
+            const value = this.getResult(ctxDataExpr);
+            if (value instanceof ClassComponent_1.ClassComponent) {
+                const instances = this.getExecutor().scope.instances;
+                const tmpComponent = value;
+                const oldName = tmpComponent.instanceName;
+                tmpComponent.instanceName = reference.name;
+                instances.delete(oldName);
+                instances.set(reference.name, tmpComponent);
+                this.getExecutor().log(`assigned '${reference.name}' to ClassComponent`);
+            }
+            else {
+                const trailers = reference.trailers ?? [];
+                if (trailers.length === 0) {
+                    this.getExecutor().scope.variables.set(reference.name, value);
+                }
+                else if (reference.value instanceof ClassComponent_1.ClassComponent) {
+                    this.setInstanceParam(reference.value, trailers, value);
+                }
+            }
+            this.setResult(ctx, value);
+        };
+        this.visitAtom_expr = (ctx) => {
+            const executor = this.getExecutor();
+            const firstId = ctx.ID(0);
+            const atomId = firstId.getText();
+            let currentReference;
+            if (this.pinTypesList.indexOf(atomId) !== -1) {
+                currentReference = {
+                    found: true,
+                    value: atomId
+                };
+            }
+            else {
+                currentReference = executor.resolveVariable(this.executionStack, atomId);
+            }
+            if (currentReference.found && currentReference.type === 'instance') {
+                const tmpComponent = currentReference.value;
+                for (const [pinId, net] of tmpComponent.pinNets) {
+                    executor.scope.setNet(tmpComponent, pinId, net);
+                }
+                if (ctx.ID().length > 1) {
+                    currentReference.trailers = [];
+                    const idLength = ctx.ID().length;
+                    for (let i = 1; i < idLength; i++) {
+                        const tmpCtx = ctx.ID(i);
+                        currentReference.trailers.push(tmpCtx.getText());
+                    }
+                }
+            }
+            if (ctx.parent instanceof CircuitScriptParser_1.ExpressionContext && !currentReference.found) {
+                throw "Unknown symbol: " + atomId;
+            }
+            this.setResult(ctx, currentReference);
+        };
+        this.visitFunctionCallExpr = (ctx) => {
+            const tmpCtx = ctx.function_call_expr();
+            this.visit(tmpCtx);
+            const result = this.getResult(tmpCtx);
+            this.setResult(ctx, result);
+        };
+        this.visitFunction_call_expr = (ctx) => {
+            const executor = this.getExecutor();
+            const atomId = ctx.ID().getText();
+            let passedNetNamespace = null;
+            const netNameSpaceExpr = ctx.net_namespace_expr();
+            if (netNameSpaceExpr) {
+                this.visit(netNameSpaceExpr);
+                passedNetNamespace = this.getResult(netNameSpaceExpr);
+            }
+            let currentReference = executor.resolveVariable(this.executionStack, atomId);
+            if (ctx.trailer_expr().length > 0) {
+                if (!currentReference.found) {
+                    throw "Unknown function name: " + atomId;
+                }
+                currentReference.trailers = [];
+                ctx.trailer_expr().forEach(item => {
+                    const itemValue = item.getText();
+                    if (item.OPEN_PAREN() && item.CLOSE_PAREN()) {
+                        let parameters = [];
+                        const ctxParameters = item.parameters();
+                        if (ctxParameters) {
+                            this.visit(ctxParameters);
+                            parameters = this.getResult(ctxParameters);
+                        }
+                        const useNetNamespace = this.getNetNamespace(executor.netNamespace, passedNetNamespace);
+                        const [, functionResult] = executor.callFunction(currentReference.name, parameters, this.executionStack, useNetNamespace);
+                        currentReference = {
+                            found: true,
+                            value: functionResult,
+                            type: (functionResult instanceof ClassComponent_1.ClassComponent) ?
+                                'instance' : 'value',
+                        };
+                    }
+                    else {
+                        currentReference.trailers.push(itemValue);
+                    }
+                });
+            }
+            this.setResult(ctx, currentReference.value);
+        };
+        this.visitValue_expr = (ctx) => {
+            const sign = ctx.Minus() ? -1 : 1;
+            const ctxIntegerValue = ctx.INTEGER_VALUE();
+            const ctxDecimalValue = ctx.DECIMAL_VALUE();
+            const ctxNumericValue = ctx.NUMERIC_VALUE();
+            const ctxBooleanValue = ctx.BOOLEAN_VALUE();
+            const ctxStringValue = ctx.STRING_VALUE();
+            const ctxPercentageValue = ctx.PERCENTAGE_VALUE();
+            const ctxBlankExpr = ctx.blank_expr();
+            let result = null;
+            if (ctxIntegerValue || ctxDecimalValue || ctxNumericValue) {
+                if (ctxIntegerValue) {
+                    result = sign * Number(ctxIntegerValue.getText());
+                }
+                else if (ctxDecimalValue) {
+                    result = sign * Number(ctxDecimalValue.getText());
+                }
+                else if (ctxNumericValue) {
+                    const textExtra = ctx.Minus() ? '-' : '';
+                    result = new ParamDefinition_1.NumericValue(textExtra + ctxNumericValue.getText());
+                }
+            }
+            else {
+                if (sign === -1) {
+                    throw "Invalid value!";
+                }
+            }
+            if (ctxBooleanValue) {
+                const stringValue = ctxBooleanValue.getText();
+                if (stringValue === 'true') {
+                    result = true;
+                }
+                else if (stringValue === 'false') {
+                    result = false;
+                }
+            }
+            else if (ctxStringValue) {
+                result = this.prepareStringValue(ctxStringValue.getText());
+            }
+            else if (ctxPercentageValue) {
+                result = new ParamDefinition_1.PercentageValue(ctxPercentageValue.getText());
+            }
+            else if (ctxBlankExpr) {
+                this.visit(ctxBlankExpr);
+                result = this.getResult(ctxBlankExpr);
+            }
+            this.setResult(ctx, result);
+        };
+        this.visitBlank_expr = (ctx) => {
+            this.setResult(ctx, new ParamDefinition_1.PinBlankValue(Number(ctx.INTEGER_VALUE().getText())));
+        };
+        this.visitValueAtomExpr = (ctx) => {
+            let value = null;
+            const ctxValueExpr = ctx.value_expr();
+            const ctxAtomExpr = ctx.atom_expr();
+            if (ctxValueExpr) {
+                this.visit(ctxValueExpr);
+                value = this.getResult(ctxValueExpr);
+            }
+            else if (ctxAtomExpr) {
+                this.visit(ctxAtomExpr);
+                const reference = this.getResult(ctxAtomExpr);
+                if (!reference.found) {
+                    value = new types_1.UndeclaredReference(reference);
+                }
+                else {
+                    value = reference.value;
+                }
+            }
+            this.setResult(ctx, value);
+        };
+        this.visitFunction_args_expr = (ctx) => {
+            const defaultValuesProvided = ctx.value_expr();
+            const IDs = ctx.ID();
+            const boundary = IDs.length - defaultValuesProvided.length;
+            const result = IDs.map((id, index) => {
+                const idText = id.getText();
+                if (index >= boundary) {
+                    const tmpCtx = defaultValuesProvided[index - boundary];
+                    this.visit(tmpCtx);
+                    const defaultValue = this.getResult(tmpCtx);
+                    return [idText, defaultValue];
+                }
+                else {
+                    return [idText];
+                }
+            });
+            this.setResult(ctx, result);
+        };
+        this.visitParameters = (ctx) => {
+            const dataExpressions = ctx.data_expr();
+            const keywordAssignmentExpressions = ctx.keyword_assignment_expr();
+            const returnList = [];
+            dataExpressions.forEach((item, index) => {
+                this.visit(item);
+                const value = this.getResult(item);
+                returnList.push(['position', index, value]);
+            });
+            keywordAssignmentExpressions.forEach((item) => {
+                this.visit(item);
+                const [key, value] = this.getResult(item);
+                returnList.push(['keyword', key, value]);
+            });
+            this.setResult(ctx, returnList);
+        };
+        this.visitImport_expr = (ctx) => {
+            const ID = ctx.ID().toString();
+            this.log('import', ID);
+            this.handleImportFile(ID, true);
+            this.log('done import', ID);
+        };
+        this.visitFunction_return_expr = (ctx) => {
+            const executor = this.getExecutor();
+            executor.log('return from function');
+            const ctxDataExpr = ctx.data_expr();
+            this.visit(ctxDataExpr);
+            const returnValue = this.getResult(ctxDataExpr);
+            executor.stopFurtherExpressions = true;
+            executor.returnValue = returnValue;
+            this.setResult(ctx, returnValue);
+        };
+        this.visitBreak_keyword = (ctx) => {
+            this.getExecutor().breakBranch();
+            this.setResult(ctx, -1);
+        };
+        this.visitRoundedBracketsExpr = (ctx) => {
+            const ctxDataExpr = ctx.data_expr();
+            this.visit(ctxDataExpr);
+            const innerResult = this.getResult(ctxDataExpr);
+            this.setResult(ctx, innerResult);
+        };
+        this.logger = new logger_1.Logger();
+        this.onErrorCallbackHandler = onErrorHandler;
+        this.startingContext = new execute_1.ExecutionContext('__', '__.', '/', 0, 0, silent, this.logger, null);
+        this.setupPrintFunction(this.startingContext);
+        this.executionStack = [this.startingContext];
+        this.startingContext.resolveNet =
+            this.createNetResolver(this.executionStack);
+        this.silent = silent;
+        this.currentDirectory = currentDirectory;
+        this.defaultLibsPath = defaultLibsPath;
+    }
+    getExecutor() {
+        return this.executionStack[this.executionStack.length - 1];
+    }
+    setupPrintFunction(context) {
+        context.createFunction('print', (params) => {
+            const items = params.map(([, , value]) => {
+                return value;
+            });
+            if (this.printToConsole) {
+                console.log('::', ...items);
+            }
+            this.printStream.push(...items);
+            return [this, null];
+        });
+    }
+    createNetResolver(executionStack) {
+        const resolveNet = (netName, netNamespace) => {
+            this.log('find net', netNamespace, netName);
+            const reversed = [...executionStack].reverse();
+            for (let i = 0; i < reversed.length; i++) {
+                const context = reversed[i];
+                const net = context.scope.getNetWithName(netName);
+                if (net !== null && net.namespace === netNamespace) {
+                    return {
+                        found: true,
+                        net,
+                    };
+                }
+            }
+            return {
+                found: false
+            };
+        };
+        return resolveNet;
+    }
+    log(...params) {
+        const indentOutput = ''.padStart(this.indentLevel * 4, '    ');
+        const indentLevelText = this.indentLevel.toString().padStart(3, ' ');
+        const args = ['[' + indentLevelText + ']', indentOutput, ...params];
+        this.logger.add(args.join(' '));
+        if (!this.silent) {
+            console.log.apply(null, args);
+        }
+    }
+    log2(message) {
+        this.getExecutor().log(message);
+    }
+    setResult(ctx, value) {
+        this.resultData.set(ctx, value);
+    }
+    getResult(ctx) {
+        return this.resultData.get(ctx);
+    }
+    setParam(ctx, value) {
+        this.paramData.set(ctx, value);
+    }
+    getParam(ctx) {
+        return this.paramData.get(ctx);
+    }
+    hasParam(ctx) {
+        return this.paramData.has(ctx);
+    }
+    handleImportFile(name, throwErrors = true) {
+        let hasError = false;
+        let hasParseError = false;
+        let pathExists = false;
+        const tmpFilePath = (0, path_1.join)(this.currentDirectory, name + ".cst");
+        this.log('importing path:', tmpFilePath);
+        let fileData = null;
+        try {
+            fileData = (0, fs_1.readFileSync)(tmpFilePath, { encoding: 'utf8' });
+            pathExists = true;
+        }
+        catch (err) {
+            pathExists = false;
+        }
+        if (!pathExists) {
+            try {
+                const tmpFilePath2 = (0, path_1.join)(this.defaultLibsPath, name + ".cst");
+                fileData = (0, fs_1.readFileSync)(tmpFilePath2, { encoding: 'utf8' });
+                pathExists = true;
+            }
+            catch (err) {
+                pathExists = false;
+            }
+        }
+        try {
+            if (pathExists) {
+                this.log('done reading imported file data');
+                const importResult = this.onImportFile(this, fileData, this.onErrorCallbackHandler);
+                hasError = importResult.hasError;
+                hasParseError = importResult.hasParseError;
+            }
+        }
+        catch (err) {
+            this.log('Failed to import file: ', err.message);
+        }
+        if (throwErrors && (hasError || hasParseError || !pathExists)) {
+            if (!pathExists) {
+                throw `File does not exist: ${name}`;
+            }
+            else {
+                throw `Failed to import: ${name}`;
+            }
+        }
+        return {
+            hasError,
+            hasParseError,
+            pathExists,
+        };
+    }
+    setupDefinedParameters(funcDefinedParameters, passedInParameters, executor) {
+        for (let i = 0; i < funcDefinedParameters.length; i++) {
+            const tmpFuncArg = funcDefinedParameters[i];
+            if (i < passedInParameters.length) {
+                const tmpPassedInArgs = passedInParameters[i];
+                if (tmpPassedInArgs[0] === 'position') {
+                    const variableName = tmpFuncArg[0];
+                    executor.log('set variable in scope, var name: ', variableName);
+                    executor.scope.variables.set(variableName, tmpPassedInArgs[2]);
+                    if (tmpPassedInArgs[2] instanceof ClassComponent_1.ClassComponent) {
+                        const component = tmpPassedInArgs[2];
+                        for (const [pinNumber, net] of component.pinNets) {
+                            executor.scope.setNet(component, pinNumber, net);
+                        }
+                    }
+                }
+            }
+            else if (tmpFuncArg.length === 2) {
+                const variableName = tmpFuncArg[0];
+                const defaultValue = tmpFuncArg[1];
+                executor.log('set variable in scope, var name: ', variableName);
+                executor.scope.variables.set(variableName, defaultValue);
+            }
+            else {
+                throw `Invalid arguments got: ` + passedInParameters;
+            }
+        }
+    }
+    runExpressions(executor, expressions) {
+        let returnValue = null;
+        for (let i = 0; i < expressions.length; i++) {
+            const expr = expressions[i];
+            this.visit(expr);
+            if (executor.stopFurtherExpressions) {
+                returnValue = executor.returnValue;
+                break;
+            }
+        }
+        return returnValue;
+    }
+    getNetNamespace(executorNetNamespace, passedNetNamespace) {
+        let result = executorNetNamespace;
+        if (passedNetNamespace !== null && passedNetNamespace.length > 0) {
+            if (passedNetNamespace === '/' || passedNetNamespace === '_') {
+                result = '';
+            }
+            else if (passedNetNamespace[0] === '+') {
+                if (executorNetNamespace === '/') {
+                    result = passedNetNamespace.slice(1);
+                }
+                else {
+                    result = executorNetNamespace + passedNetNamespace.slice(2);
+                }
+            }
+            else {
+                result = passedNetNamespace;
+            }
+            result = result + '/';
+        }
+        return result;
+    }
+    setInstanceParam(object, trailers, value) {
+        const paramName = trailers[0];
+        object.setParam(paramName, value);
+        this.getExecutor().log(`set instance ${object.instanceName} param ${paramName} to ${value}`);
+    }
+    enterNewChildContext(executionStack, parentContext, executionContextName, options, funcDefinedParameters, passedInParameters) {
+        const { netNamespace = "" } = options;
+        const currentExecutionContext = executionStack[executionStack.length - 1];
+        const executionLevel = currentExecutionContext.executionLevel;
+        const executionContextNamespace = currentExecutionContext.namespace
+            + executionContextName + ".";
+        const newExecutor = new execute_1.ExecutionContext(executionContextName, executionContextNamespace, netNamespace, executionLevel + 1, this.getExecutor().scope.indentLevel + 1, currentExecutionContext.silent, currentExecutionContext.logger, parentContext);
+        this.setupPrintFunction(newExecutor);
+        executionStack.push(newExecutor);
+        this.setupDefinedParameters(funcDefinedParameters, passedInParameters, newExecutor);
+        return newExecutor;
+    }
+    prepareStringValue(value) {
+        return value.slice(1, value.length - 1);
+    }
+}
+exports.BaseVisitor = BaseVisitor;