[BACK]Return to memory.c CVS log [TXT] [DIR] Up to [RetroPC.NET] / np2 / i286c

Diff for /np2/i286c/memory.c between versions 1.4 and 1.5

version 1.4, 2003/11/28 08:01:32 version 1.5, 2003/11/29 00:36:00
Line 9 Line 9
   
   
 #define USE_HIMEM  #define USE_HIMEM
   #define MEMORY_DEBUG
   
 // ---- write byte  // ---- write byte
   
 static void MEMCALL i286_wt(UINT32 address, BYTE value) {  static void MEMCALL i286_wt(UINT32 address, REG8 value) {
   
         mem[address & extmem.adrsmask] = value;          mem[address & extmem.adrsmask] = (BYTE)value;
 }  }
   
 static void MEMCALL tram_wt(UINT32 address, BYTE value) {  static void MEMCALL tram_wt(UINT32 address, REG8 value) {
   
         I286_REMCLOCK -= vramop.tramwait;          I286_REMCLOCK -= vramop.tramwait;
         if (address < 0xa2000) {          if (address < 0xa2000) {
                 mem[address] = value;                  mem[address] = (BYTE)value;
                 tramupdate[LOW12(address >> 1)] = 1;                  tramupdate[LOW12(address >> 1)] = 1;
                 gdcs.textdisp |= 1;                  gdcs.textdisp |= 1;
         }          }
         else if (address < 0xa3fe0) {          else if (address < 0xa3fe0) {
                 if (!(address & 1)) {                  if (!(address & 1)) {
                         mem[address] = value;                          mem[address] = (BYTE)value;
                         tramupdate[LOW12(address >> 1)] = 1;                          tramupdate[LOW12(address >> 1)] = 1;
                         gdcs.textdisp |= 1;                          gdcs.textdisp |= 1;
                 }                  }
Line 35  static void MEMCALL tram_wt(UINT32 addre Line 36  static void MEMCALL tram_wt(UINT32 addre
         else if (address < 0xa4000) {          else if (address < 0xa4000) {
                 if (!(address & 1)) {                  if (!(address & 1)) {
                         if ((!(address & 2)) || (gdcs.msw_accessable)) {                          if ((!(address & 2)) || (gdcs.msw_accessable)) {
                                 mem[address] = value;                                  mem[address] = (BYTE)value;
                                 tramupdate[LOW12(address >> 1)] = 1;                                  tramupdate[LOW12(address >> 1)] = 1;
                                 gdcs.textdisp |= 1;                                  gdcs.textdisp |= 1;
                         }                          }
Line 44  static void MEMCALL tram_wt(UINT32 addre Line 45  static void MEMCALL tram_wt(UINT32 addre
         else if (address < 0xa5000) {          else if (address < 0xa5000) {
                 if ((address & 1) && (cgwindow.writable & 1)) {                  if ((address & 1) && (cgwindow.writable & 1)) {
                         cgwindow.writable |= 0x80;                          cgwindow.writable |= 0x80;
                         fontrom[cgwindow.high + ((address >> 1) & 0x0f)] = value;                          fontrom[cgwindow.high + ((address >> 1) & 0x0f)] = (BYTE)value;
                 }                  }
         }          }
 }  }
   
 static void MEMCALL vram_w0(UINT32 address, BYTE value) {  static void MEMCALL vram_w0(UINT32 address, REG8 value) {
   
         I286_REMCLOCK -= vramop.vramwait;          I286_REMCLOCK -= vramop.vramwait;
         mem[address] = value;          mem[address] = (BYTE)value;
         vramupdate[LOW15(address)] |= 1;          vramupdate[LOW15(address)] |= 1;
         gdcs.grphdisp |= 1;          gdcs.grphdisp |= 1;
 }  }
   
 static void MEMCALL vram_w1(UINT32 address, BYTE value) {  static void MEMCALL vram_w1(UINT32 address, REG8 value) {
   
         I286_REMCLOCK -= vramop.vramwait;          I286_REMCLOCK -= vramop.vramwait;
         mem[address + VRAM_STEP] = value;          mem[address + VRAM_STEP] = (BYTE)value;
         vramupdate[LOW15(address)] |= 2;          vramupdate[LOW15(address)] |= 2;
         gdcs.grphdisp |= 2;          gdcs.grphdisp |= 2;
 }  }
   
 static void MEMCALL grcg_rmw0(UINT32 address, BYTE value) {  static void MEMCALL grcg_rmw0(UINT32 address, REG8 value) {
   
         BYTE    mask;          REG8    mask;
         BYTE    *vram;          BYTE    *vram;
   
         I286_REMCLOCK -= vramop.grcgwait;          I286_REMCLOCK -= vramop.grcgwait;
Line 94  static void MEMCALL grcg_rmw0(UINT32 add Line 95  static void MEMCALL grcg_rmw0(UINT32 add
         }          }
 }  }
   
 static void MEMCALL grcg_rmw1(UINT32 address, BYTE value) {  static void MEMCALL grcg_rmw1(UINT32 address, REG8 value) {
   
         BYTE    mask;          REG8    mask;
         BYTE    *vram;          BYTE    *vram;
   
         I286_REMCLOCK -= vramop.grcgwait;          I286_REMCLOCK -= vramop.grcgwait;
Line 123  static void MEMCALL grcg_rmw1(UINT32 add Line 124  static void MEMCALL grcg_rmw1(UINT32 add
         }          }
 }  }
   
 static void MEMCALL grcg_tdw0(UINT32 address, BYTE value) {  static void MEMCALL grcg_tdw0(UINT32 address, REG8 value) {
   
         BYTE    *vram;          BYTE    *vram;
   
Line 147  static void MEMCALL grcg_tdw0(UINT32 add Line 148  static void MEMCALL grcg_tdw0(UINT32 add
         (void)value;          (void)value;
 }  }
   
 static void MEMCALL grcg_tdw1(UINT32 address, BYTE value) {  static void MEMCALL grcg_tdw1(UINT32 address, REG8 value) {
   
         BYTE    *vram;          BYTE    *vram;
   
Line 171  static void MEMCALL grcg_tdw1(UINT32 add Line 172  static void MEMCALL grcg_tdw1(UINT32 add
         (void)value;          (void)value;
 }  }
   
 static void MEMCALL egc_wt(UINT32 address, BYTE value) {  static void MEMCALL egc_wt(UINT32 address, REG8 value) {
   
         egc_write(address, value);          egc_write(address, value);
 }  }
   
 static void MEMCALL emmc_wt(UINT32 address, BYTE value) {  static void MEMCALL emmc_wt(UINT32 address, REG8 value) {
   
         extmem.pageptr[(address >> 14) & 3][LOW14(address)] = value;          extmem.pageptr[(address >> 14) & 3][LOW14(address)] = (BYTE)value;
 }  }
   
 static void MEMCALL i286_wn(UINT32 address, BYTE value) {  static void MEMCALL i286_wn(UINT32 address, REG8 value) {
   
         (void)address;          (void)address;
         (void)value;          (void)value;
Line 190  static void MEMCALL i286_wn(UINT32 addre Line 191  static void MEMCALL i286_wn(UINT32 addre
   
 // ---- read byte  // ---- read byte
   
 static BYTE MEMCALL i286_rd(UINT32 address) {  static REG8 MEMCALL i286_rd(UINT32 address) {
   
         return(mem[address & extmem.adrsmask]);          return(mem[address & extmem.adrsmask]);
 }  }
   
 static BYTE MEMCALL tram_rd(UINT32 address) {  static REG8 MEMCALL tram_rd(UINT32 address) {
   
         I286_REMCLOCK -= vramop.tramwait;          I286_REMCLOCK -= vramop.tramwait;
         if (address < 0xa4000) {          if (address < 0xa4000) {
Line 212  static BYTE MEMCALL tram_rd(UINT32 addre Line 213  static BYTE MEMCALL tram_rd(UINT32 addre
         return(mem[address]);          return(mem[address]);
 }  }
   
 static BYTE MEMCALL vram_r0(UINT32 address) {  static REG8 MEMCALL vram_r0(UINT32 address) {
   
         I286_REMCLOCK -= vramop.vramwait;          I286_REMCLOCK -= vramop.vramwait;
         return(mem[address]);          return(mem[address]);
 }  }
   
 static BYTE MEMCALL vram_r1(UINT32 address) {  static REG8 MEMCALL vram_r1(UINT32 address) {
   
         I286_REMCLOCK -= vramop.vramwait;          I286_REMCLOCK -= vramop.vramwait;
         return(mem[address + VRAM_STEP]);          return(mem[address + VRAM_STEP]);
 }  }
   
 static BYTE MEMCALL grcg_tcr0(UINT32 address) {  static REG8 MEMCALL grcg_tcr0(UINT32 address) {
   
 const BYTE      *vram;  const BYTE      *vram;
         BYTE    ret;          REG8    ret;
   
         I286_REMCLOCK -= vramop.grcgwait;          I286_REMCLOCK -= vramop.grcgwait;
         vram = mem + LOW15(address);          vram = mem + LOW15(address);
Line 244  const BYTE *vram; Line 245  const BYTE *vram;
         if (!(grcg.modereg & 8)) {          if (!(grcg.modereg & 8)) {
                 ret |= vram[VRAM0_E] ^ grcg.tile[3].b[0];                  ret |= vram[VRAM0_E] ^ grcg.tile[3].b[0];
         }          }
         return(~ret);          return(ret ^ 0xff);
 }  }
   
 static BYTE MEMCALL grcg_tcr1(UINT32 address) {  static REG8 MEMCALL grcg_tcr1(UINT32 address) {
   
         BYTE    *vram;  const BYTE      *vram;
         BYTE    ret;          REG8    ret;
   
         I286_REMCLOCK -= vramop.grcgwait;          I286_REMCLOCK -= vramop.grcgwait;
         ret = 0;          ret = 0;
Line 267  static BYTE MEMCALL grcg_tcr1(UINT32 add Line 268  static BYTE MEMCALL grcg_tcr1(UINT32 add
         if (!(grcg.modereg & 8)) {          if (!(grcg.modereg & 8)) {
                 ret |= vram[VRAM1_E] ^ grcg.tile[3].b[0];                  ret |= vram[VRAM1_E] ^ grcg.tile[3].b[0];
         }          }
         return(~ret);          return(ret ^ 0xff);
 }  }
   
 static BYTE MEMCALL egc_rd(UINT32 address) {  static REG8 MEMCALL egc_rd(UINT32 address) {
   
         return(egc_read(address));          return(egc_read(address));
 }  }
   
 static BYTE MEMCALL emmc_rd(UINT32 address) {  static REG8 MEMCALL emmc_rd(UINT32 address) {
   
         return(extmem.pageptr[(address >> 14) & 3][LOW14(address)]);          return(extmem.pageptr[(address >> 14) & 3][LOW14(address)]);
 }  }
   
 static BYTE MEMCALL i286_itf(UINT32 address) {  static REG8 MEMCALL i286_itf(UINT32 address) {
   
         if (itf.bank) {          if (itf.bank) {
                 address = ITF_ADRS + LOW15(address);                  address = ITF_ADRS + LOW15(address);
Line 291  static BYTE MEMCALL i286_itf(UINT32 addr Line 292  static BYTE MEMCALL i286_itf(UINT32 addr
   
 // ---- write word  // ---- write word
   
 static void MEMCALL i286w_wt(UINT32 address, UINT16 value) {  static void MEMCALL i286w_wt(UINT32 address, REG16 value) {
   
         BYTE    *ptr;          BYTE    *ptr;
   
Line 299  static void MEMCALL i286w_wt(UINT32 addr Line 300  static void MEMCALL i286w_wt(UINT32 addr
         STOREINTELWORD(ptr, value);          STOREINTELWORD(ptr, value);
 }  }
   
 static void MEMCALL tramw_wt(UINT32 address, UINT16 value) {  static void MEMCALL tramw_wt(UINT32 address, REG16 value) {
   
         if (address < 0xa1fff) {          if (address < 0xa1fff) {
                 STOREINTELWORD(mem + address, value);                  STOREINTELWORD(mem + address, value);
Line 426  static void MEMCALL tramw_wt(UINT32 addr Line 427  static void MEMCALL tramw_wt(UINT32 addr
         (void)value;                                                                                                    \          (void)value;                                                                                                    \
 }  }
   
 static void MEMCALL vramw_w0(UINT32 address, UINT16 value) GRCGW_NON(0)  static void MEMCALL vramw_w0(UINT32 address, REG16 value) GRCGW_NON(0)
 static void MEMCALL vramw_w1(UINT32 address, UINT16 value) GRCGW_NON(1)  static void MEMCALL vramw_w1(UINT32 address, REG16 value) GRCGW_NON(1)
 static void MEMCALL grcgw_rmw0(UINT32 address, UINT16 value) GRCGW_RMW(0)  static void MEMCALL grcgw_rmw0(UINT32 address, REG16 value) GRCGW_RMW(0)
 static void MEMCALL grcgw_rmw1(UINT32 address, UINT16 value) GRCGW_RMW(1)  static void MEMCALL grcgw_rmw1(UINT32 address, REG16 value) GRCGW_RMW(1)
 static void MEMCALL grcgw_tdw0(UINT32 address, UINT16 value) GRCGW_TDW(0)  static void MEMCALL grcgw_tdw0(UINT32 address, REG16 value) GRCGW_TDW(0)
 static void MEMCALL grcgw_tdw1(UINT32 address, UINT16 value) GRCGW_TDW(1)  static void MEMCALL grcgw_tdw1(UINT32 address, REG16 value) GRCGW_TDW(1)
   
 static void MEMCALL egcw_wt(UINT32 address, UINT16 value) {  static void MEMCALL egcw_wt(UINT32 address, REG16 value) {
   
         if (!(address & 1)) {          if (!(address & 1)) {
                 egc_write_w(address, value);                  egc_write_w(address, value);
         }          }
         else {          else {
                 if (!(egc.sft & 0x1000)) {                  if (!(egc.sft & 0x1000)) {
                         egc_write(address, (BYTE)value);                          egc_write(address, (REG8)value);
                         egc_write(address + 1, (BYTE)(value >> 8));                          egc_write(address + 1, (REG8)(value >> 8));
                 }                  }
                 else {                  else {
                         egc_write(address + 1, (BYTE)(value >> 8));                          egc_write(address + 1, (REG8)(value >> 8));
                         egc_write(address, (BYTE)value);                          egc_write(address, (REG8)value);
                 }                  }
         }          }
 }  }
   
 static void MEMCALL emmcw_wt(UINT32 address, UINT16 value) {  static void MEMCALL emmcw_wt(UINT32 address, REG16 value) {
   
         BYTE    *ptr;          BYTE    *ptr;
   
Line 464  static void MEMCALL emmcw_wt(UINT32 addr Line 465  static void MEMCALL emmcw_wt(UINT32 addr
         }          }
 }  }
   
 static void MEMCALL i286w_wn(UINT32 address, UINT16 value) {  static void MEMCALL i286w_wn(UINT32 address, REG16 value) {
   
         (void)address;          (void)address;
         (void)value;          (void)value;
Line 473  static void MEMCALL i286w_wn(UINT32 addr Line 474  static void MEMCALL i286w_wn(UINT32 addr
   
 // ---- read word  // ---- read word
   
 static UINT16 MEMCALL i286w_rd(UINT32 address) {  static REG16 MEMCALL i286w_rd(UINT32 address) {
   
         BYTE    *ptr;          BYTE    *ptr;
   
Line 481  static UINT16 MEMCALL i286w_rd(UINT32 ad Line 482  static UINT16 MEMCALL i286w_rd(UINT32 ad
         return(LOADINTELWORD(ptr));          return(LOADINTELWORD(ptr));
 }  }
   
 static UINT16 MEMCALL tramw_rd(UINT32 address) {  static REG16 MEMCALL tramw_rd(UINT32 address) {
   
         I286_REMCLOCK -= vramop.tramwait;          I286_REMCLOCK -= vramop.tramwait;
         if (address < (0xa4000 - 1)) {          if (address < (0xa4000 - 1)) {
Line 492  static UINT16 MEMCALL tramw_rd(UINT32 ad Line 493  static UINT16 MEMCALL tramw_rd(UINT32 ad
         }          }
         else if (address < 0xa4fff) {          else if (address < 0xa4fff) {
                 if (address & 1) {                  if (address & 1) {
                         UINT16 ret;                          REG16 ret;
                         ret = fontrom[cgwindow.high + ((address >> 1) & 0x0f)];                          ret = fontrom[cgwindow.high + ((address >> 1) & 0x0f)];
                         ret += fontrom[cgwindow.low + (((address + 1) >> 1) & 0x0f)] << 8;                          ret += fontrom[cgwindow.low + (((address + 1) >> 1) & 0x0f)] << 8;
                         return(ret);                          return(ret);
                 }                  }
                 else {                  else {
                         UINT16 ret;                          REG16 ret;
                         ret = fontrom[cgwindow.low + ((address >> 1) & 0x0f)];                          ret = fontrom[cgwindow.low + ((address >> 1) & 0x0f)];
                         ret += fontrom[cgwindow.high + ((address >> 1) & 0x0f)] << 8;                          ret += fontrom[cgwindow.high + ((address >> 1) & 0x0f)] << 8;
                         return(ret);                          return(ret);
Line 510  static UINT16 MEMCALL tramw_rd(UINT32 ad Line 511  static UINT16 MEMCALL tramw_rd(UINT32 ad
         return(LOADINTELWORD(mem + address));          return(LOADINTELWORD(mem + address));
 }  }
   
 static UINT16 MEMCALL vramw_r0(UINT32 address) {  static REG16 MEMCALL vramw_r0(UINT32 address) {
   
         I286_REMCLOCK -= vramop.vramwait;          I286_REMCLOCK -= vramop.vramwait;
         return(LOADINTELWORD(mem + address));          return(LOADINTELWORD(mem + address));
 }  }
   
 static UINT16 MEMCALL vramw_r1(UINT32 address) {  static REG16 MEMCALL vramw_r1(UINT32 address) {
   
         I286_REMCLOCK -= vramop.vramwait;          I286_REMCLOCK -= vramop.vramwait;
         return(LOADINTELWORD(mem + address + VRAM_STEP));          return(LOADINTELWORD(mem + address + VRAM_STEP));
 }  }
   
 static UINT16 MEMCALL grcgw_tcr0(UINT32 address) {  static REG16 MEMCALL grcgw_tcr0(UINT32 address) {
   
         BYTE    *vram;          BYTE    *vram;
         UINT16  ret;          REG16   ret;
   
         I286_REMCLOCK -= vramop.grcgwait;          I286_REMCLOCK -= vramop.grcgwait;
         ret = 0;          ret = 0;
Line 545  static UINT16 MEMCALL grcgw_tcr0(UINT32  Line 546  static UINT16 MEMCALL grcgw_tcr0(UINT32 
         return(~ret);          return(~ret);
 }  }
   
 static UINT16 MEMCALL grcgw_tcr1(UINT32 address) {  static REG16 MEMCALL grcgw_tcr1(UINT32 address) {
   
         BYTE    *vram;          BYTE    *vram;
         UINT16  ret;          REG16   ret;
   
         I286_REMCLOCK -= vramop.grcgwait;          I286_REMCLOCK -= vramop.grcgwait;
         ret = 0;          ret = 0;
Line 565  static UINT16 MEMCALL grcgw_tcr1(UINT32  Line 566  static UINT16 MEMCALL grcgw_tcr1(UINT32 
         if (!(grcg.modereg & 8)) {          if (!(grcg.modereg & 8)) {
                 ret |= LOADINTELWORD(vram + VRAM1_E) ^ grcg.tile[3].w;                  ret |= LOADINTELWORD(vram + VRAM1_E) ^ grcg.tile[3].w;
         }          }
         return(~ret);          return((UINT16)(~ret));
 }  }
   
 static UINT16 MEMCALL egcw_rd(UINT32 address) {  static REG16 MEMCALL egcw_rd(UINT32 address) {
   
         UINT16 ret;          REG16   ret;
   
         if (!(address & 1)) {          if (!(address & 1)) {
                 return(egc_read_w(address));                  return(egc_read_w(address));
Line 578  static UINT16 MEMCALL egcw_rd(UINT32 add Line 579  static UINT16 MEMCALL egcw_rd(UINT32 add
         else {          else {
                 if (!(egc.sft & 0x1000)) {                  if (!(egc.sft & 0x1000)) {
                         ret = egc_read(address);                          ret = egc_read(address);
                         ret += (UINT16)egc_read(address + 1) << 8;                          ret += egc_read(address + 1) << 8;
                         return(ret);                          return(ret);
                 }                  }
                 else {                  else {
                         UINT16 ret;                          ret = egc_read(address + 1) << 8;
                         ret = (UINT16)egc_read(address + 1) << 8;  
                         ret += egc_read(address);                          ret += egc_read(address);
                         return(ret);                          return(ret);
                 }                  }
         }          }
 }  }
   
 static UINT16 MEMCALL emmcw_rd(UINT32 address) {  static REG16 MEMCALL emmcw_rd(UINT32 address) {
   
         BYTE    *ptr;          BYTE    *ptr;
   
Line 598  static UINT16 MEMCALL emmcw_rd(UINT32 ad Line 598  static UINT16 MEMCALL emmcw_rd(UINT32 ad
         return(LOADINTELWORD(ptr));          return(LOADINTELWORD(ptr));
 }  }
   
 static UINT16 MEMCALL i286w_itf(UINT32 address) {  static REG16 MEMCALL i286w_itf(UINT32 address) {
   
         if (itf.bank) {          if (itf.bank) {
                 address = ITF_ADRS + LOW15(address);                  address = ITF_ADRS + LOW15(address);
Line 609  static UINT16 MEMCALL i286w_itf(UINT32 a Line 609  static UINT16 MEMCALL i286w_itf(UINT32 a
   
 // ---- table  // ---- table
   
 typedef void (MEMCALL * MEM8WRITE)(UINT32 address, BYTE value);  typedef void (MEMCALL * MEM8WRITE)(UINT32 address, REG8 value);
 typedef BYTE (MEMCALL * MEM8READ)(UINT32 address);  typedef REG8 (MEMCALL * MEM8READ)(UINT32 address);
 typedef void (MEMCALL * MEM16WRITE)(UINT32 address, UINT16 value);  typedef void (MEMCALL * MEM16WRITE)(UINT32 address, REG16 value);
 typedef UINT16 (MEMCALL * MEM16READ)(UINT32 address);  typedef REG16 (MEMCALL * MEM16READ)(UINT32 address);
   
 static MEM8WRITE memory_write[] = {  static MEM8WRITE memory_write[] = {
                         i286_wt,        i286_wt,        i286_wt,        i286_wt,                // 00                          i286_wt,        i286_wt,        i286_wt,        i286_wt,                // 00
Line 679  static const MEM16READ vramw_read[] = { Line 679  static const MEM16READ vramw_read[] = {
                         vramw_r0,       vramw_r1,       egcw_rd,        egcw_rd};               // c0 rmw                          vramw_r0,       vramw_r1,       egcw_rd,        egcw_rd};               // c0 rmw
   
   
 static BYTE MEMCALL i286_nonram_r(UINT32 address) {  static REG8 MEMCALL i286_nonram_r(UINT32 address) {
   
         (void)address;          (void)address;
         return(0xff);          return(0xff);
 }  }
   
 static UINT16 MEMCALL i286_nonram_rw(UINT32 address) {  static REG16 MEMCALL i286_nonram_rw(UINT32 address) {
   
         (void)address;          (void)address;
         return(0xffff);          return(0xffff);
Line 724  void MEMCALL i286_vram_dispatch(UINT fun Line 724  void MEMCALL i286_vram_dispatch(UINT fun
         }          }
 }  }
   
 BYTE MEMCALL i286_memoryread(UINT32 address) {  #if defined(MEMORY_DEBUG)
   static REG8 MEMCALL _i286_memoryread(UINT32 address) {
   
         if (address < I286_MEMREADMAX) {          if (address < I286_MEMREADMAX) {
                 return(mem[address]);                  return(mem[address]);
Line 745  BYTE MEMCALL i286_memoryread(UINT32 addr Line 746  BYTE MEMCALL i286_memoryread(UINT32 addr
         }          }
 }  }
   
 UINT16 MEMCALL i286_memoryread_w(UINT32 address) {  static REG16 MEMCALL _i286_memoryread_w(UINT32 address) {
   
         UINT16  ret;          REG16   ret;
   
         if (address < (I286_MEMREADMAX - 1)) {          if (address < (I286_MEMREADMAX - 1)) {
                 return(LOADINTELWORD(mem + address));                  return(LOADINTELWORD(mem + address));
Line 785  UINT16 MEMCALL i286_memoryread_w(UINT32  Line 786  UINT16 MEMCALL i286_memoryread_w(UINT32 
         }          }
 }  }
   
 void MEMCALL i286_memorywrite(UINT32 address, BYTE value) {  REG8 MEMCALL i286_memoryread(UINT32 address) {
   
           REG8    r;
           r = _i286_memoryread(address);
           if (r & 0xffffff00) {
                   TRACEOUT(("error i286_memoryread %x", r));
           }
           return(r);
   }
   
   REG16 MEMCALL i286_memoryread_w(UINT32 address) {
   
           REG16   r;
   
           r = _i286_memoryread_w(address);
           if (r & 0xffff0000) {
                   TRACEOUT(("error i286_memoryread_w %x", r));
           }
           return(r);
   }
   #else
   REG8 MEMCALL i286_memoryread(UINT32 address) {
   
           if (address < I286_MEMREADMAX) {
                   return(mem[address]);
           }
   #if defined(USE_HIMEM)
           else if (address >= 0x10fff0) {
                   address -= 0x100000;
                   if (address < extmemmng_size) {
                           return(extmemmng_ptr[address]);
                   }
                   else {
                           return(0xff);
                   }
           }
   #endif
           else {
                   return(memory_read[(address >> 15) & 0x1f](address));
           }
   }
   
   REG16 MEMCALL i286_memoryread_w(UINT32 address) {
   
           REG16   ret;
   
           if (address < (I286_MEMREADMAX - 1)) {
                   return(LOADINTELWORD(mem + address));
           }
   #if defined(USE_HIMEM)
           else if (address >= (0x10fff0 - 1)) {
                   address -= 0x100000;
                   if (address == (0x00fff0 - 1)) {
                           ret = mem[0x100000 + address];
                   }
                   else if (address < extmemmng_size) {
                           ret = extmemmng_ptr[address];
                   }
                   else {
                           ret = 0xff;
                   }
                   address++;
                   if (address < extmemmng_size) {
                           ret += extmemmng_ptr[address] << 8;
                   }
                   else {
                           ret += 0xff00;
                   }
                   return(ret);
           }
   #endif
           else if ((address & 0x7fff) != 0x7fff) {
                   return(memword_read[(address >> 15) & 0x1f](address));
           }
           else {
                   ret = memory_read[(address >> 15) & 0x1f](address);
                   address++;
                   ret += memory_read[(address >> 15) & 0x1f](address) << 8;
                   return(ret);
           }
   }
   #endif
   
   void MEMCALL i286_memorywrite(UINT32 address, REG8 value) {
   
         if (address < I286_MEMWRITEMAX) {          if (address < I286_MEMWRITEMAX) {
                 mem[address] = value;                  mem[address] = (BYTE)value;
         }          }
 #if defined(USE_HIMEM)  #if defined(USE_HIMEM)
         else if (address >= 0x10fff0) {          else if (address >= 0x10fff0) {
                 address -= 0x100000;                  address -= 0x100000;
                 if (address < extmemmng_size) {                  if (address < extmemmng_size) {
                         extmemmng_ptr[address] = value;                          extmemmng_ptr[address] = (BYTE)value;
                 }                  }
         }          }
 #endif  #endif
Line 803  void MEMCALL i286_memorywrite(UINT32 add Line 887  void MEMCALL i286_memorywrite(UINT32 add
         }          }
 }  }
   
 void MEMCALL i286_memorywrite_w(UINT32 address, UINT16 value) {  void MEMCALL i286_memorywrite_w(UINT32 address, REG16 value) {
   
         if (address < (I286_MEMWRITEMAX - 1)) {          if (address < (I286_MEMWRITEMAX - 1)) {
                 STOREINTELWORD(mem + address, value);                  STOREINTELWORD(mem + address, value);
Line 833  void MEMCALL i286_memorywrite_w(UINT32 a Line 917  void MEMCALL i286_memorywrite_w(UINT32 a
         }          }
 }  }
   
 BYTE MEMCALL i286_membyte_read(UINT seg, UINT off) {  REG8 MEMCALL i286_membyte_read(UINT seg, UINT off) {
   
         UINT32  address;          UINT32  address;
   
Line 846  BYTE MEMCALL i286_membyte_read(UINT seg, Line 930  BYTE MEMCALL i286_membyte_read(UINT seg,
         }          }
 }  }
   
 UINT16 MEMCALL i286_memword_read(UINT seg, UINT off) {  REG16 MEMCALL i286_memword_read(UINT seg, UINT off) {
   
         UINT32  address;          UINT32  address;
   
Line 859  UINT16 MEMCALL i286_memword_read(UINT se Line 943  UINT16 MEMCALL i286_memword_read(UINT se
         }          }
 }  }
   
 void MEMCALL i286_membyte_write(UINT seg, UINT off, BYTE value) {  void MEMCALL i286_membyte_write(UINT seg, UINT off, REG8 value) {
   
         UINT32  address;          UINT32  address;
   
         address = (seg << 4) + off;          address = (seg << 4) + off;
         if (address < I286_MEMWRITEMAX) {          if (address < I286_MEMWRITEMAX) {
                 mem[address] = value;                  mem[address] = (BYTE)value;
         }          }
         else {          else {
                 i286_memorywrite(address, value);                  i286_memorywrite(address, value);
         }          }
 }  }
   
 void MEMCALL i286_memword_write(UINT seg, UINT off, UINT16 value) {  void MEMCALL i286_memword_write(UINT seg, UINT off, REG16 value) {
   
         UINT32  address;          UINT32  address;
   
         address = (seg << 4) + off;          address = (seg << 4) + off;
         if (address < (I286_MEMWRITEMAX - 1)) {          if (address < (I286_MEMWRITEMAX - 1)) {
                 STOREINTELWORD(mem + address,  value);                  STOREINTELWORD(mem + address, value);
         }          }
         else {          else {
                 i286_memorywrite_w(address, value);                  i286_memorywrite_w(address, value);
Removed from v.1.4  
changed lines
  Added in v.1.5

RetroPC.NET-CVS <cvs@retropc.net>