circuitscript 0.0.21 → 0.0.24

package/dist/cjs/execute.js

@@ -0,0 +1,780 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPortSide = exports.isLabelComponent = exports.isNetComponent = exports.ExecutionContext = void 0;
+const globals_js_1 = require("./globals.js");
+const ClassComponent_js_1 = require("./objects/ClassComponent.js");
+const ExecutionScope_js_1 = require("./objects/ExecutionScope.js");
+const Net_js_1 = require("./objects/Net.js");
+const PinDefinition_js_1 = require("./objects/PinDefinition.js");
+const Wire_js_1 = require("./objects/Wire.js");
+const Frame_js_1 = require("./objects/Frame.js");
+class ExecutionContext {
+    constructor(name, namespace, netNamespace, executionLevel = 0, indentLevel = 0, silent = false, logger) {
+        this.tmpPointId = 0;
+        this.resolveNet = null;
+        this.stopFurtherExpressions = false;
+        this.returnValue = null;
+        this.silent = false;
+        this.__functionCache = {};
+        this.name = name;
+        this.namespace = namespace;
+        this.netNamespace = netNamespace;
+        this.executionLevel = executionLevel;
+        this.logger = logger;
+        this.scope = ExecutionScope_js_1.ExecutionScope.create();
+        this.scope.indentLevel = indentLevel;
+        this.setupRoot();
+        this.silent = silent;
+        this.print('create new execution context', this.namespace, this.name, this.scope.indentLevel);
+    }
+    print(...params) {
+        const indentOutput = ''.padStart(this.scope.indentLevel * 4, '    ');
+        const indentLevelText = this.scope.indentLevel
+            .toString()
+            .padStart(3, ' ');
+        const args = ['[' + indentLevelText + ']', indentOutput, ...params];
+        this.logger.add(args.join(' '));
+        if (this.silent) {
+            return;
+        }
+        console.log.apply(null, args);
+    }
+    setupRoot() {
+        const componentRoot = ClassComponent_js_1.ClassComponent.simple(globals_js_1.GlobalNames.__root, 1, '__root');
+        componentRoot.typeProp = globals_js_1.ComponentTypes.net;
+        this.scope.instances.set(globals_js_1.GlobalNames.__root, componentRoot);
+        this.scope.currentComponent = componentRoot;
+        this.scope.currentPin = componentRoot.getDefaultPin();
+        this.scope.componentRoot = componentRoot;
+    }
+    instanceExists(instanceName) {
+        return this.scope.instances.has(instanceName);
+    }
+    getComponent(instanceName) {
+        return this.scope.instances.get(instanceName);
+    }
+    getUniqueInstanceName(className) {
+        let extraPrefix = '';
+        switch (className) {
+            case globals_js_1.GlobalNames.DefaultResistor:
+                extraPrefix = 'R_';
+                break;
+            case globals_js_1.GlobalNames.DefaultCapacitor:
+                extraPrefix = 'C_';
+                break;
+            case globals_js_1.GlobalNames.DefaultInductor:
+                extraPrefix = 'L_';
+                break;
+        }
+        const tmpName = extraPrefix + 'COMP_' + this.scope.unnamedCounter;
+        this.scope.unnamedCounter += 1;
+        return tmpName;
+    }
+    getUniqueNetName() {
+        const tmpName = 'NET_' + this.scope.netCounter;
+        this.scope.netCounter++;
+        return tmpName;
+    }
+    getCurrentPoint() {
+        return [this.scope.currentComponent, this.scope.currentPin];
+    }
+    linkComponentPinNet(component1, component1Pin, component2, component2Pin) {
+        const net1_exists = this.scope.hasNet(component1, component1Pin);
+        const net2_exists = this.scope.hasNet(component2, component2Pin);
+        const net1 = net1_exists
+            ? this.scope.getNet(component1, component1Pin)
+            : null;
+        const net2 = net2_exists
+            ? this.scope.getNet(component2, component2Pin)
+            : null;
+        this.print('link nets', component1, component1Pin, net1, 'to', component2, component2Pin, net2);
+        let returnNet;
+        if (net1 === null && net2 === null) {
+            const tmpNet = new Net_js_1.Net(this.netNamespace, this.getUniqueNetName());
+            this.scope.setNet(component1, component1Pin, tmpNet);
+            this.scope.setNet(component2, component2Pin, tmpNet);
+            returnNet = tmpNet;
+        }
+        else if (net1 === null && net2 !== null) {
+            this.scope.setNet(component1, component1Pin, net2);
+            returnNet = net2;
+        }
+        else if (net1 !== null && net2 === null) {
+            this.scope.setNet(component2, component2Pin, net1);
+            returnNet = net1;
+        }
+        else {
+            if (net1 !== net2) {
+                returnNet = this.mergeNets(net1, net2);
+            }
+            else {
+                return net1;
+            }
+        }
+        return returnNet;
+    }
+    mergeNets(net1, net2) {
+        if (net1 === net2) {
+            return net1;
+        }
+        let tmpNet;
+        if (net2.priority > net1.priority) {
+            tmpNet = net1;
+            net1 = net2;
+            net2 = tmpNet;
+        }
+        const scopeNets = this.scope.getNets();
+        scopeNets.forEach(([component, pin, net]) => {
+            if (Net_js_1.Net.isSame(net, net2)) {
+                this.scope.setNet(component, pin, net1);
+            }
+        });
+        return net1;
+    }
+    createComponent(instanceName, pins, params, props) {
+        const numPins = pins.length;
+        const component = new ClassComponent_js_1.ClassComponent(instanceName, numPins, globals_js_1.GlobalNames.symbol);
+        pins.forEach((pin) => {
+            component.pins.set(pin.id, pin);
+        });
+        const paramsMap = new Map();
+        params.forEach((param) => {
+            component.parameters.set(param.paramName, param.paramValue);
+            paramsMap.set(param.paramName, param.paramValue);
+        });
+        if (paramsMap.has(globals_js_1.ParamKeys.__is_net)) {
+            const netName = paramsMap.get(globals_js_1.ParamKeys.net_name);
+            const priority = paramsMap.get(globals_js_1.ParamKeys.priority);
+            const result = this.resolveNet(netName, this.netNamespace);
+            let tmpNet;
+            if (result.found) {
+                tmpNet = result.net;
+                this.print('net found', tmpNet.namespace, tmpNet.name);
+            }
+            else {
+                tmpNet = new Net_js_1.Net(this.netNamespace, netName, priority);
+                this.print('net not found, added net instance', tmpNet.namespace, tmpNet.name);
+            }
+            this.scope.setNet(component, 1, tmpNet);
+            this.print('set net', netName, 'component', component);
+        }
+        const { arrange = null } = props;
+        component.arrangeProps = arrange;
+        component.displayProp = props.display ?? null;
+        component.widthProp = props.width ?? null;
+        component.typeProp = props.type ?? null;
+        const portSides = getPortSide(component.pins, arrange);
+        portSides.forEach(({ pinId, side, position }) => {
+            if (component.pins.has(pinId)) {
+                const tmpPin = component.pins.get(pinId);
+                tmpPin.side = side;
+                tmpPin.position = position;
+            }
+        });
+        this.scope.instances.set(instanceName, component);
+        const pinsOutput = pins.map((pin) => {
+            return pin.id + ':' + pin.name;
+        });
+        this.print('add symbol', instanceName, '[' + pinsOutput.join(', ') + ']');
+        return component;
+    }
+    printPoint(extra = '') {
+        let netName = globals_js_1.NoNetText;
+        if (this.scope.hasNet(this.scope.currentComponent, this.scope.currentPin)) {
+            netName = this.scope
+                .getNet(this.scope.currentComponent, this.scope.currentPin)
+                .toString();
+        }
+        this.print((extra !== '' ? (extra + ' ') : '') + 'point: ' +
+            this.scope.currentComponent.instanceName +
+            ' ' +
+            this.scope.currentPin + ' ' + netName);
+    }
+    addComponentExisting(component, pin) {
+        const startPin = pin;
+        const nextPin = component.getNextPinAfter(startPin);
+        this.toComponent(component, startPin, { addSequence: true });
+        this.print('move to next pin: ' + nextPin);
+        this.atComponent(component, nextPin, {
+            addSequence: true
+        });
+        this.printPoint();
+        return this.getCurrentPoint();
+    }
+    toComponent(component, pinId, options) {
+        this.print('to component');
+        const { addSequence = false, cloneNetComponent = false } = options ?? {};
+        if (cloneNetComponent && this.isNetOnlyComponent(component)) {
+            component = this.cloneComponent(component);
+        }
+        if (!(component instanceof ClassComponent_js_1.ClassComponent)) {
+            throw "Not a valid component!";
+        }
+        if (pinId === null) {
+            pinId = component.getDefaultPin();
+        }
+        else {
+            if (component.hasPin(pinId)) {
+                pinId = component.getPin(pinId);
+            }
+            else {
+                console.trace();
+                throw ('Invalid pin number ' +
+                    pinId +
+                    ' in ' +
+                    component.instanceName);
+            }
+        }
+        if (this.scope.hasNet(this.scope.currentComponent, this.scope.currentPin)) {
+            this.print('net: ', this.scope
+                .getNet(this.scope.currentComponent, this.scope.currentPin)
+                .toString());
+        }
+        const linkedNet = this.linkComponentPinNet(this.scope.currentComponent, this.scope.currentPin, component, pinId);
+        this.scope.currentComponent = component;
+        this.scope.currentPin = pinId;
+        this.scope.clearActive();
+        if (addSequence) {
+            if (this.scope.sequence.length > 0) {
+                if (component.pinWires.has(pinId) && component.typeProp !== globals_js_1.ComponentTypes.point) {
+                }
+                const [entryType, , segments] = this.scope.sequence[this.scope.sequence.length - 1];
+                if (entryType === ExecutionScope_js_1.SequenceAction.Wire && isWireSegmentsEndAuto(segments)) {
+                    segments[segments.length - 1].until = [
+                        component, pinId
+                    ];
+                }
+                component.pinWires.set(pinId, segments);
+            }
+            this.scope.sequence.push([ExecutionScope_js_1.SequenceAction.To, component,
+                pinId, linkedNet]);
+        }
+        this.printPoint();
+        return this.getCurrentPoint();
+    }
+    atComponent(component, pinId, options) {
+        this.print('at component');
+        const { addSequence = false, cloneNetComponent = false } = options ?? {};
+        if (cloneNetComponent && this.isNetOnlyComponent(component)) {
+            component = this.cloneComponent(component);
+        }
+        this.scope.currentComponent = component;
+        let usePinId;
+        if (pinId === null) {
+            usePinId = component.getDefaultPin();
+        }
+        else {
+            if (component.hasPin(pinId)) {
+                usePinId = component.getPin(pinId);
+            }
+            else {
+                throw 'Invalid pin number ' + pinId + ' in ' + component;
+            }
+        }
+        if (usePinId) {
+            this.scope.currentPin = usePinId;
+        }
+        this.scope.clearActive();
+        if (addSequence) {
+            this.scope.sequence.push([ExecutionScope_js_1.SequenceAction.At,
+                component, usePinId]);
+        }
+        this.printPoint();
+        return this.getCurrentPoint();
+    }
+    isNetOnlyComponent(component) {
+        return isNetComponent(component) && !isLabelComponent(component);
+    }
+    cloneComponent(component) {
+        let clonedComponent = null;
+        if (!this.scope.copyIDs.has(component.instanceName)) {
+            this.scope.copyIDs.set(component.instanceName, 0);
+        }
+        const idNum = this.scope.copyIDs.get(component.instanceName);
+        clonedComponent = component.clone();
+        clonedComponent._copyID = idNum;
+        clonedComponent._copyFrom = component;
+        this.scope.copyIDs.set(component.instanceName, idNum + 1);
+        const cloneInstanceName = component.instanceName + ':' + idNum;
+        this.scope.instances.set(cloneInstanceName, clonedComponent);
+        clonedComponent.instanceName = cloneInstanceName;
+        this.linkComponentPinNet(component, 1, clonedComponent, 1);
+        this.print('created clone of net component:', cloneInstanceName);
+        return clonedComponent;
+    }
+    enterBlocks(blockType) {
+        if (blockType === globals_js_1.BlockTypes.Point) {
+            this.addPoint(`_point.${this.name}.${this.tmpPointId}`, false);
+            this.tmpPointId += 1;
+        }
+        else if (blockType === globals_js_1.BlockTypes.Parallel) {
+            this.addPoint(`_parallel.${this.name}.${this.tmpPointId}`, false);
+            this.tmpPointId += 1;
+        }
+        this.scope.blockStack.set(this.scope.indentLevel, {
+            entered_at: [
+                this.scope.currentComponent,
+                this.scope.currentPin,
+                this.scope.currentWireId
+            ],
+            inner_blocks: new Map(),
+            current_index: null,
+            type: blockType,
+        });
+        this.print('enter blocks');
+    }
+    exitBlocks() {
+        const stackRef = this.scope.blockStack.get(this.scope.indentLevel);
+        const { type: blockType } = stackRef;
+        if (blockType === globals_js_1.BlockTypes.Join || blockType === globals_js_1.BlockTypes.Parallel) {
+            const { final_point: finalPoint } = stackRef;
+            const [component, pin, wireId] = finalPoint;
+            this.scope.currentComponent = component;
+            this.scope.currentPin = pin;
+            this.scope.currentWireId = wireId;
+            if (wireId !== -1) {
+                this.scope.sequence.push([
+                    ExecutionScope_js_1.SequenceAction.WireJump, wireId, 1
+                ]);
+            }
+        }
+        else if (blockType === globals_js_1.BlockTypes.Point) {
+            const { entered_at: [component, pin,] } = stackRef;
+            this.atComponent(component, pin, { addSequence: true });
+        }
+        this.print('exit blocks');
+    }
+    enterBlock(blockIndex) {
+        const stackRef = this.scope.blockStack.get(this.scope.indentLevel);
+        stackRef['block_index'] = blockIndex;
+        const { type: blockType } = stackRef;
+        stackRef['inner_blocks'].set(blockIndex, {
+            last_net: null,
+            ignore_last_net: false,
+        });
+        if (blockType === globals_js_1.BlockTypes.Join || blockType === globals_js_1.BlockTypes.Point) {
+            this.scope.currentComponent = null;
+            this.scope.currentPin = null;
+            this.scope.currentWireId = -1;
+        }
+        else if (blockType === globals_js_1.BlockTypes.Parallel) {
+            const { entered_at: [component, pin,] } = stackRef;
+            this.atComponent(component, pin, { addSequence: true });
+        }
+        this.print(`enter inner block of type (${blockType}) >>>`);
+        this.scope.indentLevel += 1;
+    }
+    exitBlock(blockIndex) {
+        const stackRef = this.scope.blockStack.get(this.scope.indentLevel - 1);
+        const { type: blockType } = stackRef;
+        const blockIndexRef = stackRef['inner_blocks'].get(blockIndex);
+        blockIndexRef['last_net'] = [
+            this.scope.currentComponent,
+            this.scope.currentPin,
+            this.scope.currentWireId
+        ];
+        stackRef['block_index'] = null;
+        this.scope.indentLevel -= 1;
+        this.print('exit inner block <<<');
+        if (blockType === globals_js_1.BlockTypes.Branch) {
+            const { entered_at: [component, pin, wireId] } = stackRef;
+            this.atComponent(component, pin, { addSequence: true });
+            if (wireId !== -1) {
+                this.scope.sequence.push([ExecutionScope_js_1.SequenceAction.WireJump, wireId, 1]);
+            }
+        }
+        else if (blockType === globals_js_1.BlockTypes.Join || blockType === globals_js_1.BlockTypes.Parallel) {
+            if (blockIndex === 0) {
+                const pointIdName = (blockType === globals_js_1.BlockTypes.Join) ? '_join' : '_parallel';
+                this.addPoint(`${pointIdName}.${this.name}.${this.tmpPointId}`, false);
+                this.tmpPointId += 1;
+                stackRef['final_point'] = [
+                    this.scope.currentComponent,
+                    this.scope.currentPin,
+                    this.scope.currentWireId
+                ];
+            }
+            else {
+                const { final_point: finalPoint } = stackRef;
+                const [component, pin,] = finalPoint;
+                this.toComponent(component, pin, { addSequence: true });
+            }
+        }
+    }
+    atPointBlock() {
+        const [component, pin,] = this.getPointBlockLocation();
+        this.atComponent(component, pin, {
+            addSequence: true
+        });
+    }
+    toPointBlock() {
+        const [component, pin,] = this.getPointBlockLocation();
+        this.toComponent(component, pin, {
+            addSequence: true
+        });
+    }
+    getPointBlockLocation() {
+        this.print('get block point');
+        for (let i = 0; i < this.scope.indentLevel; i++) {
+            const stackRef = this.scope.blockStack.get(this.scope.indentLevel - 1 - i);
+            const { entered_at } = stackRef;
+            const component = entered_at[0];
+            if (component.instanceName.startsWith('_point.')) {
+                return entered_at;
+            }
+        }
+        this.print('did not find block point');
+        return null;
+    }
+    breakBranch() {
+        this.print('break branch');
+        const branchesInfo = this.scope.blockStack.get(this.scope.indentLevel - 1);
+        const branchIndex = branchesInfo['block_index'];
+        const branchIndexRef = branchesInfo['inner_blocks'].get(branchIndex);
+        branchIndexRef['ignore_last_net'] = true;
+    }
+    createFunction(functionName, __runFunc) {
+        this.scope.functions.set(functionName, __runFunc);
+        this.__functionCache[functionName] = __runFunc;
+        this.print(`defined new function '${functionName}'`);
+    }
+    hasFunction(functionName) {
+        return this.scope.functions.has(functionName);
+    }
+    getFunction(functionName) {
+        return this.scope.functions.get(functionName);
+    }
+    resolveVariable(executionStack, idName) {
+        const reversed = [...executionStack].reverse();
+        for (let i = 0; i < reversed.length; i++) {
+            const context = reversed[i];
+            if (context.hasFunction(idName)) {
+                return {
+                    found: true,
+                    value: context.getFunction(idName),
+                    type: globals_js_1.ReferenceTypes.function,
+                    name: idName,
+                };
+            }
+            else if (context.scope.variables.has(idName)) {
+                return {
+                    found: true,
+                    value: context.scope.variables.get(idName),
+                    type: globals_js_1.ReferenceTypes.variable,
+                    name: idName,
+                };
+            }
+            else if (context.scope.instances.has(idName)) {
+                return {
+                    found: true,
+                    value: context.scope.instances.get(idName),
+                    type: globals_js_1.ReferenceTypes.instance,
+                    name: idName,
+                };
+            }
+        }
+        return {
+            found: false,
+            name: idName,
+        };
+    }
+    callFunction(functionName, functionParams, executionStack, netNamespace) {
+        let __runFunc = null;
+        if (this.__functionCache[functionName] === undefined) {
+            if (this.hasFunction(functionName)) {
+                __runFunc = this.getFunction(functionName);
+            }
+            if (__runFunc === null) {
+                this.print(`searching for function ${functionName} in upper context`);
+                const tmpResolveResult = this.resolveVariable(executionStack, functionName);
+                if (tmpResolveResult.found) {
+                    __runFunc = tmpResolveResult.value;
+                }
+                else {
+                    throw `Invalid function ${functionName}`;
+                }
+            }
+            this.print('save function to cache:', functionName);
+            this.__functionCache[functionName] = __runFunc;
+        }
+        else {
+            this.print('found function in cache:', functionName);
+            __runFunc = this.__functionCache[functionName];
+        }
+        if (__runFunc !== null) {
+            this.print(`call function '${functionName}'`);
+            const functionResult = __runFunc(functionParams, { netNamespace });
+            this.print(`done call function '${functionName}'`);
+            return functionResult;
+        }
+        else {
+            throw `Invalid function '${functionName}'`;
+        }
+    }
+    mergeScope(childScope, namespace) {
+        this.print('-- merging scope to parent --');
+        const currentComponent = this.scope.currentComponent;
+        const currentPin = this.scope.currentPin;
+        const currentWireId = this.scope.currentWireId;
+        const gndCopyIdOffset = 0;
+        const tmpInstances = childScope.instances;
+        const tmpNets = childScope.getNets();
+        for (const [instanceName, component] of tmpInstances) {
+            const newInstanceName = `${namespace}.${instanceName}`;
+            component.instanceName = newInstanceName;
+            if (component === childScope.componentGnd ||
+                component === childScope.componentRoot) {
+                continue;
+            }
+            if (!this.scope.instances.has(newInstanceName)) {
+                this.scope.instances.set(newInstanceName, component);
+            }
+            else {
+                throw "Invalid instance name to merge into parent scope!";
+            }
+        }
+        tmpNets.forEach(([component, pin, net]) => {
+            this.scope.setNet(component, pin, net);
+        });
+        const linkRootComponent = true;
+        const tmpRoot = childScope.componentRoot;
+        if (linkRootComponent) {
+            const netConnectedToRoot = childScope.getNet(tmpRoot, 1);
+            if (netConnectedToRoot !== null) {
+                let currentNet = this.scope.getNet(currentComponent, currentPin);
+                if (currentNet === null) {
+                    const tmpNet = new Net_js_1.Net(this.netNamespace, this.getUniqueNetName());
+                    this.scope.setNet(currentComponent, currentPin, netConnectedToRoot);
+                    currentNet = tmpNet;
+                }
+                netConnectedToRoot.priority = currentNet.priority - 1;
+                this.toComponent(tmpRoot, 1);
+            }
+        }
+        const wireIdOffset = this.scope.wires.length;
+        const frameIdOffset = this.scope.frames.length;
+        let incrementGndLinkId = 0;
+        childScope.sequence.forEach(sequenceAction => {
+            const [action] = sequenceAction;
+            if (action === ExecutionScope_js_1.SequenceAction.Wire) {
+                const [, innerWireId, segments] = sequenceAction;
+                this.scope.sequence.push([ExecutionScope_js_1.SequenceAction.Wire, wireIdOffset + innerWireId, segments]);
+                this.scope.wires.push(new Wire_js_1.Wire(segments));
+            }
+            else if (action === ExecutionScope_js_1.SequenceAction.WireJump) {
+                const jumpWireId = wireIdOffset + sequenceAction[1];
+                this.scope.sequence.push([ExecutionScope_js_1.SequenceAction.WireJump, jumpWireId, 1]);
+            }
+            else if (action === ExecutionScope_js_1.SequenceAction.At || action === ExecutionScope_js_1.SequenceAction.To) {
+                const tmpComponent = sequenceAction[1];
+                if (isNetComponent(tmpComponent) && tmpComponent.parameters.get(globals_js_1.ParamKeys.net_name) === 'gnd') {
+                    tmpComponent._copyID = gndCopyIdOffset + incrementGndLinkId;
+                    incrementGndLinkId += 1;
+                }
+                else if (tmpComponent === tmpRoot) {
+                    if (currentWireId !== -1) {
+                        sequenceAction = [ExecutionScope_js_1.SequenceAction.WireJump, currentWireId];
+                    }
+                    else {
+                        sequenceAction = [action, currentComponent, currentPin];
+                    }
+                }
+                this.scope.sequence.push(sequenceAction);
+            }
+            else if (action === ExecutionScope_js_1.SequenceAction.Frame) {
+                const frame = sequenceAction[1];
+                const frameAction = sequenceAction[2];
+                if (frameAction === ExecutionScope_js_1.FrameAction.Enter) {
+                    frame.frameId += frameIdOffset;
+                    this.scope.frames.push(frame);
+                }
+                this.scope.sequence.push(sequenceAction);
+            }
+        });
+        if (childScope.currentComponent === childScope.componentRoot) {
+            this.scope.currentComponent = currentComponent;
+            this.scope.currentPin = currentPin;
+            this.scope.currentWireId = currentWireId;
+        }
+        else {
+            this.scope.currentComponent = childScope.currentComponent;
+            this.scope.currentPin = childScope.currentPin;
+            this.scope.currentWireId = childScope.currentWireId + wireIdOffset;
+        }
+        this.printPoint('resume at');
+        this.print('-- nets --');
+        const currentNets = this.scope.getNets();
+        currentNets.reduce((accum, [, , net]) => {
+            if (accum.indexOf(net) === -1) {
+                accum.push(net);
+                this.print(`${net.namespace}${net.name} ${net.priority}`);
+            }
+            return accum;
+        }, []);
+        this.print('-- done merging scope --');
+    }
+    addWire(segments) {
+        if (this.scope.currentComponent === null) {
+            throw "No current component";
+        }
+        const tmp = segments.map(item => {
+            const [direction, value = null] = item;
+            return {
+                direction,
+                value
+            };
+        });
+        const wireId = this.scope.wires.length;
+        this.scope.wires.push(new Wire_js_1.Wire(tmp));
+        const output = [];
+        segments.forEach(item => {
+            output.push(item.join(","));
+        });
+        this.print('add wire: ', output.join("|"));
+        this.scope.setActive(ExecutionScope_js_1.ActiveObject.Wire, wireId);
+        this.scope.sequence.push([ExecutionScope_js_1.SequenceAction.Wire, wireId, tmp]);
+        this.scope.currentComponent.pinWires.set(this.scope.currentPin, tmp);
+    }
+    addPoint(pointId, userDefined = true) {
+        if (this.scope.instances.has(pointId)) {
+            this.print('Warning: ' + pointId + ' is being redefined');
+        }
+        const useName = userDefined ? 'point.' + pointId : pointId;
+        const componentPoint = ClassComponent_js_1.ClassComponent.simple(useName, 1, "point");
+        componentPoint.displayProp = "point";
+        componentPoint.typeProp = globals_js_1.ComponentTypes.point;
+        this.scope.instances.set(pointId, componentPoint);
+        this.toComponent(componentPoint, 1, { addSequence: true });
+        return this.getCurrentPoint();
+    }
+    setProperty(nameWithProp, value) {
+        this.print('set property', nameWithProp, 'value', value);
+        let idName;
+        let paramName;
+        let useActive = false;
+        if (nameWithProp.startsWith('..')) {
+            useActive = true;
+            paramName = nameWithProp.substring(2);
+        }
+        else {
+            const parts = nameWithProp.split(".");
+            idName = parts[0];
+            paramName = parts[1];
+        }
+        if (useActive && this.scope.currentFrameId !== -1) {
+            this.scope.frames[this.scope.currentFrameId - 1]
+                .parameters.set(paramName, value);
+        }
+        else {
+            idName = this.scope.currentComponent.instanceName;
+            if (this.scope.instances.has(idName)) {
+                const component = this.scope.instances.get(idName);
+                component.parameters.set(paramName, value);
+            }
+            else if (this.scope.variables.has(idName)) {
+                throw "Not implemented yet!";
+            }
+            else {
+                throw "Unknown identifier: " + idName;
+            }
+        }
+    }
+    setCurrentComponentStyle(styles) {
+        for (const key in styles) {
+            this.scope.currentComponent.styles[key] = styles[key];
+        }
+    }
+    enterFrame() {
+        const frameId = this.scope.frames.length + 1;
+        const frameObject = new Frame_js_1.Frame(frameId);
+        this.scope.frames.push(frameObject);
+        this.scope.sequence.push([ExecutionScope_js_1.SequenceAction.Frame,
+            frameObject, ExecutionScope_js_1.FrameAction.Enter]);
+        this.scope.currentFrameId = frameId;
+        this.scope.setActive(ExecutionScope_js_1.ActiveObject.Frame, frameId);
+        return frameId;
+    }
+    exitFrame(frameId) {
+        const frame = this.scope.frames[frameId - 1];
+        this.scope.sequence.push([ExecutionScope_js_1.SequenceAction.Frame,
+            frame, ExecutionScope_js_1.FrameAction.Exit]);
+    }
+}
+exports.ExecutionContext = ExecutionContext;
+function isWireSegmentsEndAuto(segments) {
+    if (segments.length > 0) {
+        if (segments[segments.length - 1].value === null) {
+            return true;
+        }
+    }
+    return false;
+}
+function isNetComponent(component) {
+    return component.parameters.has(globals_js_1.ParamKeys.__is_net);
+}
+exports.isNetComponent = isNetComponent;
+function isLabelComponent(component) {
+    return component.parameters.has(globals_js_1.ParamKeys.__is_label);
+}
+exports.isLabelComponent = isLabelComponent;
+function getPortSide(pins, arrangeProps) {
+    const result = [];
+    if (arrangeProps === null) {
+        let counter = 0;
+        for (const [pinId] of pins) {
+            result.push({
+                pinId,
+                side: counter % 2 === 0 ? PinDefinition_js_1.PortSide.WEST : PinDefinition_js_1.PortSide.EAST,
+                order: counter,
+                position: Math.floor(counter / 2),
+            });
+            counter++;
+        }
+    }
+    else {
+        let counter = pins.size;
+        const existingPinIds = Array.from(pins.keys());
+        for (const [key, items] of arrangeProps) {
+            let useItems;
+            if (!Array.isArray(items)) {
+                useItems = [items];
+            }
+            else {
+                useItems = [...items];
+            }
+            let useSide = PinDefinition_js_1.PortSide.WEST;
+            if (key === 'left') {
+                useSide = PinDefinition_js_1.PortSide.WEST;
+            }
+            else if (key === 'right') {
+                useSide = PinDefinition_js_1.PortSide.EAST;
+            }
+            else if (key === 'top') {
+                useSide = PinDefinition_js_1.PortSide.NORTH;
+            }
+            else if (key === 'bottom') {
+                useSide = PinDefinition_js_1.PortSide.SOUTH;
+            }
+            let position = 0;
+            useItems.forEach(item => {
+                if (typeof item === 'object') {
+                    if (item.blank) {
+                        position += item.blank;
+                    }
+                }
+                if (existingPinIds.indexOf(item) !== -1) {
+                    result.push({
+                        pinId: item,
+                        side: useSide,
+                        position,
+                        order: counter
+                    });
+                    counter--;
+                    position += 1;
+                }
+            });
+        }
+    }
+    return result;
+}
+exports.getPortSide = getPortSide;