circuitscript 0.1.5 → 0.1.7

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

@@ -1,26 +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 { DoubleDelimiter1, GlobalDocumentName, ReferenceTypes } from './globals';
-import { linkBuiltInMethods } from './builtinMethods';
-import { resolveToNumericValue, throwWithContext } from './utils';
-import { SequenceAction } from './objects/ExecutionScope';
+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,
@@ -34,14 +30,17 @@ 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.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([
@@ -55,12 +54,16 @@ export class BaseVisitor extends CircuitScriptVisitor {
         this.startingContext.resolveComponentPinNet =
             this.createComponentPinNetResolver(this.executionStack);
         this.silent = silent;
-        this.currentDirectory = currentDirectory;
-        this.defaultLibsPath = defaultLibsPath;
     }
     getExecutor() {
         return this.executionStack[this.executionStack.length - 1];
     }
+    getScope() {
+        return this.getExecutor().scope;
+    }
+    getRootExecutor() {
+        return this.executionStack[0];
+    }
     setupBuiltInFunctions(context) {
         linkBuiltInMethods(context, this);
     }
@@ -109,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());
@@ -385,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);
@@ -410,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();
@@ -463,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) {
@@ -479,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) {
@@ -490,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();
@@ -544,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);
             }
@@ -617,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');
     }
 }

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

@@ -1,12 +1,14 @@
-import { Assignment_exprContext } from "./antlr/CircuitScriptParser";
-import { BaseVisitor } from "./BaseVisitor";
+import { Assignment_exprContext } from "./antlr/CircuitScriptParser.js";
+import { BaseVisitor } from "./BaseVisitor.js";
+import { buildInMethodNamesList } from "./builtinMethods.js";
+import { SymbolValidatorContext } from "./globals.js";
 export class SemanticTokensVisitor extends BaseVisitor {
     parsedTokens = [];
     lexer;
     script;
     semanticTokens = new Map();
-    constructor(silent = false, onErrorHandler = null, currentDirectory, defaultsLibsPath, lexer, script) {
-        super(silent, onErrorHandler, currentDirectory, defaultsLibsPath);
+    constructor(silent = false, onErrorHandler = null, environment, lexer, script) {
+        super(silent, onErrorHandler, environment);
         this.lexer = lexer;
         this.script = script;
     }
@@ -17,7 +19,11 @@ export class SemanticTokensVisitor extends BaseVisitor {
         });
     };
     visitFunction_call_expr = (ctx) => {
-        this.addSemanticToken(ctx.ID(), [], 'function');
+        const modifiers = [];
+        if (buildInMethodNamesList.indexOf(ctx.ID().getText()) !== -1) {
+            modifiers.push('defaultLibrary');
+        }
+        this.addSemanticToken(ctx.ID(), modifiers, 'function');
     };
     visitFunction_def_expr = (ctx) => {
         const functionName = ctx.ID().getText();
@@ -26,7 +32,7 @@ export class SemanticTokensVisitor extends BaseVisitor {
         if (ctxFunctionArgsExpr) {
             this.visit(ctxFunctionArgsExpr);
         }
-        const executionContextName = functionName + '_validate';
+        const executionContextName = functionName + SymbolValidatorContext;
         const newExecutor = this.enterNewChildContext(this.executionStack, this.getExecutor(), executionContextName, { netNamespace: "" }, [], []);
         this.runExpressions(newExecutor, ctx.function_expr());
         this.executionStack.pop();
@@ -39,9 +45,8 @@ export class SemanticTokensVisitor extends BaseVisitor {
     };
     visitCreate_graphic_expr = (ctx) => {
         this.addSemanticToken(ctx.Create(), ['defaultLibrary'], 'function');
-        ctx.graphic_expr().forEach(graphic_expr => {
-            this.visit(graphic_expr);
-        });
+        const graphicsExpressionsCtx = ctx.graphic_expressions_block();
+        this.visitResult(graphicsExpressionsCtx);
     };
     visitProperty_key_expr = (ctx) => {
         let useValue = null;
@@ -61,7 +66,7 @@ export class SemanticTokensVisitor extends BaseVisitor {
             this.addSemanticToken(useValue, [], 'property');
         }
     };
-    visitGraphic_expr = (ctx) => {
+    visitGraphicCommandExpr = (ctx) => {
         let useValue = null;
         const ctxId = ctx.ID();
         const ctxPin = ctx.Pin();
@@ -179,7 +184,7 @@ const languageKeywords = [
     'break', 'branch', 'create', 'component',
     'graphic', 'wire', 'pin', 'add', 'at', 'to',
     'point', 'join', 'parallel', 'return', 'def', 'import',
-    'true', 'false', 'nc', 'frame',
+    'true', 'false', 'nc', 'sheet', 'frame', 'if', 'for',
 ];
 const operatorKeywords = [
     'at', 'to', 'wire', 'add', 'frame', 'join', 'parallel', 'point'
@@ -203,6 +208,7 @@ function resolveTokenType(tokenType) {
             case 'ID':
                 return 'variable';
             case 'Define':
+            case 'BOOLEAN_VALUE':
                 return 'keyword';
             case 'COMMENT':
                 return 'comment';