circuitscript 0.0.22 → 0.0.25

package/build/src/visitor.js

@@ -1,1154 +0,0 @@
-import { ParseTreeVisitor } from 'antlr4';
-import { readFileSync } from 'fs';
-import { join } from 'path';
-import { ExecutionContext } from './execute.js';
-import { ClassComponent } from './objects/ClassComponent.js';
-import { NumericValue, ParamDefinition, PercentageValue, PinBlankValue, } from './objects/ParamDefinition.js';
-import { PinDefinition, PinIdType } from './objects/PinDefinition.js';
-import { PinTypes } from './objects/PinTypes.js';
-import { UndeclaredReference } from './objects/types.js';
-import { Logger } from './logger.js';
-import { BlockTypes, ComponentTypes, NoNetText } from './globals.js';
-import { SymbolDrawingCommands } from './draw_symbols.js';
-import { parseFileWithVisitor } from './parser.js';
-export class MainVisitor extends ParseTreeVisitor {
-    indentLevel = 0;
-    startingContext;
-    executionStack;
-    silent = false;
-    logger;
-    printStream = [];
-    printToConsole = true;
-    acceptedDirections = ['left', 'right', 'up', 'down'];
-    pinTypesList = [
-        PinTypes.Any,
-        PinTypes.Input,
-        PinTypes.Output,
-        PinTypes.IO,
-        PinTypes.Power,
-    ];
-    onImportFile = (visitor, filePath) => {
-        throw "Import file not implemented";
-    };
-    constructor(silent = false) {
-        super();
-        this.logger = new Logger();
-        this.startingContext = new ExecutionContext('__', '__.', '/', 0, 0, silent, this.logger);
-        this.setupPrintFunction(this.startingContext);
-        this.executionStack = [this.startingContext];
-        this.startingContext.resolveNet =
-            this.createNetResolver(this.executionStack);
-        this.silent = silent;
-    }
-    getExecutor() {
-        return this.executionStack[this.executionStack.length - 1];
-    }
-    visit(ctx) {
-        if (Array.isArray(ctx)) {
-            return ctx.map(function (child) {
-                try {
-                    return child.accept(this);
-                }
-                catch (err) {
-                    this.handleError(child, err);
-                }
-            }, this);
-        }
-        else {
-            try {
-                return ctx.accept(this);
-            }
-            catch (err) {
-                this.handleError(ctx, err);
-            }
-        }
-    }
-    handleError(ctx, err) {
-        if (!(err instanceof VisitorExecutionException)) {
-            throw new VisitorExecutionException(ctx, err);
-        }
-        else {
-            throw err;
-        }
-    }
-    visitScript(ctx) {
-        this.print('===', 'start', '===');
-        const result = this.visitChildren(ctx);
-        this.print('===', 'end', '===');
-        return result;
-    }
-    visitParameters(ctx) {
-        const dataExpressions = ctx.data_expr_list();
-        const keywordAssignmentExpressions = ctx.keyword_assignment_expr_list();
-        const returnList = [];
-        dataExpressions.forEach((item, index) => {
-            const value = this.visit(item);
-            returnList.push(['position', index, value]);
-        });
-        keywordAssignmentExpressions.forEach((item) => {
-            const [key, value] = this.visit(item);
-            returnList.push(['keyword', key, value]);
-        });
-        return returnList;
-    }
-    visitKeyword_assignment_expr(ctx) {
-        const id = ctx.ID().getText();
-        const value = this.visit(ctx.data_expr());
-        return [id, value];
-    }
-    visitAssignment_expr(ctx) {
-        const atomStr = ctx.atom_expr().getText();
-        if (atomStr.indexOf('(') !== -1 || atomStr.indexOf(')') !== -1) {
-            throw "Invalid assignment expression!";
-        }
-        const reference = this.visit(ctx.atom_expr());
-        const value = this.visit(ctx.data_expr());
-        if (value instanceof 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().print(`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) {
-                this.setInstanceParam(reference.value, trailers, value);
-            }
-        }
-        return value;
-    }
-    setInstanceParam(object, trailers, value) {
-        const paramName = trailers[0].slice(1);
-        object.setParam(paramName, value);
-        this.getExecutor().print(`set instance ${object.instanceName} param ${paramName} to ${value}`);
-    }
-    visitValue_expr(ctx) {
-        const sign = ctx.Minus() ? -1 : 1;
-        if (ctx.INTEGER_VALUE() || ctx.DECIMAL_VALUE() || ctx.NUMERIC_VALUE()) {
-            if (ctx.INTEGER_VALUE()) {
-                return sign * Number(ctx.INTEGER_VALUE().getText());
-            }
-            else if (ctx.DECIMAL_VALUE()) {
-                return sign * Number(ctx.DECIMAL_VALUE().getText());
-            }
-            else if (ctx.NUMERIC_VALUE()) {
-                const textExtra = ctx.Minus() ? '-' : '';
-                return new NumericValue(textExtra + ctx.NUMERIC_VALUE().getText());
-            }
-        }
-        else {
-            if (sign === -1) {
-                throw "Invalid value!";
-            }
-        }
-        if (ctx.BOOLEAN_VALUE()) {
-            const stringValue = ctx.BOOLEAN_VALUE().getText();
-            if (stringValue === 'true') {
-                return true;
-            }
-            else if (stringValue === 'false') {
-                return false;
-            }
-        }
-        else if (ctx.STRING_VALUE()) {
-            return this.prepareStringValue(ctx.STRING_VALUE().getText());
-        }
-        else if (ctx.PERCENTAGE_VALUE()) {
-            return new PercentageValue(ctx.PERCENTAGE_VALUE().getText());
-        }
-        else if (ctx.blank_expr()) {
-            return this.visit(ctx.blank_expr());
-        }
-    }
-    visitBlank_expr(ctx) {
-        return new PinBlankValue(Number(ctx.INTEGER_VALUE().getText()));
-    }
-    visitPin_select_expr(ctx) {
-        if (ctx.INTEGER_VALUE()) {
-            return Number(ctx.INTEGER_VALUE().getText());
-        }
-        else if (ctx.STRING_VALUE()) {
-            return this.prepareStringValue(ctx.STRING_VALUE().getText());
-        }
-        return null;
-    }
-    visitAdd_component_expr(ctx) {
-        const [component, pinValue] = this.visit(ctx.data_expr_with_assignment());
-        if (ctx.ID()) {
-            this.setComponentOrientation(component, pinValue, ctx.ID().getText());
-        }
-        return this.getExecutor().addComponentExisting(component, pinValue);
-    }
-    visitAt_component_expr(ctx) {
-        if (ctx.Point()) {
-            this.getExecutor().atPointBlock();
-        }
-        else {
-            const [component, pin] = this.visit(ctx.component_select_expr());
-            const currentPoint = this.getExecutor().atComponent(component, pin, {
-                addSequence: true,
-                cloneNetComponent: true
-            });
-            if (ctx.ID()) {
-                this.setComponentOrientation(currentPoint[0], currentPoint[1], ctx.ID().getText());
-            }
-        }
-        return this.getExecutor().getCurrentPoint();
-    }
-    visitTo_component_expr(ctx) {
-        let currentPoint;
-        if (ctx.Point()) {
-            this.getExecutor().toPointBlock();
-        }
-        else {
-            ctx.component_select_expr_list().forEach((item) => {
-                const [component, pin] = this.visit(item);
-                currentPoint = this.getExecutor().toComponent(component, pin, {
-                    addSequence: true, cloneNetComponent: true
-                });
-            });
-            if (ctx.ID()) {
-                this.setComponentOrientation(currentPoint[0], currentPoint[1], ctx.ID().getText());
-            }
-        }
-        return this.getExecutor().getCurrentPoint();
-    }
-    visitComponent_select_expr(ctx) {
-        if (ctx.data_expr_with_assignment()) {
-            return this.visit(ctx.data_expr_with_assignment());
-        }
-        else {
-            const component = this.getExecutor().scope.currentComponent;
-            let pinId = null;
-            if (ctx.pin_select_expr()) {
-                pinId = this.visit(ctx.pin_select_expr());
-            }
-            return [component, pinId];
-        }
-    }
-    visitPath_blocks(ctx) {
-        const blocks = ctx.path_block_inner_list();
-        let blockIndex = 0;
-        let blockType = BlockTypes.Branch;
-        let prevBlockType = null;
-        blocks.forEach((block, index) => {
-            if (block.Branch()) {
-                blockType = BlockTypes.Branch;
-            }
-            else if (block.Join()) {
-                blockType = BlockTypes.Join;
-            }
-            else if (block.Parallel()) {
-                blockType = BlockTypes.Parallel;
-            }
-            else if (block.Point()) {
-                blockType = BlockTypes.Point;
-            }
-            if (prevBlockType !== blockType) {
-                if (index > 0) {
-                    this.getExecutor().exitBlocks();
-                }
-                this.getExecutor().enterBlocks(blockType);
-                blockIndex = 0;
-            }
-            this.getExecutor().enterBlock(blockIndex);
-            this.visit(block);
-            this.getExecutor().exitBlock(blockIndex);
-            blockIndex += 1;
-            prevBlockType = blockType;
-        });
-        this.getExecutor().exitBlocks();
-        return this.getExecutor().getCurrentPoint();
-    }
-    visitBreak_keyword() {
-        this.getExecutor().breakBranch();
-        return -1;
-    }
-    visitCreate_component_expr(ctx) {
-        const properties = this.getPropertyExprList(ctx.property_expr_list());
-        const pins = this.parseCreateComponentPins(properties.get('pins'));
-        let instanceName = this.getExecutor().getUniqueInstanceName('');
-        const propParams = properties.get('params');
-        const params = this.parseCreateComponentParams(propParams);
-        if (params.length > 0) {
-            const firstParam = params[0];
-            const paramValue = firstParam.paramValue;
-            let appendValue = paramValue.toString();
-            if (paramValue instanceof NumericValue) {
-                appendValue = paramValue.value;
-            }
-            instanceName += '_' + appendValue;
-        }
-        const arrange = properties.has('arrange') ?
-            properties.get('arrange') : null;
-        const display = properties.has('display') ?
-            properties.get('display') : null;
-        const type = properties.has('type') ?
-            properties.get('type') : null;
-        const width = properties.has('width') ?
-            properties.get('width') : null;
-        const props = {
-            arrange,
-            display,
-            type,
-            width,
-        };
-        return this.getExecutor().createComponent(instanceName, pins, params, props);
-    }
-    visitCreate_graphic_expr(ctx) {
-        const commands = ctx.sub_expr_list().reduce((accum, item) => {
-            const [commandName, parameters] = this.visit(item);
-            const keywordParams = new Map();
-            const positionParams = parameters.reduce((accum, [argType, name, value]) => {
-                if (argType === 'position') {
-                    accum.push(value);
-                }
-                else {
-                    keywordParams.set(name, value);
-                }
-                return accum;
-            }, []);
-            accum.push([commandName, positionParams, keywordParams]);
-            return accum;
-        }, []);
-        return new SymbolDrawingCommands(commands);
-    }
-    visitSub_expr(ctx) {
-        let commandName = null;
-        if (ctx.ID()) {
-            commandName = ctx.ID().getText();
-        }
-        else if (ctx.Pin()) {
-            commandName = ctx.Pin().getText();
-        }
-        else {
-            throw "Invalid command!";
-        }
-        const parameters = this.visit(ctx.parameters());
-        return [commandName, parameters];
-    }
-    visitProperty_expr(ctx) {
-        const keyName = this.visit(ctx.property_key_expr());
-        const value = this.visit(ctx.property_value_expr());
-        const map = new Map();
-        map.set(keyName, value);
-        return map;
-    }
-    visitSingle_line_property(ctx) {
-        let value;
-        if (ctx.data_expr_list().length === 1) {
-            value = this.visit(ctx.data_expr(0));
-        }
-        else {
-            value = ctx.data_expr_list().map(item => {
-                return this.visit(item);
-            });
-        }
-        return value;
-    }
-    visitNested_properties(ctx) {
-        const result = new Map();
-        ctx.property_expr_list().forEach((item) => {
-            const property = this.visit(item);
-            for (const [key, value] of property) {
-                result.set(key, value);
-            }
-        });
-        return result;
-    }
-    visitProperty_key_expr(ctx) {
-        if (ctx.ID()) {
-            return ctx.ID().getText();
-        }
-        else if (ctx.INTEGER_VALUE()) {
-            return Number(ctx.INTEGER_VALUE().getText());
-        }
-        else if (ctx.STRING_VALUE()) {
-            return this.prepareStringValue(ctx.STRING_VALUE().getText());
-        }
-    }
-    visitData_expr_with_assignment(ctx) {
-        let component;
-        if (ctx.data_expr()) {
-            component = this.visit(ctx.data_expr());
-            if (component === null || component === undefined) {
-                throw "Could not find component: " + ctx.data_expr().getText();
-            }
-        }
-        else if (ctx.assignment_expr()) {
-            component = this.visit(ctx.assignment_expr());
-        }
-        let pinValue = null;
-        if (ctx.pin_select_expr()) {
-            pinValue = this.visit(ctx.pin_select_expr());
-        }
-        else {
-            pinValue = component.getDefaultPin();
-        }
-        return [component, pinValue];
-    }
-    visitValueAtomExpr(ctx) {
-        let value;
-        if (ctx.value_expr()) {
-            value = this.visit(ctx.value_expr());
-        }
-        else if (ctx.atom_expr()) {
-            const reference = this.visit(ctx.atom_expr());
-            if (!reference.found) {
-                value = new UndeclaredReference(reference);
-            }
-            else {
-                value = reference.value;
-            }
-        }
-        return value;
-    }
-    visitUnaryOperatorExpr(ctx) {
-        const value = this.visit(ctx.data_expr());
-        const unaryOp = ctx.unary_operator();
-        if (unaryOp) {
-            if (unaryOp.Not()) {
-                if (typeof value === "boolean") {
-                    value = !value;
-                }
-                else {
-                    throw "Failed to do Not operator";
-                }
-            }
-            else if (unaryOp.Minus()) {
-                if (typeof value === 'number') {
-                    return -value;
-                }
-                else {
-                    throw "Failed to do Negation operator";
-                }
-            }
-        }
-        return value;
-    }
-    visitDataExpr(ctx) {
-        let value;
-        if (ctx.create_component_expr()) {
-            value = this.visit(ctx.create_component_expr());
-        }
-        else if (ctx.create_graphic_expr()) {
-            value = this.visit(ctx.create_graphic_expr());
-        }
-        return value;
-    }
-    visitBinaryOperatorExpr(ctx) {
-        const value1 = this.visit(ctx.data_expr(0));
-        const value2 = this.visit(ctx.data_expr(1));
-        const binaryOperatorType = ctx.binary_operator();
-        if (binaryOperatorType.Equals()) {
-            return value1 == value2;
-        }
-        else if (binaryOperatorType.NotEquals()) {
-            return value1 != value2;
-        }
-    }
-    visitMultiplyExpr(ctx) {
-        const value1 = this.visit(ctx.data_expr(0));
-        const value2 = this.visit(ctx.data_expr(1));
-        if (ctx.Multiply()) {
-            return value1 * value2;
-        }
-        else if (ctx.Divide()) {
-            return value1 / value2;
-        }
-    }
-    visitAdditionExpr(ctx) {
-        const value1 = this.visit(ctx.data_expr(0));
-        const value2 = this.visit(ctx.data_expr(1));
-        if (ctx.Addition()) {
-            return value1 + value2;
-        }
-        else if (ctx.Minus()) {
-            return value1 - value2;
-        }
-    }
-    visitFunction_args_expr(ctx) {
-        const defaultValuesProvided = ctx.value_expr_list();
-        const IDs = ctx.ID_list();
-        const boundary = IDs.length - defaultValuesProvided.length;
-        return IDs.map((id, index) => {
-            if (index >= boundary) {
-                const defaultValue = this.visit(defaultValuesProvided[index - boundary]);
-                return [id.getText(), defaultValue];
-            }
-            else {
-                return [id.getText()];
-            }
-        });
-    }
-    createNetResolver(executionStack) {
-        const resolveNet = (netName, netNamespace) => {
-            this.print('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;
-    }
-    visitFunction_def_expr(ctx) {
-        const functionName = ctx.ID().getText();
-        let funcDefinedParameters = [];
-        if (ctx.function_args_expr()) {
-            funcDefinedParameters = this.visit(ctx.function_args_expr());
-        }
-        const executionStack = this.executionStack;
-        const functionCounter = { counter: 0 };
-        const resolveNet = this.createNetResolver(this.executionStack);
-        const __runFunc = (passedInParameters, options) => {
-            const { netNamespace = "" } = options;
-            const currentExecutionContext = executionStack[executionStack.length - 1];
-            const executionLevel = currentExecutionContext.executionLevel;
-            const executionContextName = functionName + '_' + functionCounter['counter'];
-            const executionContextNamespace = currentExecutionContext.namespace
-                + executionContextName + ".";
-            functionCounter['counter'] += 1;
-            const newExecutor = new ExecutionContext(executionContextName, executionContextNamespace, netNamespace, executionLevel + 1, this.getExecutor().scope.indentLevel + 1, currentExecutionContext.silent, currentExecutionContext.logger);
-            this.setupPrintFunction(newExecutor);
-            newExecutor.resolveNet = resolveNet;
-            executionStack.push(newExecutor);
-            this.setupDefinedParameters(functionName, funcDefinedParameters, passedInParameters, newExecutor);
-            const returnValue = this.runExpressions(newExecutor, ctx.function_expr_list());
-            const lastExecution = executionStack.pop();
-            const nextLastExecution = executionStack[executionStack.length - 1];
-            nextLastExecution.mergeScope(lastExecution.scope, executionContextName);
-            return [lastExecution, returnValue];
-        };
-        this.getExecutor().createFunction(functionName, __runFunc);
-    }
-    setupDefinedParameters(functionName, 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.print('set variable in scope, var name: ', variableName);
-                    executor.scope.variables.set(variableName, tmpPassedInArgs[2]);
-                    if (tmpPassedInArgs[2] instanceof 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.print('set variable in scope, var name: ', variableName);
-                executor.scope.variables.set(variableName, defaultValue);
-            }
-            else {
-                throw `Invalid arguments for function '${functionName}', got: `
-                    + passedInParameters;
-            }
-        }
-    }
-    visitFunction_return_expr(ctx) {
-        const executor = this.getExecutor();
-        executor.print('return from function');
-        const returnValue = this.visit(ctx.data_expr());
-        executor.stopFurtherExpressions = true;
-        executor.returnValue = returnValue;
-        return returnValue;
-    }
-    visitAtom_expr(ctx) {
-        const executor = this.getExecutor();
-        const atomId = ctx.ID().getText();
-        let passedNetNamespace = null;
-        if (ctx.net_namespace_expr()) {
-            passedNetNamespace = this.visit(ctx.net_namespace_expr());
-        }
-        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.trailer_expr_list().length > 0) {
-            if (!currentReference.found) {
-                throw "Could not find reference! " + atomId;
-            }
-            currentReference.trailers = [];
-            ctx.trailer_expr_list().forEach(item => {
-                const itemValue = item.getText();
-                if (item.OPEN_PAREN() && item.CLOSE_PAREN()) {
-                    let parameters = [];
-                    if (item.parameters()) {
-                        parameters = this.visit(item.parameters());
-                    }
-                    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) ?
-                            'instance' : 'value',
-                    };
-                }
-                else {
-                    currentReference.trailers.push(itemValue);
-                }
-            });
-        }
-        return currentReference;
-    }
-    visitPin_select_expr2(ctx) {
-        if (ctx.STRING_VALUE()) {
-            return this.prepareStringValue(ctx.STRING_VALUE().getText());
-        }
-        else if (ctx.INTEGER_VALUE()) {
-            return Number(ctx.INTEGER_VALUE().getText());
-        }
-    }
-    visitAt_block_pin_expr(ctx) {
-        const atPin = this.visit(ctx.pin_select_expr2());
-        const executor = this.getExecutor();
-        const currentComponent = executor.scope.currentComponent;
-        const currentPin = executor.scope.currentPin;
-        executor.atComponent(currentComponent, atPin, {
-            addSequence: true
-        });
-        executor.print('at block pin expressions');
-        if (ctx.at_block_pin_expression_simple()) {
-            this.visit(ctx.at_block_pin_expression_simple());
-        }
-        else if (ctx.at_block_pin_expression_complex()) {
-            this.visit(ctx.at_block_pin_expression_complex());
-        }
-        executor.print('end at block pin expressions');
-        return executor.atComponent(currentComponent, currentPin);
-    }
-    visitAt_block(ctx) {
-        const executor = this.getExecutor();
-        executor.print('entering at block');
-        this.visit(ctx.at_component_expr());
-        const currentComponent = executor.scope.currentComponent;
-        const currentPin = executor.scope.currentPin;
-        executor.scope.indentLevel += 1;
-        ctx.at_block_expressions_list().forEach(expression => {
-            this.visit(expression);
-        });
-        executor.scope.indentLevel -= 1;
-        executor.scope.currentComponent = currentComponent;
-        executor.scope.currentPin = currentPin;
-        executor.print('leaving at block');
-        return executor.getCurrentPoint();
-    }
-    visitAt_block_pin_expression_simple(ctx) {
-        if (ctx.expression()) {
-            this.visit(ctx.expression());
-        }
-        else if (ctx.NOT_CONNECTED()) {
-            return;
-        }
-    }
-    visitAt_block_pin_expression_complex(ctx) {
-        ctx.expression_list().forEach(item => {
-            this.visit(item);
-        });
-        return this.getExecutor().getCurrentPoint();
-    }
-    visitWire_expr(ctx) {
-        const segments = [];
-        const parts = ctx.children.slice(1);
-        for (let i = 0; i < parts.length; i++) {
-            const textValue = parts[i].getText();
-            if (this.acceptedDirections.indexOf(textValue) !== -1) {
-                const segment = [textValue];
-                let skipNext = false;
-                let invalidValue = true;
-                if (i + 1 < parts.length) {
-                    const nextValue = parts[i + 1].getText();
-                    const nextValueNumber = Number(nextValue);
-                    if (!isNaN(nextValueNumber)) {
-                        invalidValue = false;
-                        segment.push(nextValueNumber);
-                        skipNext = true;
-                    }
-                }
-                if (invalidValue) {
-                    throw `Invalid value provided for direction ${textValue} in wire`;
-                }
-                segments.push(segment);
-                if (skipNext) {
-                    i += 1;
-                }
-            }
-            else if (textValue === "auto" || textValue === "auto_") {
-                segments.push([textValue]);
-            }
-        }
-        this.getExecutor().addWire(segments);
-    }
-    visitPoint_expr(ctx) {
-        const ID = ctx.ID();
-        return this.getExecutor().addPoint(ID.getText());
-    }
-    visitImport_expr(ctx) {
-        const ID = ctx.ID().toString();
-        this.print('import', ID);
-        const { hasError, hasParseError } = this.onImportFile(this, ID);
-        if (hasError || hasParseError) {
-            this.print('import', ID, 'failed');
-            throw `import ${ID} failed`;
-        }
-        this.print('done import', ID);
-    }
-    visitProperty_set_expr(ctx) {
-        const result = this.visit(ctx.data_expr());
-        const resolvedProperty = this.visit(ctx.atom_expr());
-        this.getExecutor().setProperty(resolvedProperty, result);
-    }
-    visitDouble_dot_property_set_expr(ctx) {
-        const result = this.visit(ctx.data_expr());
-        const propertyName = ctx.ID().getText();
-        this.getExecutor().setProperty('..' + propertyName, result);
-    }
-    visitRoundedBracketsExpr(ctx) {
-        return this.visit(ctx.data_expr());
-    }
-    visitFrame_expr(ctx) {
-        const frameId = this.getExecutor().enterFrame();
-        this.runExpressions(this.getExecutor(), ctx.expression_list());
-        this.getExecutor().exitFrame(frameId);
-    }
-    visitNet_namespace_expr(ctx) {
-        let dataValue = null;
-        let netNamespace = null;
-        const hasPlus = ctx.Addition();
-        if (ctx.data_expr()) {
-            dataValue = this.visit(ctx.data_expr());
-            if (dataValue instanceof UndeclaredReference) {
-                netNamespace = "/" + dataValue.reference.name;
-            }
-            else if (typeof dataValue === "string") {
-                netNamespace = "/" + dataValue;
-            }
-            else {
-                throw "Failed to resolve net namespace value";
-            }
-        }
-        else {
-            netNamespace = "/";
-        }
-        return (hasPlus ? "+" : "") + netNamespace;
-    }
-    pinTypes = [
-        PinTypes.Any,
-        PinTypes.IO,
-        PinTypes.Input,
-        PinTypes.Output,
-        PinTypes.Power,
-    ];
-    createImportFileHandler(directory, defaultLibsPath) {
-        return (visitor, importPath) => {
-            let importResult;
-            importResult = this.importLib(visitor, directory, importPath);
-            if (!importResult.pathExists && importPath == 'lib') {
-                importResult = this.importLib(visitor, defaultLibsPath, importPath);
-            }
-            return importResult;
-        };
-    }
-    importLib(visitor, directory, filename) {
-        const tmpFilePath = join(directory, filename + ".cst");
-        visitor.print('importing path:', tmpFilePath);
-        let pathExists = false;
-        let fileData = null;
-        try {
-            fileData = readFileSync(tmpFilePath, { encoding: 'utf8' });
-            pathExists = true;
-        }
-        catch (err) {
-            pathExists = false;
-        }
-        try {
-            if (pathExists) {
-                visitor.print('done reading imported file data');
-                const { hasError, hasParseError } = parseFileWithVisitor(visitor, fileData);
-                return { hasError, hasParseError, pathExists };
-            }
-        }
-        catch (err) {
-            visitor.print('Failed to import file: ', err.message);
-        }
-        return {
-            hasError: true,
-            hasParseError: true,
-            pathExists,
-        };
-    }
-    parseCreateComponentPins(pinData) {
-        const pins = [];
-        if (typeof pinData === 'number') {
-            const lastPin = pinData;
-            for (let i = 0; i < lastPin; i++) {
-                const pinId = i + 1;
-                pins.push(new PinDefinition(pinId, PinIdType.Int, pinId.toString()));
-            }
-        }
-        else if (pinData instanceof Map) {
-            for (const [pinId, pinDef] of pinData) {
-                let pinIdType = PinIdType.Int;
-                let pinType = PinTypes.Any;
-                let pinName = null;
-                let altPinNames = [];
-                if (typeof pinId === 'string') {
-                    pinIdType = PinIdType.Str;
-                }
-                if (Array.isArray(pinDef)) {
-                    const firstValue = pinDef[0];
-                    if (this.pinTypes.indexOf(firstValue) !== -1) {
-                        pinType = firstValue;
-                        pinName = pinDef[1];
-                        if (pinDef.length > 2) {
-                            altPinNames = pinDef.slice(2);
-                        }
-                    }
-                    else {
-                        pinName = pinDef[0];
-                        if (pinDef.length > 1) {
-                            altPinNames = pinDef.slice(1);
-                        }
-                    }
-                }
-                else {
-                    pinName = pinDef;
-                }
-                pins.push(new PinDefinition(pinId, pinIdType, pinName, pinType, altPinNames));
-            }
-        }
-        return pins;
-    }
-    parseCreateComponentParams(params) {
-        const result = [];
-        if (params) {
-            for (const [key, value] of params) {
-                result.push(new ParamDefinition(key, value));
-            }
-        }
-        return result;
-    }
-    prepareStringValue(value) {
-        return value.slice(1, value.length - 1);
-    }
-    print(...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);
-        }
-    }
-    printNets() {
-        this.getExecutor().scope.printNets();
-    }
-    dumpNets() {
-        return this.getExecutor().scope.dumpNets();
-    }
-    dumpUniqueNets() {
-        const nets = this.getExecutor().scope.getNets();
-        return nets.reduce((accum, [, , net]) => {
-            accum.push(net);
-            return accum;
-        }, []);
-    }
-    dumpVariables() {
-        return this.getExecutor().scope.variables;
-    }
-    dumpInstances() {
-        return this.getExecutor().scope.instances;
-    }
-    dump2() {
-        const instances = this.getExecutor().scope.instances;
-        const items = [];
-        for (const [instanceName, instance] of instances) {
-            if (instance.assignedRefDes === null) {
-                continue;
-            }
-            const pinNets = this.resolveNets(this.getExecutor().scope, instance);
-            const componentItem = {
-                name: instanceName,
-                refdes: instance.assignedRefDes,
-                pins: {},
-            };
-            pinNets.forEach((item) => {
-                componentItem.pins[item.pin.id] = item.netName;
-            });
-            items.push(componentItem);
-        }
-        return items;
-    }
-    getNetList() {
-        const netlist = [];
-        const instances = this.getExecutor().scope.instances;
-        for (const [instanceName, instance] of instances) {
-            const pinNets = this.resolveNets(this.getExecutor().scope, instance);
-            const componentItem = {
-                instanceName,
-                instance,
-                pins: {},
-            };
-            pinNets.forEach((item) => {
-                componentItem.pins[item.pin.id] = {
-                    netName: item.netName,
-                    netBaseName: item.netBaseName
-                };
-            });
-            netlist.push(componentItem);
-        }
-        return netlist;
-    }
-    getGraph() {
-        const executor = this.getExecutor();
-        const sequence = executor.scope.sequence;
-        const nets = executor.scope.getNets();
-        return {
-            sequence,
-            nets,
-            components: Array.from(executor.scope.instances.values())
-        };
-    }
-    annotateComponents() {
-        this.print('===== annotate components =====');
-        const annotater = new ComponentAnnotater();
-        const instances = this.getExecutor().scope.instances;
-        const toAnnotate = [];
-        for (const [, instance] of instances) {
-            if (instance.assignedRefDes === null) {
-                if (instance.typeProp === ComponentTypes.label ||
-                    instance.typeProp === ComponentTypes.net ||
-                    instance.typeProp === ComponentTypes.point) {
-                    continue;
-                }
-                if (instance.typeProp === null) {
-                    this.print('Instance has no type:', instance.instanceName, ' assuming connector');
-                    instance.typeProp = 'conn';
-                }
-                if (instance.parameters.has('refdes')) {
-                    const refdes = instance.parameters.get('refdes');
-                    if (refdes) {
-                        instance.assignedRefDes = refdes;
-                        annotater.trackRefDes(refdes);
-                        this.print(refdes, '-', instance.instanceName);
-                        continue;
-                    }
-                }
-                toAnnotate.push(instance);
-            }
-        }
-        toAnnotate.forEach(instance => {
-            const newRefDes = annotater.getAnnotation(instance.typeProp);
-            if (newRefDes !== null) {
-                instance.assignedRefDes = newRefDes;
-                this.print(newRefDes, '-', instance.instanceName);
-            }
-            else {
-                this.print('Failed to annotate:', instance.instanceName);
-            }
-        });
-        this.print('===== annotate done =====');
-        this.print('');
-    }
-    resolveNets(scope, instance) {
-        const result = [];
-        for (const [pinId, pin] of instance.pins) {
-            let netName = NoNetText;
-            let netBaseName = NoNetText;
-            if (scope.hasNet(instance, pinId)) {
-                const netObject = scope.getNet(instance, pinId);
-                netName = netObject.namespace + netObject.name;
-                netBaseName = netObject.baseName;
-            }
-            result.push({
-                pin: pin,
-                netName: netName,
-                netBaseName,
-            });
-        }
-        return result;
-    }
-    setComponentOrientation(component, pin, orientation) {
-        if (this.acceptedDirections.indexOf(orientation) !== -1) {
-            component.setParam('_addDirection', orientation);
-            component.setParam('_addPin', pin);
-        }
-        else {
-            throw "Invalid modifier for orientation";
-        }
-    }
-    getPropertyExprList(items) {
-        const properties = new Map();
-        items.forEach((item) => {
-            const result = this.visit(item);
-            for (const [key, value] of result) {
-                properties.set(key, value);
-            }
-        });
-        return properties;
-    }
-    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;
-    }
-    checkNetNamespaceIncludes(targetNetName, targetNamespaceParts, net) {
-        if (net.name === targetNetName) {
-            const netNamespaceParts = this.getNamespaceParts(net.namespace);
-            this.print('check namespace', targetNetName, targetNamespaceParts, netNamespaceParts);
-            let matches = 0;
-            for (let i = 0; i < netNamespaceParts.length; i++) {
-                if (netNamespaceParts[i] === targetNamespaceParts[i]) {
-                    matches++;
-                }
-            }
-            if (matches === netNamespaceParts.length) {
-                return true;
-            }
-        }
-        return false;
-    }
-    getNamespaceParts(namespace) {
-        return namespace.split(".").slice(0, -2);
-    }
-    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];
-        });
-    }
-    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;
-    }
-}
-const ComponentRefDesPrefixes = {
-    'res': 'R',
-    'cap': 'C',
-    'ind': 'L',
-    'diode': 'D',
-    'conn': 'J',
-    'transistor': 'Q',
-    'relay': 'K',
-    'ic': 'U',
-    '?': '?',
-};
-class ComponentAnnotater {
-    counter = {};
-    existingRefDes = [];
-    constructor() {
-        for (const key in ComponentRefDesPrefixes) {
-            this.counter[key] = 1;
-        }
-        this.counter['?'] = 1;
-    }
-    getAnnotation(type) {
-        if (this.counter[type] === undefined && type.length <= 2) {
-            for (const [, value] of Object.entries(ComponentRefDesPrefixes)) {
-                if (value === type) {
-                    throw "Refdes prefix is already in use!";
-                }
-            }
-            if (ComponentRefDesPrefixes[type] === undefined) {
-                ComponentRefDesPrefixes[type] = type;
-                this.counter[type] = 1;
-            }
-        }
-        let attempts = 100;
-        let proposedName;
-        while (attempts >= 0) {
-            proposedName = ComponentRefDesPrefixes[type] + this.counter[type];
-            this.counter[type]++;
-            if (this.existingRefDes.indexOf(proposedName) === -1) {
-                break;
-            }
-            attempts--;
-        }
-        if (attempts === 0) {
-            throw "Annotation failed!";
-        }
-        return proposedName;
-    }
-    trackRefDes(name) {
-        this.existingRefDes.push(name);
-    }
-}
-export class VisitorExecutionException {
-    errorMessage;
-    context;
-    constructor(context, errorMessage) {
-        this.errorMessage = errorMessage;
-        this.context = context;
-    }
-    print(scriptData) {
-        const startPoint = this.context.start.start;
-        const endPoint = this.context.stop.stop + 1;
-        console.log('Error at line ' +
-            this.context.start.line + "," + this.context.start.column + ": "
-            + scriptData.slice(startPoint, endPoint) + " - " + this.errorMessage);
-    }
-}