circuitscript 0.0.24 → 0.0.26

package/dist/cjs/visitor.js

@@ -1,815 +1,639 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.VisitorExecutionException = exports.MainVisitor = void 0;
-const antlr4_1 = require("antlr4");
-const fs_1 = require("fs");
-const path_1 = require("path");
-const execute_js_1 = require("./execute.js");
+exports.VisitorExecutionException = exports.ParserVisitor = void 0;
 const ClassComponent_js_1 = require("./objects/ClassComponent.js");
 const ParamDefinition_js_1 = require("./objects/ParamDefinition.js");
 const PinDefinition_js_1 = require("./objects/PinDefinition.js");
 const PinTypes_js_1 = require("./objects/PinTypes.js");
 const types_js_1 = require("./objects/types.js");
-const logger_js_1 = require("./logger.js");
 const globals_js_1 = require("./globals.js");
 const draw_symbols_js_1 = require("./draw_symbols.js");
-const parser_js_1 = require("./parser.js");
-class MainVisitor extends antlr4_1.ParseTreeVisitor {
-    constructor(silent = false) {
-        super();
-        this.indentLevel = 0;
-        this.silent = false;
-        this.printStream = [];
-        this.printToConsole = true;
-        this.acceptedDirections = ['left', 'right', 'up', 'down'];
-        this.pinTypesList = [
-            PinTypes_js_1.PinTypes.Any,
-            PinTypes_js_1.PinTypes.Input,
-            PinTypes_js_1.PinTypes.Output,
-            PinTypes_js_1.PinTypes.IO,
-            PinTypes_js_1.PinTypes.Power,
-        ];
-        this.onImportFile = (visitor, filePath) => {
-            throw "Import file not implemented";
+const BaseVisitor_js_1 = require("./BaseVisitor.js");
+class ParserVisitor extends BaseVisitor_js_1.BaseVisitor {
+    constructor() {
+        super(...arguments);
+        this.visitKeyword_assignment_expr = (ctx) => {
+            const id = ctx.ID().getText();
+            const ctxDataExpr = ctx.data_expr();
+            this.visit(ctxDataExpr);
+            const value = this.getResult(ctxDataExpr);
+            this.setResult(ctx, [id, value]);
         };
-        this.pinTypes = [
-            PinTypes_js_1.PinTypes.Any,
-            PinTypes_js_1.PinTypes.IO,
-            PinTypes_js_1.PinTypes.Input,
-            PinTypes_js_1.PinTypes.Output,
-            PinTypes_js_1.PinTypes.Power,
-        ];
-        this.logger = new logger_js_1.Logger();
-        this.startingContext = new execute_js_1.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_js_1.ClassComponent) {
-            const instances = this.getExecutor().scope.instances;
-            const tmpComponent = value;
-            const oldName = tmpComponent.instanceName;
-            tmpComponent.instanceName = reference.name;
-            instances.delete(oldName);
-            instances.set(reference.name, tmpComponent);
-            this.getExecutor().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_js_1.ClassComponent) {
-                this.setInstanceParam(reference.value, trailers, value);
+        this.visitPin_select_expr = (ctx) => {
+            let value = null;
+            const ctxIntegerValue = ctx.INTEGER_VALUE();
+            const ctxStringValue = ctx.STRING_VALUE();
+            if (ctxIntegerValue) {
+                value = Number(ctxIntegerValue.getText());
             }
-        }
-        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 ParamDefinition_js_1.NumericValue(textExtra + ctx.NUMERIC_VALUE().getText());
+            else if (ctxStringValue) {
+                value = this.prepareStringValue(ctxStringValue.getText());
             }
-        }
-        else {
-            if (sign === -1) {
-                throw "Invalid value!";
-            }
-        }
-        if (ctx.BOOLEAN_VALUE()) {
-            const stringValue = ctx.BOOLEAN_VALUE().getText();
-            if (stringValue === 'true') {
-                return true;
+            this.setResult(ctx, value);
+        };
+        this.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);
+        };
+        this.visitAt_component_expr = (ctx) => {
+            if (ctx.Point()) {
+                this.getExecutor().atPointBlock();
             }
-            else if (stringValue === 'false') {
-                return false;
+            else {
+                const ctxComponentSelectExpr = ctx.component_select_expr();
+                this.visit(ctxComponentSelectExpr);
+                const [component, pin] = this.getResult(ctxComponentSelectExpr);
+                this.getExecutor().atComponent(component, pin, {
+                    addSequence: true
+                });
             }
-        }
-        else if (ctx.STRING_VALUE()) {
-            return this.prepareStringValue(ctx.STRING_VALUE().getText());
-        }
-        else if (ctx.PERCENTAGE_VALUE()) {
-            return new ParamDefinition_js_1.PercentageValue(ctx.PERCENTAGE_VALUE().getText());
-        }
-        else if (ctx.blank_expr()) {
-            return this.visit(ctx.blank_expr());
-        }
-    }
-    visitBlank_expr(ctx) {
-        return new ParamDefinition_js_1.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();
+        };
+        this.visitTo_component_expr = (ctx) => {
+            if (ctx.Point()) {
+                this.getExecutor().toPointBlock();
             }
-        }
-        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
+            else {
+                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());
-        }
-        else {
-            const component = this.getExecutor().scope.currentComponent;
-            let pinId = null;
-            if (ctx.pin_select_expr()) {
-                pinId = this.visit(ctx.pin_select_expr());
+            return this.getExecutor().getCurrentPoint();
+        };
+        this.visitComponent_select_expr = (ctx) => {
+            const ctxDataExprWithAssigment = ctx.data_expr_with_assignment();
+            if (ctxDataExprWithAssigment) {
+                this.visit(ctxDataExprWithAssigment);
+                this.setResult(ctx, this.getResult(ctxDataExprWithAssigment));
             }
-            return [component, pinId];
-        }
-    }
-    visitPath_blocks(ctx) {
-        const blocks = ctx.path_block_inner_list();
-        let blockIndex = 0;
-        let blockType = globals_js_1.BlockTypes.Branch;
-        let prevBlockType = null;
-        blocks.forEach((block, index) => {
-            if (block.Branch()) {
-                blockType = globals_js_1.BlockTypes.Branch;
-            }
-            else if (block.Join()) {
-                blockType = globals_js_1.BlockTypes.Join;
-            }
-            else if (block.Parallel()) {
-                blockType = globals_js_1.BlockTypes.Parallel;
-            }
-            else if (block.Point()) {
-                blockType = globals_js_1.BlockTypes.Point;
-            }
-            if (prevBlockType !== blockType) {
-                if (index > 0) {
-                    this.getExecutor().exitBlocks();
+            else {
+                const component = this.getExecutor().scope.currentComponent;
+                let pinId = null;
+                const ctxPinSelectExpr = ctx.pin_select_expr();
+                if (ctxPinSelectExpr) {
+                    this.visit(ctxPinSelectExpr);
+                    pinId = this.getResult(ctxPinSelectExpr);
                 }
-                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 ParamDefinition_js_1.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,
+                this.setResult(ctx, [component, pinId]);
+            }
         };
-        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);
+        this.visitPath_blocks = (ctx) => {
+            const blocks = ctx.path_block_inner();
+            let blockIndex = 0;
+            let blockType = globals_js_1.BlockTypes.Branch;
+            let prevBlockType = null;
+            blocks.forEach((block, index) => {
+                if (block.Branch()) {
+                    blockType = globals_js_1.BlockTypes.Branch;
                 }
-                else {
-                    keywordParams.set(name, value);
+                else if (block.Join()) {
+                    blockType = globals_js_1.BlockTypes.Join;
+                }
+                else if (block.Parallel()) {
+                    blockType = globals_js_1.BlockTypes.Parallel;
+                }
+                else if (block.Point()) {
+                    blockType = globals_js_1.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();
+        };
+        this.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');
+            const params = this.parseCreateComponentParams(propParams);
+            if (params.length > 0) {
+                const firstParam = params[0];
+                const paramValue = firstParam.paramValue;
+                let appendValue = paramValue.toString();
+                if (paramValue instanceof ParamDefinition_js_1.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 copy = properties.has('copy') ?
+                properties.get('copy') : false;
+            const width = properties.has('width') ?
+                properties.get('width') : null;
+            const props = {
+                arrange,
+                display,
+                type,
+                width,
+                copy
+            };
+            this.setResult(ctx, this.getExecutor().createComponent(instanceName, pins, params, props));
+        };
+        this.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') {
+                        accum.push(value);
+                    }
+                    else {
+                        keywordParams.set(name, value);
+                    }
+                    return accum;
+                }, []);
+                accum.push([commandName, positionParams, keywordParams]);
                 return accum;
             }, []);
-            accum.push([commandName, positionParams, keywordParams]);
-            return accum;
-        }, []);
-        return new draw_symbols_js_1.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);
+            const drawing = new draw_symbols_js_1.SymbolDrawingCommands(commands);
+            drawing.source = ctx.getText();
+            this.setResult(ctx, drawing);
+        };
+        this.visitGraphic_expr = (ctx) => {
+            let commandName = null;
+            const command = ctx._command;
+            if (command) {
+                commandName = command.text;
             }
-        });
-        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 {
+                throw "Invalid command!";
             }
-        }
-        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 types_js_1.UndeclaredReference(reference);
+            const ctxParameters = ctx.parameters();
+            this.visit(ctxParameters);
+            const parameters = this.getResult(ctxParameters);
+            this.setResult(ctx, [commandName, parameters]);
+        };
+        this.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);
+            this.setResult(ctx, map);
+        };
+        this.visitSingle_line_property = (ctx) => {
+            let value;
+            if (ctx.data_expr().length === 1) {
+                const ctxFirst = ctx.data_expr(0);
+                this.visit(ctxFirst);
+                value = this.getResult(ctxFirst);
             }
             else {
-                value = reference.value;
+                value = ctx.data_expr().map(item => {
+                    this.visit(item);
+                    return this.getResult(item);
+                });
             }
-        }
-        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";
+            this.setResult(ctx, value);
+        };
+        this.visitNested_properties = (ctx) => {
+            const result = new Map();
+            ctx.property_expr().forEach((item) => {
+                this.visit(item);
+                const property = this.getResult(item);
+                for (const [key, value] of property) {
+                    result.set(key, value);
                 }
+            });
+            this.setResult(ctx, result);
+        };
+        this.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 (unaryOp.Minus()) {
-                if (typeof value === 'number') {
-                    return -value;
-                }
-                else {
-                    throw "Failed to do Negation operator";
+            else if (ctxIntegerValue) {
+                result = Number(ctxIntegerValue.getText());
+            }
+            else if (ctxStringValue) {
+                result = this.prepareStringValue(ctxStringValue.getText());
+            }
+            this.setResult(ctx, result);
+        };
+        this.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: " + ctxDataExpr.getText();
                 }
             }
-        }
-        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 if (ctxAssignmentExpr) {
+                this.visit(ctxAssignmentExpr);
+                component = this.getResult(ctxAssignmentExpr);
+            }
+            if (component instanceof ClassComponent_js_1.ClassComponent
+                && component.copyProp) {
+                component = this.getExecutor().copyComponent(component);
+            }
+            if (component && component instanceof ClassComponent_js_1.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);
+                    }
+                });
             }
-            else {
-                return [id.getText()];
+            let pinValue = null;
+            const ctxPinSelectExpr = ctx.pin_select_expr();
+            if (ctxPinSelectExpr) {
+                this.visit(ctxPinSelectExpr);
+                pinValue = this.getResult(ctxPinSelectExpr);
             }
-        });
-    }
-    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,
-                    };
-                }
+            else {
+                pinValue = component.getDefaultPin();
             }
-            return {
-                found: false
-            };
+            this.setResult(ctx, [component, pinValue]);
         };
-        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 execute_js_1.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_js_1.ClassComponent) {
-                        const component = tmpPassedInArgs[2];
-                        for (const [pinNumber, net] of component.pinNets) {
-                            executor.scope.setNet(component, pinNumber, net);
-                        }
+        this.visitUnaryOperatorExpr = (ctx) => {
+            this.visit(ctx.data_expr());
+            let value = this.getResult(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') {
+                        value = -value;
+                    }
+                    else {
+                        throw "Failed to do Negation operator";
                     }
                 }
             }
-            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);
+            this.setResult(ctx, value);
+        };
+        this.visitDataExpr = (ctx) => {
+            let value;
+            const ctxCreateComponentExpr = ctx.create_component_expr();
+            const ctxCreateGraphicExpr = ctx.create_graphic_expr();
+            if (ctxCreateComponentExpr) {
+                this.visit(ctxCreateComponentExpr);
+                value = this.getResult(ctxCreateComponentExpr);
+            }
+            else if (ctxCreateGraphicExpr) {
+                this.visit(ctxCreateGraphicExpr);
+                value = this.getResult(ctxCreateGraphicExpr);
             }
             else {
-                throw `Invalid arguments for function '${functionName}', got: `
-                    + passedInParameters;
+                throw "Invalid data expression";
             }
-        }
-    }
-    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
+            this.setResult(ctx, value);
+        };
+        this.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()) {
+                result = value1 == value2;
+            }
+            else if (binaryOperatorType.NotEquals()) {
+                result = value1 != value2;
+            }
+            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);
+        };
+        this.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);
+        };
+        this.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()) {
+                result = value1 * value2;
+            }
+            else if (ctx.Divide()) {
+                result = value1 / value2;
+            }
+            this.setResult(ctx, result);
+        };
+        this.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()) {
+                result = value1 + value2;
+            }
+            else if (ctx.Minus()) {
+                result = value1 - value2;
+            }
+            this.setResult(ctx, result);
+        };
+        this.visitFunction_def_expr = (ctx) => {
+            const functionName = ctx.ID().getText();
+            let funcDefinedParameters = [];
+            const ctxFunctionArgsExpr = ctx.function_args_expr();
+            if (ctxFunctionArgsExpr) {
+                this.visit(ctxFunctionArgsExpr);
+                funcDefinedParameters = this.getResult(ctxFunctionArgsExpr);
+            }
+            const executionStack = this.executionStack;
+            const functionCounter = { counter: 0 };
+            const resolveNet = this.createNetResolver(this.executionStack);
+            const __runFunc = (passedInParameters, options) => {
+                const executionContextName = functionName + '_' + functionCounter['counter'];
+                const newExecutor = this.enterNewChildContext(executionStack, this.getExecutor(), executionContextName, options, funcDefinedParameters, passedInParameters);
+                functionCounter['counter'] += 1;
+                newExecutor.resolveNet = resolveNet;
+                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];
             };
-        }
-        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);
+            this.getExecutor().createFunction(functionName, __runFunc);
+        };
+        this.visitPin_select_expr2 = (ctx) => {
+            const ctxStringValue = ctx.STRING_VALUE();
+            const ctxIntegerValue = ctx.INTEGER_VALUE();
+            let result = null;
+            if (ctxStringValue) {
+                result = this.prepareStringValue(ctxStringValue.getText());
             }
-        }
-        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_js_1.ClassComponent) ?
-                            'instance' : 'value',
-                    };
+            else if (ctxIntegerValue) {
+                result = Number(ctxIntegerValue.getText());
+            }
+            this.setResult(ctx, result);
+        };
+        this.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.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 (ctxAtBlockComplex) {
+                this.visit(ctxAtBlockComplex);
+            }
+            executor.log('end at block pin expressions');
+            executor.atComponent(currentComponent, currentPin);
+        };
+        this.visitAt_block = (ctx) => {
+            const executor = this.getExecutor();
+            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().forEach(expression => {
+                this.visit(expression);
+            });
+            executor.scope.indentLevel -= 1;
+            executor.scope.currentComponent = currentComponent;
+            executor.scope.currentPin = currentPin;
+            executor.log('leaving at block');
+        };
+        this.visitAt_block_pin_expression_simple = (ctx) => {
+            const ctxExpression = ctx.expression();
+            if (ctxExpression) {
+                this.visit(ctxExpression);
+            }
+            else if (ctx.NOT_CONNECTED()) {
+                return;
+            }
+        };
+        this.visitAt_block_pin_expression_complex = (ctx) => {
+            ctx.expression().forEach(item => {
+                this.visit(item);
+            });
+        };
+        this.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';
+            }
+        };
+        this.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 {
-                    currentReference.trailers.push(itemValue);
+                else if (ctxDataExpr) {
+                    this.visit(ctxDataExpr);
+                    useValue = this.getResult(ctxDataExpr);
+                }
+                if (useValue !== null) {
+                    this.setResult(ctx, [direction, useValue]);
+                    return;
                 }
+            }
+            throw "Invalid direction or value for wire";
+        };
+        this.visitWire_expr = (ctx) => {
+            const wireAtomExpr = ctx.wire_atom_expr();
+            const segments = wireAtomExpr.map(wireSegment => {
+                this.visit(wireSegment);
+                return this.getResult(wireSegment);
             });
-        }
-        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;
-                    }
+            this.getExecutor().addWire(segments);
+        };
+        this.visitPoint_expr = (ctx) => {
+            const ID = ctx.ID();
+            return this.getExecutor().addPoint(ID.getText());
+        };
+        this.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);
+        };
+        this.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);
+        };
+        this.visitFrame_expr = (ctx) => {
+            const frameId = this.getExecutor().enterFrame();
+            this.runExpressions(this.getExecutor(), ctx.expression());
+            this.getExecutor().exitFrame(frameId);
+        };
+        this.visitNet_namespace_expr = (ctx) => {
+            let dataValue = null;
+            let netNamespace = null;
+            const hasPlus = ctx.Addition();
+            const ctxDataExpr = ctx.data_expr();
+            if (ctxDataExpr) {
+                this.visit(ctxDataExpr);
+                dataValue = this.getResult(ctxDataExpr);
+                if (dataValue instanceof types_js_1.UndeclaredReference) {
+                    netNamespace = "/" + dataValue.reference.name;
                 }
-                if (invalidValue) {
-                    throw `Invalid value provided for direction ${textValue} in wire`;
+                else if (typeof dataValue === "string") {
+                    netNamespace = "/" + dataValue;
                 }
-                segments.push(segment);
-                if (skipNext) {
-                    i += 1;
+                else {
+                    throw "Failed to resolve net namespace value";
                 }
             }
-            else if (textValue === "auto" || textValue === "auto_") {
-                segments.push([textValue]);
+            else {
+                netNamespace = "/";
             }
-        }
-        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 types_js_1.UndeclaredReference) {
-                netNamespace = "/" + dataValue.reference.name;
-            }
-            else if (typeof dataValue === "string") {
-                netNamespace = "/" + dataValue;
+            this.setResult(ctx, (hasPlus ? "+" : "") + netNamespace);
+        };
+        this.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 {
-                throw "Failed to resolve net namespace value";
+                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);
+                    }
+                }
             }
-        }
-        else {
-            netNamespace = "/";
-        }
-        return (hasPlus ? "+" : "") + netNamespace;
-    }
-    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 = (0, path_1.join)(directory, filename + ".cst");
-        visitor.print('importing path:', tmpFilePath);
-        let pathExists = false;
-        let fileData = null;
-        try {
-            fileData = (0, fs_1.readFileSync)(tmpFilePath, { encoding: 'utf8' });
-            pathExists = true;
-        }
-        catch (err) {
-            pathExists = false;
-        }
-        try {
-            if (pathExists) {
-                visitor.print('done reading imported file data');
-                const { hasError, hasParseError } = (0, parser_js_1.parseFileWithVisitor)(visitor, fileData);
-                return { hasError, hasParseError, pathExists };
-            }
-        }
-        catch (err) {
-            visitor.print('Failed to import file: ', err.message);
-        }
-        return {
-            hasError: true,
-            hasParseError: true,
-            pathExists,
+        this.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);
         };
+        this.pinTypes = [
+            PinTypes_js_1.PinTypes.Any,
+            PinTypes_js_1.PinTypes.IO,
+            PinTypes_js_1.PinTypes.Input,
+            PinTypes_js_1.PinTypes.Output,
+            PinTypes_js_1.PinTypes.Power,
+        ];
     }
     parseCreateComponentPins(pinData) {
         const pins = [];
@@ -831,8 +655,10 @@ class MainVisitor extends antlr4_1.ParseTreeVisitor {
                 }
                 if (Array.isArray(pinDef)) {
                     const firstValue = pinDef[0];
-                    if (this.pinTypes.indexOf(firstValue) !== -1) {
-                        pinType = firstValue;
+                    if (firstValue.type
+                        && firstValue.type === globals_js_1.ReferenceTypes.pinType
+                        && this.pinTypes.indexOf(firstValue.value) !== -1) {
+                        pinType = firstValue.value;
                         pinName = pinDef[1];
                         if (pinDef.length > 2) {
                             altPinNames = pinDef.slice(2);
@@ -862,18 +688,6 @@ class MainVisitor extends antlr4_1.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 +749,10 @@ class MainVisitor extends antlr4_1.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 +761,7 @@ class MainVisitor extends antlr4_1.ParseTreeVisitor {
         };
     }
     annotateComponents() {
-        this.print('===== annotate components =====');
+        this.log('===== annotate components =====');
         const annotater = new ComponentAnnotater();
         const instances = this.getExecutor().scope.instances;
         const toAnnotate = [];
@@ -956,7 +773,7 @@ class MainVisitor extends antlr4_1.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 +781,7 @@ class MainVisitor extends antlr4_1.ParseTreeVisitor {
                     if (refdes) {
                         instance.assignedRefDes = refdes;
                         annotater.trackRefDes(refdes);
-                        this.print(refdes, '-', instance.instanceName);
+                        this.log(refdes, '-', instance.instanceName);
                         continue;
                     }
                 }
@@ -975,14 +792,14 @@ class MainVisitor extends antlr4_1.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,63 +828,24 @@ class MainVisitor extends antlr4_1.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;
-    }
 }
-exports.MainVisitor = MainVisitor;
+exports.ParserVisitor = ParserVisitor;
 const ComponentRefDesPrefixes = {
     'res': 'R',
     'cap': 'C',