circuitscript 0.3.1 → 0.4.0

package/dist/esm/BaseVisitor.js

@@ -1,19 +1,23 @@
 import { Big } from 'big.js';
-import { Import_specificContext } from "./antlr/CircuitScriptParser.js";
-import { CircuitScriptVisitor } from "./antlr/CircuitScriptVisitor.js";
+import { Import_specific_or_allContext } from "./antlr/CircuitScriptParser.js";
+import { CircuitScriptParserVisitor } from "./antlr/CircuitScriptParserVisitor.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, ImportedLibrary, ImportFunctionHandling as ImportFunctionHandling } from "./objects/types.js";
-import { BaseNamespace, ComponentTypes, DoubleDelimiter1, GlobalDocumentName, ReferenceTypes, TrailerArrayIndex } from './globals.js';
+import { BaseNamespace, ComponentTypes, DoubleDelimiter1, GlobalDocumentName, PinTypesList, 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 {
+import { computeContentHash } from './cache/hash.js';
+import { readCache, writeCache } from './cache/storage.js';
+import { serializeLibraryScope } from './cache/serializer.js';
+import { deserializeLibraryScope } from './cache/deserializer.js';
+import { resolveAllImportFilepaths } from './importResolver.js';
+export class BaseVisitor extends CircuitScriptParserVisitor {
     startingContext;
     executionStack;
     filePathStack = [];
@@ -26,18 +30,15 @@ export class BaseVisitor extends CircuitScriptVisitor {
         Direction.Right, Direction.Left];
     resultData = new Map;
     componentCtxLinks = new Map;
-    pinTypesList = [
-        PinTypes.Any,
-        PinTypes.Input,
-        PinTypes.Output,
-        PinTypes.IO,
-        PinTypes.Power,
-    ];
     onErrorHandler = null;
     environment;
     importedFiles = [];
     warnings = [];
-    onImportFile = async (visitor, filePath, fileData, onErrorHandler) => {
+    loadedFiles = new Map();
+    enableCacheImports = true;
+    enableCachedImportsRead = false || this.enableCacheImports;
+    enableCachedImportsWrite = false || this.enableCacheImports;
+    onImportFile = (visitor, filePath, fileData, onErrorHandler, fileLineOffset) => {
         throw "Import file not implemented";
     };
     refdesFileAnnotations = new Map();
@@ -121,15 +122,32 @@ export class BaseVisitor extends CircuitScriptVisitor {
     log2(message) {
         this.getExecutor().log(message);
     }
-    async visitAsync(ctx) {
-        const result = await ctx.accept(this);
-        return result;
+    async resolveImportsAndLoad(inputPath, scriptData) {
+        this.log('resolve and load imports');
+        const importedFiles = await resolveAllImportFilepaths(inputPath, scriptData, this.environment);
+        this.log('resolved all referenced imports');
+        const loadedFiles = new Map();
+        for (const importFilePath of importedFiles) {
+            this.log(`reading file: ${importFilePath}`);
+            const importFileData = await this.environment.readFile(importFilePath);
+            loadedFiles.set(importFilePath, importFileData);
+        }
+        if (this.filePathStack.length > 0) {
+            const mainRefdesFile = this.getPathRefdesFile(this.filePathStack[0]);
+            const fileExists = await this.environment.exists(mainRefdesFile);
+            if (fileExists) {
+                this.log('.refdes.json file exists, reading it');
+                const mainRefdesFileData = await this.environment.readFile(mainRefdesFile);
+                loadedFiles.set(mainRefdesFile, mainRefdesFileData);
+            }
+        }
+        this.loadedFiles = loadedFiles;
     }
-    visitScript = async (ctx) => {
+    visitScript = (ctx) => {
         this.log('===', 'start', '===');
         this.allowParseImports = true;
         for (const ctxImport of ctx.import_expr()) {
-            await this.visit(ctxImport);
+            this.visit(ctxImport);
         }
         this.allowParseImports = false;
         const result = this.runExpressions(this.getExecutor(), ctx.expression());
@@ -137,17 +155,17 @@ export class BaseVisitor extends CircuitScriptVisitor {
         this.getExecutor().closeOpenPathBlocks();
         this.log('===', 'end', '===');
     };
-    async importCommon(ctx, handling) {
+    importCommon(ctx, handling) {
         const specificImports = [];
-        if (ctx instanceof Import_specificContext) {
+        if (ctx instanceof Import_specific_or_allContext) {
             const tmpSpecificImports = ctx._funcNames.map(item => {
                 return item.text;
             });
             specificImports.push(...tmpSpecificImports);
         }
-        const id = ctx._libraryName.text;
-        const importedFile = await this.handleImportFile(id, handling, true, ctx, specificImports);
-        const ctxImportAnnotation = ctx.import_annotation_expr();
+        const id = ctx._libraryName.text.slice(1, -1);
+        const importedFile = this.handleImportFile(id, handling, true, ctx, specificImports);
+        const ctxImportAnnotation = ctx.annotation_comment_expr();
         if (ctxImportAnnotation) {
             const textValue = ctxImportAnnotation.getText().replace('#=', '');
             const { importedLibrary } = importedFile;
@@ -159,148 +177,225 @@ export class BaseVisitor extends CircuitScriptVisitor {
             }
         }
     }
-    visitImport_simple = async (ctx) => {
-        await this.importCommon(ctx, ImportFunctionHandling.AllWithNamespace);
+    visitImport_simple = (ctx) => {
+        this.importCommon(ctx, ImportFunctionHandling.AllWithNamespace);
+    };
+    visitImport_specific_or_all = (ctx) => {
+        let importType = ImportFunctionHandling.SpecificMergeIntoNamespace;
+        if (ctx._all) {
+            importType = ImportFunctionHandling.AllMergeIntoNamespace;
+        }
+        this.importCommon(ctx, importType);
     };
-    visitImport_all_simple = async (ctx) => {
-        await this.importCommon(ctx, ImportFunctionHandling.AllMergeIntoNamespace);
+    visitCallableExpr = (ctx) => {
+        this.passResult(ctx, ctx.callable_expr());
     };
-    visitImport_specific = async (ctx) => {
-        await this.importCommon(ctx, ImportFunctionHandling.SpecificMergeIntoNamespace);
+    visitCallable_expr = (ctx) => {
+        const ctxParams = this.getResult(ctx);
+        const { keepReference = false } = ctxParams ?? {};
+        const executor = this.getExecutor();
+        let passedNetNamespace = null;
+        const netNameSpaceExpr = ctx.net_namespace_expr();
+        if (netNameSpaceExpr) {
+            passedNetNamespace = this.visitResult(netNameSpaceExpr);
+        }
+        const firstId = ctx.ID(0);
+        const atomId = firstId.getText();
+        let currentReference;
+        if (PinTypesList.indexOf(atomId) !== -1 && ctx.trailer().length === 0) {
+            currentReference = new AnyReference({
+                found: true,
+                value: atomId,
+                type: ReferenceTypes.pinType,
+            });
+        }
+        else {
+            this.log('resolve variable ctx: ' + ctx.getText(), 'atomId', atomId);
+            currentReference = executor.resolveVariable(this.executionStack, atomId);
+            this.log('reference:', currentReference.name, 'found:', currentReference.found);
+        }
+        if (currentReference !== undefined && currentReference.found) {
+            ctx.trailer().forEach(ctxTrailer => {
+                this.setResult(ctxTrailer, {
+                    reference: currentReference,
+                    netNamespace: passedNetNamespace
+                });
+                currentReference = this.visitResult(ctxTrailer);
+            });
+        }
+        let resultValue = currentReference;
+        if (!keepReference) {
+            if (currentReference.type !== ReferenceTypes.pinType) {
+                resultValue = unwrapValue(resultValue);
+            }
+        }
+        this.setResult(ctx, resultValue);
+        this.log2('atom resolved: ' + ctx.getText() + ' -> ' + currentReference);
+    };
+    visitTrailer = (ctx) => {
+        const { reference, netNamespace } = this.getResult(ctx);
+        const ctxLParam = ctx.LParen();
+        const ctxID = ctx.ID();
+        const ctxDataExpr = ctx.data_expr();
+        const useValue = reference.value;
+        let nextReference;
+        if (ctxID) {
+            reference.trailers.push(ctxID.getText());
+            const useRootValue = reference.rootValue ?? reference.value;
+            const useTrailerIndex = reference.trailerIndex ?? 0;
+            nextReference = this.getExecutor().resolveTrailers(reference.type, useRootValue, reference.trailers);
+            nextReference.name =
+                [reference.name,
+                    ...reference.trailers.slice(useTrailerIndex)].join('.');
+        }
+        else if (ctxDataExpr) {
+            const arrayIndex = this.visitResult(ctxDataExpr);
+            if (arrayIndex instanceof NumericValue) {
+                const arrayIndexValue = arrayIndex.toNumber();
+                const foundValue = useValue[arrayIndexValue];
+                const refType = foundValue instanceof ClassComponent
+                    ? ReferenceTypes.instance : ReferenceTypes.variable;
+                nextReference = new AnyReference({
+                    found: true,
+                    type: refType,
+                    value: foundValue,
+                    trailers: [[TrailerArrayIndex, arrayIndexValue]],
+                    rootValue: useValue
+                });
+            }
+        }
+        else if (ctxLParam) {
+            nextReference = this.handleFunctionCall(reference, netNamespace, ctx);
+        }
+        this.setResult(ctx, nextReference);
     };
     visitAssignment_expr = (ctx) => {
-        const ctxAtom = ctx.atom_expr();
-        const ctxFuncCallRef = ctx.function_call_expr();
-        let leftSideReference;
-        let lhsCtx;
-        if (ctxAtom) {
-            leftSideReference = this.getReference(ctx.atom_expr());
-            lhsCtx = ctxAtom;
-        }
-        else if (ctxFuncCallRef) {
-            this.setResult(ctxFuncCallRef, { keepReference: true });
-            leftSideReference = this.visitResult(ctxFuncCallRef);
-            lhsCtx = ctxFuncCallRef;
-        }
-        const rhsCtx = ctx.data_expr();
-        const rhsCtxResult = this.visitResult(rhsCtx);
-        if (isReference(rhsCtxResult) && !rhsCtxResult.found) {
-            this.throwWithContext(rhsCtx, rhsCtx.getText() + ' is not defined');
-        }
-        const rhsValue = unwrapValue(rhsCtxResult);
-        const trailers = leftSideReference.trailers ?? [];
-        const sequenceParts = [];
-        if (trailers.length === 0) {
-            this.getScope().setVariable(leftSideReference.name, rhsValue);
-            let itemType = '';
-            if (rhsValue instanceof ClassComponent) {
-                itemType = ReferenceTypes.instance;
-                this.log2(`assigned '${leftSideReference.name}' to ClassComponent`);
+        if (ctx.Assign()) {
+            const lhsCtx = ctx.callable_expr();
+            this.setResult(lhsCtx, { keepReference: true });
+            const leftSideReference = this.visitResult(lhsCtx);
+            const rhsCtx = ctx.data_expr();
+            const rhsCtxResult = this.visitResult(rhsCtx);
+            if (isReference(rhsCtxResult) && !rhsCtxResult.found) {
+                this.throwWithContext(rhsCtx, rhsCtx.getText() + ' is not defined');
             }
-            else {
-                itemType = ReferenceTypes.variable;
+            const rhsValue = unwrapValue(rhsCtxResult);
+            const { trailers = [] } = leftSideReference;
+            const sequenceParts = [];
+            if (trailers.length === 0) {
                 this.getScope().setVariable(leftSideReference.name, rhsValue);
-                this.log2(`assigned variable ${leftSideReference.name} to ${rhsValue}`);
+                let itemType = '';
+                if (rhsValue instanceof ClassComponent) {
+                    itemType = ReferenceTypes.instance;
+                    this.log2(`assigned '${leftSideReference.name}' to ClassComponent`);
+                }
+                else {
+                    itemType = ReferenceTypes.variable;
+                    this.getScope().setVariable(leftSideReference.name, rhsValue);
+                    this.log2(`assigned variable ${leftSideReference.name} to ${rhsValue}`);
+                }
+                sequenceParts.push(...[itemType, leftSideReference.name, rhsValue]);
             }
-            sequenceParts.push(...[itemType, leftSideReference.name, rhsValue]);
-        }
-        else {
-            if (leftSideReference.rootValue instanceof ClassComponent) {
-                this.setInstanceParam(leftSideReference.rootValue, trailers, rhsValue);
-                this.log2(`assigned component param ${leftSideReference.rootValue} trailers: ${trailers} value: ${rhsValue}`);
-                sequenceParts.push(...['instance', [leftSideReference.rootValue, trailers], rhsValue]);
-                if (leftSideReference.rootValue.typeProp === ComponentTypes.net) {
-                    const net = this.getScope().getNet(leftSideReference.rootValue, new PinId(1));
-                    if (net) {
-                        const trailerValue = trailers.join(".");
-                        net.params.set(trailerValue, rhsValue);
+            else {
+                if (leftSideReference.rootValue instanceof ClassComponent) {
+                    this.setInstanceParam(leftSideReference.rootValue, trailers, rhsValue);
+                    this.log2(`assigned component param ${leftSideReference.rootValue} trailers: ${trailers} value: ${rhsValue}`);
+                    sequenceParts.push(...['instance', [leftSideReference.rootValue, trailers], rhsValue]);
+                    if (leftSideReference.rootValue.typeProp === ComponentTypes.net) {
+                        const net = this.getScope().getNet(leftSideReference.rootValue, new PinId(1));
+                        if (net) {
+                            const trailerValue = trailers.join(".");
+                            net.params.set(trailerValue, rhsValue);
+                        }
                     }
                 }
-            }
-            else if (leftSideReference.rootValue instanceof Object) {
-                if (Array.isArray(trailers[0]) && trailers[0][0] === TrailerArrayIndex) {
-                    if (Array.isArray(leftSideReference.rootValue)) {
-                        const arrayIndexValue = trailers[0][1];
-                        leftSideReference.rootValue[arrayIndexValue] = rhsValue;
-                        this.log2(`assigned array index ${leftSideReference.rootValue} index: ${arrayIndexValue} value: ${rhsValue}`);
+                else if (leftSideReference.rootValue instanceof Object) {
+                    if (Array.isArray(trailers[0]) && trailers[0][0] === TrailerArrayIndex) {
+                        if (Array.isArray(leftSideReference.rootValue)) {
+                            const arrayIndexValue = trailers[0][1];
+                            leftSideReference.rootValue[arrayIndexValue] = rhsValue;
+                            this.log2(`assigned array index ${leftSideReference.rootValue} index: ${arrayIndexValue} value: ${rhsValue}`);
+                        }
+                        else {
+                            this.throwWithContext(lhsCtx, "Invalid array");
+                        }
                     }
                     else {
-                        this.throwWithContext(lhsCtx, "Invalid array");
+                        let expandedValue = leftSideReference.rootValue;
+                        trailers.slice(0, -1).forEach(trailer => {
+                            expandedValue = expandedValue[trailer];
+                        });
+                        const lastTrailer = trailers.slice(-1)[0];
+                        expandedValue[lastTrailer] = rhsValue;
+                        this.log2(`assigned object ${leftSideReference.rootValue} trailers: ${trailers} value: ${rhsValue}`);
                     }
+                    sequenceParts.push(...['variable', [leftSideReference.rootValue, trailers], rhsValue]);
                 }
-                else {
-                    let expandedValue = leftSideReference.rootValue;
-                    trailers.slice(0, -1).forEach(trailer => {
-                        expandedValue = expandedValue[trailer];
-                    });
-                    const lastTrailer = trailers.slice(-1)[0];
-                    expandedValue[lastTrailer] = rhsValue;
-                    this.log2(`assigned object ${leftSideReference.rootValue} trailers: ${trailers} value: ${rhsValue}`);
-                }
-                sequenceParts.push(...['variable', [leftSideReference.rootValue, trailers], rhsValue]);
             }
-        }
-        if (sequenceParts.length > 0) {
-            this.getScope().sequence.push([
-                SequenceAction.Assign, ...sequenceParts
-            ]);
-        }
-        this.setResult(ctx, rhsValue);
-    };
-    visitOperator_assignment_expr = (ctx) => {
-        const reference = this.getReference(ctx.atom_expr());
-        const value = this.visitResult(ctx.data_expr());
-        if (!reference.found) {
-            this.throwWithContext(ctx, 'Undefined reference: ' + reference.name);
-        }
-        const trailers = reference.trailers ?? [];
-        let currentValue = null;
-        if (trailers.length === 0) {
-            currentValue = this.getExecutor().scope.variables.get(reference.name);
+            if (sequenceParts.length > 0) {
+                this.getScope().sequence.push([
+                    SequenceAction.Assign, ...sequenceParts
+                ]);
+            }
+            this.setResult(ctx, rhsValue);
         }
         else {
-            if (reference.value instanceof ClassComponent) {
-                currentValue = this.getInstanceParam(reference.value, trailers);
+            const ctxCallable = ctx.callable_expr();
+            this.setResult(ctxCallable, { keepReference: true });
+            const reference = this.visitResult(ctx.callable_expr());
+            const value = this.visitResult(ctx.data_expr());
+            if (!reference.found) {
+                this.throwWithContext(ctx, 'Undefined reference: ' + reference.name);
             }
-            else if (reference.value instanceof Object) {
-                currentValue = reference.value[trailers.join('.')];
+            const trailers = reference.trailers ?? [];
+            let currentValue = null;
+            if (trailers.length === 0) {
+                currentValue = this.getExecutor().scope.variables.get(reference.name);
             }
-        }
-        if (currentValue === null) {
-            this.throwWithContext(ctx, 'Operator assignment failed: could not get value');
-        }
-        let newValue = 0;
-        const operator = new NumberOperator();
-        if (ctx.AdditionAssign()) {
-            newValue = operator.addition(currentValue, value);
-        }
-        else if (ctx.MinusAssign()) {
-            newValue = operator.subtraction(currentValue, value);
-        }
-        else if (ctx.MultiplyAssign()) {
-            newValue = operator.multiply(currentValue, value);
-        }
-        else if (ctx.DivideAssign()) {
-            newValue = operator.divide(currentValue, value);
-        }
-        else if (ctx.ModulusAssign()) {
-            newValue = operator.modulus(currentValue, value);
-        }
-        else {
-            this.throwWithContext(ctx, 'Operator assignment failed: could not perform operator');
-        }
-        if (trailers.length === 0) {
-            this.getExecutor().scope.setVariable(reference.name, newValue);
-        }
-        else {
-            if (reference.value instanceof ClassComponent) {
-                this.setInstanceParam(reference.value, trailers, newValue);
+            else {
+                if (reference.value instanceof ClassComponent) {
+                    currentValue = this.getInstanceParam(reference.value, trailers);
+                }
+                else if (reference.value instanceof Object) {
+                    currentValue = reference.value[trailers.join('.')];
+                }
+            }
+            if (currentValue === null) {
+                this.throwWithContext(ctx, 'Operator assignment failed: could not get value');
             }
-            else if (reference.value instanceof Object) {
-                reference.value[trailers.join('.')] = newValue;
+            let newValue = 0;
+            const operator = new NumberOperator();
+            if (ctx.AdditionAssign()) {
+                newValue = operator.addition(currentValue, value);
             }
+            else if (ctx.MinusAssign()) {
+                newValue = operator.subtraction(currentValue, value);
+            }
+            else if (ctx.MultiplyAssign()) {
+                newValue = operator.multiply(currentValue, value);
+            }
+            else if (ctx.DivideAssign()) {
+                newValue = operator.divide(currentValue, value);
+            }
+            else if (ctx.ModulusAssign()) {
+                newValue = operator.modulus(currentValue, value);
+            }
+            else {
+                this.throwWithContext(ctx, 'Operator assignment failed: could not perform operator');
+            }
+            if (trailers.length === 0) {
+                this.getExecutor().scope.setVariable(reference.name, newValue);
+            }
+            else {
+                if (reference.value instanceof ClassComponent) {
+                    this.setInstanceParam(reference.value, trailers, newValue);
+                }
+                else if (reference.value instanceof Object) {
+                    reference.value[trailers.join('.')] = newValue;
+                }
+            }
+            this.setResult(ctx, newValue);
         }
-        this.setResult(ctx, newValue);
     };
     getReference(ctx) {
         const atomStr = ctx.getText();
@@ -354,7 +449,7 @@ export class BaseVisitor extends CircuitScriptVisitor {
         const firstId = ctx.ID(0);
         const atomId = firstId.getText();
         let currentReference;
-        if (this.pinTypesList.indexOf(atomId) !== -1) {
+        if (PinTypesList.indexOf(atomId) !== -1) {
             currentReference = new AnyReference({
                 found: true,
                 value: atomId,
@@ -375,93 +470,52 @@ export class BaseVisitor extends CircuitScriptVisitor {
         this.setResult(ctx, currentReference);
         this.log2('atom resolved: ' + ctx.getText() + ' -> ' + currentReference);
     };
-    visitFunctionCallExpr = (ctx) => {
-        const result = this.visitResult(ctx.function_call_expr());
-        this.setResult(ctx, result);
-    };
-    visitFunction_call_expr = (ctx) => {
-        const ctxParams = this.getResult(ctx);
-        const { keepReference = false } = ctxParams ?? {};
-        this.handleFunctionCall(ctx);
-        if (!keepReference) {
-            const functionResultReference = this.getResult(ctx);
-            this.setResult(ctx, functionResultReference.value);
-        }
-    };
-    handleFunctionCall(ctx) {
+    handleFunctionCall(currentReference, passedNetNamespace, ctx) {
         const executor = this.getExecutor();
-        const atomId = ctx.ID().getText();
-        let passedNetNamespace = null;
-        const netNameSpaceExpr = ctx.net_namespace_expr();
-        if (netNameSpaceExpr) {
-            passedNetNamespace = this.visitResult(netNameSpaceExpr);
+        let parameters = [];
+        const ctxParameters = ctx.parameters();
+        if (ctxParameters) {
+            parameters = this.visitResult(ctxParameters);
         }
-        let currentReference = executor.resolveVariable(this.executionStack, atomId);
-        if (ctx.trailer_expr().length > 0) {
-            if (!currentReference.found) {
-                this.log(`could not resolve function: ${atomId}`);
-                this.throwWithContext(ctx, "could not resolve function: " + atomId);
-            }
-            currentReference.trailers = [];
-            ctx.trailer_expr().forEach(item => {
-                if (item.OPEN_PAREN() && item.CLOSE_PAREN()) {
-                    if (currentReference.type === ReferenceTypes.variable) {
-                        if (currentReference.value instanceof AnyReference && currentReference.value.type === ReferenceTypes.function) {
-                            currentReference = currentReference.value;
-                        }
-                    }
-                    let parameters = [];
-                    const ctxParameters = item.parameters();
-                    if (ctxParameters) {
-                        parameters = this.visitResult(ctxParameters);
-                    }
-                    const useNetNamespace = this.getNetNamespace(executor.netNamespace, passedNetNamespace);
-                    try {
-                        const isLibraryFunction = currentReference.rootValue
-                            && currentReference.rootValue instanceof ImportedLibrary;
-                        if (isLibraryFunction) {
-                            this.log('create new library context');
-                            const importedLibrary = currentReference.rootValue;
-                            const { context: importedLibraryContext } = importedLibrary;
-                            this.enterFile(importedLibrary.libraryFilePath);
-                            const newExecutor = this.handleEnterContext(this.getExecutor(), this.executionStack, importedLibraryContext.name, ctx, {
-                                netNamespace: executor.netNamespace,
-                                namespace: importedLibrary.libraryNamespace
-                            }, [], [], false);
-                            this.log('copy library context scope');
-                            importedLibraryContext.scope.copyTo(newExecutor.scope);
-                        }
-                        const [, functionResult] = executor.callFunction(currentReference, parameters, this.executionStack, useNetNamespace);
-                        if (isLibraryFunction) {
-                            this.log('pop library context scope');
-                            this.handlePopContext(this.getExecutor(), this.executionStack, "", false);
-                            this.exitFile();
-                        }
-                        if (isReference(functionResult)) {
-                            currentReference = functionResult;
-                        }
-                        else {
-                            currentReference = new AnyReference({
-                                found: true,
-                                value: functionResult,
-                                trailers: [],
-                                type: (functionResult instanceof ClassComponent) ?
-                                    ReferenceTypes.instance : ReferenceTypes.value,
-                            });
-                        }
-                    }
-                    catch (err) {
-                        this.throwWithContext(ctx, err);
-                    }
-                }
-                else {
-                    const ctxTrailer = item.trailer_expr2();
-                    this.setResult(ctxTrailer, currentReference);
-                    currentReference = this.visitResult(ctxTrailer);
-                }
-            });
+        const useNetNamespace = this.getNetNamespace(executor.netNamespace, passedNetNamespace);
+        try {
+            const isLibraryFunction = currentReference.rootValue
+                && currentReference.rootValue instanceof ImportedLibrary;
+            if (isLibraryFunction) {
+                this.log('create new library context');
+                const importedLibrary = currentReference.rootValue;
+                const { context: importedLibraryContext } = importedLibrary;
+                this.enterFile(importedLibrary.libraryFilePath);
+                const newExecutor = this.handleEnterContext(this.getExecutor(), this.executionStack, importedLibraryContext.name, ctx, {
+                    netNamespace: executor.netNamespace,
+                    namespace: importedLibrary.libraryNamespace
+                }, [], [], false);
+                this.log('copy library context scope');
+                importedLibraryContext.scope.copyTo(newExecutor.scope);
+            }
+            const [, functionResult] = executor.callFunction(currentReference, parameters, this.executionStack, useNetNamespace);
+            if (isLibraryFunction) {
+                this.log('pop library context scope');
+                this.handlePopContext(this.getExecutor(), this.executionStack, "", false);
+                this.exitFile();
+            }
+            if (isReference(functionResult)) {
+                currentReference = functionResult;
+            }
+            else {
+                currentReference = new AnyReference({
+                    found: true,
+                    value: functionResult,
+                    trailers: [],
+                    type: (functionResult instanceof ClassComponent) ?
+                        ReferenceTypes.instance : ReferenceTypes.value,
+                });
+            }
         }
-        this.setResult(ctx, currentReference);
+        catch (err) {
+            this.throwWithContext(ctx, err);
+        }
+        return currentReference;
     }
     handleEnterContext(executor, executionStack, contextName, ctx, options, funcDefinedParameters, passedInParameters, isBreakContext = true) {
         if (isBreakContext) {
@@ -554,30 +608,26 @@ export class BaseVisitor extends CircuitScriptVisitor {
         }
         this.setResult(ctx, result);
     };
-    visitValueAtomExpr = (ctx) => {
+    visitValueExpr = (ctx) => {
+        this.passResult(ctx, ctx.value_expr());
+    };
+    visitAtomExpr = (ctx) => {
         let value = null;
-        const ctxValueExpr = ctx.value_expr();
-        const ctxAtomExpr = ctx.atom_expr();
-        if (ctxValueExpr) {
-            value = this.visitResult(ctxValueExpr);
+        const reference = this.visitResult(ctx.atom_expr());
+        if (!reference.found) {
+            value = new UndeclaredReference(reference);
         }
-        else if (ctxAtomExpr) {
-            const reference = this.visitResult(ctxAtomExpr);
-            if (!reference.found) {
-                value = new UndeclaredReference(reference);
+        else {
+            if (reference.type && reference.type === ReferenceTypes.pinType) {
+                value = reference;
             }
             else {
-                if (reference.type && reference.type === ReferenceTypes.pinType) {
+                if ((reference.trailers && reference.trailers.length > 0)
+                    || reference.type === ReferenceTypes.function) {
                     value = reference;
                 }
                 else {
-                    if ((reference.trailers && reference.trailers.length > 0)
-                        || reference.type === ReferenceTypes.function) {
-                        value = reference;
-                    }
-                    else {
-                        value = reference.value;
-                    }
+                    value = reference.value;
                 }
             }
         }
@@ -601,6 +651,11 @@ export class BaseVisitor extends CircuitScriptVisitor {
         });
         this.setResult(ctx, result);
     };
+    visitKeyword_assignment_expr = (ctx) => {
+        const id = ctx.ID().getText();
+        const value = this.visitResult(ctx.data_expr());
+        this.setResult(ctx, [id, value]);
+    };
     visitParameters = (ctx) => {
         const dataExpressions = ctx.data_expr();
         const keywordAssignmentExpressions = ctx.keyword_assignment_expr();
@@ -653,7 +708,10 @@ export class BaseVisitor extends CircuitScriptVisitor {
         this.setResult(ctx, array);
     };
     visitArrayExpr = (ctx) => {
-        this.setResult(ctx, this.visitResult(ctx.array_expr()));
+        const array = ctx.data_expr().map(item => {
+            return this.visitResult(item);
+        });
+        this.setResult(ctx, array);
     };
     visitArrayIndexExpr = (ctx) => {
         const ctxArray = ctx.data_expr(0);
@@ -706,11 +764,27 @@ export class BaseVisitor extends CircuitScriptVisitor {
         this.visit(ctx);
         return this.getResult(ctx);
     }
-    async handleImportFile(name, importHandling, throwErrors = true, ctx = null, specificImports = []) {
+    passResult(ctx, innerCtx) {
+        const params = this.getResult(ctx);
+        if (params) {
+            this.setResult(innerCtx, params);
+        }
+        this.setResult(ctx, this.visitResult(innerCtx));
+    }
+    handleImportFile(name, importHandling, throwErrors = true, ctx = null, specificImports = []) {
         name = name.trim();
         const importAlready = this.importedFiles.find(item => {
             return item.id === name;
         });
+        let importStatement;
+        if (ctx !== null) {
+            const start = ctx.start;
+            const inputStream = start.inputStream;
+            importStatement = [
+                start.line, start.column,
+                inputStream.getTextFromRange(start.start, ctx.stop.stop)
+            ];
+        }
         if (importAlready) {
             const { importedLibrary: tmpImportedLibrary } = importAlready;
             const alreadyImportedFlag = tmpImportedLibrary.importHandlingFlag;
@@ -739,14 +813,17 @@ export class BaseVisitor extends CircuitScriptVisitor {
         let hasError = false;
         let hasParseError = false;
         let pathExists = false;
-        const tmpFilePath = this.environment.getRelativeToCurrentFolder(name + ".cst");
+        const tmpFilePath = this.environment.getAbsPathRelativeToCurrentFolder(name + ".cst");
+        const relativeFilePath = this.environment.relative(this.environment.getCurrentDirectory(), tmpFilePath);
         this.log('importing path:', tmpFilePath);
         let fileData = null;
         let filePathUsed = null;
         try {
-            filePathUsed = tmpFilePath;
-            fileData = await this.environment.readFile(tmpFilePath, { encoding: 'utf8' });
-            pathExists = true;
+            filePathUsed = relativeFilePath;
+            if (this.loadedFiles.has(relativeFilePath)) {
+                fileData = this.loadedFiles.get(relativeFilePath);
+                pathExists = true;
+            }
         }
         catch (err) {
             this.log('failed to read file');
@@ -758,8 +835,10 @@ export class BaseVisitor extends CircuitScriptVisitor {
                 const tmpFilePath2 = this.environment.getRelativeToDefaultLibs(name + ".cst");
                 this.log('checking default libs: ' + tmpFilePath2);
                 filePathUsed = tmpFilePath2;
-                fileData = await this.environment.readFile(tmpFilePath2, { encoding: 'utf8' });
-                pathExists = true;
+                if (this.loadedFiles.has(tmpFilePath2)) {
+                    fileData = this.loadedFiles.get(tmpFilePath2);
+                    pathExists = true;
+                }
             }
             catch (err) {
                 this.log('failed to read file');
@@ -774,16 +853,46 @@ export class BaseVisitor extends CircuitScriptVisitor {
                 const executionContextName = name;
                 const netNamespace = executor.netNamespace;
                 const libraryNamespace = `${BaseNamespace}${name}.`;
-                this.enterNewChildContext(executionStack, executor, executionContextName, {
+                const importContext = this.enterNewChildContext(executionStack, executor, executionContextName, {
                     netNamespace,
                     namespace: libraryNamespace,
                 }, [], []);
-                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}`);
-                importedLibrary = new ImportedLibrary(name, libraryNamespace, filePathUsed, importResult.tree, importResult.tokens, importContext, importHandling, specificImports);
+                let loadedFromCache = false;
+                let contentHash = '';
+                if (this.enableCachedImportsRead) {
+                    try {
+                        contentHash = computeContentHash(fileData);
+                        const cachedIR = readCache(filePathUsed, contentHash);
+                        if (cachedIR !== null) {
+                            this.log('cache hit for:', filePathUsed);
+                            const parseAndVisit = (miniScript, lineOffset) => {
+                                return this.onImportFile(this, filePathUsed, miniScript, this.onErrorHandler, lineOffset);
+                            };
+                            importedLibrary = deserializeLibraryScope(cachedIR, name, libraryNamespace, filePathUsed, importHandling, specificImports, importContext, parseAndVisit, () => {
+                                executionStack.push(importContext);
+                                return importContext;
+                            }, () => {
+                                executionStack.pop();
+                            }, contentHash);
+                            loadedFromCache = true;
+                            this.log('Done reading from import cache');
+                        }
+                    }
+                    catch (err) {
+                        this.log('Error while reading cache: ', err);
+                        loadedFromCache = false;
+                    }
+                }
+                if (!loadedFromCache) {
+                    const importResult = this.onImportFile(this, filePathUsed, fileData, this.onErrorHandler);
+                    hasError = importResult.hasError;
+                    hasParseError = importResult.hasParseError;
+                    this.log(`import handling flag: ${importHandling}`);
+                    importedLibrary = new ImportedLibrary(name, libraryNamespace, filePathUsed, importResult.tree, importResult.tokens, importContext, importHandling, specificImports, contentHash, importStatement);
+                    importedLibrary.parseError = hasError || hasParseError;
+                    importedLibrary.writeToCache = true;
+                }
+                executionStack.pop();
                 if (specificImports.length > 0) {
                     this.log('specific import: ' + specificImports.join(', '));
                 }
@@ -792,7 +901,8 @@ export class BaseVisitor extends CircuitScriptVisitor {
                 importedLibrary.context.scope.libraries.forEach((lib, key) => {
                     scope.libraries.set(key, lib);
                 });
-                await this.checkLibraryHasRefdesFile(filePathUsed);
+                executor.mergeScope(importedLibrary.context.scope, importedLibrary.libraryNamespace);
+                this.checkLibraryInRefdesFile(filePathUsed);
             }
         }
         catch (err) {
@@ -825,10 +935,32 @@ export class BaseVisitor extends CircuitScriptVisitor {
         this.importedFiles.push(newImportedFile);
         return newImportedFile;
     }
-    async checkLibraryHasRefdesFile(filePath) {
+    cacheLibraries() {
+        this.log('caching libraries');
+        const libraries = this.getScope().libraries;
+        for (const [libName, library] of libraries) {
+            this.log(`checking write flag for library ${library.libraryName}: ${library.writeToCache}`);
+            if (library.writeToCache && !library.parseError) {
+                try {
+                    const { fileHash } = library;
+                    const ir = serializeLibraryScope(library, fileHash);
+                    writeCache(library.libraryFilePath, fileHash, ir);
+                    this.log(`created cache for library: ${libName}`);
+                }
+                catch (err) {
+                    this.log(`failed to cache library: ${libName}`);
+                    throw new RuntimeExecutionError(`Failed to cache library: ${libName}`);
+                }
+            }
+        }
+    }
+    checkLibraryInRefdesFile(filePath) {
         return;
     }
-    getRefdesFileAnnotation(filePath, startLine, startColumn, stopLine, stopColumn) {
+    getPathRefdesFile(filePath) {
+        return '';
+    }
+    getRefdesFileAnnotationKey(filePath, startLine, startColumn, stopLine, stopColumn) {
         return `${filePath}:${startLine}:${startColumn}:${stopLine}:${stopColumn}`;
     }
     visitRoundedBracketsExpr = (ctx) => {