home *** CD-ROM | disk | FTP | other *** search
/ Aminet 18 / aminetcdnumber181997.iso / Aminet / misc / emu / gbuk.lha / src / Z80.H < prev   
C/C++ Source or Header  |  1996-11-06  |  6KB  |  155 lines
  1. /** VGB: portable GameBoy emulator ***************************/
  2. /**                                                         **/
  3. /**                           Z80.h                         **/
  4. /**                                                         **/
  5. /** This file contains declarations relevant to emulation   **/
  6. /** of Z80 CPU. See GB.h for #defines related to drivers    **/
  7. /** and GameBoy emulation.                                  **/
  8. /**                                                         **/
  9. /** Copyright (C) Marat Fayzullin 1994,1995,1996            **/
  10. /**               Marcel de Kogel 1996                      **/
  11. /**     You are not allowed to distribute this software     **/
  12. /**     commercially. Please, notify me, if you make any    **/
  13. /**     changes to this file.                               **/
  14. /*************************************************************/
  15.  
  16. //#define DEBUG             /* Compile debugging version  */
  17.  
  18. #ifdef    __DJGPP__
  19. #define    LSB_FIRST
  20. #define    FAST_MEM
  21. #endif
  22.  
  23. #ifdef    __WATCOMC__
  24. #define    LSB_FIRST
  25. #endif
  26.  
  27. #ifdef    __GNUC__
  28. #ifdef    mc68000
  29. #define    FAST_MEM
  30. #endif
  31. #endif
  32.  
  33. #define S_FLAG      0x80
  34. #define Z_FLAG      0x40
  35. #define H_FLAG      0x10
  36. #define P_FLAG      0x04
  37. #define V_FLAG      0x04
  38. #define N_FLAG      0x02
  39. #define C_FLAG      0x01
  40.  
  41. /**********************************************************/
  42. /*** NOTICE: sizeof(byte)=1 and sizeof(word)=2          ***/
  43. /**********************************************************/
  44. typedef unsigned char byte;
  45. typedef unsigned short word;
  46. typedef signed char offset;
  47.  
  48. /**********************************************************/
  49. /*** #define LSB_FIRST for machines where least         ***/
  50. /*** signifcant byte goes first.                        ***/
  51. /**********************************************************/
  52. typedef union
  53. {
  54. #ifdef LSB_FIRST
  55.   struct { byte l,h; } B;
  56. #else
  57.   struct { byte h,l; } B;
  58. #endif
  59.   word W;
  60. } pair;
  61.  
  62. typedef struct
  63. {
  64.   pair AF,BC,DE,HL,PC,SP;
  65.   byte IFF,I;
  66. } reg;
  67.  
  68. /*** Interrupts *******************************************/
  69. /*** Interrupt-related variables.                       ***/
  70. /**********************************************************/
  71. extern int IPeriod;   /* Number of commands between internal interrupts */
  72. extern byte IntSync;  /* Generate internal interrupts if IntSync==1     */
  73. extern int ICount;    /* Number of commands until next internal int-pt  */
  74. extern byte IFlag;    /* If IFlag==1, generate interrupt and set to 0   */
  75.  
  76. /*** Trace and Trap ***************************************/         
  77. /*** Switches to turn tracing on and off in DEBUG mode. ***/
  78. /**********************************************************/
  79. #ifdef DEBUG
  80. extern byte Trace;  /* Tracing is on if Trace==1  */
  81. extern word Trap;   /* When PC==Trap, set Trace=1 */
  82. #endif
  83.  
  84. /*** TrapBadOps *******************************************/
  85. /*** When 1, print warnings of illegal Z80 instructions.***/
  86. /**********************************************************/
  87. extern byte TrapBadOps;
  88.  
  89. /*** CPURunning *******************************************/
  90. /*** When 0, execution terminates.                      ***/
  91. /**********************************************************/
  92. extern byte CPURunning;
  93.  
  94. /*** Reset Z80 registers: *********************************/
  95. /*** This function can be used to reset the register    ***/
  96. /*** file before starting execution with Z80(). It sets ***/
  97. /*** the registers to their initial values.             ***/
  98. /**********************************************************/
  99. extern void ResetZ80(reg *Regs);
  100.  
  101. /*** Interpret Z80 code: **********************************/
  102. /*** Registers have initial values from Regs. PC value  ***/
  103. /*** at which emulation stopped is returned by this     ***/
  104. /*** function.                                          ***/
  105. #define    __inline__ __inline
  106. /**********************************************************/
  107. /*** Interpret Z80 code: **********************************/
  108. /*** Registers have initial values from Regs. PC value  ***/
  109. /*** at which emulation stopped is returned by this     ***/
  110. /*** function.                                          ***/
  111. /**********************************************************/
  112. word Z80(reg Regs);
  113.  
  114. /**********************************************************/
  115. /*** These functions are called when read or write to   ***/
  116. /*** RAM occurs. They perform actual reads abd writes.  ***/
  117. /**********************************************************/
  118. //typedef void (*WriteMemFn) (word A,byte V) __attribute__ ((regparm(3)));
  119. typedef void (*WriteMemFn) (word A,byte V);
  120. extern WriteMemFn WriteMemFnTable[256];
  121. extern byte *RAM,*Page[8];
  122. #ifndef FAST_MEM
  123.  //void M_WRMEM(word A,byte V)    __attribute__ ((regparm(3)));
  124.  //byte M_RDMEM(word A)           __attribute__ ((regparm(3)));
  125.  void M_WRMEM(word A,byte V);
  126.  byte M_RDMEM(word A);
  127. #else
  128.  extern __inline__ byte M_RDMEM (word A)
  129.  {
  130.   return(Page[A>>13][A&0x1FFF]);
  131.  }
  132.  extern __inline__ void M_WRMEM (word A,byte V)
  133.  {
  134.   (*WriteMemFnTable[A>>8])(A,V);
  135.  }
  136. #endif
  137.  
  138. #ifdef DEBUG
  139. /*** Single-step debugger *********************************/
  140. /*** This function should exist if DEBUG is #defined.   ***/
  141. /*** If Trace==1 it is called after each command        ***/
  142. /*** executed by the CPU and given a pointer to the     ***/
  143. /*** register file.                                     ***/
  144. /**********************************************************/
  145. void Debug(reg *R);
  146. #endif
  147.  
  148. /*** Interrupt handler ************************************/
  149. /*** This function should exist if INTERRUPTS is        ***/
  150. /*** #defined. It is called on each attempted interrupt ***/
  151. /*** and should return an interrupt address to proceed  ***/
  152. /*** with interrupt or 0xFFFF to continue execution.    ***/ 
  153. /**********************************************************/
  154. word Interrupt(void);
  155.