@jhlagado/azm 0.2.1 → 0.2.2

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

@@ -1,177 +0,0 @@
-import { span } from './source.js';
-import { parseDiag as diag } from './parseDiagnostics.js';
-import { diagIfArrayLengthMissing, parseNumberLiteral, parseTypeExprFromText } from './parseImm.js';
-import { diagInvalidBlockLine, formatIdentifierToken, topLevelStartKeyword, } from './parseTopLevelCommon.js';
-import { stripLineComment as stripComment } from './parseParserShared.js';
-function parseRecordFieldDecl(kindName, fieldText, line, fieldNamesLower, ctx, declaringTypeName) {
-    const { file, diagnostics, sourcePath, isReservedTopLevelName } = ctx;
-    const { startOffset, endOffset, lineNo, filePath } = line;
-    const match = /^([A-Za-z_][A-Za-z0-9_]*)\s+(\.(?:field|byte|word|addr))(?:\s+(.+))?$/i.exec(fieldText);
-    if (!match) {
-        diagInvalidBlockLine(diagnostics, filePath, `${kindName} field declaration`, fieldText, '<name> .field <size> or <name> .byte/.word/.addr', lineNo);
-        return undefined;
-    }
-    const fieldName = match[1].trim();
-    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(fieldName)) {
-        diag(diagnostics, filePath, `Invalid ${kindName} field name ${formatIdentifierToken(fieldName)}: expected <identifier>.`, { line: lineNo, column: 1 });
-        return undefined;
-    }
-    if (isReservedTopLevelName(fieldName)) {
-        diag(diagnostics, sourcePath, `Invalid ${kindName} field name "${fieldName}": collides with a top-level keyword.`, { line: lineNo, column: 1 });
-        return undefined;
-    }
-    const fieldNameLower = fieldName.toLowerCase();
-    if (fieldNamesLower.has(fieldNameLower)) {
-        diag(diagnostics, filePath, `Duplicate ${kindName} field name "${fieldName}".`, {
-            line: lineNo,
-            column: 1,
-        });
-        return undefined;
-    }
-    const fieldSpan = span(file, startOffset, endOffset);
-    const typeExpr = match[2].startsWith('.')
-        ? parseAsmFieldTypeExpr(match[2], match[3]?.trim(), fieldSpan)
-        : parseTypeExprFromText(match[2].trim(), fieldSpan);
-    if (!typeExpr) {
-        const typeText = (match[3] ?? match[2] ?? '').trim();
-        if (diagIfArrayLengthMissing(diagnostics, filePath, typeText, {
-            line: lineNo,
-            column: 1,
-        })) {
-            return undefined;
-        }
-        diagInvalidBlockLine(diagnostics, filePath, `${kindName} field declaration`, fieldText, '<name> .field <size> or <name> .byte/.word/.addr', lineNo);
-        return undefined;
-    }
-    if (declaringTypeName !== undefined &&
-        typeExpr.kind === 'TypeName' &&
-        typeExpr.name.toLowerCase() === declaringTypeName.toLowerCase()) {
-        diag(diagnostics, filePath, `Self-referential field type "${typeExpr.name}" has no finite size; use .addr for a pointer field.`, { line: lineNo, column: 1 });
-        return undefined;
-    }
-    fieldNamesLower.add(fieldNameLower);
-    return {
-        kind: 'RecordField',
-        span: fieldSpan,
-        name: fieldName,
-        typeExpr,
-    };
-}
-function scalarType(span, name) {
-    return { kind: 'TypeName', span, name };
-}
-function parseAsmFieldTypeExpr(directive, operandText, fieldSpan) {
-    switch (directive.toLowerCase()) {
-        case '.byte':
-            return operandText === undefined || operandText.length === 0
-                ? scalarType(fieldSpan, 'byte')
-                : undefined;
-        case '.word':
-            return operandText === undefined || operandText.length === 0
-                ? scalarType(fieldSpan, 'word')
-                : undefined;
-        case '.addr':
-            return operandText === undefined || operandText.length === 0
-                ? scalarType(fieldSpan, 'addr')
-                : undefined;
-        case '.field': {
-            if (operandText === undefined || operandText.length === 0)
-                return undefined;
-            const size = parseNumberLiteral(operandText);
-            if (size === undefined) {
-                return parseTypeExprFromText(operandText, fieldSpan);
-            }
-            if (size < 1)
-                return undefined;
-            if (size === 1)
-                return scalarType(fieldSpan, 'byte');
-            if (size === 2)
-                return scalarType(fieldSpan, 'word');
-            return {
-                kind: 'ArrayType',
-                span: fieldSpan,
-                element: scalarType(fieldSpan, 'byte'),
-                length: size,
-            };
-        }
-        default:
-            return undefined;
-    }
-}
-function parseRecordFields(fieldKind, startIndex, ctx, declarationName, endKeyword) {
-    const { file, lineCount, diagnostics, sourcePath, getRawLine, isReservedTopLevelName } = ctx;
-    const fields = [];
-    const fieldNamesLower = new Set();
-    let terminated = false;
-    let interruptedByKeyword;
-    let interruptedByLine;
-    let interruptedByFilePath;
-    let endOffset = file.text.length;
-    let index = startIndex;
-    while (index < lineCount) {
-        const fieldLine = getRawLine(index);
-        const { endOffset: lineEndOffset, lineNo, filePath } = fieldLine;
-        const fieldText = stripComment(fieldLine.raw).trim();
-        const fieldTextLower = fieldText.toLowerCase();
-        if (fieldText.length === 0) {
-            index++;
-            continue;
-        }
-        if (fieldTextLower === endKeyword) {
-            terminated = true;
-            endOffset = lineEndOffset;
-            index++;
-            break;
-        }
-        const topKeyword = topLevelStartKeyword(fieldText);
-        if (topKeyword !== undefined) {
-            interruptedByKeyword = topKeyword;
-            interruptedByLine = lineNo;
-            interruptedByFilePath = filePath;
-            break;
-        }
-        const field = parseRecordFieldDecl(fieldKind, fieldText, fieldLine, fieldNamesLower, {
-            file,
-            diagnostics,
-            sourcePath,
-            isReservedTopLevelName,
-        }, declarationName);
-        if (field)
-            fields.push(field);
-        index++;
-    }
-    return {
-        fields,
-        nextIndex: index,
-        terminated,
-        endOffset,
-        ...(interruptedByKeyword !== undefined ? { interruptedByKeyword } : {}),
-        ...(interruptedByLine !== undefined ? { interruptedByLine } : {}),
-        ...(interruptedByFilePath !== undefined ? { interruptedByFilePath } : {}),
-    };
-}
-export function parseRecordFieldBlock(params) {
-    const { declarationKind, declarationName, fieldKind, declarationLineNo, startIndex, ctx } = params;
-    const { file, diagnostics, sourcePath } = ctx;
-    const endKeyword = declarationKind === 'type' ? '.endtype' : '.endunion';
-    const parsed = parseRecordFields(fieldKind, startIndex, ctx, declarationName, endKeyword);
-    if (!parsed.terminated) {
-        if (parsed.interruptedByKeyword !== undefined &&
-            parsed.interruptedByLine !== undefined &&
-            parsed.interruptedByFilePath !== undefined) {
-            diag(diagnostics, parsed.interruptedByFilePath, `Unterminated ${declarationKind} "${declarationName}": expected "${endKeyword}" before "${parsed.interruptedByKeyword}"`, { line: parsed.interruptedByLine, column: 1 });
-        }
-        else {
-            diag(diagnostics, sourcePath, `Unterminated ${declarationKind} "${declarationName}": missing "${endKeyword}"`, { line: declarationLineNo, column: 1 });
-        }
-    }
-    if (parsed.fields.length === 0) {
-        const declarationLabel = declarationKind === 'type' ? 'Type' : 'Union';
-        diag(diagnostics, sourcePath, `${declarationLabel} "${declarationName}" must contain at least one field`, { line: declarationLineNo, column: 1 });
-    }
-    return {
-        fields: parsed.fields,
-        nextIndex: parsed.nextIndex,
-        endOffset: parsed.terminated ? parsed.endOffset : file.text.length,
-    };
-}

package/dist/legacy-root-azm/src/frontend/parseSourceItemDispatch.d.ts

@@ -1,46 +0,0 @@
-import type { Diagnostic } from '../diagnosticTypes.js';
-import type { SourceItemNode, SourceSpan } from './ast.js';
-import type { DirectiveAliasPolicy } from './directiveAliases.js';
-import type { LogicalLine } from './parseLogicalLines.js';
-import type { SourceFile } from './source.js';
-export type ParseItemContext = {
-    scope: 'source';
-    asmEnded?: boolean;
-};
-export type ParseItemResult = {
-    nextIndex: number;
-    node?: SourceItemNode;
-    nodes?: SourceItemNode[];
-};
-export type RawSourceLine = {
-    raw: string;
-    startOffset: number;
-    endOffset: number;
-    lineNo: number;
-    filePath: string;
-};
-export type ParseSourceItemDispatchArgs = {
-    index: number;
-    lineNo: number;
-    filePath: string;
-    text: string;
-    rest: string;
-    stmtSpan: SourceSpan;
-    lineStartOffset: number;
-    ctx: ParseItemContext;
-};
-type ParseSourceItemDispatchHandler = (args: ParseSourceItemDispatchArgs) => ParseItemResult | undefined;
-export type SourceItemDispatchTable = Readonly<Partial<Record<string, ParseSourceItemDispatchHandler>>>;
-type DispatchSourceItemContext = {
-    aliasPolicy?: DirectiveAliasPolicy;
-    diagnostics: Diagnostic[];
-    file: SourceFile;
-    getRawLine: (lineIndex: number) => RawSourceLine;
-    logicalLines: LogicalLine[];
-    sourceItemDispatchTable: SourceItemDispatchTable;
-    sourcePath: string;
-    asmStringEquates: Map<string, string>;
-    span: typeof import('./source.js').span;
-};
-export declare function dispatchSourceItem(index: number, ctx: ParseItemContext, dispatchContext: DispatchSourceItemContext): ParseItemResult;
-export {};

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

@@ -1,53 +0,0 @@
-import { parseAsmTopLevel } from './parseAsmTopLevel.js';
-import { topLevelStartKeyword } from './parseTopLevelCommon.js';
-import { recoverUnsupportedParserLine } from './parseParserRecovery.js';
-import { stripLineComment as stripComment } from './parseParserShared.js';
-export function dispatchSourceItem(index, ctx, dispatchContext) {
-    const { aliasPolicy, diagnostics, file, getRawLine, logicalLines, sourceItemDispatchTable, sourcePath, asmStringEquates, span, } = dispatchContext;
-    const { raw, startOffset: lineStartOffset, endOffset: lineEndOffset } = getRawLine(index);
-    const text = stripComment(raw).trim();
-    const lineNo = logicalLines[index]?.lineNo ?? index + 1;
-    const filePath = logicalLines[index]?.filePath ?? sourcePath;
-    if (text.length === 0)
-        return { nextIndex: index + 1 };
-    const rest = text;
-    const stmtSpan = span(file, lineStartOffset, lineEndOffset);
-    const parsedAsm = parseAsmTopLevel({
-        index,
-        filePath,
-        lineNo,
-        rest,
-        stmtSpan,
-        diagnostics,
-        ctx,
-        ...(aliasPolicy ? { aliasPolicy } : {}),
-        asmStringEquates,
-    });
-    if (parsedAsm)
-        return parsedAsm;
-    const dispatchKeyword = topLevelStartKeyword(rest);
-    const dispatchHandler = dispatchKeyword === undefined ? undefined : sourceItemDispatchTable[dispatchKeyword];
-    if (dispatchHandler) {
-        const parsed = dispatchHandler({
-            index,
-            lineNo,
-            filePath,
-            text,
-            rest,
-            stmtSpan,
-            lineStartOffset,
-            ctx,
-        });
-        if (parsed)
-            return parsed;
-    }
-    return recoverUnsupportedParserLine({
-        index,
-        scope: ctx.scope,
-        text,
-        rest,
-        lineNo,
-        filePath,
-        diagnostics,
-    });
-}

package/dist/legacy-root-azm/src/frontend/parseSourceItemTable.d.ts

@@ -1,16 +0,0 @@
-import type { Diagnostic } from '../diagnosticTypes.js';
-import type { LogicalLine } from './parseLogicalLines.js';
-import type { SourceFile } from './source.js';
-import type { SourceItemDispatchTable, RawSourceLine } from './parseSourceItemDispatch.js';
-type CreateSourceItemTableContext = {
-    diagnostics: Diagnostic[];
-    file: SourceFile;
-    getRawLine: (lineIndex: number) => RawSourceLine;
-    isReservedTopLevelName: (name: string) => boolean;
-    lineCount: number;
-    logicalLines: LogicalLine[];
-    sourcePath: string;
-    parseOpParamsFromText: typeof import('./parseParams.js').parseOpParamsFromText;
-};
-export declare function createSourceItemTable(ctx: CreateSourceItemTableContext): SourceItemDispatchTable;
-export {};

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

@@ -1,68 +0,0 @@
-import { consumeTopKeyword } from './parseTopLevelCommon.js';
-import { parseEnumDecl } from './parseEnum.js';
-import { parseTopLevelOpDecl } from './parseOp.js';
-import { parseTypeDecl, parseUnionDecl } from './parseTypes.js';
-export function createSourceItemTable(ctx) {
-    const { diagnostics, file, getRawLine, isReservedTopLevelName, lineCount, logicalLines: _logicalLines, parseOpParamsFromText, } = ctx;
-    function parseTypeItem({ index, lineNo, filePath, text, rest, stmtSpan, }) {
-        const typeTail = consumeTopKeyword(rest, 'type') ?? '';
-        const parsedType = parseTypeDecl(typeTail, text, stmtSpan, lineNo, index, {
-            file,
-            lineCount,
-            diagnostics,
-            sourcePath: filePath,
-            getRawLine,
-            isReservedTopLevelName,
-        });
-        if (!parsedType)
-            return { nextIndex: index + 1 };
-        return { nextIndex: parsedType.nextIndex, node: parsedType.node };
-    }
-    function parseUnionItem({ index, lineNo, filePath, text, rest, stmtSpan, }) {
-        const unionTail = consumeTopKeyword(rest, 'union') ?? '';
-        const parsedUnion = parseUnionDecl(unionTail, text, stmtSpan, lineNo, index, {
-            file,
-            lineCount,
-            diagnostics,
-            sourcePath: filePath,
-            getRawLine,
-            isReservedTopLevelName,
-        });
-        if (!parsedUnion)
-            return { nextIndex: index + 1 };
-        return { nextIndex: parsedUnion.nextIndex, node: parsedUnion.node };
-    }
-    function parseOpItem({ index, lineNo, filePath, text, rest, stmtSpan, }) {
-        const opTail = consumeTopKeyword(rest, 'op') ?? '';
-        const parsedOp = parseTopLevelOpDecl(opTail, text, stmtSpan, lineNo, index, {
-            file,
-            lineCount,
-            diagnostics,
-            sourcePath: filePath,
-            getRawLine,
-            isReservedTopLevelName,
-            parseOpParamsFromText,
-        });
-        if (!parsedOp)
-            return { nextIndex: index + 1 };
-        return { nextIndex: parsedOp.nextIndex, node: parsedOp.node };
-    }
-    function parseEnumItem({ index, lineNo, filePath, text, rest, stmtSpan, }) {
-        const enumTail = consumeTopKeyword(rest, 'enum') ?? '';
-        const enumNode = parseEnumDecl(enumTail, {
-            diagnostics,
-            sourcePath: filePath,
-            lineNo,
-            text,
-            span: stmtSpan,
-            isReservedTopLevelName,
-        });
-        return { nextIndex: index + 1, ...(enumNode ? { node: enumNode } : {}) };
-    }
-    return {
-        type: parseTypeItem,
-        union: parseUnionItem,
-        op: parseOpItem,
-        enum: parseEnumItem,
-    };
-}

package/dist/legacy-root-azm/src/frontend/parseTopLevelCommon.d.ts

@@ -1,11 +0,0 @@
-import type { Diagnostic } from '../diagnosticTypes.js';
-export declare const malformedTopLevelHeaderExpectations: ReadonlyArray<{
-    keyword: string;
-    kind: string;
-    expected: string;
-}>;
-export declare function topLevelStartKeyword(t: string): string | undefined;
-export declare function consumeTopKeyword(input: string, keyword: string): string | undefined;
-export declare function diagInvalidBlockLine(diagnostics: Diagnostic[], sourcePath: string, kind: string, lineText: string, expected: string, line: number): void;
-export declare function diagInvalidHeaderLine(diagnostics: Diagnostic[], sourcePath: string, kind: string, lineText: string, expected: string, line: number): void;
-export declare function formatIdentifierToken(rawText: string): string;

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

@@ -1,50 +0,0 @@
-import { parseDiag as diag } from './parseDiagnostics.js';
-import { TOP_LEVEL_KEYWORDS } from './grammarData.js';
-export const malformedTopLevelHeaderExpectations = [
-    { keyword: 'type', kind: 'type declaration', expected: '<name>' },
-    { keyword: 'union', kind: 'union declaration', expected: '<name>' },
-    { keyword: 'op', kind: 'op header', expected: '<name>(...)' },
-    { keyword: 'enum', kind: 'enum declaration', expected: '<name> <member>[, ...]' },
-];
-function consumeKeywordPrefix(input, keyword) {
-    const match = new RegExp(`^\\.?${keyword}(?:\\s+(.*))?$`, 'i').exec(input);
-    if (!match)
-        return undefined;
-    return (match[1] ?? '').trimStart();
-}
-export function topLevelStartKeyword(t) {
-    const rawKeyword = (t.split(/\s/, 1)[0] ?? '').toLowerCase();
-    if (!rawKeyword.startsWith('.') && (rawKeyword === 'type' || rawKeyword === 'union')) {
-        return undefined;
-    }
-    const keyword = rawKeyword.startsWith('.') ? rawKeyword.slice(1) : rawKeyword;
-    return TOP_LEVEL_KEYWORDS.has(keyword) ? keyword : undefined;
-}
-export function consumeTopKeyword(input, keyword) {
-    return consumeKeywordPrefix(input, keyword);
-}
-function quoteDiagLineText(text) {
-    const trimmed = text.trim();
-    const preview = trimmed.length > 96 ? `${trimmed.slice(0, 93)}...` : trimmed;
-    return preview.replace(/"/g, '\\"');
-}
-export function diagInvalidBlockLine(diagnostics, sourcePath, kind, lineText, expected, line) {
-    const q = quoteDiagLineText(lineText);
-    diag(diagnostics, sourcePath, `Invalid ${kind} line "${q}": expected ${expected}`, {
-        line,
-        column: 1,
-    });
-}
-export function diagInvalidHeaderLine(diagnostics, sourcePath, kind, lineText, expected, line) {
-    const q = quoteDiagLineText(lineText);
-    diag(diagnostics, sourcePath, `Invalid ${kind} line "${q}": expected ${expected}`, {
-        line,
-        column: 1,
-    });
-}
-export function formatIdentifierToken(rawText) {
-    const trimmed = rawText.trim();
-    if (trimmed.length === 0)
-        return '<empty>';
-    return `"${trimmed.replace(/"/g, '\\"')}"`;
-}

package/dist/legacy-root-azm/src/frontend/parseTypes.d.ts

@@ -1,24 +0,0 @@
-import type { SourceSpan, TypeDeclNode, UnionDeclNode } from './ast.js';
-import type { SourceFile } from './source.js';
-import type { Diagnostic } from '../diagnosticTypes.js';
-import { type RecordFieldLine } from './parseRecordFieldDecl.js';
-type RawLine = RecordFieldLine;
-type ParseTypeContext = {
-    file: SourceFile;
-    lineCount: number;
-    diagnostics: Diagnostic[];
-    sourcePath: string;
-    getRawLine: (lineIndex: number) => RawLine;
-    isReservedTopLevelName: (name: string) => boolean;
-};
-type ParsedTypeDecl = {
-    node: TypeDeclNode;
-    nextIndex: number;
-};
-type ParsedUnionDecl = {
-    node: UnionDeclNode;
-    nextIndex: number;
-};
-export declare function parseTypeDecl(typeTail: string, stmtText: string, stmtSpan: SourceSpan, lineNo: number, startIndex: number, ctx: ParseTypeContext): ParsedTypeDecl | undefined;
-export declare function parseUnionDecl(unionTail: string, stmtText: string, stmtSpan: SourceSpan, lineNo: number, startIndex: number, ctx: ParseTypeContext): ParsedUnionDecl | undefined;
-export {};

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

@@ -1,77 +0,0 @@
-import { span } from './source.js';
-import { parseDiag as diag } from './parseDiagnostics.js';
-import { diagInvalidHeaderLine, formatIdentifierToken } from './parseTopLevelCommon.js';
-import { parseRecordFieldBlock } from './parseRecordFieldDecl.js';
-function parseLayoutDeclName(declarationKind, name, stmtText, lineNo, ctx) {
-    const { diagnostics, sourcePath, isReservedTopLevelName } = ctx;
-    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(name)) {
-        if (name.length > 0) {
-            diag(diagnostics, sourcePath, `Invalid ${declarationKind} name ${formatIdentifierToken(name)}: expected <identifier>.`, { line: lineNo, column: 1 });
-        }
-        else {
-            diagInvalidHeaderLine(diagnostics, sourcePath, `${declarationKind} declaration`, stmtText, '<name>', lineNo);
-        }
-        return undefined;
-    }
-    if (isReservedTopLevelName(name)) {
-        diag(diagnostics, sourcePath, `Invalid ${declarationKind} name "${name}": collides with a top-level keyword.`, { line: lineNo, column: 1 });
-        return undefined;
-    }
-    return name;
-}
-export function parseTypeDecl(typeTail, stmtText, stmtSpan, lineNo, startIndex, ctx) {
-    const { file, diagnostics, sourcePath } = ctx;
-    const afterType = typeTail.trim();
-    const parts = afterType.split(/\s+/, 2);
-    const name = parseLayoutDeclName('type', parts[0] ?? '', stmtText, lineNo, ctx);
-    if (!name)
-        return undefined;
-    const tail = afterType.slice(name.length).trimStart();
-    if (tail.length > 0) {
-        diagInvalidHeaderLine(diagnostics, sourcePath, 'type declaration', stmtText, '<name>', lineNo);
-        return undefined;
-    }
-    const record = parseRecordFieldBlock({
-        declarationKind: 'type',
-        declarationName: name,
-        fieldKind: 'record',
-        declarationLineNo: lineNo,
-        startIndex: startIndex + 1,
-        ctx,
-    });
-    const typeEnd = record.endOffset;
-    const typeSpan = span(file, stmtSpan.start.offset, typeEnd);
-    return {
-        node: {
-            kind: 'TypeDecl',
-            span: typeSpan,
-            name,
-            typeExpr: { kind: 'RecordType', span: typeSpan, fields: record.fields },
-        },
-        nextIndex: record.nextIndex,
-    };
-}
-export function parseUnionDecl(unionTail, stmtText, stmtSpan, lineNo, startIndex, ctx) {
-    const { file } = ctx;
-    const name = parseLayoutDeclName('union', unionTail.trim(), stmtText, lineNo, ctx);
-    if (!name)
-        return undefined;
-    const record = parseRecordFieldBlock({
-        declarationKind: 'union',
-        declarationName: name,
-        fieldKind: 'union',
-        declarationLineNo: lineNo,
-        startIndex: startIndex + 1,
-        ctx,
-    });
-    const unionEnd = record.endOffset;
-    return {
-        node: {
-            kind: 'UnionDecl',
-            span: span(file, stmtSpan.start.offset, unionEnd),
-            name,
-            fields: record.fields,
-        },
-        nextIndex: record.nextIndex,
-    };
-}

package/dist/legacy-root-azm/src/frontend/parser.d.ts

@@ -1,11 +0,0 @@
-import type { SourceFileNode } from './ast.js';
-import type { Diagnostic } from '../diagnosticTypes.js';
-import { type SourceFile } from './source.js';
-import type { DirectiveAliasPolicy } from './directiveAliases.js';
-/**
- * Parse a single AZM source file from an in-memory source string.
- *
- * Implementation note:
- * - Parsing is best-effort: on errors, diagnostics are appended and parsing continues.
- */
-export declare function parseSourceFile(sourcePath: string, sourceText: string, diagnostics: Diagnostic[], sourceFileOverride?: SourceFile, aliasPolicy?: DirectiveAliasPolicy): SourceFileNode;

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

@@ -1,88 +0,0 @@
-import { buildLogicalLines, getLogicalLine } from './parseLogicalLines.js';
-import { dispatchSourceItem, } from './parseSourceItemDispatch.js';
-import { createSourceItemTable } from './parseSourceItemTable.js';
-import { parseOpParamsFromText } from './parseParams.js';
-import { isReservedTopLevelDeclName } from './parseParserShared.js';
-import { makeSourceFile, span } from './source.js';
-import { parseAsmLine } from './asm80/asmLine.js';
-import { parseWholeQuotedString } from './asm80/parseAsmRawValues.js';
-/**
- * Parse a single AZM source file from an in-memory source string.
- *
- * Implementation note:
- * - Parsing is best-effort: on errors, diagnostics are appended and parsing continues.
- */
-export function parseSourceFile(sourcePath, sourceText, diagnostics, sourceFileOverride, aliasPolicy) {
-    const file = sourceFileOverride ?? makeSourceFile(sourcePath, sourceText);
-    const logicalLines = buildLogicalLines(file, sourcePath, diagnostics);
-    const lineCount = logicalLines.length;
-    function getRawLine(lineIndex) {
-        const logical = getLogicalLine(logicalLines, lineIndex, sourcePath);
-        return {
-            raw: logical.raw,
-            startOffset: logical.startOffset,
-            endOffset: logical.endOffset,
-            lineNo: logical.lineNo,
-            filePath: logical.filePath,
-        };
-    }
-    const items = [];
-    const asmStringEquates = new Map();
-    for (let index = 0; index < lineCount; index++) {
-        const line = getRawLine(index);
-        const parsed = parseAsmLine(line.filePath, line.raw, line.lineNo, line.startOffset, aliasPolicy);
-        if (parsed?.kind === 'end')
-            break;
-        if (parsed?.kind !== 'equ')
-            continue;
-        const rawString = parseWholeQuotedString(parsed.exprText);
-        if (rawString !== undefined && rawString.length > 1) {
-            const name = parsed.name.startsWith('@') ? parsed.name.slice(1) : parsed.name;
-            asmStringEquates.set(name.toLowerCase(), rawString);
-        }
-    }
-    function isReservedTopLevelName(name) {
-        return isReservedTopLevelDeclName(name);
-    }
-    const sourceItemDispatchTable = createSourceItemTable({
-        diagnostics,
-        file,
-        getRawLine,
-        isReservedTopLevelName,
-        lineCount,
-        logicalLines,
-        sourcePath,
-        parseOpParamsFromText,
-    });
-    function parseSourceItem(index, ctx) {
-        return dispatchSourceItem(index, ctx, {
-            diagnostics,
-            file,
-            getRawLine,
-            logicalLines,
-            sourceItemDispatchTable,
-            sourcePath,
-            asmStringEquates,
-            ...(aliasPolicy ? { aliasPolicy } : {}),
-            span,
-        });
-    }
-    const sourceCtx = { scope: 'source' };
-    let i = 0;
-    while (i < lineCount) {
-        const parsed = parseSourceItem(i, sourceCtx);
-        if (parsed.nodes)
-            items.push(...parsed.nodes);
-        else if (parsed.node)
-            items.push(parsed.node);
-        i = parsed.nextIndex;
-    }
-    const sourceSpan = span(file, 0, sourceText.length);
-    const sourceFileNode = {
-        kind: 'SourceFile',
-        span: sourceSpan,
-        path: sourcePath,
-        items,
-    };
-    return sourceFileNode;
-}

package/dist/legacy-root-azm/src/frontend/source.d.ts

@@ -1,28 +0,0 @@
-import type { SourceSpan } from './ast.js';
-/**
- * Source file + precomputed line-start offsets, used to convert byte offsets into line/column spans.
- */
-export interface SourceFile {
-    path: string;
-    text: string;
-    /**
-     * 0-based byte offsets for the start of each line. The first entry is always 0.
-     */
-    lineStarts: number[];
-    /**
-     * Optional per-line file mapping for include-aware source locations.
-     */
-    lineFiles?: string[];
-    /**
-     * Optional per-line line number mapping for include-aware source locations.
-     */
-    lineBaseLines?: number[];
-}
-/**
- * Build a {@link SourceFile} from a path and UTF-8 source text.
- */
-export declare function makeSourceFile(path: string, text: string): SourceFile;
-/**
- * Construct a {@link SourceSpan} for a half-open offset range `[startOffset, endOffset]`.
- */
-export declare function span(file: SourceFile, startOffset: number, endOffset: number): SourceSpan;