@jhlagado/azm 0.2.0 → 0.2.2

package/dist/legacy-root-azm/src/lowering/traceFormat.js

@@ -1,211 +0,0 @@
-const toHexByte = (n) => `$${(n & 0xff).toString(16).toUpperCase().padStart(2, '0')}`;
-const toHexWord = (n) => `$${(n & 0xffff).toString(16).toUpperCase().padStart(4, '0')}`;
-export const formatImmExprForAsm = (expr) => {
-    switch (expr.kind) {
-        case 'ImmLiteral':
-            return toHexWord(expr.value);
-        case 'ImmName':
-            return expr.name;
-        case 'ImmSizeof':
-            return 'sizeof(...)';
-        case 'ImmOffset':
-            return 'offset(...)';
-        case 'ImmUnary':
-            return `${expr.op}${formatImmExprForAsm(expr.expr)}`;
-        case 'ImmBinary':
-            return `${formatImmExprForAsm(expr.left)} ${expr.op} ${formatImmExprForAsm(expr.right)}`;
-        default:
-            return 'imm';
-    }
-};
-export const formatEaExpr = (ea, { formatImmExpr, wrapImmEa = false }) => {
-    switch (ea.kind) {
-        case 'EaName':
-            return ea.name;
-        case 'EaImm':
-            return wrapImmEa ? `(${formatImmExpr(ea.expr)})` : formatImmExpr(ea.expr);
-        case 'EaField':
-            return `${formatEaExpr(ea.base, { formatImmExpr, wrapImmEa })}.${ea.field}`;
-        case 'EaAdd':
-            return `${formatEaExpr(ea.base, { formatImmExpr, wrapImmEa })} + ${formatImmExpr(ea.offset)}`;
-        case 'EaSub':
-            return `${formatEaExpr(ea.base, { formatImmExpr, wrapImmEa })} - ${formatImmExpr(ea.offset)}`;
-        case 'EaIndex': {
-            let idx = '';
-            switch (ea.index.kind) {
-                case 'IndexImm':
-                    idx = formatImmExpr(ea.index.value);
-                    break;
-                case 'IndexReg8':
-                case 'IndexReg16':
-                    idx = ea.index.reg;
-                    break;
-                case 'IndexMemHL':
-                    idx = '(HL)';
-                    break;
-                case 'IndexMemIxIy':
-                    idx = ea.index.disp
-                        ? `${ea.index.base}${ea.index.disp.kind === 'ImmUnary' ? '' : '+'}${formatImmExpr(ea.index.disp)}`
-                        : ea.index.base;
-                    break;
-                case 'IndexEa':
-                    idx = formatEaExpr(ea.index.expr, { formatImmExpr, wrapImmEa });
-                    break;
-            }
-            return `${formatEaExpr(ea.base, { formatImmExpr, wrapImmEa })}[${idx}]`;
-        }
-        default:
-            return 'ea';
-    }
-};
-const formatEaExprForAsm = (ea) => formatEaExpr(ea, { formatImmExpr: formatImmExprForAsm });
-const formatAsmOperandForTrace = (operand) => {
-    switch (operand.kind) {
-        case 'Reg':
-            return operand.name;
-        case 'Imm':
-            return formatImmExprForAsm(operand.expr);
-        case 'Ea':
-            return formatEaExprForAsm(operand.expr);
-        case 'Mem':
-            return `(${formatEaExprForAsm(operand.expr)})`;
-        case 'PortC':
-            return '(C)';
-        case 'PortImm8':
-            return `(${formatImmExprForAsm(operand.expr)})`;
-        default:
-            return '?';
-    }
-};
-export const formatAsmInstrForTrace = (head, operands) => {
-    const lowerHead = head.toLowerCase();
-    if (operands.length === 0)
-        return lowerHead;
-    return `${lowerHead} ${operands.map(formatAsmOperandForTrace).join(', ')}`;
-};
-const formatFixupSymbolExpr = (baseLower, addend) => {
-    if (addend === 0)
-        return baseLower;
-    if (addend > 0)
-        return `${baseLower} + ${addend}`;
-    return `${baseLower} - ${Math.abs(addend)}`;
-};
-const jpCondFromOpcode = (opcode) => {
-    switch (opcode & 0xff) {
-        case 0xc2:
-            return 'NZ';
-        case 0xca:
-            return 'Z';
-        case 0xd2:
-            return 'NC';
-        case 0xda:
-            return 'C';
-        case 0xe2:
-            return 'PO';
-        case 0xea:
-            return 'PE';
-        case 0xf2:
-            return 'P';
-        case 0xfa:
-            return 'M';
-        default:
-            return undefined;
-    }
-};
-const callCondFromOpcode = (opcode) => {
-    switch (opcode & 0xff) {
-        case 0xc4:
-            return 'NZ';
-        case 0xcc:
-            return 'Z';
-        case 0xd4:
-            return 'NC';
-        case 0xdc:
-            return 'C';
-        case 0xe4:
-            return 'PO';
-        case 0xec:
-            return 'PE';
-        case 0xf4:
-            return 'P';
-        case 0xfc:
-            return 'M';
-        default:
-            return undefined;
-    }
-};
-export const formatAbs16FixupAsm = (opcode, baseLower, addend) => {
-    const sym = formatFixupSymbolExpr(baseLower, addend);
-    switch (opcode & 0xff) {
-        case 0x01:
-            return `ld BC, ${sym}`;
-        case 0x11:
-            return `ld DE, ${sym}`;
-        case 0x21:
-            return `ld HL, ${sym}`;
-        case 0x31:
-            return `ld SP, ${sym}`;
-        case 0x2a:
-            return `ld HL, (${sym})`;
-        case 0x3a:
-            return `ld A, (${sym})`;
-        case 0x22:
-            return `ld (${sym}), HL`;
-        case 0x32:
-            return `ld (${sym}), A`;
-        case 0xc3:
-            return `jp ${sym}`;
-        case 0xcd:
-            return `call ${sym}`;
-        default: {
-            const jpCc = jpCondFromOpcode(opcode);
-            if (jpCc)
-                return `jp ${jpCc}, ${sym}`;
-            const callCc = callCondFromOpcode(opcode);
-            if (callCc)
-                return `call ${callCc}, ${sym}`;
-            return `db ${toHexByte(opcode)}, lo(${baseLower}), hi(${baseLower})`;
-        }
-    }
-};
-export const formatAbs16FixupEdAsm = (opcode2, baseLower, addend) => {
-    const sym = formatFixupSymbolExpr(baseLower, addend);
-    switch (opcode2 & 0xff) {
-        case 0x4b:
-            return `ld BC, (${sym})`;
-        case 0x5b:
-            return `ld DE, (${sym})`;
-        case 0x7b:
-            return `ld SP, (${sym})`;
-        case 0x43:
-            return `ld (${sym}), BC`;
-        case 0x53:
-            return `ld (${sym}), DE`;
-        case 0x73:
-            return `ld (${sym}), SP`;
-        default:
-            return `db $ED, ${toHexByte(opcode2)}, lo(${baseLower}), hi(${baseLower})`;
-    }
-};
-export const formatAbs16FixupPrefixedAsm = (prefix, opcode2, baseLower, addend) => {
-    const sym = formatFixupSymbolExpr(baseLower, addend);
-    const reg16 = prefix === 0xdd ? 'IX' : prefix === 0xfd ? 'IY' : undefined;
-    if (!reg16) {
-        return `db ${toHexByte(prefix)}, ${toHexByte(opcode2)}, lo(${baseLower}), hi(${baseLower})`;
-    }
-    switch (opcode2 & 0xff) {
-        case 0x21:
-            return `ld ${reg16}, ${sym}`;
-        case 0x2a:
-            return `ld ${reg16}, (${sym})`;
-        case 0x22:
-            return `ld (${sym}), ${reg16}`;
-        default:
-            return `db ${toHexByte(prefix)}, ${toHexByte(opcode2)}, lo(${baseLower}), hi(${baseLower})`;
-    }
-};
-export const formatIxDisp = (disp) => {
-    const hex = Math.abs(disp).toString(16).padStart(2, '0');
-    const sign = disp >= 0 ? '+' : '-';
-    return `${sign}$${hex}`;
-};

package/dist/legacy-root-azm/src/packageInfo.d.ts

@@ -1 +0,0 @@
-export declare function readPackageVersion(): string;

package/dist/legacy-root-azm/src/packageInfo.js

@@ -1,15 +0,0 @@
-import { createRequire } from 'node:module';
-import { dirname, resolve } from 'node:path';
-import { fileURLToPath } from 'node:url';
-export function readPackageVersion() {
-    const require = createRequire(import.meta.url);
-    const here = dirname(fileURLToPath(import.meta.url));
-    let pkg;
-    try {
-        pkg = require(resolve(here, '..', 'package.json'));
-    }
-    catch {
-        pkg = require(resolve(here, '..', '..', 'package.json'));
-    }
-    return String(pkg.version ?? '0.0.0');
-}

package/dist/legacy-root-azm/src/pathCompare.d.ts

@@ -1,3 +0,0 @@
-export declare function normalizePathForCompare(path: string, options?: {
-    realpath?: boolean;
-}): string;

package/dist/legacy-root-azm/src/pathCompare.js

@@ -1,26 +0,0 @@
-import { realpathSync } from 'node:fs';
-import { resolve } from 'node:path';
-function stripExtendedWindowsPrefix(path) {
-    if (path.startsWith('\\\\?\\UNC\\'))
-        return `\\\\${path.slice(8)}`;
-    if (path.startsWith('\\\\?\\'))
-        return path.slice(4);
-    return path;
-}
-export function normalizePathForCompare(path, options = {}) {
-    const resolved = options.realpath ? resolve(path) : path;
-    const canonical = (() => {
-        if (!options.realpath)
-            return resolved;
-        try {
-            return realpathSync.native(resolved);
-        }
-        catch {
-            return resolved;
-        }
-    })();
-    const stripped = stripExtendedWindowsPrefix(canonical);
-    const normalized = stripped.replace(/\\/g, '/');
-    const normalizedDarwin = process.platform === 'darwin' ? normalized.replace(/^\/private\//, '/') : normalized;
-    return process.platform === 'win32' ? normalizedDarwin.toLowerCase() : normalizedDarwin;
-}

package/dist/legacy-root-azm/src/pipeline.d.ts

@@ -1,91 +0,0 @@
-import type { Diagnostic } from './diagnosticTypes.js';
-import type { Artifact, FormatWriters } from './formats/types.js';
-import type { RegisterCareMode } from './registerCare/types.js';
-export type CaseStyleMode = 'off' | 'upper' | 'lower' | 'consistent';
-/**
- * Options that influence compilation behavior and which artifacts are produced.
- */
-export interface CompilerOptions {
-    /**
-     * Additional include/search directories used for textual includes and input assets.
-     *
-     * These directories are consulted after checking paths relative to the
-     * importing source file.
-     */
-    includeDirs?: string[];
-    /** Primary output path supplied by wrappers that derive sibling artifacts. */
-    outputPath?: string;
-    /** Primary output type selected by wrappers such as the CLI. */
-    outputType?: 'hex' | 'bin';
-    /**
-     * Root used for source paths in debug maps.
-     *
-     * When present, D8 file keys and generator input paths are emitted relative
-     * to this directory with `/` separators.
-     */
-    sourceRoot?: string;
-    /**
-     * Output paths recorded in D8 generator metadata when known by the caller.
-     */
-    d8mInputs?: {
-        listing?: string;
-        hex?: string;
-        bin?: string;
-    };
-    /** Emit flat binary (`.bin`). */
-    emitBin?: boolean;
-    /** Emit Intel HEX (`.hex`). */
-    emitHex?: boolean;
-    /** Emit D8 Debug Map (`.d8.json`). */
-    emitD8m?: boolean;
-    /** Emit listing (`.lst`). */
-    emitListing?: boolean;
-    /** Emit ASM80-compatible lowered source (`.z80`). */
-    emitAsm80?: boolean;
-    /** Optional case-style lint mode for asm keywords/register tokens. */
-    caseStyle?: CaseStyleMode;
-    /** Require a `main` entry label for runnable builds. */
-    requireMain?: boolean;
-    /** Default code base address. */
-    defaultCodeBase?: number;
-    /** JSON directive alias files. Later files extend or override earlier aliases. */
-    directiveAliasFiles?: string[];
-    /** Register-care analysis mode. */
-    registerCare?: RegisterCareMode;
-    /** Emit a register-care audit report artifact. */
-    emitRegisterReport?: boolean;
-    /** Emit an inferred register-care interface artifact. */
-    emitRegisterInterface?: boolean;
-    /** Rewrite source files with inferred register-care contract blocks. */
-    emitRegisterAnnotations?: boolean;
-    /** Apply conservative register-care source fixes. Implies source annotations. */
-    fixRegisterContracts?: boolean;
-    /**
-     * Promote selected caller-use output candidates while rewriting register-care
-     * source annotations. Entries use `ROUTINE:carriers`, for example `MxMask:A`.
-     */
-    acceptRegisterOutputCandidates?: string[];
-    /** Register-care analysis profile. */
-    registerCareProfile?: 'mon3';
-    /** Register-care contract files that provide contracts for external/library routines. */
-    registerCareInterfaces?: string[];
-}
-/**
- * Result of a compilation run: diagnostics plus any produced artifacts.
- */
-export interface CompileResult {
-    diagnostics: Diagnostic[];
-    artifacts: Artifact[];
-}
-/**
- * Dependency injection surface for the compiler pipeline.
- *
- * Callers provide concrete format writers so the core pipeline can be pure/in-memory.
- */
-export interface PipelineDeps {
-    formats: FormatWriters;
-}
-/**
- * Top-level compile function signature used by the pipeline contract.
- */
-export type CompileFn = (entryFile: string, options: CompilerOptions, deps: PipelineDeps) => Promise<CompileResult>;

package/dist/legacy-root-azm/src/pipeline.js

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

package/dist/legacy-root-azm/src/registerCare/analyze.d.ts

@@ -1,24 +0,0 @@
-import { type Diagnostic } from '../diagnosticTypes.js';
-import type { LoadedProgram } from '../sourceLoader.js';
-import { type RegisterCareAnnotatedFile } from './annotate.js';
-import { type RegisterCareProfileName } from './profiles.js';
-import type { RegisterCareMode, RegisterCareReportModel, RoutineContract } from './types.js';
-export interface AnalyzeRegisterCareOptions {
-    mode: RegisterCareMode;
-    emitReport: boolean;
-    emitInterface: boolean;
-    emitAnnotations?: boolean;
-    fixRegisterContracts?: boolean;
-    acceptOutputCandidates?: string[];
-    profile?: RegisterCareProfileName;
-    interfaceContracts?: RoutineContract[];
-}
-interface AnalyzeRegisterCareResult {
-    diagnostics: Diagnostic[];
-    outputCandidates?: RegisterCareReportModel['outputCandidates'];
-    reportText?: string;
-    interfaceText?: string;
-    annotatedFiles?: RegisterCareAnnotatedFile[];
-}
-export declare function analyzeRegisterCare(loaded: LoadedProgram, options: AnalyzeRegisterCareOptions): AnalyzeRegisterCareResult;
-export {};