circuitscript 0.0.32 → 0.0.34

package/dist/cjs/render.js

@@ -1,6 +1,9 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateSVG2 = void 0;
+exports.generatePdfOutput = exports.generateSvgOutput = exports.renderSheetsToSVG = void 0;
 const svg_js_1 = require("@svgdotjs/svg.js");
 const layout_js_1 = require("./layout.js");
 const sizing_js_1 = require("./sizing.js");
@@ -8,34 +11,115 @@ const globals_js_1 = require("./globals.js");
 const ParamDefinition_js_1 = require("./objects/ParamDefinition.js");
 const utils_js_1 = require("./utils.js");
 const helpers_js_1 = require("./helpers.js");
-function generateSVG2(graph) {
+const svg_to_pdfkit_1 = __importDefault(require("svg-to-pdfkit"));
+const Frame_js_1 = require("./objects/Frame.js");
+const draw_symbols_js_1 = require("./draw_symbols.js");
+function createSvgCanvas() {
     const window = (0, sizing_js_1.getCreateSVGWindow)()();
     const document = window.document;
     (0, svg_js_1.registerWindow)(window, document);
     const canvas = (0, svg_js_1.SVG)(document.documentElement);
     (0, sizing_js_1.applyFontsToSVG)(canvas);
-    generateSVGChild(canvas, graph.components, graph.wires, graph.junctions, graph.mergedWires, graph.frameObjects, graph.textObjects);
-    const scale = globals_js_1.MMToPx * globals_js_1.defaultZoomScale;
+    return canvas;
+}
+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(Frame_js_1.FrameParamKeys.SheetFrame);
+            if (frameComponent) {
+                if (frameComponent.displayProp === null) {
+                    throw 'Invalid graphic object for sheet frame';
+                }
+                const frameRects = (0, layout_js_1.ExtractDrawingRects)(frameComponent.displayProp) ?? [];
+                let originalWidthMM = 0;
+                let originalHeightMM = 0;
+                let widthMM = 0;
+                let heightMM = 0;
+                if (frameRects[0]) {
+                    originalWidthMM = (0, helpers_js_1.milsToMM)(frameRects[0].width);
+                    originalHeightMM = (0, helpers_js_1.milsToMM)(frameRects[0].height);
+                }
+                if (frameRects[1]) {
+                    widthMM = (0, helpers_js_1.milsToMM)(frameRects[1].width);
+                    heightMM = (0, helpers_js_1.milsToMM)(frameRects[1].height);
+                }
+                xOffset = (originalWidthMM - widthMM) / 2;
+                yOffset = (originalHeightMM - heightMM) / 2;
+                sheetYOffset = index * (originalHeightMM + globals_js_1.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;
+}
+exports.renderSheetsToSVG = renderSheetsToSVG;
+function generateSvgOutput(canvas, zoomScale = 1) {
+    const scale = globals_js_1.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();
 }
-exports.generateSVG2 = generateSVG2;
-function generateSVGChild(canvas, components, wires, junctions, mergedWires, frameObjects, textObjects) {
-    const displayWireId = false;
-    const bounds = (0, layout_js_1.getBounds)(components, wires, junctions, frameObjects);
-    drawGrid(canvas.group().translate(0, 0), {
-        x: bounds.xmin,
-        y: bounds.ymin,
-        x2: bounds.xmax,
-        y2: bounds.ymax
+exports.generateSvgOutput = generateSvgOutput;
+function generatePdfOutput(doc, canvas, sheetSize, sheetSizeDefined, zoomScale = 1) {
+    const children = canvas.children();
+    const numChildren = children.length;
+    const scale = globals_js_1.MMToPx * zoomScale;
+    const { originalWidthMM, originalHeightMM } = (0, helpers_js_1.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;
+        }
+        (0, svg_to_pdfkit_1.default)(doc, sheetCanvas.svg(), xOffset * globals_js_1.MMToPt, yOffset * globals_js_1.MMToPt);
+        if (index + 1 < numChildren) {
+            doc.addPage();
+        }
     });
+}
+exports.generatePdfOutput = generatePdfOutput;
+function generateSVGChild(canvas, components, wires, junctions, mergedWires, frameObjects, textObjects, gridBounds, extendGrid) {
+    const displayWireId = false;
+    if (gridBounds === null) {
+        gridBounds = (0, layout_js_1.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();
@@ -102,25 +186,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 } = (0, utils_js_1.getBoundsSize)(bounds);
-            let strokeColor = '#111';
-            if (item.type === layout_js_1.RenderFrameType.Container) {
-                strokeColor = '#111';
-            }
-            else if (item.type === layout_js_1.RenderFrameType.Elements) {
-                strokeColor = '#aaa';
-                if (!showElementFrames) {
-                    return;
+        const { width, height } = (0, utils_js_1.getBoundsSize)(bounds);
+        let strokeColor = '#111';
+        if (item.frame.frameType === globals_js_1.FrameType.Sheet) {
+            drawSheetFrameBorder(frameGroup, item);
+        }
+        else {
+            if (borderWidth > 0) {
+                if (item.type === layout_js_1.RenderFrameType.Container) {
+                    strokeColor = '#111';
+                }
+                else if (item.type === layout_js_1.RenderFrameType.Elements) {
+                    strokeColor = '#aaa';
+                    if (!globals_js_1.RenderFlags.ShowElementFrames) {
+                        return;
+                    }
                 }
+                const tmpRect = frameGroup.rect(width, height)
+                    .fill('none')
+                    .stroke({ width: (0, helpers_js_1.milsToMM)(borderWidth), color: strokeColor });
+                tmpRect.translate(item.x, item.y);
             }
-            const tmpRect = frameGroup.rect(width, height)
-                .fill('none')
-                .stroke({ width: (0, helpers_js_1.milsToMM)(borderWidth), color: strokeColor });
-            tmpRect.translate(item.x, item.y);
         }
     });
     textObjects.forEach(item => {
@@ -129,26 +217,31 @@ function generateSVGChild(canvas, components, wires, junctions, mergedWires, fra
         innerGroup.translate(x, y);
         symbol.draw(innerGroup);
     });
-    const drawOrigin = false;
     const originSize = (0, helpers_js_1.milsToMM)(10);
-    drawOrigin && canvas.group().translate(0, 0)
+    globals_js_1.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 = globals_js_1.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 = (0, helpers_js_1.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}`);
     }
@@ -162,3 +255,106 @@ function drawGrid(group, canvasSize) {
         color: '#000'
     });
 }
+function drawSheetFrameBorder(frameGroup, frame) {
+    const frameParams = frame.frame.parameters;
+    if (frameParams.has(Frame_js_1.FrameParamKeys.SheetFrame)) {
+        const frameComponent = frameParams.get(Frame_js_1.FrameParamKeys.SheetFrame);
+        const { displayProp = null } = frameComponent ?? {};
+        if (displayProp) {
+            const sheetFrameGroup = frameGroup.group();
+            const symbol = new draw_symbols_js_1.SymbolPlaceholder(displayProp);
+            symbol.refreshDrawing();
+            symbol.draw(sheetFrameGroup);
+            const offsetX = (0, helpers_js_1.milsToMM)(frameComponent.getParam('offset_x'));
+            const offsetY = (0, helpers_js_1.milsToMM)(frameComponent.getParam('offset_y'));
+            sheetFrameGroup.translate(-offsetX, -offsetY);
+        }
+    }
+}
+function drawSheetFrameBorderDirect(frameGroup, frame, borderWidth, strokeColor, width, height) {
+    const commonStroke = {
+        width: (0, helpers_js_1.milsToMM)(borderWidth),
+        color: strokeColor
+    };
+    const commonFont = {
+        family: globals_js_1.defaultFont,
+        size: 50 * globals_js_1.fontDisplayScale,
+        'dominant-baseline': 'middle',
+        'text-anchor': 'middle',
+    };
+    let rows = 1;
+    let columns = 1;
+    let showGridReference = true;
+    if (helpers_js_1.PaperGridReferences[frame.size]) {
+        [rows, columns] = helpers_js_1.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 + (0, helpers_js_1.milsToMM)(10));
+        frameGroup.text(i.toString())
+            .font(commonFont)
+            .translate(lineX - gridWidth / 2, lineStartY2 + outerMargin / 2 + (0, helpers_js_1.milsToMM)(10));
+    }
+    frameGroup.path(pathPoints).stroke(commonStroke);
+    const titleWidth = (0, helpers_js_1.milsToMM)(3000);
+    const titleHeight = (0, helpers_js_1.milsToMM)(1000);
+    const rowHeight = (0, helpers_js_1.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/cjs/visitor.js

@@ -11,6 +11,7 @@ const draw_symbols_js_1 = require("./draw_symbols.js");
 const BaseVisitor_js_1 = require("./BaseVisitor.js");
 const utils_js_1 = require("./utils.js");
 const helpers_js_1 = require("./helpers.js");
+const Frame_js_1 = require("./objects/Frame.js");
 class ParserVisitor extends BaseVisitor_js_1.BaseVisitor {
     constructor() {
         super(...arguments);
@@ -156,27 +157,38 @@ class ParserVisitor extends BaseVisitor_js_1.BaseVisitor {
             this.setResult(ctx, createdComponent);
         };
         this.visitCreate_graphic_expr = (ctx) => {
+            const graphicsExpressionsCtx = ctx.graphic_expressions_block();
+            this.visit(graphicsExpressionsCtx);
+            const commands = this.getResult(graphicsExpressionsCtx);
+            const drawing = new draw_symbols_js_1.SymbolDrawingCommands(commands);
+            drawing.source = ctx.getText();
+            this.setResult(ctx, drawing);
+        };
+        this.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 === draw_symbols_js_1.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 draw_symbols_js_1.SymbolDrawingCommands(commands);
-            drawing.source = ctx.getText();
-            this.setResult(ctx, drawing);
+            this.setResult(ctx, commands);
         };
-        this.visitGraphic_expr = (ctx) => {
+        this.visitGraphicCommandExpr = (ctx) => {
             let commandName = null;
             const command = ctx._command;
             if (command) {
@@ -213,11 +225,40 @@ class ParserVisitor extends BaseVisitor_js_1.BaseVisitor {
             }
             this.setResult(ctx, [commandName, parameters]);
         };
+        this.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, [draw_symbols_js_1.PlaceHolderCommands.for, allCommands]);
+        };
         this.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 ParamDefinition_js_1.PinBlankValue);
+                return !(Array.isArray(item));
             });
             const nameToPinId = new Map();
             const tmpPorts = allPorts.map((portName, index) => {
@@ -225,7 +266,7 @@ class ParserVisitor extends BaseVisitor_js_1.BaseVisitor {
                 return new PinDefinition_js_1.PinDefinition(index + 1, PinDefinition_js_1.PinIdType.Int, portName, PinTypes_js_1.PinTypes.Any);
             });
             const arrangeLeftItems = leftPorts.map(item => {
-                if (item instanceof ParamDefinition_js_1.PinBlankValue) {
+                if (Array.isArray(item)) {
                     return item;
                 }
                 else {
@@ -233,7 +274,7 @@ class ParserVisitor extends BaseVisitor_js_1.BaseVisitor {
                 }
             });
             const arrangeRightItems = rightPorts.map(item => {
-                if (item instanceof ParamDefinition_js_1.PinBlankValue) {
+                if (Array.isArray(item)) {
                     return item;
                 }
                 else {
@@ -282,6 +323,9 @@ class ParserVisitor extends BaseVisitor_js_1.BaseVisitor {
             this.visit(ctxPropertyValueExpr);
             const keyName = this.getResult(ctxPropertyKeyExpr);
             const value = this.getResult(ctxPropertyValueExpr);
+            if (value instanceof types_js_1.UndeclaredReference) {
+                throw value.throwMessage();
+            }
             const map = new Map();
             map.set(keyName, value);
             this.setResult(ctx, map);
@@ -527,10 +571,8 @@ class ParserVisitor extends BaseVisitor_js_1.BaseVisitor {
             this.setResult(ctx, result);
         };
         this.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;
@@ -538,13 +580,14 @@ class ParserVisitor extends BaseVisitor_js_1.BaseVisitor {
             else if (ctx.Divide()) {
                 result = value1 / value2;
             }
+            else if (ctx.Modulus()) {
+                result = value1 % value2;
+            }
             this.setResult(ctx, result);
         };
         this.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;
@@ -700,7 +743,11 @@ class ParserVisitor extends BaseVisitor_js_1.BaseVisitor {
             this.runExpressions(this.getExecutor(), ctx.expression());
         };
         this.visitFrame_expr = (ctx) => {
-            const frameId = this.getExecutor().enterFrame();
+            let frameType = globals_js_1.FrameType.Frame;
+            if (ctx.Sheet()) {
+                frameType = globals_js_1.FrameType.Sheet;
+            }
+            const frameId = this.getExecutor().enterFrame(frameType);
             this.visit(ctx.expressions_block());
             this.getExecutor().exitFrame(frameId);
         };
@@ -763,6 +810,70 @@ class ParserVisitor extends BaseVisitor_js_1.BaseVisitor {
             }
             this.setResult(ctx, result);
         };
+        this.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');
+        };
+        this.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();
+        };
         this.pinTypes = [
             PinTypes_js_1.PinTypes.Any,
             PinTypes_js_1.PinTypes.IO,
@@ -820,6 +931,14 @@ class ParserVisitor extends BaseVisitor_js_1.BaseVisitor {
             }
         }
     }
+    resolveDataExpr(data_expr) {
+        this.visit(data_expr);
+        const value = this.getResult(data_expr);
+        if (value instanceof types_js_1.UndeclaredReference) {
+            throw value.throwMessage();
+        }
+        return value;
+    }
     parseCreateComponentPins(pinData) {
         const pins = [];
         if (typeof pinData === 'number') {
@@ -1006,6 +1125,22 @@ class ParserVisitor extends BaseVisitor_js_1.BaseVisitor {
         this.log('===== annotate done =====');
         this.log('');
     }
+    applySheetFrameComponent() {
+        const baseScope = this.getExecutor().scope;
+        const document = baseScope.variables.get(globals_js_1.GlobalDocumentName);
+        let frameComponent = null;
+        if (document && document[Frame_js_1.FrameParamKeys.SheetFrame]) {
+            frameComponent = document[Frame_js_1.FrameParamKeys.SheetFrame];
+            baseScope.frames.forEach(item => {
+                if (item.frameType === globals_js_1.FrameType.Sheet) {
+                    item.parameters.set(Frame_js_1.FrameParamKeys.SheetFrame, frameComponent);
+                }
+            });
+        }
+        return {
+            frameComponent
+        };
+    }
     resolveNets(scope, instance) {
         const result = [];
         for (const [pinId, pin] of instance.pins) {