circuitscript 0.0.32 → 0.0.35

package/dist/esm/BaseVisitor.mjs

@@ -5,10 +5,10 @@ import { CircuitScriptVisitor } from "./antlr/CircuitScriptVisitor";
 import { ExecutionContext } from "./execute";
 import { Logger } from "./logger";
 import { ClassComponent } from "./objects/ClassComponent";
-import { NumericValue, PercentageValue, PinBlankValue } from "./objects/ParamDefinition";
+import { NumericValue, PercentageValue } from "./objects/ParamDefinition";
 import { PinTypes } from "./objects/PinTypes";
 import { Direction, UndeclaredReference } from "./objects/types";
-import { ReferenceTypes } from './globals';
+import { GlobalDocumentName, ReferenceTypes } from './globals';
 export class BaseVisitor extends CircuitScriptVisitor {
     indentLevel = 0;
     startingContext;
@@ -40,6 +40,7 @@ export class BaseVisitor extends CircuitScriptVisitor {
         this.logger = new Logger();
         this.onErrorCallbackHandler = onErrorHandler;
         this.startingContext = new ExecutionContext('__', '__.', '/', 0, 0, silent, this.logger, null);
+        this.startingContext.scope.variables.set(GlobalDocumentName, {});
         this.setupPrintFunction(this.startingContext);
         this.executionStack = [this.startingContext];
         this.startingContext.resolveNet =
@@ -51,10 +52,30 @@ export class BaseVisitor extends CircuitScriptVisitor {
     getExecutor() {
         return this.executionStack[this.executionStack.length - 1];
     }
+    toString(obj) {
+        if (typeof obj === 'string') {
+            return `"${obj}"`;
+        }
+        else if (typeof obj === 'number') {
+            return obj.toString();
+        }
+        else if (Array.isArray(obj)) {
+            const inner = obj.map(item => this.toString(item)).join(", ");
+            return "[" + inner + "]";
+        }
+        else {
+            if (obj.toString) {
+                return obj.toString();
+            }
+            else {
+                throw "Could not create string from object: " + obj;
+            }
+        }
+    }
     setupPrintFunction(context) {
         context.createFunction('print', (params) => {
             const items = params.map(([, , value]) => {
-                return value;
+                return this.toString(value);
             });
             if (this.printToConsole) {
                 console.log('::', ...items);
@@ -62,6 +83,38 @@ export class BaseVisitor extends CircuitScriptVisitor {
             this.printStream.push(...items);
             return [this, null];
         });
+        context.createFunction('range', (params) => {
+            const items = params.map(([, , value]) => {
+                if (isNaN(value)) {
+                    throw 'Invalid value: ' + value;
+                }
+                return value;
+            });
+            let startValue = 0;
+            let endValue = 0;
+            if (items.length === 1) {
+                endValue = items[0];
+            }
+            else if (items.length === 2) {
+                startValue = items[0];
+                endValue = items[1];
+            }
+            const returnArray = [];
+            for (let i = startValue; i < endValue; i++) {
+                returnArray.push(i);
+            }
+            return [this, returnArray];
+        });
+        context.createFunction('enumerate', (params) => {
+            const [, , array] = params[0];
+            if (!Array.isArray(array)) {
+                throw "Invalid parameter for enumerate function!";
+            }
+            const output = array.map((item, index) => {
+                return [index, item];
+            });
+            return [this, output];
+        });
     }
     createNetResolver(executionStack) {
         const resolveNet = (netName, netNamespace) => {
@@ -102,36 +155,103 @@ export class BaseVisitor extends CircuitScriptVisitor {
         return result;
     };
     visitAssignment_expr = (ctx) => {
-        const atomStr = ctx.atom_expr().getText();
-        if (atomStr.indexOf('(') !== -1 || atomStr.indexOf(')') !== -1) {
-            throw "Invalid assignment expression!";
-        }
-        const ctxAtomExpr = ctx.atom_expr();
-        this.visit(ctxAtomExpr);
-        const reference = this.getResult(ctxAtomExpr);
+        const reference = this.getReference(ctx.atom_expr());
         const ctxDataExpr = ctx.data_expr();
         this.visit(ctxDataExpr);
         const value = this.getResult(ctxDataExpr);
-        if (value instanceof ClassComponent) {
-            const instances = this.getExecutor().scope.instances;
-            const tmpComponent = value;
-            const oldName = tmpComponent.instanceName;
-            tmpComponent.instanceName = reference.name;
-            instances.delete(oldName);
-            instances.set(reference.name, tmpComponent);
-            this.getExecutor().log(`assigned '${reference.name}' to ClassComponent`);
-        }
-        else {
-            const trailers = reference.trailers ?? [];
-            if (trailers.length === 0) {
+        const trailers = reference.trailers ?? [];
+        if (trailers.length === 0) {
+            if (value instanceof ClassComponent) {
+                const instances = this.getExecutor().scope.instances;
+                const tmpComponent = value;
+                const oldName = tmpComponent.instanceName;
+                tmpComponent.instanceName = reference.name;
+                instances.delete(oldName);
+                instances.set(reference.name, tmpComponent);
+                this.getExecutor().log(`assigned '${reference.name}' to ClassComponent`);
+            }
+            else {
                 this.getExecutor().scope.variables.set(reference.name, value);
             }
-            else if (reference.value instanceof ClassComponent) {
+        }
+        else {
+            if (reference.value instanceof ClassComponent) {
                 this.setInstanceParam(reference.value, trailers, value);
             }
+            else if (reference.value instanceof Object) {
+                reference.value[trailers.join('.')] = value;
+            }
         }
         this.setResult(ctx, value);
     };
+    visitOperator_assignment_expr = (ctx) => {
+        const reference = this.getReference(ctx.atom_expr());
+        const ctxDataExpr = ctx.data_expr();
+        this.visit(ctxDataExpr);
+        const value = this.getResult(ctxDataExpr);
+        if (!reference.found) {
+            throw 'Undefined reference: ' + reference.name;
+        }
+        const trailers = reference.trailers ?? [];
+        let currentValue = null;
+        if (trailers.length === 0) {
+            currentValue = this.getExecutor().scope.variables.get(reference.name);
+        }
+        else {
+            if (reference.value instanceof ClassComponent) {
+                currentValue = this.getInstanceParam(reference.value, trailers);
+            }
+            else if (reference.value instanceof Object) {
+                currentValue = reference.value[trailers.join('.')];
+            }
+        }
+        if (currentValue === null) {
+            throw 'Operator assignment failed: could not get value';
+        }
+        let newValue = 0;
+        if (ctx.AdditionAssign()) {
+            newValue = currentValue + value;
+        }
+        else if (ctx.MinusAssign()) {
+            newValue = currentValue - value;
+        }
+        else if (ctx.MultiplyAssign()) {
+            newValue = currentValue * value;
+        }
+        else if (ctx.DivideAssign()) {
+            newValue = currentValue / value;
+        }
+        else if (ctx.ModulusAssign()) {
+            newValue = currentValue % value;
+        }
+        else {
+            throw 'Operator assignment failed: could not perform operator';
+        }
+        if (trailers.length === 0) {
+            this.getExecutor().scope.variables.set(reference.name, newValue);
+        }
+        else {
+            if (reference.value instanceof ClassComponent) {
+                this.setInstanceParam(reference.value, trailers, newValue);
+            }
+            else if (reference.value instanceof Object) {
+                reference.value[trailers.join('.')] = newValue;
+            }
+        }
+        this.setResult(ctx, newValue);
+    };
+    getReference(ctx) {
+        const atomStr = ctx.getText();
+        if (atomStr.indexOf('(') !== -1 || atomStr.indexOf(')') !== -1) {
+            throw "Invalid assignment expression!";
+        }
+        this.visit(ctx);
+        const reference = this.getResult(ctx);
+        if (!reference.found && reference.trailers && reference.trailers.length > 0) {
+            throw 'Undefined reference: ' + reference.name + '.' + reference.trailers.join('.');
+        }
+        return reference;
+    }
     visitAtom_expr = (ctx) => {
         const executor = this.getExecutor();
         const firstId = ctx.ID(0);
@@ -147,20 +267,22 @@ export class BaseVisitor extends CircuitScriptVisitor {
         else {
             currentReference = executor.resolveVariable(this.executionStack, atomId);
         }
+        const idTrailers = [];
+        if (ctx.ID().length > 1) {
+            const idLength = ctx.ID().length;
+            for (let i = 1; i < idLength; i++) {
+                const tmpCtx = ctx.ID(i);
+                idTrailers.push(tmpCtx.getText());
+            }
+        }
+        currentReference.trailers = idTrailers;
         if (currentReference.found && currentReference.type === 'instance') {
             const tmpComponent = currentReference.value;
             for (const [pinId, net] of tmpComponent.pinNets) {
                 executor.scope.setNet(tmpComponent, pinId, net);
             }
-            if (ctx.ID().length > 1) {
-                currentReference.trailers = [];
-                const idLength = ctx.ID().length;
-                for (let i = 1; i < idLength; i++) {
-                    const tmpCtx = ctx.ID(i);
-                    currentReference.trailers.push(tmpCtx.getText());
-                }
-            }
         }
+        this.getExecutor().log('atomId:', atomId, currentReference);
         if (ctx.parent instanceof ExpressionContext && !currentReference.found) {
             throw "Unknown symbol: " + atomId;
         }
@@ -220,7 +342,6 @@ export class BaseVisitor extends CircuitScriptVisitor {
         const ctxBooleanValue = ctx.BOOLEAN_VALUE();
         const ctxStringValue = ctx.STRING_VALUE();
         const ctxPercentageValue = ctx.PERCENTAGE_VALUE();
-        const ctxBlankExpr = ctx.blank_expr();
         let result = null;
         if (ctxIntegerValue || ctxDecimalValue || ctxNumericValue) {
             if (ctxIntegerValue) {
@@ -254,15 +375,8 @@ export class BaseVisitor extends CircuitScriptVisitor {
         else if (ctxPercentageValue) {
             result = new PercentageValue(ctxPercentageValue.getText());
         }
-        else if (ctxBlankExpr) {
-            this.visit(ctxBlankExpr);
-            result = this.getResult(ctxBlankExpr);
-        }
         this.setResult(ctx, result);
     };
-    visitBlank_expr = (ctx) => {
-        this.setResult(ctx, new PinBlankValue(Number(ctx.INTEGER_VALUE().getText())));
-    };
     visitValueAtomExpr = (ctx) => {
         let value = null;
         const ctxValueExpr = ctx.value_expr();
@@ -344,8 +458,32 @@ export class BaseVisitor extends CircuitScriptVisitor {
         this.setResult(ctx, returnValue);
     };
     visitBreak_keyword = (ctx) => {
-        this.getExecutor().breakBranch();
-        this.setResult(ctx, -1);
+        const breakContext = this.getExecutor().getBreakContext();
+        const currentResult = this.getResult(breakContext) ?? {};
+        this.setResult(breakContext, {
+            ...currentResult,
+            breakSignal: true
+        });
+    };
+    visitContinue_keyword = (ctx) => {
+        const breakContext = this.getExecutor().getBreakContext();
+        const currentResult = this.getResult(breakContext) ?? {};
+        this.setResult(breakContext, {
+            ...currentResult,
+            breakSignal: true,
+            continueSignal: true,
+        });
+    };
+    visitArray_expr = (ctx) => {
+        const array = ctx.data_expr().map(item => {
+            this.visit(item);
+            return this.getResult(item);
+        });
+        this.setResult(ctx, array);
+    };
+    visitArrayExpr = (ctx) => {
+        this.visit(ctx.array_expr());
+        this.setResult(ctx, this.getResult(ctx.array_expr()));
     };
     setResult(ctx, value) {
         this.resultData.set(ctx, value);
@@ -443,9 +581,15 @@ export class BaseVisitor extends CircuitScriptVisitor {
     }
     runExpressions(executor, expressions) {
         let returnValue = null;
+        const breakContext = executor.getBreakContext();
         for (let i = 0; i < expressions.length; i++) {
             const expr = expressions[i];
             this.visit(expr);
+            const { breakSignal = false } = this.getResult(breakContext) ?? {};
+            if (breakSignal) {
+                returnValue = executor.returnValue;
+                break;
+            }
             if (executor.stopFurtherExpressions) {
                 returnValue = executor.returnValue;
                 break;
@@ -479,6 +623,10 @@ export class BaseVisitor extends CircuitScriptVisitor {
         object.setParam(paramName, value);
         this.getExecutor().log(`set instance ${object.instanceName} param ${paramName} to ${value}`);
     }
+    getInstanceParam(object, trailers) {
+        const paramName = trailers[0];
+        return object.getParam(paramName);
+    }
     enterNewChildContext(executionStack, parentContext, executionContextName, options, funcDefinedParameters, passedInParameters) {
         const { netNamespace = "" } = options;
         const currentExecutionContext = executionStack[executionStack.length - 1];