circuitscript 0.0.24 → 0.0.26

package/dist/esm/visitor.mjs

@@ -1,239 +1,85 @@
-import { ParseTreeVisitor } from 'antlr4';
-import { readFileSync } from 'fs';
-import { join } from 'path';
-import { ExecutionContext } from './execute.mjs';
 import { ClassComponent } from './objects/ClassComponent.mjs';
-import { NumericValue, ParamDefinition, PercentageValue, PinBlankValue, } from './objects/ParamDefinition.mjs';
+import { NumericValue, ParamDefinition, } from './objects/ParamDefinition.mjs';
 import { PinDefinition, PinIdType } from './objects/PinDefinition.mjs';
 import { PinTypes } from './objects/PinTypes.mjs';
 import { UndeclaredReference } from './objects/types.mjs';
-import { Logger } from './logger.mjs';
-import { BlockTypes, ComponentTypes, NoNetText } from './globals.mjs';
+import { BlockTypes, ComponentTypes, NoNetText, ReferenceTypes } from './globals.mjs';
 import { SymbolDrawingCommands } from './draw_symbols.mjs';
-import { parseFileWithVisitor } from './parser.mjs';
-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) {
+import { BaseVisitor } from './BaseVisitor.mjs';
+export class ParserVisitor extends BaseVisitor {
+    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());
+        const ctxDataExpr = ctx.data_expr();
+        this.visit(ctxDataExpr);
+        const value = this.getResult(ctxDataExpr);
+        this.setResult(ctx, [id, value]);
+    };
+    visitPin_select_expr = (ctx) => {
+        let value = null;
+        const ctxIntegerValue = ctx.INTEGER_VALUE();
+        const ctxStringValue = ctx.STRING_VALUE();
+        if (ctxIntegerValue) {
+            value = Number(ctxIntegerValue.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());
+        else if (ctxStringValue) {
+            value = this.prepareStringValue(ctxStringValue.getText());
         }
+        this.setResult(ctx, value);
+    };
+    visitAdd_component_expr = (ctx) => {
+        const ctxDataWithAssignmentExpr = ctx.data_expr_with_assignment();
+        this.visit(ctxDataWithAssignmentExpr);
+        const [component, pinValue] = this.getResult(ctxDataWithAssignmentExpr);
         return this.getExecutor().addComponentExisting(component, pinValue);
-    }
-    visitAt_component_expr(ctx) {
+    };
+    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
+            const ctxComponentSelectExpr = ctx.component_select_expr();
+            this.visit(ctxComponentSelectExpr);
+            const [component, pin] = this.getResult(ctxComponentSelectExpr);
+            this.getExecutor().atComponent(component, pin, {
+                addSequence: true
             });
-            if (ctx.ID()) {
-                this.setComponentOrientation(currentPoint[0], currentPoint[1], ctx.ID().getText());
-            }
         }
         return this.getExecutor().getCurrentPoint();
-    }
-    visitTo_component_expr(ctx) {
-        let currentPoint;
+    };
+    visitTo_component_expr = (ctx) => {
         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
+            ctx.component_select_expr().forEach(item => {
+                this.visit(item);
+                const [component, pin] = this.getResult(item);
+                this.getExecutor().toComponent(component, pin, {
+                    addSequence: 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());
+    };
+    visitComponent_select_expr = (ctx) => {
+        const ctxDataExprWithAssigment = ctx.data_expr_with_assignment();
+        if (ctxDataExprWithAssigment) {
+            this.visit(ctxDataExprWithAssigment);
+            this.setResult(ctx, this.getResult(ctxDataExprWithAssigment));
         }
         else {
             const component = this.getExecutor().scope.currentComponent;
             let pinId = null;
-            if (ctx.pin_select_expr()) {
-                pinId = this.visit(ctx.pin_select_expr());
+            const ctxPinSelectExpr = ctx.pin_select_expr();
+            if (ctxPinSelectExpr) {
+                this.visit(ctxPinSelectExpr);
+                pinId = this.getResult(ctxPinSelectExpr);
             }
-            return [component, pinId];
+            this.setResult(ctx, [component, pinId]);
         }
-    }
-    visitPath_blocks(ctx) {
-        const blocks = ctx.path_block_inner_list();
+    };
+    visitPath_blocks = (ctx) => {
+        const blocks = ctx.path_block_inner();
         let blockIndex = 0;
         let blockType = BlockTypes.Branch;
         let prevBlockType = null;
@@ -265,13 +111,9 @@ export class MainVisitor extends ParseTreeVisitor {
         });
         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());
+    };
+    visitCreate_component_expr = (ctx) => {
+        const properties = this.getPropertyExprList(ctx.property_expr());
         const pins = this.parseCreateComponentPins(properties.get('pins'));
         let instanceName = this.getExecutor().getUniqueInstanceName('');
         const propParams = properties.get('params');
@@ -291,6 +133,8 @@ export class MainVisitor extends ParseTreeVisitor {
             properties.get('display') : null;
         const type = properties.has('type') ?
             properties.get('type') : null;
+        const copy = properties.has('copy') ?
+            properties.get('copy') : false;
         const width = properties.has('width') ?
             properties.get('width') : null;
         const props = {
@@ -298,12 +142,14 @@ export class MainVisitor extends ParseTreeVisitor {
             display,
             type,
             width,
+            copy
         };
-        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);
+        this.setResult(ctx, this.getExecutor().createComponent(instanceName, pins, params, props));
+    };
+    visitCreate_graphic_expr = (ctx) => {
+        const commands = ctx.graphic_expr().reduce((accum, item) => {
+            this.visit(item);
+            const [commandName, parameters] = this.getResult(item);
             const keywordParams = new Map();
             const positionParams = parameters.reduce((accum, [argType, name, value]) => {
                 if (argType === 'position') {
@@ -317,100 +163,139 @@ export class MainVisitor extends ParseTreeVisitor {
             accum.push([commandName, positionParams, keywordParams]);
             return accum;
         }, []);
-        return new SymbolDrawingCommands(commands);
-    }
-    visitSub_expr(ctx) {
+        const drawing = new SymbolDrawingCommands(commands);
+        drawing.source = ctx.getText();
+        this.setResult(ctx, drawing);
+    };
+    visitGraphic_expr = (ctx) => {
         let commandName = null;
-        if (ctx.ID()) {
-            commandName = ctx.ID().getText();
-        }
-        else if (ctx.Pin()) {
-            commandName = ctx.Pin().getText();
+        const command = ctx._command;
+        if (command) {
+            commandName = command.text;
         }
         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 ctxParameters = ctx.parameters();
+        this.visit(ctxParameters);
+        const parameters = this.getResult(ctxParameters);
+        this.setResult(ctx, [commandName, parameters]);
+    };
+    visitProperty_expr = (ctx) => {
+        const ctxPropertyKeyExpr = ctx.property_key_expr();
+        const ctxPropertyValueExpr = ctx.property_value_expr();
+        this.visit(ctxPropertyKeyExpr);
+        this.visit(ctxPropertyValueExpr);
+        const keyName = this.getResult(ctxPropertyKeyExpr);
+        const value = this.getResult(ctxPropertyValueExpr);
         const map = new Map();
         map.set(keyName, value);
-        return map;
-    }
-    visitSingle_line_property(ctx) {
+        this.setResult(ctx, map);
+    };
+    visitSingle_line_property = (ctx) => {
         let value;
-        if (ctx.data_expr_list().length === 1) {
-            value = this.visit(ctx.data_expr(0));
+        if (ctx.data_expr().length === 1) {
+            const ctxFirst = ctx.data_expr(0);
+            this.visit(ctxFirst);
+            value = this.getResult(ctxFirst);
         }
         else {
-            value = ctx.data_expr_list().map(item => {
-                return this.visit(item);
+            value = ctx.data_expr().map(item => {
+                this.visit(item);
+                return this.getResult(item);
             });
         }
-        return value;
-    }
-    visitNested_properties(ctx) {
+        this.setResult(ctx, value);
+    };
+    visitNested_properties = (ctx) => {
         const result = new Map();
-        ctx.property_expr_list().forEach((item) => {
-            const property = this.visit(item);
+        ctx.property_expr().forEach((item) => {
+            this.visit(item);
+            const property = this.getResult(item);
             for (const [key, value] of property) {
                 result.set(key, value);
             }
         });
-        return result;
-    }
-    visitProperty_key_expr(ctx) {
-        if (ctx.ID()) {
-            return ctx.ID().getText();
+        this.setResult(ctx, result);
+    };
+    visitProperty_key_expr = (ctx) => {
+        const ctxID = ctx.ID();
+        const ctxIntegerValue = ctx.INTEGER_VALUE();
+        const ctxStringValue = ctx.STRING_VALUE();
+        let result = null;
+        if (ctxID) {
+            result = ctxID.getText();
         }
-        else if (ctx.INTEGER_VALUE()) {
-            return Number(ctx.INTEGER_VALUE().getText());
+        else if (ctxIntegerValue) {
+            result = Number(ctxIntegerValue.getText());
         }
-        else if (ctx.STRING_VALUE()) {
-            return this.prepareStringValue(ctx.STRING_VALUE().getText());
+        else if (ctxStringValue) {
+            result = this.prepareStringValue(ctxStringValue.getText());
         }
-    }
-    visitData_expr_with_assignment(ctx) {
-        let component;
-        if (ctx.data_expr()) {
-            component = this.visit(ctx.data_expr());
+        this.setResult(ctx, result);
+    };
+    visitData_expr_with_assignment = (ctx) => {
+        let component = null;
+        const ctxDataExpr = ctx.data_expr();
+        const ctxAssignmentExpr = ctx.assignment_expr();
+        if (ctxDataExpr) {
+            this.visit(ctxDataExpr);
+            component = this.getResult(ctxDataExpr);
             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());
+                throw "Could not find component: " + ctxDataExpr.getText();
+            }
+        }
+        else if (ctxAssignmentExpr) {
+            this.visit(ctxAssignmentExpr);
+            component = this.getResult(ctxAssignmentExpr);
+        }
+        if (component instanceof ClassComponent
+            && component.copyProp) {
+            component = this.getExecutor().copyComponent(component);
+        }
+        if (component && component instanceof ClassComponent) {
+            const modifiers = ctx.component_modifier_expr();
+            modifiers.forEach(modifier => {
+                const modifierText = modifier.ID(0).getText();
+                const ctxValueExpr = modifier.value_expr();
+                const ctxID2 = modifier.ID(1);
+                let result = null;
+                if (ctxValueExpr) {
+                    this.visit(ctxValueExpr);
+                    result = this.getResult(ctxValueExpr);
+                }
+                else if (ctxID2) {
+                    result = ctxID2.getText();
+                }
+                if (modifierText === 'flip') {
+                    const flipValue = result;
+                    if (flipValue.indexOf('x') !== -1) {
+                        component.setParam('flipX', 1);
+                    }
+                    if (flipValue.indexOf('y') !== -1) {
+                        component.setParam('flipY', 1);
+                    }
+                }
+                else if (modifierText === 'angle') {
+                    const angleValue = Number(result);
+                    component.setParam('angle', angleValue);
+                }
+            });
         }
         let pinValue = null;
-        if (ctx.pin_select_expr()) {
-            pinValue = this.visit(ctx.pin_select_expr());
+        const ctxPinSelectExpr = ctx.pin_select_expr();
+        if (ctxPinSelectExpr) {
+            this.visit(ctxPinSelectExpr);
+            pinValue = this.getResult(ctxPinSelectExpr);
         }
         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());
+        this.setResult(ctx, [component, pinValue]);
+    };
+    visitUnaryOperatorExpr = (ctx) => {
+        this.visit(ctx.data_expr());
+        let value = this.getResult(ctx.data_expr());
         const unaryOp = ctx.unary_operator();
         if (unaryOp) {
             if (unaryOp.Not()) {
@@ -423,334 +308,269 @@ export class MainVisitor extends ParseTreeVisitor {
             }
             else if (unaryOp.Minus()) {
                 if (typeof value === 'number') {
-                    return -value;
+                    value = -value;
                 }
                 else {
                     throw "Failed to do Negation operator";
                 }
             }
         }
-        return value;
-    }
-    visitDataExpr(ctx) {
+        this.setResult(ctx, value);
+    };
+    visitDataExpr = (ctx) => {
         let value;
-        if (ctx.create_component_expr()) {
-            value = this.visit(ctx.create_component_expr());
+        const ctxCreateComponentExpr = ctx.create_component_expr();
+        const ctxCreateGraphicExpr = ctx.create_graphic_expr();
+        if (ctxCreateComponentExpr) {
+            this.visit(ctxCreateComponentExpr);
+            value = this.getResult(ctxCreateComponentExpr);
         }
-        else if (ctx.create_graphic_expr()) {
-            value = this.visit(ctx.create_graphic_expr());
+        else if (ctxCreateGraphicExpr) {
+            this.visit(ctxCreateGraphicExpr);
+            value = this.getResult(ctxCreateGraphicExpr);
         }
-        return value;
-    }
-    visitBinaryOperatorExpr(ctx) {
-        const value1 = this.visit(ctx.data_expr(0));
-        const value2 = this.visit(ctx.data_expr(1));
+        else {
+            throw "Invalid data expression";
+        }
+        this.setResult(ctx, value);
+    };
+    visitBinaryOperatorExpr = (ctx) => {
+        const ctx0 = ctx.data_expr(0);
+        const ctx1 = ctx.data_expr(1);
+        this.visit(ctx0);
+        this.visit(ctx1);
+        const value1 = this.getResult(ctx0);
+        const value2 = this.getResult(ctx1);
         const binaryOperatorType = ctx.binary_operator();
+        let result = null;
         if (binaryOperatorType.Equals()) {
-            return value1 == value2;
+            result = value1 == value2;
         }
         else if (binaryOperatorType.NotEquals()) {
-            return value1 != value2;
+            result = value1 != value2;
         }
-    }
-    visitMultiplyExpr(ctx) {
-        const value1 = this.visit(ctx.data_expr(0));
-        const value2 = this.visit(ctx.data_expr(1));
+        else if (binaryOperatorType.GreaterThan()) {
+            result = value1 > value2;
+        }
+        else if (binaryOperatorType.GreatOrEqualThan()) {
+            result = value1 >= value2;
+        }
+        else if (binaryOperatorType.LessThan()) {
+            result = value1 < value2;
+        }
+        else if (binaryOperatorType.LessOrEqualThan()) {
+            result = value1 <= value2;
+        }
+        this.setResult(ctx, result);
+    };
+    visitLogicalOperatorExpr = (ctx) => {
+        const ctx0 = ctx.data_expr(0);
+        const ctx1 = ctx.data_expr(1);
+        this.visit(ctx0);
+        const value1 = this.getResult(ctx0);
+        let value2 = false;
+        let skipNext = false;
+        if (ctx.LogicalOr() && value1) {
+            skipNext = true;
+        }
+        if (!skipNext) {
+            this.visit(ctx1);
+            value2 = this.getResult(ctx1);
+        }
+        let result = null;
+        if (ctx.LogicalAnd()) {
+            result = value1 && value2;
+        }
+        else if (ctx.LogicalOr()) {
+            result = value1 || value2;
+        }
+        this.setResult(ctx, result);
+    };
+    visitMultiplyExpr = (ctx) => {
+        this.visit(ctx.data_expr(0));
+        this.visit(ctx.data_expr(1));
+        const value1 = this.getResult(ctx.data_expr(0));
+        const value2 = this.getResult(ctx.data_expr(1));
+        let result = null;
         if (ctx.Multiply()) {
-            return value1 * value2;
+            result = value1 * value2;
         }
         else if (ctx.Divide()) {
-            return value1 / value2;
+            result = value1 / value2;
         }
-    }
-    visitAdditionExpr(ctx) {
-        const value1 = this.visit(ctx.data_expr(0));
-        const value2 = this.visit(ctx.data_expr(1));
+        this.setResult(ctx, result);
+    };
+    visitAdditionExpr = (ctx) => {
+        this.visit(ctx.data_expr(0));
+        this.visit(ctx.data_expr(1));
+        const value1 = this.getResult(ctx.data_expr(0));
+        const value2 = this.getResult(ctx.data_expr(1));
+        let result = null;
         if (ctx.Addition()) {
-            return value1 + value2;
+            result = value1 + value2;
         }
         else if (ctx.Minus()) {
-            return value1 - value2;
+            result = 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) {
+        this.setResult(ctx, result);
+    };
+    visitFunction_def_expr = (ctx) => {
         const functionName = ctx.ID().getText();
         let funcDefinedParameters = [];
-        if (ctx.function_args_expr()) {
-            funcDefinedParameters = this.visit(ctx.function_args_expr());
+        const ctxFunctionArgsExpr = ctx.function_args_expr();
+        if (ctxFunctionArgsExpr) {
+            this.visit(ctxFunctionArgsExpr);
+            funcDefinedParameters = this.getResult(ctxFunctionArgsExpr);
         }
         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 + ".";
+            const newExecutor = this.enterNewChildContext(executionStack, this.getExecutor(), executionContextName, options, funcDefinedParameters, passedInParameters);
             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 returnValue = this.runExpressions(newExecutor, ctx.function_expr());
             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());
+    };
+    visitPin_select_expr2 = (ctx) => {
+        const ctxStringValue = ctx.STRING_VALUE();
+        const ctxIntegerValue = ctx.INTEGER_VALUE();
+        let result = null;
+        if (ctxStringValue) {
+            result = this.prepareStringValue(ctxStringValue.getText());
         }
-        else if (ctx.INTEGER_VALUE()) {
-            return Number(ctx.INTEGER_VALUE().getText());
+        else if (ctxIntegerValue) {
+            result = Number(ctxIntegerValue.getText());
         }
-    }
-    visitAt_block_pin_expr(ctx) {
-        const atPin = this.visit(ctx.pin_select_expr2());
+        this.setResult(ctx, result);
+    };
+    visitAt_block_pin_expr = (ctx) => {
+        const ctxPinSelectExpr2 = ctx.pin_select_expr2();
+        this.visit(ctxPinSelectExpr2);
+        const atPin = this.getResult(ctxPinSelectExpr2);
         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());
+        executor.log('at block pin expressions');
+        const ctxAtBlockSimple = ctx.at_block_pin_expression_simple();
+        const ctxAtBlockComplex = ctx.at_block_pin_expression_complex();
+        if (ctxAtBlockSimple) {
+            this.visit(ctxAtBlockSimple);
         }
-        else if (ctx.at_block_pin_expression_complex()) {
-            this.visit(ctx.at_block_pin_expression_complex());
+        else if (ctxAtBlockComplex) {
+            this.visit(ctxAtBlockComplex);
         }
-        executor.print('end at block pin expressions');
-        return executor.atComponent(currentComponent, currentPin);
-    }
-    visitAt_block(ctx) {
+        executor.log('end at block pin expressions');
+        executor.atComponent(currentComponent, currentPin);
+    };
+    visitAt_block = (ctx) => {
         const executor = this.getExecutor();
-        executor.print('entering at block');
+        executor.log('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 => {
+        ctx.at_block_expressions().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());
+        executor.log('leaving at block');
+    };
+    visitAt_block_pin_expression_simple = (ctx) => {
+        const ctxExpression = ctx.expression();
+        if (ctxExpression) {
+            this.visit(ctxExpression);
         }
         else if (ctx.NOT_CONNECTED()) {
             return;
         }
-    }
-    visitAt_block_pin_expression_complex(ctx) {
-        ctx.expression_list().forEach(item => {
+    };
+    visitAt_block_pin_expression_complex = (ctx) => {
+        ctx.expression().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;
-                }
+    };
+    visitWire_expr_direction_only = (ctx) => {
+        const value = ctx.ID().getText();
+        if (value === 'auto' || value === 'auto_') {
+            this.setResult(ctx, [value]);
+        }
+        else {
+            throw 'Invalid direction for wire';
+        }
+    };
+    visitWire_expr_direction_value = (ctx) => {
+        const direction = ctx.ID().getText();
+        if (this.acceptedDirections.indexOf(direction) !== -1) {
+            let useValue = null;
+            const ctxIntegerValue = ctx.INTEGER_VALUE();
+            const ctxDataExpr = ctx.data_expr();
+            if (ctxIntegerValue) {
+                useValue = Number(ctxIntegerValue);
+            }
+            else if (ctxDataExpr) {
+                this.visit(ctxDataExpr);
+                useValue = this.getResult(ctxDataExpr);
             }
-            else if (textValue === "auto" || textValue === "auto_") {
-                segments.push([textValue]);
+            if (useValue !== null) {
+                this.setResult(ctx, [direction, useValue]);
+                return;
             }
         }
+        throw "Invalid direction or value for wire";
+    };
+    visitWire_expr = (ctx) => {
+        const wireAtomExpr = ctx.wire_atom_expr();
+        const segments = wireAtomExpr.map(wireSegment => {
+            this.visit(wireSegment);
+            return this.getResult(wireSegment);
+        });
         this.getExecutor().addWire(segments);
-    }
-    visitPoint_expr(ctx) {
+    };
+    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());
+    };
+    visitProperty_set_expr = (ctx) => {
+        const ctxDataExpr = ctx.data_expr();
+        this.visit(ctxDataExpr);
+        const result = this.getResult(ctxDataExpr);
+        const ctxAtomExpr = ctx.atom_expr();
+        this.visit(ctxAtomExpr);
+        const resolvedProperty = this.getResult(ctxAtomExpr);
         this.getExecutor().setProperty(resolvedProperty, result);
-    }
-    visitDouble_dot_property_set_expr(ctx) {
-        const result = this.visit(ctx.data_expr());
+    };
+    visitDouble_dot_property_set_expr = (ctx) => {
+        const ctxDataExpr = ctx.data_expr();
+        this.visit(ctxDataExpr);
+        const result = this.getResult(ctxDataExpr);
         const propertyName = ctx.ID().getText();
         this.getExecutor().setProperty('..' + propertyName, result);
-    }
-    visitRoundedBracketsExpr(ctx) {
-        return this.visit(ctx.data_expr());
-    }
-    visitFrame_expr(ctx) {
+    };
+    visitFrame_expr = (ctx) => {
         const frameId = this.getExecutor().enterFrame();
-        this.runExpressions(this.getExecutor(), ctx.expression_list());
+        this.runExpressions(this.getExecutor(), ctx.expression());
         this.getExecutor().exitFrame(frameId);
-    }
-    visitNet_namespace_expr(ctx) {
+    };
+    visitNet_namespace_expr = (ctx) => {
         let dataValue = null;
         let netNamespace = null;
         const hasPlus = ctx.Addition();
-        if (ctx.data_expr()) {
-            dataValue = this.visit(ctx.data_expr());
+        const ctxDataExpr = ctx.data_expr();
+        if (ctxDataExpr) {
+            this.visit(ctxDataExpr);
+            dataValue = this.getResult(ctxDataExpr);
             if (dataValue instanceof UndeclaredReference) {
                 netNamespace = "/" + dataValue.reference.name;
             }
@@ -764,8 +584,44 @@ export class MainVisitor extends ParseTreeVisitor {
         else {
             netNamespace = "/";
         }
-        return (hasPlus ? "+" : "") + netNamespace;
-    }
+        this.setResult(ctx, (hasPlus ? "+" : "") + netNamespace);
+    };
+    visitIf_expr = (ctx) => {
+        const ctxDataExpr = ctx.data_expr();
+        this.visit(ctxDataExpr);
+        const result = this.getResult(ctxDataExpr);
+        if (result) {
+            this.runExpressions(this.getExecutor(), ctx.expression());
+        }
+        else {
+            const ctxInnerIfExprs = ctx.if_inner_expr();
+            let innerIfWasTrue = false;
+            for (let i = 0; i < ctxInnerIfExprs.length; i++) {
+                const tmpCtx = ctxInnerIfExprs[i];
+                this.visit(tmpCtx);
+                const innerResult = this.getResult(tmpCtx);
+                if (innerResult) {
+                    innerIfWasTrue = true;
+                    break;
+                }
+            }
+            if (!innerIfWasTrue) {
+                const elseCtx = ctx.else_expr();
+                if (elseCtx) {
+                    this.visit(elseCtx);
+                }
+            }
+        }
+    };
+    visitIf_inner_expr = (ctx) => {
+        const ctxDataExpr = ctx.data_expr();
+        this.visit(ctxDataExpr);
+        const result = this.getResult(ctxDataExpr);
+        if (result) {
+            this.runExpressions(this.getExecutor(), ctx.expression());
+        }
+        this.setResult(ctx, result);
+    };
     pinTypes = [
         PinTypes.Any,
         PinTypes.IO,
@@ -773,44 +629,6 @@ export class MainVisitor extends ParseTreeVisitor {
         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') {
@@ -831,8 +649,10 @@ export class MainVisitor extends ParseTreeVisitor {
                 }
                 if (Array.isArray(pinDef)) {
                     const firstValue = pinDef[0];
-                    if (this.pinTypes.indexOf(firstValue) !== -1) {
-                        pinType = firstValue;
+                    if (firstValue.type
+                        && firstValue.type === ReferenceTypes.pinType
+                        && this.pinTypes.indexOf(firstValue.value) !== -1) {
+                        pinType = firstValue.value;
                         pinName = pinDef[1];
                         if (pinDef.length > 2) {
                             altPinNames = pinDef.slice(2);
@@ -862,18 +682,6 @@ export class MainVisitor extends ParseTreeVisitor {
         }
         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();
     }
@@ -935,7 +743,10 @@ export class MainVisitor extends ParseTreeVisitor {
     }
     getGraph() {
         const executor = this.getExecutor();
-        const sequence = executor.scope.sequence;
+        const fullSequence = executor.scope.sequence;
+        const tmpNet = executor.scope.getNet(executor.scope.componentRoot, 1);
+        const sequence = (tmpNet === null)
+            ? fullSequence.slice(1) : fullSequence;
         const nets = executor.scope.getNets();
         return {
             sequence,
@@ -944,7 +755,7 @@ export class MainVisitor extends ParseTreeVisitor {
         };
     }
     annotateComponents() {
-        this.print('===== annotate components =====');
+        this.log('===== annotate components =====');
         const annotater = new ComponentAnnotater();
         const instances = this.getExecutor().scope.instances;
         const toAnnotate = [];
@@ -956,7 +767,7 @@ export class MainVisitor extends ParseTreeVisitor {
                     continue;
                 }
                 if (instance.typeProp === null) {
-                    this.print('Instance has no type:', instance.instanceName, ' assuming connector');
+                    this.log('Instance has no type:', instance.instanceName, ' assuming connector');
                     instance.typeProp = 'conn';
                 }
                 if (instance.parameters.has('refdes')) {
@@ -964,7 +775,7 @@ export class MainVisitor extends ParseTreeVisitor {
                     if (refdes) {
                         instance.assignedRefDes = refdes;
                         annotater.trackRefDes(refdes);
-                        this.print(refdes, '-', instance.instanceName);
+                        this.log(refdes, '-', instance.instanceName);
                         continue;
                     }
                 }
@@ -975,14 +786,14 @@ export class MainVisitor extends ParseTreeVisitor {
             const newRefDes = annotater.getAnnotation(instance.typeProp);
             if (newRefDes !== null) {
                 instance.assignedRefDes = newRefDes;
-                this.print(newRefDes, '-', instance.instanceName);
+                this.log(newRefDes, '-', instance.instanceName);
             }
             else {
-                this.print('Failed to annotate:', instance.instanceName);
+                this.log('Failed to annotate:', instance.instanceName);
             }
         });
-        this.print('===== annotate done =====');
-        this.print('');
+        this.log('===== annotate done =====');
+        this.log('');
     }
     resolveNets(scope, instance) {
         const result = [];
@@ -1011,61 +822,22 @@ export class MainVisitor extends ParseTreeVisitor {
             throw "Invalid modifier for orientation";
         }
     }
+    setComponentFlip(component, flipValue) {
+        if (this.acceptedFlip.indexOf(flipValue) !== -1) {
+            component.setParam(flipValue, 1);
+        }
+    }
     getPropertyExprList(items) {
         const properties = new Map();
         items.forEach((item) => {
-            const result = this.visit(item);
+            this.visit(item);
+            const result = this.getResult(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;
-    }
-    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',