circuitscript 0.1.28 → 0.1.31

package/dist/cjs/BaseVisitor.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseVisitor = void 0;
 const big_js_1 = require("big.js");
+const CircuitScriptParser_js_1 = require("./antlr/CircuitScriptParser.js");
 const CircuitScriptVisitor_js_1 = require("./antlr/CircuitScriptVisitor.js");
 const execute_js_1 = require("./execute.js");
 const logger_js_1 = require("./logger.js");
@@ -18,10 +19,10 @@ const PinDefinition_js_1 = require("./objects/PinDefinition.js");
 class BaseVisitor extends CircuitScriptVisitor_js_1.CircuitScriptVisitor {
     constructor(silent = false, onErrorHandler = null, environment) {
         super();
-        this.indentLevel = 0;
         this.silent = false;
         this.printStream = [];
         this.printToConsole = true;
+        this.allowParseImports = false;
         this.acceptedDirections = [types_js_1.Direction.Up, types_js_1.Direction.Down,
             types_js_1.Direction.Right, types_js_1.Direction.Left];
         this.resultData = new Map;
@@ -41,17 +42,25 @@ class BaseVisitor extends CircuitScriptVisitor_js_1.CircuitScriptVisitor {
         };
         this.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', '===');
         };
+        this.visitImport_simple = async (ctx) => {
+            await this.importCommon(ctx, types_js_1.ImportFunctionHandling.AllWithNamespace);
+        };
+        this.visitImport_all_simple = async (ctx) => {
+            await this.importCommon(ctx, types_js_1.ImportFunctionHandling.AllMergeIntoNamespace);
+        };
+        this.visitImport_specific = async (ctx) => {
+            await this.importCommon(ctx, types_js_1.ImportFunctionHandling.SpecificMergeIntoNamespace);
+        };
         this.visitAssignment_expr = (ctx) => {
             const ctxAtom = ctx.atom_expr();
             const ctxFuncCallRef = ctx.function_call_expr();
@@ -427,10 +436,11 @@ class BaseVisitor extends CircuitScriptVisitor_js_1.CircuitScriptVisitor {
             const innerResult = this.getResult(ctxDataExpr);
             this.setResult(ctx, innerResult);
         };
+        this.silent = silent;
         this.logger = new logger_js_1.Logger();
         this.onErrorHandler = onErrorHandler;
         this.environment = environment;
-        this.startingContext = new execute_js_1.ExecutionContext(globals_js_1.DoubleDelimiter1, `${globals_js_1.DoubleDelimiter1}.`, '/', 0, 0, silent, this.logger, this.warnings, null);
+        this.startingContext = new execute_js_1.ExecutionContext(globals_js_1.DoubleDelimiter1, globals_js_1.BaseNamespace, '/', 0, 0, silent, this.logger, this.warnings, null);
         const scope = this.startingContext.scope;
         scope.sequence.push([
             ExecutionScope_js_1.SequenceAction.At, scope.componentRoot, scope.currentPin
@@ -492,8 +502,9 @@ class BaseVisitor extends CircuitScriptVisitor_js_1.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) {
@@ -507,6 +518,17 @@ class BaseVisitor extends CircuitScriptVisitor_js_1.CircuitScriptVisitor {
         const result = await ctx.accept(this);
         return result;
     }
+    async importCommon(ctx, handling) {
+        const specificImports = [];
+        if (ctx instanceof CircuitScriptParser_js_1.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);
+    }
     getReference(ctx) {
         const atomStr = ctx.getText();
         if (atomStr.indexOf('(') !== -1 || atomStr.indexOf(')') !== -1) {
@@ -532,7 +554,8 @@ class BaseVisitor extends CircuitScriptVisitor_js_1.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 => {
@@ -549,7 +572,24 @@ class BaseVisitor extends CircuitScriptVisitor_js_1.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 types_js_1.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 ((0, utils_js_1.isReference)(functionResult)) {
                             currentReference = functionResult;
                         }
@@ -576,6 +616,54 @@ class BaseVisitor extends CircuitScriptVisitor_js_1.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;
+    }
     setResult(ctx, value) {
         this.resultData.set(ctx, value);
     }
@@ -607,18 +695,40 @@ class BaseVisitor extends CircuitScriptVisitor_js_1.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 === types_js_1.ImportFunctionHandling.AllMergeIntoNamespace
+                || alreadyImportedFlag === types_js_1.ImportFunctionHandling.SpecificMergeIntoNamespace;
+            const invalidImportCondition1 = alreadyImportedFlag === types_js_1.ImportFunctionHandling.AllWithNamespace &&
+                importHandling !== types_js_1.ImportFunctionHandling.AllWithNamespace;
+            const invalidImportCondition2 = alreadyImportedFlag !== types_js_1.ImportFunctionHandling.AllWithNamespace &&
+                importHandling === types_js_1.ImportFunctionHandling.AllWithNamespace;
+            if (invalidImportCondition1 || invalidImportCondition2) {
+                throw new utils_js_2.RuntimeExecutionError(`Namespace import and wildcard/specific imports cannot be mixed: ${name}`, ctx);
+            }
+            if (isMergedNamespace) {
+                if (alreadyImportedFlag === types_js_1.ImportFunctionHandling.AllMergeIntoNamespace) {
+                }
+                else if (alreadyImportedFlag === types_js_1.ImportFunctionHandling.SpecificMergeIntoNamespace && importHandling === types_js_1.ImportFunctionHandling.AllMergeIntoNamespace) {
+                    tmpImportedModule.specifiedImports = [];
+                    tmpImportedModule.importHandlingFlag = types_js_1.ImportFunctionHandling.AllMergeIntoNamespace;
+                }
+                else if (alreadyImportedFlag === types_js_1.ImportFunctionHandling.SpecificMergeIntoNamespace && importHandling === types_js_1.ImportFunctionHandling.SpecificMergeIntoNamespace) {
+                    tmpImportedModule.specifiedImports.push(...specificImports);
+                }
+            }
             return importAlready;
         }
         let hasError = false;
         let hasParseError = false;
         let pathExists = false;
-        const tmpFilePath = this.environment.getRelativeToModule(name + ".cst");
+        const tmpFilePath = this.environment.getRelativeToCurrentFolder(name + ".cst");
         this.log('importing path:', tmpFilePath);
         let fileData = null;
         let filePathUsed = null;
@@ -628,30 +738,54 @@ class BaseVisitor extends CircuitScriptVisitor_js_1.CircuitScriptVisitor {
             pathExists = true;
         }
         catch (err) {
+            this.log('failed to read file');
             pathExists = false;
         }
+        let importedModule;
         if (!pathExists) {
             try {
                 const tmpFilePath2 = this.environment.getRelativeToDefaultLibs(name + ".cst");
+                this.log('checking default libs: ' + tmpFilePath2);
                 filePathUsed = tmpFilePath2;
                 fileData = await this.environment.readFile(tmpFilePath2, { encoding: 'utf8' });
                 pathExists = true;
             }
             catch (err) {
+                this.log('failed to read file');
                 pathExists = false;
             }
         }
         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 = `${globals_js_1.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 types_js_1.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 utils_js_2.RuntimeExecutionError("An error occurred while importing file", ctx);
+                throw err;
             }
             else {
                 this.log('An error occurred while importing file:', err.message);
@@ -674,6 +808,7 @@ class BaseVisitor extends CircuitScriptVisitor_js_1.CircuitScriptVisitor {
             hasError,
             hasParseError,
             pathExists,
+            importedModule: importedModule
         };
         this.importedFiles.push(newImportedFile);
         return newImportedFile;
@@ -761,14 +896,17 @@ class BaseVisitor extends CircuitScriptVisitor_js_1.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 execute_js_1.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) {

package/dist/cjs/SemanticTokenVisitor.js

@@ -107,6 +107,10 @@ class SemanticTokensVisitor extends BaseVisitor_js_1.BaseVisitor {
                 this.addSemanticToken(ctx.ID(0), [], 'variable');
             }
         };
+        this.visitOperator_assignment_expr = (ctx) => {
+            this.visit(ctx.atom_expr());
+            this.visit(ctx.data_expr());
+        };
         this.visitImport_expr = (ctx) => {
             this.addSemanticToken(ctx.ID(), [], 'namespace');
         };
@@ -114,6 +118,8 @@ class SemanticTokensVisitor extends BaseVisitor_js_1.BaseVisitor {
             ctx.ID().forEach(item => {
                 this.addSemanticToken(item, [], 'variable');
             });
+            this.visit(ctx.data_expr());
+            this.visit(ctx.expressions_block());
         };
         this.visitAnnotation_comment_expr = (ctx) => {
             this.addSemanticToken(ctx.ANNOTATION_START(), [], 'comment');