circuitscript 0.1.19 → 0.1.22

package/dist/cjs/BaseVisitor.js

@@ -25,6 +25,7 @@ class BaseVisitor extends CircuitScriptVisitor_js_1.CircuitScriptVisitor {
         this.acceptedDirections = [types_js_1.Direction.Up, types_js_1.Direction.Down,
             types_js_1.Direction.Right, types_js_1.Direction.Left];
         this.resultData = new Map;
+        this.componentCtxLinks = new Map;
         this.pinTypesList = [
             PinTypes_js_1.PinTypes.Any,
             PinTypes_js_1.PinTypes.Input,
@@ -569,6 +570,27 @@ class BaseVisitor extends CircuitScriptVisitor_js_1.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/cjs/ComponentAnnotater.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ComponentAnnotater = void 0;
+const visitor_js_1 = require("./visitor.js");
+class ComponentAnnotater {
+    constructor() {
+        this.counter = {};
+        this.indexedContextPrefix = new Map();
+        this.existingRefDes = [];
+        for (const key in visitor_js_1.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(visitor_js_1.ComponentRefDesPrefixes)) {
+                if (value === type) {
+                    throw "Refdes prefix is already in use!";
+                }
+            }
+            if (visitor_js_1.ComponentRefDesPrefixes[type] === undefined) {
+                visitor_js_1.ComponentRefDesPrefixes[type] = type;
+                this.counter[type] = 1;
+            }
+        }
+        if (visitor_js_1.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(visitor_js_1.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(visitor_js_1.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);
+    }
+}
+exports.ComponentAnnotater = ComponentAnnotater;

package/dist/cjs/RefdesAnnotationVisitor.js

@@ -0,0 +1,197 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RefdesAnnotationVisitor = void 0;
+const CircuitScriptParser_js_1 = require("./antlr/CircuitScriptParser.js");
+const BaseVisitor_js_1 = require("./BaseVisitor.js");
+class RefdesAnnotationVisitor extends BaseVisitor_js_1.BaseVisitor {
+    constructor(silent, sourceText, tokenStream, componentCtxLinks) {
+        super(true);
+        this.modifications = new Map();
+        this.resultText = '';
+        this.debug = false;
+        this.visitScript = async (ctx) => {
+            const result = this.runExpressions(this.getExecutor(), ctx.expression());
+            this.setResult(ctx, result);
+            this.getExecutor().closeOpenPathBlocks();
+            this.resultText = this.generateModifiedText();
+        };
+        this.visitAdd_component_expr = (ctx) => {
+            this.addRefdesAnnotationComment(ctx);
+        };
+        this.visitAt_component_expr = (ctx) => {
+            this.addRefdesAnnotationComment(ctx);
+        };
+        this.visitComponent_select_expr = (ctx) => {
+            this.addRefdesAnnotationComment(ctx);
+        };
+        this.visitAt_block_header = (ctx) => {
+            this.addRefdesAnnotationComment(ctx);
+        };
+        this.visitAt_block = (ctx) => {
+            this.visit(ctx.at_block_header());
+            ctx.at_block_expressions().forEach(expression => {
+                this.visit(expression);
+            });
+        };
+        this.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);
+            }
+        };
+        this.visitFunction_def_expr = (ctx) => {
+            this.runExpressions(this.getExecutor(), ctx.function_expr());
+        };
+        this.visitFunction_return_expr = (ctx) => {
+        };
+        this.visitFrame_expr = (ctx) => {
+            this.visit(ctx.expressions_block());
+        };
+        this.visitFunction_call_expr = (ctx) => {
+        };
+        this.visitParameters = (ctx) => {
+        };
+        this.addedRefdesAnnotations = [];
+        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);
+    }
+    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_js_1.CircuitScriptParser.DEDENT
+                || token.type === CircuitScriptParser_js_1.CircuitScriptParser.EOF
+                || (token.type === CircuitScriptParser_js_1.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);
+        }
+    }
+}
+exports.RefdesAnnotationVisitor = RefdesAnnotationVisitor;