assembly-yasm-helper 1.4.0

package/out/core/completionEngine.js

@@ -0,0 +1,259 @@
+"use strict";
+
+const { Utils } = require("../utils");
+const { KeywordType } = require("../data/enums");
+const { KEYWORD_MAP, REGISTERS, AVX_REGISTERS, PREPROCESSOR } = require("../data/keywords");
+const { OperandType } = require("../data/operandTypes");
+const { INSTRUCTION_SIGNATURES } = require("../data/instructionSignatures");
+const { MemoryAddressParser } = require("../engine/memoryAddressParser");
+
+const MEM_DIRECTIVES    = ['db','dw','dd','dq','dt','resb','resw','resd','resq','equ'];
+const INSTRUCTION_TYPES = new Set([KeywordType.instruction, KeywordType.memoryAllocation, KeywordType.precompiled]);
+const SIZE_KEYWORDS     = ["byte","word","dword","qword","tword","oword","yword","zword"];
+const KEYWORD_LIST      = Array.from(KEYWORD_MAP.values());
+
+/**
+ * Get completion items for a given context.
+ * @param {{ line: string, lineIdx: number, lines: string[] }} ctx
+ * @param {object} registry
+ * @returns {{ label: string, kindType: number, detail: string, doc: string, sortText: string, insertText?: string }[]}
+ */
+function getCompletionItems(ctx, registry) {
+    const { line, lineIdx, lines } = ctx;
+    const items = [];
+
+    if (_isInComment(line, line.length)) return items;
+    if (_isInString(line))               return items;
+
+    const trimmed         = line.trimStart();
+    const isRootLevel     = line.length === trimmed.length;
+    const words           = trimmed.length > 0 ? trimmed.split(/\s+/).map(w => w.toLowerCase()) : [];
+    const isTypingOperand = words.length > 1 || (words.length === 1 && /\s$/.test(line));
+
+    if (trimmed.startsWith('%'))
+        return _completePreprocessor(lines, lineIdx, registry);
+
+    if (!isTypingOperand)
+        _addRootLevelItems(isRootLevel, items);
+
+    if (words[0] === "section" && isTypingOperand)
+        return _completeSection();
+
+    if (_isInsideBracket(line))
+        return _completeBracketMemory(line, registry);
+
+    if (isTypingOperand)
+        return _completeOperands(words, line, registry, items);
+
+    if (trimmed.length > 0)
+        _completeInstructions(words, registry, items);
+
+    return _deduplicate(items);
+}
+
+// -------------------------------------------------------
+// Guards
+// -------------------------------------------------------
+
+function _isInComment(line, character) {
+    const idx = line.indexOf(';');
+    return idx !== -1 && idx < character;
+}
+
+function _isInString(line) {
+    const quotes = line.match(/['"]/g);
+    return !!(quotes && quotes.length % 2 !== 0);
+}
+
+function _isInsideBracket(line) {
+    return line.lastIndexOf("[") > line.lastIndexOf("]");
+}
+
+// -------------------------------------------------------
+// Completion sections
+// -------------------------------------------------------
+
+function _completePreprocessor(lines, lineIdx, registry) {
+    const items = [];
+    for (const p of PREPROCESSOR)
+        items.push(_makeItem(p.name, KeywordType.precompiled, p.detail, p.doc, null, "01"));
+    for (const m of registry.macros)
+        items.push(_makeItem(m.name, KeywordType.macro, "(Macro)", '', null, "05"));
+
+    const argCount = _getMacroArgCount(lines, lineIdx);
+    if (argCount > 0) {
+        for (let i = 1; i <= argCount; i++)
+            items.push(_makeItem(`%${i}`, KeywordType.constant, `(Macro arg ${i})`, '', null, "01"));
+    }
+    return items;
+}
+
+function _getMacroArgCount(lines, lineIdx) {
+    for (let i = lineIdx - 1; i >= 0; i--) {
+        const raw = lines[i].trim().toLowerCase();
+        if (raw.startsWith('%endmacro')) return 0;
+        if (raw.startsWith('%macro')) {
+            const parts = raw.split(/\s+/);
+            const n = parseInt(parts[2], 10);
+            return isNaN(n) ? 0 : n;
+        }
+    }
+    return 0;
+}
+
+function _addRootLevelItems(isRootLevel, items) {
+    if (!isRootLevel) return;
+    for (const sec of ["section .data", "section .text", "section .bss"])
+        items.push(_makeItem(sec, KeywordType.savedWord));
+    items.push(_makeItem("global", KeywordType.savedWord));
+    items.push(_makeItem("extern", KeywordType.savedWord));
+}
+
+function _completeSection() {
+    const items = [];
+    for (const sec of ["data", "text", "bss"])
+        items.push(_makeItem("." + sec, KeywordType.savedWord));
+    return items;
+}
+
+function _completeBracketMemory(line, registry) {
+    const items = [];
+    const expr  = line.slice(line.lastIndexOf("[") + 1);
+    const state = MemoryAddressParser.parse(expr);
+
+    switch (state) {
+        case "BASE":
+            for (const v of registry.vars)
+                items.push(_makeItem(v.name, KeywordType.variable, '', '', null, "01"));
+            for (const r of REGISTERS)
+                items.push(_makeItem(r, KeywordType.register, '', '', null, "02"));
+            break;
+        case "BASE_DONE":
+            items.push(_makeItem("+", KeywordType.operator, "(Offset)"));
+            break;
+        case "INDEX":
+            for (const r of REGISTERS)
+                items.push(_makeItem(r, KeywordType.register));
+            break;
+        case "INDEX_DONE":
+            items.push(_makeItem("*", KeywordType.operator, "(Scale)"));
+            break;
+        case "SCALE_INPUT":
+            for (const s of ["1","2","4","8"])
+                items.push(_makeItem(s, KeywordType.constant, "(Scale)"));
+            break;
+    }
+    return items;
+}
+
+function _completeOperands(words, line, registry, items) {
+    const firstWord = words[0].toLowerCase();
+
+    if (!INSTRUCTION_SIGNATURES[firstWord]) {
+        if (registry.findMacro(firstWord))
+            return _completeMacroOperands(registry);
+        return _completeMemoryDirectives(words);
+    }
+
+    const allowed = getAllowedOperandTypes(firstWord, getOperandIndex(line));
+    if (allowed === undefined) return items;
+
+    if (allowed & OperandType.MEM) {
+        for (const s of SIZE_KEYWORDS)
+            items.push(_makeItem(s, KeywordType.size, "(Size)", '', null, "01"));
+        for (const v of registry.vars)
+            items.push(_makeItem(v.name, KeywordType.variable, '', '', null, "02"));
+    }
+    if (allowed & OperandType.REG) {
+        REGISTERS.forEach(r     => items.push(_makeItem(r, KeywordType.register, '', '', null, _regPrefix(r))));
+        AVX_REGISTERS.forEach(r => items.push(_makeItem(r, KeywordType.register, '', '', null, "05")));
+    }
+    if (allowed & OperandType.IMM) {
+        items.push(_makeItem("0", KeywordType.constant, "(Immediate)", '', null, "04"));
+        for (const d of registry.defines || [])
+            items.push(_makeItem(d, KeywordType.constant, "(%define)", '', null, "04"));
+    }
+    if (allowed & OperandType.LABEL) {
+        const labelPrefix = (allowed === OperandType.LABEL) ? "01" : "02";
+        registry.labels.forEach(l => items.push(_makeItem(l.name, KeywordType.label, '', '', null, labelPrefix)));
+        registry.procs.forEach(p  => items.push(_makeItem(p.name, KeywordType.method, '', '', null, labelPrefix)));
+    }
+    return items;
+}
+
+function _completeMacroOperands(registry) {
+    const items = [];
+    for (const s of SIZE_KEYWORDS)
+        items.push(_makeItem(s, KeywordType.size, "(Size)", '', null, "01"));
+    for (const v of registry.vars)
+        items.push(_makeItem(v.name, KeywordType.variable, '', '', null, "02"));
+    REGISTERS.forEach(r     => items.push(_makeItem(r, KeywordType.register, '', '', null, _regPrefix(r))));
+    AVX_REGISTERS.forEach(r => items.push(_makeItem(r, KeywordType.register, '', '', null, "05")));
+    items.push(_makeItem("0", KeywordType.constant, "(Immediate)", '', null, "04"));
+    return items;
+}
+
+function _completeMemoryDirectives(words) {
+    const items = [];
+    const secondWord = words.filter(w => w.length > 0)[1] || '';
+    if (!MEM_DIRECTIVES.includes(secondWord)) {
+        for (const d of MEM_DIRECTIVES) {
+            const kw = KEYWORD_MAP.get(d);
+            items.push(_makeItem(d, KeywordType.memoryAllocation, kw ? kw.def : '(Memory)'));
+        }
+    }
+    return items;
+}
+
+function _completeInstructions(words, registry, items) {
+    const partial = (words[0] || '').toLowerCase();
+    for (const k of KEYWORD_LIST) {
+        if (INSTRUCTION_TYPES.has(k.type) && k.name.toLowerCase().startsWith(partial))
+            items.push(_makeItem(k.name, k.type, Utils.getType(k.type), k.def));
+    }
+    for (const m of registry.macros) {
+        if (m.name.toLowerCase().startsWith(partial))
+            items.push(_makeItem(m.name, KeywordType.macro, "(Macro)", m.doc || '', null, "01"));
+    }
+}
+
+function _deduplicate(items) {
+    const seen = new Set();
+    return items.filter(item => {
+        if (seen.has(item.label)) return false;
+        seen.add(item.label);
+        return true;
+    });
+}
+
+// -------------------------------------------------------
+// Helpers
+// -------------------------------------------------------
+
+function getOperandIndex(line) {
+    return line.split(";")[0].split(",").length - 1;
+}
+
+function getAllowedOperandTypes(instruction, operandIndex) {
+    const sigs = INSTRUCTION_SIGNATURES[instruction];
+    if (!sigs) return null;
+    let types = 0, found = false;
+    for (const sig of sigs) {
+        if (sig.length > operandIndex) { types |= sig[operandIndex]; found = true; }
+    }
+    return found ? types : undefined;
+}
+
+function _regPrefix(reg) {
+    const r = reg.toLowerCase();
+    if (/^(xmm|ymm|zmm)\d+$/.test(r) || /^k\d+$/.test(r)) return "05";
+    if (/^(r(ax|bx|cx|dx|si|di|bp|sp)|r\d+)$/.test(r))    return "03";
+    if (/^(e(ax|bx|cx|dx|si|di|bp|sp)|r\d+d)$/.test(r))   return "03";
+    return "04";
+}
+
+function _makeItem(label, kindType, detail = '', doc = "", insertText = null, sortPrefix = "02") {
+    return { label, kindType, detail, doc, sortText: sortPrefix + "_" + label, insertText };
+}
+
+module.exports = { getCompletionItems, getAllowedOperandTypes, getOperandIndex };

package/out/core/diagnosticEngine.js

@@ -0,0 +1,305 @@
+"use strict";
+
+const { KEYWORD_DICTIONARY } = require("../data/keywords");
+const { KeywordType, AllowKinds } = require("../data/enums");
+const { INSTRUCTION_SIGNATURES } = require("../data/instructionSignatures");
+const { OperandType } = require("../data/operandTypes");
+
+const REG_SIZE = {
+    8:   ["al","bl","cl","dl","ah","bh","ch","dh","sil","dil","bpl","spl",
+           "r8b","r9b","r10b","r11b","r12b","r13b","r14b","r15b"],
+    16:  ["ax","bx","cx","dx","si","di","bp","sp",
+           "r8w","r9w","r10w","r11w","r12w","r13w","r14w","r15w"],
+    32:  ["eax","ebx","ecx","edx","esi","edi","ebp","esp",
+           "r8d","r9d","r10d","r11d","r12d","r13d","r14d","r15d"],
+    64:  ["rax","rbx","rcx","rdx","rsi","rdi","rbp","rsp",
+           "r8","r9","r10","r11","r12","r13","r14","r15","rip"],
+    128: [],
+    256: [],
+    512: [],
+};
+for (let i = 0; i < 16; i++) REG_SIZE[128].push(`xmm${i}`);
+for (let i = 0; i < 16; i++) REG_SIZE[256].push(`ymm${i}`);
+for (let i = 0; i < 32; i++) REG_SIZE[512].push(`zmm${i}`);
+
+const REG_BITS = {};
+for (const [bits, regs] of Object.entries(REG_SIZE)) {
+    for (const r of regs) REG_BITS[r] = Number(bits);
+}
+
+const KEYWORD_MAP = new Map(KEYWORD_DICTIONARY.map(k => [k.name.toLowerCase(), k]));
+
+/**
+ * Analyze lines and return plain diagnostic objects.
+ * @param {string[]} lines
+ * @param {object} registry
+ * @returns {{ line: number, startCol: number, endCol: number, message: string, severity: 'error'|'warning' }[]}
+ */
+function analyzeDiagnostics(lines, registry) {
+    const diags = [];
+    _checkLevel1(lines, diags);
+    _checkLevel2(lines, diags, registry);
+    _checkLevel3(lines, diags);
+    return diags;
+}
+
+// ==========================================
+// Level 1: Syntax
+// ==========================================
+function _checkLevel1(lines, diags) {
+    _checkDuplicateLabels(lines, diags);
+    _checkUnclosedBlocks(lines, diags);
+}
+
+function _checkDuplicateLabels(lines, diags) {
+    const seen = new Map();
+    for (let i = 0; i < lines.length; i++) {
+        const lineNoComment = lines[i].split(';')[0].trimEnd();
+        if (!lineNoComment.trimStart().endsWith(':')) continue;
+        const name = lineNoComment.trim().slice(0, -1).trim().toLowerCase();
+        if (!name) continue;
+        if (name.startsWith('%%')) continue;
+        if (seen.has(name)) {
+            diags.push(_makeDiag(i, lines[i].indexOf(name.charAt(0)), name.length,
+                `Duplicate label '${name}' (first defined at line ${seen.get(name) + 1})`,
+                'error'));
+        } else {
+            seen.set(name, i);
+        }
+    }
+}
+
+function _checkUnclosedBlocks(lines, diags) {
+    const procStack = [], macroStack = [], ifStack = [], tasmMacStack = [];
+
+    for (let i = 0; i < lines.length; i++) {
+        const clean = lines[i].split(';')[0].trim().toLowerCase();
+        if (!clean) continue;
+        const words  = clean.split(/\s+/);
+        const first  = words[0];
+        const second = words[1] || '';
+
+        if (second === "proc")     procStack.push(i);
+        if (first === "endp") {
+            if (procStack.length === 0) diags.push(_makeDiag(i, 0, 4, "'endp' without matching 'proc'", 'error'));
+            else procStack.pop();
+        }
+        if (first === "%macro")    macroStack.push(i);
+        if (first === "%endmacro") {
+            if (macroStack.length === 0) diags.push(_makeDiag(i, 0, 8, "'%endmacro' without matching '%macro'", 'error'));
+            else macroStack.pop();
+        }
+        if (["%if","%ifdef","%ifndef"].includes(first)) ifStack.push(i);
+        if (first === "%endif") {
+            if (ifStack.length === 0) diags.push(_makeDiag(i, 0, 6, "'%endif' without matching '%if'", 'error'));
+            else ifStack.pop();
+        }
+        if (second === "macro")  tasmMacStack.push(i);
+        if (first === "endm") {
+            if (tasmMacStack.length === 0) diags.push(_makeDiag(i, 0, 4, "'endm' without matching 'macro'", 'error'));
+            else tasmMacStack.pop();
+        }
+    }
+
+    for (const li of procStack)    diags.push(_makeDiag(li, 0, 4, `'proc' is never closed with 'endp'`, 'error'));
+    for (const li of macroStack)   diags.push(_makeDiag(li, 0, 6, `'%macro' is never closed with '%endmacro'`, 'error'));
+    for (const li of ifStack)      diags.push(_makeDiag(li, 0, 3, `'%if' block is never closed with '%endif'`, 'error'));
+    for (const li of tasmMacStack) diags.push(_makeDiag(li, 0, 5, `'macro' is never closed with 'endm'`, 'error'));
+}
+
+// ==========================================
+// Level 2: Reference
+// ==========================================
+function _checkLevel2(lines, diags, registry) {
+    const jumpOps = ["jmp","je","jne","jz","jnz","jg","jl","jge","jle",
+                     "ja","jb","jae","jbe","jc","jnc","js","jns","jo","jno",
+                     "jcxz","jecxz","jrcxz","loop","loope","loopne"];
+
+    const knownLabels = new Set([
+        ...registry.labels.map(l => l.name.toLowerCase()),
+        ...registry.procs.map(p => p.name.toLowerCase())
+    ]);
+    const knownVars = new Set(registry.vars.map(v => v.name.toLowerCase()));
+
+    for (let i = 0; i < lines.length; i++) {
+        const lineNoComment = lines[i].split(';')[0];
+        const clean = lineNoComment.trim().toLowerCase();
+        if (!clean) continue;
+        const words = clean.split(/[\s,]+/).filter(w => w.length > 0);
+        if (words.length < 2) continue;
+        const first = words[0];
+
+        if (jumpOps.includes(first) || first === "call") {
+            const target = words[1];
+            if (!_isNumber(target) && !target.startsWith('[') && !target.startsWith('0x')) {
+                if (!knownLabels.has(target)) {
+                    const col = lineNoComment.toLowerCase().indexOf(target, first.length);
+                    diags.push(_makeDiag(i, col, target.length,
+                        `Undefined label or procedure '${target}'`, 'warning'));
+                }
+            }
+        }
+
+        const dataOps = ["mov","add","sub","cmp","and","or","xor","test","lea","movzx","movsx"];
+        if (dataOps.includes(first)) {
+            for (let w = 1; w < words.length; w++) {
+                const word = words[w].replace(/[\[\]]/g, '');
+                if (_isRegister(word) || _isNumber(word) || _isSizeKeyword(word)) continue;
+                if (/^[a-z_][a-z0-9_]*$/.test(word) && !knownVars.has(word) && !knownLabels.has(word)) {
+                    const col = lineNoComment.toLowerCase().indexOf(word, first.length);
+                    if (col !== -1) {
+                        diags.push(_makeDiag(i, col, word.length,
+                            `'${word}' is not defined as a variable or label`, 'warning'));
+                    }
+                }
+            }
+        }
+    }
+}
+
+// ==========================================
+// Level 3: Instruction Validation
+// ==========================================
+function _checkLevel3(lines, diags) {
+    for (let i = 0; i < lines.length; i++) {
+        const lineNoComment = lines[i].split(';')[0];
+        const clean = lineNoComment.trim().toLowerCase();
+        if (!clean || clean.endsWith(':')) continue;
+
+        const spaceIdx = clean.search(/[\s\t]/);
+        if (spaceIdx === -1) continue;
+
+        const opcode = clean.substring(0, spaceIdx).trim();
+        const kw = KEYWORD_MAP.get(opcode);
+        if (!kw) continue;
+        if (kw.type !== KeywordType.instruction) continue;
+
+        const operandStr = clean.substring(spaceIdx).trim();
+        const operands = operandStr.split(',').map(o => o.trim()).filter(o => o.length > 0);
+
+        const sigForms = INSTRUCTION_SIGNATURES[opcode];
+        const validBySig = sigForms?.some(sig => sig.length === operands.length);
+        if (kw.opCount >= 0 && operands.length !== kw.opCount && !validBySig) {
+            const col = lineNoComment.toLowerCase().indexOf(opcode);
+            diags.push(_makeDiag(i, col, opcode.length,
+                `'${opcode}' requires ${kw.opCount} operand(s), got ${operands.length}`, 'error'));
+            continue;
+        }
+
+        if (kw.opCount === 1 && operands.length === 1) {
+            const op = operands[0].replace(/[\[\]]/g, '').trim();
+            _checkOperandType(i, lineNoComment, op, opcode, kw.allowType, diags);
+        }
+
+        if (kw.opCount === 2 && operands.length === 2) {
+            _checkSizeMismatch(i, lineNoComment, opcode, operands, diags);
+        }
+
+        if (sigForms && operands.length >= 2) {
+            const types = operands.map(o => _classifyOperand(o));
+            const matched = sigForms.some(sig =>
+                sig.length === operands.length &&
+                sig.every((expected, j) => types[j] & expected)
+            );
+            if (!matched) {
+                const col = lineNoComment.toLowerCase().indexOf(opcode);
+                diags.push(_makeDiag(i, col, opcode.length,
+                    `'${opcode}' has no valid form for (${types.map(t => _typeName(t)).join(', ')})`, 'warning'));
+            }
+        }
+    }
+}
+
+function _checkOperandType(lineIdx, rawLine, operand, opcode, allowType, diags) {
+    if (allowType === AllowKinds.label) {
+        if (_isRegister(operand) || _isNumber(operand)) {
+            const col = rawLine.toLowerCase().indexOf(operand, opcode.length);
+            diags.push(_makeDiag(lineIdx, col, operand.length,
+                `'${opcode}' expects a label, not '${operand}'`, 'error'));
+        }
+        return;
+    }
+    if (allowType === AllowKinds.constants) {
+        if (!_isNumber(operand)) {
+            const col = rawLine.toLowerCase().indexOf(operand, opcode.length);
+            diags.push(_makeDiag(lineIdx, col, operand.length,
+                `'${opcode}' expects a constant, not '${operand}'`, 'error'));
+        }
+    }
+}
+
+function _checkSizeMismatch(lineIdx, rawLine, opcode, operands, diags) {
+    const sizeConvOps = ["movzx", "movsx", "movsxd"];
+    if (sizeConvOps.includes(opcode)) return;
+
+    const SIZE_KEYWORD_BITS = {
+        "byte": 8, "word": 16, "dword": 32, "qword": 64,
+        "tbyte": 80, "oword": 128, "yword": 256, "zword": 512
+    };
+
+    const getInfo = (op) => {
+        let s = op.replace(/\[/g, ' ').replace(/\]/g, ' ').trim();
+        const tokens = s.split(/\s+/).filter(t => t.length > 0);
+        let sizeKeyword = null, reg = null;
+        for (const t of tokens) {
+            if (SIZE_KEYWORD_BITS[t] !== undefined) sizeKeyword = t;
+            else if (REG_BITS[t] !== undefined) reg = t;
+        }
+        if (sizeKeyword) return { bits: SIZE_KEYWORD_BITS[sizeKeyword], label: sizeKeyword, token: sizeKeyword };
+        if (reg)         return { bits: REG_BITS[reg], label: reg, token: reg };
+        return null;
+    };
+
+    const info1 = getInfo(operands[0]);
+    const info2 = getInfo(operands[1]);
+    if (!info1 || !info2 || info1.bits === info2.bits) return;
+
+    const commaIdx = rawLine.indexOf(',');
+    const searchFrom = commaIdx !== -1 ? commaIdx : 0;
+    const col = rawLine.toLowerCase().indexOf(info2.token, searchFrom);
+
+    diags.push(_makeDiag(lineIdx, col, info2.token.length,
+        `Size mismatch: '${info1.label}' is ${info1.bits}-bit but '${info2.label}' is ${info2.bits}-bit`, 'error'));
+}
+
+// ==========================================
+// Helpers
+// ==========================================
+function _makeDiag(line, col, length, message, severity) {
+    const startCol = Math.max(0, col);
+    return { line, startCol, endCol: startCol + length, message, severity };
+}
+
+function _classifyOperand(op) {
+    if (op.includes('[')) return OperandType.MEM;
+    const tokens = op.split(/\s+/).filter(t => t.length > 0);
+    if (tokens.some(t => _isRegister(t))) return OperandType.REG;
+    if (tokens.length === 1 && _isNumber(tokens[0])) return OperandType.IMM;
+    return OperandType.LABEL | OperandType.IMM;
+}
+
+function _typeName(bits) {
+    if ((bits & 3) === 3) return 'r/m';
+    if (bits & OperandType.REG)   return 'reg';
+    if (bits & OperandType.MEM)   return 'mem';
+    if (bits & OperandType.IMM)   return 'imm';
+    if (bits & OperandType.LABEL) return 'label';
+    return '?';
+}
+
+function _isRegister(word) {
+    return word in REG_BITS ||
+           /^(xmm|ymm|zmm)\d+$/.test(word) ||
+           /^r\d+(b|w|d)?$/.test(word);
+}
+
+function _isNumber(word) {
+    return /^0x[0-9a-f]+$/i.test(word) ||
+           /^[0-9][0-9a-f]*(h|b|d)?$/i.test(word);
+}
+
+function _isSizeKeyword(word) {
+    return ["byte","word","dword","qword","tbyte","oword","yword","zword","ptr","rel","near","far","short"].includes(word);
+}
+
+module.exports = { analyzeDiagnostics };

package/out/core/foldingEngine.js

@@ -0,0 +1,55 @@
+"use strict";
+
+const PROC_START  = /^\s*[A-Za-z_.$?][\w.$?]*\s+proc\b/i;
+const PROC_END    = /^\s*endp\s*(?:;.*)?$/i;
+const MACRO_START = /^\s*%macro\b/i;
+const MACRO_END   = /^\s*%endmacro\s*(?:;.*)?$/i;
+const STRUC_START = /^\s*[A-Za-z_.$?][\w.$?]*\s+struc\b/i;
+const STRUC_END   = /^\s*ends\s*(?:;.*)?$/i;
+const SECTION_RE  = /^\s*(section|segment)\b/i;
+
+/**
+ * Compute folding ranges for document lines.
+ * @param {string[]} lines
+ * @returns {{ start: number, end: number, kind: 'region'|null }[]}
+ */
+function getFoldingRanges(lines) {
+    const ranges = [];
+    const count  = lines.length;
+
+    const procStack  = [];
+    const macroStack = [];
+    const strucStack = [];
+    let   sectionStart = -1;
+
+    for (let i = 0; i < count; i++) {
+        const line = lines[i];
+
+        if (SECTION_RE.test(line)) {
+            if (sectionStart >= 0) {
+                let end = i - 1;
+                while (end > sectionStart && lines[end].trim() === '') end--;
+                if (end > sectionStart) ranges.push({ start: sectionStart, end, kind: 'region' });
+            }
+            sectionStart = i;
+            continue;
+        }
+
+        if (PROC_START.test(line))  { procStack.push(i);  continue; }
+        if (PROC_END.test(line)  && procStack.length)  { const s = procStack.pop();  if (i > s) ranges.push({ start: s, end: i, kind: null }); continue; }
+        if (MACRO_START.test(line)) { macroStack.push(i); continue; }
+        if (MACRO_END.test(line) && macroStack.length) { const s = macroStack.pop(); if (i > s) ranges.push({ start: s, end: i, kind: null }); continue; }
+        if (STRUC_START.test(line)) { strucStack.push(i); continue; }
+        if (STRUC_END.test(line) && strucStack.length)  { const s = strucStack.pop();  if (i > s) ranges.push({ start: s, end: i, kind: null }); continue; }
+    }
+
+    if (sectionStart >= 0) {
+        let end = count - 1;
+        while (end > sectionStart && lines[end].trim() === '') end--;
+        if (end > sectionStart) ranges.push({ start: sectionStart, end, kind: 'region' });
+    }
+
+    return ranges;
+}
+
+module.exports = { getFoldingRanges };

package/out/core/hoverEngine.js

@@ -0,0 +1,62 @@
+"use strict";
+
+const { Utils } = require("../utils");
+const { INSTRUCTION_SIGNATURES } = require("../data/instructionSignatures");
+
+/**
+ * Get hover content for a word.
+ * @param {string} word
+ * @param {object} registry
+ * @returns {{ language: string, value: string }[] | null}
+ */
+function getHoverContent(word, registry) {
+    const output = [];
+    const proc     = registry.findProcedure(word);
+    const variable = registry.findVariable(word);
+    const keyword  = registry.getKeyword(word);
+    const macro    = registry.findMacro(word);
+    const label    = registry.findLabel(word);
+
+    if (Utils.isNumberStr(word)) {
+        output.push({ language: "assembly", value: Utils.getNumMsg(word) });
+    } else if (variable) {
+        output.push({
+            language: "assembly",
+            value: `(Variable) ${variable.name}: ${variable.type}${variable.section ? "  [section " + variable.section + "]" : ""}`
+        });
+    } else if (proc) {
+        output.push(
+            { language: "assembly", value: "(Procedure) " + proc.name },
+            { language: "plainText", value: proc.description.des },
+            { language: "assembly", value: proc.description.paramsString() },
+            { language: "assembly", value: proc.description.outputs() }
+        );
+    } else if (macro) {
+        const argStr  = macro.argCount !== undefined ? `  — ${macro.argCount} arg${macro.argCount !== 1 ? 's' : ''}` : '';
+        const lineStr = macro.line !== undefined ? `  [line ${macro.line + 1}]` : '';
+        output.push({ language: "assembly", value: "(Macro) " + macro.name + argStr + lineStr });
+    } else if (keyword) {
+        output.push(
+            { language: "assembly", value: Utils.getType(keyword.type) + " " + keyword.name },
+            { language: "plainText", value: keyword.def },
+            { language: "assembly", value: "Syntax: " + keyword.data }
+        );
+        const sigs = INSTRUCTION_SIGNATURES[word.toLowerCase()];
+        if (sigs?.length) {
+            const ts = b => ((b&3)===3)?'r/m':(b&1)?'reg':(b&2)?'mem':(b&4)?'imm':(b&8)?'label':'?';
+            const forms = sigs.map(f =>
+                f.length ? `${word.toLowerCase()} ${f.map(ts).join(', ')}` : word.toLowerCase()
+            ).join('\n');
+            output.push({ language: 'assembly', value: forms });
+        }
+    } else if (label) {
+        const lineInfo = label.line !== undefined
+            ? `  [line ${label.line + 1}]`
+            : (label.value ? ` => ${label.value}` : '');
+        output.push({ language: 'assembly', value: '(Label) ' + label.name + lineInfo });
+    }
+
+    return output.length > 0 ? output : null;
+}
+
+module.exports = { getHoverContent };