[BACK]Return to ini.cpp CVS log [TXT] [DIR] Up to [RetroPC.NET] / np2 / win9x

Diff for /np2/win9x/ini.cpp between versions 1.7 and 1.35

version 1.7, 2003/10/29 14:02:35 version 1.35, 2005/03/16 06:05:18
Line 2 Line 2
 #include        <windowsx.h>  #include        <windowsx.h>
 #include        <io.h>  #include        <io.h>
 #include        "strres.h"  #include        "strres.h"
   #include        "profile.h"
 #include        "np2.h"  #include        "np2.h"
 #include        "np2arg.h"  #include        "np2arg.h"
   #if defined(OSLANG_UCS2)
   #include        "oemtext.h"
   #endif
 #include        "dosio.h"  #include        "dosio.h"
 #include        "ini.h"  #include        "ini.h"
 #include        "winkbd.h"  #include        "winkbd.h"
 #include        "pccore.h"  #include        "pccore.h"
   
   
 static void inirdargs16(const char *src, const INITBL *ini) {  
   static BOOL inigetbmp(const UINT8 *ptr, UINT pos) {
   
           return((ptr[pos >> 3] >> (pos & 7)) & 1);
   }
   
   static void inisetbmp(UINT8 *ptr, UINT pos, BOOL set) {
   
           UINT8   bit;
   
           ptr += (pos >> 3);
           bit = 1 << (pos & 7);
           if (set) {
                   *ptr |= bit;
           }
           else {
                   *ptr &= ~bit;
           }
   }
   
   static void inirdargs16(const OEMCHAR *src, const INITBL *ini) {
   
         SINT16  *dst;          SINT16  *dst;
         int             dsize;          int             dsize;
         int             i;          int             i;
         char    c;          OEMCHAR c;
   
         dst = (SINT16 *)ini->value;          dst = (SINT16 *)ini->value;
         dsize = ini->arg;          dsize = ini->arg;
Line 37  static void inirdargs16(const char *src, Line 61  static void inirdargs16(const char *src,
         }          }
 }  }
   
 static void inirdargh8(const char *src, const INITBL *ini) {  static void inirdargh8(const OEMCHAR *src, const INITBL *ini) {
   
         BYTE    *dst;          UINT8   *dst;
         int             dsize;          int             dsize;
         int             i;          int             i;
         BYTE    val;          UINT8   val;
         BOOL    set;          BOOL    set;
         char    c;          OEMCHAR c;
   
         dst = (BYTE *)ini->value;          dst = (UINT8 *)ini->value;
         dsize = ini->arg;          dsize = ini->arg;
   
         for (i=0; i<dsize; i++) {          for (i=0; i<dsize; i++) {
Line 82  static void inirdargh8(const char *src,  Line 106  static void inirdargh8(const char *src, 
         }          }
 }  }
   
 static void iniwrsetargh8(char *work, int size, const INITBL *ini) {  static void iniwrsetargh8(OEMCHAR *work, int size, const INITBL *ini) {
   
         UINT    i;          UINT    i;
 const BYTE      *ptr;  const UINT8     *ptr;
         UINT    arg;          UINT    arg;
         char    tmp[8];          OEMCHAR tmp[8];
   
         ptr = (BYTE *)ini->value;          ptr = (UINT8 *)ini->value;
         arg = ini->arg;          arg = ini->arg;
         if (arg > 0) {          if (arg > 0) {
                 SPRINTF(tmp, "%.2x", ptr[0]);                  OEMSPRINTF(tmp, OEMTEXT("%.2x"), ptr[0]);
                 milstr_ncpy(work, tmp, size);                  milstr_ncpy(work, tmp, size);
         }          }
         for (i=1; i<arg; i++) {          for (i=1; i<arg; i++) {
                 SPRINTF(tmp, " %.2x", ptr[i]);                  OEMSPRINTF(tmp, OEMTEXT(" %.2x"), ptr[i]);
                 milstr_ncat(work, tmp, size);                  milstr_ncat(work, tmp, size);
         }          }
 }  }
Line 104  const BYTE *ptr; Line 128  const BYTE *ptr;
   
 // ---- user  // ---- user
   
 static void inirdbyte3(const char *src, const INITBL *ini) {  static void inirdbyte3(const OEMCHAR *src, const INITBL *ini) {
   
         UINT    i;          UINT    i;
   
Line 114  static void inirdbyte3(const char *src,  Line 138  static void inirdbyte3(const char *src, 
                 }                  }
                 if ((((src[i] - '0') & 0xff) < 9) ||                  if ((((src[i] - '0') & 0xff) < 9) ||
                         (((src[i] - 'A') & 0xdf) < 26)) {                          (((src[i] - 'A') & 0xdf) < 26)) {
                         ((BYTE *)ini->value)[i] = src[i];                          ((UINT8 *)ini->value)[i] = (UINT8)src[i];
                 }                  }
         }          }
 }  }
   
 static void inirdkb(const char *src, const INITBL *ini) {  static void inirdkb(const OEMCHAR *src, const INITBL *ini) {
   
         if ((!milstr_extendcmp(src, "PC98")) ||          if ((!milstr_extendcmp(src, OEMTEXT("PC98"))) ||
                 (!milstr_cmp(src, "98"))) {                  (!milstr_cmp(src, OEMTEXT("98")))) {
                 *(BYTE *)ini->value = KEY_PC98;                  *(UINT8 *)ini->value = KEY_PC98;
         }          }
         else if ((!milstr_extendcmp(src, "DOS")) ||          else if ((!milstr_extendcmp(src, OEMTEXT("DOS"))) ||
                         (!milstr_cmp(src, "PCAT")) ||                          (!milstr_cmp(src, OEMTEXT("PCAT"))) ||
                         (!milstr_cmp(src, "AT"))) {                          (!milstr_cmp(src, OEMTEXT("AT")))) {
                 *(BYTE *)ini->value = KEY_KEY106;                  *(UINT8 *)ini->value = KEY_KEY106;
         }          }
         else if ((!milstr_extendcmp(src, "KEY101")) ||          else if ((!milstr_extendcmp(src, OEMTEXT("KEY101"))) ||
                         (!milstr_cmp(src, "101"))) {                          (!milstr_cmp(src, OEMTEXT("101")))) {
                 *(BYTE *)ini->value = KEY_KEY101;                  *(UINT8 *)ini->value = KEY_KEY101;
         }          }
 }  }
   
   
 // ----  // ----
   
 void ini_read(const char *path, const char *title,  void ini_read(const OEMCHAR *path, const OEMCHAR *title,
                                                                                         const INITBL *tbl, UINT count) {                                                                                          const INITBL *tbl, UINT count) {
   
 const INITBL    *p;  const INITBL    *p;
 const INITBL    *pterm;  const INITBL    *pterm;
         char            work[512];  #if defined(OSLANG_UCS2)
           OEMCHAR         item[10];
   #else
   const OEMCHAR   *item;
   #endif
           OEMCHAR         work[512];
         UINT32          val;          UINT32          val;
   
         p = tbl;          p = tbl;
         pterm = tbl + count;          pterm = tbl + count;
         while(p < pterm) {          while(p < pterm) {
   #if defined(OSLANG_UCS2)
                   oemtext_sjistooem(item, NELEMENTS(item), p->item, (UINT)-1);
   #else
                   item = p->item;
   #endif
                 switch(p->itemtype & INITYPE_MASK) {                  switch(p->itemtype & INITYPE_MASK) {
                         case INITYPE_STR:                          case INITYPE_STR:
                                 GetPrivateProfileString(title, p->item, (char *)p->value,                                  GetPrivateProfileString(title, item, (OEMCHAR *)p->value,
                                                                                         (char *)p->value, p->arg, path);                                                                                          (OEMCHAR *)p->value, p->arg, path);
                                 break;                                  break;
   
                         case INITYPE_BOOL:                          case INITYPE_BOOL:
                                 GetPrivateProfileString(title, p->item,                                  GetPrivateProfileString(title, item,
                                                                         (*((BYTE *)p->value))?str_true:str_false,                                                                          (*((UINT8 *)p->value))?str_true:str_false,
                                                                                                 work, sizeof(work), path);                                                                                                  work, NELEMENTS(work), path);
                                 *((BYTE *)p->value) = (!milstr_cmp(work, str_true))?1:0;                                  *((UINT8 *)p->value) = (!milstr_cmp(work, str_true))?1:0;
                                   break;
   
                           case INITYPE_BITMAP:
                                   GetPrivateProfileString(title, item,
                                           (inigetbmp((UINT8 *)p->value, p->arg))?str_true:str_false,
                                                                                                   work, NELEMENTS(work), path);
                                   inisetbmp((UINT8 *)p->value, p->arg,
                                                                                   (milstr_cmp(work, str_true) == 0));
                                 break;                                  break;
   
                         case INITYPE_ARGS16:                          case INITYPE_ARGS16:
                                 GetPrivateProfileString(title, p->item, str_null,                                  GetPrivateProfileString(title, item, str_null,
                                                                                                 work, sizeof(work), path);                                                                                                  work, NELEMENTS(work), path);
                                 inirdargs16(work, p);                                  inirdargs16(work, p);
                                 break;                                  break;
   
                         case INITYPE_ARGH8:                          case INITYPE_ARGH8:
                                 GetPrivateProfileString(title, p->item, str_null,                                  GetPrivateProfileString(title, item, str_null,
                                                                                                 work, sizeof(work), path);                                                                                                  work, NELEMENTS(work), path);
                                 inirdargh8(work, p);                                  inirdargh8(work, p);
                                 break;                                  break;
   
                         case INITYPE_SINT8:                          case INITYPE_SINT8:
                         case INITYPE_UINT8:                          case INITYPE_UINT8:
                                 val = (BYTE)GetPrivateProfileInt(title, p->item,                                  val = (UINT8)GetPrivateProfileInt(title, item,
                                                                                                 *(BYTE *)p->value, path);                                                                                                  *(UINT8 *)p->value, path);
                                 *(BYTE *)p->value = (BYTE)val;                                  *(UINT8 *)p->value = (UINT8)val;
                                 break;                                  break;
   
                         case INITYPE_SINT16:                          case INITYPE_SINT16:
                         case INITYPE_UINT16:                          case INITYPE_UINT16:
                                 val = (UINT16)GetPrivateProfileInt(title, p->item,                                  val = (UINT16)GetPrivateProfileInt(title, item,
                                                                                                 *(UINT16 *)p->value, path);                                                                                                  *(UINT16 *)p->value, path);
                                 *(UINT16 *)p->value = (UINT16)val;                                  *(UINT16 *)p->value = (UINT16)val;
                                 break;                                  break;
   
                         case INITYPE_SINT32:                          case INITYPE_SINT32:
                         case INITYPE_UINT32:                          case INITYPE_UINT32:
                                 val = (UINT32)GetPrivateProfileInt(title, p->item,                                  val = (UINT32)GetPrivateProfileInt(title, item,
                                                                                                 *(UINT32 *)p->value, path);                                                                                                  *(UINT32 *)p->value, path);
                                 *(UINT32 *)p->value = (UINT32)val;                                  *(UINT32 *)p->value = (UINT32)val;
                                 break;                                  break;
   
                         case INITYPE_HEX8:                          case INITYPE_HEX8:
                                 SPRINTF(work, str_x, *(BYTE *)p->value),                                  OEMSPRINTF(work, str_x, *(UINT8 *)p->value),
                                 GetPrivateProfileString(title, p->item, work,                                  GetPrivateProfileString(title, item, work,
                                                                                                 work, sizeof(work), path);                                                                                                  work, NELEMENTS(work), path);
                                 val = (BYTE)milstr_solveHEX(work);                                  val = (UINT8)milstr_solveHEX(work);
                                 *(BYTE *)p->value = (BYTE)val;                                  *(UINT8 *)p->value = (UINT8)val;
                                 break;                                  break;
   
                         case INITYPE_HEX16:                          case INITYPE_HEX16:
                                 SPRINTF(work, str_x, *(UINT16 *)p->value),                                  OEMSPRINTF(work, str_x, *(UINT16 *)p->value),
                                 GetPrivateProfileString(title, p->item, work,                                  GetPrivateProfileString(title, item, work,
                                                                                                 work, sizeof(work), path);                                                                                                  work, NELEMENTS(work), path);
                                 val = (UINT16)milstr_solveHEX(work);                                  val = (UINT16)milstr_solveHEX(work);
                                 *(UINT16 *)p->value = (UINT16)val;                                  *(UINT16 *)p->value = (UINT16)val;
                                 break;                                  break;
   
                         case INITYPE_HEX32:                          case INITYPE_HEX32:
                                 SPRINTF(work, str_x, *(UINT32 *)p->value),                                  OEMSPRINTF(work, str_x, *(UINT32 *)p->value),
                                 GetPrivateProfileString(title, p->item, work,                                  GetPrivateProfileString(title, item, work,
                                                                                                 work, sizeof(work), path);                                                                                                  work, NELEMENTS(work), path);
                                 val = (UINT32)milstr_solveHEX(work);                                  val = (UINT32)milstr_solveHEX(work);
                                 *(UINT16 *)p->value = (UINT32)val;                                  *(UINT32 *)p->value = (UINT32)val;
                                 break;                                  break;
   
                         case INITYPE_BYTE3:                          case INITYPE_BYTE3:
                                 GetPrivateProfileString(title, p->item, str_null,                                  GetPrivateProfileString(title, item, str_null,
                                                                                                 work, sizeof(work), path);                                                                                                  work, NELEMENTS(work), path);
                                 inirdbyte3(work, p);                                  inirdbyte3(work, p);
                                 break;                                  break;
   
                         case INITYPE_KB:                          case INITYPE_KB:
                                 GetPrivateProfileString(title, p->item, str_null,                                  GetPrivateProfileString(title, item, str_null,
                                                                                                 work, sizeof(work), path);                                                                                                  work, NELEMENTS(work), path);
                                 inirdkb(work, p);                                  inirdkb(work, p);
                                 break;                                  break;
                 }                  }
Line 236  const INITBL *pterm; Line 278  const INITBL *pterm;
         }          }
 }  }
   
 void ini_write(const char *path, const char *title,  void ini_write(const OEMCHAR *path, const OEMCHAR *title,
                                                                                         const INITBL *tbl, UINT count) {                                                                                          const INITBL *tbl, UINT count) {
   
 const INITBL    *p;  const INITBL    *p;
 const INITBL    *pterm;  const INITBL    *pterm;
 const char              *set;  const OEMCHAR   *set;
         char            work[512];          OEMCHAR         work[512];
   
         p = tbl;          p = tbl;
         pterm = tbl + count;          pterm = tbl + count;
Line 252  const char  *set; Line 294  const char  *set;
                         set = work;                          set = work;
                         switch(p->itemtype & INITYPE_MASK) {                          switch(p->itemtype & INITYPE_MASK) {
                                 case INITYPE_STR:                                  case INITYPE_STR:
                                         set = (char *)p->value;                                          set = (OEMCHAR *)p->value;
                                         break;                                          break;
   
                                 case INITYPE_BOOL:                                  case INITYPE_BOOL:
                                         set = (*((BYTE *)p->value))?str_true:str_false;                                          set = (*((UINT8 *)p->value))?str_true:str_false;
                                         break;                                          break;
   
                                 case INITYPE_ARGH8:                                  case INITYPE_ARGH8:
                                         iniwrsetargh8(work, sizeof(work), p);                                          iniwrsetargh8(work, NELEMENTS(work), p);
                                         break;                                          break;
   
                                 case INITYPE_SINT8:                                  case INITYPE_SINT8:
                                         SPRINTF(work, str_d, *((char *)p->value));                                          OEMSPRINTF(work, str_d, *((SINT8 *)p->value));
                                         break;                                          break;
   
                                 case INITYPE_SINT16:                                  case INITYPE_SINT16:
                                         SPRINTF(work, str_d, *((SINT16 *)p->value));                                          OEMSPRINTF(work, str_d, *((SINT16 *)p->value));
                                         break;                                          break;
   
                                 case INITYPE_SINT32:                                  case INITYPE_SINT32:
                                         SPRINTF(work, str_d, *((SINT32 *)p->value));                                          OEMSPRINTF(work, str_d, *((SINT32 *)p->value));
                                         break;                                          break;
   
                                 case INITYPE_UINT8:                                  case INITYPE_UINT8:
                                         SPRINTF(work, str_u, *((BYTE *)p->value));                                          OEMSPRINTF(work, str_u, *((UINT8 *)p->value));
                                         break;                                          break;
   
                                 case INITYPE_UINT16:                                  case INITYPE_UINT16:
                                         SPRINTF(work, str_u, *((UINT16 *)p->value));                                          OEMSPRINTF(work, str_u, *((UINT16 *)p->value));
                                         break;                                          break;
   
                                 case INITYPE_UINT32:                                  case INITYPE_UINT32:
                                         SPRINTF(work, str_u, *((UINT32 *)p->value));                                          OEMSPRINTF(work, str_u, *((UINT32 *)p->value));
                                         break;                                          break;
   
                                 case INITYPE_HEX8:                                  case INITYPE_HEX8:
                                         SPRINTF(work, str_x, *((BYTE *)p->value));                                          OEMSPRINTF(work, str_x, *((UINT8 *)p->value));
                                         break;                                          break;
   
                                 case INITYPE_HEX16:                                  case INITYPE_HEX16:
                                         SPRINTF(work, str_x, *((UINT16 *)p->value));                                          OEMSPRINTF(work, str_x, *((UINT16 *)p->value));
                                         break;                                          break;
   
                                 case INITYPE_HEX32:                                  case INITYPE_HEX32:
                                         SPRINTF(work, str_x, *((UINT32 *)p->value));                                          OEMSPRINTF(work, str_x, *((UINT32 *)p->value));
                                         break;                                          break;
   
                                 default:                                  default:
Line 304  const char  *set; Line 346  const char  *set;
                                         break;                                          break;
                         }                          }
                         if (set) {                          if (set) {
   #if defined(OSLANG_UCS2)
                                   OEMCHAR item[10];
                                   oemtext_sjis2oem(item, NELEMENTS(item), p->item, (UINT)-1);
                                   WritePrivateProfileString(title, item, set, path);
   #else
                                 WritePrivateProfileString(title, p->item, set, path);                                  WritePrivateProfileString(title, p->item, set, path);
   #endif
                         }                          }
                 }                  }
                 p++;                  p++;
Line 314  const char  *set; Line 362  const char  *set;
   
 // ----  // ----
   
 static const char ini_title[] = "NekoProjectII";  #if !defined(SUPPORT_PC9821)
   static const OEMCHAR ini_title[] = OEMTEXT("NekoProjectII");
   #else
   static const OEMCHAR ini_title[] = OEMTEXT("NekoProject21");
   #endif
   
 enum {  enum {
         INIRO_STR                       = INITYPE_STR + INIFLAG_RO,          INIRO_STR                       = INITYPE_STR + INIFLAG_RO,
         INIRO_BOOL                      = INITYPE_BOOL + INIFLAG_RO,          INIRO_BOOL                      = INITYPE_BOOL + INIFLAG_RO,
         INIMAX_UINT8            = INITYPE_UINT8 + INIFLAG_RO,          INIRO_BITMAP            = INITYPE_BITMAP + INIFLAG_RO,
           INIRO_UINT8                     = INITYPE_UINT8 + INIFLAG_RO,
           INIMAX_UINT8            = INITYPE_UINT8 + INIFLAG_MAX,
         INIAND_UINT8            = INITYPE_UINT8 + INIFLAG_AND,          INIAND_UINT8            = INITYPE_UINT8 + INIFLAG_AND,
         INIROMAX_SINT32         = INITYPE_SINT32 + INIFLAG_RO + INIFLAG_MAX,          INIROMAX_SINT32         = INITYPE_SINT32 + INIFLAG_RO + INIFLAG_MAX,
         INIROAND_HEX32          = INITYPE_HEX32 + INIFLAG_RO + INIFLAG_AND,          INIROAND_HEX32          = INITYPE_HEX32 + INIFLAG_RO + INIFLAG_AND,
Line 330  enum { Line 384  enum {
   
 static const INITBL iniitem[] = {  static const INITBL iniitem[] = {
         {"np2title", INIRO_STR,                 np2oscfg.titles,          {"np2title", INIRO_STR,                 np2oscfg.titles,
                                                                                                         sizeof(np2oscfg.titles)},                                                                                                  NELEMENTS(np2oscfg.titles)},
         {"np2winid", INIRO_BYTE3,               np2oscfg.winid,                 0},          {"np2winid", INIRO_BYTE3,               np2oscfg.winid,                 0},
         {"WindposX", INITYPE_SINT32,    &np2oscfg.winx,                 0},          {"WindposX", INITYPE_SINT32,    &np2oscfg.winx,                 0},
         {"WindposY", INITYPE_SINT32,    &np2oscfg.winy,                 0},          {"WindposY", INITYPE_SINT32,    &np2oscfg.winy,                 0},
Line 342  static const INITBL iniitem[] = { Line 396  static const INITBL iniitem[] = {
         {"HDfolder", INITYPE_STR,               hddfolder,                              MAX_PATH},          {"HDfolder", INITYPE_STR,               hddfolder,                              MAX_PATH},
         {"bmap_Dir", INITYPE_STR,               bmpfilefolder,                  MAX_PATH},          {"bmap_Dir", INITYPE_STR,               bmpfilefolder,                  MAX_PATH},
         {"fontfile", INITYPE_STR,               np2cfg.fontfile,                MAX_PATH},          {"fontfile", INITYPE_STR,               np2cfg.fontfile,                MAX_PATH},
           {"biospath", INIRO_STR,                 np2cfg.biospath,                MAX_PATH},
           {"hdrvroot", INIRO_STR,                 np2cfg.hdrvroot,                MAX_PATH},
           {"hdrv_acc", INIRO_UINT8,               &np2cfg.hdrvacc,                0},
   
           {"pc_model", INITYPE_STR,               &np2cfg.model,
                                                                                                   NELEMENTS(np2cfg.model)},
         {"clk_base", INITYPE_UINT32,    &np2cfg.baseclock,              0},          {"clk_base", INITYPE_UINT32,    &np2cfg.baseclock,              0},
         {"clk_mult", INITYPE_UINT32,    &np2cfg.multiple,               0},          {"clk_mult", INITYPE_UINT32,    &np2cfg.multiple,               0},
   
         {"DIPswtch", INITYPE_ARGH8,             np2cfg.dipsw,                   3},          {"DIPswtch", INITYPE_ARGH8,             np2cfg.dipsw,                   3},
         {"MEMswtch", INITYPE_ARGH8,             np2cfg.memsw,                   8},          {"MEMswtch", INITYPE_ARGH8,             np2cfg.memsw,                   8},
         {"ExMemory", INIMAX_UINT8,              &np2cfg.EXTMEM,                 13},          {"ExMemory", INIMAX_UINT8,              &np2cfg.EXTMEM,                 63},
         {"ITF_WORK", INIRO_BOOL,                &np2cfg.ITF_WORK,               0},          {"ITF_WORK", INIRO_BOOL,                &np2cfg.ITF_WORK,               0},
   
         {"HDD1FILE", INITYPE_STR,               np2cfg.hddfile[0],              MAX_PATH},          {"HDD1FILE", INITYPE_STR,               np2cfg.sasihdd[0],              MAX_PATH},
         {"HDD2FILE", INITYPE_STR,               np2cfg.hddfile[1],              MAX_PATH},          {"HDD2FILE", INITYPE_STR,               np2cfg.sasihdd[1],              MAX_PATH},
 //      {"Removabl", INI_EX|1,  0,              &np2cfg.REMOVEHD,               0},  #if defined(SUPPORT_SCSI)
           {"SCSIHDD0", INITYPE_STR,               np2cfg.scsihdd[0],              MAX_PATH},
           {"SCSIHDD1", INITYPE_STR,               np2cfg.scsihdd[1],              MAX_PATH},
           {"SCSIHDD2", INITYPE_STR,               np2cfg.scsihdd[2],              MAX_PATH},
           {"SCSIHDD3", INITYPE_STR,               np2cfg.scsihdd[3],              MAX_PATH},
   #endif
   
         {"SampleHz", INITYPE_UINT16,    &np2cfg.samplingrate,   0},          {"SampleHz", INITYPE_UINT16,    &np2cfg.samplingrate,   0},
         {"Latencys", INITYPE_UINT16,    &np2cfg.delayms,                0},          {"Latencys", INITYPE_UINT16,    &np2cfg.delayms,                0},
Line 369  static const INITBL iniitem[] = { Line 433  static const INITBL iniitem[] = {
         {"optSPBVR", INITYPE_HEX8,              &np2cfg.spb_vrc,                0},          {"optSPBVR", INITYPE_HEX8,              &np2cfg.spb_vrc,                0},
         {"optSPBVL", INIMAX_UINT8,              &np2cfg.spb_vrl,                24},          {"optSPBVL", INIMAX_UINT8,              &np2cfg.spb_vrl,                24},
         {"optSPB_X", INITYPE_BOOL,              &np2cfg.spb_x,                  0},          {"optSPB_X", INITYPE_BOOL,              &np2cfg.spb_x,                  0},
         {"optMPU98", INITYPE_HEX8               &np2cfg.mpuopt,                 0},          {"optMPU98", INITYPE_HEX8,              &np2cfg.mpuopt,                 0},
   
         {"volume_F", INIMAX_UINT8,              &np2cfg.vol_fm,                 128},          {"volume_F", INIMAX_UINT8,              &np2cfg.vol_fm,                 128},
         {"volume_S", INIMAX_UINT8,              &np2cfg.vol_ssg,                128},          {"volume_S", INIMAX_UINT8,              &np2cfg.vol_ssg,                128},
Line 397  static const INITBL iniitem[] = { Line 461  static const INITBL iniitem[] = {
         {"GRCG_EGC", INIAND_UINT8,              &np2cfg.grcg,                   3},          {"GRCG_EGC", INIAND_UINT8,              &np2cfg.grcg,                   3},
         {"color16b", INITYPE_BOOL,              &np2cfg.color16,                0},          {"color16b", INITYPE_BOOL,              &np2cfg.color16,                0},
         {"skipline", INITYPE_BOOL,              &np2cfg.skipline,               0},          {"skipline", INITYPE_BOOL,              &np2cfg.skipline,               0},
         {"skplight", INITYPE_UINT16             &np2cfg.skiplight,              0},          {"skplight", INITYPE_UINT16,    &np2cfg.skiplight,              0},
         {"LCD_MODE", INIAND_UINT8,              &np2cfg.LCD_MODE,               0x03},          {"LCD_MODE", INIAND_UINT8,              &np2cfg.LCD_MODE,               0x03},
         {"BG_COLOR", INIROAND_HEX32,    &np2cfg.BG_COLOR,               0xffffff},          {"BG_COLOR", INIROAND_HEX32,    &np2cfg.BG_COLOR,               0xffffff},
         {"FG_COLOR", INIROAND_HEX32,    &np2cfg.FG_COLOR,               0xffffff},          {"FG_COLOR", INIROAND_HEX32,    &np2cfg.FG_COLOR,               0xffffff},
Line 408  static const INITBL iniitem[] = { Line 472  static const INITBL iniitem[] = {
   
         {"calendar", INITYPE_BOOL,              &np2cfg.calendar,               0},          {"calendar", INITYPE_BOOL,              &np2cfg.calendar,               0},
         {"USE144FD", INITYPE_BOOL,              &np2cfg.usefd144,               0},          {"USE144FD", INITYPE_BOOL,              &np2cfg.usefd144,               0},
           {"FDDRIVE1", INIRO_BITMAP,              &np2cfg.fddequip,               0},
           {"FDDRIVE2", INIRO_BITMAP,              &np2cfg.fddequip,               1},
           {"FDDRIVE3", INIRO_BITMAP,              &np2cfg.fddequip,               2},
           {"FDDRIVE4", INIRO_BITMAP,              &np2cfg.fddequip,               3},
   
   
         // OS°Í¸¡©          // OS°Í¸¡©
         {"keyboard", INIRO_KB,                  &np2oscfg.KEYBOARD,             0},          {"keyboard", INIRO_KB,                  &np2oscfg.KEYBOARD,             0},
Line 451  static const INITBL iniitem[] = { Line 520  static const INITBL iniitem[] = {
         {"com3mmdl", INITYPE_STR,               np2oscfg.com3.mdl,              64},          {"com3mmdl", INITYPE_STR,               np2oscfg.com3.mdl,              64},
         {"com3mdef", INITYPE_STR,               np2oscfg.com3.def,              MAX_PATH},          {"com3mdef", INITYPE_STR,               np2oscfg.com3.def,              MAX_PATH},
   
         {"force400", INITYPE_BOOL,              &np2oscfg.force400,             0},          {"force400", INIRO_BOOL,                &np2oscfg.force400,             0},
         {"e_resume", INITYPE_BOOL,              &np2oscfg.resume,               0},          {"e_resume", INITYPE_BOOL,              &np2oscfg.resume,               0},
         {"STATSAVE", INIRO_BOOL,                &np2oscfg.statsave,             0},          {"STATSAVE", INIRO_BOOL,                &np2oscfg.statsave,             0},
         {"nousemmx", INITYPE_BOOL,              &np2oscfg.disablemmx,   0},             // ver0.36          {"nousemmx", INITYPE_BOOL,              &np2oscfg.disablemmx,   0},             // ver0.36
           {"windtype", INITYPE_UINT8,             &np2oscfg.wintype,              0},
         {"toolwind", INITYPE_BOOL,              &np2oscfg.toolwin,              0},             // ver0.38          {"toolwind", INITYPE_BOOL,              &np2oscfg.toolwin,              0},             // ver0.38
           {"keydispl", INITYPE_BOOL,              &np2oscfg.keydisp,              0},
           {"jast_snd", INITYPE_BOOL,              &np2oscfg.jastsnd,              0},             // ver0.73
           {"useromeo", INITYPE_BOOL,              &np2oscfg.useromeo,             0},             // ver0.74
           {"thickfrm", INITYPE_BOOL,              &np2oscfg.thickframe,   0},             // ver0.77
           {"xrollkey", INIRO_BOOL,                &np2oscfg.xrollkey,             0},             // ver0.78
           {"fscrnbpp", INIRO_UINT8,               &np2oscfg.fscrnbpp,             0},
         {"I286SAVE", INIRO_BOOL,                &np2oscfg.I286SAVE,             0}};          {"I286SAVE", INIRO_BOOL,                &np2oscfg.I286SAVE,             0}};
   
   
 static void getinifile(char *initfile, int max) {  void initgetfile(OEMCHAR *path, UINT size) {
   
         char    *p;  const OEMCHAR   *ext;
   
         milstr_ncpy(initfile, modulefile, max);          file_cpyname(path, modulefile, size);
         if (np2arg.ini) {          if (np2arg.ini) {
                 if ((np2arg.ini[0] == '/') || (np2arg.ini[0] == '-')) {                  if ((np2arg.ini[0] == '/') || (np2arg.ini[0] == '-')) {
                         file_cutname(initfile);                          file_cutname(path);
                         milstr_ncat(initfile, file_getname(np2arg.ini + 2), max);                          file_catname(path, file_getname(np2arg.ini + 2), size);
                 }                  }
                 else {                  else {
                         milstr_ncpy(initfile, np2arg.ini, max);                          file_cpyname(path, np2arg.ini, size);
                 }                  }
                 p = file_getext(initfile);                  ext = file_getext(path);
                 if (!(*p)) {                  if (ext[0] != '\0') {
                         milstr_ncat(initfile, ".ini", max);                          file_catname(path, OEMTEXT(".ini"), size);
                 }                  }
         }          }
         else {          else {
                 file_cutext(initfile);                  file_cutext(path);
                 milstr_ncat(initfile, ".ini", max);                  file_catname(path, OEMTEXT(".ini"), size);
         }          }
 }  }
   
 void initload(void) {  void initload(void) {
   
         char    path[MAX_PATH];          OEMCHAR path[MAX_PATH];
   
         getinifile(path, sizeof(path));          initgetfile(path, NELEMENTS(path));
         ini_read(path, ini_title, iniitem, sizeof(iniitem)/sizeof(INITBL));          ini_read(path, ini_title, iniitem, NELEMENTS(iniitem));
 }  }
   
 void initsave(void) {  void initsave(void) {
   
         char    path[MAX_PATH];          OEMCHAR path[MAX_PATH];
   
         getinifile(path, sizeof(path));          initgetfile(path, NELEMENTS(path));
         ini_write(path, ini_title, iniitem, sizeof(iniitem)/sizeof(INITBL));          ini_write(path, ini_title, iniitem, NELEMENTS(iniitem));
 }  }
   
Removed from v.1.7  
changed lines
  Added in v.1.35

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