circuitscript 0.1.5 → 0.1.7

package/dist/esm/parser.js

@@ -0,0 +1,71 @@
+import { CircuitScriptParser } from './antlr/CircuitScriptParser.js';
+import { MainLexer } from './lexer.js';
+import { ParseSyntaxError, RuntimeExecutionError, SimpleStopwatch } from './utils.js';
+import { CharStream, CommonTokenStream } from 'antlr4ng';
+export async function parseFileWithVisitor(visitor, data) {
+    const lexerErrorListener = new CircuitscriptParserErrorListener(visitor.onErrorHandler);
+    const parserErrorListener = new CircuitscriptParserErrorListener(visitor.onErrorHandler);
+    const chars = CharStream.fromString(data);
+    const lexer = new MainLexer(chars);
+    lexer.removeErrorListeners();
+    lexer.addErrorListener(lexerErrorListener);
+    const lexerTimer = new SimpleStopwatch();
+    const tokens = new CommonTokenStream(lexer);
+    tokens.fill();
+    const lexerTimeTaken = lexerTimer.lap();
+    const parserTimer = new SimpleStopwatch();
+    const parser = new CircuitScriptParser(tokens);
+    parser.removeErrorListeners();
+    parser.addErrorListener(parserErrorListener);
+    const tree = parser.script();
+    try {
+        await visitor.visitAsync(tree);
+    }
+    catch (error) {
+        if (visitor.onErrorHandler) {
+            if (error instanceof RuntimeExecutionError) {
+                visitor.onErrorHandler(error.message, null, error);
+            }
+            else {
+                throw error;
+            }
+        }
+    }
+    const parserTimeTaken = parserTimer.lap();
+    return {
+        tree, parser,
+        hasParseError: false,
+        hasError: false,
+        parserTimeTaken,
+        lexerTimeTaken,
+    };
+}
+export class CircuitscriptParserErrorListener {
+    syntaxErrorCounter = 0;
+    onErrorHandler = null;
+    constructor(onErrorHandler = null) {
+        this.onErrorHandler = onErrorHandler;
+    }
+    syntaxError(recognizer, offendingSymbol, line, column, msg, e) {
+        if (this.onErrorHandler && e) {
+            this.onErrorHandler(msg, e.ctx, e);
+        }
+        else {
+            if (offendingSymbol && msg.match("extraneous input 'import' expecting")) {
+                msg = "Invalid import statement";
+                throw new ParseSyntaxError("Invalid import statement", offendingSymbol);
+            }
+            console.log("Syntax error at line", line, ':', column, ' - ', msg);
+        }
+        this.syntaxErrorCounter++;
+    }
+    reportAmbiguity(recognizer, dfa, startIndex, stopIndex, exact, ambigAlts, configs) {
+    }
+    reportAttemptingFullContext(recognizer, dfa, startIndex, stopIndex, conflictingAlts, configs) {
+    }
+    reportContextSensitivity(recognizer, dfa, startIndex, stopIndex, prediction, configs) {
+    }
+    hasSyntaxErrors() {
+        return (this.syntaxErrorCounter > 0);
+    }
+}

package/dist/esm/{regenerate-tests.mjs → regenerate-tests.js}

@@ -1,11 +1,11 @@
 import fs from 'fs';
-import { getDefaultLibsPath, getFontsPath, renderScript } from './helpers.mjs';
-import { prepareSVGEnvironment } from './sizing.mjs';
+import { renderScript } from './helpers.js';
+import { NodeScriptEnvironment } from "./environment.js";
 const mainDir = './__tests__/renderData/';
-const fontsPath = getFontsPath();
-const defaultLibsPath = getDefaultLibsPath();
+const env = new NodeScriptEnvironment();
+NodeScriptEnvironment.setInstance(env);
 async function regenerateTests(extra = "") {
-    await prepareSVGEnvironment(fontsPath);
+    env.prepareSVGEnvironment();
     const cstFiles = [];
     const files = fs.readdirSync(mainDir);
     files.forEach(file => {
@@ -17,9 +17,12 @@ async function regenerateTests(extra = "") {
         const inputPath = mainDir + file;
         const scriptData = fs.readFileSync(inputPath, { encoding: 'utf-8' });
         const outputPath = mainDir + 'svgs/' + file + extra + '.svg';
+        env.setModuleDirectory(mainDir);
         renderScript(scriptData, outputPath, {
-            currentDirectory: mainDir,
-            defaultLibsPath,
+            dumpNets: false,
+            dumpData: false,
+            showStats: false,
+            environment: env,
         });
         console.log('generated ', outputPath);
     });

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

@@ -1,15 +1,17 @@
 import { SVG, registerWindow } from '@svgdotjs/svg.js';
-import { ExtractDrawingRects, RenderFrameType, getBounds } from "./layout.mjs";
-import { applyFontsToSVG, getCreateSVGWindow } from './sizing.mjs';
-import { ColorScheme, ComponentTypes, FrameType, MMToPt, MMToPx, ParamKeys, RenderFlags, defaultGridSizeUnits, defaultPageSpacingMM, defaultWireLineWidth, fontDisplayScale, junctionSize } from './globals.mjs';
-import { numeric, NumericValue } from './objects/ParamDefinition.mjs';
-import { combineMaps, getBoundsSize } from './utils.mjs';
-import { getPaperSize, milsToMM } from './helpers.mjs';
+import { ExtractDrawingRects, RenderFrameType, getBounds } from "./layout.js";
+import { applyFontsToSVG } from './sizing.js';
+import { ColorScheme, ComponentTypes, FrameType, MMToPt, MMToPx, ParamKeys, RenderFlags, defaultGridSizeUnits, defaultPageSpacingMM, defaultWireLineWidth, fontDisplayScale, junctionSize } from './globals.js';
+import { numeric, NumericValue } from './objects/ParamDefinition.js';
+import { combineMaps, getBoundsSize } from './utils.js';
+import { getPaperSize, milsToMM } from './helpers.js';
+import { NodeScriptEnvironment } from "./environment.js";
 import SVGtoPDF from 'svg-to-pdfkit';
-import { FrameParamKeys } from './objects/Frame.mjs';
-import { SymbolPlaceholder } from './draw_symbols.mjs';
+import { FrameParamKeys } from './objects/Frame.js';
+import { SymbolPlaceholder } from './draw_symbols.js';
 function createSvgCanvas() {
-    const window = getCreateSVGWindow()();
+    const env = NodeScriptEnvironment.getInstance();
+    const window = env.createSVGWindow();
     const document = window.document;
     registerWindow(window, document);
     const canvas = SVG(document.documentElement);

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

@@ -1,42 +1,14 @@
-import { SVG, registerWindow } from '@svgdotjs/svg.js';
 import { Big } from 'big.js';
-import { HorizontalAlign, HorizontalAlignProp, VerticalAlign, VerticalAlignProp } from './geometry.mjs';
-import { defaultFont } from './globals.mjs';
-import { JSModuleType, detectJSModuleType } from './helpers.mjs';
-let MainCanvas = null;
-const supportedFonts = {
-    'Arial': 'Arial.ttf',
-};
-let globalCreateSVGWindow;
-export async function prepareSVGEnvironment(fontsPath) {
-    const moduleType = detectJSModuleType();
-    if (moduleType === JSModuleType.CommonJs) {
-        const { config, createSVGWindow } = await import('svgdom');
-        globalCreateSVGWindow = createSVGWindow;
-        if (fontsPath !== null) {
-            await config.setFontDir(fontsPath)
-                .setFontFamilyMappings(supportedFonts)
-                .preloadFonts();
-        }
-    }
-}
-export function getCreateSVGWindow() {
-    if (globalCreateSVGWindow === undefined) {
-        throw "SVG environment is not set up yet";
-    }
-    return globalCreateSVGWindow;
-}
+import { HorizontalAlign, HorizontalAlignProp, VerticalAlign, VerticalAlignProp } from './geometry.js';
+import { defaultFont } from './globals.js';
+import { NodeScriptEnvironment } from "./environment.js";
 export function applyFontsToSVG(canvas) {
 }
 const measureTextSizeCache = {};
 const measureTextSizeCacheHits = {};
 export function measureTextSize2(text, fontFamily, fontSize, fontWeight = 'regular', anchor = HorizontalAlign.Left, vanchor = VerticalAlign.Bottom) {
-    if (MainCanvas === null) {
-        const window = getCreateSVGWindow()();
-        const { document } = window;
-        registerWindow(window, document);
-        MainCanvas = SVG(document.documentElement);
-    }
+    const environment = NodeScriptEnvironment.getInstance();
+    const mainCanvas = environment.getCanvasWindow();
     const key = `${text}-${fontFamily}-${fontSize}-${fontWeight}-${anchor}-${vanchor}`;
     if (measureTextSizeCache[key] === undefined) {
         let dominantBaseline = VerticalAlignProp.Hanging;
@@ -64,7 +36,7 @@ export function measureTextSize2(text, fontFamily, fontSize, fontWeight = 'regul
                 break;
         }
         fontFamily = defaultFont;
-        const tmpTextElement = MainCanvas.text(text).font({
+        const tmpTextElement = mainCanvas.text(text).font({
             family: fontFamily,
             size: fontSize,
             anchor: useAnchor,

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

@@ -1,8 +1,8 @@
 import { Big } from 'big.js';
-import { ClassComponent } from "./objects/ClassComponent";
-import { NumericValue } from "./objects/ParamDefinition";
-import { SequenceAction } from './objects/ExecutionScope';
-import { BlockTypes } from './globals';
+import { ClassComponent } from "./objects/ClassComponent.js";
+import { NumericValue } from "./objects/ParamDefinition.js";
+import { SequenceAction } from './objects/ExecutionScope.js';
+import { BlockTypes } from './globals.js';
 export class SimpleStopwatch {
     startTime;
     constructor() {
@@ -71,20 +71,17 @@ export function getPortType(component) {
 export function roundValue(value) {
     return resolveToNumericValue(new Big(value.toBigNumber().toFixed(7)));
 }
-export function throwWithContext(context, message) {
-    const startLine = context.start?.line;
-    const startColumn = context.start?.column;
-    const startString = startLine + ":" + startColumn;
-    const stopLine = context.stop?.line;
-    const stopColumn = context.stop?.column;
-    let stopString = "";
-    if (startLine === stopLine) {
-        stopString = stopColumn?.toString();
+export function throwWithContext(context, messageOrError) {
+    if (messageOrError instanceof BaseError) {
+        throw messageOrError;
     }
-    else {
-        stopString = stopLine + ":" + stopString;
-    }
-    throw `Parse exception at [${startString} - ${stopString}] : ${message}`;
+    throwWithTokenRange(messageOrError, context.start, context.stop);
+}
+export function throwWithToken(message, token) {
+    throw new ParseError(message, token);
+}
+export function throwWithTokenRange(message, startToken, endToken) {
+    throw new ParseError(message, startToken, endToken);
 }
 export function combineMaps(map1, map2) {
     const newMap = new Map(map1);
@@ -240,3 +237,50 @@ export function getBlockTypeString(type) {
     }
     return returnValue;
 }
+export class BaseError extends Error {
+    name = 'BaseError';
+    message;
+    startToken;
+    endToken;
+    filePath;
+    constructor(message, startToken, endToken, filePath) {
+        super(message);
+        this.message = message;
+        this.startToken = startToken;
+        this.endToken = endToken;
+        this.filePath = filePath;
+    }
+    toString() {
+        const parts = [this.name];
+        if (this.startToken) {
+            const { line, column } = this.startToken;
+            if (this.endToken && (this.endToken.line !== this.startToken.line || this.endToken.column !== this.startToken.column)) {
+                const endLine = this.endToken.line;
+                const endColumn = this.endToken.column + (this.endToken.stop - this.endToken.start);
+                parts.push(` at ${line}:${column}-${endLine}:${endColumn}`);
+            }
+            else {
+                parts.push(` at ${line}:${column}`);
+            }
+        }
+        parts.push(`: ${this.message}`);
+        return parts.join('');
+    }
+}
+export class ParseSyntaxError extends BaseError {
+    name = 'ParseSyntaxError';
+}
+export class ParseError extends ParseSyntaxError {
+    name = 'ParseError';
+}
+export class RuntimeExecutionError extends BaseError {
+    name = 'RuntimeExecutionError';
+}
+export class RenderError extends Error {
+    stage;
+    constructor(message, stage) {
+        super(message);
+        this.name = 'RenderError';
+        this.stage = stage;
+    }
+}

package/dist/esm/validate/SymbolTable.js

@@ -0,0 +1,90 @@
+import { ParseSymbolType } from "../objects/types.js";
+export class SymbolTable {
+    symbols = new Map();
+    executonContextsNamespaces = [];
+    getSymbols() {
+        return this.symbols;
+    }
+    addFunction(token, fileName, executionContext, id, funcDefinedParameters) {
+        return this.add(fileName, executionContext, id, ParseSymbolType.Function, {
+            funcDefinedParameters
+        }, token);
+    }
+    addVariable(token, fileName, executionContext, id, variableValue) {
+        return this.add(fileName, executionContext, id, ParseSymbolType.Variable, {
+            variableValue
+        }, token);
+    }
+    addUndefined(filePath, executionContext, id, token) {
+        return this.add(filePath, executionContext, id, ParseSymbolType.Undefined, {}, token);
+    }
+    add(fileName, executionContext, id, type, extra, token) {
+        if (this.executonContextsNamespaces.indexOf(executionContext.namespace) === -1) {
+            this.executonContextsNamespaces.push(executionContext.namespace);
+        }
+        const item = {
+            id,
+            type,
+            context: executionContext,
+            fileName,
+            extra,
+            token,
+            instances: [],
+        };
+        if (token !== null) {
+            item.instances.push(token);
+        }
+        this.symbols.set(this.idName(executionContext, id), item);
+        return item;
+    }
+    idName(executionContext, id) {
+        return executionContext.namespace + id;
+    }
+    dumpSymbols() {
+        for (const [key, value] of this.symbols) {
+            console.log(value.type.padEnd(10, " "), key);
+        }
+    }
+    exists(executionContext, id) {
+        const name = this.idName(executionContext, id);
+        return this.symbols.has(name);
+    }
+    existsAny(executionContext, id) {
+        if (this.exists(executionContext, id)) {
+            return true;
+        }
+        else {
+            return this.searchParentContext(executionContext, id) !== null;
+        }
+    }
+    get(executionContext, id) {
+        const name = this.idName(executionContext, id);
+        return this.symbols.get(name);
+    }
+    getParentContexts(executionContext, contextsNamespace) {
+        if (executionContext.parentContext !== null) {
+            contextsNamespace.push(executionContext.parentContext.namespace);
+            this.getParentContexts(executionContext.parentContext, contextsNamespace);
+        }
+        return contextsNamespace;
+    }
+    searchParentContext(executionContext, id) {
+        const contextNames = this.getParentContexts(executionContext, []);
+        for (const [key,] of this.symbols) {
+            if (key.endsWith(`.${id}`)) {
+                const { context } = this.symbols.get(key);
+                if (contextNames.indexOf(context.namespace) !== -1) {
+                    return context;
+                }
+            }
+        }
+        return null;
+    }
+    clearUndefined() {
+        for (const [key, value] of this.symbols) {
+            if (value.type === ParseSymbolType.Undefined) {
+                this.symbols.delete(key);
+            }
+        }
+    }
+}

package/dist/esm/validate/SymbolValidatorResolveVisitor.js

@@ -0,0 +1,10 @@
+import { SymbolValidatorVisitor } from "./SymbolValidatorVisitor.js";
+export class SymbolValidatorResolveVisitor extends SymbolValidatorVisitor {
+    addSymbolVariable(token, name, value) {
+    }
+    addSymbolFunction(token, functionName, funcDefinedParameters) {
+        if (this.symbolTable.exists(this.getExecutor(), functionName)) {
+            this.symbolTable.addFunction(token, this.getCurrentFile(), this.getExecutor(), functionName, funcDefinedParameters);
+        }
+    }
+}

package/dist/esm/validate/SymbolValidatorVisitor.js

@@ -0,0 +1,163 @@
+import { buildInMethodNamesList } from "../builtinMethods.js";
+import { ParseSymbolType } from "../objects/types.js";
+import { SymbolTable } from "./SymbolTable.js";
+import { BaseVisitor } from "../BaseVisitor.js";
+import { SymbolValidatorContext } from "../globals.js";
+export class SymbolValidatorVisitor extends BaseVisitor {
+    symbolTable = new SymbolTable();
+    filePathStack = [];
+    enterFile(filePath) {
+        this.filePathStack.push(filePath);
+    }
+    exitFile() {
+        this.filePathStack.pop();
+    }
+    getCurrentFile() {
+        return this.filePathStack[this.filePathStack.length - 1];
+    }
+    addSymbolVariable(token, name, value, executor = null) {
+        const useExecutor = executor === null ? this.getExecutor() : executor;
+        this.symbolTable.addVariable(token, this.getCurrentFile(), useExecutor, name, value);
+        this.log2('add symbol variable: ' + name);
+    }
+    addSymbolFunction(token, functionName, funcDefinedParameters) {
+        if (!this.symbolTable.exists(this.getExecutor(), functionName)) {
+            this.symbolTable.addFunction(token, this.getCurrentFile(), this.getExecutor(), functionName, funcDefinedParameters);
+            this.log2('add symbol function: ' + functionName);
+        }
+    }
+    handleAtomSymbol(atom) {
+        const atomId = atom.getText();
+        const executor = this.getExecutor();
+        let tmpSymbol;
+        if (this.symbolTable.exists(executor, atomId)) {
+            tmpSymbol = this.symbolTable.get(executor, atomId);
+        }
+        else {
+            if (buildInMethodNamesList.indexOf(atomId) !== -1) {
+                tmpSymbol = this.symbolTable.addFunction(null, "<builtIn>", this.getRootExecutor(), atomId, {});
+            }
+            else {
+                const foundContext = this.symbolTable.searchParentContext(executor, atomId);
+                if (foundContext === null) {
+                    tmpSymbol = this.symbolTable.addUndefined(this.getCurrentFile(), executor, atomId, atom.getSymbol());
+                    this.log2('symbol not found: ' + atomId);
+                }
+                else {
+                    tmpSymbol = this.symbolTable.get(foundContext, atomId);
+                }
+            }
+        }
+        if (tmpSymbol.type !== ParseSymbolType.Undefined) {
+            this.addSymbolInstance(tmpSymbol, atom.getSymbol());
+        }
+        return tmpSymbol;
+    }
+    addSymbolInstance(symbol, token) {
+        symbol = symbol;
+        if (symbol.instances.indexOf(token) == -1) {
+            symbol.instances.push(token);
+        }
+    }
+    setSymbols(symbolTable) {
+        this.symbolTable = symbolTable;
+    }
+    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());
+        }
+    };
+    visitAssignment_expr = (ctx) => {
+        const ctxDataExpr = ctx.data_expr();
+        this.visit(ctxDataExpr);
+        const value = this.getResult(ctxDataExpr);
+        const atomId = ctx.atom_expr().ID(0);
+        const atomText = atomId.getText();
+        const executor = this.getExecutor();
+        if (!this.symbolTable.exists(executor, atomText)) {
+            this.addSymbolVariable(atomId.getSymbol(), atomId.getText(), value);
+        }
+        else {
+            const tmpSymbol = this.symbolTable.get(executor, atomText);
+            this.addSymbolInstance(tmpSymbol, atomId.getSymbol());
+        }
+        return null;
+    };
+    visitAtom_expr = (ctx) => {
+        const tmpSymbol = this.handleAtomSymbol(ctx.ID(0));
+        this.setResult(ctx, tmpSymbol);
+    };
+    visitFunction_call_expr = (ctx) => {
+        this.handleAtomSymbol(ctx.ID());
+        if (ctx.trailer_expr().length > 0) {
+            ctx.trailer_expr().forEach(item => {
+                if (item.OPEN_PAREN() && item.CLOSE_PAREN()) {
+                    const params = item.parameters();
+                    if (params) {
+                        this.visit(params);
+                    }
+                }
+            });
+        }
+    };
+    visitValueAtomExpr = (ctx) => {
+        let value = null;
+        const ctxValueExpr = ctx.value_expr();
+        const cxtAtomExpr = ctx.atom_expr();
+        if (ctxValueExpr) {
+            this.visit(ctxValueExpr);
+            value = this.getResult(ctxValueExpr);
+        }
+        else if (cxtAtomExpr) {
+            this.visit(cxtAtomExpr);
+            value = this.getResult(cxtAtomExpr);
+        }
+        this.setResult(ctx, value);
+    };
+    visitUnaryOperatorExpr = (ctx) => {
+        this.visit(ctx.data_expr());
+    };
+    visitMultiplyExpr = (ctx) => {
+        this.visit(ctx.data_expr(0));
+        this.visit(ctx.data_expr(1));
+    };
+    visitAdditionExpr = (ctx) => {
+        this.visit(ctx.data_expr(0));
+        this.visit(ctx.data_expr(1));
+    };
+    visitBinaryOperatorExpr = (ctx) => {
+        this.visit(ctx.data_expr(0));
+        this.visit(ctx.data_expr(1));
+    };
+    visitDataExpr = (ctx) => {
+        return;
+    };
+    visitFunction_def_expr = (ctx) => {
+        const functionName = ctx.ID().getText();
+        let funcDefinedParameters = [];
+        const ctxFunctionArgsExpr = ctx.function_args_expr();
+        if (ctxFunctionArgsExpr) {
+            this.visit(ctxFunctionArgsExpr);
+            funcDefinedParameters = this.getResult(ctxFunctionArgsExpr);
+        }
+        this.addSymbolFunction(ctx.ID().getSymbol(), functionName, funcDefinedParameters);
+        const executionContextName = functionName + SymbolValidatorContext;
+        const passedInParamsNull = funcDefinedParameters.map((param, index) => {
+            return ['position', index, null];
+        });
+        const newExecutor = this.enterNewChildContext(this.executionStack, this.getExecutor(), executionContextName, { netNamespace: "" }, funcDefinedParameters, passedInParamsNull);
+        funcDefinedParameters.forEach(param => {
+            this.addSymbolVariable(param[1], param[0], null, newExecutor);
+        });
+        this.runExpressions(newExecutor, ctx.function_expr());
+        this.executionStack.pop();
+    };
+    getSymbols() {
+        return this.symbolTable;
+    }
+    dumpSymbols() {
+        this.symbolTable.dumpSymbols();
+    }
+}

package/dist/esm/validate.js

@@ -0,0 +1,86 @@
+#! /usr/bin/env node
+import { program } from 'commander';
+import { readFileSync, existsSync } from 'fs';
+import { getSemanticTokens, validateScript } from './helpers.js';
+import { NodeScriptEnvironment } from "./environment.js";
+import { ParseSymbolType } from './objects/types.js';
+export default async function validate() {
+    const env = new NodeScriptEnvironment();
+    NodeScriptEnvironment.setInstance(env);
+    const version = env.getPackageVersion();
+    program
+        .description('generate validation output circuitscript files')
+        .version(version)
+        .argument('[input path]', 'Input path')
+        .argument('[output path]', 'Output path')
+        .option('-i, --input text <input text>', 'Input text directly')
+        .option('-c, --current-directory <path>', 'Set current directory')
+        .option('-w, --watch', 'Watch for file changes')
+        .option('-n, --dump-nets', 'Dump out net information')
+        .option('-d, --dump-data', 'Dump data during parsing')
+        .option('-s, --stats', 'Show stats during generation')
+        .option('-x, --skip-output', 'Skip output generation');
+    if (process.argv.length < 3) {
+        program.help();
+    }
+    program.parse();
+    const options = program.opts();
+    const args = program.args;
+    const watchFileChanges = options.watch;
+    const dumpNets = options.dumpNets;
+    const dumpData = options.dumpData;
+    if (options.currentDirectory) {
+        env.setModuleDirectory(options.currentDirectory);
+    }
+    if (watchFileChanges) {
+        console.log('watching for file changes...');
+    }
+    await env.prepareSVGEnvironment();
+    let inputFilePath = "";
+    if (args.length > 2) {
+        console.log("Error: Extra arguments passed");
+        return;
+    }
+    let scriptData;
+    if (args.length > 0 && args[0]) {
+        inputFilePath = args[0];
+        if (existsSync(inputFilePath)) {
+            scriptData = readFileSync(inputFilePath, { encoding: 'utf-8' });
+        }
+        else {
+            console.error("Error: File could not be found");
+            return;
+        }
+    }
+    else if (options.input) {
+        scriptData = options.input;
+    }
+    else {
+        console.error("Error: No input provided");
+        return;
+    }
+    const scriptOptions = {
+        dumpNets,
+        dumpData,
+        showStats: options.stats,
+        environment: env,
+    };
+    const visitor = await validateScript(inputFilePath, scriptData, scriptOptions);
+    const symbols = visitor.getSymbols().getSymbols();
+    symbols.forEach((value, key) => {
+        if (value.type !== ParseSymbolType.Undefined) {
+            value = value;
+            const token = value.token;
+            console.log(key, value.fileName, token !== null ? (token.line + ":" + token.column) : "");
+            value.instances.forEach(instance => {
+                console.log("    " + instance.line + ":" + instance.column + " " + instance.start);
+            });
+        }
+    });
+    const { parsedTokens } = await getSemanticTokens(scriptData, scriptOptions);
+    parsedTokens.forEach(item => {
+        const { line, column, tokenType, tokenModifiers, textValue } = item;
+        console.log(`${line}:${column} - ${textValue} - ${tokenType} | ${tokenModifiers.join(',')}`);
+    });
+}
+validate();