@jhlagado/azm 0.2.10 → 0.2.12

package/dist/src/syntax/parse-directive-statement.js

@@ -1,7 +1,11 @@
-import { parseExpression, parseTypeExpr } from './parse-expression.js';
+import { IDENTIFIER_PATTERN, LABEL_NAME_PATTERN } from './names.js';
+import { parseEnumItem, parseEquItem } from './parse-declaration-directives.js';
+import { firstNonWhitespaceColumn } from './parse-diagnostics.js';
+import { parseDataDirective, parseDsDirective, parseStringDataDirective, } from './parse-data-directives.js';
+import { parseExpressionDirective } from './parse-location-directives.js';
 const DIRECTIVE_PARSERS = [
     {
-        pattern: /^([A-Za-z_.$?][A-Za-z0-9_.$?]*)\s+\.equ\s+(.+)$/,
+        pattern: new RegExp(`^(${LABEL_NAME_PATTERN})\\s+\\.equ\\s+(.+)$`),
         parse: (line, match, span) => parseEquItem(line, match[1] ?? '', match[2] ?? '', span),
     },
     {
@@ -9,14 +13,23 @@ const DIRECTIVE_PARSERS = [
         parse: (line, match, span) => parseExpressionDirective(line, 'org', match[1] ?? '', span),
     },
     {
-        pattern: /^enum\s+([A-Za-z_][A-Za-z0-9_]*)\s+(.+)$/,
+        pattern: new RegExp(`^enum\\s+(${IDENTIFIER_PATTERN})\\s+(.+)$`),
         parse: (line, match) => ({
             items: [],
-            diagnostics: [parseError(line, `Use "${match[1] ?? ''} .enum ..." for enums.`)],
+            diagnostics: [
+                {
+                    severity: 'error',
+                    code: 'AZMN_PARSE',
+                    message: `Use "${match[1] ?? ''} .enum ..." for enums.`,
+                    sourceName: line.sourceName,
+                    line: line.line,
+                    column: firstNonWhitespaceColumn(line.text),
+                },
+            ],
         }),
     },
     {
-        pattern: /^([A-Za-z_][A-Za-z0-9_]*)\s+\.enum\s+(.+)$/,
+        pattern: new RegExp(`^(${IDENTIFIER_PATTERN})\\s+\\.enum\\s+(.+)$`),
         parse: (line, match, span) => parseEnumItem(line, match[1] ?? '', match[2] ?? '', span),
     },
     {
@@ -44,6 +57,7 @@ const DIRECTIVE_PARSERS = [
         parse: (line, match, span) => parseStringDataDirective(line, (match[1] ?? '').slice(1).toLowerCase(), match[2] ?? '', span),
     },
 ];
+export { parseColonDeclaration } from './parse-declaration-directives.js';
 export function parseDirectiveStatement(line, text, span) {
     for (const parser of DIRECTIVE_PARSERS) {
         const match = parser.pattern.exec(text);
@@ -53,257 +67,3 @@ export function parseDirectiveStatement(line, text, span) {
     }
     return undefined;
 }
-export function parseColonDeclaration(line, name, statementText, span) {
-    const equ = /^\.equ\s+(.+)$/.exec(statementText);
-    if (equ) {
-        return parseEquItem(line, name, equ[1] ?? '', span);
-    }
-    const enumDecl = /^\.enum\s+(.+)$/.exec(statementText);
-    if (enumDecl) {
-        return parseEnumItem(line, name, enumDecl[1] ?? '', span);
-    }
-    return undefined;
-}
-function parseEquItem(line, name, expressionText, span) {
-    const stringValue = parseWholeQuotedString(expressionText.trim());
-    const expression = stringValue !== undefined && stringValue.length > 1
-        ? { kind: 'number', value: 0 }
-        : parseExpression(expressionText);
-    if (!expression) {
-        return {
-            items: [],
-            diagnostics: [parseError(line, `invalid .equ expression: ${expressionText}`)],
-        };
-    }
-    return {
-        items: [
-            {
-                kind: 'equ',
-                name,
-                expression,
-                ...(stringValue !== undefined && stringValue.length > 1 ? { stringValue } : {}),
-                span,
-            },
-        ],
-        diagnostics: [],
-    };
-}
-function parseExpressionDirective(line, kind, expressionText, span) {
-    const expression = parseExpression(expressionText);
-    if (!expression) {
-        return {
-            items: [],
-            diagnostics: [parseError(line, `invalid .${kind} expression: ${expressionText}`)],
-        };
-    }
-    if (kind === 'align') {
-        return { items: [{ kind, alignment: expression, span }], diagnostics: [] };
-    }
-    return { items: [{ kind, expression, span }], diagnostics: [] };
-}
-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: [parseError(line, `invalid .${directive} value list`)],
-        };
-    }
-    return {
-        items: directive === 'db'
-            ? [{ kind: 'db', values: values, span }]
-            : [{ kind: 'dw', values: values, span }],
-        diagnostics: [],
-    };
-}
-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: [],
-    };
-}
-function validateDsValueList(line, parts) {
-    return parts.length < 1 || parts.length > 2
-        ? parseError(line, `invalid .ds value list`)
-        : undefined;
-}
-function parseDsSize(line, sizeText) {
-    const size = parseTypeSizeExpression(sizeText) ?? parseExpression(sizeText);
-    if (!size) {
-        return {
-            diagnostic: parseError(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: parseError(line, `invalid .ds fill: ${fillText}`),
-        };
-    }
-    return { fill };
-}
-function parseStringDataDirective(line, directive, valueText, span) {
-    const value = parseQuotedString(valueText);
-    if (value === undefined) {
-        return {
-            items: [],
-            diagnostics: [parseError(line, `.${directive} expects one double-quoted string`)],
-        };
-    }
-    return { items: [{ kind: 'string-data', directive, value, span }], diagnostics: [] };
-}
-function parseEnumItem(line, name, membersText, span) {
-    const rawMembers = membersText.split(',').map((member) => member.trim());
-    if (membersText.trim().length === 0 || rawMembers.some((member) => member.length === 0)) {
-        return {
-            items: [],
-            diagnostics: [parseError(line, `invalid enum member list`)],
-        };
-    }
-    const members = [];
-    const diagnostics = [];
-    for (const member of rawMembers) {
-        if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(member)) {
-            diagnostics.push(parseError(line, `Invalid enum member name "${member}": expected <identifier>.`));
-            continue;
-        }
-        members.push(member);
-    }
-    if (diagnostics.length > 0) {
-        return { items: [], diagnostics };
-    }
-    return { items: [{ kind: 'enum', name, members, span }], diagnostics: [] };
-}
-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) {
-    return parseQuotedStringWithQuotes(text, new Set(['"']));
-}
-function parseWholeQuotedString(text) {
-    return parseQuotedStringWithQuotes(text, new Set(['"', "'"]));
-}
-function parseQuotedStringWithQuotes(text, allowedQuotes) {
-    const input = text.trim();
-    const quote = input[0];
-    if (!quote || !allowedQuotes.has(quote) || input[input.length - 1] !== quote) {
-        return undefined;
-    }
-    return parseQuotedStringContent(input, quote);
-}
-function parseQuotedStringContent(input, quote) {
-    let value = '';
-    for (let index = 1; index < input.length - 1; index += 1) {
-        const char = input[index] ?? '';
-        if (char === '\\') {
-            if (index + 1 >= input.length - 1) {
-                return undefined;
-            }
-            value += input[index + 1] ?? '';
-            index += 1;
-            continue;
-        }
-        if (char === quote) {
-            return undefined;
-        }
-        value += char;
-    }
-    return value;
-}
-function parseDataValue(text) {
-    const expression = parseExpression(text);
-    if (expression) {
-        return expression;
-    }
-    const value = parseWholeQuotedString(text);
-    return value === undefined ? undefined : { kind: 'string-fragment', value };
-}
-function firstColumn(text) {
-    const match = /\S/.exec(text);
-    return match ? match.index + 1 : 1;
-}
-function parseError(line, message) {
-    return {
-        severity: 'error',
-        code: 'AZMN_PARSE',
-        message,
-        sourceName: line.sourceName,
-        line: line.line,
-        column: firstColumn(line.text),
-    };
-}

package/dist/src/syntax/parse-instruction-chain.d.ts

@@ -0,0 +1,22 @@
+import type { Diagnostic } from '../model/diagnostic.js';
+import type { ParsedLeadingLabel } from './names.js';
+interface InstructionChainLine {
+    readonly text: string;
+}
+export interface ParseChainStatementResult<TItem> {
+    readonly items: readonly TItem[];
+    readonly diagnostics: readonly Diagnostic[];
+}
+export interface ParseInstructionChainOptions<TLine extends InstructionChainLine, TItem> {
+    readonly line: TLine;
+    readonly parseStatement: (line: TLine, statementText: string, statementColumn: number) => ParseChainStatementResult<TItem>;
+    readonly makeLabelItem: (label: ParsedLeadingLabel, line: TLine) => TItem;
+    readonly makeDiagnostic: (line: TLine, column: number, message: string) => Diagnostic;
+    readonly appendLineComment?: (items: TItem[], line: TLine) => void;
+}
+export interface ParseInstructionChainResult<TItem> {
+    readonly items: readonly TItem[];
+    readonly diagnostics: readonly Diagnostic[];
+}
+export declare function parseInstructionChain<TLine extends InstructionChainLine, TItem>(options: ParseInstructionChainOptions<TLine, TItem>): ParseInstructionChainResult<TItem> | undefined;
+export {};

package/dist/src/syntax/parse-instruction-chain.js

@@ -0,0 +1,62 @@
+import { splitInstructionChain } from '../source/instruction-chain.js';
+import { hasLeadingLabel, parseLeadingLabel } from './names.js';
+import { isChainedDirectiveOrDeclaration } from './statement-classification.js';
+export function parseInstructionChain(options) {
+    const segments = splitInstructionChain(options.line.text);
+    if (segments === undefined)
+        return undefined;
+    const items = [];
+    const diagnostics = [];
+    for (let index = 0; index < segments.length; index += 1) {
+        const segment = segments[index];
+        const parsed = parseInstructionChainSegment(options, segment.text, segment.column, index);
+        diagnostics.push(...parsed.diagnostics);
+        items.push(...parsed.items);
+    }
+    options.appendLineComment?.(items, options.line);
+    return { items, diagnostics };
+}
+function parseInstructionChainSegment(options, text, column, segmentIndex) {
+    if (text.length === 0) {
+        return {
+            items: [],
+            diagnostics: [
+                options.makeDiagnostic(options.line, column, 'empty instruction segment in chained line'),
+            ],
+        };
+    }
+    if (segmentIndex > 0 && hasLeadingLabel(text)) {
+        return {
+            items: [],
+            diagnostics: [
+                options.makeDiagnostic(options.line, column, 'labels are only allowed before the first chained instruction'),
+            ],
+        };
+    }
+    const labeled = segmentIndex === 0 ? parseLeadingLabel(text, column) : undefined;
+    const statementText = labeled?.statementText ?? text;
+    const statementColumn = labeled?.statementColumn ?? column;
+    if (statementText.length === 0) {
+        return {
+            items: [],
+            diagnostics: [
+                options.makeDiagnostic(options.line, statementColumn, 'empty instruction segment in chained line'),
+            ],
+        };
+    }
+    if (isChainedDirectiveOrDeclaration(statementText)) {
+        return {
+            items: [],
+            diagnostics: [
+                options.makeDiagnostic(options.line, statementColumn, 'directives must be on their own line; chained lines only support instructions and ops'),
+            ],
+        };
+    }
+    const items = [];
+    if (labeled) {
+        items.push(options.makeLabelItem(labeled, options.line));
+    }
+    const statement = options.parseStatement(options.line, statementText, statementColumn);
+    items.push(...statement.items);
+    return { items, diagnostics: statement.diagnostics };
+}

package/dist/src/syntax/parse-layout-declarations.js

@@ -1,4 +1,6 @@
 import { stripLineComment } from '../source/strip-line-comment.js';
+import { IDENTIFIER_PATTERN } from './names.js';
+import { firstNonWhitespaceColumn, parseLineError } from './parse-diagnostics.js';
 import { parseTypeExpr } from './parse-expression.js';
 export function parseLayoutDeclarationAt(lines, index) {
     const line = lines[index];
@@ -9,7 +11,7 @@ export function parseLayoutDeclarationAt(lines, index) {
     if (typeAlias !== undefined) {
         return { consumedUntilIndex: index, ...typeAlias };
     }
-    const prefixLayoutHeader = /^\.(type|union)\s+([A-Za-z_][A-Za-z0-9_]*)\s*$/.exec(text);
+    const prefixLayoutHeader = new RegExp(`^\\.(type|union)\\s+(${IDENTIFIER_PATTERN})\\s*$`).exec(text);
     if (prefixLayoutHeader) {
         const directive = prefixLayoutHeader[1] ?? 'type';
         return {
@@ -26,7 +28,7 @@ export function parseLayoutDeclarationAt(lines, index) {
     return parseLayoutBlock(lines, index, layoutHeader);
 }
 function parseTypeAlias(line, text) {
-    const nameLeftTypeAlias = /^([A-Za-z_][A-Za-z0-9_]*)(?::\s*|\s+)\.typealias\s+(.+)$/.exec(text);
+    const nameLeftTypeAlias = new RegExp(`^(${IDENTIFIER_PATTERN})(?::\\s*|\\s+)\\.typealias\\s+(.+)$`).exec(text);
     if (nameLeftTypeAlias) {
         const typeExprText = nameLeftTypeAlias[2] ?? '';
         const typeExpr = parseTypeExpr(typeExprText);
@@ -43,7 +45,7 @@ function parseTypeAlias(line, text) {
             diagnostics: [],
         };
     }
-    const oldTypeAlias = /^\.type\s+([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.+)$/.exec(text);
+    const oldTypeAlias = new RegExp(`^\\.type\\s+(${IDENTIFIER_PATTERN})\\s*=\\s*(.+)$`).exec(text);
     if (oldTypeAlias) {
         return {
             diagnostics: [
@@ -54,7 +56,7 @@ function parseTypeAlias(line, text) {
     return undefined;
 }
 function parseNameLeftLayoutHeader(text) {
-    const match = /^([A-Za-z_][A-Za-z0-9_]*)(?::\s*|\s+)\.(type|union)\s*$/.exec(text);
+    const match = new RegExp(`^(${IDENTIFIER_PATTERN})(?::\\s*|\\s+)\\.(type|union)\\s*$`).exec(text);
     return match
         ? {
             directive: match[2] ?? '',
@@ -107,9 +109,10 @@ function spanForLine(line) {
     return {
         sourceName: line.sourceName,
         line: line.line,
-        column: firstColumn(line.text),
+        column: firstNonWhitespaceColumn(line.text),
         ...(line.sourceUnit !== undefined ? { sourceUnit: line.sourceUnit } : {}),
         ...(line.sourceRelation !== undefined ? { sourceRelation: line.sourceRelation } : {}),
+        ...(line.sourceUnitRelation !== undefined ? { sourceUnitRelation: line.sourceUnitRelation } : {}),
     };
 }
 function skipToLayoutEnd(lines, index, directive) {
@@ -122,7 +125,7 @@ function skipToLayoutEnd(lines, index, directive) {
     return index;
 }
 function parseLayoutField(text) {
-    const match = /^([A-Za-z_][A-Za-z0-9_]*)\s+(\.(?:field|byte|word|addr))(?:\s+(.+))?$/.exec(text);
+    const match = new RegExp(`^(${IDENTIFIER_PATTERN})\\s+(\\.(?:field|byte|word|addr))(?:\\s+(.+))?$`).exec(text);
     if (!match) {
         return undefined;
     }
@@ -174,16 +177,5 @@ function scalarFieldSize(typeName) {
     }
 }
 function parseDiagnostic(line, message) {
-    return {
-        severity: 'error',
-        code: 'AZMN_PARSE',
-        message,
-        sourceName: line.sourceName,
-        line: line.line,
-        column: firstColumn(line.text),
-    };
-}
-function firstColumn(text) {
-    const match = /\S/.exec(text);
-    return match ? match.index + 1 : 1;
+    return parseLineError(line, message);
 }

package/dist/src/syntax/parse-layout-expression.js

@@ -1,6 +1,7 @@
+import { IDENTIFIER_PATTERN } from './names.js';
 export function parseTypeExpr(text) {
     const trimmed = text.trim();
-    const match = /^([A-Za-z_][A-Za-z0-9_]*)(?:\[\s*([0-9]+)\s*\])?$/.exec(trimmed);
+    const match = new RegExp(`^(${IDENTIFIER_PATTERN})(?:\\[\\s*([0-9]+)\\s*\\])?$`).exec(trimmed);
     if (!match) {
         return undefined;
     }
@@ -118,7 +119,7 @@ function parseLayoutCastPathPart(text, parseNestedExpression) {
         : parseLayoutCastIndex(text, parseNestedExpression);
 }
 function parseLayoutCastField(text) {
-    const field = /^\.([A-Za-z_][A-Za-z0-9_]*)/.exec(text);
+    const field = new RegExp(`^\\.(${IDENTIFIER_PATTERN})`).exec(text);
     return field ? { part: { kind: 'field', name: field[1] ?? '' }, rest: text.slice(field[0].length) } : undefined;
 }
 function parseLayoutCastIndex(text, parseNestedExpression) {
@@ -168,7 +169,7 @@ function parseOffsetIndex(text) {
         : undefined;
 }
 function parseOffsetField(text) {
-    const field = /^[A-Za-z_][A-Za-z0-9_]*/.exec(text);
+    const field = new RegExp(`^${IDENTIFIER_PATTERN}`).exec(text);
     return field
         ? { part: { kind: 'field', name: field[0] }, rest: text.slice(field[0].length) }
         : undefined;

package/dist/src/syntax/parse-line.js

@@ -1,5 +1,7 @@
 import { extractLineComment, stripLineComment } from '../source/strip-line-comment.js';
 import { normalizeDirectiveAlias } from './directive-aliases.js';
+import { LABEL_NAME_PATTERN, parseEntryLabel } from './names.js';
+import { firstNonWhitespaceColumn, parseLineError } from './parse-diagnostics.js';
 import { parseColonDeclaration, parseDirectiveStatement } from './parse-directive-statement.js';
 import { parseZ80Instruction } from '../z80/parse-instruction.js';
 export function parseLogicalLine(line, options = {}) {
@@ -8,34 +10,38 @@ export function parseLogicalLine(line, options = {}) {
         return commentOnlyLine(line);
     }
     const span = spanForLine(line);
-    const labelWithStatement = /^(@?[A-Za-z_.$?][A-Za-z0-9_.$?]*):\s*(.+)$/.exec(text);
+    const labelWithStatement = new RegExp(`^(@?${LABEL_NAME_PATTERN}):\\s*(.+)$`).exec(text);
     if (labelWithStatement) {
         const rawLabel = labelWithStatement[1] ?? '';
-        const labelName = normalizeEntryLabelName(rawLabel);
-        const isEntry = rawLabel.startsWith('@');
+        const label = parseEntryLabel(rawLabel);
+        if (!label)
+            return withLineComment(line, parseCanonicalStatement(line, text, span));
         const statementText = labelWithStatement[2] ?? '';
-        const declaration = parseColonDeclaration(line, labelName, statementText, span);
+        const declaration = parseColonDeclaration(line, label.name, statementText, span);
         if (declaration) {
             return withLineComment(line, declaration);
         }
         const parsedStatement = parseCanonicalStatement(line, statementText, span);
         return withLineComment(line, {
             items: [
-                { kind: 'label', name: labelName, ...(isEntry ? { isEntry: true } : {}), span },
+                { kind: 'label', name: label.name, ...(label.isEntry ? { isEntry: true } : {}), span },
                 ...parsedStatement.items,
             ],
             diagnostics: parsedStatement.diagnostics,
         });
     }
-    const labelOnly = /^(@?[A-Za-z_.$?][A-Za-z0-9_.$?]*):$/.exec(text);
+    const labelOnly = new RegExp(`^(@?${LABEL_NAME_PATTERN}):$`).exec(text);
     if (labelOnly) {
         const rawLabel = labelOnly[1] ?? '';
+        const label = parseEntryLabel(rawLabel);
+        if (!label)
+            return withLineComment(line, parseCanonicalStatement(line, text, span));
         return withLineComment(line, {
             items: [
                 {
                     kind: 'label',
-                    name: normalizeEntryLabelName(rawLabel),
-                    ...(rawLabel.startsWith('@') ? { isEntry: true } : {}),
+                    name: label.name,
+                    ...(label.isEntry ? { isEntry: true } : {}),
                     span,
                 },
             ],
@@ -58,7 +64,7 @@ function commentOnlyLine(line) {
                 span: {
                     sourceName: line.sourceName,
                     line: line.line,
-                    column: firstColumn(line.text),
+                    column: firstNonWhitespaceColumn(line.text),
                     ...(line.sourceUnit !== undefined ? { sourceUnit: line.sourceUnit } : {}),
                     ...(line.sourceRelation !== undefined ? { sourceRelation: line.sourceRelation } : {}),
                 },
@@ -82,7 +88,7 @@ function withLineComment(line, result) {
                 span: {
                     sourceName: line.sourceName,
                     line: line.line,
-                    column: firstColumn(line.text),
+                    column: firstNonWhitespaceColumn(line.text),
                     ...(line.sourceUnit !== undefined ? { sourceUnit: line.sourceUnit } : {}),
                     ...(line.sourceRelation !== undefined ? { sourceRelation: line.sourceRelation } : {}),
                 },
@@ -106,37 +112,21 @@ function parseCanonicalStatement(line, text, span) {
     if (instruction?.diagnostics && instruction.diagnostics.length > 0) {
         return {
             items: [],
-            diagnostics: instruction.diagnostics.map((message) => parseError(line, message)),
+            diagnostics: instruction.diagnostics.map((message) => parseLineError(line, message)),
         };
     }
     if (instruction?.error) {
-        return { items: [], diagnostics: [parseError(line, instruction.error)] };
+        return { items: [], diagnostics: [parseLineError(line, instruction.error)] };
     }
-    return { items: [], diagnostics: [parseError(line, `unsupported source line: ${text}`)] };
+    return { items: [], diagnostics: [parseLineError(line, `unsupported source line: ${text}`)] };
 }
 function spanForLine(line) {
     return {
         sourceName: line.sourceName,
         line: line.line,
-        column: firstColumn(line.text),
+        column: firstNonWhitespaceColumn(line.text),
         ...(line.sourceUnit !== undefined ? { sourceUnit: line.sourceUnit } : {}),
         ...(line.sourceRelation !== undefined ? { sourceRelation: line.sourceRelation } : {}),
-    };
-}
-function normalizeEntryLabelName(raw) {
-    return raw.startsWith('@') ? raw.slice(1) : raw;
-}
-function firstColumn(text) {
-    const match = /\S/.exec(text);
-    return match ? match.index + 1 : 1;
-}
-function parseError(line, message) {
-    return {
-        severity: 'error',
-        code: 'AZMN_PARSE',
-        message,
-        sourceName: line.sourceName,
-        line: line.line,
-        column: firstColumn(line.text),
+        ...(line.sourceUnitRelation !== undefined ? { sourceUnitRelation: line.sourceUnitRelation } : {}),
     };
 }

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

@@ -0,0 +1,7 @@
+import type { LogicalLine } from '../source/logical-lines.js';
+import type { ParseLineResult } from './parse-line.js';
+export declare function parseExpressionDirective(line: LogicalLine, kind: 'align' | 'binfrom' | 'binto' | 'org', expressionText: string, span: {
+    readonly sourceName: string;
+    readonly line: number;
+    readonly column: number;
+}): ParseLineResult;

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

@@ -0,0 +1,15 @@
+import { parseLineError } from './parse-diagnostics.js';
+import { parseExpression } from './parse-expression.js';
+export function parseExpressionDirective(line, kind, expressionText, span) {
+    const expression = parseExpression(expressionText);
+    if (!expression) {
+        return {
+            items: [],
+            diagnostics: [parseLineError(line, `invalid .${kind} expression: ${expressionText}`)],
+        };
+    }
+    if (kind === 'align') {
+        return { items: [{ kind, alignment: expression, span }], diagnostics: [] };
+    }
+    return { items: [{ kind, expression, span }], diagnostics: [] };
+}

package/dist/src/syntax/statement-classification.d.ts

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

package/dist/src/syntax/statement-classification.js

@@ -0,0 +1,24 @@
+import { IDENTIFIER_PATTERN, LABEL_NAME_PATTERN } from './names.js';
+const CHAIN_DECLARATION_RE = new RegExp(`^${LABEL_NAME_PATTERN}\\s+\\.?(?:equ|enum|type|union|typealias)\\b`, 'i');
+const IDENTIFIER_STATEMENT_RE = new RegExp(`^${IDENTIFIER_PATTERN}(?:\\s+.*)?$`);
+const EQU_DECLARATION_RE = new RegExp(`^${IDENTIFIER_PATTERN}\\s+\\.?equ\\b`, 'i');
+const LAYOUT_DECLARATION_RE = new RegExp(`^${IDENTIFIER_PATTERN}\\s+\\.(?:enum|type|union|typealias|field|byte|word|addr)\\b`);
+export function isChainedDirectiveOrDeclaration(text) {
+    return (/^\./.test(text) ||
+        /^(?:org|equ|db|dw|ds|align|include|import|binfrom|binto|cstr|pstr|istr|end|enum|type|union|field|byte|word|addr|endtype|endunion|typealias|if|else|endif|op)\b/i.test(text) ||
+        CHAIN_DECLARATION_RE.test(text));
+}
+export function isPotentialOpInvocationStatement(text) {
+    if (!IDENTIFIER_STATEMENT_RE.test(text))
+        return false;
+    if (EQU_DECLARATION_RE.test(text))
+        return false;
+    if (LAYOUT_DECLARATION_RE.test(text))
+        return false;
+    if (/^(?:op|end|enum|type|union|field|byte|word|addr)\b/i.test(text))
+        return false;
+    if (/^(?:org|equ|db|dw|ds|align|include|binfrom|binto|cstr|pstr|istr)\b/i.test(text)) {
+        return false;
+    }
+    return true;
+}