@jhlagado/azm 0.1.1 → 0.2.0

package/dist/src/source/source-span.js

@@ -0,0 +1 @@
+export {};

package/dist/src/source/strip-line-comment.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Remove an ASM80-style end-of-line comment (`;`), respecting quoted strings.
+ */
+export declare function stripLineComment(text: string): string;

package/dist/src/source/strip-line-comment.js

@@ -0,0 +1,27 @@
+/**
+ * Remove an ASM80-style end-of-line comment (`;`), respecting quoted strings.
+ */
+export function stripLineComment(text) {
+    let quote;
+    let escaped = false;
+    for (let index = 0; index < text.length; index += 1) {
+        const char = text[index];
+        if (escaped) {
+            escaped = false;
+            continue;
+        }
+        if (char === '\\' && quote) {
+            escaped = true;
+            continue;
+        }
+        if ((char === '"' || char === "'") &&
+            !(char === "'" && quote === undefined && /[A-Za-z0-9_]/.test(text[index - 1] ?? ''))) {
+            quote = quote === char ? undefined : (quote ?? char);
+            continue;
+        }
+        if (char === ';' && !quote) {
+            return text.slice(0, index);
+        }
+    }
+    return text;
+}

package/dist/src/syntax/directive-aliases.d.ts

@@ -0,0 +1,10 @@
+export type DirectiveAliasProfile = {
+    readonly extends?: 'azm';
+    readonly directiveAliases?: Readonly<Record<string, string>>;
+};
+export type DirectiveAliasPolicy = {
+    readonly directiveAliases: ReadonlyMap<string, string>;
+};
+export declare function buildDirectiveAliasPolicy(projectProfiles?: readonly DirectiveAliasProfile[]): DirectiveAliasPolicy;
+export declare function readDirectiveAliasProfile(path: string): Promise<DirectiveAliasProfile>;
+export declare function normalizeDirectiveAlias(text: string, policy?: DirectiveAliasPolicy): string;

package/dist/src/syntax/directive-aliases.js

@@ -0,0 +1,199 @@
+import { readFile } from 'node:fs/promises';
+const RESERVED_INSTRUCTION_HEADS = new Set([
+    'adc',
+    'add',
+    'and',
+    'bit',
+    'call',
+    'ccf',
+    'cp',
+    'cpd',
+    'cpdr',
+    'cpi',
+    'cpir',
+    'cpl',
+    'daa',
+    'dec',
+    'di',
+    'djnz',
+    'ei',
+    'ex',
+    'exx',
+    'halt',
+    'im',
+    'in',
+    'inc',
+    'ind',
+    'indr',
+    'ini',
+    'inir',
+    'jp',
+    'jr',
+    'ld',
+    'ldd',
+    'lddr',
+    'ldi',
+    'ldir',
+    'neg',
+    'nop',
+    'or',
+    'otdr',
+    'otir',
+    'out',
+    'outd',
+    'outi',
+    'pop',
+    'push',
+    'res',
+    'ret',
+    'reti',
+    'retn',
+    'rl',
+    'rla',
+    'rlc',
+    'rlca',
+    'rld',
+    'rr',
+    'rra',
+    'rrc',
+    'rrca',
+    'rrd',
+    'rst',
+    'sbc',
+    'scf',
+    'set',
+    'sla',
+    'sll',
+    'sra',
+    'srl',
+    'sub',
+    'xor',
+]);
+const RESERVED_LANGUAGE_HEADS = new Set(['enum', 'op', 'type', 'union', 'field', 'byte', 'word', 'addr']);
+const CANONICAL_DIRECTIVES = new Set([
+    '.align',
+    '.binfrom',
+    '.binto',
+    '.cstr',
+    '.db',
+    '.ds',
+    '.dw',
+    '.end',
+    '.equ',
+    '.include',
+    '.istr',
+    '.org',
+    '.pstr',
+]);
+const BUILT_IN_DIRECTIVE_ALIASES = new Map([
+    ['ALIGN', '.align'],
+    ['BINFROM', '.binfrom'],
+    ['BINTO', '.binto'],
+    ['CSTR', '.cstr'],
+    ['DB', '.db'],
+    ['DS', '.ds'],
+    ['DW', '.dw'],
+    ['END', '.end'],
+    ['EQU', '.equ'],
+    ['INCLUDE', '.include'],
+    ['ISTR', '.istr'],
+    ['ORG', '.org'],
+    ['PSTR', '.pstr'],
+]);
+const DEFAULT_DIRECTIVE_ALIAS_POLICY = {
+    directiveAliases: BUILT_IN_DIRECTIVE_ALIASES,
+};
+export function buildDirectiveAliasPolicy(projectProfiles = []) {
+    const directiveAliases = new Map(BUILT_IN_DIRECTIVE_ALIASES);
+    const baselineKeys = new Set(directiveAliases.keys());
+    for (const profile of projectProfiles) {
+        if (profile.extends !== undefined && profile.extends !== 'azm') {
+            throw new Error(`Unsupported directive alias base "${String(profile.extends)}"`);
+        }
+        if (profile.extends === undefined) {
+            throw new Error(`Project directive alias files must extend "azm"`);
+        }
+        for (const [rawKey, rawTarget] of Object.entries(profile.directiveAliases ?? {})) {
+            const key = normalizeAliasKey(rawKey);
+            if (!key)
+                throw new Error(`Invalid directive alias head "${rawKey}"`);
+            if (baselineKeys.has(key)) {
+                throw new Error(`Directive alias "${rawKey}" conflicts with the AZM baseline`);
+            }
+            const lowerKey = key.toLowerCase();
+            if (RESERVED_INSTRUCTION_HEADS.has(lowerKey)) {
+                throw new Error(`Directive alias "${rawKey}" conflicts with a Z80 instruction`);
+            }
+            if (RESERVED_LANGUAGE_HEADS.has(lowerKey)) {
+                throw new Error(`Directive alias "${rawKey}" conflicts with an AZM language keyword`);
+            }
+            const target = normalizeAliasTarget(rawTarget);
+            if (!target)
+                throw new Error(`Invalid directive alias target "${rawTarget}" for "${rawKey}"`);
+            directiveAliases.set(key, target);
+        }
+    }
+    return { directiveAliases };
+}
+export async function readDirectiveAliasProfile(path) {
+    const text = await readFile(path, 'utf8');
+    const parsed = JSON.parse(text);
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        throw new Error(`Directive alias file "${path}" must contain a JSON object`);
+    }
+    const profile = parsed;
+    if (profile.extends !== undefined && profile.extends !== 'azm') {
+        throw new Error(`Unsupported directive alias base "${String(profile.extends)}" in "${path}"`);
+    }
+    if (profile.directiveAliases !== undefined &&
+        (!profile.directiveAliases ||
+            typeof profile.directiveAliases !== 'object' ||
+            Array.isArray(profile.directiveAliases))) {
+        throw new Error(`Directive alias file "${path}" has invalid "directiveAliases"`);
+    }
+    return profile;
+}
+export function normalizeDirectiveAlias(text, policy = DEFAULT_DIRECTIVE_ALIAS_POLICY) {
+    const trimmed = text.trimStart();
+    const leading = text.slice(0, text.length - trimmed.length);
+    const label = /^([A-Za-z_.$?][A-Za-z0-9_.$?]*:)\s+(.+)$/.exec(trimmed);
+    if (label) {
+        return `${leading}${label[1]} ${normalizeHead(label[2] ?? '', policy)}`;
+    }
+    const equ = /^([A-Za-z_.$?][A-Za-z0-9_.$?]*)\s+([A-Za-z]+)\b(.*)$/.exec(trimmed);
+    if (equ && resolveDirectiveAlias(equ[2] ?? '', policy) === '.equ') {
+        return `${leading}${equ[1]} .equ${equ[3] ?? ''}`;
+    }
+    return `${leading}${normalizeHead(trimmed, policy)}`;
+}
+function normalizeHead(text, policy) {
+    const head = /^([A-Za-z]+)\b(.*)$/.exec(text);
+    if (!head) {
+        return text;
+    }
+    const canonical = resolveDirectiveAlias(head[1] ?? '', policy);
+    if (!canonical) {
+        return text;
+    }
+    return `${canonical}${head[2] ?? ''}`;
+}
+function normalizeAliasKey(key) {
+    const trimmed = key.trim();
+    if (!/^[.]?[A-Za-z][A-Za-z0-9_]*$/.test(trimmed))
+        return undefined;
+    return trimmed.replace(/^\./, '').toUpperCase();
+}
+function normalizeAliasTarget(value) {
+    const trimmed = value.trim().toLowerCase();
+    const dotted = trimmed.startsWith('.') ? trimmed : `.${trimmed}`;
+    return CANONICAL_DIRECTIVES.has(dotted) ? dotted : undefined;
+}
+function resolveDirectiveAlias(head, policy) {
+    const key = normalizeAliasKey(head);
+    if (!key)
+        return undefined;
+    const dotted = `.${key.toLowerCase()}`;
+    if (head.trim().startsWith('.') && CANONICAL_DIRECTIVES.has(dotted))
+        return dotted;
+    return policy.directiveAliases.get(key);
+}

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

@@ -0,0 +1,3 @@
+import type { Expression, TypeExpr } from '../model/expression.js';
+export declare function parseExpression(text: string): Expression | undefined;
+export declare function parseTypeExpr(text: string): TypeExpr | undefined;