circuitscript 0.1.29 → 0.1.32

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,11 @@ 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.filePathStack = [];
         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;
@@ -39,19 +41,28 @@ class BaseVisitor extends CircuitScriptVisitor_js_1.CircuitScriptVisitor {
         this.onImportFile = async (visitor, filePath, fileData, onErrorHandler) => {
             throw "Import file not implemented";
         };
+        this.refdesFileAnnotations = new Map();
         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();
@@ -431,12 +442,7 @@ class BaseVisitor extends CircuitScriptVisitor_js_1.CircuitScriptVisitor {
         this.logger = new logger_js_1.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 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
@@ -498,8 +504,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) {
@@ -513,6 +520,28 @@ 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;
+        const importedFile = await this.handleImportFile(id, handling, true, ctx, specificImports);
+        const ctxImportAnnotation = ctx.import_annotation_expr();
+        if (ctxImportAnnotation) {
+            const textValue = ctxImportAnnotation.getText().replace('#=', '');
+            const { importedModule } = importedFile;
+            if (textValue === 'annotate') {
+                importedModule.enableRefdesAnnotation = true;
+            }
+            else if (textValue === 'annotate-external') {
+                importedModule.enableRefdesAnnotationFile = true;
+            }
+        }
+    }
     getReference(ctx) {
         const atomStr = ctx.getText();
         if (atomStr.indexOf('(') !== -1 || atomStr.indexOf(')') !== -1) {
@@ -538,7 +567,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 => {
@@ -555,7 +585,26 @@ 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;
+                            this.enterFile(importedModule.moduleFilePath);
+                            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);
+                            this.exitFile();
+                        }
                         if ((0, utils_js_1.isReference)(functionResult)) {
                             currentReference = functionResult;
                         }
@@ -582,6 +631,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);
     }
@@ -602,7 +699,8 @@ class BaseVisitor extends CircuitScriptVisitor_js_1.CircuitScriptVisitor {
         instance.ctxReferences.push({
             ctx,
             indexedStack,
-            creationFlag
+            creationFlag,
+            filePath: this.getCurrentFile(),
         });
         this.componentCtxLinks.set(ctx, instance);
     }
@@ -613,12 +711,34 @@ 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;
@@ -637,6 +757,7 @@ class BaseVisitor extends CircuitScriptVisitor_js_1.CircuitScriptVisitor {
             this.log('failed to read file');
             pathExists = false;
         }
+        let importedModule;
         if (!pathExists) {
             try {
                 const tmpFilePath2 = this.environment.getRelativeToDefaultLibs(name + ".cst");
@@ -651,16 +772,37 @@ class BaseVisitor extends CircuitScriptVisitor_js_1.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 = `${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, importResult.tree, importResult.tokens, 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);
+                });
+                await this.checkModuleHasRefdesFile(filePathUsed);
             }
         }
         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);
@@ -683,10 +825,17 @@ class BaseVisitor extends CircuitScriptVisitor_js_1.CircuitScriptVisitor {
             hasError,
             hasParseError,
             pathExists,
+            importedModule: importedModule
         };
         this.importedFiles.push(newImportedFile);
         return newImportedFile;
     }
+    async checkModuleHasRefdesFile(filePath) {
+        return;
+    }
+    getRefdesFileAnnotation(filePath, startLine, startColumn, stopLine, stopColumn) {
+        return `${filePath}:${startLine}:${startColumn}:${stopLine}:${stopColumn}`;
+    }
     setupDefinedParameters(funcDefinedParameters, passedInParameters, executor) {
         for (let i = 0; i < funcDefinedParameters.length; i++) {
             const tmpFuncArg = funcDefinedParameters[i];
@@ -770,14 +919,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) {
@@ -811,5 +963,16 @@ class BaseVisitor extends CircuitScriptVisitor_js_1.CircuitScriptVisitor {
             return (val instanceof ParamDefinition_js_1.NumericValue);
         }, 'numeric value');
     }
+    enterFile(filePath) {
+        this.log(`enter file: ${filePath}`);
+        this.filePathStack.push(filePath);
+    }
+    exitFile() {
+        this.log(`exit file: ${this.getCurrentFile()}`);
+        this.filePathStack.pop();
+    }
+    getCurrentFile() {
+        return this.filePathStack[this.filePathStack.length - 1];
+    }
 }
 exports.BaseVisitor = BaseVisitor;

package/dist/cjs/RefdesAnnotationVisitor.js

@@ -10,8 +10,7 @@ class RefdesAnnotationVisitor extends BaseVisitor_js_1.BaseVisitor {
         this.resultText = '';
         this.debug = false;
         this.visitScript = async (ctx) => {
-            const result = this.runExpressions(this.getExecutor(), ctx.expression());
-            this.setResult(ctx, result);
+            this.runExpressions(this.getExecutor(), ctx.expression());
             this.getExecutor().closeOpenPathBlocks();
             this.resultText = this.generateModifiedText();
         };
@@ -43,8 +42,10 @@ class RefdesAnnotationVisitor extends BaseVisitor_js_1.BaseVisitor {
             });
             if (allRefdes.length > 0) {
                 const originalText = this.getOriginalText(ctx);
-                const annotation = ' #= ' + allRefdes.join(',');
-                this.modifications.set(ctx, originalText + annotation);
+                this.modifications.set(ctx, {
+                    originalText,
+                    refdes: allRefdes,
+                });
             }
         };
         this.visitFunction_def_expr = (ctx) => {
@@ -77,10 +78,10 @@ class RefdesAnnotationVisitor extends BaseVisitor_js_1.BaseVisitor {
             const instance = this.componentCtxLinks.get(ctx);
             const alreadyHaveRefdesAnnotation = instance.assignedRefDes !== null ?
                 (this.addedRefdesAnnotations.indexOf(instance.assignedRefDes) !== -1) : false;
-            if (!instance.hasParam('refdes')
+            const { forceSaveRefdesAnnotation: forceSaveRefdes } = instance;
+            if (!alreadyHaveRefdesAnnotation && (forceSaveRefdes || (!instance.hasParam('refdes')
                 && instance.placeHolderRefDes === null
-                && instance.assignedRefDes
-                && !alreadyHaveRefdesAnnotation) {
+                && instance.assignedRefDes))) {
                 let useRefDes = instance.assignedRefDes;
                 let isPlaceholderRefdes = false;
                 const { ctxReferences } = instance;
@@ -106,13 +107,25 @@ class RefdesAnnotationVisitor extends BaseVisitor_js_1.BaseVisitor {
         const refdes = this.generateRefdesAnnotationComment(ctx);
         if (refdes !== null) {
             const originalText = this.getOriginalText(ctx);
-            const annotation = ' #= ' + refdes;
-            this.modifications.set(ctx, originalText + annotation);
+            this.modifications.set(ctx, {
+                originalText,
+                refdes: [refdes]
+            });
         }
     }
     getOutput() {
         return this.resultText;
     }
+    getOutputForExternalRefdesFile() {
+        const result = [];
+        this.modifications.forEach((modification, ctx) => {
+            const { line: startLine, column: startColumn } = ctx.start;
+            const { line: stopLine, column: stopColumn } = ctx.stop;
+            const joinedRefdes = modification.refdes.join(',');
+            result.push(`${startLine}:${startColumn}:${stopLine}:${stopColumn}:${joinedRefdes}`);
+        });
+        return result;
+    }
     generateModifiedText() {
         const output = [];
         const allTokens = this.tokenStream.getTokens();
@@ -140,7 +153,7 @@ class RefdesAnnotationVisitor extends BaseVisitor_js_1.BaseVisitor {
                         output.push(this.sourceText.substring(lastSourcePos, token.start));
                     }
                     if (this.modifications.has(ctx)) {
-                        output.push(this.modifications.get(ctx));
+                        output.push(this.generateReplacementText(this.modifications.get(ctx)));
                         this.markTokensAsProcessed(ctx, processedTokens);
                         if (ctx.stop) {
                             lastSourcePos = ctx.stop.stop + 1;
@@ -193,5 +206,9 @@ class RefdesAnnotationVisitor extends BaseVisitor_js_1.BaseVisitor {
             console.log(...message);
         }
     }
+    generateReplacementText(modification) {
+        const joinedRefdes = modification.refdes.join(', ');
+        return `${modification.originalText} #= ${joinedRefdes}`;
+    }
 }
 exports.RefdesAnnotationVisitor = RefdesAnnotationVisitor;