circuitscript 0.0.29 → 0.0.31

package/dist/esm/main.mjs

@@ -2,7 +2,7 @@
 import { program } from 'commander';
 import figlet from 'figlet';
 import path from 'path';
-import { readFileSync, watch } from 'fs';
+import { readFileSync, watch, existsSync } from 'fs';
 import { prepareSVGEnvironment } from './sizing.mjs';
 import { getDefaultLibsPath, getFontsPath, getPackageVersion, renderScript } from './helpers.mjs';
 export default async function main() {
@@ -47,16 +47,22 @@ export default async function main() {
     let scriptData;
     if (args.length > 0 && args[0]) {
         inputFilePath = args[0];
-        scriptData = readFileSync(inputFilePath, { encoding: 'utf-8' });
-        if (currentDirectory === null) {
-            currentDirectory = path.dirname(inputFilePath);
+        if (existsSync(inputFilePath)) {
+            scriptData = readFileSync(inputFilePath, { encoding: 'utf-8' });
+            if (currentDirectory === null) {
+                currentDirectory = path.dirname(inputFilePath);
+            }
+        }
+        else {
+            console.error("Error: File could not be found");
+            return;
         }
     }
     else if (options.input) {
         scriptData = options.input;
     }
     else {
-        console.log("Error: No input provided");
+        console.error("Error: No input provided");
         return;
     }
     const scriptOptions = {

package/dist/esm/objects/ClassComponent.mjs

@@ -22,8 +22,14 @@ export class ClassComponent {
     followWireOrientationProp = true;
     wireOrientationAngle = 0;
     useWireOrientationAngle = true;
+    didSetWireOrientationAngle = false;
     styles = {};
     assignedRefDes = null;
+    moduleContainsExpressions;
+    moduleCounter = 0;
+    moduleExecutionContext;
+    moduleExecutionContextName;
+    modulePinIdToPortMap;
     constructor(instanceName, numPins, className) {
         this.instanceName = instanceName;
         this.numPins = numPins;

package/dist/esm/objects/ExecutionScope.mjs

@@ -89,7 +89,7 @@ export class ExecutionScope {
             }
         });
         return sortedNet.map(([component, pin, net]) => {
-            return [net.namespace + net.name, component.instanceName, pin];
+            return [net.toString(), component.instanceName, pin];
         });
     }
     printNets() {

package/dist/esm/objects/Net.mjs

@@ -18,10 +18,11 @@ export class Net {
         this.baseName = name;
     }
     toString() {
-        return this.name;
+        return this.namespace + this.name;
     }
     static isSame(netA, netB) {
-        return netA.name === netB.name &&
+        return netA.namespace === netB.namespace &&
+            netA.name === netB.name &&
             netA.baseName === netB.baseName &&
             netA.priority === netB.priority &&
             netA.type === netB.type;

package/dist/esm/objects/PinTypes.mjs

@@ -6,3 +6,9 @@ export var PinTypes;
     PinTypes["IO"] = "io";
     PinTypes["Power"] = "power";
 })(PinTypes || (PinTypes = {}));
+export const AllPinTypes = [
+    PinTypes.Any,
+    PinTypes.Input,
+    PinTypes.Output,
+    PinTypes.IO,
+];

package/dist/esm/objects/types.mjs

@@ -4,6 +4,20 @@ export class UndeclaredReference {
         this.reference = reference;
     }
 }
+export class DeclaredReference {
+    found;
+    name;
+    trailers;
+    type;
+    value;
+    constructor(refType) {
+        this.found = refType.found;
+        this.name = refType.name;
+        this.trailers = refType.trailers;
+        this.type = refType.type;
+        this.value = refType.value;
+    }
+}
 export var ParseSymbolType;
 (function (ParseSymbolType) {
     ParseSymbolType["Variable"] = "variable";

package/dist/esm/regenerate-tests.mjs

@@ -4,7 +4,7 @@ import { prepareSVGEnvironment } from './sizing.mjs';
 const mainDir = './__tests__/renderData/';
 const fontsPath = getFontsPath();
 const defaultLibsPath = getDefaultLibsPath();
-async function regenerateTests() {
+async function regenerateTests(extra = "") {
     await prepareSVGEnvironment(fontsPath);
     const cstFiles = [];
     const files = fs.readdirSync(mainDir);
@@ -16,12 +16,73 @@ async function regenerateTests() {
     cstFiles.forEach(file => {
         const inputPath = mainDir + file;
         const scriptData = fs.readFileSync(inputPath, { encoding: 'utf-8' });
-        const outputPath = inputPath + '.svg';
+        const outputPath = mainDir + 'svgs/' + file + extra + '.svg';
         renderScript(scriptData, outputPath, {
             currentDirectory: mainDir,
             defaultLibsPath,
         });
         console.log('generated ', outputPath);
     });
+    return cstFiles;
 }
-regenerateTests();
+(async () => {
+    const generateDiff = false;
+    const nextExtra = generateDiff ? '.next' : '';
+    const cstFiles = await regenerateTests(nextExtra);
+    const allFiles = [];
+    if (generateDiff) {
+        cstFiles.forEach(file => {
+            const svg1 = 'svgs/' + file + '.svg';
+            const svg2 = 'svgs/' + file + '.next.svg';
+            const cleanedName = file.replace('script', '').replace('.cst', '');
+            allFiles.push([file, svg1, svg2, cleanedName]);
+        });
+        const sortedFiles = allFiles.sort((a, b) => {
+            const nameA = a[3];
+            const nameB = b[3];
+            const indexA = Number(nameA);
+            const indexB = Number(nameB);
+            if (indexA > indexB) {
+                return 1;
+            }
+            else if (indexA < indexB) {
+                return -1;
+            }
+            else {
+                return 0;
+            }
+        });
+        const output = [];
+        sortedFiles.forEach(group => {
+            const [file, svg1, svg2] = group;
+            output.push(`<div class='group'>
+                <h3>${file}</h3>
+                <div class='items'>
+                    <div style='margin-right: 10px'>
+                        <h4>${svg1}</h4>
+                        <img src='${svg1}'/>
+                    </div>
+                    <div>
+                        <h4>${svg2}</h4>
+                        <img src='${svg2}'/>
+                    </div>
+                </div>
+            </div>`);
+        });
+        const result = `
+            <html>
+                <header>
+                    <title>SVG compare</title>
+                    <style>
+                        img { border: solid thin #ccc; }
+                        .items { display: flex; }
+                        body { font-family: Arial; }
+                    </style>
+                </header>
+                <body>
+                    ${output.join('')}
+                </body>
+            </html>`;
+        fs.writeFileSync(mainDir + "compiled.html", result);
+    }
+})();

package/dist/esm/render.mjs

@@ -1,9 +1,10 @@
 import { SVG, registerWindow } from '@svgdotjs/svg.js';
 import { RenderFrameType, getBounds } from "./layout.mjs";
 import { applyFontsToSVG, getCreateSVGWindow } from './sizing.mjs';
-import { ColorScheme, ComponentTypes, ParamKeys, junctionSize } from './globals.mjs';
+import { ColorScheme, ComponentTypes, MMToPx, ParamKeys, defaultGridSizeUnits, defaultWireLineWidth, defaultZoomScale, junctionSize } from './globals.mjs';
 import { NumericValue } from './objects/ParamDefinition.mjs';
 import { getBoundsSize } from './utils.mjs';
+import { milsToMM } from './helpers.mjs';
 export function generateSVG2(graph) {
     const window = getCreateSVGWindow()();
     const document = window.document;
@@ -12,10 +13,10 @@ export function generateSVG2(graph) {
     applyFontsToSVG(canvas);
     generateSVGChild(canvas, graph.components, graph.wires, graph.junctions, graph.mergedWires, graph.frameObjects, graph.textObjects);
     const { x, y, width, height } = canvas.bbox();
-    const margin = 5;
+    const margin = milsToMM(10);
     const widthAndMargin = width + margin * 2;
     const heightAndMargin = height + margin * 2;
-    const scale = 1;
+    const scale = MMToPx * defaultZoomScale;
     canvas.size(widthAndMargin * scale, heightAndMargin * scale);
     canvas.viewbox(x - margin, y - margin, widthAndMargin, heightAndMargin);
     return canvas.svg();
@@ -79,8 +80,11 @@ function generateSVGChild(canvas, components, wires, junctions, mergedWires, fra
             const pt1 = segment[0];
             const pt2 = segment[1];
             mergedWireGroup.line([pt1, pt2])
-                .stroke({ width: 1, color: ColorScheme.WireColor,
-                linecap: 'square' })
+                .stroke({
+                width: defaultWireLineWidth,
+                color: ColorScheme.WireColor,
+                linecap: 'square'
+            })
                 .fill('none');
         });
         intersectPoints.forEach(point => {
@@ -109,7 +113,7 @@ function generateSVGChild(canvas, components, wires, junctions, mergedWires, fra
             }
             const tmpRect = frameGroup.rect(width, height)
                 .fill('none')
-                .stroke({ width: borderWidth, color: strokeColor });
+                .stroke({ width: milsToMM(borderWidth), color: strokeColor });
             tmpRect.translate(item.x, item.y);
         }
     });
@@ -120,13 +124,14 @@ function generateSVGChild(canvas, components, wires, junctions, mergedWires, fra
         symbol.draw(innerGroup);
     });
     const drawOrigin = false;
+    const originSize = milsToMM(10);
     drawOrigin && canvas.group().translate(0, 0)
-        .circle(5)
-        .translate(-5 / 2, -5 / 2)
+        .circle(originSize)
+        .translate(-originSize / 2, -originSize / 2)
         .stroke('none').fill('red');
 }
 function drawGrid(group, canvasSize) {
-    const gridSize = 20;
+    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;
@@ -134,19 +139,20 @@ function drawGrid(group, canvasSize) {
     const gridEndY = (Math.ceil(y2 / gridSize) + 1) * gridSize;
     const numCols = Math.ceil((gridEndX - gridStartX) / gridSize);
     const lines = [];
+    const smallOffset = milsToMM(3);
+    const startY = gridStartY - smallOffset / 2;
+    const endY = gridEndY + smallOffset;
     for (let i = 0; i <= numCols; i++) {
         const startX = gridStartX + i * gridSize;
-        const startY = gridStartY - 0.5;
-        const endY = gridEndY;
         lines.push(`M ${startX} ${startY} L ${startX} ${endY}`);
     }
+    const strokeSize = milsToMM(3);
     group.path(lines.join(" "))
-        .fill('none')
         .attr({
-        'stroke-dasharray': '1,' + (gridSize - 1),
+        'stroke-dasharray': `${strokeSize},${gridSize - strokeSize}`,
     })
         .stroke({
-        width: 1,
-        color: '#aaa'
+        width: strokeSize,
+        color: '#000'
     });
 }

package/dist/esm/sizing.mjs

@@ -3,7 +3,9 @@ import { HorizontalAlign, VerticalAlign } from './geometry.mjs';
 import { defaultFont } from './globals.mjs';
 import { JSModuleType, detectJSModuleType } from './helpers.mjs';
 let MainCanvas = null;
-const supportedFonts = {};
+const supportedFonts = {
+    'Arial': 'Arial.ttf',
+};
 let globalCreateSVGWindow;
 export async function prepareSVGEnvironment(fontsPath) {
     const moduleType = detectJSModuleType();
@@ -25,9 +27,6 @@ export function getCreateSVGWindow() {
 }
 export function applyFontsToSVG(canvas) {
 }
-export async function measureTextSize(text, fontFamily, fontSize) {
-    return measureTextSize2(text, fontFamily, fontSize);
-}
 const measureTextSizeCache = {};
 const measureTextSizeCacheHits = {};
 export function measureTextSize2(text, fontFamily, fontSize, fontWeight = 'regular', anchor = HorizontalAlign.Left, vanchor = VerticalAlign.Bottom) {

package/dist/esm/utils.mjs

@@ -23,11 +23,17 @@ export function printBounds(bounds) {
         return 'null';
     }
 }
+function hasRemainder(value, value2) {
+    const tmpValue = Math.abs(value) / value2;
+    const flooredValue = Math.floor(tmpValue);
+    const diff = tmpValue - flooredValue;
+    return diff;
+}
 export function resizeToNearestGrid(bounds, gridSize = 20) {
-    const addXMin = (bounds.xmin % gridSize) === 0 ? -1 : 0;
-    const addYMin = (bounds.ymin % gridSize) === 0 ? -1 : 0;
-    const addXMax = (bounds.xmax % gridSize) === 0 ? 1 : 0;
-    const addYMax = (bounds.ymax % gridSize) === 0 ? 1 : 0;
+    const addXMin = hasRemainder(bounds.xmin, gridSize) === 0 ? -1 : 0;
+    const addYMin = hasRemainder(bounds.ymin, gridSize) === 0 ? -1 : 0;
+    const addXMax = hasRemainder(bounds.xmax, gridSize) === 0 ? 1 : 0;
+    const addYMax = hasRemainder(bounds.ymax, gridSize) === 0 ? 1 : 0;
     return {
         xmin: Math.floor((bounds.xmin + addXMin) / gridSize) * gridSize,
         ymin: Math.floor((bounds.ymin + addYMin) / gridSize) * gridSize,
@@ -44,3 +50,19 @@ export function getBoundsSize(bounds) {
         height: bounds.ymax - bounds.ymin,
     };
 }
+export function getPortType(component) {
+    const drawingCommands = component.displayProp;
+    let foundPinType = null;
+    const commands = drawingCommands.getCommands();
+    commands.some(item => {
+        if (item[0] === 'label' && item[2].has('portType')) {
+            foundPinType = item[2].get('portType');
+            return true;
+        }
+        return false;
+    });
+    return foundPinType;
+}
+export function roundValue(value) {
+    return +value.toFixed(7);
+}

package/dist/esm/visitor.mjs

@@ -1,11 +1,13 @@
 import { ClassComponent } from './objects/ClassComponent.mjs';
-import { NumericValue, ParamDefinition, } from './objects/ParamDefinition.mjs';
+import { NumericValue, ParamDefinition, PinBlankValue, } from './objects/ParamDefinition.mjs';
 import { PinDefinition, PinIdType } from './objects/PinDefinition.mjs';
 import { PinTypes } from './objects/PinTypes.mjs';
-import { UndeclaredReference } from './objects/types.mjs';
-import { BlockTypes, ComponentTypes, NoNetText, ReferenceTypes } from './globals.mjs';
+import { DeclaredReference, UndeclaredReference } from './objects/types.mjs';
+import { BlockTypes, ComponentTypes, 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';
 export class ParserVisitor extends BaseVisitor {
     visitKeyword_assignment_expr = (ctx) => {
         const id = ctx.ID().getText();
@@ -145,7 +147,8 @@ export class ParserVisitor extends BaseVisitor {
             arrange, display, type, width, copy,
             angle, followWireOrientation
         };
-        this.setResult(ctx, this.getExecutor().createComponent(instanceName, pins, params, props));
+        const createdComponent = this.getExecutor().createComponent(instanceName, pins, params, props);
+        this.setResult(ctx, createdComponent);
     };
     visitCreate_graphic_expr = (ctx) => {
         const commands = ctx.graphic_expr().reduce((accum, item) => {
@@ -191,8 +194,82 @@ export class ParserVisitor extends BaseVisitor {
             this.visit(ctxParameters);
             parameters = this.getResult(ctxParameters);
         }
+        if (commandName === 'label') {
+            parameters.forEach(item => {
+                if (item[0] == 'keyword' && item[1] === 'portType') {
+                    if (item[2] === 'in') {
+                        item[2] = 'input';
+                    }
+                    else if (item[2] === 'out') {
+                        item[2] = 'output';
+                    }
+                }
+            });
+        }
         this.setResult(ctx, [commandName, parameters]);
     };
+    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);
+        });
+        const nameToPinId = new Map();
+        const tmpPorts = allPorts.map((portName, index) => {
+            nameToPinId.set(portName, index + 1);
+            return new PinDefinition(index + 1, PinIdType.Int, portName, PinTypes.Any);
+        });
+        const arrangeLeftItems = leftPorts.map(item => {
+            if (item instanceof PinBlankValue) {
+                return item;
+            }
+            else {
+                return nameToPinId.get(item);
+            }
+        });
+        const arrangeRightItems = rightPorts.map(item => {
+            if (item instanceof PinBlankValue) {
+                return item;
+            }
+            else {
+                return nameToPinId.get(item);
+            }
+        });
+        const arrange = new Map();
+        if (arrangeLeftItems.length > 0) {
+            arrange.set('left', arrangeLeftItems);
+        }
+        if (arrangeRightItems.length > 0) {
+            arrange.set('right', arrangeRightItems);
+        }
+        const width = properties.has('width') ?
+            properties.get('width') : null;
+        const blankParams = [];
+        const props = {
+            arrange, width
+        };
+        const moduleInstanceName = this.getExecutor().getUniqueInstanceName('');
+        const createdComponent = this.getExecutor().createComponent(moduleInstanceName, tmpPorts, blankParams, props);
+        createdComponent.typeProp = 'module';
+        const ctxPropertyBlock = ctx.property_block_expr();
+        if (ctxPropertyBlock) {
+            const [firstBlock] = ctxPropertyBlock;
+            this.visit(firstBlock);
+            const [keyName, expressionsBlock] = this.getResult(firstBlock);
+            if (keyName === 'contains') {
+                createdComponent.moduleContainsExpressions = expressionsBlock;
+                this.expandModuleContains(createdComponent, this.getExecutor().netNamespace);
+            }
+        }
+        this.setResult(ctx, createdComponent);
+    };
+    visitProperty_block_expr = (ctx) => {
+        const tmpCtx = ctx.property_key_expr();
+        this.visit(tmpCtx);
+        const keyName = this.getResult(tmpCtx);
+        const expressionsBlock = ctx.expressions_block();
+        this.setResult(ctx, [keyName, expressionsBlock]);
+    };
     visitProperty_expr = (ctx) => {
         const ctxPropertyKeyExpr = ctx.property_key_expr();
         const ctxPropertyValueExpr = ctx.property_value_expr();
@@ -270,6 +347,14 @@ export class ParserVisitor extends BaseVisitor {
             && component.copyProp) {
             component = this.getExecutor().copyComponent(component);
         }
+        if (component instanceof DeclaredReference
+            && component.found
+            && component.trailers
+            && component.trailers.length > 0
+            && component.trailers[0] === 'contains') {
+            component = component.value;
+            this.placeModuleContains(component);
+        }
         if (component && component instanceof ClassComponent) {
             const modifiers = ctx.component_modifier_expr();
             modifiers.forEach(modifier => {
@@ -328,10 +413,65 @@ export class ParserVisitor extends BaseVisitor {
             pinValue = this.getResult(ctxPinSelectExpr);
         }
         else {
-            pinValue = component.getDefaultPin();
+            if (component instanceof ClassComponent) {
+                pinValue = component.getDefaultPin();
+            }
+            else {
+                const undeclaredRef = component;
+                throw 'Invalid component: ' + undeclaredRef.reference.name;
+            }
         }
         this.setResult(ctx, [component, pinValue]);
     };
+    expandModuleContains(component, netNamespace) {
+        this.getExecutor().log('expanding module `contains`');
+        const executionStack = this.executionStack;
+        const resolveNet = this.createNetResolver(executionStack);
+        const executionContextName = this.getExecutor().namespace + "_"
+            + component.instanceName
+            + '_' + component.moduleCounter;
+        const tmpNamespace = this.getNetNamespace(netNamespace, "+/" + component.instanceName + "_" + component.moduleCounter);
+        const newExecutor = this.enterNewChildContext(executionStack, this.getExecutor(), executionContextName, { netNamespace: tmpNamespace }, [], []);
+        component.moduleCounter += 1;
+        newExecutor.resolveNet = resolveNet;
+        this.visit(component.moduleContainsExpressions);
+        const executionContext = executionStack.pop();
+        component.moduleExecutionContext = executionContext;
+        component.moduleExecutionContextName = executionContextName;
+        this.linkModuleSymbolWithContains(component, executionContext);
+    }
+    linkModuleSymbolWithContains(moduleComponent, executionContext) {
+        this.log('link module symbol');
+        const modulePinMapping = new Map();
+        moduleComponent.pins.forEach(pin => {
+            const pinName = pin.name;
+            modulePinMapping.set(pinName, pin.id);
+        });
+        const pinIdToPortMap = new Map();
+        moduleComponent.modulePinIdToPortMap = pinIdToPortMap;
+        for (const [key, component] of executionContext.scope.instances) {
+            if (component._copyID !== null && component.typeProp === 'port') {
+                const portName = component.parameters.get('net_name');
+                const modulePinId = modulePinMapping.get(portName);
+                pinIdToPortMap.set(modulePinId, component);
+                const portType = getPortType(component);
+                const tmpPin = moduleComponent.pins.get(modulePinId);
+                tmpPin.pinType = portType;
+            }
+        }
+    }
+    placeModuleContains(moduleComponent) {
+        if (moduleComponent.typeProp === 'module'
+            && moduleComponent.moduleContainsExpressions) {
+            this.log('place module `contains`');
+            this.getExecutor().mergeScope(moduleComponent.moduleExecutionContext.scope, moduleComponent.moduleExecutionContextName);
+            this.log('connect module ports');
+            for (const [pinId, portComponent] of moduleComponent.modulePinIdToPortMap) {
+                this.getExecutor().atComponent(moduleComponent, pinId);
+                this.getExecutor().toComponent(portComponent, 1);
+            }
+        }
+    }
     visitUnaryOperatorExpr = (ctx) => {
         this.visit(ctx.data_expr());
         let value = this.getResult(ctx.data_expr());
@@ -360,6 +500,7 @@ export class ParserVisitor extends BaseVisitor {
         let value;
         const ctxCreateComponentExpr = ctx.create_component_expr();
         const ctxCreateGraphicExpr = ctx.create_graphic_expr();
+        const ctxCreateModuleExpr = ctx.create_module_expr();
         if (ctxCreateComponentExpr) {
             this.visit(ctxCreateComponentExpr);
             value = this.getResult(ctxCreateComponentExpr);
@@ -368,6 +509,10 @@ export class ParserVisitor extends BaseVisitor {
             this.visit(ctxCreateGraphicExpr);
             value = this.getResult(ctxCreateGraphicExpr);
         }
+        else if (ctxCreateModuleExpr) {
+            this.visit(ctxCreateModuleExpr);
+            value = this.getResult(ctxCreateModuleExpr);
+        }
         else {
             throw "Invalid data expression";
         }
@@ -536,13 +681,11 @@ export class ParserVisitor extends BaseVisitor {
         }
     };
     visitAt_block_pin_expression_complex = (ctx) => {
-        ctx.expression().forEach(item => {
-            this.visit(item);
-        });
+        this.visit(ctx.expressions_block());
     };
     visitWire_expr_direction_only = (ctx) => {
         const value = ctx.ID().getText();
-        if (value === 'auto' || value === 'auto_') {
+        if (value === WireAutoDirection.Auto || value === WireAutoDirection.Auto_) {
             this.setResult(ctx, [value]);
         }
         else {
@@ -563,7 +706,7 @@ export class ParserVisitor extends BaseVisitor {
                 useValue = this.getResult(ctxDataExpr);
             }
             if (useValue !== null) {
-                this.setResult(ctx, [direction, useValue]);
+                this.setResult(ctx, [direction, new UnitDimension(useValue)]);
                 return;
             }
         }
@@ -597,9 +740,12 @@ export class ParserVisitor extends BaseVisitor {
         const propertyName = ctx.ID().getText();
         this.getExecutor().setProperty('..' + propertyName, result);
     };
+    visitExpressions_block = (ctx) => {
+        this.runExpressions(this.getExecutor(), ctx.expression());
+    };
     visitFrame_expr = (ctx) => {
         const frameId = this.getExecutor().enterFrame();
-        this.runExpressions(this.getExecutor(), ctx.expression());
+        this.visit(ctx.expressions_block());
         this.getExecutor().exitFrame(frameId);
     };
     visitNet_namespace_expr = (ctx) => {
@@ -630,7 +776,7 @@ export class ParserVisitor extends BaseVisitor {
         this.visit(ctxDataExpr);
         const result = this.getResult(ctxDataExpr);
         if (result) {
-            this.runExpressions(this.getExecutor(), ctx.expression());
+            this.visit(ctx.expressions_block());
         }
         else {
             const ctxInnerIfExprs = ctx.if_inner_expr();
@@ -657,7 +803,7 @@ export class ParserVisitor extends BaseVisitor {
         this.visit(ctxDataExpr);
         const result = this.getResult(ctxDataExpr);
         if (result) {
-            this.runExpressions(this.getExecutor(), ctx.expression());
+            this.visit(ctx.expressions_block());
         }
         this.setResult(ctx, result);
     };
@@ -712,6 +858,26 @@ export class ParserVisitor extends BaseVisitor {
         }
         return pins;
     }
+    parseCreateModulePorts(portsDefinition) {
+        let leftItems = [];
+        let rightItems = [];
+        if (portsDefinition.has('left')) {
+            leftItems = portsDefinition.get('left');
+            if (!Array.isArray(leftItems)) {
+                leftItems = [leftItems];
+            }
+        }
+        if (portsDefinition.has('right')) {
+            rightItems = portsDefinition.get('right');
+            if (!Array.isArray(rightItems)) {
+                rightItems = [rightItems];
+            }
+        }
+        return {
+            left: leftItems,
+            right: rightItems
+        };
+    }
     parseCreateComponentParams(params) {
         const result = [];
         if (params) {