circuitscript 0.0.18 → 0.0.20

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

@@ -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';
@@ -11,7 +11,7 @@ export class ExecutionContext {
     netNamespace;
     executionLevel;
     scope;
-    joinPointId = 0;
+    tmpPointId = 0;
     resolveNet = null;
     stopFurtherExpressions = false;
     returnValue = null;
@@ -305,24 +305,32 @@ export class ExecutionContext {
         this.print('created clone of net component:', cloneInstanceName);
         return clonedComponent;
     }
-    enterBranches(branchType) {
-        this.scope.branchStack.set(this.scope.indentLevel, {
+    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_branches: new Map(),
+            inner_blocks: new Map(),
             current_index: null,
-            type: branchType,
+            type: blockType,
         });
-        this.print('enter branches');
+        this.print('enter blocks');
     }
-    exitBranches() {
-        const stackRef = this.scope.branchStack.get(this.scope.indentLevel);
-        const { type: branchType } = stackRef;
-        if (branchType === BranchType.Join) {
-            const { join_final_point: finalPoint } = stackRef;
+    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;
@@ -333,65 +341,99 @@ export class ExecutionContext {
                 ]);
             }
         }
-        this.print('exit branches');
+        else if (blockType === BlockTypes.Point) {
+            const { entered_at: [component, pin,] } = stackRef;
+            this.atComponent(component, pin, { addSequence: true });
+        }
+        this.print('exit blocks');
     }
-    enterBranch(branchIndex) {
-        const stackRef = this.scope.branchStack.get(this.scope.indentLevel);
-        stackRef['branch_index'] = branchIndex;
-        const { type: branchType } = stackRef;
-        stackRef['inner_branches'].set(branchIndex, {
+    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 (branchType === BranchType.Join) {
+        if (blockType === BlockTypes.Join || blockType === BlockTypes.Point) {
             this.scope.currentComponent = null;
             this.scope.currentPin = null;
             this.scope.currentWireId = -1;
         }
-        this.print(`enter inner branch of type (${branchType}) >>>`);
+        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 { type: branchType } = stackRef;
-        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 <<<');
-        if (branchType === BranchType.Branch) {
-            this.atComponent(preBranchComponent, preBranchPin, { addSequence: true });
-            if (preBranchWireId !== -1) {
-                this.scope.sequence.push([SequenceAction.WireJump, preBranchWireId, 1]);
-            }
-        }
-        else if (branchType === BranchType.Join) {
-            if (branchIndex === 0) {
-                this.addPoint(`_join.${this.name}.${this.joinPointId}`, false);
-                this.joinPointId += 1;
-                stackRef['join_final_point'] = [
+        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 { join_final_point: finalPoint } = stackRef;
-                const [joinComponent, joinPin, joinWireId] = finalPoint;
-                this.toComponent(joinComponent, joinPin, { addSequence: true });
+                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) {
@@ -574,6 +616,9 @@ export class ExecutionContext {
         this.print('-- done merging scope --');
     }
     addWire(segments) {
+        if (this.scope.currentComponent === null) {
+            throw "No current component";
+        }
         const tmp = segments.map(item => {
             const [direction, value = null] = item;
             return {

package/build/src/globals.js

@@ -48,8 +48,10 @@ export var ReferenceTypes;
     ReferenceTypes["variable"] = "variable";
     ReferenceTypes["instance"] = "instance";
 })(ReferenceTypes || (ReferenceTypes = {}));
-export var BranchType;
-(function (BranchType) {
-    BranchType[BranchType["Branch"] = 1] = "Branch";
-    BranchType[BranchType["Join"] = 2] = "Join";
-})(BranchType || (BranchType = {}));
+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/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 { BranchType, ComponentTypes, NoNetText } 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,25 +232,38 @@ export class MainVisitor extends ParseTreeVisitor {
             return [component, pinId];
         }
     }
-    visitBranch_blocks(ctx) {
-        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;
+    visitPath_blocks(ctx) {
+        const blocks = ctx.path_block_inner_list();
+        let blockIndex = 0;
+        let blockType = BlockTypes.Branch;
+        let prevBlockType = null;
+        blocks.forEach((block, index) => {
+            if (block.Branch()) {
+                blockType = BlockTypes.Branch;
             }
-            else if (firstBranch.Join()) {
-                branchType = BranchType.Join;
+            else if (block.Join()) {
+                blockType = BlockTypes.Join;
             }
-        }
-        this.getExecutor().enterBranches(branchType);
-        branches.forEach((branch, index) => {
-            this.getExecutor().enterBranch(index);
-            this.visit(branch);
-            this.getExecutor().exitBranch(index);
+            else if (block.Parallel()) {
+                blockType = BlockTypes.Parallel;
+            }
+            else if (block.Point()) {
+                blockType = BlockTypes.Point;
+            }
+            if (prevBlockType !== blockType) {
+                if (index > 0) {
+                    this.getExecutor().exitBlocks();
+                }
+                this.getExecutor().enterBlocks(blockType);
+                blockIndex = 0;
+            }
+            this.getExecutor().enterBlock(blockIndex);
+            this.visit(block);
+            this.getExecutor().exitBlock(blockIndex);
+            blockIndex += 1;
+            prevBlockType = blockType;
         });
-        this.getExecutor().exitBranches();
+        this.getExecutor().exitBlocks();
         return this.getExecutor().getCurrentPoint();
     }
     visitBreak_keyword() {