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

Diff for /np2/pccore.c between versions 1.71 and 1.97

version 1.71, 2004/02/19 03:04:01 version 1.97, 2005/02/07 14:46:07
Line 7 Line 7
 #include        "cpucore.h"  #include        "cpucore.h"
 #include        "pccore.h"  #include        "pccore.h"
 #include        "iocore.h"  #include        "iocore.h"
   #include        "gdc_sub.h"
 #include        "cbuscore.h"  #include        "cbuscore.h"
 #include        "pc9861k.h"  #include        "pc9861k.h"
 #include        "mpu98ii.h"  #include        "mpu98ii.h"
Line 20 Line 21
 #include        "maketext.h"  #include        "maketext.h"
 #include        "maketgrp.h"  #include        "maketgrp.h"
 #include        "makegrph.h"  #include        "makegrph.h"
   #include        "makegrex.h"
 #include        "sound.h"  #include        "sound.h"
 #include        "fmboard.h"  #include        "fmboard.h"
 #include        "beep.h"  #include        "beep.h"
Line 39 Line 41
 #include        "debugsub.h"  #include        "debugsub.h"
   
   
         const char      np2version[] = NP2VER_CORE;  const OEMCHAR np2version[] = OEMTEXT(NP2VER_CORE);
   
   #if defined(_WIN32_WCE)
   #define PCBASEMULTIPLE  2
   #else
   #define PCBASEMULTIPLE  4
   #endif
   
   
         NP2CFG  np2cfg = {          NP2CFG  np2cfg = {
                                 0, 1, 0, 32, 0, 0, 0x40,                                  0, 1, 0, 32, 0, 0, 0x40,
                                 0, 0, 0, 0,                                  0, 0, 0, 0,
                                 {0x3e, 0x73, 0x7b}, 0,                                  {0x3e, 0x73, 0x7b}, 0,
                                 0, 0, {1, 1, 6, 1, 8, 1},                                  0, 0, {1, 1, 6, 1, 8, 1},
                                 {{0, {0, }}, {0, {0, }}},  
   
                                 "VX", PCBASECLOCK25, 4,                                  OEMTEXT("VX"), PCBASECLOCK25, PCBASEMULTIPLE,
                                 {0x48, 0x05, 0x04, 0x00, 0x01, 0x00, 0x00, 0x6e},                                  {0x48, 0x05, 0x04, 0x00, 0x01, 0x00, 0x00, 0x6e},
                                 1, 1, 2, 1, 0x000000, 0xffffff,                                  1, 1, 2, 1, 0x000000, 0xffffff,
                                 22050, 800, 4, 0,                                  22050, 500, 4, 0,
                                 {0, 0, 0}, 0xd1, 0x7f, 0xd1, 0, 0, 1,                                  {0, 0, 0}, 0xd1, 0x7f, 0xd1, 0, 0, 1,
                                 3, {0x0c, 0x0c, 0x08, 0x06, 0x03, 0x0c}, 64, 64, 64, 64, 64,                                  3, {0x0c, 0x0c, 0x08, 0x06, 0x03, 0x0c}, 64, 64, 64, 64, 64,
                                 1, 0x82,                                  1, 0x82,
                                 0, {0x17, 0x04, 0x1f}, {0x0c, 0x0c, 0x02, 0x10, 0x3f, 0x3f},                                  0, {0x17, 0x04, 0x1f}, {0x0c, 0x0c, 0x02, 0x10, 0x3f, 0x3f},
                                 3, 1, 80, 0, 0,                                  3, 1, 80, 0, 0,
                                 {"", ""},                                  {OEMTEXT(""), OEMTEXT("")},
 #if defined(SUPPORT_SCSI)  #if defined(SUPPORT_SCSI)
                                 {"", "", "", ""},                                  {OEMTEXT(""), OEMTEXT(""), OEMTEXT(""), OEMTEXT("")},
 #endif  #endif
                                 "", "", ""};                                  OEMTEXT(""), OEMTEXT(""), OEMTEXT("")};
   
         PCCORE  pccore = {      PCBASECLOCK25, 4,          PCCORE  pccore = {      PCBASECLOCK25, PCBASEMULTIPLE,
                                                 0, PCMODEL_VX, 0, 0, {0x3e, 0x73, 0x7b}, 0,                                                  0, PCMODEL_VX, 0, 0, {0x3e, 0x73, 0x7b}, 0,
                                                 0, 0,                                                  0, 0,
                                                 4 * PCBASECLOCK25};                                                  PCBASECLOCK25 * PCBASEMULTIPLE};
   
 static const BYTE msw_default[8] =  
                                                         {0x48, 0x05, 0x04, 0x00, 0x01, 0x00, 0x00, 0x6e};  
   
         BYTE    screenupdate = 3;          UINT8   screenupdate = 3;
         int             screendispflag = 1;          int             screendispflag = 1;
         int             soundrenewal = 0;          int             soundrenewal = 0;
         BOOL    drawframe;          BOOL    drawframe;
Line 81  static const BYTE msw_default[8] = Line 86  static const BYTE msw_default[8] =
   
 // ---------------------------------------------------------------------------  // ---------------------------------------------------------------------------
   
 void getbiospath(char *path, const char *fname, int maxlen) {  void getbiospath(OEMCHAR *path, const OEMCHAR *fname, int maxlen) {
   
 const char      *p;  const OEMCHAR   *p;
   
         p = np2cfg.biospath;          p = np2cfg.biospath;
         if (p[0]) {          if (p[0]) {
Line 121  static void pccore_set(void) { Line 126  static void pccore_set(void) {
         }          }
         else {          else {
                 pccore.baseclock = PCBASECLOCK20;                       // 2.0MHz                  pccore.baseclock = PCBASECLOCK20;                       // 2.0MHz
                 pccore.cpumode = CPUMODE_8MHz;                  pccore.cpumode = CPUMODE_8MHZ;
         }          }
         multiple = np2cfg.multiple;          multiple = np2cfg.multiple;
         if (multiple == 0) {          if (multiple == 0) {
Line 132  static void pccore_set(void) { Line 137  static void pccore_set(void) {
         }          }
         pccore.multiple = multiple;          pccore.multiple = multiple;
         pccore.realclock = pccore.baseclock * multiple;          pccore.realclock = pccore.baseclock * multiple;
 #if 0  
         keybrd.xferclock = pccore.realclock / 1920;  
         gdc.rasterclock = pccore.realclock / 24816;  
         gdc.hsyncclock = (gdc.rasterclock * 4) / 5;  
         gdc.dispclock = pccore.realclock * 50 / 3102;  
         gdc.vsyncclock = pccore.realclock * 5 / 3102;  
 #endif  
         // HDDの接続 (I/Oの使用状態が変わるので..          // HDDの接続 (I/Oの使用状態が変わるので..
         if (np2cfg.dipsw[1] & 0x20) {          if (np2cfg.dipsw[1] & 0x20) {
                 pccore.hddif |= PCHDD_IDE;                  pccore.hddif |= PCHDD_IDE;
Line 168  static void pccore_set(void) { Line 167  static void pccore_set(void) {
   
 // --------------------------------------------------------------------------  // --------------------------------------------------------------------------
   
   #if !defined(DISABLE_SOUND)
 static void sound_init(void) {  static void sound_init(void) {
   
         UINT    rate;          UINT    rate;
Line 201  static void sound_term(void) { Line 201  static void sound_term(void) {
         soundmng_stop();          soundmng_stop();
         amd98_deinitialize();          amd98_deinitialize();
         rhythm_deinitialize();          rhythm_deinitialize();
           beep_deinitialize();
         fddmtrsnd_deinitialize();          fddmtrsnd_deinitialize();
         sound_destroy();          sound_destroy();
 }  }
   #endif
   
 void pccore_init(void) {  void pccore_init(void) {
   
Line 222  void pccore_init(void) { Line 224  void pccore_init(void) {
         gdcsub_initialize();          gdcsub_initialize();
         fddfile_initialize();          fddfile_initialize();
   
   #if !defined(DISABLE_SOUND)
         sound_init();          sound_init();
   #endif
   
         rs232c_construct();          rs232c_construct();
         mpu98ii_construct();          mpu98ii_construct();
Line 241  void pccore_term(void) { Line 245  void pccore_term(void) {
         hostdrv_deinitialize();          hostdrv_deinitialize();
 #endif  #endif
   
   #if !defined(DISABLE_SOUND)
         sound_term();          sound_term();
   #endif
   
         fdd_eject(0);          fdd_eject(0);
         fdd_eject(1);          fdd_eject(1);
Line 267  void pccore_cfgupdate(void) { Line 273  void pccore_cfgupdate(void) {
   
         renewal = FALSE;          renewal = FALSE;
         for (i=0; i<8; i++) {          for (i=0; i<8; i++) {
                 if (np2cfg.memsw[i] != mem[MEMB_MSW + i*4]) {                  if (np2cfg.memsw[i] != mem[MEMX_MSW + i*4]) {
                         np2cfg.memsw[i] = mem[MEMB_MSW + i*4];                          np2cfg.memsw[i] = mem[MEMX_MSW + i*4];
                         renewal = TRUE;                          renewal = TRUE;
                 }                  }
         }          }
Line 282  void pccore_reset(void) { Line 288  void pccore_reset(void) {
         int             i;          int             i;
   
         soundmng_stop();          soundmng_stop();
   #if !defined(DISABLE_SOUND)
         if (soundrenewal) {          if (soundrenewal) {
                 soundrenewal = 0;                  soundrenewal = 0;
                 sound_term();                  sound_term();
                 sound_init();                  sound_init();
         }          }
   #endif
         ZeroMemory(mem, 0x110000);          ZeroMemory(mem, 0x110000);
         ZeroMemory(mem + VRAM1_B, 0x18000);          ZeroMemory(mem + VRAM1_B, 0x18000);
         ZeroMemory(mem + VRAM1_E, 0x08000);          ZeroMemory(mem + VRAM1_E, 0x08000);
Line 354  void pccore_reset(void) { Line 361  void pccore_reset(void) {
   
         bios_initialize();          bios_initialize();
   
         if (np2cfg.ITF_WORK) {          CS_BASE = 0xf0000;
                 CS_BASE = 0xf0000;          CPU_CS = 0xf000;
                 CPU_CS = 0xf000;          CPU_IP = 0xfff0;
                 CPU_IP = 0xfff0;  
         }  
         else {  
                 for (i=0; i<8; i++) {  
                         mem[0xa3fe2 + i*4] = msw_default[i];  
                 }  
                 CS_BASE = 0xfd800;  
                 CPU_CS = 0xfd80;  
                 CPU_IP = 0x0002;  
         }  
         CPU_CLEARPREFETCH();          CPU_CLEARPREFETCH();
         sysmng_cpureset();          sysmng_cpureset();
   
Line 380  void pccore_reset(void) { Line 378  void pccore_reset(void) {
   
 static void drawscreen(void) {  static void drawscreen(void) {
   
         BYTE    timing;          UINT8   timing;
           void    (VRAMCALL * grphfn)(int page, int alldraw);
           UINT8   bit;
   
         tramflag.timing++;          tramflag.timing++;
         timing = ((LOADINTELWORD(gdc.m.para + GDC_CSRFORM + 1)) >> 5) & 0x3e;          timing = ((LOADINTELWORD(gdc.m.para + GDC_CSRFORM + 1)) >> 5) & 0x3e;
Line 398  static void drawscreen(void) { Line 398  static void drawscreen(void) {
                 gdc_updateclock();                  gdc_updateclock();
         }          }
   
         if (drawframe) {          if (!drawframe) {
                 if ((gdcs.textdisp & GDCSCRN_EXT) ||                  return;
                         (gdcs.grphdisp & GDCSCRN_EXT)) {          }
                         if (dispsync_renewalvertical()) {          if ((gdcs.textdisp & GDCSCRN_EXT) || (gdcs.grphdisp & GDCSCRN_EXT)) {
                                 gdcs.textdisp |= GDCSCRN_ALLDRAW2;                  if (dispsync_renewalvertical()) {
                                 gdcs.grphdisp |= GDCSCRN_ALLDRAW2;                          gdcs.textdisp |= GDCSCRN_ALLDRAW2;
                         }                          gdcs.grphdisp |= GDCSCRN_ALLDRAW2;
                 }  
                 if (gdcs.textdisp & GDCSCRN_EXT) {  
                         gdcs.textdisp &= ~GDCSCRN_EXT;  
                         dispsync_renewalhorizontal();  
                         tramflag.renewal |= 1;  
                         if (dispsync_renewalmode()) {  
                                 screenupdate |= 2;  
                         }  
                 }  
                 if (gdcs.palchange) {  
                         gdcs.palchange = 0;  
                         pal_change(0);  
                         screenupdate |= 1;  
                 }                  }
                 if (gdcs.grphdisp & GDCSCRN_EXT) {          }
                         gdcs.grphdisp &= ~GDCSCRN_EXT;          if (gdcs.textdisp & GDCSCRN_EXT) {
                         if (((gdc.clock & 0x80) && (gdc.clock != 0x83)) ||                  gdcs.textdisp &= ~GDCSCRN_EXT;
                                 (gdc.clock == 0x03)) {                  dispsync_renewalhorizontal();
                                 gdc.clock ^= 0x80;                  tramflag.renewal |= 1;
                                 gdcs.grphdisp |= GDCSCRN_ALLDRAW2;                  if (dispsync_renewalmode()) {
                           screenupdate |= 2;
                   }
           }
           if (gdcs.palchange) {
                   gdcs.palchange = 0;
                   pal_change(0);
                   screenupdate |= 1;
           }
           if (gdcs.grphdisp & GDCSCRN_EXT) {
                   gdcs.grphdisp &= ~GDCSCRN_EXT;
                   if (((gdc.clock & 0x80) && (gdc.clock != 0x83)) ||
                           (gdc.clock == 0x03)) {
                           gdc.clock ^= 0x80;
                           gdcs.grphdisp |= GDCSCRN_ALLDRAW2;
                   }
           }
           if (gdcs.grphdisp & GDCSCRN_ENABLE) {
                   if (!(gdc.mode1 & 2)) {
                           grphfn = makegrph;
                           bit = GDCSCRN_MAKE;
                           if (gdcs.disp) {
                                   bit <<= 1;
                           }
   #if defined(SUPPORT_PC9821)
                           if (gdc.analog & 2) {
                                   grphfn = makegrphex;
                                   if (gdc.analog & 4) {
                                           bit = GDCSCRN_MAKE | (GDCSCRN_MAKE << 1);
                                   }
                           }
   #endif
                           if (gdcs.grphdisp & bit) {
                                   (*grphfn)(gdcs.disp, gdcs.grphdisp & bit & GDCSCRN_ALLDRAW2);
                                   gdcs.grphdisp &= ~bit;
                                   screenupdate |= 1;
                         }                          }
                 }                  }
                 if (gdcs.grphdisp & GDCSCRN_ENABLE) {                  else if (gdcs.textdisp & GDCSCRN_ENABLE) {
                         if (!(gdc.mode1 & 2)) {                          if (!gdcs.disp) {
                                 if (!gdcs.disp) {                                  if ((gdcs.grphdisp & GDCSCRN_MAKE) ||
                                         if (gdcs.grphdisp & GDCSCRN_MAKE) {                                          (gdcs.textdisp & GDCSCRN_MAKE)) {
                                                 makegrph(0, gdcs.grphdisp & GDCSCRN_ALLDRAW);                                          if (!(gdc.mode1 & 0x4)) {
                                                 gdcs.grphdisp &= ~GDCSCRN_MAKE;                                                  maketextgrph(0, gdcs.textdisp & GDCSCRN_ALLDRAW,
                                                 screenupdate |= 1;                                                                  gdcs.grphdisp & GDCSCRN_ALLDRAW);
                                         }                                          }
                                 }                                          else {
                                 else {                                                  maketextgrph40(0, gdcs.textdisp & GDCSCRN_ALLDRAW,
                                         if (gdcs.grphdisp & (GDCSCRN_MAKE << 1)) {                                                                  gdcs.grphdisp & GDCSCRN_ALLDRAW);
                                                 makegrph(1, gdcs.grphdisp & (GDCSCRN_ALLDRAW << 1));  
                                                 gdcs.grphdisp &= ~(GDCSCRN_MAKE << 1);  
                                                 screenupdate |= 1;  
                                         }                                          }
                                           gdcs.grphdisp &= ~GDCSCRN_MAKE;
                                           screenupdate |= 1;
                                 }                                  }
                         }                          }
                         else if (gdcs.textdisp & GDCSCRN_ENABLE) {                          else {
                                 if (!gdcs.disp) {                                  if ((gdcs.grphdisp & (GDCSCRN_MAKE << 1)) ||
                                         if ((gdcs.grphdisp & GDCSCRN_MAKE) ||                                          (gdcs.textdisp & GDCSCRN_MAKE)) {
                                                 (gdcs.textdisp & GDCSCRN_MAKE)) {                                          if (!(gdc.mode1 & 0x4)) {
                                                 if (!(gdc.mode1 & 0x4)) {                                                  maketextgrph(1, gdcs.textdisp & GDCSCRN_ALLDRAW,
                                                         maketextgrph(0, gdcs.textdisp & GDCSCRN_ALLDRAW,                                                                  gdcs.grphdisp & (GDCSCRN_ALLDRAW << 1));
                                                                         gdcs.grphdisp & GDCSCRN_ALLDRAW);  
                                                 }  
                                                 else {  
                                                         maketextgrph40(0, gdcs.textdisp & GDCSCRN_ALLDRAW,  
                                                                         gdcs.grphdisp & GDCSCRN_ALLDRAW);  
                                                 }  
                                                 gdcs.grphdisp &= ~GDCSCRN_MAKE;  
                                                 screenupdate |= 1;  
                                         }                                          }
                                 }                                          else {
                                 else {                                                  maketextgrph40(1, gdcs.textdisp & GDCSCRN_ALLDRAW,
                                         if ((gdcs.grphdisp & (GDCSCRN_MAKE << 1)) ||                                                                  gdcs.grphdisp & (GDCSCRN_ALLDRAW << 1));
                                                 (gdcs.textdisp & GDCSCRN_MAKE)) {  
                                                 if (!(gdc.mode1 & 0x4)) {  
                                                         maketextgrph(1, gdcs.textdisp & GDCSCRN_ALLDRAW,  
                                                                         gdcs.grphdisp & (GDCSCRN_ALLDRAW << 1));  
                                                 }  
                                                 else {  
                                                         maketextgrph40(1, gdcs.textdisp & GDCSCRN_ALLDRAW,  
                                                                         gdcs.grphdisp & (GDCSCRN_ALLDRAW << 1));  
                                                 }  
                                                 gdcs.grphdisp &= ~(GDCSCRN_MAKE << 1);  
                                                 screenupdate |= 1;  
                                         }                                          }
                                           gdcs.grphdisp &= ~(GDCSCRN_MAKE << 1);
                                           screenupdate |= 1;
                                 }                                  }
                         }                          }
                 }                  }
           }
                 if (gdcs.textdisp & GDCSCRN_ENABLE) {          if (gdcs.textdisp & GDCSCRN_ENABLE) {
                         if (tramflag.renewal) {                  if (tramflag.renewal) {
                                 gdcs.textdisp |= maketext_curblink();                          gdcs.textdisp |= maketext_curblink();
                         }                  }
                         if ((cgwindow.writable & 0x80) && (tramflag.gaiji)) {                  if ((cgwindow.writable & 0x80) && (tramflag.gaiji)) {
                                 gdcs.textdisp |= GDCSCRN_ALLDRAW;                          gdcs.textdisp |= GDCSCRN_ALLDRAW;
                         }                  }
                         cgwindow.writable &= ~0x80;                  cgwindow.writable &= ~0x80;
                         if (gdcs.textdisp & GDCSCRN_MAKE) {                  if (gdcs.textdisp & GDCSCRN_MAKE) {
                                 if (!(gdc.mode1 & 0x4)) {                          if (!(gdc.mode1 & 0x4)) {
                                         maketext(gdcs.textdisp & GDCSCRN_ALLDRAW);                                  maketext(gdcs.textdisp & GDCSCRN_ALLDRAW);
                                 }  
                                 else {  
                                         maketext40(gdcs.textdisp & GDCSCRN_ALLDRAW);  
                                 }  
                                 gdcs.textdisp &= ~GDCSCRN_MAKE;  
                                 screenupdate |= 1;  
                         }                          }
                           else {
                                   maketext40(gdcs.textdisp & GDCSCRN_ALLDRAW);
                           }
                           gdcs.textdisp &= ~GDCSCRN_MAKE;
                           screenupdate |= 1;
                 }                  }
                 if (screenupdate) {          }
                         screenupdate = scrndraw_draw((BYTE)(screenupdate & 2));          if (screenupdate) {
                         drawcount++;                  screenupdate = scrndraw_draw((UINT8)(screenupdate & 2));
                 }                  drawcount++;
         }          }
 }  }
   
Line 545  void screenvsync(NEVENTITEM item) { Line 548  void screenvsync(NEVENTITEM item) {
   
 // ---------------------------------------------------------------------------  // ---------------------------------------------------------------------------
   
   // #define SINGLESTEPONLY
 // #define      IPTRACE                 (1 << 12)  // #define      IPTRACE                 (1 << 12)
   
 #if defined(TRACE) && IPTRACE  #if defined(TRACE) && IPTRACE
 static UINT             trpos = 0;  static  UINT    trpos = 0;
 static UINT32   treip[IPTRACE];  static  UINT32  treip[IPTRACE];
   
 void iptrace_out(void) {  void iptrace_out(void) {
   
Line 586  UINT cflg; Line 590  UINT cflg;
 #endif  #endif
   
   
   void pccore_postevent(UINT32 event) {   // yet!
   
           (void)event;
   }
   
 void pccore_exec(BOOL draw) {  void pccore_exec(BOOL draw) {
   
         drawframe = draw;          drawframe = draw;
         keystat_sync();  //      keystat_sync();
         soundmng_sync();          soundmng_sync();
         mouseif_sync();          mouseif_sync();
         pal_eventclear();          pal_eventclear();
Line 605  void pccore_exec(BOOL draw) { Line 614  void pccore_exec(BOOL draw) {
   
         while(screendispflag) {          while(screendispflag) {
 #if defined(TRACE)  #if defined(TRACE)
         resetcnt++;                  resetcnt++;
 #endif  #endif
                 pic_irq();                  pic_irq();
                 if (CPU_RESETREQ) {                  if (CPU_RESETREQ) {
                         CPU_RESETREQ = 0;                          CPU_RESETREQ = 0;
 #if 1  
                         CPU_SHUT();                          CPU_SHUT();
 #else  
                         CPU_CS = 0xf000;  
                         CS_BASE = 0xf0000;  
                         CPU_IP = 0xfff0;  
 #if defined(CPUCORE_IA32)  
                         CPU_DX = 0x0300;  
 #endif  
                         CPU_CLEARPREFETCH();  
 #endif  
                 }                  }
   
 #if 1 // ndef TRACE  #if !defined(SINGLESTEPONLY)
                 if (CPU_REMCLOCK > 0) {                  if (CPU_REMCLOCK > 0) {
                         if (!(CPU_TYPE & CPUTYPE_V30)) {                          if (!(CPU_TYPE & CPUTYPE_V30)) {
                                 CPU_EXEC();                                  CPU_EXEC();
Line 634  void pccore_exec(BOOL draw) { Line 633  void pccore_exec(BOOL draw) {
                 }                  }
 #else  #else
                 while(CPU_REMCLOCK > 0) {                  while(CPU_REMCLOCK > 0) {
 #if IPTRACE  
                         treip[trpos & (IPTRACE - 1)] = (CPU_CS << 16) + CPU_IP;  
                         trpos++;  
 #endif  
 #if 0  #if 0
                         if ((CPU_CS == 0xf800) && (CPU_IP == 0x0B5B)) {                          if (CPU_CS == 0x0000) {
                                 TRACEOUT(("%.2x %.2x %.2x %.2x %.2x %.2x %.2x %.2x %.2x %.2x",                                  if (CPU_IP == 0x1191) {
                                                         mem[0x9000], mem[0x9001],                                          char buf[10];
                                                         mem[0x9002], mem[0x9003],                                          int i;
                                                         mem[0x9004], mem[0x9005],                                          for (i=0; i<6; i++) {
                                                         mem[0x9006], mem[0x9007],                                                  buf[i] = MEML_READ8(0x1000, CPU_BX + i);
                                                         mem[0x9008], mem[0x9009]));                                          }
                         }                                          buf[6] = '\0';
                         if ((CPU_CS == 0xf800) && (CPU_IP == 0x15FF)) {                                          TRACEOUT(("load: %s", buf));
                                 TRACEOUT(("DX = %.4x / DS:DI = %.4x:%.4x [%.2x]",                                  }
                                                                         CPU_DX, CPU_DS, CPU_DI, mem[0xa3fe0]));                                  if (CPU_IP == 0x1265) {
                                           TRACEOUT(("%.4x:%.4x addr=%.4x ret=%.4x",
                                                                                           CPU_CS, CPU_IP, CPU_DX,
                                                                                                   MEML_READ16(CPU_SS, CPU_SP)));
                                   }
                         }                          }
 #endif  #endif
 #if 0  #if 0
                         if ((tr & 2) && (mem[0x0471e] == '\\')) {                          if (CPU_CS == 0x0080) {
                                 TRACEOUT(("DTA BREAK %.4x:%.4x", CPU_CS, CPU_IP));                                  if (CPU_IP == 0x052A) {
                                 TRACEOUT(("0471:000e %.2x %.2x %.2x %.2x %.2x %.2x %.2x %.2x",                                          UINT i;
         mem[0x0471e+0], mem[0x0471e+1], mem[0x0471e+2], mem[0x0471e+3],                                          UINT addr;
         mem[0x0471e+4], mem[0x0471e+5], mem[0x0471e+6], mem[0x0471e+7]));                                          char fname[9];
                                 tr -= 2;                                          addr = MEML_READ16(CPU_SS, CPU_BP + 4);
                         }                                          for (i=0; i<8; i++) {
                         // DOS6                                                  fname[i] = MEML_READ8(CPU_DS, addr + i);
                         if (CPU_CS == 0xffd0) {                                          }
                                 if (CPU_IP == 0xc4c2) {                                          fname[8] = 0;
                                         TRACEOUT(("DS:DX = %.4x:%.4x / CX = %.4x", CPU_DS, CPU_DX, CPU_CX));                                          TRACEOUT(("%.4x:%.4x play... addr:%.4x %s",
                                                                                           CPU_CS, CPU_IP, addr, fname));
                                 }                                  }
                                 else if (CPU_IP == 0xc21d) {                          }
                                         TRACEOUT(("-> DS:BX = %.4x:%.4x", CPU_DS, CPU_BX));  #endif
   #if 0
                           if (CPU_CS == 0x800) {
                                   if (CPU_IP == 0x017A) {
                                           TRACEOUT(("%.4x:%.4x solve... DS=%.4x SIZE=%.4x KEY=%.4x",
                                                                   CPU_CS, CPU_IP,
                                                                   MEML_READ16(CPU_SS, CPU_BP - 0x06),
                                                                   CPU_DX,
                                                                   MEML_READ16(CPU_SS, CPU_BP - 0x08)));
                                 }                                  }
                         }                          }
 #endif  #endif
 #if 0  #if 0
                         if ((CPU_CS == 0x0620) || (CPU_CS == 0x08a0)) {                          if (CPU_CS == 0x3d52) {
                                 TRACEOUT(("%.4x:%.4x", CPU_CS, CPU_IP));                                  if (CPU_IP == 0x4A57) {
                                           TRACEOUT(("%.4x:%.4x %.4x:%.4x/%.4x/%.4x",
                                                                   CPU_DX, CPU_BX, CPU_DS,
                                                                   MEML_READ16(CPU_SS, CPU_BP + 0x06),
                                                                   MEML_READ16(CPU_SS, CPU_BP + 0x08),
                                                                   MEML_READ16(CPU_SS, CPU_BP + 0x0a)));
                                   }
                                   if (CPU_IP == 0x4BF8) {
                                           debugsub_memorydump();
                                   }
   #if 1
                                   if (CPU_IP == 0x4B7A) {
                                           TRACEOUT(("datum = %x", CPU_AX));
                                   }
                                   if (CPU_IP == 0x4B87) {
                                           TRACEOUT(("leng = %x", CPU_AX));
                                   }
                                   if (CPU_IP == 0x4BD5) {
                                           TRACEOUT(("%.4x:%.4x <- %.2x[%.4x]",
                                                                   CPU_ES, CPU_BX, CPU_AL, CPU_DI));
                                   }
   #endif
                         }                          }
 #endif  #endif
 #if 0           // VX LIO  #if 0   // DC
                         if (CPU_CS == 0xf990) {                          if (CPU_CS == 0x1000) {
                                 if (CPU_IP == 0x07BE) {                                  if (CPU_IP == 0x5924) {
                                         TRACEOUT(("%d,%d - %d,%d", CPU_BP, CPU_DX, CPU_SI, CPU_DI));                                          TRACEOUT(("%.4x:%.4x -> %.4x:%.4x", CPU_CS, CPU_IP,
                                                           MEML_READ16(CPU_DS, 0x6846),
                                                           MEML_READ16(CPU_DS, 0x6848)));
                                 }                                  }
                         }                          }
 #endif  #endif
 //                      i286x_step();  #if 0   // 羅針盤
                         i286c_step();                          if (CPU_CS == 0x60) {
                                   if (CPU_IP == 0xADF9) {
                                           TRACEOUT(("%.4x:%.4x -> %.4x:%.4x:%.4x", CPU_CS, CPU_IP, CPU_BX, CPU_SI, CPU_AX));
                                   }
                                   else if (CPU_IP == 0xC7E1) {
                                           TRACEOUT(("%.4x:%.4x -> %.4x:%.4x", CPU_CS, CPU_IP, CPU_ES, CPU_BX));
                                   }
                           }
   #endif
   #if 1
                           if (CPU_CS == 0x60) {
                                   if (CPU_IP == 0x8AC2) {
                                           UINT pos = CPU_SI + (CPU_AX * 6);
                                           TRACEOUT(("%.4x:%.4x -> %.4x:%.4x-%.4x:%.4x [%.2x %.2x %.2x %.2x %.2x %.2x]", CPU_CS, CPU_IP, CPU_SI, CPU_AX, CPU_DX, CPU_DI,
   MEML_READ8(CPU_DS, pos+0),
   MEML_READ8(CPU_DS, pos+1),
   MEML_READ8(CPU_DS, pos+2),
   MEML_READ8(CPU_DS, pos+3),
   MEML_READ8(CPU_DS, pos+4),
   MEML_READ8(CPU_DS, pos+5)));
                                   }
                           }
   #endif
   #if IPTRACE
                           treip[trpos & (IPTRACE - 1)] = (CPU_CS << 16) + CPU_IP;
                           trpos++;
   #endif
   //                      TRACEOUT(("%.4x:%.4x", CPU_CS, CPU_IP));
                           CPU_STEPEXEC();
                 }                  }
 #endif  #endif
                 nevent_progress();                  nevent_progress();
Removed from v.1.71  
changed lines
  Added in v.1.97

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