circuitscript 0.1.11 → 0.1.12

package/dist/esm/antlr/CircuitScriptVisitor.js

@@ -2,9 +2,11 @@ import { AbstractParseTreeVisitor } from "antlr4ng";
 export class CircuitScriptVisitor extends AbstractParseTreeVisitor {
     visitScript;
     visitExpression;
+    visitFlow_expressions;
+    visitGraph_expressions;
+    visitGraph_linear_expression;
     visitExpressions_block;
-    visitPath_blocks;
-    visitPath_block_inner;
+    visitPath_block;
     visitProperty_set_expr2;
     visitAssignment_expr2;
     visitPin_select_expr;

package/dist/esm/builtinMethods.js

@@ -1,6 +1,6 @@
 import Big from "big.js";
 import { numeric, NumericValue } from "./objects/ParamDefinition.js";
-import { resolveToNumericValue } from "./utils.js";
+import { prepareValue, resolveToNumericValue } from "./utils.js";
 const builtInMethods = [
     ['enumerate', enumerate],
     ['toMils', toMils],
@@ -15,7 +15,10 @@ export const buildInMethodNamesList = builtInMethods.map(item => item[0]);
 export function linkBuiltInMethods(context, visitor) {
     context.createFunction('print', (params) => {
         const args = getPositionParams(params);
-        const items = args.map(item => toString(item));
+        const items = args.map(item => {
+            const value = prepareValue(item);
+            return toString(value);
+        });
         if (visitor.printToConsole) {
             console.log('::', ...items);
         }
@@ -75,6 +78,7 @@ function toMils(value) {
     return resolveToNumericValue(bigValue);
 }
 function objectLength(obj) {
+    obj = prepareValue(obj);
     if (Array.isArray(obj)) {
         return numeric(obj.length);
     }

package/dist/esm/execute.js

@@ -357,6 +357,10 @@ export class ExecutionContext {
             }
         }
         this.scope.setCurrent(component, usePinId);
+        if (!this.scope.hasNet(component, pinId)) {
+            const tmpNet = new Net(this.netNamespace, this.getUniqueNetName());
+            this.scope.setNet(component, pinId, tmpNet);
+        }
         this.scope.clearActive();
         if (addSequence) {
             this.scope.sequence.push([SequenceAction.At,
@@ -400,13 +404,14 @@ export class ExecutionContext {
             this.tmpPointId += 1;
         }
         this.scope.blockStack.set(this.scope.indentLevel, {
-            entered_at: [
+            start_point: [
                 this.scope.currentComponent,
                 this.scope.currentPin,
                 this.scope.currentWireId
             ],
+            end_point: null,
             inner_blocks: new Map(),
-            current_index: null,
+            current_index: 0,
             type: blockType,
         });
         this.log('enter blocks');
@@ -415,7 +420,7 @@ export class ExecutionContext {
         const stackRef = this.scope.blockStack.get(this.scope.indentLevel);
         const { type: blockType } = stackRef;
         if (blockType === BlockTypes.Join || blockType === BlockTypes.Parallel) {
-            const { final_point: finalPoint } = stackRef;
+            const { end_point: finalPoint } = stackRef;
             const [component, pin, wireId] = finalPoint;
             this.scope.setCurrent(component, pin);
             this.scope.currentWireId = wireId;
@@ -426,17 +431,22 @@ export class ExecutionContext {
             }
         }
         else if (blockType === BlockTypes.Point) {
-            const { entered_at: [component, pin,] } = stackRef;
+            const { start_point: [component, pin,] } = stackRef;
             this.atComponent(component, pin, { addSequence: true });
         }
+        this.scope.blockStack.delete(this.scope.indentLevel);
         this.log('exit blocks');
     }
+    closeAllBlocks() {
+        if (this.scope.blockStack.has(this.scope.indentLevel)) {
+            this.exitBlocks();
+        }
+    }
     enterBlock(blockIndex) {
         const stackRef = this.scope.blockStack.get(this.scope.indentLevel);
-        stackRef['block_index'] = blockIndex;
         const { type: blockType } = stackRef;
         const blockTypeName = getBlockTypeString(blockType);
-        stackRef['inner_blocks'].set(blockIndex, {
+        stackRef.inner_blocks.set(blockIndex, {
             last_net: null,
             ignore_last_net: false,
         });
@@ -445,7 +455,7 @@ export class ExecutionContext {
             this.scope.currentWireId = -1;
         }
         else if (blockType === BlockTypes.Parallel) {
-            const { entered_at: [component, pin,] } = stackRef;
+            const { start_point: [component, pin,] } = stackRef;
             this.atComponent(component, pin, { addSequence: true });
         }
         this.log(`enter inner block of type (${blockTypeName}) >>>`);
@@ -454,17 +464,16 @@ export class ExecutionContext {
     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'] = [
+        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.log('exit inner block <<<');
         if (blockType === BlockTypes.Branch) {
-            const { entered_at: [component, pin, wireId] } = stackRef;
+            const { start_point: [component, pin, wireId] } = stackRef;
             this.atComponent(component, pin, { addSequence: true });
             if (wireId !== -1) {
                 this.scope.sequence.push([SequenceAction.WireJump, wireId, 1]);
@@ -475,14 +484,14 @@ export class ExecutionContext {
                 const pointIdName = `${Delimiter1}${getBlockTypeString(blockType)}`;
                 this.addPoint(`${pointIdName}.${this.name}.${this.tmpPointId}`, false);
                 this.tmpPointId += 1;
-                stackRef['final_point'] = [
+                stackRef.end_point = [
                     this.scope.currentComponent,
                     this.scope.currentPin,
                     this.scope.currentWireId
                 ];
             }
             else {
-                const { final_point: finalPoint } = stackRef;
+                const { end_point: finalPoint } = stackRef;
                 const [component, pin,] = finalPoint;
                 this.toComponent(component, pin, { addSequence: true });
             }
@@ -504,10 +513,10 @@ export class ExecutionContext {
         this.log('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];
+            const { start_point } = stackRef;
+            const component = start_point[0];
             if (component.instanceName.startsWith(`${Delimiter1}point.`)) {
-                return entered_at;
+                return start_point;
             }
         }
         this.log('did not find block point');
@@ -548,8 +557,8 @@ export class ExecutionContext {
                 });
             }
             else {
-                const isVariable = context.scope.variables.has(idName);
-                const isComponentInstance = context.scope.instances.has(idName);
+                let isVariable = context.scope.variables.has(idName);
+                let isComponentInstance = context.scope.instances.has(idName);
                 if (isVariable || isComponentInstance) {
                     const scopeList = isVariable ? context.scope.variables
                         : context.scope.instances;
@@ -558,11 +567,25 @@ export class ExecutionContext {
                     if (trailers.length > 0) {
                         parentValue = useValue;
                         const trailersPath = trailers.join(".");
+                        if (!isComponentInstance && (parentValue instanceof ClassComponent)) {
+                            isComponentInstance = true;
+                            isVariable = false;
+                        }
                         if (isVariable) {
                             useValue = parentValue[trailersPath];
                         }
                         else if (isComponentInstance) {
-                            useValue = parentValue.parameters.get(trailersPath);
+                            const tmpComponent = parentValue;
+                            if (tmpComponent.typeProp === ComponentTypes.net) {
+                                const usedNet = this.scope.getNet(tmpComponent, 1);
+                                if (usedNet) {
+                                    const trailerValue = trailers.join(".");
+                                    useValue = usedNet.params.get(trailerValue) ?? null;
+                                }
+                            }
+                            else {
+                                useValue = parentValue.parameters.get(trailersPath);
+                            }
                         }
                     }
                     return new DeclaredReference({
@@ -618,9 +641,7 @@ export class ExecutionContext {
     }
     mergeScope(childScope, namespace) {
         this.log('-- merging scope to parent --');
-        const currentComponent = this.scope.currentComponent;
-        const currentPin = this.scope.currentPin;
-        const currentWireId = this.scope.currentWireId;
+        const { currentComponent, currentPin, currentWireId } = this.scope;
         const tmpInstances = childScope.instances;
         const tmpNets = childScope.getNets();
         for (const [instanceName, component] of tmpInstances) {

package/dist/esm/globals.js

@@ -100,6 +100,12 @@ export var BlockTypes;
     BlockTypes[BlockTypes["Parallel"] = 3] = "Parallel";
     BlockTypes[BlockTypes["Point"] = 4] = "Point";
 })(BlockTypes || (BlockTypes = {}));
+export var NetGraphicsParams;
+(function (NetGraphicsParams) {
+    NetGraphicsParams["Color"] = "color";
+    NetGraphicsParams["Highight"] = "highlight";
+    NetGraphicsParams["LineWidth"] = "lineWidth";
+})(NetGraphicsParams || (NetGraphicsParams = {}));
 export var FrameType;
 (function (FrameType) {
     FrameType[FrameType["Frame"] = 1] = "Frame";

package/dist/esm/layout.js

@@ -2,7 +2,7 @@ import graphlib, { Graph } from '@dagrejs/graphlib';
 const { alg } = graphlib;
 import { SymbolCustom, SymbolDrawing, SymbolCustomModule, SymbolPlaceholder, SymbolText, PlaceHolderCommands } from "./draw_symbols.js";
 import { FrameAction, SequenceAction } from "./objects/ExecutionScope.js";
-import { ComponentTypes, defaultFrameTitleTextSize, defaultGridSizeUnits, FrameType, ParamKeys, WireAutoDirection } from './globals.js';
+import { ComponentTypes, defaultFrameTitleTextSize, defaultGridSizeUnits, FrameType, NetGraphicsParams, ParamKeys, WireAutoDirection } from './globals.js';
 import { Geometry, HorizontalAlign, VerticalAlign } from './geometry.js';
 import { Logger } from './logger.js';
 import { FixedFrameIds, Frame, FrameParamKeys, FramePlotDirection } from './objects/Frame.js';
@@ -31,6 +31,7 @@ export class LayoutEngine {
     }
     runLayout(sequence, nets) {
         const logNodesAndEdges = true;
+        const renderNets = this.collectRenderNets(nets);
         this.print('===== creating graph and populating with nodes =====');
         const { graph, containerFrames } = this.generateLayoutGraph(sequence, nets);
         this.print('===== done populating graph =====');
@@ -83,7 +84,7 @@ export class LayoutEngine {
                 }
                 wireGroups.get(netName).push(wire);
             });
-            const { junctions, mergedWires } = this.findJunctions(wireGroups);
+            const { junctions, mergedWires } = this.findJunctions(wireGroups, renderNets);
             return {
                 frame: sheet,
                 frames,
@@ -91,11 +92,33 @@ export class LayoutEngine {
                 wires,
                 textObjects,
                 junctions,
-                mergedWires,
+                mergedWires
             };
         });
         return sheetFrameObjects;
     }
+    collectRenderNets(nets) {
+        const renderNets = new Map();
+        const uniqueNets = new Set(nets.map(([, , net]) => net));
+        uniqueNets.forEach(net => {
+            const renderNet = {
+                netName: net.toString(),
+                net,
+            };
+            if (net.params.has(NetGraphicsParams.Color)) {
+                renderNet.color = net.params.get(NetGraphicsParams.Color);
+            }
+            if (net.params.has(NetGraphicsParams.LineWidth)) {
+                const value = net.params.get(NetGraphicsParams.LineWidth);
+                renderNet.lineWidth = milsToMM(value).toNumber();
+            }
+            if (net.params.has(NetGraphicsParams.Highight)) {
+                renderNet.highlight = net.params.get(NetGraphicsParams.Highight);
+            }
+            renderNets.set(net.toString(), renderNet);
+        });
+        return renderNets;
+    }
     flattenFrameItems(frame) {
         const items = [];
         frame.innerItems.forEach(item => {
@@ -107,11 +130,11 @@ export class LayoutEngine {
         });
         return items;
     }
-    findJunctions(wireGroups) {
+    findJunctions(wireGroups, nets) {
         const junctions = [];
         const mergedWires = [];
         const debugSegments = false;
-        for (const [key, wires] of wireGroups) {
+        for (const [netName, wires] of wireGroups) {
             const allLines = wires.map(wire => {
                 return wire.points.map(pt => {
                     return {
@@ -120,6 +143,10 @@ export class LayoutEngine {
                     };
                 });
             });
+            let renderNet = null;
+            if (nets.has(netName)) {
+                renderNet = nets.get(netName);
+            }
             if (debugSegments) {
                 const tmpSegments = [];
                 allLines.forEach(wire => {
@@ -133,20 +160,22 @@ export class LayoutEngine {
                     }
                 });
                 mergedWires.push({
-                    netName: key,
+                    netName: netName,
                     segments: tmpSegments,
                     intersectPoints: [],
+                    net: renderNet,
                 });
             }
             else {
                 const { intersectPoints, segments } = Geometry.mergeWires(allLines);
                 mergedWires.push({
-                    netName: key,
+                    netName: netName,
                     segments,
                     intersectPoints,
+                    net: renderNet,
                 });
                 intersectPoints.forEach(([x, y]) => {
-                    junctions.push(new RenderJunction(numeric(x), numeric(y)));
+                    junctions.push(new RenderJunction(numeric(x), numeric(y), renderNet));
                 });
             }
         }
@@ -657,22 +686,25 @@ export class LayoutEngine {
                 }
                 case SequenceAction.Wire: {
                     const [, wireId, wireSegments] = sequenceStep;
-                    const wire = new RenderWire(numeric(0), numeric(0), wireSegments);
-                    wire.id = wireId;
-                    let useNetName = null;
+                    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;
+                                return comp.instanceName === previousNode
+                                    && pin === previousPin;
                             });
-                            useNetName = matchingItem !== undefined ? matchingItem[2].name : null;
+                            if (matchingItem !== undefined) {
+                                useNet = matchingItem[2];
+                            }
                         }
                         else if (prevNodeType === RenderItemType.Wire) {
-                            useNetName = prevNodeItem.netName;
+                            useNet = prevNodeItem.net;
                         }
                     }
-                    wire.netName = useNetName;
+                    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));
@@ -1188,8 +1220,10 @@ export class RenderWire extends RenderObject {
     segments = [];
     points = [];
     netName;
-    constructor(x, y, segments) {
+    net;
+    constructor(net, x, y, segments) {
         super();
+        this.net = net;
         this.x = x;
         this.y = y;
         this.segments = segments;
@@ -1428,9 +1462,11 @@ export var RenderFrameType;
 export class RenderJunction {
     x;
     y;
-    constructor(x, y) {
+    net;
+    constructor(x, y, net) {
         this.x = x;
         this.y = y;
+        this.net = net;
     }
 }
 export function CalculatePinPositions(component) {

package/dist/esm/objects/ExecutionScope.js

@@ -103,6 +103,9 @@ export class ExecutionScope {
             console.log(netName.padEnd(10), '=>', instanceName, pin);
         });
     }
+    setVariable(name, value) {
+        this.variables.set(name, value);
+    }
     setActive(type, item) {
         this.clearActive();
         if (type === ActiveObject.Wire) {

package/dist/esm/objects/Net.js

@@ -4,6 +4,7 @@ export class Net {
     namespace;
     priority;
     type;
+    params = new Map();
     constructor(namespace, name, priority = 0, type = null) {
         if (namespace.indexOf(' ') !== -1) {
             throw "Invalid net namespace provided";

package/dist/esm/objects/ParamDefinition.js

@@ -1,4 +1,4 @@
-import { getNumberExponential, getNumberExponentialText, resolveToNumericValue } from "../utils.js";
+import { getNumberExponential, getNumberExponentialText, isReference, resolveToNumericValue } from "../utils.js";
 import { Big } from 'big.js';
 export class ParamDefinition {
     paramName;
@@ -121,6 +121,9 @@ export class NumberOperator {
         if (typeof value === 'number') {
             return new WrappedNumber(value);
         }
+        else if (isReference(value)) {
+            return value.value;
+        }
         else {
             return value;
         }

package/dist/esm/objects/types.js

@@ -1,3 +1,23 @@
+import { RuntimeExecutionError } from '../utils.js';
+export class AnyReference {
+    found = false;
+    name;
+    trailers = [];
+    type;
+    value;
+    parentValue;
+    constructor(refType) {
+        if (refType.value instanceof AnyReference) {
+            throw new RuntimeExecutionError("Nested reference types!");
+        }
+        this.found = refType.found;
+        this.name = refType.name;
+        this.trailers = refType.trailers;
+        this.type = refType.type;
+        this.value = refType.value;
+        this.parentValue = refType.parentValue;
+    }
+}
 export class UndeclaredReference {
     reference;
     constructor(reference) {
@@ -18,21 +38,7 @@ export class UndeclaredReference {
         return name + extra;
     }
 }
-export class DeclaredReference {
-    found;
-    name;
-    trailers;
-    type;
-    value;
-    parentValue;
-    constructor(refType) {
-        this.found = refType.found;
-        this.name = refType.name;
-        this.trailers = refType.trailers;
-        this.type = refType.type;
-        this.value = refType.value;
-        this.parentValue = refType.parentValue;
-    }
+export class DeclaredReference extends AnyReference {
     toString() {
         return `[DeclaredReference name: ${this.name} trailers:${this.trailers} found: ${this.found}]`;
     }

package/dist/esm/render.js

@@ -1,7 +1,7 @@
 import { SVG, registerWindow } from '@svgdotjs/svg.js';
 import { ExtractDrawingRects, RenderFrameType, getBounds } from "./layout.js";
 import { applyFontsToSVG } from './sizing.js';
-import { ColorScheme, ComponentTypes, FrameType, MMToPt, MMToPx, ParamKeys, RenderFlags, defaultGridSizeUnits, defaultPageSpacingMM, defaultWireLineWidth, fontDisplayScale, junctionSize } from './globals.js';
+import { ColorScheme, ComponentTypes, FrameType, MMToPt, MMToPx, MilsToMM, ParamKeys, RenderFlags, defaultGridSizeUnits, defaultPageSpacingMM, defaultWireLineWidth, fontDisplayScale, junctionSize } from './globals.js';
 import { numeric, NumericValue } from './objects/ParamDefinition.js';
 import { combineMaps, getBoundsSize } from './utils.js';
 import { getPaperSize, milsToMM } from './helpers.js';
@@ -169,28 +169,70 @@ function generateSVGChild(canvas, components, wires, junctions, mergedWires, fra
                 .translate(wire.x.add(5).toNumber(), wire.y.add(5).toNumber());
         });
     }
+    const mergedWireHighlightGroup = canvas.group();
     const mergedWireGroup = canvas.group();
     mergedWires.forEach(tmpItem => {
-        const { segments, intersectPoints } = tmpItem;
+        const { segments, intersectPoints, net = null } = tmpItem;
+        let useJunctionColor = ColorScheme.JunctionColor;
+        let useColor = ColorScheme.WireColor;
+        let useLineWidth = defaultWireLineWidth;
+        let displayHighlight = false;
+        let displayHighlightColor = null;
+        if (net !== null) {
+            useColor = net.color ?? ColorScheme.WireColor;
+            useJunctionColor = net.color ?? ColorScheme.JunctionColor;
+            useLineWidth = net.lineWidth ?? defaultWireLineWidth;
+            if (net.highlight !== null) {
+                displayHighlight = true;
+                displayHighlightColor = net.highlight ?? null;
+            }
+        }
+        const pathItems = [];
+        const highlightExtraSize = 5 * MilsToMM;
         segments.forEach(segment => {
             const pt1 = segment[0];
             const pt2 = segment[1];
-            mergedWireGroup.line([pt1, pt2])
+            pathItems.push(...[
+                'M', pt1[0], pt1[1],
+                'L', pt2[0], pt2[1]
+            ]);
+        });
+        if (displayHighlight) {
+            mergedWireHighlightGroup.path(pathItems)
                 .stroke({
-                width: defaultWireLineWidth,
-                color: ColorScheme.WireColor,
+                width: useLineWidth + highlightExtraSize,
+                color: displayHighlightColor,
+                opacity: 0.3,
                 linecap: 'square'
             })
                 .fill('none');
-        });
+        }
+        mergedWireGroup.path(pathItems)
+            .stroke({
+            width: useLineWidth,
+            color: useColor,
+            linecap: 'square'
+        })
+            .fill('none');
         const halfJunctionSize = junctionSize.half();
+        const highlightJunctionSize = numeric(junctionSize.toNumber() + highlightExtraSize);
+        const tmpHighlightExtraSize = highlightJunctionSize.half();
         intersectPoints.forEach(point => {
             const [x, y,] = point;
             const translateX = numeric(x).sub(halfJunctionSize);
             const translateY = numeric(y).sub(halfJunctionSize);
+            if (displayHighlight && displayHighlightColor !== null) {
+                const tmpTranslateX = numeric(x).sub(tmpHighlightExtraSize);
+                const tmpTranslateY = numeric(y).sub(tmpHighlightExtraSize);
+                mergedWireHighlightGroup.circle(highlightJunctionSize.toNumber())
+                    .translate(tmpTranslateX.toNumber(), tmpTranslateY.toNumber())
+                    .fill(displayHighlightColor)
+                    .opacity(0.3)
+                    .stroke('none');
+            }
             mergedWireGroup.circle(junctionSize.toNumber())
                 .translate(translateX.toNumber(), translateY.toNumber())
-                .fill(ColorScheme.JunctionColor)
+                .fill(useJunctionColor)
                 .stroke('none');
         });
     });

package/dist/esm/utils.js

@@ -4,6 +4,7 @@ import { ClassComponent } from "./objects/ClassComponent.js";
 import { NumericValue } from "./objects/ParamDefinition.js";
 import { SequenceAction } from './objects/ExecutionScope.js';
 import { BlockTypes } from './globals.js';
+import { DeclaredReference, AnyReference } from './objects/types.js';
 export class SimpleStopwatch {
     startTime;
     constructor() {
@@ -325,3 +326,15 @@ export function printWarnings(warnings) {
         console.log(`Warning: ${message}`);
     });
 }
+export function prepareValue(value) {
+    if (isReference(value)) {
+        return value.value;
+    }
+    else {
+        return value;
+    }
+}
+export function isReference(value) {
+    return (value instanceof AnyReference ||
+        value instanceof DeclaredReference);
+}