circuitscript 0.0.18 → 0.0.20

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/execute.ts

@@ -1,4 +1,4 @@
-import { BranchType, ComponentTypes, GlobalNames, NoNetText, 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,7 +26,7 @@ export class ExecutionContext {
 
     scope: ExecutionScope;
 
-    joinPointId = 0;
+    tmpPointId = 0;     // Counter for points created within the context
 
     resolveNet: (name: string, netNamespace:string) => ({
         found: boolean, net?: Net
@@ -536,33 +536,42 @@ export class ExecutionContext {
         return clonedComponent;
     }
 
-    enterBranches(branchType: BranchType): void {
-        // Create object to track all the inner branches of 
-        // the branch group
+    enterBlocks(blockType: BlockTypes): void {
+        // Create object to track all the inner blocks of 
+        // the block group
 
-        this.scope.branchStack.set(this.scope.indentLevel, {
-            // Tracks the position when the branch is entered
+        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_branches: new Map<number, any>(),
+            inner_blocks: new Map<number, any>(),
             current_index: null,
-            type: branchType,
+            type: blockType,
         });
 
-        this.print('enter branches');
+        this.print('enter blocks');
     }
 
-    exitBranches(): void {
-        const stackRef = this.scope.branchStack.get(
+    exitBlocks(): void {
+        const stackRef = this.scope.blockStack.get(
             this.scope.indentLevel,
         );
 
-        const { type: branchType } = stackRef;
-        if (branchType === BranchType.Join) {
-            // Move to the end location of the first branch
-            const { join_final_point: finalPoint } = stackRef;
+        const { type: blockType } = stackRef;
+
+        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;
 
             this.scope.currentComponent = component;
@@ -574,101 +583,149 @@ export class ExecutionContext {
                     SequenceAction.WireJump, wireId, 1
                 ]);
             }
+        } else if (blockType === BlockTypes.Point) {
+            const { entered_at: [component, pin,] } =
+                stackRef;
+
+            // Preblock location should be a created point without any wires
+            this.atComponent(component, pin, { addSequence: true });
         }
 
-        this.print('exit branches');
+        this.print('exit blocks');
     }
 
-    enterBranch(branchIndex: number): void {
-        // Current net before any branching is already stored in enterBranches()
-        const stackRef = this.scope.branchStack.get(this.scope.indentLevel);
-        stackRef['branch_index'] = branchIndex;
+    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;
 
-        const { type: branchType } = stackRef;
+        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 (branchType === BranchType.Join) {
-            // Clear current component, pin, wire before entering the branch
+        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 branch of type (${branchType}) >>>`);
+        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);
-        const { type: branchType } = stackRef;
+    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) {
 
-        this.print('exit inner branch <<<');
+            // Restore the latest entry in the branch stack
+            const { entered_at: [component, pin, wireId] } =
+                stackRef;
 
-        if (branchType === BranchType.Branch) {
             // Do not duplicate any net symbol since this is a branch
-            this.atComponent(preBranchComponent, preBranchPin, { addSequence: true });
+            this.atComponent(component, pin, { addSequence: true });
 
-            if (preBranchWireId !== -1) {
+            if (wireId !== -1) {
                 // If previous node is a wire, then jump to END of wire
-                this.scope.sequence.push([SequenceAction.WireJump, preBranchWireId, 1]);
+                this.scope.sequence.push([SequenceAction.WireJump, wireId, 1]);
             }
-        } else if (branchType === BranchType.Join) {
-            if (branchIndex === 0) {
-                // First join branch will determine the final join location
+        } else if (blockType === BlockTypes.Join || blockType === BlockTypes.Parallel) {
+            if (blockIndex === 0) {
+                // First join block will determine the final join location
 
-                // Add point to current location
-                this.addPoint(`_join.${this.name}.${this.joinPointId}`, false);
-                
-                this.joinPointId += 1;
+                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['join_final_point'] = [
+                stackRef['final_point'] = [
                     this.scope.currentComponent,
                     this.scope.currentPin,
                     this.scope.currentWireId
                 ];
 
             } else {
-                const { join_final_point: finalPoint } = stackRef;
-                const [joinComponent, joinPin, joinWireId] = finalPoint;
+                const { final_point: finalPoint } = stackRef;
+                const [component, pin,] = finalPoint;
 
                 // Link the current component to the join component and join pin
-                this.toComponent(joinComponent, joinPin, { addSequence: true });
+                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
+        });
+    }
+
+    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');
+
+        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 (component.instanceName.startsWith('_point.')) {
+                return entered_at;
+            }
+        }
+
+        this.print('did not find block point');
+
+        return null;
+    }
+
     breakBranch(): void {
         this.print('break branch');
         // 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;
     }
 
@@ -951,6 +1008,11 @@ export class ExecutionContext {
     }
 
     addWire(segments: [string, number?][]): void {
+
+        if (this.scope.currentComponent === null) {
+            throw "No current component";
+        }
+
         const tmp = segments.map(item => {
             const [direction, value=null] = item;
             return {

package/src/globals.ts

@@ -59,7 +59,9 @@ export enum ReferenceTypes {
     instance = 'instance',
 }
 
-export enum BranchType {
-    Branch = 1,
-    Join = 2,
+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/objects/ExecutionScope.ts

@@ -15,7 +15,7 @@ export class ExecutionScope {
 
     variables: Map<string, ValueType | ClassComponent> = new Map();
 
-    branchStack: Map<number, any> = new Map();
+    blockStack: Map<number, any> = new Map();
 
     wires: Wire[] = [];
     frames: Frame[] = [];

package/src/visitor.ts

@@ -15,7 +15,7 @@ import {
     Atom_exprContext,
     BinaryOperatorExprContext,
     Blank_exprContext,
-    Branch_blocksContext,
+    Path_blocksContext,
     Component_select_exprContext,
     Create_component_exprContext,
     Create_graphic_exprContext,
@@ -59,10 +59,10 @@ import {
 import { PinDefinition, PinIdType } from './objects/PinDefinition.js';
 import { PinTypes } from './objects/PinTypes.js';
 import { ExecutionScope } from './objects/ExecutionScope.js';
-import { CFunction, CFunctionOptions, CallableParameter, ComplexType, ComponentPin, 
+import { CFunctionOptions, CallableParameter, ComplexType, ComponentPin, 
     ComponentPinNet, FunctionDefinedParameter, ReferenceType, UndeclaredReference, ValueType } from './objects/types.js';
 import { Logger } from './logger.js';
-import { BranchType, ComponentTypes, NoNetText } from './globals.js';
+import { BlockTypes, ComponentTypes, NoNetText } from './globals.js';
 import { Net } from './objects/Net.js';
 import { SubExpressionCommand, SymbolDrawingCommands } from './draw_symbols.js';
 import { parseFileWithVisitor } from './parser.js';
@@ -303,36 +303,48 @@ export class MainVisitor extends ParseTreeVisitor<any> {
     }
 
     visitAt_component_expr(ctx: At_component_exprContext): ComponentPin {
-        const [component, pin] = this.visit(ctx.component_select_expr());
+        if (ctx.Point()) {
+            this.getExecutor().atPointBlock();
 
-        const currentPoint = this.getExecutor().atComponent(component, pin, {
-            addSequence: true,
-            cloneNetComponent: true
-        });
-        
-        if (ctx.ID()){
-            // If there is ID specified, then it can only be for the 
-            // component orientation.
-            this.setComponentOrientation(currentPoint[0], 
-                currentPoint[1], ctx.ID().getText())
+        } else {
+            const [component, pin] = this.visit(ctx.component_select_expr());
+
+            const currentPoint = this.getExecutor().atComponent(component, pin, {
+                addSequence: true,
+                cloneNetComponent: true
+            });
+
+            if (ctx.ID()) {
+                // If there is ID specified, then it can only be for the 
+                // component orientation.
+                this.setComponentOrientation(currentPoint[0],
+                    currentPoint[1], ctx.ID().getText())
+            }
         }
-        
-        return currentPoint;
+
+        return this.getExecutor().getCurrentPoint();
     }
 
-    visitTo_component_expr(ctx: To_component_exprContext): ComponentPin  {
+    visitTo_component_expr(ctx: To_component_exprContext): ComponentPin {
         let currentPoint: ComponentPin;
-        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()){
-            // If there is ID specified, then it can only be for the 
-            // component orientation.
-            this.setComponentOrientation(currentPoint[0], 
-                currentPoint[1], ctx.ID().getText())
+        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()) {
+                // If there is ID specified, then it can only be for the 
+                // component orientation.
+                this.setComponentOrientation(currentPoint[0],
+                    currentPoint[1], ctx.ID().getText())
+            }
         }
 
         return this.getExecutor().getCurrentPoint();
@@ -352,30 +364,44 @@ export class MainVisitor extends ParseTreeVisitor<any> {
         }
     }
 
-    visitBranch_blocks(ctx: Branch_blocksContext): ComponentPin {
-        const branches = ctx.branch_block_inner_list();
-        let branchType = BranchType.Branch;
+    visitPath_blocks(ctx: Path_blocksContext): ComponentPin {
+        const blocks = ctx.path_block_inner_list();
+
+        let blockIndex = 0; // Tracks the index of the block with the given type
+        let blockType = BlockTypes.Branch;
+        let prevBlockType = null;
 
-        if (branches.length > 0){
-            const firstBranch = branches[0];
-            if (firstBranch.Branch()){
-                branchType = BranchType.Branch
-            } else if (firstBranch.Join()){
-                branchType = BranchType.Join;
+        blocks.forEach((block, index) => {
+            if (block.Branch()) {
+                blockType = BlockTypes.Branch
+            } else if (block.Join()) {
+                blockType = BlockTypes.Join;
+            } else if (block.Parallel()) {
+                blockType = BlockTypes.Parallel;
+            } else if (block.Point()) {
+                blockType = BlockTypes.Point;
             }
-        }
 
-        this.getExecutor().enterBranches(branchType);
+            if (prevBlockType !== blockType) {
+                if (index > 0) { 
+                    // If not the first block, then exit the 
+                    // group of blocks.
+                    this.getExecutor().exitBlocks();
+                }
 
-        branches.forEach((branch, index) => {
-            this.getExecutor().enterBranch(index);
+                this.getExecutor().enterBlocks(blockType);
+                blockIndex = 0; // Reset counter.
+            }
 
-            this.visit(branch);
+            this.getExecutor().enterBlock(blockIndex);
+            this.visit(block);
+            this.getExecutor().exitBlock(blockIndex);
+            blockIndex += 1;
 
-            this.getExecutor().exitBranch(index);
+            prevBlockType = blockType;
         });
 
-        this.getExecutor().exitBranches();
+        this.getExecutor().exitBlocks();
         return this.getExecutor().getCurrentPoint();
     }