disz80.c

/*  Z80 disassembler

*** Copyright:  1994-1996 Günter Woigk
mailto:kio@little-bat.de

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

Permission to use, copy, modify, distribute, and sell this software and
its documentation for any purpose is hereby granted without fee, provided
that the above copyright notice appear in all copies and that both that
copyright notice and this permission notice appear in supporting
documentation, and that the name of the copyright holder not be used
in advertising or publicity pertaining to distribution of the software
without specific, written prior permission.  The copyright holder makes no
representations about the suitability of this software for any purpose.
It is provided "as is" without express or implied warranty.

THE COPYRIGHT HOLDER DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY SPECIAL, INDIRECT OR
CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
PERFORMANCE OF THIS SOFTWARE.

30.Jan.95:  Started work on disassembler stuff                  KIO !
02.Jun.95:  Reworked completely                                 KIO !
20.Oct.01   revised for CW7Pro and ANSI C compliance            hdusel@bnv-gz.de
*/

#include <string.h>
#include <avr/pgmspace.h>

#include "AtomBusMon.h"

#define legal       0
#define illegal     1
#define weird       2

#undef  RR
#undef  IM
#undef  RH
#undef  RL
#undef  BC
#undef  DE
#undef  HL
#undef  IX
#undef  IY
#undef  SP
#undef  PC
#undef  XH
#undef  XL
#undef  YH
#undef  YL
#undef  ADC

// ---- opcode definitions ------------------------------------------------------------------

enum {
  NIX,    NOP,    LD,     INC,    DEC,    RLCA,   EX,     ADD,
  RRCA,   DJNZ,   RLA,    JR,     RRA,    DAA,    CPL,    HALT,
  SCF,    CCF,    RLC,    RRC,    RL,     RR,     SLA,    SRA,
  SLL,    SRL,    IN,     OUT,    SBC,    NEG,    RETN,   IM,
  ADC,    RETI,   RRD,    RLD,    SUB,    AND,    XOR,
  OR,     CP,     BIT,    RES,    SET,    LDI,    CPI,    INI,
  OUTI,   LDD,    CPD,    IND,    OUTD,   LDIR,   CPIR,   INIR,
  OTIR,   LDDR,   CPDR,   INDR,   OTDR,   RET,    POP,    JP,
  CALL,   PUSH,   RST,    PFX,    EXX,    DI,     EI,
  BC,     DE,     HL,     IX,     IY,     SP,     AF,     AF2,
  B,      C,      D,      E,      H,      L,      XHL,    A,      // <- KEEP THIS ORDER!
  XBC,    XDE,    R,      I,      XC,     XSP,    PC,     F,
  N0,     N1,     N2,     N3,     N4,     N5,     N6,     N7,
  Z,      NZ,     NC,     PO,     PE,     M,      P,
  N,      NN,     XNN,    XN,     DIS,    CB,     ED,
  XH,     XL,     YH,     YL,     XIX,    XIY
};

static const char word_NIX[] PROGMEM = "";
static const char word_NOP[] PROGMEM = "NOP";
static const char word_LD[] PROGMEM = "LD";
static const char word_INC[] PROGMEM = "INC";
static const char word_DEC[] PROGMEM = "DEC";
static const char word_RLCA[] PROGMEM = "RLCA";
static const char word_EX[] PROGMEM = "EX";
static const char word_ADD[] PROGMEM = "ADD";
static const char word_RRCA[] PROGMEM = "RRCA";
static const char word_DJNZ[] PROGMEM = "DJNZ";
static const char word_RLA[] PROGMEM = "RLA";
static const char word_JR[] PROGMEM = "JR";
static const char word_RRA[] PROGMEM = "RRA";
static const char word_DAA[] PROGMEM = "DAA";
static const char word_CPL[] PROGMEM = "CPL";
static const char word_HALT[] PROGMEM = "HALT";
static const char word_SCF[] PROGMEM = "SCF";
static const char word_CCF[] PROGMEM = "CCF";
static const char word_RLC[] PROGMEM = "RLC";
static const char word_RRC[] PROGMEM = "RRC";
static const char word_RL[] PROGMEM = "RL";
static const char word_RR[] PROGMEM = "RR";
static const char word_SLA[] PROGMEM = "SLA";
static const char word_SRA[] PROGMEM = "SRA";
static const char word_SLL[] PROGMEM = "SLL";
static const char word_SRL[] PROGMEM = "SRL";
static const char word_IN[] PROGMEM = "IN";
static const char word_OUT[] PROGMEM = "OUT";
static const char word_SBC[] PROGMEM = "SBC";
static const char word_NEG[] PROGMEM = "NEG";
static const char word_RETN[] PROGMEM = "RETN";
static const char word_IM[] PROGMEM = "IM";
static const char word_ADC[] PROGMEM = "ADC";
static const char word_RETI[] PROGMEM = "RETI";
static const char word_RRD[] PROGMEM = "RRD";
static const char word_RLD[] PROGMEM = "RLD";
static const char word_SUB[] PROGMEM = "SUB";
static const char word_AND[] PROGMEM = "AND";
static const char word_XOR[] PROGMEM = "XOR";
static const char word_OR[] PROGMEM = "OR";
static const char word_CP[] PROGMEM = "CP";
static const char word_BIT[] PROGMEM = "BIT";
static const char word_RES[] PROGMEM = "RES";
static const char word_SET[] PROGMEM = "SET";
static const char word_LDI[] PROGMEM = "LDI";
static const char word_CPI[] PROGMEM = "CPI";
static const char word_INI[] PROGMEM = "INI";
static const char word_OUTI[] PROGMEM = "OUTI";
static const char word_LDD[] PROGMEM = "LDD";
static const char word_CPD[] PROGMEM = "CPD";
static const char word_IND[] PROGMEM = "IND";
static const char word_OUTD[] PROGMEM = "OUTD";
static const char word_LDIR[] PROGMEM = "LDIR";
static const char word_CPIR[] PROGMEM = "CPIR";
static const char word_INIR[] PROGMEM = "INIR";
static const char word_OTIR[] PROGMEM = "OTIR";
static const char word_LDDR[] PROGMEM = "LDDR";
static const char word_CPDR[] PROGMEM = "CPDR";
static const char word_INDR[] PROGMEM = "INDR";
static const char word_OTDR[] PROGMEM = "OTDR";
static const char word_RET[] PROGMEM = "RET";
static const char word_POP[] PROGMEM = "POP";
static const char word_JP[] PROGMEM = "JP";
static const char word_CALL[] PROGMEM = "CALL";
static const char word_PUSH[] PROGMEM = "PUSH";
static const char word_RST[] PROGMEM = "RST";
static const char word_PFX[] PROGMEM = "PREFIX";
static const char word_EXX[] PROGMEM = "EXX";
static const char word_DI[] PROGMEM = "DI";
static const char word_EI[] PROGMEM = "EI";
static const char word_BC[] PROGMEM = "BC";
static const char word_DE[] PROGMEM = "DE";
static const char word_HL[] PROGMEM = "HL";
static const char word_IX[] PROGMEM = "IX";
static const char word_IY[] PROGMEM = "IY";
static const char word_SP[] PROGMEM = "SP";
static const char word_AF[] PROGMEM = "AF";
static const char word_AF2[] PROGMEM = "AF'";
static const char word_B[] PROGMEM = "B";
static const char word_C[] PROGMEM = "C";
static const char word_D[] PROGMEM = "D";
static const char word_E[] PROGMEM = "E";
static const char word_H[] PROGMEM = "H";
static const char word_L[] PROGMEM = "L";
static const char word_XHL[] PROGMEM = "(HL)";
static const char word_A[] PROGMEM = "A";
static const char word_XBC[] PROGMEM = "(BC)";
static const char word_XDE[] PROGMEM = "(DE)";
static const char word_R[] PROGMEM = "R";
static const char word_I[] PROGMEM = "I";
static const char word_XC[] PROGMEM = "(C)";
static const char word_XSP[] PROGMEM = "(SP)";
static const char word_PC[] PROGMEM = "PC";
static const char word_F[] PROGMEM = "F";
static const char word_N0[] PROGMEM = "0";
static const char word_N1[] PROGMEM = "1";
static const char word_N2[] PROGMEM = "2";
static const char word_N3[] PROGMEM = "3";
static const char word_N4[] PROGMEM = "4";
static const char word_N5[] PROGMEM = "5";
static const char word_N6[] PROGMEM = "6";
static const char word_N7[] PROGMEM = "7";
static const char word_Z[] PROGMEM = "Z";
static const char word_NZ[] PROGMEM = "NZ";
static const char word_NC[] PROGMEM = "NC";
static const char word_PO[] PROGMEM = "PO";
static const char word_PE[] PROGMEM = "PE";
static const char word_M[] PROGMEM = "M";
static const char word_P[] PROGMEM = "P";
static const char word_N[] PROGMEM = "N";
static const char word_NN[] PROGMEM = "NN";
static const char word_XNN[] PROGMEM = "XNN";
static const char word_XN[] PROGMEM = "XN";
static const char word_DIS[] PROGMEM = "DIS";
static const char word_CB[] PROGMEM = "CB";
static const char word_ED[] PROGMEM = "ED";
static const char word_XH[] PROGMEM = "XH";
static const char word_XL[] PROGMEM = "XL";
static const char word_YH[] PROGMEM = "YH";
static const char word_YL[] PROGMEM = "YL";
static const char word_XIX[] PROGMEM = "DIS(IX)";
static const char word_XIY[] PROGMEM = "DIS(IY)";

static const char * const word[] PROGMEM =
  {
    word_NIX,
    word_NOP,
    word_LD,
    word_INC,
    word_DEC,
    word_RLCA,
    word_EX,
    word_ADD,
    word_RRCA,
    word_DJNZ,
    word_RLA,
    word_JR,
    word_RRA,
    word_DAA,
    word_CPL,
    word_HALT,
    word_SCF,
    word_CCF,
    word_RLC,
    word_RRC,
    word_RL,
    word_RR,
    word_SLA,
    word_SRA,
    word_SLL,
    word_SRL,
    word_IN,
    word_OUT,
    word_SBC,
    word_NEG,
    word_RETN,
    word_IM,
    word_ADC,
    word_RETI,
    word_RRD,
    word_RLD,
    word_SUB,
    word_AND,
    word_XOR,
    word_OR,
    word_CP,
    word_BIT,
    word_RES,
    word_SET,
    word_LDI,
    word_CPI,
    word_INI,
    word_OUTI,
    word_LDD,
    word_CPD,
    word_IND,
    word_OUTD,
    word_LDIR,
    word_CPIR,
    word_INIR,
    word_OTIR,
    word_LDDR,
    word_CPDR,
    word_INDR,
    word_OTDR,
    word_RET,
    word_POP,
    word_JP,
    word_CALL,
    word_PUSH,
    word_RST,
    word_PFX,
    word_EXX,
    word_DI,
    word_EI,
    word_BC,
    word_DE,
    word_HL,
    word_IX,
    word_IY,
    word_SP,
    word_AF,
    word_AF2,
    word_B,
    word_C,
    word_D,
    word_E,
    word_H,
    word_L,
    word_XHL,
    word_A,
    word_XBC,
    word_XDE,
    word_R,
    word_I,
    word_XC,
    word_XSP,
    word_PC,
    word_F,
    word_N0,
    word_N1,
    word_N2,
    word_N3,
    word_N4,
    word_N5,
    word_N6,
    word_N7,
    word_Z,
    word_NZ,
    word_NC,
    word_PO,
    word_PE,
    word_M,
    word_P,
    word_N,
    word_NN,
    word_XNN,
    word_XN,
    word_DIS,
    word_CB,
    word_ED,
    word_XH,
    word_XL,
    word_YH,
    word_YL,
    word_XIX,
    word_XIY
  };

static const unsigned char cmd_00[192] PROGMEM =
  {
    NOP,0,0,
    LD,BC,NN,
    LD,XBC,A,
    INC,BC,0,
    INC,B,0,
    DEC,B,0,
    LD,B,N,
    RLCA,0,0,
    EX,AF,AF2,
    ADD,HL,BC,
    LD,A,XBC,
    DEC,BC,0,
    INC,C,0,
    DEC,C,0,
    LD,C,N,
    RRCA,0,0,
    DJNZ,DIS,0,
    LD,DE,NN,
    LD,XDE,A,
    INC,DE,0,
    INC,D,0,
    DEC,D,0,
    LD,D,N,
    RLA,0,0,
    JR,DIS,0,
    ADD,HL,DE,
    LD,A,XDE,
    DEC,DE,0,
    INC,E,0,
    DEC,E,0,
    LD,E,N,
    RRA,0,0,
    JR,NZ,DIS,
    LD,HL,NN,
    LD,XNN,HL,
    INC,HL,0,
    INC,H,0,
    DEC,H,0,
    LD,H,N,
    DAA,0,0,
    JR,Z,DIS,
    ADD,HL,HL,
    LD,HL,XNN,
    DEC,HL,0,
    INC,L,0,
    DEC,L,0,
    LD,L,N,
    CPL,0,0,
    JR,NC,DIS,
    LD,SP,NN,
    LD,XNN,A,
    INC,SP,0,
    INC,XHL,0,
    DEC,XHL,0,
    LD,XHL,N,
    SCF,0,0,
    JR,C,N,
    ADD,HL,SP,
    LD,A,XNN,
    DEC,SP,0,
    INC,A,0,
    DEC,A,0,
    LD,A,N,
    CCF,0,0
  };

static const unsigned char cmd_C0[192] PROGMEM = {

    RET,NZ,0,
    POP,BC,0,
    JP,NZ,NN,
    JP,NN,0,
    CALL,NZ,NN,
    PUSH,BC,0,
    ADD,A,N,
    RST,N0,0,
    RET,Z,0,
    RET,0,0,
    JP,Z,NN,
    PFX,CB,0,
    CALL,Z,NN,
    CALL,NN,0,
    ADC,A,N,
    RST,N1,0,
    RET,NC,0,
    POP,DE,0,
    JP,NC,NN,
    OUT,XN,A,
    CALL,NC,NN,
    PUSH,DE,0,
    SUB,A,N,
    RST,N2,0,
    RET,C,0,
    EXX,0,0,
    JP,C,NN,
    IN,A,XN,
    CALL,C,NN,
    PFX,IX,0,
    SBC,A,N,
    RST,N3,0,
    RET,PO,0,
    POP,HL,0,
    JP,PO,NN,
    EX,HL,XSP,
    CALL,PO,NN,
    PUSH,HL,0,
    AND,A,N,
    RST,N4,0,
    RET,PE,0,
    LD,PC,HL,
    JP,PE,NN,
    EX,DE,HL,
    CALL,PE,NN,
    PFX,ED,0,
    XOR,A,N,
    RST,N5,0,
    RET,P,0,
    POP,AF,0,
    JP,P,NN,
    DI,0,0,
    CALL,P,NN,
    PUSH,AF,0,
    OR,A,N,
    RST,N6,0,
    RET,M,0,
    LD,SP,HL,
    JP,M,NN,
    EI,0,0,
    CALL,M,NN,
    PFX,IY,0,
    CP,A,N,
    RST,N7,0
};

static const unsigned char cmd_ED40[192] PROGMEM = {

    IN,B,XC,
    OUT,XC,B,
    SBC,HL,BC,
    LD,XNN,BC,
    NEG,0,0,
    RETN,0,0,
    IM,N0,0,
    LD,I,A,
    IN,C,XC,
    OUT,XC,C,
    ADC,HL,BC,
    LD,BC,XNN,
    NEG,0,0,
    RETI,0,0,
    IM,N0,0,
    LD,R,A,
    IN,D,XC,
    OUT,XC,D,
    SBC,HL,DE,
    LD,XNN,DE,
    NEG,0,0,
    RETN,0,0,
    IM,N1,0,
    LD,A,I,
    IN,E,XC,
    OUT,XC,E,
    ADC,HL,DE,
    LD,DE,XNN,
    NEG,0,0,
    RETI,0,0,
    IM,N2,0,
    LD,A,R,
    IN,H,XC,
    OUT,XC,H,
    SBC,HL,HL,
    LD,XNN,HL,
    NEG,0,0,
    RETN,0,0,
    IM,N0,0,
    RRD,0,0,
    IN,L,XC,
    OUT,XC,L,
    ADC,HL,HL,
    LD,HL,XNN,
    NEG,0,0,
    RETI,0,0,
    IM,N0,0,
    RLD,0,0,
    IN,F,XC,
    OUT,XC,N0,
    SBC,HL,SP,
    LD,XNN,SP,
    NEG,0,0,
    RETN,0,0,
    IM,N1,0,
    NOP,0,0,
    IN,A,XC,
    OUT,XC,A,
    ADC,HL,SP,
    LD,SP,XNN,
    NEG,0,0,
    RETI,0,0,
    IM,N2,0,
    NOP,0,0
  };

static const char msg_HALT[] PROGMEM = "**HALT**\n";
static const char msg_INT[] PROGMEM = "**INT**\n";
static const char msg_NMI[] PROGMEM = "**NMI**\n";

unsigned char cmd_halt[] = { HALT,0,0 };
unsigned char cmd_nop[]  = { NOP,0,0 };

unsigned char c_ari[]    = { ADD,ADC,SUB,SBC,AND,XOR,OR,CP };

unsigned char c_blk[]    = { LDI,CPI,INI,OUTI,0,0,0,0,LDD,CPD,IND,OUTD,0,0,0,0,
                             LDIR,CPIR,INIR,OTIR,0,0,0,0,LDDR,CPDR,INDR,OTDR };

unsigned char c_sh[]     = { RLC,RRC,RL,RR,SLA,SRA,SLL,SRL };

// ============================================================================================


unsigned char Peek(unsigned int addr) {
  loadAddr(addr);
  return readMemByte();
}

const unsigned char *copyFromPgmMem(const unsigned char *mem) {
  static unsigned char buffer[3];
  buffer[0] = pgm_read_byte(mem++);
  buffer[1] = pgm_read_byte(mem++);
  buffer[2] = pgm_read_byte(mem++);
  return buffer;
}


// ---- return mnenonic descriptor for normal instructions
//      note: for immediate use only, returned result becomes invalid with next call!
const unsigned char* mnemo(unsigned char op) {
  static unsigned char cl[3]={LD,A,A};
  static unsigned char ca[3]={ADD,A,A};

  switch (op>>6)
    {
    case 0: return copyFromPgmMem(cmd_00 + op * 3);
    case 1: if (op==0x76) return cmd_halt;
      cl[1] = B + ((op>>3)&0x07);
      cl[2] = B + (op&0x07);
      return cl;
    case 2: ca[0] = c_ari[(op>>3)&0x07];
      ca[2] = B + (op&0x07);
      return ca;
    case 3: return copyFromPgmMem(cmd_C0 + (op&0x3f) * 3);
    }
  return NULL;
}


// ---- return mnenonic descriptor for CB instructions
//      note: for immediate use only!
unsigned char* mnemoCB(unsigned char op) {
  static unsigned char cmd[3];

  switch (op>>6)
    {
    case 0: cmd[0] = c_sh[(op>>3)&0x07];
      cmd[1] = B + (op&0x07);
      cmd[2] = 0;
      return cmd;
    case 1: cmd[0] = BIT; break;
    case 2: cmd[0] = RES; break;
    case 3: cmd[0] = SET; break;
    }
  cmd[1] = N0 + ((op>>3)&0x07);
  cmd[2] = B + (op&0x07);
  return cmd;
}


// ---- return mnenonic descriptor for IXCB instructions
//      note: for immediate use only!
unsigned char* mnemoIXCB(unsigned char op) {
  unsigned char *c;

  c = mnemoCB(op);
  if (c[1]==XHL) c[1]=XIX;    // this is only allowed, because mnemo() doesn't
  if (c[2]==XHL) c[2]=XIX;    // retrieve a pointer but creates mnemo descr ad hoc
  return c;
}


// ---- return mnenonic descriptor for IYCB instructions
//      note: for immediate use only!
unsigned char* mnemoIYCB(unsigned char op) {
  unsigned char *c;

  c = mnemoCB(op);
  if (c[1]==XHL) c[1]=XIY;    // this is only allowed, because mnemo() doesn't
  if (c[2]==XHL) c[2]=XIY;    // retrieve a pointer but creates mnemo descr ad hoc
  return c;
}


// ---- return mnenonic descriptor for ED instructions
//      note: for immediate use only!
const unsigned char* mnemoED(unsigned char op) {
  static unsigned char cmd[3]={0,0,0};

  if (op<0x40) return cmd_nop;

  if (op>=0x080)
    {   if ((op&0xE4)!=0xA0) return cmd_nop;
      cmd[0] = c_blk[op&0x1B];
      return cmd;
    };

  return copyFromPgmMem(cmd_ED40 + (op-0x40) * 3);
}


// ---- return mnenonic descriptor for IX instructions
//      note: for immediate use only!
unsigned char*   mnemoIX (unsigned char op) {
  static unsigned char cmd[3];

  memcpy (cmd, mnemo(op), 3);

  if (cmd[1]==XHL) { cmd[1]=XIX; return cmd; }
  if (cmd[2]==XHL) { cmd[2]=XIX; return cmd; }
  if (cmd[1]==HL)  { cmd[1]=IX;  return cmd; }
  if (cmd[2]==HL)  { cmd[2]=IX;  return cmd; }
  if (cmd[1]==H) cmd[1]=XH;
  if (cmd[1]==L) cmd[1]=XL;
  if (cmd[2]==H) cmd[2]=XH;
  if (cmd[2]==L) cmd[2]=XL;
  return cmd;
}


// ---- return mnenonic descriptor for IY instructions
//      note: for immediate use only!
unsigned char*   mnemoIY (unsigned char op) {
  static unsigned char cmd[3];

  memcpy (cmd, mnemo(op), 3);

  if (cmd[1]==XHL) { cmd[1]=XIY; return cmd; }
  if (cmd[2]==XHL) { cmd[2]=XIY; return cmd; }
  if (cmd[1]==HL)  { cmd[1]=IY;  return cmd; }
  if (cmd[2]==HL)  { cmd[2]=IY;  return cmd; }
  if (cmd[1]==H) cmd[1]=YH;
  if (cmd[1]==L) cmd[1]=YL;
  if (cmd[2]==H) cmd[2]=YH;
  if (cmd[2]==L) cmd[2]=YL;
  return cmd;
}

// ---- get legal state of CB instruction --------------------------------------
//      all instructions legal except: sll is illegal
int IllegalCB (unsigned char op) {
  return op>=0x30 && op<0x38 ? illegal : legal;
}


// ---- get legal state of IXCB/IYCB instruction ----------------------------------
//      all instructions which do not use IX are weird
//      instructions using IX are legal except: sll is illegal
int IllegalXXCB (unsigned char op) {
  if ((op&0x07)!=6) return weird;
  return op>=0x30 && op<0x38 ? illegal : legal;
}


// ---- get legal state of ED instruction --------------------------------------
//      0x00-0x3F and 0x80-0xFF weird except block instructions
//      0x40-0x7F legal or weird
//      in f,(c) is legal; out (c),0 is weird
int IllegalED (unsigned char op) {
  char *il = "1111111111110101111100111111001111110001111100011011000011110000";

  if ((op>>6)==1) return il[op-0x40]-'0' ? weird : legal;
  return *mnemoED(op)==NOP ? weird : legal;
}


// ---- get legal state of IX/IY instruction --------------------------------------
//      all illegal instructions, which use XH or XL are illegal
//      all illegal instructions, which don't use XH or XL are weird
//      prefixes are legal
int IllegalXX (unsigned char op) {
  const unsigned char *c;

  c = mnemo(op);

  if (*c==PFX || c[1]==XHL || c[2]==XHL) return legal;
  if (c[1]==H||c[1]==L||c[2]==H||c[2]==L) return illegal;
  return weird;
}


// ---- Calculate length of instruction                         30.jun.95 KIO !
//      op2 is only used if op1 is a prefix instruction
//      IX/IY before IX/IY/ed have no effect and are reported as length 1
int OpcodeLength (unsigned char op1, unsigned char op2) {
  static char* len0 = "1311112111111121231111212111112123311121213111212331112121311121"; // 0x00 - 0x3F
  static char* len3 = "1133312111303321113231211132302111313121113130211131312111313021"; // 0xC0 - 0xFF; prefixes are 0

  switch (op1>>6)
    {
    case 0: return len0[op1]-'0';       // 0x00 - 0x3F: various length
    case 1:                             // 0x40 - 0x7F: ld r,r: all 1
    case 2: return 1;                   // 0x80 - 0xBF: arithmetics/logics op a,r: all 1
    }

  switch (op1)    // test for prefix
    {
    case 0xcb:  return 2;
    case 0xed:  if (/* op2<0x40 || op2>=0x80 || ((op2&7)!=3) */ (op2&0xc7)!=0x43) return 2; else return 4;
    case 0xdd:
    case 0xfd:
      switch (op2>>6)
        {
        case 0: return len0[op2]-'0'+1 + (op2>=0x34&&op2<=0x36);    // inc(hl); dec(hl); ld(hl),N: add displacement
        case 1:
        case 2: if (((op2&0x07)==6) == ((op2&0x0F8)==0x70)) return 2; else return 3;
        }
      if (op2==0xcb) return 4;
      return len3[op2&0x3F]-'0'+1;    // note: entries for prefixes are 0 giving a total of 1, just to skip the useless prefix
    }

  return len3[op1&0x3F]-'0';          // 0xC0 - 0xFF: no prefix:  various length
}


// ===================================================================================

char * xword (char *ptr, unsigned char n, unsigned int *ip) {
  unsigned int nn;

  // TODO: Replace switch with a more intelligent case
  switch (n)
    {
    case DIS:
      n = Peek((*ip)++);
      *ptr++ = '$';
      ptr = strhex4(ptr, *ip+(char)n);      // branch destination
      break;
    case N:
      n = Peek((*ip)++);
      *ptr++ = '$';
      ptr = strhex2(ptr, n);
      break;
    case NN:
      n = Peek((*ip)++);
      nn = n+256*Peek((*ip)++);
      *ptr++ = '$';
      ptr = strhex4(ptr, nn);
      break;
    case XNN:
      n = Peek((*ip)++);
      nn = n+256*Peek((*ip)++);
      *ptr++ = '(';
      *ptr++ = '$';
      ptr = strhex4(ptr, nn);
      *ptr++ = ')';
      break;
    case XN:
      n = Peek((*ip)++);
      *ptr++ = '(';
      *ptr++ = '$';
      ptr = strhex2(ptr, n);
      *ptr++ = ')';
      break;
    case XIX:
      n = Peek((*ip)++);
      *ptr++ = '(';
      *ptr++ = 'I';
      *ptr++ = 'X';
      if (n&0x80) {
        *ptr++ = '-';
        ptr = strhex2(ptr, 256 - n);
      } else {
        *ptr++ = '+';
        ptr = strhex2(ptr, n);
      }
      *ptr++ = ')';
      break;
    case XIY:
      n = Peek((*ip)++);
      *ptr++ = '(';
      *ptr++ = 'I';
      *ptr++ = 'Y';
      if (n&0x80) {
        *ptr++ = '-';
        ptr = strhex2(ptr, 256 - n);
      } else {
        *ptr++ = '+';
        ptr = strhex2(ptr, n);
      }
      *ptr++ = ')';
      break;
    default:
      strcpy_P(ptr, (PGM_P)pgm_read_word(&(word[n])));
      ptr += strlen(ptr);
      break;
    }
  return ptr;
}


// ---- expand 3-char descriptor m[3] to mnemonic with arguments via pc
char *disass (char *ptr, const unsigned char *m, unsigned int *ip) {
  strcpy_P(ptr, (PGM_P)pgm_read_word(&(word[*m++])));
  *(ptr + strlen(ptr)) = ' ';
  ptr += 5;
  if (*m) {
    ptr = xword(ptr, *m++,ip);
  }
  if (*m) {
    *ptr++ = ',';
    ptr = xword(ptr, *m,ip);
  }
  return ptr;
}

char * disassem (char *ptr, unsigned int *ip) {
  unsigned char op;

  op = Peek((*ip)++);
  switch (op)
    {
    case 0xcb:
      ptr = disass(ptr, mnemoCB(Peek((*ip)++)), ip);
      break;
    case 0xed:
      ptr = disass(ptr, mnemoED(Peek((*ip)++)), ip);
      break;
    case 0xdd:
      op = Peek((*ip)++);
      if (op!=0xCB) {
        ptr = disass(ptr, mnemoIX(op), ip);
      } else {
        ptr = disass(ptr, mnemoIXCB(Peek((*ip)+1)), ip);
        (*ip)++;
      }
      break;
    case 0xfd:
      op = Peek((*ip)++);
      if (op!=0xCB) {
        ptr = disass(ptr, mnemoIY(op), ip);
      } else {
        ptr = disass(ptr, mnemoIYCB(Peek((*ip)+1)), ip);
        (*ip)++;
      }
      break;
    default:
      ptr = disass(ptr, mnemo(op),ip);
      break;
    }
  return ptr;
}

addr_t disassemble(addr_t addr, uint8_t m) {
  static char buffer[64];

  char *ptr;
  addr_t addr2 = addr;

  // Ignore the current CPU state in the disassemble connamd
  uint8_t pdc = (m == MODE_DIS_CMD) ? 0 : PDC_DIN;

  // 0123456789012345678901234567890123456789
  // AAAA : HH HH HH HH : LD   RR,($XXXX)

  strfill(buffer, ' ', sizeof(buffer));
  buffer[5] = ':';
  buffer[19] = ':';

  // Address
  strhex4(buffer, addr);

  // Opcode
  ptr = buffer + 21;

  if (pdc & 0x80) {
    strcpy_P(ptr, msg_HALT);
  } else if (pdc & 0x40) {
    strcpy(ptr, msg_NMI);
  } else if (pdc & 0x20) {
    strcpy(ptr, msg_INT);
  } else {
    ptr = disassem(ptr, &addr2);
    *ptr++ = '\n';
    *ptr++ = '\0';
  }

  // Hex
  loadAddr(addr);
  ptr = buffer + 7;
  while (addr < addr2) {
    strhex2(ptr, readMemByteInc());
    ptr += 3;
    addr++;
  }
  logs(buffer);
  return addr;
}