circuitscript 0.1.19 → 0.1.22

package/dist/esm/antlr/CircuitScriptVisitor.js

@@ -22,6 +22,7 @@ export class CircuitScriptVisitor extends AbstractParseTreeVisitor {
     visitAt_to_multiple_line_expr_to_pin;
     visitAt_block;
     visitAt_block_expressions;
+    visitAt_block_header;
     visitAt_block_pin_expr;
     visitAt_block_pin_expression_simple;
     visitAt_block_pin_expression_complex;
@@ -78,4 +79,5 @@ export class CircuitScriptVisitor extends AbstractParseTreeVisitor {
     visitElse_expr;
     visitWhile_expr;
     visitFor_expr;
+    visitAnnotation_comment_expr;
 }

package/dist/esm/environment.js

@@ -14,6 +14,7 @@ export class NodeScriptEnvironment {
     useModuleDirectoryPath = null;
     useDefaultLibsPath = null;
     globalCreateSVGWindow = null;
+    cachedVersion = null;
     supportedFonts = {
         'Arial': 'Arial.ttf',
     };
@@ -24,7 +25,20 @@ export class NodeScriptEnvironment {
         this.useDefaultLibsPath = path;
     }
     getPackageVersion() {
-        return TOOL_VERSION;
+        if (this.cachedVersion !== null) {
+            return this.cachedVersion;
+        }
+        try {
+            const packageJsonPath = path.join(this.getToolsPath(), '../', 'package.json');
+            const packageJsonContent = fs.readFileSync(packageJsonPath, 'utf-8');
+            const packageJson = JSON.parse(packageJsonContent);
+            this.cachedVersion = packageJson.version || TOOL_VERSION;
+            return this.cachedVersion;
+        }
+        catch (error) {
+            console.warn('Failed to read version from package.json, using fallback version:', error);
+            return TOOL_VERSION;
+        }
     }
     getModuleDirectory() {
         if (this.useModuleDirectoryPath !== null) {

package/dist/esm/execute.js

@@ -28,6 +28,7 @@ export class ExecutionContext {
     parentContext;
     componentAngleFollowsWire = true;
     warnings = [];
+    indexedStack = new Map();
     constructor(name, namespace, netNamespace, executionLevel = 0, scopeLevel = 0, silent = false, logger, warnings, parent) {
         this.name = name;
         this.namespace = namespace;
@@ -547,9 +548,39 @@ export class ExecutionContext {
         this.log('did not find block point');
         return null;
     }
+    getParentBreakContext() {
+        if (this.scope.breakStack.length > 0) {
+            return this.scope.breakStack[this.scope.breakStack.length - 1];
+        }
+        return null;
+    }
     addBreakContext(ctx) {
         this.log('add break context');
         this.scope.breakStack.push(ctx);
+        this.indexedStack.set(ctx, {
+            index: 0,
+            funcCallIndex: new Map(),
+        });
+    }
+    setBreakContextIndex(index) {
+        const latestCtx = this.scope.breakStack[this.scope.breakStack.length - 1];
+        if (latestCtx) {
+            const current = this.indexedStack.get(latestCtx);
+            this.indexedStack.set(latestCtx, {
+                ...current,
+                index,
+            });
+        }
+    }
+    resetBreakContextFunctionCalls() {
+        const latestCtx = this.scope.breakStack[this.scope.breakStack.length - 1];
+        if (latestCtx) {
+            const current = this.indexedStack.get(latestCtx);
+            this.indexedStack.set(latestCtx, {
+                index: current.index,
+                funcCallIndex: new Map(),
+            });
+        }
     }
     popBreakContext() {
         this.log('pop break context');
@@ -672,9 +703,18 @@ export class ExecutionContext {
             __runFunc = this.__functionCache.get(functionName);
         }
         if (__runFunc !== null) {
+            let functionCallIndex = -1;
+            if (!this.scope.functionCounter.has(__runFunc)) {
+                this.scope.functionCounter.set(__runFunc, 0);
+                functionCallIndex = 0;
+            }
+            else {
+                functionCallIndex = this.scope.functionCounter.get(__runFunc);
+            }
+            this.scope.functionCounter.set(__runFunc, functionCallIndex + 1);
             this.log(`call function '${functionName}'`);
             this.log(`net namespace: ${netNamespace}`);
-            const functionResult = __runFunc(functionParams, { netNamespace });
+            const functionResult = __runFunc(functionParams, { netNamespace, functionCallIndex });
             this.log(`done call function '${functionName}'`);
             return functionResult;
         }
@@ -687,6 +727,7 @@ export class ExecutionContext {
         const { currentComponent, currentPin, currentWireId } = this.scope;
         const tmpInstances = childScope.instances;
         const tmpNets = childScope.getNets();
+        const mergedInstances = [];
         for (const [instanceName, component] of tmpInstances) {
             const newInstanceName = `${namespace}.${instanceName}`;
             component.instanceName = newInstanceName;
@@ -699,6 +740,7 @@ export class ExecutionContext {
             else {
                 throw "Invalid instance name to merge into parent scope!";
             }
+            mergedInstances.push(component);
         }
         const childScopeUniqueNets = new Set(tmpNets.map(([, , net]) => net));
         childScopeUniqueNets.forEach(net => {
@@ -772,6 +814,7 @@ export class ExecutionContext {
             return accum;
         }, []);
         this.log('-- done merging scope --');
+        return mergedInstances;
     }
     addWire(segments) {
         if (this.scope.currentComponent === null) {
@@ -895,7 +938,7 @@ export class ExecutionContext {
             idName = this.scope.currentComponent.instanceName;
             if (this.scope.instances.has(idName)) {
                 const component = this.scope.instances.get(idName);
-                component.parameters.set(paramName, value);
+                component.setParam(paramName, value);
             }
             else if (this.scope.variables.has(idName)) {
                 throw "Not implemented yet!";

package/dist/esm/graph.js

@@ -26,6 +26,7 @@ export class NetGraph {
         const baseFrame = new RenderFrame(new Frame(FixedFrameIds.BaseFrame));
         const frameStack = [baseFrame];
         const containerFrames = [baseFrame];
+        const nodeFrames = new Map();
         sequence.forEach((sequenceStep, index) => {
             const action = sequenceStep[0];
             let tmpComponent;
@@ -35,6 +36,10 @@ export class NetGraph {
                     this.print(...sequenceStep);
                     const [, component, pin] = sequenceStep;
                     const tmpInstanceName = component.instanceName;
+                    if (action === SequenceAction.At) {
+                        previousNode = null;
+                        previousPin = null;
+                    }
                     if (!graph.hasNode(tmpInstanceName)) {
                         this.print('create instance', tmpInstanceName);
                         const { displayProp = null } = component;
@@ -58,8 +63,15 @@ export class NetGraph {
                         tmpComponent = new RenderComponent(component, useWidth, useHeight);
                         tmpComponent.symbol = tmpSymbol;
                         graph.setNode(tmpInstanceName, [RenderItemType.Component, tmpComponent, index]);
-                        const currentFrame = frameStack[frameStack.length - 1];
-                        currentFrame && currentFrame.innerItems.push(tmpComponent);
+                        let useFrame = frameStack[frameStack.length - 1];
+                        if (nodeFrames.has(previousNode)) {
+                            const previousNodeFrame = nodeFrames.get(previousNode);
+                            if (previousNodeFrame !== useFrame) {
+                                useFrame = previousNodeFrame;
+                            }
+                        }
+                        useFrame && useFrame.innerItems.push(tmpComponent);
+                        nodeFrames.set(tmpInstanceName, useFrame);
                     }
                     if (action === SequenceAction.To && previousNode && previousPin) {
                         this.setGraphEdge(graph, previousNode, tmpInstanceName, makeEdgeValue(previousNode, previousPin, tmpInstanceName, pin, index));
@@ -91,6 +103,7 @@ export class NetGraph {
                     wire.netName = useNet.toString();
                     const wireName = getWireName(wire.id);
                     graph.setNode(wireName, [RenderItemType.Wire, wire, index]);
+                    let tmpPreviousNode = previousNode;
                     this.setGraphEdge(graph, previousNode, wireName, makeEdgeValue(previousNode, previousPin, wireName, 0, index));
                     previousNode = wireName;
                     previousPin = 1;
@@ -107,6 +120,14 @@ export class NetGraph {
                         }
                         return tmp;
                     });
+                    let useFrame = frameStack[frameStack.length - 1];
+                    if (nodeFrames.has(tmpPreviousNode)) {
+                        const previousNodeFrame = nodeFrames.get(tmpPreviousNode);
+                        if (previousNodeFrame !== useFrame) {
+                            useFrame = previousNodeFrame;
+                        }
+                    }
+                    nodeFrames.set(wireName, useFrame);
                     this.print(SequenceAction.Wire, wireId, JSON.stringify(wireSegmentsInfo));
                     break;
                 }

package/dist/esm/helpers.js

@@ -18,6 +18,7 @@ import { FrameParamKeys } from "./objects/Frame.js";
 import Big from "big.js";
 import { Logger } from "./logger.js";
 import { NetGraph } from "./graph.js";
+import { RefdesAnnotationVisitor } from "./RefdesAnnotationVisitor.js";
 export var JSModuleType;
 (function (JSModuleType) {
     JSModuleType["CommonJs"] = "cjs";
@@ -154,7 +155,7 @@ export async function renderScript(scriptData, outputPath, options) {
     return renderScriptCustom(scriptData, outputPath, options, parseHandlers);
 }
 export async function renderScriptCustom(scriptData, outputPath, options, parseHandlers) {
-    const { dumpNets = false, dumpData = false, showStats = false, environment } = options;
+    const { dumpNets = false, dumpData = false, showStats = false, environment, inputPath = null, updateSource = false, saveAnnotatedCopy = undefined, } = options;
     const errors = [];
     const onErrorHandler = (message, context, error) => {
         if (error && error instanceof RuntimeExecutionError) {
@@ -198,7 +199,7 @@ export async function renderScriptCustom(scriptData, outputPath, options, parseH
             mkdirSync(dumpDirectory);
         }
     }
-    const { tree, parser, parserTimeTaken, lexerTimeTaken, throwError } = await parseFileWithVisitor(visitor, scriptData);
+    const { tree, parser, tokens, parserTimeTaken, lexerTimeTaken, throwError } = await parseFileWithVisitor(visitor, scriptData);
     printWarnings(visitor.getWarnings());
     showStats && console.log('Lexing took:', lexerTimeTaken);
     showStats && console.log('Parsing took:', parserTimeTaken);
@@ -208,6 +209,22 @@ export async function renderScriptCustom(scriptData, outputPath, options, parseH
     catch (err) {
         throw new RenderError(`Error during component annotation: ${err}`, 'annotation');
     }
+    const componentLinks = visitor.getComponentCtxLinks();
+    const refdesVisitor = new RefdesAnnotationVisitor(true, scriptData, tokens, componentLinks);
+    await refdesVisitor.visitAsync(tree);
+    if (inputPath && (updateSource || saveAnnotatedCopy !== undefined)) {
+        let usePath = inputPath;
+        if (saveAnnotatedCopy === true) {
+            const dir = path.dirname(inputPath);
+            const ext = path.extname(inputPath);
+            const basename = path.basename(inputPath, ext);
+            usePath = path.join(dir, `${basename}.annotated${ext}`);
+        }
+        else if (typeof saveAnnotatedCopy === 'string') {
+            usePath = saveAnnotatedCopy;
+        }
+        writeFileSync(usePath, refdesVisitor.getOutput());
+    }
     if (dumpNets) {
         const nets = visitor.dumpNets();
         nets.forEach(item => console.log(item.join(" | ")));
@@ -326,8 +343,8 @@ export class ParseOutputHandler {
     afterRender = false;
 }
 export class KiCadNetListOutputHandler extends ParseOutputHandler {
-    beforeRender = true;
-    parse(visitor, outputPath, fileExtension) {
+    afterRender = true;
+    parse(visitor, outputPath, fileExtension, extra = null) {
         if (outputPath !== null && fileExtension === "net") {
             const { tree: kiCadNetList, missingFootprints } = generateKiCadNetList(visitor.getNetList());
             missingFootprints.forEach(entry => {

package/dist/esm/layout.js

@@ -1219,6 +1219,7 @@ export class RenderText extends RenderObject {
     }
 }
 export class RenderFrame extends RenderObject {
+    static FrameIdCounter = 0;
     bounds = null;
     frame;
     innerItems = [];
@@ -1233,10 +1234,13 @@ export class RenderFrame extends RenderObject {
     subgraphId = "";
     renderType;
     containsTitle = false;
+    frameId;
     constructor(frame, type = RenderFrameType.Container) {
         super();
         this.frame = frame;
         this.renderType = type;
+        this.frameId = RenderFrame.FrameIdCounter;
+        RenderFrame.FrameIdCounter++;
     }
     toString() {
         let name = "";

package/dist/esm/lexer.js

@@ -26,12 +26,14 @@ export class MainLexer extends CircuitScriptLexer {
             this.tokens = this.tokens.filter(function (val) {
                 return val.type !== CircuitScriptParser.EOF;
             });
-            this.emitToken(this.commonToken(CircuitScriptParser.NEWLINE, "\n"));
+            const fillerNewLine = this.commonToken(CircuitScriptParser.NEWLINE, "");
+            this.emitToken(fillerNewLine);
+            fillerNewLine.__skip = true;
             while (this.indents.length) {
                 this.emitToken(this.createDedent());
                 this.indents.pop();
             }
-            this.emitToken(this.commonToken(CircuitScriptParser.EOF, "<EOF>"));
+            this.emitToken(this.commonToken(CircuitScriptParser.EOF, ""));
         }
         const next = super.nextToken();
         return this.tokens.length ? this.tokens.shift() : next;
@@ -42,16 +44,24 @@ export class MainLexer extends CircuitScriptLexer {
     getCharIndex() {
         return this.inputStream.index;
     }
-    commonToken(type, text) {
-        const stop = this.getCharIndex() - 1;
-        const start = text.length ? stop - text.length + 1 : stop;
+    commonToken(type, text, start = -1, stop = -1) {
+        if (start === -1 && stop === -1) {
+            stop = this.getCharIndex() - 1;
+            start = text.length ? stop - text.length + 1 : stop;
+        }
         const token = CommonToken.fromSource([this, this.inputStream], type, 0, start, stop);
         let tokenTypeString = null;
         if (type === CircuitScriptParser.INDENT) {
-            tokenTypeString = "indent";
+            tokenTypeString = 'indent';
         }
         else if (type === CircuitScriptParser.DEDENT) {
-            tokenTypeString = "dedent";
+            tokenTypeString = 'dedent';
+        }
+        else if (type === CircuitScriptParser.NEWLINE) {
+            tokenTypeString = 'newline';
+        }
+        else if (type === CircuitScriptParser.EOF) {
+            tokenTypeString = 'EOF';
         }
         if (tokenTypeString !== null) {
             token.text = tokenTypeString;
@@ -89,7 +99,9 @@ export class MainLexer extends CircuitScriptLexer {
             this.skip();
         }
         else {
-            this.emitToken(this.commonToken(CircuitScriptParser.NEWLINE, newLine));
+            const start = this.getCharIndex() - this.text.length;
+            const stop = this.getCharIndex() - 1;
+            this.emitToken(this.commonToken(CircuitScriptParser.NEWLINE, newLine, start, start));
             const indent = this.getIndentationCount(spaces);
             const previous = this.indents.length ? this.indents[this.indents.length - 1] : 0;
             if (indent === previous) {
@@ -97,7 +109,7 @@ export class MainLexer extends CircuitScriptLexer {
             }
             else if (indent > previous) {
                 this.indents.push(indent);
-                this.emitToken(this.commonToken(CircuitScriptParser.INDENT, spaces));
+                this.emitToken(this.commonToken(CircuitScriptParser.INDENT, spaces, start + 1, stop));
             }
             else {
                 while (this.indents.length && this.indents[this.indents.length - 1] > indent) {

package/dist/esm/main.js

@@ -15,6 +15,8 @@ export default async function main() {
         .argument('[output path]', 'Output path')
         .option('-i, --input text <input text>', 'Input text directly')
         .option('-c, --current-directory <path>', 'Set current directory')
+        .option('-u, --update-source', 'Update source file with refdes annotation')
+        .option('-j, --annotated-path [file-path]', 'Save annotated source file at given path')
         .option('-w, --watch', 'Watch for file changes')
         .option('-n, --dump-nets', 'Dump out net information')
         .option('-d, --dump-data', 'Dump data during parsing')
@@ -62,11 +64,22 @@ export default async function main() {
         console.error("Error: No input provided");
         return;
     }
+    let updateSource = false;
+    if (options.updateSource !== undefined) {
+        updateSource = options.updateSource;
+    }
+    let saveAnnotatedCopyPath = undefined;
+    if (options.annotatedPath !== undefined) {
+        saveAnnotatedCopyPath = options.annotatedPath;
+    }
     const scriptOptions = {
         dumpNets,
         dumpData,
         showStats: options.stats,
         environment: env,
+        inputPath: inputFilePath,
+        updateSource,
+        saveAnnotatedCopy: saveAnnotatedCopyPath,
     };
     let outputPath = null;
     if (args.length > 0 && args[1]) {

package/dist/esm/objects/ClassComponent.js

@@ -29,6 +29,9 @@ export class ClassComponent {
     useWireOrientationAngle = true;
     didSetWireOrientationAngle = false;
     assignedRefDes = null;
+    placeHolderRefDes = null;
+    ctxReferences = [];
+    _creationIndex = -1;
     constructor(instanceName, numPins) {
         this.instanceName = instanceName;
         this.numPins = numPins;
@@ -108,7 +111,7 @@ export class ClassComponent {
             return this.parameters.get(key);
         }
         else {
-            throw 'Invalid parameter key';
+            throw 'Invalid parameter key: ' + key;
         }
     }
     toString() {

package/dist/esm/objects/ExecutionScope.js

@@ -6,6 +6,7 @@ export class ExecutionScope {
     nets = [];
     instances = new Map();
     functions = new Map();
+    functionCounter = new Map();
     variables = new Map();
     symbols = new Map();
     blockStack = new Map();

package/dist/esm/parser.js

@@ -35,6 +35,7 @@ export async function parseFileWithVisitor(visitor, data) {
     const parserTimeTaken = parserTimer.lap();
     return {
         tree, parser,
+        tokens,
         hasParseError: false,
         hasError: false,
         parserTimeTaken,