circuitscript 0.1.28 → 0.1.31

package/dist/cjs/builtinMethods.js

@@ -8,6 +8,7 @@ const big_js_1 = __importDefault(require("big.js"));
 const ParamDefinition_js_1 = require("./objects/ParamDefinition.js");
 const types_js_1 = require("./objects/types.js");
 const utils_js_1 = require("./utils.js");
+const globals_js_1 = require("./globals.js");
 const builtInMethods = [
     ['enumerate', enumerate],
     ['toMils', toMils],
@@ -20,7 +21,7 @@ const builtInMethods = [
 ];
 exports.buildInMethodNamesList = builtInMethods.map(item => item[0]);
 function linkBuiltInMethods(context, visitor) {
-    context.createFunction('print', (params) => {
+    context.createFunction(globals_js_1.BaseNamespace, 'print', (params) => {
         const args = getPositionParams(params);
         const items = args.map(item => {
             return toString((0, utils_js_1.unwrapValue)(item));
@@ -34,7 +35,7 @@ function linkBuiltInMethods(context, visitor) {
     });
     builtInMethods.forEach(([functionName, functionImpl]) => {
         if (functionImpl !== null) {
-            context.createFunction(functionName, params => {
+            context.createFunction(globals_js_1.BaseNamespace, functionName, params => {
                 const args = getPositionParams(params);
                 const functionReturn = functionImpl(...args);
                 return [visitor, functionReturn];
@@ -155,6 +156,9 @@ function toString(obj) {
     else if (obj instanceof types_js_1.CFunctionEntry) {
         return obj.toString();
     }
+    else if (obj instanceof types_js_1.ImportedModule) {
+        return `[module: ${obj.moduleName}]`;
+    }
     else {
         if (obj === undefined) {
             return 'undefined';

package/dist/cjs/environment.js

@@ -7,12 +7,14 @@ exports.NodeScriptEnvironment = void 0;
 const svg_js_1 = require("@svgdotjs/svg.js");
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
+const crypto_js_1 = __importDefault(require("crypto-js"));
 const globals_js_1 = require("./globals.js");
 const utils_js_1 = require("./utils.js");
 class NodeScriptEnvironment {
     constructor() {
         this.useModuleDirectoryPath = null;
         this.useDefaultLibsPath = null;
+        this.currentFile = '';
         this.globalCreateSVGWindow = null;
         this.cachedVersion = null;
         this.supportedFonts = {
@@ -118,6 +120,22 @@ class NodeScriptEnvironment {
     async readFile(path, options) {
         return fs_1.default.promises.readFile(path, options);
     }
+    getAbsolutePath(filePath) {
+        return path_1.default.resolve(filePath);
+    }
+    getDirPath(filePath) {
+        return path_1.default.dirname(path_1.default.resolve(filePath));
+    }
+    setCurrentFile(filePath) {
+        this.currentFile = this.getAbsolutePath(filePath);
+        return this.currentFile;
+    }
+    getCurrentFile() {
+        return this.currentFile;
+    }
+    getRelativeToCurrentFolder(filePath) {
+        return path_1.default.join(this.getDirPath(this.currentFile), filePath);
+    }
     async exists(path) {
         try {
             fs_1.default.promises.access(path, fs_1.default.constants.F_OK);
@@ -127,6 +145,9 @@ class NodeScriptEnvironment {
             return false;
         }
     }
+    hashStringSHA256(value) {
+        return crypto_js_1.default.SHA256(value).toString();
+    }
 }
 exports.NodeScriptEnvironment = NodeScriptEnvironment;
 NodeScriptEnvironment._instance = null;

package/dist/cjs/execute.js

@@ -34,7 +34,7 @@ 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;
     }
@@ -175,8 +175,8 @@ class ExecutionContext {
             paramsMap.set(param.paramName, param.paramValue);
         });
         if (component.typeProp === globals_js_1.ComponentTypes.net) {
-            const netName = paramsMap.get(globals_js_1.ParamKeys.net_name);
-            const netType = paramsMap.get(globals_js_1.ParamKeys.net_type);
+            const netName = paramsMap.get(globals_js_1.ParamKeys.net_name) ?? this.getUniqueNetName();
+            const netType = paramsMap.get(globals_js_1.ParamKeys.net_type) ?? types_js_1.NetTypes.Any;
             let priority = 0;
             if (paramsMap.has(globals_js_1.ParamKeys.priority)) {
                 priority = paramsMap.get(globals_js_1.ParamKeys.priority).toNumber();
@@ -586,10 +586,11 @@ class ExecutionContext {
     getBreakContext() {
         return this.scope.breakStack[this.scope.breakStack.length - 1];
     }
-    createFunction(functionName, __runFunc, source, uniqueId) {
-        this.scope.functions.set(functionName, new types_js_1.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 types_js_1.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);
@@ -598,32 +599,63 @@ 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 types_js_1.DeclaredReference({
                     found: true,
-                    value: context.getFunction(idName),
+                    value: context.getFunction(functionPath),
                     type: globals_js_1.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 === types_js_1.ImportFunctionHandling.AllMergeIntoNamespace ||
+                        (module.importHandlingFlag === types_js_1.ImportFunctionHandling.SpecificMergeIntoNamespace
+                            && module.specifiedImports.indexOf(idName) !== -1)) {
+                        const moduleContext = module.context;
+                        const functionPath = `${moduleContext.namespace}${idName}`;
+                        if (module.context.hasFunction(functionPath)) {
+                            return new types_js_1.DeclaredReference({
+                                found: true,
+                                rootValue: module,
+                                value: module.context.getFunction(functionPath),
+                                type: globals_js_1.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 === types_js_1.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_js_1.ClassComponent)) {
                         isComponentInstance = true;
                         isVariable = false;
                     }
-                    const tmpReference = this.resolveTrailers(isVariable ? globals_js_1.ReferenceTypes.variable : globals_js_1.ReferenceTypes.instance, useValue, trailers);
+                    const referenceType = isModule ? globals_js_1.ReferenceTypes.module :
+                        (isVariable ? globals_js_1.ReferenceTypes.variable : globals_js_1.ReferenceTypes.instance);
+                    const tmpReference = this.resolveTrailers(referenceType, useValue, trailers);
                     return new types_js_1.DeclaredReference({
-                        type: isVariable ? globals_js_1.ReferenceTypes.variable
-                            : globals_js_1.ReferenceTypes.instance,
+                        type: referenceType,
                         found: (tmpReference.value !== undefined),
                         rootValue: tmpReference.rootValue,
                         value: tmpReference.value,
@@ -644,65 +676,63 @@ class ExecutionContext {
         if (trailers.length > 0) {
             rootValue = useValue;
             const trailersPath = trailers.join(".");
-            if (type === globals_js_1.ReferenceTypes.variable) {
-                useValue = rootValue;
-                trailers.forEach(trailerPath => {
-                    useValue = useValue[trailerPath];
-                });
-            }
-            else if (type === globals_js_1.ReferenceTypes.instance) {
-                const tmpComponent = rootValue;
-                if (tmpComponent.typeProp === globals_js_1.ComponentTypes.net) {
-                    const usedNet = this.scope.getNet(tmpComponent, new PinDefinition_js_1.PinId(1));
-                    if (usedNet) {
-                        const trailerValue = trailers.join(".");
-                        useValue = usedNet.params.get(trailerValue) ?? null;
+            switch (type) {
+                case globals_js_1.ReferenceTypes.variable:
+                    useValue = rootValue;
+                    trailers.forEach(trailerPath => {
+                        useValue = useValue[trailerPath];
+                    });
+                    break;
+                case globals_js_1.ReferenceTypes.instance: {
+                    const tmpComponent = rootValue;
+                    if (tmpComponent.typeProp === globals_js_1.ComponentTypes.net) {
+                        const usedNet = this.scope.getNet(tmpComponent, new PinDefinition_js_1.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 globals_js_1.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 types_js_1.AnyReference({
+                            found: true,
+                            type: globals_js_1.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 types_js_1.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)) {
@@ -720,6 +750,7 @@ class ExecutionContext {
             return functionResult;
         }
         else {
+            this.log(`Invalid function: ${functionName}`);
             throw `Invalid function '${functionName}'`;
         }
     }
@@ -730,7 +761,7 @@ 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/cjs/globals.js

@@ -1,10 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TrailerArrayIndex = exports.SymbolValidatorContext = exports.RenderFlags = exports.GlobalDocumentName = exports.ModuleContainsKeyword = exports.FrameType = exports.NetGraphicsParams = exports.BlockTypes = exports.ReferenceTypes = exports.ComponentTypes = exports.ColorScheme = exports.PortPaddingVertical = exports.PortPaddingHorizontal = exports.PortArrowSize = exports.junctionSize = exports.defaultFontSize = exports.defaultFontBold = exports.defaultFont = exports.displayUnits = exports.defaultFrameTitleTextSize = exports.CustomSymbolParamTextSize = exports.CustomSymbolRefDesSize = exports.CustomSymbolPinIdSize = exports.CustomSymbolPinTextSize = exports.defaultPageSpacingMM = exports.defaultPageMarginMM = exports.defaultPinIdTextSize = exports.defaultPinNameTextSize = exports.defaultWireLineWidth = exports.defaultSymbolLineWidth = exports.fontDisplayScale = exports.defaultZoomScale = exports.defaultGridSizeUnits = exports.portHeight = exports.portWidth = exports.PxToMM = exports.MMToPt = exports.MMToPx = exports.MilsToMM = exports.WireAutoDirection = exports.LengthUnit = exports.ValidPinSides = exports.SymbolPinSide = exports.LayoutDirection = exports.ParamKeys = exports.NoNetText = exports.GlobalNames = exports.DoubleDelimiter1 = exports.Delimiter1 = exports.TOOL_VERSION = void 0;
+exports.SymbolValidatorContext = exports.RenderFlags = exports.GlobalDocumentName = exports.ModuleContainsKeyword = exports.FrameType = exports.NetGraphicsParams = exports.BlockTypes = exports.ReferenceTypes = exports.ComponentTypes = exports.ColorScheme = exports.PortPaddingVertical = exports.PortPaddingHorizontal = exports.PortArrowSize = exports.junctionSize = exports.defaultFontSize = exports.defaultFontBold = exports.defaultFont = exports.displayUnits = exports.defaultFrameTitleTextSize = exports.CustomSymbolParamTextSize = exports.CustomSymbolRefDesSize = exports.CustomSymbolPinIdSize = exports.CustomSymbolPinTextSize = exports.defaultPageSpacingMM = exports.defaultPageMarginMM = exports.defaultPinIdTextSize = exports.defaultPinNameTextSize = exports.defaultWireLineWidth = exports.defaultSymbolLineWidth = exports.fontDisplayScale = exports.defaultZoomScale = exports.defaultGridSizeUnits = exports.portHeight = exports.portWidth = exports.PxToMM = exports.MMToPt = exports.MMToPx = exports.MilsToMM = exports.WireAutoDirection = exports.LengthUnit = exports.ValidPinSides = exports.SymbolPinSide = exports.LayoutDirection = exports.ParamKeys = exports.NoNetText = exports.GlobalNames = exports.BaseNamespace = exports.DoubleDelimiter1 = exports.Delimiter1 = exports.TOOL_VERSION = void 0;
+exports.TrailerArrayIndex = void 0;
 const ParamDefinition_js_1 = require("./objects/ParamDefinition.js");
 exports.TOOL_VERSION = '0.1.5';
 exports.Delimiter1 = '-';
 exports.DoubleDelimiter1 = `${exports.Delimiter1}${exports.Delimiter1}`;
+exports.BaseNamespace = `${exports.DoubleDelimiter1}.`;
 var GlobalNames;
 (function (GlobalNames) {
     GlobalNames["__root"] = "--root";
@@ -96,6 +98,7 @@ var ReferenceTypes;
     ReferenceTypes["variable"] = "variable";
     ReferenceTypes["instance"] = "instance";
     ReferenceTypes["pinType"] = "pinType";
+    ReferenceTypes["module"] = "module";
     ReferenceTypes["unknown"] = "unknown";
 })(ReferenceTypes || (exports.ReferenceTypes = ReferenceTypes = {}));
 var BlockTypes;

package/dist/cjs/helpers.js

@@ -187,7 +187,7 @@ async function renderScript(scriptData, outputPath, options) {
 }
 exports.renderScript = renderScript;
 async function renderScriptCustom(scriptData, outputPath, options, parseHandlers, postAnnotationCallbacks) {
-    const { dumpNets = false, dumpData = false, showStats = false, enableErc = false, enableBom = false, bomOutputPath = undefined, environment } = options;
+    const { dumpNets = false, dumpData = false, showStats = false, enableErc = false, enableBom = false, inputPath = '', bomOutputPath = undefined, environment } = options;
     const errors = [];
     const onErrorHandler = (message, context, error) => {
         if (error && error instanceof utils_js_1.RuntimeExecutionError) {
@@ -214,11 +214,16 @@ async function renderScriptCustom(scriptData, outputPath, options, parseHandlers
             errors.push(new utils_js_1.ParseError(message, context.start, context.stop));
         }
     };
-    const visitor = new visitor_js_1.ParserVisitor(true, onErrorHandler, options.environment);
+    environment.setCurrentFile(inputPath);
+    const visitor = new visitor_js_1.ParserVisitor(true, onErrorHandler, environment);
     visitor.onImportFile = async (visitor, filePath, fileData) => {
-        const { hasError, hasParseError } = await (0, parser_js_1.parseFileWithVisitor)(visitor, fileData);
+        const { hasError, hasParseError, throwError } = await (0, parser_js_1.parseFileWithVisitor)(visitor, fileData);
         if (hasError || hasParseError) {
-            throw new utils_js_1.ParseError(`Error parsing imported file: ${filePath}`, undefined, undefined, filePath);
+            let importErrorMsg = "";
+            if (throwError) {
+                importErrorMsg = ": " + throwError.message;
+            }
+            throw new utils_js_1.ParseError(`Error parsing imported file: ${filePath}${importErrorMsg}`, undefined, undefined, filePath);
         }
         return { hasError, hasParseError };
     };

package/dist/cjs/objects/ExecutionScope.js

@@ -12,6 +12,7 @@ class ExecutionScope {
         this.functionCounter = new Map();
         this.variables = new Map();
         this.symbols = new Map();
+        this.modules = new Map();
         this.blockStack = new Map();
         this.contextStack = [];
         this.onPropertyHandler = [];
@@ -169,6 +170,14 @@ 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);
+        });
+    }
 }
 exports.ExecutionScope = ExecutionScope;
 ExecutionScope.scopeId = 0;

package/dist/cjs/objects/types.js

@@ -1,11 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.NetTypes = exports.TypeProps = exports.Direction = exports.ParseSymbolType = exports.DeclaredReference = exports.UndeclaredReference = exports.AnyReference = exports.CFunctionEntry = void 0;
+exports.ImportFunctionHandling = exports.ImportedModule = exports.NetTypes = exports.TypeProps = exports.Direction = exports.ParseSymbolType = exports.DeclaredReference = exports.UndeclaredReference = exports.AnyReference = exports.CFunctionEntry = void 0;
 const globals_js_1 = require("../globals.js");
 const utils_js_1 = require("../utils.js");
 class CFunctionEntry {
-    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;
@@ -125,3 +127,20 @@ var NetTypes;
     NetTypes["Any"] = "any";
     NetTypes["Source"] = "source";
 })(NetTypes || (exports.NetTypes = NetTypes = {}));
+class ImportedModule {
+    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;
+    }
+}
+exports.ImportedModule = ImportedModule;
+var ImportFunctionHandling;
+(function (ImportFunctionHandling) {
+    ImportFunctionHandling["AllWithNamespace"] = "all-with-namespace";
+    ImportFunctionHandling["AllMergeIntoNamespace"] = "all-merge-into-namespace";
+    ImportFunctionHandling["SpecificMergeIntoNamespace"] = "specific-merge-into-namespace";
+})(ImportFunctionHandling || (exports.ImportFunctionHandling = ImportFunctionHandling = {}));

package/dist/cjs/parser.js

@@ -22,6 +22,8 @@ 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);
     }
@@ -34,13 +36,15 @@ 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/cjs/validate/SymbolTable.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SymbolTable = void 0;
+exports.cloneSymbol = exports.SymbolTable = void 0;
 const types_js_1 = require("../objects/types.js");
 class SymbolTable {
     constructor() {
@@ -94,3 +94,9 @@ class SymbolTable {
     }
 }
 exports.SymbolTable = SymbolTable;
+function cloneSymbol(symbol) {
+    return {
+        ...symbol
+    };
+}
+exports.cloneSymbol = cloneSymbol;

package/dist/cjs/validate/SymbolValidatorVisitor.js

@@ -1,22 +1,26 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SymbolValidatorVisitor = void 0;
+const CircuitScriptParser_js_1 = require("../antlr/CircuitScriptParser.js");
 const builtinMethods_js_1 = require("../builtinMethods.js");
 const types_js_1 = require("../objects/types.js");
 const SymbolTable_js_1 = require("./SymbolTable.js");
+const SymbolTable_js_2 = require("./SymbolTable.js");
 const BaseVisitor_js_1 = require("../BaseVisitor.js");
 const globals_js_1 = require("../globals.js");
 class SymbolValidatorVisitor extends BaseVisitor_js_1.BaseVisitor {
     constructor() {
         super(...arguments);
-        this.symbolTable = new SymbolTable_js_1.SymbolTable();
+        this.symbolTable = new SymbolTable_js_2.SymbolTable();
         this.filePathStack = [];
-        this.visitImport_expr = (ctx) => {
-            const ID = ctx.ID().toString();
-            const { pathExists } = this.handleImportFile(ID, false, ctx);
-            if (!pathExists) {
-                this.symbolTable.addUndefined(this.getCurrentFile(), this.getExecutor(), ID, ctx.ID().getSymbol());
-            }
+        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 ctxDataExpr = ctx.data_expr();
@@ -165,6 +169,49 @@ class SymbolValidatorVisitor extends BaseVisitor_js_1.BaseVisitor {
     setSymbols(symbolTable) {
         this.symbolTable = symbolTable;
     }
+    async importCommon(ctx, handling) {
+        const specifiedImports = [];
+        if (ctx instanceof CircuitScriptParser_js_1.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._moduleName);
+        }
+        else {
+            this.applyModuleImports(importedModule);
+        }
+    }
+    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 === types_js_1.ParseSymbolType.Function) {
+                const definedSymbol = value;
+                if (definedSymbol.fileName === module.moduleFilePath) {
+                    const addSymbolToNamespace = importHandling === types_js_1.ImportFunctionHandling.AllMergeIntoNamespace
+                        || (importHandling === types_js_1.ImportFunctionHandling.SpecificMergeIntoNamespace
+                            && specifiedImports.indexOf(definedSymbol.id) !== -1);
+                    if (addSymbolToNamespace) {
+                        const funcPath = `${globals_js_1.BaseNamespace}${definedSymbol.id}`;
+                        const tmpSymbol = (0, SymbolTable_js_1.cloneSymbol)(value);
+                        tmpSymbol.context = executor;
+                        addedSymbols.push([funcPath, tmpSymbol]);
+                    }
+                }
+            }
+        });
+        addedSymbols.forEach(item => {
+            const [key, value] = item;
+            symbolTable.set(key, value);
+        });
+    }
     getSymbols() {
         return this.symbolTable;
     }