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

Diff for /np2/wince/ini.cpp between versions 1.3 and 1.17

version 1.3, 2003/11/15 07:10:03 version 1.17, 2005/05/16 06:08:23
Line 1 Line 1
 #include        "compiler.h"  #include        "compiler.h"
 #include        "strres.h"  #include        "strres.h"
 #include        "profile.h"  #include        "textfile.h"
 #include        "np2.h"  #include        "np2.h"
 #include        "dosio.h"  #include        "dosio.h"
 #include        "ini.h"  #include        "ini.h"
 #include        "pccore.h"  #include        "pccore.h"
   
   
 typedef struct {  static void binset(UINT8 *bin, UINT binlen, const OEMCHAR *src) {
 const char              *title;  
 const INITBL    *tbl;  
 const INITBL    *tblterm;  
         UINT            count;  
 } _INIARG, *INIARG;  
   
 static void inirdarg8(BYTE *dst, int dsize, const char *src) {          UINT    i;
           UINT8   val;
         int             i;  
         BYTE    val;  
         BOOL    set;          BOOL    set;
         char    c;          OEMCHAR c;
   
         for (i=0; i<dsize; i++) {          for (i=0; i<binlen; i++) {
                 val = 0;                  val = 0;
                 set = FALSE;                  set = FALSE;
                 while(*src == ' ') {                  while(*src == ' ') {
Line 50  static void inirdarg8(BYTE *dst, int dsi Line 43  static void inirdarg8(BYTE *dst, int dsi
                 if (set == FALSE) {                  if (set == FALSE) {
                         break;                          break;
                 }                  }
                 dst[i] = val;                  bin[i] = val;
         }          }
 }  }
   
 static BOOL inireadcb(void *arg, const char *para,  static void binget(OEMCHAR *work, int size, const UINT8 *bin, UINT binlen) {
                                                                                 const char *key, const char *data) {  
   
 const INITBL    *p;          UINT    i;
           OEMCHAR tmp[8];
   
           if (binlen) {
                   OEMSPRINTF(tmp, OEMTEXT("%.2x"), bin[0]);
                   milstr_ncpy(work, tmp, size);
           }
           for (i=1; i<binlen; i++) {
                   OEMSPRINTF(tmp, OEMTEXT(" %.2x"), bin[i]);
                   milstr_ncat(work, tmp, size);
           }
   }
   
   
   // ----
   
   typedef struct {
   const OEMCHAR   *title;
   const PFTBL             *tbl;
   const PFTBL             *tblterm;
           UINT            count;
   } _PFARG, *PFARG;
   
   static BOOL inireadcb(void *arg, const OEMCHAR *para,
                                                                           const OEMCHAR *key, const OEMCHAR *data) {
   
   const PFTBL     *p;
   
         if (arg == NULL) {          if (arg == NULL) {
                 return(FAILURE);                  return(FAILURE);
         }          }
         if (milstr_cmp(para, ((INIARG)arg)->title)) {          if (milstr_cmp(para, ((PFARG)arg)->title)) {
                 return(SUCCESS);                  return(SUCCESS);
         }          }
         p = ((INIARG)arg)->tbl;          p = ((PFARG)arg)->tbl;
         while(p < ((INIARG)arg)->tblterm) {          while(p < ((PFARG)arg)->tblterm) {
                 if (!milstr_cmp(key, p->item)) {                  if (!milstr_cmp(key, p->item)) {
                         switch(p->itemtype) {                          switch(p->itemtype & PFTYPE_MASK) {
                                 case INITYPE_STR:                                  case PFTYPE_STR:
                                         milstr_ncpy((char *)p->value, data, p->size);                                          milstr_ncpy((OEMCHAR *)p->value, data, p->arg);
                                         break;                                          break;
   
                                 case INITYPE_BOOL:                                  case PFTYPE_BOOL:
                                         *((BYTE *)p->value) = (!milstr_cmp(data, str_true))?1:0;                                          *((UINT8 *)p->value) = (!milstr_cmp(data, str_true))?1:0;
                                         break;                                          break;
   
                                 case INITYPE_BYTEARG:                                  case PFTYPE_BIN:
                                         inirdarg8((BYTE *)p->value, p->size, data);                                          binset((UINT8 *)p->value, p->arg, data);
                                         break;                                          break;
   
                                 case INITYPE_SINT8:                                  case PFTYPE_SINT8:
                                 case INITYPE_UINT8:                                  case PFTYPE_UINT8:
                                         *((BYTE *)p->value) = (BYTE)milstr_solveINT(data);                                          *((UINT8 *)p->value) = (UINT8)milstr_solveINT(data);
                                         break;                                          break;
   
                                 case INITYPE_SINT16:                                  case PFTYPE_SINT16:
                                 case INITYPE_UINT16:                                  case PFTYPE_UINT16:
                                         *((UINT16 *)p->value) = (UINT16)milstr_solveINT(data);                                          *((UINT16 *)p->value) = (UINT16)milstr_solveINT(data);
                                         break;                                          break;
   
                                 case INITYPE_SINT32:                                  case PFTYPE_SINT32:
                                 case INITYPE_UINT32:                                  case PFTYPE_UINT32:
                                         *((UINT32 *)p->value) = (UINT32)milstr_solveINT(data);                                          *((UINT32 *)p->value) = (UINT32)milstr_solveINT(data);
                                         break;                                          break;
   
                                 case INITYPE_HEX8:                                  case PFTYPE_HEX8:
                                         *((BYTE *)p->value) = (BYTE)milstr_solveHEX(data);                                          *((UINT8 *)p->value) = (UINT8)milstr_solveHEX(data);
                                         break;                                          break;
   
                                 case INITYPE_HEX16:                                  case PFTYPE_HEX16:
                                         *((UINT16 *)p->value) = (UINT16)milstr_solveHEX(data);                                          *((UINT16 *)p->value) = (UINT16)milstr_solveHEX(data);
                                         break;                                          break;
   
                                 case INITYPE_HEX32:                                  case PFTYPE_HEX32:
                                         *((UINT32 *)p->value) = (UINT32)milstr_solveHEX(data);                                          *((UINT32 *)p->value) = (UINT32)milstr_solveHEX(data);
                                         break;                                          break;
                         }                          }
Line 114  const INITBL *p; Line 132  const INITBL *p;
         return(SUCCESS);          return(SUCCESS);
 }  }
   
 void ini_read(const char *path, const char *title,  void ini_read(const OEMCHAR *path, const OEMCHAR *title,
                                                                                         const INITBL *tbl, UINT count) {                                                                                          const PFTBL *tbl, UINT count) {
   
         _INIARG iniarg;          _PFARG  iniarg;
   
         if (path == NULL) {          if (path == NULL) {
                 return;                  return;
Line 131  void ini_read(const char *path, const ch Line 149  void ini_read(const char *path, const ch
   
 // ----  // ----
   
 static void iniwrsetstr(char *work, int size, const char *ptr) {  static void iniwrsetstr(OEMCHAR *work, int size, const OEMCHAR *ptr) {
   
         int             i;          int             i;
         char    c;          OEMCHAR c;
   
         if (ptr[0] == ' ') {          if (ptr[0] == ' ') {
                 goto iwss_extend;                  goto iwss_extend;
                   
         }          }
         i = strlen(ptr);          i = OEMSTRLEN(ptr);
         if ((i) && (ptr[i-1] == ' ')) {          if ((i) && (ptr[i-1] == ' ')) {
                 goto iwss_extend;                  goto iwss_extend;
         }          }
Line 177  iwss_extend: Line 194  iwss_extend:
         }          }
 }  }
   
 static void iniwrsetarg8(char *work, int size, const BYTE *ptr, int arg) {  void ini_write(const OEMCHAR *path, const OEMCHAR *title,
                                                                                           const PFTBL *tbl, UINT count) {
         int             i;  
         char    tmp[8];  
   
         if (arg > 0) {  
                 SPRINTF(tmp, "%.2x", ptr[0]);  
                 milstr_ncpy(work, tmp, size);  
         }  
         for (i=1; i<arg; i++) {  
                 SPRINTF(tmp, " %.2x", ptr[i]);  
                 milstr_ncat(work, tmp, size);  
         }  
 }  
   
 void ini_write(const char *path, const char *title,  
                                                                                         const INITBL *tbl, UINT count) {  
   
         FILEH           fh;          TEXTFILEH       tfh;
 const INITBL    *p;  const PFTBL             *p;
 const INITBL    *pterm;  const PFTBL             *pterm;
         BOOL            set;          BOOL            set;
         char            work[512];          OEMCHAR         work[512];
   
         fh = file_create(path);          tfh = textfile_create(path, 0x800);
         if (fh == FILEH_INVALID) {          if (tfh == NULL) {
                 return;                  return;
         }          }
         milstr_ncpy(work, "[", sizeof(work));          milstr_ncpy(work, OEMTEXT("["), NELEMENTS(work));
         milstr_ncat(work, title, sizeof(work));          milstr_ncat(work, title, NELEMENTS(work));
         milstr_ncat(work, "]\r\n", sizeof(work));          milstr_ncat(work, OEMTEXT("]\r\n"), NELEMENTS(work));
         file_write(fh, work, strlen(work));          textfile_write(tfh, work);
   
         p = tbl;          p = tbl;
         pterm = tbl + count;          pterm = tbl + count;
         while(p < pterm) {          while(p < pterm) {
                 work[0] = '\0';                  work[0] = '\0';
                 set = SUCCESS;                  set = SUCCESS;
                 switch(p->itemtype) {                  switch(p->itemtype & PFTYPE_MASK) {
                         case INITYPE_STR:                          case PFTYPE_STR:
                                 iniwrsetstr(work, sizeof(work), (char *)p->value);                                  iniwrsetstr(work, NELEMENTS(work), (OEMCHAR *)p->value);
                                 break;                                  break;
   
                         case INITYPE_BOOL:                          case PFTYPE_BOOL:
                                 milstr_ncpy(work, (*((BYTE *)p->value))?str_true:str_false,                                  milstr_ncpy(work, (*((UINT8 *)p->value))?str_true:str_false,
                                                                                                                                 sizeof(work));                                                                                                                          NELEMENTS(work));
                                 break;                                  break;
   
                         case INITYPE_BYTEARG:                          case PFTYPE_BIN:
                                 iniwrsetarg8(work, sizeof(work), (BYTE *)p->value, p->size);                                  binget(work, NELEMENTS(work), (UINT8 *)p->value, p->arg);
                                 break;                                  break;
   
                         case INITYPE_SINT8:                          case PFTYPE_SINT8:
                                 SPRINTF(work, "%d", *((char *)p->value));                                  OEMSPRINTF(work, str_d, *((SINT8 *)p->value));
                                 break;                                  break;
   
                         case INITYPE_SINT16:                          case PFTYPE_SINT16:
                                 SPRINTF(work, "%d", *((SINT16 *)p->value));                                  OEMSPRINTF(work, str_d, *((SINT16 *)p->value));
                                 break;                                  break;
   
                         case INITYPE_SINT32:                          case PFTYPE_SINT32:
                                 SPRINTF(work, "%d", *((SINT32 *)p->value));                                  OEMSPRINTF(work, str_d, *((SINT32 *)p->value));
                                 break;                                  break;
   
                         case INITYPE_UINT8:                          case PFTYPE_UINT8:
                                 SPRINTF(work, "%u", *((BYTE *)p->value));                                  OEMSPRINTF(work, str_u, *((UINT8 *)p->value));
                                 break;                                  break;
   
                         case INITYPE_UINT16:                          case PFTYPE_UINT16:
                                 SPRINTF(work, "%u", *((UINT16 *)p->value));                                  OEMSPRINTF(work, str_u, *((UINT16 *)p->value));
                                 break;                                  break;
   
                         case INITYPE_UINT32:                          case PFTYPE_UINT32:
                                 SPRINTF(work, "%u", *((UINT32 *)p->value));                                  OEMSPRINTF(work, str_u, *((UINT32 *)p->value));
                                 break;                                  break;
   
                         case INITYPE_HEX8:                          case PFTYPE_HEX8:
                                 SPRINTF(work, "%x", *((BYTE *)p->value));                                  OEMSPRINTF(work, str_x, *((UINT8 *)p->value));
                                 break;                                  break;
   
                         case INITYPE_HEX16:                          case PFTYPE_HEX16:
                                 SPRINTF(work, "%x", *((UINT16 *)p->value));                                  OEMSPRINTF(work, str_x, *((UINT16 *)p->value));
                                 break;                                  break;
   
                         case INITYPE_HEX32:                          case PFTYPE_HEX32:
                                 SPRINTF(work, "%x", *((UINT32 *)p->value));                                  OEMSPRINTF(work, str_x, *((UINT32 *)p->value));
                                 break;                                  break;
   
                         default:                          default:
Line 270  const INITBL *pterm; Line 272  const INITBL *pterm;
                                 break;                                  break;
                 }                  }
                 if (set == SUCCESS) {                  if (set == SUCCESS) {
                         file_write(fh, p->item, strlen(p->item));                          textfile_write(tfh, p->item);
                         file_write(fh, "=", 1);                          textfile_write(tfh, OEMTEXT("="));
                         file_write(fh, work, strlen(work));                          textfile_write(tfh, work);
                         file_write(fh, "\r\n", 2);                          textfile_write(tfh, OEMTEXT("\r\n"));
                 }                  }
                 p++;                  p++;
         }          }
         file_close(fh);          textfile_close(tfh);
 }  }
   
   
 // ----  // ----
   
 static const char ini_title[] = "NekoProjectII";  #if defined(OSLANG_UTF8)
 static const char inifile[] = "np2.cfg";  static const OEMCHAR ini_title[] = OEMTEXT("NekoProjectIICE");
   static const OEMCHAR inifile[] = OEMTEXT("np2ce.cfg");
 static const INITBL iniitem[] = {  #else
         {"pc_model", INITYPE_STR,               &np2cfg.model,  static const OEMCHAR ini_title[] = OEMTEXT("NekoProjectII");
                                                                                                         sizeof(np2cfg.model)},  static const OEMCHAR inifile[] = OEMTEXT("np2.cfg");
         {"clk_base", INITYPE_SINT32,    &np2cfg.baseclock,              0},  #endif
         {"clk_mult", INITYPE_SINT32,    &np2cfg.multiple,               0},  
   enum {
         {"DIPswtch", INITYPE_BYTEARG,   np2cfg.dipsw,                   3},          PFRO_STR                = PFFLAG_RO + PFTYPE_STR,
         {"MEMswtch", INITYPE_BYTEARG,   np2cfg.memsw,                   8},          PFRO_BOOL               = PFFLAG_RO + PFTYPE_BOOL,
         {"ExMemory", INITYPE_UINT8,             &np2cfg.EXTMEM,                 0},          PFRO_HEX32              = PFFLAG_RO + PFTYPE_HEX32
         {"ITF_WORK", INITYPE_BOOL,              &np2cfg.ITF_WORK,               0},  };
   
         {"HDD1FILE", INITYPE_STR,               np2cfg.hddfile[0],              MAX_PATH},  static const PFTBL iniitem[] = {
         {"HDD2FILE", INITYPE_STR,               np2cfg.hddfile[1],              MAX_PATH},          PFSTR("pc_model", PFTYPE_STR,           np2cfg.model),
           PFVAL("clk_base", PFTYPE_UINT32,        &np2cfg.baseclock),
         {"SampleHz", INITYPE_UINT16,    &np2cfg.samplingrate,   0},          PFVAL("clk_mult", PFTYPE_UINT32,        &np2cfg.multiple),
         {"Latencys", INITYPE_UINT16,    &np2cfg.delayms,                0},  
         {"SNDboard", INITYPE_HEX8,              &np2cfg.SOUND_SW,               0},          PFEXT("DIPswtch", PFTYPE_BIN,           np2cfg.dipsw,                   3),
         {"BEEP_vol", INITYPE_UINT8,             &np2cfg.BEEP_VOL,               0},          PFEXT("MEMswtch", PFTYPE_BIN,           np2cfg.memsw,                   8),
         {"xspeaker", INITYPE_BOOL,              &np2cfg.snd_x,                  0},          PFMAX("ExMemory", PFTYPE_UINT8,         &np2cfg.EXTMEM,                 63),
           PFVAL("ITF_WORK", PFRO_BOOL,            &np2cfg.ITF_WORK),
         {"SND14vol", INITYPE_BYTEARG,   np2cfg.vol14,                   6},  
 //      {"opt14BRD", INITYPE_BYTEARG,   np2cfg.snd14opt,                3},          PFSTR("HDD1FILE", PFTYPE_STR,           np2cfg.sasihdd[0]),
         {"opt26BRD", INITYPE_HEX8,              &np2cfg.snd26opt,               0},          PFSTR("HDD2FILE", PFTYPE_STR,           np2cfg.sasihdd[1]),
         {"opt86BRD", INITYPE_HEX8,              &np2cfg.snd86opt,               0},  #if defined(SUPPORT_SCSI)
         {"optSPBRD", INITYPE_HEX8,              &np2cfg.spbopt,                 0},          PFSTR("SCSIHDD0", PFTYPE_STR,           np2cfg.scsihdd[0]),
         {"optSPBVR", INITYPE_HEX8,              &np2cfg.spb_vrc,                0},          PFSTR("SCSIHDD1", PFTYPE_STR,           np2cfg.scsihdd[1]),
         {"optSPBVL", INITYPE_UINT8,             &np2cfg.spb_vrl,                0},          PFSTR("SCSIHDD2", PFTYPE_STR,           np2cfg.scsihdd[2]),
         {"optSPB_X", INITYPE_BOOL,              &np2cfg.spb_x,                  0},          PFSTR("SCSIHDD3", PFTYPE_STR,           np2cfg.scsihdd[3]),
         {"optMPU98", INITYPE_HEX8,              &np2cfg.mpuopt,                 0},  #endif
           PFSTR("fontfile", PFTYPE_STR,           np2cfg.fontfile),
         {"volume_F", INITYPE_UINT8,             &np2cfg.vol_fm,                 0},          PFSTR("biospath", PFRO_STR,                     np2cfg.biospath),
         {"volume_S", INITYPE_UINT8,             &np2cfg.vol_ssg,                0},  
         {"volume_A", INITYPE_UINT8,             &np2cfg.vol_adpcm,              0},          PFVAL("SampleHz", PFTYPE_UINT16,        &np2cfg.samplingrate),
         {"volume_P", INITYPE_UINT8,             &np2cfg.vol_pcm,                0},          PFVAL("Latencys", PFTYPE_UINT16,        &np2cfg.delayms),
         {"volume_R", INITYPE_UINT8,             &np2cfg.vol_rhythm,             0},          PFVAL("SNDboard", PFTYPE_HEX8,          &np2cfg.SOUND_SW),
           PFAND("BEEP_vol", PFTYPE_UINT8,         &np2cfg.BEEP_VOL,               3),
         {"Seek_Snd", INITYPE_BOOL,              &np2cfg.MOTOR,                  0},          PFVAL("xspeaker", PFRO_BOOL,            &np2cfg.snd_x),
         {"Seek_Vol", INITYPE_UINT8,             &np2cfg.MOTORVOL,               0},  
           PFEXT("SND14vol", PFTYPE_BIN,           np2cfg.vol14,                   6),
         {"btnRAPID", INITYPE_BOOL,              &np2cfg.BTN_RAPID,              0},  //      PFEXT("opt14BRD", PFTYPE_BIN,           np2cfg.snd14opt,                3),
         {"btn_MODE", INITYPE_BOOL,              &np2cfg.BTN_MODE,               0},          PFVAL("opt26BRD", PFTYPE_HEX8,          &np2cfg.snd26opt),
         {"MS_RAPID", INITYPE_BOOL,              &np2cfg.MOUSERAPID,             0},          PFVAL("opt86BRD", PFTYPE_HEX8,          &np2cfg.snd86opt),
           PFVAL("optSPBRD", PFTYPE_HEX8,          &np2cfg.spbopt),
         {"VRAMwait", INITYPE_BYTEARG,   np2cfg.wait,                    6},          PFVAL("optSPBVR", PFTYPE_HEX8,          &np2cfg.spb_vrc),
         {"DispSync", INITYPE_BOOL,              &np2cfg.DISPSYNC,               0},          PFMAX("optSPBVL", PFTYPE_UINT8,         &np2cfg.spb_vrl,                24),
         {"Real_Pal", INITYPE_BOOL,              &np2cfg.RASTER,                 0},          PFVAL("optSPB_X", PFTYPE_BOOL,          &np2cfg.spb_x),
         {"RPal_tim", INITYPE_UINT8,             &np2cfg.realpal,                0},          PFVAL("optMPU98", PFTYPE_HEX8,          &np2cfg.mpuopt),
         {"s_NOWAIT", INITYPE_BOOL,              &np2oscfg.NOWAIT,               0},  
         {"SkpFrame", INITYPE_UINT8,             &np2oscfg.DRAW_SKIP,    0},          PFMAX("volume_F", PFTYPE_UINT8,         &np2cfg.vol_fm,                 128),
         {"uPD72020", INITYPE_BOOL,              &np2cfg.uPD72020,               0},          PFMAX("volume_S", PFTYPE_UINT8,         &np2cfg.vol_ssg,                128),
         {"GRCG_EGC", INITYPE_UINT8,             &np2cfg.grcg,                   0},          PFMAX("volume_A", PFTYPE_UINT8,         &np2cfg.vol_adpcm,              128),
         {"color16b", INITYPE_BOOL,              &np2cfg.color16,                0},          PFMAX("volume_P", PFTYPE_UINT8,         &np2cfg.vol_pcm,                128),
         {"skipline", INITYPE_BOOL,              &np2cfg.skipline,               0},          PFMAX("volume_R", PFTYPE_UINT8,         &np2cfg.vol_rhythm,             128),
         {"skplight", INITYPE_SINT16,    &np2cfg.skiplight,              0},  
         {"LCD_MODE", INITYPE_UINT8,             &np2cfg.LCD_MODE,               0},          PFVAL("Seek_Snd", PFTYPE_BOOL,          &np2cfg.MOTOR),
         {"BG_COLOR", INITYPE_HEX32,             &np2cfg.BG_COLOR,               0},          PFMAX("Seek_Vol", PFTYPE_UINT8,         &np2cfg.MOTORVOL,               100),
         {"FG_COLOR", INITYPE_HEX32,             &np2cfg.FG_COLOR,               0},  
         {"pc9861_e", INITYPE_BOOL,              &np2cfg.pc9861enable,   0},          PFVAL("btnRAPID", PFTYPE_BOOL,          &np2cfg.BTN_RAPID),
         {"pc9861_s", INITYPE_BYTEARG,   np2cfg.pc9861sw,                3},          PFVAL("btn_MODE", PFTYPE_BOOL,          &np2cfg.BTN_MODE),
         {"pc9861_j", INITYPE_BYTEARG,   np2cfg.pc9861jmp,               6},          PFVAL("MS_RAPID", PFTYPE_BOOL,          &np2cfg.MOUSERAPID),
         {"calendar", INITYPE_BOOL,              &np2cfg.calendar,               0},  
         {"USE144FD", INITYPE_BOOL,              &np2cfg.usefd144,               0}};          PFEXT("VRAMwait", PFTYPE_BIN,           np2cfg.wait,                    6),
           PFVAL("DispSync", PFTYPE_BOOL,          &np2cfg.DISPSYNC),
 #define INIITEMS        (sizeof(iniitem) / sizeof(INITBL))          PFVAL("Real_Pal", PFTYPE_BOOL,          &np2cfg.RASTER),
           PFMAX("RPal_tim", PFTYPE_UINT8,         &np2cfg.realpal,                64),
           PFVAL("uPD72020", PFTYPE_BOOL,          &np2cfg.uPD72020),
           PFAND("GRCG_EGC", PFTYPE_UINT8,         &np2cfg.grcg,                   3),
           PFVAL("color16b", PFTYPE_BOOL,          &np2cfg.color16),
           PFVAL("skipline", PFTYPE_BOOL,          &np2cfg.skipline),
           PFVAL("skplight", PFTYPE_UINT16,        &np2cfg.skiplight),
           PFAND("LCD_MODE", PFTYPE_UINT8,         &np2cfg.LCD_MODE,               0x03),
           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),
   
           // OS°Í¸¡Á
           PFVAL("s_NOWAIT", PFTYPE_BOOL,          &np2oscfg.NOWAIT),
           PFVAL("SkpFrame", PFTYPE_UINT8,         &np2oscfg.DRAW_SKIP),
           PFVAL("F12_bind", PFTYPE_UINT8,         &np2oscfg.F12KEY),
           PFVAL("e_resume", PFTYPE_BOOL,          &np2oscfg.resume),
   
   #if !defined(GX_DLL)
           PFVAL("WindposX", PFTYPE_SINT32,        &np2oscfg.winx),
           PFVAL("WindposY", PFTYPE_SINT32,        &np2oscfg.winy),
   #endif
   #if defined(WIN32_PLATFORM_PSPC)
           PFVAL("pbindcur", PFTYPE_UINT8,         &np2oscfg.bindcur),
           PFVAL("pbindbtn", PFTYPE_UINT8,         &np2oscfg.bindbtn),
   #endif
           PFVAL("jast_snd", PFTYPE_BOOL,          &np2oscfg.jastsnd),
   };
   
   
 void initload(void) {  void initload(void) {
   
         char    path[MAX_PATH];          OEMCHAR path[MAX_PATH];
   
         milstr_ncpy(path, file_getcd(inifile), sizeof(path));          milstr_ncpy(path, file_getcd(inifile), NELEMENTS(path));
         ini_read(path, ini_title, iniitem, INIITEMS);          ini_read(path, ini_title, iniitem, NELEMENTS(iniitem));
 }  }
   
 void initsave(void) {  void initsave(void) {
   
         char    path[MAX_PATH];          OEMCHAR path[MAX_PATH];
   
         milstr_ncpy(path, file_getcd(inifile), sizeof(path));          milstr_ncpy(path, file_getcd(inifile), NELEMENTS(path));
         ini_write(path, ini_title, iniitem, INIITEMS);          ini_write(path, ini_title, iniitem, NELEMENTS(iniitem));
 }  }
   
Removed from v.1.3  
changed lines
  Added in v.1.17

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