Platon Technologies
not logged in Login Registration
EnglishSlovak
open source software development celebrating 10 years of open source development! Friday, October 16, 2026
[BACK] [TXT][DIR] Up to [Platon] / libcfg+ / src / platon / str

Diff for libcfg+/src/platon/str/strdyn.c between version 1.18 and 1.19

version 1.18, 2002/06/23 16:41:03 version 1.19, 2002/08/16 20:31:43
Line 1 
Line 1 
   #ifdef HAVE_CONFIG_H
   #  include "config.h"
   #endif
   
 #include <stdio.h>  #include <stdio.h>
 #include <string.h>  #include <string.h>
 #include <stdlib.h>  #include <stdlib.h>
Line 6 
Line 10 
 #include "strplus.h"  #include "strplus.h"
 #include "strdyn.h"  #include "strdyn.h"
   
   #ifndef FUNCTION
   #  define FUNCTION_NAME(_unused, _name) _unused##_name
   #  define FUNCTION(_name) FUNCTION_NAME(, ## _name)
   #endif
   
   
         void          void
 strdyn_free(ar)  FUNCTION(strdyn_free)(ar)
         char **ar;          char **ar;
 {  {
         register int i;          register int i;
Line 19  strdyn_free(ar)
Line 29  strdyn_free(ar)
 }  }
   
         void          void
 strdyn_safe_free(ar)  FUNCTION(strdyn_safe_free)(ar)
         char **ar;          char **ar;
 {  {
         if (ar == NULL)          if (ar == NULL)
                 return;                  return;
   
         strdyn_free(ar);          FUNCTION(strdyn_free)(ar);
   
         return;          return;
 }  }
   
         int          int
 strdyn_get_size(ar)  FUNCTION(strdyn_get_size)(ar)
         char **ar;          char **ar;
 {  {
         register int i;          register int i;
Line 43  strdyn_get_size(ar)
Line 53  strdyn_get_size(ar)
 }  }
   
         char **          char **
 strdyn_create(void)  FUNCTION(strdyn_create)(void)
 {  {
         register char **ar;          register char **ar;
   
Line 55  strdyn_create(void)
Line 65  strdyn_create(void)
         return ar;          return ar;
 }  }
   
         char **  char **
 strdyn_create_va(  FUNCTION(strdyn_create_va)(
         char *s1,                  char *s1,
         ...)                  ...)
 {  {
         register char **ar;          register char **ar;
   
         if ((ar = strdyn_create()) == NULL)          if ((ar = FUNCTION(strdyn_create)()) == NULL)
                 return NULL;                  return NULL;
   
         if (s1 != NULL) {          if (s1 != NULL) {
                 register char *s;                  register char *s;
                 va_list ap;                  va_list ap;
   
                 if ((ar = strdyn_add(ar, s1)) == NULL)                  if ((ar = FUNCTION(strdyn_add)(ar, s1)) == NULL)
                         return NULL;                          return NULL;
   
                 va_start(ap, s1);                  va_start(ap, s1);
   
                 while ((s = va_arg(ap, char *)) != NULL)                  while ((s = va_arg(ap, char *)) != NULL)
                         if ((ar = strdyn_add(ar, s)) == NULL)                          if ((ar = FUNCTION(strdyn_add)(ar, s)) == NULL)
                                 return NULL;                                  return NULL;
   
                 va_end(ap);                  va_end(ap);
Line 85  strdyn_create_va(
Line 95  strdyn_create_va(
 }  }
   
         char **          char **
 strdyn_create_ar(ar)  FUNCTION(strdyn_create_ar)(ar)
         char **ar;          char **ar;
 {  {
         register int i;          register int i;
         register char **new_ar;          register char **new_ar;
   
         if ((new_ar = (char**) malloc((strdyn_get_size(ar) + 1)          if ((new_ar = (char**) malloc((FUNCTION(strdyn_get_size)(ar) + 1)
                                         * sizeof(char*))) == NULL)                                          * sizeof(char*))) == NULL)
                 return NULL;                          return NULL;
   
         for (i = 0; ar[i] != NULL; i++)          for (i = 0; ar[i] != NULL; i++)
                 new_ar[i] = strdup(ar[i]);                  new_ar[i] = strdup(ar[i]);
Line 103  strdyn_create_ar(ar)
Line 113  strdyn_create_ar(ar)
         return new_ar;          return new_ar;
 }  }
   
         char **  char **
 strdyn_safe_create_ar(ar)  FUNCTION(strdyn_safe_create_ar)(ar)
         char **ar;          char **ar;
 {  {
         if (ar == NULL)          if (ar == NULL)
                 return NULL;                  return NULL;
   
         return strdyn_create_ar(ar);          return FUNCTION(strdyn_create_ar)(ar);
 }  }
   
         char **  char **
 strdyn_add(ar, s)  FUNCTION(strdyn_add)(ar, s)
         char       **ar;          char       **ar;
         const char *s;          const char *s;
 {  {
         register int count;          register int count;
   
         if (ar == NULL)          if (ar == NULL)
                 if ((ar = strdyn_create()) == NULL)                  if ((ar = FUNCTION(strdyn_create)()) == NULL)
                         return NULL;                          return NULL;
   
         count = strdyn_get_size(ar);          count = FUNCTION(strdyn_get_size)(ar);
   
         if ((ar = (char **) realloc(ar, (count + 2) * sizeof(char *))) == NULL)          if ((ar = (char **) realloc(ar, (count + 2) * sizeof(char *))) == NULL)
                 return NULL;                  return NULL;
Line 135  strdyn_add(ar, s)
Line 145  strdyn_add(ar, s)
         return ar;          return ar;
 }  }
   
         char **  char **
 strdyn_add_va(  FUNCTION(strdyn_add_va)(
         char **ar,                  char **ar,
         ...)                  ...)
 {  {
         register char *s;          register char *s;
         va_list ap;          va_list ap;
   
         if (ar == NULL)          if (ar == NULL)
                 if ((ar = strdyn_create()) == NULL)                  if ((ar = FUNCTION(strdyn_create)()) == NULL)
                         return NULL;                          return NULL;
   
         va_start(ap, ar);          va_start(ap, ar);
   
         while ((s = va_arg(ap, char *)) != NULL)          while ((s = va_arg(ap, char *)) != NULL)
                 if ((ar = strdyn_add(ar, s)) == NULL)                  if ((ar = FUNCTION(strdyn_add)(ar, s)) == NULL)
                         return NULL;                          return NULL;
   
         va_end(ap);          va_end(ap);
Line 158  strdyn_add_va(
Line 168  strdyn_add_va(
         return ar;          return ar;
 }  }
   
         char **  char **
 strdyn_add_ar(ar, s_ar)  FUNCTION(strdyn_add_ar)(ar, s_ar)
         char         **ar;          char         **ar;
         char * const *s_ar;          char * const *s_ar;
 {  {
         register int k;          register int k;
   
         for (k = 0; s_ar[k] != NULL; k++)          for (k = 0; s_ar[k] != NULL; k++)
                 if ((ar = strdyn_add(ar, s_ar[k])) == NULL)                  if ((ar = FUNCTION(strdyn_add)(ar, s_ar[k])) == NULL)
                         return NULL;                          return NULL;
   
         return ar;          return ar;
 }  }
   
         char **  char **
 strdyn_remove_idx(ar, idx)  FUNCTION(strdyn_remove_idx)(ar, idx)
         char **ar;          char **ar;
         int  idx;          int  idx;
 {  {
Line 193  strdyn_remove_idx(ar, idx)
Line 203  strdyn_remove_idx(ar, idx)
         return ar;          return ar;
 }  }
   
         char **  char **
 strdyn_remove_str(ar, s)  FUNCTION(strdyn_remove_str)(ar, s)
         char **ar;          char **ar;
         char *s;          char *s;
 {  {
         register int idx;          register int idx;
   
         idx = strdyn_search(ar, s);          idx = FUNCTION(strdyn_search)(ar, s);
   
         if (idx < 0)          if (idx < 0)
                 return ar;                  return ar;
   
         return strdyn_remove_idx(ar, idx);          return FUNCTION(strdyn_remove_idx)(ar, idx);
 }  }
   
         char **  char **
 strdyn_remove_str_all(ar, s)  FUNCTION(strdyn_remove_str_all)(ar, s)
         char **ar;          char **ar;
         char *s;          char *s;
 {  {
Line 219  strdyn_remove_str_all(ar, s)
Line 229  strdyn_remove_str_all(ar, s)
                 if (new_ar != NULL)                  if (new_ar != NULL)
                         ar = new_ar;                          ar = new_ar;
   
                 if ((new_ar = strdyn_remove_str(ar, s)) == NULL)                  if ((new_ar = FUNCTION(strdyn_remove_str)(ar, s)) == NULL)
                         return NULL;                          return NULL;
         }          }
   
         return ar;          return ar;
 }  }
   
         char **  char **
 strdyn_remove_empty(ar)  FUNCTION(strdyn_remove_empty)(ar)
         char **ar;          char **ar;
 {  {
         register int i, j;          register int i, j;
Line 250  strdyn_remove_empty(ar)
Line 260  strdyn_remove_empty(ar)
         return ar;          return ar;
 }  }
   
         char **  char **
 strdyn_remove_all(ar)  FUNCTION(strdyn_remove_all)(ar)
         char **ar;          char **ar;
 {  {
         register int i;          register int i;
Line 267  strdyn_remove_all(ar)
Line 277  strdyn_remove_all(ar)
         return ar;          return ar;
 }  }
   
         char **  char **
 strdyn_explode_chr(str, sep)  FUNCTION(strdyn_explode_chr)(str, sep)
         char *str;          char *str;
         int sep;          int sep;
 {  {
Line 277  strdyn_explode_chr(str, sep)
Line 287  strdyn_explode_chr(str, sep)
         sep_str[0] = (char) sep;          sep_str[0] = (char) sep;
         sep_str[1] = '\0';          sep_str[1] = '\0';
   
         return strdyn_explode_str(str, sep_str);          return FUNCTION(strdyn_explode_str)(str, sep_str);
 }  }
   
         char **  char **
 strdyn_explode2_chr(str, sep)  FUNCTION(strdyn_explode2_chr)(str, sep)
         char *str;          char *str;
         int sep;          int sep;
 {  {
   
         return strdyn_remove_empty(strdyn_explode_chr(str, sep));          return FUNCTION(strdyn_remove_empty)(FUNCTION(strdyn_explode_chr)(str, sep));
 }  }
   
         char **  char **
 strdyn_explode_str(str, sep)  FUNCTION(strdyn_explode_str)(str, sep)
         char *str;          char *str;
         char *sep;          char *sep;
 {  {
Line 301  strdyn_explode_str(str, sep)
Line 311  strdyn_explode_str(str, sep)
         if (str == NULL || sep == NULL)          if (str == NULL || sep == NULL)
                 return NULL;                  return NULL;
   
         ar_size = strcnt_sepstr(str, sep);          ar_size = FUNCTION(strcnt_sepstr)(str, sep);
   
         if ((ar = (char**) malloc((ar_size + 2) * sizeof(char*))) == NULL)          if ((ar = (char**) malloc((ar_size + 2) * sizeof(char*))) == NULL)
                 return NULL;                  return NULL;
Line 328  strdyn_explode_str(str, sep)
Line 338  strdyn_explode_str(str, sep)
   
 }  }
   
         char **  char **
 strdyn_explode2_str(str, sep)  FUNCTION(strdyn_explode2_str)(str, sep)
         char *str;          char *str;
         char *sep;          char *sep;
 {  {
         return strdyn_remove_empty(strdyn_explode_str(str, sep));          return FUNCTION(strdyn_remove_empty)(FUNCTION(strdyn_explode_str)(str, sep));
 }  }
   
         char **  char **
 strdyn_explode_ar(str, sep)  FUNCTION(strdyn_explode_ar)(str, sep)
         char *str;          char *str;
         char **sep;          char **sep;
 {  {
Line 346  strdyn_explode_ar(str, sep)
Line 356  strdyn_explode_ar(str, sep)
   
         char **ar, **ar1;          char **ar, **ar1;
   
         if ((ar1 = strdyn_explode_str(str, sep[0])) == NULL)          if ((ar1 = FUNCTION(strdyn_explode_str)(str, sep[0])) == NULL)
                 return NULL;                  return NULL;
   
         if (sep[1] != NULL) {          if (sep[1] != NULL) {
                 char **ar2;                  char **ar2;
                 register int i;                  register int i;
   
                 if ((ar = strdyn_create()) == NULL) {                  if ((ar = FUNCTION(strdyn_create)()) == NULL) {
                         strdyn_free(ar1);                          FUNCTION(strdyn_free)(ar1);
                         return NULL;                          return NULL;
                 }                  }
   
                 for (i = 0; i < strdyn_count(ar1); i++) {                  for (i = 0; i < strdyn_count(ar1); i++) {
                         if ((ar2 = strdyn_explode_ar(ar1[i], sep + 1)) == NULL) {                          if ((ar2 = FUNCTION(strdyn_explode_ar)(ar1[i], sep + 1)) == NULL) {
                                 strdyn_free(ar1);                                  FUNCTION(strdyn_free)(ar1);
                                 strdyn_free(ar);                                  FUNCTION(strdyn_free)(ar);
                                 return NULL;                                  return NULL;
                         }                          }
   
                         if ((ar = strdyn_add_ar(ar, ar2)) == NULL) {                          if ((ar = FUNCTION(strdyn_add_ar)(ar, ar2)) == NULL) {
                                 strdyn_free(ar1);                                  FUNCTION(strdyn_free)(ar1);
                                 strdyn_free(ar);                                  FUNCTION(strdyn_free)(ar);
                                 strdyn_free(ar2);                                  FUNCTION(strdyn_free)(ar2);
                                 return NULL;                                  return NULL;
                         }                          }
   
                         strdyn_free(ar2);                          FUNCTION(strdyn_free)(ar2);
                 }                  }
   
                 strdyn_free(ar1);                  FUNCTION(strdyn_free)(ar1);
         }          }
         else          else
                 ar = ar1;                  ar = ar1;
Line 383  strdyn_explode_ar(str, sep)
Line 393  strdyn_explode_ar(str, sep)
         return ar;          return ar;
 }  }
   
         char **  char **
 strdyn_explode2_ar(str, sep)  FUNCTION(strdyn_explode2_ar)(str, sep)
         char *str;          char *str;
         char **sep;          char **sep;
 {  {
         return strdyn_remove_empty(strdyn_explode_ar(str, sep));          return FUNCTION(strdyn_remove_empty)(FUNCTION(strdyn_explode_ar)(str, sep));
 }  }
   
         char *  char *
 strdyn_implode_chr(ar, sep)  FUNCTION(strdyn_implode_chr)(ar, sep)
         char **ar;          char **ar;
         int sep;          int sep;
 {  {
Line 401  strdyn_implode_chr(ar, sep)
Line 411  strdyn_implode_chr(ar, sep)
         sep_str[0] = (char) sep;          sep_str[0] = (char) sep;
         sep_str[1] = '\0';          sep_str[1] = '\0';
   
         return strdyn_implode_str(ar, sep_str);          return FUNCTION(strdyn_implode_str)(ar, sep_str);
 }  }
   
         char *  char *
 strdyn_implode2_chr(ar, sep)  FUNCTION(strdyn_implode2_chr)(ar, sep)
         char **ar;          char **ar;
         int sep;          int sep;
 {  {
         register char **new_ar;          register char **new_ar;
         register char *s;          register char *s;
   
         new_ar = strdyn_remove_empty(strdyn_duplicate(ar));          new_ar = FUNCTION(strdyn_remove_empty)(strdyn_duplicate(ar));
   
         s = strdyn_implode_chr(new_ar, sep);          s = FUNCTION(strdyn_implode_chr)(new_ar, sep);
   
         strdyn_free(new_ar);          FUNCTION(strdyn_free)(new_ar);
   
         return s;          return s;
 }  }
   
         char *  char *
 strdyn_implode_str(ar, sep)  FUNCTION(strdyn_implode_str)(ar, sep)
         char **ar;          char **ar;
         char *sep;          char *sep;
 {  {
Line 451  strdyn_implode_str(ar, sep)
Line 461  strdyn_implode_str(ar, sep)
         return str;          return str;
 }  }
   
         char *  char *
 strdyn_implode2_str(ar, str)  FUNCTION(strdyn_implode2_str)(ar, str)
         char **ar;          char **ar;
         char *str;          char *str;
 {  {
         register char **new_ar;          register char **new_ar;
         register char *s;          register char *s;
   
         new_ar = strdyn_remove_empty(strdyn_duplicate(ar));          new_ar = FUNCTION(strdyn_remove_empty)(strdyn_duplicate(ar));
   
         s = strdyn_implode_str(new_ar, str);          s = FUNCTION(strdyn_implode_str)(new_ar, str);
   
         strdyn_free(new_ar);          FUNCTION(strdyn_free)(new_ar);
   
         return s;          return s;
 }  }
   
         char **  char **
 strdyn_conjunct(ar1, ar2)  FUNCTION(strdyn_conjunct)(ar1, ar2)
         char **ar1;          char **ar1;
         char **ar2;          char **ar2;
 {  {
         register int i;          register int i;
         register char **ar;          register char **ar;
   
         if ((ar = strdyn_create()) == NULL)          if ((ar = FUNCTION(strdyn_create)()) == NULL)
                 return NULL;                  return NULL;
   
         for (i = 0; ar2[i] != NULL; i++) {          for (i = 0; ar2[i] != NULL; i++) {
                 if (! strdyn_compare(ar1, ar2[i])) {                  if (! FUNCTION(strdyn_compare)(ar1, ar2[i])) {
                         if ((ar = strdyn_add(ar, ar2[i])) == NULL)                          if ((ar = FUNCTION(strdyn_add)(ar, ar2[i])) == NULL)
                                 return NULL;                                  return NULL;
                 }                  }
         }          }
Line 489  strdyn_conjunct(ar1, ar2)
Line 499  strdyn_conjunct(ar1, ar2)
         return ar;          return ar;
 }  }
   
         char **  char **
 strdyn_consolide(ar1, ar2)  FUNCTION(strdyn_consolide)(ar1, ar2)
         char **ar1;          char **ar1;
         char **ar2;          char **ar2;
 {  {
         register int i;          register int i;
         register char **ar;          register char **ar;
   
         if ((ar = strdyn_create()) == NULL)          if ((ar = FUNCTION(strdyn_create)()) == NULL)
                 return NULL;                  return NULL;
   
         for (i = 0; ar1[i] != NULL; i++) {          for (i = 0; ar1[i] != NULL; i++) {
                 if (strdyn_compare(ar, ar1[i])) {                  if (FUNCTION(strdyn_compare)(ar, ar1[i])) {
                         if ((ar = strdyn_add(ar, ar1[i])) == NULL)                          if ((ar = FUNCTION(strdyn_add)(ar, ar1[i])) == NULL)
                                 return NULL;                                  return NULL;
                 }                  }
         }          }
   
         for (i = 0; ar2[i] != NULL; i++) {          for (i = 0; ar2[i] != NULL; i++) {
                 if (strdyn_compare(ar, ar2[i])) {                  if (FUNCTION(strdyn_compare)(ar, ar2[i])) {
                         if ((ar = strdyn_add(ar, ar2[i])) == NULL)                          if ((ar = FUNCTION(strdyn_add)(ar, ar2[i])) == NULL)
                                 return NULL;                                  return NULL;
                 }                  }
         }          }
Line 517  strdyn_consolide(ar1, ar2)
Line 527  strdyn_consolide(ar1, ar2)
         return ar;          return ar;
 }  }
   
         int  int
 strdyn_search(ar, s)  FUNCTION(strdyn_search)(ar, s)
         char **ar;          char **ar;
         char *s;          char *s;
 {  {
Line 531  strdyn_search(ar, s)
Line 541  strdyn_search(ar, s)
         return -1;          return -1;
 }  }
   
         int  int
 strdyn_casesearch(ar, s)  FUNCTION(strdyn_casesearch)(ar, s)
         char **ar;          char **ar;
         char *s;          char *s;
 {  {
Line 545  strdyn_casesearch(ar, s)
Line 555  strdyn_casesearch(ar, s)
         return -1;          return -1;
 }  }
   
         int  int
 strdyn_compare(ar, s)  FUNCTION(strdyn_compare)(ar, s)
         char **ar;          char **ar;
         char *s;          char *s;
 {  {
         return strdyn_search(ar, s) < 0 ? -1 : 0;          return FUNCTION(strdyn_search)(ar, s) < 0 ? -1 : 0;
 }  }
   
         int  int
 strdyn_casecompare(ar, s)  FUNCTION(strdyn_casecompare)(ar, s)
         char **ar;          char **ar;
         char *s;          char *s;
 {  {
         return strdyn_casesearch(ar, s) < 0 ? -1 : 0;          return FUNCTION(strdyn_casesearch)(ar, s) < 0 ? -1 : 0;
           return FUNCTION(strdyn_casesearch)(ar, s) < 0 ? -1 : 0;
 }  }
   
         int  int
 strdyn_compare_all(ar, s)  FUNCTION(strdyn_compare_all)(ar, s)
         char **ar;          char **ar;
         char *s;          char *s;
 {  {
Line 575  strdyn_compare_all(ar, s)
Line 586  strdyn_compare_all(ar, s)
         return 0;          return 0;
 }  }
   
         char *  char *
 strdyn_str2(s, ar, idx)  FUNCTION(strdyn_str2)(s, ar, idx)
         char *s;          char *s;
         char **ar;          char **ar;
         int  *idx;          int  *idx;
Line 675  main(void)
Line 686  main(void)
   
 #endif  #endif
   
   
Legend:
Removed from v.1.18  
changed lines
  Added in v.1.19
Platon Group <platon@platon.org> http://platon.org/
Copyright © 2002-2006 Platon Group
Site powered by Metafox CMS 		Go to Top