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

Diff for /np2/win9x/ini.cpp between versions 1.17 and 1.42

version 1.17, 2003/12/25 03:02:40 version 1.42, 2006/12/24 07:53:01
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) {  
   
   // ---- user
   
   static void inirdargs16(const OEMCHAR *src, const PFTBL *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 45  static void inirdargs16(const char *src,
         }          }
 }  }
   
 static void inirdargh8(const char *src, const INITBL *ini) {  static void inirdbyte3(const OEMCHAR *src, const PFTBL *ini) {
   
         BYTE    *dst;          UINT    i;
         int             dsize;  
         int             i;  
         BYTE    val;  
         BOOL    set;  
         char    c;  
   
         dst = (BYTE *)ini->value;          for (i=0; i<3; i++) {
         dsize = ini->arg;                  if (src[i] == '\0') {
                           break;
                   }
                   if ((((src[i] - '0') & 0xff) < 9) ||
                           (((src[i] - 'A') & 0xdf) < 26)) {
                           ((UINT8 *)ini->value)[i] = (UINT8)src[i];
                   }
           }
   }
   
         for (i=0; i<dsize; i++) {  static void inirdkb(const OEMCHAR *src, const PFTBL *ini) {
   
           if ((!milstr_extendcmp(src, OEMTEXT("PC98"))) ||
                   (!milstr_cmp(src, OEMTEXT("98")))) {
                   *(UINT8 *)ini->value = KEY_PC98;
           }
           else if ((!milstr_extendcmp(src, OEMTEXT("DOS"))) ||
                           (!milstr_cmp(src, OEMTEXT("PCAT"))) ||
                           (!milstr_cmp(src, OEMTEXT("AT")))) {
                   *(UINT8 *)ini->value = KEY_KEY106;
           }
           else if ((!milstr_extendcmp(src, OEMTEXT("KEY101"))) ||
                           (!milstr_cmp(src, OEMTEXT("101")))) {
                   *(UINT8 *)ini->value = KEY_KEY101;
           }
   }
   
   
   // ---- Use WinAPI
   
   #if !defined(_UNICODE)
   static void bitmapset(UINT8 *ptr, UINT pos, BOOL set) {
   
           UINT8   bit;
   
           ptr += (pos >> 3);
           bit = 1 << (pos & 7);
           if (set) {
                   *ptr |= bit;
           }
           else {
                   *ptr &= ~bit;
           }
   }
   
   static BOOL bitmapget(const UINT8 *ptr, UINT pos) {
   
           return((ptr[pos >> 3] >> (pos & 7)) & 1);
   }
   
   static void binset(UINT8 *bin, UINT binlen, const OEMCHAR *src) {
   
           UINT    i;
           UINT8   val;
           BOOL    set;
           OEMCHAR c;
   
           for (i=0; i<binlen; i++) {
                 val = 0;                  val = 0;
                 set = FALSE;                  set = FALSE;
                 while(*src == ' ') {                  while(*src == ' ') {
Line 78  static void inirdargh8(const char *src,  Line 136  static void inirdargh8(const char *src, 
                 if (set == FALSE) {                  if (set == FALSE) {
                         break;                          break;
                 }                  }
                 dst[i] = val;                  bin[i] = val;
         }          }
 }  }
   
 static void iniwrsetargh8(char *work, int size, const INITBL *ini) {  static void binget(OEMCHAR *work, int size, const UINT8 *bin, UINT binlen) {
   
         UINT    i;          UINT    i;
 const BYTE      *ptr;          OEMCHAR tmp[8];
         UINT    arg;  
         char    tmp[8];          if (binlen) {
                   OEMSPRINTF(tmp, OEMTEXT("%.2x"), bin[0]);
         ptr = (BYTE *)ini->value;  
         arg = ini->arg;  
         if (arg > 0) {  
                 SPRINTF(tmp, "%.2x", ptr[0]);  
                 milstr_ncpy(work, tmp, size);                  milstr_ncpy(work, tmp, size);
         }          }
         for (i=1; i<arg; i++) {          for (i=1; i<binlen; i++) {
                 SPRINTF(tmp, " %.2x", ptr[i]);                  OEMSPRINTF(tmp, OEMTEXT(" %.2x"), bin[i]);
                 milstr_ncat(work, tmp, size);                  milstr_ncat(work, tmp, size);
         }          }
 }  }
   
   void ini_read(const OEMCHAR *path, const OEMCHAR *title,
                                                                                           const PFTBL *tbl, UINT count) {
   
 // ---- user  const PFTBL     *p;
   const PFTBL     *pterm;
 static void inirdbyte3(const char *src, const INITBL *ini) {          OEMCHAR work[512];
           UINT32  val;
         UINT    i;  
   
         for (i=0; i<3; i++) {  
                 if (src[i] == '\0') {  
                         break;  
                 }  
                 if ((((src[i] - '0') & 0xff) < 9) ||  
                         (((src[i] - 'A') & 0xdf) < 26)) {  
                         ((BYTE *)ini->value)[i] = src[i];  
                 }  
         }  
 }  
   
 static void inirdkb(const char *src, const INITBL *ini) {  
   
         if ((!milstr_extendcmp(src, "PC98")) ||  
                 (!milstr_cmp(src, "98"))) {  
                 *(BYTE *)ini->value = KEY_PC98;  
         }  
         else if ((!milstr_extendcmp(src, "DOS")) ||  
                         (!milstr_cmp(src, "PCAT")) ||  
                         (!milstr_cmp(src, "AT"))) {  
                 *(BYTE *)ini->value = KEY_KEY106;  
         }  
         else if ((!milstr_extendcmp(src, "KEY101")) ||  
                         (!milstr_cmp(src, "101"))) {  
                 *(BYTE *)ini->value = KEY_KEY101;  
         }  
 }  
   
   
 // ----  
   
 void ini_read(const char *path, const char *title,  
                                                                                         const INITBL *tbl, UINT count) {  
   
 const INITBL    *p;  
 const INITBL    *pterm;  
         char            work[512];  
         UINT32          val;  
   
         p = tbl;          p = tbl;
         pterm = tbl + count;          pterm = tbl + count;
         while(p < pterm) {          while(p < pterm) {
                 switch(p->itemtype & INITYPE_MASK) {                  switch(p->itemtype & PFTYPE_MASK) {
                         case INITYPE_STR:                          case PFTYPE_STR:
                                 GetPrivateProfileString(title, p->item, (char *)p->value,                                  GetPrivateProfileString(title, p->item, (OEMCHAR *)p->value,
                                                                                         (char *)p->value, p->arg, path);                                                                                          (OEMCHAR *)p->value, p->arg, path);
                                 break;                                  break;
   
                         case INITYPE_BOOL:                          case PFTYPE_BOOL:
                                 GetPrivateProfileString(title, p->item,                                  GetPrivateProfileString(title, p->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;                                  break;
   
                         case INITYPE_ARGS16:                          case PFTYPE_BITMAP:
                                 GetPrivateProfileString(title, p->item, str_null,                                  GetPrivateProfileString(title, p->item,
                                                                                                 work, sizeof(work), path);                                          (bitmapget((UINT8 *)p->value, p->arg))?str_true:str_false,
                                 inirdargs16(work, p);                                                                                                  work, NELEMENTS(work), path);
                                   bitmapset((UINT8 *)p->value, p->arg,
                                                                                   (milstr_cmp(work, str_true) == 0));
                                 break;                                  break;
   
                         case INITYPE_ARGH8:                          case PFTYPE_BIN:
                                 GetPrivateProfileString(title, p->item, str_null,                                  GetPrivateProfileString(title, p->item, str_null,
                                                                                                 work, sizeof(work), path);                                                                                                  work, NELEMENTS(work), path);
                                 inirdargh8(work, p);                                  binset((UINT8 *)p->value, p->arg, work);
                                 break;                                  break;
   
                         case INITYPE_SINT8:                          case PFTYPE_SINT8:
                         case INITYPE_UINT8:                          case PFTYPE_UINT8:
                                 val = (BYTE)GetPrivateProfileInt(title, p->item,                                  val = (UINT8)GetPrivateProfileInt(title, p->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 PFTYPE_SINT16:
                         case INITYPE_UINT16:                          case PFTYPE_UINT16:
                                 val = (UINT16)GetPrivateProfileInt(title, p->item,                                  val = (UINT16)GetPrivateProfileInt(title, p->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 PFTYPE_SINT32:
                         case INITYPE_UINT32:                          case PFTYPE_UINT32:
                                 val = (UINT32)GetPrivateProfileInt(title, p->item,                                  val = (UINT32)GetPrivateProfileInt(title, p->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 PFTYPE_HEX8:
                                 SPRINTF(work, str_x, *(BYTE *)p->value),                                  OEMSPRINTF(work, str_x, *(UINT8 *)p->value),
                                 GetPrivateProfileString(title, p->item, work,                                  GetPrivateProfileString(title, p->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 PFTYPE_HEX16:
                                 SPRINTF(work, str_x, *(UINT16 *)p->value),                                  OEMSPRINTF(work, str_x, *(UINT16 *)p->value),
                                 GetPrivateProfileString(title, p->item, work,                                  GetPrivateProfileString(title, p->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 PFTYPE_HEX32:
                                 SPRINTF(work, str_x, *(UINT32 *)p->value),                                  OEMSPRINTF(work, str_x, *(UINT32 *)p->value),
                                 GetPrivateProfileString(title, p->item, work,                                  GetPrivateProfileString(title, p->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;
   
                           case PFTYPE_ARGS16:
                                   GetPrivateProfileString(title, p->item, str_null,
                                                                                                   work, NELEMENTS(work), path);
                                   inirdargs16(work, p);
                                 break;                                  break;
   
                         case INITYPE_BYTE3:                          case PFTYPE_BYTE3:
                                 GetPrivateProfileString(title, p->item, str_null,                                  GetPrivateProfileString(title, p->item, str_null,
                                                                                                 work, sizeof(work), path);                                                                                                  work, NELEMENTS(work), path);
                                 inirdbyte3(work, p);                                  inirdbyte3(work, p);
                                 break;                                  break;
   
                         case INITYPE_KB:                          case PFTYPE_KB:
                                 GetPrivateProfileString(title, p->item, str_null,                                  GetPrivateProfileString(title, p->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 260  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 PFTBL *tbl, UINT count) {
   
 const INITBL    *p;  const PFTBL             *p;
 const INITBL    *pterm;  const PFTBL             *pterm;
 const char              *set;  const OEMCHAR   *set;
         char            work[512];          OEMCHAR         work[512];
   
         p = tbl;          p = tbl;
         pterm = tbl + count;          pterm = tbl + count;
         while(p < pterm) {          while(p < pterm) {
                 if (!(p->itemtype & INIFLAG_RO)) {                  if (!(p->itemtype & PFFLAG_RO)) {
                         work[0] = '\0';                          work[0] = '\0';
                         set = work;                          set = work;
                         switch(p->itemtype & INITYPE_MASK) {                          switch(p->itemtype & PFTYPE_MASK) {
                                 case INITYPE_STR:                                  case PFTYPE_STR:
                                         set = (char *)p->value;                                          set = (OEMCHAR *)p->value;
                                           break;
   
                                   case PFTYPE_BOOL:
                                           set = (*((UINT8 *)p->value))?str_true:str_false;
                                         break;                                          break;
   
                                 case INITYPE_BOOL:                                  case PFTYPE_BITMAP:
                                         set = (*((BYTE *)p->value))?str_true:str_false;                                          set = (bitmapget((UINT8 *)p->value, p->arg))?
                                                                                                                   str_true:str_false;
                                         break;                                          break;
   
                                 case INITYPE_ARGH8:                                  case PFTYPE_BIN:
                                         iniwrsetargh8(work, sizeof(work), p);                                          binget(work, NELEMENTS(work), (UINT8 *)p->value, p->arg);
                                         break;                                          break;
   
                                 case INITYPE_SINT8:                                  case PFTYPE_SINT8:
                                         SPRINTF(work, str_d, *((char *)p->value));                                          OEMSPRINTF(work, str_d, *((SINT8 *)p->value));
                                         break;                                          break;
   
                                 case INITYPE_SINT16:                                  case PFTYPE_SINT16:
                                         SPRINTF(work, str_d, *((SINT16 *)p->value));                                          OEMSPRINTF(work, str_d, *((SINT16 *)p->value));
                                         break;                                          break;
   
                                 case INITYPE_SINT32:                                  case PFTYPE_SINT32:
                                         SPRINTF(work, str_d, *((SINT32 *)p->value));                                          OEMSPRINTF(work, str_d, *((SINT32 *)p->value));
                                         break;                                          break;
   
                                 case INITYPE_UINT8:                                  case PFTYPE_UINT8:
                                         SPRINTF(work, str_u, *((BYTE *)p->value));                                          OEMSPRINTF(work, str_u, *((UINT8 *)p->value));
                                         break;                                          break;
   
                                 case INITYPE_UINT16:                                  case PFTYPE_UINT16:
                                         SPRINTF(work, str_u, *((UINT16 *)p->value));                                          OEMSPRINTF(work, str_u, *((UINT16 *)p->value));
                                         break;                                          break;
   
                                 case INITYPE_UINT32:                                  case PFTYPE_UINT32:
                                         SPRINTF(work, str_u, *((UINT32 *)p->value));                                          OEMSPRINTF(work, str_u, *((UINT32 *)p->value));
                                         break;                                          break;
   
                                 case INITYPE_HEX8:                                  case PFTYPE_HEX8:
                                         SPRINTF(work, str_x, *((BYTE *)p->value));                                          OEMSPRINTF(work, str_x, *((UINT8 *)p->value));
                                         break;                                          break;
   
                                 case INITYPE_HEX16:                                  case PFTYPE_HEX16:
                                         SPRINTF(work, str_x, *((UINT16 *)p->value));                                          OEMSPRINTF(work, str_x, *((UINT16 *)p->value));
                                         break;                                          break;
   
                                 case INITYPE_HEX32:                                  case PFTYPE_HEX32:
                                         SPRINTF(work, str_x, *((UINT32 *)p->value));                                          OEMSPRINTF(work, str_x, *((UINT32 *)p->value));
                                         break;                                          break;
   
                                 default:                                  default:
Line 311  const char  *set; Line 340  const char  *set;
         }          }
 }  }
   
   #else   // !defined(_UNICODE)
   
   // ---- Use profile.c
   
   static void pfread(const PFTBL *item, const OEMCHAR *string) {
   
           switch(item->itemtype & PFTYPE_MASK) {
                   case PFTYPE_ARGS16:
                           inirdargs16(string, item);
                           break;
   
                   case PFTYPE_BYTE3:
                           inirdbyte3(string, item);
                           break;
   
                   case PFTYPE_KB:
                           inirdkb(string, item);
                           break;
           }
   }
   
   void ini_read(const OEMCHAR *path, const OEMCHAR *title,
                                                                                           const PFTBL *tbl, UINT count) {
   
           profile_iniread(path, title, tbl, count, pfread);
   }
   
   void ini_write(const OEMCHAR *path, const OEMCHAR *title,
                                                                                           const PFTBL *tbl, UINT count) {
   
           profile_iniwrite(path, title, tbl, count, NULL);
   }
   
   #endif  // !defined(_UNICODE)
   
   
 // ----  // ----
   
 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,          PFRO_STR                = PFFLAG_RO + PFTYPE_STR,
         INIRO_BOOL                      = INITYPE_BOOL + INIFLAG_RO,          PFRO_BOOL               = PFFLAG_RO + PFTYPE_BOOL,
         INIMAX_UINT8            = INITYPE_UINT8 + INIFLAG_MAX,          PFRO_BITMAP             = PFFLAG_RO + PFTYPE_BITMAP,
         INIAND_UINT8            = INITYPE_UINT8 + INIFLAG_AND,          PFRO_UINT8              = PFFLAG_RO + PFTYPE_UINT8,
         INIROMAX_SINT32         = INITYPE_SINT32 + INIFLAG_RO + INIFLAG_MAX,          PFRO_SINT32             = PFFLAG_RO + PFTYPE_SINT32,
         INIROAND_HEX32          = INITYPE_HEX32 + INIFLAG_RO + INIFLAG_AND,          PFRO_HEX32              = PFFLAG_RO + PFTYPE_HEX32,
           PFRO_BYTE3              = PFFLAG_RO + PFTYPE_BYTE3,
         INIRO_BYTE3                     = INITYPE_BYTE3 + INIFLAG_RO,          PFRO_KB                 = PFFLAG_RO + PFTYPE_KB
         INIRO_KB                        = INITYPE_KB + INIFLAG_RO  
 };  };
   
 static const INITBL iniitem[] = {  static const PFTBL iniitem[] = {
         {"np2title", INIRO_STR,                 np2oscfg.titles,          PFSTR("np2title", PFRO_STR,                     np2oscfg.titles),
                                                                                                         sizeof(np2oscfg.titles)},          PFVAL("np2winid", PFRO_BYTE3,           np2oscfg.winid),
         {"np2winid", INIRO_BYTE3,               np2oscfg.winid,                 0},          PFVAL("WindposX", PFTYPE_SINT32,        &np2oscfg.winx),
         {"WindposX", INITYPE_SINT32,    &np2oscfg.winx,                 0},          PFVAL("WindposY", PFTYPE_SINT32,        &np2oscfg.winy),
         {"WindposY", INITYPE_SINT32,    &np2oscfg.winy,                 0},          PFMAX("paddingx", PFRO_SINT32,          &np2oscfg.paddingx,             32),
         {"paddingx", INIROMAX_SINT32,   &np2oscfg.paddingx,             32},          PFMAX("paddingy", PFRO_SINT32,          &np2oscfg.paddingy,             32),
         {"paddingy", INIROMAX_SINT32,   &np2oscfg.paddingy,             32},          PFVAL("Win_Snap", PFTYPE_BOOL,          &np2oscfg.WINSNAP),
         {"Win_Snap", INITYPE_BOOL,              &np2oscfg.WINSNAP,              0},  
           PFSTR("FDfolder", PFTYPE_STR,           fddfolder),
         {"FDfolder", INITYPE_STR,               fddfolder,                              MAX_PATH},          PFSTR("HDfolder", PFTYPE_STR,           hddfolder),
         {"HDfolder", INITYPE_STR,               hddfolder,                              MAX_PATH},          PFSTR("bmap_Dir", PFTYPE_STR,           bmpfilefolder),
         {"bmap_Dir", INITYPE_STR,               bmpfilefolder,                  MAX_PATH},          PFSTR("fontfile", PFTYPE_STR,           np2cfg.fontfile),
         {"fontfile", INITYPE_STR,               np2cfg.fontfile,                MAX_PATH},          PFSTR("biospath", PFRO_STR,                     np2cfg.biospath),
         {"biospath", INIRO_STR,                 np2cfg.biospath,                MAX_PATH},  
   #if defined(SUPPORT_HOSTDRV)
         {"pc_model", INITYPE_STR,               &np2cfg.model,          PFSTR("hdrvroot", PFRO_STR,                     np2cfg.hdrvroot),
                                                                                                         sizeof(np2cfg.model)},          PFVAL("hdrv_acc", PFRO_UINT8,           &np2cfg.hdrvacc),
         {"clk_base", INITYPE_UINT32,    &np2cfg.baseclock,              0},  #endif
         {"clk_mult", INITYPE_UINT32,    &np2cfg.multiple,               0},  
           PFSTR("pc_model", PFTYPE_STR,           np2cfg.model),
         {"DIPswtch", INITYPE_ARGH8,             np2cfg.dipsw,                   3},          PFVAL("clk_base", PFTYPE_UINT32,        &np2cfg.baseclock),
         {"MEMswtch", INITYPE_ARGH8,             np2cfg.memsw,                   8},          PFVAL("clk_mult", PFTYPE_UINT32,        &np2cfg.multiple),
         {"ExMemory", INIMAX_UINT8,              &np2cfg.EXTMEM,                 13},  
         {"ITF_WORK", INIRO_BOOL,                &np2cfg.ITF_WORK,               0},          PFEXT("DIPswtch", PFTYPE_BIN,           np2cfg.dipsw,                   3),
           PFEXT("MEMswtch", PFTYPE_BIN,           np2cfg.memsw,                   8),
         {"HDD1FILE", INITYPE_STR,               np2cfg.hddfile[0],              MAX_PATH},          PFMAX("ExMemory", PFTYPE_UINT8,         &np2cfg.EXTMEM,                 63),
         {"HDD2FILE", INITYPE_STR,               np2cfg.hddfile[1],              MAX_PATH},          PFVAL("ITF_WORK", PFRO_BOOL,            &np2cfg.ITF_WORK),
 //      {"Removabl", INI_EX|1,  0,              &np2cfg.REMOVEHD,               0},  
           PFSTR("HDD1FILE", PFTYPE_STR,           np2cfg.sasihdd[0]),
         {"SampleHz", INITYPE_UINT16,    &np2cfg.samplingrate,   0},          PFSTR("HDD2FILE", PFTYPE_STR,           np2cfg.sasihdd[1]),
         {"Latencys", INITYPE_UINT16,    &np2cfg.delayms,                0},  #if defined(SUPPORT_SCSI)
         {"SNDboard", INITYPE_HEX8,              &np2cfg.SOUND_SW,               0},          PFSTR("SCSIHDD0", PFTYPE_STR,           np2cfg.scsihdd[0]),
         {"BEEP_vol", INIAND_UINT8,              &np2cfg.BEEP_VOL,               3},          PFSTR("SCSIHDD1", PFTYPE_STR,           np2cfg.scsihdd[1]),
         {"xspeaker", INIRO_BOOL,                &np2cfg.snd_x,                  0},          PFSTR("SCSIHDD2", PFTYPE_STR,           np2cfg.scsihdd[2]),
           PFSTR("SCSIHDD3", PFTYPE_STR,           np2cfg.scsihdd[3]),
         {"SND14vol", INITYPE_ARGH8,             np2cfg.vol14,                   6},  #endif
 //      {"opt14BRD", INITYPE_ARGH8,             np2cfg.snd14opt,                3},  
         {"opt26BRD", INITYPE_HEX8,              &np2cfg.snd26opt,               0},          PFVAL("SampleHz", PFTYPE_UINT16,        &np2cfg.samplingrate),
         {"opt86BRD", INITYPE_HEX8,              &np2cfg.snd86opt,               0},          PFVAL("Latencys", PFTYPE_UINT16,        &np2cfg.delayms),
         {"optSPBRD", INITYPE_HEX8,              &np2cfg.spbopt,                 0},          PFVAL("SNDboard", PFTYPE_HEX8,          &np2cfg.SOUND_SW),
         {"optSPBVR", INITYPE_HEX8,              &np2cfg.spb_vrc,                0},          PFAND("BEEP_vol", PFTYPE_UINT8,         &np2cfg.BEEP_VOL,               3),
         {"optSPBVL", INIMAX_UINT8,              &np2cfg.spb_vrl,                24},          PFVAL("xspeaker", PFRO_BOOL,            &np2cfg.snd_x),
         {"optSPB_X", INITYPE_BOOL,              &np2cfg.spb_x,                  0},  
         {"optMPU98", INITYPE_HEX8               &np2cfg.mpuopt,                 0},          PFEXT("SND14vol", PFTYPE_BIN,           np2cfg.vol14,                   6),
   //      PFEXT("opt14BRD", PFTYPE_BIN,           np2cfg.snd14opt,                3),
         {"volume_F", INIMAX_UINT8,              &np2cfg.vol_fm,                 128},          PFVAL("opt26BRD", PFTYPE_HEX8,          &np2cfg.snd26opt),
         {"volume_S", INIMAX_UINT8,              &np2cfg.vol_ssg,                128},          PFVAL("opt86BRD", PFTYPE_HEX8,          &np2cfg.snd86opt),
         {"volume_A", INIMAX_UINT8,              &np2cfg.vol_adpcm,              128},          PFVAL("optSPBRD", PFTYPE_HEX8,          &np2cfg.spbopt),
         {"volume_P", INIMAX_UINT8,              &np2cfg.vol_pcm,                128},          PFVAL("optSPBVR", PFTYPE_HEX8,          &np2cfg.spb_vrc),
         {"volume_R", INIMAX_UINT8,              &np2cfg.vol_rhythm,             128},          PFMAX("optSPBVL", PFTYPE_UINT8,         &np2cfg.spb_vrl,                24),
           PFVAL("optSPB_X", PFTYPE_BOOL,          &np2cfg.spb_x),
         {"Seek_Snd", INITYPE_BOOL,              &np2cfg.MOTOR,                  0},          PFVAL("optMPU98", PFTYPE_HEX8,          &np2cfg.mpuopt),
         {"Seek_Vol", INIMAX_UINT8,              &np2cfg.MOTORVOL,               100},  
           PFMAX("volume_F", PFTYPE_UINT8,         &np2cfg.vol_fm,                 128),
         {"btnRAPID", INITYPE_BOOL,              &np2cfg.BTN_RAPID,              0},          PFMAX("volume_S", PFTYPE_UINT8,         &np2cfg.vol_ssg,                128),
         {"btn_MODE", INITYPE_BOOL,              &np2cfg.BTN_MODE,               0},          PFMAX("volume_A", PFTYPE_UINT8,         &np2cfg.vol_adpcm,              128),
         {"Mouse_sw", INITYPE_BOOL,              &np2oscfg.MOUSE_SW,             0},          PFMAX("volume_P", PFTYPE_UINT8,         &np2cfg.vol_pcm,                128),
         {"MS_RAPID", INITYPE_BOOL,              &np2cfg.MOUSERAPID,             0},          PFMAX("volume_R", PFTYPE_UINT8,         &np2cfg.vol_rhythm,             128),
   
         {"backgrnd", INIAND_UINT8,              &np2oscfg.background,   3},          PFVAL("Seek_Snd", PFTYPE_BOOL,          &np2cfg.MOTOR),
         {"VRAMwait", INITYPE_ARGH8,             np2cfg.wait,                    6},          PFMAX("Seek_Vol", PFTYPE_UINT8,         &np2cfg.MOTORVOL,               100),
         {"DspClock", INIAND_UINT8,              &np2oscfg.DISPCLK,              3},  
         {"DispSync", INITYPE_BOOL,              &np2cfg.DISPSYNC,               0},          PFVAL("btnRAPID", PFTYPE_BOOL,          &np2cfg.BTN_RAPID),
         {"Real_Pal", INITYPE_BOOL,              &np2cfg.RASTER,                 0},          PFVAL("btn_MODE", PFTYPE_BOOL,          &np2cfg.BTN_MODE),
         {"RPal_tim", INIMAX_UINT8,              &np2cfg.realpal,                64},          PFVAL("Mouse_sw", PFTYPE_BOOL,          &np2oscfg.MOUSE_SW),
         {"s_NOWAIT", INITYPE_BOOL,              &np2oscfg.NOWAIT,               0},          PFVAL("MS_RAPID", PFTYPE_BOOL,          &np2cfg.MOUSERAPID),
         {"SkpFrame", INITYPE_UINT8,             &np2oscfg.DRAW_SKIP,    0},  
         {"uPD72020", INITYPE_BOOL,              &np2cfg.uPD72020,               0},          PFAND("backgrnd", PFTYPE_UINT8,         &np2oscfg.background,   3),
         {"GRCG_EGC", INIAND_UINT8,              &np2cfg.grcg,                   3},          PFEXT("VRAMwait", PFTYPE_BIN,           np2cfg.wait,                    6),
         {"color16b", INITYPE_BOOL,              &np2cfg.color16,                0},          PFAND("DspClock", PFTYPE_UINT8,         &np2oscfg.DISPCLK,              3),
         {"skipline", INITYPE_BOOL,              &np2cfg.skipline,               0},          PFVAL("DispSync", PFTYPE_BOOL,          &np2cfg.DISPSYNC),
         {"skplight", INITYPE_UINT16,    &np2cfg.skiplight,              0},          PFVAL("Real_Pal", PFTYPE_BOOL,          &np2cfg.RASTER),
         {"LCD_MODE", INIAND_UINT8,              &np2cfg.LCD_MODE,               0x03},          PFMAX("RPal_tim", PFTYPE_UINT8,         &np2cfg.realpal,                64),
         {"BG_COLOR", INIROAND_HEX32,    &np2cfg.BG_COLOR,               0xffffff},          PFVAL("s_NOWAIT", PFTYPE_BOOL,          &np2oscfg.NOWAIT),
         {"FG_COLOR", INIROAND_HEX32,    &np2cfg.FG_COLOR,               0xffffff},          PFVAL("SkpFrame", PFTYPE_UINT8,         &np2oscfg.DRAW_SKIP),
           PFVAL("uPD72020", PFTYPE_BOOL,          &np2cfg.uPD72020),
         {"pc9861_e", INITYPE_BOOL,              &np2cfg.pc9861enable,   0},          PFAND("GRCG_EGC", PFTYPE_UINT8,         &np2cfg.grcg,                   3),
         {"pc9861_s", INITYPE_ARGH8,             np2cfg.pc9861sw,                3},          PFVAL("color16b", PFTYPE_BOOL,          &np2cfg.color16),
         {"pc9861_j", INITYPE_ARGH8,             np2cfg.pc9861jmp,               6},          PFVAL("skipline", PFTYPE_BOOL,          &np2cfg.skipline),
           PFVAL("skplight", PFTYPE_UINT16,        &np2cfg.skiplight),
         {"calendar", INITYPE_BOOL,              &np2cfg.calendar,               0},          PFAND("LCD_MODE", PFTYPE_UINT8,         &np2cfg.LCD_MODE,               0x03),
         {"USE144FD", INITYPE_BOOL,              &np2cfg.usefd144,               0},          PFAND("BG_COLOR", PFRO_HEX32,           &np2cfg.BG_COLOR,               0xffffff),
           PFAND("FG_COLOR", PFRO_HEX32,           &np2cfg.FG_COLOR,               0xffffff),
   
           PFVAL("pc9861_e", PFTYPE_BOOL,          &np2cfg.pc9861enable),
           PFEXT("pc9861_s", PFTYPE_BIN,           np2cfg.pc9861sw,                3),
           PFEXT("pc9861_j", PFTYPE_BIN,           np2cfg.pc9861jmp,               6),
   
           PFVAL("calendar", PFTYPE_BOOL,          &np2cfg.calendar),
           PFVAL("USE144FD", PFTYPE_BOOL,          &np2cfg.usefd144),
           PFEXT("FDDRIVE1", PFRO_BITMAP,          &np2cfg.fddequip,               0),
           PFEXT("FDDRIVE2", PFRO_BITMAP,          &np2cfg.fddequip,               1),
           PFEXT("FDDRIVE3", PFRO_BITMAP,          &np2cfg.fddequip,               2),
           PFEXT("FDDRIVE4", PFRO_BITMAP,          &np2cfg.fddequip,               3),
   
         // OS°Í¸¡©          // OS°Í¸¡©
         {"keyboard", INIRO_KB,                  &np2oscfg.KEYBOARD,             0},          PFVAL("keyboard", PFRO_KB,                      &np2oscfg.KEYBOARD),
         {"F12_COPY", INITYPE_UINT8,             &np2oscfg.F12COPY,              0},          PFVAL("F12_COPY", PFTYPE_UINT8,         &np2oscfg.F12COPY),
         {"Joystick", INITYPE_BOOL,              &np2oscfg.JOYPAD1,              0},          PFVAL("Joystick", PFTYPE_BOOL,          &np2oscfg.JOYPAD1),
         {"Joy1_btn", INITYPE_ARGH8,             np2oscfg.JOY1BTN,               4},          PFEXT("Joy1_btn", PFTYPE_BIN,           np2oscfg.JOY1BTN,               4),
   
         {"clocknow", INITYPE_UINT8,             &np2oscfg.clk_x,                0},          PFVAL("clocknow", PFTYPE_UINT8,         &np2oscfg.clk_x),
         {"clockfnt", INITYPE_UINT8,             &np2oscfg.clk_fnt,              0},          PFVAL("clockfnt", PFTYPE_UINT8,         &np2oscfg.clk_fnt),
         {"clock_up", INIROAND_HEX32,    &np2oscfg.clk_color1,   0xffffff},          PFAND("clock_up", PFRO_HEX32,           &np2oscfg.clk_color1,   0xffffff),
         {"clock_dn", INIROAND_HEX32,    &np2oscfg.clk_color2,   0xffffff},          PFAND("clock_dn", PFRO_HEX32,           &np2oscfg.clk_color2,   0xffffff),
   
         {"use_sstp", INITYPE_BOOL,              &np2oscfg.sstp,                 0},          PFVAL("use_sstp", PFTYPE_BOOL,          &np2oscfg.sstp),
         {"sstpport", INITYPE_UINT16,    &np2oscfg.sstpport,             0},          PFVAL("sstpport", PFTYPE_UINT16,        &np2oscfg.sstpport),
         {"comfirm_", INITYPE_BOOL,              &np2oscfg.comfirm,              0},          PFVAL("comfirm_", PFTYPE_BOOL,          &np2oscfg.comfirm),
         {"shortcut", INITYPE_HEX8,              &np2oscfg.shortcut,             0},             // ver0.30          PFVAL("shortcut", PFTYPE_HEX8,          &np2oscfg.shortcut),
   
         {"mpu98map", INITYPE_STR,               np2oscfg.mpu.mout,              MAXPNAMELEN},          PFSTR("mpu98map", PFTYPE_STR,           np2oscfg.mpu.mout),
         {"mpu98min", INITYPE_STR,               np2oscfg.mpu.min,               MAXPNAMELEN},          PFSTR("mpu98min", PFTYPE_STR,           np2oscfg.mpu.min),
         {"mpu98mdl", INITYPE_STR,               np2oscfg.mpu.mdl,               64},          PFSTR("mpu98mdl", PFTYPE_STR,           np2oscfg.mpu.mdl),
         {"mpu98def", INITYPE_STR,               np2oscfg.mpu.def,               MAX_PATH},          PFSTR("mpu98def", PFTYPE_STR,           np2oscfg.mpu.def),
   
         {"com1port", INIMAX_UINT8,              &np2oscfg.com1.port,    5},             // ver0.34          PFMAX("com1port", PFTYPE_UINT8,         &np2oscfg.com1.port,    5),
         {"com1para", INITYPE_UINT8,             &np2oscfg.com1.param,   0},          PFVAL("com1para", PFTYPE_UINT8,         &np2oscfg.com1.param),
         {"com1_bps", INITYPE_UINT32,    &np2oscfg.com1.speed,   0},          PFVAL("com1_bps", PFTYPE_UINT32,        &np2oscfg.com1.speed),
         {"com1mmap", INITYPE_STR,               np2oscfg.com1.mout,             MAXPNAMELEN},          PFSTR("com1mmap", PFTYPE_STR,           np2oscfg.com1.mout),
         {"com1mmdl", INITYPE_STR,               np2oscfg.com1.mdl,              64},          PFSTR("com1mmdl", PFTYPE_STR,           np2oscfg.com1.mdl),
         {"com1mdef", INITYPE_STR,               np2oscfg.com1.def,              MAX_PATH},          PFSTR("com1mdef", PFTYPE_STR,           np2oscfg.com1.def),
   
         {"com2port", INIMAX_UINT8,              &np2oscfg.com2.port,    5},             // ver0.34          PFMAX("com2port", PFTYPE_UINT8,         &np2oscfg.com2.port,    5),
         {"com2para", INITYPE_UINT8,             &np2oscfg.com2.param,   0},          PFVAL("com2para", PFTYPE_UINT8,         &np2oscfg.com2.param),
         {"com2_bps", INITYPE_UINT32,    &np2oscfg.com2.speed,   0},          PFVAL("com2_bps", PFTYPE_UINT32,        &np2oscfg.com2.speed),
         {"com2mmap", INITYPE_STR,               np2oscfg.com2.mout,             MAXPNAMELEN},          PFSTR("com2mmap", PFTYPE_STR,           np2oscfg.com2.mout),
         {"com2mmdl", INITYPE_STR,               np2oscfg.com2.mdl,              64},          PFSTR("com2mmdl", PFTYPE_STR,           np2oscfg.com2.mdl),
         {"com2mdef", INITYPE_STR,               np2oscfg.com2.def,              MAX_PATH},          PFSTR("com2mdef", PFTYPE_STR,           np2oscfg.com2.def),
   
         {"com3port", INIMAX_UINT8,              &np2oscfg.com3.port,    5},             // ver0.34          PFMAX("com3port", PFTYPE_UINT8,         &np2oscfg.com3.port,    5),
         {"com3para", INITYPE_UINT8,             &np2oscfg.com3.param,   0},          PFVAL("com3para", PFTYPE_UINT8,         &np2oscfg.com3.param),
         {"com3_bps", INITYPE_UINT32,    &np2oscfg.com3.speed,   0},          PFVAL("com3_bps", PFTYPE_UINT32,        &np2oscfg.com3.speed),
         {"com3mmap", INITYPE_STR,               np2oscfg.com3.mout,             MAXPNAMELEN},          PFSTR("com3mmap", PFTYPE_STR,           np2oscfg.com3.mout),
         {"com3mmdl", INITYPE_STR,               np2oscfg.com3.mdl,              64},          PFSTR("com3mmdl", PFTYPE_STR,           np2oscfg.com3.mdl),
         {"com3mdef", INITYPE_STR,               np2oscfg.com3.def,              MAX_PATH},          PFSTR("com3mdef", PFTYPE_STR,           np2oscfg.com3.def),
   
         {"force400", INITYPE_BOOL,              &np2oscfg.force400,             0},          PFVAL("force400", PFRO_BOOL,            &np2oscfg.force400),
         {"e_resume", INITYPE_BOOL,              &np2oscfg.resume,               0},          PFVAL("e_resume", PFTYPE_BOOL,          &np2oscfg.resume),
         {"STATSAVE", INIRO_BOOL,                &np2oscfg.statsave,             0},          PFVAL("STATSAVE", PFRO_BOOL,            &np2oscfg.statsave),
         {"nousemmx", INITYPE_BOOL,              &np2oscfg.disablemmx,   0},             // ver0.36  #if !defined(_WIN64)
         {"windtype", INITYPE_UINT8,             &np2oscfg.wintype,              0},          PFVAL("nousemmx", PFTYPE_BOOL,          &np2oscfg.disablemmx),
         {"toolwind", INITYPE_BOOL,              &np2oscfg.toolwin,              0},             // ver0.38  #endif
         {"keydispl", INITYPE_BOOL,              &np2oscfg.keydisp,              0},          PFVAL("windtype", PFTYPE_UINT8,         &np2oscfg.wintype),
         {"jast_snd", INITYPE_BOOL,              &np2oscfg.jastsnd,              0},             // ver0.73          PFVAL("toolwind", PFTYPE_BOOL,          &np2oscfg.toolwin),
         {"I286SAVE", INIRO_BOOL,                &np2oscfg.I286SAVE,             0}};          PFVAL("keydispl", PFTYPE_BOOL,          &np2oscfg.keydisp),
           PFVAL("jast_snd", PFTYPE_BOOL,          &np2oscfg.jastsnd),
           PFVAL("useromeo", PFTYPE_BOOL,          &np2oscfg.useromeo),
           PFVAL("thickfrm", PFTYPE_BOOL,          &np2oscfg.thickframe),
           PFVAL("xrollkey", PFRO_BOOL,            &np2oscfg.xrollkey),
           PFVAL("fscrnbpp", PFRO_UINT8,           &np2oscfg.fscrnbpp),
           PFVAL("I286SAVE", PFRO_BOOL,            &np2oscfg.I286SAVE)};
   
   
   static const OEMCHAR ext_ini[] = OEMTEXT(".ini");
   
 void initgetfile(char *path, UINT size) {  void initgetfile(OEMCHAR *path, UINT size) {
   
         char    *p;  const OEMCHAR   *ext;
   
         file_cpyname(path, modulefile, size);          file_cpyname(path, modulefile, size);
         if (np2arg.ini) {          if (np2arg.ini) {
Line 478  void initgetfile(char *path, UINT size)  Line 565  void initgetfile(char *path, UINT size) 
                 else {                  else {
                         file_cpyname(path, np2arg.ini, size);                          file_cpyname(path, np2arg.ini, size);
                 }                  }
                 p = file_getext(path);                  ext = file_getext(path);
                 if (!(*p)) {                  if (ext[0] != '\0') {
                         file_catname(path, ".ini", size);                          file_catname(path, ext_ini, size);
                 }                  }
         }          }
         else {          else {
                 file_cutext(path);                  file_cutext(path);
                 file_catname(path, ".ini", size);                  file_catname(path, ext_ini, size);
         }          }
 }  }
   
 void initload(void) {  void initload(void) {
   
         char    path[MAX_PATH];          OEMCHAR path[MAX_PATH];
   
         initgetfile(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];
   
         initgetfile(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.17  
changed lines
  Added in v.1.42

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