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

Diff for /np2/debugsub.c between versions 1.1.1.1 and 1.14

version 1.1.1.1, 2003/10/16 17:57:09 version 1.14, 2005/03/20 06:09:16
Line 1 Line 1
 #include        "compiler.h"  #include        "compiler.h"
 #include        "strres.h"  #include        "strres.h"
   #include        "textfile.h"
 #include        "dosio.h"  #include        "dosio.h"
 #include        "i286.h"  #include        "cpucore.h"
 #include        "memory.h"  
 #include        "pccore.h"  #include        "pccore.h"
 #include        "iocore.h"  #include        "iocore.h"
 #include        "debugsub.h"  #include        "debugsub.h"
   
   
 static const char s_nv[] = "NV";  #if defined(MACOS)
 static const char s_ov[] = "OV";  #define CRLITERAL       "\r"
 static const char s_dn[] = "DN";  #define CRCONST         str_cr
 static const char s_up[] = "UP";  #elif defined(X11) || defined(SLZAURUS)
 static const char s_di[] = "DI";  #define CRLITERAL       "\n"
 static const char s_ei[] = "EI";  #define CRCONST         str_lf
 static const char s_pl[] = "PL";  #else
 static const char s_ng[] = "NG";  #define CRLITERAL       "\r\n"
 static const char s_nz[] = "NZ";  #define CRCONST         str_crlf
 static const char s_zr[] = "ZR";  #endif
 static const char s_na[] = "NA";  
 static const char s_ac[] = "AC";  
 static const char s_po[] = "PO";  static const OEMCHAR s_nv[] = OEMTEXT("NV");
 static const char s_pe[] = "PE";  static const OEMCHAR s_ov[] = OEMTEXT("OV");
 static const char s_nc[] = "NC";  static const OEMCHAR s_dn[] = OEMTEXT("DN");
 static const char s_cy[] = "CY";  static const OEMCHAR s_up[] = OEMTEXT("UP");
   static const OEMCHAR s_di[] = OEMTEXT("DI");
   static const OEMCHAR s_ei[] = OEMTEXT("EI");
   static const OEMCHAR s_pl[] = OEMTEXT("PL");
   static const OEMCHAR s_ng[] = OEMTEXT("NG");
   static const OEMCHAR s_nz[] = OEMTEXT("NZ");
   static const OEMCHAR s_zr[] = OEMTEXT("ZR");
   static const OEMCHAR s_na[] = OEMTEXT("NA");
   static const OEMCHAR s_ac[] = OEMTEXT("AC");
   static const OEMCHAR s_po[] = OEMTEXT("PO");
   static const OEMCHAR s_pe[] = OEMTEXT("PE");
   static const OEMCHAR s_nc[] = OEMTEXT("NC");
   static const OEMCHAR s_cy[] = OEMTEXT("CY");
   
 static const char *flagstr[16][2] = {  static const OEMCHAR *flagstr[16][2] = {
                                 {NULL, NULL},           // 0x8000                                  {NULL, NULL},           // 0x8000
                                 {NULL, NULL},           // 0x4000                                  {NULL, NULL},           // 0x4000
                                 {NULL, NULL},           // 0x2000                                  {NULL, NULL},           // 0x2000
Line 43  static const char *flagstr[16][2] = { Line 55  static const char *flagstr[16][2] = {
                                 {NULL, NULL},           // 0x0002                                  {NULL, NULL},           // 0x0002
                                 {s_nc, s_cy}};          // 0x0001                                  {s_nc, s_cy}};          // 0x0001
   
 static const char file_i286reg[] = "i286reg.%03u";  static const OEMCHAR file_i286reg[] = OEMTEXT("i286reg.%.3u");
 static const char file_i286cs[] = "i286_cs.%03u";  static const OEMCHAR file_i286cs[] = OEMTEXT("i286_cs.%.3u");
 static const char file_i286ds[] = "i286_ds.%03u";  static const OEMCHAR file_i286ds[] = OEMTEXT("i286_ds.%.3u");
 static const char file_i286es[] = "i286_es.%03u";  static const OEMCHAR file_i286es[] = OEMTEXT("i286_es.%.3u");
 static const char file_i286ss[] = "i286_ss.%03u";  static const OEMCHAR file_i286ss[] = OEMTEXT("i286_ss.%.3u");
 static const char file_i286txt[] = "i286txt.%03u";  static const OEMCHAR file_memorybin[] = OEMTEXT("memory.bin");
 static const char file_memorybin[] = "memory.bin";  
   static const OEMCHAR str_register[] =                                                           \
 static const char str_register[] =                                                                      \                                  OEMTEXT("AX=%.4x  BX=%.4x  CX=%.4x  DX=%.4x  ")         \
                                         "AX=%04x  BX=%04x  CX=%04x  DX=%04x  "                  \                                  OEMTEXT("SP=%.4x  BP=%.4x  SI=%.4x  DI=%.4x")           \
                                         "SP=%04x  BP=%04x  SI=%04x  DI=%04x\n"                  \                                  OEMTEXT(CRLITERAL)                                                                      \
                                         "DS=%04x  ES=%04x  SS=%04x  CS=%04x  "                  \                                  OEMTEXT("DS=%.4x  ES=%.4x  SS=%.4x  CS=%.4x  ")         \
                                         "IP=%04x   ";                                  OEMTEXT("IP=%.4x   ");
 static const char str_picstat[] =                                                                       \  static const OEMCHAR str_picstat[] =                                                            \
                                         "\nPIC0=%02x:%02x:%02x\nPIC1=%02x:%02x:%02x\n"  \                                  OEMTEXT(CRLITERAL)                                                                      \
                                         "8255PORTC = %02x / system-port = %02x";                                  OEMTEXT("PIC0=%.2x:%.2x:%.2x")                                          \
                                   OEMTEXT(CRLITERAL)                                                                      \
                                   OEMTEXT("PIC1=%.2x:%.2x:%.2x")                                          \
 const char *debugsub_flags(UINT16 flag) {                                  OEMTEXT(CRLITERAL)                                                                      \
                                   OEMTEXT("8255PORTC = %.2x / system-port = %.2x");
 static char     work[128];  
         int             i;  
         UINT16  bit;  const OEMCHAR *debugsub_flags(UINT16 flag) {
   
   static OEMCHAR  work[128];
           int                     i;
           UINT16          bit;
   
         work[0] = 0;          work[0] = 0;
         for (i=0, bit=0x8000; bit; i++, bit>>=1) {          for (i=0, bit=0x8000; bit; i++, bit>>=1) {
                 if (flagstr[i][0]) {                  if (flagstr[i][0]) {
                         if (flag & bit) {                          if (flag & bit) {
                                 milstr_ncat(work, flagstr[i][1], sizeof(work));                                  milstr_ncat(work, flagstr[i][1], NELEMENTS(work));
                         }                          }
                         else {                          else {
                                 milstr_ncat(work, flagstr[i][0], sizeof(work));                                  milstr_ncat(work, flagstr[i][0], NELEMENTS(work));
                         }                          }
                         if (bit != 1) {                          if (bit != 1) {
                                 milstr_ncat(work, str_space, sizeof(work));                                  milstr_ncat(work, str_space, NELEMENTS(work));
                         }                          }
                 }                  }
         }          }
         return(work);          return(work);
 }  }
   
 const char *debugsub_regs(void) {  const OEMCHAR *debugsub_regs(void) {
   
 static char work[256];  static OEMCHAR  work[256];
   
         SPRINTF(work, str_register, I286_AX, I286_BX, I286_CX, I286_DX,          OEMSPRINTF(work, str_register,  CPU_AX, CPU_BX, CPU_CX, CPU_DX,
                                                                 I286_SP, I286_BP, I286_SI, I286_DI,                                                                          CPU_SP, CPU_BP, CPU_SI, CPU_DI,
                                                                 I286_DS, I286_ES, I286_SS, I286_CS, I286_IP);                                                                          CPU_DS, CPU_ES, CPU_SS, CPU_CS, CPU_IP);
         milstr_ncat(work, debugsub_flags(I286_FLAG), sizeof(work));          milstr_ncat(work, debugsub_flags(CPU_FLAG), NELEMENTS(work));
         milstr_ncat(work, str_cr, sizeof(work));          milstr_ncat(work, CRCONST, NELEMENTS(work));
         return(work);          return(work);
 }  }
   
 void debugsub_status(void) {  static void writeseg(const OEMCHAR *fname, UINT32 addr, UINT limit) {
   
 static int      filenum = 0;  
         FILEH   fh;          FILEH   fh;
         char    work[512];          UINT    size;
 const char      *p;          UINT8   buf[0x400];                                                             // Stack 0x1000 -> 0x400
   
         SPRINTF(work, file_i286reg, filenum);          fh = file_create_c(fname);
         fh = file_create_c(work);          if (fh == FILEH_INVALID) {
         if (fh != FILEH_INVALID) {                  return;
           }
           limit = min(limit, 0xffff);
           limit++;
           while(limit) {
                   size = min(limit, sizeof(buf));
                   MEML_READ(addr, buf, size);
                   file_write(fh, buf, size);
                   addr += size;
                   limit -= size;
           }
           file_close(fh);
   }
   
   void debugsub_status(void) {
   
   static int              filenum = 0;
           TEXTFILEH       tfh;
           OEMCHAR         work[512];
   const OEMCHAR   *p;
   
           OEMSPRINTF(work, file_i286reg, filenum);
           tfh = textfile_create(file_getcd(work), 0);
           if (tfh != NULL) {
                 p = debugsub_regs();                  p = debugsub_regs();
                 file_write(fh, p, strlen(p));                  textfile_write(tfh, p);
                 SPRINTF(work, str_picstat,                  OEMSPRINTF(work, str_picstat,
                                                                 pic.pi[0].imr, pic.pi[0].irr, pic.pi[0].isr,                                                                  pic.pi[0].imr, pic.pi[0].irr, pic.pi[0].isr,
                                                                 pic.pi[1].imr, pic.pi[1].irr, pic.pi[1].isr,                                                                  pic.pi[1].imr, pic.pi[1].irr, pic.pi[1].isr,
                                                                 mouseif.portc, sysport.c);                                                                  mouseif.upd8255.portc, sysport.c);
                 file_write(fh, work, strlen(work));                  textfile_write(tfh, work);
                 file_close(fh);                  textfile_close(tfh);
         }          }
   
         SPRINTF(work, file_i286cs, filenum);          OEMSPRINTF(work, file_i286cs, filenum);
         fh = file_create_c(work);          writeseg(work, CS_BASE, 0xffff);
         if (fh != FILEH_INVALID) {          OEMSPRINTF(work, file_i286ds, filenum);
                 file_write(fh, &mem[CS_BASE], 0x10000);          writeseg(work, DS_BASE, 0xffff);
                 file_close(fh);          OEMSPRINTF(work, file_i286es, filenum);
         }          writeseg(work, ES_BASE, 0xffff);
         SPRINTF(work, file_i286ds, filenum);          OEMSPRINTF(work, file_i286ss, filenum);
         fh = file_create_c(work);          writeseg(work, SS_BASE, 0xffff);
         if (fh != FILEH_INVALID) {  
                 file_write(fh, &mem[DS_BASE], 0x10000);  
                 file_close(fh);  
         }  
         SPRINTF(work, file_i286es, filenum);  
         fh = file_create_c(work);  
         if (fh != FILEH_INVALID) {  
                 file_write(fh, &mem[ES_BASE], 0x10000);  
                 file_close(fh);  
         }  
         SPRINTF(work, file_i286ss, filenum);  
         fh = file_create_c(work);  
         if (fh != FILEH_INVALID) {  
                 file_write(fh, &mem[SS_BASE], 0x10000);  
                 file_close(fh);  
         }  
         SPRINTF(work, file_i286txt, filenum);  
         fh = file_create_c(work);  
         if (fh != FILEH_INVALID) {  
                 file_write(fh, &mem[0xa0000], 0x4000);  
                 file_close(fh);  
         }  
         filenum++;          filenum++;
 }  }
   
Line 156  void debugsub_memorydump(void) { Line 172  void debugsub_memorydump(void) {
   
         fh = file_create_c(file_memorybin);          fh = file_create_c(file_memorybin);
         if (fh != FILEH_INVALID) {          if (fh != FILEH_INVALID) {
                 for (i=0; i<34; i++) {                  for (i=0; i<34; i++)
   //              for (i=0; i<64; i++)
                   {
                         file_write(fh, mem + i*0x8000, 0x8000);                          file_write(fh, mem + i*0x8000, 0x8000);
                 }                  }
                 file_close(fh);                  file_close(fh);
Removed from v.1.1.1.1  
changed lines
  Added in v.1.14

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