circuitscript 0.1.28 → 0.1.31

package/dist/cjs/visitor.js

@@ -16,8 +16,8 @@ const Frame_js_1 = require("./objects/Frame.js");
 const ComponentAnnotater_js_1 = require("./ComponentAnnotater.js");
 const ComponentMatchConditions_js_1 = require("./ComponentMatchConditions.js");
 class ParserVisitor extends BaseVisitor_js_1.BaseVisitor {
-    constructor() {
-        super(...arguments);
+    constructor(silent = false, onErrorHandler = null, environment) {
+        super(silent, onErrorHandler, environment);
         this.componentCreationIndex = 0;
         this.creationCtx = new Map();
         this.visitKeyword_assignment_expr = (ctx) => {
@@ -841,7 +841,7 @@ class ParserVisitor extends BaseVisitor_js_1.BaseVisitor {
         this.visitFunction_def_expr = (ctx) => {
             const functionName = ctx.ID().getText();
             const uniqueFunctionID = '__._' + ctx.start.line + '_'
-                + ctx.start.column + '_' + functionName + '_' + ctx.getText();
+                + ctx.start.column + '_' + functionName + '_' + this.environment.hashStringSHA256(ctx.getText());
             let funcDefinedParameters = [];
             const ctxFunctionArgsExpr = ctx.function_args_expr();
             if (ctxFunctionArgsExpr) {
@@ -853,54 +853,17 @@ class ParserVisitor extends BaseVisitor_js_1.BaseVisitor {
             const resolveComponentPinNet = this.createComponentPinNetResolver(this.executionStack);
             const __runFunc = (passedInParameters, options) => {
                 const executor = this.getExecutor();
-                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);
                 const functionCounterIndex = functionCounter['counter'];
-                const executionContextName = `${functionName}-${functionCounterIndex}`;
-                const newExecutor = this.enterNewChildContext(executionStack, this.getExecutor(), executionContextName, options, funcDefinedParameters, passedInParameters);
                 functionCounter['counter'] += 1;
+                const executionContextName = `${functionName}-${functionCounterIndex}`;
+                const newExecutor = this.handleEnterContext(executor, executionStack, executionContextName, ctx, options, funcDefinedParameters, passedInParameters);
                 newExecutor.resolveNet = resolveNet;
                 newExecutor.resolveComponentPinNet = resolveComponentPinNet;
                 const returnValue = this.runExpressions(newExecutor, ctx.function_expr());
-                const lastExecution = executionStack.pop();
-                const nextLastExecution = executionStack[executionStack.length - 1];
-                const mergedComponents = nextLastExecution.mergeScope(lastExecution.scope, executionContextName);
-                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();
+                const lastExecution = this.handlePopContext(executor, executionStack, executionContextName);
                 return [lastExecution, returnValue];
             };
-            this.getExecutor().createFunction(functionName, __runFunc, ctx, uniqueFunctionID);
+            this.getExecutor().createFunction(this.getExecutor().namespace, functionName, __runFunc, ctx, uniqueFunctionID);
         };
         this.visitPin_select_expr2 = (ctx) => {
             const ctxStringValue = ctx.STRING_VALUE();
@@ -1322,6 +1285,13 @@ class ParserVisitor extends BaseVisitor_js_1.BaseVisitor {
             PinTypes_js_1.PinTypes.Output,
             PinTypes_js_1.PinTypes.Power,
         ];
+        if (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('-----------------');
+        }
     }
     expandModuleContains(component, netNamespace) {
         this.getExecutor().log('expanding module `contains`');
@@ -1331,10 +1301,8 @@ class ParserVisitor extends BaseVisitor_js_1.BaseVisitor {
             + component.instanceName
             + globals_js_1.Delimiter1 + component.moduleCounter;
         const tmpNamespace = this.getNetNamespace(netNamespace, "+/" + component.instanceName + globals_js_1.Delimiter1 + component.moduleCounter);
-        const newExecutor = this.enterNewChildContext(executionStack, executor, executionContextName, { netNamespace: tmpNamespace }, [], []);
+        this.enterNewChildContext(executionStack, executor, executionContextName, { netNamespace: tmpNamespace }, [], []);
         component.moduleCounter += 1;
-        newExecutor.resolveNet = this.createNetResolver(executionStack);
-        newExecutor.resolveComponentPinNet = this.createComponentPinNetResolver(executionStack);
         this.visit(component.moduleContainsExpressions);
         const executionContext = executionStack.pop();
         component.moduleExecutionContext = executionContext;

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;
@@ -40,10 +41,11 @@ export class BaseVisitor extends CircuitScriptVisitor {
     };
     constructor(silent = false, onErrorHandler = null, environment) {
         super();
+        this.silent = silent;
         this.logger = new Logger();
         this.onErrorHandler = onErrorHandler;
         this.environment = environment;
-        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
@@ -105,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) {
@@ -122,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();
@@ -364,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 => {
@@ -381,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;
                         }
@@ -408,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();
@@ -602,18 +690,40 @@ 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;
         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;
@@ -623,30 +733,54 @@ export class BaseVisitor extends 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 = `${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);
@@ -669,6 +803,7 @@ export class BaseVisitor extends CircuitScriptVisitor {
             hasError,
             hasParseError,
             pathExists,
+            importedModule: importedModule
         };
         this.importedFiles.push(newImportedFile);
         return newImportedFile;
@@ -762,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) {

package/dist/esm/SemanticTokenVisitor.js

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