@jhlagado/azm 0.2.10 → 0.2.12

package/dist/src/source/logical-lines.d.ts

@@ -5,6 +5,7 @@ export interface LogicalLine {
     readonly text: string;
     readonly sourceUnit?: string;
     readonly sourceRelation?: SourceRelation;
+    readonly sourceUnitRelation?: SourceRelation;
 }
 export type SourceRelation = 'entry' | 'include' | 'import';
 export declare function scanLogicalLines(source: SourceFile): LogicalLine[];

package/dist/src/source/source-span.d.ts

@@ -4,4 +4,5 @@ export interface SourceSpan {
     readonly column: number;
     readonly sourceUnit?: string;
     readonly sourceRelation?: 'entry' | 'include' | 'import';
+    readonly sourceUnitRelation?: 'entry' | 'include' | 'import';
 }

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;

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;