circuitscript 0.1.11 → 0.1.12

package/dist/esm/visitor.js

@@ -4,6 +4,7 @@ import { PinDefinition, PinIdType } from './objects/PinDefinition.js';
 import { PinTypes } from './objects/PinTypes.js';
 import { DeclaredReference, UndeclaredReference } from './objects/types.js';
 import { BlockTypes, ComponentTypes, Delimiter1, FrameType, GlobalDocumentName, ModuleContainsKeyword, NoNetText, ParamKeys, ReferenceTypes, SymbolPinSide, ValidPinSides, WireAutoDirection } from './globals.js';
+import { prepareValue } from "./utils.js";
 import { PlaceHolderCommands, SymbolDrawingCommands } from './draw_symbols.js';
 import { BaseVisitor } from './BaseVisitor.js';
 import { getPortType, RuntimeExecutionError } from './utils.js';
@@ -82,39 +83,55 @@ export class ParserVisitor extends BaseVisitor {
         }
         this.setResult(ctx, componentPin);
     };
-    visitPath_blocks = (ctx) => {
-        const blocks = ctx.path_block_inner();
-        let blockIndex = 0;
+    visitPath_block = (ctx) => {
         let blockType = BlockTypes.Branch;
-        let prevBlockType = null;
-        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;
+        if (ctx.Branch()) {
+            blockType = BlockTypes.Branch;
+        }
+        else if (ctx.Join()) {
+            blockType = BlockTypes.Join;
+        }
+        else if (ctx.Parallel()) {
+            blockType = BlockTypes.Parallel;
+        }
+        else if (ctx.Point()) {
+            blockType = BlockTypes.Point;
+        }
+        const scope = this.getScope();
+        const executor = this.getExecutor();
+        const indentLevel = scope.indentLevel;
+        if (scope.blockStack.has(indentLevel)) {
+            const blockStackEntry = scope.blockStack.get(indentLevel);
+            if (blockStackEntry.type !== blockType) {
+                executor.exitBlocks();
             }
-            if (prevBlockType !== blockType) {
-                if (index > 0) {
-                    this.getExecutor().exitBlocks();
-                }
-                this.getExecutor().enterBlocks(blockType);
-                blockIndex = 0;
+        }
+        if (!scope.blockStack.has(indentLevel)) {
+            executor.enterBlocks(blockType);
+        }
+        const blockStackEntry = scope.blockStack.get(indentLevel);
+        const { current_index } = blockStackEntry;
+        executor.enterBlock(current_index);
+        this.visit(ctx.expressions_block());
+        executor.exitBlock(current_index);
+        blockStackEntry.current_index++;
+    };
+    visitGraph_expressions = (ctx) => {
+        if (ctx.path_block() === null) {
+            const scope = this.getScope();
+            const indentLevel = scope.indentLevel;
+            if (scope.blockStack.has(indentLevel)) {
+                this.getExecutor().exitBlocks();
             }
-            this.getExecutor().enterBlock(blockIndex);
-            this.visit(block);
-            this.getExecutor().exitBlock(blockIndex);
-            blockIndex += 1;
-            prevBlockType = blockType;
-        });
-        this.getExecutor().exitBlocks();
-        return this.getExecutor().getCurrentPoint();
+        }
+        const ctxPathBlock = ctx.path_block();
+        const ctxNotPathBlock = ctx.graph_linear_expression();
+        if (ctxPathBlock) {
+            this.visit(ctxPathBlock);
+        }
+        if (ctxNotPathBlock) {
+            this.visit(ctxNotPathBlock);
+        }
     };
     visitCreate_component_expr = (ctx) => {
         const scope = this.getScope();
@@ -293,7 +310,7 @@ export class ParserVisitor extends BaseVisitor {
         if (ctxId !== null) {
             const varName = ctxId.getText();
             paramIds.push(varName);
-            this.getScope().variables.set(varName, {});
+            this.getScope().setVariable(varName, {});
         }
         const executor = this.getExecutor();
         const stack = [...this.executionStack];
@@ -303,7 +320,7 @@ export class ParserVisitor extends BaseVisitor {
                 variables.forEach((value, key) => {
                     obj[key] = value;
                 });
-                executor.scope.variables.set(paramIds[0], obj);
+                executor.scope.setVariable(paramIds[0], obj);
             }
             const currentStack = this.executionStack.splice(0);
             this.executionStack.push(...stack);
@@ -384,7 +401,7 @@ export class ParserVisitor extends BaseVisitor {
     };
     visitGraphicForExpr = (ctx) => {
         const forVariableNames = ctx.ID().map(item => item.getText());
-        const listItems = this.visitResult(ctx.data_expr());
+        const listItems = prepareValue(this.visitResult(ctx.data_expr()));
         let keepLooping = true;
         let counter = 0;
         let allCommands = [];
@@ -395,7 +412,7 @@ export class ParserVisitor extends BaseVisitor {
                     useValueArray = [useValueArray];
                 }
                 useValueArray.forEach((value, index) => {
-                    this.getScope().variables.set(forVariableNames[index], value);
+                    this.getScope().setVariable(forVariableNames[index], value);
                 });
                 const commands = this.visitResult(ctx.graphic_expressions_block());
                 allCommands = allCommands.concat(commands);
@@ -526,6 +543,7 @@ export class ParserVisitor extends BaseVisitor {
         const ctxAssignmentExpr = ctx.assignment_expr();
         if (ctxDataExpr) {
             component = this.visitResult(ctxDataExpr);
+            component = prepareValue(component);
             componentCtx = ctxDataExpr;
             if (component === null || component === undefined) {
                 this.throwWithContext(ctxDataExpr, "Could not find component: " + ctxDataExpr.getText());
@@ -867,15 +885,13 @@ export class ParserVisitor extends BaseVisitor {
         const executor = this.getExecutor();
         executor.log('entering at block');
         this.visit(ctx.at_component_expr());
-        const currentComponent = executor.scope.currentComponent;
-        const currentPin = executor.scope.currentPin;
+        const [currentComponent, currentPin] = executor.getCurrentPoint();
         executor.scope.indentLevel += 1;
         ctx.at_block_expressions().forEach(expression => {
             this.visit(expression);
         });
         executor.scope.indentLevel -= 1;
-        executor.scope.currentComponent = currentComponent;
-        executor.scope.currentPin = currentPin;
+        executor.scope.setCurrent(currentComponent, currentPin);
         executor.log('leaving at block');
     };
     visitAt_block_pin_expression_simple = (ctx) => {
@@ -1057,7 +1073,8 @@ export class ParserVisitor extends BaseVisitor {
     visitFor_expr = (ctx) => {
         this.log('in for loop');
         const forVariableNames = ctx.ID().map(item => item.getText());
-        const listItems = this.visitResult(ctx.data_expr());
+        let listItems = this.visitResult(ctx.data_expr());
+        listItems = prepareValue(listItems);
         this.getExecutor().addBreakContext(ctx);
         let keepLooping = true;
         let counter = 0;
@@ -1068,7 +1085,7 @@ export class ParserVisitor extends BaseVisitor {
                     useValueArray = [useValueArray];
                 }
                 useValueArray.forEach((value, index) => {
-                    this.getScope().variables.set(forVariableNames[index], value);
+                    this.getScope().setVariable(forVariableNames[index], value);
                 });
                 this.visit(ctx.expressions_block());
                 keepLooping = true;

package/dist/types/BaseVisitor.d.ts

@@ -4,13 +4,13 @@ import { ExecutionContext } from "./execute.js";
 import { Logger } from "./logger.js";
 import { ClassComponent } from "./objects/ClassComponent.js";
 import { Net } from "./objects/Net.js";
-import { CallableParameter, CFunctionOptions, ComplexType, Direction, FunctionDefinedParameter, ReferenceType } from "./objects/types.js";
+import { CallableParameter, CFunctionOptions, ComplexType, Direction, FunctionDefinedParameter, AnyReference } from "./objects/types.js";
 import { ParserRuleContext } from 'antlr4ng';
 import { ExecutionWarning } from "./utils.js";
 import { BaseError } from './utils.js';
 import { ExecutionScope } from './objects/ExecutionScope.js';
 import { NodeScriptEnvironment } from "./environment.js";
-export declare class BaseVisitor extends CircuitScriptVisitor<ComplexType | ReferenceType | any> {
+export declare class BaseVisitor extends CircuitScriptVisitor<ComplexType | AnyReference | any> {
     indentLevel: number;
     startingContext: ExecutionContext;
     executionStack: ExecutionContext[];

package/dist/types/antlr/CircuitScriptParser.d.ts

@@ -71,68 +71,70 @@ export declare class CircuitScriptParser extends antlr.Parser {
     static readonly DEDENT = 67;
     static readonly RULE_script = 0;
     static readonly RULE_expression = 1;
-    static readonly RULE_expressions_block = 2;
-    static readonly RULE_path_blocks = 3;
-    static readonly RULE_path_block_inner = 4;
-    static readonly RULE_property_set_expr2 = 5;
-    static readonly RULE_assignment_expr2 = 6;
-    static readonly RULE_pin_select_expr = 7;
-    static readonly RULE_component_modifier_expr = 8;
-    static readonly RULE_data_expr_with_assignment = 9;
-    static readonly RULE_add_component_expr = 10;
-    static readonly RULE_component_select_expr = 11;
-    static readonly RULE_pin_select_expr2 = 12;
-    static readonly RULE_at_component_expr = 13;
-    static readonly RULE_to_component_expr = 14;
-    static readonly RULE_at_to_multiple_expr = 15;
-    static readonly RULE_at_to_multiple_line_expr = 16;
-    static readonly RULE_at_to_multiple_line_expr_to_pin = 17;
-    static readonly RULE_at_block = 18;
-    static readonly RULE_at_block_expressions = 19;
-    static readonly RULE_at_block_pin_expr = 20;
-    static readonly RULE_at_block_pin_expression_simple = 21;
-    static readonly RULE_at_block_pin_expression_complex = 22;
-    static readonly RULE_break_keyword = 23;
-    static readonly RULE_continue_keyword = 24;
-    static readonly RULE_assignment_expr = 25;
-    static readonly RULE_operator_assignment_expr = 26;
-    static readonly RULE_keyword_assignment_expr = 27;
-    static readonly RULE_parameters = 28;
-    static readonly RULE_property_set_expr = 29;
-    static readonly RULE_double_dot_property_set_expr = 30;
-    static readonly RULE_data_expr = 31;
-    static readonly RULE_binary_operator = 32;
-    static readonly RULE_unary_operator = 33;
-    static readonly RULE_value_expr = 34;
-    static readonly RULE_function_def_expr = 35;
-    static readonly RULE_function_expr = 36;
-    static readonly RULE_function_args_expr = 37;
-    static readonly RULE_atom_expr = 38;
-    static readonly RULE_trailer_expr = 39;
-    static readonly RULE_function_call_expr = 40;
-    static readonly RULE_net_namespace_expr = 41;
-    static readonly RULE_function_return_expr = 42;
-    static readonly RULE_property_block_expr = 43;
-    static readonly RULE_create_component_expr = 44;
-    static readonly RULE_graphic_expressions_block = 45;
-    static readonly RULE_create_graphic_expr = 46;
-    static readonly RULE_create_module_expr = 47;
-    static readonly RULE_nested_properties_inner = 48;
-    static readonly RULE_graphic_expr = 49;
-    static readonly RULE_property_expr = 50;
-    static readonly RULE_property_key_expr = 51;
-    static readonly RULE_property_value_expr = 52;
-    static readonly RULE_wire_atom_expr = 53;
-    static readonly RULE_wire_expr = 54;
-    static readonly RULE_array_expr = 55;
-    static readonly RULE_point_expr = 56;
-    static readonly RULE_import_expr = 57;
-    static readonly RULE_frame_expr = 58;
-    static readonly RULE_if_expr = 59;
-    static readonly RULE_if_inner_expr = 60;
-    static readonly RULE_else_expr = 61;
-    static readonly RULE_while_expr = 62;
-    static readonly RULE_for_expr = 63;
+    static readonly RULE_flow_expressions = 2;
+    static readonly RULE_graph_expressions = 3;
+    static readonly RULE_graph_linear_expression = 4;
+    static readonly RULE_expressions_block = 5;
+    static readonly RULE_path_block = 6;
+    static readonly RULE_property_set_expr2 = 7;
+    static readonly RULE_assignment_expr2 = 8;
+    static readonly RULE_pin_select_expr = 9;
+    static readonly RULE_component_modifier_expr = 10;
+    static readonly RULE_data_expr_with_assignment = 11;
+    static readonly RULE_add_component_expr = 12;
+    static readonly RULE_component_select_expr = 13;
+    static readonly RULE_pin_select_expr2 = 14;
+    static readonly RULE_at_component_expr = 15;
+    static readonly RULE_to_component_expr = 16;
+    static readonly RULE_at_to_multiple_expr = 17;
+    static readonly RULE_at_to_multiple_line_expr = 18;
+    static readonly RULE_at_to_multiple_line_expr_to_pin = 19;
+    static readonly RULE_at_block = 20;
+    static readonly RULE_at_block_expressions = 21;
+    static readonly RULE_at_block_pin_expr = 22;
+    static readonly RULE_at_block_pin_expression_simple = 23;
+    static readonly RULE_at_block_pin_expression_complex = 24;
+    static readonly RULE_break_keyword = 25;
+    static readonly RULE_continue_keyword = 26;
+    static readonly RULE_assignment_expr = 27;
+    static readonly RULE_operator_assignment_expr = 28;
+    static readonly RULE_keyword_assignment_expr = 29;
+    static readonly RULE_parameters = 30;
+    static readonly RULE_property_set_expr = 31;
+    static readonly RULE_double_dot_property_set_expr = 32;
+    static readonly RULE_data_expr = 33;
+    static readonly RULE_binary_operator = 34;
+    static readonly RULE_unary_operator = 35;
+    static readonly RULE_value_expr = 36;
+    static readonly RULE_function_def_expr = 37;
+    static readonly RULE_function_expr = 38;
+    static readonly RULE_function_args_expr = 39;
+    static readonly RULE_atom_expr = 40;
+    static readonly RULE_trailer_expr = 41;
+    static readonly RULE_function_call_expr = 42;
+    static readonly RULE_net_namespace_expr = 43;
+    static readonly RULE_function_return_expr = 44;
+    static readonly RULE_property_block_expr = 45;
+    static readonly RULE_create_component_expr = 46;
+    static readonly RULE_graphic_expressions_block = 47;
+    static readonly RULE_create_graphic_expr = 48;
+    static readonly RULE_create_module_expr = 49;
+    static readonly RULE_nested_properties_inner = 50;
+    static readonly RULE_graphic_expr = 51;
+    static readonly RULE_property_expr = 52;
+    static readonly RULE_property_key_expr = 53;
+    static readonly RULE_property_value_expr = 54;
+    static readonly RULE_wire_atom_expr = 55;
+    static readonly RULE_wire_expr = 56;
+    static readonly RULE_array_expr = 57;
+    static readonly RULE_point_expr = 58;
+    static readonly RULE_import_expr = 59;
+    static readonly RULE_frame_expr = 60;
+    static readonly RULE_if_expr = 61;
+    static readonly RULE_if_inner_expr = 62;
+    static readonly RULE_else_expr = 63;
+    static readonly RULE_while_expr = 64;
+    static readonly RULE_for_expr = 65;
     static readonly literalNames: (string | null)[];
     static readonly symbolicNames: (string | null)[];
     static readonly ruleNames: string[];
@@ -145,9 +147,11 @@ export declare class CircuitScriptParser extends antlr.Parser {
     constructor(input: antlr.TokenStream);
     script(): ScriptContext;
     expression(): ExpressionContext;
+    flow_expressions(): Flow_expressionsContext;
+    graph_expressions(): Graph_expressionsContext;
+    graph_linear_expression(): Graph_linear_expressionContext;
     expressions_block(): Expressions_blockContext;
-    path_blocks(): Path_blocksContext;
-    path_block_inner(): Path_block_innerContext;
+    path_block(): Path_blockContext;
     property_set_expr2(): Property_set_expr2Context;
     assignment_expr2(): Assignment_expr2Context;
     pin_select_expr(): Pin_select_exprContext;
@@ -231,28 +235,46 @@ export declare class ScriptContext extends antlr.ParserRuleContext {
 }
 export declare class ExpressionContext extends antlr.ParserRuleContext {
     constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
-    add_component_expr(): Add_component_exprContext | null;
-    to_component_expr(): To_component_exprContext | null;
-    at_component_expr(): At_component_exprContext | null;
+    graph_expressions(): Graph_expressionsContext | null;
+    flow_expressions(): Flow_expressionsContext | null;
     assignment_expr(): Assignment_exprContext | null;
     operator_assignment_expr(): Operator_assignment_exprContext | null;
     property_set_expr(): Property_set_exprContext | null;
     property_set_expr2(): Property_set_expr2Context | null;
     double_dot_property_set_expr(): Double_dot_property_set_exprContext | null;
-    break_keyword(): Break_keywordContext | null;
-    continue_keyword(): Continue_keywordContext | null;
     function_def_expr(): Function_def_exprContext | null;
     function_call_expr(): Function_call_exprContext | null;
-    wire_expr(): Wire_exprContext | null;
     import_expr(): Import_exprContext | null;
-    frame_expr(): Frame_exprContext | null;
     atom_expr(): Atom_exprContext | null;
-    at_block(): At_blockContext | null;
-    path_blocks(): Path_blocksContext | null;
-    point_expr(): Point_exprContext | null;
+    frame_expr(): Frame_exprContext | null;
+    get ruleIndex(): number;
+    accept<Result>(visitor: CircuitScriptVisitor<Result>): Result | null;
+}
+export declare class Flow_expressionsContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
     if_expr(): If_exprContext | null;
     while_expr(): While_exprContext | null;
     for_expr(): For_exprContext | null;
+    break_keyword(): Break_keywordContext | null;
+    continue_keyword(): Continue_keywordContext | null;
+    get ruleIndex(): number;
+    accept<Result>(visitor: CircuitScriptVisitor<Result>): Result | null;
+}
+export declare class Graph_expressionsContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    graph_linear_expression(): Graph_linear_expressionContext | null;
+    path_block(): Path_blockContext | null;
+    get ruleIndex(): number;
+    accept<Result>(visitor: CircuitScriptVisitor<Result>): Result | null;
+}
+export declare class Graph_linear_expressionContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    add_component_expr(): Add_component_exprContext | null;
+    to_component_expr(): To_component_exprContext | null;
+    at_component_expr(): At_component_exprContext | null;
+    at_block(): At_blockContext | null;
+    wire_expr(): Wire_exprContext | null;
+    point_expr(): Point_exprContext | null;
     get ruleIndex(): number;
     accept<Result>(visitor: CircuitScriptVisitor<Result>): Result | null;
 }
@@ -267,14 +289,7 @@ export declare class Expressions_blockContext extends antlr.ParserRuleContext {
     get ruleIndex(): number;
     accept<Result>(visitor: CircuitScriptVisitor<Result>): Result | null;
 }
-export declare class Path_blocksContext extends antlr.ParserRuleContext {
-    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
-    path_block_inner(): Path_block_innerContext[];
-    path_block_inner(i: number): Path_block_innerContext | null;
-    get ruleIndex(): number;
-    accept<Result>(visitor: CircuitScriptVisitor<Result>): Result | null;
-}
-export declare class Path_block_innerContext extends antlr.ParserRuleContext {
+export declare class Path_blockContext extends antlr.ParserRuleContext {
     constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
     expressions_block(): Expressions_blockContext;
     Branch(): antlr.TerminalNode | null;
@@ -450,8 +465,9 @@ export declare class Continue_keywordContext extends antlr.ParserRuleContext {
 }
 export declare class Assignment_exprContext extends antlr.ParserRuleContext {
     constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
-    atom_expr(): Atom_exprContext;
     data_expr(): Data_exprContext;
+    atom_expr(): Atom_exprContext | null;
+    function_call_expr(): Function_call_exprContext | null;
     get ruleIndex(): number;
     accept<Result>(visitor: CircuitScriptVisitor<Result>): Result | null;
 }

package/dist/types/antlr/CircuitScriptVisitor.d.ts

@@ -1,9 +1,11 @@
 import { AbstractParseTreeVisitor } from "antlr4ng";
 import { ScriptContext } from "./CircuitScriptParser.js";
 import { ExpressionContext } from "./CircuitScriptParser.js";
+import { Flow_expressionsContext } from "./CircuitScriptParser.js";
+import { Graph_expressionsContext } from "./CircuitScriptParser.js";
+import { Graph_linear_expressionContext } from "./CircuitScriptParser.js";
 import { Expressions_blockContext } from "./CircuitScriptParser.js";
-import { Path_blocksContext } from "./CircuitScriptParser.js";
-import { Path_block_innerContext } from "./CircuitScriptParser.js";
+import { Path_blockContext } from "./CircuitScriptParser.js";
 import { Property_set_expr2Context } from "./CircuitScriptParser.js";
 import { Assignment_expr2Context } from "./CircuitScriptParser.js";
 import { Pin_select_exprContext } from "./CircuitScriptParser.js";
@@ -78,9 +80,11 @@ import { For_exprContext } from "./CircuitScriptParser.js";
 export declare class CircuitScriptVisitor<Result> extends AbstractParseTreeVisitor<Result> {
     visitScript?: (ctx: ScriptContext) => Result;
     visitExpression?: (ctx: ExpressionContext) => Result;
+    visitFlow_expressions?: (ctx: Flow_expressionsContext) => Result;
+    visitGraph_expressions?: (ctx: Graph_expressionsContext) => Result;
+    visitGraph_linear_expression?: (ctx: Graph_linear_expressionContext) => Result;
     visitExpressions_block?: (ctx: Expressions_blockContext) => Result;
-    visitPath_blocks?: (ctx: Path_blocksContext) => Result;
-    visitPath_block_inner?: (ctx: Path_block_innerContext) => Result;
+    visitPath_block?: (ctx: Path_blockContext) => Result;
     visitProperty_set_expr2?: (ctx: Property_set_expr2Context) => Result;
     visitAssignment_expr2?: (ctx: Assignment_expr2Context) => Result;
     visitPin_select_expr?: (ctx: Pin_select_exprContext) => Result;

package/dist/types/execute.d.ts

@@ -62,6 +62,7 @@ export declare class ExecutionContext {
     copyComponent(component: ClassComponent): ClassComponent;
     enterBlocks(blockType: BlockTypes): void;
     exitBlocks(): void;
+    closeAllBlocks(): void;
     enterBlock(blockIndex: number): void;
     exitBlock(blockIndex: number): void;
     atPointBlock(): void;

package/dist/types/globals.d.ts

@@ -88,6 +88,11 @@ export declare enum BlockTypes {
     Parallel = 3,
     Point = 4
 }
+export declare enum NetGraphicsParams {
+    Color = "color",
+    Highight = "highlight",
+    LineWidth = "lineWidth"
+}
 export declare enum FrameType {
     Frame = 1,
     Sheet = 2

package/dist/types/layout.d.ts

@@ -8,6 +8,7 @@ import { Net } from './objects/Net.js';
 import { Logger } from './logger.js';
 import { Frame, FramePlotDirection } from './objects/Frame.js';
 import { BoundBox } from './utils.js';
+import { ComponentPinNetPair } from './objects/types.js';
 import { NumericValue } from './objects/ParamDefinition.js';
 export declare class LayoutEngine {
     logger: Logger;
@@ -19,7 +20,8 @@ export declare class LayoutEngine {
     protected print(...params: any[]): void;
     protected printLevel(level: number, ...params: any[]): void;
     protected padLevel(value: number): string;
-    runLayout(sequence: SequenceItem[], nets: [ClassComponent, pin: number, net: Net][]): SheetFrame[];
+    runLayout(sequence: SequenceItem[], nets: ComponentPinNetPair[]): SheetFrame[];
+    private collectRenderNets;
     private flattenFrameItems;
     private findJunctions;
     private placeFrames;
@@ -52,6 +54,14 @@ export declare class RenderObject {
     isFloating: boolean;
     floatingRelativeTo: [selfPin: number, nodeId: string, pin: number][];
 }
+export type RenderNet = {
+    netName: string;
+    net: Net;
+    color?: string;
+    lineWidth?: number;
+    highlight?: string;
+    highlightOpacity?: number;
+};
 export declare class RenderWire extends RenderObject {
     id: number;
     segments: WireSegment[];
@@ -60,7 +70,8 @@ export declare class RenderWire extends RenderObject {
         y: number;
     }[];
     netName: string;
-    constructor(x: NumericValue, y: NumericValue, segments: WireSegment[]);
+    net: Net;
+    constructor(net: Net, x: NumericValue, y: NumericValue, segments: WireSegment[]);
     refreshPoints(): void;
     getAutoPoints(value: [x: NumericValue, y: NumericValue], direction: WireAutoDirection): [dx: number, dy: number][];
     getWireEnd(): {
@@ -76,6 +87,7 @@ export type MergedWire = {
     netName: string;
     segments: [x: number, y: number][][];
     intersectPoints: [x: number, y: number, count: number][];
+    net: RenderNet;
 };
 export declare class RenderComponent extends RenderObject {
     component: ClassComponent;
@@ -122,7 +134,8 @@ export declare enum RenderFrameType {
 export declare class RenderJunction {
     x: NumericValue;
     y: NumericValue;
-    constructor(x: NumericValue, y: NumericValue);
+    net: RenderNet;
+    constructor(x: NumericValue, y: NumericValue, net: RenderNet);
 }
 export type SheetFrame = {
     frame: RenderFrame;

package/dist/types/objects/ExecutionScope.d.ts

@@ -1,7 +1,7 @@
 import { ClassComponent } from './ClassComponent.js';
 import { Net } from './Net.js';
-import { CFunction, ComponentPinNet, ComponentPinNetPair, ParseSymbolType, ValueType } from './types.js';
-import { LayoutDirection } from '../globals.js';
+import { CFunction, ComponentPinNet, ComponentPinNetPair, ComponentPinWireId, ParseSymbolType, ValueType } from './types.js';
+import { BlockTypes, LayoutDirection } from '../globals.js';
 import { Wire, WireSegment } from './Wire.js';
 import { Frame } from './Frame.js';
 import { ParserRuleContext } from 'antlr4ng';
@@ -17,7 +17,7 @@ export declare class ExecutionScope {
     symbols: Map<string, {
         type: ParseSymbolType;
     }>;
-    blockStack: Map<number, any>;
+    blockStack: Map<number, BlockStackEntry>;
     contextStack: ParserRuleContext[];
     onPropertyHandler: OnPropertyHandler[];
     breakStack: ParserRuleContext[];
@@ -46,6 +46,7 @@ export declare class ExecutionScope {
     getNets(): ComponentPinNetPair[];
     dumpNets(): ComponentPinNet[];
     printNets(): void;
+    setVariable(name: string, value: any): void;
     setActive(type: ActiveObject, item: any): void;
     clearActive(): void;
     setCurrent(component: ClassComponent | null, pin?: number | null): void;
@@ -82,4 +83,15 @@ export type SequenceActionAtTo = [
 export type SequenceActionWire = [SequenceAction.Wire, wireId: number, WireSegment[]];
 export type SequenceActionAssign = [SequenceAction.Assign, variable: string, ClassComponent];
 export type SequenceItem = SequenceActionAtTo | SequenceActionWire | [SequenceAction.WireJump, wireId: number, pinId: number] | [SequenceAction.Frame, Frame, "enter" | "exit"] | SequenceActionAssign;
+export type InnerBlockStackEntry = {
+    last_net: ComponentPinWireId | null;
+    ignore_last_net: boolean;
+};
+export type BlockStackEntry = {
+    start_point: ComponentPinWireId;
+    end_point: ComponentPinWireId | null;
+    inner_blocks: Map<number, InnerBlockStackEntry>;
+    current_index: number;
+    type: BlockTypes;
+};
 export {};

package/dist/types/objects/Net.d.ts

@@ -4,6 +4,7 @@ export declare class Net {
     namespace: string;
     priority: number;
     type: any;
+    params: Map<string, any>;
     constructor(namespace: string, name: string, priority?: number, type?: any);
     toString(): string;
     static isSame(netA: Net, netB: Net): boolean;

package/dist/types/objects/types.d.ts

@@ -3,6 +3,7 @@ import { ExecutionContext } from '../execute.js';
 import { ClassComponent } from './ClassComponent.js';
 import { Net } from './Net.js';
 import { NumericValue, PercentageValue } from './ParamDefinition.js';
+import { ReferenceTypes } from '../globals.js';
 export type CFunction = (args: CallableParameter[], options?: CFunctionOptions) => CFunctionResult;
 export type CFunctionOptions = {
     netNamespace?: string;
@@ -21,6 +22,11 @@ export type ComponentPinNetPair = [
     pin: number,
     net: Net
 ];
+export type ComponentPinWireId = [
+    component: ClassComponent,
+    pin: number,
+    wireId: number
+];
 export type ComponentPin = [
     component: ClassComponent,
     pinId: number | string
@@ -41,32 +47,33 @@ export type FunctionDefinedParameter = [
     token: Token,
     defaultValue: ValueType
 ] | [name: string, token: Token];
+export declare class AnyReference {
+    found: boolean;
+    name?: string;
+    trailers: string[];
+    type?: ReferenceTypes;
+    value?: any;
+    parentValue?: any;
+    constructor(refType: {
+        found: boolean;
+        name?: string;
+        trailers?: string[];
+        type?: ReferenceTypes;
+        value?: any;
+        parentValue?: any;
+    });
+}
 export declare class UndeclaredReference {
-    reference: ReferenceType;
-    constructor(reference: ReferenceType);
+    reference: AnyReference;
+    constructor(reference: AnyReference);
     throwMessage(): string;
     toString(): string;
     nameString(): string;
 }
-export declare class DeclaredReference {
-    found: boolean;
-    name?: string;
-    trailers?: string[];
-    type?: 'value' | 'instance' | 'variable';
-    value?: any;
-    parentValue?: any;
-    constructor(refType: ReferenceType);
+export declare class DeclaredReference extends AnyReference {
     toString(): string;
     toDisplayString(): string;
 }
-export type ReferenceType = {
-    found: boolean;
-    name?: string;
-    trailers?: string[];
-    type?: 'value' | 'instance' | 'variable';
-    value?: any;
-    parentValue?: any;
-};
 export declare enum ParseSymbolType {
     Variable = "variable",
     Function = "function",