circuitscript 0.0.17 → 0.0.19

package/src/antlr/CircuitScriptVisitor.ts

@@ -7,8 +7,8 @@ import {ParseTreeVisitor} from 'antlr4';
 
 import { ScriptContext } from "./CircuitScriptParser";
 import { ExpressionContext } from "./CircuitScriptParser";
-import { Branch_blocksContext } from "./CircuitScriptParser";
-import { Branch_block_innerContext } from "./CircuitScriptParser";
+import { Path_blocksContext } from "./CircuitScriptParser";
+import { Path_block_innerContext } from "./CircuitScriptParser";
 import { Property_set_expr2Context } from "./CircuitScriptParser";
 import { Assignment_expr2Context } from "./CircuitScriptParser";
 import { Data_expr_with_assignmentContext } from "./CircuitScriptParser";
@@ -82,17 +82,17 @@ export default class CircuitScriptVisitor<Result> extends ParseTreeVisitor<Resul
 	 */
 	visitExpression?: (ctx: ExpressionContext) => Result;
 	/**
-	 * Visit a parse tree produced by `CircuitScriptParser.branch_blocks`.
+	 * Visit a parse tree produced by `CircuitScriptParser.path_blocks`.
 	 * @param ctx the parse tree
 	 * @return the visitor result
 	 */
-	visitBranch_blocks?: (ctx: Branch_blocksContext) => Result;
+	visitPath_blocks?: (ctx: Path_blocksContext) => Result;
 	/**
-	 * Visit a parse tree produced by `CircuitScriptParser.branch_block_inner`.
+	 * Visit a parse tree produced by `CircuitScriptParser.path_block_inner`.
 	 * @param ctx the parse tree
 	 * @return the visitor result
 	 */
-	visitBranch_block_inner?: (ctx: Branch_block_innerContext) => Result;
+	visitPath_block_inner?: (ctx: Path_block_innerContext) => Result;
 	/**
 	 * Visit a parse tree produced by `CircuitScriptParser.property_set_expr2`.
 	 * @param ctx the parse tree

package/src/draw_symbols.ts

@@ -93,10 +93,15 @@ export abstract class SymbolGraphic {
     pinPosition(id: number): { x: number; y: number; angle: number; } {
         const pin = this.drawing.getPinPosition(id);
 
+        // Allow pin position values to be rounded to 4 d.p
+        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/src/execute.ts

@@ -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';
@@ -26,6 +26,8 @@ export class ExecutionContext {
 
     scope: ExecutionScope;
 
+    tmpPointId = 0;     // Counter for points created within the context
+
     resolveNet: (name: string, netNamespace:string) => ({
         found: boolean, net?: Net
     }) = null;
@@ -316,12 +318,22 @@ export class ExecutionContext {
         return component;
     }
 
-    printPoint(): void {
+    printPoint(extra = ''): void {
+        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(
-            'point: ' +
-                this.scope.currentComponent.instanceName +
-                ' ' +
-                this.scope.currentPin,
+            (extra !== '' ? (extra + ' ') : '') + 'point: ' +
+            this.scope.currentComponent.instanceName +
+            ' ' +
+            this.scope.currentPin + ' ' + netName
         );
     }
 
@@ -524,117 +536,183 @@ export class ExecutionContext {
         return clonedComponent;
     }
 
-    enterBranches(): void {
-        this.scope.branchStack.set(this.scope.indentLevel, {
-            // Tracks the position when the branch is entered
-            entered_at: [this.scope.currentComponent, this.scope.currentPin, this.scope.currentWireId],
-            inner_branches: new Map<number, any>(),
+    enterBlocks(blockType: BlockTypes): void {
+        // Create object to track all the inner blocks of 
+        // the block group
+
+        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, {
+            // Tracks the position when the block is entered
+            entered_at: [
+                this.scope.currentComponent,
+                this.scope.currentPin,
+                this.scope.currentWireId],
+            inner_blocks: new Map<number, any>(),
             current_index: null,
+            type: blockType,
         });
 
-        this.print('enter branches');
-    }
-
-    exitBranches(): void {
-        false && this.joinBranches();
-        
-        this.print('exit branches');
+        this.print('enter blocks');
     }
 
-    joinBranches(): void {
-        // When exiting/leaving a group of branches
-        const innerBranches = this.scope.branchStack.get(
+    exitBlocks(): void {
+        const stackRef = this.scope.blockStack.get(
             this.scope.indentLevel,
-        )['inner_branches'];
+        );
 
-        const lastNets: [number, [ClassComponent, number, Net]][] = [];
+        const { type: blockType } = stackRef;
 
-        // Gather all the last nets that should be joined together
-        for (const [key, value] of innerBranches) {
-            if (value['ignore_last_net'] === false) {
-                const [component, pin] = value['last_net'];
+        if (blockType === BlockTypes.Join || blockType === BlockTypes.Parallel) {
+            // Move to the end location of the first block
+            const { final_point: finalPoint } = stackRef;
+            const [component, pin, wireId] = finalPoint;
 
-                let netPriority = 0;
-                if (this.scope.hasNet(component, pin)) {
-                    netPriority = this.scope.getNet(component, pin).priority;
-                }
+            this.scope.currentComponent = component;
+            this.scope.currentPin = pin;
+            this.scope.currentWireId = wireId;
 
-                lastNets.push([netPriority, value['last_net']]);
+            if (wireId !== -1) {
+                this.scope.sequence.push([
+                    SequenceAction.WireJump, wireId, 1
+                ]);
             }
-        }
+        } else if (blockType === BlockTypes.Point) {
+            const { entered_at: [component, pin,] } =
+                stackRef;
 
-        if (lastNets.length > 0) {
-            // Items in the lastNets list might not have an actual net created/defined yet
-
-            // Sort the nets so that the net with the highest priority is first
-            const sortedNets = lastNets.sort((a, b) => {
-                if (a[0] > b[0]) {
-                    return -1;
-                } else if (a[0] < b[0]) {
-                    return 1;
-                } else {
-                    return 0;
-                }
-            });
-
-            // Not always a good idea to always use the first item for combining...
-            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;
+            // Preblock location should be a created point without any wires
+            this.atComponent(component, pin, { addSequence: true });
         }
-    }
 
-    enterBranch(branchIndex: number): void {
-        this.print('enter inner branch >>>');
+        this.print('exit blocks');
+    }
 
-        // Current net before any branching is already stored in enterBranches()
-        const stackRef = this.scope.branchStack.get(this.scope.indentLevel);
+    enterBlock(blockIndex: number): void {
+        // Current net before any blocks is already stored in enterBlocks()
+        const stackRef = this.scope.blockStack.get(this.scope.indentLevel);
+        stackRef['block_index'] = blockIndex;
 
-        stackRef['branch_index'] = branchIndex;
+        const { type: blockType } = stackRef;
 
-        // Setup the state for the inner branch at the given index
-        stackRef['inner_branches'].set(branchIndex, {
+        // Setup the state for the inner block at the given index
+        stackRef['inner_blocks'].set(blockIndex, {
             last_net: null,
             ignore_last_net: false,
         });
 
+        if (blockType === BlockTypes.Join || blockType === BlockTypes.Point) {
+            // Clear current component, pin, wire before entering the block
+            this.scope.currentComponent = null;
+            this.scope.currentPin = null;
+            this.scope.currentWireId = -1;
+        } else if (blockType === BlockTypes.Parallel) {
+            // Move to starting point of the parallel blocks
+            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: number): void {
-        const stackRef = this.scope.branchStack.get(this.scope.indentLevel - 1);
+    exitBlock(blockIndex: number): void {
+        const stackRef = this.scope.blockStack.get(this.scope.indentLevel - 1);
+        const { type: blockType } = stackRef;
 
         // Save the last net reference
-        const branchIndexRef = stackRef['inner_branches'].get(branchIndex);
-        branchIndexRef['last_net'] = [
+        const blockIndexRef = stackRef['inner_blocks'].get(blockIndex);
+        blockIndexRef['last_net'] = [
             this.scope.currentComponent,
             this.scope.currentPin,
+            this.scope.currentWireId
         ];
 
-        stackRef['branch_index'] = null;
+        stackRef['block_index'] = null;
+        this.scope.indentLevel -= 1;
 
-        // Restore the latest entry in the branch stack
-        const [preBranchComponent, preBranchPin, preBranchWireId] = stackRef['entered_at'];
+        this.print('exit inner block <<<');
 
-        this.scope.indentLevel -= 1;
+        if (blockType === BlockTypes.Branch) {
+
+            // Restore the latest entry in the branch stack
+            const { entered_at: [component, pin, wireId] } =
+                stackRef;
+
+            // Do not duplicate any net symbol since this is a branch
+            this.atComponent(component, pin, { addSequence: true });
+
+            if (wireId !== -1) {
+                // If previous node is a wire, then jump to END of wire
+                this.scope.sequence.push([SequenceAction.WireJump, wireId, 1]);
+            }
+        } else if (blockType === BlockTypes.Join || blockType === BlockTypes.Parallel) {
+            if (blockIndex === 0) {
+                // First join block will determine the final join location
+
+                const pointIdName = (blockType === BlockTypes.Join) ? '_join' : '_parallel';
+
+                // Add point to current location, start with _join keyword to
+                // indicate that this is a point for join keyword
+                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;
+
+                // Link the current component to the join component and join pin
+                this.toComponent(component, pin, { addSequence: true });
+            }
+        }
+    }
+
+    atPointBlock(): void {
+        const [component, pin,] = this.getPointBlockLocation();
+        this.atComponent(component, pin, {
+            addSequence: true
+        });
+    }
+
+    toPointBlock(): void {
+        // Point has been specifically created for block, wireId should be -1
+        const [component, pin,] = this.getPointBlockLocation();
+        this.toComponent(component, pin, {
+            addSequence: true
+        });
+    }
 
-        this.print('exit inner branch <<<');
+    getPointBlockLocation(): [component: ClassComponent, pin: number, wireId: number] {
+        // Returns the position at the nearest `point:` block, searches within
+        // previous block stacks
+        this.print('get block point');
 
-        // Do not duplicate any net symbol since this is a branch
-        this.atComponent(preBranchComponent, preBranchPin, {addSequence: true});
+        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: ClassComponent = entered_at[0];
 
-        if (preBranchWireId !== -1){
-            this.scope.sequence.push([SequenceAction.WireJump, preBranchWireId]);
+            if (component.instanceName.startsWith('_point.')) {
+                return entered_at;
+            }
         }
+
+        this.print('did not find block point');
+
+        return null;
     }
 
     breakBranch(): void {
@@ -642,12 +720,12 @@ export class ExecutionContext {
         // Mark that the branch stack at the current indent level
         // should be ignored
 
-        const branchesInfo = this.scope.branchStack.get(
+        const branchesInfo = this.scope.blockStack.get(
             this.scope.indentLevel - 1,
         );
-        const branchIndex = branchesInfo['branch_index'];
+        const branchIndex = branchesInfo['block_index'];
 
-        const branchIndexRef = branchesInfo['inner_branches'].get(branchIndex);
+        const branchIndexRef = branchesInfo['inner_blocks'].get(branchIndex);
         branchIndexRef['ignore_last_net'] = true;
     }
 
@@ -748,7 +826,7 @@ export class ExecutionContext {
                 { netNamespace });
 
             this.print(`done call function '${functionName}'`);
-
+            
             return functionResult;
         } else {
             throw `Invalid function '${functionName}'`;
@@ -855,7 +933,7 @@ export class ExecutionContext {
                 // Wire IDs in wire jumps need to be updated.
                 const jumpWireId = wireIdOffset + sequenceAction[1];
                 this.scope.sequence.push(
-                    [SequenceAction.WireJump, jumpWireId]
+                    [SequenceAction.WireJump, jumpWireId, 1]
                 );
             } else if (action === SequenceAction.At || action === SequenceAction.To) {
                 const tmpComponent: ClassComponent = sequenceAction[1];
@@ -895,9 +973,24 @@ export class ExecutionContext {
             }
         });
 
-        this.scope.currentComponent = currentComponent;
-        this.scope.currentPin = currentPin;
+        if (childScope.currentComponent === childScope.componentRoot) {
+            // If child scope is current at the root node, then use the 
+            // location in the parent scope as the current component 
+            // since that would be equivalent
+            this.scope.currentComponent = currentComponent;
+            this.scope.currentPin = currentPin;
+            this.scope.currentWireId = currentWireId;
 
+        } else {
+            // Otherwise move the current scope to the current node within 
+            // the child scope
+            this.scope.currentComponent = childScope.currentComponent;
+            this.scope.currentPin = childScope.currentPin;
+            this.scope.currentWireId = childScope.currentWireId + wireIdOffset;
+        }
+
+        this.printPoint('resume at');
+        
         this.print('-- nets --');
 
         // dump the list of nets in the current scope
@@ -947,17 +1040,18 @@ export class ExecutionContext {
         )
     }
 
-    addPoint(pointId: string): ComponentPin {
+    addPoint(pointId: string, userDefined = true): ComponentPin {
         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);
-        this.toComponent(componentPoint, 1, {addSequence: true});
+        this.toComponent(componentPoint, 1, { addSequence: true });
 
         return this.getCurrentPoint();
     }

package/src/export.ts

@@ -1,4 +1,4 @@
-import { ComponentTypes } from "./globals.js";
+import { ComponentTypes, NoNetText } from "./globals.js";
 import { NumericValue } from "./objects/ParamDefinition.js";
 import { NetListItem } from "./visitor.js";
 
@@ -39,7 +39,7 @@ export function generateKiCADNetList(netlist: NetListItem[]): string {
                 const netInfo = pins[key];
                 const netName = netInfo.netName;
 
-                if (netName === 'NO_NET'){
+                if (netName === NoNetText){
                     continue;
                 }
 

package/src/globals.ts

@@ -9,6 +9,7 @@ export enum GlobalNames {
     symbol = 'symbol',
 }
 
+export const NoNetText = 'NO_NET';
 
 export enum ParamKeys {
 
@@ -56,4 +57,11 @@ export enum ReferenceTypes {
     value = 'value',
     variable = 'variable',
     instance = 'instance',
+}
+
+export enum BlockTypes {
+    Branch = 1,     // split off circuit paths, same starting insertion point
+    Join = 2,       // join circuit paths, same ending insertion point
+    Parallel = 3,   // same starting and ending points for the circuit paths
+    Point = 4,      // to this point
 }

package/src/layout.ts

@@ -121,12 +121,29 @@ 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: Map<string, RenderWire[]>): {
+        junctions: RenderJunction[],
+        mergedWires: MergedWire[],
+    } {
         const junctions: RenderJunction[] = [];
-    
-        const mergedWires:MergedWire[] = [];
-    
+
+        const mergedWires: MergedWire[] = [];
+
         for (const [key, wires] of wireGroups) {
-    
+
             // Create array of all wires with the same net name
             const allLines = wires.map(wire => {
                 return wire.points.map(pt => {
@@ -136,28 +153,23 @@ export class LayoutEngine {
                     }
                 });
             });
-    
+
             const { intersectPoints, segments } = Geometry.mergeWires(allLines);
             mergedWires.push({
                 netName: key,
                 segments,
                 intersectPoints,
             });
-    
+
             intersectPoints.forEach(([x, y]) => {
                 junctions.push(new RenderJunction(x, y));
             });
         }
 
         return {
-            components: placedComponents,
-            wires: placedWires,
-            mergedWires,
             junctions,
-
-            frameObjects,
-            textObjects,
-        };
+            mergedWires
+        }
     }
 
     placeFrames(graph: graphlib.Graph, subgraphInfo: SubGraphInfo[],
@@ -635,7 +647,7 @@ export class LayoutEngine {
                 }
     
                 if (action === SequenceAction.To) {
-                    graph.setEdge(previousNode, tmpInstanceName,
+                    this.setGraphEdge(graph, previousNode, tmpInstanceName,
                         makeEdgeValue(previousNode, previousPin, tmpInstanceName, pin, i));
                 }
     
@@ -649,9 +661,8 @@ export class LayoutEngine {
 
                 const wire = new RenderWire(0, 0, wireSegments);
                 wire.id = wireId;
-    
                 let useNetName = null;
-    
+
                 if (previousNode !== null) {
                     const [prevNodeType, prevNodeItem] = graph.node(previousNode);
                     if (prevNodeType === RenderItemType.Component) {
@@ -674,9 +685,9 @@ export class LayoutEngine {
                 graph.setNode(wireName, [RenderItemType.Wire, wire, i]);
     
                 // Connect previous node to pin:0 of the wire
-                graph.setEdge(previousNode, wireName, 
+                this.setGraphEdge(graph, previousNode, wireName, 
                     makeEdgeValue(previousNode, previousPin, wireName, 0, i));
-    
+
                 previousNode = wireName;
                 previousPin = 1;
                 
@@ -707,10 +718,17 @@ export class LayoutEngine {
                 
             } else if (action === SequenceAction.WireJump) {
                 this.print(...sequence[i]);
-                const [, wireId] = sequence[i] as [SequenceAction.WireJump, number];
-                previousNode = getWireName(wireId);
-                previousPin = 1;
+                const wireId = sequence[i][1] as number;
+                const wireName = getWireName(wireId);
+
+                let wirePin = 1;
 
+                if (sequence[i].length === 3) {
+                    wirePin = sequence[i][2] as number;
+                }
+
+                previousNode = wireName;
+                previousPin = wirePin;              
             } else if (action === SequenceAction.Frame){
                 const [, frameObject, frameAction] = sequence[i];
 
@@ -754,6 +772,11 @@ export class LayoutEngine {
         }
     }
 
+    setGraphEdge(graph: graphlib.Graph, node1: string, node2: string,
+        edgeValue: EdgeValue): void {
+        graph.setEdge(node1, node2, edgeValue);
+    }
+
     sizeSubGraphs(graph: graphlib.Graph): SubGraphInfo[] {
         
         // Layouts out all nodes within a subgraph and determines the size
@@ -966,13 +989,11 @@ export class LayoutEngine {
                     const [x1, y1] = getNodePositionAtPin(node1, pin1);
                     const [x2, y2] = getNodePositionAtPin(node2, pin2);
                     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`);
                         }
                     }
                 }
@@ -1189,10 +1210,10 @@ export class LayoutEngine {
             item.y = fromY - pinPosition.y; 
 
         } else if (item instanceof RenderWire){
-            if (pin === 0){
+            if (pin === 0) { // Start of the wire
                 item.x = fromX;
                 item.y = fromY;
-            } else {
+            } else { // End of wire
                 const wireEnd = item.getWireEnd();
                 item.x = fromX - wireEnd.x;
                 item.y = fromY - wireEnd.y;
@@ -1281,8 +1302,12 @@ function getNeighbours(graph: graphlib.Graph, nodeIds: string[]): [from: string,
     }, [] as [from: string, to: string][]);
 }
 
-function makeEdgeValue(instanceName1: string, instancePin1: number, instanceName2: string, instancePin2: number, priority: number): 
-    [instance1: string, instancePin1: number, instance2: string, instancePin2: number, priority: number] {
+type EdgeValue = [instance1: string, instancePin1: number, 
+    instance2: string, instancePin2: number, priority: number];
+
+function makeEdgeValue(instanceName1: string, instancePin1: number, 
+        instanceName2: string, instancePin2: number, priority: number)
+    : EdgeValue {
     return [instanceName1, instancePin1, instanceName2, instancePin2, priority];
     // return `${instanceName1}:pin:${instancePin1} -- ${instanceName2}:pin:${instancePin2}`;
 }