src/cfg/platon/str/strdyn.c

   1 #ifdef HAVE_CONFIG_H
   2 #  include "config.h"
   3 #endif
   4
   5 #include <stdio.h>
   6 #include <string.h>
   7 #include <stdlib.h>
   8 #include <stdarg.h>
   9
  10 #include <platon/str/strplus.h>
  11 #include <platon/str/strdyn.h>
  12
  13         void
  14 PLATON_FUNC(strdyn_free)(ar)
  15         char **ar;
  16 {
  17         register int i;
  18
  19         for (i = 0; ar[i] != NULL; i++)
  20                 free(ar[i]);
  21
  22         free(ar);
  23 }
  24
  25         void
  26 PLATON_FUNC(strdyn_safe_free)(ar)
  27         char **ar;
  28 {
  29         if (ar == NULL)
  30                 return;
  31
  32         PLATON_FUNC(strdyn_free)(ar);
  33
  34         return;
  35 }
  36
  37         int
  38 PLATON_FUNC(strdyn_get_size)(ar)
  39         char **ar;
  40 {
  41         register int i;
  42
  43         for (i = 0; ar[i] != NULL; i++)
  44                 ;
  45
  46         return i;
  47 }
  48
  49         char **
  50 PLATON_FUNC(strdyn_create)(void)
  51 {
  52         register char **ar;
  53
  54         if ((ar = (char **) malloc(1 * sizeof(char *))) == NULL)
  55                 return NULL;
  56
  57         ar[0] = NULL;
  58
  59         return ar;
  60 }
  61
  62 char **
  63 PLATON_FUNC(strdyn_create_va)(
  64                 char *s1,
  65                 ...)
  66 {
  67         register char **ar;
  68
  69         if ((ar = PLATON_FUNC(strdyn_create)()) == NULL)
  70                 return NULL;
  71
  72         if (s1 != NULL) {
  73                 register char *s;
  74                 va_list ap;
  75
  76                 if ((ar = PLATON_FUNC(strdyn_add)(ar, s1)) == NULL)
  77                         return NULL;
  78
  79                 va_start(ap, s1);
  80
  81                 while ((s = va_arg(ap, char *)) != NULL)
  82                         if ((ar = PLATON_FUNC(strdyn_add)(ar, s)) == NULL)
  83                                 return NULL;
  84
  85                 va_end(ap);
  86         }
  87
  88         return ar;
  89 }
  90
  91         char **
  92 PLATON_FUNC(strdyn_create_ar)(ar)
  93         char **ar;
  94 {
  95         register int i;
  96         register char **new_ar;
  97
  98         if ((new_ar = (char**) malloc((PLATON_FUNC(strdyn_get_size)(ar) + 1)
  99                                         * sizeof(char*))) == NULL)
 100                         return NULL;
 101
 102         for (i = 0; ar[i] != NULL; i++)
 103                 new_ar[i] = strdup(ar[i]);
 104
 105         new_ar[i] = NULL;
 106
 107         return new_ar;
 108 }
 109
 110 char **
 111 PLATON_FUNC(strdyn_safe_create_ar)(ar)
 112         char **ar;
 113 {
 114         if (ar == NULL)
 115                 return NULL;
 116
 117         return PLATON_FUNC(strdyn_create_ar)(ar);
 118 }
 119
 120 char **
 121 PLATON_FUNC(strdyn_add)(ar, s)
 122         char       **ar;
 123         const char *s;
 124 {
 125         register int count;
 126
 127         if (ar == NULL)
 128                 if ((ar = PLATON_FUNC(strdyn_create)()) == NULL)
 129                         return NULL;
 130
 131         count = PLATON_FUNC(strdyn_get_size)(ar);
 132
 133         if ((ar = (char **) realloc(ar, (count + 2) * sizeof(char *))) == NULL)
 134                 return NULL;
 135
 136         ar[count] = strdup(s);
 137         ar[count + 1] = NULL;
 138
 139         return ar;
 140 }
 141
 142 char **
 143 PLATON_FUNC(strdyn_add_va)(
 144                 char **ar,
 145                 ...)
 146 {
 147         register char *s;
 148         va_list ap;
 149
 150         if (ar == NULL)
 151                 if ((ar = PLATON_FUNC(strdyn_create)()) == NULL)
 152                         return NULL;
 153
 154         va_start(ap, ar);
 155
 156         while ((s = va_arg(ap, char *)) != NULL)
 157                 if ((ar = PLATON_FUNC(strdyn_add)(ar, s)) == NULL)
 158                         return NULL;
 159
 160         va_end(ap);
 161
 162         return ar;
 163 }
 164
 165 char **
 166 PLATON_FUNC(strdyn_add_ar)(ar, s_ar)
 167         char         **ar;
 168         char * const *s_ar;
 169 {
 170         register int k;
 171
 172         for (k = 0; s_ar[k] != NULL; k++)
 173                 if ((ar = PLATON_FUNC(strdyn_add)(ar, s_ar[k])) == NULL)
 174                         return NULL;
 175
 176         return ar;
 177 }
 178
 179 char **
 180 PLATON_FUNC(strdyn_remove_idx)(ar, idx)
 181         char **ar;
 182         int  idx;
 183 {
 184         register int i;
 185
 186         for (i = 0; ar[i] != NULL; i++) {
 187                 if (i == idx)
 188                         free(ar[i]);
 189
 190                 if (i >= idx)
 191                         ar[i] = ar[i + 1];
 192         }
 193
 194         if ((ar = (char**) realloc(ar, i * sizeof(char*))) == NULL)
 195                 return NULL;
 196
 197         return ar;
 198 }
 199
 200 char **
 201 PLATON_FUNC(strdyn_remove_str)(ar, s)
 202         char **ar;
 203         char *s;
 204 {
 205         register int idx;
 206
 207         idx = PLATON_FUNC(strdyn_search)(ar, s);
 208
 209         if (idx < 0)
 210                 return ar;
 211
 212         return PLATON_FUNC(strdyn_remove_idx)(ar, idx);
 213 }
 214
 215 char **
 216 PLATON_FUNC(strdyn_remove_str_all)(ar, s)
 217         char **ar;
 218         char *s;
 219 {
 220         char **new_ar = NULL;
 221
 222         while (new_ar != ar) {
 223                 if (new_ar != NULL)
 224                         ar = new_ar;
 225
 226                 if ((new_ar = PLATON_FUNC(strdyn_remove_str)(ar, s)) == NULL)
 227                         return NULL;
 228         }
 229
 230         return ar;
 231 }
 232
 233 char **
 234 PLATON_FUNC(strdyn_remove_empty)(ar)
 235         char **ar;
 236 {
 237         register int i, j;
 238
 239         for (i = 0; ar[i] != NULL; ) {
 240
 241                 if (strlen(ar[i]) == 0) {
 242                         free(ar[i]);
 243
 244                         for (j = i; ar[j] != NULL; j++)
 245                                 ar[j] = ar[j + 1];
 246                 }
 247                 else
 248                         i++;
 249         }
 250
 251         if ((ar = (char**) realloc(ar, (i + 1) * sizeof(char*))) == NULL)
 252                 return NULL;
 253
 254         return ar;
 255 }
 256
 257 char **
 258 PLATON_FUNC(strdyn_remove_all)(ar)
 259         char **ar;
 260 {
 261         register int i;
 262
 263         for (i = 0; ar[i] != NULL; i++)
 264                 free(ar[i]);
 265
 266         if ((ar = (char**) realloc(ar, /* 1 * */ sizeof(char*))) == NULL)
 267                 return NULL;
 268
 269         ar[0] = NULL;
 270
 271         return ar;
 272 }
 273
 274 char **
 275 PLATON_FUNC(strdyn_explode_chr)(str, sep)
 276         char *str;
 277         int sep;
 278 {
 279         char sep_str[2];
 280
 281         sep_str[0] = (char) sep;
 282         sep_str[1] = '\0';
 283
 284         return PLATON_FUNC(strdyn_explode_str)(str, sep_str);
 285 }
 286
 287 char **
 288 PLATON_FUNC(strdyn_explode2_chr)(str, sep)
 289         char *str;
 290         int sep;
 291 {
 292
 293         return PLATON_FUNC(strdyn_remove_empty)(PLATON_FUNC(strdyn_explode_chr)(str, sep));
 294 }
 295
 296 char **
 297 PLATON_FUNC(strdyn_explode_str)(str, sep)
 298         char *str;
 299         char *sep;
 300 {
 301         register char **ar;
 302         register char *s;
 303         register int ar_size, s_size, sep_size, i;
 304
 305         if (str == NULL || sep == NULL)
 306                 return NULL;
 307
 308         ar_size = PLATON_FUNC(strcnt_sepstr)(str, sep);
 309
 310         if ((ar = (char**) malloc((ar_size + 2) * sizeof(char*))) == NULL)
 311                 return NULL;
 312
 313         sep_size = strlen(sep);
 314
 315         for (s = str, i = 0; i < ar_size; i++, s += s_size + sep_size) {
 316
 317                 s_size = strstr(s, sep) - s;
 318
 319                 if ((ar[i] = (char*) malloc((s_size + 1) * sizeof(char))) == NULL) {
 320                         PLATON_FUNC(strdyn_free)(ar);
 321                         return NULL;
 322                 }
 323
 324                 strncpy(ar[i], s, s_size);
 325                 ar[i][s_size] = '\0';
 326         }
 327
 328         if ((ar[ar_size] = strdup(s)) == NULL) {
 329                 PLATON_FUNC(strdyn_free)(ar);
 330                 return NULL;
 331         }
 332
 333         ar[ar_size + 1] = NULL;
 334
 335         return ar;
 336
 337 }
 338
 339 char **
 340 PLATON_FUNC(strdyn_explode2_str)(str, sep)
 341         char *str;
 342         char *sep;
 343 {
 344         return PLATON_FUNC(strdyn_remove_empty)(PLATON_FUNC(strdyn_explode_str)(str, sep));
 345 }
 346
 347 char **
 348 PLATON_FUNC(strdyn_explode_ar)(str, sep)
 349         char *str;
 350         char **sep;
 351 {
 352         /* WARNING: Unefective recursion used! */
 353         /* TODO: Various code optimalizations. */
 354
 355         char **ar, **ar1;
 356
 357         if ((ar1 = PLATON_FUNC(strdyn_explode_str)(str, sep[0])) == NULL)
 358                 return NULL;
 359
 360         if (sep[1] != NULL) {
 361                 char **ar2;
 362                 register int i;
 363
 364                 if ((ar = PLATON_FUNC(strdyn_create)()) == NULL) {
 365                         PLATON_FUNC(strdyn_free)(ar1);
 366                         return NULL;
 367                 }
 368
 369                 for (i = 0; i < strdyn_count(ar1); i++) {
 370                         if ((ar2 = PLATON_FUNC(strdyn_explode_ar)(ar1[i], sep + 1)) == NULL) {
 371                                 PLATON_FUNC(strdyn_free)(ar1);
 372                                 PLATON_FUNC(strdyn_free)(ar);
 373                                 return NULL;
 374                         }
 375
 376                         if ((ar = PLATON_FUNC(strdyn_add_ar)(ar, ar2)) == NULL) {
 377                                 PLATON_FUNC(strdyn_free)(ar1);
 378                                 PLATON_FUNC(strdyn_free)(ar);
 379                                 PLATON_FUNC(strdyn_free)(ar2);
 380                                 return NULL;
 381                         }
 382
 383                         PLATON_FUNC(strdyn_free)(ar2);
 384                 }
 385
 386                 PLATON_FUNC(strdyn_free)(ar1);
 387         }
 388         else
 389                 ar = ar1;
 390
 391         return ar;
 392 }
 393
 394 char **
 395 PLATON_FUNC(strdyn_explode2_ar)(str, sep)
 396         char *str;
 397         char **sep;
 398 {
 399         return PLATON_FUNC(strdyn_remove_empty)(PLATON_FUNC(strdyn_explode_ar)(str, sep));
 400 }
 401
 402 char *
 403 PLATON_FUNC(strdyn_implode_chr)(ar, sep)
 404         char **ar;
 405         int sep;
 406 {
 407         char sep_str[2];
 408
 409         sep_str[0] = (char) sep;
 410         sep_str[1] = '\0';
 411
 412         return PLATON_FUNC(strdyn_implode_str)(ar, sep_str);
 413 }
 414
 415 char *
 416 PLATON_FUNC(strdyn_implode2_chr)(ar, sep)
 417         char **ar;
 418         int sep;
 419 {
 420         register char **new_ar;
 421         register char *s;
 422
 423         new_ar = PLATON_FUNC(strdyn_remove_empty)(strdyn_duplicate(ar));
 424
 425         s = PLATON_FUNC(strdyn_implode_chr)(new_ar, sep);
 426
 427         PLATON_FUNC(strdyn_free)(new_ar);
 428
 429         return s;
 430 }
 431
 432 char *
 433 PLATON_FUNC(strdyn_implode_str)(ar, sep)
 434         char **ar;
 435         char *sep;
 436 {
 437         register int i, str_size, sep_size;
 438         register char *str, *s;
 439
 440         sep_size = strlen(sep);
 441
 442         for (i = 0, str_size = 0; ar[i] != NULL; i++)
 443                 str_size += strlen(ar[i]) + sep_size;
 444
 445         str_size -= sep_size;
 446
 447         if ((str = (char*) malloc((str_size + 1) * sizeof(char))) == NULL)
 448                 return NULL;
 449
 450         for (i = 0,     s = str; ar[i] != NULL; i++) {
 451                 strcpy(s, ar[i]);
 452                 s += strlen(ar[i]);
 453
 454                 if (ar[i + 1] != NULL)
 455                         strcpy(s, sep);
 456                 s += sep_size;
 457         }
 458
 459         return str;
 460 }
 461
 462 char *
 463 PLATON_FUNC(strdyn_implode2_str)(ar, str)
 464         char **ar;
 465         char *str;
 466 {
 467         register char **new_ar;
 468         register char *s;
 469
 470         new_ar = PLATON_FUNC(strdyn_remove_empty)(strdyn_duplicate(ar));
 471
 472         s = PLATON_FUNC(strdyn_implode_str)(new_ar, str);
 473
 474         PLATON_FUNC(strdyn_free)(new_ar);
 475
 476         return s;
 477 }
 478
 479 char **
 480 PLATON_FUNC(strdyn_conjunct)(ar1, ar2)
 481         char **ar1;
 482         char **ar2;
 483 {
 484         register int i;
 485         register char **ar;
 486
 487         if ((ar = PLATON_FUNC(strdyn_create)()) == NULL)
 488                 return NULL;
 489
 490         for (i = 0; ar2[i] != NULL; i++) {
 491                 if (! PLATON_FUNC(strdyn_compare)(ar1, ar2[i])) {
 492                         if ((ar = PLATON_FUNC(strdyn_add)(ar, ar2[i])) == NULL)
 493                                 return NULL;
 494                 }
 495         }
 496
 497         return ar;
 498 }
 499
 500 char **
 501 PLATON_FUNC(strdyn_consolide)(ar1, ar2)
 502         char **ar1;
 503         char **ar2;
 504 {
 505         register int i;
 506         register char **ar;
 507
 508         if ((ar = PLATON_FUNC(strdyn_create)()) == NULL)
 509                 return NULL;
 510
 511         for (i = 0; ar1[i] != NULL; i++) {
 512                 if (PLATON_FUNC(strdyn_compare)(ar, ar1[i])) {
 513                         if ((ar = PLATON_FUNC(strdyn_add)(ar, ar1[i])) == NULL)
 514                                 return NULL;
 515                 }
 516         }
 517
 518         for (i = 0; ar2[i] != NULL; i++) {
 519                 if (PLATON_FUNC(strdyn_compare)(ar, ar2[i])) {
 520                         if ((ar = PLATON_FUNC(strdyn_add)(ar, ar2[i])) == NULL)
 521                                 return NULL;
 522                 }
 523         }
 524
 525         return ar;
 526 }
 527
 528 int
 529 PLATON_FUNC(strdyn_search)(ar, s)
 530         char **ar;
 531         char *s;
 532 {
 533         register int i;
 534
 535         for (i = 0; ar[i] != NULL; i++)
 536                 if (! strcmp(ar[i], s))
 537                         return i;
 538
 539         return -1;
 540 }
 541
 542 int
 543 PLATON_FUNC(strdyn_casesearch)(ar, s)
 544         char **ar;
 545         char *s;
 546 {
 547         register int i;
 548
 549         for (i = 0; ar[i] != NULL; i++)
 550                 if (! strcasecmp(ar[i], s))
 551                         return i;
 552
 553         return -1;
 554 }
 555
 556 int
 557 PLATON_FUNC(strdyn_compare)(ar, s)
 558         char **ar;
 559         char *s;
 560 {
 561         return PLATON_FUNC(strdyn_search)(ar, s) < 0 ? -1 : 0;
 562 }
 563
 564 int
 565 PLATON_FUNC(strdyn_casecompare)(ar, s)
 566         char **ar;
 567         char *s;
 568 {
 569         return PLATON_FUNC(strdyn_casesearch)(ar, s) < 0 ? -1 : 0;
 570 }
 571
 572 int
 573 PLATON_FUNC(strdyn_compare_all)(ar, s)
 574         char **ar;
 575         char *s;
 576 {
 577         register int i;
 578
 579         for (i = 0; ar[i] != NULL; i++)
 580                 if (strcmp(ar[i], s))
 581                         return -1;
 582
 583         return 0;
 584 }
 585
 586 char *
 587 PLATON_FUNC(strdyn_str2)(s, ar, idx)
 588         char *s;
 589         char **ar;
 590         int  *idx;
 591 {
 592         register char *ret, *tmp_s;
 593         register int i;
 594
 595         for (ret = NULL, i = 0; ar[i] != NULL; i++)
 596                 if ((tmp_s = strstr(s, ar[i])) != NULL
 597                                 && (ret == NULL || tmp_s < ret)) {
 598                         ret = tmp_s;
 599
 600                         if (idx != NULL)
 601                                 *idx = i;
 602                 }
 603
 604         return ret;
 605 }
 606
 607 #if defined(SELF) || defined(SELFTEST) || defined(SELF_STRDYN)
 608
 609 #define TESTSTR1 "___AAA_BBBB__C_DaDaD____"
 610 #define TESTSEP1 '_'
 611 #define TESTSEP2 "__"
 612
 613         int
 614 main(void)
 615 {
 616
 617         register int i;
 618         char **ar1, **ar2, **ar_join, **ar_intersect;
 619         char *s;
 620
 621         ar2 = strdyn_create_va("A", "B", "C", "D", NULL);
 622
 623         i = 0;
 624         while (ar2[i] != NULL) {
 625                 printf("ar2[%d] = \"%s\"\n", i, ar2[i]);
 626                 i++;
 627         }
 628
 629         printf("strdyn_explode2_chr(\"%s\", '%c') = ar1\n", TESTSTR1, TESTSEP1);
 630         ar1 = strdyn_explode2_chr(TESTSTR1, TESTSEP1);
 631
 632         puts("strdyn_free(ar1)");
 633         strdyn_free(ar1);
 634
 635         printf("strdyn_explode_str(\"%s\", \"%s\") = ar1\n", TESTSTR1, TESTSEP2);
 636         ar1 = strdyn_explode_str(TESTSTR1, TESTSEP2);
 637
 638         for (i = 0; ar1[i] != NULL; i++)
 639                 printf("ar1[%d] = \"%s\"\n", i, ar1[i]);
 640
 641         s = strdyn_implode2_chr(ar1, TESTSEP1);
 642         printf("strdyn_implode2_chr(ar1, '%c') = \"%s\"\n", TESTSEP1, s);
 643
 644         puts("free(s)");
 645         free(s);
 646
 647         s = strdyn_implode2_str(ar1, TESTSEP2);
 648         printf("strdyn_implode2_str(ar1, \"%s\") = \"%s\"\n", TESTSEP2, s);
 649
 650         puts("free(s)");
 651         free(s);
 652
 653         ar_join = strdyn_join(ar1, ar2);
 654         ar_intersect = strdyn_intersect(ar1, ar2);
 655
 656         i = 0;
 657         while (ar_join[i] != NULL) {
 658                 printf("ar_join[%d] = \"%s\"\n", i, ar_join[i]);
 659                 i++;
 660         }
 661
 662         i = 0;
 663         while (ar_intersect[i] != NULL) {
 664                 printf("ar_intersect[%d] = \"%s\"\n", i, ar_intersect[i]);
 665                 i++;
 666         }
 667
 668         puts("strdyn_free(ar1)");
 669         strdyn_free(ar1);
 670
 671         puts("strdyn_free(ar2)");
 672         strdyn_free(ar2);
 673
 674         puts("strdyn_free(ar_join)");
 675         strdyn_free(ar_join);
 676
 677         puts("strdyn_free(ar_intersect)");
 678         strdyn_free(ar_intersect);
 679
 680
 681         return 0;
 682 }
 683
 684 #endif
 685