src/cstring.c

   1 /*
   2 ** Splint - annotation-assisted static program checker
   3 ** Copyright (C) 1994-2003 University of Virginia,
   4 **         Massachusetts Institute of Technology
   5 **
   6 ** This program is free software; you can redistribute it and/or modify it
   7 ** under the terms of the GNU General Public License as published by the
   8 ** Free Software Foundation; either version 2 of the License, or (at your
   9 ** option) any later version.
  10 **
  11 ** This program is distributed in the hope that it will be useful, but
  12 ** WITHOUT ANY WARRANTY; without even the implied warranty of
  13 ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 ** General Public License for more details.
  15 **
  16 ** The GNU General Public License is available from http://www.gnu.org/ or
  17 ** the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
  18 ** MA 02111-1307, USA.
  19 **
  20 ** For information on splint: info@splint.org
  21 ** To report a bug: splint-bug@splint.org
  22 ** For more information: http://www.splint.org
  23 */
  24 /*
  25 ** cstring.c
  26 */
  27
  28 /*
  29  * Herbert 06/12/2000
  30  * - use drive spec specials with OS2 like with WIN32
  31  * - cstring_replaceAll () needed in cpplib.c
  32  */
  33
  34 # include "splintMacros.nf"
  35 # include "basic.h"
  36 # include "osd.h"
  37 # include "portab.h"
  38
  39 /*@only@*/ /*@notnull@*/
  40 cstring cstring_newEmpty (void)
  41 {
  42   return (cstring_create (0));
  43 }
  44
  45 char cstring_firstChar (cstring s)
  46 {
  47   llassert (cstring_isDefined (s));
  48   llassert (cstring_length (s) > 0);
  49
  50   return (s[0]);
  51 }
  52
  53 char cstring_getChar (cstring s, size_t n)
  54 {
  55   size_t length = cstring_length (s);
  56
  57   llassert (cstring_isDefined (s));
  58   llassert (n >= 1 && n <= length);
  59
  60   return (s[n - 1]);
  61 }
  62
  63 cstring cstring_suffix (cstring s, size_t n)
  64 {
  65   llassert (cstring_isDefined (s));
  66   llassert (n <= cstring_length (s));
  67
  68   return (s + n);
  69 }
  70
  71 cstring cstring_prefix (cstring s, size_t n)
  72    /*@requires maxRead(s) >= n /\ maxSet(s) >= n @*/
  73    /*@ensures maxRead(result) == n /\ maxSet(result) == n @*/
  74 {
  75   cstring t;
  76   char c;
  77   llassert (cstring_isDefined (s));
  78   llassert (n <= cstring_length (s));
  79
  80   c = *(s + n);
  81   /*@-mods@*/  /* The modifications cancel out. */
  82   *(s + n) = '\0';
  83   t = cstring_copy (s);
  84   *(s + n) = c;
  85   /*@=mods@*/
  86
  87   return t;
  88 }
  89
  90 /* effects If s = [0-9]*, returns s as an int.
  91 **         else returns -1.
  92 */
  93
  94 int cstring_toPosInt (cstring s)
  95 {
  96   int val = 0;
  97
  98   cstring_chars (s, c)
  99     {
 100       if (isdigit ((unsigned char) c))
 101         {
 102           val = (val * 10) + (int)(c - '0');
 103         }
 104       else
 105         {
 106           return -1;
 107         }
 108     } end_cstring_chars ;
 109
 110   return val;
 111 }
 112
 113 cstring cstring_afterChar (cstring s, char c)
 114 {
 115   llassert (cstring_isDefined (s));
 116   return strchr (s, c);
 117 }
 118
 119 cstring cstring_beforeChar (cstring s, char c)
 120 {
 121   if (cstring_isDefined (s))
 122     {
 123       char *cp = strchr (s, c);
 124
 125       if (cp != NULL)
 126         {
 127           cstring ret;
 128
 129           /*@-mods@*/
 130           *cp = '\0';
 131           ret = cstring_copy (s);
 132           *cp = c;
 133           /*@=mods@*/ /* modification is undone */
 134
 135           return ret;
 136         }
 137     }
 138
 139   return cstring_undefined;
 140 }
 141
 142 void cstring_setChar (cstring s, size_t n, char c) /*@requires maxRead(s) >= (n - 1) /\ maxSet(s) >= (n - 1) @*/
 143 {
 144   llassert (cstring_isDefined (s));
 145   llassert (n > 0 && n <= cstring_length (s));
 146
 147   s[n - 1] = c;
 148 }
 149
 150 char cstring_lastChar (cstring s)
 151 {
 152   size_t length;
 153
 154   llassert (cstring_isDefined (s));
 155
 156   length = cstring_length (s);
 157   llassert (length > 0);
 158
 159   return (s[length - 1]);
 160 }
 161
 162 /*@only@*/ cstring cstring_copy (cstring s) /*@ensures maxSet(result) == maxRead(s) /\ maxRead(result) == maxRead(s) @*/
 163 {
 164   if (cstring_isDefined (s))
 165     {
 166       return (mstring_copy (s));
 167     }
 168   else
 169     {
 170       return cstring_undefined;
 171     }
 172 }
 173
 174 /*@only@*/ cstring cstring_copyLength (char *s, size_t len) /*@requires maxSet(s) >= (len - 1) @*/
 175 {
 176   char *res = mstring_create (len + 1);
 177
 178   strncpy (res, s, len);
 179   res[len] = '\0';
 180   return res;
 181 }
 182
 183 bool cstring_containsChar (cstring c, char ch)
 184 {
 185   if (cstring_isDefined (c))
 186     {
 187       return (strchr (c, ch) != NULL);
 188     }
 189   else
 190     {
 191       return FALSE;
 192     }
 193 }
 194
 195 /*
 196 ** Replaces all occurances of old in s with new.
 197 */
 198
 199 void cstring_replaceAll (cstring s, char old, char snew)
 200 {
 201
 202   llassert (old != snew);
 203
 204   if (cstring_isDefined (s))
 205     {
 206       char *sp = strchr (s, old);
 207
 208       while (sp != NULL)
 209         {
 210           *sp = snew;
 211           sp = strchr (sp, old);
 212         }
 213
 214           }
 215 }
 216
 217 void cstring_replaceLit (/*@unique@*/ cstring s, char *old, char *snew)
 218    /*@requires maxRead(snew) >= 0 /\ maxRead(old) >= 0 /\ maxRead(old) >= maxRead(snew) @*/
 219 {
 220   llassert (strlen (old) >= strlen (snew));
 221
 222   if (cstring_isDefined (s))
 223     {
 224       char *sp = strstr (s, old);
 225
 226       while (sp != NULL)
 227         {
 228           int lendiff = size_toInt (strlen (old) - strlen (snew));
 229           char *tsnew = snew;
 230
 231           llassert (lendiff >= 0);
 232
 233           while (*tsnew != '\0')
 234             {
 235               llassert (*sp != '\0');
 236               *sp++ = *tsnew++;
 237             }
 238
 239           if (lendiff > 0)
 240             {
 241               while (*(sp + lendiff) != '\0')
 242                 {
 243                   *sp = *(sp + lendiff);
 244                   sp++;
 245                 }
 246
 247               *sp = '\0';
 248             }
 249
 250           sp = strstr (s, old);
 251         }
 252     }
 253 }
 254
 255 /*
 256 ** removes all chars in clist from s
 257 */
 258
 259 void cstring_stripChars (cstring s, const char *clist)
 260 {
 261   if (cstring_isDefined (s))
 262     {
 263       int i;
 264       size_t size = cstring_length (s);
 265
 266       for (i = 0; i < size_toInt (size); i++)
 267         {
 268           /*drl bee: is*/
 269           char c = s[i];
 270
 271           if (strchr (clist, c) != NULL)
 272             {
 273               /* strip this char */
 274               int j;
 275
 276               size--;
 277
 278               for (j = i; j < size_toInt (size); j++)
 279                 {
 280                   /*drl bee: is*/ /*drl bee: is*/ s[j] = s[j+1];
 281                 }
 282
 283               /*drl bee: is*/ s[size] = '\0';
 284               i--;
 285             }
 286         }
 287     }
 288 }
 289
 290 bool cstring_contains (/*@unique@*/ cstring c, cstring sub)
 291 {
 292   if (cstring_isDefined (c))
 293     {
 294       llassert (cstring_isDefined (sub));
 295
 296       return (strstr (c, sub) != NULL);
 297     }
 298   else
 299     {
 300       return FALSE;
 301     }
 302 }
 303
 304 static char lookLike (char c) /*@*/
 305 {
 306   if (c == 'I' || c == 'l')
 307     {
 308       return '1';
 309     }
 310   else if (c == 'O' || c == 'o')
 311     {
 312       return '0';
 313     }
 314   else if (c == 'Z')
 315     {
 316       return '2';
 317     }
 318   else if (c == 'S')
 319     {
 320       return '5';
 321     }
 322   else
 323     {
 324       return c;
 325     }
 326 }
 327
 328 cmpcode cstring_genericEqual (cstring s, cstring t,
 329                               size_t nchars,
 330                               bool caseinsensitive,
 331                               bool lookalike)
 332   /*@requires maxRead(s) >= nchars /\ maxRead(t) >= nchars @*/
 333 {
 334   if (s == t) return CGE_SAME;
 335   else if (cstring_isUndefined (s))
 336     {
 337       return cstring_isEmpty (t) ? CGE_SAME : CGE_DISTINCT;
 338     }
 339   else if (cstring_isUndefined (t))
 340     {
 341       return cstring_isEmpty (s) ? CGE_SAME : CGE_DISTINCT;
 342     }
 343   else
 344     {
 345       int i = 0;
 346       bool diffcase = FALSE;
 347       bool difflookalike = FALSE;
 348
 349       while (*s != '\0')
 350         {
 351           if (nchars > 0 && i >= size_toInt (nchars))
 352             {
 353               break;
 354             }
 355
 356           if (*t == *s)
 357             {
 358               ; /* no difference */
 359             }
 360           else if (caseinsensitive
 361                    && (toupper ((int) *t) == toupper ((int) *s)))
 362             {
 363               diffcase = TRUE;
 364             }
 365           else if (lookalike && (lookLike (*t) == lookLike (*s)))
 366             {
 367               difflookalike = TRUE;
 368             }
 369           else
 370             {
 371               return CGE_DISTINCT;
 372             }
 373           i++;
 374           s++;
 375           t++;
 376         }
 377
 378   /*drl bee: ib*/
 379       /*drl bee: ib*/
 380       if (*s == '\0' && *t != '\0')
 381         {
 382           return CGE_DISTINCT;
 383         }
 384
 385       if (diffcase)
 386         {
 387           return CGE_CASE;
 388         }
 389       else if (difflookalike)
 390         {
 391           return CGE_LOOKALIKE;
 392         }
 393       else
 394         {
 395           return CGE_SAME;
 396         }
 397     }
 398 }
 399
 400
 401
 402 bool cstring_equalFree (/*@only@*/ cstring c1, /*@only@*/ cstring c2)
 403 {
 404   bool res = cstring_equal (c1, c2);
 405   cstring_free (c1);
 406   cstring_free (c2);
 407   return res;
 408 }
 409
 410 bool cstring_equal (cstring c1, cstring c2)
 411 {
 412   if (c1 == c2) return TRUE;
 413   else if (cstring_isUndefined (c1)) return cstring_isEmpty (c2);
 414   else if (cstring_isUndefined (c2)) return cstring_isEmpty (c1);
 415   else return (strcmp (c1, c2) == 0);
 416 }
 417
 418 bool cstring_equalLen (cstring c1, cstring c2, size_t len)
 419 {
 420   if (c1 == c2) return TRUE;
 421   else if (cstring_isUndefined (c1)) return cstring_isEmpty (c2);
 422   else if (cstring_isUndefined (c2)) return cstring_isEmpty (c1);
 423   else return (strncmp (c1, c2, len) == 0);
 424 }
 425
 426 bool cstring_equalCaseInsensitive (cstring c1, cstring c2)
 427 {
 428   if (c1 == c2) return TRUE;
 429   else if (cstring_isUndefined (c1)) return cstring_isEmpty (c2);
 430   else if (cstring_isUndefined (c2)) return cstring_isEmpty (c1);
 431   else return (cstring_genericEqual (c1, c2, 0, TRUE, FALSE) != CGE_DISTINCT);
 432 }
 433
 434 bool cstring_equalLenCaseInsensitive (cstring c1, cstring c2, size_t len)
 435 {
 436   if (c1 == c2) return TRUE;
 437   else if (cstring_isUndefined (c1)) return cstring_isEmpty (c2);
 438   else if (cstring_isUndefined (c2)) return cstring_isEmpty (c1);
 439   else return (cstring_genericEqual (c1, c2, len, TRUE, FALSE) != CGE_DISTINCT);
 440 }
 441
 442 bool cstring_equalPrefix (cstring c1, cstring c2)
 443 {
 444   llassert (c2 != NULL);
 445
 446   if (cstring_isUndefined (c1))
 447     {
 448       return (strlen (c2) == 0);
 449     }
 450
 451   return (strncmp (c1, c2, strlen (c2)) == 0);
 452 }
 453
 454 bool cstring_equalPrefixLit (cstring c1, const char *c2)
 455 {
 456   llassert (c2 != NULL);
 457
 458   if (cstring_isUndefined (c1))
 459     {
 460       return (strlen (c2) == 0);
 461     }
 462
 463   return (strncmp (c1, c2, strlen (c2)) == 0);
 464 }
 465
 466 int cstring_xcompare (cstring *c1, cstring *c2)
 467 {
 468   return (cstring_compare (*c1, *c2));
 469 }
 470
 471 int cstring_compare (cstring c1, cstring c2)
 472 {
 473   int res;
 474
 475   if (c1 == c2)
 476     {
 477       res = 0;
 478     }
 479   else if (cstring_isUndefined (c1))
 480     {
 481       if (cstring_isEmpty (c2))
 482         {
 483           res = 0;
 484         }
 485       else
 486         {
 487           res = 1;
 488         }
 489     }
 490   else if (cstring_isUndefined (c2))
 491     {
 492       if (cstring_isEmpty (c1))
 493         {
 494           res = 0;
 495         }
 496       else
 497         {
 498           res = -1;
 499         }
 500     }
 501   else
 502     {
 503       res = strcmp (c1, c2);
 504     }
 505
 506     return (res);
 507 }
 508
 509 void cstring_markOwned (/*@owned@*/ cstring s)
 510 {
 511   sfreeEventually (s);
 512 }
 513
 514 void cstring_free (/*@only@*/ cstring s)
 515 {
 516   if (cstring_isDefined (s))
 517     {
 518       /*drl 2/3/2002*/
 519       s[0] = '\0';
 520
 521       sfree (s);
 522     }
 523 }
 524
 525 cstring cstring_fromChars (/*@exposed@*/ const char *cp)
 526 {
 527   return (cstring) cp;
 528 }
 529
 530 /*@exposed@*/ char *cstring_toCharsSafe (cstring s)
 531 {
 532   static /*@only@*/ cstring emptystring = cstring_undefined;
 533
 534   if (cstring_isDefined (s))
 535     {
 536       return (char *) s;
 537     }
 538   else
 539     {
 540       if (cstring_isUndefined (emptystring))
 541         {
 542           emptystring = cstring_newEmpty ();
 543         }
 544
 545       return emptystring;
 546     }
 547 }
 548
 549 size_t cstring_length (cstring s)
 550 {
 551   if (cstring_isDefined (s))
 552     {
 553       return strlen (s);
 554     }
 555
 556   return 0;
 557 }
 558
 559 cstring
 560 cstring_capitalize (cstring s) /*@requires maxSet(s) >= 0 @*/
 561 {
 562   if (!cstring_isEmpty (s))
 563     {
 564       cstring ret = cstring_copy (s);
 565
 566       cstring_setChar (ret, 1, (char) toupper ((int) cstring_firstChar (ret)));
 567       return ret;
 568     }
 569
 570   return cstring_undefined;
 571 }
 572
 573 cstring
 574 cstring_capitalizeFree (cstring s) /*@requires maxSet(s) >= 0 /\ maxRead(s) >= 0 @*/
 575 {
 576   if (!cstring_isEmpty (s))
 577     {
 578       cstring_setChar (s, 1, (char) toupper ((int) cstring_firstChar (s)));
 579       return s;
 580     }
 581
 582   return s;
 583 }
 584
 585 cstring
 586 cstring_clip (cstring s, size_t len)
 587 {
 588   if (cstring_isUndefined (s) || cstring_length (s) <= len)
 589     {
 590       ;
 591     }
 592   else
 593     {
 594       llassert (s != NULL);
 595       /*drl bee: mrms*/
 596       *(s + len) = '\0';
 597     }
 598
 599   return s;
 600 }
 601
 602 /*@only@*/ cstring
 603 cstring_elide (cstring s, size_t len)
 604 {
 605   if (cstring_isUndefined (s) || cstring_length (s) <= len)
 606     {
 607       return cstring_copy (s);
 608     }
 609   else
 610     {
 611       cstring sc = cstring_create (len);
 612
 613       strncpy (sc, s, len);
 614       /*drl bee: mrms*/
 615       *(sc + len - 1) = '\0';
 616       *(sc + len - 2) = '.';
 617       *(sc + len - 3) = '.';
 618       *(sc + len - 4) = '.';
 619
 620       return sc;
 621     }
 622 }
 623
 624 /*@only@*/ cstring
 625 cstring_fill (cstring s, size_t n) /*@requires n >= 0 @*/
 626 {
 627   cstring t = cstring_create (n + 1);
 628   cstring ot = t;
 629   size_t len = cstring_length (s);
 630   size_t i;
 631
 632   if (len > n)
 633     {
 634       for (i = 0; i < n; i++)
 635         {
 636         /*drl bee: is*/
 637           /*drl bee: is*/
 638           *t++ = *s++;
 639         }
 640       *t = '\0';
 641     }
 642   else
 643     {
 644       for (i = 0; i < len; i++)
 645         {
 646         /*drl bee: is*/
 647 /*drl bee: is*/
 648           *t++ = *s++;
 649         }
 650       for (i = 0; i < n - len; i++)
 651         {
 652 /*drl bee: is*/
 653           *t++ = ' ';
 654         }
 655       *t = '\0';
 656     }
 657
 658   return ot;
 659 }
 660
 661 cstring
 662 cstring_downcase (cstring s)
 663 {
 664   if (cstring_isDefined (s))
 665     {
 666       cstring t = cstring_create (strlen (s) + 1);
 667       cstring ot = t;
 668       char c;
 669
 670  /*drl bee: lhnt*/      while ((c = *s) != '\0')
 671         {
 672           if (c >= 'A' && c <= 'Z')
 673             {
 674               c = c - 'A' + 'a';
 675             }
 676           *t++ = c;
 677           s++;
 678         }
 679      /*drl bee: is*/  *t = '\0';
 680
 681       return ot;
 682     }
 683   else
 684     {
 685       return cstring_undefined;
 686     }
 687 }
 688
 689 /*@notnull@*/ cstring
 690 cstring_appendChar (/*@only@*/ cstring s1, char c)
 691 {
 692   size_t l = cstring_length (s1);
 693   char *s;
 694
 695   s = (char *) dmalloc (sizeof (*s) * (l + 2));
 696
 697   if (cstring_isDefined (s1))
 698     {
 699       strcpy (s, s1);
 700       *(s + l) = c;
 701       /*drl bee: dm*/ *(s + l + 1) = '\0';
 702       sfree (s1);
 703     }
 704   else
 705     {
 706       *(s) = c;
 707       /*drl bee: dm*/  *(s + 1) = '\0';
 708     }
 709
 710   return s;
 711 }
 712
 713 /*@only@*/ cstring
 714 cstring_concatFree (cstring s, cstring t)
 715 {
 716   cstring res = cstring_concat (s, t);
 717   cstring_free (s);
 718   cstring_free (t);
 719   return res;
 720 }
 721
 722 /*@only@*/ cstring
 723 cstring_concatFree1 (cstring s, cstring t)
 724 {
 725   cstring res = cstring_concat (s, t);
 726   cstring_free (s);
 727   return res;
 728 }
 729
 730 /*@only@*/ cstring
 731 cstring_concatChars (cstring s, char *t)
 732 {
 733   cstring res = cstring_concat (s, cstring_fromChars (t));
 734   cstring_free (s);
 735   return res;
 736 }
 737
 738 /*@only@*/ cstring
 739 cstring_concatLength (cstring s1, char *s2, size_t len) /*@requires maxSet(s2) >= (len - 1) @*/
 740 {
 741   cstring tmp = cstring_copyLength (s2, len);
 742   cstring res = cstring_concat (s1, tmp);
 743   cstring_free (tmp);
 744   cstring_free (s1);
 745
 746   return res;
 747 }
 748
 749 /*@only@*/ cstring
 750 cstring_concat (cstring s, cstring t) /*@requires maxSet(s) >= 0 @*/
 751 {
 752   char *ret = mstring_create (cstring_length (s) + cstring_length (t));
 753
 754   if (cstring_isDefined (s))
 755     {
 756     /*drl bee: sl*/   strcpy (ret, s);
 757     }
 758   if (cstring_isDefined (t))
 759     {
 760       strcat (ret, t);
 761     }
 762
 763   return ret;
 764 }
 765
 766 /*@notnull@*/ /*@only@*/ cstring
 767 cstring_prependCharO (char c, /*@only@*/ cstring s1)
 768 {
 769   cstring res = cstring_prependChar (c, s1);
 770
 771   cstring_free (s1);
 772   return (res);
 773 }
 774
 775 /*@notnull@*/ /*@only@*/ cstring
 776 cstring_prependChar (char c, /*@temp@*/ cstring s1)
 777 {
 778   size_t l = cstring_length (s1);
 779   char *s = (char *) dmalloc (sizeof (*s) * (l + 2));
 780
 781 /*drl bee: dm*/   *(s) = c;
 782
 783   if (cstring_isDefined (s1))
 784     {
 785       /*@-mayaliasunique@*/
 786       strcpy (s + 1, s1);
 787       /*@=mayaliasunique@*/
 788     }
 789
 790  /*drl bee: dm*/ *(s + l + 1) = '\0';
 791   return s;
 792 }
 793
 794 bool
 795 cstring_hasNonAlphaNumBar (cstring s)
 796 {
 797   int c;
 798
 799   if (cstring_isUndefined (s)) return FALSE;
 800
 801 /*drl bee: lhnt*/  while ((c = (int) *s) != (int) '\0')
 802     {
 803       if ((isalnum (c) == 0) && (c != (int) '_')
 804           && (c != (int) '.') && (c != (int) CONNECTCHAR))
 805         {
 806           return TRUE;
 807         }
 808
 809       s++;
 810     }
 811   return FALSE;
 812 }
 813
 814 /*@only@*/ /*@notnull@*/ cstring
 815 cstring_create (size_t n)
 816 {
 817   char *s = dmalloc (sizeof (*s) * (n + 1));
 818
 819   /*drl bee: dm*/ *s = '\0';
 820   return s;
 821 }
 822
 823 /*@only@*/ /*@notnull@*/ cstring
 824 cstring_copySegment (cstring s, size_t findex, size_t tindex)
 825 {
 826   cstring res = cstring_create (tindex - findex + 1);
 827
 828   llassert (cstring_isDefined (s));
 829   llassert (cstring_length (s) > tindex);
 830
 831   strncpy (res, (s + findex), size_fromInt (size_toInt (tindex - findex) + 1));
 832   return res;
 833 }
 834
 835 lsymbol cstring_toSymbol (cstring s)
 836 {
 837   lsymbol res = lsymbol_fromString (s);
 838
 839   cstring_free (s);
 840   return res;
 841 }
 842
 843 cstring cstring_bsearch (cstring key, char **table, int nentries)
 844 {
 845   if (cstring_isDefined (key))
 846     {
 847       int low = 0;
 848       int high = nentries;
 849       int mid = (high + low + 1) / 2;
 850       int last = -1;
 851       cstring res = cstring_undefined;
 852
 853       while (low <= high && mid < nentries)
 854         {
 855           int cmp;
 856
 857           llassert (mid != last);
 858           llassert (mid >= 0 && mid < nentries);
 859
 860           cmp = cstring_compare (key, table[mid]);
 861
 862           if (cmp == 0)
 863             {
 864               res = table[mid];
 865               break;
 866             }
 867           else if (cmp < 0) /* key is before table[mid] */
 868             {
 869               high = mid - 1;
 870             }
 871           else /* key of after table[mid] */
 872             {
 873               low = mid + 1;
 874             }
 875
 876           last = mid;
 877           mid = (high + low + 1) / 2;
 878         }
 879
 880       if (mid != 0 && mid < nentries - 1)
 881         {
 882           llassert (cstring_compare (key, table[mid - 1]) > 0);
 883         /*drl bee: ndv*/  llassert (cstring_compare (key, table[mid + 1]) < 0);
 884         }
 885
 886       return res;
 887     }
 888
 889   return cstring_undefined;
 890 }
 891
 892 extern /*@observer@*/ cstring cstring_advanceWhiteSpace (cstring s)
 893 {
 894   if (cstring_isDefined (s)) {
 895     char *t = s;
 896
 897  /*drl bee: lhnt*/   while (*t != '\0' && isspace ((int) *t)) {
 898       t++;
 899     }
 900
 901     return t;
 902   }
 903
 904   return cstring_undefined;
 905 }
 906
 907 /*@i3534 @*/
 908 /*@ignore@*/ /* !!! DRL don't ignore large segments like this without a good reason! */
 909
 910 /* changes strings like "sdf" "sdfsd" into "sdfsdfsd"*/
 911 /* This function understands that "sdf\"  \"sdfsdf" is okay*/
 912 static mstring doMergeString (cstring s)
 913 {
 914   char *ptr;
 915   mstring ret;
 916   char * retPtr;
 917   bool escape;
 918
 919   llassert(cstring_isDefined (s));
 920
 921   ret = mstring_create (cstring_length(s) );
 922
 923   ptr = s;
 924
 925   retPtr = ret;
 926   /*
 927   llassert(*ptr == '\"');
 928
 929   *retPtr = *ptr;
 930
 931   retPtr++;
 932   ptr++;
 933   */
 934
 935   while (*ptr != '\0')
 936     {
 937       escape = FALSE;
 938
 939       if (*ptr == '\\')
 940         {
 941           *retPtr = *ptr;
 942
 943           if (!escape)
 944             escape = TRUE;
 945           else
 946             /* case of escaped \ ('\\')  */
 947             escape = FALSE;
 948         }
 949       else if ( (*ptr == '\"') && (!escape) )
 950         {
 951           while ( (ptr[1] != '\"') && (ptr[1] != '\0') )
 952             {
 953               ptr++;
 954             }
 955           if (ptr[1] == '\0')
 956             {
 957               llassert(*ptr == '\"');
 958               *retPtr =  '\"';
 959               retPtr++;
 960               *retPtr = '\0';
 961               BADEXIT;
 962               return ret;
 963             }
 964           else
 965             {
 966               ptr++;
 967             }
 968         }
 969       else
 970         {
 971           *retPtr = *ptr;
 972         }
 973
 974       retPtr++;
 975       ptr++;
 976
 977     }/* end while */
 978   retPtr = '\0';
 979   return ret;
 980 }
 981
 982 static mstring doExpandEscapes (cstring s, /*@out@*/ size_t *len)
 983 {
 984   char *ptr;
 985   mstring ret;
 986   char * retPtr;
 987
 988   llassert(cstring_isDefined (s));
 989
 990   ret = mstring_create (cstring_length(s));
 991
 992   ptr = s;
 993
 994   retPtr = ret;
 995   while (*ptr != '\0')
 996     {
 997       if (*ptr != '\\')
 998         {
 999           *retPtr = *ptr;
1000           retPtr++;
1001           ptr++;
1002           continue;
1003         }
1004
1005       if (*ptr == '\\')
1006         {
1007           ptr++;
1008           if (*ptr == '\0')
1009             {
1010               /*not a legal escape sequence but try to handle it in a sesible way*/
1011               *retPtr = '\\';
1012               retPtr++;
1013             }
1014
1015           /* Handle Octal escapes  */
1016           else if (*ptr >= '0' && *ptr <= '9' )
1017             {
1018               int total;
1019               total = (int)(*ptr - '0');
1020               ptr++;
1021               /*octal can only be 3 characters long */
1022               if (*ptr != '\0' &&  (*ptr >= '0' && *ptr <= '9' ) )
1023                 {
1024                   total *= 8;
1025                   ptr++;
1026                   if (*ptr != '\0' &&  (*ptr >= '0' && *ptr <= '9' ) )
1027                     {
1028                       total *= 8;
1029                       total += (int) (*ptr - '0');
1030                       ptr++;
1031                     }
1032                 }
1033
1034               *retPtr =  (char) total;
1035               retPtr++;
1036             }
1037
1038           else if (*ptr == 'x')
1039             {
1040               int total;
1041               total = 0;
1042               ptr++;
1043               if (!(*ptr != '\0' &&
1044                     ( (*ptr >= '0' && *ptr <= '9' ) ||
1045                       (toupper(*ptr) >= (int)('A') && toupper(*ptr) <= (int)('F') ) )
1046                       ))
1047                 {
1048                   total = (int)'x';
1049                 }
1050               else
1051                 {
1052                   while (*ptr != '\0' &&
1053                     ( (*ptr >= '0' && *ptr <= '9' ) ||
1054                       (toupper(*ptr) >= ((int)('A')) && toupper(*ptr) <= ((int)'F') ) )
1055                          )
1056                     {
1057                       total *= 16;
1058                       if (*ptr >= '0' && *ptr <= '9' )
1059                         total += (int)(*ptr - '0');
1060                       else
1061                         total += ( (toupper(*ptr) - 'A') + 10);
1062                       ptr++;
1063                     }
1064                 }
1065               *retPtr =  (char) total;
1066               retPtr++;
1067             }
1068           else
1069             {
1070               switch ( *ptr )
1071                 {
1072                 case 'a':
1073                   *retPtr = '\a';
1074                   retPtr++;
1075                   /*@switchbreak@*/ break;
1076
1077                 case 'b':
1078                   *retPtr = '\b';
1079                   retPtr++;
1080                   /*@switchbreak@*/ break;
1081
1082                 case 'f':
1083                   *retPtr = '\f';
1084                   retPtr++;
1085                   /*@switchbreak@*/ break;
1086
1087                 case 'n':
1088                   *retPtr = '\n';
1089                   retPtr++;
1090                   /*@switchbreak@*/ break;
1091
1092                 case 'r':
1093                   *retPtr = '\r';
1094                   retPtr++;
1095                   /*@switchbreak@*/ break;
1096
1097                 case 't':
1098                   *retPtr = '\t';
1099                   retPtr++;
1100                   /*@switchbreak@*/ break;
1101                   /* ' " ? \ */
1102                   /* we assume invalid sequences are handled somewhere else
1103                      so we handle an invalid sequence of the form \char by replacing
1104                      it with char (this is what gcc does) the C standard says a diagnostic is
1105                      required..*/
1106                 default:
1107                   *retPtr = *ptr;
1108                   retPtr++;
1109                 }
1110               ptr++;
1111             }
1112
1113         }/*end outer if*/
1114
1115     }/*end while */
1116
1117   /* add the null character */
1118   *retPtr = '\0';
1119
1120   *len = retPtr - ret;
1121   return ret;
1122 }
1123
1124
1125 /*this function is like sctring_expandEscapses */
1126 mstring cstring_expandEscapes (cstring s)
1127 {
1128   size_t len;
1129
1130   mstring ret;
1131   ret = doExpandEscapes (s, &len);
1132   return ret;
1133 }
1134
1135 size_t cstring_lengthExpandEscapes (cstring s)
1136 {
1137   size_t len;
1138   mstring tmpStr, tmpStr2;
1139
1140   tmpStr = doMergeString (s);
1141   tmpStr2 = doExpandEscapes (tmpStr, &len);
1142
1143   cstring_free(tmpStr);
1144   cstring_free(tmpStr2);
1145
1146   return len;
1147 }
1148
1149 cstring cstring_replaceChar(/*@returned@*/ cstring c, char oldChar, char newChar)
1150 {
1151   char *ptr;
1152   llassert(oldChar != '\0');
1153   if (cstring_isUndefined(c) )
1154     {
1155       llcontbug(cstring_makeLiteral("cstring_replaceChar called with undefined string"));
1156       return c;
1157     }
1158
1159   ptr = c;
1160   while (*ptr != '\0')
1161     {
1162       if (*ptr == oldChar)
1163         *ptr = newChar;
1164       ptr++;
1165     }
1166
1167   return c;
1168 }
1169 /*@end@*/
1170
1171
1172
1173
1174
1175
1176