@jhlagado/azm 0.2.9 → 0.2.11

package/README.md

@@ -10,6 +10,7 @@ AZM manual and broader Debug80 documentation:
 - [Debug80 documentation](https://debug80.com/)
 - [AZM Book 0 — Assembler Manual](https://debug80.com/azm-book/book0/)
 - [AZM Book 4](https://jhlagado.github.io/debug80-docs/azm-book/book4/)
+- [AZM Grammar Reference](docs/reference/azm-grammar.md)
 
 ## Install
 
@@ -120,9 +121,7 @@ Use `@Name:` for callable routine entries. The `@` marks a register contracts
 routine boundary; call sites still write the symbol name without `@`:
 
 ```asm
-;!      in        A
-;!      out       A
-;!      clobbers  BC
+;! in A; out A; clobbers BC
 @MxMask:
         LD      C,A
         OR      A
@@ -187,6 +186,19 @@ indent instructions and standalone directives, and align operands enough to keep
 dense assembly readable. Exact tab width is less important than keeping one
 source file internally consistent.
 
+AZM normally uses one statement per physical line. For short, dense instruction
+sequences, a physical line may contain multiple instructions or `op` invocations
+separated by a spaced backslash:
+
+```asm
+Loop:   ld      a,(hl) \ inc hl \ djnz Loop
+```
+
+This is only instruction compaction. Directives and declarations still belong on
+their own lines, and labels are only allowed before the first chained
+instruction. A semicolon still starts a comment; it is not an instruction
+separator.
+
 ## Literals
 
 AZM accepts the usual Z80 numeric forms:
@@ -406,9 +418,7 @@ register and stack assumptions visible before they become debugger sessions.
 Routine entry labels start with `@`:
 
 ```asm
-;! in A,HL
-;! out carry
-;! clobbers B
+;! in A,HL; out carry; clobbers B
 @CheckTile:
         ld      b,(hl)
         cp      b
@@ -423,9 +433,11 @@ name:
 ```
 
 AZMDoc register contract comments use `;!` and may record inputs, outputs,
-clobbered registers and preserved registers. `clobbers B` means the routine may
-change `B`. `preserves B` means the value that enters in `B` is still present
-when the routine returns.
+clobbered registers and preserved registers. Separate clauses on the same line
+with semicolons. Older one-clause-per-line comments are still accepted, but AZM
+generated annotations use the compact single-line form. `clobbers B` means the
+routine may change `B`. `preserves B` means the value that enters in `B` is
+still present when the routine returns.
 
 Run the analysis with:
 

package/dist/src/core/compile.js

@@ -2,10 +2,12 @@ import { assembleProgram } from '../assembly/assemble-program.js';
 import { writeIntelHex } from '../outputs/hex.js';
 import { createSourceFile } from '../source/source-file.js';
 import { scanLogicalLines } from '../source/logical-lines.js';
-import { stripLineComment } from '../source/strip-line-comment.js';
+import { extractLineComment, stripLineComment } from '../source/strip-line-comment.js';
+import { parseInstructionChain } from '../syntax/parse-instruction-chain.js';
 import { parseLogicalLine } from '../syntax/parse-line.js';
 import { parseLayoutDeclarationAt } from '../syntax/parse-layout-declarations.js';
 import { collectOps, expandOpInvocation, parseOpInvocation, } from '../expansion/op-expansion.js';
+import { parseZ80Instruction } from '../z80/parse-instruction.js';
 import { applyConditionalAssembly } from './conditional-assembly.js';
 export function parseNextSourceItems(lines, options = {}) {
     const diagnostics = [];
@@ -43,6 +45,9 @@ function parsePendingLine(context, index, afterTopLevelEnd) {
     if (parseExpandedOpLine(context, line)) {
         return { consumedUntilIndex: index, afterTopLevelEnd };
     }
+    if (parseInstructionChainLine(context, line)) {
+        return { consumedUntilIndex: index, afterTopLevelEnd };
+    }
     return parseNormalLine(context, index, line, afterTopLevelEnd);
 }
 function shouldSkipPendingLine(context, index, line, afterTopLevelEnd) {
@@ -78,6 +83,97 @@ function parseNormalLine(context, index, line, afterTopLevelEnd) {
         afterTopLevelEnd: afterTopLevelEnd || result.items.some((item) => item.kind === 'end'),
     };
 }
+function parseInstructionChainLine(context, line) {
+    const parsed = parseInstructionChain({
+        line,
+        parseStatement: (segmentLine, statementText, statementColumn) => parseChainStatement(context, segmentLine, statementText, statementColumn),
+        makeLabelItem: (label, segmentLine) => ({
+            kind: 'label',
+            name: label.name,
+            ...(label.isEntry ? { isEntry: true } : {}),
+            span: spanAt(segmentLine, label.labelColumn),
+        }),
+        makeDiagnostic: chainDiagnostic,
+        appendLineComment: appendChainComment,
+    });
+    if (parsed === undefined)
+        return false;
+    context.diagnostics.push(...parsed.diagnostics);
+    context.items.push(...parsed.items);
+    return true;
+}
+function parseChainStatement(context, line, statementText, statementColumn) {
+    const segmentLine = paddedSegmentLine(line, statementText, statementColumn);
+    const opCall = parseOpInvocation(segmentLine);
+    const overloads = opCall ? context.ops.get(opCall.name) : undefined;
+    if (opCall && overloads) {
+        const diagnostics = [];
+        return {
+            items: expandOpInvocation(context.ops, overloads, opCall.operands, segmentLine, diagnostics),
+            diagnostics,
+        };
+    }
+    return parseChainInstruction(line, statementText, statementColumn);
+}
+function parseChainInstruction(line, text, column) {
+    const instruction = parseZ80Instruction(text);
+    if (instruction?.instruction) {
+        return {
+            items: [{ kind: 'instruction', instruction: instruction.instruction, span: spanAt(line, column) }],
+            diagnostics: [],
+        };
+    }
+    if (instruction?.diagnostics && instruction.diagnostics.length > 0) {
+        return {
+            items: [],
+            diagnostics: instruction.diagnostics.map((message) => chainDiagnostic(line, column, message)),
+        };
+    }
+    if (instruction?.error) {
+        return { items: [], diagnostics: [chainDiagnostic(line, column, instruction.error)] };
+    }
+    return {
+        items: [],
+        diagnostics: [chainDiagnostic(line, column, `unsupported source line: ${text}`)],
+    };
+}
+function appendChainComment(items, line) {
+    const comment = extractLineComment(line.text);
+    if (!comment)
+        return;
+    items.push({
+        kind: 'comment',
+        text: comment,
+        origin: 'user',
+        span: spanAt(line, firstColumn(line.text)),
+    });
+}
+function paddedSegmentLine(line, text, column) {
+    return { ...line, text: `${' '.repeat(Math.max(0, column - 1))}${text}` };
+}
+function spanAt(line, column) {
+    return {
+        sourceName: line.sourceName,
+        line: line.line,
+        column,
+        ...(line.sourceUnit !== undefined ? { sourceUnit: line.sourceUnit } : {}),
+        ...(line.sourceRelation !== undefined ? { sourceRelation: line.sourceRelation } : {}),
+    };
+}
+function firstColumn(text) {
+    const match = /\S/.exec(text);
+    return match ? match.index + 1 : 1;
+}
+function chainDiagnostic(line, column, message) {
+    return {
+        severity: 'error',
+        code: 'AZMN_PARSE',
+        message,
+        sourceName: line.sourceName,
+        line: line.line,
+        column,
+    };
+}
 export function compileSource(sourceText, options = {}) {
     const source = createSourceFile(options.entryName ?? '<memory>', sourceText);
     const { diagnostics, items } = parseNextSourceItems(scanLogicalLines(source));

package/dist/src/expansion/op-expansion.js

@@ -1,4 +1,6 @@
 import { stripLineComment } from '../source/strip-line-comment.js';
+import { IDENTIFIER_PATTERN } from '../syntax/names.js';
+import { parseInstructionChain, } from '../syntax/parse-instruction-chain.js';
 import { parseLogicalLine } from '../syntax/parse-line.js';
 import { expandSelectedOp } from './op-expand-selected.js';
 import { splitOperands } from './op-operand-splitting.js';
@@ -21,7 +23,7 @@ export function collectOps(lines, diagnostics, parseOptions = {}) {
     return { ops, opLineIndexes };
 }
 function parseOpHeader(line, diagnostics) {
-    const opHeader = /^op\s+([A-Za-z_][A-Za-z0-9_]*)\s*\((.*)\)\s*$/i.exec(stripLineComment(line.text).trim());
+    const opHeader = new RegExp(`^op\\s+(${IDENTIFIER_PATTERN})\\s*\\((.*)\\)\\s*$`, 'i').exec(stripLineComment(line.text).trim());
     if (!opHeader)
         return undefined;
     return { name: opHeader[1] ?? '', params: parseOpParams(opHeader[2] ?? '', line, diagnostics) };
@@ -35,9 +37,8 @@ function collectOpBody(lines, startIndex, params, diagnostics, parseOptions, opL
         if (isOpEnd(bodyLine.text)) {
             return { body, terminated: true, endIndex: index };
         }
-        const template = parseOpBodyTemplate(bodyLine, paramNames, diagnostics, parseOptions);
-        if (template)
-            body.push(template);
+        const templates = parseOpBodyTemplates(bodyLine, paramNames, diagnostics, parseOptions);
+        body.push(...templates);
     }
     return { body, terminated: false, endIndex: lines.length };
 }
@@ -60,7 +61,7 @@ function recordCollectedOp(ops, header, collected, line, diagnostics) {
 }
 export function parseOpInvocation(line) {
     const text = stripLineComment(line.text).trim();
-    const match = /^([A-Za-z_][A-Za-z0-9_]*)(?:\s+(.+))?$/.exec(text);
+    const match = new RegExp(`^(${IDENTIFIER_PATTERN})(?:\\s+(.+))?$`).exec(text);
     if (!match) {
         return undefined;
     }
@@ -87,7 +88,7 @@ function parseOpParams(text, line, diagnostics) {
     }
     const params = [];
     for (const part of parts) {
-        const match = /^([A-Za-z_][A-Za-z0-9_]*)\s+([A-Za-z][A-Za-z0-9_]*)$/.exec(part.trim());
+        const match = new RegExp(`^(${IDENTIFIER_PATTERN})\\s+([A-Za-z][A-Za-z0-9_]*)$`).exec(part.trim());
         if (!match) {
             diagnostics.push(parseDiagnostic(line, 'Invalid op parameter list: trailing or empty entries are not permitted.'));
             continue;
@@ -115,8 +116,42 @@ function parseOpBodyTemplate(line, paramNames, diagnostics, parseOptions) {
         return parsedSource;
     return template;
 }
+function parseOpBodyTemplates(line, paramNames, diagnostics, parseOptions) {
+    const parsed = parseInstructionChain({
+        line,
+        parseStatement: (segmentLine, statementText, statementColumn) => parseOpBodyStatement(paddedLine(segmentLine, statementText, statementColumn), paramNames, diagnostics, parseOptions),
+        makeLabelItem: (label, segmentLine) => ({
+            kind: 'source-items',
+            items: [
+                {
+                    kind: 'label',
+                    name: label.name,
+                    ...(label.isEntry ? { isEntry: true } : {}),
+                    span: { sourceName: segmentLine.sourceName, line: segmentLine.line, column: label.labelColumn },
+                },
+            ],
+        }),
+        makeDiagnostic: parseDiagnosticAt,
+    });
+    if (parsed === undefined) {
+        const template = parseOpBodyTemplate(line, paramNames, diagnostics, parseOptions);
+        return template ? [template] : [];
+    }
+    diagnostics.push(...parsed.diagnostics);
+    return parsed.items;
+}
+function parseOpBodyStatement(line, paramNames, diagnostics, parseOptions) {
+    const statementDiagnostics = [];
+    const template = parseOpBodyTemplate(line, paramNames, statementDiagnostics, parseOptions);
+    return template
+        ? { items: [template], diagnostics: statementDiagnostics }
+        : { items: [], diagnostics: statementDiagnostics };
+}
+function paddedLine(line, text, column) {
+    return { ...line, text: `${' '.repeat(Math.max(0, column - 1))}${text}` };
+}
 function parseTemplateInstructionCandidate(text, paramNames) {
-    const instruction = /^([A-Za-z_][A-Za-z0-9_]*)(?:\s+(.+))?$/.exec(text);
+    const instruction = new RegExp(`^(${IDENTIFIER_PATTERN})(?:\\s+(.+))?$`).exec(text);
     if (!instruction)
         return undefined;
     const operands = parseTemplateOperands(instruction[2] ?? '', paramNames);
@@ -155,7 +190,7 @@ function parseTemplateOperand(text, paramNames) {
     if (paramNames.has(trimmed)) {
         return { kind: 'param', name: trimmed };
     }
-    const portParam = /^\(\s*([A-Za-z_][A-Za-z0-9_]*)\s*\)$/.exec(trimmed);
+    const portParam = new RegExp(`^\\(\\s*(${IDENTIFIER_PATTERN})\\s*\\)$`).exec(trimmed);
     if (portParam && paramNames.has(portParam[1] ?? '')) {
         return { kind: 'port-param', name: portParam[1] ?? '' };
     }
@@ -169,13 +204,16 @@ function isOpEnd(text) {
     return /^end\s*$/i.test(stripLineComment(text).trim());
 }
 function parseDiagnostic(line, message) {
+    return parseDiagnosticAt(line, firstColumn(line.text), message);
+}
+function parseDiagnosticAt(line, column, message) {
     return {
         severity: 'error',
         code: 'AZMN_PARSE',
         message,
         sourceName: line.sourceName,
         line: line.line,
-        column: firstColumn(line.text),
+        column,
     };
 }
 function firstColumn(text) {

package/dist/src/outputs/d8-files.js

@@ -53,6 +53,7 @@ function addSourceSegments(entries, sourceSegments) {
             start: segment.start,
             end: segment.end,
             line: segment.line,
+            column: segment.column,
             lstLine: segment.line,
             kind: segment.kind,
             confidence: segment.confidence,

package/dist/src/outputs/types.d.ts

@@ -100,6 +100,7 @@ export interface D8mSegment {
     end: number;
     lstLine: number;
     line?: number;
+    column?: number;
     kind: D8mSegmentKind;
     confidence: D8mSegmentConfidence;
 }

package/dist/src/register-contracts/report.js

@@ -2,6 +2,7 @@ function list(units) {
     return units.length === 0 ? '-' : units.join(',');
 }
 const FLAG_UNITS = new Set(['carry', 'zero', 'sign', 'parity', 'halfCarry']);
+const FLAG_UNIT_LIST = ['carry', 'zero', 'sign', 'parity', 'halfCarry'];
 const CONTRACT_CARRIER_PAIRS = [
     { label: 'BC', hi: 'B', lo: 'C' },
     { label: 'DE', hi: 'D', lo: 'E' },
@@ -32,6 +33,14 @@ export function contractCarrierList(units) {
     }
     return parts.length === 0 ? '-' : parts.join(',');
 }
+function sourceContractCarrierList(units) {
+    const unique = [...new Set(units)];
+    const hasAllFlags = FLAG_UNIT_LIST.every((unit) => unique.includes(unit));
+    const compacted = hasAllFlags
+        ? unique.filter((unit) => !FLAG_UNITS.has(unit)).concat('F')
+        : unique;
+    return contractCarrierList(compacted);
+}
 function relationOutputUnits(relations) {
     return relations.flatMap((rel) => rel.out);
 }
@@ -59,9 +68,9 @@ function sourceContractEntries(summary) {
     const outputUnits = relationOutputUnits(summary.valueRelations);
     if (outputUnits.length > 0)
         out.push({ keyword: 'out', carriers: contractCarrierList(outputUnits) });
-    const clobbers = summary.mayWrite.filter((unit) => !relationOut.has(unit) && !FLAG_UNITS.has(unit));
+    const clobbers = summary.mayWrite.filter((unit) => !relationOut.has(unit));
     if (clobbers.length > 0)
-        out.push({ keyword: 'clobbers', carriers: contractCarrierList(clobbers) });
+        out.push({ keyword: 'clobbers', carriers: sourceContractCarrierList(clobbers) });
     return out;
 }
 function stackStatus(summary) {
@@ -152,5 +161,8 @@ export function renderRegisterContractsInterface(summaries) {
     return `${lines.join('\n')}\n`;
 }
 export function renderRegisterContractsSourceBlock(summary) {
-    return sourceContractEntries(summary).map((entry) => `;!      ${entry.keyword.padEnd(10)}${entry.carriers}`);
+    const entries = sourceContractEntries(summary);
+    if (entries.length === 0)
+        return [];
+    return [`;! ${entries.map((entry) => `${entry.keyword} ${entry.carriers}`).join('; ')}`];
 }

package/dist/src/register-contracts/smartCommentParsing.d.ts

@@ -1,3 +1,4 @@
 import type { SmartComment } from './types.js';
 export declare function parseSmartCommentLine(line: string): SmartComment | undefined;
+export declare function parseSmartCommentLines(line: string): SmartComment[];
 export declare function isCompactSourceCommentLine(line: string): boolean;

package/dist/src/register-contracts/smartCommentParsing.js

@@ -1,5 +1,6 @@
 import { expandCarrierList } from './carriers.js';
 const COMPACT_SOURCE_TAG_RE = /^;?\s*!\s*(in|out|clobbers|preserves)(?:\s+(.+))?$/i;
+const COMPACT_SOURCE_CLAUSE_RE = /^(in|out|clobbers|preserves)(?:\s+(.+))?$/i;
 const COMPACT_SOURCE_LINE_RE = /^\s*;\s*!\s*(?:in|out|maybe-out|clobbers|preserves)(?:\s|$)/i;
 const CARRIER_RE = /^\{([^}]+)\}(?:\s+(.+))?$/;
 const CONTRACT_COMMENT_KINDS = new Set(['in', 'out', 'clobbers', 'preserves']);
@@ -35,17 +36,51 @@ function parseCarrierPayload(rest) {
     return { carriers, ...(name ? { name } : {}) };
 }
 export function parseSmartCommentLine(line) {
+    return parseSmartCommentLines(line)[0];
+}
+export function parseSmartCommentLines(line) {
     const trimmed = line.trim();
     const expectOut = parseExpectOutComment(trimmed);
     if (expectOut !== undefined)
-        return expectOut;
+        return [expectOut];
+    const semicolonSeparated = parseSemicolonSeparatedSourceComments(trimmed);
+    if (semicolonSeparated.length > 0)
+        return semicolonSeparated;
     const match = COMPACT_SOURCE_TAG_RE.exec(trimmed);
-    if (!match)
-        return undefined;
-    const tag = match[1].toLowerCase();
-    if (!CONTRACT_COMMENT_KINDS.has(tag))
-        return undefined;
-    return parseCarrierComment(tag, match[2]?.trim());
+    if (match) {
+        const tag = match[1].toLowerCase();
+        if (!CONTRACT_COMMENT_KINDS.has(tag))
+            return [];
+        const comment = parseCarrierComment(tag, match[2]?.trim());
+        return comment === undefined ? [] : [comment];
+    }
+    return [];
+}
+function parseSemicolonSeparatedSourceComments(trimmed) {
+    const sourcePrefix = /^;?\s*!\s*/.exec(trimmed);
+    if (sourcePrefix === null)
+        return [];
+    const content = trimmed.slice(sourcePrefix[0].length);
+    const parts = content
+        .split(';')
+        .map((part) => part.trim())
+        .filter(Boolean);
+    if (parts.length <= 1)
+        return [];
+    const comments = [];
+    for (const part of parts) {
+        const match = COMPACT_SOURCE_CLAUSE_RE.exec(part);
+        if (!match)
+            return [];
+        const tag = match[1].toLowerCase();
+        if (!CONTRACT_COMMENT_KINDS.has(tag))
+            return [];
+        const comment = parseCarrierComment(tag, match[2]?.trim());
+        if (comment === undefined)
+            return [];
+        comments.push(comment);
+    }
+    return comments;
 }
 function parseExpectOutComment(trimmed) {
     const expectOut = /^;?\s*expects\s+out\s+(.+)$/i.exec(trimmed);

package/dist/src/register-contracts/smartComments.d.ts

@@ -1,5 +1,5 @@
 import type { LocatedSmartComment, RegisterContractsRoutine, RoutineContract } from './types.js';
-import { parseSmartCommentLine } from './smartCommentParsing.js';
-export { parseSmartCommentLine };
+import { parseSmartCommentLine, parseSmartCommentLines } from './smartCommentParsing.js';
+export { parseSmartCommentLine, parseSmartCommentLines };
 export declare function parseSmartComments(sourceLineComments: ReadonlyMap<string, ReadonlyMap<number, string>>): LocatedSmartComment[];
 export declare function buildRoutineContracts(comments: LocatedSmartComment[], routines?: RegisterContractsRoutine[], sourceTexts?: ReadonlyMap<string, string>): Map<string, RoutineContract>;

package/dist/src/register-contracts/smartComments.js

@@ -1,12 +1,11 @@
 import { collectPrecedingCommentBlock } from './smartCommentBlocks.js';
-import { parseSmartCommentLine } from './smartCommentParsing.js';
-export { parseSmartCommentLine };
+import { parseSmartCommentLine, parseSmartCommentLines } from './smartCommentParsing.js';
+export { parseSmartCommentLine, parseSmartCommentLines };
 export function parseSmartComments(sourceLineComments) {
     const out = [];
     for (const [file, comments] of sourceLineComments) {
         for (const [line, text] of comments) {
-            const parsed = parseSmartCommentLine(`;${text}`);
-            if (parsed) {
+            for (const parsed of parseSmartCommentLines(`;${text}`)) {
                 out.push({ file, line, comment: parsed });
             }
         }

package/dist/src/source/instruction-chain.d.ts

@@ -0,0 +1,5 @@
+export interface InstructionChainSegment {
+    readonly text: string;
+    readonly column: number;
+}
+export declare function splitInstructionChain(text: string): readonly InstructionChainSegment[] | undefined;

package/dist/src/source/instruction-chain.js

@@ -0,0 +1,75 @@
+import { findLineCommentStart } from './line-comment-scanner.js';
+export function splitInstructionChain(text) {
+    const commentStart = findLineCommentStart(text);
+    const codeText = commentStart === undefined ? text : text.slice(0, commentStart);
+    const separators = findChainSeparators(codeText);
+    if (separators.length === 0)
+        return undefined;
+    const segments = [];
+    let start = 0;
+    for (const separator of [...separators, codeText.length]) {
+        const raw = codeText.slice(start, separator);
+        segments.push(segmentFromRaw(raw, start));
+        start = separator + 1;
+    }
+    return segments;
+}
+function findChainSeparators(text) {
+    const separators = [];
+    let state = {};
+    for (let index = 0; index < text.length; index += 1) {
+        const char = text[index];
+        if (state.escaped === true) {
+            state = { ...state, escaped: false };
+            continue;
+        }
+        if (char === '\\' && state.quote !== undefined) {
+            state = { ...state, escaped: true };
+            continue;
+        }
+        if (startsOrEndsQuote(text, index, state)) {
+            state =
+                state.quote === char
+                    ? withoutQuote(state)
+                    : withQuote(state, state.quote ?? char ?? '');
+            continue;
+        }
+        if (char === '\\' && isReadableSeparator(text, index)) {
+            separators.push(index);
+        }
+    }
+    return separators;
+}
+function segmentFromRaw(raw, rawStart) {
+    const leading = /^\s*/.exec(raw)?.[0].length ?? 0;
+    const trailing = /\s*$/.exec(raw)?.[0].length ?? 0;
+    const text = raw.slice(leading, raw.length - trailing);
+    return {
+        text,
+        column: rawStart + (text.length === 0 ? 0 : leading) + 1,
+    };
+}
+function startsOrEndsQuote(text, index, state) {
+    const char = text[index];
+    return isQuote(char) && !isApostropheSuffix(text, index, state);
+}
+function isQuote(char) {
+    return char === '"' || char === "'";
+}
+function isApostropheSuffix(text, index, state) {
+    return (state.quote === undefined &&
+        text[index] === "'" &&
+        /[A-Za-z0-9_]/.test(text[index - 1] ?? ''));
+}
+function withoutQuote(state) {
+    return state.escaped === true ? { escaped: true } : {};
+}
+function withQuote(state, quote) {
+    return {
+        quote,
+        ...(state.escaped === true ? { escaped: true } : {}),
+    };
+}
+function isReadableSeparator(text, index) {
+    return /\s/.test(text[index - 1] ?? '') && /\s/.test(text[index + 1] ?? '');
+}

package/dist/src/syntax/names.d.ts

@@ -0,0 +1,18 @@
+export declare const IDENTIFIER_PATTERN = "[A-Za-z_][A-Za-z0-9_]*";
+export declare const LABEL_NAME_PATTERN = "[A-Za-z_.$?][A-Za-z0-9_.$?]*";
+export interface ParsedEntryLabel {
+    readonly rawLabel: string;
+    readonly name: string;
+    readonly isEntry: boolean;
+}
+export interface ParsedLeadingLabel extends ParsedEntryLabel {
+    readonly labelColumn: number;
+    readonly statementText: string;
+    readonly statementColumn: number;
+}
+export declare function isIdentifier(text: string): boolean;
+export declare function isLabelName(text: string): boolean;
+export declare function parseEntryLabel(text: string): ParsedEntryLabel | undefined;
+export declare function normalizeEntryLabelName(raw: string): string;
+export declare function hasLeadingLabel(text: string): boolean;
+export declare function parseLeadingLabel(text: string, column: number): ParsedLeadingLabel | undefined;

package/dist/src/syntax/names.js

@@ -0,0 +1,44 @@
+export const IDENTIFIER_PATTERN = '[A-Za-z_][A-Za-z0-9_]*';
+export const LABEL_NAME_PATTERN = '[A-Za-z_.$?][A-Za-z0-9_.$?]*';
+const IDENTIFIER_RE = new RegExp(`^${IDENTIFIER_PATTERN}$`);
+const LABEL_NAME_RE = new RegExp(`^${LABEL_NAME_PATTERN}$`);
+const ENTRY_LABEL_RE = new RegExp(`^@?${LABEL_NAME_PATTERN}$`);
+const LEADING_LABEL_RE = new RegExp(`^(@?${LABEL_NAME_PATTERN}):\\s*(.*)$`);
+export function isIdentifier(text) {
+    return IDENTIFIER_RE.test(text);
+}
+export function isLabelName(text) {
+    return LABEL_NAME_RE.test(text);
+}
+export function parseEntryLabel(text) {
+    if (!ENTRY_LABEL_RE.test(text))
+        return undefined;
+    return {
+        rawLabel: text,
+        name: normalizeEntryLabelName(text),
+        isEntry: text.startsWith('@'),
+    };
+}
+export function normalizeEntryLabelName(raw) {
+    return raw.startsWith('@') ? raw.slice(1) : raw;
+}
+export function hasLeadingLabel(text) {
+    return new RegExp(`^@?${LABEL_NAME_PATTERN}:`).test(text);
+}
+export function parseLeadingLabel(text, column) {
+    const match = LEADING_LABEL_RE.exec(text);
+    if (!match)
+        return undefined;
+    const rawLabel = match[1] ?? '';
+    const parsed = parseEntryLabel(rawLabel);
+    if (!parsed)
+        return undefined;
+    const statementText = match[2] ?? '';
+    const statementOffset = text.indexOf(statementText, rawLabel.length + 1);
+    return {
+        ...parsed,
+        labelColumn: column,
+        statementText,
+        statementColumn: column + (statementOffset === -1 ? text.length : statementOffset),
+    };
+}

package/dist/src/syntax/parse-data-directives.d.ts

@@ -0,0 +1,17 @@
+import type { LogicalLine } from '../source/logical-lines.js';
+import type { ParseLineResult } from './parse-line.js';
+export declare function parseDataDirective(line: LogicalLine, directiveText: string, valueText: string, span: {
+    readonly sourceName: string;
+    readonly line: number;
+    readonly column: number;
+}): ParseLineResult;
+export declare function parseDsDirective(line: LogicalLine, valueText: string, span: {
+    readonly sourceName: string;
+    readonly line: number;
+    readonly column: number;
+}): ParseLineResult;
+export declare function parseStringDataDirective(line: LogicalLine, directive: 'cstr' | 'istr' | 'pstr', valueText: string, span: {
+    readonly sourceName: string;
+    readonly line: number;
+    readonly column: number;
+}): ParseLineResult;