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

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

version 1.5, 2004/03/31 11:59:17 version 1.10, 2004/06/12 15:32:52
Line 336  PFILEH profile_open(const char *filename Line 336  PFILEH profile_open(const char *filename
                 }                  }
         }          }
         file_close(fh);          file_close(fh);
         ret->buffer = (BYTE *)(ret + 1);          ret->buffer = (char *)(ret + 1);
         ret->buffers = size;          ret->buffers = size;
         ret->size = filesize;          ret->size = filesize;
         ret->flag = flag;          ret->flag = flag;
Line 401  BOOL profile_write(const char *app, cons Line 401  BOOL profile_write(const char *app, cons
                 return(FAILURE);                  return(FAILURE);
         }          }
         if (!pfp.apphit) {          if (!pfp.apphit) {
                 newsize = pfp.applen + 2 + 2;                  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) {                  if (replace(hdl, pfp.pos, 0, newsize) != SUCCESS) {
                         return(FAILURE);                          return(FAILURE);
                 }                  }
Line 409  BOOL profile_write(const char *app, cons Line 415  BOOL profile_write(const char *app, cons
                 *buf++ = '[';                  *buf++ = '[';
                 CopyMemory(buf, app, pfp.applen);                  CopyMemory(buf, app, pfp.applen);
                 buf += pfp.applen;                  buf += pfp.applen;
                 buf[0] = ']';                  *buf++ = ']';
                 buf[1] = '\r';  #if defined(OSLINEBREAK_CR) || defined(OSLINEBREAK_CRLF)
                 buf[2] = '\n';                  *buf++ = '\r';
   #endif
   #if defined(OSLINEBREAK_LF) || defined(OSLINEBREAK_CRLF)
                   *buf++ = '\n';
   #endif
                 pfp.pos += newsize;                  pfp.pos += newsize;
         }          }
         datalen = strlen(data);          datalen = strlen(data);
         newsize = pfp.keylen + 1 + datalen + 2;          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) {          if (replace(hdl, pfp.pos, pfp.size, newsize) != SUCCESS) {
                 return(FAILURE);                  return(FAILURE);
         }          }
Line 425  BOOL profile_write(const char *app, cons Line 441  BOOL profile_write(const char *app, cons
         *buf++ = '=';          *buf++ = '=';
         CopyMemory(buf, data, datalen);          CopyMemory(buf, data, datalen);
         buf += datalen;          buf += datalen;
         buf[0] = '\r';  #if defined(OSLINEBREAK_CR) || defined(OSLINEBREAK_CRLF)
         buf[1] = '\n';          *buf++ = '\r';
   #endif
   #if defined(OSLINEBREAK_LF) || defined(OSLINEBREAK_CRLF)
           *buf++ = '\n';
   #endif
         return(SUCCESS);          return(SUCCESS);
 }  }
   
   static void bitmapset(BYTE *ptr, UINT pos, BOOL set) {
   
 // ----          UINT8   bit;
   
           ptr += (pos >> 3);
           bit = 1 << (pos & 7);
           if (set) {
                   *ptr |= bit;
           }
           else {
                   *ptr &= ~bit;
           }
   }
   
   static BOOL bitmapget(const BYTE *ptr, UINT pos) {
   
           return((ptr[pos >> 3] >> (pos & 7)) & 1);
   }
   
   static void binset(BYTE *bin, UINT binlen, const char *src) {
   
           UINT    i;
           BYTE    val;
           BOOL    set;
           char    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;
                   }
                   bin[i] = val;
           }
   }
   
   static void binget(char *work, int size, const BYTE *bin, UINT binlen) {
   
           UINT    i;
           char    tmp[8];
   
           if (binlen) {
                   SPRINTF(tmp, "%.2x", bin[0]);
                   milstr_ncpy(work, tmp, size);
           }
           for (i=1; i<binlen; i++) {
                   SPRINTF(tmp, " %.2x", bin[i]);
                   milstr_ncat(work, tmp, size);
           }
   }
   
 void profile_iniread(const char *path, const char *app,  void profile_iniread(const char *path, const char *app,
                                                                                         const PFTBL *tbl, UINT count) {                                                                  const PFTBL *tbl, UINT count, PFREAD cb) {
   
         PFILEH  pfh;          PFILEH  pfh;
 const PFTBL     *p;  const PFTBL     *p;
Line 450  const PFTBL *pterm; Line 541  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) {                          switch(p->itemtype & PFITYPE_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((BYTE *)p->value, p->arg,
                                                                           (!milstr_cmp(work, str_true))?TRUE:FALSE);
                                           break;
   
                                   case PFTYPE_BIN:
                                           binset((BYTE *)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_SINT32:
                                 case PFTYPE_UINT32:                                  case PFTYPE_UINT32:
                                 *(UINT32 *)p->value = (UINT32)milstr_solveINT(work);                                          *(UINT32 *)p->value = (UINT32)milstr_solveINT(work);
                                 break;                                          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++;                  p++;
Line 463  const PFTBL *pterm; Line 599  const PFTBL *pterm;
 }  }
   
 void profile_iniwrite(const char *path, const char *app,  void profile_iniwrite(const char *path, const char *app,
                                                                                         const PFTBL *tbl, UINT count) {                                                                  const PFTBL *tbl, UINT count, PFWRITE cb) {
   
         PFILEH  pfh;          PFILEH  pfh;
 const PFTBL     *p;  const PFTBL     *p;
Line 478  const char *set; Line 614  const char *set;
         p = tbl;          p = tbl;
         pterm = tbl + count;          pterm = tbl + count;
         while(p < pterm) {          while(p < pterm) {
                 work[0] = '\0';                  if (!(p->itemtype & PFFLAG_RO)) {
                 set = work;                          work[0] = '\0';
                 switch(p->itemtype) {                          set = work;
                         case PFTYPE_SINT32:                          switch(p->itemtype & PFITYPE_MASK) {
                                 SPRINTF(work, str_d, *((SINT32 *)p->value));                                  case PFTYPE_STR:
                                 break;                                          set = (char *)p->value;
                                           break;
   
                                   case PFTYPE_BOOL:
                                           set = (*((UINT8 *)p->value))?str_true:str_false;
                                           break;
   
                                   case PFTYPE_BITMAP:
                                           set = (bitmapget((BYTE *)p->value, p->arg))?
                                                                                                                   str_true:str_false;
                                           break;
   
                                   case PFTYPE_BIN:
                                           binget(work, sizeof(work), (BYTE *)p->value, p->arg);
                                           break;
   
                                   case PFTYPE_SINT8:
                                           SPRINTF(work, str_d, *((SINT8 *)p->value));
                                           break;
   
                                   case PFTYPE_SINT16:
                                           SPRINTF(work, str_d, *((SINT16 *)p->value));
                                           break;
   
                         default:                                  case PFTYPE_SINT32:
                                 set = NULL;                                          SPRINTF(work, str_d, *((SINT32 *)p->value));
                                 break;                                          break;
                 }  
                 if (set) {                                  case PFTYPE_UINT8:
                         profile_write(app, p->item, set, pfh);                                          SPRINTF(work, str_u, *((UINT8 *)p->value));
                                           break;
   
                                   case PFTYPE_UINT16:
                                           SPRINTF(work, str_u, *((UINT16 *)p->value));
                                           break;
   
                                   case PFTYPE_UINT32:
                                           SPRINTF(work, str_u, *((UINT32 *)p->value));
                                           break;
   
                                   case PFTYPE_HEX8:
                                           SPRINTF(work, str_x, *((UINT8 *)p->value));
                                           break;
   
                                   case PFTYPE_HEX16:
                                           SPRINTF(work, str_x, *((UINT16 *)p->value));
                                           break;
   
                                   case PFTYPE_HEX32:
                                           SPRINTF(work, str_x, *((UINT32 *)p->value));
                                           break;
   
                                   default:
                                           if (cb != NULL) {
                                                   set = (*cb)(p, work, sizeof(work));
                                           }
                                           else {
                                                   set = NULL;
                                           }
                                           break;
                           }
                           if (set) {
                                   profile_write(app, p->item, set, pfh);
                           }
                 }                  }
                 p++;                  p++;
         }          }
Removed from v.1.5  
changed lines
  Added in v.1.10

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