circuitscript 0.1.4 → 0.1.7

package/dist/cjs/visitor.js

@@ -46,9 +46,14 @@ class ParserVisitor extends BaseVisitor_js_1.BaseVisitor {
         this.visitTo_component_expr = (ctx) => {
             ctx.component_select_expr().forEach(item => {
                 const [component, pin] = this.visitResult(item);
-                this.getExecutor().toComponent(component, pin, {
-                    addSequence: true
-                });
+                try {
+                    this.getExecutor().toComponent(component, pin, {
+                        addSequence: true
+                    });
+                }
+                catch (err) {
+                    throw new utils_js_1.RuntimeExecutionError(err.message, ctx.start, ctx.stop);
+                }
             });
             return this.getExecutor().getCurrentPoint();
         };
@@ -63,7 +68,10 @@ class ParserVisitor extends BaseVisitor_js_1.BaseVisitor {
                 componentPin = this.visitResult(ctxDataExprWithAssigment);
             }
             else {
-                const component = this.getExecutor().scope.currentComponent;
+                let component = this.getScope().currentComponent;
+                if (component._pointLinkComponent) {
+                    component = component._pointLinkComponent;
+                }
                 let pinId = null;
                 const ctxPinSelectExpr = ctx.pin_select_expr();
                 if (ctxPinSelectExpr) {
@@ -111,6 +119,92 @@ class ParserVisitor extends BaseVisitor_js_1.BaseVisitor {
             return this.getExecutor().getCurrentPoint();
         };
         this.visitCreate_component_expr = (ctx) => {
+            const scope = this.getScope();
+            scope.setOnPropertyHandler((path, value, ctx) => {
+                if (path.length === 1) {
+                    const [, keyName] = path[0];
+                    switch (keyName) {
+                        case 'type':
+                            this.validateString(value, ctx);
+                            break;
+                        case 'angle':
+                        case 'width':
+                        case 'height':
+                            this.validateNumeric(value, ctx);
+                            break;
+                        case 'pins':
+                            if (!(value instanceof Map)) {
+                                this.validateNumeric(value, ctx);
+                            }
+                            break;
+                        case 'copy':
+                            if (value instanceof ParamDefinition_js_1.NumericValue) {
+                                this.validateNumeric(value, ctx);
+                            }
+                            else if (typeof value === 'boolean') {
+                                this.validateBoolean(value, ctx);
+                            }
+                            else {
+                                throw new utils_js_1.RuntimeExecutionError("Invalid value for 'copy' property", ctx.start, ctx.end);
+                            }
+                            break;
+                    }
+                }
+                else {
+                    const [, keyName] = path[0];
+                    if (keyName === 'arrange') {
+                        const [sideKeyCtx, sideKeyName] = path[1];
+                        if (globals_js_1.ValidPinSides.indexOf(sideKeyName) === -1) {
+                            throw new utils_js_1.RuntimeExecutionError(`Invalid side ${sideKeyName} in arrange`, sideKeyCtx.start, sideKeyCtx.stop);
+                        }
+                        else {
+                            if (path.length > 2 && path[2][0] === 'index') {
+                                if (Array.isArray(value)) {
+                                    const goodBlank = value.length === 1 &&
+                                        value[0] instanceof ParamDefinition_js_1.NumericValue;
+                                    if (!goodBlank) {
+                                        throw new utils_js_1.RuntimeExecutionError(`Invalid blank specifier`, ctx.start, ctx.stop);
+                                    }
+                                }
+                                else {
+                                    if (!(value instanceof ParamDefinition_js_1.NumericValue)) {
+                                        throw new utils_js_1.RuntimeExecutionError(`Invalid numeric value for arrange.${sideKeyName}`, ctx.start, ctx.stop);
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    else if (keyName === 'params') {
+                        const [, subKeyName] = path[1];
+                        switch (subKeyName) {
+                            case 'mpn':
+                            case 'refdes':
+                            case 'footprint':
+                                this.validateString(value, ctx);
+                                break;
+                            case 'place':
+                                this.validateBoolean(value, ctx);
+                                break;
+                        }
+                    }
+                    else if (keyName === 'pins') {
+                        if (path.length === 2) {
+                            if (value.length === 2) {
+                                const [pinType,] = value;
+                                if (pinType instanceof types_js_1.UndeclaredReference) {
+                                    throw new utils_js_1.RuntimeExecutionError(`Invalid pin type: ${pinType.reference.name}`, ctx.start, ctx.end);
+                                }
+                            }
+                        }
+                    }
+                }
+            });
+            scope.enterContext(ctx);
+            ctx.property_expr().forEach(item => {
+                this.visitResult(item);
+            });
+            scope.exitContext();
+            scope.popOnPropertyHandler();
             const properties = this.getPropertyExprList(ctx.property_expr());
             const pins = this.parseCreateComponentPins(properties.get('pins'));
             let instanceName = this.getExecutor().getUniqueInstanceName();
@@ -123,7 +217,7 @@ class ParserVisitor extends BaseVisitor_js_1.BaseVisitor {
                 if (paramValue instanceof ParamDefinition_js_1.NumericValue) {
                     appendValue = paramValue.value;
                 }
-                instanceName += '_' + appendValue;
+                instanceName += `${globals_js_1.Delimiter1}${appendValue}`;
             }
             const arrange = properties.has('arrange') ?
                 properties.get('arrange') : null;
@@ -145,8 +239,13 @@ class ParserVisitor extends BaseVisitor_js_1.BaseVisitor {
                 arrange, display, type, width, height, copy,
                 angle, followWireOrientation
             };
-            const createdComponent = this.getExecutor().createComponent(instanceName, pins, params, props);
-            this.setResult(ctx, createdComponent);
+            try {
+                const createdComponent = this.getExecutor().createComponent(instanceName, pins, params, props);
+                this.setResult(ctx, createdComponent);
+            }
+            catch (error) {
+                this.throwWithContext(ctx, error.message);
+            }
         };
         this.visitCreate_graphic_expr = (ctx) => {
             const ctxId = ctx.ID();
@@ -154,7 +253,7 @@ class ParserVisitor extends BaseVisitor_js_1.BaseVisitor {
             if (ctxId !== null) {
                 const varName = ctxId.getText();
                 paramIds.push(varName);
-                this.getExecutor().scope.variables.set(varName, {});
+                this.getScope().variables.set(varName, {});
             }
             const executor = this.getExecutor();
             const stack = [...this.executionStack];
@@ -256,7 +355,7 @@ class ParserVisitor extends BaseVisitor_js_1.BaseVisitor {
                         useValueArray = [useValueArray];
                     }
                     useValueArray.forEach((value, index) => {
-                        this.getExecutor().scope.variables.set(forVariableNames[index], value);
+                        this.getScope().variables.set(forVariableNames[index], value);
                     });
                     const commands = this.visitResult(ctx.graphic_expressions_block());
                     allCommands = allCommands.concat(commands);
@@ -315,8 +414,16 @@ class ParserVisitor extends BaseVisitor_js_1.BaseVisitor {
             this.setResult(ctx, [keyName, expressionsBlock]);
         };
         this.visitProperty_expr = (ctx) => {
-            const keyName = this.visitResult(ctx.property_key_expr());
-            const value = this.visitResult(ctx.property_value_expr());
+            const ctxKey = ctx.property_key_expr();
+            const ctxValue = ctx.property_value_expr();
+            const scope = this.getScope();
+            this.getScope().enterContext(ctxKey);
+            this.getScope().enterContext(ctxValue);
+            const keyName = this.visitResult(ctxKey);
+            const value = this.visitResult(ctxValue);
+            scope.triggerPropertyHandler(value, ctxValue);
+            this.getScope().exitContext();
+            this.getScope().exitContext();
             if (value instanceof types_js_1.UndeclaredReference && (value.reference.parentValue === undefined
                 && value.reference.value === undefined)) {
                 throw value.throwMessage();
@@ -326,15 +433,21 @@ class ParserVisitor extends BaseVisitor_js_1.BaseVisitor {
             this.setResult(ctx, map);
         };
         this.visitSingle_line_property = (ctx) => {
+            this.getScope().enterContext(ctx);
             let value;
             if (ctx.data_expr().length === 1) {
                 value = this.visitResult(ctx.data_expr(0));
             }
             else {
-                value = ctx.data_expr().map(item => {
-                    return this.visitResult(item);
+                value = ctx.data_expr().map((item, index) => {
+                    this.getScope().enterContext(index);
+                    const result = this.visitResult(item);
+                    this.getScope().triggerPropertyHandler(result, item);
+                    this.getScope().exitContext();
+                    return result;
                 });
             }
+            this.getScope().exitContext();
             this.setResult(ctx, value);
         };
         this.visitNested_properties_inner = (ctx) => {
@@ -614,11 +727,13 @@ class ParserVisitor extends BaseVisitor_js_1.BaseVisitor {
             const executionStack = this.executionStack;
             const functionCounter = { counter: 0 };
             const resolveNet = this.createNetResolver(this.executionStack);
+            const resolveComponentPinNet = this.createComponentPinNetResolver(this.executionStack);
             const __runFunc = (passedInParameters, options) => {
-                const executionContextName = functionName + '_' + functionCounter['counter'];
+                const executionContextName = `${functionName}-${functionCounter['counter']}`;
                 const newExecutor = this.enterNewChildContext(executionStack, this.getExecutor(), executionContextName, options, funcDefinedParameters, passedInParameters);
                 functionCounter['counter'] += 1;
                 newExecutor.resolveNet = resolveNet;
+                newExecutor.resolveComponentPinNet = resolveComponentPinNet;
                 const returnValue = this.runExpressions(newExecutor, ctx.function_expr());
                 const lastExecution = executionStack.pop();
                 const nextLastExecution = executionStack[executionStack.length - 1];
@@ -705,6 +820,9 @@ class ParserVisitor extends BaseVisitor_js_1.BaseVisitor {
                 }
                 else if (ctxDataExpr) {
                     useValue = this.visitResult(ctxDataExpr);
+                    if (useValue instanceof ParamDefinition_js_1.NumericValue) {
+                        useValue = useValue.toNumber();
+                    }
                 }
                 if (useValue !== null) {
                     this.setResult(ctx, [direction, new helpers_js_1.UnitDimension(useValue)]);
@@ -846,7 +964,7 @@ class ParserVisitor extends BaseVisitor_js_1.BaseVisitor {
                         useValueArray = [useValueArray];
                     }
                     useValueArray.forEach((value, index) => {
-                        this.getExecutor().scope.variables.set(forVariableNames[index], value);
+                        this.getScope().variables.set(forVariableNames[index], value);
                     });
                     this.visit(ctx.expressions_block());
                     keepLooping = true;
@@ -882,15 +1000,15 @@ class ParserVisitor extends BaseVisitor_js_1.BaseVisitor {
     expandModuleContains(component, netNamespace) {
         this.getExecutor().log('expanding module `contains`');
         const executionStack = this.executionStack;
-        const resolveNet = this.createNetResolver(executionStack);
         const executor = this.getExecutor();
-        const executionContextName = executor.namespace + "_"
+        const executionContextName = executor.namespace + globals_js_1.Delimiter1
             + component.instanceName
-            + '_' + component.moduleCounter;
-        const tmpNamespace = this.getNetNamespace(netNamespace, "+/" + component.instanceName + "_" + component.moduleCounter);
+            + globals_js_1.Delimiter1 + component.moduleCounter;
+        const tmpNamespace = this.getNetNamespace(netNamespace, "+/" + component.instanceName + globals_js_1.Delimiter1 + component.moduleCounter);
         const newExecutor = this.enterNewChildContext(executionStack, executor, executionContextName, { netNamespace: tmpNamespace }, [], []);
         component.moduleCounter += 1;
-        newExecutor.resolveNet = resolveNet;
+        newExecutor.resolveNet = this.createNetResolver(executionStack);
+        newExecutor.resolveComponentPinNet = this.createComponentPinNetResolver(executionStack);
         this.visit(component.moduleContainsExpressions);
         const executionContext = executionStack.pop();
         component.moduleExecutionContext = executionContext;
@@ -1041,32 +1159,32 @@ class ParserVisitor extends BaseVisitor_js_1.BaseVisitor {
         return result;
     }
     printNets() {
-        this.getExecutor().scope.printNets();
+        this.getScope().printNets();
     }
     dumpNets() {
-        return this.getExecutor().scope.dumpNets();
+        return this.getScope().dumpNets();
     }
     dumpUniqueNets() {
-        const nets = this.getExecutor().scope.getNets();
+        const nets = this.getScope().getNets();
         return nets.reduce((accum, [, , net]) => {
             accum.push(net);
             return accum;
         }, []);
     }
     dumpVariables() {
-        return this.getExecutor().scope.variables;
+        return this.getScope().variables;
     }
     dumpInstances() {
-        return this.getExecutor().scope.instances;
+        return this.getScope().instances;
     }
     dump2() {
-        const instances = this.getExecutor().scope.instances;
+        const instances = this.getScope().instances;
         const items = [];
         for (const [instanceName, instance] of instances) {
             if (instance.assignedRefDes === null) {
                 continue;
             }
-            const pinNets = this.resolveNets(this.getExecutor().scope, instance);
+            const pinNets = this.resolveNets(this.getScope(), instance);
             const componentItem = {
                 name: instanceName,
                 refdes: instance.assignedRefDes,
@@ -1081,9 +1199,9 @@ class ParserVisitor extends BaseVisitor_js_1.BaseVisitor {
     }
     getNetList() {
         const netlist = [];
-        const instances = this.getExecutor().scope.instances;
+        const instances = this.getScope().instances;
         for (const [instanceName, instance] of instances) {
-            const pinNets = this.resolveNets(this.getExecutor().scope, instance);
+            const pinNets = this.resolveNets(this.getScope(), instance);
             const componentItem = {
                 instanceName,
                 instance,
@@ -1114,7 +1232,7 @@ class ParserVisitor extends BaseVisitor_js_1.BaseVisitor {
     annotateComponents() {
         this.log('===== annotate components =====');
         const annotater = new ComponentAnnotater();
-        const instances = this.getExecutor().scope.instances;
+        const instances = this.getScope().instances;
         const toAnnotate = [];
         for (const [, instance] of instances) {
             if (instance.typeProp === globals_js_1.ComponentTypes.net
@@ -1151,7 +1269,7 @@ class ParserVisitor extends BaseVisitor_js_1.BaseVisitor {
         this.log('');
     }
     applySheetFrameComponent() {
-        const baseScope = this.getExecutor().scope;
+        const baseScope = this.getScope();
         const document = baseScope.variables.get(globals_js_1.GlobalDocumentName);
         let frameComponent = null;
         if (document && document[Frame_js_1.FrameParamKeys.SheetType]) {

package/dist/esm/{BaseVisitor.mjs → BaseVisitor.js}

@@ -1,25 +1,22 @@
-import { readFileSync } from 'fs';
-import { join } from 'path';
 import { Big } from 'big.js';
-import { ExpressionContext } from "./antlr/CircuitScriptParser";
-import { CircuitScriptVisitor } from "./antlr/CircuitScriptVisitor";
-import { ExecutionContext } from "./execute";
-import { Logger } from "./logger";
-import { ClassComponent } from "./objects/ClassComponent";
-import { NumberOperator, NumericValue, PercentageValue } from "./objects/ParamDefinition";
-import { PinTypes } from "./objects/PinTypes";
-import { Direction, UndeclaredReference } from "./objects/types";
-import { GlobalDocumentName, ReferenceTypes } from './globals';
-import { linkBuiltInMethods } from './builtinMethods';
-import { resolveToNumericValue, throwWithContext } from './utils';
+import { ExpressionContext } 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, UndeclaredReference } from "./objects/types.js";
+import { DoubleDelimiter1, GlobalDocumentName, ReferenceTypes } from './globals.js';
+import { linkBuiltInMethods } from './builtinMethods.js';
+import { resolveToNumericValue, RuntimeExecutionError, throwWithContext } from './utils.js';
+import { SequenceAction } from './objects/ExecutionScope.js';
 export class BaseVisitor extends CircuitScriptVisitor {
     indentLevel = 0;
     startingContext;
     executionStack;
     silent = false;
     logger;
-    currentDirectory;
-    defaultLibsPath;
     printStream = [];
     printToConsole = true;
     acceptedDirections = [Direction.Up, Direction.Down,
@@ -33,28 +30,41 @@ export class BaseVisitor extends CircuitScriptVisitor {
         PinTypes.IO,
         PinTypes.Power,
     ];
-    onErrorCallbackHandler = null;
-    onImportFile = (visitor, filePath) => {
+    onErrorHandler = null;
+    environment;
+    importedFiles = [];
+    onImportFile = async (visitor, filePath, fileData, onErrorHandler) => {
         throw "Import file not implemented";
     };
-    constructor(silent = false, onErrorHandler = null, currentDirectory, defaultLibsPath) {
+    constructor(silent = false, onErrorHandler = null, environment) {
         super();
         this.logger = new Logger();
-        this.onErrorCallbackHandler = onErrorHandler;
-        this.startingContext = new ExecutionContext('__', '__.', '/', 0, 0, silent, this.logger, null);
-        this.startingContext.scope.variables.set(GlobalDocumentName, {});
-        this.setupPrintFunction(this.startingContext);
+        this.onErrorHandler = onErrorHandler;
+        this.environment = environment;
+        this.startingContext = new ExecutionContext(DoubleDelimiter1, `${DoubleDelimiter1}.`, '/', 0, 0, silent, this.logger, null);
+        const scope = this.startingContext.scope;
+        scope.sequence.push([
+            SequenceAction.At, scope.componentRoot, scope.currentPin
+        ]);
+        scope.variables.set(GlobalDocumentName, {});
+        this.setupBuiltInFunctions(this.startingContext);
         this.executionStack = [this.startingContext];
         this.startingContext.resolveNet =
             this.createNetResolver(this.executionStack);
+        this.startingContext.resolveComponentPinNet =
+            this.createComponentPinNetResolver(this.executionStack);
         this.silent = silent;
-        this.currentDirectory = currentDirectory;
-        this.defaultLibsPath = defaultLibsPath;
     }
     getExecutor() {
         return this.executionStack[this.executionStack.length - 1];
     }
-    setupPrintFunction(context) {
+    getScope() {
+        return this.getExecutor().scope;
+    }
+    getRootExecutor() {
+        return this.executionStack[0];
+    }
+    setupBuiltInFunctions(context) {
         linkBuiltInMethods(context, this);
     }
     createNetResolver(executionStack) {
@@ -77,6 +87,19 @@ export class BaseVisitor extends CircuitScriptVisitor {
         };
         return resolveNet;
     }
+    createComponentPinNetResolver(executionStack) {
+        return (component, pin) => {
+            const reversed = [...executionStack].reverse();
+            for (let i = 0; i < reversed.length; i++) {
+                const context = reversed[i];
+                const net = context.scope.getNet(component, pin);
+                if (net !== null) {
+                    return net;
+                }
+            }
+            return null;
+        };
+    }
     log(...params) {
         const indentOutput = ''.padStart(this.indentLevel * 4, '    ');
         const indentLevelText = this.indentLevel.toString().padStart(3, ' ');
@@ -89,11 +112,21 @@ export class BaseVisitor extends CircuitScriptVisitor {
     log2(message) {
         this.getExecutor().log(message);
     }
-    visitScript = (ctx) => {
+    async visitAsync(ctx) {
+        const result = await ctx.accept(this);
+        return result;
+    }
+    visitScript = async (ctx) => {
         this.log('===', 'start', '===');
-        const result = this.visitChildren(ctx);
+        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);
+        }
+        const result = this.runExpressions(this.getExecutor(), ctx.expression());
+        this.setResult(ctx, result);
         this.log('===', 'end', '===');
-        return result;
     };
     visitAssignment_expr = (ctx) => {
         const reference = this.getReference(ctx.atom_expr());
@@ -103,12 +136,9 @@ export class BaseVisitor extends CircuitScriptVisitor {
         const trailers = reference.trailers ?? [];
         if (trailers.length === 0) {
             if (value instanceof ClassComponent) {
-                const instances = this.getExecutor().scope.instances;
-                const tmpComponent = value;
-                const oldName = tmpComponent.instanceName;
-                tmpComponent.instanceName = reference.name;
-                instances.delete(oldName);
-                instances.set(reference.name, tmpComponent);
+                const variables = this.getExecutor().scope.variables;
+                variables.set(reference.name, value);
+                this.getExecutor().scope.sequence.push([SequenceAction.Assign, reference.name, value]);
                 this.log2(`assigned '${reference.name}' to ClassComponent`);
             }
             else {
@@ -229,7 +259,6 @@ export class BaseVisitor extends CircuitScriptVisitor {
                 executor.scope.setNet(tmpComponent, pinId, net);
             }
         }
-        this.log2(`atomId: ${atomId} ${currentReference}`);
         if (ctx.parent instanceof ExpressionContext && !currentReference.found) {
             this.throwWithContext(ctx, "Unknown symbol: " + atomId);
         }
@@ -369,10 +398,10 @@ export class BaseVisitor extends CircuitScriptVisitor {
                 const tmpCtx = defaultValuesProvided[index - boundary];
                 this.visit(tmpCtx);
                 const defaultValue = this.getResult(tmpCtx);
-                return [idText, defaultValue];
+                return [idText, tmpCtx.start, defaultValue];
             }
             else {
-                return [idText];
+                return [idText, id.getSymbol()];
             }
         });
         this.setResult(ctx, result);
@@ -394,10 +423,7 @@ export class BaseVisitor extends CircuitScriptVisitor {
         this.setResult(ctx, returnList);
     };
     visitImport_expr = (ctx) => {
-        const ID = ctx.ID().toString();
-        this.log('import', ID);
-        this.handleImportFile(ID, true, ctx);
-        this.log('done import', ID);
+        throw new RuntimeExecutionError("Cannot parse imports here", ctx.start, ctx.stop);
     };
     visitFunction_return_expr = (ctx) => {
         const executor = this.getExecutor();
@@ -447,15 +473,24 @@ export class BaseVisitor extends CircuitScriptVisitor {
         this.visit(ctx);
         return this.getResult(ctx);
     }
-    handleImportFile(name, throwErrors = true, ctx = null) {
+    async handleImportFile(name, throwErrors = true, ctx = null) {
+        name = name.trim();
+        const importAlready = this.importedFiles.find(item => {
+            return item.id === name;
+        });
+        if (importAlready) {
+            return importAlready;
+        }
         let hasError = false;
         let hasParseError = false;
         let pathExists = false;
-        const tmpFilePath = join(this.currentDirectory, name + ".cst");
+        const tmpFilePath = this.environment.getRelativeToModule(name + ".cst");
         this.log('importing path:', tmpFilePath);
         let fileData = null;
+        let filePathUsed = null;
         try {
-            fileData = readFileSync(tmpFilePath, { encoding: 'utf8' });
+            filePathUsed = tmpFilePath;
+            fileData = await this.environment.readFile(tmpFilePath, { encoding: 'utf8' });
             pathExists = true;
         }
         catch (err) {
@@ -463,8 +498,9 @@ export class BaseVisitor extends CircuitScriptVisitor {
         }
         if (!pathExists) {
             try {
-                const tmpFilePath2 = join(this.defaultLibsPath, name + ".cst");
-                fileData = readFileSync(tmpFilePath2, { encoding: 'utf8' });
+                const tmpFilePath2 = this.environment.getRelativeToDefaultLibs(name + ".cst");
+                filePathUsed = tmpFilePath2;
+                fileData = await this.environment.readFile(tmpFilePath2, { encoding: 'utf8' });
                 pathExists = true;
             }
             catch (err) {
@@ -474,31 +510,39 @@ export class BaseVisitor extends CircuitScriptVisitor {
         try {
             if (pathExists) {
                 this.log('done reading imported file data');
-                const importResult = this.onImportFile(this, fileData, this.onErrorCallbackHandler);
+                const importResult = await this.onImportFile(this, filePathUsed, fileData, this.onErrorHandler);
                 hasError = importResult.hasError;
                 hasParseError = importResult.hasParseError;
             }
         }
         catch (err) {
-            this.log('Failed to import file: ', err.message);
+            if (ctx != null) {
+                throw new RuntimeExecutionError("An error occurred while importing file", ctx.start, ctx.stop);
+            }
+            else {
+                this.log('An error occurred while importing file:', err.message);
+            }
         }
         let errorMessage = null;
         if (throwErrors && (hasError || hasParseError || !pathExists)) {
             if (!pathExists) {
-                errorMessage = `File does not exist: ${name}`;
+                errorMessage = `File does not exist: ${name} (${filePathUsed})`;
             }
             else {
                 errorMessage = `Failed to import: ${name}`;
             }
         }
         if (errorMessage !== null && ctx) {
-            this.throwWithContext(ctx, errorMessage);
+            throw new RuntimeExecutionError(errorMessage, ctx.start, ctx.end);
         }
-        return {
+        const newImportedFile = {
+            id: name.trim(),
             hasError,
             hasParseError,
             pathExists,
         };
+        this.importedFiles.push(newImportedFile);
+        return newImportedFile;
     }
     visitRoundedBracketsExpr = (ctx) => {
         const ctxDataExpr = ctx.data_expr();
@@ -528,9 +572,9 @@ export class BaseVisitor extends CircuitScriptVisitor {
                     executor.scope.variables.set(variableName, tmpPassedInArgs[2]);
                 }
             }
-            else if (tmpFuncArg.length === 2) {
+            else if (tmpFuncArg.length === 3) {
                 const variableName = tmpFuncArg[0];
-                const defaultValue = tmpFuncArg[1];
+                const defaultValue = tmpFuncArg[2];
                 executor.log('set variable in scope, var name: ', variableName);
                 executor.scope.variables.set(variableName, defaultValue);
             }
@@ -594,7 +638,6 @@ export class BaseVisitor extends CircuitScriptVisitor {
         const executionContextNamespace = currentExecutionContext.namespace
             + executionContextName + ".";
         const newExecutor = new ExecutionContext(executionContextName, executionContextNamespace, netNamespace, executionLevel + 1, this.getExecutor().scope.indentLevel + 1, currentExecutionContext.silent, currentExecutionContext.logger, parentContext);
-        this.setupPrintFunction(newExecutor);
         executionStack.push(newExecutor);
         this.setupDefinedParameters(funcDefinedParameters, passedInParameters, newExecutor);
         return newExecutor;
@@ -602,7 +645,32 @@ export class BaseVisitor extends CircuitScriptVisitor {
     prepareStringValue(value) {
         return value.slice(1, value.length - 1);
     }
-    throwWithContext(context, message) {
-        throwWithContext(context, message);
+    throwWithContext(context, messageOrError) {
+        throwWithContext(context, messageOrError);
+    }
+    validateType(value, context, validateFunction, expectedType) {
+        if (value === undefined) {
+            return false;
+        }
+        const result = validateFunction(value);
+        if (!result) {
+            throw new RuntimeExecutionError(`Invalid ${expectedType}`, context.start, context.stop);
+        }
+        return result;
+    }
+    validateString(value, context) {
+        this.validateType(value, context, (val) => {
+            return typeof val === 'string';
+        }, 'string');
+    }
+    validateBoolean(value, context) {
+        this.validateType(value, context, (val) => {
+            return typeof val === 'boolean';
+        }, 'boolean');
+    }
+    validateNumeric(value, context) {
+        this.validateType(value, context, (val) => {
+            return (val instanceof NumericValue);
+        }, 'numeric value');
     }
 }