@jhlagado/azm 0.2.0 → 0.2.2

package/dist/legacy-root-azm/src/frontend/parseOpHeader.js

@@ -1,32 +0,0 @@
-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/legacy-root-azm/src/frontend/parseOperands.d.ts

@@ -1,4 +0,0 @@
-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/legacy-root-azm/src/frontend/parseOperands.js

@@ -1,290 +0,0 @@
-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/legacy-root-azm/src/frontend/parseParams.d.ts

@@ -1,6 +0,0 @@
-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/legacy-root-azm/src/frontend/parseParams.js

@@ -1,62 +0,0 @@
-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/legacy-root-azm/src/frontend/parseParserRecovery.d.ts

@@ -1,12 +0,0 @@
-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/legacy-root-azm/src/frontend/parseParserRecovery.js

@@ -1,17 +0,0 @@
-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/legacy-root-azm/src/frontend/parseParserShared.d.ts

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

package/dist/legacy-root-azm/src/frontend/parseParserShared.js

@@ -1,8 +0,0 @@
-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/legacy-root-azm/src/frontend/parseRawDataDirectiveStart.d.ts

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

package/dist/legacy-root-azm/src/frontend/parseRawDataDirectiveStart.js

@@ -1,3 +0,0 @@
-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/legacy-root-azm/src/frontend/parseRawDataDirectives.d.ts

@@ -1,7 +0,0 @@
-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/legacy-root-azm/src/frontend/parseRawDataDirectives.js

@@ -1,142 +0,0 @@
-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/legacy-root-azm/src/frontend/parseRecordFieldDecl.d.ts

@@ -1,34 +0,0 @@
-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 {};