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

Diff for /xmil/common/profile.c between versions 1.1 and 1.3

version 1.1, 2004/08/01 05:31:29 version 1.3, 2004/08/20 08:41:38
Line 1 Line 1
 #include        "compiler.h"  #include        "compiler.h"
 #include        "strres.h"  #include        "strres.h"
 #include        "dosio.h"  #include        "dosio.h"
 #include        "textfile.h"  
 #include        "profile.h"  #include        "profile.h"
   #if defined(OSLANG_UCS2)
   #include        "ucscnv.h"
   #endif
   
   
 static void strdelspace(char **buf, int *size) {  
   
         char    *p;  
         int             len;  
   
         p = *buf;  
         len = *size;  
         while((len > 0) && (p[0] == ' ')) {  
                 p++;  
                 len--;  
         }  
         while((len > 0) && (p[len - 1] == ' ')) {  
                 len--;  
         }  
         *buf = p;  
         *size = len;  
 }  
   
 static char *profana(char *buf, char **data) {  
   
         int             len;  
         char    *buf2;  
         int             l;  
   
         len = strlen(buf);  
         strdelspace(&buf, &len);  
         if ((len >= 2) && (buf[0] == '[') && (buf[len - 1] == ']')) {  
                 buf++;  
                 len -= 2;  
                 strdelspace(&buf, &len);  
                 buf[len] = '\0';  
                 *data = NULL;  
                 return(buf);  
         }  
         for (l=0; l<len; l++) {  
                 if (buf[l] == '=') {  
                         break;  
                 }  
         }  
         if (l < len) {  
                 len -= (l + 1);  
                 buf2 = buf + (l + 1);  
                 strdelspace(&buf, &l);  
                 buf[l] = '\0';  
                 strdelspace(&buf2, &len);  
                 if ((len >= 2) && (buf2[0] == '\"') && (buf2[len - 1] == '\"')) {  
                         buf2++;  
                         len -= 2;  
                         strdelspace(&buf2, &len);  
                 }  
                 buf2[len] = '\0';  
                 *data = buf2;  
                 return(buf);  
         }  
         return(NULL);  
 }  
   
 BOOL profile_enum(const char *filename, void *arg,  
                                                         BOOL (*proc)(void *arg, const char *para,  
                                                                         const char *key, const char *data)) {  
         TEXTFILEH       fh;  
         BOOL            r;  
         char            buf[0x200];  
         char            para[0x100];  
         char            *key;  
         char            *data;  
   
         r = FALSE;  
         if (proc == NULL) {  
                 goto gden_err0;  
         }  
         fh = textfile_open(filename, 0x800);  
         if (fh == NULL) {  
                 goto gden_err0;  
         }  
         para[0] = '\0';  
         while(1) {  
                 if (textfile_read(fh, buf, sizeof(buf)) != SUCCESS) {  
                         break;  
                 }  
                 key = profana(buf, &data);  
                 if (key) {  
                         if (data == NULL) {  
                                 milstr_ncpy(para, key, sizeof(para));  
                         }  
                         else {  
                                 r = proc(arg, para, key, data);  
                                 if (r != SUCCESS) {  
                                         break;  
                                 }  
                         }  
                 }  
         }  
         textfile_close(fh);  
   
 gden_err0:  
         return(r);  
 }  
   
   
 // ----  
   
 const char *profile_getarg(const char *str, char *buf, UINT leng) {  
   
         UINT8   c;  
   
         if (leng) {  
                 leng--;  
         }  
         else {  
                 buf = NULL;  
         }  
         if (str) {  
                 c = (UINT8)*str;  
                 while(((c - 1) & 0xff) < 0x20) {  
                         str++;  
                         c = (UINT8)*str;  
                 }  
                 if (c == 0) {  
                         str = NULL;  
                 }  
         }  
         if (str) {  
                 c = (UINT8)*str;  
                 while(c > 0x20) {  
                         if (leng) {  
                                 *buf++ = c;  
                                 leng--;  
                         }  
                         str++;  
                         c = (UINT8)*str;  
                 }  
         }  
         if (buf) {  
                 buf[0] = '\0';  
         }  
         return(str);  
 }  
   
   
   
 // ---- まだテスト  
   
 typedef struct {  typedef struct {
         UINT    applen;          UINT    applen;
         UINT    keylen;          UINT    keylen;
Line 158  const char *data; Line 17  const char *data;
         UINT    datasize;          UINT    datasize;
 } PFPOS;  } PFPOS;
   
   
   static const UINT8 utf8header[3] = {0xef, 0xbb, 0xbf};
   
   static BRESULT keycmp(const char *str, const char *cmp) {
   
           int             s;
           int             c;
   
           do {
                   c = *cmp++;
                   if (c == 0) {
                           return(SUCCESS);
                   }
                   if ((c >= 'a') && (c <= 'z')) {
                           c -= 0x20;
                   }
                   s = *str++;
                   if ((s >= 'a') && (s <= 'z')) {
                           s -= 0x20;
                   }
           } while(s == c);
           return(FAILURE);
   }
   
 static char *delspace(const char *buf, UINT *len) {  static char *delspace(const char *buf, UINT *len) {
   
         UINT    l;          UINT    l;
Line 176  static char *delspace(const char *buf, U Line 59  static char *delspace(const char *buf, U
         return((char *)buf);          return((char *)buf);
 }  }
   
 static BOOL seakey(PFILEH hdl, PFPOS *pfp, const char *app, const char *key) {  static BRESULT seakey(PFILEH hdl, PFPOS *pfp,
                                                                                   const char *app, const char *key) {
   
         PFPOS   ret;          PFPOS   ret;
         UINT    pos;          UINT    pos;
Line 189  static BOOL seakey(PFILEH hdl, PFPOS *pf Line 73  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 = STRLEN(app);
         ret.keylen = strlen(key);          ret.keylen = STRLEN(key);
         if ((ret.applen == 0) || (ret.keylen == 0)) {          if ((ret.applen == 0) || (ret.keylen == 0)) {
                 return(FAILURE);                  return(FAILURE);
         }          }
Line 226  static BOOL seakey(PFILEH hdl, PFPOS *pf Line 110  static BOOL seakey(PFILEH hdl, PFPOS *pf
                         buf++;                          buf++;
                         len -= 2;                          len -= 2;
                         buf = delspace(buf, &len);                          buf = delspace(buf, &len);
                         if ((len == ret.applen) && (!milstr_memcmp(buf, app))) {                          if ((len == ret.applen) && (keycmp(buf, app) == SUCCESS)) {
                                 ret.apphit = 1;                                  ret.apphit = 1;
                         }                          }
                 }                  }
                 else if ((ret.apphit) && (len > ret.keylen) &&                  else if ((ret.apphit) && (len > ret.keylen) &&
                                 (!milstr_memcmp(buf, key))) {                                  (keycmp(buf, key) == SUCCESS)) {
                         buf += ret.keylen;                          buf += ret.keylen;
                         len -= ret.keylen;                          len -= ret.keylen;
                         buf = delspace(buf, &len);                          buf = delspace(buf, &len);
Line 259  static BOOL seakey(PFILEH hdl, PFPOS *pf Line 143  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;
Line 301  static BOOL replace(PFILEH hdl, UINT pos Line 185  static BOOL replace(PFILEH hdl, UINT pos
         return(SUCCESS);          return(SUCCESS);
 }  }
   
 PFILEH profile_open(const char *filename, UINT flag) {  PFILEH profile_open(const OEMCHAR *filename, UINT flag) {
   
         FILEH   fh;          FILEH   fh;
         UINT    filesize;          UINT    filesize;
         UINT    size;          UINT    size;
         PFILEH  ret;          PFILEH  ret;
           char    *ptr;
   
         if (filename == NULL) {          if (filename == NULL) {
                 goto pfore_err1;                  goto pfore_err1;
Line 320  PFILEH profile_open(const char *filename Line 205  PFILEH profile_open(const char *filename
                 goto pfore_err1;                  goto pfore_err1;
         }          }
         else {          else {
                 fh = file_create(filename);  #if defined(OSLANG_UTF8) || defined(OSLANG_UCS2)
                 if (fh == FILEH_INVALID) {                  flag |= PFILEH_UTF8;
                         goto pfore_err1;  #endif
                 }  
         }          }
         size = filesize + 0x2000;          size = filesize + 0x2000;
         ret = (PFILEH)_MALLOC(sizeof(_PFILEH) + size, filename);          ret = (PFILEH)_MALLOC(sizeof(_PFILEH) + size, filename);
         if (ret == NULL) {          if (ret == NULL) {
                 goto pfore_err2;                  goto pfore_err2;
         }          }
         if (filesize) {          if (fh != FILEH_INVALID) {
                 if (file_read(fh, ret + 1, filesize) != filesize) {                  if (file_read(fh, ret + 1, filesize) != filesize) {
                         goto pfore_err3;                          goto pfore_err3;
                 }                  }
                   file_close(fh);
           }
           ptr = (char *)(ret + 1);
           if ((filesize >= 3) && (!memcmp(ptr, utf8header, 3))) {
                   ptr += 3;
                   size -= 3;
                   filesize -= 3;
                   flag |= PFILEH_UTF8;
         }          }
         file_close(fh);          ret->buffer = ptr;
         ret->buffer = (char *)(ret + 1);  
         ret->buffers = size;          ret->buffers = size;
         ret->size = filesize;          ret->size = filesize;
         ret->flag = flag;          ret->flag = flag;
         file_cpyname(ret->path, filename, sizeof(ret->path));          file_cpyname(ret->path, filename, NELEMENTS(ret->path));
         return(ret);          return(ret);
   
 pfore_err3:  pfore_err3:
         _MFREE(ret);          _MFREE(ret);
   
 pfore_err2:  pfore_err2:
         file_close(fh);          if (fh != FILEH_INVALID) {
                   file_close(fh);
           }
   
 pfore_err1:  pfore_err1:
         return(NULL);          return(NULL);
Line 361  void profile_close(PFILEH hdl) { Line 254  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) {
                                   if (hdl->flag & PFILEH_UTF8) {
                                           file_write(fh, utf8header, 3);
                                   }
                                 file_write(fh, hdl->buffer, hdl->size);                                  file_write(fh, hdl->buffer, hdl->size);
                                 file_close(fh);                                  file_close(fh);
                         }                          }
Line 369  void profile_close(PFILEH hdl) { Line 265  void profile_close(PFILEH hdl) {
         }          }
 }  }
   
 BOOL profile_read(const char *app, const char *key, const char *def,  BRESULT profile_read(const char *app, const char *key, const OEMCHAR *def,
                                                                                 char *ret, UINT size, PFILEH hdl) {                                                                                  OEMCHAR *ret, UINT size, PFILEH hdl) {
   
         PFPOS   pfp;          PFPOS   pfp;
   
Line 382  BOOL profile_read(const char *app, const Line 278  BOOL profile_read(const char *app, const
                 return(FAILURE);                  return(FAILURE);
         }          }
         else {          else {
   #if defined(OSLANG_UCS2)
                   ucscnv_utf8toucs2(ret, size, pfp.data, pfp.datasize);
   #else
                 size = min(size, pfp.datasize + 1);                  size = min(size, pfp.datasize + 1);
                 milstr_ncpy(ret, pfp.data, size);                  milstr_ncpy(ret, pfp.data, size);
   #endif
                 return(SUCCESS);                  return(SUCCESS);
         }          }
 }  }
   
 BOOL profile_write(const char *app, const char *key,  BRESULT profile_write(const char *app, const char *key,
                                                                                         const char *data, PFILEH hdl) {                                                                                          const OEMCHAR *data, PFILEH hdl) {
   
         PFPOS   pfp;          PFPOS   pfp;
         UINT    newsize;          UINT    newsize;
Line 424  BOOL profile_write(const char *app, cons Line 324  BOOL profile_write(const char *app, cons
 #endif  #endif
                 pfp.pos += newsize;                  pfp.pos += newsize;
         }          }
         datalen = strlen(data);  #if defined(OSLANG_UCS2)
           datalen = ucscnv_ucs2toutf8(NULL, (UINT)-1, data, (UINT)-1);
   #else
           datalen = STRLEN(data);
   #endif
         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 439  BOOL profile_write(const char *app, cons Line 343  BOOL profile_write(const char *app, cons
         CopyMemory(buf, key, pfp.keylen);          CopyMemory(buf, key, pfp.keylen);
         buf += pfp.keylen;          buf += pfp.keylen;
         *buf++ = '=';          *buf++ = '=';
   #if defined(OSLANG_UCS2)
           ucscnv_ucs2toutf8(buf, datalen + 1, data, (UINT)-1);
   #else
         CopyMemory(buf, data, datalen);          CopyMemory(buf, data, datalen);
   #endif
         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 358  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, BRESULT set) {
   
         UINT8   bit;          UINT8   bit;
   
Line 464  static void bitmapset(BYTE *ptr, UINT po Line 372  static void bitmapset(BYTE *ptr, UINT po
         }          }
 }  }
   
 static BOOL bitmapget(const BYTE *ptr, UINT pos) {  static BRESULT 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;          BRESULT 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 417  static void binset(BYTE *bin, UINT binle
         }          }
 }  }
   
 static void binget(char *work, int size, const BYTE *bin, UINT binlen) {  static void binget(OEMCHAR *work, UINT 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 char *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 539  const PFTBL *pterm; Line 447  const PFTBL *pterm;
         p = tbl;          p = tbl;
         pterm = tbl + count;          pterm = tbl + count;
         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, NELEMENTS(work), pfh)
                                                                                                                                 == SUCCESS) {                                                                                                                                  == SUCCESS) {
                         switch(p->itemtype & PFITYPE_MASK) {                          switch(p->itemtype & PFITYPE_MASK) {
                                 case PFTYPE_STR:                                  case PFTYPE_STR:
Line 551  const PFTBL *pterm; Line 459  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);                                                                  (BRESULT)((!milstr_cmp(work, str_true))?1:0));
                                         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 506  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 char *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 619  const char *set; Line 527  const char *set;
                         set = work;                          set = work;
                         switch(p->itemtype & PFITYPE_MASK) {                          switch(p->itemtype & PFITYPE_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 535  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:
Removed from v.1.1  
changed lines
  Added in v.1.3

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