circuitscript 0.1.14 → 0.1.16

package/dist/esm/layout.js

@@ -1,21 +1,20 @@
-import graphlib, { Graph } from '@dagrejs/graphlib';
+import graphlib from '@dagrejs/graphlib';
 const { alg } = graphlib;
-import { SymbolCustom, SymbolDrawing, SymbolCustomModule, SymbolPlaceholder, SymbolText, PlaceHolderCommands } from "./draw_symbols.js";
-import { FrameAction, SequenceAction } from "./objects/ExecutionScope.js";
-import { ComponentTypes, defaultFrameTitleTextSize, defaultGridSizeUnits, FrameType, NetGraphicsParams, ParamKeys, WireAutoDirection } from './globals.js';
+import { SymbolCustom, SymbolDrawing, SymbolPlaceholder, SymbolText, PlaceHolderCommands } from "./draw_symbols.js";
+import { defaultFrameTitleTextSize, defaultGridSizeUnits, FrameType, NetGraphicsParams, ParamKeys, WireAutoDirection } from './globals.js';
 import { Geometry, HorizontalAlign, VerticalAlign } from './geometry.js';
-import { Logger } from './logger.js';
 import { FixedFrameIds, Frame, FrameParamKeys, FramePlotDirection } from './objects/Frame.js';
 import { areasOverlap, combineMaps, getBoundsSize, printBounds, resizeBounds, resizeToNearestGrid, roundValue, toNearestGrid } from './utils.js';
 import { Direction } from './objects/types.js';
 import { milsToMM, UnitDimension } from './helpers.js';
-import { numeric, NumericValue } from './objects/ParamDefinition.js';
+import { numeric } from './objects/ParamDefinition.js';
+import { generateLayoutPinDefinition, getWireName, RenderItemType } from './graph.js';
 export class LayoutEngine {
     logger;
     layoutWarnings = [];
     showBaseFrame = false;
-    constructor(options = { showBaseFrame: false }) {
-        this.logger = new Logger();
+    constructor(logger, options = { showBaseFrame: false }) {
+        this.logger = logger;
         const { showBaseFrame = false } = options ?? {};
         this.showBaseFrame = showBaseFrame;
     }
@@ -29,30 +28,8 @@ export class LayoutEngine {
         const padding = ''.padStart(value * 4, ' ');
         return "[" + value + "]" + padding;
     }
-    runLayout(sequence, nets) {
-        const logNodesAndEdges = true;
+    runLayout(graph, containerFrames, nets) {
         const renderNets = this.collectRenderNets(nets);
-        this.print('===== creating graph and populating with nodes =====');
-        const { graph, containerFrames } = this.generateLayoutGraph(sequence, nets);
-        this.print('===== done populating graph =====');
-        this.print('');
-        if (logNodesAndEdges) {
-            this.print('===== graph edges =====');
-            const allEdges = graph.edges();
-            allEdges.forEach(edge => {
-                const [nodeId1, pin1, nodeId2, pin2] = graph.edge(edge);
-                this.print(nodeId1, 'pin', pin1, '-----', nodeId2, 'pin', pin2);
-            });
-            this.print('===== end edges =====');
-            this.print();
-            this.print('===== graph nodes =====');
-            const nodes = graph.nodes();
-            nodes.forEach(node => {
-                this.print(`name:${node}, value:${graph.node(node)}`);
-            });
-            this.print('===== end nodes =====');
-            this.print('');
-        }
         const subgraphInfo = this.sizeSubGraphs(graph);
         const dumpSubgraphInfo = true;
         if (dumpSubgraphInfo) {
@@ -112,8 +89,19 @@ export class LayoutEngine {
                 const value = net.params.get(NetGraphicsParams.LineWidth);
                 renderNet.lineWidth = milsToMM(value).toNumber();
             }
-            if (net.params.has(NetGraphicsParams.Highight)) {
-                renderNet.highlight = net.params.get(NetGraphicsParams.Highight);
+            if (net.params.has(NetGraphicsParams.Highlight)) {
+                renderNet.highlight =
+                    net.params.get(NetGraphicsParams.Highlight);
+            }
+            if (net.params.has(NetGraphicsParams.HighlightWidth)) {
+                renderNet.highlightWidth =
+                    milsToMM(net.params.get(NetGraphicsParams.HighlightWidth))
+                        .toNumber();
+            }
+            if (net.params.has(NetGraphicsParams.HighlightOpacity)) {
+                renderNet.highlightOpacity =
+                    net.params.get(NetGraphicsParams.HighlightOpacity)
+                        .toNumber();
             }
             renderNets.set(net.toString(), renderNet);
         });
@@ -167,12 +155,13 @@ export class LayoutEngine {
                 });
             }
             else {
-                const { intersectPoints, segments } = Geometry.mergeWires(allLines);
+                const { intersectPoints, segments, lines } = Geometry.mergeWires(allLines);
                 mergedWires.push({
                     netName: netName,
                     segments,
                     intersectPoints,
                     net: renderNet,
+                    lines,
                 });
                 intersectPoints.forEach(([x, y]) => {
                     junctions.push(new RenderJunction(numeric(x), numeric(y), renderNet));
@@ -631,158 +620,6 @@ export class LayoutEngine {
             }
         }
     }
-    generateLayoutGraph(sequence, nets) {
-        let previousNode = null;
-        let previousPin = null;
-        const graph = new Graph({
-            directed: true,
-            compound: true,
-        });
-        this.print('sequence length:', sequence.length);
-        const baseFrame = new RenderFrame(new Frame(FixedFrameIds.BaseFrame));
-        const frameStack = [baseFrame];
-        const containerFrames = [baseFrame];
-        sequence.forEach((sequenceStep, index) => {
-            const action = sequenceStep[0];
-            let tmpComponent;
-            switch (action) {
-                case SequenceAction.To:
-                case SequenceAction.At: {
-                    this.print(...sequenceStep);
-                    const [, component, pin] = sequenceStep;
-                    const tmpInstanceName = component.instanceName;
-                    if (!graph.hasNode(tmpInstanceName)) {
-                        this.print('create instance', tmpInstanceName);
-                        const { displayProp = null } = component;
-                        let tmpSymbol;
-                        if (displayProp instanceof SymbolDrawing) {
-                            tmpSymbol = new SymbolPlaceholder(displayProp);
-                            tmpSymbol.drawing.logger = this.logger;
-                        }
-                        else {
-                            const symbolPinDefinitions = generateLayoutPinDefinition(component);
-                            if (component.typeProp === ComponentTypes.module) {
-                                tmpSymbol = new SymbolCustomModule(symbolPinDefinitions, component.pinsMaxPositions);
-                            }
-                            else {
-                                tmpSymbol = new SymbolCustom(symbolPinDefinitions, component.pinsMaxPositions);
-                            }
-                        }
-                        applyComponentParamsToSymbol(component, tmpSymbol);
-                        tmpSymbol.refreshDrawing();
-                        const { width: useWidth, height: useHeight } = tmpSymbol.size();
-                        tmpComponent = new RenderComponent(component, useWidth, useHeight);
-                        tmpComponent.symbol = tmpSymbol;
-                        graph.setNode(tmpInstanceName, [RenderItemType.Component, tmpComponent, index]);
-                        const currentFrame = frameStack[frameStack.length - 1];
-                        currentFrame && currentFrame.innerItems.push(tmpComponent);
-                    }
-                    if (action === SequenceAction.To && previousNode && previousPin) {
-                        this.setGraphEdge(graph, previousNode, tmpInstanceName, makeEdgeValue(previousNode, previousPin, tmpInstanceName, pin, index));
-                    }
-                    previousNode = tmpInstanceName;
-                    previousPin = pin;
-                    break;
-                }
-                case SequenceAction.Wire: {
-                    const [, wireId, wireSegments] = sequenceStep;
-                    let useNet;
-                    if (previousNode !== null) {
-                        const [prevNodeType, prevNodeItem] = graph.node(previousNode);
-                        if (prevNodeType === RenderItemType.Component) {
-                            const matchingItem = nets.find(([comp, pin]) => {
-                                return comp.instanceName === previousNode
-                                    && pin === previousPin;
-                            });
-                            if (matchingItem !== undefined) {
-                                useNet = matchingItem[2];
-                            }
-                        }
-                        else if (prevNodeType === RenderItemType.Wire) {
-                            useNet = prevNodeItem.net;
-                        }
-                    }
-                    const wire = new RenderWire(useNet, numeric(0), numeric(0), wireSegments);
-                    wire.id = wireId;
-                    wire.netName = useNet.toString();
-                    const wireName = getWireName(wire.id);
-                    graph.setNode(wireName, [RenderItemType.Wire, wire, index]);
-                    this.setGraphEdge(graph, previousNode, wireName, makeEdgeValue(previousNode, previousPin, wireName, 0, index));
-                    previousNode = wireName;
-                    previousPin = 1;
-                    const wireSegmentsInfo = wireSegments.map(item => {
-                        const tmp = {
-                            direction: item.direction,
-                            value: item.value,
-                        };
-                        if (item.valueXY) {
-                            tmp.valueXY = item.valueXY;
-                        }
-                        if (item.until) {
-                            tmp.until = [item.until[0].toString(), item.until[1]];
-                        }
-                        return tmp;
-                    });
-                    this.print(SequenceAction.Wire, wireId, JSON.stringify(wireSegmentsInfo));
-                    break;
-                }
-                case SequenceAction.WireJump: {
-                    this.print(...sequenceStep);
-                    const wireId = sequenceStep[1];
-                    const wireName = getWireName(wireId);
-                    let wirePin = 1;
-                    if (sequenceStep.length === 3) {
-                        wirePin = sequenceStep[2];
-                    }
-                    previousNode = wireName;
-                    previousPin = wirePin;
-                    break;
-                }
-                case SequenceAction.Frame: {
-                    const [, frameObject, frameAction] = sequenceStep;
-                    if (frameAction === FrameAction.Enter) {
-                        const prevFrame = frameStack[frameStack.length - 1];
-                        const newFrame = new RenderFrame(frameObject);
-                        if (frameObject.parameters.has(FrameParamKeys.Direction)) {
-                            newFrame.direction =
-                                frameObject.parameters.get(FrameParamKeys.Direction);
-                        }
-                        if (frameObject.parameters.has(FrameParamKeys.Padding)) {
-                            newFrame.padding = milsToMM(frameObject.parameters.get(FrameParamKeys.Padding));
-                        }
-                        if (frameObject.parameters.has(FrameParamKeys.Border)) {
-                            newFrame.borderWidth =
-                                frameObject.parameters.get(FrameParamKeys.Border);
-                        }
-                        if (frameObject.parameters.has(FrameParamKeys.Width)) {
-                            newFrame.width = milsToMM(frameObject.parameters.get(FrameParamKeys.Width));
-                        }
-                        if (frameObject.parameters.has(FrameParamKeys.Height)) {
-                            newFrame.height = milsToMM(frameObject.parameters.get(FrameParamKeys.Height));
-                        }
-                        containerFrames.push(newFrame);
-                        frameStack.push(newFrame);
-                        prevFrame && prevFrame.innerItems.push(newFrame);
-                    }
-                    else if (frameAction === FrameAction.Exit) {
-                        frameStack.pop();
-                    }
-                    break;
-                }
-            }
-        });
-        return {
-            graph,
-            containerFrames,
-        };
-    }
-    setGraphEdge(graph, node1, node2, edgeValue) {
-        if (!graph.isDirected && graph.hasEdge(node1, node2)) {
-            this.print(`Warning: edge already exists ${node1} ${node2}`);
-        }
-        graph.setEdge(node1, node2, edgeValue);
-        this.print(`created edge: node1:${node1} node2:${node2} edgeValue:${edgeValue}`);
-    }
     sizeSubGraphs(graph) {
         const subGraphs = alg.components(graph);
         const subGraphsStarts = [];
@@ -1080,52 +917,6 @@ function getNeighbours(graph, nodeIds) {
         return accum;
     }, []);
 }
-function makeEdgeValue(instanceName1, instancePin1, instanceName2, instancePin2, priority) {
-    return [instanceName1, instancePin1, instanceName2, instancePin2, priority];
-}
-function getWireName(wireId) {
-    return 'wire:' + wireId;
-}
-function generateLayoutPinDefinition(component) {
-    const pins = component.pins;
-    const symbolPinDefinitions = [];
-    const existingPinIds = Array.from(pins.keys());
-    const arrangeProps = component.arrangeProps ?? [];
-    const addedPins = [];
-    for (const [key, items] of arrangeProps) {
-        let useItems;
-        if (!Array.isArray(items)) {
-            useItems = [items];
-        }
-        else {
-            useItems = [...items];
-        }
-        useItems.forEach(pinId => {
-            if (pinId instanceof NumericValue) {
-                const pinIdValue = pinId.toNumber();
-                if (existingPinIds.indexOf(pinIdValue) !== -1) {
-                    const pin = pins.get(pinIdValue);
-                    symbolPinDefinitions.push({
-                        side: key,
-                        pinId: pinIdValue,
-                        text: pin.name,
-                        position: pin.position,
-                        pinType: pin.pinType,
-                    });
-                    addedPins.push(pinIdValue);
-                }
-            }
-        });
-    }
-    const unplacedPins = existingPinIds.filter(pinId => {
-        return addedPins.indexOf(pinId) === -1;
-    });
-    if (unplacedPins.length > 0) {
-        component._unplacedPins = unplacedPins;
-        console.warn("Warning: There are unplaced pins: " + unplacedPins);
-    }
-    return symbolPinDefinitions;
-}
 export function applyComponentParamsToSymbol(component, symbol) {
     const { widthProp = null, heightProp = null } = component;
     const newMap = new Map(component.parameters);
@@ -1511,8 +1302,3 @@ export function ExtractDrawingRects(drawing) {
 function isPointOverlap(x, y, other) {
     return (x >= other.x && y >= other.y && x <= (other.x + other.width) && y <= (other.y + other.height));
 }
-var RenderItemType;
-(function (RenderItemType) {
-    RenderItemType["Wire"] = "wire";
-    RenderItemType["Component"] = "component";
-})(RenderItemType || (RenderItemType = {}));

package/dist/esm/objects/types.js

@@ -1,4 +1,21 @@
+import { ReferenceTypes } from '../globals.js';
 import { RuntimeExecutionError } from '../utils.js';
+export class CFunctionEntry {
+    name;
+    execute;
+    uniqueId;
+    source;
+    constructor(name, execute, source, uniqueId) {
+        this.name = name;
+        this.execute = execute;
+        this.uniqueId = uniqueId;
+        this.source = source;
+    }
+    toString() {
+        return `[Function: ${this.name}]`;
+    }
+}
+;
 export class AnyReference {
     found = false;
     name;
@@ -6,21 +23,27 @@ export class AnyReference {
     type;
     value;
     parentValue;
+    referenceName = 'AnyReference';
     constructor(refType) {
-        if (refType.value instanceof AnyReference) {
+        if (refType.value instanceof AnyReference
+            && refType.value.type !== ReferenceTypes.function) {
             throw new RuntimeExecutionError("Nested reference types!");
         }
         this.found = refType.found;
         this.name = refType.name;
         this.trailers = refType.trailers;
-        this.type = refType.type;
+        this.type = refType.type ?? ReferenceTypes.unknown;
         this.value = refType.value;
         this.parentValue = refType.parentValue;
     }
+    toString() {
+        return `[${this.referenceName} name: ${this.name} trailers:${this.trailers} found: ${this.found}]`;
+    }
 }
-export class UndeclaredReference {
+export class UndeclaredReference extends AnyReference {
     reference;
     constructor(reference) {
+        super(reference);
         this.reference = reference;
     }
     throwMessage() {
@@ -39,9 +62,7 @@ export class UndeclaredReference {
     }
 }
 export class DeclaredReference extends AnyReference {
-    toString() {
-        return `[DeclaredReference name: ${this.name} trailers:${this.trailers} found: ${this.found}]`;
-    }
+    referenceName = 'DeclaredReference';
     toDisplayString() {
         let returnValue = undefined;
         if (this.parentValue) {

package/dist/esm/render.js

@@ -172,12 +172,14 @@ function generateSVGChild(canvas, components, wires, junctions, mergedWires, fra
     const mergedWireHighlightGroup = canvas.group();
     const mergedWireGroup = canvas.group();
     mergedWires.forEach(tmpItem => {
-        const { segments, intersectPoints, net = null } = tmpItem;
+        const { intersectPoints, net = null, lines = null } = tmpItem;
         let useJunctionColor = ColorScheme.JunctionColor;
         let useColor = ColorScheme.WireColor;
         let useLineWidth = defaultWireLineWidth;
         let displayHighlight = false;
         let displayHighlightColor = null;
+        let displayHighlightOpacity = 0.3;
+        let displayHighlightWidth = 5 * MilsToMM;
         if (net !== null) {
             useColor = net.color ?? ColorScheme.WireColor;
             useJunctionColor = net.color ?? ColorScheme.JunctionColor;
@@ -185,25 +187,29 @@ function generateSVGChild(canvas, components, wires, junctions, mergedWires, fra
             if (net.highlight !== null) {
                 displayHighlight = true;
                 displayHighlightColor = net.highlight ?? null;
+                if (net.highlightOpacity !== undefined) {
+                    displayHighlightOpacity = net.highlightOpacity;
+                }
+                if (net.highlightWidth !== undefined) {
+                    displayHighlightWidth = net.highlightWidth;
+                }
             }
         }
         const pathItems = [];
-        const highlightExtraSize = 5 * MilsToMM;
-        segments.forEach(segment => {
-            const pt1 = segment[0];
-            const pt2 = segment[1];
-            pathItems.push(...[
-                'M', pt1[0], pt1[1],
-                'L', pt2[0], pt2[1]
-            ]);
+        const useLines = lines ?? [];
+        useLines.forEach(line => {
+            line.forEach((point, index) => {
+                const commandType = (index === 0) ? 'M' : 'L';
+                pathItems.push(...[commandType, point[0], point[1]]);
+            });
         });
         if (displayHighlight) {
             mergedWireHighlightGroup.path(pathItems)
                 .stroke({
-                width: useLineWidth + highlightExtraSize,
+                width: useLineWidth + displayHighlightWidth,
                 color: displayHighlightColor,
-                opacity: 0.3,
-                linecap: 'square'
+                opacity: displayHighlightOpacity,
+                linecap: 'butt'
             })
                 .fill('none');
         }
@@ -211,11 +217,11 @@ function generateSVGChild(canvas, components, wires, junctions, mergedWires, fra
             .stroke({
             width: useLineWidth,
             color: useColor,
-            linecap: 'square'
+            linecap: 'butt'
         })
             .fill('none');
         const halfJunctionSize = junctionSize.half();
-        const highlightJunctionSize = numeric(junctionSize.toNumber() + highlightExtraSize);
+        const highlightJunctionSize = numeric(junctionSize.toNumber() + displayHighlightWidth);
         const tmpHighlightExtraSize = highlightJunctionSize.half();
         intersectPoints.forEach(point => {
             const [x, y,] = point;

package/dist/esm/visitor.js

@@ -2,7 +2,7 @@ import { ClassComponent } from './objects/ClassComponent.js';
 import { NumberOperator, numeric, NumericValue, ParamDefinition } from './objects/ParamDefinition.js';
 import { PinDefinition, PinIdType } from './objects/PinDefinition.js';
 import { PinTypes } from './objects/PinTypes.js';
-import { DeclaredReference, UndeclaredReference } from './objects/types.js';
+import { AnyReference, DeclaredReference, UndeclaredReference } from './objects/types.js';
 import { BlockTypes, ComponentTypes, Delimiter1, FrameType, GlobalDocumentName, ModuleContainsKeyword, NoNetText, ParamKeys, ReferenceTypes, SymbolPinSide, ValidPinSides, WireAutoDirection } from './globals.js';
 import { unwrapValue } from "./utils.js";
 import { PlaceHolderCommands, SymbolDrawingCommands } from './draw_symbols.js';
@@ -376,7 +376,7 @@ export class ParserVisitor extends BaseVisitor {
         if (ctxNestedProperties) {
             const nestedKeyValues = this.visitResult(ctxNestedProperties);
             nestedKeyValues.forEach((value, key) => {
-                parameters.push(['keyword', key, value]);
+                parameters.push(['keyword', key, unwrapValue(value)]);
             });
         }
         else {
@@ -534,36 +534,36 @@ export class ParserVisitor extends BaseVisitor {
         this.setResult(ctx, result);
     };
     visitData_expr_with_assignment = (ctx) => {
-        let component = null;
-        let componentCtx = null;
+        let dataResult = null;
+        let componentCtx;
         const ctxDataExpr = ctx.data_expr();
         const ctxAssignmentExpr = ctx.assignment_expr();
         if (ctxDataExpr) {
-            component = this.visitResult(ctxDataExpr);
-            component = unwrapValue(component);
+            dataResult = this.visitResult(ctxDataExpr);
             componentCtx = ctxDataExpr;
-            if (component === null || component === undefined) {
-                this.throwWithContext(ctxDataExpr, "Could not find component: " + ctxDataExpr.getText());
-            }
         }
         else if (ctxAssignmentExpr) {
-            component = this.visitResult(ctxAssignmentExpr);
+            dataResult = this.visitResult(ctxAssignmentExpr);
             componentCtx = ctxAssignmentExpr;
         }
-        if (component instanceof ClassComponent
-            && component.copyProp) {
-            component = this.getExecutor().copyComponent(component);
-        }
-        if (component instanceof UndeclaredReference) {
-            const { reference: { trailers = [], parentValue = null } } = component;
+        if (dataResult instanceof AnyReference) {
+            const { trailers = [], parentValue = null } = dataResult;
             if (parentValue instanceof ClassComponent
                 && trailers.length > 0
                 && trailers[0] === ModuleContainsKeyword) {
-                component = parentValue;
-                this.placeModuleContains(component);
+                dataResult = parentValue;
+                this.placeModuleContains(dataResult);
             }
         }
-        if (component && component instanceof ClassComponent) {
+        dataResult = unwrapValue(dataResult);
+        if (dataResult === null || dataResult === undefined) {
+            this.throwWithContext(componentCtx, "Could not find component: " + componentCtx.getText());
+        }
+        if (dataResult instanceof ClassComponent
+            && dataResult.copyProp) {
+            dataResult = this.getExecutor().copyComponent(dataResult);
+        }
+        if (dataResult && dataResult instanceof ClassComponent) {
             const modifiers = ctx.component_modifier_expr();
             modifiers.forEach(modifier => {
                 const modifierText = modifier.ID(0).getText();
@@ -580,23 +580,23 @@ export class ParserVisitor extends BaseVisitor {
                 if (modifierText === ParamKeys.flip) {
                     const flipValue = result;
                     if (flipValue.indexOf('x') !== -1) {
-                        component.setParam(ParamKeys.flipX, 1);
+                        dataResult.setParam(ParamKeys.flipX, 1);
                         shouldIgnoreWireOrientation = true;
                     }
                     if (flipValue.indexOf('y') !== -1) {
-                        component.setParam(ParamKeys.flipY, 1);
+                        dataResult.setParam(ParamKeys.flipY, 1);
                         shouldIgnoreWireOrientation = true;
                     }
                 }
                 else if (modifierText === ParamKeys.angle) {
-                    component.setParam(ParamKeys.angle, result);
+                    dataResult.setParam(ParamKeys.angle, result);
                     shouldIgnoreWireOrientation = true;
                 }
                 else if (modifierText === 'anchor') {
-                    component.setParam('anchor', result);
+                    dataResult.setParam('anchor', result);
                 }
                 if (shouldIgnoreWireOrientation) {
-                    component.useWireOrientationAngle = false;
+                    dataResult.useWireOrientationAngle = false;
                 }
             });
         }
@@ -606,15 +606,15 @@ export class ParserVisitor extends BaseVisitor {
             pinValue = this.visitResult(ctxPinSelectExpr);
         }
         else {
-            if (component instanceof ClassComponent) {
-                pinValue = component.getDefaultPin();
+            if (dataResult instanceof ClassComponent) {
+                pinValue = dataResult.getDefaultPin();
             }
             else {
-                const undeclaredRef = component;
+                const undeclaredRef = dataResult;
                 this.throwWithContext(componentCtx, 'Invalid component: ' + undeclaredRef.reference.name);
             }
         }
-        this.setResult(ctx, [component, pinValue]);
+        this.setResult(ctx, [dataResult, pinValue]);
     };
     expandModuleContains(component, netNamespace) {
         this.getExecutor().log('expanding module `contains`');
@@ -794,8 +794,8 @@ export class ParserVisitor extends BaseVisitor {
         this.setResult(ctx, result);
     };
     visitAdditionExpr = (ctx) => {
-        const value1 = this.resolveDataExpr(ctx.data_expr(0));
-        const value2 = this.resolveDataExpr(ctx.data_expr(1));
+        const value1 = unwrapValue(this.resolveDataExpr(ctx.data_expr(0)));
+        const value2 = unwrapValue(this.resolveDataExpr(ctx.data_expr(1)));
         if (ctx.Addition() && (typeof value1 === 'string' || typeof value2 === 'string')) {
             let tmpValue1 = value1;
             if (value1 instanceof NumericValue) {
@@ -824,6 +824,8 @@ export class ParserVisitor extends BaseVisitor {
     };
     visitFunction_def_expr = (ctx) => {
         const functionName = ctx.ID().getText();
+        const uniqueFunctionID = '__._' + ctx.start.line + '_'
+            + ctx.start.column + '_' + functionName + '_' + ctx.getText();
         let funcDefinedParameters = [];
         const ctxFunctionArgsExpr = ctx.function_args_expr();
         if (ctxFunctionArgsExpr) {
@@ -845,7 +847,7 @@ export class ParserVisitor extends BaseVisitor {
             nextLastExecution.mergeScope(lastExecution.scope, executionContextName);
             return [lastExecution, returnValue];
         };
-        this.getExecutor().createFunction(functionName, __runFunc);
+        this.getExecutor().createFunction(functionName, __runFunc, ctx, uniqueFunctionID);
     };
     visitPin_select_expr2 = (ctx) => {
         const ctxStringValue = ctx.STRING_VALUE();

package/dist/types/BaseVisitor.d.ts

@@ -1,4 +1,4 @@
-import { Array_exprContext, ArrayExprContext, Assignment_exprContext, Atom_exprContext, ExpressionContext, Flow_expressionsContext, Function_args_exprContext, Function_call_exprContext, Function_exprContext, Function_return_exprContext, FunctionCallExprContext, Import_exprContext, Operator_assignment_exprContext, ParametersContext, RoundedBracketsExprContext, ScriptContext, Value_exprContext, ValueAtomExprContext } from "./antlr/CircuitScriptParser.js";
+import { Array_exprContext, ArrayExprContext, ArrayIndexExprContext, Assignment_exprContext, Atom_exprContext, ExpressionContext, Flow_expressionsContext, Function_args_exprContext, Function_call_exprContext, Function_exprContext, Function_return_exprContext, FunctionCallExprContext, Import_exprContext, Operator_assignment_exprContext, ParametersContext, RoundedBracketsExprContext, ScriptContext, Trailer_expr2Context, Value_exprContext, ValueAtomExprContext } from "./antlr/CircuitScriptParser.js";
 import { CircuitScriptVisitor } from "./antlr/CircuitScriptVisitor.js";
 import { ExecutionContext } from "./execute.js";
 import { Logger } from "./logger.js";
@@ -46,6 +46,7 @@ export declare class BaseVisitor extends CircuitScriptVisitor<ComplexType | AnyR
     visitAssignment_expr: (ctx: Assignment_exprContext) => void;
     visitOperator_assignment_expr: (ctx: Operator_assignment_exprContext) => void;
     private getReference;
+    visitTrailer_expr2: (ctx: Trailer_expr2Context) => void;
     visitAtom_expr: (ctx: Atom_exprContext) => void;
     visitFunctionCallExpr: (ctx: FunctionCallExprContext) => void;
     visitFunction_call_expr: (ctx: Function_call_exprContext) => void;
@@ -59,6 +60,7 @@ export declare class BaseVisitor extends CircuitScriptVisitor<ComplexType | AnyR
     visitFlow_expressions: (ctx: Flow_expressionsContext) => void;
     visitArray_expr: (ctx: Array_exprContext) => void;
     visitArrayExpr: (ctx: ArrayExprContext) => void;
+    visitArrayIndexExpr: (ctx: ArrayIndexExprContext) => void;
     protected setResult(ctx: ParserRuleContext, value: any): void;
     protected getResult(ctx: ParserRuleContext): any;
     visitResult(ctx: ParserRuleContext): any;