circuitscript 0.0.32 → 0.0.35

package/dist/esm/render.mjs

@@ -1,37 +1,116 @@
 import { SVG, registerWindow } from '@svgdotjs/svg.js';
-import { RenderFrameType, getBounds } from "./layout.mjs";
+import { ExtractDrawingRects, RenderFrameType, getBounds } from "./layout.mjs";
 import { applyFontsToSVG, getCreateSVGWindow } from './sizing.mjs';
-import { ColorScheme, ComponentTypes, MMToPx, ParamKeys, defaultGridSizeUnits, defaultWireLineWidth, defaultZoomScale, fontDisplayScale, junctionSize } from './globals.mjs';
+import { ColorScheme, ComponentTypes, FrameType, MMToPt, MMToPx, ParamKeys, RenderFlags, defaultFont, defaultGridSizeUnits, defaultPageSpacingMM, defaultWireLineWidth, fontDisplayScale, junctionSize } from './globals.mjs';
 import { NumericValue } from './objects/ParamDefinition.mjs';
 import { getBoundsSize } from './utils.mjs';
-import { milsToMM } from './helpers.mjs';
-export function generateSVG2(graph) {
+import { getPaperSize, milsToMM, PaperGridReferences } from './helpers.mjs';
+import SVGtoPDF from 'svg-to-pdfkit';
+import { FrameParamKeys } from './objects/Frame.mjs';
+import { SymbolPlaceholder } from './draw_symbols.mjs';
+function createSvgCanvas() {
     const window = getCreateSVGWindow()();
     const document = window.document;
     registerWindow(window, document);
     const canvas = SVG(document.documentElement);
     applyFontsToSVG(canvas);
-    generateSVGChild(canvas, graph.components, graph.wires, graph.junctions, graph.mergedWires, graph.frameObjects, graph.textObjects);
-    const scale = MMToPx * defaultZoomScale;
+    return canvas;
+}
+export function renderSheetsToSVG(sheetFrames) {
+    const canvas = createSvgCanvas();
+    sheetFrames.forEach((sheet, index) => {
+        const sheetGroup = canvas.group();
+        sheetGroup.id('sheet-' + index);
+        const { components, wires, junctions, mergedWires, frames, textObjects } = sheet;
+        const allFrames = [sheet.frame, ...frames];
+        let gridBounds = null;
+        let extendGrid = true;
+        let xOffset = 0;
+        let yOffset = 0;
+        let sheetYOffset = 0;
+        if (sheet.frame.frame) {
+            const frameComponent = sheet.frame.frame.parameters
+                .get(FrameParamKeys.SheetFrame);
+            if (frameComponent) {
+                if (frameComponent.displayProp === null) {
+                    throw 'Invalid graphic object for sheet frame';
+                }
+                const frameRects = ExtractDrawingRects(frameComponent.displayProp) ?? [];
+                let originalWidthMM = 0;
+                let originalHeightMM = 0;
+                let widthMM = 0;
+                let heightMM = 0;
+                if (frameRects[0]) {
+                    originalWidthMM = milsToMM(frameRects[0].width);
+                    originalHeightMM = milsToMM(frameRects[0].height);
+                }
+                if (frameRects[1]) {
+                    widthMM = milsToMM(frameRects[1].width);
+                    heightMM = milsToMM(frameRects[1].height);
+                }
+                xOffset = (originalWidthMM - widthMM) / 2;
+                yOffset = (originalHeightMM - heightMM) / 2;
+                sheetYOffset = index * (originalHeightMM + defaultPageSpacingMM);
+                gridBounds = {
+                    xmin: 0,
+                    ymin: 0,
+                    xmax: widthMM,
+                    ymax: heightMM
+                };
+                extendGrid = false;
+            }
+        }
+        const sheetElements = sheetGroup.group();
+        generateSVGChild(sheetElements, components, wires, junctions, mergedWires, allFrames, textObjects, gridBounds, extendGrid);
+        sheetElements.translate(xOffset, yOffset);
+        sheetGroup.translate(0, sheetYOffset);
+    });
+    return canvas;
+}
+export function generateSvgOutput(canvas, zoomScale = 1) {
+    const scale = MMToPx * zoomScale;
     const { x, y, width, height } = canvas.bbox();
     const scaledWidth = width * scale;
     const scaledHeight = height * scale;
     canvas.size(scaledWidth, scaledHeight);
     canvas.viewbox(x, y, width, height);
-    return {
-        svg: canvas.svg(),
-        width, height,
-    };
+    return canvas.svg();
 }
-function generateSVGChild(canvas, components, wires, junctions, mergedWires, frameObjects, textObjects) {
-    const displayWireId = false;
-    const bounds = getBounds(components, wires, junctions, frameObjects);
-    drawGrid(canvas.group().translate(0, 0), {
-        x: bounds.xmin,
-        y: bounds.ymin,
-        x2: bounds.xmax,
-        y2: bounds.ymax
+export function generatePdfOutput(doc, canvas, sheetSize, sheetSizeDefined, zoomScale = 1) {
+    const children = canvas.children();
+    const numChildren = children.length;
+    const scale = MMToPx * zoomScale;
+    const { originalWidthMM, originalHeightMM } = getPaperSize(sheetSize);
+    children.forEach((child, index) => {
+        const sheetCanvas = createSvgCanvas();
+        sheetCanvas.add(child);
+        const { x, y, width, height } = sheetCanvas.bbox();
+        const sheetBorder = child.find('#sheet-border');
+        if (sheetBorder.length > 0) {
+            sheetBorder[0].remove();
+        }
+        const scaledWidth = width * scale;
+        const scaledHeight = height * scale;
+        sheetCanvas.size(scaledWidth, scaledHeight);
+        sheetCanvas.viewbox(x, y, width, height);
+        let xOffset = 0;
+        let yOffset = 0;
+        if (!sheetSizeDefined) {
+            xOffset = (originalWidthMM - width) / 2;
+            yOffset = (originalHeightMM - height) / 2;
+        }
+        SVGtoPDF(doc, sheetCanvas.svg(), xOffset * MMToPt, yOffset * MMToPt);
+        if (index + 1 < numChildren) {
+            doc.addPage();
+        }
     });
+}
+function generateSVGChild(canvas, components, wires, junctions, mergedWires, frameObjects, textObjects, gridBounds, extendGrid) {
+    const displayWireId = false;
+    if (gridBounds === null) {
+        gridBounds = getBounds(components, wires, junctions, frameObjects);
+    }
+    drawGrid(canvas.group().translate(0, 0), gridBounds, extendGrid);
     components.forEach(item => {
         const { x, y, width, height } = item;
         const symbolGroup = canvas.group();
@@ -98,25 +177,29 @@ function generateSVGChild(canvas, components, wires, junctions, mergedWires, fra
         });
     });
     const frameGroup = canvas.group();
-    const showElementFrames = false;
     frameObjects.forEach(item => {
         const { bounds, borderWidth } = item;
-        if (borderWidth > 0) {
-            const { width, height } = getBoundsSize(bounds);
-            let strokeColor = '#111';
-            if (item.type === RenderFrameType.Container) {
-                strokeColor = '#111';
-            }
-            else if (item.type === RenderFrameType.Elements) {
-                strokeColor = '#aaa';
-                if (!showElementFrames) {
-                    return;
+        const { width, height } = getBoundsSize(bounds);
+        let strokeColor = '#111';
+        if (item.frame.frameType === FrameType.Sheet) {
+            drawSheetFrameBorder(frameGroup, item);
+        }
+        else {
+            if (borderWidth > 0) {
+                if (item.type === RenderFrameType.Container) {
+                    strokeColor = '#111';
+                }
+                else if (item.type === RenderFrameType.Elements) {
+                    strokeColor = '#aaa';
+                    if (!RenderFlags.ShowElementFrames) {
+                        return;
+                    }
                 }
+                const tmpRect = frameGroup.rect(width, height)
+                    .fill('none')
+                    .stroke({ width: milsToMM(borderWidth), color: strokeColor });
+                tmpRect.translate(item.x, item.y);
             }
-            const tmpRect = frameGroup.rect(width, height)
-                .fill('none')
-                .stroke({ width: milsToMM(borderWidth), color: strokeColor });
-            tmpRect.translate(item.x, item.y);
         }
     });
     textObjects.forEach(item => {
@@ -125,26 +208,31 @@ function generateSVGChild(canvas, components, wires, junctions, mergedWires, fra
         innerGroup.translate(x, y);
         symbol.draw(innerGroup);
     });
-    const drawOrigin = false;
     const originSize = milsToMM(10);
-    drawOrigin && canvas.group().translate(0, 0)
+    RenderFlags.ShowOrigin && canvas.group().translate(0, 0)
         .circle(originSize)
         .translate(-originSize / 2, -originSize / 2)
         .stroke('none').fill('red');
 }
-function drawGrid(group, canvasSize) {
+function drawGrid(group, canvasSize, extendGrid) {
     const gridSize = defaultGridSizeUnits;
-    const { x, y, x2, y2 } = canvasSize;
-    const gridStartX = (Math.floor(x / gridSize) - 1) * gridSize;
-    const gridStartY = (Math.floor(y / gridSize) - 1) * gridSize;
-    const gridEndX = (Math.ceil(x2 / gridSize) + 1) * gridSize;
-    const gridEndY = (Math.ceil(y2 / gridSize) + 1) * gridSize;
-    const numCols = Math.ceil((gridEndX - gridStartX) / gridSize);
+    const { xmin, ymin, xmax, ymax } = canvasSize;
+    const extraValue = extendGrid ? 1 : 0;
+    const gridStartX = (Math.floor(xmin / gridSize) - extraValue) * gridSize;
+    const gridStartY = (Math.floor(ymin / gridSize) - extraValue) * gridSize;
+    const gridEndX = extendGrid
+        ? (Math.ceil(xmax / gridSize) + extraValue) * gridSize
+        : (xmax - xmin);
+    const gridEndY = extendGrid
+        ? (Math.ceil(ymax / gridSize) + extraValue) * gridSize
+        : (ymax - ymin);
+    const numCols = Math.floor((gridEndX - gridStartX) / gridSize)
+        + (extendGrid ? 1 : 0);
     const lines = [];
     const smallOffset = milsToMM(3);
     const startY = gridStartY - smallOffset / 2;
     const endY = gridEndY + smallOffset;
-    for (let i = 0; i <= numCols; i++) {
+    for (let i = 0; i < numCols; i++) {
         const startX = gridStartX + i * gridSize;
         lines.push(`M ${startX} ${startY} L ${startX} ${endY}`);
     }
@@ -158,3 +246,106 @@ function drawGrid(group, canvasSize) {
         color: '#000'
     });
 }
+function drawSheetFrameBorder(frameGroup, frame) {
+    const frameParams = frame.frame.parameters;
+    if (frameParams.has(FrameParamKeys.SheetFrame)) {
+        const frameComponent = frameParams.get(FrameParamKeys.SheetFrame);
+        const { displayProp = null } = frameComponent ?? {};
+        if (displayProp) {
+            const sheetFrameGroup = frameGroup.group();
+            const symbol = new SymbolPlaceholder(displayProp);
+            symbol.refreshDrawing();
+            symbol.draw(sheetFrameGroup);
+            const offsetX = milsToMM(frameComponent.getParam('offset_x'));
+            const offsetY = milsToMM(frameComponent.getParam('offset_y'));
+            sheetFrameGroup.translate(-offsetX, -offsetY);
+        }
+    }
+}
+function drawSheetFrameBorderDirect(frameGroup, frame, borderWidth, strokeColor, width, height) {
+    const commonStroke = {
+        width: milsToMM(borderWidth),
+        color: strokeColor
+    };
+    const commonFont = {
+        family: defaultFont,
+        size: 50 * fontDisplayScale,
+        'dominant-baseline': 'middle',
+        'text-anchor': 'middle',
+    };
+    let rows = 1;
+    let columns = 1;
+    let showGridReference = true;
+    if (PaperGridReferences[frame.size]) {
+        [rows, columns] = PaperGridReferences[frame.size];
+    }
+    else {
+        showGridReference = false;
+    }
+    if (!showGridReference) {
+        return;
+    }
+    const outerMargin = 2;
+    const outerWidth = width + outerMargin * 2;
+    const outerHeight = height + outerMargin * 2;
+    const outerRect = frameGroup.rect(outerWidth, outerHeight)
+        .fill('none')
+        .stroke(commonStroke);
+    outerRect.translate(frame.x - outerMargin, frame.y - outerMargin);
+    const gridWidth = outerWidth / columns;
+    const gridHeight = outerHeight / rows;
+    const pathPoints = [];
+    for (let i = 1; i < rows + 1; i++) {
+        const lineStartX = frame.x - outerMargin;
+        const lineStartX2 = frame.x - outerMargin + outerWidth - outerMargin;
+        const lineY = frame.y - outerMargin + (gridHeight * i);
+        if (i < rows) {
+            pathPoints.push(...[
+                "M", lineStartX, lineY, "L", lineStartX + outerMargin, lineY,
+                "M", lineStartX2, lineY, "L", lineStartX2 + outerMargin, lineY
+            ]);
+        }
+        const displayValue = String.fromCharCode(i + 64);
+        frameGroup.text(displayValue)
+            .font(commonFont)
+            .translate(lineStartX + outerMargin / 2, lineY - gridHeight / 2);
+        frameGroup.text(displayValue)
+            .font(commonFont)
+            .translate(lineStartX2 + outerMargin / 2, lineY - gridHeight / 2);
+    }
+    for (let i = 1; i < columns + 1; i++) {
+        const lineStartY = frame.y - outerMargin;
+        const lineStartY2 = frame.y - outerMargin + outerHeight - outerMargin;
+        const lineX = frame.x - outerMargin + (gridWidth * i);
+        if (i < columns) {
+            pathPoints.push(...[
+                "M", lineX, lineStartY, "L", lineX, lineStartY + outerMargin,
+                "M", lineX, lineStartY2, "L", lineX, lineStartY2 + outerMargin
+            ]);
+        }
+        frameGroup.text(i.toString())
+            .font(commonFont)
+            .translate(lineX - gridWidth / 2, lineStartY + outerMargin / 2 + milsToMM(10));
+        frameGroup.text(i.toString())
+            .font(commonFont)
+            .translate(lineX - gridWidth / 2, lineStartY2 + outerMargin / 2 + milsToMM(10));
+    }
+    frameGroup.path(pathPoints).stroke(commonStroke);
+    const titleWidth = milsToMM(3000);
+    const titleHeight = milsToMM(1000);
+    const rowHeight = milsToMM(200);
+    const points = [
+        "M", width - titleWidth, height,
+        "L", width - titleWidth, height - titleHeight,
+        "L", width, height - titleHeight,
+        "M", width - titleWidth, height - rowHeight,
+        "L", width, height - rowHeight,
+        "M", width - titleWidth, height - rowHeight * 2,
+        "L", width, height - rowHeight * 2,
+        "M", width - titleWidth, height - rowHeight * 3,
+        "L", width, height - rowHeight * 3
+    ];
+    frameGroup.path(points).stroke(commonStroke).fill('none');
+    if (frame.containsTitle) {
+    }
+}

package/dist/esm/visitor.mjs

@@ -1,13 +1,14 @@
 import { ClassComponent } from './objects/ClassComponent.mjs';
-import { NumericValue, ParamDefinition, PinBlankValue, } from './objects/ParamDefinition.mjs';
+import { NumericValue, ParamDefinition } from './objects/ParamDefinition.mjs';
 import { PinDefinition, PinIdType } from './objects/PinDefinition.mjs';
 import { PinTypes } from './objects/PinTypes.mjs';
 import { DeclaredReference, UndeclaredReference } from './objects/types.mjs';
-import { BlockTypes, ComponentTypes, NoNetText, ReferenceTypes, WireAutoDirection } from './globals.mjs';
+import { BlockTypes, ComponentTypes, FrameType, GlobalDocumentName, NoNetText, ReferenceTypes, WireAutoDirection } from './globals.mjs';
 import { PlaceHolderCommands, SymbolDrawingCommands } from './draw_symbols.mjs';
 import { BaseVisitor } from './BaseVisitor.mjs';
 import { getPortType } from './utils.mjs';
 import { UnitDimension } from './helpers.mjs';
+import { FrameParamKeys } from './objects/Frame.mjs';
 export class ParserVisitor extends BaseVisitor {
     visitKeyword_assignment_expr = (ctx) => {
         const id = ctx.ID().getText();
@@ -151,27 +152,38 @@ export class ParserVisitor extends BaseVisitor {
         this.setResult(ctx, createdComponent);
     };
     visitCreate_graphic_expr = (ctx) => {
+        const graphicsExpressionsCtx = ctx.graphic_expressions_block();
+        this.visit(graphicsExpressionsCtx);
+        const commands = this.getResult(graphicsExpressionsCtx);
+        const drawing = new SymbolDrawingCommands(commands);
+        drawing.source = ctx.getText();
+        this.setResult(ctx, drawing);
+    };
+    visitGraphic_expressions_block = (ctx) => {
         const commands = ctx.graphic_expr().reduce((accum, item) => {
             this.visit(item);
             const [commandName, parameters] = this.getResult(item);
-            const keywordParams = new Map();
-            const positionParams = parameters.reduce((accum, [argType, name, value]) => {
-                if (argType === 'position') {
-                    accum.push(value);
-                }
-                else {
-                    keywordParams.set(name, value);
-                }
-                return accum;
-            }, []);
-            accum.push([commandName, positionParams, keywordParams]);
+            if (commandName === PlaceHolderCommands.for) {
+                accum = accum.concat(parameters);
+            }
+            else {
+                const keywordParams = new Map();
+                const positionParams = parameters.reduce((accum, [argType, name, value]) => {
+                    if (argType === 'position') {
+                        accum.push(value);
+                    }
+                    else {
+                        keywordParams.set(name, value);
+                    }
+                    return accum;
+                }, []);
+                accum.push([commandName, positionParams, keywordParams]);
+            }
             return accum;
         }, []);
-        const drawing = new SymbolDrawingCommands(commands);
-        drawing.source = ctx.getText();
-        this.setResult(ctx, drawing);
+        this.setResult(ctx, commands);
     };
-    visitGraphic_expr = (ctx) => {
+    visitGraphicCommandExpr = (ctx) => {
         let commandName = null;
         const command = ctx._command;
         if (command) {
@@ -208,11 +220,40 @@ export class ParserVisitor extends BaseVisitor {
         }
         this.setResult(ctx, [commandName, parameters]);
     };
+    visitGraphicForExpr = (ctx) => {
+        const forVariableNames = ctx.ID().map(item => item.getText());
+        const ctxDataExpr = ctx.data_expr();
+        this.visit(ctxDataExpr);
+        const listItems = this.getResult(ctxDataExpr);
+        let keepLooping = true;
+        let counter = 0;
+        let allCommands = [];
+        while (keepLooping) {
+            if (counter < listItems.length) {
+                let useValueArray = listItems[counter];
+                if (!Array.isArray(useValueArray)) {
+                    useValueArray = [useValueArray];
+                }
+                useValueArray.forEach((value, index) => {
+                    this.getExecutor().scope.variables.set(forVariableNames[index], value);
+                });
+                const graphicsExpressionsCtx = ctx.graphic_expressions_block();
+                this.visit(graphicsExpressionsCtx);
+                const commands = this.getResult(graphicsExpressionsCtx);
+                allCommands = allCommands.concat(commands);
+                counter += 1;
+            }
+            else {
+                keepLooping = false;
+            }
+        }
+        this.setResult(ctx, [PlaceHolderCommands.for, allCommands]);
+    };
     visitCreate_module_expr = (ctx) => {
         const properties = this.getPropertyExprList(ctx.property_expr());
         const { left: leftPorts, right: rightPorts } = this.parseCreateModulePorts(properties.get('ports'));
         const allPorts = [...leftPorts, ...rightPorts].filter(item => {
-            return !(item instanceof PinBlankValue);
+            return !(Array.isArray(item));
         });
         const nameToPinId = new Map();
         const tmpPorts = allPorts.map((portName, index) => {
@@ -220,7 +261,7 @@ export class ParserVisitor extends BaseVisitor {
             return new PinDefinition(index + 1, PinIdType.Int, portName, PinTypes.Any);
         });
         const arrangeLeftItems = leftPorts.map(item => {
-            if (item instanceof PinBlankValue) {
+            if (Array.isArray(item)) {
                 return item;
             }
             else {
@@ -228,7 +269,7 @@ export class ParserVisitor extends BaseVisitor {
             }
         });
         const arrangeRightItems = rightPorts.map(item => {
-            if (item instanceof PinBlankValue) {
+            if (Array.isArray(item)) {
                 return item;
             }
             else {
@@ -277,6 +318,9 @@ export class ParserVisitor extends BaseVisitor {
         this.visit(ctxPropertyValueExpr);
         const keyName = this.getResult(ctxPropertyKeyExpr);
         const value = this.getResult(ctxPropertyValueExpr);
+        if (value instanceof UndeclaredReference) {
+            throw value.throwMessage();
+        }
         const map = new Map();
         map.set(keyName, value);
         this.setResult(ctx, map);
@@ -571,10 +615,8 @@ export class ParserVisitor extends BaseVisitor {
         this.setResult(ctx, result);
     };
     visitMultiplyExpr = (ctx) => {
-        this.visit(ctx.data_expr(0));
-        this.visit(ctx.data_expr(1));
-        const value1 = this.getResult(ctx.data_expr(0));
-        const value2 = this.getResult(ctx.data_expr(1));
+        const value1 = this.resolveDataExpr(ctx.data_expr(0));
+        const value2 = this.resolveDataExpr(ctx.data_expr(1));
         let result = null;
         if (ctx.Multiply()) {
             result = value1 * value2;
@@ -582,13 +624,14 @@ export class ParserVisitor extends BaseVisitor {
         else if (ctx.Divide()) {
             result = value1 / value2;
         }
+        else if (ctx.Modulus()) {
+            result = value1 % value2;
+        }
         this.setResult(ctx, result);
     };
     visitAdditionExpr = (ctx) => {
-        this.visit(ctx.data_expr(0));
-        this.visit(ctx.data_expr(1));
-        const value1 = this.getResult(ctx.data_expr(0));
-        const value2 = this.getResult(ctx.data_expr(1));
+        const value1 = this.resolveDataExpr(ctx.data_expr(0));
+        const value2 = this.resolveDataExpr(ctx.data_expr(1));
         let result = null;
         if (ctx.Addition()) {
             result = value1 + value2;
@@ -744,7 +787,11 @@ export class ParserVisitor extends BaseVisitor {
         this.runExpressions(this.getExecutor(), ctx.expression());
     };
     visitFrame_expr = (ctx) => {
-        const frameId = this.getExecutor().enterFrame();
+        let frameType = FrameType.Frame;
+        if (ctx.Sheet()) {
+            frameType = FrameType.Sheet;
+        }
+        const frameId = this.getExecutor().enterFrame(frameType);
         this.visit(ctx.expressions_block());
         this.getExecutor().exitFrame(frameId);
     };
@@ -807,6 +854,78 @@ export class ParserVisitor extends BaseVisitor {
         }
         this.setResult(ctx, result);
     };
+    visitWhile_expr = (ctx) => {
+        const dataExpr = ctx.data_expr();
+        let keepLooping = true;
+        this.log('enter while loop');
+        this.getExecutor().addBreakContext(ctx);
+        while (keepLooping) {
+            this.visit(dataExpr);
+            const result = this.getResult(dataExpr);
+            if (result) {
+                this.visit(ctx.expressions_block());
+                keepLooping = true;
+                const currentResult = this.getResult(ctx) ?? {};
+                const { breakSignal = false, continueSignal = false } = currentResult;
+                if (breakSignal && !continueSignal) {
+                    keepLooping = false;
+                }
+                else if (breakSignal && continueSignal) {
+                    this.setResult(ctx, {
+                        ...currentResult,
+                        breakSignal: false,
+                        continueSignal: false
+                    });
+                }
+            }
+            else {
+                keepLooping = false;
+            }
+        }
+        this.getExecutor().popBreakContext();
+        this.log('exit while loop');
+    };
+    visitFor_expr = (ctx) => {
+        const forVariableName = ctx.ID().getText();
+        const ctxDataExpr = ctx.data_expr();
+        this.visit(ctxDataExpr);
+        const listItems = this.getResult(ctxDataExpr);
+        this.getExecutor().addBreakContext(ctx);
+        let keepLooping = true;
+        let counter = 0;
+        while (keepLooping) {
+            if (counter < listItems.length) {
+                this.getExecutor().scope.variables.set(forVariableName, listItems[counter]);
+                this.visit(ctx.expressions_block());
+                keepLooping = true;
+                const currentResult = this.getResult(ctx) ?? {};
+                const { breakSignal = false, continueSignal = false } = currentResult;
+                if (breakSignal && !continueSignal) {
+                    keepLooping = false;
+                }
+                else if (breakSignal && continueSignal) {
+                    this.setResult(ctx, {
+                        ...currentResult,
+                        breakSignal: false,
+                        continueSignal: false
+                    });
+                }
+                counter += 1;
+            }
+            else {
+                keepLooping = false;
+            }
+        }
+        this.getExecutor().popBreakContext();
+    };
+    resolveDataExpr(data_expr) {
+        this.visit(data_expr);
+        const value = this.getResult(data_expr);
+        if (value instanceof UndeclaredReference) {
+            throw value.throwMessage();
+        }
+        return value;
+    }
     pinTypes = [
         PinTypes.Any,
         PinTypes.IO,
@@ -1000,6 +1119,22 @@ export class ParserVisitor extends BaseVisitor {
         this.log('===== annotate done =====');
         this.log('');
     }
+    applySheetFrameComponent() {
+        const baseScope = this.getExecutor().scope;
+        const document = baseScope.variables.get(GlobalDocumentName);
+        let frameComponent = null;
+        if (document && document[FrameParamKeys.SheetFrame]) {
+            frameComponent = document[FrameParamKeys.SheetFrame];
+            baseScope.frames.forEach(item => {
+                if (item.frameType === FrameType.Sheet) {
+                    item.parameters.set(FrameParamKeys.SheetFrame, frameComponent);
+                }
+            });
+        }
+        return {
+            frameComponent
+        };
+    }
     resolveNets(scope, instance) {
         const result = [];
         for (const [pinId, pin] of instance.pins) {

package/dist/types/BaseVisitor.d.ts

@@ -1,4 +1,4 @@
-import { Assignment_exprContext, Atom_exprContext, Blank_exprContext, Break_keywordContext, ExpressionContext, Function_args_exprContext, Function_call_exprContext, Function_exprContext, Function_return_exprContext, FunctionCallExprContext, Import_exprContext, ParametersContext, RoundedBracketsExprContext, ScriptContext, Value_exprContext, ValueAtomExprContext } from "./antlr/CircuitScriptParser";
+import { Array_exprContext, ArrayExprContext, Assignment_exprContext, Atom_exprContext, Break_keywordContext, Continue_keywordContext, ExpressionContext, 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";
 import { CircuitScriptVisitor } from "./antlr/CircuitScriptVisitor";
 import { ExecutionContext } from "./execute";
 import { Logger } from "./logger";
@@ -28,6 +28,7 @@ export declare class BaseVisitor extends CircuitScriptVisitor<ComplexType | Refe
     };
     constructor(silent: boolean | undefined, onErrorHandler: OnErrorCallback | null | undefined, currentDirectory: string | null, defaultLibsPath: string);
     getExecutor(): ExecutionContext;
+    protected toString(obj: any): string;
     protected setupPrintFunction(context: ExecutionContext): void;
     createNetResolver(executionStack: ExecutionContext[]): (netName: string, netNamespace: string) => {
         found: boolean;
@@ -37,17 +38,21 @@ export declare class BaseVisitor extends CircuitScriptVisitor<ComplexType | Refe
     log2(message: string): void;
     visitScript: (ctx: ScriptContext) => void;
     visitAssignment_expr: (ctx: Assignment_exprContext) => void;
+    visitOperator_assignment_expr: (ctx: Operator_assignment_exprContext) => void;
+    private getReference;
     visitAtom_expr: (ctx: Atom_exprContext) => void;
     visitFunctionCallExpr: (ctx: FunctionCallExprContext) => void;
     visitFunction_call_expr: (ctx: Function_call_exprContext) => void;
     visitValue_expr: (ctx: Value_exprContext) => void;
-    visitBlank_expr: (ctx: Blank_exprContext) => void;
     visitValueAtomExpr: (ctx: ValueAtomExprContext) => void;
     visitFunction_args_expr: (ctx: Function_args_exprContext) => void;
     visitParameters: (ctx: ParametersContext) => void;
     visitImport_expr: (ctx: Import_exprContext) => void;
     visitFunction_return_expr: (ctx: Function_return_exprContext) => void;
     visitBreak_keyword: (ctx: Break_keywordContext) => void;
+    visitContinue_keyword: (ctx: Continue_keywordContext) => void;
+    visitArray_expr: (ctx: Array_exprContext) => void;
+    visitArrayExpr: (ctx: ArrayExprContext) => void;
     protected setResult(ctx: ParserRuleContext, value: any): void;
     protected getResult(ctx: ParserRuleContext): any;
     protected handleImportFile(name: string, throwErrors?: boolean): {
@@ -60,6 +65,7 @@ export declare class BaseVisitor extends CircuitScriptVisitor<ComplexType | Refe
     protected runExpressions(executor: ExecutionContext, expressions: ExpressionContext[] | Function_exprContext[]): ComplexType;
     protected getNetNamespace(executorNetNamespace: string, passedNetNamespace: string | null): string;
     protected setInstanceParam(object: ClassComponent, trailers: string[], value: any): void;
+    protected getInstanceParam<T>(object: ClassComponent, trailers: string[]): T;
     protected enterNewChildContext(executionStack: ExecutionContext[], parentContext: ExecutionContext, executionContextName: string, options: CFunctionOptions, funcDefinedParameters: FunctionDefinedParameter[], passedInParameters: CallableParameter[]): ExecutionContext;
     protected prepareStringValue(value: string): string;
 }