circuitscript 0.1.29 → 0.1.31

package/dist/esm/antlr/CircuitScriptVisitor.js

@@ -72,7 +72,9 @@ export class CircuitScriptVisitor extends AbstractParseTreeVisitor {
     visitWire_expr;
     visitArray_expr;
     visitPoint_expr;
-    visitImport_expr;
+    visitImport_simple;
+    visitImport_all_simple;
+    visitImport_specific;
     visitFrame_expr;
     visitIf_expr;
     visitIf_inner_expr;

package/dist/esm/builtinMethods.js

@@ -1,7 +1,8 @@
 import Big from "big.js";
 import { numeric, NumericValue } from "./objects/ParamDefinition.js";
-import { CFunctionEntry } from "./objects/types.js";
+import { CFunctionEntry, ImportedModule } from "./objects/types.js";
 import { unwrapValue, resolveToNumericValue, RuntimeExecutionError } from "./utils.js";
+import { BaseNamespace } from "./globals.js";
 const builtInMethods = [
     ['enumerate', enumerate],
     ['toMils', toMils],
@@ -14,7 +15,7 @@ const builtInMethods = [
 ];
 export const buildInMethodNamesList = builtInMethods.map(item => item[0]);
 export function linkBuiltInMethods(context, visitor) {
-    context.createFunction('print', (params) => {
+    context.createFunction(BaseNamespace, 'print', (params) => {
         const args = getPositionParams(params);
         const items = args.map(item => {
             return toString(unwrapValue(item));
@@ -28,7 +29,7 @@ export function linkBuiltInMethods(context, visitor) {
     });
     builtInMethods.forEach(([functionName, functionImpl]) => {
         if (functionImpl !== null) {
-            context.createFunction(functionName, params => {
+            context.createFunction(BaseNamespace, functionName, params => {
                 const args = getPositionParams(params);
                 const functionReturn = functionImpl(...args);
                 return [visitor, functionReturn];
@@ -148,6 +149,9 @@ function toString(obj) {
     else if (obj instanceof CFunctionEntry) {
         return obj.toString();
     }
+    else if (obj instanceof ImportedModule) {
+        return `[module: ${obj.moduleName}]`;
+    }
     else {
         if (obj === undefined) {
             return 'undefined';

package/dist/esm/environment.js

@@ -1,6 +1,7 @@
 import { registerWindow, SVG } from "@svgdotjs/svg.js";
 import fs from 'fs';
 import path from "path";
+import CryptoJs from "crypto-js";
 import { TOOL_VERSION } from "./globals.js";
 import { RuntimeExecutionError } from "./utils.js";
 export class NodeScriptEnvironment {
@@ -138,4 +139,7 @@ export class NodeScriptEnvironment {
             return false;
         }
     }
+    hashStringSHA256(value) {
+        return CryptoJs.SHA256(value).toString();
+    }
 }

package/dist/esm/execute.js

@@ -4,7 +4,7 @@ import { ActiveObject, ExecutionScope, FrameAction, SequenceAction } from './obj
 import { Net } from './objects/Net.js';
 import { numeric, NumericValue } from './objects/ParamDefinition.js';
 import { PinId, PortSide } from './objects/PinDefinition.js';
-import { AnyReference, CFunctionEntry, DeclaredReference, Direction, NetTypes } from './objects/types.js';
+import { AnyReference, CFunctionEntry, DeclaredReference, Direction, ImportFunctionHandling, NetTypes } from './objects/types.js';
 import { Wire } from './objects/Wire.js';
 import { Frame } from './objects/Frame.js';
 import { CalculatePinPositions } from './layout.js';
@@ -39,7 +39,7 @@ export class ExecutionContext {
         this.scope.scopeLevel = scopeLevel;
         this.setupRoot();
         this.silent = silent;
-        this.log('create new execution context', this.namespace, this.name, this.scope.scopeLevel);
+        this.log(`create new execution context, namespace: ${this.namespace}, name: ${this.name}, level: ${this.scope.scopeLevel}`);
         this.parentContext = parent;
         this.warnings = warnings;
     }
@@ -591,10 +591,11 @@ export class ExecutionContext {
     getBreakContext() {
         return this.scope.breakStack[this.scope.breakStack.length - 1];
     }
-    createFunction(functionName, __runFunc, source, uniqueId) {
-        this.scope.functions.set(functionName, new CFunctionEntry(functionName, __runFunc, source, uniqueId));
-        this.__functionCache.set(functionName, __runFunc);
-        this.log(`defined new function '${functionName}'`);
+    createFunction(namespace, functionName, __runFunc, source, uniqueId) {
+        const functionPath = `${namespace}${functionName}`;
+        this.scope.functions.set(functionPath, new CFunctionEntry(namespace, functionName, __runFunc, source, uniqueId));
+        this.__functionCache.set(functionPath, __runFunc);
+        this.log(`defined new function: ${functionPath}`);
     }
     hasFunction(functionName) {
         return this.scope.functions.has(functionName);
@@ -603,32 +604,63 @@ export class ExecutionContext {
         return this.scope.functions.get(functionName);
     }
     resolveVariable(executionStack, idName, trailers = []) {
+        this.log('resolve variable name:', idName, 'trailers:', trailers);
         const reversed = [...executionStack].reverse();
         for (let i = 0; i < reversed.length; i++) {
             const context = reversed[i];
-            if (context.hasFunction(idName)) {
+            const functionPath = `${context.namespace}${idName}`;
+            if (context.hasFunction(functionPath)) {
                 return new DeclaredReference({
                     found: true,
-                    value: context.getFunction(idName),
+                    value: context.getFunction(functionPath),
                     type: ReferenceTypes.function,
                     name: idName,
                 });
             }
             else {
+                const modules = Array.from(context.scope.modules.values());
+                for (let j = 0; j < modules.length; j++) {
+                    const module = modules[j];
+                    if (module.importHandlingFlag === ImportFunctionHandling.AllMergeIntoNamespace ||
+                        (module.importHandlingFlag === ImportFunctionHandling.SpecificMergeIntoNamespace
+                            && module.specifiedImports.indexOf(idName) !== -1)) {
+                        const moduleContext = module.context;
+                        const functionPath = `${moduleContext.namespace}${idName}`;
+                        if (module.context.hasFunction(functionPath)) {
+                            return new DeclaredReference({
+                                found: true,
+                                rootValue: module,
+                                value: module.context.getFunction(functionPath),
+                                type: ReferenceTypes.function,
+                                name: idName,
+                                trailerIndex: 1,
+                                trailers: [idName],
+                            });
+                        }
+                    }
+                }
+                let isModule = false;
+                if (context.scope.modules.has(idName)) {
+                    const module = context.scope.modules.get(idName);
+                    if (module.importHandlingFlag === ImportFunctionHandling.AllWithNamespace) {
+                        isModule = true;
+                    }
+                }
                 let isVariable = context.scope.variables.has(idName);
                 let isComponentInstance = context.scope.instances.has(idName);
-                if (isVariable || isComponentInstance) {
-                    const scopeList = isVariable ? context.scope.variables
-                        : context.scope.instances;
+                if (isModule || isVariable || isComponentInstance) {
+                    const scopeList = isModule ? context.scope.modules :
+                        (isVariable ? context.scope.variables : context.scope.instances);
                     const useValue = scopeList.get(idName);
                     if (!isComponentInstance && (useValue instanceof ClassComponent)) {
                         isComponentInstance = true;
                         isVariable = false;
                     }
-                    const tmpReference = this.resolveTrailers(isVariable ? ReferenceTypes.variable : ReferenceTypes.instance, useValue, trailers);
+                    const referenceType = isModule ? ReferenceTypes.module :
+                        (isVariable ? ReferenceTypes.variable : ReferenceTypes.instance);
+                    const tmpReference = this.resolveTrailers(referenceType, useValue, trailers);
                     return new DeclaredReference({
-                        type: isVariable ? ReferenceTypes.variable
-                            : ReferenceTypes.instance,
+                        type: referenceType,
                         found: (tmpReference.value !== undefined),
                         rootValue: tmpReference.rootValue,
                         value: tmpReference.value,
@@ -649,65 +681,63 @@ export class ExecutionContext {
         if (trailers.length > 0) {
             rootValue = useValue;
             const trailersPath = trailers.join(".");
-            if (type === ReferenceTypes.variable) {
-                useValue = rootValue;
-                trailers.forEach(trailerPath => {
-                    useValue = useValue[trailerPath];
-                });
-            }
-            else if (type === ReferenceTypes.instance) {
-                const tmpComponent = rootValue;
-                if (tmpComponent.typeProp === ComponentTypes.net) {
-                    const usedNet = this.scope.getNet(tmpComponent, new PinId(1));
-                    if (usedNet) {
-                        const trailerValue = trailers.join(".");
-                        useValue = usedNet.params.get(trailerValue) ?? null;
+            switch (type) {
+                case ReferenceTypes.variable:
+                    useValue = rootValue;
+                    trailers.forEach(trailerPath => {
+                        useValue = useValue[trailerPath];
+                    });
+                    break;
+                case ReferenceTypes.instance: {
+                    const tmpComponent = rootValue;
+                    if (tmpComponent.typeProp === ComponentTypes.net) {
+                        const usedNet = this.scope.getNet(tmpComponent, new PinId(1));
+                        if (usedNet) {
+                            const trailerValue = trailers.join(".");
+                            useValue = usedNet.params.get(trailerValue) ?? null;
+                        }
+                    }
+                    else {
+                        useValue = rootValue
+                            .parameters.get(trailersPath);
                     }
+                    break;
                 }
-                else {
-                    useValue = rootValue
-                        .parameters.get(trailersPath);
+                case ReferenceTypes.module: {
+                    const funcName = trailers[0];
+                    const module = rootValue;
+                    const functionPath = `${module.moduleNamespace}${funcName}`;
+                    if (module.context.hasFunction(functionPath)) {
+                        const foundFunc = module.context.getFunction(functionPath);
+                        return new AnyReference({
+                            found: true,
+                            type: ReferenceTypes.function,
+                            rootValue,
+                            trailers,
+                            trailerIndex: trailers.length,
+                            value: foundFunc,
+                        });
+                    }
+                    break;
                 }
             }
         }
         let found = false;
-        if (rootValue !== undefined && useValue !== undefined) {
+        if (useValue !== undefined) {
             found = true;
         }
         return new AnyReference({
             found,
-            type: type,
+            type,
             rootValue,
             trailers,
             trailerIndex: trailers.length,
             value: useValue,
         });
     }
-    callFunction(functionName, functionParams, executionStack, netNamespace) {
-        let __runFunc = null;
-        if (!this.__functionCache.has(functionName)) {
-            if (this.hasFunction(functionName)) {
-                const entry = this.getFunction(functionName);
-                __runFunc = entry.execute;
-            }
-            if (__runFunc === null) {
-                this.log(`searching for function ${functionName} in upper context`);
-                const tmpResolveResult = this.resolveVariable(executionStack, functionName);
-                if (tmpResolveResult.found) {
-                    const entry = tmpResolveResult.value;
-                    __runFunc = entry.execute;
-                }
-                else {
-                    throw `Invalid function ${functionName}`;
-                }
-            }
-            this.log('save function to cache:', functionName);
-            this.__functionCache.set(functionName, __runFunc);
-        }
-        else {
-            this.log('found function in cache:', functionName);
-            __runFunc = this.__functionCache.get(functionName);
-        }
+    callFunction(functionReference, functionParams, executionStack, netNamespace) {
+        const functionEntry = functionReference.value;
+        const { name: functionName, execute: __runFunc } = functionEntry;
         if (__runFunc !== null) {
             let functionCallIndex = -1;
             if (!this.scope.functionCounter.has(__runFunc)) {
@@ -725,6 +755,7 @@ export class ExecutionContext {
             return functionResult;
         }
         else {
+            this.log(`Invalid function: ${functionName}`);
             throw `Invalid function '${functionName}'`;
         }
     }
@@ -735,7 +766,7 @@ export class ExecutionContext {
         const tmpNets = childScope.getNets();
         const mergedInstances = [];
         for (const [instanceName, component] of tmpInstances) {
-            const newInstanceName = `${namespace}.${instanceName}`;
+            const newInstanceName = namespace !== "" ? `${namespace}.${instanceName}` : instanceName;
             component.instanceName = newInstanceName;
             if (component === childScope.componentRoot) {
                 continue;

package/dist/esm/globals.js

@@ -2,6 +2,7 @@ import { numeric } from "./objects/ParamDefinition.js";
 export const TOOL_VERSION = '0.1.5';
 export const Delimiter1 = '-';
 export const DoubleDelimiter1 = `${Delimiter1}${Delimiter1}`;
+export const BaseNamespace = `${DoubleDelimiter1}.`;
 export var GlobalNames;
 (function (GlobalNames) {
     GlobalNames["__root"] = "--root";
@@ -93,6 +94,7 @@ export var ReferenceTypes;
     ReferenceTypes["variable"] = "variable";
     ReferenceTypes["instance"] = "instance";
     ReferenceTypes["pinType"] = "pinType";
+    ReferenceTypes["module"] = "module";
     ReferenceTypes["unknown"] = "unknown";
 })(ReferenceTypes || (ReferenceTypes = {}));
 export var BlockTypes;

package/dist/esm/helpers.js

@@ -206,9 +206,13 @@ export async function renderScriptCustom(scriptData, outputPath, options, parseH
     environment.setCurrentFile(inputPath);
     const visitor = new ParserVisitor(true, onErrorHandler, environment);
     visitor.onImportFile = async (visitor, filePath, fileData) => {
-        const { hasError, hasParseError } = await parseFileWithVisitor(visitor, fileData);
+        const { hasError, hasParseError, throwError } = await parseFileWithVisitor(visitor, fileData);
         if (hasError || hasParseError) {
-            throw new ParseError(`Error parsing imported file: ${filePath}`, undefined, undefined, filePath);
+            let importErrorMsg = "";
+            if (throwError) {
+                importErrorMsg = ": " + throwError.message;
+            }
+            throw new ParseError(`Error parsing imported file: ${filePath}${importErrorMsg}`, undefined, undefined, filePath);
         }
         return { hasError, hasParseError };
     };

package/dist/esm/objects/ExecutionScope.js

@@ -9,6 +9,7 @@ export class ExecutionScope {
     functionCounter = new Map();
     variables = new Map();
     symbols = new Map();
+    modules = new Map();
     blockStack = new Map();
     contextStack = [];
     onPropertyHandler = [];
@@ -168,6 +169,14 @@ export class ExecutionScope {
     getInstances() {
         return Array.from(this.instances.values());
     }
+    copyTo(scope) {
+        this.functions.forEach((value, key) => {
+            scope.functions.set(key, value);
+        });
+        this.variables.forEach((value, key) => {
+            scope.variables.set(key, value);
+        });
+    }
 }
 export var SequenceAction;
 (function (SequenceAction) {

package/dist/esm/objects/types.js

@@ -2,11 +2,15 @@ import { ReferenceTypes } from '../globals.js';
 import { RuntimeExecutionError } from '../utils.js';
 export class CFunctionEntry {
     name;
+    namespace;
+    originalNamespace;
     execute;
     uniqueId;
     source;
-    constructor(name, execute, source, uniqueId) {
+    constructor(namespace, name, execute, source, uniqueId) {
         this.name = name;
+        this.namespace = namespace;
+        this.originalNamespace = namespace;
         this.execute = execute;
         this.uniqueId = uniqueId;
         this.source = source;
@@ -124,3 +128,25 @@ export var NetTypes;
     NetTypes["Any"] = "any";
     NetTypes["Source"] = "source";
 })(NetTypes || (NetTypes = {}));
+export class ImportedModule {
+    moduleName;
+    context;
+    importHandlingFlag;
+    specifiedImports;
+    moduleNamespace;
+    moduleFilePath;
+    constructor(moduleName, moduleNamespace, moduleFilePath, context, flag, specifiedImports) {
+        this.moduleName = moduleName;
+        this.moduleNamespace = moduleNamespace;
+        this.moduleFilePath = moduleFilePath;
+        this.context = context;
+        this.importHandlingFlag = flag;
+        this.specifiedImports = specifiedImports;
+    }
+}
+export var ImportFunctionHandling;
+(function (ImportFunctionHandling) {
+    ImportFunctionHandling["AllWithNamespace"] = "all-with-namespace";
+    ImportFunctionHandling["AllMergeIntoNamespace"] = "all-merge-into-namespace";
+    ImportFunctionHandling["SpecificMergeIntoNamespace"] = "specific-merge-into-namespace";
+})(ImportFunctionHandling || (ImportFunctionHandling = {}));

package/dist/esm/parser.js

@@ -19,6 +19,8 @@ export async function parseFileWithVisitor(visitor, data) {
     parser.addErrorListener(parserErrorListener);
     const tree = parser.script();
     let throwError;
+    let hasError = false;
+    let hasParseError = false;
     try {
         await visitor.visitAsync(tree);
     }
@@ -31,13 +33,15 @@ export async function parseFileWithVisitor(visitor, data) {
                 throwError = error;
             }
         }
+        hasError = true;
+        hasParseError = true;
     }
     const parserTimeTaken = parserTimer.lap();
     return {
         tree, parser,
         tokens,
-        hasParseError: false,
-        hasError: false,
+        hasParseError,
+        hasError,
         parserTimeTaken,
         lexerTimeTaken,
         throwError

package/dist/esm/validate/SymbolTable.js

@@ -88,3 +88,8 @@ export class SymbolTable {
         }
     }
 }
+export function cloneSymbol(symbol) {
+    return {
+        ...symbol
+    };
+}

package/dist/esm/validate/SymbolValidatorVisitor.js

@@ -1,8 +1,10 @@
+import { Import_specificContext } from "../antlr/CircuitScriptParser.js";
 import { buildInMethodNamesList } from "../builtinMethods.js";
-import { ParseSymbolType } from "../objects/types.js";
+import { ImportFunctionHandling, ParseSymbolType } from "../objects/types.js";
+import { cloneSymbol } from "./SymbolTable.js";
 import { SymbolTable } from "./SymbolTable.js";
 import { BaseVisitor } from "../BaseVisitor.js";
-import { SymbolValidatorContext } from "../globals.js";
+import { BaseNamespace, SymbolValidatorContext } from "../globals.js";
 export class SymbolValidatorVisitor extends BaseVisitor {
     symbolTable = new SymbolTable();
     filePathStack = [];
@@ -62,13 +64,58 @@ export class SymbolValidatorVisitor extends BaseVisitor {
     setSymbols(symbolTable) {
         this.symbolTable = symbolTable;
     }
-    visitImport_expr = (ctx) => {
-        const ID = ctx.ID().toString();
-        const { pathExists } = this.handleImportFile(ID, false, ctx);
+    async importCommon(ctx, handling) {
+        const specifiedImports = [];
+        if (ctx instanceof Import_specificContext) {
+            const tmpImports = ctx._funcNames.map(item => {
+                return item.text;
+            });
+            specifiedImports.push(...tmpImports);
+        }
+        const id = ctx._moduleName.text;
+        const { pathExists, importedModule } = await this.handleImportFile(id, handling, true, ctx, specifiedImports);
         if (!pathExists) {
-            this.symbolTable.addUndefined(this.getCurrentFile(), this.getExecutor(), ID, ctx.ID().getSymbol());
+            this.symbolTable.addUndefined(this.getCurrentFile(), this.getExecutor(), id, ctx._moduleName);
+        }
+        else {
+            this.applyModuleImports(importedModule);
         }
+    }
+    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);
     };
+    applyModuleImports(module) {
+        const { importHandlingFlag: importHandling, specifiedImports } = module;
+        const addedSymbols = [];
+        const executor = this.getExecutor();
+        const symbolTable = this.symbolTable.getSymbols();
+        symbolTable.forEach((value, key) => {
+            if (value.type === ParseSymbolType.Function) {
+                const definedSymbol = value;
+                if (definedSymbol.fileName === module.moduleFilePath) {
+                    const addSymbolToNamespace = importHandling === ImportFunctionHandling.AllMergeIntoNamespace
+                        || (importHandling === ImportFunctionHandling.SpecificMergeIntoNamespace
+                            && specifiedImports.indexOf(definedSymbol.id) !== -1);
+                    if (addSymbolToNamespace) {
+                        const funcPath = `${BaseNamespace}${definedSymbol.id}`;
+                        const tmpSymbol = cloneSymbol(value);
+                        tmpSymbol.context = executor;
+                        addedSymbols.push([funcPath, tmpSymbol]);
+                    }
+                }
+            }
+        });
+        addedSymbols.forEach(item => {
+            const [key, value] = item;
+            symbolTable.set(key, value);
+        });
+    }
     visitAssignment_expr = (ctx) => {
         const ctxDataExpr = ctx.data_expr();
         this.visit(ctxDataExpr);

package/dist/esm/visitor.js

@@ -13,6 +13,16 @@ import { FrameParamKeys } from './objects/Frame.js';
 import { ComponentAnnotater } from './ComponentAnnotater.js';
 import { applyPartConditions, extractPartConditions, flattenConditionNodes } from './ComponentMatchConditions.js';
 export class ParserVisitor extends BaseVisitor {
+    constructor(silent = false, onErrorHandler = null, environment) {
+        super(silent, onErrorHandler, environment);
+        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('-----------------');
+        }
+    }
     componentCreationIndex = 0;
     creationCtx = new Map();
     visitKeyword_assignment_expr = (ctx) => {
@@ -685,10 +695,8 @@ export class ParserVisitor extends BaseVisitor {
             + component.instanceName
             + Delimiter1 + component.moduleCounter;
         const tmpNamespace = this.getNetNamespace(netNamespace, "+/" + component.instanceName + 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;
@@ -886,7 +894,7 @@ export class ParserVisitor extends BaseVisitor {
     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) {
@@ -898,54 +906,17 @@ export class ParserVisitor extends 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);
     };
     visitPin_select_expr2 = (ctx) => {
         const ctxStringValue = ctx.STRING_VALUE();