circuitscript 0.1.5 → 0.1.8

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

@@ -1,14 +1,13 @@
 #! /usr/bin/env node
 import { program } from 'commander';
 import figlet from 'figlet';
-import path from 'path';
-import { readFileSync, watch, existsSync } from 'fs';
-import { prepareSVGEnvironment } from './sizing.mjs';
-import { getDefaultLibsPath, getFontsPath, getPackageVersion, renderScript } from './helpers.mjs';
+import { watch } from 'fs';
+import { renderScript } from './helpers.js';
+import { NodeScriptEnvironment } from "./environment.js";
 export default async function main() {
-    const fontsPath = getFontsPath();
-    const defaultLibsPath = getDefaultLibsPath();
-    const version = getPackageVersion();
+    const env = new NodeScriptEnvironment();
+    NodeScriptEnvironment.setInstance(env);
+    const version = env.getPackageVersion();
     program
         .description('generate graphical output from circuitscript files')
         .version(version)
@@ -33,11 +32,13 @@ export default async function main() {
     const watchFileChanges = options.watch;
     const dumpNets = options.dumpNets;
     const dumpData = options.dumpData;
-    let currentDirectory = options.currentDirectory ?? null;
+    if (options.currentDirectory) {
+        throw "Parameter not supported yet";
+    }
     if (watchFileChanges) {
         console.log('watching for file changes...');
     }
-    await prepareSVGEnvironment(fontsPath);
+    await env.prepareSVGEnvironment();
     let inputFilePath = "";
     if (args.length > 2) {
         console.log("Error: Extra arguments passed");
@@ -46,11 +47,8 @@ export default async function main() {
     let scriptData;
     if (args.length > 0 && args[0]) {
         inputFilePath = args[0];
-        if (existsSync(inputFilePath)) {
-            scriptData = readFileSync(inputFilePath, { encoding: 'utf-8' });
-            if (currentDirectory === null) {
-                currentDirectory = path.dirname(inputFilePath);
-            }
+        if ((await env.exists(inputFilePath))) {
+            scriptData = await env.readFile(inputFilePath, { encoding: 'utf-8' });
         }
         else {
             console.error("Error: File could not be found");
@@ -65,28 +63,42 @@ export default async function main() {
         return;
     }
     const scriptOptions = {
-        currentDirectory,
-        defaultLibsPath,
         dumpNets,
         dumpData,
         showStats: options.stats,
+        environment: env,
     };
     let outputPath = null;
     if (args.length > 0 && args[1]) {
         outputPath = args[1];
     }
-    const output = renderScript(scriptData, outputPath, scriptOptions);
+    const output = await parseFile(scriptData, outputPath, scriptOptions);
     if (outputPath === null && output && (options.skipOutput === undefined)) {
         console.log(output);
     }
     if (watchFileChanges) {
-        watch(inputFilePath, event => {
+        watch(inputFilePath, async (event) => {
             if (event === 'change') {
-                const scriptData = readFileSync(inputFilePath, { encoding: 'utf-8' });
-                renderScript(scriptData, outputPath, scriptOptions);
-                console.log('done');
+                const scriptData = await env.readFile(inputFilePath, { encoding: 'utf-8' });
+                parseFile(scriptData, outputPath, scriptOptions);
             }
         });
     }
 }
+async function parseFile(scriptData, outputPath, scriptOptions) {
+    try {
+        const { svgOutput: output, errors } = await renderScript(scriptData, outputPath, scriptOptions);
+        errors.forEach((err, index) => {
+            console.log(`[${index}] ${err}`);
+        });
+        if (errors.length > 0) {
+            console.log('Render failed due to syntax or parsing errors');
+        }
+        return output;
+    }
+    catch (error) {
+        console.error(`Unexpected Error: ${error}`);
+    }
+    return null;
+}
 main();

package/dist/esm/objects/{ClassComponent.mjs → ClassComponent.js}

@@ -1,7 +1,7 @@
-import { SymbolDrawingCommands } from '../draw_symbols.mjs';
-import { PinDefinition, PinIdType } from './PinDefinition.mjs';
-import { PinTypes } from './PinTypes.mjs';
-import { ParamKeys } from '../globals.mjs';
+import { SymbolDrawingCommands } from '../draw_symbols.js';
+import { PinDefinition, PinIdType } from './PinDefinition.js';
+import { PinTypes } from './PinTypes.js';
+import { ParamKeys } from '../globals.js';
 export class ClassComponent {
     instanceName;
     numPins;
@@ -14,6 +14,7 @@ export class ClassComponent {
     _cachedParams;
     _copyID = null;
     _copyFrom = null;
+    _pointLinkComponent;
     arrangeProps = null;
     displayProp = null;
     widthProp = null;

package/dist/esm/objects/{ExecutionScope.mjs → ExecutionScope.js}

@@ -1,3 +1,4 @@
+import { Property_key_exprContext } from '../antlr/CircuitScriptParser.js';
 export class ExecutionScope {
     scopeId;
     nets = [];
@@ -6,6 +7,8 @@ export class ExecutionScope {
     variables = new Map();
     symbols = new Map();
     blockStack = new Map();
+    contextStack = [];
+    onPropertyHandler = [];
     breakStack = [];
     wires = [];
     frames = [];
@@ -122,6 +125,36 @@ export class ExecutionScope {
             this.currentPin = null;
         }
     }
+    enterContext(context) {
+        this.contextStack.push(context);
+    }
+    exitContext() {
+        return this.contextStack.pop();
+    }
+    findPropertyKeyTree() {
+        const keyNames = [];
+        for (let i = this.contextStack.length - 1; i >= 0; i--) {
+            const ctx = this.contextStack[i];
+            if (ctx instanceof Property_key_exprContext) {
+                keyNames.push([ctx, ctx.getText()]);
+            }
+            else if (typeof ctx === 'number') {
+                keyNames.push(['index', ctx]);
+            }
+        }
+        return keyNames.reverse();
+    }
+    setOnPropertyHandler(handler) {
+        this.onPropertyHandler.push(handler);
+    }
+    popOnPropertyHandler() {
+        return this.onPropertyHandler.pop();
+    }
+    triggerPropertyHandler(value, valueCtx) {
+        const lastHandler = this.onPropertyHandler[this.onPropertyHandler.length - 1];
+        const propertyTree = this.findPropertyKeyTree();
+        lastHandler && lastHandler(propertyTree, value, valueCtx);
+    }
 }
 export var SequenceAction;
 (function (SequenceAction) {

package/dist/esm/objects/{Frame.mjs → Frame.js}

@@ -1,4 +1,4 @@
-import { FrameType } from "../globals.mjs";
+import { FrameType } from "../globals.js";
 export class Frame {
     parameters = new Map();
     frameId;

package/dist/esm/objects/{ParamDefinition.mjs → ParamDefinition.js}

@@ -1,4 +1,4 @@
-import { getNumberExponential, getNumberExponentialText, resolveToNumericValue } from "../utils";
+import { getNumberExponential, getNumberExponentialText, resolveToNumericValue } from "../utils.js";
 import { Big } from 'big.js';
 export class ParamDefinition {
     paramName;

package/dist/esm/objects/{PinDefinition.mjs → PinDefinition.js}

@@ -1,4 +1,4 @@
-import { PinTypes } from './PinTypes.mjs';
+import { PinTypes } from './PinTypes.js';
 export class PinDefinition {
     id;
     idType;

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);
+    await env.prepareSVGEnvironment();
     const cstFiles = [];
     const files = fs.readdirSync(mainDir);
     files.forEach(file => {
@@ -13,16 +13,20 @@ async function regenerateTests(extra = "") {
             cstFiles.push(file);
         }
     });
-    cstFiles.forEach(file => {
+    for (let i = 0; i < cstFiles.length; i++) {
+        const file = cstFiles[i];
         const inputPath = mainDir + file;
         const scriptData = fs.readFileSync(inputPath, { encoding: 'utf-8' });
         const outputPath = mainDir + 'svgs/' + file + extra + '.svg';
-        renderScript(scriptData, outputPath, {
-            currentDirectory: mainDir,
-            defaultLibsPath,
+        env.setModuleDirectory(mainDir);
+        env.setDefaultLibsPath(mainDir + '../../libs/');
+        await renderScript(scriptData, outputPath, {
+            dumpNets: false,
+            dumpData: false,
+            showStats: false,
+            environment: env,
         });
-        console.log('generated ', outputPath);
-    });
+    }
     return cstFiles;
 }
 (async () => {

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);
+        }
+    }
+}