circuitscript 0.1.14 → 0.1.16

package/dist/esm/BaseVisitor.js

@@ -1,5 +1,4 @@
 import { Big } from 'big.js';
-import { ExpressionContext } from "./antlr/CircuitScriptParser.js";
 import { CircuitScriptVisitor } from "./antlr/CircuitScriptVisitor.js";
 import { ExecutionContext } from "./execute.js";
 import { Logger } from "./logger.js";
@@ -7,7 +6,7 @@ import { ClassComponent } from "./objects/ClassComponent.js";
 import { NumberOperator, NumericValue, PercentageValue } from "./objects/ParamDefinition.js";
 import { PinTypes } from "./objects/PinTypes.js";
 import { Direction, AnyReference, UndeclaredReference } from "./objects/types.js";
-import { ComponentTypes, DoubleDelimiter1, GlobalDocumentName, ReferenceTypes } from './globals.js';
+import { ComponentTypes, DoubleDelimiter1, GlobalDocumentName, ReferenceTypes, TrailerArrayIndex } from './globals.js';
 import { isReference, unwrapValue as unwrapValue } from "./utils.js";
 import { linkBuiltInMethods } from './builtinMethods.js';
 import { resolveToNumericValue, RuntimeExecutionError, throwWithContext } from './utils.js';
@@ -134,28 +133,37 @@ export class BaseVisitor extends CircuitScriptVisitor {
         const ctxAtom = ctx.atom_expr();
         const ctxFuncCallRef = ctx.function_call_expr();
         let leftSideReference;
+        let lhsCtx;
         if (ctxAtom) {
             leftSideReference = this.getReference(ctx.atom_expr());
+            lhsCtx = ctxAtom;
         }
         else if (ctxFuncCallRef) {
             this.setResult(ctxFuncCallRef, { keepReference: true });
             leftSideReference = this.visitResult(ctxFuncCallRef);
+            lhsCtx = ctxFuncCallRef;
+        }
+        const rhsCtx = ctx.data_expr();
+        const rhsCtxResult = this.visitResult(rhsCtx);
+        if (isReference(rhsCtxResult) && !rhsCtxResult.found) {
+            this.throwWithContext(rhsCtx, rhsCtx.getText() + ' is not defined');
         }
-        const rhsCtxResult = this.visitResult(ctx.data_expr());
         const rhsValue = unwrapValue(rhsCtxResult);
         const trailers = leftSideReference.trailers ?? [];
         const sequenceParts = [];
         if (trailers.length === 0) {
+            this.getScope().setVariable(leftSideReference.name, rhsValue);
+            let itemType = '';
             if (rhsValue instanceof ClassComponent) {
-                this.getScope().setVariable(leftSideReference.name, rhsValue);
-                sequenceParts.push(...['instance', leftSideReference.name, rhsValue]);
+                itemType = ReferenceTypes.instance;
                 this.log2(`assigned '${leftSideReference.name}' to ClassComponent`);
             }
             else {
+                itemType = ReferenceTypes.variable;
                 this.getScope().setVariable(leftSideReference.name, rhsValue);
                 this.log2(`assigned variable ${leftSideReference.name} to ${rhsValue}`);
-                sequenceParts.push(...['variable', leftSideReference.name, rhsValue]);
             }
+            sequenceParts.push(...[itemType, leftSideReference.name, rhsValue]);
         }
         else {
             if (leftSideReference.parentValue instanceof ClassComponent) {
@@ -171,8 +179,20 @@ export class BaseVisitor extends CircuitScriptVisitor {
                 }
             }
             else if (leftSideReference.parentValue instanceof Object) {
-                leftSideReference.parentValue[trailers.join('.')] = rhsValue;
-                this.log2(`assigned object ${leftSideReference.parentValue} trailers: ${trailers} value: ${rhsValue}`);
+                if (Array.isArray(trailers[0]) && trailers[0][0] === TrailerArrayIndex) {
+                    if (Array.isArray(leftSideReference.parentValue)) {
+                        const arrayIndexValue = trailers[0][1];
+                        leftSideReference.parentValue[arrayIndexValue] = rhsValue;
+                        this.log2(`assigned array index ${leftSideReference.parentValue} index: ${arrayIndexValue} value: ${rhsValue}`);
+                    }
+                    else {
+                        this.throwWithContext(lhsCtx, "Invalid array");
+                    }
+                }
+                else {
+                    leftSideReference.parentValue[trailers.join('.')] = rhsValue;
+                    this.log2(`assigned object ${leftSideReference.parentValue} trailers: ${trailers} value: ${rhsValue}`);
+                }
                 sequenceParts.push(...['variable', [leftSideReference.parentValue, trailers], rhsValue]);
             }
         }
@@ -252,19 +272,39 @@ export class BaseVisitor extends CircuitScriptVisitor {
         }
         return reference;
     }
+    visitTrailer_expr2 = (ctx) => {
+        const reference = this.getResult(ctx);
+        const ctxID = ctx.ID();
+        const ctxDataExpr = ctx.data_expr();
+        const useValue = reference.value;
+        let nextReference;
+        if (ctxID) {
+            reference.trailers.push(ctxID.getText());
+            nextReference = this.getExecutor().resolveTrailers(reference.type, useValue, reference.trailers);
+        }
+        else if (ctxDataExpr) {
+            const arrayIndex = this.visitResult(ctxDataExpr);
+            if (arrayIndex instanceof NumericValue) {
+                const arrayIndexValue = arrayIndex.toNumber();
+                const foundValue = useValue[arrayIndexValue];
+                const refType = foundValue instanceof ClassComponent
+                    ? ReferenceTypes.instance : ReferenceTypes.variable;
+                nextReference = new AnyReference({
+                    found: true,
+                    type: refType,
+                    value: foundValue,
+                    trailers: [[TrailerArrayIndex, arrayIndexValue]],
+                    parentValue: useValue
+                });
+            }
+        }
+        this.setResult(ctx, nextReference);
+    };
     visitAtom_expr = (ctx) => {
         const executor = this.getExecutor();
         const firstId = ctx.ID(0);
         const atomId = firstId.getText();
         let currentReference;
-        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());
-            }
-        }
         if (this.pinTypesList.indexOf(atomId) !== -1) {
             currentReference = new AnyReference({
                 found: true,
@@ -273,18 +313,18 @@ export class BaseVisitor extends CircuitScriptVisitor {
             });
         }
         else {
-            currentReference = executor.resolveVariable(this.executionStack, atomId, idTrailers);
+            currentReference = executor.resolveVariable(this.executionStack, atomId);
         }
-        if (currentReference.found && currentReference.type === 'instance' && idTrailers.length === 0) {
-            const tmpComponent = currentReference.value;
-            for (const [pinId, net] of tmpComponent.pinNets) {
-                executor.scope.setNet(tmpComponent, pinId, net);
+        if (currentReference !== undefined && currentReference.found) {
+            const trailersLength = ctx.trailer_expr2().length;
+            for (let i = 0; i < trailersLength; i++) {
+                const trailerCtx = ctx.trailer_expr2(i);
+                this.setResult(trailerCtx, currentReference);
+                currentReference = this.visitResult(trailerCtx);
             }
         }
-        if (ctx.parent instanceof ExpressionContext && !currentReference.found) {
-            this.throwWithContext(ctx, "Unknown symbol: " + atomId);
-        }
         this.setResult(ctx, currentReference);
+        this.log2('atom resolved: ' + ctx.getText() + ' -> ' + currentReference);
     };
     visitFunctionCallExpr = (ctx) => {
         const result = this.visitResult(ctx.function_call_expr());
@@ -315,6 +355,11 @@ export class BaseVisitor extends CircuitScriptVisitor {
             currentReference.trailers = [];
             ctx.trailer_expr().forEach(item => {
                 if (item.OPEN_PAREN() && item.CLOSE_PAREN()) {
+                    if (currentReference.type === ReferenceTypes.variable) {
+                        if (currentReference.value instanceof AnyReference && currentReference.value.type === ReferenceTypes.function) {
+                            currentReference = currentReference.value;
+                        }
+                    }
                     let parameters = [];
                     const ctxParameters = item.parameters();
                     if (ctxParameters) {
@@ -341,10 +386,9 @@ export class BaseVisitor extends CircuitScriptVisitor {
                     }
                 }
                 else {
-                    currentReference.trailers.push(item.ID().getText());
-                    currentReference = this.getExecutor().resolveTrailers(currentReference.type, (currentReference.parentValue !== undefined)
-                        ? currentReference.parentValue
-                        : currentReference.value, currentReference.trailers);
+                    const ctxTrailer = item.trailer_expr2();
+                    this.setResult(ctxTrailer, currentReference);
+                    currentReference = this.visitResult(ctxTrailer);
                 }
             });
         }
@@ -410,7 +454,8 @@ export class BaseVisitor extends CircuitScriptVisitor {
                     value = reference;
                 }
                 else {
-                    if (reference.trailers && reference.trailers.length > 0) {
+                    if ((reference.trailers && reference.trailers.length > 0)
+                        || reference.type === ReferenceTypes.function) {
                         value = reference;
                     }
                     else {
@@ -445,11 +490,11 @@ export class BaseVisitor extends CircuitScriptVisitor {
         const returnList = [];
         dataExpressions.forEach((item, index) => {
             const value = this.visitResult(item);
-            returnList.push(['position', index, value]);
+            returnList.push(['position', index, unwrapValue(value)]);
         });
         keywordAssignmentExpressions.forEach((item) => {
             const [key, value] = this.visitResult(item);
-            returnList.push(['keyword', key, value]);
+            returnList.push(['keyword', key, unwrapValue(value)]);
         });
         this.setResult(ctx, returnList);
     };
@@ -459,9 +504,7 @@ export class BaseVisitor extends CircuitScriptVisitor {
     visitFunction_return_expr = (ctx) => {
         const executor = this.getExecutor();
         executor.log('return from function');
-        const ctxDataExpr = ctx.data_expr();
-        this.visit(ctxDataExpr);
-        const returnValue = this.getResult(ctxDataExpr);
+        const returnValue = this.visitResult(ctx.data_expr());
         executor.stopFurtherExpressions = true;
         executor.returnValue = returnValue;
         this.setResult(ctx, returnValue);
@@ -495,6 +538,25 @@ export class BaseVisitor extends CircuitScriptVisitor {
     visitArrayExpr = (ctx) => {
         this.setResult(ctx, this.visitResult(ctx.array_expr()));
     };
+    visitArrayIndexExpr = (ctx) => {
+        const ctxArray = ctx.data_expr(0);
+        const ctxArrayIndex = ctx.data_expr(1);
+        const arrayItem = this.visitResult(ctxArray);
+        const indexValue = this.visitResult(ctxArrayIndex);
+        if (!Array.isArray(arrayItem)) {
+            throw new RuntimeExecutionError("Invalid array", ctxArray);
+        }
+        if (!(indexValue instanceof NumericValue)) {
+            throw new RuntimeExecutionError("Invalid index value", ctxArrayIndex);
+        }
+        const indexValueNumber = indexValue.toNumber();
+        if (isNaN(indexValueNumber)) {
+            throw new RuntimeExecutionError("Invalid index value", ctxArrayIndex);
+        }
+        if (Array.isArray(arrayItem)) {
+            this.setResult(ctx, arrayItem[indexValueNumber]);
+        }
+    };
     setResult(ctx, value) {
         this.resultData.set(ctx, value);
     }

package/dist/esm/antlr/CircuitScriptLexer.js

@@ -69,7 +69,7 @@ export class CircuitScriptLexer extends antlr.Lexer {
         "DEFAULT_TOKEN_CHANNEL", "HIDDEN"
     ];
     static literalNames = [
-        null, "':'", "','", "'='", "'..'", "'.'", "'['", "']'", "'break'",
+        null, "':'", "','", "'='", "'..'", "'['", "']'", "'.'", "'break'",
         "'branch'", "'create'", "'component'", "'graphic'", "'module'",
         "'wire'", "'pin'", "'add'", "'at'", "'to'", "'point'", "'join'",
         "'parallel'", "'return'", "'def'", "'import'", "'for'", "'in'",
@@ -235,8 +235,8 @@ export class CircuitScriptLexer extends antlr.Lexer {
         0, 131, 473, 1, 0, 0, 0, 133, 477, 1, 0, 0, 0, 135, 486, 1, 0, 0, 0, 137, 138, 5, 58, 0,
         0, 138, 2, 1, 0, 0, 0, 139, 140, 5, 44, 0, 0, 140, 4, 1, 0, 0, 0, 141, 142, 5, 61, 0, 0,
         142, 6, 1, 0, 0, 0, 143, 144, 5, 46, 0, 0, 144, 145, 5, 46, 0, 0, 145, 8, 1, 0, 0, 0, 146,
-        147, 5, 46, 0, 0, 147, 10, 1, 0, 0, 0, 148, 149, 5, 91, 0, 0, 149, 12, 1, 0, 0, 0, 150,
-        151, 5, 93, 0, 0, 151, 14, 1, 0, 0, 0, 152, 153, 5, 98, 0, 0, 153, 154, 5, 114, 0, 0, 154,
+        147, 5, 91, 0, 0, 147, 10, 1, 0, 0, 0, 148, 149, 5, 93, 0, 0, 149, 12, 1, 0, 0, 0, 150,
+        151, 5, 46, 0, 0, 151, 14, 1, 0, 0, 0, 152, 153, 5, 98, 0, 0, 153, 154, 5, 114, 0, 0, 154,
         155, 5, 101, 0, 0, 155, 156, 5, 97, 0, 0, 156, 157, 5, 107, 0, 0, 157, 16, 1, 0, 0, 0,
         158, 159, 5, 98, 0, 0, 159, 160, 5, 114, 0, 0, 160, 161, 5, 97, 0, 0, 161, 162, 5, 110,
         0, 0, 162, 163, 5, 99, 0, 0, 163, 164, 5, 104, 0, 0, 164, 18, 1, 0, 0, 0, 165, 166, 5,