circuitscript 0.6.0 → 0.6.1

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

@@ -1028,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
@@ -1040,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/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/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

@@ -455,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:
@@ -681,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";
@@ -1048,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/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";
@@ -237,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;
@@ -244,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));
                 }
             });
         }
@@ -700,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);
@@ -716,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;
                 }
@@ -1069,18 +1078,36 @@ export class ParserVisitor extends BaseVisitor {
     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");