[BACK]Return to parse.c CVS log [TXT] [DIR] Up to [ELWIX - Embedded LightWeight unIX -] / libaitcfg / src

Diff for /libaitcfg/src/parse.c between versions 1.10 and 1.11

version 1.10, 2012/08/06 14:53:34 version 1.11, 2012/09/19 15:22:32
Line 47  SUCH DAMAGE. Line 47  SUCH DAMAGE.
 #include "aitcfg.h"  #include "aitcfg.h"
   
   
 static inline int  
 cfg_Write(FILE *f, char *fmt, ...)  
 {  
         int ret = 0;  
         va_list lst;  
   
         va_start(lst, fmt);  
         ret = vfprintf(f, fmt, lst);  
         va_end(lst);  
   
         return ret;  
 }  
   
 static inline void  static inline void
 _invertQueue(cfg_root_t * __restrict cfg)  _invertQueue(cfg_root_t * __restrict cfg)
 {  {
Line 88  cfgReadConfig(FILE *f, cfg_root_t * __restrict cfg) Line 75  cfgReadConfig(FILE *f, cfg_root_t * __restrict cfg)
         int flg = 0;          int flg = 0;
         char *psAttr, *psVal, szSection[STRSIZ] = { 0 };          char *psAttr, *psVal, szSection[STRSIZ] = { 0 };
   
           if (!f || !cfg) {
                   cfg_SetErr(EINVAL, "Invalid parameter(s)");
                   return -1;
           }
   
         while (!feof(f)) {          while (!feof(f)) {
                 memset(line, 0, sizeof line);                  memset(line, 0, sizeof line);
                 fgets(line, sizeof line - 1, f);                  fgets(line, sizeof line - 1, f);
Line 124  cfgReadConfig(FILE *f, cfg_root_t * __restrict cfg) Line 116  cfgReadConfig(FILE *f, cfg_root_t * __restrict cfg)
                 /* *NEW PAIR* alloc new pair element */                  /* *NEW PAIR* alloc new pair element */
                 av = io_malloc(sizeof(struct tagCfg));                  av = io_malloc(sizeof(struct tagCfg));
                 if (!av) {                  if (!av) {
                        LOGERR;                        cfg_SetErr(io_GetErrno(), "%s", io_GetError());
                         return -1;                          return -1;
                 } else {                  } else {
                         memset(av, 0, sizeof(struct tagCfg));                          memset(av, 0, sizeof(struct tagCfg));
Line 172  cfgReadConfig(FILE *f, cfg_root_t * __restrict cfg) Line 164  cfgReadConfig(FILE *f, cfg_root_t * __restrict cfg)
                 if (*szSection) {                  if (*szSection) {
                         AIT_SET_STR(&av->cfg_sec, szSection);                          AIT_SET_STR(&av->cfg_sec, szSection);
                         AIT_KEY(&av->cfg_sec) = crcFletcher16(AIT_GET_LIKE(&av->cfg_sec, u_short*),                           AIT_KEY(&av->cfg_sec) = crcFletcher16(AIT_GET_LIKE(&av->cfg_sec, u_short*), 
                                        io_align(AIT_LEN(&av->cfg_sec) - 1, 1) / 2);                                        io_align(AIT_LEN(&av->cfg_sec) - 1, 2) / 2);
                 }                  }
   
                 io_RTrimStr(psAttr);                  io_RTrimStr(psAttr);
Line 182  cfgReadConfig(FILE *f, cfg_root_t * __restrict cfg) Line 174  cfgReadConfig(FILE *f, cfg_root_t * __restrict cfg)
                 AIT_SET_STR(&av->cfg_val, psVal);                  AIT_SET_STR(&av->cfg_val, psVal);
                 AIT_SET_STR(&av->cfg_attr, psAttr);                  AIT_SET_STR(&av->cfg_attr, psAttr);
                 AIT_KEY(&av->cfg_attr) = crcFletcher16(AIT_GET_LIKE(&av->cfg_attr, u_short*),                   AIT_KEY(&av->cfg_attr) = crcFletcher16(AIT_GET_LIKE(&av->cfg_attr, u_short*), 
                                io_align(AIT_LEN(&av->cfg_attr) - 1, 1) / 2);                                io_align(AIT_LEN(&av->cfg_attr) - 1, 2) / 2);
   
                 CFG_RC_LOCK(cfg);                  CFG_RC_LOCK(cfg);
                 RB_INSERT(tagRC, cfg, av);                  RB_INSERT(tagRC, cfg, av);
Line 207  cfgWriteConfig(FILE *f, cfg_root_t * __restrict cfg, i Line 199  cfgWriteConfig(FILE *f, cfg_root_t * __restrict cfg, i
         time_t tim;          time_t tim;
         char line[BUFSIZ] = { 0 }, szSection[STRSIZ] = { 0 };          char line[BUFSIZ] = { 0 }, szSection[STRSIZ] = { 0 };
   
           if (!f || !cfg) {
                   cfg_SetErr(EINVAL, "Invalid parameter(s)");
                   return -1;
           }
   
         CFG_RC_LOCK(cfg);          CFG_RC_LOCK(cfg);
         _invertQueue(cfg);          _invertQueue(cfg);
         SLIST_FOREACH(av, cfg, cfg_next) {          SLIST_FOREACH(av, cfg, cfg_next) {
Line 231  cfgWriteConfig(FILE *f, cfg_root_t * __restrict cfg, i Line 228  cfgWriteConfig(FILE *f, cfg_root_t * __restrict cfg, i
   
                 /* build line */                  /* build line */
                 memset(line, 0, sizeof line);                  memset(line, 0, sizeof line);
                if (!AIT_ISEMPTY(&av->cfg_attr) && AIT_TYPE(&av->cfg_attr) == string &&                 if (!AIT_ISEMPTY(&av->cfg_attr) && AIT_TYPE(&av->cfg_attr) == string) {
                                AIT_ADDR(&av->cfg_attr)) {                        strlcpy(line, AIT_GET_STRZ(&av->cfg_attr), sizeof line);
                        strlcpy(line, AIT_GET_STR(&av->cfg_attr), sizeof line); 
                         if (whitespace)                          if (whitespace)
                                 strlcat(line, " = ", sizeof line);                                  strlcat(line, " = ", sizeof line);
                         else                          else
                                 strlcat(line, "=", sizeof line);                                  strlcat(line, "=", sizeof line);
                 }                  }
                if (!AIT_ISEMPTY(&av->cfg_val) && AIT_TYPE(&av->cfg_val) == string &&                 if (!AIT_ISEMPTY(&av->cfg_val) && AIT_TYPE(&av->cfg_val) == string)
                                AIT_ADDR(&av->cfg_val))                        strlcat(line, AIT_GET_STRZ(&av->cfg_val), sizeof line);
                        strlcat(line, AIT_GET_STR(&av->cfg_val), sizeof line); 
   
                 /* write */                  /* write */
                 if (!cfg_Write(f, "%s\n", line)) {                  if (!cfg_Write(f, "%s\n", line)) {
                         LOGERR;                          LOGERR;
                           _invertQueue(cfg);
                         CFG_RC_UNLOCK(cfg);                          CFG_RC_UNLOCK(cfg);
                         return -1;                          return -1;
                 }                  }
Line 290  cfgConcatConfig(cfg_root_t * __restrict cfg, cfg_root_ Line 286  cfgConcatConfig(cfg_root_t * __restrict cfg, cfg_root_
                 RB_INSERT(tagRC, cfg, item);                  RB_INSERT(tagRC, cfg, item);
   
         CFG_RC_UNLOCK(cfg);          CFG_RC_UNLOCK(cfg);
         CFG_RC_UNLOCK(add_cfg);  
   
         add_cfg->slh_first = NULL;          add_cfg->slh_first = NULL;
         add_cfg->rbh_root = NULL;          add_cfg->rbh_root = NULL;
           CFG_RC_UNLOCK(add_cfg);
         pthread_mutex_destroy(&add_cfg->rc_mtx);          pthread_mutex_destroy(&add_cfg->rc_mtx);
         return 0;          return 0;
 }  }
Line 341  cfgMergeConfig(cfg_root_t * __restrict cfg, cfg_root_t Line 337  cfgMergeConfig(cfg_root_t * __restrict cfg, cfg_root_t
         }          }
   
         CFG_RC_UNLOCK(cfg);          CFG_RC_UNLOCK(cfg);
         CFG_RC_UNLOCK(add_cfg);  
   
         add_cfg->slh_first = NULL;          add_cfg->slh_first = NULL;
         add_cfg->rbh_root = NULL;          add_cfg->rbh_root = NULL;
           CFG_RC_UNLOCK(add_cfg);
         pthread_mutex_destroy(&add_cfg->rc_mtx);          pthread_mutex_destroy(&add_cfg->rc_mtx);
         return 0;          return 0;
 }  }
Line 363  cfgReadLines(FILE *f, const char *delim, const char *e Line 359  cfgReadLines(FILE *f, const char *delim, const char *e
 {  {
         char line[BUFSIZ];          char line[BUFSIZ];
         struct tagCfg *d, *av = NULL;          struct tagCfg *d, *av = NULL;
        char *psAttr, *psVal = NULL;        char *p, *psSec, *psAttr, *psVal;
   
           if (!cfg)
                   return -1;
           if (!delim)
                   delim = ATR_LINES_DELIM;
   
         while (!feof(f)) {          while (!feof(f)) {
                   psSec = psAttr = psVal = NULL;
                 memset(line, 0, sizeof line);                  memset(line, 0, sizeof line);
                 fgets(line, sizeof line - 1, f);                  fgets(line, sizeof line - 1, f);
                 /* check for user end-of-file */                  /* check for user end-of-file */
Line 382  cfgReadLines(FILE *f, const char *delim, const char *e Line 384  cfgReadLines(FILE *f, const char *delim, const char *e
                                 continue;                                  continue;
                 }                  }
   
                if (!io_MakeAV2(line, delim, &psAttr, &psVal))                if (!io_MakeAV2(line, delim, &p, &psVal))
                         continue;                          continue;
                 else {                  else {
                           io_RTrimStr(p);
                         io_LTrimStr(psVal);                          io_LTrimStr(psVal);
                         io_RTrimStr(psAttr);  
                 }                  }
                   if (!io_MakeAV2(p, SEC_LINES_DELIM, &psSec, &psAttr))
                           psAttr = p;
   
                 /* *NEW PAIR* alloc new pair element */                  /* *NEW PAIR* alloc new pair element */
                 av = io_malloc(sizeof(struct tagCfg));                  av = io_malloc(sizeof(struct tagCfg));
Line 397  cfgReadLines(FILE *f, const char *delim, const char *e Line 401  cfgReadLines(FILE *f, const char *delim, const char *e
                 } else                  } else
                         memset(av, 0, sizeof(struct tagCfg));                          memset(av, 0, sizeof(struct tagCfg));
   
                   if (psSec) {
                           AIT_SET_STR(&av->cfg_sec, psSec);
                           AIT_KEY(&av->cfg_sec) = crcFletcher16(AIT_GET_LIKE(&av->cfg_sec, u_short*), 
                                           io_align(AIT_LEN(&av->cfg_sec) - 1, 2) / 2);
                   }
                 if (psVal)                  if (psVal)
                         AIT_SET_STR(&av->cfg_val, psVal);                          AIT_SET_STR(&av->cfg_val, psVal);
                 AIT_SET_STR(&av->cfg_attr, psAttr);                  AIT_SET_STR(&av->cfg_attr, psAttr);
                 AIT_KEY(&av->cfg_attr) = crcFletcher16(AIT_GET_LIKE(&av->cfg_attr, u_short*),                   AIT_KEY(&av->cfg_attr) = crcFletcher16(AIT_GET_LIKE(&av->cfg_attr, u_short*), 
                                io_align(AIT_LEN(&av->cfg_attr) - 1, 1) / 2);                                io_align(AIT_LEN(&av->cfg_attr) - 1, 2) / 2);
   
                 CFG_RC_LOCK(cfg);                  CFG_RC_LOCK(cfg);
                 /* find & delete duplicates */                  /* find & delete duplicates */
Line 423  cfgReadLines(FILE *f, const char *delim, const char *e Line 432  cfgReadLines(FILE *f, const char *delim, const char *e
         return 0;          return 0;
 }  }
   
   /*
    * cfgWriteLines() - Write custom lines and export data to variable
    *
    * @f = File resource
    * @delim = Custom delimiter, if =NULL default is '='
    * @eol = End of line string, if =NULL default is "\n"
    * @section = Export only section, if =NULL default is all
    * @cfg = Config root
    * return: =NULL error or !=NULL exported data, must be free after use with io_freeVar()
    */
   ait_val_t *
   cfgWriteLines(FILE *f, const char *delim, const char *eol, const char *section, cfg_root_t * __restrict cfg)
   {
           ait_val_t *v = NULL;
           struct tagCfg *av;
   
           if (!cfg)
                   return NULL;
           if (!delim)
                   delim = ATR_LINES_DELIM;
           if (!eol)
                   eol = EOL_LINES_DELIM;
           if (!(v = io_allocVar())) {
                   cfg_SetErr(io_GetErrno(), "%s", io_GetError());
                   return NULL;
           } else
                   AIT_INIT_VAL2(v, string);
   
           SLIST_FOREACH(av, cfg, cfg_next) {
                   if (AIT_ISEMPTY(&av->cfg_attr))
                           continue;
                   if (section) {
                           if (!AIT_ISEMPTY(&av->cfg_sec) && *section)
                                   continue;
                           if (strcmp(section, AIT_GET_STR(&av->cfg_sec)))
                                   continue;
                   }
   
                   if (!AIT_ISEMPTY(&av->cfg_sec)) {
                           AIT_SET_STRCAT(v, AIT_GET_STR(&av->cfg_sec));
                           AIT_SET_STRCAT(v, SEC_LINES_DELIM);
                   }
                   AIT_SET_STRCAT(v, AIT_GET_STR(&av->cfg_attr));
                   AIT_SET_STRCAT(v, delim);
                   if (!AIT_ISEMPTY(&av->cfg_val))
                           AIT_SET_STRCAT(v, AIT_GET_STR(&av->cfg_val));
                   AIT_SET_STRCAT(v, eol);
           }
   
           if (f)
                   fputs(AIT_GET_STR(v), f);
           return v;
   }
Removed from v.1.10  
changed lines
  Added in v.1.11

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>