circuitscript 0.0.17 → 0.0.18

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 { BranchType, 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;
 
+    joinPointId = 0;
+
     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,116 +536,125 @@ export class ExecutionContext {
         return clonedComponent;
     }
 
-    enterBranches(): void {
+    enterBranches(branchType: BranchType): void {
+        // Create object to track all the inner branches of 
+        // the branch group
+
         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],
+            entered_at: [
+                this.scope.currentComponent,
+                this.scope.currentPin,
+                this.scope.currentWireId],
             inner_branches: new Map<number, any>(),
             current_index: null,
+            type: branchType,
         });
 
         this.print('enter branches');
     }
 
     exitBranches(): void {
-        false && this.joinBranches();
-        
-        this.print('exit branches');
-    }
-
-    joinBranches(): void {
-        // When exiting/leaving a group of branches
-        const innerBranches = this.scope.branchStack.get(
+        const stackRef = this.scope.branchStack.get(
             this.scope.indentLevel,
-        )['inner_branches'];
-
-        const lastNets: [number, [ClassComponent, number, Net]][] = [];
+        );
 
-        // 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'];
+        const { type: branchType } = stackRef;
+        if (branchType === BranchType.Join) {
+            // Move to the end location of the first branch
+            const { join_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
+                ]);
             }
         }
 
-        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;
-        }
+        this.print('exit branches');
     }
 
     enterBranch(branchIndex: number): void {
-        this.print('enter inner branch >>>');
-
         // Current net before any branching is already stored in enterBranches()
         const stackRef = this.scope.branchStack.get(this.scope.indentLevel);
-
         stackRef['branch_index'] = branchIndex;
 
+        const { type: branchType } = stackRef;
+
         // Setup the state for the inner branch at the given index
         stackRef['inner_branches'].set(branchIndex, {
             last_net: null,
             ignore_last_net: false,
         });
 
+        if (branchType === BranchType.Join) {
+            // Clear current component, pin, wire before entering the branch
+            this.scope.currentComponent = null;
+            this.scope.currentPin = null;
+            this.scope.currentWireId = -1;
+        }
+
+        this.print(`enter inner branch of type (${branchType}) >>>`);
+
         this.scope.indentLevel += 1;
     }
 
     exitBranch(branchIndex: number): void {
         const stackRef = this.scope.branchStack.get(this.scope.indentLevel - 1);
-
+        const { type: branchType } = stackRef;
         // Save the last net reference
         const branchIndexRef = stackRef['inner_branches'].get(branchIndex);
         branchIndexRef['last_net'] = [
             this.scope.currentComponent,
             this.scope.currentPin,
+            this.scope.currentWireId
         ];
 
         stackRef['branch_index'] = null;
 
         // Restore the latest entry in the branch stack
-        const [preBranchComponent, preBranchPin, preBranchWireId] = stackRef['entered_at'];
+        const [preBranchComponent, preBranchPin, preBranchWireId] =
+            stackRef['entered_at'];
 
         this.scope.indentLevel -= 1;
 
         this.print('exit inner branch <<<');
 
-        // Do not duplicate any net symbol since this is a branch
-        this.atComponent(preBranchComponent, preBranchPin, {addSequence: true});
+        if (branchType === BranchType.Branch) {
+            // Do not duplicate any net symbol since this is a branch
+            this.atComponent(preBranchComponent, preBranchPin, { addSequence: true });
+
+            if (preBranchWireId !== -1) {
+                // If previous node is a wire, then jump to END of wire
+                this.scope.sequence.push([SequenceAction.WireJump, preBranchWireId, 1]);
+            }
+        } else if (branchType === BranchType.Join) {
+            if (branchIndex === 0) {
+                // First join branch will determine the final join location
 
-        if (preBranchWireId !== -1){
-            this.scope.sequence.push([SequenceAction.WireJump, preBranchWireId]);
+                // Add point to current location
+                this.addPoint(`_join.${this.name}.${this.joinPointId}`, false);
+                
+                this.joinPointId += 1;
+
+                stackRef['join_final_point'] = [
+                    this.scope.currentComponent,
+                    this.scope.currentPin,
+                    this.scope.currentWireId
+                ];
+
+            } else {
+                const { join_final_point: finalPoint } = stackRef;
+                const [joinComponent, joinPin, joinWireId] = finalPoint;
+
+                // Link the current component to the join component and join pin
+                this.toComponent(joinComponent, joinPin, { addSequence: true });
+            }
         }
     }
 
@@ -748,7 +769,7 @@ export class ExecutionContext {
                 { netNamespace });
 
             this.print(`done call function '${functionName}'`);
-
+            
             return functionResult;
         } else {
             throw `Invalid function '${functionName}'`;
@@ -855,7 +876,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 +916,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 +983,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,9 @@ export enum ReferenceTypes {
     value = 'value',
     variable = 'variable',
     instance = 'instance',
+}
+
+export enum BranchType {
+    Branch = 1,
+    Join = 2,
 }

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}`;
 }

package/src/objects/ExecutionScope.ts

@@ -165,12 +165,20 @@ export class ExecutionScope {
 }
 
 export enum SequenceAction {
+    // Link current insertion point to component pin
     To = 'to',
+
+    // Move insertion point at component pin
     At = 'at',
+
+    // Link current insertion point with wire of given segments
     Wire = 'wire',
 
+    // Jump to wire with target ID. Pin 0 of wire is the start of the 
+    // wire, pin 1 is the other end of the wire.
     WireJump = 'wire-jump',
 
+    // Creates a new frame group
     Frame = 'frame',
 }
 
@@ -187,7 +195,7 @@ export enum ActiveObject {
 
 export type SequenceItem =
     [SequenceAction.To | SequenceAction.At, ClassComponent, number, LayoutDirection?, string?]
-    | [SequenceAction.Wire, number, WireSegment[]]
-    | [SequenceAction.WireJump, number]
+    | [SequenceAction.Wire, wireId: number, WireSegment[]]
+    | [SequenceAction.WireJump, wireId: number, pinId: number]
     | [SequenceAction.Frame, Frame, "enter" | "exit"]
     ;

package/src/visitor.ts

@@ -62,7 +62,7 @@ import { ExecutionScope } from './objects/ExecutionScope.js';
 import { CFunction, CFunctionOptions, CallableParameter, ComplexType, ComponentPin, 
     ComponentPinNet, FunctionDefinedParameter, ReferenceType, UndeclaredReference, ValueType } from './objects/types.js';
 import { Logger } from './logger.js';
-import { ComponentTypes } from './globals.js';
+import { BranchType, ComponentTypes, NoNetText } from './globals.js';
 import { Net } from './objects/Net.js';
 import { SubExpressionCommand, SymbolDrawingCommands } from './draw_symbols.js';
 import { parseFileWithVisitor } from './parser.js';
@@ -353,9 +353,20 @@ export class MainVisitor extends ParseTreeVisitor<any> {
     }
 
     visitBranch_blocks(ctx: Branch_blocksContext): ComponentPin {
-        this.getExecutor().enterBranches();
-
         const branches = ctx.branch_block_inner_list();
+        let branchType = BranchType.Branch;
+
+        if (branches.length > 0){
+            const firstBranch = branches[0];
+            if (firstBranch.Branch()){
+                branchType = BranchType.Branch
+            } else if (firstBranch.Join()){
+                branchType = BranchType.Join;
+            }
+        }
+
+        this.getExecutor().enterBranches(branchType);
+
         branches.forEach((branch, index) => {
             this.getExecutor().enterBranch(index);
 
@@ -733,7 +744,7 @@ export class MainVisitor extends ParseTreeVisitor<any> {
 
             // Function execution is completed, get the last executor
             const lastExecution = executionStack.pop();
-            
+
             // Merge what ever was created in the scope with the outer scope
             const nextLastExecution = executionStack[executionStack.length - 1];
             nextLastExecution.mergeScope(
@@ -1396,8 +1407,8 @@ export class MainVisitor extends ParseTreeVisitor<any> {
         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);