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

Diff for /np2/common/profile.c between versions 1.10 and 1.15

version 1.10, 2004/06/12 15:32:52 version 1.15, 2005/03/24 04:40:33
Line 5 Line 5
 #include        "profile.h"  #include        "profile.h"
   
   
 static void strdelspace(char **buf, int *size) {  static void strdelspace(OEMCHAR **buf, int *size) {
   
         char    *p;          OEMCHAR *p;
         int             len;          int             len;
   
         p = *buf;          p = *buf;
Line 23  static void strdelspace(char **buf, int  Line 23  static void strdelspace(char **buf, int 
         *size = len;          *size = len;
 }  }
   
 static char *profana(char *buf, char **data) {  static OEMCHAR *profana(OEMCHAR *buf, OEMCHAR **data) {
   
         int             len;          int             len;
         char    *buf2;          OEMCHAR *buf2;
         int             l;          int             l;
   
         len = strlen(buf);          len = OEMSTRLEN(buf);
         strdelspace(&buf, &len);          strdelspace(&buf, &len);
         if ((len >= 2) && (buf[0] == '[') && (buf[len - 1] == ']')) {          if ((len >= 2) && (buf[0] == '[') && (buf[len - 1] == ']')) {
                 buf++;                  buf++;
Line 62  static char *profana(char *buf, char **d Line 62  static char *profana(char *buf, char **d
         return(NULL);          return(NULL);
 }  }
   
 BOOL profile_enum(const char *filename, void *arg,  BOOL profile_enum(const OEMCHAR *filename, void *arg,
                                                         BOOL (*proc)(void *arg, const char *para,                                                          BOOL (*proc)(void *arg, const OEMCHAR *para,
                                                                         const char *key, const char *data)) {                                                                  const OEMCHAR *key, const OEMCHAR *data)) {
         TEXTFILEH       fh;          TEXTFILEH       fh;
         BOOL            r;          BOOL            r;
         char            buf[0x200];          OEMCHAR         buf[0x200];
         char            para[0x100];          OEMCHAR         para[0x100];
         char            *key;          OEMCHAR         *key;
         char            *data;          OEMCHAR         *data;
   
         r = FALSE;          r = FALSE;
         if (proc == NULL) {          if (proc == NULL) {
Line 82  BOOL profile_enum(const char *filename,  Line 82  BOOL profile_enum(const char *filename, 
         }          }
         para[0] = '\0';          para[0] = '\0';
         while(1) {          while(1) {
                 if (textfile_read(fh, buf, sizeof(buf)) != SUCCESS) {                  if (textfile_read(fh, buf, NELEMENTS(buf)) != SUCCESS) {
                         break;                          break;
                 }                  }
                 key = profana(buf, &data);                  key = profana(buf, &data);
                 if (key) {                  if (key) {
                         if (data == NULL) {                          if (data == NULL) {
                                 milstr_ncpy(para, key, sizeof(para));                                  milstr_ncpy(para, key, NELEMENTS(para));
                         }                          }
                         else {                          else {
                                 r = proc(arg, para, key, data);                                  r = proc(arg, para, key, data);
Line 107  gden_err0: Line 107  gden_err0:
   
 // ----  // ----
   
 const char *profile_getarg(const char *str, char *buf, UINT leng) {  const OEMCHAR *profile_getarg(const OEMCHAR *str, OEMCHAR *buf, UINT leng) {
   
         UINT8   c;          UINT8   c;
   
Line 149  const char *profile_getarg(const char *s Line 149  const char *profile_getarg(const char *s
 // ---- まだテスト  // ---- まだテスト
   
 typedef struct {  typedef struct {
         UINT    applen;          UINT            applen;
         UINT    keylen;          UINT            keylen;
         UINT    pos;          UINT            pos;
         UINT    size;          UINT            size;
         UINT    apphit;          UINT            apphit;
 const char      *data;  const OEMCHAR   *data;
         UINT    datasize;          UINT            datasize;
 } PFPOS;  } PFPOS;
   
 static char *delspace(const char *buf, UINT *len) {  #define PFBUFSIZE       (1 << 8)
   
   static OEMCHAR *delspace(const OEMCHAR *buf, UINT *len) {
   
         UINT    l;          UINT    l;
   
Line 173  static char *delspace(const char *buf, U Line 175  static char *delspace(const char *buf, U
                 }                  }
                 *len = l;                  *len = l;
         }          }
         return((char *)buf);          return((OEMCHAR *)buf);
 }  }
   
 static BOOL seakey(PFILEH hdl, PFPOS *pfp, const char *app, const char *key) {  static BRESULT seakey(PFILEH hdl, PFPOS *pfp, const OEMCHAR *app,
                                                                                                                   const OEMCHAR *key) {
   
         PFPOS   ret;          PFPOS   ret;
         UINT    pos;          UINT    pos;
         UINT    size;          UINT    size;
         char    *buf;          OEMCHAR *buf;
         UINT    len;          UINT    len;
         UINT    cnt;          UINT    cnt;
   
Line 189  static BOOL seakey(PFILEH hdl, PFPOS *pf Line 192  static BOOL seakey(PFILEH hdl, PFPOS *pf
                 return(FAILURE);                  return(FAILURE);
         }          }
         ZeroMemory(&ret, sizeof(ret));          ZeroMemory(&ret, sizeof(ret));
         ret.applen = strlen(app);          ret.applen = OEMSTRLEN(app);
         ret.keylen = strlen(key);          ret.keylen = OEMSTRLEN(key);
         if ((ret.applen == 0) || (ret.keylen == 0)) {          if ((ret.applen == 0) || (ret.keylen == 0)) {
                 return(FAILURE);                  return(FAILURE);
         }          }
Line 259  static BOOL seakey(PFILEH hdl, PFPOS *pf Line 262  static BOOL seakey(PFILEH hdl, PFPOS *pf
         return(SUCCESS);          return(SUCCESS);
 }  }
   
 static BOOL replace(PFILEH hdl, UINT pos, UINT size1, UINT size2) {  static BRESULT replace(PFILEH hdl, UINT pos, UINT size1, UINT size2) {
   
         UINT    cnt;          UINT    cnt;
         UINT    size;          UINT    size;
         char    *p;          UINT    newsize;
         char    *q;          OEMCHAR *p;
           OEMCHAR *q;
   
         size1 += pos;          size1 += pos;
         size2 += pos;          size2 += pos;
Line 273  static BOOL replace(PFILEH hdl, UINT pos Line 277  static BOOL replace(PFILEH hdl, UINT pos
         }          }
         cnt = hdl->size - size1;          cnt = hdl->size - size1;
         if (size1 < size2) {          if (size1 < size2) {
                 size = size2 - size1;                  size = hdl->size + size2 - size1;
                 if ((hdl->size + size) > hdl->buffers) {                  if (size > hdl->buffers) {
                         return(FAILURE);                          newsize = (size & (~(PFBUFSIZE - 1))) + PFBUFSIZE;
                           p = (OEMCHAR *)_MALLOC(newsize * sizeof(OEMCHAR), "profile");
                           if (p == NULL) {
                                   return(FAILURE);
                           }
                           if (hdl->buffer) {
                                   CopyMemory(p, hdl->buffer, hdl->buffers * sizeof(OEMCHAR));
                                   _MFREE(hdl->buffer);
                           }
                           hdl->buffer = p;
                           hdl->buffers = newsize;
                 }                  }
                 hdl->size += size;                  hdl->size = size;
                 if (cnt) {                  if (cnt) {
                         p = hdl->buffer + size1;                          p = hdl->buffer + size1;
                         q = hdl->buffer + size2;                          q = hdl->buffer + size2;
Line 301  static BOOL replace(PFILEH hdl, UINT pos Line 315  static BOOL replace(PFILEH hdl, UINT pos
         return(SUCCESS);          return(SUCCESS);
 }  }
   
 PFILEH profile_open(const char *filename, UINT flag) {  static PFILEH registfile(FILEH fh) {
   
         FILEH   fh;          UINT    hdrsize;
         UINT    filesize;          UINT    srcwidth;
           BOOL    xendian;
           UINT    rsize;
           UINT8   hdr[4];
         UINT    size;          UINT    size;
           UINT    newsize;
           OEMCHAR *buf;
         PFILEH  ret;          PFILEH  ret;
   
         if (filename == NULL) {          hdrsize = 0;
                 goto pfore_err1;          srcwidth = 1;
           xendian = FALSE;
           rsize = file_read(fh, hdr, sizeof(hdr));
           if ((rsize >= 3) &&
                   (hdr[0] == 0xef) && (hdr[1] == 0xbb) && (hdr[2] == 0xbf)) {
                   // UTF-8
                   hdrsize = 3;
           }
           else if ((rsize >= 2) && (hdr[0] == 0xff) && (hdr[1] == 0xfe)) {
                   // UCSLE
                   hdrsize = 2;
                   srcwidth = 2;
   #if defined(BYTESEX_BIG)
                   xendian = TRUE;
   #endif
           }
           else if ((rsize >= 2) && (hdr[0] == 0xfe) && (hdr[1] == 0xff)) {
                   // UCS2BE
                   hdrsize = 2;
                   srcwidth = 2;
   #if defined(BYTESEX_LITTLE)
                   xendian = TRUE;
   #endif
           }
   
           if (srcwidth != sizeof(OEMCHAR)) {
                   goto rf_err1;
         }          }
         fh = file_open(filename);          size = file_getsize(fh);
         filesize = 0;          if (size < hdrsize) {
         if (fh != FILEH_INVALID) {                  goto rf_err1;
                 filesize = file_getsize(fh);  
         }          }
         else if (flag & PFILEH_READONLY) {          if (file_seek(fh, (long)hdrsize, FSEEK_SET) != (long)hdrsize) {
                 goto pfore_err1;                  goto rf_err1;
         }          }
         else {          size = (size - hdrsize) / srcwidth;
                 fh = file_create(filename);          newsize = (size & (~(PFBUFSIZE - 1))) + PFBUFSIZE;
                 if (fh == FILEH_INVALID) {          buf = (OEMCHAR *)_MALLOC(newsize * srcwidth, "profile");
                         goto pfore_err1;          if (buf == NULL) {
                 }                  goto rf_err1;
         }          }
         size = filesize + 0x2000;          rsize = file_read(fh, buf, newsize * srcwidth) / srcwidth;
         ret = (PFILEH)_MALLOC(sizeof(_PFILEH) + size, filename);  
           ret = (PFILEH)_MALLOC(sizeof(_PFILEH), "profile");
         if (ret == NULL) {          if (ret == NULL) {
                 goto pfore_err2;                  goto rf_err2;
         }          }
         if (filesize) {          ZeroMemory(ret, sizeof(_PFILEH));
                 if (file_read(fh, ret + 1, filesize) != filesize) {          ret->buffer = buf;
                         goto pfore_err3;          ret->buffers = newsize;
                 }          ret->size = rsize;
           if (hdrsize) {
                   CopyMemory(ret->hdr, hdr, hdrsize);
         }          }
         file_close(fh);          ret->hdrsize = hdrsize;
         ret->buffer = (char *)(ret + 1);  
         ret->buffers = size;  
         ret->size = filesize;  
         ret->flag = flag;  
         file_cpyname(ret->path, filename, sizeof(ret->path));  
         return(ret);          return(ret);
   
 pfore_err3:  rf_err2:
         _MFREE(ret);          _MFREE(buf);
   
 pfore_err2:  rf_err1:
         file_close(fh);          return(NULL);
   }
   
   static PFILEH registnew(void) {
   
   const UINT8     *hdr;
           UINT    hdrsize;
           PFILEH  ret;
   
 pfore_err1:  #if defined(OSLANG_UTF8)
           hdr = str_utf8;
           hdrsize = sizeof(str_utf8);
   #elif defined(OSLANG_UCS2) 
           hdr = (UINT8 *)str_ucs2;
           hdrsize = sizeof(str_ucs2);
   #else
           hdr = NULL;
           hdrsize = 0;
   #endif
   
           ret = (PFILEH)_MALLOC(sizeof(_PFILEH), "profile");
           if (ret == NULL) {
                   goto rn_err;
           }
           ZeroMemory(ret, sizeof(_PFILEH));
   //      ret->buffer = NULL;
   //      ret->buffers = 0;
   //      ret->size = 0;
           if (hdrsize) {
                   CopyMemory(ret->hdr, hdr, hdrsize);
           }
           ret->hdrsize = hdrsize;
           return(ret);
   
   rn_err:
         return(NULL);          return(NULL);
 }  }
   
   PFILEH profile_open(const OEMCHAR *filename, UINT flag) {
   
           PFILEH  ret;
           FILEH   fh;
   
           ret = NULL;
           if (filename != NULL) {
                   fh = file_open_rb(filename);
                   if (fh != FILEH_INVALID) {
                           ret = registfile(fh);
                           file_close(fh);
                   }
                   else if (flag & PFILEH_READONLY) {
                   }
                   else {
                           ret = registnew();
                   }
           }
           if (ret) {
                   ret->flag = flag;
                   file_cpyname(ret->path, filename, NELEMENTS(ret->path));
           }
           return(ret);
   }
   
 void profile_close(PFILEH hdl) {  void profile_close(PFILEH hdl) {
   
         FILEH   fh;          FILEH   fh;
Line 361  void profile_close(PFILEH hdl) { Line 460  void profile_close(PFILEH hdl) {
                 if (hdl->flag & PFILEH_MODIFY) {                  if (hdl->flag & PFILEH_MODIFY) {
                         fh = file_create(hdl->path);                          fh = file_create(hdl->path);
                         if (fh != FILEH_INVALID) {                          if (fh != FILEH_INVALID) {
                                 file_write(fh, hdl->buffer, hdl->size);                                  file_write(fh, hdl->hdr, hdl->hdrsize);
                                   file_write(fh, hdl->buffer, hdl->size * sizeof(OEMCHAR));
                                 file_close(fh);                                  file_close(fh);
                         }                          }
                 }                  }
Line 369  void profile_close(PFILEH hdl) { Line 469  void profile_close(PFILEH hdl) {
         }          }
 }  }
   
 BOOL profile_read(const char *app, const char *key, const char *def,  BRESULT profile_read(const OEMCHAR *app, const OEMCHAR *key,
                                                                                 char *ret, UINT size, PFILEH hdl) {                                          const OEMCHAR *def, OEMCHAR *ret, UINT size, PFILEH hdl) {
   
         PFPOS   pfp;          PFPOS   pfp;
   
Line 388  BOOL profile_read(const char *app, const Line 488  BOOL profile_read(const char *app, const
         }          }
 }  }
   
 BOOL profile_write(const char *app, const char *key,  BRESULT profile_write(const OEMCHAR *app, const OEMCHAR *key,
                                                                                         const char *data, PFILEH hdl) {                                                                                          const OEMCHAR *data, PFILEH hdl) {
   
         PFPOS   pfp;          PFPOS   pfp;
         UINT    newsize;          UINT    newsize;
         UINT    datalen;          UINT    datalen;
         char    *buf;          OEMCHAR *buf;
   
         if ((hdl == NULL) || (hdl->flag & PFILEH_READONLY) ||          if ((hdl == NULL) || (hdl->flag & PFILEH_READONLY) ||
                 (data == NULL) || (seakey(hdl, &pfp, app, key) != SUCCESS)) {                  (data == NULL) || (seakey(hdl, &pfp, app, key) != SUCCESS)) {
Line 413  BOOL profile_write(const char *app, cons Line 513  BOOL profile_write(const char *app, cons
                 }                  }
                 buf = hdl->buffer + pfp.pos;                  buf = hdl->buffer + pfp.pos;
                 *buf++ = '[';                  *buf++ = '[';
                 CopyMemory(buf, app, pfp.applen);                  CopyMemory(buf, app, pfp.applen * sizeof(OEMCHAR));
                 buf += pfp.applen;                  buf += pfp.applen;
                 *buf++ = ']';                  *buf++ = ']';
 #if defined(OSLINEBREAK_CR) || defined(OSLINEBREAK_CRLF)  #if defined(OSLINEBREAK_CR) || defined(OSLINEBREAK_CRLF)
Line 424  BOOL profile_write(const char *app, cons Line 524  BOOL profile_write(const char *app, cons
 #endif  #endif
                 pfp.pos += newsize;                  pfp.pos += newsize;
         }          }
         datalen = strlen(data);          datalen = OEMSTRLEN(data);
         newsize = pfp.keylen + 1 + datalen;          newsize = pfp.keylen + 1 + datalen;
 #if defined(OSLINEBREAK_CR) || defined(OSLINEBREAK_CRLF)  #if defined(OSLINEBREAK_CR) || defined(OSLINEBREAK_CRLF)
         newsize++;          newsize++;
Line 436  BOOL profile_write(const char *app, cons Line 536  BOOL profile_write(const char *app, cons
                 return(FAILURE);                  return(FAILURE);
         }          }
         buf = hdl->buffer + pfp.pos;          buf = hdl->buffer + pfp.pos;
         CopyMemory(buf, key, pfp.keylen);          CopyMemory(buf, key, pfp.keylen * sizeof(OEMCHAR));
         buf += pfp.keylen;          buf += pfp.keylen;
         *buf++ = '=';          *buf++ = '=';
         CopyMemory(buf, data, datalen);          CopyMemory(buf, data, datalen * sizeof(OEMCHAR));
         buf += datalen;          buf += datalen;
 #if defined(OSLINEBREAK_CR) || defined(OSLINEBREAK_CRLF)  #if defined(OSLINEBREAK_CR) || defined(OSLINEBREAK_CRLF)
         *buf++ = '\r';          *buf++ = '\r';
Line 450  BOOL profile_write(const char *app, cons Line 550  BOOL profile_write(const char *app, cons
         return(SUCCESS);          return(SUCCESS);
 }  }
   
 static void bitmapset(BYTE *ptr, UINT pos, BOOL set) {  
   // ----
   
   static void bitmapset(UINT8 *ptr, UINT pos, BOOL set) {
   
         UINT8   bit;          UINT8   bit;
   
Line 464  static void bitmapset(BYTE *ptr, UINT po Line 567  static void bitmapset(BYTE *ptr, UINT po
         }          }
 }  }
   
 static BOOL bitmapget(const BYTE *ptr, UINT pos) {  static BOOL bitmapget(const UINT8 *ptr, UINT pos) {
   
         return((ptr[pos >> 3] >> (pos & 7)) & 1);          return((ptr[pos >> 3] >> (pos & 7)) & 1);
 }  }
   
 static void binset(BYTE *bin, UINT binlen, const char *src) {  static void binset(UINT8 *bin, UINT binlen, const OEMCHAR *src) {
   
         UINT    i;          UINT    i;
         BYTE    val;          UINT8   val;
         BOOL    set;          BOOL    set;
         char    c;          OEMCHAR c;
   
         for (i=0; i<binlen; i++) {          for (i=0; i<binlen; i++) {
                 val = 0;                  val = 0;
Line 509  static void binset(BYTE *bin, UINT binle Line 612  static void binset(BYTE *bin, UINT binle
         }          }
 }  }
   
 static void binget(char *work, int size, const BYTE *bin, UINT binlen) {  static void binget(OEMCHAR *work, int size, const UINT8 *bin, UINT binlen) {
   
         UINT    i;          UINT    i;
         char    tmp[8];          OEMCHAR tmp[8];
   
         if (binlen) {          if (binlen) {
                 SPRINTF(tmp, "%.2x", bin[0]);                  OEMSPRINTF(tmp, OEMTEXT("%.2x"), bin[0]);
                 milstr_ncpy(work, tmp, size);                  milstr_ncpy(work, tmp, size);
         }          }
         for (i=1; i<binlen; i++) {          for (i=1; i<binlen; i++) {
                 SPRINTF(tmp, " %.2x", bin[i]);                  OEMSPRINTF(tmp, OEMTEXT(" %.2x"), bin[i]);
                 milstr_ncat(work, tmp, size);                  milstr_ncat(work, tmp, size);
         }          }
 }  }
   
 void profile_iniread(const char *path, const char *app,  void profile_iniread(const OEMCHAR *path, const OEMCHAR *app,
                                                                 const PFTBL *tbl, UINT count, PFREAD cb) {                                                                  const PFTBL *tbl, UINT count, PFREAD cb) {
   
         PFILEH  pfh;          PFILEH  pfh;
 const PFTBL     *p;  const PFTBL     *p;
 const PFTBL     *pterm;  const PFTBL     *pterm;
         char    work[512];          OEMCHAR work[512];
   
         pfh = profile_open(path, 0);          pfh = profile_open(path, 0);
         if (pfh == NULL) {          if (pfh == NULL) {
Line 541  const PFTBL *pterm; Line 644  const PFTBL *pterm;
         while(p < pterm) {          while(p < pterm) {
                 if (profile_read(app, p->item, NULL, work, sizeof(work), pfh)                  if (profile_read(app, p->item, NULL, work, sizeof(work), pfh)
                                                                                                                                 == SUCCESS) {                                                                                                                                  == SUCCESS) {
                         switch(p->itemtype & PFITYPE_MASK) {                          switch(p->itemtype & PFTYPE_MASK) {
                                 case PFTYPE_STR:                                  case PFTYPE_STR:
                                         milstr_ncpy(p->value, work, p->arg);                                          milstr_ncpy((OEMCHAR *)p->value, work, p->arg);
                                         break;                                          break;
   
                                 case PFTYPE_BOOL:                                  case PFTYPE_BOOL:
Line 551  const PFTBL *pterm; Line 654  const PFTBL *pterm;
                                         break;                                          break;
   
                                 case PFTYPE_BITMAP:                                  case PFTYPE_BITMAP:
                                         bitmapset((BYTE *)p->value, p->arg,                                          bitmapset((UINT8 *)p->value, p->arg,
                                                                         (!milstr_cmp(work, str_true))?TRUE:FALSE);                                                                          (!milstr_cmp(work, str_true))?TRUE:FALSE);
                                         break;                                          break;
   
                                 case PFTYPE_BIN:                                  case PFTYPE_BIN:
                                         binset((BYTE *)p->value, p->arg, work);                                          binset((UINT8 *)p->value, p->arg, work);
                                         break;                                          break;
   
                                 case PFTYPE_SINT8:                                  case PFTYPE_SINT8:
Line 598  const PFTBL *pterm; Line 701  const PFTBL *pterm;
         profile_close(pfh);          profile_close(pfh);
 }  }
   
 void profile_iniwrite(const char *path, const char *app,  void profile_iniwrite(const OEMCHAR *path, const OEMCHAR *app,
                                                                 const PFTBL *tbl, UINT count, PFWRITE cb) {                                                                  const PFTBL *tbl, UINT count, PFWRITE cb) {
   
         PFILEH  pfh;          PFILEH          pfh;
 const PFTBL     *p;  const PFTBL             *p;
 const PFTBL     *pterm;  const PFTBL             *pterm;
 const char      *set;  const OEMCHAR   *set;
         char    work[512];          OEMCHAR         work[512];
   
         pfh = profile_open(path, 0);          pfh = profile_open(path, 0);
         if (pfh == NULL) {          if (pfh == NULL) {
Line 617  const char *set; Line 720  const char *set;
                 if (!(p->itemtype & PFFLAG_RO)) {                  if (!(p->itemtype & PFFLAG_RO)) {
                         work[0] = '\0';                          work[0] = '\0';
                         set = work;                          set = work;
                         switch(p->itemtype & PFITYPE_MASK) {                          switch(p->itemtype & PFTYPE_MASK) {
                                 case PFTYPE_STR:                                  case PFTYPE_STR:
                                         set = (char *)p->value;                                          set = (OEMCHAR *)p->value;
                                         break;                                          break;
   
                                 case PFTYPE_BOOL:                                  case PFTYPE_BOOL:
Line 627  const char *set; Line 730  const char *set;
                                         break;                                          break;
   
                                 case PFTYPE_BITMAP:                                  case PFTYPE_BITMAP:
                                         set = (bitmapget((BYTE *)p->value, p->arg))?                                          set = (bitmapget((UINT8 *)p->value, p->arg))?
                                                                                                                 str_true:str_false;                                                                                                                  str_true:str_false;
                                         break;                                          break;
   
                                 case PFTYPE_BIN:                                  case PFTYPE_BIN:
                                         binget(work, sizeof(work), (BYTE *)p->value, p->arg);                                          binget(work, NELEMENTS(work), (UINT8 *)p->value, p->arg);
                                         break;                                          break;
   
                                 case PFTYPE_SINT8:                                  case PFTYPE_SINT8:
                                         SPRINTF(work, str_d, *((SINT8 *)p->value));                                          OEMSPRINTF(work, str_d, *((SINT8 *)p->value));
                                         break;                                          break;
   
                                 case PFTYPE_SINT16:                                  case PFTYPE_SINT16:
                                         SPRINTF(work, str_d, *((SINT16 *)p->value));                                          OEMSPRINTF(work, str_d, *((SINT16 *)p->value));
                                         break;                                          break;
   
                                 case PFTYPE_SINT32:                                  case PFTYPE_SINT32:
                                         SPRINTF(work, str_d, *((SINT32 *)p->value));                                          OEMSPRINTF(work, str_d, *((SINT32 *)p->value));
                                         break;                                          break;
   
                                 case PFTYPE_UINT8:                                  case PFTYPE_UINT8:
                                         SPRINTF(work, str_u, *((UINT8 *)p->value));                                          OEMSPRINTF(work, str_u, *((UINT8 *)p->value));
                                         break;                                          break;
   
                                 case PFTYPE_UINT16:                                  case PFTYPE_UINT16:
                                         SPRINTF(work, str_u, *((UINT16 *)p->value));                                          OEMSPRINTF(work, str_u, *((UINT16 *)p->value));
                                         break;                                          break;
   
                                 case PFTYPE_UINT32:                                  case PFTYPE_UINT32:
                                         SPRINTF(work, str_u, *((UINT32 *)p->value));                                          OEMSPRINTF(work, str_u, *((UINT32 *)p->value));
                                         break;                                          break;
   
                                 case PFTYPE_HEX8:                                  case PFTYPE_HEX8:
                                         SPRINTF(work, str_x, *((UINT8 *)p->value));                                          OEMSPRINTF(work, str_x, *((UINT8 *)p->value));
                                         break;                                          break;
   
                                 case PFTYPE_HEX16:                                  case PFTYPE_HEX16:
                                         SPRINTF(work, str_x, *((UINT16 *)p->value));                                          OEMSPRINTF(work, str_x, *((UINT16 *)p->value));
                                         break;                                          break;
   
                                 case PFTYPE_HEX32:                                  case PFTYPE_HEX32:
                                         SPRINTF(work, str_x, *((UINT32 *)p->value));                                          OEMSPRINTF(work, str_x, *((UINT32 *)p->value));
                                         break;                                          break;
   
                                 default:                                  default:
                                         if (cb != NULL) {                                          if (cb != NULL) {
                                                 set = (*cb)(p, work, sizeof(work));                                                  set = (*cb)(p, work, NELEMENTS(work));
                                         }                                          }
                                         else {                                          else {
                                                 set = NULL;                                                  set = NULL;
Removed from v.1.10  
changed lines
  Added in v.1.15

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