circuitscript 0.1.11 → 0.1.13

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;
@@ -23,8 +25,6 @@ export class CircuitScriptVisitor extends AbstractParseTreeVisitor {
     visitAt_block_pin_expr;
     visitAt_block_pin_expression_simple;
     visitAt_block_pin_expression_complex;
-    visitBreak_keyword;
-    visitContinue_keyword;
     visitAssignment_expr;
     visitOperator_assignment_expr;
     visitKeyword_assignment_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 { unwrapValue, resolveToNumericValue, RuntimeExecutionError } from "./utils.js";
 const builtInMethods = [
     ['enumerate', enumerate],
     ['toMils', toMils],
@@ -15,7 +15,9 @@ 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 => {
+            return toString(unwrapValue(item));
+        });
         if (visitor.printToConsole) {
             console.log('::', ...items);
         }
@@ -75,6 +77,7 @@ function toMils(value) {
     return resolveToNumericValue(bigValue);
 }
 function objectLength(obj) {
+    obj = unwrapValue(obj);
     if (Array.isArray(obj)) {
         return numeric(obj.length);
     }
@@ -105,6 +108,9 @@ function arrayGet(arrayObject, index) {
     else {
         useValue = index;
     }
+    if (isNaN(useValue)) {
+        throw new RuntimeExecutionError("Invalid index for arrayGet");
+    }
     return arrayObject[useValue];
 }
 function arraySet(arrayObject, index, setValue) {

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 { DeclaredReference, Direction } from './objects/types.js';
+import { AnyReference, DeclaredReference, Direction } from './objects/types.js';
 import { Wire } from './objects/Wire.js';
 import { Frame } from './objects/Frame.js';
 import { CalculatePinPositions } from './layout.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,29 +557,23 @@ 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;
-                    let parentValue = undefined;
-                    let useValue = scopeList.get(idName);
-                    if (trailers.length > 0) {
-                        parentValue = useValue;
-                        const trailersPath = trailers.join(".");
-                        if (isVariable) {
-                            useValue = parentValue[trailersPath];
-                        }
-                        else if (isComponentInstance) {
-                            useValue = parentValue.parameters.get(trailersPath);
-                        }
+                    const useValue = scopeList.get(idName);
+                    if (!isComponentInstance && (useValue instanceof ClassComponent)) {
+                        isComponentInstance = true;
+                        isVariable = false;
                     }
+                    const tmpReference = this.resolveTrailers(isVariable ? ReferenceTypes.variable : ReferenceTypes.instance, useValue, trailers);
                     return new DeclaredReference({
                         type: isVariable ? ReferenceTypes.variable
                             : ReferenceTypes.instance,
-                        found: (useValue !== undefined),
-                        parentValue,
-                        value: useValue,
+                        found: (tmpReference.value !== undefined),
+                        parentValue: tmpReference.parentValue,
+                        value: tmpReference.value,
                         name: idName,
                         trailers,
                     });
@@ -582,6 +585,37 @@ export class ExecutionContext {
             name: idName,
         });
     }
+    resolveTrailers(type, item, trailers = []) {
+        let parentValue;
+        let useValue = item;
+        if (trailers.length > 0) {
+            parentValue = useValue;
+            const trailersPath = trailers.join(".");
+            if (type === ReferenceTypes.variable) {
+                useValue = parentValue[trailersPath];
+            }
+            else if (type === ReferenceTypes.instance) {
+                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 AnyReference({
+            found: true,
+            type: type,
+            parentValue,
+            trailers,
+            value: useValue,
+        });
+    }
     callFunction(functionName, functionParams, executionStack, netNamespace) {
         let __runFunc = null;
         if (this.__functionCache[functionName] === undefined) {
@@ -618,9 +652,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/helpers.js

@@ -184,14 +184,6 @@ export async function renderScript(scriptData, outputPath, options) {
     };
     visitor.log('reading file');
     visitor.log('done reading file');
-    const { tree, parser, parserTimeTaken, lexerTimeTaken } = await parseFileWithVisitor(visitor, scriptData);
-    printWarnings(visitor.getWarnings());
-    showStats && console.log('Lexing took:', lexerTimeTaken);
-    showStats && console.log('Parsing took:', parserTimeTaken);
-    if (dumpNets) {
-        const nets = visitor.dumpNets();
-        nets.forEach(item => console.log(item.join(" | ")));
-    }
     const dumpDirectory = environment.getRelativeToModule('/dump/');
     if (dumpData) {
         console.log('Dump data to:', dumpDirectory);
@@ -199,8 +191,19 @@ export async function renderScript(scriptData, outputPath, options) {
             mkdirSync(dumpDirectory);
         }
     }
+    const { tree, parser, parserTimeTaken, lexerTimeTaken, throwError } = await parseFileWithVisitor(visitor, scriptData);
+    printWarnings(visitor.getWarnings());
+    showStats && console.log('Lexing took:', lexerTimeTaken);
+    showStats && console.log('Parsing took:', parserTimeTaken);
+    if (dumpNets) {
+        const nets = visitor.dumpNets();
+        nets.forEach(item => console.log(item.join(" | ")));
+    }
     dumpData && writeFileSync(dumpDirectory + 'tree.lisp', tree.toStringTree(null, parser));
     dumpData && writeFileSync(dumpDirectory + 'raw-parser.txt', visitor.logger.dump());
+    if (throwError) {
+        throw throwError;
+    }
     let svgOutput = "";
     if (errors.length === 0) {
         const { frameComponent } = visitor.applySheetFrameComponent();

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/parser.js

@@ -18,6 +18,7 @@ export async function parseFileWithVisitor(visitor, data) {
     parser.removeErrorListeners();
     parser.addErrorListener(parserErrorListener);
     const tree = parser.script();
+    let throwError;
     try {
         await visitor.visitAsync(tree);
     }
@@ -27,7 +28,7 @@ export async function parseFileWithVisitor(visitor, data) {
                 visitor.onErrorHandler(error.message, null, error);
             }
             else {
-                throw error;
+                throwError = error;
             }
         }
     }
@@ -38,6 +39,7 @@ export async function parseFileWithVisitor(visitor, data) {
         hasError: false,
         parserTimeTaken,
         lexerTimeTaken,
+        throwError
     };
 }
 export class CircuitscriptParserErrorListener {