circuitscript 0.0.26 → 0.0.28

package/dist/esm/antlr/CircuitScriptVisitor.mjs

@@ -50,6 +50,7 @@ export class CircuitScriptVisitor extends AbstractParseTreeVisitor {
     visitFunction_return_expr;
     visitCreate_component_expr;
     visitCreate_graphic_expr;
+    visitNested_properties_inner;
     visitGraphic_expr;
     visitProperty_expr;
     visitProperty_key_expr;

package/dist/esm/draw_symbols.mjs

@@ -1,5 +1,5 @@
 import { ReferenceTypes, SymbolPinSide, defaultFont } from "./globals.mjs";
-import { Geometry, GeometryProp, HorizontalAlign, Label, VerticalAlign } from "./geometry.mjs";
+import { Geometry, GeometryProp, HorizontalAlign, Textbox, VerticalAlign } from "./geometry.mjs";
 import { PinTypes } from "./objects/PinTypes.mjs";
 const defaultSymbolLineWidth = 2;
 export class SymbolGraphic {
@@ -252,7 +252,7 @@ export class SymbolText extends SymbolGraphic {
     }
     generateDrawing() {
         const drawing = new SymbolDrawing();
-        drawing.addLabel(0, 0, this.text, {
+        drawing.addTextbox(0, 0, this.text, {
             fontSize: this.fontSize,
             anchor: HorizontalAlign.Middle,
             fontWeight: this.fontWeight,
@@ -317,13 +317,7 @@ export class SymbolPlaceholder extends SymbolGraphic {
                         break;
                     }
                 case PlaceHolderCommands.label: {
-                    const keywords = ['fontSize', 'anchor', 'vanchor', 'angle'];
-                    const style = {};
-                    keywords.forEach(item => {
-                        if (keywordParams.has(item)) {
-                            style[item] = keywordParams.get(item);
-                        }
-                    });
+                    const style = this.parseLabelStyle(keywordParams);
                     positionParams = [...positionParams];
                     positionParams.push(style);
                     const labelId = positionParams[0];
@@ -336,10 +330,33 @@ export class SymbolPlaceholder extends SymbolGraphic {
                     drawing.addLabelId(...tmpPositionParams);
                     break;
                 }
+                case PlaceHolderCommands.text: {
+                    const style = this.parseLabelStyle(keywordParams);
+                    const content = keywordParams.get('content');
+                    let offsetX = 0;
+                    let offsetY = 0;
+                    if (keywordParams.has('offset')) {
+                        const offset = keywordParams.get('offset');
+                        offsetX = offset[0];
+                        offsetY = offset[1];
+                    }
+                    drawing.addTextbox(offsetX, offsetY, content, style);
+                    break;
+                }
             }
         });
         drawing.log("=== end generate drawing ===");
     }
+    parseLabelStyle(keywordParams) {
+        const keywords = ['fontSize', 'anchor', 'vanchor', 'angle'];
+        const style = {};
+        keywords.forEach(item => {
+            if (keywordParams.has(item)) {
+                style[item] = keywordParams.get(item);
+            }
+        });
+        return style;
+    }
     drawPinParams(drawing, commandName, keywordParams, positionParams) {
         drawing.log('add pin', ...positionParams);
         const keywordDisplayPinId = 'display_pin_id';
@@ -449,6 +466,7 @@ export var PlaceHolderCommands;
     PlaceHolderCommands["lineWidth"] = "lineWidth";
     PlaceHolderCommands["fill"] = "fill";
     PlaceHolderCommands["lineColor"] = "lineColor";
+    PlaceHolderCommands["text"] = "text";
 })(PlaceHolderCommands || (PlaceHolderCommands = {}));
 export class SymbolCustom extends SymbolGraphic {
     pinDefinition = [];
@@ -636,6 +654,10 @@ export class SymbolDrawing {
         this.items.push(Geometry.label(id, x, y, textValue, style));
         return this;
     }
+    addTextbox(x, y, textValue, style) {
+        this.items.push(Geometry.textbox(null, x, y, textValue, style));
+        return this;
+    }
     addPath(...pathParts) {
         const parts = pathParts.reduce((accum, tmp) => {
             if (typeof tmp === "string") {
@@ -710,7 +732,7 @@ export class SymbolDrawing {
         let currentLineColor = '#333';
         const pathItems = [];
         this.items.forEach(item => {
-            if (!(item instanceof Label)) {
+            if (!(item instanceof Textbox)) {
                 if (item instanceof GeometryProp) {
                     if (item.name === 'lineWidth') {
                         currentLineWidth = item.value;
@@ -725,7 +747,7 @@ export class SymbolDrawing {
                 else {
                     let tmpResult = Geometry.groupFlip([item], this.flipX, this.flipY);
                     tmpResult = Geometry.groupRotate(tmpResult, this.angle, this.mainOrigin);
-                    const { path, isClosedPolygon } = this.featuresToPath(tmpResult);
+                    const { path, isClosedPolygon } = this.featuresToPath(tmpResult, this.flipX, this.flipY);
                     pathItems.push({
                         path: path,
                         lineWidth: currentLineWidth,
@@ -741,21 +763,21 @@ export class SymbolDrawing {
         let features = this.pins.map(item => item[1]);
         features = Geometry.groupFlip(features, this.flipX, this.flipY);
         features = Geometry.groupRotate(features, this.angle, this.mainOrigin);
-        const { path } = this.featuresToPath(features);
+        const { path } = this.featuresToPath(features, this.flipX, this.flipY);
         return path;
     }
     getLabels() {
-        return this.items.filter(item => item instanceof Label);
+        return this.items.filter(item => item instanceof Textbox);
     }
-    featuresToPath(items) {
-        return Geometry.featuresToPath(items);
+    featuresToPath(items, flipX, flipY) {
+        return Geometry.featuresToPath(items, flipX, flipY);
     }
     getBoundingBox(excludeLabels = false) {
         const pinFeatures = this.pins.map(pin => {
             return pin[1];
         });
         const drawingFeatures = this.items.reduce((accum, item) => {
-            if (!excludeLabels || (excludeLabels && !(item instanceof Label))) {
+            if (!excludeLabels || (excludeLabels && !(item instanceof Textbox && item.label))) {
                 if (!(item instanceof GeometryProp)) {
                     accum.push(item);
                 }

package/dist/esm/execute.mjs

@@ -3,8 +3,10 @@ import { ClassComponent } from './objects/ClassComponent.mjs';
 import { ActiveObject, ExecutionScope, FrameAction, SequenceAction } from './objects/ExecutionScope.mjs';
 import { Net } from './objects/Net.mjs';
 import { PortSide } from './objects/PinDefinition.mjs';
+import { Direction } from './objects/types.mjs';
 import { Wire } from './objects/Wire.mjs';
 import { Frame } from './objects/Frame.mjs';
+import { CalculatePinPositions } from './layout.mjs';
 export class ExecutionContext {
     name;
     namespace;
@@ -19,6 +21,7 @@ export class ExecutionContext {
     logger;
     __functionCache = {};
     parentContext;
+    componentAngleFollowsWire = true;
     constructor(name, namespace, netNamespace, executionLevel = 0, indentLevel = 0, silent = false, logger, parent) {
         this.name = name;
         this.namespace = namespace;
@@ -149,6 +152,15 @@ export class ExecutionContext {
         component.widthProp = props.width ?? null;
         component.typeProp = props.type ?? null;
         component.copyProp = props.copy ?? false;
+        let useAngle = null;
+        if (props.angle) {
+            useAngle = props.angle % 360;
+            if (useAngle < 0) {
+                useAngle += 360;
+            }
+        }
+        component.angleProp = useAngle ?? 0;
+        component.followWireOrientationProp = props.followWireOrientation;
         const paramsMap = new Map();
         params.forEach((param) => {
             component.parameters.set(param.paramName, param.paramValue);
@@ -205,6 +217,7 @@ export class ExecutionContext {
     addComponentExisting(component, pin) {
         const startPin = pin;
         const nextPin = component.getNextPinAfter(startPin);
+        this.applyComponentAngleFromWire(component, pin);
         this.toComponent(component, startPin, { addSequence: true });
         this.log('move to next pin: ' + nextPin);
         this.atComponent(component, nextPin, {
@@ -240,6 +253,7 @@ export class ExecutionContext {
                 .toString());
         }
         const linkedNet = this.linkComponentPinNet(this.scope.currentComponent, this.scope.currentPin, component, pinId);
+        this.applyComponentAngleFromWire(component, pinId);
         this.scope.currentComponent = component;
         this.scope.currentPin = pinId;
         this.scope.clearActive();
@@ -688,6 +702,59 @@ export class ExecutionContext {
             this.scope.currentComponent.styles[key] = styles[key];
         }
     }
+    applyComponentAngleFromWire(component, pin) {
+        if (this.componentAngleFollowsWire
+            && component.followWireOrientationProp
+            && component.useWireOrientationAngle
+            && this.scope.currentWireId !== -1) {
+            const currentWire = this.scope.wires[this.scope.currentWireId];
+            const lastSegment = currentWire.path[currentWire.path.length - 1];
+            const pinPositions = CalculatePinPositions(component);
+            if (pinPositions.has(pin)) {
+                const connectedPinPos = pinPositions.get(pin);
+                let targetAngle = null;
+                switch (lastSegment.direction) {
+                    case Direction.Down:
+                        targetAngle = 90;
+                        break;
+                    case Direction.Up:
+                        targetAngle = 270;
+                        break;
+                    case Direction.Right:
+                        targetAngle = 0;
+                        break;
+                    case Direction.Left:
+                        targetAngle = 180;
+                        break;
+                    default:
+                        targetAngle = null;
+                }
+                if (targetAngle === null) {
+                    return;
+                }
+                this.log('set component angle from wire, target angle:', targetAngle, ', component angle:', component.angleProp, 'pin angle:', connectedPinPos.angle);
+                let useAngle = (targetAngle - connectedPinPos.angle) % 360;
+                if (useAngle < 0) {
+                    useAngle += 360;
+                }
+                if (useAngle === 90) {
+                    component.setParam('angle', 90);
+                }
+                else if (useAngle === 180) {
+                    if (component.angleProp === 0 || component.angleProp === 180) {
+                        component.setParam('flipX', 1);
+                    }
+                    else if (component.angleProp === 90 || component.angleProp === 270) {
+                        component.setParam('flipY', 1);
+                    }
+                }
+                else if (useAngle === 270) {
+                    component.setParam('angle', 270);
+                }
+                component.wireOrientationAngle = useAngle;
+            }
+        }
+    }
     enterFrame() {
         const frameId = this.scope.frames.length + 1;
         const frameObject = new Frame(frameId);

package/dist/esm/geometry.mjs

@@ -2,7 +2,7 @@ import Flatten from '@flatten-js/core';
 import { measureTextSize2 } from './sizing.mjs';
 import { defaultFont } from './globals.mjs';
 import { NumericValue } from './objects/ParamDefinition.mjs';
-export class Label extends Flatten.Polygon {
+export class Textbox extends Flatten.Polygon {
     id;
     text;
     anchorPoint = [0, 0];
@@ -11,10 +11,11 @@ export class Label extends Flatten.Polygon {
     font = 'default';
     style;
     textMeasurementBounds;
+    label;
     get box() {
         return this.polygon.box;
     }
-    constructor(id, text, anchorPoint, polygon, style, bounds) {
+    constructor(id, text, anchorPoint, polygon, style, bounds, label) {
         super(polygon.vertices);
         this.id = id;
         this.text = text;
@@ -23,8 +24,9 @@ export class Label extends Flatten.Polygon {
         this.boundingBox = polygon.box;
         this.polygon = polygon;
         this.textMeasurementBounds = bounds;
+        this.label = label;
     }
-    static fromPoint(id, x, y, text, style) {
+    static fromPoint(id, x, y, text, style, label) {
         let useText;
         if (typeof text === 'number') {
             useText = text.toString();
@@ -37,7 +39,7 @@ export class Label extends Flatten.Polygon {
             useText = text;
         }
         else {
-            throw 'Invalid string passed into label';
+            throw 'Invalid string passed into textbox';
         }
         const { fontSize = 10, anchor = HorizontalAlign.Left, vanchor = VerticalAlign.Bottom, fontWeight = 'regular', } = style ?? {};
         const { width, height, box } = measureTextSize2(useText, defaultFont, fontSize, fontWeight, anchor, vanchor);
@@ -49,20 +51,22 @@ export class Label extends Flatten.Polygon {
             [box.x, box.y],
         ];
         const polygon = new Flatten.Polygon(polygonCoords);
-        return new Label(id, useText, [x, y], polygon, style, box);
+        return new Textbox(id, useText, [x, y], polygon, style, box, label);
     }
     rotate(angle, origin) {
         const feature = super.rotate(angle, origin);
-        return new Label(this.id, this.text, this.anchorPoint, feature, this.style, this.textMeasurementBounds);
+        return new Textbox(this.id, this.text, this.anchorPoint, feature, this.style, this.textMeasurementBounds, this.label);
     }
     transform(matrix) {
         const feature = super.transform(matrix);
-        return new Label(this.id, this.text, this.anchorPoint, feature, this.style, this.textMeasurementBounds);
+        return new Textbox(this.id, this.text, this.anchorPoint, feature, this.style, this.textMeasurementBounds, this.label);
     }
     getLabelPosition() {
         return this.anchorPoint;
     }
 }
+export class Label extends Textbox {
+}
 export class GeometryProp {
     name;
     value;
@@ -79,7 +83,10 @@ export class Geometry {
         return new Flatten.Line(Geometry.point(x1, y1), Geometry.point(x2, y2));
     }
     static label(id, x, y, text, style) {
-        return Label.fromPoint(id, x, y, text, style);
+        return Textbox.fromPoint(id, x, y, text, style, true);
+    }
+    static textbox(id, x, y, text, style) {
+        return Textbox.fromPoint(id, x, y, text, style, false);
     }
     static segment(start, end) {
         return new Flatten.Segment(Geometry.point(start[0], start[1]), Geometry.point(end[0], end[1]));
@@ -130,12 +137,28 @@ export class Geometry {
         let maxX = Number.NEGATIVE_INFINITY;
         let maxY = Number.NEGATIVE_INFINITY;
         features.forEach(feature => {
-            const box = feature.box;
-            if (feature instanceof Label
+            const tmpBox = feature.box;
+            let box = {
+                xmin: tmpBox.xmin,
+                ymin: tmpBox.ymin,
+                xmax: tmpBox.xmax,
+                ymax: tmpBox.ymax
+            };
+            if (feature instanceof Textbox
+                && feature.label
                 && typeof feature.text === 'string'
                 && feature.text.trim().length === 0) {
                 return;
             }
+            if (feature instanceof Textbox && !feature.label) {
+                const [x, y] = feature.anchorPoint;
+                box = {
+                    xmin: box.xmin + x,
+                    ymin: box.ymin + y,
+                    xmax: box.xmax + x,
+                    ymax: box.ymax + y
+                };
+            }
             if (box.xmin === undefined) {
                 throw "Invalid box!";
             }
@@ -151,24 +174,12 @@ export class Geometry {
             height: maxY - minY,
         };
     }
-    static getType(feature) {
-        if (feature instanceof Label) {
-            return 'label';
-        }
-        else if (feature instanceof Flatten.Polygon) {
-            return 'polygon';
-        }
-        else if (feature instanceof Flatten.Segment) {
-            return 'segment';
-        }
-        console.log('unknown type', feature);
-    }
     static FullCircleRadians = 2 * Math.PI;
-    static featuresToPath(items) {
+    static featuresToPath(items, flipX, flipY) {
         const paths = [];
         let isClosedPolygon = false;
         items.forEach(item => {
-            if (item instanceof Label) {
+            if (item instanceof Textbox) {
                 return;
             }
             const path = [];
@@ -185,7 +196,15 @@ export class Geometry {
                 }
                 const startPoint = getArcPointRadians(x, y, radius, item.startAngle);
                 const endPoint = getArcPointRadians(x, y, radius, useEndAngle);
-                paths.push('M', startPoint[0], startPoint[1], 'A', radius, radius, 0, 1, 1, endPoint[0], endPoint[1], extraEnd);
+                let largeArcSweepFlag = 0;
+                if (useEndAngle - item.startAngle > Math.PI) {
+                    largeArcSweepFlag = 1;
+                }
+                let sweepFlag = 1;
+                if (flipX === 1 && flipY === 0) {
+                    sweepFlag = 0;
+                }
+                paths.push('M', startPoint[0], startPoint[1], 'A', radius, radius, 0, largeArcSweepFlag, sweepFlag, endPoint[0], endPoint[1], extraEnd);
             }
             else {
                 const coords = Geometry.getCoords(item);

package/dist/esm/helpers.mjs

@@ -215,6 +215,7 @@ export function renderScript(scriptData, outputPath, options) {
         showStats && console.log('Render took:', generateSvgTimer.lap());
         if (outputPath) {
             writeFileSync(outputPath, svgOutput);
+            console.log('Generated file', outputPath);
         }
     }
     catch (err) {

package/dist/esm/layout.mjs

@@ -7,6 +7,7 @@ import { Geometry } from './geometry.mjs';
 import { Logger } from './logger.mjs';
 import { Frame, FrameParamKeys, FramePlotDirection } from './objects/Frame.mjs';
 import { getBoundsSize, printBounds, resizeBounds, resizeToNearestGrid, toNearestGrid } from './utils.mjs';
+import { Direction } from './objects/types.mjs';
 export class LayoutEngine {
     logger;
     placeSubgraphVersion = 2;
@@ -935,16 +936,16 @@ function applyComponentParamsToSymbol(typeProp, component, symbol) {
 function calculateSymbolAngle(symbol, pin, direction) {
     let directionVector = 0;
     switch (direction) {
-        case 'right':
+        case Direction.Right:
             directionVector = 0;
             break;
-        case 'down':
+        case Direction.Down:
             directionVector = 90;
             break;
-        case 'left':
+        case Direction.Left:
             directionVector = 180;
             break;
-        case 'up':
+        case Direction.Up:
             directionVector = 270;
             break;
     }
@@ -1012,16 +1013,16 @@ export class RenderWire extends RenderObject {
         this.segments.forEach(segment => {
             const { direction, value } = segment;
             let didAddPoint = false;
-            if (direction === 'down') {
+            if (direction === Direction.Down) {
                 tmpY += value;
             }
-            else if (direction === 'up') {
+            else if (direction === Direction.Up) {
                 tmpY -= value;
             }
-            else if (direction === 'left') {
+            else if (direction === Direction.Left) {
                 tmpX -= value;
             }
-            else if (direction === 'right') {
+            else if (direction === Direction.Right) {
                 tmpX += value;
             }
             else if (direction === 'auto' || direction === "auto_") {
@@ -1090,16 +1091,16 @@ export class RenderWire extends RenderObject {
         let tmpY = this.y;
         excludeLastSegment.forEach(segment => {
             const { direction, value } = segment;
-            if (direction === 'down') {
+            if (direction === Direction.Down) {
                 tmpY += value;
             }
-            else if (direction === 'up') {
+            else if (direction === Direction.Up) {
                 tmpY -= value;
             }
-            else if (direction === 'left') {
+            else if (direction === Direction.Left) {
                 tmpX -= value;
             }
-            else if (direction === 'right') {
+            else if (direction === Direction.Right) {
                 tmpX += value;
             }
         });
@@ -1107,16 +1108,16 @@ export class RenderWire extends RenderObject {
         let valueXY = null;
         const lastSegment = this.segments[this.segments.length - 1];
         switch (lastSegment.direction) {
-            case 'left':
+            case Direction.Left:
                 useValue = tmpX - untilX;
                 break;
-            case 'right':
+            case Direction.Right:
                 useValue = untilX - tmpX;
                 break;
-            case 'up':
+            case Direction.Up:
                 useValue = untilY - tmpY;
                 break;
-            case 'down':
+            case Direction.Down:
                 useValue = tmpY - untilY;
                 break;
             case 'auto':
@@ -1224,6 +1225,24 @@ export class RenderJunction {
         this.y = y;
     }
 }
+export function CalculatePinPositions(component) {
+    const pinPositionMapping = new Map();
+    let tmpSymbol;
+    if (component.displayProp !== null
+        && component.displayProp instanceof SymbolDrawing) {
+        tmpSymbol = new SymbolPlaceholder(component.displayProp);
+    }
+    else {
+        const symbolPinDefinitions = generateLayoutPinDefinition(component);
+        tmpSymbol = new SymbolCustom(symbolPinDefinitions);
+    }
+    tmpSymbol.refreshDrawing();
+    const pins = component.pins;
+    pins.forEach((value, key) => {
+        pinPositionMapping.set(key, tmpSymbol.pinPosition(key));
+    });
+    return pinPositionMapping;
+}
 function isPointOverlap(x, y, other) {
     return (x >= other.x && y >= other.y && x <= (other.x + other.width) && y <= (other.y + other.height));
 }

package/dist/esm/objects/ClassComponent.mjs

@@ -18,6 +18,10 @@ export class ClassComponent {
     widthProp = null;
     typeProp = null;
     copyProp = false;
+    angleProp = 0;
+    followWireOrientationProp = true;
+    wireOrientationAngle = 0;
+    useWireOrientationAngle = true;
     styles = {};
     assignedRefDes = null;
     constructor(instanceName, numPins, className) {
@@ -120,6 +124,9 @@ export class ClassComponent {
         component.arrangeProps = this.arrangeProps;
         component.widthProp = this.widthProp;
         component.typeProp = this.typeProp;
+        component.angleProp = this.angleProp;
+        component.followWireOrientationProp = this.followWireOrientationProp;
+        component.useWireOrientationAngle = this.useWireOrientationAngle;
         if (this.displayProp) {
             if (typeof this.displayProp === "string") {
                 component.displayProp = this.displayProp;

package/dist/esm/objects/types.mjs

@@ -10,3 +10,10 @@ export var ParseSymbolType;
     ParseSymbolType["Function"] = "function";
     ParseSymbolType["Undefined"] = "undefined";
 })(ParseSymbolType || (ParseSymbolType = {}));
+export var Direction;
+(function (Direction) {
+    Direction["Left"] = "left";
+    Direction["Right"] = "right";
+    Direction["Down"] = "down";
+    Direction["Up"] = "up";
+})(Direction || (Direction = {}));

package/dist/esm/visitor.mjs

@@ -4,7 +4,7 @@ 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 { SymbolDrawingCommands } from './draw_symbols.mjs';
+import { PlaceHolderCommands, SymbolDrawingCommands } from './draw_symbols.mjs';
 import { BaseVisitor } from './BaseVisitor.mjs';
 export class ParserVisitor extends BaseVisitor {
     visitKeyword_assignment_expr = (ctx) => {
@@ -30,7 +30,7 @@ export class ParserVisitor extends BaseVisitor {
         const ctxDataWithAssignmentExpr = ctx.data_expr_with_assignment();
         this.visit(ctxDataWithAssignmentExpr);
         const [component, pinValue] = this.getResult(ctxDataWithAssignmentExpr);
-        return this.getExecutor().addComponentExisting(component, pinValue);
+        this.getExecutor().addComponentExisting(component, pinValue);
     };
     visitAt_component_expr = (ctx) => {
         if (ctx.Point()) {
@@ -137,12 +137,13 @@ export class ParserVisitor extends BaseVisitor {
             properties.get('copy') : false;
         const width = properties.has('width') ?
             properties.get('width') : null;
+        const angle = properties.has('angle') ?
+            properties.get('angle') : null;
+        const followWireOrientation = properties.has('followWireOrientation') ?
+            properties.get('followWireOrientation') : true;
         const props = {
-            arrange,
-            display,
-            type,
-            width,
-            copy
+            arrange, display, type, width, copy,
+            angle, followWireOrientation
         };
         this.setResult(ctx, this.getExecutor().createComponent(instanceName, pins, params, props));
     };
@@ -176,9 +177,20 @@ export class ParserVisitor extends BaseVisitor {
         else {
             throw "Invalid command!";
         }
-        const ctxParameters = ctx.parameters();
-        this.visit(ctxParameters);
-        const parameters = this.getResult(ctxParameters);
+        let parameters = [];
+        const ctxNestedProperties = ctx.nested_properties_inner();
+        if (ctxNestedProperties) {
+            this.visit(ctxNestedProperties);
+            const nestedKeyValues = this.getResult(ctxNestedProperties);
+            nestedKeyValues.forEach((value, key) => {
+                parameters.push(['keyword', key, value]);
+            });
+        }
+        else {
+            const ctxParameters = ctx.parameters();
+            this.visit(ctxParameters);
+            parameters = this.getResult(ctxParameters);
+        }
         this.setResult(ctx, [commandName, parameters]);
     };
     visitProperty_expr = (ctx) => {
@@ -207,7 +219,7 @@ export class ParserVisitor extends BaseVisitor {
         }
         this.setResult(ctx, value);
     };
-    visitNested_properties = (ctx) => {
+    visitNested_properties_inner = (ctx) => {
         const result = new Map();
         ctx.property_expr().forEach((item) => {
             this.visit(item);
@@ -218,6 +230,11 @@ export class ParserVisitor extends BaseVisitor {
         });
         this.setResult(ctx, result);
     };
+    visitNested_properties = (ctx) => {
+        const ctxNested = ctx.nested_properties_inner();
+        this.visit(ctxNested);
+        this.setResult(ctx, this.getResult(ctxNested));
+    };
     visitProperty_key_expr = (ctx) => {
         const ctxID = ctx.ID();
         const ctxIntegerValue = ctx.INTEGER_VALUE();
@@ -267,18 +284,40 @@ export class ParserVisitor extends BaseVisitor {
                 else if (ctxID2) {
                     result = ctxID2.getText();
                 }
+                let shouldIgnoreWireOrientation = false;
                 if (modifierText === 'flip') {
                     const flipValue = result;
                     if (flipValue.indexOf('x') !== -1) {
                         component.setParam('flipX', 1);
+                        shouldIgnoreWireOrientation = true;
                     }
                     if (flipValue.indexOf('y') !== -1) {
                         component.setParam('flipY', 1);
+                        shouldIgnoreWireOrientation = true;
                     }
                 }
                 else if (modifierText === 'angle') {
                     const angleValue = Number(result);
                     component.setParam('angle', angleValue);
+                    shouldIgnoreWireOrientation = true;
+                }
+                else if (modifierText === 'anchor') {
+                    if (component.displayProp
+                        && component.displayProp instanceof SymbolDrawingCommands) {
+                        const commands = (component.displayProp)
+                            .getCommands();
+                        commands.forEach(command => {
+                            const positionParams = command[1];
+                            const keywordParams = command[2];
+                            if (command[0] === PlaceHolderCommands.label
+                                && positionParams[0] === 'value') {
+                                keywordParams.set('anchor', result);
+                            }
+                        });
+                    }
+                }
+                if (shouldIgnoreWireOrientation) {
+                    component.useWireOrientationAngle = false;
                 }
             });
         }