circuitscript 0.1.29 → 0.1.31

package/dist/esm/BaseVisitor.js

@@ -1,25 +1,26 @@
 import { Big } from 'big.js';
+import { Import_specificContext } from "./antlr/CircuitScriptParser.js";
 import { CircuitScriptVisitor } from "./antlr/CircuitScriptVisitor.js";
 import { ExecutionContext } from "./execute.js";
 import { Logger } from "./logger.js";
 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, TrailerArrayIndex } from './globals.js';
+import { Direction, AnyReference, UndeclaredReference, ImportedModule, ImportFunctionHandling as ImportFunctionHandling } from "./objects/types.js";
+import { BaseNamespace, 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';
 import { SequenceAction } from './objects/ExecutionScope.js';
 import { PinId } from './objects/PinDefinition.js';
 export class BaseVisitor extends CircuitScriptVisitor {
-    indentLevel = 0;
     startingContext;
     executionStack;
     silent = false;
     logger;
     printStream = [];
     printToConsole = true;
+    allowParseImports = false;
     acceptedDirections = [Direction.Up, Direction.Down,
         Direction.Right, Direction.Left];
     resultData = new Map;
@@ -44,12 +45,7 @@ export class BaseVisitor extends CircuitScriptVisitor {
         this.logger = new Logger();
         this.onErrorHandler = onErrorHandler;
         this.environment = environment;
-        this.log('-- Environment --');
-        this.log('Module directory: ' + environment.getModuleDirectory());
-        this.log('Default libs path: ' + environment.getDefaultLibsPath());
-        this.log('Current file: ' + environment.getCurrentFile());
-        this.log('-----------------');
-        this.startingContext = new ExecutionContext(DoubleDelimiter1, `${DoubleDelimiter1}.`, '/', 0, 0, silent, this.logger, this.warnings, null);
+        this.startingContext = new ExecutionContext(DoubleDelimiter1, BaseNamespace, '/', 0, 0, silent, this.logger, this.warnings, null);
         const scope = this.startingContext.scope;
         scope.sequence.push([
             SequenceAction.At, scope.componentRoot, scope.currentPin
@@ -111,8 +107,9 @@ export class BaseVisitor extends CircuitScriptVisitor {
         };
     }
     log(...params) {
-        const indentOutput = ''.padStart(this.indentLevel * 4, '    ');
-        const indentLevelText = this.indentLevel.toString().padStart(3, ' ');
+        const indentLevel = this.getScope().scopeLevel;
+        const indentOutput = ''.padStart(indentLevel * 4, '    ');
+        const indentLevelText = indentLevel.toString().padStart(3, ' ');
         const args = ['[' + indentLevelText + ']', indentOutput, ...params];
         this.logger.add(args.join(' '));
         if (!this.silent) {
@@ -128,17 +125,36 @@ export class BaseVisitor extends CircuitScriptVisitor {
     }
     visitScript = async (ctx) => {
         this.log('===', 'start', '===');
-        const imports = ctx.import_expr();
-        for (let i = 0; i < imports.length; i++) {
-            const ctxImport = imports[i];
-            const ID = ctxImport.ID().toString();
-            await this.handleImportFile(ID, true, ctxImport);
+        this.allowParseImports = true;
+        for (const ctxImport of ctx.import_expr()) {
+            await this.visit(ctxImport);
         }
+        this.allowParseImports = false;
         const result = this.runExpressions(this.getExecutor(), ctx.expression());
         this.setResult(ctx, result);
         this.getExecutor().closeOpenPathBlocks();
         this.log('===', 'end', '===');
     };
+    async importCommon(ctx, handling) {
+        const specificImports = [];
+        if (ctx instanceof Import_specificContext) {
+            const tmpSpecificImports = ctx._funcNames.map(item => {
+                return item.text;
+            });
+            specificImports.push(...tmpSpecificImports);
+        }
+        const id = ctx._moduleName.text;
+        await this.handleImportFile(id, handling, true, ctx, specificImports);
+    }
+    visitImport_simple = async (ctx) => {
+        await this.importCommon(ctx, ImportFunctionHandling.AllWithNamespace);
+    };
+    visitImport_all_simple = async (ctx) => {
+        await this.importCommon(ctx, ImportFunctionHandling.AllMergeIntoNamespace);
+    };
+    visitImport_specific = async (ctx) => {
+        await this.importCommon(ctx, ImportFunctionHandling.SpecificMergeIntoNamespace);
+    };
     visitAssignment_expr = (ctx) => {
         const ctxAtom = ctx.atom_expr();
         const ctxFuncCallRef = ctx.function_call_expr();
@@ -370,7 +386,8 @@ export class BaseVisitor extends CircuitScriptVisitor {
         let currentReference = executor.resolveVariable(this.executionStack, atomId);
         if (ctx.trailer_expr().length > 0) {
             if (!currentReference.found) {
-                this.throwWithContext(ctx, "Unknown function name: " + atomId);
+                this.log(`could not resolve function: ${atomId}`);
+                this.throwWithContext(ctx, "could not resolve function: " + atomId);
             }
             currentReference.trailers = [];
             ctx.trailer_expr().forEach(item => {
@@ -387,7 +404,24 @@ export class BaseVisitor extends CircuitScriptVisitor {
                     }
                     const useNetNamespace = this.getNetNamespace(executor.netNamespace, passedNetNamespace);
                     try {
-                        const [, functionResult] = executor.callFunction(currentReference.name, parameters, this.executionStack, useNetNamespace);
+                        const isModuleFunction = currentReference.rootValue
+                            && currentReference.rootValue instanceof ImportedModule;
+                        if (isModuleFunction) {
+                            this.log('create new module context');
+                            const importedModule = currentReference.rootValue;
+                            const importedModuleContext = importedModule.context;
+                            const newExecutor = this.handleEnterContext(this.getExecutor(), this.executionStack, importedModuleContext.name, ctx, {
+                                netNamespace: executor.netNamespace,
+                                namespace: importedModule.moduleNamespace
+                            }, [], [], false);
+                            this.log('copy module context scope');
+                            importedModuleContext.scope.copyTo(newExecutor.scope);
+                        }
+                        const [, functionResult] = executor.callFunction(currentReference, parameters, this.executionStack, useNetNamespace);
+                        if (isModuleFunction) {
+                            this.log('pop module context scope');
+                            this.handlePopContext(this.getExecutor(), this.executionStack, "", false);
+                        }
                         if (isReference(functionResult)) {
                             currentReference = functionResult;
                         }
@@ -414,6 +448,54 @@ export class BaseVisitor extends CircuitScriptVisitor {
         }
         this.setResult(ctx, currentReference);
     }
+    handleEnterContext(executor, executionStack, contextName, ctx, options, funcDefinedParameters, passedInParameters, isBreakContext = true) {
+        if (isBreakContext) {
+            const parentBreakContext = executor.getParentBreakContext();
+            executor.addBreakContext(ctx);
+            let useIndex = -1;
+            if (parentBreakContext === null) {
+                useIndex = options.functionCallIndex;
+            }
+            else {
+                const parentEntry = executor.indexedStack.get(parentBreakContext);
+                const { funcCallIndex } = parentEntry;
+                if (!funcCallIndex.has(ctx)) {
+                    funcCallIndex.set(ctx, 0);
+                    useIndex = 0;
+                }
+                else {
+                    useIndex = funcCallIndex.get(ctx) + 1;
+                    funcCallIndex.set(ctx, useIndex);
+                }
+            }
+            executor.setBreakContextIndex(useIndex);
+        }
+        return this.enterNewChildContext(executionStack, executor, contextName, options, funcDefinedParameters, passedInParameters);
+    }
+    handlePopContext(executor, executionStack, namespaceExtension, isBreakContext = true) {
+        const poppedContext = executionStack.pop();
+        const nextLastExecution = executionStack[executionStack.length - 1];
+        const mergedComponents = nextLastExecution.mergeScope(poppedContext.scope, namespaceExtension);
+        if (isBreakContext) {
+            const scope = this.getScope();
+            const indexedStack = [];
+            if (scope.breakStack.length > 0) {
+                const executor = this.getExecutor();
+                scope.breakStack.forEach(stackCtx => {
+                    const entry = executor.indexedStack.get(stackCtx);
+                    const { index } = entry;
+                    indexedStack.push([stackCtx, index]);
+                });
+                mergedComponents.forEach(component => {
+                    component.ctxReferences.forEach(ref => {
+                        ref.indexedStack = [...indexedStack, ...ref.indexedStack];
+                    });
+                });
+            }
+            executor.popBreakContext();
+        }
+        return poppedContext;
+    }
     visitValue_expr = (ctx) => {
         const sign = ctx.Minus() ? -1 : 1;
         const ctxIntegerValue = ctx.INTEGER_VALUE();
@@ -608,12 +690,34 @@ export class BaseVisitor extends CircuitScriptVisitor {
         this.visit(ctx);
         return this.getResult(ctx);
     }
-    async handleImportFile(name, throwErrors = true, ctx = null) {
+    async handleImportFile(name, importHandling, throwErrors = true, ctx = null, specificImports = []) {
         name = name.trim();
         const importAlready = this.importedFiles.find(item => {
             return item.id === name;
         });
         if (importAlready) {
+            const tmpImportedModule = importAlready.importedModule;
+            const alreadyImportedFlag = tmpImportedModule.importHandlingFlag;
+            const isMergedNamespace = alreadyImportedFlag === ImportFunctionHandling.AllMergeIntoNamespace
+                || alreadyImportedFlag === ImportFunctionHandling.SpecificMergeIntoNamespace;
+            const invalidImportCondition1 = alreadyImportedFlag === ImportFunctionHandling.AllWithNamespace &&
+                importHandling !== ImportFunctionHandling.AllWithNamespace;
+            const invalidImportCondition2 = alreadyImportedFlag !== ImportFunctionHandling.AllWithNamespace &&
+                importHandling === ImportFunctionHandling.AllWithNamespace;
+            if (invalidImportCondition1 || invalidImportCondition2) {
+                throw new RuntimeExecutionError(`Namespace import and wildcard/specific imports cannot be mixed: ${name}`, ctx);
+            }
+            if (isMergedNamespace) {
+                if (alreadyImportedFlag === ImportFunctionHandling.AllMergeIntoNamespace) {
+                }
+                else if (alreadyImportedFlag === ImportFunctionHandling.SpecificMergeIntoNamespace && importHandling === ImportFunctionHandling.AllMergeIntoNamespace) {
+                    tmpImportedModule.specifiedImports = [];
+                    tmpImportedModule.importHandlingFlag = ImportFunctionHandling.AllMergeIntoNamespace;
+                }
+                else if (alreadyImportedFlag === ImportFunctionHandling.SpecificMergeIntoNamespace && importHandling === ImportFunctionHandling.SpecificMergeIntoNamespace) {
+                    tmpImportedModule.specifiedImports.push(...specificImports);
+                }
+            }
             return importAlready;
         }
         let hasError = false;
@@ -632,6 +736,7 @@ export class BaseVisitor extends CircuitScriptVisitor {
             this.log('failed to read file');
             pathExists = false;
         }
+        let importedModule;
         if (!pathExists) {
             try {
                 const tmpFilePath2 = this.environment.getRelativeToDefaultLibs(name + ".cst");
@@ -646,16 +751,36 @@ export class BaseVisitor extends CircuitScriptVisitor {
             }
         }
         try {
-            if (pathExists) {
+            if (pathExists && filePathUsed) {
                 this.log('done reading imported file data');
+                const executionStack = this.executionStack;
+                const executor = this.getExecutor();
+                const executionContextName = name;
+                const netNamespace = executor.netNamespace;
+                const moduleNamespace = `${BaseNamespace}${name}.`;
+                this.enterNewChildContext(executionStack, executor, executionContextName, {
+                    netNamespace,
+                    namespace: moduleNamespace,
+                }, [], []);
                 const importResult = await this.onImportFile(this, filePathUsed, fileData, this.onErrorHandler);
                 hasError = importResult.hasError;
                 hasParseError = importResult.hasParseError;
+                const importContext = executionStack.pop();
+                this.log(`import handling flag: ${importHandling}`);
+                importedModule = new ImportedModule(name, moduleNamespace, filePathUsed, importContext, importHandling, specificImports);
+                if (specificImports.length > 0) {
+                    this.log('specific import: ' + specificImports.join(', '));
+                }
+                const scope = this.getScope();
+                scope.modules.set(name, importedModule);
+                importedModule.context.scope.modules.forEach((module, key) => {
+                    scope.modules.set(key, module);
+                });
             }
         }
         catch (err) {
             if (ctx != null) {
-                throw new RuntimeExecutionError("An error occurred while importing file", ctx);
+                throw err;
             }
             else {
                 this.log('An error occurred while importing file:', err.message);
@@ -678,6 +803,7 @@ export class BaseVisitor extends CircuitScriptVisitor {
             hasError,
             hasParseError,
             pathExists,
+            importedModule: importedModule
         };
         this.importedFiles.push(newImportedFile);
         return newImportedFile;
@@ -771,14 +897,17 @@ export class BaseVisitor extends CircuitScriptVisitor {
         return object.getParam(paramName);
     }
     enterNewChildContext(executionStack, parentContext, executionContextName, options, funcDefinedParameters, passedInParameters) {
-        const { netNamespace = "" } = options;
+        const { netNamespace = "", namespace = null, } = options;
         const currentExecutionContext = executionStack[executionStack.length - 1];
         const executionLevel = currentExecutionContext.executionLevel;
-        const executionContextNamespace = currentExecutionContext.namespace
+        const executionContextNamespace = namespace ?? currentExecutionContext.namespace
             + executionContextName + ".";
         const newExecutor = new ExecutionContext(executionContextName, executionContextNamespace, netNamespace, executionLevel + 1, this.getExecutor().scope.scopeLevel + 1, currentExecutionContext.silent, currentExecutionContext.logger, currentExecutionContext.warnings, parentContext);
         executionStack.push(newExecutor);
         this.setupDefinedParameters(funcDefinedParameters, passedInParameters, newExecutor);
+        newExecutor.resolveNet = this.createNetResolver(executionStack);
+        newExecutor.resolveComponentPinNet =
+            this.createComponentPinNetResolver(executionStack);
         return newExecutor;
     }
     prepareStringValue(value) {