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

Diff for /np2/win9x/ini.cpp between versions 1.2 and 1.38

version 1.2, 2003/10/21 11:22:05 version 1.38, 2005/03/20 08:58:19
Line 1 Line 1
 #include        "compiler.h"  #include        "compiler.h"
 #include        <windowsx.h>  #include        <windowsx.h>
 #include        <io.h>  #include        <io.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"
   
   
 #define         CFGLEN          (MAX_PATH + 32)  
   
 static const char ini_title[] = "NekoProjectII";  static BOOL inigetbmp(const UINT8 *ptr, UINT pos) {
   
 typedef struct {          return((ptr[pos >> 3] >> (pos & 7)) & 1);
         char    item[9];  
         BYTE    itemtype;  
         WORD    flag;  
         void    *value;  
         DWORD   arg;  
 } INI_ITEM;  
   
 #define INI_RO          0x0001  
 #define INIAND          0x0002  
 #define INIMAX          0x0004  
 #define INIA4           0x0008  
 #define INIEND          0x8000  
   
 #define INI_STR         0x00  
 #define INI_BOOL        0x01  
 #define INI_ARG         0x02  
 #define INI_BYTE        0x11  
 #define INI_WORD        0x12  
 #define INI_DWORD       0x14  
 #define INI_HEXB        0x21  
 #define INI_HEXD        0x24  
 #define INI_EX          0x80  
   
   
 static INI_ITEM iniitem[] = {  
   
         {"np2title", INI_STR,   INI_RO|INIMAX,  
                                                                         np2oscfg.titles, sizeof(np2oscfg.titles)},  
         {"np2winid", INI_EX|0,  INI_RO, np2oscfg.winid,                 0},  
   
         {"WindposX", INI_DWORD, 0,              &np2oscfg.winx,                 0},  
         {"WindposY", INI_DWORD, 0,              &np2oscfg.winy,                 0},  
         {"paddingx", INI_DWORD, INI_RO|INIMAX,  
                                                                         &np2oscfg.paddingx,             32},  
         {"paddingy", INI_DWORD, INI_RO|INIMAX,  
                                                                         &np2oscfg.paddingy,             32},  
         {"Win_Snap", INI_BOOL,  0,              &np2oscfg.WINSNAP,              0},  
   
         {"FDfolder", INI_STR,   INIMAX, fddfolder,                              MAX_PATH},  
         {"HDfolder", INI_STR,   INIMAX, hddfolder,                              MAX_PATH},  
         {"bmap_Dir", INI_STR,   INIMAX, bmpfilefolder,                  MAX_PATH},  
   
         {"fontfile", INI_STR,   INIMAX, np2cfg.fontfile,                MAX_PATH},  
   
         {"clk_base", INI_DWORD, 0,              &np2cfg.baseclock,              0},  
         {"clk_mult", INI_DWORD, 0,              &np2cfg.multiple,               0},  
   
         {"DIPswtch", INI_ARG,   0,              np2cfg.dipsw,                   3},  
         {"MEMswtch", INI_ARG,   0,              np2cfg.memsw,                   8},  
         {"ExMemory", INI_BYTE,  INIMAX, &np2cfg.EXTMEM,                 13},  
         {"ITF_WORK", INI_BOOL,  INI_RO, &np2cfg.ITF_WORK,               0},  
   
         {"HDD1FILE", INI_STR,   INIMAX, np2cfg.hddfile[0],              MAX_PATH},  
         {"HDD2FILE", INI_STR,   INIMAX, np2cfg.hddfile[1],              MAX_PATH},  
 //      {"Removabl", INI_EX|1,  0,              &np2cfg.REMOVEHD,               0},  
   
         {"SampleHz", INI_WORD,  0,              &np2cfg.samplingrate,   0},  
         {"Latencys", INI_WORD,  0,              &np2cfg.delayms,                0},  
         {"SNDboard", INI_HEXB,  0,              &np2cfg.SOUND_SW,               0},  
         {"BEEP_vol", INI_BYTE,  INIAND, &np2cfg.BEEP_VOL,               0x03},  
         {"xspeaker", INI_BOOL,  INI_RO, &np2cfg.snd_x,                  0},  
   
         {"SND14vol", INI_ARG,   INIA4,  np2cfg.vol14,                   6},             // ver0.27  
 //      {"opt14BRD", INI_ARG,   0,              np2cfg.snd14opt,                3},  
         {"opt26BRD", INI_HEXB,  0,              &np2cfg.snd26opt,               0},  
         {"opt86BRD", INI_HEXB,  0,              &np2cfg.snd86opt,               0},  
         {"optSPBRD", INI_HEXB,  0,              &np2cfg.spbopt,                 0},  
         {"optSPBVR", INI_HEXB,  0,              &np2cfg.spb_vrc,                0},             // ver0.30  
         {"optSPBVL", INI_BYTE,  INIMAX, &np2cfg.spb_vrl,                24},    // ver0.30  
         {"optSPB_X", INI_BOOL,  0,              &np2cfg.spb_x,                  0},  
         {"optMPU98", INI_HEXB,  0,              &np2cfg.mpuopt,                 0},  
   
         {"volume_F", INI_BYTE,  INIMAX, &np2cfg.vol_fm,                 128},   // ver0.28  
         {"volume_S", INI_BYTE,  INIMAX, &np2cfg.vol_ssg,                128},  
         {"volume_A", INI_BYTE,  INIMAX, &np2cfg.vol_adpcm,              128},  
         {"volume_P", INI_BYTE,  INIMAX, &np2cfg.vol_pcm,                128},  
         {"volume_R", INI_BYTE,  INIMAX, &np2cfg.vol_rhythm,             128},  
   
         {"Seek_Snd", INI_BOOL,  0,              &np2cfg.MOTOR,                  0},  
         {"Seek_Vol", INI_BYTE,  INIMAX, &np2cfg.MOTORVOL,               100},  
   
         {"btnRAPID", INI_BOOL,  0,              &np2cfg.BTN_RAPID,              0},  
         {"btn_MODE", INI_BOOL,  0,              &np2cfg.BTN_MODE,               0},  
         {"Mouse_sw", INI_BOOL,  0,              &np2oscfg.MOUSE_SW,             0},  
         {"MS_RAPID", INI_BOOL,  0,              &np2cfg.MOUSERAPID,             0},  
   
         {"backgrnd", INI_BYTE,  INIAND, &np2oscfg.background,   0x03},  
         {"VRAMwait", INI_ARG,   0,              np2cfg.wait,                    6},  
         {"DspClock", INI_BYTE,  INIAND, &np2oscfg.DISPCLK,              0x03},  
         {"DispSync", INI_BOOL,  0,              &np2cfg.DISPSYNC,               0},  
         {"Real_Pal", INI_BOOL,  0,              &np2cfg.RASTER,                 0},  
         {"RPal_tim", INI_BYTE,  INIMAX, &np2cfg.realpal,                64},  
         {"s_NOWAIT", INI_BOOL,  0,              &np2oscfg.NOWAIT,               0},  
         {"SkpFrame", INI_BYTE,  0,              &np2oscfg.DRAW_SKIP,    0},  
         {"uPD72020", INI_BOOL,  0,              &np2cfg.uPD72020,               0},  
         {"GRCG_EGC", INI_BYTE,  INIAND, &np2cfg.grcg,                   0x03},  
         {"color16b", INI_BOOL,  0,              &np2cfg.color16,                0},  
         {"skipline", INI_BOOL,  0,              &np2cfg.skipline,               0},  
         {"skplight", INI_WORD,  0,              &np2cfg.skiplight,              0},  
         {"LCD_MODE", INI_BYTE,  INIAND, &np2cfg.LCD_MODE,               0x03},  
         {"BG_COLOR", INI_HEXD,  INI_RO|INIAND,  
                                                                         &np2cfg.BG_COLOR,               0xffffff},  
         {"FG_COLOR", INI_HEXD,  INI_RO|INIAND,  
                                                                         &np2cfg.FG_COLOR,               0xffffff},  
   
         {"pc9861_e", INI_BOOL,  0,              &np2cfg.pc9861enable,   0},             // ver0.29  
         {"pc9861_s", INI_ARG,   0,              np2cfg.pc9861sw,                3},  
         {"pc9861_j", INI_ARG,   0,              np2cfg.pc9861jmp,               6},  
   
         {"calendar", INI_BOOL,  0,              &np2cfg.calendar,               0},             // ver0.34  
         {"USE144FD", INI_BOOL,  0,              &np2cfg.usefd144,               0},             // ver0.31  
   
         // OS°Í¸¡©                                                                                                             // ver0.29  
         {"keyboard", INI_EX|3,  INI_RO, &np2oscfg.KEYBOARD,             0},  
         {"F12_COPY", INI_BYTE,  0,              &np2oscfg.F12COPY,              0},  
         {"Joystick", INI_BOOL,  0,              &np2oscfg.JOYPAD1,              0},             // ver0.28  
         {"Joy1_btn", INI_ARG,   0,              np2oscfg.JOY1BTN,               4},  
   
         {"clocknow", INI_BYTE,  0,              &np2oscfg.clk_x,                0},  
         {"clockfnt", INI_BYTE,  0,              &np2oscfg.clk_fnt,              0},  
         {"clock_up", INI_HEXD,  INI_RO|INIAND,  
                                                                         &np2oscfg.clk_color1,   0xffffff},  
         {"clock_dn", INI_HEXD,  INI_RO|INIAND,  
                                                                         &np2oscfg.clk_color2,   0xffffff},  
   
         {"use_sstp", INI_BOOL,  0,              &np2oscfg.sstp,                 0},  
         {"sstpport", INI_WORD,  0,              &np2oscfg.sstpport,             0},  
         {"comfirm_", INI_BOOL,  0,              &np2oscfg.comfirm,              0},  
         {"shortcut", INI_HEXB,  0,              &np2oscfg.shortcut,             0},             // ver0.30  
   
   
         {"mpu98map", INI_STR,   INIMAX, np2oscfg.mpu.mout,              MAXPNAMELEN},  
         {"mpu98min", INI_STR,   INIMAX, np2oscfg.mpu.min,               MAXPNAMELEN},  
         {"mpu98mdl", INI_STR,   INIMAX, np2oscfg.mpu.mdl,               64},  
         {"mpu98def", INI_STR,   INIMAX, np2oscfg.mpu.def,               MAX_PATH},  
   
         {"com1port", INI_BYTE,  INIMAX, &np2oscfg.com1.port,    5},             // ver0.34  
         {"com1para", INI_BYTE,  0,              &np2oscfg.com1.param,   0},  
         {"com1_bps", INI_DWORD, 0,              &np2oscfg.com1.speed,   0},  
         {"com1mmap", INI_STR,   INIMAX, np2oscfg.com1.mout,             MAXPNAMELEN},  
         {"com1mmdl", INI_STR,   INIMAX, np2oscfg.com1.mdl,              64},  
         {"com1mdef", INI_STR,   INIMAX, np2oscfg.com1.def,              MAX_PATH},  
   
         {"com2port", INI_BYTE,  INIMAX, &np2oscfg.com2.port,    5},             // ver0.34  
         {"com2para", INI_BYTE,  0,              &np2oscfg.com2.param,   0},  
         {"com2_bps", INI_DWORD, 0,              &np2oscfg.com2.speed,   0},  
         {"com2mmap", INI_STR,   INIMAX, np2oscfg.com2.mout,             MAXPNAMELEN},  
         {"com2mmdl", INI_STR,   INIMAX, np2oscfg.com2.mdl,              64},  
         {"com2mdef", INI_STR,   INIMAX, np2oscfg.com2.def,              MAX_PATH},  
   
         {"com3port", INI_BYTE,  INIMAX, &np2oscfg.com3.port,    5},             // ver0.34  
         {"com3para", INI_BYTE,  0,              &np2oscfg.com3.param,   0},  
         {"com3_bps", INI_DWORD, 0,              &np2oscfg.com3.speed,   0},  
         {"com3mmap", INI_STR,   INIMAX, np2oscfg.com3.mout,             MAXPNAMELEN},  
         {"com3mmdl", INI_STR,   INIMAX, np2oscfg.com3.mdl,              64},  
         {"com3mdef", INI_STR,   INIMAX, np2oscfg.com3.def,              MAX_PATH},  
   
         {"force400", INI_BOOL,  INI_RO, &np2oscfg.force400,             0},  
         {"e_resume", INI_BOOL,  0,              &np2oscfg.resume,               0},             // ver0.30  
         {"STATSAVE", INI_BOOL,  INI_RO, &np2oscfg.statsave,             0},             // ver0.30  
   
         {"I286SAVE", INI_BOOL,  INI_RO|INIEND,  
                                                                         &np2oscfg.I286SAVE,             0}};  
   
 #define INIITEMS        (sizeof(iniitem) / sizeof(INI_ITEM))  
   
   
 static long solveHEX(char *str) {  
   
         return(milstr_solveHEX(str));  
 }  
   
 static char *makeBOOL(BYTE value) {  
   
         if (value) {  
                 return("true");  
         }  
         return("false");  
 }  
   
 static BYTE solveBOOL(LPSTR str) {  
   
         if ((!milstr_cmp(str, "TRUE")) || (!milstr_cmp(str, "ON")) ||  
                 (!milstr_cmp(str, "+")) || (!milstr_cmp(str, "1")) ||  
                 (!milstr_cmp(str, "ENABLE"))) {  
                 return(1);  
         }  
         return(0);  
 }  }
   
   static void inisetbmp(UINT8 *ptr, UINT pos, BOOL set) {
   
 static void getinifile(char *initfile, int max) {          UINT8   bit;
   
         char    *p;  
   
         milstr_ncpy(initfile, modulefile, max);          ptr += (pos >> 3);
         if (np2arg.ini) {          bit = 1 << (pos & 7);
                 if ((np2arg.ini[0] == '/') || (np2arg.ini[0] == '-')) {          if (set) {
                         file_cutname(initfile);                  *ptr |= bit;
                         milstr_ncat(initfile, file_getname(np2arg.ini + 2), max);  
                 }  
                 else {  
                         milstr_ncpy(initfile, np2arg.ini, max);  
                 }  
                 p = file_getext(initfile);  
                 if (!(*p)) {  
                         milstr_ncat(initfile, ".ini", max);  
                 }  
         }          }
         else {          else {
                 file_cutext(initfile);                  *ptr &= ~bit;
                 milstr_ncat(initfile, ".ini", max);  
         }          }
 }  }
   
   static void inirdargs16(const OEMCHAR *src, const PFTBL *ini) {
   
 void initload(void) {          SINT16  *dst;
           int             dsize;
           int             i;
           OEMCHAR c;
   
         char            initfile[MAX_PATH];          dst = (SINT16 *)ini->value;
         char            cfgstr[CFGLEN];          dsize = ini->arg;
         DWORD           i;  
         char            *arg[8];          for (i=0; i<dsize; i++) {
         DWORD           args;                  while(*src == ' ') {
         INI_ITEM        *p;                          src++;
                   }
         getinifile(initfile, MAX_PATH);                                                                 // ver0.29                  if (*src == '\0') {
         p = iniitem;                          break;
         while(1) {                  }
                 if (!(p->itemtype & 0xf0)) {                  dst[i] = (SINT16)milstr_solveINT(src);
                         switch(p->itemtype) {                  while(*src != '\0') {
                                 case INI_STR:                          c = *src++;
                                         GetPrivateProfileString(ini_title, p->item,                          if (c == ',') {
                                                                                 (char *)p->value, (char *)p->value,                                  break;
                                                                                 p->arg, initfile);  
                                         break;  
                                 case INI_BOOL:  
                                         GetPrivateProfileString(ini_title, p->item,  
                                                                                 makeBOOL(*((BYTE *)p->value) & 1),  
                                                                                                 cfgstr, CFGLEN, initfile);  
                                         *(BYTE *)(p->value) = solveBOOL(cfgstr);  
                                         break;  
                                 case INI_ARG:  
                                         GetPrivateProfileString(ini_title, p->item, "",  
                                                                                                 cfgstr, CFGLEN, initfile);  
                                         args = milstr_getarg(cfgstr, arg, p->arg);  
                                         if (args == p->arg) {  
                                                 for (i=0; i<args; i++) {  
                                                         ((BYTE *)p->value)[i] = (BYTE)solveHEX(arg[i]);  
                                                         if (p->flag & INIA4) {  
                                                                 ((BYTE *)p->value)[i] &= 0x0f;  
                                                         }  
                                                 }  
                                         }  
                                         break;  
                         }                          }
                 }                  }
                 else if (!(p->itemtype & INI_EX)) {          }
                         switch(p->itemtype) {  }
                                 case INI_BYTE:  
                                         *(BYTE *)p->value = (BYTE)GetPrivateProfileInt(  static void inirdargh8(const OEMCHAR *src, const PFTBL *ini) {
                                                         ini_title, p->item, *(BYTE *)p->value, initfile);  
                                         break;          UINT8   *dst;
                                 case INI_WORD:          int             dsize;
                                         *(WORD *)p->value = (WORD)GetPrivateProfileInt(          int             i;
                                                         ini_title, p->item, *(WORD *)p->value, initfile);          UINT8   val;
                                         break;          BOOL    set;
                                 case INI_DWORD:          OEMCHAR c;
                                         *(DWORD *)p->value = (DWORD)GetPrivateProfileInt(  
                                                         ini_title, p->item, *(DWORD *)p->value, initfile);          dst = (UINT8 *)ini->value;
                                         break;          dsize = ini->arg;
                                 case INI_HEXB:  
                                         wsprintf(cfgstr, "%x", *(BYTE *)p->value),          for (i=0; i<dsize; i++) {
                                         GetPrivateProfileString(ini_title, p->item,                  val = 0;
                                                                                 cfgstr, cfgstr, CFGLEN, initfile);                  set = FALSE;
                                         *(BYTE *)p->value = (BYTE)solveHEX(cfgstr);                  while(*src == ' ') {
                                         break;                          src++;
                                 case INI_HEXD:                  }
                                         wsprintf(cfgstr, "%x", *(DWORD *)p->value),                  while(1) {
                                         GetPrivateProfileString(ini_title, p->item,                          c = *src;
                                                                                 cfgstr, cfgstr, CFGLEN, initfile);                          if ((c == '\0') || (c == ' ')) {
                                         *(DWORD *)p->value = solveHEX(cfgstr);                                  break;
                                         break;  
                         }                          }
                         if (p->flag & INIMAX) {                          else if ((c >= '0') && (c <= '9')) {
                                 switch((p->itemtype) & 0x0f) {                                  val <<= 4;
                                         case 1:                                  val += c - '0';
                                                 if (*(BYTE *)p->value > (BYTE)p->arg) {                                  set = TRUE;
                                                         *(BYTE *)p->value = (BYTE)p->arg;  
                                                 }  
                                                 break;  
                                         case 2:  
                                                 if (*(WORD *)p->value > (WORD)p->arg) {  
                                                         *(WORD *)p->value = (WORD)p->arg;  
                                                 }  
                                                 break;  
                                         case 4:  
                                                 if (*(DWORD *)p->value > (DWORD)p->arg) {  
                                                         *(DWORD *)p->value = (DWORD)p->arg;  
                                                 }  
                                                 break;  
                                 }  
                         }                          }
                         if (p->flag & INIAND) {                          else {
                                 switch((p->itemtype) & 0x0f) {                                  c |= 0x20;
                                         case 1:                                  if ((c >= 'a') && (c <= 'f')) {
                                                 *(BYTE *)p->value &= (BYTE)p->arg;                                          val <<= 4;
                                                 break;                                          val += c - 'a' + 10;
                                         case 2:                                          set = TRUE;
                                                 *(WORD *)p->value &= (WORD)p->arg;  
                                                 break;  
                                         case 4:  
                                                 *(DWORD *)p->value &= (DWORD)p->arg;  
                                                 break;  
                                 }                                  }
                         }                          }
                           src++;
                 }                  }
                 else {                  if (set == FALSE) {
                         switch(p->itemtype) {                          break;
                                 case INI_EX|0:                          // winid  
                                         GetPrivateProfileString(ini_title, p->item,  
                                                                 (char *)p->value, cfgstr, CFGLEN, initfile);  
                                         for (i=0; i<3; i++) {  
                                                 if (((cfgstr[i] >= '0') && (cfgstr[i] < '9')) ||  
                                                         ((cfgstr[i] >= 'A') && (cfgstr[i] < 'Z')) ||  
                                                         ((cfgstr[i] >= 'a') && (cfgstr[i] < 'z'))) {  
                                                         ((BYTE *)p->value)[i] = cfgstr[i];  
                                                 }  
                                         }  
                                         break;  
                                 case INI_EX|1:                          // remove hdd  
                                         *(BYTE *)p->value =  
                                                         (BYTE)((GetPrivateProfileInt(ini_title, p->item,  
                                                                                 ((*(BYTE *)p->value) & 1) + 1,  
                                                                                         initfile) - 1) & 1);  
                                         break;  
 #if 0  
                                 case INI_EX|2:                          // midi module  
                                         GetPrivateProfileString(ini_title, p->item,  
                                                                                 MIDI_num2module(*(BYTE *)p->value),  
                                                                                 cfgstr, CFGLEN, initfile);  
                                         *(BYTE *)p->value = MIDI_module2num(cfgstr);  
                                         break;  
 #endif  
                                 case INI_EX|3:                          // keyboard  
                                         GetPrivateProfileString(ini_title, p->item, "unknown",  
                                                                                                 cfgstr, CFGLEN, initfile);  
                                         if ((!milstr_extendcmp(cfgstr, "PC98")) ||  
                                                 (!milstr_cmp(cfgstr, "98"))) {  
                                                 *(BYTE *)p->value = KEY_PC98;  
                                         }  
                                         else if ((!milstr_extendcmp(cfgstr, "DOS")) ||  
                                                         (!milstr_cmp(cfgstr, "PCAT")) ||  
                                                         (!milstr_cmp(cfgstr, "AT"))) {  
                                                 *(BYTE *)p->value = KEY_KEY106;  
                                         }  
                                         else if ((!milstr_extendcmp(cfgstr, "KEY101")) ||  
                                                         (!milstr_cmp(cfgstr, "101"))) {  
                                                 *(BYTE *)p->value = KEY_KEY101;  
                                         }  
                                         break;  
                         }  
                 }                  }
                 if (p->flag & INIEND) {                  dst[i] = val;
           }
   }
   
   static void iniwrsetargh8(OEMCHAR *work, int size, const PFTBL *ini) {
   
           UINT    i;
   const UINT8     *ptr;
           UINT    arg;
           OEMCHAR tmp[8];
   
           ptr = (UINT8 *)ini->value;
           arg = ini->arg;
           if (arg > 0) {
                   OEMSPRINTF(tmp, OEMTEXT("%.2x"), ptr[0]);
                   milstr_ncpy(work, tmp, size);
           }
           for (i=1; i<arg; i++) {
                   OEMSPRINTF(tmp, OEMTEXT(" %.2x"), ptr[i]);
                   milstr_ncat(work, tmp, size);
           }
   }
   
   
   // ---- user
   
   static void inirdbyte3(const OEMCHAR *src, const PFTBL *ini) {
   
           UINT    i;
   
           for (i=0; i<3; i++) {
                   if (src[i] == '\0') {
                         break;                          break;
                 }                  }
                   if ((((src[i] - '0') & 0xff) < 9) ||
                           (((src[i] - 'A') & 0xdf) < 26)) {
                           ((UINT8 *)ini->value)[i] = (UINT8)src[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;
           }
   }
   
   
   // ----
   
   void ini_read(const OEMCHAR *path, const OEMCHAR *title,
                                                                                           const PFTBL *tbl, UINT count) {
   
   const PFTBL     *p;
   const PFTBL     *pterm;
           OEMCHAR work[512];
           UINT32  val;
   
           p = tbl;
           pterm = tbl + count;
           while(p < pterm) {
                   switch(p->itemtype & PFTYPE_MASK) {
                           case PFTYPE_STR:
                                   GetPrivateProfileString(title, p->item, (OEMCHAR *)p->value,
                                                                                           (OEMCHAR *)p->value, p->arg, path);
                                   break;
   
                           case PFTYPE_BOOL:
                                   GetPrivateProfileString(title, p->item,
                                                                           (*((UINT8 *)p->value))?str_true:str_false,
                                                                                                   work, NELEMENTS(work), path);
                                   *((UINT8 *)p->value) = (!milstr_cmp(work, str_true))?1:0;
                                   break;
   
                           case PFTYPE_BITMAP:
                                   GetPrivateProfileString(title, p->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;
   
                           case PFTYPE_ARGS16:
                                   GetPrivateProfileString(title, p->item, str_null,
                                                                                                   work, NELEMENTS(work), path);
                                   inirdargs16(work, p);
                                   break;
   
                           case PFTYPE_BIN:
                                   GetPrivateProfileString(title, p->item, str_null,
                                                                                                   work, NELEMENTS(work), path);
                                   inirdargh8(work, p);
                                   break;
   
                           case PFTYPE_SINT8:
                           case PFTYPE_UINT8:
                                   val = (UINT8)GetPrivateProfileInt(title, p->item,
                                                                                                   *(UINT8 *)p->value, path);
                                   *(UINT8 *)p->value = (UINT8)val;
                                   break;
   
                           case PFTYPE_SINT16:
                           case PFTYPE_UINT16:
                                   val = (UINT16)GetPrivateProfileInt(title, p->item,
                                                                                                   *(UINT16 *)p->value, path);
                                   *(UINT16 *)p->value = (UINT16)val;
                                   break;
   
                           case PFTYPE_SINT32:
                           case PFTYPE_UINT32:
                                   val = (UINT32)GetPrivateProfileInt(title, p->item,
                                                                                                   *(UINT32 *)p->value, path);
                                   *(UINT32 *)p->value = (UINT32)val;
                                   break;
   
                           case PFTYPE_HEX8:
                                   OEMSPRINTF(work, str_x, *(UINT8 *)p->value),
                                   GetPrivateProfileString(title, p->item, work,
                                                                                                   work, NELEMENTS(work), path);
                                   val = (UINT8)milstr_solveHEX(work);
                                   *(UINT8 *)p->value = (UINT8)val;
                                   break;
   
                           case PFTYPE_HEX16:
                                   OEMSPRINTF(work, str_x, *(UINT16 *)p->value),
                                   GetPrivateProfileString(title, p->item, work,
                                                                                                   work, NELEMENTS(work), path);
                                   val = (UINT16)milstr_solveHEX(work);
                                   *(UINT16 *)p->value = (UINT16)val;
                                   break;
   
                           case PFTYPE_HEX32:
                                   OEMSPRINTF(work, str_x, *(UINT32 *)p->value),
                                   GetPrivateProfileString(title, p->item, work,
                                                                                                   work, NELEMENTS(work), path);
                                   val = (UINT32)milstr_solveHEX(work);
                                   *(UINT32 *)p->value = (UINT32)val;
                                   break;
   
                           case PFTYPE_BYTE3:
                                   GetPrivateProfileString(title, p->item, str_null,
                                                                                                   work, NELEMENTS(work), path);
                                   inirdbyte3(work, p);
                                   break;
   
                           case PFTYPE_KB:
                                   GetPrivateProfileString(title, p->item, str_null,
                                                                                                   work, NELEMENTS(work), path);
                                   inirdkb(work, p);
                                   break;
                   }
                 p++;                  p++;
         }          }
 }  }
   
 void initsave(void) {  void ini_write(const OEMCHAR *path, const OEMCHAR *title,
                                                                                           const PFTBL *tbl, UINT count) {
   
   const PFTBL             *p;
   const PFTBL             *pterm;
   const OEMCHAR   *set;
           OEMCHAR         work[512];
   
           p = tbl;
           pterm = tbl + count;
           while(p < pterm) {
                   if (!(p->itemtype & PFFLAG_RO)) {
                           work[0] = '\0';
                           set = work;
                           switch(p->itemtype & PFTYPE_MASK) {
                                   case PFTYPE_STR:
                                           set = (OEMCHAR *)p->value;
                                           break;
   
                                   case PFTYPE_BOOL:
                                           set = (*((UINT8 *)p->value))?str_true:str_false;
                                           break;
   
         char            initfile[MAX_PATH];                                  case PFTYPE_BIN:
         char            cfgstr[CFGLEN];                                          iniwrsetargh8(work, NELEMENTS(work), p);
         DWORD           i;  
         INI_ITEM        *p;  
   
         getinifile(initfile, MAX_PATH);                                                                 // ver0.29  
         p = iniitem;  
         while(!(p->flag & INIEND)) {  
                 if (p->flag & INI_RO) {  
                 }  
                 else if (!(p->itemtype & INI_EX)) {  
                         switch(p->itemtype) {  
                                 case INI_STR:  
                                         WritePrivateProfileString(ini_title, p->item,  
                                                                                                 (char *)p->value, initfile);  
                                         break;  
                                 case INI_BOOL:  
                                         WritePrivateProfileString(ini_title, p->item,  
                                                                 makeBOOL(*((BYTE *)p->value) & 1), initfile);  
                                         break;  
                                 case INI_ARG:  
                                         for (i=0; i<p->arg; i++) {  
                                                 wsprintf(&cfgstr[i*3], "%02x ",  
                                                                                                         ((BYTE *)p->value)[i]);  
                                         }  
                                         cfgstr[i*3-1] = '\0';  
                                         WritePrivateProfileString(ini_title, p->item,  
                                                                                                                         cfgstr, initfile);  
                                         break;  
                                 case INI_BYTE:  
                                         wsprintf(cfgstr, "%u", *(BYTE *)p->value);  
                                         WritePrivateProfileString(ini_title, p->item,  
                                                                                                                 cfgstr, initfile);  
                                         break;  
                                 case INI_WORD:  
                                         wsprintf(cfgstr, "%u", *(WORD *)p->value);  
                                         WritePrivateProfileString(ini_title, p->item,  
                                                                                                                 cfgstr, initfile);  
                                         break;  
                                 case INI_DWORD:  
                                         wsprintf(cfgstr, "%u", *(DWORD *)p->value);  
                                         WritePrivateProfileString(ini_title, p->item,  
                                                                                                                 cfgstr, initfile);  
                                         break;  
                                 case INI_HEXB:  
                                         wsprintf(cfgstr, "%x", *(BYTE *)p->value);  
                                         WritePrivateProfileString(ini_title, p->item,  
                                                                                                                 cfgstr, initfile);  
                                         break;  
                                 case INI_HEXD:  
                                         wsprintf(cfgstr, "%x", *(DWORD *)p->value);  
                                         WritePrivateProfileString(ini_title, p->item,  
                                                                                                                 cfgstr, initfile);  
                                         break;                                          break;
   
                                   case PFTYPE_SINT8:
                                           OEMSPRINTF(work, str_d, *((SINT8 *)p->value));
                                           break;
   
                                   case PFTYPE_SINT16:
                                           OEMSPRINTF(work, str_d, *((SINT16 *)p->value));
                                           break;
   
                                   case PFTYPE_SINT32:
                                           OEMSPRINTF(work, str_d, *((SINT32 *)p->value));
                                           break;
   
                                   case PFTYPE_UINT8:
                                           OEMSPRINTF(work, str_u, *((UINT8 *)p->value));
                                           break;
   
                                   case PFTYPE_UINT16:
                                           OEMSPRINTF(work, str_u, *((UINT16 *)p->value));
                                           break;
   
                                   case PFTYPE_UINT32:
                                           OEMSPRINTF(work, str_u, *((UINT32 *)p->value));
                                           break;
   
                                   case PFTYPE_HEX8:
                                           OEMSPRINTF(work, str_x, *((UINT8 *)p->value));
                                           break;
   
                                   case PFTYPE_HEX16:
                                           OEMSPRINTF(work, str_x, *((UINT16 *)p->value));
                                           break;
   
                                   case PFTYPE_HEX32:
                                           OEMSPRINTF(work, str_x, *((UINT32 *)p->value));
                                           break;
   
                                   default:
                                           set = NULL;
                                           break;
                           }
                           if (set) {
                                   WritePrivateProfileString(title, p->item, set, path);
                         }                          }
                 }                  }
                 else {                  p++;
                         switch(p->itemtype) {          }
                                 case INI_EX|1:                          // remove hdd  }
                                         wsprintf(cfgstr, "%u", (*(BYTE *)p->value) + 1);  
                                         WritePrivateProfileString(ini_title, p->item,  
                                                                                                                 cfgstr, initfile);  // ----
                                         break;  
 #if 0  #if !defined(SUPPORT_PC9821)
                                 case INI_EX|2:                          // midi module  static const OEMCHAR ini_title[] = OEMTEXT("NekoProjectII");
                                         WritePrivateProfileString(ini_title, p->item,  #else
                                                                 MIDI_num2module(*(BYTE *)p->value), initfile);  static const OEMCHAR ini_title[] = OEMTEXT("NekoProject21");
                                         break;  
 #endif  #endif
                         }  
   enum {
           PFRO_STR                = PFFLAG_RO + PFTYPE_STR,
           PFRO_BOOL               = PFFLAG_RO + PFTYPE_BOOL,
           PFRO_BITMAP             = PFFLAG_RO + PFTYPE_BITMAP,
           PFRO_UINT8              = PFFLAG_RO + PFTYPE_UINT8,
           PFRO_SINT32             = PFFLAG_RO + PFTYPE_SINT32,
           PFRO_HEX32              = PFFLAG_RO + PFTYPE_HEX32,
           PFRO_BYTE3              = PFFLAG_RO + PFTYPE_BYTE3,
           PFRO_KB                 = PFFLAG_RO + PFTYPE_KB
   };
   
   static const PFTBL iniitem[] = {
           PFSTR("np2title", PFRO_STR,                     np2oscfg.titles),
           PFVAL("np2winid", PFRO_BYTE3,           np2oscfg.winid),
           PFVAL("WindposX", PFTYPE_SINT32,        &np2oscfg.winx),
           PFVAL("WindposY", PFTYPE_SINT32,        &np2oscfg.winy),
           PFMAX("paddingx", PFRO_SINT32,          &np2oscfg.paddingx,             32),
           PFMAX("paddingy", PFRO_SINT32,          &np2oscfg.paddingy,             32),
           PFVAL("Win_Snap", PFTYPE_BOOL,          &np2oscfg.WINSNAP),
   
           PFSTR("FDfolder", PFTYPE_STR,           fddfolder),
           PFSTR("HDfolder", PFTYPE_STR,           hddfolder),
           PFSTR("bmap_Dir", PFTYPE_STR,           bmpfilefolder),
           PFSTR("fontfile", PFTYPE_STR,           np2cfg.fontfile),
           PFSTR("biospath", PFRO_STR,                     np2cfg.biospath),
   
   #if defined(SUPPORT_HOSTDRV)
           PFSTR("hdrvroot", PFRO_STR,                     np2cfg.hdrvroot),
           PFVAL("hdrv_acc", PFRO_UINT8,           &np2cfg.hdrvacc),
   #endif
   
           PFSTR("pc_model", PFTYPE_STR,           &np2cfg.model),
           PFVAL("clk_base", PFTYPE_UINT32,        &np2cfg.baseclock),
           PFVAL("clk_mult", PFTYPE_UINT32,        &np2cfg.multiple),
   
           PFEXT("DIPswtch", PFTYPE_BIN,           np2cfg.dipsw,                   3),
           PFEXT("MEMswtch", PFTYPE_BIN,           np2cfg.memsw,                   8),
           PFMAX("ExMemory", PFTYPE_UINT8,         &np2cfg.EXTMEM,                 63),
           PFVAL("ITF_WORK", PFRO_BOOL,            &np2cfg.ITF_WORK),
   
           PFSTR("HDD1FILE", PFTYPE_STR,           np2cfg.sasihdd[0]),
           PFSTR("HDD2FILE", PFTYPE_STR,           np2cfg.sasihdd[1]),
   #if defined(SUPPORT_SCSI)
           PFSTR("SCSIHDD0", PFTYPE_STR,           np2cfg.scsihdd[0]),
           PFSTR("SCSIHDD1", PFTYPE_STR,           np2cfg.scsihdd[1]),
           PFSTR("SCSIHDD2", PFTYPE_STR,           np2cfg.scsihdd[2]),
           PFSTR("SCSIHDD3", PFTYPE_STR,           np2cfg.scsihdd[3]),
   #endif
   
           PFVAL("SampleHz", PFTYPE_UINT16,        &np2cfg.samplingrate),
           PFVAL("Latencys", PFTYPE_UINT16,        &np2cfg.delayms),
           PFVAL("SNDboard", PFTYPE_HEX8,          &np2cfg.SOUND_SW),
           PFAND("BEEP_vol", PFTYPE_UINT8,         &np2cfg.BEEP_VOL,               3),
           PFVAL("xspeaker", PFRO_BOOL,            &np2cfg.snd_x),
   
           PFEXT("SND14vol", PFTYPE_BIN,           np2cfg.vol14,                   6),
   //      PFEXT("opt14BRD", PFTYPE_BIN,           np2cfg.snd14opt,                3),
           PFVAL("opt26BRD", PFTYPE_HEX8,          &np2cfg.snd26opt),
           PFVAL("opt86BRD", PFTYPE_HEX8,          &np2cfg.snd86opt),
           PFVAL("optSPBRD", PFTYPE_HEX8,          &np2cfg.spbopt),
           PFVAL("optSPBVR", PFTYPE_HEX8,          &np2cfg.spb_vrc),
           PFMAX("optSPBVL", PFTYPE_UINT8,         &np2cfg.spb_vrl,                24),
           PFVAL("optSPB_X", PFTYPE_BOOL,          &np2cfg.spb_x),
           PFVAL("optMPU98", PFTYPE_HEX8,          &np2cfg.mpuopt),
   
           PFMAX("volume_F", PFTYPE_UINT8,         &np2cfg.vol_fm,                 128),
           PFMAX("volume_S", PFTYPE_UINT8,         &np2cfg.vol_ssg,                128),
           PFMAX("volume_A", PFTYPE_UINT8,         &np2cfg.vol_adpcm,              128),
           PFMAX("volume_P", PFTYPE_UINT8,         &np2cfg.vol_pcm,                128),
           PFMAX("volume_R", PFTYPE_UINT8,         &np2cfg.vol_rhythm,             128),
   
           PFVAL("Seek_Snd", PFTYPE_BOOL,          &np2cfg.MOTOR),
           PFMAX("Seek_Vol", PFTYPE_UINT8,         &np2cfg.MOTORVOL,               100),
   
           PFVAL("btnRAPID", PFTYPE_BOOL,          &np2cfg.BTN_RAPID),
           PFVAL("btn_MODE", PFTYPE_BOOL,          &np2cfg.BTN_MODE),
           PFVAL("Mouse_sw", PFTYPE_BOOL,          &np2oscfg.MOUSE_SW),
           PFVAL("MS_RAPID", PFTYPE_BOOL,          &np2cfg.MOUSERAPID),
   
           PFAND("backgrnd", PFTYPE_UINT8,         &np2oscfg.background,   3),
           PFEXT("VRAMwait", PFTYPE_BIN,           np2cfg.wait,                    6),
           PFAND("DspClock", PFTYPE_UINT8,         &np2oscfg.DISPCLK,              3),
           PFVAL("DispSync", PFTYPE_BOOL,          &np2cfg.DISPSYNC),
           PFVAL("Real_Pal", PFTYPE_BOOL,          &np2cfg.RASTER),
           PFMAX("RPal_tim", PFTYPE_UINT8,         &np2cfg.realpal,                64),
           PFVAL("s_NOWAIT", PFTYPE_BOOL,          &np2oscfg.NOWAIT),
           PFVAL("SkpFrame", PFTYPE_UINT8,         &np2oscfg.DRAW_SKIP),
           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),
           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°Í¸¡©
           PFVAL("keyboard", PFRO_KB,                      &np2oscfg.KEYBOARD),
           PFVAL("F12_COPY", PFTYPE_UINT8,         &np2oscfg.F12COPY),
           PFVAL("Joystick", PFTYPE_BOOL,          &np2oscfg.JOYPAD1),
           PFEXT("Joy1_btn", PFTYPE_BIN,           np2oscfg.JOY1BTN,               4),
   
           PFVAL("clocknow", PFTYPE_UINT8,         &np2oscfg.clk_x),
           PFVAL("clockfnt", PFTYPE_UINT8,         &np2oscfg.clk_fnt),
           PFAND("clock_up", PFRO_HEX32,           &np2oscfg.clk_color1,   0xffffff),
           PFAND("clock_dn", PFRO_HEX32,           &np2oscfg.clk_color2,   0xffffff),
   
           PFVAL("use_sstp", PFTYPE_BOOL,          &np2oscfg.sstp),
           PFVAL("sstpport", PFTYPE_UINT16,        &np2oscfg.sstpport),
           PFVAL("comfirm_", PFTYPE_BOOL,          &np2oscfg.comfirm),
           PFVAL("shortcut", PFTYPE_HEX8,          &np2oscfg.shortcut),
   
           PFSTR("mpu98map", PFTYPE_STR,           np2oscfg.mpu.mout),
           PFSTR("mpu98min", PFTYPE_STR,           np2oscfg.mpu.min),
           PFSTR("mpu98mdl", PFTYPE_STR,           np2oscfg.mpu.mdl),
           PFSTR("mpu98def", PFTYPE_STR,           np2oscfg.mpu.def),
   
           PFMAX("com1port", PFTYPE_UINT8,         &np2oscfg.com1.port,    5),
           PFVAL("com1para", PFTYPE_UINT8,         &np2oscfg.com1.param),
           PFVAL("com1_bps", PFTYPE_UINT32,        &np2oscfg.com1.speed),
           PFSTR("com1mmap", PFTYPE_STR,           np2oscfg.com1.mout),
           PFSTR("com1mmdl", PFTYPE_STR,           np2oscfg.com1.mdl),
           PFSTR("com1mdef", PFTYPE_STR,           np2oscfg.com1.def),
   
           PFMAX("com2port", PFTYPE_UINT8,         &np2oscfg.com2.port,    5),
           PFVAL("com2para", PFTYPE_UINT8,         &np2oscfg.com2.param),
           PFVAL("com2_bps", PFTYPE_UINT32,        &np2oscfg.com2.speed),
           PFSTR("com2mmap", PFTYPE_STR,           np2oscfg.com2.mout),
           PFSTR("com2mmdl", PFTYPE_STR,           np2oscfg.com2.mdl),
           PFSTR("com2mdef", PFTYPE_STR,           np2oscfg.com2.def),
   
           PFMAX("com3port", PFTYPE_UINT8,         &np2oscfg.com3.port,    5),
           PFVAL("com3para", PFTYPE_UINT8,         &np2oscfg.com3.param),
           PFVAL("com3_bps", PFTYPE_UINT32,        &np2oscfg.com3.speed),
           PFSTR("com3mmap", PFTYPE_STR,           np2oscfg.com3.mout),
           PFSTR("com3mmdl", PFTYPE_STR,           np2oscfg.com3.mdl),
           PFSTR("com3mdef", PFTYPE_STR,           np2oscfg.com3.def),
   
           PFVAL("force400", PFRO_BOOL,            &np2oscfg.force400),
           PFVAL("e_resume", PFTYPE_BOOL,          &np2oscfg.resume),
           PFVAL("STATSAVE", PFRO_BOOL,            &np2oscfg.statsave),
           PFVAL("nousemmx", PFTYPE_BOOL,          &np2oscfg.disablemmx),
           PFVAL("windtype", PFTYPE_UINT8,         &np2oscfg.wintype),
           PFVAL("toolwind", PFTYPE_BOOL,          &np2oscfg.toolwin),
           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)};
   
   
   void initgetfile(OEMCHAR *path, UINT size) {
   
   const OEMCHAR   *ext;
   
           file_cpyname(path, modulefile, size);
           if (np2arg.ini) {
                   if ((np2arg.ini[0] == '/') || (np2arg.ini[0] == '-')) {
                           file_cutname(path);
                           file_catname(path, file_getname(np2arg.ini + 2), size);
                 }                  }
                 if (p->flag & INIEND) {                  else {
                         break;                          file_cpyname(path, np2arg.ini, size);
                 }                  }
                 p++;                  ext = file_getext(path);
                   if (ext[0] != '\0') {
                           file_catname(path, OEMTEXT(".ini"), size);
                   }
           }
           else {
                   file_cutext(path);
                   file_catname(path, OEMTEXT(".ini"), size);
         }          }
 }  }
   
   void initload(void) {
   
           OEMCHAR path[MAX_PATH];
   
           initgetfile(path, NELEMENTS(path));
           ini_read(path, ini_title, iniitem, NELEMENTS(iniitem));
   }
   
   void initsave(void) {
   
           OEMCHAR path[MAX_PATH];
   
           initgetfile(path, NELEMENTS(path));
           ini_write(path, ini_title, iniitem, NELEMENTS(iniitem));
   }
   
Removed from v.1.2  
changed lines
  Added in v.1.38

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