@jhlagado/azm 0.1.0

package/dist/src/frontend/parseOpHeader.js

@@ -0,0 +1,32 @@
+import { parseDiag as diag } from './parseDiagnostics.js';
+import { diagInvalidHeaderLine, formatIdentifierToken } from './parseTopLevelCommon.js';
+export function parseOpHeader(options) {
+    const { header, stmtText, stmtSpan: _stmtSpan, lineNo, diagnostics, sourcePath, expectedHeader, isReservedTopLevelName, parseParams, } = options;
+    const openParen = header.indexOf('(');
+    const closeParen = header.lastIndexOf(')');
+    if (openParen < 0 || closeParen < openParen) {
+        diagInvalidHeaderLine(diagnostics, sourcePath, 'op header', stmtText, expectedHeader, lineNo);
+        return undefined;
+    }
+    const name = header.slice(0, openParen).trim();
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(name)) {
+        diag(diagnostics, sourcePath, `Invalid op name ${formatIdentifierToken(name)}: expected <identifier>.`, { line: lineNo, column: 1 });
+        return undefined;
+    }
+    if (isReservedTopLevelName(name)) {
+        diag(diagnostics, sourcePath, `Invalid op name "${name}": collides with a top-level keyword.`, {
+            line: lineNo,
+            column: 1,
+        });
+        return undefined;
+    }
+    const paramsText = header.slice(openParen + 1, closeParen);
+    const params = parseParams(paramsText);
+    if (!params)
+        return undefined;
+    return {
+        name,
+        params,
+        trailing: header.slice(closeParen + 1).trimStart(),
+    };
+}

package/dist/src/frontend/parseOperands.d.ts

@@ -0,0 +1,4 @@
+import type { AsmOperandNode, EaExprNode, SourceSpan } from './ast.js';
+import type { Diagnostic } from '../diagnosticTypes.js';
+export declare function parseEaExprFromText(filePath: string, exprText: string, exprSpan: SourceSpan, diagnostics: Diagnostic[]): EaExprNode | undefined;
+export declare function parseAsmOperand(filePath: string, operandText: string, operandSpan: SourceSpan, diagnostics: Diagnostic[], emitDiagnostics?: boolean, preferDottedImmediate?: boolean): AsmOperandNode | undefined;

package/dist/src/frontend/parseOperands.js

@@ -0,0 +1,290 @@
+import { DiagnosticIds } from '../diagnosticTypes.js';
+import { immLiteral, parseImmExprFromText, parseNumberLiteral, parseTypeExprFromText, } from './parseImm.js';
+import { parseDiag as diag, parseDiagAtWithId } from './parseDiagnostics.js';
+import { ALL_REGISTER_NAMES, INDEX_MEM_BASE_REGISTERS, INDEX_REG16_NAMES, INDEX_REG8_NAMES, } from './grammarData.js';
+function parseBalancedContent(text, open, close) {
+    if (!text.startsWith(open))
+        return undefined;
+    let depth = 0;
+    for (let i = 0; i < text.length; i++) {
+        const ch = text[i];
+        if (ch === open) {
+            depth++;
+            continue;
+        }
+        if (ch !== close)
+            continue;
+        depth--;
+        if (depth === 0) {
+            return {
+                inside: text.slice(1, i),
+                rest: text.slice(i + 1),
+            };
+        }
+        if (depth < 0)
+            return undefined;
+    }
+    return undefined;
+}
+function parseBalancedBracketContent(text) {
+    return parseBalancedContent(text, '[', ']');
+}
+function parseBalancedParenContent(text) {
+    return parseBalancedContent(text, '(', ')');
+}
+function canonicalRegisterToken(token) {
+    if (/^af'$/i.test(token))
+        return "AF'";
+    return token.toUpperCase();
+}
+function parseEaSegments(filePath, expr, initialRest, exprSpan, diagnostics) {
+    let rest = initialRest.trimStart();
+    let sawSegment = false;
+    while (rest.length > 0) {
+        if (rest.startsWith('.')) {
+            const m = /^\.([A-Za-z_][A-Za-z0-9_]*)/.exec(rest);
+            if (!m)
+                return undefined;
+            expr = { kind: 'EaField', span: exprSpan, base: expr, field: m[1] };
+            rest = rest.slice(m[0].length).trimStart();
+            sawSegment = true;
+            continue;
+        }
+        if (rest.startsWith('[')) {
+            const bracket = parseBalancedBracketContent(rest);
+            if (!bracket)
+                return undefined;
+            const index = parseEaIndexFromText(filePath, bracket.inside, exprSpan, diagnostics);
+            if (!index)
+                return undefined;
+            expr = { kind: 'EaIndex', span: exprSpan, base: expr, index };
+            rest = bracket.rest.trimStart();
+            sawSegment = true;
+            continue;
+        }
+        break;
+    }
+    return { expr, rest, sawSegment };
+}
+function parseLayoutCastBaseAtom(text, exprSpan) {
+    const tokenMatch = /^([A-Za-z_][A-Za-z0-9_']*)/.exec(text);
+    if (!tokenMatch)
+        return undefined;
+    const token = tokenMatch[1];
+    const canonical = canonicalRegisterToken(token);
+    if (ALL_REGISTER_NAMES.has(canonical))
+        return undefined;
+    return {
+        base: { kind: 'EaName', span: exprSpan, name: token },
+        rest: text.slice(token.length).trimStart(),
+    };
+}
+function parseLayoutCastBase(filePath, text, exprSpan, diagnostics) {
+    const trimmed = text.trimStart();
+    if (!trimmed.startsWith('(')) {
+        return parseLayoutCastBaseAtom(trimmed, exprSpan);
+    }
+    const grouped = parseBalancedParenContent(trimmed);
+    if (!grouped)
+        return undefined;
+    const inner = grouped.inside.trim();
+    const atom = parseLayoutCastBaseAtom(inner, exprSpan);
+    if (!atom)
+        return undefined;
+    const opMatch = /^([+-])\s*(.+)$/.exec(atom.rest);
+    if (!opMatch)
+        return undefined;
+    const offset = parseImmExprFromText(filePath, opMatch[2], exprSpan, diagnostics, false);
+    if (!offset)
+        return undefined;
+    return {
+        base: opMatch[1] === '+'
+            ? { kind: 'EaAdd', span: exprSpan, base: atom.base, offset }
+            : { kind: 'EaSub', span: exprSpan, base: atom.base, offset },
+        rest: grouped.rest.trimStart(),
+    };
+}
+function parseLayoutCastHead(filePath, text, exprSpan, diagnostics) {
+    if (!text.startsWith('<'))
+        return undefined;
+    const closeIndex = text.indexOf('>');
+    if (closeIndex <= 1)
+        return undefined;
+    const typeText = text.slice(1, closeIndex).trim();
+    const typeExpr = parseTypeExprFromText(typeText, exprSpan);
+    if (!typeExpr)
+        return undefined;
+    const parsedBase = parseLayoutCastBase(filePath, text.slice(closeIndex + 1), exprSpan, diagnostics);
+    if (!parsedBase)
+        return undefined;
+    const segments = parseEaSegments(filePath, { kind: 'EaLayoutCast', span: exprSpan, typeExpr, base: parsedBase.base }, parsedBase.rest, exprSpan, diagnostics);
+    if (!segments || !segments.sawSegment)
+        return undefined;
+    return { expr: segments.expr, rest: segments.rest };
+}
+function parseEaIndexFromText(filePath, indexText, indexSpan, diagnostics) {
+    const t = indexText.trim();
+    if (t.startsWith('(') && t.endsWith(')')) {
+        const inner = t.slice(1, -1).trim();
+        const innerCanonical = canonicalRegisterToken(inner);
+        if (innerCanonical === 'HL')
+            return { kind: 'IndexMemHL', span: indexSpan };
+        const ixiy = /^([A-Za-z_][A-Za-z0-9_']*)(?:\s*([+-])\s*(.+))?$/i.exec(inner);
+        if (ixiy) {
+            const baseToken = canonicalRegisterToken(ixiy[1]);
+            if (INDEX_MEM_BASE_REGISTERS.has(baseToken)) {
+                const base = baseToken;
+                const dispText = ixiy[2] ? `${ixiy[2]}${ixiy[3]?.trim() ?? ''}` : '';
+                const disp = dispText.length > 0
+                    ? parseImmExprFromText(filePath, dispText, indexSpan, diagnostics, false)
+                    : undefined;
+                if (dispText.length > 0 && !disp) {
+                    diag(diagnostics, filePath, `Invalid index expression: ${t}`, {
+                        line: indexSpan.start.line,
+                        column: indexSpan.start.column,
+                    });
+                    return undefined;
+                }
+                return { kind: 'IndexMemIxIy', span: indexSpan, base, ...(disp ? { disp } : {}) };
+            }
+        }
+        if (!/[A-Za-z_]/.test(inner)) {
+            const grouped = parseImmExprFromText(filePath, inner, indexSpan, diagnostics, false);
+            if (grouped) {
+                parseDiagAtWithId(diagnostics, indexSpan.file, DiagnosticIds.IndexParenRedundant, 'warning', `Redundant outer parentheses in constant index expression "${t}".`, { line: indexSpan.start.line, column: indexSpan.start.column });
+            }
+        }
+    }
+    const reg = canonicalRegisterToken(t);
+    if (INDEX_REG16_NAMES.has(reg))
+        return { kind: 'IndexReg16', span: indexSpan, reg };
+    if (INDEX_REG8_NAMES.has(reg))
+        return { kind: 'IndexReg8', span: indexSpan, reg };
+    const imm = parseImmExprFromText(filePath, t, indexSpan, diagnostics, false);
+    if (imm)
+        return { kind: 'IndexImm', span: indexSpan, value: imm };
+    const ea = parseEaExprFromText(filePath, t, indexSpan, diagnostics);
+    if (ea)
+        return { kind: 'IndexEa', span: indexSpan, expr: ea };
+    diag(diagnostics, filePath, `Invalid index expression: ${t}`, {
+        line: indexSpan.start.line,
+        column: indexSpan.start.column,
+    });
+    return undefined;
+}
+export function parseEaExprFromText(filePath, exprText, exprSpan, diagnostics) {
+    let rest = exprText.trim();
+    let expr;
+    const layoutCast = parseLayoutCastHead(filePath, rest, exprSpan, diagnostics);
+    if (layoutCast) {
+        expr = layoutCast.expr;
+        rest = layoutCast.rest;
+    }
+    else {
+        const baseMatch = /^([A-Za-z_][A-Za-z0-9_]*)/.exec(rest);
+        if (!baseMatch)
+            return undefined;
+        expr = { kind: 'EaName', span: exprSpan, name: baseMatch[1] };
+        rest = rest.slice(baseMatch[0].length).trimStart();
+        const segments = parseEaSegments(filePath, expr, rest, exprSpan, diagnostics);
+        if (!segments)
+            return undefined;
+        expr = segments.expr;
+        rest = segments.rest;
+    }
+    if (rest.length > 0) {
+        const m = /^([+-])\s*(.+)$/.exec(rest);
+        if (!m)
+            return undefined;
+        const off = parseImmExprFromText(filePath, m[2], exprSpan, diagnostics);
+        if (!off)
+            return undefined;
+        expr =
+            m[1] === '+'
+                ? { kind: 'EaAdd', span: exprSpan, base: expr, offset: off }
+                : { kind: 'EaSub', span: exprSpan, base: expr, offset: off };
+        rest = '';
+    }
+    return rest.length === 0 ? expr : undefined;
+}
+export function parseAsmOperand(filePath, operandText, operandSpan, diagnostics, emitDiagnostics = true, preferDottedImmediate = false) {
+    const t = operandText.trim();
+    if (t.length === 0)
+        return undefined;
+    const canonicalRegister = canonicalRegisterToken(t);
+    if (ALL_REGISTER_NAMES.has(canonicalRegister)) {
+        return { kind: 'Reg', span: operandSpan, name: canonicalRegister };
+    }
+    const n = parseNumberLiteral(t);
+    if (n !== undefined) {
+        return { kind: 'Imm', span: operandSpan, expr: immLiteral(filePath, operandSpan, n) };
+    }
+    if (t.startsWith('(') && t.endsWith(')')) {
+        const inner = t.slice(1, -1).trim();
+        // Z80 register-indirect memory `(hl)` / `(bc)` / `(de)` — not `EaName` for a symbol
+        // spelled "hl" (see #1356). Aligns with `parseEaIndexFromText` treating `(hl)` as `IndexMemHL`.
+        const registerMemIndirect = /^(hl|bc|de)$/i.exec(inner);
+        if (registerMemIndirect) {
+            const name = canonicalRegisterToken(registerMemIndirect[1]);
+            return {
+                kind: 'Mem',
+                span: operandSpan,
+                expr: { kind: 'EaName', span: operandSpan, name },
+            };
+        }
+        if (/^(ix|iy)\s*\[/i.test(inner)) {
+            if (emitDiagnostics) {
+                diag(diagnostics, filePath, `Indexed memory operands use (ix+disp)/(iy+disp), not ${inner}.`, {
+                    line: operandSpan.start.line,
+                    column: operandSpan.start.column,
+                });
+            }
+            return undefined;
+        }
+        const indexedMemIndirect = /^[A-Za-z_][A-Za-z0-9_']*\s*[+-]/.test(inner);
+        if (preferDottedImmediate && inner.includes('.') && !indexedMemIndirect) {
+            const imm = parseImmExprFromText(filePath, inner, operandSpan, diagnostics, false);
+            if (imm) {
+                return {
+                    kind: 'Mem',
+                    span: operandSpan,
+                    expr: { kind: 'EaImm', span: operandSpan, expr: imm },
+                };
+            }
+        }
+        const ea = parseEaExprFromText(filePath, inner, operandSpan, diagnostics);
+        if (ea)
+            return { kind: 'Mem', span: operandSpan, expr: ea };
+        const imm = parseImmExprFromText(filePath, inner, operandSpan, diagnostics, emitDiagnostics);
+        if (imm) {
+            return {
+                kind: 'Mem',
+                span: operandSpan,
+                expr: { kind: 'EaImm', span: operandSpan, expr: imm },
+            };
+        }
+    }
+    if (preferDottedImmediate && t.includes('.')) {
+        const expr = parseImmExprFromText(filePath, t, operandSpan, diagnostics, false);
+        if (expr)
+            return { kind: 'Imm', span: operandSpan, expr };
+    }
+    if (t.includes('.') || t.includes('[')) {
+        const ea = parseEaExprFromText(filePath, t, operandSpan, diagnostics);
+        if (ea)
+            return { kind: 'Ea', span: operandSpan, expr: ea };
+    }
+    const expr = parseImmExprFromText(filePath, t, operandSpan, diagnostics, emitDiagnostics);
+    if (expr) {
+        return { kind: 'Imm', span: operandSpan, expr };
+    }
+    if (t.startsWith("'"))
+        return undefined;
+    if (emitDiagnostics) {
+        diag(diagnostics, filePath, `Unsupported operand: ${t}`, {
+            line: operandSpan.start.line,
+            column: operandSpan.start.column,
+        });
+    }
+    return undefined;
+}

package/dist/src/frontend/parseParams.d.ts

@@ -0,0 +1,6 @@
+import type { OpParamNode, SourceSpan } from './ast.js';
+import type { Diagnostic } from '../diagnosticTypes.js';
+export type ParseParamsContext = {
+    isReservedTopLevelName: (name: string) => boolean;
+};
+export declare function parseOpParamsFromText(filePath: string, paramsText: string, paramsSpan: SourceSpan, diagnostics: Diagnostic[], ctx: ParseParamsContext): OpParamNode[] | undefined;

package/dist/src/frontend/parseParams.js

@@ -0,0 +1,62 @@
+import { parseDiag as diag } from './parseDiagnostics.js';
+import { MATCHER_KIND_BY_TYPE, MATCHER_TYPES } from './grammarData.js';
+function parseOpMatcherFromText(matcherText, matcherSpan) {
+    const t = matcherText.trim();
+    const lower = t.toLowerCase();
+    if (!MATCHER_TYPES.has(lower))
+        return { kind: 'MatcherFixed', span: matcherSpan, token: t };
+    return {
+        kind: MATCHER_KIND_BY_TYPE[lower],
+        span: matcherSpan,
+    };
+}
+export function parseOpParamsFromText(filePath, paramsText, paramsSpan, diagnostics, ctx) {
+    const trimmed = paramsText.trim();
+    if (trimmed.length === 0)
+        return [];
+    const parts = trimmed.split(',').map((p) => p.trim());
+    if (parts.some((p) => p.length === 0)) {
+        diag(diagnostics, filePath, `Invalid op parameter list: trailing or empty entries are not permitted.`, {
+            line: paramsSpan.start.line,
+            column: paramsSpan.start.column,
+        });
+        return undefined;
+    }
+    const out = [];
+    const seen = new Set();
+    for (const part of parts) {
+        const m = /^([A-Za-z_][A-Za-z0-9_]*)\s+(.+)$/.exec(part);
+        if (!m) {
+            diag(diagnostics, filePath, `Invalid op parameter declaration: expected <name> <matcher>`, {
+                line: paramsSpan.start.line,
+                column: paramsSpan.start.column,
+            });
+            return undefined;
+        }
+        const name = m[1];
+        if (ctx.isReservedTopLevelName(name)) {
+            diag(diagnostics, filePath, `Invalid op parameter name "${name}": collides with a top-level keyword.`, {
+                line: paramsSpan.start.line,
+                column: paramsSpan.start.column,
+            });
+            return undefined;
+        }
+        const lower = name.toLowerCase();
+        if (seen.has(lower)) {
+            diag(diagnostics, filePath, `Duplicate op parameter name "${name}".`, {
+                line: paramsSpan.start.line,
+                column: paramsSpan.start.column,
+            });
+            return undefined;
+        }
+        seen.add(lower);
+        const matcherText = m[2].trim();
+        out.push({
+            kind: 'OpParam',
+            span: paramsSpan,
+            name,
+            matcher: parseOpMatcherFromText(matcherText, paramsSpan),
+        });
+    }
+    return out;
+}

package/dist/src/frontend/parseParserRecovery.d.ts

@@ -0,0 +1,12 @@
+import type { Diagnostic } from '../diagnosticTypes.js';
+export declare function recoverUnsupportedParserLine(args: {
+    index: number;
+    scope: 'source';
+    text: string;
+    rest: string;
+    lineNo: number;
+    filePath: string;
+    diagnostics: Diagnostic[];
+}): {
+    nextIndex: number;
+};

package/dist/src/frontend/parseParserRecovery.js

@@ -0,0 +1,17 @@
+import { diagInvalidHeaderLine, malformedTopLevelHeaderExpectations, } from './parseTopLevelCommon.js';
+import { parseDiag as diag } from './parseDiagnostics.js';
+export function recoverUnsupportedParserLine(args) {
+    const { index, text, rest, lineNo, filePath, diagnostics } = args;
+    const hasTopKeyword = (kw) => new RegExp(`^${kw}\\b`, 'i').test(rest);
+    for (const expectation of malformedTopLevelHeaderExpectations) {
+        if (hasTopKeyword(expectation.keyword)) {
+            diagInvalidHeaderLine(diagnostics, filePath, expectation.kind, text, expectation.expected, lineNo);
+            return { nextIndex: index + 1 };
+        }
+    }
+    diag(diagnostics, filePath, `Unsupported top-level construct: ${text}`, {
+        line: lineNo,
+        column: 1,
+    });
+    return { nextIndex: index + 1 };
+}

package/dist/src/frontend/parseParserShared.d.ts

@@ -0,0 +1,2 @@
+export declare function isReservedTopLevelDeclName(name: string): boolean;
+export declare function stripLineComment(line: string): string;

package/dist/src/frontend/parseParserShared.js

@@ -0,0 +1,8 @@
+import { TOP_LEVEL_KEYWORDS } from './grammarData.js';
+export function isReservedTopLevelDeclName(name) {
+    return TOP_LEVEL_KEYWORDS.has(name.toLowerCase());
+}
+export function stripLineComment(line) {
+    const semi = line.indexOf(';');
+    return semi >= 0 ? line.slice(0, semi) : line;
+}

package/dist/src/frontend/parseRawDataDirectiveStart.d.ts

@@ -0,0 +1 @@
+export declare function looksLikeRawDataDirectiveStart(text: string): boolean;

package/dist/src/frontend/parseRawDataDirectiveStart.js

@@ -0,0 +1,3 @@
+export function looksLikeRawDataDirectiveStart(text) {
+    return /^(db|dw|ds)\b/i.test(text) || /^[A-Za-z_][A-Za-z0-9_]*\s*:\s*(db|dw|ds)\b/i.test(text);
+}

package/dist/src/frontend/parseRawDataDirectives.d.ts

@@ -0,0 +1,7 @@
+import type { Diagnostic } from '../diagnosticTypes.js';
+import type { AsmRawDataNode, SourceSpan } from './ast.js';
+export declare function parseRawDataSizeOperands(sizeText: string, lineNo: number, lineSpan: SourceSpan, filePath: string, diagnostics: Diagnostic[]): AsmRawDataNode | undefined;
+/**
+ * Parses a `db`/`dw`/`ds` line with no leading label (continuation bytes after a labeled block).
+ */
+export declare function parseBareRawDataDirective(directiveText: string, lineNo: number, lineSpan: SourceSpan, filePath: string, diagnostics: Diagnostic[]): AsmRawDataNode | undefined;

package/dist/src/frontend/parseRawDataDirectives.js

@@ -0,0 +1,142 @@
+import { parseImmExprFromText, parseTypeExprFromText } from './parseImm.js';
+import { parseDiag as diag } from './parseDiagnostics.js';
+function splitTopLevelComma(text) {
+    const parts = [];
+    let start = 0;
+    let parenDepth = 0;
+    let bracketDepth = 0;
+    let braceDepth = 0;
+    let inChar = false;
+    let escaped = false;
+    for (let i = 0; i < text.length; i++) {
+        const ch = text[i];
+        if (inChar) {
+            if (escaped)
+                escaped = false;
+            else if (ch === '\\')
+                escaped = true;
+            else if (ch === "'")
+                inChar = false;
+            continue;
+        }
+        if (ch === "'") {
+            inChar = true;
+            continue;
+        }
+        if (ch === '(') {
+            parenDepth++;
+            continue;
+        }
+        if (ch === ')') {
+            if (parenDepth > 0)
+                parenDepth--;
+            continue;
+        }
+        if (ch === '[') {
+            bracketDepth++;
+            continue;
+        }
+        if (ch === ']') {
+            if (bracketDepth > 0)
+                bracketDepth--;
+            continue;
+        }
+        if (ch === '{') {
+            braceDepth++;
+            continue;
+        }
+        if (ch === '}') {
+            if (braceDepth > 0)
+                braceDepth--;
+            continue;
+        }
+        if (ch === ',' && parenDepth === 0 && bracketDepth === 0 && braceDepth === 0) {
+            parts.push(text.slice(start, i));
+            start = i + 1;
+        }
+    }
+    parts.push(text.slice(start));
+    return parts;
+}
+function parseRawDataValues(directive, valuesText, lineNo, lineSpan, filePath, diagnostics) {
+    const parts = splitTopLevelComma(valuesText).map((part) => part.trim());
+    if (parts.length === 0 || parts.every((part) => part.length === 0)) {
+        diag(diagnostics, filePath, `"${directive}" expects one or more imm expressions`, {
+            line: lineNo,
+            column: 1,
+        });
+        return undefined;
+    }
+    const values = [];
+    for (const part of parts) {
+        if (part.length === 0) {
+            diag(diagnostics, filePath, `"${directive}" expects one or more imm expressions`, {
+                line: lineNo,
+                column: 1,
+            });
+            return undefined;
+        }
+        const expr = parseImmExprFromText(filePath, part, lineSpan, diagnostics);
+        if (!expr)
+            return undefined;
+        values.push(expr);
+    }
+    return { kind: 'AsmRawData', span: lineSpan, name: '', directive, values, valuesText };
+}
+function parseRawDataSizeExpr(sizeText, lineSpan, filePath, diagnostics) {
+    const imm = parseImmExprFromText(filePath, sizeText, lineSpan, diagnostics, false);
+    if (imm)
+        return imm;
+    if (/\[[^\]]+\]/.test(sizeText) || /^(?:byte|word|addr)$/i.test(sizeText.trim())) {
+        const typeExpr = parseTypeExprFromText(sizeText, lineSpan);
+        if (typeExpr)
+            return { kind: 'ImmSizeof', span: lineSpan, typeExpr };
+    }
+    return parseImmExprFromText(filePath, sizeText, lineSpan, diagnostics);
+}
+export function parseRawDataSizeOperands(sizeText, lineNo, lineSpan, filePath, diagnostics) {
+    const parts = splitTopLevelComma(sizeText).map((part) => part.trim());
+    if (parts.length < 1 || parts.length > 2 || parts[0].length === 0) {
+        diag(diagnostics, filePath, '"ds" expects a size and optional fill value', {
+            line: lineNo,
+            column: 1,
+        });
+        return undefined;
+    }
+    const size = parseRawDataSizeExpr(parts[0], lineSpan, filePath, diagnostics);
+    if (!size)
+        return undefined;
+    const fill = parts.length === 2 && parts[1].length > 0
+        ? parseImmExprFromText(filePath, parts[1], lineSpan, diagnostics)
+        : undefined;
+    if (parts.length === 2 && !fill)
+        return undefined;
+    return {
+        kind: 'AsmRawData',
+        span: lineSpan,
+        name: '',
+        directive: 'ds',
+        size,
+        ...(fill ? { fill } : {}),
+        valuesText: sizeText,
+    };
+}
+/**
+ * Parses a `db`/`dw`/`ds` line with no leading label (continuation bytes after a labeled block).
+ */
+export function parseBareRawDataDirective(directiveText, lineNo, lineSpan, filePath, diagnostics) {
+    return parseNamedRawDataDirective('', directiveText, lineNo, lineSpan, filePath, diagnostics);
+}
+function parseNamedRawDataDirective(name, directiveText, lineNo, lineSpan, filePath, diagnostics) {
+    const match = /^(db|dw|ds)\b(.*)$/i.exec(directiveText.trim());
+    if (!match)
+        return undefined;
+    const directive = match[1].toLowerCase();
+    const payload = match[2].trim();
+    const parsed = directive === 'ds'
+        ? parseRawDataSizeOperands(payload, lineNo, lineSpan, filePath, diagnostics)
+        : parseRawDataValues(directive, payload, lineNo, lineSpan, filePath, diagnostics);
+    if (!parsed)
+        return undefined;
+    return { ...parsed, name, span: lineSpan };
+}

package/dist/src/frontend/parseRecordFieldDecl.d.ts

@@ -0,0 +1,34 @@
+import type { RecordFieldNode } from './ast.js';
+import type { Diagnostic } from '../diagnosticTypes.js';
+import type { SourceFile } from './source.js';
+export type RecordFieldLine = {
+    raw: string;
+    startOffset: number;
+    endOffset: number;
+    lineNo: number;
+    filePath: string;
+};
+type RecordFieldValidationContext = {
+    file: SourceFile;
+    diagnostics: Diagnostic[];
+    sourcePath: string;
+    isReservedTopLevelName: (name: string) => boolean;
+};
+type RecordFieldBlockContext = RecordFieldValidationContext & {
+    lineCount: number;
+    getRawLine: (lineIndex: number) => RecordFieldLine;
+};
+type ParsedFieldBlock = {
+    fields: RecordFieldNode[];
+    nextIndex: number;
+    endOffset: number;
+};
+export declare function parseRecordFieldBlock(params: {
+    declarationKind: 'type' | 'union';
+    declarationName: string;
+    fieldKind: 'record' | 'union';
+    declarationLineNo: number;
+    startIndex: number;
+    ctx: RecordFieldBlockContext;
+}): ParsedFieldBlock;
+export {};