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

Diff for /np2/generic/np2info.c between versions 1.8 and 1.9

version 1.8, 2005/02/07 14:46:10 version 1.9, 2005/02/09 20:11:35
Line 9 Line 9
 #include        "np2info.h"  #include        "np2info.h"
   
   
 static const char str_comma[] = ", ";  static const OEMCHAR str_comma[] = OEMTEXT(", ");
 static const char str_2halfMHz[] = "2.5MHz";  static const OEMCHAR str_2halfMHz[] = OEMTEXT("2.5MHz");
 #define str_5MHz        (str_2halfMHz + 2)  #define str_5MHz        (str_2halfMHz + 2)
 static const char str_8MHz[] = "8MHz";  static const OEMCHAR str_8MHz[] = OEMTEXT("8MHz");
 static const char str_notexist[] = "not exist";  static const OEMCHAR str_notexist[] = OEMTEXT("not exist");
 static const char str_disable[] = "disable";  static const OEMCHAR str_disable[] = OEMTEXT("disable");
   
 static const char str_cpu[] =  static const OEMCHAR str_cpu[] = OEMTEXT("8086-2\00070116\00080286\00080386\00080486\0Pentium\0PentiumPro");
                                                 "8086-2\0"                                      \  static const OEMCHAR str_winclr[] = OEMTEXT("256-colors\00065536-colors\0full color\0true color");
                                                 "70116\0"                                       \  static const OEMCHAR str_winmode[] = OEMTEXT(" (window)\0 (fullscreen)");
                                                 "80286\0"                                       \  static const OEMCHAR str_grcgchip[] = OEMTEXT("\0GRCG \0GRCG CG-Window \0EGC CG-Window ");
                                                 "80386\0"                                       \  static const OEMCHAR str_vrammode[] = OEMTEXT("Digital\0Analog\000256colors");
                                                 "80486\0"                                       \  static const OEMCHAR str_vrampage[] = OEMTEXT(" page-0\0 page-1\0 page-all");
                                                 "Pentium\0"                                     \  static const OEMCHAR str_chpan[] = OEMTEXT("none\0Mono-R\0Mono-L\0Stereo");
                                                 "PentiumPro";  static const OEMCHAR str_fmboard[] = OEMTEXT("none\0PC-9801-14\0PC-9801-26\0PC-9801-86\0PC-9801-26 + 86\0PC-9801-118\0PC-9801-86 + Chibi-oto\0Speak board\0Spark board\0AMD-98");
 static const char str_winclr[] =  
                                                 "256-colors\0"                          \  static const OEMCHAR str_clockfmt[] = OEMTEXT("%d.%1dMHz");
                                                 "65536-colors\0"                        \  static const OEMCHAR str_memfmt[] = OEMTEXT("%3uKB");
                                                 "full color\0"                          \  static const OEMCHAR str_memfmt2[] = OEMTEXT("%3uKB + %uKB");
                                                 "true color";  static const OEMCHAR str_memfmt3[] = OEMTEXT("%d.%1dMB");
 static const char str_winmode[] =  static const OEMCHAR str_twidth[] = OEMTEXT("width-%u");
                                                 " (window)\0"                           \  static const OEMCHAR str_dispclock[] = OEMTEXT("%u.%.2ukHz / %u.%uHz");
                                                 " (fullscreen)";  
 static const char str_grcgchip[] =  static const OEMCHAR str_pcm86a[] = OEMTEXT("   PCM: %dHz %dbit %s");
                                                 "\0"                                            \  static const OEMCHAR str_pcm86b[] = OEMTEXT("        %d / %d / 32768");
                                                 "GRCG \0"                                       \  static const OEMCHAR str_rhythm[] = OEMTEXT("BSCHTR");
                                                 "GRCG CG-Window \0"                     \  
                                                 "EGC CG-Window ";  
 static const char str_vrammode[] =  
                                                 "Digital\0"                                     \  
                                                 "Analog\0"                                      \  
                                                 "256colors";  
 static const char str_vrampage[] =  
                                                 " page-0\0"                                     \  
                                                 " page-1\0"                                     \  
                                                 " page-all";  
 static const char str_chpan[] =  
                                                 "none\0"                                        \  
                                                 "Mono-R\0"                                      \  
                                                 "Mono-L\0"                                      \  
                                                 "Stereo";  
 static const char str_fmboard[] =  
                                                 "none\0"                                        \  
                                                 "PC-9801-14\0"                          \  
                                                 "PC-9801-26\0"                          \  
                                                 "PC-9801-86\0"                          \  
                                                 "PC-9801-26 + 86\0"                     \  
                                                 "PC-9801-118\0"                         \  
                                                 "PC-9801-86 + Chibi-oto\0"      \  
                                                 "Speak board\0"                         \  
                                                 "Spark board\0"                         \  
                                                 "AMD-98";  
   
 static const char str_clockfmt[] = "%d.%1dMHz";  
 static const char str_memfmt[] = "%3uKB";  
 static const char str_memfmt2[] = "%3uKB + %uKB";  
 static const char str_memfmt3[] = "%d.%1dMB";  
 static const char str_width[] = "width-%u";  
 static const char str_dispclock[] = "%u.%.2ukHz / %u.%uHz";  
   
 static const char str_pcm86a[] = "   PCM: %dHz %dbit %s";  
 static const char str_pcm86b[] = "        %d / %d / 32768";  
 static const char str_rhythm[] = "BSCHTR";  
   
   
 // ---- common  // ---- common
   
 static void info_ver(char *str, int maxlen, NP2INFOEX *ex) {  static void info_ver(OEMCHAR *str, int maxlen, const NP2INFOEX *ex) {
   
         milstr_ncpy(str, np2version, maxlen);          milstr_ncpy(str, np2version, maxlen);
         (void)ex;          (void)ex;
 }  }
   
 static void info_cpu(char *str, int maxlen, NP2INFOEX *ex) {  static void info_cpu(OEMCHAR *str, int maxlen, const NP2INFOEX *ex) {
   
         UINT    family;          UINT    family;
   
Line 95  static void info_cpu(char *str, int maxl Line 58  static void info_cpu(char *str, int maxl
         (void)ex;          (void)ex;
 }  }
   
 static void info_clock(char *str, int maxlen, NP2INFOEX *ex) {  static void info_clock(OEMCHAR *str, int maxlen, const NP2INFOEX *ex) {
   
         UINT32  clock;          UINT32  clock;
         char    clockstr[16];          OEMCHAR clockstr[16];
   
         clock = (pccore.realclock + 50000) / 100000;          clock = (pccore.realclock + 50000) / 100000;
         SPRINTF(clockstr, str_clockfmt, clock/10, clock % 10);          OEMSPRINTF(clockstr, str_clockfmt, clock/10, clock % 10);
         milstr_ncpy(str, clockstr, maxlen);          milstr_ncpy(str, clockstr, maxlen);
         (void)ex;          (void)ex;
 }  }
   
 static void info_base(char *str, int maxlen, NP2INFOEX *ex) {  static void info_base(OEMCHAR *str, int maxlen, const NP2INFOEX *ex) {
   
         milstr_ncpy(str,          milstr_ncpy(str,
                                 (pccore.cpumode & CPUMODE_8MHZ)?str_8MHz:str_5MHz, maxlen);                                  (pccore.cpumode & CPUMODE_8MHZ)?str_8MHz:str_5MHz, maxlen);
         (void)ex;          (void)ex;
 }  }
   
 static void info_mem1(char *str, int maxlen, NP2INFOEX *ex) {  static void info_mem1(OEMCHAR *str, int maxlen, const NP2INFOEX *ex) {
   
         UINT    memsize;          UINT    memsize;
         char    memstr[32];          OEMCHAR memstr[32];
   
         memsize = np2cfg.memsw[2] & 7;          memsize = np2cfg.memsw[2] & 7;
         if (memsize < 6) {          if (memsize < 6) {
Line 126  static void info_mem1(char *str, int max Line 89  static void info_mem1(char *str, int max
                 memsize = 640;                  memsize = 640;
         }          }
         if (pccore.extmem) {          if (pccore.extmem) {
                 SPRINTF(memstr, str_memfmt2, memsize, pccore.extmem * 1024);                  OEMSPRINTF(memstr, str_memfmt2, memsize, pccore.extmem * 1024);
         }          }
         else {          else {
                 SPRINTF(memstr, str_memfmt, memsize);                  OEMSPRINTF(memstr, str_memfmt, memsize);
         }          }
         milstr_ncpy(str, memstr, maxlen);          milstr_ncpy(str, memstr, maxlen);
         (void)ex;          (void)ex;
 }  }
   
 static void info_mem2(char *str, int maxlen, NP2INFOEX *ex) {  static void info_mem2(OEMCHAR *str, int maxlen, const NP2INFOEX *ex) {
   
         UINT    memsize;          UINT    memsize;
         char    memstr[16];          OEMCHAR memstr[16];
   
         memsize = np2cfg.memsw[2] & 7;          memsize = np2cfg.memsw[2] & 7;
         if (memsize < 6) {          if (memsize < 6) {
Line 148  static void info_mem2(char *str, int max Line 111  static void info_mem2(char *str, int max
                 memsize = 640;                  memsize = 640;
         }          }
         memsize += pccore.extmem * 1024;          memsize += pccore.extmem * 1024;
         SPRINTF(memstr, str_memfmt, memsize);          OEMSPRINTF(memstr, str_memfmt, memsize);
         milstr_ncpy(str, memstr, maxlen);          milstr_ncpy(str, memstr, maxlen);
         (void)ex;          (void)ex;
 }  }
   
 static void info_mem3(char *str, int maxlen, NP2INFOEX *ex) {  static void info_mem3(OEMCHAR *str, int maxlen, const NP2INFOEX *ex) {
   
         UINT    memsize;          UINT    memsize;
         char    memstr[16];          OEMCHAR memstr[16];
   
         memsize = np2cfg.memsw[2] & 7;          memsize = np2cfg.memsw[2] & 7;
         if (memsize < 6) {          if (memsize < 6) {
Line 166  static void info_mem3(char *str, int max Line 129  static void info_mem3(char *str, int max
                 memsize = 640;                  memsize = 640;
         }          }
         if (pccore.extmem > 1) {          if (pccore.extmem > 1) {
                 SPRINTF(memstr, str_memfmt3, pccore.extmem, memsize / 100);                  OEMSPRINTF(memstr, str_memfmt3, pccore.extmem, memsize / 100);
         }          }
         else {          else {
                 SPRINTF(memstr, str_memfmt, memsize);                  OEMSPRINTF(memstr, str_memfmt, memsize);
         }          }
         milstr_ncpy(str, memstr, maxlen);          milstr_ncpy(str, memstr, maxlen);
         (void)ex;          (void)ex;
 }  }
   
 static void info_gdc(char *str, int maxlen, NP2INFOEX *ex) {  static void info_gdc(OEMCHAR *str, int maxlen, const NP2INFOEX *ex) {
   
         milstr_ncpy(str, milstr_list(str_grcgchip, grcg.chip & 3), maxlen);          milstr_ncpy(str, milstr_list(str_grcgchip, grcg.chip & 3), maxlen);
         milstr_ncat(str, str_2halfMHz + ((gdc.clock & 0x80)?2:0), maxlen);          milstr_ncat(str, str_2halfMHz + ((gdc.clock & 0x80)?2:0), maxlen);
         (void)ex;          (void)ex;
 }  }
   
 static void info_gdc2(char *str, int maxlen, NP2INFOEX *ex) {  static void info_gdc2(OEMCHAR *str, int maxlen, const NP2INFOEX *ex) {
   
         char    textstr[32];          OEMCHAR textstr[32];
   
         SPRINTF(textstr, str_dispclock,          OEMSPRINTF(textstr, str_dispclock,
                                                 gdc.hclock / 1000, (gdc.hclock / 10) % 100,                                                  gdc.hclock / 1000, (gdc.hclock / 10) % 100,
                                                 gdc.vclock / 10, gdc.vclock % 10);                                                  gdc.vclock / 10, gdc.vclock % 10);
         milstr_ncpy(str, textstr, maxlen);          milstr_ncpy(str, textstr, maxlen);
         (void)ex;          (void)ex;
 }  }
   
 static void info_text(char *str, int maxlen, NP2INFOEX *ex) {  static void info_text(OEMCHAR *str, int maxlen, const NP2INFOEX *ex) {
   
 const char      *p;  const OEMCHAR   *p;
         char    textstr[64];          OEMCHAR         textstr[64];
   
         if (!(gdcs.textdisp & GDCSCRN_ENABLE)) {          if (!(gdcs.textdisp & GDCSCRN_ENABLE)) {
                 p = str_disable;                  p = str_disable;
         }          }
         else {          else {
                 SPRINTF(textstr, str_width, ((gdc.mode1 & 0x4)?40:80));                  OEMSPRINTF(textstr, str_twidth, ((gdc.mode1 & 0x4)?40:80));
                 p = textstr;                  p = textstr;
         }          }
         milstr_ncpy(str, p, maxlen);          milstr_ncpy(str, p, maxlen);
         (void)ex;          (void)ex;
 }  }
   
 static void info_grph(char *str, int maxlen, NP2INFOEX *ex) {  static void info_grph(OEMCHAR *str, int maxlen, const NP2INFOEX *ex) {
   
 const char      *p;  const OEMCHAR   *p;
         UINT    md;          UINT            md;
         UINT    pg;          UINT            pg;
         char    grphstr[32];          OEMCHAR         work[32];
   
         if (!(gdcs.grphdisp & GDCSCRN_ENABLE)) {          if (!(gdcs.grphdisp & GDCSCRN_ENABLE)) {
                 p = str_disable;                  p = str_disable;
Line 230  const char *p; Line 193  const char *p;
                         }                          }
                 }                  }
 #endif  #endif
                 milstr_ncpy(grphstr, milstr_list(str_vrammode, md), sizeof(grphstr));                  milstr_ncpy(work, milstr_list(str_vrammode, md), NELEMENTS(work));
                 milstr_ncat(grphstr, milstr_list(str_vrampage, pg), sizeof(grphstr));                  milstr_ncat(work, milstr_list(str_vrampage, pg), NELEMENTS(work));
                 p = grphstr;                  p = work;
         }          }
         milstr_ncpy(str, p, maxlen);          milstr_ncpy(str, p, maxlen);
         (void)ex;          (void)ex;
 }  }
   
 static void info_sound(char *str, int maxlen, NP2INFOEX *ex) {  static void info_sound(OEMCHAR *str, int maxlen, const NP2INFOEX *ex) {
   
         UINT    type;          UINT    type;
   
Line 284  static void info_sound(char *str, int ma Line 247  static void info_sound(char *str, int ma
         (void)ex;          (void)ex;
 }  }
   
 static void info_extsnd(char *str, int maxlen, NP2INFOEX *ex) {  static void info_extsnd(OEMCHAR *str, int maxlen, const NP2INFOEX *ex) {
   
         char    buf[64];          OEMCHAR buf[64];
   
         info_sound(str, maxlen, ex);          info_sound(str, maxlen, ex);
         if (usesound & 4) {          if (usesound & 4) {
                 milstr_ncat(str, ex->cr, maxlen);                  milstr_ncat(str, ex->cr, maxlen);
                 SPRINTF(buf, str_pcm86a,                  OEMSPRINTF(buf, str_pcm86a,
                                                         pcm86rate8[pcm86.fifo & 7] >> 3,                                                          pcm86rate8[pcm86.fifo & 7] >> 3,
                                                         (16 - ((pcm86.dactrl >> 3) & 8)),                                                          (16 - ((pcm86.dactrl >> 3) & 8)),
                                                         milstr_list(str_chpan, (pcm86.dactrl >> 4) & 3));                                                          milstr_list(str_chpan, (pcm86.dactrl >> 4) & 3));
                 milstr_ncat(str, buf, maxlen);                  milstr_ncat(str, buf, maxlen);
                 milstr_ncat(str, ex->cr, maxlen);                  milstr_ncat(str, ex->cr, maxlen);
                 SPRINTF(buf, str_pcm86b, pcm86.virbuf, pcm86.fifosize);                  OEMSPRINTF(buf, str_pcm86b, pcm86.virbuf, pcm86.fifosize);
                 milstr_ncat(str, buf, maxlen);                  milstr_ncat(str, buf, maxlen);
         }          }
 }  }
   
 static void info_bios(char *str, int maxlen, NP2INFOEX *ex) {  static void info_bios(OEMCHAR *str, int maxlen, const NP2INFOEX *ex) {
   
         str[0] = '\0';          str[0] = '\0';
         if (pccore.rom & PCROM_BIOS) {          if (pccore.rom & PCROM_BIOS) {
Line 320  static void info_bios(char *str, int max Line 283  static void info_bios(char *str, int max
         (void)ex;          (void)ex;
 }  }
   
 static void info_rhythm(char *str, int maxlen, NP2INFOEX *ex) {  static void info_rhythm(OEMCHAR *str, int maxlen, const NP2INFOEX *ex) {
   
         char    rhythmstr[8];          OEMCHAR rhythmstr[8];
         UINT    exist;          UINT    exist;
         UINT    i;          UINT    i;
   
         exist = rhythm_getcaps();          exist = rhythm_getcaps();
         milstr_ncpy(rhythmstr, str_rhythm, sizeof(rhythmstr));          milstr_ncpy(rhythmstr, str_rhythm, NELEMENTS(rhythmstr));
         for (i=0; i<6; i++) {          for (i=0; i<6; i++) {
                 if (!(exist & (1 << i))) {                  if (!(exist & (1 << i))) {
                         rhythmstr[i] = '_';                          rhythmstr[i] = '_';
Line 337  static void info_rhythm(char *str, int m Line 300  static void info_rhythm(char *str, int m
         (void)ex;          (void)ex;
 }  }
   
 static void info_display(char *str, int maxlen, NP2INFOEX *ex) {  static void info_display(OEMCHAR *str, int maxlen, const NP2INFOEX *ex) {
   
         UINT    bpp;          UINT    bpp;
   
Line 352  static void info_display(char *str, int  Line 315  static void info_display(char *str, int 
 // ---- make string  // ---- make string
   
 typedef struct {  typedef struct {
         char    key[8];          OEMCHAR key[8];
         void    (*proc)(char *str, int maxlen, NP2INFOEX *ex);          void    (*proc)(OEMCHAR *str, int maxlen, const NP2INFOEX *ex);
 } INFOPROC;  } INFOPROC;
   
 static const INFOPROC infoproc[] = {  static const INFOPROC infoproc[] = {
                         {"VER",                 info_ver},                          {OEMTEXT("VER"),        info_ver},
                         {"CPU",                 info_cpu},                          {OEMTEXT("CPU"),        info_cpu},
                         {"CLOCK",               info_clock},                          {OEMTEXT("CLOCK"),      info_clock},
                         {"BASE",                info_base},                          {OEMTEXT("BASE"),       info_base},
                         {"MEM1",                info_mem1},                          {OEMTEXT("MEM1"),       info_mem1},
                         {"MEM2",                info_mem2},                          {OEMTEXT("MEM2"),       info_mem2},
                         {"MEM3",                info_mem3},                          {OEMTEXT("MEM3"),       info_mem3},
                         {"GDC",                 info_gdc},                          {OEMTEXT("GDC"),        info_gdc},
                         {"GDC2",                info_gdc2},                          {OEMTEXT("GDC2"),       info_gdc2},
                         {"TEXT",                info_text},                          {OEMTEXT("TEXT"),       info_text},
                         {"GRPH",                info_grph},                          {OEMTEXT("GRPH"),       info_grph},
                         {"SND",                 info_sound},                          {OEMTEXT("SND"),        info_sound},
                         {"EXSND",               info_extsnd},                          {OEMTEXT("EXSND"),      info_extsnd},
                         {"BIOS",                info_bios},                          {OEMTEXT("BIOS"),       info_bios},
                         {"RHYTHM",              info_rhythm},                          {OEMTEXT("RHYTHM"),     info_rhythm},
                         {"DISP",                info_display}};                          {OEMTEXT("DISP"),       info_display}};
   
   
 static BOOL defext(char *dst, const char *key, int maxlen, NP2INFOEX *ex) {  static BOOL defext(OEMCHAR *dst, const OEMCHAR *key, int maxlen,
                                                                                                                   const NP2INFOEX *ex) {
   
         milstr_ncpy(dst, key, maxlen);          milstr_ncpy(dst, key, maxlen);
         (void)ex;          (void)ex;
         return(TRUE);          return(TRUE);
 }  }
   
 void np2info(char *dst, const char *src, int maxlen, const NP2INFOEX *ex) {  void np2info(OEMCHAR *dst, const OEMCHAR *src, int maxlen,
                                                                                                                   const NP2INFOEX *ex) {
   
         NP2INFOEX       statex;          NP2INFOEX       statex;
         char            c;          OEMCHAR         c;
         int                     leng;          int                     leng;
         char            infwork[12];          OEMCHAR         infwork[12];
 const INFOPROC  *inf;  const INFOPROC  *inf;
 const INFOPROC  *infterm;  const INFOPROC  *infterm;
   
Line 395  const INFOPROC *infterm; Line 360  const INFOPROC *infterm;
                 return;                  return;
         }          }
         if (ex == NULL) {          if (ex == NULL) {
                 milstr_ncpy(statex.cr, str_oscr, sizeof(statex.cr));                  milstr_ncpy(statex.cr, str_oscr, NELEMENTS(statex.cr));
                 statex.ext = NULL;                  statex.ext = NULL;
         }          }
         else {          else {
Line 434  const INFOPROC *infterm; Line 399  const INFOPROC *infterm;
                                 if (c == '%') {                                  if (c == '%') {
                                         break;                                          break;
                                 }                                  }
                                 if (leng < (int)(sizeof(infwork) - 1)) {                                  if (leng < (int)(NELEMENTS(infwork) - 1)) {
                                         infwork[leng++] = c;                                          infwork[leng++] = c;
                                 }                                  }
                         }                          }
Line 454  const INFOPROC *infterm; Line 419  const INFOPROC *infterm;
                                 }                                  }
                         }                          }
                 }                  }
                 leng = strlen(dst);                  leng = OEMSTRLEN(dst);
                 dst += leng;                  dst += leng;
                 maxlen -= leng;                  maxlen -= leng;
         }          }
Removed from v.1.8  
changed lines
  Added in v.1.9

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