circuitscript 0.3.1 → 0.4.0

package/dist/esm/antlr/{CircuitScriptVisitor.js → CircuitScriptParserVisitor.js}

@@ -1,81 +1,61 @@
 import { AbstractParseTreeVisitor } from "antlr4ng";
-export class CircuitScriptVisitor extends AbstractParseTreeVisitor {
+export class CircuitScriptParserVisitor extends AbstractParseTreeVisitor {
     visitScript;
     visitExpression;
     visitFlow_expressions;
     visitGraph_expressions;
-    visitGraph_linear_expression;
     visitExpressions_block;
     visitPath_block;
-    visitProperty_set_expr2;
-    visitAssignment_expr2;
     visitPin_select_expr;
     visitComponent_modifier_expr;
     visitData_expr_with_assignment;
+    visitAssignment_expr;
     visitAdd_component_expr;
     visitComponent_select_expr;
-    visitPin_select_expr2;
     visitAt_component_expr;
     visitTo_component_expr;
-    visitAt_to_multiple_expr;
-    visitAt_to_multiple_line_expr;
-    visitAt_to_multiple_line_expr_to_pin;
+    visitAt_block_header;
     visitAt_block;
     visitAt_block_expressions;
-    visitAt_block_header;
     visitAt_block_pin_expr;
-    visitAt_block_pin_expression_simple;
-    visitAt_block_pin_expression_complex;
-    visitAssignment_expr;
-    visitOperator_assignment_expr;
     visitKeyword_assignment_expr;
     visitParameters;
-    visitProperty_set_expr;
     visitDouble_dot_property_set_expr;
+    visitValueExpr;
     visitArrayExpr;
-    visitArrayIndexExpr;
-    visitFunctionCallExpr;
     visitAdditionExpr;
     visitMultiplyExpr;
     visitLogicalOperatorExpr;
-    visitDataExpr;
+    visitCreateExpr;
     visitUnaryOperatorExpr;
-    visitValueAtomExpr;
+    visitCallableExpr;
     visitBinaryOperatorExpr;
     visitRoundedBracketsExpr;
-    visitBinary_operator;
-    visitUnary_operator;
     visitValue_expr;
     visitFunction_def_expr;
     visitFunction_expr;
     visitFunction_args_expr;
-    visitAtom_expr;
-    visitTrailer_expr;
-    visitTrailer_expr2;
-    visitFunction_call_expr;
-    visitNet_namespace_expr;
     visitFunction_return_expr;
+    visitNet_namespace_expr;
+    visitCallable_expr;
+    visitTrailer;
     visitProperty_block_expr;
-    visitCreate_component_expr;
+    visitProperties_block;
     visitGraphic_expressions_block;
+    visitCreate_expr;
+    visitCreate_component_expr;
     visitCreate_graphic_expr;
     visitCreate_module_expr;
-    visitNested_properties_inner;
-    visitGraphicCommandExpr;
     visitGraphicForExpr;
+    visitGraphicCommandExpr;
     visitProperty_expr;
     visitProperty_key_expr;
     visitNested_properties;
     visitSingle_line_property;
-    visitWire_expr_direction_value;
-    visitWire_expr_direction_only;
     visitWire_expr;
-    visitArray_expr;
     visitPoint_expr;
     visitImport_simple;
-    visitImport_all_simple;
-    visitImport_specific;
-    visitImport_annotation_expr;
+    visitImport_specific_or_all;
     visitFrame_expr;
     visitIf_expr;
     visitIf_inner_expr;
@@ -87,7 +67,6 @@ export class CircuitScriptVisitor extends AbstractParseTreeVisitor {
     visitPart_match_block;
     visitPart_sub_expr;
     visitPart_condition_expr;
-    visitPart_condition_key_only_expr;
     visitPart_value_expr;
     visitAnnotation_comment_expr;
 }

package/dist/esm/cache/deserializer.js

@@ -0,0 +1,30 @@
+import { ImportedLibrary } from '../objects/types.js';
+export function deserializeLibraryScope(ir, name, libraryNamespace, filePathUsed, importHandling, specificImports, importContext, parseAndVisit, enterContext, exitContext, libraryFileHash) {
+    const importedLibrary = new ImportedLibrary(name, libraryNamespace, filePathUsed, null, null, importContext, importHandling, specificImports, libraryFileHash);
+    ir.functions.forEach(func => {
+        const { name, uniqueId } = func;
+        const functionEntry = importContext.createFunctionLazyLoaded(importContext.namespace, name, uniqueId);
+        functionEntry.lazyLoader = () => {
+            importContext.log(`loading lazy function ${name}`);
+            enterContext();
+            const [line, column, sourceText] = func.sourceText;
+            const { tokens, tree } = parseAndVisit(sourceText, line - 1);
+            importedLibrary.referencedTokens.push([tokens, tree]);
+            exitContext();
+            functionEntry.tokens = tokens;
+            functionEntry.tree = tree;
+        };
+    });
+    enterContext();
+    for (const importStatement of ir.imports) {
+        const [line, column, statement] = importStatement;
+        parseAndVisit(statement, line - 1);
+    }
+    for (const block of (ir.topLevel ?? [])) {
+        const [line, column, sourceText] = block;
+        const { tokens, tree } = parseAndVisit(sourceText, line - 1);
+        importedLibrary.referencedTokens.push([tokens, tree]);
+    }
+    exitContext();
+    return importedLibrary;
+}

package/dist/esm/cache/hash.js

@@ -0,0 +1,4 @@
+import { createHash } from 'crypto';
+export function computeContentHash(fileContent) {
+    return createHash('sha256').update(fileContent, 'utf8').digest('hex');
+}

package/dist/esm/cache/serializer.js

@@ -0,0 +1,118 @@
+import { CACHE_SCHEMA_VERSION } from './types.js';
+import { CircuitScriptLexer } from '../antlr/CircuitScriptLexer.js';
+import { generateModifiedSourceText } from '../annotate/utils.js';
+export function serializeLibraryScope(importedLib, contentHash) {
+    const functions = [];
+    const topLevelExpressions = [];
+    const scope = importedLib.context.scope;
+    const { tokens: libraryTokens, refdesAnnotations } = importedLib;
+    const libraryInputStream = libraryTokens.tokenSource.inputStream;
+    scope.functions.forEach((entry) => {
+        let useSource = '';
+        let useTokenLine = 0;
+        let useTokenColumn = 0;
+        if (libraryTokens !== null && entry.source !== null) {
+            const source = entry.source;
+            const startIndex = source.start?.tokenIndex ?? 0;
+            const stopIndex = source.stop?.tokenIndex ?? -1;
+            const contextTokens = libraryTokens.getTokens(startIndex, stopIndex);
+            const startToken = source.start;
+            const startChar = startToken.start ?? -1;
+            const stopChar = getFunctionDefinitionEnding(source, libraryTokens);
+            const sourceText = libraryInputStream != null && startChar >= 0 && stopChar >= 0
+                ? libraryInputStream.getTextFromRange(startChar, stopChar)
+                : libraryTokens.getTextFromContext(source);
+            useSource = generateModifiedSourceText(refdesAnnotations, contextTokens, sourceText, startToken.start);
+            useTokenLine = startToken.line;
+            useTokenColumn = startToken.column;
+        }
+        functions.push({
+            name: entry.name,
+            namespace: entry.originalNamespace,
+            uniqueId: entry.uniqueId ?? '',
+            sourceText: [
+                useTokenLine, useTokenColumn, useSource
+            ]
+        });
+    });
+    const tree = importedLib.tree;
+    if (tree != null) {
+        let groupCtx = [];
+        let groupStart = null;
+        let prevStopLine = null;
+        const flushGroup = () => {
+            let useSource = '';
+            if (groupCtx.length > 0 && groupStart !== null) {
+                const startToken = groupCtx[0].start;
+                const stopToken = groupCtx[groupCtx.length - 1].stop;
+                const startIndex = startToken.tokenIndex ?? 0;
+                const stopIndex = stopToken.tokenIndex ?? -1;
+                const contextTokens = libraryTokens.getTokens(startIndex, stopIndex);
+                const startChar = startToken.start ?? -1;
+                const stopChar = stopToken.stop ?? -1;
+                const sourceText = libraryInputStream.getTextFromRange(startChar, stopChar);
+                useSource = generateModifiedSourceText(refdesAnnotations, contextTokens, sourceText, startToken.start);
+                topLevelExpressions.push([
+                    ...groupStart,
+                    useSource
+                ]);
+            }
+            groupCtx = [];
+            groupStart = null;
+            prevStopLine = null;
+        };
+        for (const exprCtx of tree.expression()) {
+            if (exprCtx.function_def_expr() !== null) {
+                flushGroup();
+                continue;
+            }
+            if (exprCtx.NEWLINE() !== null) {
+                if (groupCtx.length > 0) {
+                    groupCtx.push(exprCtx);
+                }
+                continue;
+            }
+            const startToken = exprCtx.start;
+            if (startToken == null)
+                continue;
+            const currentStartLine = startToken.line;
+            if (prevStopLine !== null && currentStartLine > prevStopLine + 1) {
+                flushGroup();
+            }
+            if (groupStart == null) {
+                groupStart = [currentStartLine, startToken.column];
+            }
+            groupCtx.push(exprCtx);
+            prevStopLine = exprCtx.stop?.line ?? currentStartLine;
+        }
+        flushGroup();
+    }
+    const imports = [];
+    for (const [libName, lib] of importedLib.context.scope.libraries) {
+        imports.push(lib.importStatement);
+    }
+    return {
+        schemaVersion: CACHE_SCHEMA_VERSION,
+        contentHash,
+        libraryFilePath: importedLib.libraryFilePath,
+        imports,
+        functions,
+        topLevel: topLevelExpressions,
+    };
+}
+function getFunctionDefinitionEnding(source, tokens) {
+    let stopChar = source.stop?.stop ?? -1;
+    const stopTokenIndex = source.stop?.tokenIndex ?? -1;
+    if (stopTokenIndex >= 0) {
+        for (let i = stopTokenIndex; i >= 0; i--) {
+            const tok = tokens.get(i);
+            if (tok.type !== CircuitScriptLexer.NEWLINE &&
+                tok.type !== CircuitScriptLexer.DEDENT &&
+                tok.type !== CircuitScriptLexer.INDENT) {
+                stopChar = tok.stop ?? stopChar;
+                break;
+            }
+        }
+    }
+    return stopChar;
+}

package/dist/esm/cache/storage.js

@@ -0,0 +1,39 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync, renameSync } from 'fs';
+import { dirname, basename, join } from 'path';
+import { CACHE_SCHEMA_VERSION } from './types.js';
+export function getCachePath(libFilePath) {
+    const dir = dirname(libFilePath);
+    const base = basename(libFilePath);
+    return join(dir, '.cst.cache', `${base}.json`);
+}
+export function readCache(libFilePath, hash) {
+    try {
+        const cachePath = getCachePath(libFilePath);
+        if (!existsSync(cachePath)) {
+            return null;
+        }
+        const raw = readFileSync(cachePath, 'utf8');
+        const ir = JSON.parse(raw);
+        if (ir.schemaVersion !== CACHE_SCHEMA_VERSION || ir.contentHash !== hash) {
+            return null;
+        }
+        return ir;
+    }
+    catch {
+        return null;
+    }
+}
+export function writeCache(libFilePath, hash, ir) {
+    try {
+        const cachePath = getCachePath(libFilePath);
+        const cacheDir = dirname(cachePath);
+        if (!existsSync(cacheDir)) {
+            mkdirSync(cacheDir, { recursive: true });
+        }
+        const tmp = cachePath + '.tmp';
+        writeFileSync(tmp, JSON.stringify(ir), 'utf8');
+        renameSync(tmp, cachePath);
+    }
+    catch {
+    }
+}

package/dist/esm/cache/types.js

@@ -0,0 +1 @@
+export const CACHE_SCHEMA_VERSION = 3;

package/dist/esm/{environment.js → environment/environment.js}

@@ -2,8 +2,8 @@ import { registerWindow, SVG } from "@svgdotjs/svg.js";
 import fs from 'fs';
 import path from "path";
 import CryptoJs from "crypto-js";
-import { TOOL_VERSION } from "./globals.js";
-import { RuntimeExecutionError } from "./utils.js";
+import { TOOL_VERSION } from "../globals.js";
+import { RuntimeExecutionError } from "../utils.js";
 export class NodeScriptEnvironment {
     existsSync(pathLike) {
         return fs.existsSync(pathLike);
@@ -53,14 +53,15 @@ export class NodeScriptEnvironment {
             return this.useModuleDirectoryPath;
         }
         if (typeof __dirname !== 'undefined') {
-            return __dirname;
+            return path.resolve(__dirname + "/../");
         }
         const stackLine = new Error().stack?.split('\n')[1];
         if (stackLine) {
             const fileMatch = stackLine.match(/\((.+)\:[\d]+\:[\d]+\)/);
             if (fileMatch) {
                 const filePath = fileMatch[1].replace('file://', '');
-                return path.dirname(filePath);
+                const finalPath = path.resolve(path.dirname(filePath) + "/../");
+                return finalPath;
             }
         }
         throw new RuntimeExecutionError("Failed to get current module directory");
@@ -128,7 +129,15 @@ export class NodeScriptEnvironment {
         return path.resolve(filePath);
     }
     getDirPath(filePath) {
-        return path.dirname(path.resolve(filePath));
+        const resolved = path.resolve(filePath);
+        try {
+            if (fs.statSync(resolved).isDirectory()) {
+                return resolved;
+            }
+        }
+        catch {
+        }
+        return path.dirname(resolved);
     }
     setCurrentFile(filePath) {
         this.currentFile = this.getAbsolutePath(filePath);
@@ -137,7 +146,7 @@ export class NodeScriptEnvironment {
     getCurrentFile() {
         return this.currentFile;
     }
-    getRelativeToCurrentFolder(filePath) {
+    getAbsPathRelativeToCurrentFolder(filePath) {
         return path.join(this.getDirPath(this.currentFile), filePath);
     }
     async exists(path) {
@@ -170,4 +179,7 @@ export class NodeScriptEnvironment {
     createWriteStream(filePath) {
         return fs.createWriteStream(filePath);
     }
+    getCurrentDirectory() {
+        return process.cwd();
+    }
 }

package/dist/esm/environment/esm-environment.js

@@ -0,0 +1,17 @@
+import { config, createSVGWindow } from 'svgdom';
+import { NodeScriptEnvironment } from './environment';
+export class ESMNodeScriptEnvironment extends NodeScriptEnvironment {
+    async prepareSVGEnvironmentInternal(fontsPath) {
+        try {
+            this.globalCreateSVGWindow = createSVGWindow;
+            if (fontsPath !== null) {
+                await config.setFontDir(fontsPath)
+                    .setFontFamilyMappings(this.supportedFonts)
+                    .preloadFonts();
+            }
+        }
+        catch (error) {
+            throw new Error(`Failed to load svgdom ESM module: ${error}`);
+        }
+    }
+}

package/dist/esm/environment/helpers.js

@@ -0,0 +1,4 @@
+import { ESMNodeScriptEnvironment } from "./esm-environment";
+export function getNewEnvironment() {
+    return new ESMNodeScriptEnvironment();
+}

package/dist/esm/execute.js

@@ -7,9 +7,9 @@ import { PinId, PortSide } from './objects/PinDefinition.js';
 import { AnyReference, CFunctionEntry, DeclaredReference, Direction, ImportFunctionHandling, NetTypes } from './objects/types.js';
 import { Wire } from './objects/Wire.js';
 import { Frame } from './objects/Frame.js';
-import { CalculatePinPositions } from './layout.js';
+import { CalculatePinPositions } from './render/layout.js';
 import { UnitDimension } from './helpers.js';
-import { PlaceHolderCommands, SymbolDrawingCommands } from './draw_symbols.js';
+import { PlaceHolderCommands, SymbolDrawingCommands } from './render/draw_symbols.js';
 import { getBlockTypeString, RuntimeExecutionError } from './utils.js';
 export class ExecutionContext {
     name;
@@ -620,10 +620,36 @@ export class ExecutionContext {
         return this.scope.breakStack[this.scope.breakStack.length - 1];
     }
     createFunction(namespace, functionName, __runFunc, source, uniqueId) {
-        const functionPath = `${namespace}${functionName}`;
-        this.scope.functions.set(functionPath, new CFunctionEntry(namespace, functionName, __runFunc, source, uniqueId));
+        const functionEntry = new CFunctionEntry(namespace, functionName, __runFunc, source, uniqueId);
+        const functionPath = functionEntry.getFunctionPath();
+        if (this.scope.functions.has(functionPath)) {
+            this.log(`function: ${functionPath} already exists`);
+            const existingEntry = this.scope.functions.get(functionPath);
+            if (existingEntry.lazyLoaded) {
+                this.log(`updating lazy function: ${functionPath}`);
+                existingEntry.execute = __runFunc;
+                existingEntry.source = source;
+            }
+            else {
+                this.log(`function is already defined: ${functionName}`);
+                console.log(`WARNING: function is already defined ${functionName}`);
+            }
+        }
+        else {
+            this.scope.functions.set(functionPath, functionEntry);
+            this.log(`defined new function: ${functionPath}`);
+        }
         this.__functionCache.set(functionPath, __runFunc);
-        this.log(`defined new function: ${functionPath}`);
+        return functionEntry;
+    }
+    createFunctionLazyLoaded(namespace, functionName, uniqueId) {
+        const functionEntry = new CFunctionEntry(namespace, functionName, null, null, uniqueId);
+        const functionPath = functionEntry.getFunctionPath();
+        functionEntry.lazyLoaded = true;
+        this.scope.functions.set(functionPath, functionEntry);
+        this.__functionCache.set(functionPath, null);
+        this.log(`defined new function with lazy flag: ${functionPath}`);
+        return functionEntry;
     }
     hasFunction(functionName) {
         return this.scope.functions.has(functionName);
@@ -653,11 +679,11 @@ export class ExecutionContext {
                             && library.specifiedImports.indexOf(idName) !== -1)) {
                         const { context: libraryContext } = library;
                         const functionPath = `${libraryContext.namespace}${idName}`;
-                        if (library.context.hasFunction(functionPath)) {
+                        if (libraryContext.hasFunction(functionPath)) {
                             return new DeclaredReference({
                                 found: true,
                                 rootValue: library,
-                                value: library.context.getFunction(functionPath),
+                                value: libraryContext.getFunction(functionPath),
                                 type: ReferenceTypes.function,
                                 name: idName,
                                 trailerIndex: 1,
@@ -764,7 +790,14 @@ export class ExecutionContext {
     }
     callFunction(functionReference, functionParams, executionStack, netNamespace) {
         const functionEntry = functionReference.value;
-        const { name: functionName, execute: __runFunc } = functionEntry;
+        const { name: functionName } = functionEntry;
+        let { execute: __runFunc } = functionEntry;
+        if (__runFunc === null && functionEntry.lazyLoaded) {
+            this.log(`load lazy function: ${functionEntry.getFunctionPath()}`);
+            functionEntry.lazyLoader !== null && functionEntry.lazyLoader();
+            this.log(`done loading lazy function: ${functionEntry.getFunctionPath()}, replacing execute method`);
+            __runFunc = functionEntry.execute;
+        }
         if (__runFunc !== null) {
             let functionCallIndex = -1;
             if (!this.scope.functionCounter.has(__runFunc)) {
@@ -946,7 +979,7 @@ export class ExecutionContext {
                 [numeric(1), numeric(0), numeric(0),
                     numeric(0), numeric(0)],
                 new Map([
-                    ["display_pin_id", false]
+                    ["display_id", false]
                 ]),
                 null
             ]
@@ -1082,8 +1115,9 @@ export class ExecutionContext {
                 if (targetAngle === null) {
                     return;
                 }
-                this.log('set component unit angle from wire, target angle:', targetAngle, ', component unit angle:', targetUnit.angleProp, 'pin angle:', connectedPinPos.angle);
-                let useAngle = (targetAngle - connectedPinPos.angle.toNumber()) % 360;
+                const pinAngle = connectedPinPos.angle.toNumber();
+                this.log('set component unit angle from wire, target angle:', targetAngle, ', component unit angle:', targetUnit.angleProp, 'pin angle:', pinAngle);
+                let useAngle = (targetAngle - pinAngle) % 360;
                 if (useAngle < 0) {
                     useAngle += 360;
                 }
@@ -1091,12 +1125,12 @@ export class ExecutionContext {
                     targetUnit.setParam(ParamKeys.angle, numeric(90));
                 }
                 else if (useAngle === 180) {
-                    if (targetUnit.angleProp === 0 || targetUnit.angleProp === 180) {
-                        targetUnit.setParam(ParamKeys.flipX, numeric(1));
-                    }
-                    else if (targetUnit.angleProp === 90 || targetUnit.angleProp === 270) {
+                    if (pinAngle == 90 || pinAngle == 270) {
                         targetUnit.setParam(ParamKeys.flipY, numeric(1));
                     }
+                    else if (pinAngle == 0 || pinAngle == 180) {
+                        targetUnit.setParam(ParamKeys.flipX, numeric(1));
+                    }
                 }
                 else if (useAngle === 270) {
                     targetUnit.setParam(ParamKeys.angle, numeric(270));

package/dist/esm/globals.js

@@ -1,4 +1,5 @@
 import { numeric } from "./objects/ParamDefinition.js";
+import { PinTypes } from "./objects/PinTypes.js";
 export const TOOL_VERSION = '0.1.5';
 export const Delimiter1 = '-';
 export const DoubleDelimiter1 = `${Delimiter1}${Delimiter1}`;
@@ -131,3 +132,10 @@ export const RenderFlags = {
 export const SymbolValidatorContext = '_sym';
 export const TrailerArrayIndex = 'index';
 export const DefaultComponentUnit = '__default';
+export const PinTypesList = [
+    PinTypes.Any,
+    PinTypes.Input,
+    PinTypes.Output,
+    PinTypes.IO,
+    PinTypes.Power,
+];