Platon Technologies
not logged in Login Registration
EnglishSlovak
open source software development celebrating 10 years of open source development! Thursday, October 15, 2026
[BACK] [TXT][DIR] Up to [Platon] / libplaton / platon / str

Diff for libplaton/platon/str/strdyn.c between version 1.5 and 1.6

version 1.5, 2001/10/11 13:27:35 version 1.6, 2001/10/21 16:44:22
Line 117  char **strdyn_remove_empty(char **ar) {
Line 117  char **strdyn_remove_empty(char **ar) {
         return ar;          return ar;
 }  }
   
 #if ! defined(SELF) && ! defined(SELFTEST)  char **strdyn_explode_chr(char *str, char sep) {
           char sep_str[2];
   
 /*          sep_str[0] = sep;
  * Function strcnt(), used by function below, is defined in strplus.c          sep_str[1] = '\0';
  * so when we are building self-testing binary, skip this section.  
  */  
   
 char **strdyn_explode(char *str, char sep) {          return strdyn_explode_str(str, sep_str);
   }
   
   char **strdyn_explode2_chr(char *str, char sep) {
   
           return strdyn_remove_empty(strdyn_explode_chr(str, sep));
   }
   
   char **strdyn_explode_str(char *str, char *sep) {
         register char **ar;          register char **ar;
         register char *s;          register char *s;
         register int ar_size, s_size, i;          register int ar_size, s_size, sep_size, i;
   
         if (str == NULL)          if (str == NULL || sep == NULL)
                 return NULL;                  return NULL;
   
         ar_size = strcnt(str, sep);          ar_size = 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;
   
         for (s = str, i = 0; i < ar_size; i++, s += s_size + 1) {          sep_size = strlen(sep);
   
                 s_size = strchr(s, sep) - s;          for (s = str, i = 0; i < ar_size; i++, s += s_size + sep_size) {
   
                   s_size = strstr(s, sep) - s;
   
                 if ((ar[i] = (char*) malloc((s_size + 1) * sizeof(char))) == NULL)                  if ((ar[i] = (char*) malloc((s_size + 1) * sizeof(char))) == NULL)
                         return NULL;                          return NULL;
Line 154  char **strdyn_explode(char *str, char se
Line 163  char **strdyn_explode(char *str, char se
         ar[ar_size + 1] = NULL;          ar[ar_size + 1] = NULL;
   
         return ar;          return ar;
   
   }
   
   char **strdyn_explode2_str(char *str, char *sep) {
   
           return strdyn_remove_empty(strdyn_explode_str(str, sep));
 }  }
   
 #endif  char *strdyn_implode_chr(char **ar, char sep) {
           char sep_str[2];
   
           sep_str[0] = sep;
           sep_str[1] = '\0';
   
           return strdyn_implode_str(ar, sep_str);
   }
   
   char *strdyn_implode2_chr(char **ar, char sep) {
           register char **new_ar;
           register char *s;
   
           new_ar = strdyn_remove_empty(strdyn_duplicate(ar));
   
           s = strdyn_implode_chr(new_ar, sep);
   
 char **strdyn_explode2(char *str, char sep) {          strdyn_free(new_ar);
   
         return strdyn_remove_empty(strdyn_explode(str, sep));          return s;
 }  }
   
 char *strdyn_implode(char **ar, char sep) {  char *strdyn_implode_str(char **ar, char *sep) {
         register int i, str_size;          register int i, str_size, sep_size;
         register char *str, *s;          register char *str, *s;
   
           sep_size = strlen(sep);
   
         for (i = 0, str_size = 0; ar[i] != NULL; )          for (i = 0, str_size = 0; ar[i] != NULL; )
                 str_size += strlen(ar[i++]) + 1;                  str_size += strlen(ar[i++]) + sep_size;
   
         if ((str = (char*) malloc(str_size * sizeof(char))) == NULL)          if ((str = (char*) malloc(str_size * sizeof(char))) == NULL)
                 return NULL;                  return NULL;
Line 178  char *strdyn_implode(char **ar, char sep
Line 210  char *strdyn_implode(char **ar, char sep
                 s += strlen(ar[i]);                  s += strlen(ar[i]);
   
                 if (ar[i + 1] != NULL)                  if (ar[i + 1] != NULL)
                         *s++ = sep;                          strcpy(s, sep);
                           s += sep_size;
         }          }
   
         return str;          return str;
 }  }
   
 char *strdyn_implode2(char **ar, char sep) {  char *strdyn_implode2_str(char **ar, 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 = strdyn_remove_empty(strdyn_duplicate(ar));
   
         s = strdyn_implode(new_ar, sep);          s = strdyn_implode_str(new_ar, str);
   
         strdyn_free(new_ar);          strdyn_free(new_ar);
   
Line 291  int strdyn_compare_all(char **ar, char *
Line 324  int strdyn_compare_all(char **ar, char *
         return 0;          return 0;
 }  }
   
 #if defined(SELF) || defined(SELFTEST)  #if defined(SELF) || defined(SELFTEST) || defined(SELF_STRDYN)
   
 #define TESTSTR1 "___AAA_BBBB__C_DaDaD____"  #define TESTSTR1 "___AAA_BBBB__C_DaDaD____"
 #define TESTSEP1 '_'  #define TESTSEP1 '_'
   #define TESTSEP2 "__"
   
 int main(void) {  int main(void) {
   
Line 310  int main(void) {
Line 344  int main(void) {
                 i++;                  i++;
         }          }
   
         printf("strdyn_explode(\"%s\", '%c') = ar1\n", TESTSTR1, TESTSEP1);          printf("strdyn_explode2_chr(\"%s\", '%c') = ar1\n", TESTSTR1, TESTSEP1);
         ar1 = strdyn_explode2(TESTSTR1, TESTSEP1);          ar1 = strdyn_explode2_chr(TESTSTR1, TESTSEP1);
   
         i = 0;          puts("strdyn_free(ar1)");
         while (ar1[i] != NULL) {          strdyn_free(ar1);
   
           printf("strdyn_explode_str(\"%s\", \"%s\") = ar1\n", TESTSTR1, TESTSEP2);
           ar1 = strdyn_explode_str(TESTSTR1, TESTSEP2);
   
           for (i = 0; ar1[i] != NULL; i++)
                 printf("ar1[%d] = \"%s\"\n", i, ar1[i]);                  printf("ar1[%d] = \"%s\"\n", i, ar1[i]);
                 i++;  
         }  
   
         s = strdyn_implode2(ar1, TESTSEP1);          s = strdyn_implode2_chr(ar1, TESTSEP1);
         printf("strdyn_implode(ar1, '%c') = \"%s\"\n", TESTSEP1, s);          printf("strdyn_implode2_chr(ar1, '%c') = \"%s\"\n", TESTSEP1, s);
   
           puts("free(s)");
           free(s);
   
           s = strdyn_implode2_str(ar1, TESTSEP2);
           printf("strdyn_implode2_str(ar1, \"%s\") = \"%s\"\n", TESTSEP2, s);
   
           puts("free(s)");
           free(s);
   
         ar_join = strdyn_join(ar1, ar2);          ar_join = strdyn_join(ar1, ar2);
         ar_intersect = strdyn_intersect(ar1, ar2);          ar_intersect = strdyn_intersect(ar1, ar2);
Line 349  int main(void) {
Line 395  int main(void) {
         puts("strdyn_free(ar_intersect)");          puts("strdyn_free(ar_intersect)");
         strdyn_free(ar_intersect);          strdyn_free(ar_intersect);
   
         puts("free(s)");  
         free(s);  
   
         return 0;          return 0;
 }  }
Legend:
Removed from v.1.5  
changed lines
  Added in v.1.6
Platon Group <platon@platon.org> http://platon.org/
Copyright © 2002-2006 Platon Group
Site powered by Metafox CMS 		Go to Top