circuitscript 0.1.20 → 0.1.23

package/dist/esm/BaseVisitor.js

@@ -23,6 +23,7 @@ export class BaseVisitor extends CircuitScriptVisitor {
     acceptedDirections = [Direction.Up, Direction.Down,
         Direction.Right, Direction.Left];
     resultData = new Map;
+    componentCtxLinks = new Map;
     pinTypesList = [
         PinTypes.Any,
         PinTypes.Input,
@@ -564,6 +565,27 @@ export class BaseVisitor extends CircuitScriptVisitor {
     getResult(ctx) {
         return this.resultData.get(ctx);
     }
+    linkComponentToCtx(ctx, instance, creationFlag = true) {
+        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]);
+            });
+        }
+        instance.ctxReferences.push({
+            ctx,
+            indexedStack,
+            creationFlag
+        });
+        this.componentCtxLinks.set(ctx, instance);
+    }
+    getComponentCtxLinks() {
+        return this.componentCtxLinks;
+    }
     visitResult(ctx) {
         this.visit(ctx);
         return this.getResult(ctx);

package/dist/esm/ComponentAnnotater.js

@@ -0,0 +1,84 @@
+import { ComponentRefDesPrefixes } from './visitor.js';
+export class ComponentAnnotater {
+    counter = {};
+    indexedContextPrefix = new Map();
+    existingRefDes = [];
+    constructor() {
+        for (const key in ComponentRefDesPrefixes) {
+            this.counter[key] = 1;
+        }
+    }
+    getAnnotation(instance) {
+        const type = instance.typeProp ?? 'conn';
+        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 prefix = '';
+        let resultRefdes = '';
+        const { ctxReferences } = instance;
+        if (ctxReferences.length > 0) {
+            const firstReference = ctxReferences[0];
+            const { ctx: useCtx, indexedStack, creationFlag } = firstReference;
+            if (indexedStack.length > 0 && creationFlag) {
+                const indexes = indexedStack.map(item => {
+                    return item[1] + 1;
+                });
+                if (!this.indexedContextPrefix.has(useCtx)) {
+                    if (instance.placeHolderRefDes) {
+                        prefix = instance.placeHolderRefDes.replaceAll('_', '');
+                    }
+                    else {
+                        const { index: nextIndex, proposedName } = this.getNextRefdesCounter(ComponentRefDesPrefixes[type], this.counter[type]);
+                        this.counter[type] = nextIndex;
+                        prefix = proposedName;
+                    }
+                    this.existingRefDes.push(prefix);
+                    this.indexedContextPrefix.set(useCtx, prefix);
+                }
+                const prefixParts = [this.indexedContextPrefix.get(useCtx), ...indexes];
+                resultRefdes = prefixParts.join('_');
+                if (this.existingRefDes.indexOf(resultRefdes) !== -1) {
+                    console.log('Warning: Refdes already used:', resultRefdes);
+                }
+            }
+            else {
+                const refdesCounter = this.getNextRefdesCounter(ComponentRefDesPrefixes[type], this.counter[type]);
+                this.counter[type] = refdesCounter.index;
+                resultRefdes = refdesCounter.proposedName;
+            }
+            this.existingRefDes.push(resultRefdes);
+            return resultRefdes;
+        }
+    }
+    getNextRefdesCounter(prefix, startingIndex) {
+        let attempts = 100;
+        let proposedName = "";
+        let index = startingIndex;
+        while (attempts >= 0) {
+            proposedName = prefix + index;
+            index++;
+            if (this.existingRefDes.indexOf(proposedName) === -1) {
+                break;
+            }
+            attempts--;
+        }
+        if (attempts === 0) {
+            throw "Annotation failed";
+        }
+        return { index, proposedName };
+    }
+    trackRefDes(name) {
+        this.existingRefDes.push(name);
+    }
+}

package/dist/esm/RefdesAnnotationVisitor.js

@@ -0,0 +1,196 @@
+import { CircuitScriptParser } from './antlr/CircuitScriptParser.js';
+import { BaseVisitor } from './BaseVisitor.js';
+export class RefdesAnnotationVisitor extends BaseVisitor {
+    sourceText;
+    tokenStream;
+    modifications = new Map();
+    resultText = '';
+    debug = false;
+    componentCtxLinks;
+    constructor(silent, sourceText, tokenStream, componentCtxLinks) {
+        super(true);
+        this.sourceText = sourceText;
+        this.tokenStream = tokenStream;
+        this.componentCtxLinks = componentCtxLinks;
+    }
+    getOriginalText(ctx) {
+        if (!ctx.start || !ctx.stop) {
+            return '';
+        }
+        const startIndex = ctx.start.start;
+        const stopIndex = ctx.stop.stop;
+        return this.sourceText.substring(startIndex, stopIndex + 1);
+    }
+    visitScript = async (ctx) => {
+        const result = this.runExpressions(this.getExecutor(), ctx.expression());
+        this.setResult(ctx, result);
+        this.getExecutor().closeOpenPathBlocks();
+        this.resultText = this.generateModifiedText();
+    };
+    visitAdd_component_expr = (ctx) => {
+        this.addRefdesAnnotationComment(ctx);
+    };
+    visitAt_component_expr = (ctx) => {
+        this.addRefdesAnnotationComment(ctx);
+    };
+    visitComponent_select_expr = (ctx) => {
+        this.addRefdesAnnotationComment(ctx);
+    };
+    visitAt_block_header = (ctx) => {
+        this.addRefdesAnnotationComment(ctx);
+    };
+    visitAt_block = (ctx) => {
+        this.visit(ctx.at_block_header());
+        ctx.at_block_expressions().forEach(expression => {
+            this.visit(expression);
+        });
+    };
+    visitTo_component_expr = (ctx) => {
+        const allRefdes = [];
+        ctx.component_select_expr().forEach(itemCtx => {
+            const tmpRefdes = this.generateRefdesAnnotationComment(itemCtx);
+            if (tmpRefdes !== null) {
+                allRefdes.push(tmpRefdes);
+            }
+        });
+        if (allRefdes.length > 0) {
+            const originalText = this.getOriginalText(ctx);
+            const annotation = ' #= ' + allRefdes.join(',');
+            this.modifications.set(ctx, originalText + annotation);
+        }
+    };
+    visitFunction_def_expr = (ctx) => {
+        this.runExpressions(this.getExecutor(), ctx.function_expr());
+    };
+    visitFunction_return_expr = (ctx) => {
+    };
+    visitFrame_expr = (ctx) => {
+        this.visit(ctx.expressions_block());
+    };
+    visitFunction_call_expr = (ctx) => {
+    };
+    visitParameters = (ctx) => {
+    };
+    addedRefdesAnnotations = [];
+    generateRefdesAnnotationComment(ctx) {
+        if (this.componentCtxLinks.has(ctx)) {
+            const instance = this.componentCtxLinks.get(ctx);
+            const alreadyHaveRefdesAnnotation = instance.assignedRefDes !== null ?
+                (this.addedRefdesAnnotations.indexOf(instance.assignedRefDes) !== -1) : false;
+            if (!instance.hasParam('refdes')
+                && instance.placeHolderRefDes === null
+                && instance.assignedRefDes
+                && !alreadyHaveRefdesAnnotation) {
+                let useRefDes = instance.assignedRefDes;
+                let isPlaceholderRefdes = false;
+                const { ctxReferences } = instance;
+                if (ctxReferences.length > 0) {
+                    const firstReference = ctxReferences[0];
+                    const { indexedStack: loopStack = [] } = firstReference;
+                    if (loopStack.length > 0) {
+                        isPlaceholderRefdes = true;
+                        const parts = instance.assignedRefDes.split('_');
+                        useRefDes = parts[0] + '_';
+                    }
+                    if (this.addedRefdesAnnotations.indexOf(instance.assignedRefDes) === -1
+                        && !isPlaceholderRefdes) {
+                        this.addedRefdesAnnotations.push(instance.assignedRefDes);
+                    }
+                    return useRefDes;
+                }
+            }
+        }
+        return null;
+    }
+    addRefdesAnnotationComment(ctx) {
+        const refdes = this.generateRefdesAnnotationComment(ctx);
+        if (refdes !== null) {
+            const originalText = this.getOriginalText(ctx);
+            const annotation = ' #= ' + refdes;
+            this.modifications.set(ctx, originalText + annotation);
+        }
+    }
+    getOutput() {
+        return this.resultText;
+    }
+    generateModifiedText() {
+        const output = [];
+        const allTokens = this.tokenStream.getTokens();
+        const processedTokens = new Set();
+        let lastSourcePos = 0;
+        const contextTokenRanges = this.buildContextTokenRanges();
+        for (let i = 0; i < allTokens.length; i++) {
+            const token = allTokens[i];
+            if (processedTokens.has(i)) {
+                continue;
+            }
+            const tokenText = this.sourceText.substring(token.start, token.stop + 1);
+            this.log(i, `token: [${tokenText}], length: ${tokenText.length}, text: [${token.text}]`);
+            if (token.type === CircuitScriptParser.DEDENT
+                || token.type === CircuitScriptParser.EOF
+                || (token.type === CircuitScriptParser.NEWLINE && token.__skip)) {
+                this.log('--skip dedent/EOF token');
+                continue;
+            }
+            const ctx = this.findContextForToken(token, contextTokenRanges);
+            if (ctx) {
+                const isFirstTokenInContext = token.tokenIndex === ctx.start?.tokenIndex;
+                if (isFirstTokenInContext) {
+                    if (token.start > lastSourcePos) {
+                        output.push(this.sourceText.substring(lastSourcePos, token.start));
+                    }
+                    if (this.modifications.has(ctx)) {
+                        output.push(this.modifications.get(ctx));
+                        this.markTokensAsProcessed(ctx, processedTokens);
+                        if (ctx.stop) {
+                            lastSourcePos = ctx.stop.stop + 1;
+                        }
+                        continue;
+                    }
+                }
+            }
+            if (token.start > lastSourcePos) {
+                output.push(this.sourceText.substring(lastSourcePos, token.start));
+            }
+            if (tokenText.length > 0) {
+                output.push(tokenText);
+            }
+            processedTokens.add(i);
+            lastSourcePos = token.stop + 1;
+        }
+        if (lastSourcePos < this.sourceText.length) {
+            output.push(this.sourceText.substring(lastSourcePos));
+        }
+        return output.join('');
+    }
+    buildContextTokenRanges() {
+        const ranges = new Map();
+        for (const ctx of this.modifications.keys()) {
+            if (ctx.start && ctx.stop) {
+                ranges.set(ctx, [ctx.start.tokenIndex, ctx.stop.tokenIndex]);
+            }
+        }
+        return ranges;
+    }
+    findContextForToken(token, contextRanges) {
+        for (const [ctx, [start, end]] of contextRanges) {
+            if (token.tokenIndex >= start && token.tokenIndex <= end) {
+                return ctx;
+            }
+        }
+        return null;
+    }
+    markTokensAsProcessed(ctx, processedTokens) {
+        if (!ctx.start || !ctx.stop) {
+            return;
+        }
+        for (let i = ctx.start.tokenIndex; i <= ctx.stop.tokenIndex; i++) {
+            processedTokens.add(i);
+        }
+    }
+    log(...message) {
+        if (this.debug) {
+            console.log(...message);
+        }
+    }
+}