@jhlagado/azm 0.2.10 → 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
 
@@ -185,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:

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/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;

package/dist/src/syntax/parse-data-directives.js

@@ -0,0 +1,147 @@
+import { parseWholeQuotedString } from './parse-declaration-directives.js';
+import { parseLineError } from './parse-diagnostics.js';
+import { parseExpression, parseTypeExpr } from './parse-expression.js';
+export function parseDataDirective(line, directiveText, valueText, span) {
+    const directive = directiveText.slice(1).toLowerCase();
+    const parts = splitValueList(valueText);
+    const values = directive === 'db'
+        ? parts.map(parseDataValue).filter((value) => value !== undefined)
+        : parts.map(parseExpression).filter((value) => value !== undefined);
+    if (values.length !== parts.length) {
+        return {
+            items: [],
+            diagnostics: [parseLineError(line, `invalid .${directive} value list`)],
+        };
+    }
+    return {
+        items: directive === 'db'
+            ? [{ kind: 'db', values: values, span }]
+            : [{ kind: 'dw', values: values, span }],
+        diagnostics: [],
+    };
+}
+export function parseDsDirective(line, valueText, span) {
+    const parts = splitValueList(valueText);
+    const listDiagnostic = validateDsValueList(line, parts);
+    if (listDiagnostic) {
+        return { items: [], diagnostics: [listDiagnostic] };
+    }
+    const sizeResult = parseDsSize(line, parts[0] ?? '');
+    if (sizeResult.diagnostic) {
+        return { items: [], diagnostics: [sizeResult.diagnostic] };
+    }
+    const fillResult = parseDsFill(line, parts[1]);
+    if (fillResult.diagnostic) {
+        return { items: [], diagnostics: [fillResult.diagnostic] };
+    }
+    return {
+        items: [
+            fillResult.fill === undefined
+                ? { kind: 'ds', size: sizeResult.size, span }
+                : { kind: 'ds', size: sizeResult.size, fill: fillResult.fill, span },
+        ],
+        diagnostics: [],
+    };
+}
+export function parseStringDataDirective(line, directive, valueText, span) {
+    const value = parseQuotedString(valueText);
+    if (value === undefined) {
+        return {
+            items: [],
+            diagnostics: [parseLineError(line, `.${directive} expects one double-quoted string`)],
+        };
+    }
+    return { items: [{ kind: 'string-data', directive, value, span }], diagnostics: [] };
+}
+function validateDsValueList(line, parts) {
+    return parts.length < 1 || parts.length > 2
+        ? parseLineError(line, `invalid .ds value list`)
+        : undefined;
+}
+function parseDsSize(line, sizeText) {
+    const size = parseTypeSizeExpression(sizeText) ?? parseExpression(sizeText);
+    if (!size) {
+        return {
+            diagnostic: parseLineError(line, `invalid .ds size: ${sizeText}`),
+        };
+    }
+    return { size };
+}
+function parseDsFill(line, fillText) {
+    if (fillText === undefined)
+        return { fill: undefined };
+    const fill = parseExpression(fillText);
+    if (!fill) {
+        return {
+            diagnostic: parseLineError(line, `invalid .ds fill: ${fillText}`),
+        };
+    }
+    return { fill };
+}
+function parseTypeSizeExpression(text) {
+    const typeExpr = parseTypeExpr(text);
+    return typeExpr ? { kind: 'type-size', typeExpr } : undefined;
+}
+function splitValueList(text) {
+    const values = [];
+    let state = { quote: undefined, escaped: false, parenDepth: 0 };
+    let start = 0;
+    for (let index = 0; index < text.length; index += 1) {
+        if (isValueSeparator(text[index] ?? '', state)) {
+            values.push(text.slice(start, index));
+            start = index + 1;
+            continue;
+        }
+        state = scanValueListChar(text[index] ?? '', state);
+    }
+    values.push(text.slice(start));
+    return values;
+}
+function isValueSeparator(char, state) {
+    return char === ',' && state.quote === undefined && state.parenDepth === 0;
+}
+function scanValueListChar(char, state) {
+    const escapedState = scanEscapedValueListChar(char, state);
+    if (escapedState)
+        return escapedState;
+    const quotedState = scanQuotedValueListChar(char, state);
+    if (quotedState)
+        return quotedState;
+    return scanParenthesizedValueListChar(char, state);
+}
+function scanEscapedValueListChar(char, state) {
+    if (state.escaped)
+        return { ...state, escaped: false };
+    if (char === '\\' && state.quote !== undefined)
+        return { ...state, escaped: true };
+    return undefined;
+}
+function scanQuotedValueListChar(char, state) {
+    if (char !== '"' && char !== "'")
+        return undefined;
+    return { ...state, quote: state.quote === char ? undefined : (state.quote ?? char) };
+}
+function scanParenthesizedValueListChar(char, state) {
+    if (state.quote !== undefined)
+        return state;
+    if (char === '(')
+        return { ...state, parenDepth: state.parenDepth + 1 };
+    if (char === ')')
+        return { ...state, parenDepth: Math.max(0, state.parenDepth - 1) };
+    return state;
+}
+function parseQuotedString(text) {
+    const input = text.trim();
+    if (input[0] !== '"' || input[input.length - 1] !== '"') {
+        return undefined;
+    }
+    return parseWholeQuotedString(input);
+}
+function parseDataValue(text) {
+    const expression = parseExpression(text);
+    if (expression) {
+        return expression;
+    }
+    const value = parseWholeQuotedString(text);
+    return value === undefined ? undefined : { kind: 'string-fragment', value };
+}

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

@@ -0,0 +1,18 @@
+import type { LogicalLine } from '../source/logical-lines.js';
+import type { ParseLineResult } from './parse-line.js';
+export declare function parseColonDeclaration(line: LogicalLine, name: string, statementText: string, span: {
+    readonly sourceName: string;
+    readonly line: number;
+    readonly column: number;
+}): ParseLineResult | undefined;
+export declare function parseEquItem(line: LogicalLine, name: string, expressionText: string, span: {
+    readonly sourceName: string;
+    readonly line: number;
+    readonly column: number;
+}): ParseLineResult;
+export declare function parseEnumItem(line: LogicalLine, name: string, membersText: string, span: {
+    readonly sourceName: string;
+    readonly line: number;
+    readonly column: number;
+}): ParseLineResult;
+export declare function parseWholeQuotedString(text: string): string | undefined;