@razdolbai/merls 0.1.0

package/dist/src/asm/expression.js

@@ -0,0 +1,163 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseExpression = parseExpression;
+exports.parseOperand = parseOperand;
+const binaryPrecedence = new Map([
+    ["+", 10],
+    ["-", 10],
+    ["*", 20],
+    ["/", 20]
+]);
+function parseExpression(tokens, startIndex = 0, minimumPrecedence = 0) {
+    let { expression: left, nextTokenIndex } = parsePrefix(tokens, startIndex);
+    while (nextTokenIndex < tokens.length) {
+        const operatorToken = tokens[nextTokenIndex];
+        if (operatorToken?.kind !== "expressionOperator") {
+            break;
+        }
+        const precedence = binaryPrecedence.get(operatorToken.lexeme);
+        if (precedence === undefined || precedence < minimumPrecedence) {
+            break;
+        }
+        const parsedRight = parseExpression(tokens, nextTokenIndex + 1, precedence + 1);
+        left = {
+            kind: "binary",
+            operator: operatorToken.lexeme,
+            left,
+            right: parsedRight.expression
+        };
+        nextTokenIndex = parsedRight.nextTokenIndex;
+    }
+    return {
+        expression: left,
+        nextTokenIndex
+    };
+}
+function parseOperand(tokens, startIndex = 0) {
+    let index = startIndex;
+    let immediate = false;
+    let indirect = false;
+    let indexRegister = null;
+    if (tokens[index]?.kind === "expressionOperator" && tokens[index]?.lexeme === "#") {
+        immediate = true;
+        index += 1;
+    }
+    if (tokens[index]?.kind === "numericLiteral" && tokens[index]?.lexeme.startsWith("#")) {
+        immediate = true;
+        const token = tokens[index];
+        const expression = {
+            kind: "numericLiteral",
+            value: token.lexeme.slice(1)
+        };
+        return {
+            operand: {
+                immediate,
+                indirect,
+                indexRegister,
+                expression
+            },
+            nextTokenIndex: index + 1
+        };
+    }
+    let parsedExpression;
+    if (tokens[index]?.kind === "expressionOperator" && tokens[index]?.lexeme === "(") {
+        indirect = true;
+        parsedExpression = parseExpression(tokens, index + 1);
+        index = parsedExpression.nextTokenIndex;
+        if (tokens[index]?.kind === "expressionOperator" && tokens[index]?.lexeme === ",") {
+            indexRegister = parseIndexRegister(tokens[index + 1]);
+            index += 2;
+        }
+        expectOperator(tokens[index], ")");
+        index += 1;
+        if (tokens[index]?.kind === "expressionOperator" && tokens[index]?.lexeme === ",") {
+            indexRegister = parseIndexRegister(tokens[index + 1]);
+            index += 2;
+        }
+    }
+    else {
+        parsedExpression = parseExpression(tokens, index);
+        index = parsedExpression.nextTokenIndex;
+        if (tokens[index]?.kind === "expressionOperator" && tokens[index]?.lexeme === ",") {
+            indexRegister = parseIndexRegister(tokens[index + 1]);
+            index += 2;
+        }
+    }
+    return {
+        operand: {
+            immediate,
+            indirect,
+            indexRegister,
+            expression: parsedExpression.expression
+        },
+        nextTokenIndex: index
+    };
+}
+function parsePrefix(tokens, startIndex) {
+    const token = tokens[startIndex];
+    if (token === undefined) {
+        throw new Error("expected expression token");
+    }
+    if (token.kind === "numericLiteral") {
+        return {
+            expression: {
+                kind: "numericLiteral",
+                value: token.lexeme
+            },
+            nextTokenIndex: startIndex + 1
+        };
+    }
+    if (token.kind === "identifier" || token.kind === "label" || token.kind === "localLabel") {
+        return {
+            expression: {
+                kind: "identifier",
+                value: token.lexeme
+            },
+            nextTokenIndex: startIndex + 1
+        };
+    }
+    if (token.kind === "string") {
+        return {
+            expression: {
+                kind: "string",
+                value: token.lexeme.slice(1, -1)
+            },
+            nextTokenIndex: startIndex + 1
+        };
+    }
+    if (token.kind === "modifier") {
+        const parsedInner = parsePrefix(tokens, startIndex + 1);
+        return {
+            expression: {
+                kind: "modifier",
+                operator: token.lexeme,
+                expression: parsedInner.expression
+            },
+            nextTokenIndex: parsedInner.nextTokenIndex
+        };
+    }
+    if (token.kind === "expressionOperator" && token.lexeme === "(") {
+        const parsedInner = parseExpression(tokens, startIndex + 1);
+        expectOperator(tokens[parsedInner.nextTokenIndex], ")");
+        return {
+            expression: parsedInner.expression,
+            nextTokenIndex: parsedInner.nextTokenIndex + 1
+        };
+    }
+    if (token.kind === "expressionOperator" && token.lexeme === "#") {
+        return parsePrefix(tokens, startIndex + 1);
+    }
+    throw new Error(`unexpected expression token: ${token.lexeme}`);
+}
+function expectOperator(token, lexeme) {
+    if (token?.kind !== "expressionOperator" || token.lexeme !== lexeme) {
+        throw new Error(`expected operator ${lexeme}`);
+    }
+}
+function parseIndexRegister(token) {
+    const normalized = token?.lexeme.toLowerCase();
+    if (token?.kind === "identifier" && (normalized === "x" || normalized === "y")) {
+        return normalized;
+    }
+    throw new Error("expected index register");
+}

package/dist/src/asm/lexer.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lexSource = lexSource;
+const metadata_1 = require("./metadata");
+const operatorCharacters = new Set(["(", ")", ",", "#", "+", "-", "*", "/", "=", "<", ">", "^"]);
+function lexSource(source) {
+    const lines = source.split(/\r?\n/).map((text, index) => lexLine(text, index));
+    return { lines };
+}
+function lexLine(text, line) {
+    const tokens = [];
+    const firstNonWhitespace = text.search(/\S/);
+    if (firstNonWhitespace === -1) {
+        return { line, text, tokens };
+    }
+    const trimmed = text.slice(firstNonWhitespace);
+    if (trimmed.startsWith(";") || (firstNonWhitespace === 0 && trimmed.startsWith("*"))) {
+        tokens.push(createToken("comment", text.slice(firstNonWhitespace), firstNonWhitespace, text.length));
+        return { line, text, tokens };
+    }
+    let index = firstNonWhitespace;
+    let sawOperation = false;
+    while (index < text.length) {
+        const char = text[index];
+        if (char === " " || char === "\t") {
+            index += 1;
+            continue;
+        }
+        if (char === ";") {
+            tokens.push(createToken("comment", text.slice(index), index, text.length));
+            break;
+        }
+        if (char === '"' || char === "'") {
+            const end = consumeString(text, index);
+            tokens.push(createToken("string", text.slice(index, end), index, end));
+            index = end;
+            continue;
+        }
+        if (operatorCharacters.has(char)) {
+            const numericLiteral = consumeNumericLiteral(text, index);
+            if (numericLiteral !== null) {
+                tokens.push(createToken("numericLiteral", numericLiteral.lexeme, index, numericLiteral.end));
+                index = numericLiteral.end;
+                continue;
+            }
+            const operatorKind = char === "<" || char === ">" || char === "^"
+                ? "modifier"
+                : "expressionOperator";
+            tokens.push(createToken(operatorKind, char, index, index + 1));
+            index += 1;
+            continue;
+        }
+        const end = consumeWord(text, index);
+        const lexeme = text.slice(index, end);
+        const kind = classifyWord(text, lexeme, index, end, tokens.length === 0, sawOperation, firstNonWhitespace);
+        tokens.push(createToken(kind, lexeme, index, end));
+        sawOperation ||= kind === "directive" || kind === "mnemonic";
+        index = end;
+    }
+    return { line, text, tokens };
+}
+function createToken(kind, lexeme, start, end) {
+    return {
+        kind,
+        lexeme,
+        start,
+        end
+    };
+}
+function consumeString(text, start) {
+    const quote = text[start];
+    let index = start + 1;
+    while (index < text.length) {
+        if (text[index] === quote) {
+            return index + 1;
+        }
+        index += 1;
+    }
+    return text.length;
+}
+function consumeNumericLiteral(text, start) {
+    const prefixed = text.slice(start).match(/^#?(?:\$[0-9A-Fa-f]+|%[01]+|\d+)/);
+    if (prefixed !== null) {
+        return {
+            lexeme: prefixed[0],
+            end: start + prefixed[0].length
+        };
+    }
+    return null;
+}
+function consumeWord(text, start) {
+    let index = start;
+    while (index < text.length) {
+        const char = text[index];
+        if (char === " " || char === "\t" || char === ";" || operatorCharacters.has(char)) {
+            break;
+        }
+        index += 1;
+    }
+    return index;
+}
+function classifyWord(text, lexeme, start, end, isFirstToken, sawOperation, firstNonWhitespace) {
+    const normalized = lexeme.toLowerCase();
+    if (metadata_1.opcodeTable.has(normalized)) {
+        return "mnemonic";
+    }
+    if (metadata_1.directiveTable.has(normalized)) {
+        return "directive";
+    }
+    if (lexeme.startsWith("]") || lexeme.startsWith(":")) {
+        return "localLabel";
+    }
+    if (/^(?:\$[0-9A-Fa-f]+|%[01]+|\d+)$/.test(lexeme)) {
+        return "numericLiteral";
+    }
+    const trailingText = text.slice(end);
+    const looksLikeLabelBoundary = trailingText.length === 0 || /^[\t ]/.test(trailingText);
+    if (isFirstToken && !sawOperation && firstNonWhitespace === 0 && looksLikeLabelBoundary) {
+        return "label";
+    }
+    return "identifier";
+}

package/dist/src/asm/local-labels.js

@@ -0,0 +1,140 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveLocalLabels = resolveLocalLabels;
+function resolveLocalLabels(document) {
+    const definitions = new Map();
+    const references = new Map();
+    const definitionsByAnchor = new Map();
+    let currentAnchor = null;
+    for (const line of document.lines) {
+        currentAnchor = updateAnchor(currentAnchor, line.node, line.line);
+        const localDefinition = getLocalDefinition(line.node);
+        if (currentAnchor === null || localDefinition === null) {
+            continue;
+        }
+        const qualifiedName = qualifyName(localDefinition, currentAnchor.line);
+        const definition = {
+            name: localDefinition,
+            line: line.line,
+            anchor: currentAnchor.name,
+            qualifiedName
+        };
+        definitions.set(qualifiedName, definition);
+        let anchorDefinitions = definitionsByAnchor.get(currentAnchor.name);
+        if (anchorDefinitions === undefined) {
+            anchorDefinitions = new Map();
+            definitionsByAnchor.set(currentAnchor.name, anchorDefinitions);
+        }
+        anchorDefinitions.set(localDefinition, definition);
+    }
+    currentAnchor = null;
+    for (const line of document.lines) {
+        currentAnchor = updateAnchor(currentAnchor, line.node, line.line);
+        if (currentAnchor === null) {
+            continue;
+        }
+        const anchorDefinitions = definitionsByAnchor.get(currentAnchor.name);
+        if (anchorDefinitions === undefined) {
+            continue;
+        }
+        for (const localName of findLocalReferences(line.node)) {
+            const target = anchorDefinitions.get(localName);
+            if (target === undefined) {
+                continue;
+            }
+            references.set(qualifyName(localName, line.line), {
+                name: localName,
+                line: line.line,
+                anchor: currentAnchor.name,
+                qualifiedName: target.qualifiedName,
+                targetLine: target.line
+            });
+        }
+    }
+    return {
+        definitions,
+        references
+    };
+}
+function updateAnchor(currentAnchor, node, line) {
+    const label = getGlobalLabel(node);
+    if (label === null) {
+        return currentAnchor;
+    }
+    return {
+        name: label,
+        line
+    };
+}
+function getGlobalLabel(node) {
+    if (node.shape === "equate" && !isLocalLabel(node.label)) {
+        return node.label;
+    }
+    if (node.shape === "labelOnly" && !isLocalLabel(node.label)) {
+        return node.label;
+    }
+    if (node.shape === "instruction" && node.label !== null && !isLocalLabel(node.label)) {
+        return node.label;
+    }
+    if (node.shape === "directive" && node.label !== null && !isLocalLabel(node.label)) {
+        return node.label;
+    }
+    if (node.shape === "data" && node.label !== null && !isLocalLabel(node.label)) {
+        return node.label;
+    }
+    return null;
+}
+function getLocalDefinition(node) {
+    if (node.shape === "labelOnly" && isLocalLabel(node.label)) {
+        return node.label;
+    }
+    if (node.shape === "instruction" && node.label !== null && isLocalLabel(node.label)) {
+        return node.label;
+    }
+    if (node.shape === "directive" && node.label !== null && isLocalLabel(node.label)) {
+        return node.label;
+    }
+    if (node.shape === "data" && node.label !== null && isLocalLabel(node.label)) {
+        return node.label;
+    }
+    if (node.shape === "equate" && isLocalLabel(node.label)) {
+        return node.label;
+    }
+    return null;
+}
+function findLocalReferences(node) {
+    if (node.shape === "instruction" && node.operand !== null) {
+        return findLocalNamesInOperand(node.operand);
+    }
+    if (node.shape === "directive" && node.operand !== null) {
+        return findLocalNamesInExpression(node.operand);
+    }
+    if (node.shape === "equate") {
+        return findLocalNamesInExpression(node.expression);
+    }
+    return [];
+}
+function findLocalNamesInOperand(operand) {
+    return findLocalNamesInExpression(operand.expression);
+}
+function findLocalNamesInExpression(expression) {
+    switch (expression.kind) {
+        case "identifier":
+            return isLocalLabel(expression.value) ? [expression.value] : [];
+        case "modifier":
+            return findLocalNamesInExpression(expression.expression);
+        case "binary":
+            return [
+                ...findLocalNamesInExpression(expression.left),
+                ...findLocalNamesInExpression(expression.right)
+            ];
+        default:
+            return [];
+    }
+}
+function isLocalLabel(name) {
+    return name.startsWith("]") || name.startsWith(":");
+}
+function qualifyName(name, line) {
+    return `${name}@${line}`;
+}

package/dist/src/asm/metadata.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.directiveTable = exports.directiveDefinitions = exports.opcodeTable = exports.opcodeDefinitions = void 0;
+function defineOpcode(mnemonic, modes) {
+    return {
+        mnemonic,
+        modes
+    };
+}
+function defineDirective(name, kind, supported, summary) {
+    return {
+        name,
+        kind,
+        supported,
+        summary
+    };
+}
+exports.opcodeDefinitions = [
+    defineOpcode("adc", ["immediate", "zeroPage", "zeroPageX", "absolute", "absoluteX", "absoluteY", "indexedIndirect", "indirectIndexed"]),
+    defineOpcode("and", ["immediate", "zeroPage", "zeroPageX", "absolute", "absoluteX", "absoluteY", "indexedIndirect", "indirectIndexed"]),
+    defineOpcode("asl", ["accumulator", "zeroPage", "zeroPageX", "absolute", "absoluteX"]),
+    defineOpcode("bcc", ["relative"]),
+    defineOpcode("bcs", ["relative"]),
+    defineOpcode("beq", ["relative"]),
+    defineOpcode("bit", ["zeroPage", "absolute"]),
+    defineOpcode("bmi", ["relative"]),
+    defineOpcode("bne", ["relative"]),
+    defineOpcode("bpl", ["relative"]),
+    defineOpcode("brk", ["implied"]),
+    defineOpcode("bvc", ["relative"]),
+    defineOpcode("bvs", ["relative"]),
+    defineOpcode("clc", ["implied"]),
+    defineOpcode("cld", ["implied"]),
+    defineOpcode("cli", ["implied"]),
+    defineOpcode("clv", ["implied"]),
+    defineOpcode("cmp", ["immediate", "zeroPage", "zeroPageX", "absolute", "absoluteX", "absoluteY", "indexedIndirect", "indirectIndexed"]),
+    defineOpcode("cpx", ["immediate", "zeroPage", "absolute"]),
+    defineOpcode("cpy", ["immediate", "zeroPage", "absolute"]),
+    defineOpcode("dec", ["zeroPage", "zeroPageX", "absolute", "absoluteX"]),
+    defineOpcode("dex", ["implied"]),
+    defineOpcode("dey", ["implied"]),
+    defineOpcode("eor", ["immediate", "zeroPage", "zeroPageX", "absolute", "absoluteX", "absoluteY", "indexedIndirect", "indirectIndexed"]),
+    defineOpcode("inc", ["zeroPage", "zeroPageX", "absolute", "absoluteX"]),
+    defineOpcode("inx", ["implied"]),
+    defineOpcode("iny", ["implied"]),
+    defineOpcode("jmp", ["absolute", "indirect"]),
+    defineOpcode("jsr", ["absolute"]),
+    defineOpcode("lda", ["immediate", "zeroPage", "zeroPageX", "absolute", "absoluteX", "absoluteY", "indexedIndirect", "indirectIndexed"]),
+    defineOpcode("ldx", ["immediate", "zeroPage", "zeroPageY", "absolute", "absoluteY"]),
+    defineOpcode("ldy", ["immediate", "zeroPage", "zeroPageX", "absolute", "absoluteX"]),
+    defineOpcode("lsr", ["accumulator", "zeroPage", "zeroPageX", "absolute", "absoluteX"]),
+    defineOpcode("nop", ["implied"]),
+    defineOpcode("ora", ["immediate", "zeroPage", "zeroPageX", "absolute", "absoluteX", "absoluteY", "indexedIndirect", "indirectIndexed"]),
+    defineOpcode("pha", ["implied"]),
+    defineOpcode("php", ["implied"]),
+    defineOpcode("pla", ["implied"]),
+    defineOpcode("plp", ["implied"]),
+    defineOpcode("rol", ["accumulator", "zeroPage", "zeroPageX", "absolute", "absoluteX"]),
+    defineOpcode("ror", ["accumulator", "zeroPage", "zeroPageX", "absolute", "absoluteX"]),
+    defineOpcode("rti", ["implied"]),
+    defineOpcode("rts", ["implied"]),
+    defineOpcode("sbc", ["immediate", "zeroPage", "zeroPageX", "absolute", "absoluteX", "absoluteY", "indexedIndirect", "indirectIndexed"]),
+    defineOpcode("sec", ["implied"]),
+    defineOpcode("sed", ["implied"]),
+    defineOpcode("sei", ["implied"]),
+    defineOpcode("sta", ["zeroPage", "zeroPageX", "absolute", "absoluteX", "absoluteY", "indexedIndirect", "indirectIndexed"]),
+    defineOpcode("stx", ["zeroPage", "zeroPageY", "absolute"]),
+    defineOpcode("sty", ["zeroPage", "zeroPageX", "absolute"]),
+    defineOpcode("tax", ["implied"]),
+    defineOpcode("tay", ["implied"]),
+    defineOpcode("tsx", ["implied"]),
+    defineOpcode("txa", ["implied"]),
+    defineOpcode("txs", ["implied"]),
+    defineOpcode("tya", ["implied"])
+];
+exports.opcodeTable = new Map(exports.opcodeDefinitions.map((definition) => [definition.mnemonic, definition]));
+exports.directiveDefinitions = [
+    defineDirective("asm", "include", true, "Assemble another source file immediately."),
+    defineDirective("asc", "data", true, "Emit an ASCII string."),
+    defineDirective("da", "data", true, "Emit an address-sized value."),
+    defineDirective("db", "data", true, "Emit byte data."),
+    defineDirective("dend", "storage", true, "End a DUM storage section."),
+    defineDirective("dsk", "build", true, "Set the output disk or image name."),
+    defineDirective("ds", "storage", true, "Reserve storage bytes."),
+    defineDirective("dum", "storage", true, "Begin a DUM storage section."),
+    defineDirective("end", "assembler", true, "End assembly."),
+    defineDirective("equ", "assembler", true, "Define a symbolic constant."),
+    defineDirective("err", "assembler", true, "Force an assembly error."),
+    defineDirective("hex", "data", true, "Emit raw hexadecimal bytes."),
+    defineDirective("mac", "assembler", true, "Begin a macro definition."),
+    defineDirective("mx", "mode", false, "65816-only accumulator and index width control."),
+    defineDirective("org", "assembler", true, "Set or restore the assembly origin."),
+    defineDirective("put", "include", true, "Include another source file."),
+    defineDirective("sav", "build", true, "Save an output file."),
+    defineDirective("sna", "build", true, "Set the output file name."),
+    defineDirective("str", "data", true, "Emit a Merlin string."),
+    defineDirective("typ", "build", true, "Set the output file type."),
+    defineDirective("use", "include", true, "Include a library-style source file."),
+    defineDirective("xc", "mode", false, "65816-only extended instruction mode control.")
+];
+exports.directiveTable = new Map(exports.directiveDefinitions.map((definition) => [definition.name, definition]));

package/dist/src/asm/parser.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseSourceLines = parseSourceLines;
+exports.parseLexedLine = parseLexedLine;
+const metadata_1 = require("./metadata");
+const expression_1 = require("./expression");
+const lexer_1 = require("./lexer");
+const dataDirectiveKinds = new Set(["data"]);
+function parseSourceLines(source) {
+    return (0, lexer_1.lexSource)(source).lines.map(parseLexedLine);
+}
+function parseLexedLine(line) {
+    const tokens = stripTrailingComment(line.tokens);
+    if (tokens.length === 0) {
+        const commentToken = line.tokens[0];
+        if (commentToken?.kind === "comment") {
+            return {
+                shape: "commentOnly",
+                text: line.text,
+                comment: commentToken.lexeme
+            };
+        }
+        return {
+            shape: "empty",
+            text: line.text
+        };
+    }
+    try {
+        return parseStructuredLine(line.text, tokens);
+    }
+    catch (error) {
+        return {
+            shape: "malformed",
+            text: line.text,
+            message: error instanceof Error ? error.message : "unknown parse failure"
+        };
+    }
+}
+function parseStructuredLine(text, tokens) {
+    let index = 0;
+    let label = null;
+    if (tokens[index]?.kind === "label" || tokens[index]?.kind === "localLabel") {
+        label = tokens[index]?.lexeme ?? null;
+        index += 1;
+    }
+    const token = tokens[index];
+    if (token === undefined) {
+        if (label !== null) {
+            return {
+                shape: "labelOnly",
+                text,
+                label
+            };
+        }
+        return {
+            shape: "empty",
+            text
+        };
+    }
+    if (token.kind === "expressionOperator" && token.lexeme === "=") {
+        if (label === null) {
+            throw new Error("equate requires a label");
+        }
+        const parsed = (0, expression_1.parseExpression)(tokens, index + 1);
+        return {
+            shape: "equate",
+            text,
+            label,
+            expression: parsed.expression
+        };
+    }
+    if (token.kind === "mnemonic") {
+        const operandTokens = tokens.slice(index + 1);
+        const operand = operandTokens.length > 0 ? (0, expression_1.parseOperand)(operandTokens).operand : null;
+        return {
+            shape: "instruction",
+            text,
+            label,
+            mnemonic: token.lexeme.toLowerCase(),
+            operand
+        };
+    }
+    if (token.kind === "directive") {
+        const directive = metadata_1.directiveTable.get(token.lexeme.toLowerCase());
+        if (directive !== undefined && dataDirectiveKinds.has(directive.kind)) {
+            return {
+                shape: "data",
+                text,
+                label,
+                directive: token.lexeme.toLowerCase(),
+                payload: tokens.slice(index + 1).map((current) => current.lexeme).join("")
+            };
+        }
+        const operandTokens = tokens.slice(index + 1);
+        const directiveName = token.lexeme.toLowerCase();
+        if (operandTokens.length > 0 && (directiveName === "end" || directiveName === "dend" || directiveName === "xc")) {
+            throw new Error(`unexpected operand for ${directiveName}`);
+        }
+        const operand = operandTokens.length > 0
+            ? (0, expression_1.parseExpression)(operandTokens).expression
+            : null;
+        return {
+            shape: "directive",
+            text,
+            label,
+            directive: directiveName,
+            operand
+        };
+    }
+    throw new Error(`unsupported line start: ${token.lexeme}`);
+}
+function stripTrailingComment(tokens) {
+    const commentIndex = tokens.findIndex((token) => token.kind === "comment");
+    if (commentIndex === -1) {
+        return tokens;
+    }
+    return tokens.slice(0, commentIndex);
+}

package/dist/src/asm/symbols.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectSymbols = collectSymbols;
+const metadata_1 = require("./metadata");
+function collectSymbols(document) {
+    const symbols = new Map();
+    for (const line of document.lines) {
+        const node = line.node;
+        if (node.shape === "equate") {
+            symbols.set(node.label, defineSymbol(node.label, "equate", line.line));
+            continue;
+        }
+        if (node.shape === "labelOnly") {
+            symbols.set(node.label, defineSymbol(node.label, "label", line.line));
+            continue;
+        }
+        if (node.shape === "instruction" && node.label !== null) {
+            symbols.set(node.label, defineSymbol(node.label, "label", line.line));
+            continue;
+        }
+        if (node.shape === "directive" && node.label !== null) {
+            const directive = metadata_1.directiveTable.get(node.directive);
+            if (directive?.kind === "data" || directive?.kind === "storage") {
+                symbols.set(node.label, defineSymbol(node.label, "data", line.line));
+            }
+            continue;
+        }
+        if (node.shape === "data" && node.label !== null) {
+            symbols.set(node.label, defineSymbol(node.label, "data", line.line));
+        }
+    }
+    return symbols;
+}
+function defineSymbol(name, kind, line) {
+    return {
+        name,
+        kind,
+        line
+    };
+}