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

Diff for /np2/common/profile.c between versions 1.3 and 1.13

version 1.3, 2004/02/19 11:32:11 version 1.13, 2005/03/20 06:09:16
Line 1 Line 1
 #include        "compiler.h"  #include        "compiler.h"
   #include        "strres.h"
 #include        "dosio.h"  #include        "dosio.h"
 #include        "textfile.h"  #include        "textfile.h"
 #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 22  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 61  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 81  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 106  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 144  const char *profile_getarg(const char *s Line 145  const char *profile_getarg(const char *s
 }  }
   
   
 // ----  
   // ---- まだテスト
   
 typedef struct {  typedef struct {
         UINT8   num;          UINT            applen;
         char    str[7];          UINT            keylen;
 } KEYNAME;          UINT            pos;
           UINT            size;
           UINT            apphit;
   const OEMCHAR   *data;
           UINT            datasize;
   } PFPOS;
   
 #include        "pf_key.tbl"  #define PFBUFSIZE       (1 << 8)
   
 static const char *getarg(const char *str, char *buf, UINT leng) {  static OEMCHAR *delspace(const OEMCHAR *buf, UINT *len) {
   
         UINT8   c;          UINT    l;
   
         if (leng) {          if ((buf != NULL) && (len != NULL)) {
                 leng--;                  l = *len;
         }                  while((l) && (buf[0] == ' ')) {
         else {                          l--;
                 buf = NULL;                          buf++;
                   }
                   while((l) && (buf[l - 1] == ' ')) {
                           l--;
                   }
                   *len = l;
         }          }
         if (str) {          return((OEMCHAR *)buf);
                 c = (UINT8)*str;  }
                 while(((c - 1) & 0xff) < 0x20) {  
                         str++;  static BRESULT seakey(PFILEH hdl, PFPOS *pfp, const OEMCHAR *app,
                         c = (UINT8)*str;                                                                                                                  const OEMCHAR *key) {
   
           PFPOS   ret;
           UINT    pos;
           UINT    size;
           OEMCHAR *buf;
           UINT    len;
           UINT    cnt;
   
           if ((hdl == NULL) || (app == NULL) || (key == NULL)) {
                   return(FAILURE);
           }
           ZeroMemory(&ret, sizeof(ret));
           ret.applen = OEMSTRLEN(app);
           ret.keylen = OEMSTRLEN(key);
           if ((ret.applen == 0) || (ret.keylen == 0)) {
                   return(FAILURE);
           }
   
           pos = 0;
           size = hdl->size;
           while(size) {
                   buf = hdl->buffer + pos;
                   len = 0;
                   cnt = 0;
                   do {
                           if (buf[len] == '\r') {
                                   if (((len + 1) < size) && (buf[len + 1] == '\n')) {
                                           cnt = 2;
                                   }
                                   else {
                                           cnt = 1;
                                   }
                                   break;
                           }
                           if (buf[len] == '\n') {
                                   cnt = 1;
                                   break;
                           }
                           len++;
                   } while(len < size);
                   cnt += len;
                   buf = delspace(buf, &len);
                   if ((len >= 2) && (buf[0] == '[') && (buf[len - 1] == ']')) {
                           if (ret.apphit) {
                                   break;
                           }
                           buf++;
                           len -= 2;
                           buf = delspace(buf, &len);
                           if ((len == ret.applen) && (!milstr_memcmp(buf, app))) {
                                   ret.apphit = 1;
                           }
                 }                  }
                 if (c == 0) {                  else if ((ret.apphit) && (len > ret.keylen) &&
                         str = NULL;                                  (!milstr_memcmp(buf, key))) {
                           buf += ret.keylen;
                           len -= ret.keylen;
                           buf = delspace(buf, &len);
                           if ((len) && (buf[0] == '=')) {
                                   buf++;
                                   len--;
                                   buf = delspace(buf, &len);
                                   ret.pos = pos;
                                   ret.size = cnt;
                                   ret.data = buf;
                                   ret.datasize = len;
                                   break;
                           }
                 }                  }
                   if (len) {
                           ret.pos = pos + cnt;
                           ret.size = 0;
                   }
                   pos += cnt;
                   size -= cnt;
         }          }
         if (str) {          if (pfp) {
                 c = (UINT8)*str;                  *pfp = ret;
                 while(c > 0x20) {          }
                         if (leng) {          return(SUCCESS);
                                 *buf++ = c;  }
                                 leng--;  
   static BRESULT replace(PFILEH hdl, UINT pos, UINT size1, UINT size2) {
   
           UINT    cnt;
           UINT    newsize;
           OEMCHAR *p;
           OEMCHAR *q;
   
           size1 += pos;
           size2 += pos;
           if (size1 > hdl->size) {
                   return(FAILURE);
           }
           cnt = hdl->size - size1;
           if (size1 < size2) {
                   newsize = hdl->size + size2 - size1;
                   if (newsize > hdl->buffers) {
                           newsize = (newsize & (PFBUFSIZE - 1)) + PFBUFSIZE;
                           p = (OEMCHAR *)_MALLOC(newsize * sizeof(OEMCHAR), "profile");
                           if (p == NULL) {
                                   return(FAILURE);
                         }                          }
                         str++;                          CopyMemory(p, hdl->buffer, hdl->buffers * sizeof(OEMCHAR));
                         c = (UINT8)*str;                          if (hdl->buffer) {
                                   _MFREE(hdl->buffer);
                           }
                           hdl->buffer = p;
                           hdl->buffers = newsize;
                   }
                   hdl->size = newsize;
                   if (cnt) {
                           p = hdl->buffer + size1;
                           q = hdl->buffer + size2;
                           do {
                                   --cnt;
                                   q[cnt] = p[cnt];
                           } while(cnt);
                   }
           }
           else if (size1 > size2) {
                   hdl->size -= (size1 - size2);
                   if (cnt) {
                           p = hdl->buffer + size1;
                           q = hdl->buffer + size2;
                           do {
                                   *q++ = *p++;
                           } while(--cnt);
                 }                  }
         }          }
         if (buf) {          hdl->flag |= PFILEH_MODIFY;
                 buf[0] = '\0';          return(SUCCESS);
   }
   
   static PFILEH registfile(FILEH fh) {
   
           UINT    hdrsize;
           UINT    srcwidth;
           BOOL    xendian;
           UINT    rsize;
           UINT8   hdr[4];
           UINT    size;
           UINT    newsize;
           OEMCHAR *buf;
           PFILEH  ret;
   
           hdrsize = 0;
           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;
           }
           size = file_getsize(fh);
           if (size < hdrsize) {
                   goto rf_err1;
           }
           if (file_seek(fh, (long)hdrsize, FSEEK_SET) != (long)hdrsize) {
                   goto rf_err1;
           }
           size = (size - hdrsize) / srcwidth;
           newsize = (size & (PFBUFSIZE - 1)) + PFBUFSIZE;
           buf = (OEMCHAR *)_MALLOC(newsize * srcwidth, "profile");
           if (buf == NULL) {
                   goto rf_err1;
           }
           rsize = file_read(fh, buf, newsize * srcwidth) / srcwidth;
   
           ret = (PFILEH)_MALLOC(sizeof(_PFILEH), "profile");
           if (ret == NULL) {
                   goto rf_err2;
           }
           ZeroMemory(ret, sizeof(_PFILEH));
           ret->buffer = buf;
           ret->buffers = newsize;
           ret->size = rsize;
           if (hdrsize) {
                   CopyMemory(ret->hdr, hdr, hdrsize);
         }          }
         return(str);          ret->hdrsize = hdrsize;
           return(ret);
   
   rf_err2:
           _MFREE(buf);
   
   rf_err1:
           return(NULL);
   }
   
   static PFILEH registnew(void) {
   
   const UINT8     *hdr;
           UINT    hdrsize;
           PFILEH  ret;
   
   #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);
 }  }
   
 static const KEYNAME *searchkeynum(const char *str) {  PFILEH profile_open(const OEMCHAR *filename, UINT flag) {
   
 const KEYNAME   *n;          PFILEH  ret;
 const KEYNAME   *nterm;          FILEH   fh;
   
         n = keyname;          ret = NULL;
         nterm = keyname + (sizeof(keyname) / sizeof(KEYNAME));          if (filename != NULL) {
         while(n < nterm) {                  fh = file_open_rb(filename);
                 if (!milstr_cmp(str, n->str)) {                  if (fh != FILEH_INVALID) {
                         return(n);                          ret = registfile(fh);
                           file_close(fh);
                   }
                   else if (flag & PFILEH_READONLY) {
                   }
                   else {
                           ret = registnew();
                 }                  }
                 n++;  
         }          }
         return(NULL);          if (ret) {
                   ret->flag = flag;
                   file_cpyname(ret->path, filename, NELEMENTS(ret->path));
           }
           return(ret);
 }  }
   
 static const KEYNAME *searchkeystr(UINT8 num) {  void profile_close(PFILEH hdl) {
   
 const KEYNAME   *n;          FILEH   fh;
 const KEYNAME   *nterm;  
   
         n = keyname;          if (hdl) {
         nterm = keyname + (sizeof(keyname) / sizeof(KEYNAME));                  if (hdl->flag & PFILEH_MODIFY) {
         while(n < nterm) {                          fh = file_create(hdl->path);
                 if (n->num == num) {                          if (fh != FILEH_INVALID) {
                         return(n);                                  file_write(fh, hdl->hdr, hdl->hdrsize);
                                   file_write(fh, hdl->buffer, hdl->size * sizeof(OEMCHAR));
                                   file_close(fh);
                           }
                 }                  }
                 n++;                  _MFREE(hdl);
         }          }
         return(NULL);  
 }  }
   
 UINT profile_setkeys(const char *str, UINT8 *key, UINT keymax) {  BRESULT profile_read(const OEMCHAR *app, const OEMCHAR *key,
                                           const OEMCHAR *def, OEMCHAR *ret, UINT size, PFILEH hdl) {
   
           PFPOS   pfp;
   
           if ((seakey(hdl, &pfp, app, key) != SUCCESS) || (pfp.data == NULL)) {
                   if (def == NULL) {
                           def = str_null;
                   }
                   milstr_ncpy(ret, def, size);
                   return(FAILURE);
           }
           else {
                   size = min(size, pfp.datasize + 1);
                   milstr_ncpy(ret, pfp.data, size);
                   return(SUCCESS);
           }
   }
   
   BRESULT profile_write(const OEMCHAR *app, const OEMCHAR *key,
                                                                                           const OEMCHAR *data, PFILEH hdl) {
   
           PFPOS   pfp;
           UINT    newsize;
           UINT    datalen;
           OEMCHAR *buf;
   
           if ((hdl == NULL) || (hdl->flag & PFILEH_READONLY) ||
                   (data == NULL) || (seakey(hdl, &pfp, app, key) != SUCCESS)) {
                   return(FAILURE);
           }
           if (!pfp.apphit) {
                   newsize = pfp.applen + 2;
   #if defined(OSLINEBREAK_CR) || defined(OSLINEBREAK_CRLF)
                   newsize++;
   #endif
   #if defined(OSLINEBREAK_LF) || defined(OSLINEBREAK_CRLF)
                   newsize++;
   #endif
                   if (replace(hdl, pfp.pos, 0, newsize) != SUCCESS) {
                           return(FAILURE);
                   }
                   buf = hdl->buffer + pfp.pos;
                   *buf++ = '[';
                   CopyMemory(buf, app, pfp.applen);
                   buf += pfp.applen;
                   *buf++ = ']';
   #if defined(OSLINEBREAK_CR) || defined(OSLINEBREAK_CRLF)
                   *buf++ = '\r';
   #endif
   #if defined(OSLINEBREAK_LF) || defined(OSLINEBREAK_CRLF)
                   *buf++ = '\n';
   #endif
                   pfp.pos += newsize;
           }
           datalen = OEMSTRLEN(data);
           newsize = pfp.keylen + 1 + datalen;
   #if defined(OSLINEBREAK_CR) || defined(OSLINEBREAK_CRLF)
           newsize++;
   #endif
   #if defined(OSLINEBREAK_LF) || defined(OSLINEBREAK_CRLF)
           newsize++;
   #endif
           if (replace(hdl, pfp.pos, pfp.size, newsize) != SUCCESS) {
                   return(FAILURE);
           }
           buf = hdl->buffer + pfp.pos;
           CopyMemory(buf, key, pfp.keylen);
           buf += pfp.keylen;
           *buf++ = '=';
           CopyMemory(buf, data, datalen);
           buf += datalen;
   #if defined(OSLINEBREAK_CR) || defined(OSLINEBREAK_CRLF)
           *buf++ = '\r';
   #endif
   #if defined(OSLINEBREAK_LF) || defined(OSLINEBREAK_CRLF)
           *buf++ = '\n';
   #endif
           return(SUCCESS);
   }
   
   
   // ----
   
         UINT            ret;  static void bitmapset(UINT8 *ptr, UINT pos, BOOL set) {
         char            work[7];  
 const KEYNAME   *k;          UINT8   bit;
   
         ret = 0;          ptr += (pos >> 3);
         while(ret < keymax) {          bit = 1 << (pos & 7);
                 str = getarg(str, work, sizeof(work));          if (set) {
                 if (str == NULL) {                  *ptr |= bit;
           }
           else {
                   *ptr &= ~bit;
           }
   }
   
   static BOOL bitmapget(const UINT8 *ptr, UINT pos) {
   
           return((ptr[pos >> 3] >> (pos & 7)) & 1);
   }
   
   static void binset(UINT8 *bin, UINT binlen, const OEMCHAR *src) {
   
           UINT    i;
           UINT8   val;
           BOOL    set;
           OEMCHAR c;
   
           for (i=0; i<binlen; i++) {
                   val = 0;
                   set = FALSE;
                   while(*src == ' ') {
                           src++;
                   }
                   while(1) {
                           c = *src;
                           if ((c == '\0') || (c == ' ')) {
                                   break;
                           }
                           else if ((c >= '0') && (c <= '9')) {
                                   val <<= 4;
                                   val += c - '0';
                                   set = TRUE;
                           }
                           else {
                                   c |= 0x20;
                                   if ((c >= 'a') && (c <= 'f')) {
                                           val <<= 4;
                                           val += c - 'a' + 10;
                                           set = TRUE;
                                   }
                           }
                           src++;
                   }
                   if (set == FALSE) {
                         break;                          break;
                 }                  }
                 k = searchkeynum(work);                  bin[i] = val;
                 if (k) {          }
                         key[ret] = k->num;  }
                         ret++;  
   static void binget(OEMCHAR *work, int size, const UINT8 *bin, UINT binlen) {
   
           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);
           }
   }
   
   void profile_iniread(const OEMCHAR *path, const OEMCHAR *app,
                                                                   const PFTBL *tbl, UINT count, PFREAD cb) {
   
           PFILEH  pfh;
   const PFTBL     *p;
   const PFTBL     *pterm;
           OEMCHAR work[512];
   
           pfh = profile_open(path, 0);
           if (pfh == NULL) {
                   return;
           }
           p = tbl;
           pterm = tbl + count;
           while(p < pterm) {
                   if (profile_read(app, p->item, NULL, work, sizeof(work), pfh)
                                                                                                                                   == SUCCESS) {
                           switch(p->itemtype & PFTYPE_MASK) {
                                   case PFTYPE_STR:
                                           milstr_ncpy(p->value, work, p->arg);
                                           break;
   
                                   case PFTYPE_BOOL:
                                           *((UINT8 *)p->value) = (!milstr_cmp(work, str_true))?1:0;
                                           break;
   
                                   case PFTYPE_BITMAP:
                                           bitmapset((UINT8 *)p->value, p->arg,
                                                                           (!milstr_cmp(work, str_true))?TRUE:FALSE);
                                           break;
   
                                   case PFTYPE_BIN:
                                           binset((UINT8 *)p->value, p->arg, work);
                                           break;
   
                                   case PFTYPE_SINT8:
                                   case PFTYPE_UINT8:
                                           *(UINT8 *)p->value = (UINT32)milstr_solveINT(work);
                                           break;
   
                                   case PFTYPE_SINT16:
                                   case PFTYPE_UINT16:
                                           *(UINT16 *)p->value = (UINT32)milstr_solveINT(work);
                                           break;
   
                                   case PFTYPE_SINT32:
                                   case PFTYPE_UINT32:
                                           *(UINT32 *)p->value = (UINT32)milstr_solveINT(work);
                                           break;
   
                                   case PFTYPE_HEX8:
                                           *(UINT8 *)p->value = (UINT8)milstr_solveHEX(work);
                                           break;
   
                                   case PFTYPE_HEX16:
                                           *(UINT16 *)p->value = (UINT16)milstr_solveHEX(work);
                                           break;
   
                                   case PFTYPE_HEX32:
                                           *(UINT32 *)p->value = (UINT32)milstr_solveHEX(work);
                                           break;
   
                                   default:
                                           if (cb != NULL) {
                                                   (*cb)(p, work);
                                           }
                                           break;
                           }
                 }                  }
                   p++;
         }          }
         return(ret);          profile_close(pfh);
 }  }
   
 void profile_getkeys(char *str, UINT strmax, const UINT8 *key, UINT keys) {  void profile_iniwrite(const OEMCHAR *path, const OEMCHAR *app,
                                                                   const PFTBL *tbl, UINT count, PFWRITE cb) {
   
         UINT            space;          PFILEH          pfh;
         UINT            i;  const PFTBL             *p;
 const KEYNAME   *k;  const PFTBL             *pterm;
         UINT            len;  const OEMCHAR   *set;
           OEMCHAR         work[512];
   
         if ((str == NULL) || (strmax == 0)) {          pfh = profile_open(path, 0);
           if (pfh == NULL) {
                 return;                  return;
         }          }
         strmax--;          p = tbl;
         space = 0;          pterm = tbl + count;
         for (i=0; i<keys; i++) {          while(p < pterm) {
                 k = searchkeystr(key[i]);                  if (!(p->itemtype & PFFLAG_RO)) {
                 if (k) {                          work[0] = '\0';
                         len = strlen(k->str);                          set = work;
                         if ((len + space) > strmax) {                          switch(p->itemtype & PFTYPE_MASK) {
                                 break;                                  case PFTYPE_STR:
                                           set = (OEMCHAR *)p->value;
                                           break;
   
                                   case PFTYPE_BOOL:
                                           set = (*((UINT8 *)p->value))?str_true:str_false;
                                           break;
   
                                   case PFTYPE_BITMAP:
                                           set = (bitmapget((UINT8 *)p->value, p->arg))?
                                                                                                                   str_true:str_false;
                                           break;
   
                                   case PFTYPE_BIN:
                                           binget(work, NELEMENTS(work), (UINT8 *)p->value, p->arg);
                                           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:
                                           if (cb != NULL) {
                                                   set = (*cb)(p, work, NELEMENTS(work));
                                           }
                                           else {
                                                   set = NULL;
                                           }
                                           break;
                         }                          }
                         if (space) {                          if (set) {
                                 *str++ = ' ';                                  profile_write(app, p->item, set, pfh);
                         }                          }
                         CopyMemory(str, k->str, len);  
                         str += len;  
                         space = 1;  
                 }                  }
                   p++;
         }          }
         str[0] = '\0';          profile_close(pfh);
 }  }
   
Removed from v.1.3  
changed lines
  Added in v.1.13

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