cpm.h

 #ifndef CPM_H
#define CPM_H

enum eBIOSFunc {
    // CP/M 2.2 Stuff
    B_BOOT = 0,
    B_WBOOT = 3,
    B_CONST = 6,
    B_CONIN = 9,
    B_CONOUT = 12,
    B_LIST = 15,
    B_AUXOUT = 18,
    B_READER = 21,
    B_HOME = 24,
    B_SELDSK = 27,
    B_SETTRK = 30,
    B_SETSEC = 33,
    B_SETDMA = 36,
    B_READ = 39,
    B_WRITE = 42,
    B_LISTST = 45,
    B_SECTRAN = 48,
    // CP/M 3.0 Stuff
    B_CONOST = 51,
    B_AUXIST = 54,
    B_AUXOST = 57,
    B_DEVTBL = 60,
    B_DEVINI = 63,
    B_DRVTBL = 66,
    B_MULTIO = 69,
    B_FLUSH = 72,
    B_MOVE = 75,
    B_TIME = 78,
    B_SELMEM = 81,
    B_SETBNK = 84,
    B_XMOVE = 87,
    B_USERF = 90, // Used by internal CCP to return to prompt
    B_RESERV1 = 93,
    B_RESERV2 = 96
};

enum eBDOSFunc {
    // CP/M 2.2 Stuff
    P_TERMCPM = 0,
    C_READ = 1,
    C_WRITE = 2,
    A_READ = 3,
    A_WRITE = 4,
    L_WRITE = 5,
    C_RAWIO = 6,
    A_STATIN = 7,
    A_STATOUT = 8,
    C_WRITESTR = 9,
    C_READSTR = 10,
    C_STAT = 11,
    S_BDOSVER = 12,
    DRV_ALLRESET = 13,
    DRV_SET = 14,
    F_OPEN = 15,
    F_CLOSE = 16,
    F_SFIRST = 17,
    F_SNEXT = 18,
    F_DELETE = 19,
    F_READ = 20,
    F_WRITE = 21,
    F_MAKE = 22,
    F_RENAME = 23,
    DRV_LOGINVEC = 24,
    DRV_GET = 25,
    F_DMAOFF = 26,
    DRV_ALLOCVEC = 27,
    DRV_SETRO = 28,
    DRV_ROVEC = 29,
    F_ATTRIB = 30,
    DRV_PDB = 31,
    F_USERNUM = 32,
    F_READRAND = 33,
    F_WRITERAND = 34,
    F_SIZE = 35,
    F_RANDREC = 36,
    DRV_RESET = 37,
    DRV_ACCESS_MPM = 38, // This is an MP/M function that is not supported under CP/M 3.
    DRV_FREE_MPM = 39,   // This is an MP/M function that is not supported under CP/M 3.
    F_WRITEZF = 40,
    // CP/M 3.0 Stuff
    F_TESTWRITE = 41,
    F_LOCKFILE = 42,
    F_UNLOCKFILE = 43,
    F_MULTISEC = 44,
    F_ERRMODE = 45,
    DRV_SPACE = 46,
    P_CHAIN = 47,
    DRV_FLUSH = 48,
    S_SCB = 49,
    S_BIOS = 50,
    P_LOAD = 59,
    S_RSX = 60,
    F_CLEANUP = 98,
    F_TRUNCATE = 99,
    DRV_SETLABEL = 100,
    DRV_GETLABEL = 101,
    F_TIMEDATE = 102,
    F_WRITEXFCB = 103,
    T_SET = 104,
    T_GET = 105,
    F_PASSWD = 106,
    S_SERIAL = 107,
    P_CODE = 108,
    C_MODE = 109,
    C_DELIMIT = 110,
    C_WRITEBLK = 111,
    L_WRITEBLK = 112,
    F_PARSE = 152,
    // RunCPM Stuff
    F_PINMODE = 220,
    F_DREAD = 221,
    F_DWRITE = 222,
    F_AREAD = 223,
    F_AWRITE = 224,
    F_SETMASK = 230,
    F_BDOSCALL = 231,
    F_UPTIME = 248,
    F_MAKEDISK = 249,
    F_HOSTOS = 250,
    F_VERSION = 251,
    F_CCPVERSION = 252,
    F_CCPADDR = 253,
    F_SETCPUSPEED = 254
};

/* see main.c for definition */

#define JP 0xc3
#define CALL 0xcd
#define RET 0xc9
#define INa 0xdb  // Triggers a BIOS call
#define OUTa 0xd3 // Triggers a BDOS call
// Interruption handling
#define RST_08 0xcf  // RST 08h - BIOS calls
#define RST_10 0xd7  // RST 10h - BDOS calls  
#define RST_18 0xdf  // RST 18h - Hardware calls
#define NOP 0x00     // No operation

/* set up full PUN and LST filenames to be on drive A: user 0 */
#ifdef USE_PUN
char pun_file[17] = {'A', FOLDERCHAR, '0', FOLDERCHAR, 'P', 'U', 'N', '.', 'T', 'X', 'T', 0};
#endif // ifdef USE_PUN

#ifdef USE_LST
char lst_file[17] = {'A', FOLDERCHAR, '0', FOLDERCHAR, 'L', 'S', 'T', '.', 'T', 'X', 'T', 0};
#endif // ifdef USE_LST

#ifdef PROFILE
unsigned long time_start = 0;
unsigned long time_now = 0;
#endif // ifdef PROFILE

void _PatchBIOS(void) {
    uint16 i;

    // Patches in the BIOS jump destinations
    for (i = 0; i < 99; i = i + 3) {
        _RamWrite(BIOSjmppage + i, JP);
        _RamWrite16(BIOSjmppage + i + 1, BIOSpage + i);
    }

    // Patches in the BIOS page content
    for (i = 0; i < 99; i = i + 3) {
#ifdef INT_HANDOFF
        _RamWrite(BIOSpage + i, RST_08);
        _RamWrite(BIOSpage + i + 1, RET);
        _RamWrite(BIOSpage + i + 2, NOP);
#else
        _RamWrite(BIOSpage + i, OUTa);
        _RamWrite(BIOSpage + i + 1, 0xFF);
        _RamWrite(BIOSpage + i + 2, RET);
#endif
    }
} //_PatchBIOS

void _PatchCPM(void) {
    uint16 i;

    // **********  Patch CP/M page zero into the memory  **********

    /* BIOS entry point */
    _RamWrite(0x0000, JP); /* JP BIOS+3 (warm boot) */
    _RamWrite16(0x0001, BIOSjmppage + 3);
    if (Status != STATUS_RESTART) {
        /* IOBYTE - Points to Console */
        _RamWrite(IOByte, 0x3D);

        /* Current drive/user - A:/0 */
        _RamWrite(DSKByte, 0x00);
    }
    /* BDOS entry point (0x0005) */
    _RamWrite(0x0005, JP);
    _RamWrite16(0x0006, BDOSjmppage + 0x06);

    // **********  Patch CP/M Version into the memory so the CCP can see it
#ifdef ABDOS
    // Loads the ABDOS.SYS file into memory or throws an error if it doesn't exist
    if (_sys_exists((uint8 *)"A/0/ABDOS.SYS")) {
        _RamLoad((uint8 *)"A/0/ABDOS.SYS", BDOSjmppage, 0);
    } else {
        _puts("\r\nABDOS.SYS not found");
        exit(1);
    }
#else
    _RamWrite16(BDOSjmppage, 0x1600);
    _RamWrite16(BDOSjmppage + 2, 0x0000);
    _RamWrite16(BDOSjmppage + 4, 0x0000);

    // Patches in the BDOS jump destination
    _RamWrite(BDOSjmppage + 6, JP);
    _RamWrite16(BDOSjmppage + 7, BDOSpage);

    // Patches in the BDOS page content
#ifdef INT_HANDOFF
    _RamWrite(BDOSpage, RST_10);
    _RamWrite(BDOSpage + 1, RET);
    _RamWrite(BDOSpage + 2, NOP);
#else
    _RamWrite(BDOSpage, INa);
    _RamWrite(BDOSpage + 1, 0xFF);
    _RamWrite(BDOSpage + 2, RET);
#endif

    _PatchBIOS();
#endif

    // **********  Patch CP/M (fake) Disk Parameter Block after the BDOS call entry  **********
    i = DPBaddr;
    _RamWrite(i++, 0x00); // DEFW spt - Sectors Per Track (256)
    _RamWrite(i++, 0x01);
    _RamWrite(i++, 0x05); // DEFB bsh - Data allocation "Block Shift Factor" (for 4096 block size)
    _RamWrite(i++, 0x1F); // DEFB blm - Data allocation Block Mask (31 for 4096 block size)
    _RamWrite(i++, 0x01); // DEFB exm - Data allocation Extent Mask (1 = total blocks > 256)
    _RamWrite(i++, 0xF7); // DEFW dsm - Logical disk size in blocks - 1 (2039)
    _RamWrite(i++, 0x07);
    _RamWrite(i++, 0xFF); // DEFW drm - Maximum directory entries - 1 (1023)
    _RamWrite(i++, 0x03);
    _RamWrite(i++, 0xFF); // DEFB al0 - Reserved directory blocks
    _RamWrite(i++, 0x00); // DEFB al1 - Reserved directory blocks
    _RamWrite(i++, 0x00); // DEFW cks - Check area Size (0 for fixed disks)
    _RamWrite(i++, 0x00);
    _RamWrite(i++, 0x01); // DEFW off - Number of system reserved tracks at the beginning of the ( logical ) disk
    _RamWrite(i++, 0x00);
    blockShift = _RamRead(DPBaddr + 2);
    blockMask = _RamRead(DPBaddr + 3);
    extentMask = _RamRead(DPBaddr + 4);
    numAllocBlocks = _RamRead16(DPBaddr + 5) + 1;
    extentsPerDirEntry = extentMask + 1;

    // **********  Patch CP/M (fake) Disk Parameter Header after the Disk Parameter Block  **********
    _RamWrite(i++, 0); // Addr of the sector translation table
    _RamWrite(i++, 0);
    _RamWrite(i++, 0); // Workspace
    _RamWrite(i++, 0);
    _RamWrite(i++, 0);
    _RamWrite(i++, 0);
    _RamWrite(i++, 0);
    _RamWrite(i++, 0);
    _RamWrite(i++, 0x80); // Addr of the Sector Buffer
    _RamWrite(i++, 0);
    _RamWrite(i++, LOW_REGISTER(DPBaddr)); // Addr of the DPB Disk Parameter Block
    _RamWrite(i++, HIGH_REGISTER(DPBaddr));
    _RamWrite(i++, 0); // Addr of the Directory Checksum Vector
    _RamWrite(i++, 0);
    _RamWrite(i++, 0); // Addr of the Allocation Vector
    _RamWrite(i++, 0);

    //

    // figure out the number of the first allocation block
    // after the directory for the phoney allocation block
    // list in _findnext()
    firstBlockAfterDir = 0;
    i = 0x80;

    while (_RamRead(DPBaddr + 9) & i) {
        firstBlockAfterDir++;
        i >>= 1;
    }
    if (_RamRead(DPBaddr + 9) == 0xFF) {
        i = 0x80;

        while (_RamRead(DPBaddr + 10) & i) {
            firstBlockAfterDir++;
            i >>= 1;
        }
    }
    physicalExtentBytes = logicalExtentBytes * (extentMask + 1);
} // _PatchCPM

#ifdef DEBUGLOG
uint8 LogBuffer[128];

void _logRegs(void) {
    uint8 J, I;
    uint8 Flags[9] = {'S', 'Z', '5', 'H', '3', 'P', 'N', 'C'};
    uint8 c = HIGH_REGISTER(AF);

    if ((c < 32) || (c > 126))
        c = 46;

    for (J = 0, I = LOW_REGISTER(AF); J < 8; ++J, I <<= 1)
        Flags[J] = I & 0x80 ? Flags[J] : '.';
    sprintf((char *)LogBuffer, "  BC:%04x DE:%04x HL:%04x AF:%02x(%c)|%s| IX:%04x IY:%04x SP:%04x PC:%04x\n",
            WORD16(BC), WORD16(DE), WORD16(HL), HIGH_REGISTER(AF), c, Flags, WORD16(IX), WORD16(IY), WORD16(SP), WORD16(PC));
    _sys_logbuffer(LogBuffer);
} // _logRegs

void _logMem(uint16 address, uint8 amount) { // Amount = number of 16 bytes lines, so 1 CP/M block = 8, not 128
    uint8 i, m, c, pos;
    uint8 head = 8;
    uint8 hexa[] = "0123456789ABCDEF";

    for (i = 0; i < amount; ++i) {
        pos = 0;

        for (m = 0; m < head; ++m)
            LogBuffer[pos++] = ' ';
        sprintf((char *)LogBuffer, "  %04x: ", address);

        for (m = 0; m < 16; ++m) {
            c = _RamRead(address++);
            LogBuffer[pos++] = hexa[c >> 4];
            LogBuffer[pos++] = hexa[c & 0x0f];
            LogBuffer[pos++] = ' ';
            LogBuffer[m + head + 48] = c > 31 && c < 127 ? c : '.';
        }
        pos += 16;
        LogBuffer[pos++] = 0x0a;
        LogBuffer[pos++] = 0x00;
        _sys_logbuffer(LogBuffer);
    }
} // _logMem

void _logChar(char *txt, uint8 c) {
    uint8 asc[2];

    asc[0] = c > 31 && c < 127 ? c : '.';
    asc[1] = 0;
    sprintf((char *)LogBuffer, "        %s = %02xh:%3d (%s)\n", txt, c, c, asc);
    _sys_logbuffer(LogBuffer);
} // _logChar

void _logBiosIn(uint8 ch) {
    #ifdef LOGBIOS_NOT
    if (ch == LOGBIOS_NOT)
        return;
    #endif // ifdef LOGBIOS_NOT
    #ifdef LOGBIOS_ONLY
    if (ch != LOGBIOS_ONLY)
        return;
    #endif // ifdef LOGBIOS_ONLY
    static const char *BIOSCalls[33] =
        {
            "boot", "wboot", "const", "conin", "conout", "list", "punch/aux", "reader", "home", "seldsk", "settrk", "setsec", "setdma",
            "read", "write", "listst", "sectran", "conost", "auxist", "auxost", "devtbl", "devini", "drvtbl", "multio", "flush", "move",
            "time", "selmem", "setbnk", "xmove", "userf", "reserv1", "reserv2"};
    int index = ch / 3;

    if (index < 18) {
        sprintf((char *)LogBuffer, "\nBios call: %3d/%02xh (%s) IN:\n", ch, ch, BIOSCalls[index]);
        _sys_logbuffer(LogBuffer);
    } else {
        sprintf((char *)LogBuffer, "\nBios call: %3d/%02xh IN:\n", ch, ch);
        _sys_logbuffer(LogBuffer);
    }
    _logRegs();
} // _logBiosIn

void _logBiosOut(uint8 ch) {
    #ifdef LOGBIOS_NOT
    if (ch == LOGBIOS_NOT)
        return;
    #endif // ifdef LOGBIOS_NOT
    #ifdef LOGBIOS_ONLY
    if (ch != LOGBIOS_ONLY)
        return;
    #endif // ifdef LOGBIOS_ONLY
    sprintf((char *)LogBuffer, "               OUT:\n");
    _sys_logbuffer(LogBuffer);
    _logRegs();
} // _logBiosOut

void _logBdosIn(uint8 ch) {
    #ifdef LOGBDOS_NOT
    if (ch == LOGBDOS_NOT)
        return;
    #endif // ifdef LOGBDOS_NOT
    #ifdef LOGBDOS_ONLY
    if (ch != LOGBDOS_ONLY)
        return;
    #endif // ifdef LOGBDOS_ONLY
    uint16 address = 0;
    uint8 size = 0;

    static const char *CPMCalls[41] =
        {
            "System Reset", "Console Input", "Console Output", "Reader Input", "Punch Output", "List Output", "Direct I/O",
            "Get IOByte", "Set IOByte", "Print String", "Read Buffered", "Console Status", "Get Version", "Reset Disk",
            "Select Disk", "Open File", "Close File", "Search First", "Search Next", "Delete File", "Read Sequential",
            "Write Sequential", "Make File", "Rename File", "Get Login Vector", "Get Current Disk", "Set DMA Address",
            "Get Alloc", "Write Protect Disk", "Get R/O Vector", "Set File Attr", "Get Disk Params", "Get/Set User",
            "Read Random", "Write Random", "Get File Size", "Set Random Record", "Reset Drive", "N/A", "N/A",
            "Write Random 0 fill"};

    if (ch < 41) {
        sprintf((char *)LogBuffer, "\nBdos call: %3d/%02xh (%s) IN from 0x%04x:\n", ch, ch, CPMCalls[ch], _RamRead16(SP) - 3);
        _sys_logbuffer(LogBuffer);
    } else {
        sprintf((char *)LogBuffer, "\nBdos call: %3d/%02xh IN from 0x%04x:\n", ch, ch, _RamRead16(SP) - 3);
        _sys_logbuffer(LogBuffer);
    }
    _logRegs();

    switch (ch) {
    case 2:
    case 4:
    case 5:
    case 6: {
        _logChar("E", LOW_REGISTER(DE));
        break;
    }

    case 9:
    case 10: {
        address = DE;
        size = 8;
        break;
    }

    case 15:
    case 16:
    case 17:
    case 18:
    case 19:
    case 22:
    case 23:
    case 30:
    case 35:
    case 36: {
        address = DE;
        size = 3;
        break;
    }

    case 20:
    case 21:
    case 33:
    case 34:
    case 40: {
        address = DE;
        size = 3;
        _logMem(address, size);
        sprintf((char *)LogBuffer, "\n");
        _sys_logbuffer(LogBuffer);
        address = dmaAddr;
        size = 8;
        break;
    }

    default: {
        break;
    }
    } // switch
    if (size)
        _logMem(address, size);
} // _logBdosIn

void _logBdosOut(uint8 ch) {
    #ifdef LOGBDOS_NOT
    if (ch == LOGBDOS_NOT)
        return;
    #endif // ifdef LOGBDOS_NOT
    #ifdef LOGBDOS_ONLY
    if (ch != LOGBDOS_ONLY)
        return;
    #endif // ifdef LOGBDOS_ONLY
    uint16 address = 0;
    uint8 size = 0;

    sprintf((char *)LogBuffer, "              OUT:\n");
    _sys_logbuffer(LogBuffer);
    _logRegs();

    switch (ch) {
    case 1:
    case 3:
    case 6: {
        _logChar("A", HIGH_REGISTER(AF));
        break;
    }

    case 10: {
        address = DE;
        size = 8;
        break;
    }

    case 20:
    case 21:
    case 33:
    case 34:
    case 40: {
        address = DE;
        size = 3;
        _logMem(address, size);
        sprintf((char *)LogBuffer, "\n");
        _sys_logbuffer(LogBuffer);
        address = dmaAddr;
        size = 8;
        break;
    }

    case 26: {
        address = dmaAddr;
        size = 8;
        break;
    }

    case 15:
    case 16:
    case 17:
    case 18:
    case 19:
    case 22:
    case 23:
    case 30:
    case 35:
    case 36: {
        address = DE;
        size = 3;
        break;
    }

    default: {
        break;
    }
    } // switch
    if (size)
        _logMem(address, size);
} // _logBdosOut
#endif // ifdef DEBUGLOG

void _Bios(void) {
    uint8 ch = LOW_REGISTER(PCX);
    uint8 disk[2] = {'A', 0};

#ifdef DEBUGLOG
    _logBiosIn(ch);
#endif

    switch (ch) {
    case B_BOOT: {
        Status = STATUS_EXIT; // 0 - Ends RunCPM
        break;
    }
    case B_WBOOT: {
        Status = STATUS_RESTART; // 1 - Back to CCP
        break;
    }
    case B_CONST: { // 2 - Console status
        SET_HIGH_REGISTER(AF, _chready());
        break;
    }
    case B_CONIN: { // 3 - Console input
        SET_HIGH_REGISTER(AF, _getcon());
#ifdef DEBUG
        if (HIGH_REGISTER(AF) == DEBUGKEY)
            Debug = 1;
#endif // ifdef DEBUG
        break;
    }
    case B_CONOUT: { // 4 - Console output
        _putcon(LOW_REGISTER(BC));
        break;
    }
    case B_LIST: { // 5 - List output
        break;
    }
    case B_AUXOUT: { // 6 - Aux/Punch output
        break;
    }
    case B_READER: { // 7 - Reader input (returns 0x1a = device not implemented)
        SET_HIGH_REGISTER(AF, 0x1a);
        break;
    }
    case B_HOME: { // 8 - Home disk head
        break;
    }
    case B_SELDSK: { // 9 - Select disk drive
        disk[0] += LOW_REGISTER(BC);
        HL = 0x0000;
        if (_sys_select(&disk[0]))
            HL = DPHaddr;
        break;
    }
    case B_SETTRK: { // 10 - Set track number
        break;
    }
    case B_SETSEC: { // 11 - Set sector number
        break;
    }
    case B_SETDMA: { // 12 - Set DMA address
        HL = BC;
        dmaAddr = BC;
        break;
    }
    case B_READ: { // 13 - Read selected sector
        SET_HIGH_REGISTER(AF, 0x00);
        break;
    }
    case B_WRITE: { // 14 - Write selected sector
        SET_HIGH_REGISTER(AF, 0x00);
        break;
    }
    case B_LISTST: { // 15 - Get list device status
        SET_HIGH_REGISTER(AF, 0x0ff);
        break;
    }
    case B_SECTRAN: { // 16 - Sector translate
        HL = BC;      // HL=BC=No translation (1:1)
        break;
    }
    case B_CONOST: { // 17 - Return status of current screen output device
        SET_HIGH_REGISTER(AF, 0x0ff);
        break;
    }
    case B_AUXIST: { // 18 - Return status of current auxiliary input device
        SET_HIGH_REGISTER(AF, 0x00);
        break;
    }
    case B_AUXOST: { // 19 - Return status of current auxiliary output device
        SET_HIGH_REGISTER(AF, 0x00);
        break;
    }
    case B_DEVTBL: { // 20 - Return the address of the devices table, or 0 if not implemented
        HL = 0x0000;
        break;
    }
    case B_DEVINI: { // 21 - Reinitialise character device number C
        break;
    }
    case B_DRVTBL: { // 22 - Return the address of the drive table
        HL = 0x0FFFF;
        break;
    }
    case B_MULTIO: { // 23 - Notify the BIOS of multi sector transfer
        break;
    }
    case B_FLUSH: { // 24 - Write any pending data to disc
        SET_HIGH_REGISTER(AF, 0x00);
        break;
    }
    case B_MOVE: { // 25 - Move a block of memory
        if (!isXmove) {
            srcBank = dstBank = curBank;
            srcBankBase = dstBankBase = curBankBase;
        }
        while (BC--)
            RAM[dstBankBase + HL++] = RAM[srcBankBase + DE++];
        isXmove = FALSE;
        break;
    }
    case B_TIME: { // 26 - Get/Set SCB time
        break;
    }
    case B_SELMEM: { // 27 - Select memory bank
        curBank = HIGH_REGISTER(AF);
        if (curBank >= BANKS) // guard against RAM[] overrun on an out-of-range bank
            curBank = BANKS - 1;
        curBankBase = ((uint32)curBank) << 16; // banks are 0-based: bank N -> RAM offset N*64K
        break;
    }
    case B_SETBNK: { // 28 - Set the bank to be used for the next read/write sector operation
        ioBank = HIGH_REGISTER(AF);
        if (ioBank >= BANKS)
            ioBank = BANKS - 1;
        ioBankBase = ((uint32)ioBank) << 16;
        break; // without this, SETBNK fell through into XMOVE and corrupted srcBank/dstBank/isXmove
    }
    case B_XMOVE: { // 29 - Preload banks for MOVE
        srcBank = LOW_REGISTER(BC);
        dstBank = HIGH_REGISTER(BC);
        if (srcBank >= BANKS)
            srcBank = BANKS - 1;
        if (dstBank >= BANKS)
            dstBank = BANKS - 1;
        srcBankBase = ((uint32)srcBank) << 16;
        dstBankBase = ((uint32)dstBank) << 16;
        isXmove = TRUE;
        break;
    }
    case B_USERF: { // 30 - This allows programs ending in RET return to internal CCP
        Status = STATUS_RETURN;
        break;
    }
    case B_RESERV1:
    case B_RESERV2: {
        break;
    }
    default: {
#ifdef DEBUG // Show unimplemented BIOS calls only when debugging
        _puts("\r\nUnimplemented BIOS call.\r\n");
        _puts("C = 0x");
        _puthex8(ch);
        _puts("\r\n");
#endif // ifdef DEBUG
        break;
    }
    } // switch
#ifdef DEBUGLOG
    _logBiosOut(ch);
#endif
} // _Bios

/* Packed BCD helpers for the CP/M 3 clock (BDOS 104/105) */
#define BCD2DEC(b) ((((b) >> 4) & 0x0F) * 10 + ((b) & 0x0F))
#define DEC2BCD(d) ((uint8)((((d) / 10) << 4) | ((d) % 10)))

/* Difference (in seconds) between the host clock and the clock set via
   BDOS 104 (T_SET). Lets a set time round-trip through BDOS 105 (T_GET). */
static long clockOffset = 0;

/* Program return code, get/set via BDOS 108 (P_CODE). */
static uint16 programRetCode = 0;

/* Console mode word, get/set via BDOS 109 (C_MODE). RunCPM's console layer is
   already raw (no ^S pause, no tab expansion, no ^C termination, no ^P echo),
   so most "disable" bits are effectively always on. Bits 8-9 are honored by
   function 11 (Get console status). */
static uint16 consoleMode = 0;

void _Bdos(void) {
    uint8 ch = LOW_REGISTER(BC);

#ifdef DEBUGLOG
    _logBdosIn(ch);
#endif

    HL = 0x0000;                            // HL is reset by the BDOS
    SET_LOW_REGISTER(BC, LOW_REGISTER(DE)); // C ends up equal to E

    switch (ch) {
#ifndef ABDOS
    /*
       C = 0 : System reset
       Doesn't return. Reloads CP/M
     */
    case P_TERMCPM: {
        Status = STATUS_RESTART; // Same as call to "BOOT"
        break;
    }

    /*
       C = 1 : Console input
       Gets a char from the console
       Returns: A=Char
     */
    case C_READ: {
        HL = _getconE();
    #ifdef DEBUG
        if (HL == DEBUGKEY)
            Debug = 1;
    #endif // ifdef DEBUG
        break;
    }

    /*
       C = 2 : Console output
       E = Char
       Sends the char in E to the console
     */
    case C_WRITE: {
        _putcon(LOW_REGISTER(DE));
        break;
    }

    /*
       C = 3 : Auxiliary (Reader) input
       Returns: A=Char
     */
    case A_READ: {
        HL = 0x1a;
        break;
    }

    /*
       C = 4 : Auxiliary (Punch) output
     */
    case A_WRITE: {
    #ifdef USE_PUN
        if (!pun_open) {
            pun_dev = _sys_fopen_w((uint8 *)pun_file);
            pun_open = TRUE;
        }
        if (pun_dev) {
            _sys_fputc(LOW_REGISTER(DE), pun_dev);
        }
    #endif // ifdef USE_PUN
        break;
    }

    /*
       C = 5 : Printer output
     */
    case L_WRITE: {
    #ifdef USE_LST
        if (!lst_open) {
            lst_dev = _sys_fopen_w((uint8 *)lst_file);
            lst_open = TRUE;
        }
        if (lst_dev)
            _sys_fputc(LOW_REGISTER(DE), lst_dev);
    #endif // ifdef USE_LST
        break;
    }

    /*
       C = 6 : Direct console IO
       E = 0xFF : Checks for char available and returns it, or 0x00 if none (read)
       E = 0xFE : Return console input status. Zero if no character is waiting, nonzero otherwise. (CPM3)
       E = 0xFD : Wait until a character is ready, return it without echoing. (CPM3)
       E = char : Outputs char (write)
       Returns: A=Char or 0x00 (on read)
     */
    case C_RAWIO: {
        uint8 e = LOW_REGISTER(DE);
        if (e == 0xFF) {
            // Check for char available and return it, or 0x00 if none (non-blocking read)
            HL = _getconNB();
    #ifdef DEBUG
            if (HL == DEBUGKEY)
                Debug = 1;
    #endif // ifdef DEBUG
    #ifdef CPM3
        } else if (e == 0xFE) {
            // Return console input status. Zero if no character is waiting, nonzero otherwise. (CPM3)
            HL = _chready() ? 0x00FF : 0x0000;
        } else if (e == 0xFD) {
            // Wait until a character is ready, return it without echoing. (CPM3)
            HL = _getcon();
    #ifdef DEBUG
            if (HL == DEBUGKEY)
                Debug = 1;
    #endif // ifdef DEBUG
    #endif // ifdef CPM3
        } else {
            // E = char : Outputs char (write)
            _putcon(e);
        }
        break;
    }

    /*
       C = 7 : Get IOBYTE (CPM2)
       Gets the system IOBYTE
       Returns: A = IOBYTE (CPM2)
       C = 7 : Auxiliary Input status (CPM3)
       0FFh is returned if the Auxiliary Input device has a character ready; otherwise 0 is returned.
       Returns: A=0 or 0FFh (CPM3)
     */
    case A_STATIN: {
        #ifdef CPM3
            HL = _chready() ? 0xFF : 0x00;
        #else
            HL = _RamRead(0x0003);
        #endif
        break;
    }

    /*
       C = 8 : Set IOBYTE (CPM2)
       E = IOBYTE
       Sets the system IOBYTE to E
       C = 8 : Auxiliary Output status (CPM3)
       0FFh is returned if the Auxiliary Output device is ready for characters; otherwise 0 is returned.
       Returns: A=0 or 0FFh (CPM3)
     */
    case A_STATOUT: {
        #ifdef CPM3
            HL = 0xFF; // Auxiliary Output device is always ready
        #else
            _RamWrite(0x0003, LOW_REGISTER(DE));
        #endif
        break;
    }

    /*
       C = 9 : Output string
       DE = Address of string
       Sends the $ terminated string pointed by (DE) to the screen
       Under CP/M 3 the termination character can be changed by the user via BDOS call 110 (C_DELIMIT).
     */
    case C_WRITESTR: {
        uint8 delim = outputDelimiter;
        while ((ch = _RamRead(DE++)) != delim)
            _putcon(ch);
        break;
    }

    /*
       C = 10 (0Ah) : Buffered input
       CP/M 2: 
        DE = Address of buffer
       CP/M 3:
        DE = Address of buffer
        DE = 0 Use DMA address abd the buffer already contains data
            if DE=address:
                buffer: DEFB    size
                        DEFB    ?
                        DEFB    bytes
            if DE=0:
                buffer: DEFB    size
                        DEFB    len
                        DEFB    bytes

            Reads (DE) bytes from the console
       Returns: A = Number of chars read
       DE) = First char
     */
    case C_READSTR: {
        uint16 i;
        uint8 j, chr;
        // Under CP/M3 DE==0 means use the DMA buffer. Compute a common base address
        // so the rest of the code can operate on either DE-provided buffer or DMA.
        uint16 bufBase = (WORD16(DE) == 0) ? dmaAddr : WORD16(DE);
        uint16 chrsMaxIdx = bufBase;                // index to max number of characters
        uint16 chrsCntIdx = (chrsMaxIdx + 1) & 0xFFFF; // index to number of characters read
        uint16 chrsIdx = (chrsCntIdx + 1) & 0xFFFF;    // index to characters
        // printf("\n\r chrsMaxIdx: %0X, chrsCntIdx: %0X", chrsMaxIdx, chrsCntIdx);

        static uint8 *last = 0;
        if (!last)
            last = (uint8 *)calloc(1, 256); // allocate one (for now!)

    #ifdef PROFILE
        if (time_start != 0) {
            time_now = millis();
            printf(" (%ld)\n", time_now - time_start);
            time_start = 0;
        }
    #endif                                    // ifdef PROFILE
        uint8 chrsMax = _RamRead(chrsMaxIdx); // Gets the max number of characters that can be read
        uint8 chrsCnt = 0;                    // this is the number of characters read
    #ifdef CPM3
        // CP/M3 behaviour: if DE==0 the DMA buffer may already contain data
        // Layout when DE==0: [size][len][bytes...]
        if (WORD16(DE) == 0) {
            uint8 existingLen = _RamRead(chrsCntIdx);
            if (existingLen) { // buffer already contains data, return immediately
                HL = existingLen;
                break;
            }
            // otherwise fall through and fill the DMA buffer interactively
        }
    #endif // ifdef CPM3
        uint8 curCol = 0;                     // this is the cursor column (relative to where it started)

        while (chrsMax) {
            // pre-backspace, retype & post backspace counts
            uint8 preBS = 0, reType = 0, postBS = 0;

            chr = _getcon(); // input a character

            if (chr == 1) { // ^A - Move cursor one character to the left
                if (curCol > 0) {
                    preBS++; // backspace one
                } else {
                    _putcon('\007'); // ring the bell
                }
            }

            if (chr == 2) { // ^B - Toggle between beginning & end of line
                if (curCol) {
                    preBS = curCol; // move to beginning
                } else {
                    reType = chrsCnt - curCol; // move to EOL
                }
            }

            if ((chr == 3) && (chrsCnt == 0)) { // ^C - Abort string input
                _puts("^C");
                Status = STATUS_RESTART;
                break;
            }

    #ifdef DEBUG
            if (chr == DEBUGKEY) { // Enter debugger
                Debug = 1;
                break;
            }
    #endif // ifdef DEBUG

            if (chr == 5) { // ^E - goto beginning of next line
                _putcon('\n');
                preBS = curCol;
                reType = postBS = chrsCnt;
            }

            if (chr == 6) { // ^F - Move the cursor one character forward
                if (curCol < chrsCnt) {
                    reType++;
                } else {
                    _putcon('\007'); // ring the bell
                }
            }

            if (chr == 7) { // ^G - Delete character at cursor
                if (curCol < chrsCnt) {
                    // delete this character from buffer
                    for (i = curCol, j = i + 1; j < chrsCnt; i++, j++) {
                        ch = _RamRead(((chrsIdx + j) & 0xFFFF));
                        _RamWrite((chrsIdx + i) & 0xFFFF, ch);
                    }
                    reType = postBS = chrsCnt - curCol;
                    chrsCnt--;
                } else {
                    _putcon('\007'); // ring the bell
                }
            }

            if (((chr == 0x08) || (chr == 0x7F))) { // ^H and DEL - Delete one character to left of cursor
                if (curCol > 0) {                   // not at BOL
                    if (curCol < chrsCnt) {         // not at EOL
                        // delete previous character from buffer
                        for (i = curCol, j = i - 1; i < chrsCnt; i++, j++) {
                            ch = _RamRead(((chrsIdx + i) & 0xFFFF));
                            _RamWrite((chrsIdx + j) & 0xFFFF, ch);
                        }
                        preBS++; // pre-backspace one
                        // note: does one extra to erase EOL
                        reType = postBS = chrsCnt - curCol + 1;
                    } else {
                        preBS = reType = postBS = 1;
                    }
                    chrsCnt--;
                } else {
                    _putcon('\007'); // ring the bell
                }
            }

            if ((chr == 0x0A) || (chr == 0x0D)) { // ^J and ^M - Ends editing
    #ifdef PROFILE
                time_start = millis();
    #endif
                break;
            }

            if (chr == 0x0B) { // ^K - Delete to EOL from cursor
                if (curCol < chrsCnt) {
                    reType = postBS = chrsCnt - curCol;
                    chrsCnt = curCol; // truncate buffer to here
                } else {
                    _putcon('\007'); // ring the bell
                }
            }

            if (chr == 18) { // ^R - Retype the command line
                _puts("#\b\n");
                preBS = curCol;            // backspace to BOL
                reType = chrsCnt;          // retype everything
                postBS = chrsCnt - curCol; // backspace to cursor column
            }

            if (chr == 21) { // ^U - delete all characters
                _puts("#\b\n");
                preBS = curCol; // backspace to BOL
                chrsCnt = 0;
            }

            if (chr == 23) {   // ^W - recall last command
                if (!curCol) { // if at beginning of command line
                    uint8 lastCnt = last[0];
                    if (lastCnt) { // and there's a last command
                        // restore last command
                        for (j = 0; j <= lastCnt; j++) {
                            _RamWrite((chrsCntIdx + j) & 0xFFFF, last[j]);
                        }
                        // retype to greater of chrsCnt & lastCnt
                        reType = (chrsCnt > lastCnt) ? chrsCnt : lastCnt;
                        chrsCnt = lastCnt; // this is the restored length
                        // backspace to end of restored command
                        postBS = reType - chrsCnt;
                    } else {
                        _putcon('\007'); // ring the bell
                    }
                } else if (curCol < chrsCnt) { // if not at EOL
                    reType = chrsCnt - curCol; // move to EOL
                }
            }

            if (chr == 24) { // ^X - delete all character left of the cursor
                if (curCol > 0) {
                    // move rest of line to beginning of line
                    for (i = 0, j = curCol; j < chrsCnt; i++, j++) {
                        ch = _RamRead(((chrsIdx + j) & 0xFFFF));
                        _RamWrite((chrsIdx + i) & 0xFFFF, ch);
                    }
                    preBS = curCol;
                    reType = chrsCnt;
                    postBS = chrsCnt;
                    chrsCnt -= curCol;
                } else {
                    _putcon('\007'); // ring the bell
                }
            }

            if (chr == 31) { // ^? - help
                _puts("\n\r^A Left  ^B B/EOL ^C Abort ^E N/Lin ^F Right ^G Del@C ^H/Del BackSp\n\r");
                _puts("^K DelEOL ^R Retype ^U DelAll ^W Recall ^X DelBOL ^? Help\n\r");
                preBS = curCol;            // backspace to BOL
                reType = chrsCnt;          // retype everything
                postBS = chrsCnt - curCol; // backspace to cursor column
            }

            if (((chr >= 0x20) && (chr <= 0x7E)) || (chr == 0x1A)) { // valid character (allow ^Z)
                if (curCol < chrsCnt) {
                    // move rest of buffer one character right
                    for (i = chrsCnt, j = i - 1; i > curCol; i--, j--) {
                        ch = _RamRead(((chrsIdx + j) & 0xFFFF));
                        _RamWrite((chrsIdx + i) & 0xFFFF, ch);
                    }
                }
                // put the new character in the buffer
                _RamWrite((chrsIdx + curCol) & 0xffff, chr);

                chrsCnt++;
                reType = chrsCnt - curCol;
                postBS = reType - 1;
            }

            // pre-backspace
            for (i = 0; i < preBS; i++) {
                _putcon('\b');
                curCol--;
            }

            // retype
            for (i = 0; i < reType; i++) {
                if (curCol < chrsCnt) {
                    ch = _RamRead(((chrsIdx + curCol) & 0xFFFF));
                } else {
                    ch = ' ';
                }
                _putcon(ch);
                curCol++;
            }

            // post-backspace
            for (i = 0; i < postBS; i++) {
                _putcon('\b');
                curCol--;
            }

            if (chrsCnt == chrsMax) // Reached the maximum count
                break;
        } // while (chrsMax)

        // Save the number of characters read
        _RamWrite(chrsCntIdx, chrsCnt);

        // Return the number of characters read in A (low byte of HL)
        HL = chrsCnt;

        // if there are characters...
        if (chrsCnt) {
            //... then save this as last command
            for (j = 0; j <= chrsCnt; j++) {
                last[j] = _RamRead((chrsCntIdx + j) & 0xFFFF);
            }
        }
        _putcon('\r'); // Gives a visual feedback that read ended
        break;
    }

    /*
       C = 11 (0Bh) : Get console status
       Returns: A=0x00 or 0xFF
       Under CP/M3 the console mode (BDOS 109) bits 8-9 override the result:
       1 = always ready, 2 = never ready, 0/3 = normal hardware status.
     */
    case C_STAT: {
#ifdef CPM3
        uint8 sub = (consoleMode >> 8) & 0x03;
        if (sub == 1) {
            HL = 0xFF; // always returns true
            break;
        }
        if (sub == 2) {
            HL = 0x00; // always returns false
            break;
        }
#endif
        HL = _chready();
        break;
    }
#endif // ABDOS

    /*
       C = 12 (0Ch) : Get version number
       Returns: B=H=system type, A=L=version number
     */
    case S_BDOSVER: {
        #ifdef CPM3
            HL = 0x31;
        #else
            HL = 0x22;
        #endif
        break;
    }

    /*
       C = 13 (0Dh) : Reset disk system
     */
    case DRV_ALLRESET: {
        roVector = 0; // Make all drives R/W
        loginVector = 0;
        dmaAddr = 0x0080;
        multiRecordCount = 1; // CP/M 3 BDOS resets multi-sector count on system reset
        cDrive = 0;           // userCode remains unchanged
        HL = _CheckSUB();     // Checks if there's a $$$.SUB on the boot disk
        break;
    }

    /*
       C = 14 (0Eh) : Select Disk
       Returns: A=0x00 or 0xFF
     */
    case DRV_SET: {
        oDrive = cDrive;
        cDrive = LOW_REGISTER(DE);
        HL = _SelectDisk(LOW_REGISTER(DE) + 1); // +1 here is to allow SelectDisk to be used directly by disk.h as well
        if (!HL) {
            oDrive = cDrive;
        } else {
            if ((_RamRead(DSKByte) & 0x0f) == cDrive) {
                cDrive = oDrive = 0;
                _RamWrite(DSKByte, _RamRead(DSKByte) & 0xf0);
            } else {
                cDrive = oDrive;
            }
        }
        break;
    }

    /*
       C = 15 (0Fh) : Open file
       Entered with DE = address of FCB.
       Returns: A = 0xFF on error or 0-3 on success (CP/M3 semantics).
       On CP/M 3, a hardware error (when A=0xFF) may be returned in B/H.
       If FCB->cr is 0xFF on entry, on return FCB->cr will contain the
       last-record byte count (LRBC).
     */
    case F_OPEN: {
        HL = _OpenFile(DE);
        break;
    }

    /*
       C = 16 (10h) : Close file
       Entered with DE = address of FCB.
       Returns: A = 0xFF on error or 0-3 on success.
       On CP/M 3: If F5' (top bit of the 5th filename byte) is set then pending data
       are written and the file remains open.
       If A=0xFF, H/B contain hardware error.
     */
    case F_CLOSE: {
        HL = _CloseFile(DE);
        break;
    }

    /*
       C = 17 (11h) : Search for first
     */
    case F_SFIRST: {
        HL = _SearchFirst(DE, TRUE); // TRUE = Creates a fake dir entry when finding the file
        break;
    }

    /*
       C = 18 (12h) : Search for next
     */
    case F_SNEXT: {
        HL = _SearchNext(DE, TRUE); // TRUE = Creates a fake dir entry when finding the file
        break;
    }

    /*
       C = 19 (13h) : Delete file
     */
    case F_DELETE: {
        HL = _DeleteFile(DE);
        break;
    }

    /*
       C = 20 (14h) : Read sequential
       DE = address of FCB
       ToDo under CP/M 3 this can be a multiple of 128 bytes
       Returns: A = return code
     */
    case F_READ: {
        HL = _ReadSeq(DE);
        break;
    }

    /*
       C = 21 (15h) : Write sequential
       DE = address of FCB
       ToDo under CP/M 3 this can be a multiple of 128 bytes
       Returns: A=return code
       */
    case F_WRITE: {
        HL = _WriteSeq(DE);
        break;
    }

    /*
       C = 22 (16h) : Make file
     */
    case F_MAKE: {
        HL = _MakeFile(DE);
        break;
    }

    /*
       C = 23 (17h) : Rename file
     */
    case F_RENAME: {
        HL = _RenameFile(DE);
        break;
    }

    /*
       C = 24 (18h) : Return log-in vector (active drive map)
     */
    case DRV_LOGINVEC: {
        HL = loginVector; // (todo) improve this
        break;
    }

    /*
       C = 25 (19h) : Return current disk
     */
    case DRV_GET: {
        HL = cDrive;
        break;
    }

    /*
       C = 26 (1Ah) : Set DMA address
     */
    case F_DMAOFF: {
        dmaAddr = DE;
        break;
    }

    /*
       C = 27 (1Bh) : Get ADDR(Alloc)
     */
    case DRV_ALLOCVEC: {
        HL = SCBaddr;
        break;
    }

    /*
       C = 28 (1Ch) : Write protect current disk
     */
    case DRV_SETRO: {
        roVector = roVector | (1 << cDrive);
        break;
    }

    /*
       C = 29 (1Dh) : Get R/O vector
     */
    case DRV_ROVEC: {
        HL = roVector;
        break;
    }

    /*
       C = 30 (1Eh) : Set file attributes (does nothing)
     */
    case F_ATTRIB: {
        HL = 0;
        break;
    }

    /*
       C = 31 (1Fh) : Get ADDR(Disk Parms)
     */
    case DRV_PDB: {
        HL = DPBaddr;
        break;
    }

    /*
       C = 32 (20h) : Get/Set user code
     */
    case F_USERNUM: {
        if (LOW_REGISTER(DE) == 0xFF) {
            HL = userCode;
        } else {
            _SetUser(DE);
        }
        break;
    }

    /*
       C = 33 (21h) : Read random
       ToDo under CPM3, if A returns 0xFF, H returns hardware error
     */
    case F_READRAND: {
        HL = _ReadRand(DE);
        break;
    }

    /*
       C = 34 (22h) : Write random
       ToDo under CPM3, if A returns 0xFF, H returns hardware error
       */
    case F_WRITERAND: {
        HL = _WriteRand(DE);
        break;
    }

    /*
       C = 35 (23h) : Compute file size
     */
    case F_SIZE: {
        HL = _GetFileSize(DE);
        break;
    }

    /*
       C = 36 (24h) : Set random record
     */
    case F_RANDREC: {
        HL = _SetRandom(DE);
        break;
    }

    /*
       C = 37 (25h) : Reset drive
     */
    case DRV_RESET: {
        roVector = roVector & ~DE;
        break;
    }

    /*
      ToDo C = 38 (26h) : Access drives (CPM3)
        This is an MP/M function that is not supported under CP/M 3. If called, the file
         system returns a zero In register A indicating that the access request is successful.
     */
    case DRV_ACCESS_MPM: {
        HL = 0x0000;
        break;
    }

    /*
      ToDo C = 39 (27h) : Free drives (CPM3)
        This is an MP/M function that is not supported under CP/M 3. If called, the file
         system returns a zero In register A indicating that the access request is successful.
     */
    case DRV_FREE_MPM: {
        HL = 0x0000;
        break;
    }

    /*
       C = 40 (28h) : Write random with zero fill (we have no disk blocks, so just write random)
       DE = address of FCB
       Returns: A = return code
                H = Physical Error
     */
    case F_WRITEZF: {
        HL = _WriteRand(DE);
        break;
    }

    /*
       ToDo: C = 41 (29h) : Test and Write Record (CPM3)
       DE = address of FCB
       Returns: A = return code
                H = Physical Error
     */
    case F_TESTWRITE: {
        break;
    }

    /*
       ToDo: C = 42 (2Ah) : Lock Record (CPM3)
       DE = address of FCB
       Returns: A = return code
                H = Physical Error
     */
    case F_LOCKFILE: {
        break;
    }

    /*
       ToDo: C = 43 (2Bh) : Unlock Record (CPM3)
       DE = address of FCB
       Returns: A = return code
                H = Physical Error
     */
    case F_UNLOCKFILE: {
        break;
    }

    /*
       C = 44 (2Ch) : Set number of records to read/write at once (CPM3)
       E = Number of Sectors
       Returns: A = return code (Returns A=0 if E was valid, 0FFh otherwise)
     */
    case F_MULTISEC: {
#ifdef CPM3
        {
            uint8 e = LOW_REGISTER(DE);
            if ((e >= 1) && (e <= 127)) {
                multiRecordCount = e;
                HL = 0x0000; /* A = 0 => OK */
            } else {
                HL = 0x00FF; /* A = 0xFF => invalid */
            }
        }
#else
        /* Not supported under CP/M 2.2 */
        HL = 0x00FF;
#endif
        break;
    }

    /*
       ToDo: C = 45 (2Dh) : Set BDOS Error Mode (CPM3)
       E = BDOS Error Mode
       E < 254 Compatibility mode; program is terminated and an error message printed.
       E = 254 Error code is returned in H, error message is printed.
       E = 255 Error code is returned in H, no error message is printed.
       Returns: None
     */
    case F_ERRMODE: {
        break;
    }

    /*
       ToDo: C = 46 (2Eh) : Get Free Disk Space (CPM3)
       E = Drive
       Returns: A = return code
                H = Physical Error
                Binary result in the first 3 bytes of current DMA buffer
     */
    case DRV_SPACE: {
        break;
    }

    /*
       C = 47 (2Fh) : Chain to program (CPM3)
       E = Chain flag (0xFF = pass current drive/user to the chained program,
           otherwise the chained program starts at drive A: user 0)
       The command line to run is stored null-terminated in the default DMA
       buffer (0x0080). The call does not return to the caller: it warm boots
       and the CCP runs the chained command.
     */
    case P_CHAIN: {
#ifdef CPM3
        uint16 src = 0x0080;
        uint8 n = 0;
        uint8 c;
        while (n < (uint8)(sizeof(chainCmd) - 1) && (c = _RamRead(src + n)) != 0) {
            chainCmd[n] = c;
            ++n;
        }
        chainCmd[n] = 0;
        chainLoad = 1;
        if (LOW_REGISTER(DE) != 0xFF) { // do not inherit drive/user
            userCode = 0;
            cDrive = oDrive = 0;
            _RamWrite(DSKByte, 0x00);
        }
        Status = STATUS_RESTART; // warm boot into the CCP
#endif
        break;
    }

    /*
       C = 48 (30h) : Flush Buffers (CPM3)
       E = Purge flag
       Returns: A = return code (0 = OK)
                H = Physical Error
       RunCPM opens, writes and closes each file record individually, so regular
       file data is already on disk. The only host buffers held open across calls
       are the LST: and PUN: device streams - flush those.
     */
    case DRV_FLUSH: {
#ifdef USE_LST
        if (lst_open)
            _sys_fflush(lst_dev);
#endif
#ifdef USE_PUN
        if (pun_open)
            _sys_fflush(pun_dev);
#endif
        HL = 0x0000; // A = 0 (OK), H = 0 (no physical error)
        break;
    }

    /*
       C = 49 (31h) : Get/Set System Control (CPM3)
       DE = SCB PB Address. SCBPB layout (bytes):
         +0 offset (0-99 into the SCB)
         +1 set    (0xFF = set byte, 0xFE = set word, anything else = get)
         +2 value  (byte or word to store when setting)
       Returns: A = byte at offset, HL = word at offset (on get).
                The BDOS forces A = low byte of HL on return, so the byte
                value naturally falls out of HL's low half.
     */
    case S_SCB: {
        uint16 pb = DE;
        uint8 offset = _RamRead(pb + 0);
        uint8 set = _RamRead(pb + 1);
        if (set == 0xFF) {                  // set byte
            _RamWrite(SCBaddr + offset, _RamRead(pb + 2));
        } else if (set == 0xFE) {           // set word
            _RamWrite16(SCBaddr + offset, _RamRead16(pb + 2));
        } else {                            // get byte/word
            HL = _RamRead16(SCBaddr + offset);
        }
        break;
    }

    /*
       C = 50 (32h) : Direct BIOS Calls (CPM3)
       DE = BIOS PB Address. BIOSPB layout (bytes):
         +0 func (logical BIOS fn 0-32)  +1 A  +2 C  +3 B  +4 E  +5 D  +6 L  +7 H
       Returns: for SELDSK(9)/SECTRAN(16)/DEVTBL(20)/DRVTBL(22) the BIOS HL result
       in HL (and A=L, B=H); for every other function the BIOS A result in A and L.
     */
    case S_BIOS: {
#ifdef CPM3
        uint16 pb = DE;
        uint8 fn = _RamRead(pb + 0); // logical BIOS function number
        uint16 oldPC = PCX;

        // Load the Z80 registers the BIOS will see from the parameter block.
        // BC/DE/HL are stored low-byte-first, so _RamRead16 reads them directly.
        SET_HIGH_REGISTER(AF, _RamRead(pb + 1)); // A
        BC = _RamRead16(pb + 2);                 // C,B
        DE = _RamRead16(pb + 4);                 // E,D
        HL = _RamRead16(pb + 6);                 // L,H

        // _Bios() dispatches on the low byte of PC, which equals (function * 3),
        // i.e. the BIOS jump-table offset (B_WBOOT=3, B_SELMEM=81, ...).
        SET_LOW_REGISTER(PCX, (uint8)(fn * 3));
        _Bios();
        PCX = oldPC; // restore PC so the caller resumes correctly

        // Map the BIOS return onto the BDOS return convention (A=L(HL), B=H(HL)).
        // SELDSK/SECTRAN/DEVTBL/DRVTBL return in HL (leave HL as the BIOS set it);
        // all others return in A, so place A into HL so A and L both hold it.
        if (fn != 9 && fn != 16 && fn != 20 && fn != 22)
            HL = HIGH_REGISTER(AF);
#endif // ifdef CPM3
        break;
    }

    /*
       ToDo: C = 59 (3Bh) : Load Overlay (CPM3)
       DE = address of FCB
       Returns: A = return code
                H = Physical Error
     */
    case P_LOAD: {
        break;
    }

    /*
       C = 60 (3Ch) : Call Resident System Extension (RSX) (CPM3)
       DE =  RSX PB Address
       Returns: A = return code
                H = Physical Error
     */
    case S_RSX: {
#ifdef CPM3
        // No RSX modules are loaded, so report the call as not handled
        // (A = 0FFh).
        HL = 0x00FF;
#endif // ifdef CPM3
        break;
    }

    /*
       ToDo: C = 98 (62h) : Free Blocks (CPM3)
       Returns: A = return code
                H = Physical Error
     */
    case F_CLEANUP: {
        break;
    }

    /*
       C = 99 (63h) : Truncate File (CPM3)
       DE = address of FCB. The random record field (r0/r1/r2) holds the new
            size in 128-byte records; the file is truncated to record * 128.
       Returns: A = Directory code (0 = OK, 0xFF = error)
                H = Extended or Physical Error
     */
    case F_TRUNCATE: {
#ifdef CPM3
        HL = _TruncateFile(DE);
#endif
        break;
    }

    /*
       ToDo: C = 100 (64h) : Set Directory Label (CPM3)
       DE = address of FCB
       Returns: A = Directory code
                H = Extended or Physical Error
     */
    case DRV_SETLABEL: {
        break;
    }

    /*
       ToDo: C = 101 (65h) : Return Directory Label Data (CPM3)
       E = Drive
       Returns: A = Directory Label Data Byte or 0xFF
                H = Physical Error
     */
    case DRV_GETLABEL: {
        break;
    }

    /*
       C = 102 (66h) : Read File Date Stamps and Password Mode (CPM3)
       DE = address of FCB
       Returns: A = Directory code (0xFF if the file was not found)
                H = Physical Error
       On success the FCB is filled in:
                FCB+9 bit7 (t1') = set if the file is read-only
                FCB+24..27      = create/access date stamp
                FCB+28..31      = update date stamp
                FCB+12 (ex)     = password mode (0, no password support here)
       Each date stamp is: day count (word, day 1 = 1978-01-01), hour (BCD),
       minute (BCD). The stamps are derived from the host file via BDOS only.
     */
    case F_TIMEDATE: {
#ifdef CPM3
        uint8 result = 0xff;
        _FCBtoHostname(DE, &filename[0]);
        unsigned long mt = _sys_filemtime(&filename[0]);
        if (mt) {
            time_t ft = (time_t)mt;
            struct tm lt = *localtime(&ft);
            struct tm base, fday;
            time_t baseNoon, fNoon;
            uint16 days;
            uint8 bh = DEC2BCD(lt.tm_hour);
            uint8 bm = DEC2BCD(lt.tm_min);
            // Whole days between the file day (noon) and 1978-01-01 (noon)
            memset(&base, 0, sizeof(base));
            base.tm_year = 78;
            base.tm_mon = 0;
            base.tm_mday = 1;
            base.tm_hour = 12;
            base.tm_isdst = -1;
            baseNoon = mktime(&base);
            fday = lt;
            fday.tm_hour = 12;
            fday.tm_min = 0;
            fday.tm_sec = 0;
            fday.tm_isdst = -1;
            fNoon = mktime(&fday);
            days = (uint16)((fNoon - baseNoon) / 86400 + 1);
            // Create/access stamp (host only exposes one timestamp, reuse it)
            _RamWrite(DE + 24, days & 0xff);
            _RamWrite(DE + 25, (days >> 8) & 0xff);
            _RamWrite(DE + 26, bh);
            _RamWrite(DE + 27, bm);
            // Update stamp
            _RamWrite(DE + 28, days & 0xff);
            _RamWrite(DE + 29, (days >> 8) & 0xff);
            _RamWrite(DE + 30, bh);
            _RamWrite(DE + 31, bm);
            // Password mode (none supported)
            _RamWrite(DE + 12, 0x00);
            // Read-only attribute lives in t1' (high bit of the first type byte)
            if (_sys_isreadonly(&filename[0]))
                _RamWrite(DE + 9, _RamRead(DE + 9) | 0x80);
            else
                _RamWrite(DE + 9, _RamRead(DE + 9) & 0x7f);
            result = 0x00;
        }
        HL = result;
#endif
        break;
    }

    /*
       ToDo: C = 103 (67h) : Write File XFCB (CPM3)
       DE = address of FCB
       Returns: A = Directory code
                H = Physical Error
     */
    case F_WRITEXFCB: {
        break;
    }

    /*
       C = 104 (68h) : Set Date and Time (CPM3)
       DE = Date and Time (DAT) Address
            DAT+0/1 = Day count (little-endian, day 1 = 1978-01-01)
            DAT+2   = Hour   (packed BCD)
            DAT+3   = Minute (packed BCD)
            DAT+4   = Second (packed BCD)
       Returns: None
     */
    case T_SET: {
        uint16 days = _RamRead(DE) | (_RamRead(DE + 1) << 8);
        uint8 hour = BCD2DEC(_RamRead(DE + 2));
        uint8 mins = BCD2DEC(_RamRead(DE + 3));
        uint8 secs = BCD2DEC(_RamRead(DE + 4));
        struct tm base;
        time_t baseT, target;
        memset(&base, 0, sizeof(base));
        base.tm_year = 78;          // 1978
        base.tm_mon = 0;            // January
        base.tm_mday = 1;           // 1st
        base.tm_hour = 12;          // noon, to avoid DST midnight ambiguity
        base.tm_isdst = -1;
        baseT = mktime(&base);
        // baseT is noon on day 1; rewind to midnight, then add the DAT fields
        target = baseT - 12 * 3600 + (time_t)(days - 1) * 86400
                 + (time_t)hour * 3600 + (time_t)mins * 60 + secs;
        clockOffset = (long)(target - time(NULL));
        break;
    }

    /*
       C = 105 (69h) : Get Date and Time (CPM3)
       DE = Date and Time (DAT) Address (filled in, same layout as T_SET)
       Returns: Date and Time (DAT) set
                A = Seconds (in packed BCD format)
     */
    case T_GET: {
        time_t now = time(NULL) + clockOffset;
        struct tm cur, base;
        time_t curNoon, baseNoon;
        uint16 days;
        uint8 hour, mins, secs;
        cur = *localtime(&now);
        hour = DEC2BCD(cur.tm_hour);
        mins = DEC2BCD(cur.tm_min);
        secs = DEC2BCD(cur.tm_sec);
        // Day count = whole days between today (noon) and 1978-01-01 (noon)
        cur.tm_hour = 12;
        cur.tm_min = 0;
        cur.tm_sec = 0;
        cur.tm_isdst = -1;
        curNoon = mktime(&cur);
        memset(&base, 0, sizeof(base));
        base.tm_year = 78;
        base.tm_mon = 0;
        base.tm_mday = 1;
        base.tm_hour = 12;
        base.tm_isdst = -1;
        baseNoon = mktime(&base);
        days = (uint16)((curNoon - baseNoon) / 86400 + 1);
        _RamWrite(DE, days & 0xFF);
        _RamWrite(DE + 1, (days >> 8) & 0xFF);
        _RamWrite(DE + 2, hour);
        _RamWrite(DE + 3, mins);
        _RamWrite(DE + 4, secs);
        HL = secs;          // A (low byte of HL) = seconds in packed BCD
        break;
    }

    /*
       ToDo: C = 106 (6Ah) : Set Default Password (CPM3)
       DE = Password Address
       Returns: None
     */
    case F_PASSWD: {
        break;
    }

    /*
       C = 107 (6Bh) : Return Serial Number (CPM3)
       DE = Serial Number Field (6 bytes)
       Returns: Serial number field set (printable ASCII)
     */
    case S_SERIAL: {
        static const uint8 serial[6] = {'R', 'u', 'n', 'C', 'P', 'M'};
        uint8 i;
        for (i = 0; i < 6; ++i)
            _RamWrite(DE + i, serial[i]);
        break;
    }

    /*
       C = 108 (6Ch) : Get/Set Program Return Code (CPM3)
       DE =  0xFFFF (Get) or Program Return Code (Set)
       Returns: HL = Program Return Code (on Get)
     */
    case P_CODE: {
        if (WORD16(DE) == 0xFFFF) {
            HL = programRetCode;
        } else {
            programRetCode = WORD16(DE);
        }
        break;
    }

    /*
       C = 109 (6Dh) : Get/Set Console Mode (CPM3)
       DE =  0xFFFF (Get) or Console Mode (Set)
       Returns: HL = Console Mode (on Get)
       Console mode bits (CP/M3): 0 = fn 11 detects only ^C, 1 = ^S no pause,
       2 = no tab expand / no ^P echo, 3 = ^C does not terminate. RunCPM's
       console is already raw, so those behaviours are intrinsic; bits 8-9 are
       acted on by function 11 (Get console status).
     */
    case C_MODE: {
        if (WORD16(DE) == 0xFFFF) {
            HL = consoleMode;
        } else {
            consoleMode = WORD16(DE);
        }
        break;
    }

    /*
       C = 110 (6Eh) : Get/Set Output Delimiter (CPM3)
       DE =  0xFFFF (Get) or E = Delimiter (Set)
       Returns: A = Output Delimiter (on Get)
       The delimiter terminates strings printed by function 9 (default '$').
     */
    case C_DELIMIT: {
        if (DE == 0xFFFF) {
            HL = outputDelimiter; // A will receive low byte of HL
        } else {
            outputDelimiter = LOW_REGISTER(DE);
        }
        break;
    }

    /*
       C = 111 (6Fh) : Print Block (CPM3)
       DE =  address of a Character Control Block (CCB):
             CCB+0 = buffer address (word)
             CCB+2 = length in bytes (word)
       Sends the block to the console using an explicit length (no delimiter).
       Returns: None
     */
    case C_WRITEBLK: {
        uint16 addr = _RamRead16(DE);
        uint16 len = _RamRead16(DE + 2);
        while (len--)
            _putcon(_RamRead(addr++));
        break;
    }

    /*
       ToDo: C = 112 (70h) : List Block (CPM3)
       DE =  address of CCB
       Returns: None
     */
    case L_WRITEBLK: {
        break;
    }

    /*
       ToDo: C = 152 (98h) : List Block (CPM3)
       DE =  address of PFCB
       Returns: HL = Return code
                Parsed file control block
     */
    case F_PARSE: {
        break;
    }

#if defined board_digital_io

    /*
       C = 220 (DCh) : PinMode
     */
    case F_PINMODE: {
        pinMode(HIGH_REGISTER(DE), LOW_REGISTER(DE));
        break;
    }

    /*
       C = 221 (DDh) : DigitalRead
     */
    case F_DREAD: {
        HL = digitalRead(HIGH_REGISTER(DE));
        break;
    }

    /*
       C = 222 (DEh) : DigitalWrite
     */
    case F_DWRITE: {
        digitalWrite(HIGH_REGISTER(DE), LOW_REGISTER(DE));
        break;
    }

    /*
       C = 223 (DFh) : AnalogRead
     */
    case F_AREAD: {
        HL = analogRead(HIGH_REGISTER(DE));
        break;
    }
#endif // if defined board_digital_io
#if defined board_analog_io

    /*
       C = 224 (E0h) : AnalogWrite
     */
    case F_AWRITE: {
        analogWrite(HIGH_REGISTER(DE), LOW_REGISTER(DE));
        break;
    }
#endif // if defined board_analog_io

    /*
       C = 230 (E6h) : Set 8 bit masking
     */
    case F_SETMASK: {
        mask8bit = LOW_REGISTER(DE);
        break;
    }

    /*
       C = 231 (E7h) : Host specific BDOS call
     */
    case F_BDOSCALL: {
        HL = hostbdos(DE);
        break;
    }

    /*
       C = 232 (E8h) : ESP32 specific BDOS call
     */
#if defined board_esp32
    case 232: {
        HL = esp32bdos(DE);
        break;
    }

#endif // if defined board_esp32
#if defined board_stm32
    case 232: {
        HL = stm32bdos(DE);
        break;
    }

#endif // if defined board_stm32

    /*
       C = 248 (F8h) : Milliseconds Uptime
       Returns the number of milliseconds (since the board started).
     */
    case F_UPTIME: {
        timer = millis();
        HL = timer & 0xFFFF;
        DE = (timer >> 16) & 0xFFFF;
        break;
    }

    /*
       C = 249 (F9h) : MakeDisk
       Makes a disk directory if not existent.
     */
    case F_MAKEDISK: {
        HL = _MakeDisk(DE);
        break;
    }

    /*
       C = 250 (FAh) : HostOS
       Returns: A = 0x00 - Windows / 0x01 - Arduino / 0x02 - Posix / 0x03 - Dos / 0x04 - Teensy / 0x05 - ESP32 / 0x06 - STM32
     */
    case F_HOSTOS: {
        HL = HostOS;
        break;
    }

    /*
       C = 251 (FBh) : Version
       Returns: A = 0xVv - Version in BCD representation: V.v
     */
    case F_VERSION: {
        HL = VersionBCD;
        break;
    }

    /*
       C = 252 (FCh) : CCP version
       Returns: A = 0x00-0x04 = DRI|CCPZ|ZCPR2|ZCPR3|Z80CCP / 0xVv = Internal version in BCD: V.v
     */
    case F_CCPVERSION: {
        HL = VersionCCP;
        break;
    }

    /*
       C = 253 (FDh) : CCP address
     */
    case F_CCPADDR: {
        HL = CCPaddr;
        break;
    }

    /*
       C = 254 (FEh) : Set CPU speed
       DE = Number of instructions to trigger the delay
    */
    case F_SETCPUSPEED: {
        cpuDelayInstructions = DE;
        break;
    }

    /*
       Unimplemented calls get listed
     */
    default: {
#ifdef DEBUG // Show unimplemented BDOS calls only when debugging
        _puts("\r\nUnimplemented BDOS call.\r\n");
        _puts("C = 0x");
        _puthex8(ch);
        _puts("\r\n");
#endif // ifdef DEBUG
        break;
    }
    } // switch

    // CP/M BDOS does this before returning
    SET_HIGH_REGISTER(BC, HIGH_REGISTER(HL));
    SET_HIGH_REGISTER(AF, LOW_REGISTER(HL));

#ifdef DEBUGLOG
    _logBdosOut(ch);
#endif
} // _Bdos

#endif // ifndef CPM_H