text: /*
   * R65C02.h - Definitions for emulation of the R65C02 processor.
   *
   * Written by
   *  Marco van den Heuvel <blackystardust68@yahoo.com>
   *
   * This file is part of VICE, the Versatile Commodore Emulator.
   * See README for copyright notice.
   *
   *  This program is free software; you can redistribute it and/or modify
   *  it under the terms of the GNU General Public License as published by
   *  the Free Software Foundation; either version 2 of the License, or
   *  (at your option) any later version.
   *
   *  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.  See the
   *  GNU General Public License for more details.
   *
   *  You should have received a copy of the GNU General Public License
   *  along with this program; if not, write to the Free Software
   *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
   *  02111-1307  USA.
   *
   */
  
  #ifndef VICE_R65C02_H
  #define VICE_R65C02_H
  
  #include "types.h"
  
  /* Struct for the R65C02 registers.  */
  /* This contains some redundancy to make it compatible with the way registers
     are handled within the CPU emulation.  The struct should be accessed using
     the `R65C02_REGS_*()' macros.  */
  typedef struct R65C02_regs_s {
      unsigned int pc;
      uint8_t a;
      uint8_t x;
      uint8_t y;
      uint8_t sp;
      uint8_t p;
      uint8_t n;
      uint8_t z;
  } R65C02_regs_t;
  
  /* These define the position of the status flags in the P (`status')
     register.  */
  #define P_SIGN          0x80
  #define P_OVERFLOW      0x40
  #define P_UNUSED        0x20
  #define P_BREAK         0x10
  #define P_DECIMAL       0x08
  #define P_INTERRUPT     0x04
  #define P_ZERO          0x02
  #define P_CARRY         0x01
  
  #define R65C02_REGS_SET_A(regs, val) (regs)->a = (val)
  #define R65C02_REGS_SET_X(regs, val) (regs)->x = (val)
  #define R65C02_REGS_SET_Y(regs, val) (regs)->y = (val)
  #define R65C02_REGS_SET_SP(regs, val) (regs)->sp = (val)
  #define R65C02_REGS_SET_PC(regs, val) (regs)->pc = (val)
  
  #define R65C02_REGS_SET_OVERFLOW(regs, val) \
      do {                                    \
          if (val) {                          \
              (regs)->p |= P_OVERFLOW;        \
          } else {                            \
              (regs)->p &= ~P_OVERFLOW;       \
          }                                   \
      } while (0)
  
  #define R65C02_REGS_SET_BREAK(regs, val) \
      do {                                 \
          if (val) {                       \
              (regs)->p |= P_BREAK;        \
          } else {                         \
              (regs)->p &= ~P_BREAK;       \
          }                                \
      } while (0)
  
  #define R65C02_REGS_SET_DECIMAL(regs, val) \
      do {                                   \
          if (val) {                         \
              (regs)->p |= P_DECIMAL;        \
          } else {                           \
              (regs)->p &= ~P_DECIMAL;       \
          }                                  \
      } while (0)
  
  #define R65C02_REGS_SET_INTERRUPT(regs, val) \
      do {                                     \
          if (val) {                           \
              (regs)->p |= P_INTERRUPT;        \
          } else {                             \
              (regs)->p &= ~P_INTERRUPT;       \
          }                                    \
      } while (0)
  
  #define R65C02_REGS_SET_CARRY(regs, val) \
      do {                                 \
          if (val) {                       \
              (regs)->p |= P_CARRY;        \
          } else {                         \
              (regs)->p &= ~P_CARRY;       \
          }                                \
      } while (0)
  
  #define R65C02_REGS_SET_SIGN(regs, val) ((regs)->n = (val) ? 0x80 : 0)
  
  #define R65C02_REGS_SET_ZERO(regs, val) ((regs)->z = !(val))
  
  #define R65C02_REGS_SET_STATUS(regs, val)        \
      ((regs)->p = ((val) & ~(P_ZERO | P_SIGN)),   \
       R65C02_REGS_SET_ZERO(regs, (val) & P_ZERO), \
       (regs)->n = (val))
  
  #define R65C02_REGS_GET_A(regs) ((regs)->a)
  #define R65C02_REGS_GET_X(regs) ((regs)->x)
  #define R65C02_REGS_GET_Y(regs) ((regs)->y)
  #define R65C02_REGS_GET_SP(regs) ((regs)->sp)
  #define R65C02_REGS_GET_PC(regs) ((regs)->pc)
  #define R65C02_REGS_GET_FLAGS(regs) ((regs)->p)
  #define R65C02_REGS_GET_OVERFLOW(regs) ((regs)->p & P_OVERFLOW)
  #define R65C02_REGS_GET_BREAK(regs) ((regs)->p & P_BREAK)
  #define R65C02_REGS_GET_DECIMAL(regs) ((regs)->p & P_DECIMAL)
  #define R65C02_REGS_GET_INTERRUPT(regs) ((regs)->p & P_INTERRUPT)
  #define R65C02_REGS_GET_CARRY(regs) ((regs)->p & P_CARRY)
  #define R65C02_REGS_GET_SIGN(regs) ((regs)->n & 0x80)
  #define R65C02_REGS_GET_ZERO(regs) (!(regs)->z)
  #define R65C02_REGS_GET_STATUS(regs)           \
      ((regs)->p | ((regs)->n & 0x80) | P_UNUSED \
       | (R65C02_REGS_GET_ZERO(regs) ? P_ZERO : 0))
  
  #endif
  