circuitscript 0.1.8 → 0.1.9

package/dist/esm/visitor.js

@@ -47,7 +47,7 @@ export class ParserVisitor extends BaseVisitor {
                 });
             }
             catch (err) {
-                throw new RuntimeExecutionError(err.message, ctx.start, ctx.stop);
+                throw new RuntimeExecutionError(err.message, ctx);
             }
         });
         return this.getExecutor().getCurrentPoint();
@@ -115,6 +115,24 @@ export class ParserVisitor extends BaseVisitor {
     };
     visitCreate_component_expr = (ctx) => {
         const scope = this.getScope();
+        const definedPinIds = [];
+        const arrangedPinIds = [];
+        const checkPinExistsAndNotDuplicated = (pinId, ctx) => {
+            if (definedPinIds.indexOf(pinId) === -1) {
+                this.warnings.push({
+                    message: `Invalid pin ${pinId}`, ctx
+                });
+            }
+            if (arrangedPinIds.indexOf(pinId) !== -1) {
+                this.warnings.push({
+                    message: `Pin ${pinId} specified more than once`,
+                    ctx,
+                });
+            }
+            arrangedPinIds.push(pinId);
+        };
+        let didDefineArrangeProp = false;
+        let didDefineDisplayProp = false;
         scope.setOnPropertyHandler((path, value, ctx) => {
             if (path.length === 1) {
                 const [, keyName] = path[0];
@@ -127,9 +145,25 @@ export class ParserVisitor extends BaseVisitor {
                     case 'height':
                         this.validateNumeric(value, ctx);
                         break;
+                    case 'display':
+                        if (didDefineArrangeProp) {
+                            throw new RuntimeExecutionError("arrange property has already been defined", ctx);
+                        }
+                        didDefineDisplayProp = true;
+                        break;
+                    case 'arrange':
+                        if (didDefineDisplayProp) {
+                            throw new RuntimeExecutionError("display property already defined", ctx);
+                        }
+                        didDefineArrangeProp = true;
+                        break;
                     case 'pins':
                         if (!(value instanceof Map)) {
                             this.validateNumeric(value, ctx);
+                            const numPins = value.toNumber();
+                            for (let i = 0; i < numPins; i++) {
+                                definedPinIds.push(i + 1);
+                            }
                         }
                         break;
                     case 'copy':
@@ -140,7 +174,7 @@ export class ParserVisitor extends BaseVisitor {
                             this.validateBoolean(value, ctx);
                         }
                         else {
-                            throw new RuntimeExecutionError("Invalid value for 'copy' property", ctx.start, ctx.end);
+                            throw new RuntimeExecutionError("Invalid value for 'copy' property", ctx);
                         }
                         break;
                 }
@@ -150,20 +184,26 @@ export class ParserVisitor extends BaseVisitor {
                 if (keyName === 'arrange') {
                     const [sideKeyCtx, sideKeyName] = path[1];
                     if (ValidPinSides.indexOf(sideKeyName) === -1) {
-                        throw new RuntimeExecutionError(`Invalid side ${sideKeyName} in arrange`, sideKeyCtx.start, sideKeyCtx.stop);
+                        throw new RuntimeExecutionError(`Invalid side ${sideKeyName} in arrange`, sideKeyCtx);
                     }
                     else {
-                        if (path.length > 2 && path[2][0] === 'index') {
+                        if (path.length === 2 && value instanceof NumericValue) {
+                            checkPinExistsAndNotDuplicated(value.toNumber(), ctx);
+                        }
+                        else if (path.length > 2 && path[2][0] === 'index') {
                             if (Array.isArray(value)) {
                                 const goodBlank = value.length === 1 &&
                                     value[0] instanceof NumericValue;
                                 if (!goodBlank) {
-                                    throw new RuntimeExecutionError(`Invalid blank specifier`, ctx.start, ctx.stop);
+                                    throw new RuntimeExecutionError(`Invalid blank specifier`, ctx);
                                 }
                             }
                             else {
                                 if (!(value instanceof NumericValue)) {
-                                    throw new RuntimeExecutionError(`Invalid numeric value for arrange.${sideKeyName}`, ctx.start, ctx.stop);
+                                    throw new RuntimeExecutionError(`Invalid numeric value for arrange.${sideKeyName}`, ctx);
+                                }
+                                else {
+                                    checkPinExistsAndNotDuplicated(value.toNumber(), ctx);
                                 }
                             }
                         }
@@ -184,10 +224,12 @@ export class ParserVisitor extends BaseVisitor {
                 }
                 else if (keyName === 'pins') {
                     if (path.length === 2) {
+                        const idName = path[1][1];
+                        definedPinIds.push(idName);
                         if (value.length === 2) {
                             const [pinType,] = value;
                             if (pinType instanceof UndeclaredReference) {
-                                throw new RuntimeExecutionError(`Invalid pin type: ${pinType.reference.name}`, ctx.start, ctx.end);
+                                throw new RuntimeExecutionError(`Invalid pin type: ${pinType.reference.name}`, ctx);
                             }
                         }
                     }
@@ -416,7 +458,7 @@ export class ParserVisitor extends BaseVisitor {
         this.getScope().enterContext(ctxValue);
         const keyName = this.visitResult(ctxKey);
         const value = this.visitResult(ctxValue);
-        scope.triggerPropertyHandler(value, ctxValue);
+        scope.triggerPropertyHandler(this, value, ctxValue);
         this.getScope().exitContext();
         this.getScope().exitContext();
         if (value instanceof UndeclaredReference && (value.reference.parentValue === undefined
@@ -437,7 +479,7 @@ export class ParserVisitor extends BaseVisitor {
             value = ctx.data_expr().map((item, index) => {
                 this.getScope().enterContext(index);
                 const result = this.visitResult(item);
-                this.getScope().triggerPropertyHandler(result, item);
+                this.getScope().triggerPropertyHandler(this, result, item);
                 this.getScope().exitContext();
                 return result;
             });
@@ -1063,45 +1105,46 @@ export class ParserVisitor extends BaseVisitor {
     parseCreateComponentPins(pinData) {
         const pins = [];
         if (pinData instanceof NumericValue) {
+            const tmpMap = new Map();
             const lastPin = pinData.toNumber();
             for (let i = 0; i < lastPin; i++) {
                 const pinId = i + 1;
-                pins.push(new PinDefinition(pinId, PinIdType.Int, pinId.toString()));
+                tmpMap.set(pinId, numeric(pinId));
             }
-        }
-        else if (pinData instanceof Map) {
-            for (const [pinId, pinDef] of pinData) {
-                let pinIdType = PinIdType.Int;
-                let pinType = PinTypes.Any;
-                let pinName = null;
-                let altPinNames = [];
-                if (typeof pinId === 'string') {
-                    pinIdType = PinIdType.Str;
-                }
-                if (Array.isArray(pinDef)) {
-                    const firstValue = pinDef[0];
-                    if (firstValue.type
-                        && firstValue.type === ReferenceTypes.pinType
-                        && this.pinTypes.indexOf(firstValue.value) !== -1) {
-                        pinType = firstValue.value;
-                        pinName = pinDef[1];
-                        if (pinDef.length > 2) {
-                            altPinNames = pinDef.slice(2);
-                        }
-                    }
-                    else {
-                        pinName = pinDef[0];
-                        if (pinDef.length > 1) {
-                            altPinNames = pinDef.slice(1);
-                        }
+            pinData = tmpMap;
+        }
+        pinData = pinData ?? [];
+        for (const [pinId, pinDef] of pinData) {
+            let pinIdType = PinIdType.Int;
+            let pinType = PinTypes.Any;
+            let pinName = null;
+            let altPinNames = [];
+            if (typeof pinId === 'string') {
+                pinIdType = PinIdType.Str;
+            }
+            if (Array.isArray(pinDef)) {
+                const firstValue = pinDef[0];
+                if (firstValue.type
+                    && firstValue.type === ReferenceTypes.pinType
+                    && this.pinTypes.indexOf(firstValue.value) !== -1) {
+                    pinType = firstValue.value;
+                    pinName = pinDef[1];
+                    if (pinDef.length > 2) {
+                        altPinNames = pinDef.slice(2);
                     }
                 }
                 else {
-                    pinName = pinDef;
+                    pinName = pinDef[0];
+                    if (pinDef.length > 1) {
+                        altPinNames = pinDef.slice(1);
+                    }
                 }
-                this.log('pins', pinId, pinIdType, pinName, pinType, altPinNames);
-                pins.push(new PinDefinition(pinId, pinIdType, pinName, pinType, altPinNames));
             }
+            else {
+                pinName = pinDef;
+            }
+            this.log('pins', pinId, pinIdType, pinName, pinType, altPinNames);
+            pins.push(new PinDefinition(pinId, pinIdType, pinName, pinType, altPinNames));
         }
         return pins;
     }
@@ -1310,6 +1353,9 @@ export class ParserVisitor extends BaseVisitor {
         });
         return properties;
     }
+    getWarnings() {
+        return this.warnings;
+    }
 }
 const ComponentRefDesPrefixes = {
     res: 'R',

package/dist/types/BaseVisitor.d.ts

@@ -6,6 +6,7 @@ import { ClassComponent } from "./objects/ClassComponent.js";
 import { Net } from "./objects/Net.js";
 import { CallableParameter, CFunctionOptions, ComplexType, Direction, FunctionDefinedParameter, ReferenceType } from "./objects/types.js";
 import { ParserRuleContext } from 'antlr4ng';
+import { ExecutionWarning } from "./utils.js";
 import { BaseError } from './utils.js';
 import { ExecutionScope } from './objects/ExecutionScope.js';
 import { NodeScriptEnvironment } from "./environment.js";
@@ -24,6 +25,7 @@ export declare class BaseVisitor extends CircuitScriptVisitor<ComplexType | Refe
     onErrorHandler: OnErrorHandler | null;
     environment: NodeScriptEnvironment;
     protected importedFiles: ImportFile[];
+    protected warnings: ExecutionWarning[];
     onImportFile: (visitor: BaseVisitor, filePath: string, fileData: string, onErrorHandler: OnErrorHandler) => Promise<{
         hasError: boolean;
         hasParseError: boolean;
@@ -60,7 +62,7 @@ export declare class BaseVisitor extends CircuitScriptVisitor<ComplexType | Refe
     visitArrayExpr: (ctx: ArrayExprContext) => void;
     protected setResult(ctx: ParserRuleContext, value: any): void;
     protected getResult(ctx: ParserRuleContext): any;
-    protected visitResult(ctx: ParserRuleContext): any;
+    visitResult(ctx: ParserRuleContext): any;
     protected handleImportFile(name: string, throwErrors?: boolean, ctx?: ParserRuleContext | null): Promise<ImportFile>;
     visitRoundedBracketsExpr: (ctx: RoundedBracketsExprContext) => void;
     protected setupDefinedParameters(funcDefinedParameters: FunctionDefinedParameter[], passedInParameters: CallableParameter[], executor: ExecutionContext): void;

package/dist/types/execute.d.ts

@@ -1,4 +1,5 @@
 import { BlockTypes, FrameType } from './globals.js';
+import { ExecutionWarning } from "./utils.js";
 import { ClassComponent } from './objects/ClassComponent.js';
 import { ExecutionScope } from './objects/ExecutionScope.js';
 import { Net } from './objects/Net.js';
@@ -28,7 +29,9 @@ export declare class ExecutionContext {
     __functionCache: {};
     parentContext: ExecutionContext;
     componentAngleFollowsWire: boolean;
-    constructor(name: string, namespace: string, netNamespace: string, executionLevel: number | undefined, indentLevel: number | undefined, silent: boolean | undefined, logger: Logger, parent: ExecutionContext);
+    warnings: ExecutionWarning[];
+    constructor(name: string, namespace: string, netNamespace: string, executionLevel: number | undefined, indentLevel: number | undefined, silent: boolean | undefined, logger: Logger, warnings: ExecutionWarning[], parent: ExecutionContext);
+    logWarning(message: string, context?: ParserRuleContext, fileName?: string): void;
     log(...params: any[]): void;
     private setupRoot;
     getUniqueInstanceName(): string;
@@ -46,6 +49,8 @@ export declare class ExecutionContext {
         angle?: NumericValue;
         followWireOrientation: boolean;
     }, isModule?: boolean): ClassComponent;
+    private removeArrangePropDuplicates;
+    private getArrangePropPins;
     printPoint(extra?: string): void;
     addComponentExisting(component: ClassComponent, pin: number): ComponentPin;
     toComponent(component: ClassComponent, pinId: number | null, options?: {

package/dist/types/objects/ClassComponent.d.ts

@@ -18,6 +18,7 @@ export declare class ClassComponent {
     _copyID?: number;
     _copyFrom?: ClassComponent;
     _pointLinkComponent?: ClassComponent;
+    _unplacedPins: number[];
     arrangeProps: Map<string, NumericValue[]> | null;
     displayProp: SymbolDrawingCommands | null;
     widthProp: number | null;

package/dist/types/objects/ExecutionScope.d.ts

@@ -5,6 +5,7 @@ import { LayoutDirection } from '../globals.js';
 import { Wire, WireSegment } from './Wire.js';
 import { Frame } from './Frame.js';
 import { ParserRuleContext } from 'antlr4ng';
+import { BaseVisitor } from 'src/BaseVisitor.js';
 type OnPropertyHandler = (path: PropertyTreeKey[], value: any, valueContext: ParserRuleContext) => void;
 export type PropertyTreeKey = [ctx: ParserRuleContext, value: any] | ['index', number];
 export declare class ExecutionScope {
@@ -50,10 +51,10 @@ export declare class ExecutionScope {
     setCurrent(component: ClassComponent | null, pin?: number | null): void;
     enterContext(context: ParserRuleContext): void;
     exitContext(): ParserRuleContext;
-    findPropertyKeyTree(): PropertyTreeKey[];
+    private findPropertyKeyTree;
     setOnPropertyHandler(handler: OnPropertyHandler): void;
     popOnPropertyHandler(): OnPropertyHandler;
-    triggerPropertyHandler(value: any, valueCtx: ParserRuleContext): void;
+    triggerPropertyHandler(visitor: BaseVisitor, value: any, valueCtx: ParserRuleContext): void;
 }
 export declare enum SequenceAction {
     To = "to",

package/dist/types/utils.d.ts

@@ -4,6 +4,7 @@ import { ClassComponent } from "./objects/ClassComponent.js";
 import { NumericValue } from "./objects/ParamDefinition.js";
 import { SequenceAction, SequenceItem } from './objects/ExecutionScope.js';
 import { BlockTypes } from './globals.js';
+import { ExecutionWarning } from './utils.js';
 export declare class SimpleStopwatch {
     startTime: Date;
     constructor();
@@ -49,9 +50,10 @@ export declare class BaseError extends Error {
     startToken?: Token;
     endToken?: Token;
     filePath?: string;
-    constructor(message: string, startToken?: Token, endToken?: Token, filePath?: string);
+    constructor(message: string, startTokenOrCtx?: Token | ParserRuleContext, endToken?: Token, filePath?: string);
     toString(): string;
 }
+export declare function getLinePositionAsString(ctx: ParserRuleContext): string | null;
 export declare class ParseSyntaxError extends BaseError {
     name: string;
 }
@@ -65,3 +67,9 @@ export declare class RenderError extends Error {
     stage?: string;
     constructor(message: string, stage?: string);
 }
+export type ExecutionWarning = {
+    message: string;
+    fileName?: string;
+    ctx?: ParserRuleContext;
+};
+export declare function printWarnings(warnings: ExecutionWarning[]): void;

package/dist/types/visitor.d.ts

@@ -2,6 +2,7 @@ import { Add_component_exprContext, AdditionExprContext, At_blockContext, At_blo
 import { ClassComponent } from './objects/ClassComponent.js';
 import { PinTypes } from './objects/PinTypes.js';
 import { ComponentPin, ComponentPinNet, ComponentPinNetPair } from './objects/types.js';
+import { ExecutionWarning } from "./utils.js";
 import { Net } from './objects/Net.js';
 import { BaseVisitor } from './BaseVisitor.js';
 import { ParserRuleContext } from 'antlr4ng';
@@ -83,6 +84,7 @@ export declare class ParserVisitor extends BaseVisitor {
     };
     private resolveNets;
     private getPropertyExprList;
+    getWarnings(): ExecutionWarning[];
 }
 export type NetListItem = {
     instanceName: string;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "circuitscript",
-    "version": "0.1.8",
+    "version": "0.1.9",
     "description": "Interpreter for the circuitscript language",
     "homepage": "https://circuitscript.net",
     "engines": {