@jhlagado/azm 0.2.9 → 0.2.11

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;

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

@@ -0,0 +1,90 @@
+import { isIdentifier } from './names.js';
+import { parseLineError } from './parse-diagnostics.js';
+import { parseExpression } from './parse-expression.js';
+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;
+}
+export 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: [parseLineError(line, `invalid .equ expression: ${expressionText}`)],
+        };
+    }
+    return {
+        items: [
+            {
+                kind: 'equ',
+                name,
+                expression,
+                ...(stringValue !== undefined && stringValue.length > 1 ? { stringValue } : {}),
+                span,
+            },
+        ],
+        diagnostics: [],
+    };
+}
+export 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: [parseLineError(line, `invalid enum member list`)],
+        };
+    }
+    const members = [];
+    const diagnostics = [];
+    for (const member of rawMembers) {
+        if (!isIdentifier(member)) {
+            diagnostics.push(parseLineError(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: [] };
+}
+export 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;
+}

package/dist/src/syntax/parse-diagnostics.d.ts

@@ -3,10 +3,18 @@ type ParseDiagLocation = {
     line: number;
     column: number;
 };
+type ParseDiagLine = {
+    readonly sourceName: string;
+    readonly line: number;
+    readonly text: string;
+};
 /** Push a parse diagnostic with Next default code/severity (`AZMN_PARSE` / error). */
 export declare function parseDiag(diagnostics: Diagnostic[], sourceName: string, message: string, where?: ParseDiagLocation): void;
 /** Push a parse diagnostic at an explicit 1-based line/column. */
 export declare function parseDiagAt(diagnostics: Diagnostic[], sourceName: string, message: string, line: number, column: number): void;
 /** Push a diagnostic with explicit code, severity, and optional location. */
 export declare function parseDiagAtWithId(diagnostics: Diagnostic[], sourceName: string, code: DiagnosticId | string, severity: DiagnosticSeverity, message: string, where?: ParseDiagLocation): void;
+/** Return a parse diagnostic at the first non-whitespace column of a source line. */
+export declare function parseLineError(line: ParseDiagLine, message: string): Diagnostic;
+export declare function firstNonWhitespaceColumn(text: string): number;
 export {};

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

@@ -16,3 +16,18 @@ export function parseDiagAtWithId(diagnostics, sourceName, code, severity, messa
         ...(where ? { line: where.line, column: where.column } : {}),
     });
 }
+/** Return a parse diagnostic at the first non-whitespace column of a source line. */
+export function parseLineError(line, message) {
+    return {
+        code: 'AZMN_PARSE',
+        severity: 'error',
+        message,
+        sourceName: line.sourceName,
+        line: line.line,
+        column: firstNonWhitespaceColumn(line.text),
+    };
+}
+export function firstNonWhitespaceColumn(text) {
+    const match = /\S/.exec(text);
+    return match ? match.index + 1 : 1;
+}

package/dist/src/syntax/parse-directive-statement.d.ts

@@ -1,9 +1,5 @@
 import type { LogicalLine } from '../source/logical-lines.js';
 import type { SourceSpan } from '../source/source-span.js';
 import type { ParseLineResult } from './parse-line.js';
+export { parseColonDeclaration } from './parse-declaration-directives.js';
 export declare function parseDirectiveStatement(line: LogicalLine, text: string, span: SourceSpan): ParseLineResult | undefined;
-export declare function parseColonDeclaration(line: LogicalLine, name: string, statementText: string, span: {
-    readonly sourceName: string;
-    readonly line: number;
-    readonly column: number;
-}): ParseLineResult | undefined;

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 {};