home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 4 / Apprentice-Release4.iso / Source Code / Libraries / Z80 emulator / 68K version / z80.h < prev    next >
Encoding:
C/C++ Source or Header  |  1995-11-19  |  7.5 KB  |  219 lines  |  [TEXT/CWIE]
  1. /*    Z80 Emulator: header file
  2.     Copyright (C) 1995 G.Woigk
  3.     
  4.     This file is part of Mac Spectacle and it is free software
  5.     See application.c for details
  6.             
  7.     This program is distributed in the hope that it will be useful,
  8.     but WITHOUT ANY WARRANTY; without even the implied warranty of
  9.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  
  10. */
  11.  
  12.  
  13. #if CMD_PROFILE
  14.  
  15. extern    Boolean    count_instr;
  16. extern    long        *cnt_xx;
  17. extern    long        *cnt_cb;
  18. extern    long        *cnt_ed;
  19. extern    long        *cnt_xy;
  20. extern    long        *cnt_xycb;
  21.  
  22. #endif
  23.  
  24. #if PC_PROFILE
  25.  
  26. extern    Boolean    count_pc;
  27. extern    long        *cnt_pc;
  28.  
  29. #endif
  30.  
  31.  
  32. // -----    Accessing the Core ---------------------------------------------------------
  33.  
  34. extern    Char*    RdPtr    ( Short addr );            // get pointer for reading
  35. extern    Char*    WrPtr    ( Short addr );            // get pointer for writing
  36.  
  37. extern    Char        Peek    ( Short addr );                // read byte
  38. extern            Poke    ( Short addr, Char byte );        // write byte
  39.  
  40.  
  41.  
  42. // -----    Block copying inside/from/to core -------------------------------------------
  43.  
  44. extern    long        tfu;            // bytes actually transferred  if  OSErr!=ok
  45. extern    OSErr    Buffer2File    ( void* bu,    short fileID,    long len );
  46. extern    OSErr    File2Buffer    ( short fileID,    void* bu,        long len );
  47. extern    OSErr    Core2File        ( Short addr,    short fileID,    long len );
  48. extern    OSErr    File2Core        ( short fileID,    Short addr,    long len );
  49. extern            Core2Buffer    ( Short addr,    void* bu,        long len );
  50. extern            Buffer2Core    ( void* bu,    Short addr,    long len );
  51. extern            Core2Core    ( Short src,    Short dest,    long len );
  52. extern            Buffer2Buffer    ( void* src,    void* dest,    long len );
  53.  
  54.  
  55. // -----    Flag tables ----------------------------------------------------------------
  56.  
  57. extern    Char        zlog_flags[256];    // convert:   A register  ->  z80 flags with V=parity and C=0
  58. #if !GENERATINGPOWERPC
  59. extern    Char        mlog_flags[256];    // convert:   A register  ->  m68 flags with V=parity and C=0
  60. extern    Char        z80flags[256];        // convert:   m68 flag byte  ->  Z80 flag byte
  61. extern    Char        m68flags[256];    // convert:   Z80 flag byte  ->  m68 flag byte
  62. #endif
  63.  
  64.  
  65. // -----    The Z80 core --------------------------------------------------------------
  66. extern    Char**    CORE_M;            // master handle for all allocated RAM and ROM
  67. extern    Char*    CORE;            // do not use any longer!!!
  68. extern    Char*    rpage[];            // mapped in pages for reading
  69. extern    Char*    wpage[];            // mapped in pages for writing
  70. extern    Char*    ram[];            // real RAM pages
  71. extern    Char*    rom[];            // real ROM pages
  72. extern    Char*    norom;            // dummy page for writing to ROM
  73.  
  74. extern    Char        zx128pagectrl;        // last byte sent to ZX 128's paging control port
  75. extern    ZX128PageCtrl    ( Char );        // output byte to zx 128's page control port
  76.  
  77.  
  78. // -----    Z80 registers on entry and return of Z80() -----------------------------------
  79.  
  80. typedef    union    dreg    dreg;
  81. union dreg
  82. {    Short    rr;
  83.     struct    { Char hi,lo; }    r;
  84. };
  85.  
  86.  
  87. typedef union pair pair;
  88. union pair
  89. {    Char        *ptr;
  90.     struct    {    Short corebase; Short reg; }    rr;
  91.     struct    {    Short corebase; Char hi,lo; }    r;
  92. };
  93.  
  94.  
  95. typedef struct z80 z80;
  96. struct z80
  97. {    pair        bc,de,hl,ix,iy,pc,sp;        // registers
  98.     Short    bc2,de2,hl2;            // registers
  99.     Char        aa2,a2,aa,a;            // A2 & A are stuffed in one long register inside Z80_68k()
  100.     Char        ff2, f2, ff, f;            // F2  & F are stuffed in one long register inside Z80_68k()
  101.     Char        i, irptcmd;            // irpt vector: i register & byte read from data bus
  102.     Char        iff1,iff2;                // interrupt enable flip flops
  103.     Char        exit,wuff;                // watchdog flag & nmi/irpt flags
  104.     Char        r, im;                // refresh counter & interrupt mode: 0 ... 2
  105.     long        cycles;                // processor T states (count down for interrupt)
  106.     long        total;                // T states since start of Z80 (overflows approx. every 20')
  107. };
  108.  
  109. extern    z80        zreg;            // all z80 registers, flags and bits are stored in this struct
  110.  
  111.  
  112. // -----    definitions to ease the use of the z80 registers & core:
  113.  
  114. #define    CYCLES    zreg.cycles        // processor T states (count down for interrupt)
  115. #define    TOTAL    zreg.total            // T states since start of Z80 (overflows approx. every 20')
  116. #define    WUFF    zreg.wuff            // watchdog flag
  117. #define    EXIT        zreg.exit            // nmi & irpt flags
  118. #define    IFF1        zreg.iff1            // irpt flip flop
  119. #define    IFF2        zreg.iff2            // iff1 copy during nmi processing
  120. #define    IM        zreg.im            // interrupt mode: 0 ... 2
  121. #define    RR        zreg.r            // 7 bit DRAM refresh counter
  122. #define    RI        zreg.i            // hi byte of interrupt vector: i register
  123. #define    IRPTCMD    zreg.irptcmd        // lo byte of interrupt vector: read from bus
  124. #define    IRPTVEK    *(Short*)&RI        // interrupt vector in interrupt mode 2
  125.  
  126. #define    RA        zreg.a            // Z80() uses register variable 'a'
  127. #define    RF        zreg.f            // Z80() uses register variable 'f'
  128. #define    RA2        zreg.a2
  129. #define    RF2        zreg.f2
  130.  
  131. #define    BC2        zreg.bc2
  132. #define    DE2        zreg.de2
  133. #define    HL2        zreg.hl2
  134.  
  135. #define    ABC        zreg.bc.ptr
  136. #define    BC        zreg.bc.rr.reg
  137. #define    RB        zreg.bc.r.hi
  138. #define    RC        zreg.bc.r.lo
  139.  
  140. #define    ADE        zreg.de.ptr
  141. #define    DE        zreg.de.rr.reg
  142. #define    RD        zreg.de.r.hi
  143. #define    RE        zreg.de.r.lo
  144.  
  145. #define    AHL        zreg.hl.ptr
  146. #define    HL        zreg.hl.rr.reg
  147. #define    RH        zreg.hl.r.hi
  148. #define    RL        zreg.hl.r.lo
  149.  
  150. #define    AIX        zreg.ix.ptr
  151. #define    IX        zreg.ix.rr.reg
  152. #define    XH        zreg.ix.r.hi
  153. #define    XL        zreg.ix.r.lo
  154.  
  155. #define    AIY        zreg.iy.ptr
  156. #define    IY        zreg.iy.rr.reg
  157. #define    YH        zreg.iy.r.hi
  158. #define    YL        zreg.iy.r.lo
  159.  
  160. #define    APC        zreg.pc.ptr    
  161. #define    PC        zreg.pc.rr.reg
  162. #define    PCH        zreg.pc.r.hi
  163. #define    PCL        zreg.pc.r.lo
  164.  
  165. #define    ASP        zreg.sp.ptr
  166. #define    SP        zreg.sp.rr.reg
  167. #define    SPH        zreg.sp.r.hi
  168. #define    SPL        zreg.sp.r.lo
  169.  
  170. #define    disabled        0x00        // irpt flags
  171. #define    enabled        0xFF            // irpt flags
  172.  
  173. // bits in WUFF:
  174. #define    is_nmi        0x80        // non maskable interrupt: handled inside Z80()
  175. #define    is_irpt        0x7F            // normal interrupt counter: handled inside Z80()
  176.  
  177. // -----    Return values of Z80() -----------------------------------------------------
  178.  
  179. #define    watchdog_irpt    0            // watchdog exception
  180. #define    nimp_instr    1            // not implemented instruction at pc -> stop engine
  181. #define    halt_instr        2            // halt instruction encountered at pc-1 -> execute it!
  182. #define    rst0_instr    3            // rst 0 instruction encountered at pc-1 -> execute it!
  183. #define    irpt_error    4            // not supported interrupt mode/instruction -> stop engine
  184. #define    ill_instr2        5            // info:    illegal instruction executed at pc-2:
  185. #define    ill_instr3        6            //        SLL and usual XL,XH,YL,YH opcodes
  186. #define    ill_instr4        7            //
  187. #define    weird_instr1    8            // info:    unusual illegal instruction executed at pc-1: 
  188. #define    weird_instr2    9            //        all other illegals
  189. #define    weird_instr3    10            //
  190. #define    weird_instr4    11            //
  191.  
  192. // -----    Constants for Init_Z80() --------------------------------------------------------
  193.  
  194. extern    int        z80_hardware;        // hardware which is actually emulated
  195. #define    zx_48k    1
  196. #define    zx_128    2
  197.  
  198. // -----    Procedures -------------------------------------------------------------------
  199.  
  200. extern            InitZ80 ( int hardware );        // allocate core, init z80
  201. extern    short    Z80 ( );                    // return value states reason why Z80() returned
  202. extern    short    Z80_T ( );                    // same as Z80() but with T cycle counting
  203. extern    short    Z80_PPC ( );                // same as Z80_T() but written in C
  204.  
  205.  
  206. // -----    The following procedures must be supplied by the application program ---------------
  207.  
  208. extern    Do_Output        ( Short addr, Char n );    // Output byte to port
  209. Char        Do_Input         ( Short addr );            // Input byte from port
  210. extern    Do_Cycles        ( void );                // Count down for T cycles reached 0
  211. extern    write_to_rom    ( Short A, Char N);        // Write byte to ROM (or don't)
  212.  
  213. extern    Z80_Info ( long cc, Short ip );
  214. extern    Z80_Info_Irpt( long cc );                // info call to debugger if INFO_IRPT==on
  215. extern    Z80_Info_NMI ( long cc );                // info call to debugger if INFO_NMI==on
  216. extern    Z80_1st_Loc ( long cc, Short ip );        // info call to debugger if PC_PROFILE==on
  217. extern    Z80_1st_Instr ( long cc, Short ip );        // info call to debugger if CMD_PROFILE==on
  218.  
  219.