circuitscript 0.0.17 → 0.0.19

package/build/src/antlr/CircuitScriptVisitor.js

@@ -2,8 +2,8 @@ import { ParseTreeVisitor } from 'antlr4';
 export default class CircuitScriptVisitor extends ParseTreeVisitor {
     visitScript;
     visitExpression;
-    visitBranch_blocks;
-    visitBranch_block_inner;
+    visitPath_blocks;
+    visitPath_block_inner;
     visitProperty_set_expr2;
     visitAssignment_expr2;
     visitData_expr_with_assignment;

package/build/src/draw_symbols.js

@@ -53,10 +53,13 @@ export class SymbolGraphic {
     }
     pinPosition(id) {
         const pin = this.drawing.getPinPosition(id);
+        const [x, y] = pin.start;
+        const useX = Math.round(x * 10000) / 10000;
+        const useY = Math.round(y * 10000 / 10000);
         if (pin) {
             return {
-                x: pin.start[0],
-                y: pin.start[1],
+                x: useX,
+                y: useY,
                 angle: pin.angle,
             };
         }

package/build/src/execute.js

@@ -1,4 +1,4 @@
-import { ComponentTypes, GlobalNames, ParamKeys, ReferenceTypes } from './globals.js';
+import { BlockTypes, ComponentTypes, GlobalNames, NoNetText, ParamKeys, ReferenceTypes } from './globals.js';
 import { ClassComponent } from './objects/ClassComponent.js';
 import { ActiveObject, ExecutionScope, FrameAction, SequenceAction } from './objects/ExecutionScope.js';
 import { Net } from './objects/Net.js';
@@ -11,6 +11,7 @@ export class ExecutionContext {
     netNamespace;
     executionLevel;
     scope;
+    tmpPointId = 0;
     resolveNet = null;
     stopFurtherExpressions = false;
     returnValue = null;
@@ -180,11 +181,17 @@ export class ExecutionContext {
         this.print('add symbol', instanceName, '[' + pinsOutput.join(', ') + ']');
         return component;
     }
-    printPoint() {
-        this.print('point: ' +
+    printPoint(extra = '') {
+        let netName = 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);
+            this.scope.currentPin + ' ' + netName);
     }
     addComponentExisting(component, pin) {
         const startPin = pin;
@@ -298,85 +305,135 @@ export class ExecutionContext {
         this.print('created clone of net component:', cloneInstanceName);
         return clonedComponent;
     }
-    enterBranches() {
-        this.scope.branchStack.set(this.scope.indentLevel, {
-            entered_at: [this.scope.currentComponent, this.scope.currentPin, this.scope.currentWireId],
-            inner_branches: new Map(),
+    enterBlocks(blockType) {
+        if (blockType === BlockTypes.Point) {
+            this.addPoint(`_point.${this.name}.${this.tmpPointId}`, false);
+            this.tmpPointId += 1;
+        }
+        else if (blockType === 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 branches');
-    }
-    exitBranches() {
-        false && this.joinBranches();
-        this.print('exit branches');
-    }
-    joinBranches() {
-        const innerBranches = this.scope.branchStack.get(this.scope.indentLevel)['inner_branches'];
-        const lastNets = [];
-        for (const [key, value] of innerBranches) {
-            if (value['ignore_last_net'] === false) {
-                const [component, pin] = value['last_net'];
-                let netPriority = 0;
-                if (this.scope.hasNet(component, pin)) {
-                    netPriority = this.scope.getNet(component, pin).priority;
-                }
-                lastNets.push([netPriority, value['last_net']]);
-            }
-        }
-        if (lastNets.length > 0) {
-            const sortedNets = lastNets.sort((a, b) => {
-                if (a[0] > b[0]) {
-                    return -1;
-                }
-                else if (a[0] < b[0]) {
-                    return 1;
-                }
-                else {
-                    return 0;
-                }
-            });
-            const [comp1, pin1] = sortedNets[0][1];
-            const tmpList = sortedNets.slice(1);
-            tmpList.forEach((item) => {
-                const [, [comp2, pin2]] = item;
-                this.atComponent(comp1, pin1, { addSequence: true });
-                this.toComponent(comp2, pin2, { addSequence: true });
-            });
-            this.scope.currentComponent = comp1;
-            this.scope.currentPin = pin1;
-        }
-    }
-    enterBranch(branchIndex) {
-        this.print('enter inner branch >>>');
-        const stackRef = this.scope.branchStack.get(this.scope.indentLevel);
-        stackRef['branch_index'] = branchIndex;
-        stackRef['inner_branches'].set(branchIndex, {
+        this.print('enter blocks');
+    }
+    exitBlocks() {
+        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 [component, pin, wireId] = finalPoint;
+            this.scope.currentComponent = component;
+            this.scope.currentPin = pin;
+            this.scope.currentWireId = wireId;
+            if (wireId !== -1) {
+                this.scope.sequence.push([
+                    SequenceAction.WireJump, wireId, 1
+                ]);
+            }
+        }
+        else if (blockType === 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 === BlockTypes.Join || blockType === BlockTypes.Point) {
+            this.scope.currentComponent = null;
+            this.scope.currentPin = null;
+            this.scope.currentWireId = -1;
+        }
+        else if (blockType === 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;
     }
-    exitBranch(branchIndex) {
-        const stackRef = this.scope.branchStack.get(this.scope.indentLevel - 1);
-        const branchIndexRef = stackRef['inner_branches'].get(branchIndex);
-        branchIndexRef['last_net'] = [
+    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['branch_index'] = null;
-        const [preBranchComponent, preBranchPin, preBranchWireId] = stackRef['entered_at'];
+        stackRef['block_index'] = null;
         this.scope.indentLevel -= 1;
-        this.print('exit inner branch <<<');
-        this.atComponent(preBranchComponent, preBranchPin, { addSequence: true });
-        if (preBranchWireId !== -1) {
-            this.scope.sequence.push([SequenceAction.WireJump, preBranchWireId]);
+        this.print('exit inner block <<<');
+        if (blockType === BlockTypes.Branch) {
+            const { entered_at: [component, pin, wireId] } = stackRef;
+            this.atComponent(component, pin, { addSequence: true });
+            if (wireId !== -1) {
+                this.scope.sequence.push([SequenceAction.WireJump, wireId, 1]);
+            }
+        }
+        else if (blockType === BlockTypes.Join || blockType === BlockTypes.Parallel) {
+            if (blockIndex === 0) {
+                const pointIdName = (blockType === 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.branchStack.get(this.scope.indentLevel - 1);
-        const branchIndex = branchesInfo['branch_index'];
-        const branchIndexRef = branchesInfo['inner_branches'].get(branchIndex);
+        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) {
@@ -508,7 +565,7 @@ export class ExecutionContext {
             }
             else if (action === SequenceAction.WireJump) {
                 const jumpWireId = wireIdOffset + sequenceAction[1];
-                this.scope.sequence.push([SequenceAction.WireJump, jumpWireId]);
+                this.scope.sequence.push([SequenceAction.WireJump, jumpWireId, 1]);
             }
             else if (action === SequenceAction.At || action === SequenceAction.To) {
                 const tmpComponent = sequenceAction[1];
@@ -536,8 +593,17 @@ export class ExecutionContext {
                 this.scope.sequence.push(sequenceAction);
             }
         });
-        this.scope.currentComponent = currentComponent;
-        this.scope.currentPin = currentPin;
+        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]) => {
@@ -568,11 +634,12 @@ export class ExecutionContext {
         this.scope.sequence.push([SequenceAction.Wire, wireId, tmp]);
         this.scope.currentComponent.pinWires.set(this.scope.currentPin, tmp);
     }
-    addPoint(pointId) {
+    addPoint(pointId, userDefined = true) {
         if (this.scope.instances.has(pointId)) {
             this.print('Warning: ' + pointId + ' is being redefined');
         }
-        const componentPoint = ClassComponent.simple("point." + pointId, 1, "point");
+        const useName = userDefined ? 'point.' + pointId : pointId;
+        const componentPoint = ClassComponent.simple(useName, 1, "point");
         componentPoint.displayProp = "point";
         componentPoint.typeProp = ComponentTypes.point;
         this.scope.instances.set(pointId, componentPoint);

package/build/src/export.js

@@ -1,4 +1,4 @@
-import { ComponentTypes } from "./globals.js";
+import { ComponentTypes, NoNetText } from "./globals.js";
 import { NumericValue } from "./objects/ParamDefinition.js";
 export function generateKiCADNetList(netlist) {
     const componentsList = [];
@@ -28,7 +28,7 @@ export function generateKiCADNetList(netlist) {
             for (const key in pins) {
                 const netInfo = pins[key];
                 const netName = netInfo.netName;
-                if (netName === 'NO_NET') {
+                if (netName === NoNetText) {
                     continue;
                 }
                 if (nets[netName] === undefined) {

package/build/src/globals.js

@@ -7,6 +7,7 @@ export var GlobalNames;
     GlobalNames["DefaultInductor"] = "ind";
     GlobalNames["symbol"] = "symbol";
 })(GlobalNames || (GlobalNames = {}));
+export const NoNetText = 'NO_NET';
 export var ParamKeys;
 (function (ParamKeys) {
     ParamKeys["__is_net"] = "__is_net";
@@ -47,3 +48,10 @@ export var ReferenceTypes;
     ReferenceTypes["variable"] = "variable";
     ReferenceTypes["instance"] = "instance";
 })(ReferenceTypes || (ReferenceTypes = {}));
+export var BlockTypes;
+(function (BlockTypes) {
+    BlockTypes[BlockTypes["Branch"] = 1] = "Branch";
+    BlockTypes[BlockTypes["Join"] = 2] = "Join";
+    BlockTypes[BlockTypes["Parallel"] = 3] = "Parallel";
+    BlockTypes[BlockTypes["Point"] = 4] = "Point";
+})(BlockTypes || (BlockTypes = {}));

package/build/src/layout.js

@@ -79,6 +79,17 @@ export class LayoutEngine {
             }
             wireGroups.get(netName).push(wire);
         });
+        const { junctions, mergedWires } = this.findJunctions(wireGroups);
+        return {
+            components: placedComponents,
+            wires: placedWires,
+            mergedWires,
+            junctions,
+            frameObjects,
+            textObjects,
+        };
+    }
+    findJunctions(wireGroups) {
         const junctions = [];
         const mergedWires = [];
         for (const [key, wires] of wireGroups) {
@@ -101,12 +112,8 @@ export class LayoutEngine {
             });
         }
         return {
-            components: placedComponents,
-            wires: placedWires,
-            mergedWires,
             junctions,
-            frameObjects,
-            textObjects,
+            mergedWires
         };
     }
     placeFrames(graph, subgraphInfo, frameObjects) {
@@ -402,7 +409,7 @@ export class LayoutEngine {
                     currentFrame && currentFrame.innerItems.push(tmpComponent);
                 }
                 if (action === SequenceAction.To) {
-                    graph.setEdge(previousNode, tmpInstanceName, makeEdgeValue(previousNode, previousPin, tmpInstanceName, pin, i));
+                    this.setGraphEdge(graph, previousNode, tmpInstanceName, makeEdgeValue(previousNode, previousPin, tmpInstanceName, pin, i));
                 }
                 previousNode = tmpInstanceName;
                 previousPin = pin;
@@ -427,7 +434,7 @@ export class LayoutEngine {
                 wire.netName = useNetName;
                 const wireName = getWireName(wire.id);
                 graph.setNode(wireName, [RenderItemType.Wire, wire, i]);
-                graph.setEdge(previousNode, wireName, makeEdgeValue(previousNode, previousPin, wireName, 0, i));
+                this.setGraphEdge(graph, previousNode, wireName, makeEdgeValue(previousNode, previousPin, wireName, 0, i));
                 previousNode = wireName;
                 previousPin = 1;
                 const wireSegmentsInfo = wireSegments.map(item => {
@@ -447,9 +454,14 @@ export class LayoutEngine {
             }
             else if (action === SequenceAction.WireJump) {
                 this.print(...sequence[i]);
-                const [, wireId] = sequence[i];
-                previousNode = getWireName(wireId);
-                previousPin = 1;
+                const wireId = sequence[i][1];
+                const wireName = getWireName(wireId);
+                let wirePin = 1;
+                if (sequence[i].length === 3) {
+                    wirePin = sequence[i][2];
+                }
+                previousNode = wireName;
+                previousPin = wirePin;
             }
             else if (action === SequenceAction.Frame) {
                 const [, frameObject, frameAction] = sequence[i];
@@ -482,6 +494,9 @@ export class LayoutEngine {
             containerFrames,
         };
     }
+    setGraphEdge(graph, node1, node2, edgeValue) {
+        graph.setEdge(node1, node2, edgeValue);
+    }
     sizeSubGraphs(graph) {
         const subGraphs = graphlib.alg.components(graph);
         const subGraphsStarts = [];
@@ -613,9 +628,8 @@ export class LayoutEngine {
                     if (x1 !== x2 && y1 !== y2) {
                         if (node1 instanceof RenderWire &&
                             node2 instanceof RenderComponent) {
-                            this.layoutWarnings.push('component ' +
-                                node2.component.instanceName +
-                                ' may not be placed correctly');
+                            const refdes = node2.component.assignedRefDes;
+                            this.layoutWarnings.push(`component ${refdes} may not be placed correctly`);
                         }
                     }
                 }

package/build/src/objects/ExecutionScope.js

@@ -4,7 +4,7 @@ export class ExecutionScope {
     instances = new Map();
     functions = new Map();
     variables = new Map();
-    branchStack = new Map();
+    blockStack = new Map();
     wires = [];
     frames = [];
     indentLevel = 0;

package/build/src/visitor.js

@@ -8,7 +8,7 @@ import { PinDefinition, PinIdType } from './objects/PinDefinition.js';
 import { PinTypes } from './objects/PinTypes.js';
 import { UndeclaredReference } from './objects/types.js';
 import { Logger } from './logger.js';
-import { ComponentTypes } from './globals.js';
+import { BlockTypes, ComponentTypes, NoNetText } from './globals.js';
 import { SymbolDrawingCommands } from './draw_symbols.js';
 import { parseFileWithVisitor } from './parser.js';
 export class MainVisitor extends ParseTreeVisitor {
@@ -186,26 +186,36 @@ export class MainVisitor extends ParseTreeVisitor {
         return this.getExecutor().addComponentExisting(component, pinValue);
     }
     visitAt_component_expr(ctx) {
-        const [component, pin] = this.visit(ctx.component_select_expr());
-        const currentPoint = this.getExecutor().atComponent(component, pin, {
-            addSequence: true,
-            cloneNetComponent: true
-        });
-        if (ctx.ID()) {
-            this.setComponentOrientation(currentPoint[0], currentPoint[1], ctx.ID().getText());
+        if (ctx.Point()) {
+            this.getExecutor().atPointBlock();
         }
-        return currentPoint;
+        else {
+            const [component, pin] = this.visit(ctx.component_select_expr());
+            const currentPoint = this.getExecutor().atComponent(component, pin, {
+                addSequence: true,
+                cloneNetComponent: true
+            });
+            if (ctx.ID()) {
+                this.setComponentOrientation(currentPoint[0], currentPoint[1], ctx.ID().getText());
+            }
+        }
+        return this.getExecutor().getCurrentPoint();
     }
     visitTo_component_expr(ctx) {
         let currentPoint;
-        ctx.component_select_expr_list().forEach((item) => {
-            const [component, pin] = this.visit(item);
-            currentPoint = this.getExecutor().toComponent(component, pin, {
-                addSequence: true, cloneNetComponent: true
+        if (ctx.Point()) {
+            this.getExecutor().toPointBlock();
+        }
+        else {
+            ctx.component_select_expr_list().forEach((item) => {
+                const [component, pin] = this.visit(item);
+                currentPoint = this.getExecutor().toComponent(component, pin, {
+                    addSequence: true, cloneNetComponent: true
+                });
             });
-        });
-        if (ctx.ID()) {
-            this.setComponentOrientation(currentPoint[0], currentPoint[1], ctx.ID().getText());
+            if (ctx.ID()) {
+                this.setComponentOrientation(currentPoint[0], currentPoint[1], ctx.ID().getText());
+            }
         }
         return this.getExecutor().getCurrentPoint();
     }
@@ -222,15 +232,31 @@ export class MainVisitor extends ParseTreeVisitor {
             return [component, pinId];
         }
     }
-    visitBranch_blocks(ctx) {
-        this.getExecutor().enterBranches();
-        const branches = ctx.branch_block_inner_list();
-        branches.forEach((branch, index) => {
-            this.getExecutor().enterBranch(index);
+    visitPath_blocks(ctx) {
+        const blocks = ctx.path_block_inner_list();
+        let blockType = BlockTypes.Branch;
+        if (blocks.length > 0) {
+            const firstBlock = blocks[0];
+            if (firstBlock.Branch()) {
+                blockType = BlockTypes.Branch;
+            }
+            else if (firstBlock.Join()) {
+                blockType = BlockTypes.Join;
+            }
+            else if (firstBlock.Parallel()) {
+                blockType = BlockTypes.Parallel;
+            }
+            else if (firstBlock.Point()) {
+                blockType = BlockTypes.Point;
+            }
+        }
+        this.getExecutor().enterBlocks(blockType);
+        blocks.forEach((branch, index) => {
+            this.getExecutor().enterBlock(index);
             this.visit(branch);
-            this.getExecutor().exitBranch(index);
+            this.getExecutor().exitBlock(index);
         });
-        this.getExecutor().exitBranches();
+        this.getExecutor().exitBlocks();
         return this.getExecutor().getCurrentPoint();
     }
     visitBreak_keyword() {
@@ -945,8 +971,8 @@ export class MainVisitor extends ParseTreeVisitor {
     resolveNets(scope, instance) {
         const result = [];
         for (const [pinId, pin] of instance.pins) {
-            let netName = 'NO_NET';
-            let netBaseName = 'NO_NET';
+            let netName = NoNetText;
+            let netBaseName = NoNetText;
             if (scope.hasNet(instance, pinId)) {
                 const netObject = scope.getNet(instance, pinId);
                 netName = netObject.namespace + netObject.name;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "circuitscript",
-    "version": "0.0.17",
+    "version": "0.0.19",
     "description": "Interpreter for the circuitscript language",
     "homepage": "https://circuitscript.net",
     "engines": {

package/src/antlr/CircuitScript.g4

@@ -17,6 +17,8 @@ Add:        'add';
 At:         'at';
 To:         'to';
 Point:      'point';
+Join:       'join';
+Parallel:   'parallel';
 
 Return:     'return';
 Define:     'def';
@@ -46,18 +48,18 @@ expression: add_component_expr
         | break_keyword
         | function_def_expr
         | wire_expr
-        | point_expr
         | import_expr
         | frame_expr
         | atom_expr
         
         | at_block
-        | branch_blocks
+        | path_blocks
+        | point_expr
         ;
 
-branch_blocks: branch_block_inner+;
-branch_block_inner:
-	Branch ':' NEWLINE INDENT (NEWLINE | expression)+ DEDENT;
+path_blocks: path_block_inner+;
+path_block_inner:
+	(Branch | Join | Parallel | Point) ':' NEWLINE INDENT (NEWLINE | expression)+ DEDENT;
 
 property_set_expr2:
 	atom_expr ':' NEWLINE INDENT ( NEWLINE | assignment_expr2)+ DEDENT;
@@ -72,10 +74,10 @@ pin_select_expr:        Pin (INTEGER_VALUE | STRING_VALUE);
 // This does not have the 'pin' word
 pin_select_expr2: INTEGER_VALUE | STRING_VALUE;
 
-at_component_expr:      At component_select_expr ID?;
+at_component_expr:      At ((component_select_expr ID?) | Point);                           // ID? is for orientation
 // at_component_expr_next:   'at' component_select_expr (',' component_select_expr)*;
 
-to_component_expr: To component_select_expr (',' component_select_expr)* ID?;
+to_component_expr: To ((component_select_expr (',' component_select_expr)* ID?) | Point);   // ID? is for orientation
 // pin_select_expr_next:   'pin' INTEGER_VALUE (',' INTEGER_VALUE)?;
 
 at_to_multiple_expr: At component_select_expr To component_select_expr (',' component_select_expr)* ':' NEWLINE INDENT (NEWLINE | at_to_multiple_line_expr) + DEDENT;