circuitscript 0.0.18 → 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/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) {

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,31 @@ 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 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 (firstBranch.Join()) {
-                branchType = BranchType.Join;
+            else if (firstBlock.Point()) {
+                blockType = BlockTypes.Point;
             }
         }
-        this.getExecutor().enterBranches(branchType);
-        branches.forEach((branch, index) => {
-            this.getExecutor().enterBranch(index);
+        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() {

package/package.json

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

package/src/antlr/CircuitScript.g4

@@ -17,11 +17,12 @@ Add:        'add';
 At:         'at';
 To:         'to';
 Point:      'point';
+Join:       'join';
+Parallel:   'parallel';
 
 Return:     'return';
 Define:     'def';
 Import:     'import';
-Join:       'join';
 
 If:         'if';
 Not:        '!';
@@ -47,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|Join) ':' 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;
@@ -73,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;