circuitscript 0.1.20 → 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/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/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,

package/dist/cjs/visitor.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.VisitorExecutionException = exports.ParserVisitor = void 0;
+exports.VisitorExecutionException = exports.ComponentRefDesPrefixes = exports.ParserVisitor = void 0;
 const ClassComponent_js_1 = require("./objects/ClassComponent.js");
 const ParamDefinition_js_1 = require("./objects/ParamDefinition.js");
 const PinDefinition_js_1 = require("./objects/PinDefinition.js");
@@ -13,9 +13,11 @@ const BaseVisitor_js_1 = require("./BaseVisitor.js");
 const utils_js_2 = require("./utils.js");
 const helpers_js_1 = require("./helpers.js");
 const Frame_js_1 = require("./objects/Frame.js");
+const ComponentAnnotater_js_1 = require("./ComponentAnnotater.js");
 class ParserVisitor extends BaseVisitor_js_1.BaseVisitor {
     constructor() {
         super(...arguments);
+        this.componentCreationIndex = 0;
         this.visitKeyword_assignment_expr = (ctx) => {
             const id = ctx.ID().getText();
             const value = this.visitResult(ctx.data_expr());
@@ -40,28 +42,53 @@ class ParserVisitor extends BaseVisitor_js_1.BaseVisitor {
             }
             this.setResult(ctx, pinId);
         };
+        this.trackNewComponentCreated = (callback) => {
+            const preCreatedIndex = this.componentCreationIndex;
+            callback();
+            const postCreatedIndex = this.componentCreationIndex;
+            let creationFlag = false;
+            if (postCreatedIndex > preCreatedIndex) {
+                creationFlag = true;
+            }
+            return creationFlag;
+        };
         this.visitAdd_component_expr = (ctx) => {
-            const [component, pinValue] = this.visitResult(ctx.data_expr_with_assignment());
-            this.getExecutor().addComponentExisting(component, pinValue);
+            let refComponent;
+            const creationFlag = this.trackNewComponentCreated(() => {
+                const [component, pinValue] = this.visitResult(ctx.data_expr_with_assignment());
+                this.getExecutor().addComponentExisting(component, pinValue);
+                refComponent = component;
+            });
+            this.linkComponentToCtx(ctx, refComponent, creationFlag);
         };
         this.visitAt_component_expr = (ctx) => {
-            const [component, pin] = this.visitResult(ctx.component_select_expr());
-            this.getExecutor().atComponent(component, pin, {
-                addSequence: true
+            let refComponent;
+            const creationFlag = this.trackNewComponentCreated(() => {
+                const [component, pin] = this.visitResult(ctx.component_select_expr());
+                this.getExecutor().atComponent(component, pin, {
+                    addSequence: true
+                });
+                refComponent = component;
             });
+            this.linkComponentToCtx(ctx, refComponent, creationFlag);
             return this.getExecutor().getCurrentPoint();
         };
         this.visitTo_component_expr = (ctx) => {
             ctx.component_select_expr().forEach(item => {
-                const [component, pin] = this.visitResult(item);
-                try {
-                    this.getExecutor().toComponent(component, pin, {
-                        addSequence: true
-                    });
-                }
-                catch (err) {
-                    throw new utils_js_2.RuntimeExecutionError(err.message, ctx);
-                }
+                let refComponent;
+                const creationFlag = this.trackNewComponentCreated(() => {
+                    const [component, pin] = this.visitResult(item);
+                    try {
+                        this.getExecutor().toComponent(component, pin, {
+                            addSequence: true
+                        });
+                        refComponent = component;
+                    }
+                    catch (err) {
+                        throw new utils_js_2.RuntimeExecutionError(err.message, ctx);
+                    }
+                });
+                this.linkComponentToCtx(item, refComponent, creationFlag);
             });
             return this.getExecutor().getCurrentPoint();
         };
@@ -332,6 +359,7 @@ class ParserVisitor extends BaseVisitor_js_1.BaseVisitor {
             try {
                 const createdComponent = this.getExecutor().createComponent(instanceName, pins, params, props);
                 this.setResult(ctx, createdComponent);
+                createdComponent._creationIndex = this.componentCreationIndex++;
             }
             catch (error) {
                 this.throwWithContext(ctx, error.message);
@@ -822,7 +850,28 @@ class ParserVisitor extends BaseVisitor_js_1.BaseVisitor {
             const resolveNet = this.createNetResolver(this.executionStack);
             const resolveComponentPinNet = this.createComponentPinNetResolver(this.executionStack);
             const __runFunc = (passedInParameters, options) => {
-                const executionContextName = `${functionName}-${functionCounter['counter']}`;
+                const executor = this.getExecutor();
+                const parentBreakContext = executor.getParentBreakContext();
+                executor.addBreakContext(ctx);
+                let useIndex = -1;
+                if (parentBreakContext === null) {
+                    useIndex = options.functionCallIndex;
+                }
+                else {
+                    const parentEntry = executor.indexedStack.get(parentBreakContext);
+                    const { funcCallIndex } = parentEntry;
+                    if (!funcCallIndex.has(ctx)) {
+                        funcCallIndex.set(ctx, 0);
+                        useIndex = 0;
+                    }
+                    else {
+                        useIndex = funcCallIndex.get(ctx) + 1;
+                        funcCallIndex.set(ctx, useIndex);
+                    }
+                }
+                executor.setBreakContextIndex(useIndex);
+                const functionCounterIndex = functionCounter['counter'];
+                const executionContextName = `${functionName}-${functionCounterIndex}`;
                 const newExecutor = this.enterNewChildContext(executionStack, this.getExecutor(), executionContextName, options, funcDefinedParameters, passedInParameters);
                 functionCounter['counter'] += 1;
                 newExecutor.resolveNet = resolveNet;
@@ -830,7 +879,23 @@ class ParserVisitor extends BaseVisitor_js_1.BaseVisitor {
                 const returnValue = this.runExpressions(newExecutor, ctx.function_expr());
                 const lastExecution = executionStack.pop();
                 const nextLastExecution = executionStack[executionStack.length - 1];
-                nextLastExecution.mergeScope(lastExecution.scope, executionContextName);
+                const mergedComponents = nextLastExecution.mergeScope(lastExecution.scope, executionContextName);
+                const scope = this.getScope();
+                const indexedStack = [];
+                if (scope.breakStack.length > 0) {
+                    const executor = this.getExecutor();
+                    scope.breakStack.forEach(stackCtx => {
+                        const entry = executor.indexedStack.get(stackCtx);
+                        const { index } = entry;
+                        indexedStack.push([stackCtx, index]);
+                    });
+                    mergedComponents.forEach(component => {
+                        component.ctxReferences.forEach(ref => {
+                            ref.indexedStack = [...indexedStack, ...ref.indexedStack];
+                        });
+                    });
+                }
+                executor.popBreakContext();
                 return [lastExecution, returnValue];
             };
             this.getExecutor().createFunction(functionName, __runFunc, ctx, uniqueFunctionID);
@@ -874,10 +939,18 @@ class ParserVisitor extends BaseVisitor_js_1.BaseVisitor {
             executor.log('end at block pin expressions');
             executor.atComponent(currentComponent, currentPin);
         };
+        this.visitAt_block_header = (ctx) => {
+            const ctxAtComponent = ctx.at_component_expr();
+            this.visit(ctxAtComponent);
+            const [currentComponent,] = this.getExecutor().getCurrentPoint();
+            this.componentCtxLinks.delete(ctxAtComponent);
+            this.componentCtxLinks.set(ctx, currentComponent);
+        };
         this.visitAt_block = (ctx) => {
             const executor = this.getExecutor();
             executor.log('entering at block');
-            this.visit(ctx.at_component_expr());
+            const ctxAtBlockComponent = ctx.at_block_header();
+            this.visit(ctxAtBlockComponent);
             const [currentComponent, currentPin] = executor.getCurrentPoint();
             executor.scope.scopeLevel += 1;
             ctx.at_block_expressions().forEach(expression => {
@@ -1037,10 +1110,14 @@ class ParserVisitor extends BaseVisitor_js_1.BaseVisitor {
             const dataExpr = ctx.data_expr();
             let keepLooping = true;
             this.log('enter while loop');
-            this.getExecutor().addBreakContext(ctx);
+            const executor = this.getExecutor();
+            executor.addBreakContext(ctx);
+            let counter = 0;
             while (keepLooping) {
                 const result = this.visitResult(dataExpr);
                 if (result) {
+                    executor.setBreakContextIndex(counter);
+                    executor.resetBreakContextFunctionCalls();
                     this.visit(ctx.expressions_block());
                     keepLooping = true;
                     const currentResult = this.getResult(ctx) ?? {};
@@ -1055,6 +1132,7 @@ class ParserVisitor extends BaseVisitor_js_1.BaseVisitor {
                             continueSignal: false
                         });
                     }
+                    counter++;
                 }
                 else {
                     keepLooping = false;
@@ -1068,7 +1146,8 @@ class ParserVisitor extends BaseVisitor_js_1.BaseVisitor {
             const forVariableNames = ctx.ID().map(item => item.getText());
             let listItems = this.visitResult(ctx.data_expr());
             listItems = (0, utils_js_1.unwrapValue)(listItems);
-            this.getExecutor().addBreakContext(ctx);
+            const executor = this.getExecutor();
+            executor.addBreakContext(ctx);
             let keepLooping = true;
             let counter = 0;
             while (keepLooping) {
@@ -1080,6 +1159,8 @@ class ParserVisitor extends BaseVisitor_js_1.BaseVisitor {
                     useValueArray.forEach((value, index) => {
                         this.getScope().setVariable(forVariableNames[index], value);
                     });
+                    executor.setBreakContextIndex(counter);
+                    executor.resetBreakContextFunctionCalls();
                     this.visit(ctx.expressions_block());
                     keepLooping = true;
                     const currentResult = this.getResult(ctx) ?? {};
@@ -1101,7 +1182,19 @@ class ParserVisitor extends BaseVisitor_js_1.BaseVisitor {
                     keepLooping = false;
                 }
             }
-            this.getExecutor().popBreakContext();
+            executor.popBreakContext();
+        };
+        this.visitAnnotation_comment_expr = (ctx) => {
+            const refdesID = ctx.ID().getText();
+            const currentComponent = this.getScope().currentComponent;
+            if (currentComponent !== null) {
+                if (refdesID.indexOf('_') === -1) {
+                    currentComponent.setParam('refdes', refdesID);
+                }
+                else {
+                    currentComponent.placeHolderRefDes = refdesID;
+                }
+            }
         };
         this.pinTypes = [
             PinTypes_js_1.PinTypes.Any,
@@ -1346,7 +1439,7 @@ class ParserVisitor extends BaseVisitor_js_1.BaseVisitor {
     }
     annotateComponents() {
         this.log('===== annotate components =====');
-        const annotater = new ComponentAnnotater();
+        const annotater = new ComponentAnnotater_js_1.ComponentAnnotater();
         const instances = this.getScope().instances;
         const toAnnotate = [];
         for (const [, instance] of instances) {
@@ -1355,8 +1448,8 @@ class ParserVisitor extends BaseVisitor_js_1.BaseVisitor {
                 continue;
             }
             if (instance.assignedRefDes === null) {
-                if (instance.parameters.has('refdes')) {
-                    const refdes = instance.parameters.get('refdes');
+                if (instance.hasParam('refdes')) {
+                    const refdes = instance.getParam('refdes');
                     if (refdes) {
                         instance.assignedRefDes = refdes;
                         annotater.trackRefDes(refdes);
@@ -1368,10 +1461,7 @@ class ParserVisitor extends BaseVisitor_js_1.BaseVisitor {
             }
         }
         toAnnotate.forEach(instance => {
-            const useTypeProp = instance.typeProp ?? 'conn';
-            instance.typeProp === null
-                && this.log('Instance has no type:', instance.instanceName, ' assuming connector');
-            const newRefDes = annotater.getAnnotation(useTypeProp);
+            const newRefDes = annotater.getAnnotation(instance);
             if (newRefDes !== null) {
                 instance.assignedRefDes = newRefDes;
                 this.log(newRefDes, '-', instance.instanceName);
@@ -1456,7 +1546,7 @@ class ParserVisitor extends BaseVisitor_js_1.BaseVisitor {
     }
 }
 exports.ParserVisitor = ParserVisitor;
-const ComponentRefDesPrefixes = {
+exports.ComponentRefDesPrefixes = {
     res: 'R',
     cap: 'C',
     ind: 'L',
@@ -1467,48 +1557,6 @@ const ComponentRefDesPrefixes = {
     ic: 'U',
     '?': '?',
 };
-class ComponentAnnotater {
-    constructor() {
-        this.counter = {};
-        this.existingRefDes = [];
-        for (const key in ComponentRefDesPrefixes) {
-            this.counter[key] = 1;
-        }
-    }
-    getAnnotation(type) {
-        if (this.counter[type] === undefined && type.length <= 2) {
-            for (const [, value] of Object.entries(ComponentRefDesPrefixes)) {
-                if (value === type) {
-                    throw "Refdes prefix is already in use!";
-                }
-            }
-            if (ComponentRefDesPrefixes[type] === undefined) {
-                ComponentRefDesPrefixes[type] = type;
-                this.counter[type] = 1;
-            }
-        }
-        if (ComponentRefDesPrefixes[type] === undefined) {
-            return null;
-        }
-        let attempts = 100;
-        let proposedName = "";
-        while (attempts >= 0) {
-            proposedName = ComponentRefDesPrefixes[type] + this.counter[type];
-            this.counter[type]++;
-            if (this.existingRefDes.indexOf(proposedName) === -1) {
-                break;
-            }
-            attempts--;
-        }
-        if (attempts === 0) {
-            throw "Annotation failed!";
-        }
-        return proposedName;
-    }
-    trackRefDes(name) {
-        this.existingRefDes.push(name);
-    }
-}
 class VisitorExecutionException {
     constructor(context, errorMessage) {
         this.errorMessage = errorMessage;