circuitscript 0.5.7 → 0.6.1

package/dist/esm/antlr/CircuitScriptParserVisitor.js

@@ -2,6 +2,7 @@ import { AbstractParseTreeVisitor } from "antlr4ng";
 export class CircuitScriptParserVisitor extends AbstractParseTreeVisitor {
     visitScript;
     visitExpression;
+    visitNon_newline_expression;
     visitFlow_expressions;
     visitGraph_expressions;
     visitExpressions_block;
@@ -17,6 +18,7 @@ export class CircuitScriptParserVisitor extends AbstractParseTreeVisitor {
     visitAt_block_header;
     visitAt_block;
     visitAt_block_expressions;
+    visitAt_block_expressions_inner;
     visitAt_block_pin_expr;
     visitKeyword_assignment_expr;
     visitParameters;

package/dist/esm/cache/serializer.js

@@ -62,7 +62,7 @@ export function serializeLibraryScope(importedLib, contentHash) {
             prevStopLine = null;
         };
         for (const exprCtx of tree.expression()) {
-            if (exprCtx.function_def_expr() !== null) {
+            if (exprCtx.non_newline_expression()?.function_def_expr() !== null) {
                 flushGroup();
                 continue;
             }

package/dist/esm/errors.js

@@ -111,9 +111,12 @@ export function collectErrorChain(error) {
     return items;
 }
 export function printErrorChain(error) {
-    const errors = collectErrorChain(error);
-    errors.reverse();
-    for (const err of errors) {
+    let useErrors = collectErrorChain(error);
+    if (useErrors.length === 0) {
+        useErrors = [error];
+    }
+    useErrors.reverse();
+    for (const err of useErrors) {
         console.log("  " + err.toString());
     }
 }

package/dist/esm/execute.js

@@ -553,9 +553,7 @@ export class ExecutionContext {
         }
         else if (blockType === BlockTypes.Join || blockType === BlockTypes.Parallel) {
             if (blockIndex === 0) {
-                const pointIdName = `${Delimiter1}${getBlockTypeString(blockType)}`;
-                this.addPoint(`${pointIdName}.${this.name}.${this.tmpPointId}`, false);
-                this.tmpPointId += 1;
+                this.addPointForBlockType(blockType);
                 stackRef.end_point = [
                     this.scope.currentComponent,
                     this.scope.currentPin,
@@ -569,6 +567,11 @@ export class ExecutionContext {
             }
         }
     }
+    addPointForBlockType(blockType) {
+        const pointIdName = `${Delimiter1}${getBlockTypeString(blockType)}`;
+        this.addPoint(`${pointIdName}.${this.name}.${this.tmpPointId}`, false);
+        this.tmpPointId += 1;
+    }
     atPointBlock() {
         const [component, pin,] = this.getPointBlockLocation();
         this.atComponent(component, pin, {
@@ -585,10 +588,12 @@ export class ExecutionContext {
         this.log('get block point');
         for (let i = 0; i < this.scope.scopeLevel; i++) {
             const stackRef = this.scope.blockStack.get(this.scope.scopeLevel - 1 - i);
-            const { start_point } = stackRef;
-            const component = start_point[0];
-            if (component.instanceName.startsWith(`${Delimiter1}point.`)) {
-                return start_point;
+            if (stackRef) {
+                const { start_point } = stackRef;
+                const component = start_point[0];
+                if (component.instanceName.startsWith(`${Delimiter1}point.`)) {
+                    return start_point;
+                }
             }
         }
         this.log('did not find block point');
@@ -1023,7 +1028,8 @@ export class ExecutionContext {
         });
     }
     applyComponentAngleFromWire(component, pin, opposite = false) {
-        const targetUnit = component.getUnitForPin(pin);
+        const usePin = component.getPin(pin);
+        const targetUnit = component.getUnitForPin(usePin);
         if (this.componentAngleFollowsWire
             && targetUnit.followWireOrientationProp
             && targetUnit.useWireOrientationAngle
@@ -1035,8 +1041,8 @@ export class ExecutionContext {
                 useSegment = currentWire.path[0];
             }
             const pinPositions = CalculatePinPositions(targetUnit);
-            if (pinPositions.has(pin)) {
-                const connectedPinPos = pinPositions.get(pin);
+            if (pinPositions.has(usePin)) {
+                const connectedPinPos = pinPositions.get(usePin);
                 let targetAngle = null;
                 let useDirection = useSegment.direction;
                 if (opposite) {

package/dist/esm/objects/BlockTypes.js

@@ -4,4 +4,5 @@ export var BlockTypes;
     BlockTypes[BlockTypes["Join"] = 2] = "Join";
     BlockTypes[BlockTypes["Parallel"] = 3] = "Parallel";
     BlockTypes[BlockTypes["Point"] = 4] = "Point";
+    BlockTypes[BlockTypes["AtBlock"] = 5] = "AtBlock";
 })(BlockTypes || (BlockTypes = {}));

package/dist/esm/objects/ClassComponent.js

@@ -196,10 +196,10 @@ export class ClassComponent {
         }
         throw new RuntimeExecutionError(`Could not find pin '${pinId}' on component '${this.instanceName}'`);
     }
-    getNextPinAfter(pinIndex) {
+    getNextPinAfter(pinId) {
         const pins = Array.from(this.pins.keys());
-        pins.sort();
-        const index = pins.findIndex(tmp => tmp.equals(pinIndex));
+        const foundPin = this.getPin(pinId);
+        const index = pins.findIndex(tmp => tmp.equals(foundPin));
         if (index + 1 < pins.length) {
             return pins[index + 1];
         }

package/dist/esm/objects/Frame.js

@@ -35,6 +35,10 @@ export var FrameParamKeys;
     FrameParamKeys["TitleAlign"] = "title_align";
     FrameParamKeys["HorizontalAlign"] = "align";
     FrameParamKeys["VerticalAlign"] = "valign";
+    FrameParamKeys["FontSize"] = "font_size";
+    FrameParamKeys["Bold"] = "bold";
+    FrameParamKeys["Italic"] = "italic";
+    FrameParamKeys["Color"] = "color";
     FrameParamKeys["SheetNumber"] = "sheet_number";
     FrameParamKeys["SheetTotal"] = "sheet_total";
 })(FrameParamKeys || (FrameParamKeys = {}));

package/dist/esm/regenerate-tests.js

@@ -22,13 +22,16 @@ async function regenerateTests(extra = "", fileList = []) {
         const outputPath = mainDir + 'svgs/' + file + extra + '.svg';
         env.setModuleDirectory(mainDir);
         env.setDefaultLibsPath(mainDir + '../../../libs/');
-        await renderScript(scriptData, outputPath, {
+        const { errors } = await renderScript(scriptData, outputPath, {
             inputPath,
             dumpNets: false,
             dumpData: false,
             showStats: false,
             environment: env,
         });
+        if (errors.length > 0) {
+            console.log(errors);
+        }
     }
     return cstFiles;
 }

package/dist/esm/render/draw_symbols.js

@@ -139,7 +139,7 @@ export class SymbolGraphic {
         const labels = this.drawing.getLabels();
         for (const label of labels) {
             const tmpLabel = label;
-            const { fontSize = numeric(50), anchor = HorizontalAlign.Left, vanchor = VerticalAlign.Bottom, fontWeight = 'regular', angle: tmpLabelAngle = numeric(0), textColor = "#333", } = tmpLabel.style ?? {};
+            const { fontSize = numeric(50), anchor = HorizontalAlign.Left, vanchor = VerticalAlign.Bottom, fontWeight = 'regular', fontStyle = 'normal', angle: tmpLabelAngle = numeric(0), textColor = "#333", } = tmpLabel.style ?? {};
             let anchorStyle = 'start';
             let dominantBaseline = 'auto';
             let useAnchor = anchor;
@@ -293,15 +293,19 @@ export class SymbolGraphic {
             if (isRotation180) {
                 useLabelAngle = (labelAngle + 180) % 360;
             }
-            textContainer.text(tmpLabel.text)
-                .fill(textColor)
-                .font({
+            const fontProperties = {
                 family: useFont,
                 size: fontSize.toNumber() * fontDisplayScale,
                 anchor: anchorStyle,
                 'dominant-baseline': dominantBaseline,
                 weight: fontWeight,
-            })
+            };
+            if (fontStyle !== 'normal') {
+                fontProperties.style = fontStyle;
+            }
+            textContainer.text(tmpLabel.text)
+                .fill(textColor)
+                .font(fontProperties)
                 .attr("xml:space", "preserve")
                 .rotate(useLabelAngle, 0, 0);
             const { a, b, c, d, e, f } = textContainer.matrix();
@@ -349,6 +353,8 @@ export class SymbolText extends SymbolGraphic {
     text;
     fontSize = numeric(40);
     fontWeight = 'regular';
+    fontStyle = 'normal';
+    color = undefined;
     constructor(text) {
         super();
         this.text = text;
@@ -360,6 +366,8 @@ export class SymbolText extends SymbolGraphic {
             fontSize: this.fontSize,
             anchor: HorizontalAlign.Center,
             fontWeight: this.fontWeight,
+            fontStyle: this.fontStyle,
+            textColor: this.color
         });
         this.drawing = drawing;
     }
@@ -447,6 +455,9 @@ export class SymbolPlaceholder extends SymbolGraphic {
                 case PlaceHolderCommands.triangle:
                     drawing.addTriangle(...positionParams);
                     break;
+                case PlaceHolderCommands.arrow:
+                    drawing.addArrow(...positionParams);
+                    break;
                 case PlaceHolderCommands.pin:
                 case PlaceHolderCommands.hpin:
                 case PlaceHolderCommands.vpin:
@@ -504,18 +515,16 @@ export class SymbolPlaceholder extends SymbolGraphic {
     }
     parseLabelStyle(keywordParams) {
         const keywords = ['fontSize', 'anchor', 'vanchor',
-            'angle', 'textColor', 'portType', 'bold'];
+            'angle', 'textColor', 'portType', 'bold', 'italic'];
         const style = {};
         keywords.forEach(item => {
             if (keywordParams.has(item)) {
                 style[item] = keywordParams.get(item);
                 if (item === 'bold') {
-                    if (keywordParams.get(item) === true) {
-                        style['fontWeight'] = 'bold';
-                    }
-                    else {
-                        style['fontWeight'] = 'normal';
-                    }
+                    style.fontWeight = keywordParams.get(item) === true ? 'bold' : 'regular';
+                }
+                else if (item === 'italic') {
+                    style.fontStyle = keywordParams.get(item) === true ? 'italic' : 'normal';
                 }
             }
         });
@@ -675,6 +684,7 @@ export var PlaceHolderCommands;
     PlaceHolderCommands["rect"] = "rect";
     PlaceHolderCommands["crect"] = "crect";
     PlaceHolderCommands["triangle"] = "triangle";
+    PlaceHolderCommands["arrow"] = "arrow";
     PlaceHolderCommands["pin"] = "pin";
     PlaceHolderCommands["hpin"] = "hpin";
     PlaceHolderCommands["vpin"] = "vpin";
@@ -1042,6 +1052,35 @@ export class SymbolDrawing {
         ]));
         return this;
     }
+    addArrow(startX, startY, endX, endY, arrowLength = numeric(25), arrowWidth = numeric(25)) {
+        startX = milsToMM(startX);
+        startY = milsToMM(startY);
+        endX = milsToMM(endX);
+        endY = milsToMM(endY);
+        arrowLength = milsToMM(arrowLength);
+        arrowWidth = milsToMM(arrowWidth);
+        const dxNum = endX.sub(startX).toNumber();
+        const dyNum = endY.sub(startY).toNumber();
+        const len = Math.sqrt(dxNum * dxNum + dyNum * dyNum);
+        const unitDx = numeric(dxNum / len);
+        const unitDy = numeric(dyNum / len);
+        const arrowBaseX = endX.sub(unitDx.mul(arrowLength));
+        const arrowBaseY = endY.sub(unitDy.mul(arrowLength));
+        this.items.push(Geometry.segment([startX, startY], [arrowBaseX, arrowBaseY]));
+        const perpX = numeric(-unitDy.toNumber());
+        const perpY = numeric(unitDx.toNumber());
+        const dx1 = perpX.mul(arrowWidth).half();
+        const dy1 = perpY.mul(arrowWidth).half();
+        const dx2 = perpX.mul(arrowWidth.neg()).half();
+        const dy2 = perpY.mul(arrowWidth.neg()).half();
+        this.items.push(Geometry.polygon([
+            [dx1.add(arrowBaseX), dy1.add(arrowBaseY)],
+            [dx2.add(arrowBaseX), dy2.add(arrowBaseY)],
+            [endX, endY],
+            [dx1.add(arrowBaseX), dy1.add(arrowBaseY)],
+        ]));
+        return this;
+    }
     addLabel(x, y, textValue, style) {
         this.items.push(Geometry.label(null, x, y, textValue, style));
         return this;

package/dist/esm/render/geometry.js

@@ -44,8 +44,8 @@ export class Textbox extends Flatten.Polygon {
         else {
             throw 'Invalid string passed into textbox';
         }
-        const { fontSize = numeric(50), anchor = HorizontalAlign.Left, vanchor = VerticalAlign.Bottom, fontWeight = 'regular', portType = null, } = style ?? {};
-        const { box } = measureTextSize2(useText, defaultFont, fontSize.mul(fontDisplayScale).toNumber(), fontWeight, anchor, vanchor);
+        const { fontSize = numeric(50), anchor = HorizontalAlign.Left, vanchor = VerticalAlign.Bottom, fontWeight = 'regular', fontStyle = 'normal', portType = null, } = style ?? {};
+        const { box } = measureTextSize2(useText, defaultFont, fontSize.mul(fontDisplayScale).toNumber(), fontWeight, fontStyle, anchor, vanchor);
         let polygonCoords = [];
         let anchorOffsetX = 0;
         let anchorOffsetY = 0;

package/dist/esm/render/layout.js

@@ -551,12 +551,20 @@ export class LayoutEngine {
         const isSheetFrame = frameObject.frameType === FrameType.Sheet;
         if (frameParams.has(FrameParamKeys.Title) && !isSheetFrame) {
             const title = frameParams.get(FrameParamKeys.Title);
+            const fontSize = frameParams.get(FrameParamKeys.FontSize) ?? numeric(defaultFrameTitleTextSize);
+            const isBold = frameParams.get(FrameParamKeys.Bold) ?? true;
+            const isItalic = frameParams.get(FrameParamKeys.Italic) ?? false;
+            const titleColor = frameParams.get(FrameParamKeys.Color) ?? null;
             const titleFrame = new RenderFrame(new Frame(FixedFrameIds.FrameIdNotUsed), RenderFrameType.Elements);
             titleFrame.containsTitle = true;
             titleFrame.subgraphId = title.replace(/\s/g, "_");
             const textObject = new RenderText(title);
-            textObject.fontSize = numeric(defaultFrameTitleTextSize);
-            textObject.fontWeight = 'bold';
+            textObject.fontSize = fontSize;
+            textObject.fontWeight = isBold ? 'bold' : 'regular';
+            textObject.fontStyle = isItalic ? 'italic' : 'normal';
+            if (titleColor !== null) {
+                textObject.color = titleColor;
+            }
             textObject.x = numeric(0);
             textObject.y = numeric(0);
             textObject.symbol.refreshDrawing();
@@ -1212,6 +1220,8 @@ export class RenderText extends RenderObject {
     symbol;
     _fontSize = numeric(12);
     _fontWeight = 'regular';
+    _fontStyle = 'normal';
+    _color = undefined;
     get fontSize() {
         return this._fontSize;
     }
@@ -1226,6 +1236,20 @@ export class RenderText extends RenderObject {
         this._fontWeight = value;
         this.symbol.fontWeight = value;
     }
+    get fontStyle() {
+        return this._fontStyle;
+    }
+    set fontStyle(value) {
+        this._fontStyle = value;
+        this.symbol.fontStyle = value;
+    }
+    get color() {
+        return this._color;
+    }
+    set color(value) {
+        this._color = value;
+        this.symbol.color = value;
+    }
     constructor(text) {
         super();
         this.symbol = new SymbolText(text);

package/dist/esm/sizing.js

@@ -6,10 +6,10 @@ export function applyFontsToSVG(canvas) {
 }
 const measureTextSizeCache = {};
 const measureTextSizeCacheHits = {};
-export function measureTextSize2(text, fontFamily, fontSize, fontWeight = 'regular', anchor = HorizontalAlign.Left, vanchor = VerticalAlign.Bottom) {
+export function measureTextSize2(text, fontFamily, fontSize, fontWeight = 'regular', fontStyle = 'normal', anchor = HorizontalAlign.Left, vanchor = VerticalAlign.Bottom) {
     const environment = NodeScriptEnvironment.getInstance();
     const mainCanvas = environment.getCanvasWindow();
-    const key = `${text}-${fontFamily}-${fontSize}-${fontWeight}-${anchor}-${vanchor}`;
+    const key = `${text}-${fontFamily}-${fontSize}-${fontWeight}-${fontStyle}-${anchor}-${vanchor}`;
     if (measureTextSizeCache[key] === undefined) {
         let dominantBaseline = VerticalAlignProp.Hanging;
         switch (vanchor) {
@@ -42,6 +42,7 @@ export function measureTextSize2(text, fontFamily, fontSize, fontWeight = 'regul
             anchor: useAnchor,
             'dominant-baseline': dominantBaseline,
             weight: fontWeight,
+            style: fontStyle,
         })
             .attr("xml:space", "preserve")
             .fill('#333');

package/dist/esm/visitor.js

@@ -4,7 +4,7 @@ import { ParamDefinition } from "./objects/ParamDefinition.js";
 import { numeric } from "./objects/NumericValue.js";
 import { PinDefinition, PinId, PinIdType } from './objects/PinDefinition.js';
 import { PinTypes } from './objects/PinTypes.js';
-import { AnyReference, DeclaredReference, UndeclaredReference } from './objects/types.js';
+import { AnyReference, DeclaredReference, Direction, UndeclaredReference } from './objects/types.js';
 import { ComponentTypes, Delimiter1, FrameType, GlobalDocumentName, ModuleContainsKeyword, NoNetText, ParamKeys, RefdesFileSuffix, ReferenceTypes, SymbolPinSide, ValidPinSides, WireAutoDirection } from './globals.js';
 import { BlockTypes } from "./objects/BlockTypes.js";
 import { unwrapValue } from "./utils.js";
@@ -80,7 +80,7 @@ export class ParserVisitor extends BaseVisitor {
         return this.getExecutor().getCurrentPoint();
     };
     visitTo_component_expr = (ctx) => {
-        ctx.component_select_expr().forEach(item => {
+        for (const item of ctx.component_select_expr()) {
             let refComponent;
             const creationFlag = this.trackNewComponentCreated(() => {
                 const [component, pin] = this.visitResult(item);
@@ -95,7 +95,7 @@ export class ParserVisitor extends BaseVisitor {
                 }
             });
             this.linkComponentToCtx(item, refComponent, creationFlag);
-        });
+        }
         return this.getExecutor().getCurrentPoint();
     };
     visitComponent_select_expr = (ctx) => {
@@ -154,7 +154,18 @@ export class ParserVisitor extends BaseVisitor {
         const blockStackEntry = scope.blockStack.get(scopeLevel);
         const { current_index } = blockStackEntry;
         executor.enterBlock(current_index);
-        this.visit(ctx.expressions_block());
+        const ctxNonNewlineExpressions = ctx.non_newline_expression();
+        const ctxExpressionsBlock = ctx.expressions_block();
+        const ctxAtBlockExpressions = ctx.at_block_expressions();
+        if (ctxNonNewlineExpressions.length > 0) {
+            this.runExpressions(executor, ctxNonNewlineExpressions);
+        }
+        else if (ctxExpressionsBlock) {
+            this.visit(ctxExpressionsBlock);
+        }
+        else if (ctxAtBlockExpressions) {
+            this.visit(ctxAtBlockExpressions);
+        }
         executor.exitBlock(current_index);
         blockStackEntry.current_index++;
     };
@@ -226,6 +237,7 @@ export class ParserVisitor extends BaseVisitor {
         const suffix = properties.get('suffix') ?? null;
         let pins = [];
         if (display !== null && arrange === null && typeProp !== ComponentTypes.graphic) {
+            display.variables = properties.get('params') ?? new Map();
             const drawCommands = display.getCommands();
             drawCommands.forEach(command => {
                 const [commandValue,] = command;
@@ -233,9 +245,11 @@ export class ParserVisitor extends BaseVisitor {
                     || commandValue === PlaceHolderCommands.hpin
                     || commandValue === PlaceHolderCommands.pin) {
                     const id = PinId.from(command[1][0]);
-                    const pinType = id.getType();
-                    const pinName = id.toString();
-                    pins.push(new PinDefinition(id, pinType, pinName, PinTypes.Any));
+                    let pinName = id.toString();
+                    if (typeof command[1][1] === 'string') {
+                        pinName = command[1][1];
+                    }
+                    pins.push(new PinDefinition(id, id.getType(), pinName, PinTypes.Any));
                 }
             });
         }
@@ -689,14 +703,17 @@ export class ParserVisitor extends BaseVisitor {
                 let shouldIgnoreWireOrientation = false;
                 if (modifierText === ParamKeys.flip) {
                     const flipValue = result.name;
+                    let didSetX = false;
+                    let didSetY = false;
                     if (flipValue.indexOf('x') !== -1) {
                         defaultUnit.setParam(ParamKeys.flipX, numeric(1));
-                        shouldIgnoreWireOrientation = true;
+                        didSetX = true;
                     }
                     if (flipValue.indexOf('y') !== -1) {
                         defaultUnit.setParam(ParamKeys.flipY, numeric(1));
-                        shouldIgnoreWireOrientation = true;
+                        didSetY = true;
                     }
+                    shouldIgnoreWireOrientation = didSetX && didSetY;
                 }
                 else if (modifierText === ParamKeys.angle) {
                     defaultUnit.setParam(ParamKeys.angle, result);
@@ -705,6 +722,9 @@ export class ParserVisitor extends BaseVisitor {
                 else if (modifierText === 'anchor') {
                     dataResult.setParam('anchor', result.name);
                 }
+                else {
+                    dataResult.setParam(modifierText, result);
+                }
                 if (shouldIgnoreWireOrientation) {
                     defaultUnit.useWireOrientationAngle = false;
                 }
@@ -959,24 +979,63 @@ export class ParserVisitor extends BaseVisitor {
     };
     visitAt_block_pin_expr = (ctx) => {
         const executor = this.getExecutor();
-        const [currentComponent, currentPin] = executor.getCurrentPoint();
+        const scope = this.getScope();
+        const scopeLevel = scope.scopeLevel;
+        const params = this.getResult(ctx);
+        const blockIndex = params.index;
+        let useComponent;
+        for (let i = scopeLevel - 1; i >= 0; i--) {
+            const blockStackEntry = scope.blockStack.get(i);
+            if (blockStackEntry.type === BlockTypes.AtBlock) {
+                useComponent = blockStackEntry.start_point[0];
+                break;
+            }
+        }
         executor.closeOpenPathBlocks();
         const propKey = this.visitResult(ctx.property_key_expr());
         const atPin = new PinId(propKey);
-        executor.atComponent(currentComponent, atPin, {
+        executor.atComponent(useComponent, atPin, {
             addSequence: true
         });
-        executor.log('at block pin expressions');
-        const ctxExpression = ctx.expression();
+        executor.log(`at block pin expressions, pin id: ${atPin}`);
+        const ctxExpression = ctx.non_newline_expression();
         const ctxExpressionsBlock = ctx.expressions_block();
-        if (ctxExpression) {
-            this.visit(ctxExpression);
+        if (ctxExpression.length > 0) {
+            this.runExpressions(executor, ctxExpression);
         }
         else if (ctxExpressionsBlock) {
             this.visit(ctxExpressionsBlock);
         }
-        executor.log('end at block pin expressions');
-        executor.atComponent(currentComponent, currentPin);
+        const parentBlockStackEntry = scope.blockStack.get(scopeLevel - 1);
+        if (parentBlockStackEntry.type === BlockTypes.Join) {
+            if (blockIndex === 0 && parentBlockStackEntry.current_index === 0) {
+                executor.addPointForBlockType(BlockTypes.Join);
+                parentBlockStackEntry.end_point = [
+                    scope.currentComponent,
+                    scope.currentPin,
+                    scope.currentWireId
+                ];
+            }
+            else {
+                const { end_point: finalPoint } = parentBlockStackEntry;
+                const [component, pin] = finalPoint;
+                executor.toComponent(component, pin, { addSequence: true });
+            }
+        }
+    };
+    visitAt_block_expressions = (ctx) => {
+        let atBlockPinIndex = 0;
+        for (const tmpCtx of ctx.at_block_expressions_inner()) {
+            const ctxAtBlockPin = tmpCtx.at_block_pin_expr();
+            if (ctxAtBlockPin) {
+                this.setResult(ctxAtBlockPin, { index: atBlockPinIndex });
+                atBlockPinIndex++;
+                this.visit(ctxAtBlockPin);
+            }
+            else {
+                this.visit(tmpCtx.expression());
+            }
+        }
     };
     visitAt_block_header = (ctx) => {
         const ctxAtComponent = ctx.at_component_expr();
@@ -990,33 +1049,65 @@ export class ParserVisitor extends BaseVisitor {
     };
     visitAt_block = (ctx) => {
         const executor = this.getExecutor();
-        executor.log('entering at block');
+        const scope = this.getScope();
+        const scopeLevel = scope.scopeLevel;
+        if (scope.blockStack.has(scopeLevel)) {
+            executor.exitBlocks();
+        }
         const ctxAtBlockComponent = ctx.at_block_header();
         this.visit(ctxAtBlockComponent);
         const [currentComponent, currentPin] = executor.getCurrentPoint();
-        executor.scope.scopeLevel += 1;
-        ctx.at_block_expressions().forEach(expression => {
-            this.visit(expression);
+        scope.blockStack.set(scopeLevel, {
+            start_point: [
+                scope.currentComponent,
+                scope.currentPin,
+                scope.currentWireId
+            ],
+            end_point: null,
+            current_index: 0,
+            type: BlockTypes.AtBlock,
         });
+        executor.log('entering at block');
+        executor.scope.scopeLevel += 1;
+        this.visit(ctx.at_block_expressions());
         executor.scope.scopeLevel -= 1;
         executor.scope.setCurrent(currentComponent, currentPin);
+        scope.blockStack.delete(scopeLevel);
         executor.log('leaving at block');
     };
     visitWire_expr = (ctx) => {
         const segments = [];
         ctx.ID().forEach((ctxId, index) => {
-            const value = ctxId.getText();
+            const valueText = ctxId.getText();
             const ctxDataExpr = ctx.data_expr(index);
-            if ((value === WireAutoDirection.Auto || value === WireAutoDirection.Auto_) && ctxDataExpr === null) {
-                segments.push([value]);
+            let value = null;
+            switch (valueText) {
+                case 'right':
+                case 'rg':
+                case 'r':
+                    value = Direction.Right;
+                    break;
+                case 'left':
+                case 'lf':
+                case 'l':
+                    value = Direction.Left;
+                    break;
+                case 'up':
+                case 'u':
+                    value = Direction.Up;
+                    break;
+                case 'down':
+                case 'dw':
+                case 'd':
+                    value = Direction.Down;
+                    break;
+            }
+            if ((valueText === WireAutoDirection.Auto || valueText === WireAutoDirection.Auto_) && ctxDataExpr === null) {
+                segments.push([valueText]);
             }
             else if (this.acceptedDirections.indexOf(value) !== -1 && ctxDataExpr) {
-                let useValue = null;
-                useValue = this.visitResult(ctxDataExpr);
-                if (useValue instanceof NumericValue) {
-                    useValue = useValue.toNumber();
-                }
-                segments.push([value, new UnitDimension(useValue)]);
+                const useValue = this.visitResult(ctxDataExpr);
+                segments.push([value, new UnitDimension(useValue.toNumber())]);
             }
             else {
                 this.throwWithContext(ctx, "Invalid wire expression");
@@ -1072,9 +1163,12 @@ export class ParserVisitor extends BaseVisitor {
         if (ctx.Sheet()) {
             frameType = FrameType.Sheet;
         }
-        const frameId = this.getExecutor().enterFrame(frameType);
-        this.visit(ctx.expressions_block());
-        this.getExecutor().exitFrame(frameId);
+        const ctxExpressionsBlock = ctx.expressions_block();
+        if (ctxExpressionsBlock) {
+            const frameId = this.getExecutor().enterFrame(frameType);
+            this.visit(ctxExpressionsBlock);
+            this.getExecutor().exitFrame(frameId);
+        }
     };
     visitNet_namespace_expr = (ctx) => {
         let dataValue;