circuitscript 0.0.22 → 0.0.25

package/dist/esm/visitor.mjs

@@ -0,0 +1,838 @@
+import { isNetOnlyComponent } from './execute.mjs';
+import { ClassComponent } from './objects/ClassComponent.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 { BlockTypes, ComponentTypes, NoNetText } from './globals.mjs';
+import { SymbolDrawingCommands } from './draw_symbols.mjs';
+import { BaseVisitor } from './BaseVisitor.mjs';
+export class ParserVisitor extends BaseVisitor {
+    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]);
+    };
+    visitPin_select_expr = (ctx) => {
+        let value = null;
+        const ctxIntegerValue = ctx.INTEGER_VALUE();
+        const ctxStringValue = ctx.STRING_VALUE();
+        if (ctxIntegerValue) {
+            value = Number(ctxIntegerValue.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.setParam(ctxDataWithAssignmentExpr, { clone: false });
+        this.visit(ctxDataWithAssignmentExpr);
+        const [component, pinValue] = this.getResult(ctxDataWithAssignmentExpr);
+        return this.getExecutor().addComponentExisting(component, pinValue);
+    };
+    visitAt_component_expr = (ctx) => {
+        if (ctx.Point()) {
+            this.getExecutor().atPointBlock();
+        }
+        else {
+            const ctxComponentSelectExpr = ctx.component_select_expr();
+            this.visit(ctxComponentSelectExpr);
+            const [component, pin] = this.getResult(ctxComponentSelectExpr);
+            this.getExecutor().atComponent(component, pin, {
+                addSequence: true
+            });
+        }
+        return this.getExecutor().getCurrentPoint();
+    };
+    visitTo_component_expr = (ctx) => {
+        if (ctx.Point()) {
+            this.getExecutor().toPointBlock();
+        }
+        else {
+            ctx.component_select_expr().forEach(item => {
+                this.visit(item);
+                const [component, pin] = this.getResult(item);
+                this.getExecutor().toComponent(component, pin, {
+                    addSequence: true
+                });
+            });
+        }
+        return this.getExecutor().getCurrentPoint();
+    };
+    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;
+            const ctxPinSelectExpr = ctx.pin_select_expr();
+            if (ctxPinSelectExpr) {
+                this.visit(ctxPinSelectExpr);
+                pinId = this.getResult(ctxPinSelectExpr);
+            }
+            this.setResult(ctx, [component, pinId]);
+        }
+    };
+    visitPath_blocks = (ctx) => {
+        const blocks = ctx.path_block_inner();
+        let blockIndex = 0;
+        let blockType = BlockTypes.Branch;
+        let prevBlockType = null;
+        blocks.forEach((block, index) => {
+            if (block.Branch()) {
+                blockType = BlockTypes.Branch;
+            }
+            else if (block.Join()) {
+                blockType = BlockTypes.Join;
+            }
+            else if (block.Parallel()) {
+                blockType = BlockTypes.Parallel;
+            }
+            else if (block.Point()) {
+                blockType = BlockTypes.Point;
+            }
+            if (prevBlockType !== blockType) {
+                if (index > 0) {
+                    this.getExecutor().exitBlocks();
+                }
+                this.getExecutor().enterBlocks(blockType);
+                blockIndex = 0;
+            }
+            this.getExecutor().enterBlock(blockIndex);
+            this.visit(block);
+            this.getExecutor().exitBlock(blockIndex);
+            blockIndex += 1;
+            prevBlockType = blockType;
+        });
+        this.getExecutor().exitBlocks();
+        return this.getExecutor().getCurrentPoint();
+    };
+    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 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, this.getExecutor().createComponent(instanceName, pins, params, props));
+    };
+    visitCreate_graphic_expr = (ctx) => {
+        const commands = ctx.sub_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;
+        }, []);
+        const drawing = new SymbolDrawingCommands(commands);
+        drawing.source = ctx.getText();
+        this.setResult(ctx, drawing);
+    };
+    visitSub_expr = (ctx) => {
+        let commandName = null;
+        const command = ctx._command;
+        if (command) {
+            commandName = command.text;
+        }
+        else {
+            throw "Invalid command!";
+        }
+        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);
+        this.setResult(ctx, map);
+    };
+    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 = ctx.data_expr().map(item => {
+                this.visit(item);
+                return this.getResult(item);
+            });
+        }
+        this.setResult(ctx, value);
+    };
+    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);
+    };
+    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 (ctxIntegerValue) {
+            result = Number(ctxIntegerValue.getText());
+        }
+        else if (ctxStringValue) {
+            result = this.prepareStringValue(ctxStringValue.getText());
+        }
+        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: " + ctxDataExpr.getText();
+            }
+        }
+        else if (ctxAssignmentExpr) {
+            this.visit(ctxAssignmentExpr);
+            component = this.getResult(ctxAssignmentExpr);
+        }
+        let allowClone = true;
+        if (this.hasParam(ctx)) {
+            const { clone } = this.getParam(ctx);
+            allowClone = clone;
+        }
+        if (allowClone && component instanceof ClassComponent
+            && isNetOnlyComponent(component)) {
+            component = this.getExecutor().cloneComponent(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;
+        const ctxPinSelectExpr = ctx.pin_select_expr();
+        if (ctxPinSelectExpr) {
+            this.visit(ctxPinSelectExpr);
+            pinValue = this.getResult(ctxPinSelectExpr);
+        }
+        else {
+            pinValue = component.getDefaultPin();
+        }
+        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()) {
+                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";
+                }
+            }
+        }
+        this.setResult(ctx, value);
+    };
+    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 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()) {
+            result = value1 == value2;
+        }
+        else if (binaryOperatorType.NotEquals()) {
+            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()) {
+            result = value1 * value2;
+        }
+        else if (ctx.Divide()) {
+            result = value1 / value2;
+        }
+        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()) {
+            result = value1 + value2;
+        }
+        else if (ctx.Minus()) {
+            result = value1 - value2;
+        }
+        this.setResult(ctx, result);
+    };
+    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];
+        };
+        this.getExecutor().createFunction(functionName, __runFunc);
+    };
+    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 (ctxIntegerValue) {
+            result = Number(ctxIntegerValue.getText());
+        }
+        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.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);
+    };
+    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');
+    };
+    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().forEach(item => {
+            this.visit(item);
+        });
+    };
+    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);
+            }
+            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) => {
+        const ID = ctx.ID();
+        return this.getExecutor().addPoint(ID.getText());
+    };
+    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 ctxDataExpr = ctx.data_expr();
+        this.visit(ctxDataExpr);
+        const result = this.getResult(ctxDataExpr);
+        const propertyName = ctx.ID().getText();
+        this.getExecutor().setProperty('..' + propertyName, result);
+    };
+    visitFrame_expr = (ctx) => {
+        const frameId = this.getExecutor().enterFrame();
+        this.runExpressions(this.getExecutor(), ctx.expression());
+        this.getExecutor().exitFrame(frameId);
+    };
+    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 UndeclaredReference) {
+                netNamespace = "/" + dataValue.reference.name;
+            }
+            else if (typeof dataValue === "string") {
+                netNamespace = "/" + dataValue;
+            }
+            else {
+                throw "Failed to resolve net namespace value";
+            }
+        }
+        else {
+            netNamespace = "/";
+        }
+        this.setResult(ctx, (hasPlus ? "+" : "") + netNamespace);
+    };
+    pinTypes = [
+        PinTypes.Any,
+        PinTypes.IO,
+        PinTypes.Input,
+        PinTypes.Output,
+        PinTypes.Power,
+    ];
+    parseCreateComponentPins(pinData) {
+        const pins = [];
+        if (typeof pinData === 'number') {
+            const lastPin = pinData;
+            for (let i = 0; i < lastPin; i++) {
+                const pinId = i + 1;
+                pins.push(new PinDefinition(pinId, PinIdType.Int, pinId.toString()));
+            }
+        }
+        else if (pinData instanceof Map) {
+            for (const [pinId, pinDef] of pinData) {
+                let pinIdType = PinIdType.Int;
+                let pinType = PinTypes.Any;
+                let pinName = null;
+                let altPinNames = [];
+                if (typeof pinId === 'string') {
+                    pinIdType = PinIdType.Str;
+                }
+                if (Array.isArray(pinDef)) {
+                    const firstValue = pinDef[0];
+                    if (this.pinTypes.indexOf(firstValue) !== -1) {
+                        pinType = firstValue;
+                        pinName = pinDef[1];
+                        if (pinDef.length > 2) {
+                            altPinNames = pinDef.slice(2);
+                        }
+                    }
+                    else {
+                        pinName = pinDef[0];
+                        if (pinDef.length > 1) {
+                            altPinNames = pinDef.slice(1);
+                        }
+                    }
+                }
+                else {
+                    pinName = pinDef;
+                }
+                pins.push(new PinDefinition(pinId, pinIdType, pinName, pinType, altPinNames));
+            }
+        }
+        return pins;
+    }
+    parseCreateComponentParams(params) {
+        const result = [];
+        if (params) {
+            for (const [key, value] of params) {
+                result.push(new ParamDefinition(key, value));
+            }
+        }
+        return result;
+    }
+    printNets() {
+        this.getExecutor().scope.printNets();
+    }
+    dumpNets() {
+        return this.getExecutor().scope.dumpNets();
+    }
+    dumpUniqueNets() {
+        const nets = this.getExecutor().scope.getNets();
+        return nets.reduce((accum, [, , net]) => {
+            accum.push(net);
+            return accum;
+        }, []);
+    }
+    dumpVariables() {
+        return this.getExecutor().scope.variables;
+    }
+    dumpInstances() {
+        return this.getExecutor().scope.instances;
+    }
+    dump2() {
+        const instances = this.getExecutor().scope.instances;
+        const items = [];
+        for (const [instanceName, instance] of instances) {
+            if (instance.assignedRefDes === null) {
+                continue;
+            }
+            const pinNets = this.resolveNets(this.getExecutor().scope, instance);
+            const componentItem = {
+                name: instanceName,
+                refdes: instance.assignedRefDes,
+                pins: {},
+            };
+            pinNets.forEach((item) => {
+                componentItem.pins[item.pin.id] = item.netName;
+            });
+            items.push(componentItem);
+        }
+        return items;
+    }
+    getNetList() {
+        const netlist = [];
+        const instances = this.getExecutor().scope.instances;
+        for (const [instanceName, instance] of instances) {
+            const pinNets = this.resolveNets(this.getExecutor().scope, instance);
+            const componentItem = {
+                instanceName,
+                instance,
+                pins: {},
+            };
+            pinNets.forEach((item) => {
+                componentItem.pins[item.pin.id] = {
+                    netName: item.netName,
+                    netBaseName: item.netBaseName
+                };
+            });
+            netlist.push(componentItem);
+        }
+        return netlist;
+    }
+    getGraph() {
+        const executor = this.getExecutor();
+        const 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,
+            nets,
+            components: Array.from(executor.scope.instances.values())
+        };
+    }
+    annotateComponents() {
+        this.log('===== annotate components =====');
+        const annotater = new ComponentAnnotater();
+        const instances = this.getExecutor().scope.instances;
+        const toAnnotate = [];
+        for (const [, instance] of instances) {
+            if (instance.assignedRefDes === null) {
+                if (instance.typeProp === ComponentTypes.label ||
+                    instance.typeProp === ComponentTypes.net ||
+                    instance.typeProp === ComponentTypes.point) {
+                    continue;
+                }
+                if (instance.typeProp === null) {
+                    this.log('Instance has no type:', instance.instanceName, ' assuming connector');
+                    instance.typeProp = 'conn';
+                }
+                if (instance.parameters.has('refdes')) {
+                    const refdes = instance.parameters.get('refdes');
+                    if (refdes) {
+                        instance.assignedRefDes = refdes;
+                        annotater.trackRefDes(refdes);
+                        this.log(refdes, '-', instance.instanceName);
+                        continue;
+                    }
+                }
+                toAnnotate.push(instance);
+            }
+        }
+        toAnnotate.forEach(instance => {
+            const newRefDes = annotater.getAnnotation(instance.typeProp);
+            if (newRefDes !== null) {
+                instance.assignedRefDes = newRefDes;
+                this.log(newRefDes, '-', instance.instanceName);
+            }
+            else {
+                this.log('Failed to annotate:', instance.instanceName);
+            }
+        });
+        this.log('===== annotate done =====');
+        this.log('');
+    }
+    resolveNets(scope, instance) {
+        const result = [];
+        for (const [pinId, pin] of instance.pins) {
+            let netName = NoNetText;
+            let netBaseName = NoNetText;
+            if (scope.hasNet(instance, pinId)) {
+                const netObject = scope.getNet(instance, pinId);
+                netName = netObject.namespace + netObject.name;
+                netBaseName = netObject.baseName;
+            }
+            result.push({
+                pin: pin,
+                netName: netName,
+                netBaseName,
+            });
+        }
+        return result;
+    }
+    setComponentOrientation(component, pin, orientation) {
+        if (this.acceptedDirections.indexOf(orientation) !== -1) {
+            component.setParam('_addDirection', orientation);
+            component.setParam('_addPin', pin);
+        }
+        else {
+            throw "Invalid modifier for orientation";
+        }
+    }
+    setComponentFlip(component, flipValue) {
+        if (this.acceptedFlip.indexOf(flipValue) !== -1) {
+            component.setParam(flipValue, 1);
+        }
+    }
+    getPropertyExprList(items) {
+        const properties = new Map();
+        items.forEach((item) => {
+            this.visit(item);
+            const result = this.getResult(item);
+            for (const [key, value] of result) {
+                properties.set(key, value);
+            }
+        });
+        return properties;
+    }
+}
+const ComponentRefDesPrefixes = {
+    'res': 'R',
+    'cap': 'C',
+    'ind': 'L',
+    'diode': 'D',
+    'conn': 'J',
+    'transistor': 'Q',
+    'relay': 'K',
+    'ic': 'U',
+    '?': '?',
+};
+class ComponentAnnotater {
+    counter = {};
+    existingRefDes = [];
+    constructor() {
+        for (const key in ComponentRefDesPrefixes) {
+            this.counter[key] = 1;
+        }
+        this.counter['?'] = 1;
+    }
+    getAnnotation(type) {
+        if (this.counter[type] === undefined && type.length <= 2) {
+            for (const [, value] of Object.entries(ComponentRefDesPrefixes)) {
+                if (value === type) {
+                    throw "Refdes prefix is already in use!";
+                }
+            }
+            if (ComponentRefDesPrefixes[type] === undefined) {
+                ComponentRefDesPrefixes[type] = type;
+                this.counter[type] = 1;
+            }
+        }
+        let attempts = 100;
+        let proposedName;
+        while (attempts >= 0) {
+            proposedName = ComponentRefDesPrefixes[type] + this.counter[type];
+            this.counter[type]++;
+            if (this.existingRefDes.indexOf(proposedName) === -1) {
+                break;
+            }
+            attempts--;
+        }
+        if (attempts === 0) {
+            throw "Annotation failed!";
+        }
+        return proposedName;
+    }
+    trackRefDes(name) {
+        this.existingRefDes.push(name);
+    }
+}
+export class VisitorExecutionException {
+    errorMessage;
+    context;
+    constructor(context, errorMessage) {
+        this.errorMessage = errorMessage;
+        this.context = context;
+    }
+    print(scriptData) {
+        const startPoint = this.context.start.start;
+        const endPoint = this.context.stop.stop + 1;
+        console.log('Error at line ' +
+            this.context.start.line + "," + this.context.start.column + ": "
+            + scriptData.slice(startPoint, endPoint) + " - " + this.errorMessage);
+    }
+}