circuitscript 0.1.15 → 0.1.16

package/dist/esm/antlr/CircuitScriptVisitor.js

@@ -32,6 +32,7 @@ export class CircuitScriptVisitor extends AbstractParseTreeVisitor {
     visitProperty_set_expr;
     visitDouble_dot_property_set_expr;
     visitArrayExpr;
+    visitArrayIndexExpr;
     visitFunctionCallExpr;
     visitAdditionExpr;
     visitMultiplyExpr;
@@ -49,6 +50,7 @@ export class CircuitScriptVisitor extends AbstractParseTreeVisitor {
     visitFunction_args_expr;
     visitAtom_expr;
     visitTrailer_expr;
+    visitTrailer_expr2;
     visitFunction_call_expr;
     visitNet_namespace_expr;
     visitFunction_return_expr;

package/dist/esm/builtinMethods.js

@@ -1,5 +1,6 @@
 import Big from "big.js";
 import { numeric, NumericValue } from "./objects/ParamDefinition.js";
+import { CFunctionEntry } from "./objects/types.js";
 import { unwrapValue, resolveToNumericValue, RuntimeExecutionError } from "./utils.js";
 const builtInMethods = [
     ['enumerate', enumerate],
@@ -144,8 +145,17 @@ function toString(obj) {
     else if (obj instanceof NumericValue) {
         return obj.toBigNumber().toString();
     }
+    else if (obj instanceof CFunctionEntry) {
+        return obj.toString();
+    }
     else {
-        if (obj.toDisplayString) {
+        if (obj === undefined) {
+            return 'undefined';
+        }
+        else if (obj === null) {
+            return 'null';
+        }
+        else if (obj.toDisplayString) {
             return obj.toDisplayString();
         }
         else if (obj.toString) {

package/dist/esm/execute.js

@@ -4,7 +4,7 @@ import { ActiveObject, ExecutionScope, FrameAction, SequenceAction } from './obj
 import { Net } from './objects/Net.js';
 import { numeric, NumericValue } from './objects/ParamDefinition.js';
 import { PortSide } from './objects/PinDefinition.js';
-import { AnyReference, DeclaredReference, Direction } from './objects/types.js';
+import { AnyReference, CFunctionEntry, DeclaredReference, Direction } from './objects/types.js';
 import { Wire } from './objects/Wire.js';
 import { Frame } from './objects/Frame.js';
 import { CalculatePinPositions } from './layout.js';
@@ -24,7 +24,7 @@ export class ExecutionContext {
     returnValue = null;
     silent = false;
     logger;
-    __functionCache = {};
+    __functionCache = new Map();
     parentContext;
     componentAngleFollowsWire = true;
     warnings = [];
@@ -538,9 +538,9 @@ export class ExecutionContext {
     getBreakContext() {
         return this.scope.breakStack[this.scope.breakStack.length - 1];
     }
-    createFunction(functionName, __runFunc) {
-        this.scope.functions.set(functionName, __runFunc);
-        this.__functionCache[functionName] = __runFunc;
+    createFunction(functionName, __runFunc, source, uniqueId) {
+        this.scope.functions.set(functionName, new CFunctionEntry(functionName, __runFunc, source, uniqueId));
+        this.__functionCache.set(functionName, __runFunc);
         this.log(`defined new function '${functionName}'`);
     }
     hasFunction(functionName) {
@@ -609,12 +609,17 @@ export class ExecutionContext {
                     }
                 }
                 else {
-                    useValue = parentValue.parameters.get(trailersPath);
+                    useValue = parentValue
+                        .parameters.get(trailersPath);
                 }
             }
         }
+        let found = false;
+        if (parentValue !== undefined && useValue !== undefined) {
+            found = true;
+        }
         return new AnyReference({
-            found: true,
+            found,
             type: type,
             parentValue,
             trailers,
@@ -623,26 +628,28 @@ export class ExecutionContext {
     }
     callFunction(functionName, functionParams, executionStack, netNamespace) {
         let __runFunc = null;
-        if (this.__functionCache[functionName] === undefined) {
+        if (!this.__functionCache.has(functionName)) {
             if (this.hasFunction(functionName)) {
-                __runFunc = this.getFunction(functionName);
+                const entry = this.getFunction(functionName);
+                __runFunc = entry.execute;
             }
             if (__runFunc === null) {
                 this.log(`searching for function ${functionName} in upper context`);
                 const tmpResolveResult = this.resolveVariable(executionStack, functionName);
                 if (tmpResolveResult.found) {
-                    __runFunc = tmpResolveResult.value;
+                    const entry = tmpResolveResult.value;
+                    __runFunc = entry.execute;
                 }
                 else {
                     throw `Invalid function ${functionName}`;
                 }
             }
             this.log('save function to cache:', functionName);
-            this.__functionCache[functionName] = __runFunc;
+            this.__functionCache.set(functionName, __runFunc);
         }
         else {
             this.log('found function in cache:', functionName);
-            __runFunc = this.__functionCache[functionName];
+            __runFunc = this.__functionCache.get(functionName);
         }
         if (__runFunc !== null) {
             this.log(`call function '${functionName}'`);

package/dist/esm/globals.js

@@ -92,6 +92,7 @@ export var ReferenceTypes;
     ReferenceTypes["variable"] = "variable";
     ReferenceTypes["instance"] = "instance";
     ReferenceTypes["pinType"] = "pinType";
+    ReferenceTypes["unknown"] = "unknown";
 })(ReferenceTypes || (ReferenceTypes = {}));
 export var BlockTypes;
 (function (BlockTypes) {
@@ -123,3 +124,4 @@ export const RenderFlags = {
     ShowLabelOrigin: false,
 };
 export const SymbolValidatorContext = '_sym';
+export const TrailerArrayIndex = 'index';

package/dist/esm/graph.js

@@ -0,0 +1,293 @@
+import { Graph } from "@dagrejs/graphlib";
+import { SymbolDrawing, SymbolPlaceholder, SymbolCustomModule, SymbolCustom } from "./draw_symbols.js";
+import { ComponentTypes } from "./globals.js";
+import { milsToMM } from "./helpers.js";
+import { RenderFrame, RenderComponent, applyComponentParamsToSymbol, RenderWire } from "./layout.js";
+import { SequenceAction, FrameAction } from "./objects/ExecutionScope.js";
+import { Frame, FixedFrameIds, FrameParamKeys } from "./objects/Frame.js";
+import { numeric, NumericValue } from "./objects/ParamDefinition.js";
+export class NetGraph {
+    logger;
+    constructor(logger) {
+        this.logger = logger;
+    }
+    generateLayoutGraph(sequence, nets) {
+        this.print('===== creating graph and populating with nodes =====');
+        let previousNode = null;
+        let previousPin = null;
+        const graph = new Graph({
+            directed: true,
+            compound: true,
+        });
+        this.print('sequence length:', sequence.length);
+        const baseFrame = new RenderFrame(new Frame(FixedFrameIds.BaseFrame));
+        const frameStack = [baseFrame];
+        const containerFrames = [baseFrame];
+        sequence.forEach((sequenceStep, index) => {
+            const action = sequenceStep[0];
+            let tmpComponent;
+            switch (action) {
+                case SequenceAction.To:
+                case SequenceAction.At: {
+                    this.print(...sequenceStep);
+                    const [, component, pin] = sequenceStep;
+                    const tmpInstanceName = component.instanceName;
+                    if (!graph.hasNode(tmpInstanceName)) {
+                        this.print('create instance', tmpInstanceName);
+                        const { displayProp = null } = component;
+                        let tmpSymbol;
+                        if (displayProp instanceof SymbolDrawing) {
+                            tmpSymbol = new SymbolPlaceholder(displayProp);
+                            tmpSymbol.drawing.logger = this.logger;
+                        }
+                        else {
+                            const symbolPinDefinitions = generateLayoutPinDefinition(component);
+                            if (component.typeProp === ComponentTypes.module) {
+                                tmpSymbol = new SymbolCustomModule(symbolPinDefinitions, component.pinsMaxPositions);
+                            }
+                            else {
+                                tmpSymbol = new SymbolCustom(symbolPinDefinitions, component.pinsMaxPositions);
+                            }
+                        }
+                        applyComponentParamsToSymbol(component, tmpSymbol);
+                        tmpSymbol.refreshDrawing();
+                        const { width: useWidth, height: useHeight } = tmpSymbol.size();
+                        tmpComponent = new RenderComponent(component, useWidth, useHeight);
+                        tmpComponent.symbol = tmpSymbol;
+                        graph.setNode(tmpInstanceName, [RenderItemType.Component, tmpComponent, index]);
+                        const currentFrame = frameStack[frameStack.length - 1];
+                        currentFrame && currentFrame.innerItems.push(tmpComponent);
+                    }
+                    if (action === SequenceAction.To && previousNode && previousPin) {
+                        this.setGraphEdge(graph, previousNode, tmpInstanceName, makeEdgeValue(previousNode, previousPin, tmpInstanceName, pin, index));
+                    }
+                    previousNode = tmpInstanceName;
+                    previousPin = pin;
+                    break;
+                }
+                case SequenceAction.Wire: {
+                    const [, wireId, wireSegments] = sequenceStep;
+                    let useNet;
+                    if (previousNode !== null) {
+                        const [prevNodeType, prevNodeItem] = graph.node(previousNode);
+                        if (prevNodeType === RenderItemType.Component) {
+                            const matchingItem = nets.find(([comp, pin]) => {
+                                return comp.instanceName === previousNode
+                                    && pin === previousPin;
+                            });
+                            if (matchingItem !== undefined) {
+                                useNet = matchingItem[2];
+                            }
+                        }
+                        else if (prevNodeType === RenderItemType.Wire) {
+                            useNet = prevNodeItem.net;
+                        }
+                    }
+                    const wire = new RenderWire(useNet, numeric(0), numeric(0), wireSegments);
+                    wire.id = wireId;
+                    wire.netName = useNet.toString();
+                    const wireName = getWireName(wire.id);
+                    graph.setNode(wireName, [RenderItemType.Wire, wire, index]);
+                    this.setGraphEdge(graph, previousNode, wireName, makeEdgeValue(previousNode, previousPin, wireName, 0, index));
+                    previousNode = wireName;
+                    previousPin = 1;
+                    const wireSegmentsInfo = wireSegments.map(item => {
+                        const tmp = {
+                            direction: item.direction,
+                            value: item.value,
+                        };
+                        if (item.valueXY) {
+                            tmp.valueXY = item.valueXY;
+                        }
+                        if (item.until) {
+                            tmp.until = [item.until[0].toString(), item.until[1]];
+                        }
+                        return tmp;
+                    });
+                    this.print(SequenceAction.Wire, wireId, JSON.stringify(wireSegmentsInfo));
+                    break;
+                }
+                case SequenceAction.WireJump: {
+                    this.print(...sequenceStep);
+                    const wireId = sequenceStep[1];
+                    const wireName = getWireName(wireId);
+                    let wirePin = 1;
+                    if (sequenceStep.length === 3) {
+                        wirePin = sequenceStep[2];
+                    }
+                    previousNode = wireName;
+                    previousPin = wirePin;
+                    break;
+                }
+                case SequenceAction.Frame: {
+                    const [, frameObject, frameAction] = sequenceStep;
+                    if (frameAction === FrameAction.Enter) {
+                        const prevFrame = frameStack[frameStack.length - 1];
+                        const newFrame = new RenderFrame(frameObject);
+                        if (frameObject.parameters.has(FrameParamKeys.Direction)) {
+                            newFrame.direction =
+                                frameObject.parameters.get(FrameParamKeys.Direction);
+                        }
+                        if (frameObject.parameters.has(FrameParamKeys.Padding)) {
+                            newFrame.padding = milsToMM(frameObject.parameters.get(FrameParamKeys.Padding));
+                        }
+                        if (frameObject.parameters.has(FrameParamKeys.Border)) {
+                            newFrame.borderWidth =
+                                frameObject.parameters.get(FrameParamKeys.Border);
+                        }
+                        if (frameObject.parameters.has(FrameParamKeys.Width)) {
+                            newFrame.width = milsToMM(frameObject.parameters.get(FrameParamKeys.Width));
+                        }
+                        if (frameObject.parameters.has(FrameParamKeys.Height)) {
+                            newFrame.height = milsToMM(frameObject.parameters.get(FrameParamKeys.Height));
+                        }
+                        containerFrames.push(newFrame);
+                        frameStack.push(newFrame);
+                        prevFrame && prevFrame.innerItems.push(newFrame);
+                    }
+                    else if (frameAction === FrameAction.Exit) {
+                        frameStack.pop();
+                    }
+                    break;
+                }
+            }
+        });
+        this.print('===== done populating graph =====');
+        this.print('');
+        const logNodesAndEdges = true;
+        if (logNodesAndEdges) {
+            this.print('===== graph edges =====');
+            const allEdges = graph.edges();
+            allEdges.forEach(edge => {
+                const [nodeId1, pin1, nodeId2, pin2] = graph.edge(edge);
+                this.print(nodeId1, 'pin', pin1, '-----', nodeId2, 'pin', pin2);
+            });
+            this.print('===== end edges =====');
+            this.print();
+            this.print('===== graph nodes =====');
+            const nodes = graph.nodes();
+            nodes.forEach(node => {
+                this.print(`name:${node}, value:${graph.node(node)}`);
+            });
+            this.print('===== end nodes =====');
+            this.print('');
+        }
+        return {
+            graph,
+            containerFrames,
+        };
+    }
+    setGraphEdge(graph, node1, node2, edgeValue) {
+        if (!graph.isDirected && graph.hasEdge(node1, node2)) {
+            this.print(`Warning: edge already exists ${node1} ${node2}`);
+        }
+        graph.setEdge(node1, node2, edgeValue);
+        this.print(`created edge: node1:${node1} node2:${node2} edgeValue:${edgeValue}`);
+    }
+    print(...params) {
+        this.logger.add(params.join(' '));
+    }
+    generateNetGraph(nets) {
+        const graph = new Graph({
+            directed: false
+        });
+        nets.forEach(item => {
+            const [component, pin, net] = item;
+            const netNodeName = this.getNetNodeName(net);
+            if (!graph.hasNode(netNodeName)) {
+                graph.setNode(netNodeName, net);
+            }
+            const componentNodeName = this.getComponentName(component);
+            if (!graph.hasNode(componentNodeName)) {
+                graph.setNode(componentNodeName, component);
+            }
+            graph.setEdge(netNodeName, componentNodeName, [component, pin, net]);
+        });
+    }
+    findNodePaths(graph, startNode, endNode, seenNodes = []) {
+        const edges = graph.nodeEdges(startNode);
+        const paths = [];
+        for (let i = 0; i < edges.length; i++) {
+            const edge = edges[i];
+            const node1 = edge.v;
+            const node2 = edge.w;
+            let nextNode = "";
+            if (node1 === startNode) {
+                nextNode = node2;
+            }
+            else {
+                nextNode = node1;
+            }
+            if (nextNode === endNode) {
+                paths.push([startNode, endNode]);
+                continue;
+            }
+            else if (seenNodes.indexOf(nextNode) !== -1) {
+                continue;
+            }
+            seenNodes.push(startNode);
+            const routes = this.findNodePaths(graph, nextNode, endNode, seenNodes);
+            for (let j = 0; j < routes.length; j++) {
+                paths.push([startNode, ...routes[j]]);
+            }
+        }
+        return paths;
+    }
+    getNetNodeName(net) {
+        return 'net:' + net.toString();
+    }
+    getComponentName(component) {
+        return 'component:' + component.instanceName;
+    }
+}
+function makeEdgeValue(instanceName1, instancePin1, instanceName2, instancePin2, priority) {
+    return [instanceName1, instancePin1, instanceName2, instancePin2, priority];
+}
+export function getWireName(wireId) {
+    return 'wire:' + wireId;
+}
+export function generateLayoutPinDefinition(component) {
+    const pins = component.pins;
+    const symbolPinDefinitions = [];
+    const existingPinIds = Array.from(pins.keys());
+    const arrangeProps = component.arrangeProps ?? [];
+    const addedPins = [];
+    for (const [key, items] of arrangeProps) {
+        let useItems;
+        if (!Array.isArray(items)) {
+            useItems = [items];
+        }
+        else {
+            useItems = [...items];
+        }
+        useItems.forEach(pinId => {
+            if (pinId instanceof NumericValue) {
+                const pinIdValue = pinId.toNumber();
+                if (existingPinIds.indexOf(pinIdValue) !== -1) {
+                    const pin = pins.get(pinIdValue);
+                    symbolPinDefinitions.push({
+                        side: key,
+                        pinId: pinIdValue,
+                        text: pin.name,
+                        position: pin.position,
+                        pinType: pin.pinType,
+                    });
+                    addedPins.push(pinIdValue);
+                }
+            }
+        });
+    }
+    const unplacedPins = existingPinIds.filter(pinId => {
+        return addedPins.indexOf(pinId) === -1;
+    });
+    if (unplacedPins.length > 0) {
+        component._unplacedPins = unplacedPins;
+        console.warn("Warning: There are unplaced pins: " + unplacedPins);
+    }
+    return symbolPinDefinitions;
+}
+export var RenderItemType;
+(function (RenderItemType) {
+    RenderItemType["Wire"] = "wire";
+    RenderItemType["Component"] = "component";
+})(RenderItemType || (RenderItemType = {}));

package/dist/esm/helpers.js

@@ -17,6 +17,7 @@ import { defaultPageMarginMM, defaultZoomScale, LengthUnit, MilsToMM, PxToMM } f
 import { FrameParamKeys } from "./objects/Frame.js";
 import Big from "big.js";
 import { Logger } from "./logger.js";
+import { NetGraph } from "./graph.js";
 export var JSModuleType;
 (function (JSModuleType) {
     JSModuleType["CommonJs"] = "cjs";
@@ -237,11 +238,14 @@ export async function renderScript(scriptData, outputPath, options) {
                     errors,
                 };
             }
-            const layoutEngine = new LayoutEngine();
+            const logger = new Logger();
+            const graphEngine = new NetGraph(logger);
+            const layoutEngine = new LayoutEngine(logger);
             const layoutTimer = new SimpleStopwatch();
             let sheetFrames;
             try {
-                sheetFrames = layoutEngine.runLayout(sequence, nets);
+                const { graph, containerFrames } = graphEngine.generateLayoutGraph(sequence, nets);
+                sheetFrames = layoutEngine.runLayout(graph, containerFrames, nets);
             }
             catch (err) {
                 throw new RenderError(`Error during layout generation: ${err}`, 'layout');