circuitscript 0.1.19 → 0.1.22

package/dist/cjs/environment.js

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

package/dist/cjs/execute.js

@@ -24,6 +24,7 @@ class ExecutionContext {
         this.__functionCache = new Map();
         this.componentAngleFollowsWire = true;
         this.warnings = [];
+        this.indexedStack = new Map();
         this.name = name;
         this.namespace = namespace;
         this.netNamespace = netNamespace;
@@ -542,9 +543,39 @@ 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');
@@ -667,9 +698,18 @@ 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;
         }
@@ -682,6 +722,7 @@ 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;
@@ -694,6 +735,7 @@ 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 => {
@@ -767,6 +809,7 @@ class ExecutionContext {
             return accum;
         }, []);
         this.log('-- done merging scope --');
+        return mergedInstances;
     }
     addWire(segments) {
         if (this.scope.currentComponent === null) {
@@ -890,7 +933,7 @@ 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/cjs/graph.js

@@ -51,6 +51,7 @@ class NetGraph {
         const baseFrame = new layout_js_1.RenderFrame(new Frame_js_1.Frame(Frame_js_1.FixedFrameIds.BaseFrame));
         const frameStack = [baseFrame];
         const containerFrames = [baseFrame];
+        const nodeFrames = new Map();
         sequence.forEach((sequenceStep, index) => {
             const action = sequenceStep[0];
             let tmpComponent;
@@ -60,6 +61,10 @@ class NetGraph {
                     this.print(...sequenceStep);
                     const [, component, pin] = sequenceStep;
                     const tmpInstanceName = component.instanceName;
+                    if (action === ExecutionScope_js_1.SequenceAction.At) {
+                        previousNode = null;
+                        previousPin = null;
+                    }
                     if (!graph.hasNode(tmpInstanceName)) {
                         this.print('create instance', tmpInstanceName);
                         const { displayProp = null } = component;
@@ -83,8 +88,15 @@ class NetGraph {
                         tmpComponent = new layout_js_1.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 === ExecutionScope_js_1.SequenceAction.To && previousNode && previousPin) {
                         this.setGraphEdge(graph, previousNode, tmpInstanceName, makeEdgeValue(previousNode, previousPin, tmpInstanceName, pin, index));
@@ -116,6 +128,7 @@ 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;
@@ -132,6 +145,14 @@ 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(ExecutionScope_js_1.SequenceAction.Wire, wireId, JSON.stringify(wireSegmentsInfo));
                     break;
                 }

package/dist/cjs/helpers.js

@@ -24,6 +24,7 @@ const Frame_js_1 = require("./objects/Frame.js");
 const big_js_1 = __importDefault(require("big.js"));
 const logger_js_1 = require("./logger.js");
 const graph_js_1 = require("./graph.js");
+const RefdesAnnotationVisitor_js_1 = require("./RefdesAnnotationVisitor.js");
 var JSModuleType;
 (function (JSModuleType) {
     JSModuleType["CommonJs"] = "cjs";
@@ -165,7 +166,7 @@ async function renderScript(scriptData, outputPath, options) {
 }
 exports.renderScript = renderScript;
 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 utils_js_1.RuntimeExecutionError) {
@@ -209,7 +210,7 @@ async function renderScriptCustom(scriptData, outputPath, options, parseHandlers
             (0, fs_1.mkdirSync)(dumpDirectory);
         }
     }
-    const { tree, parser, parserTimeTaken, lexerTimeTaken, throwError } = await (0, parser_js_1.parseFileWithVisitor)(visitor, scriptData);
+    const { tree, parser, tokens, parserTimeTaken, lexerTimeTaken, throwError } = await (0, parser_js_1.parseFileWithVisitor)(visitor, scriptData);
     (0, utils_js_1.printWarnings)(visitor.getWarnings());
     showStats && console.log('Lexing took:', lexerTimeTaken);
     showStats && console.log('Parsing took:', parserTimeTaken);
@@ -219,6 +220,22 @@ async function renderScriptCustom(scriptData, outputPath, options, parseHandlers
     catch (err) {
         throw new utils_js_1.RenderError(`Error during component annotation: ${err}`, 'annotation');
     }
+    const componentLinks = visitor.getComponentCtxLinks();
+    const refdesVisitor = new RefdesAnnotationVisitor_js_1.RefdesAnnotationVisitor(true, scriptData, tokens, componentLinks);
+    await refdesVisitor.visitAsync(tree);
+    if (inputPath && (updateSource || saveAnnotatedCopy !== undefined)) {
+        let usePath = inputPath;
+        if (saveAnnotatedCopy === true) {
+            const dir = path_1.default.dirname(inputPath);
+            const ext = path_1.default.extname(inputPath);
+            const basename = path_1.default.basename(inputPath, ext);
+            usePath = path_1.default.join(dir, `${basename}.annotated${ext}`);
+        }
+        else if (typeof saveAnnotatedCopy === 'string') {
+            usePath = saveAnnotatedCopy;
+        }
+        (0, fs_1.writeFileSync)(usePath, refdesVisitor.getOutput());
+    }
     if (dumpNets) {
         const nets = visitor.dumpNets();
         nets.forEach(item => console.log(item.join(" | ")));
@@ -343,9 +360,9 @@ exports.ParseOutputHandler = ParseOutputHandler;
 class KiCadNetListOutputHandler extends ParseOutputHandler {
     constructor() {
         super(...arguments);
-        this.beforeRender = true;
+        this.afterRender = true;
     }
-    parse(visitor, outputPath, fileExtension) {
+    parse(visitor, outputPath, fileExtension, extra = null) {
         if (outputPath !== null && fileExtension === "net") {
             const { tree: kiCadNetList, missingFootprints } = (0, export_js_1.generateKiCadNetList)(visitor.getNetList());
             missingFootprints.forEach(entry => {

package/dist/cjs/layout.js

@@ -1241,6 +1241,8 @@ class RenderFrame extends RenderObject {
         this.containsTitle = false;
         this.frame = frame;
         this.renderType = type;
+        this.frameId = RenderFrame.FrameIdCounter;
+        RenderFrame.FrameIdCounter++;
     }
     toString() {
         let name = "";
@@ -1255,6 +1257,7 @@ class RenderFrame extends RenderObject {
     }
 }
 exports.RenderFrame = RenderFrame;
+RenderFrame.FrameIdCounter = 0;
 var RenderFrameType;
 (function (RenderFrameType) {
     RenderFrameType[RenderFrameType["Container"] = 1] = "Container";

package/dist/cjs/lexer.js

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

package/dist/cjs/main.js

@@ -20,6 +20,8 @@ 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')
@@ -67,11 +69,22 @@ 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/cjs/objects/ClassComponent.js

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

package/dist/cjs/objects/ExecutionScope.js

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

package/dist/cjs/parser.js

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