circuitscript 0.1.29 → 0.1.32

package/dist/esm/BaseVisitor.js

@@ -1,25 +1,27 @@
 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;
+    filePathStack = [];
     silent = false;
     logger;
     printStream = [];
     printToConsole = true;
+    allowParseImports = false;
     acceptedDirections = [Direction.Up, Direction.Down,
         Direction.Right, Direction.Left];
     resultData = new Map;
@@ -38,18 +40,14 @@ export class BaseVisitor extends CircuitScriptVisitor {
     onImportFile = async (visitor, filePath, fileData, onErrorHandler) => {
         throw "Import file not implemented";
     };
+    refdesFileAnnotations = new Map();
     constructor(silent = false, onErrorHandler = null, environment) {
         super();
         this.silent = silent;
         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 +109,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 +127,47 @@ 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;
+        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;
+            }
+        }
+    }
+    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 +399,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 +417,26 @@ 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;
+                            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 (isReference(functionResult)) {
                             currentReference = functionResult;
                         }
@@ -414,6 +463,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();
@@ -597,7 +694,8 @@ export class BaseVisitor extends CircuitScriptVisitor {
         instance.ctxReferences.push({
             ctx,
             indexedStack,
-            creationFlag
+            creationFlag,
+            filePath: this.getCurrentFile(),
         });
         this.componentCtxLinks.set(ctx, instance);
     }
@@ -608,12 +706,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 +752,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 +767,37 @@ 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, 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 RuntimeExecutionError("An error occurred while importing file", ctx);
+                throw err;
             }
             else {
                 this.log('An error occurred while importing file:', err.message);
@@ -678,10 +820,17 @@ export class BaseVisitor extends 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}`;
+    }
     visitRoundedBracketsExpr = (ctx) => {
         const ctxDataExpr = ctx.data_expr();
         this.visit(ctxDataExpr);
@@ -771,14 +920,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) {
@@ -812,4 +964,15 @@ export class BaseVisitor extends CircuitScriptVisitor {
             return (val instanceof 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];
+    }
 }

package/dist/esm/RefdesAnnotationVisitor.js

@@ -22,8 +22,7 @@ export class RefdesAnnotationVisitor extends BaseVisitor {
         return this.sourceText.substring(startIndex, stopIndex + 1);
     }
     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();
     };
@@ -55,8 +54,10 @@ export class RefdesAnnotationVisitor extends 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,
+            });
         }
     };
     visitFunction_def_expr = (ctx) => {
@@ -77,10 +78,10 @@ export class RefdesAnnotationVisitor extends 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 @@ export class RefdesAnnotationVisitor extends 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 @@ export class RefdesAnnotationVisitor extends 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,4 +206,8 @@ export class RefdesAnnotationVisitor extends BaseVisitor {
             console.log(...message);
         }
     }
+    generateReplacementText(modification) {
+        const joinedRefdes = modification.refdes.join(', ');
+        return `${modification.originalText} #= ${joinedRefdes}`;
+    }
 }