assembly-yasm-helper 1.4.0

package/out/providers/signatureHelpProvider.js

@@ -0,0 +1,125 @@
+"use strict";
+const vscode = require("vscode");
+const { KEYWORD_MAP } = require("../data/keywords");
+const { INSTRUCTION_SIGNATURES } = require("../data/instructionSignatures");
+
+// Convert an OperandType bitfield to a readable string
+const _ts = b => ((b&3)===3)?'r/m':(b&1)?'reg':(b&2)?'mem':(b&4)?'imm':(b&8)?'label':'?';
+
+class AsmSignatureHelpProvider {
+
+    constructor(registry) { this.registry = registry; }
+
+    provideSignatureHelp(document, position, token, context) {
+        if (!vscode.workspace.getConfiguration('assembly').get('enableSignatureHelp')) return null;
+
+        const line = document.lineAt(position.line).text.slice(0, position.character);
+
+        const commentIdx = line.indexOf(';');
+        if (commentIdx !== -1 && commentIdx < position.character) return null;
+
+        const trimmed = line.trimStart();
+        const words = trimmed.split(/\s+/);
+        if (words.length < 2) return null;
+
+        const opcode = words[0].toLowerCase();
+        const kw = KEYWORD_MAP.get(opcode);
+        const sigs = INSTRUCTION_SIGNATURES[opcode];
+        const macro = this.registry?.findMacro(opcode);
+
+        // count commas after opcode to determine active parameter index
+        const afterOpcode = line.slice(line.toLowerCase().indexOf(opcode) + opcode.length);
+        const commaCount = (afterOpcode.match(/,/g) || []).length;
+
+        const result = new vscode.SignatureHelp();
+
+        if (sigs?.length) {
+            result.signatures = sigs.map(form => {
+                const label = form.length
+                    ? `${opcode} ${form.map(_ts).join(', ')}`
+                    : opcode;
+                const sig = new vscode.SignatureInformation(label, kw?.def || '');
+                let searchFrom = opcode.length + (form.length ? 1 : 0);
+                for (const bits of form) {
+                    const name = _ts(bits);
+                    const start = label.indexOf(name, searchFrom);
+                    const end   = start + name.length;
+                    sig.parameters.push(new vscode.ParameterInformation([start, end]));
+                    searchFrom = end + 1;
+                }
+                return sig;
+            });
+
+            // pick the best matching signature based on already-typed operands
+            const typedParts = afterOpcode.split(',');
+            let activeIdx = 0;
+            if (commaCount > 0) {
+                const completedOps = typedParts.slice(0, commaCount).map(o => o.trim());
+                for (let i = 0; i < sigs.length; i++) {
+                    if (sigs[i].length < typedParts.length) continue;
+                    if (completedOps.every((op, j) => !op || (this._classify(op) & sigs[i][j]))) {
+                        activeIdx = i;
+                        break;
+                    }
+                }
+            }
+
+            result.activeSignature = activeIdx;
+            result.activeParameter = Math.min(commaCount, sigs[activeIdx].length - 1);
+
+        } else if (kw?.data) {
+            // fallback: single signature from keyword data
+            const sig = new vscode.SignatureInformation(kw.data, kw.def || '');
+            const paramStr = kw.data.slice(opcode.length).trim();
+            if (paramStr) {
+                let searchFrom = kw.data.length - paramStr.length;
+                for (const p of paramStr.split(',')) {
+                    const name = p.trim();
+                    const start = kw.data.indexOf(name, searchFrom);
+                    const end   = start + name.length;
+                    sig.parameters.push(new vscode.ParameterInformation([start, end]));
+                    searchFrom = end + 1;
+                }
+            }
+            result.signatures      = [sig];
+            result.activeSignature = 0;
+            result.activeParameter = Math.min(commaCount, sig.parameters.length - 1);
+
+        } else if (macro?.argCount > 0) {
+            // user-defined macro: build signature from argCount
+            const params = Array.from({ length: macro.argCount }, (_, i) => `%${i + 1}`);
+            const label = `${macro.name} ${params.join(', ')}`;
+            const sig = new vscode.SignatureInformation(label, `(Macro) ${macro.name} — ${macro.argCount} arg${macro.argCount !== 1 ? 's' : ''}`);
+            let searchFrom = macro.name.length + 1;
+            for (const p of params) {
+                const start = label.indexOf(p, searchFrom);
+                const end   = start + p.length;
+                sig.parameters.push(new vscode.ParameterInformation([start, end]));
+                searchFrom = end + 1;
+            }
+            result.signatures      = [sig];
+            result.activeSignature = 0;
+            result.activeParameter = Math.min(commaCount, params.length - 1);
+
+        } else {
+            return null;
+        }
+
+        return result;
+    }
+
+    // Lightweight operand classifier for signature matching
+    _classify(op) {
+        if (op.includes('[')) return 2; // MEM
+        const tokens = op.split(/\s+/).filter(t => t.length > 0);
+        if (tokens.some(t => this._isReg(t))) return 1; // REG
+        if (tokens.length === 1 && /^(0x[0-9a-f]+|[0-9][0-9a-f]*[hbd]?)$/i.test(tokens[0])) return 4; // IMM
+        return 8 | 4; // LABEL | IMM
+    }
+
+    _isReg(w) {
+        return /^(r(ax|bx|cx|dx|si|di|bp|sp)|e(ax|bx|cx|dx|si|di|bp|sp)|[abcd][xhl]|[sd]il|[bs]pl|r\d{1,2}[bdw]?|[xyz]mm\d+|k[0-7]|[cdefgs]s|[re]ip|rflags|eflags)$/i.test(w);
+    }
+}
+
+module.exports = { AsmSignatureHelpProvider };

package/out/providers/symbolProvider.js

@@ -0,0 +1,66 @@
+"use strict";
+const vscode = require("vscode");
+
+class AsmDocumentSymbolProvider {
+    constructor(registry) {
+        this.registry = registry;
+    }
+
+    provideDocumentSymbols(document, token) {
+        if (!vscode.workspace.getConfiguration('assembly').get('enableDocumentSymbols')) return [];
+
+        const symbols = [];
+
+        for (const proc of this.registry.procs) {
+            if (proc.line === undefined) continue;
+            const range = new vscode.Range(proc.line, 0, proc.line, 0);
+            symbols.push(new vscode.DocumentSymbol(
+                proc.name,
+                '(Procedure)',
+                vscode.SymbolKind.Function,
+                range,
+                range
+            ));
+        }
+
+        for (const v of this.registry.vars) {
+            if (v.line === undefined) continue;
+            const range = new vscode.Range(v.line, 0, v.line, 0);
+            symbols.push(new vscode.DocumentSymbol(
+                v.name,
+                v.type + (v.section ? ' [' + v.section + ']' : ''),
+                vscode.SymbolKind.Variable,
+                range,
+                range
+            ));
+        }
+
+        for (const macro of this.registry.macros) {
+            if (macro.line === undefined) continue;
+            const range = new vscode.Range(macro.line, 0, macro.line, 0);
+            symbols.push(new vscode.DocumentSymbol(
+                macro.name,
+                '(Macro)',
+                vscode.SymbolKind.Module,
+                range,
+                range
+            ));
+        }
+
+        for (const label of this.registry.labels) {
+            if (label.line === undefined) continue;
+            const range = new vscode.Range(label.line, 0, label.line, 0);
+            symbols.push(new vscode.DocumentSymbol(
+                label.name,
+                '(Label)',
+                vscode.SymbolKind.Key,
+                range,
+                range
+            ));
+        }
+
+        return symbols;
+    }
+}
+
+module.exports = { AsmDocumentSymbolProvider };

package/out/registry.js

@@ -0,0 +1,167 @@
+"use strict";
+
+const { KEYWORD_MAP } = require("./data/keywords");
+
+class SymbolRegistry {
+
+    constructor() {
+        this.clear();
+    }
+
+    clear() {
+
+        // arrays (สำหรับ iterate)
+        this.vars = [];
+        this.procs = [];
+        this.macros = [];
+        this.labels = [];
+        this.labelsEE = [];
+        this.structs = [];
+
+        this.structureInfo = [];
+        this.includedFiles = [];
+
+        // fast lookup maps
+        this.varMap = new Map();
+        this.procMap = new Map();
+        this.macroMap = new Map();
+        this.labelMap = new Map();
+
+        // duplicate guard
+        this.varSet = new Set();
+        this.procSet = new Set();
+        this.macroSet = new Set();
+        this.labelSet = new Set();
+
+        // section index
+        this.sectionIndex = new Map();
+    }
+
+    // --------------------------------
+    // SECTION INDEX
+    // --------------------------------
+
+    addToSection(section, symbol) {
+
+        if (!section) return;
+
+        const key = section.toLowerCase();
+
+        if (!this.sectionIndex.has(key)) {
+            this.sectionIndex.set(key, []);
+        }
+
+        this.sectionIndex.get(key).push(symbol);
+    }
+
+    getSectionSymbols(section) {
+        return this.sectionIndex.get(section.toLowerCase()) || [];
+    }
+
+    // --------------------------------
+    // VARIABLES
+    // --------------------------------
+
+    addVariable(v) {
+
+        const key = v.name.toLowerCase();
+
+        if (this.varSet.has(key)) return;
+
+        this.varSet.add(key);
+
+        this.vars.push(v);
+        this.varMap.set(key, v);
+
+        this.addToSection(v.section, v);
+    }
+
+    findVariable(name) {
+        return this.varMap.get(name.toLowerCase());
+    }
+
+    // --------------------------------
+    // PROCEDURES
+    // --------------------------------
+
+    addProcedure(p) {
+
+        const key = p.name.toLowerCase();
+
+        if (this.procSet.has(key)) return;
+
+        this.procSet.add(key);
+
+        this.procs.push(p);
+        this.procMap.set(key, p);
+
+        this.addToSection(p.section, p);
+    }
+
+    findProcedure(name) {
+        return this.procMap.get(name.toLowerCase());
+    }
+
+    // --------------------------------
+    // MACROS
+    // --------------------------------
+
+    addMacro(name, line, argCount = 0) {
+
+        const key = name.toLowerCase();
+
+        if (this.macroSet.has(key)) return;
+
+        this.macroSet.add(key);
+
+        const sym = { name, line, argCount };
+        this.macros.push(sym);
+        this.macroMap.set(key, sym);
+    }
+
+    findMacro(name) {
+        return this.macroMap.get(name.toLowerCase());
+    }
+
+    // --------------------------------
+    // LABELS
+    // --------------------------------
+
+    addLabel(name, line) {
+
+        const key = name.toLowerCase();
+
+        if (this.labelSet.has(key)) return;
+
+        this.labelSet.add(key);
+
+        const sym = { name, line };
+        this.labels.push(sym);
+        this.labelMap.set(key, sym);
+    }
+
+    findLabel(name) {
+
+        const key = name.toLowerCase();
+
+        if (this.labelMap.has(key)) {
+            return this.labelMap.get(key);
+        }
+
+        return this.labelsEE.find(
+            l => l.name.toLowerCase() === key
+        );
+    }
+
+    // --------------------------------
+    // KEYWORDS
+    // --------------------------------
+
+    getKeyword(word) {
+        if (!word) return undefined;
+        return KEYWORD_MAP.get(word.toLowerCase());
+    }
+
+}
+
+module.exports = { SymbolRegistry };

package/out/scanner.js

@@ -0,0 +1,174 @@
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const { AsmTokenizer } = require("./tokenizer");
+const { Utils } = require("./utils");
+const { Info, Procedure, Label } = require("./data/structs");
+
+class DocumentScanner {
+
+    constructor(registry, currentFilePath = null) {
+        this.tokenizer = new AsmTokenizer();
+        this.registry = registry;
+        this.currentFilePath = currentFilePath;
+        this.currentSection = "";
+
+        // regex cache
+        this.varRegex    = /\b(db|dw|dd|dq|dt|resb|resw|resd|resq|equ)\b/i;
+        this.labelRegex  = /^\s*((?:%%)?[A-Za-z_.$?][\w.$?]*):/;
+        this.procRegex   = /^\s*([A-Za-z_.$?][\w.$?]*)\s+proc\b/i;
+        this.macroRegex  = /^\s*%macro\b/i;
+        this.defineRegex = /^\s*%(define|assign)\b/i;
+    }
+
+    async scan(documentLines, clearPrevious = true) {
+        if (clearPrevious) {
+            this.registry.clear();
+            if (this.currentFilePath) {
+                this.registry.includedFiles.push(path.normalize(this.currentFilePath));
+            }
+        }
+        this.currentSection = "";
+
+        for (let x = 0; x < documentLines.length; x++) {
+            const ctx = this._buildContext(documentLines[x]);
+
+            if (this._detectSection(ctx))            continue;
+            this._detectLabel(ctx, x);
+            this._detectVariable(ctx, x, clearPrevious);
+            await this._detectProcedure(ctx, x, documentLines);
+            await this._detectInclude(ctx);
+            this._detectMacro(ctx, x);
+            this._detectDefine(ctx);
+            this._detectExtern(ctx, x);
+        }
+    }
+
+    // -------------------------------------------------------
+    // Context builder — tokenizes each line once
+    // -------------------------------------------------------
+
+    _buildContext(line) {
+        const clean = Utils.clearSpace(line);
+        return {
+            raw:       line,
+            clean,
+            lower:     clean.toLowerCase(),
+            noComment: line.replace(/;.*$/, "").trim(),
+            words:     this.tokenizer.tokenize(line)
+        };
+    }
+
+    // -------------------------------------------------------
+    // Detection methods
+    // -------------------------------------------------------
+
+    _detectSection(ctx) {
+        if (!ctx.lower.startsWith("section") && !ctx.lower.startsWith("segment")) return false;
+        if (ctx.words.length > 1) this.currentSection = ctx.words[1].toLowerCase();
+        return true;
+    }
+
+    _detectLabel(ctx, x) {
+        const match = ctx.noComment.match(this.labelRegex);
+        if (match && !this.registry.findLabel(match[1])) {
+            this.registry.addLabel(match[1], x);
+        }
+
+        // MASM label directive
+        if (ctx.lower.startsWith("label") && ctx.words.length >= 2) {
+            const name = ctx.words[1];
+            this.registry.labelsEE.push(
+                new Label(name, ctx.raw.substring(ctx.raw.indexOf(name) + name.length))
+            );
+        }
+    }
+
+    _detectVariable(ctx, x, clearPrevious) {
+        if (!clearPrevious) return;
+        if (ctx.words.length < 2 || !this.varRegex.test(ctx.words[1])) return;
+
+        this.registry.addVariable({
+            name:    ctx.words[0],
+            type:    ctx.words[1],
+            section: this.currentSection,
+            line:    x
+        });
+    }
+
+    async _detectProcedure(ctx, x, documentLines) {
+        const match = ctx.clean.match(this.procRegex);
+        if (!match || this.registry.findProcedure(match[1])) return;
+
+        const name = match[1];
+        const des  = this._parseProcDocComments(documentLines, x, name);
+
+        const proc    = new Procedure(name, des);
+        proc.section  = this.currentSection;
+        proc.line     = x;
+        this.registry.addProcedure(proc);
+    }
+
+    _parseProcDocComments(documentLines, procLine, name) {
+        const des  = new Info("", "");
+        const text = [];
+
+        for (let ptr = procLine - 1; ptr >= 0; ptr--) {
+            const prev = Utils.clearSpace(documentLines[ptr]);
+            if (!prev.startsWith(";")) break;
+            text.push(documentLines[ptr].substring(documentLines[ptr].indexOf(";") + 1));
+        }
+
+        for (const t of text) {
+            if      (t.startsWith("@out: ")) des.output.push(t.substring(t.indexOf(" ", t.indexOf("@out: "))));
+            else if (t.startsWith("@arg: ")) des.params.push(Utils.clearSpace(t.substring(t.indexOf(" ", t.indexOf("@arg: ")))));
+            else                             des.des += t;
+        }
+
+        des.name = name;
+        return des;
+    }
+
+    async _detectInclude(ctx) {
+        if (!ctx.lower.startsWith("%include") && !ctx.lower.startsWith("include")) return;
+
+        const fileMatch = ctx.raw.match(/['"](.*?)['"]/);
+        if (!fileMatch || !this.currentFilePath) return;
+
+        const baseDir    = path.dirname(this.currentFilePath);
+        const normalized = path.normalize(path.resolve(baseDir, fileMatch[1]));
+
+        if (!fs.existsSync(normalized) || this.registry.includedFiles.includes(normalized)) return;
+
+        const filedata = fs.readFileSync(normalized, "utf8");
+        this.registry.includedFiles.push(normalized);
+
+        const oldSection = this.currentSection;
+        await this.scan(filedata.split(/\r?\n/), false);
+        this.currentSection = oldSection;
+    }
+
+    _detectMacro(ctx, x) {
+        if (!this.macroRegex.test(ctx.raw) || ctx.words.length <= 1) return;
+        const macroName = ctx.words[1];
+        const argCount  = ctx.words.length > 2 ? parseInt(ctx.words[2], 10) : 0;
+        if (!this.registry.findMacro(macroName))
+            this.registry.addMacro(macroName, x, isNaN(argCount) ? 0 : argCount);
+    }
+
+    _detectDefine(ctx) {
+        if (!this.defineRegex.test(ctx.raw) || ctx.words.length <= 1) return;
+        const defineName = ctx.words[1];
+        if (!this.registry.defines) this.registry.defines = [];
+        if (!this.registry.defines.includes(defineName)) this.registry.defines.push(defineName);
+    }
+
+    _detectExtern(ctx, x) {
+        if (ctx.words[0]?.toLowerCase() !== "extern" || ctx.words.length <= 1) return;
+        const externName = ctx.words[1];
+        if (!this.registry.findLabel(externName)) this.registry.addLabel(externName, x);
+    }
+}
+
+module.exports = { DocumentScanner };

package/out/tokenizer.js

@@ -0,0 +1,67 @@
+"use strict";
+
+class AsmTokenizer {
+
+    tokenize(line) {
+
+        const tokens = [];
+        let current = "";
+        let inString = false;
+
+        for (let i = 0; i < line.length; i++) {
+
+            const ch = line[i];
+
+            // comment
+            if (!inString && ch === ';') {
+                break;
+            }
+
+            // string start/end
+            if (ch === '"' || ch === "'") {
+
+                current += ch;
+
+                if (inString) {
+                    tokens.push(current);
+                    current = "";
+                    inString = false;
+                } else {
+                    inString = true;
+                }
+
+                continue;
+            }
+
+            if (inString) {
+                current += ch;
+                continue;
+            }
+
+            // separators
+            if (/\s|,|\[|\]|\(|\)/.test(ch)) {
+
+                if (current.length) {
+                    tokens.push(current);
+                    current = "";
+                }
+
+                if (!/\s/.test(ch)) {
+                    tokens.push(ch);
+                }
+
+                continue;
+            }
+
+            current += ch;
+        }
+
+        if (current.length) {
+            tokens.push(current);
+        }
+
+        return tokens;
+    }
+}
+
+module.exports = { AsmTokenizer };

package/out/utils.js

@@ -0,0 +1,89 @@
+"use strict";
+
+const { KeywordType } = require("./data/enums");
+
+class Utils {
+
+    static typeMap = {
+        [KeywordType.instruction]: "(Command)",
+        [KeywordType.memoryAllocation]: "(Memory)",
+        [KeywordType.precompiled]: "(Instruction)",
+        [KeywordType.register]: "(Register)",
+        [KeywordType.savedWord]: "(Saved)",
+        [KeywordType.size]: "(Size)",
+        [KeywordType.label]: "(Label)",
+        [KeywordType.macro]: "(Macro)",
+        [KeywordType.method]: "(Procedure)",
+        [KeywordType.structure]: "(Structure)",
+        [KeywordType.variable]: "(Variable)"
+    };
+
+    static getType(type) {
+        return Utils.typeMap[type] || "(Unknown)";
+    }
+
+    static clearSpace(str) {
+        return str.trim();
+    }
+
+    static splitLine(line) {
+
+        return line
+            .split(/[,\s\[\]\(\)]+/)
+            .filter(Boolean);
+
+    }
+
+    static isNumberStr(str) {
+
+        return (
+            /^0x[0-9a-f]+$/i.test(str) ||
+            /^[0-9]+$/i.test(str) ||
+            /^[0-9a-f]+h$/i.test(str) ||
+            /^[01]+b$/i.test(str) ||
+            /^[0-9]+d$/i.test(str)
+        );
+
+    }
+
+    static getNumMsg(word) {
+
+        let base;
+        let value;
+
+        if (/^0x/i.test(word)) {
+
+            base = 16;
+            value = Number.parseInt(word, 16);
+
+        } else if (word.endsWith("h")) {
+
+            base = 16;
+            value = Number.parseInt(word.slice(0, -1), 16);
+
+        } else if (word.endsWith("b")) {
+
+            base = 2;
+            value = Number.parseInt(word.slice(0, -1), 2);
+
+        } else {
+
+            base = 10;
+            value = Number.parseInt(word, 10);
+
+        }
+
+        if (Number.isNaN(value)) return null;
+
+        let s = `(${base === 16 ? "Hexadecimal" : base === 2 ? "Binary" : "Decimal"} Number) ${word}:\n`;
+
+        if (base !== 10) s += `\tDecimal: ${value.toString(10)}\n`;
+        if (base !== 16) s += `\tHex: ${value.toString(16)}h / 0x${value.toString(16).toUpperCase()}\n`;
+        if (base !== 2) s += `\tBinary: ${value.toString(2)}b\n`;
+
+        return s;
+    }
+
+}
+
+module.exports = { Utils };