src/cstring.c

   1 /*
   2 ** Splint - annotation-assisted static program checker
   3 ** Copyright (C) 1994-2002 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 # ifndef NOLCL
 731 /*@only@*/ cstring
 732 cstring_concatChars (cstring s, char *t)
 733 {
 734   cstring res = cstring_concat (s, cstring_fromChars (t));
 735   cstring_free (s);
 736   return res;
 737 }
 738 # endif
 739
 740 /*@only@*/ cstring
 741 cstring_concatLength (cstring s1, char *s2, size_t len) /*@requires maxSet(s2) >= (len - 1) @*/
 742 {
 743   cstring tmp = cstring_copyLength (s2, len);
 744   cstring res = cstring_concat (s1, tmp);
 745   cstring_free (tmp);
 746   cstring_free (s1);
 747
 748   return res;
 749 }
 750
 751 /*@only@*/ cstring
 752 cstring_concat (cstring s, cstring t) /*@requires maxSet(s) >= 0 @*/
 753 {
 754   char *ret = mstring_create (cstring_length (s) + cstring_length (t));
 755
 756   if (cstring_isDefined (s))
 757     {
 758     /*drl bee: sl*/   strcpy (ret, s);
 759     }
 760   if (cstring_isDefined (t))
 761     {
 762       strcat (ret, t);
 763     }
 764
 765   return ret;
 766 }
 767
 768 /*@notnull@*/ /*@only@*/ cstring
 769 cstring_prependCharO (char c, /*@only@*/ cstring s1)
 770 {
 771   cstring res = cstring_prependChar (c, s1);
 772
 773   cstring_free (s1);
 774   return (res);
 775 }
 776
 777 /*@notnull@*/ /*@only@*/ cstring
 778 cstring_prependChar (char c, /*@temp@*/ cstring s1)
 779 {
 780   size_t l = cstring_length (s1);
 781   char *s = (char *) dmalloc (sizeof (*s) * (l + 2));
 782
 783 /*drl bee: dm*/   *(s) = c;
 784
 785   if (cstring_isDefined (s1))
 786     {
 787       /*@-mayaliasunique@*/
 788       strcpy (s + 1, s1);
 789       /*@=mayaliasunique@*/
 790     }
 791
 792  /*drl bee: dm*/ *(s + l + 1) = '\0';
 793   return s;
 794 }
 795
 796 # ifndef NOLCL
 797 bool
 798 cstring_hasNonAlphaNumBar (cstring s)
 799 {
 800   int c;
 801
 802   if (cstring_isUndefined (s)) return FALSE;
 803
 804 /*drl bee: lhnt*/  while ((c = (int) *s) != (int) '\0')
 805     {
 806       if ((isalnum (c) == 0) && (c != (int) '_')
 807           && (c != (int) '.') && (c != (int) CONNECTCHAR))
 808         {
 809           return TRUE;
 810         }
 811
 812       s++;
 813     }
 814   return FALSE;
 815 }
 816 # endif
 817
 818 /*@only@*/ /*@notnull@*/ cstring
 819 cstring_create (size_t n)
 820 {
 821   char *s = dmalloc (sizeof (*s) * (n + 1));
 822
 823   /*drl bee: dm*/ *s = '\0';
 824   return s;
 825 }
 826
 827 /*@only@*/ /*@notnull@*/ cstring
 828 cstring_copySegment (cstring s, size_t findex, size_t tindex)
 829 {
 830   cstring res = cstring_create (tindex - findex + 1);
 831
 832   llassert (cstring_isDefined (s));
 833   llassert (cstring_length (s) > tindex);
 834
 835   strncpy (res, (s + findex), size_fromInt ((tindex - findex + 1)));
 836   return res;
 837 }
 838
 839 # ifndef NOLCL
 840 lsymbol cstring_toSymbol (cstring s)
 841 {
 842   lsymbol res = lsymbol_fromString (s);
 843
 844   cstring_free (s);
 845   return res;
 846 }
 847 # endif
 848
 849 cstring cstring_bsearch (cstring key, char **table, int nentries)
 850 {
 851   if (cstring_isDefined (key))
 852     {
 853       int low = 0;
 854       int high = nentries;
 855       int mid = (high + low + 1) / 2;
 856       int last = -1;
 857       cstring res = cstring_undefined;
 858
 859       while (low <= high && mid < nentries)
 860         {
 861           int cmp;
 862
 863           llassert (mid != last);
 864           llassert (mid >= 0 && mid < nentries);
 865
 866           cmp = cstring_compare (key, table[mid]);
 867
 868           if (cmp == 0)
 869             {
 870               res = table[mid];
 871               break;
 872             }
 873           else if (cmp < 0) /* key is before table[mid] */
 874             {
 875               high = mid - 1;
 876             }
 877           else /* key of after table[mid] */
 878             {
 879               low = mid + 1;
 880             }
 881
 882           last = mid;
 883           mid = (high + low + 1) / 2;
 884         }
 885
 886       if (mid != 0 && mid < nentries - 1)
 887         {
 888           llassert (cstring_compare (key, table[mid - 1]) > 0);
 889         /*drl bee: ndv*/  llassert (cstring_compare (key, table[mid + 1]) < 0);
 890         }
 891
 892       return res;
 893     }
 894
 895   return cstring_undefined;
 896 }
 897
 898 extern /*@observer@*/ cstring cstring_advanceWhiteSpace (cstring s)
 899 {
 900   if (cstring_isDefined (s)) {
 901     char *t = s;
 902
 903  /*drl bee: lhnt*/   while (*t != '\0' && isspace ((int) *t)) {
 904       t++;
 905     }
 906
 907     return t;
 908   }
 909
 910   return cstring_undefined;
 911 }
 912
 913 /* changes strings like "sdf" "sdfsd" into "sdfsdfsd"*/
 914 /* This function understands that "sdf\"  \"sdfsdf" is okay*/
 915 static mstring doMergeString (cstring s)
 916 {
 917   char *ptr;
 918   mstring ret;
 919   char * retPtr;
 920   bool escape;
 921
 922   llassert(cstring_isDefined (s));
 923
 924   ret = mstring_create (cstring_length(s) );
 925
 926   ptr = s;
 927
 928   retPtr = ret;
 929   /*
 930   llassert(*ptr == '\"');
 931
 932   *retPtr = *ptr;
 933
 934   retPtr++;
 935   ptr++;
 936   */
 937
 938   while (*ptr != '\0')
 939     {
 940       escape = FALSE;
 941
 942       if (*ptr == '\\')
 943         {
 944           *retPtr = *ptr;
 945
 946           if (!escape)
 947             escape = TRUE;
 948           else
 949             /* case of escaped \ ('\\')  */
 950             escape = FALSE;
 951         }
 952       else if ( (*ptr == '\"') && (!escape) )
 953         {
 954           while ( (ptr[1] != '\"') && (ptr[1] != '\0') )
 955             {
 956               ptr++;
 957             }
 958           if (ptr[1] == '\0')
 959             {
 960               llassert(*ptr == '\"');
 961               *retPtr =  '\"';
 962               retPtr++;
 963               *retPtr = '\0';
 964               BADEXIT;
 965               return ret;
 966             }
 967           else
 968             {
 969               ptr++;
 970             }
 971         }
 972       else
 973         {
 974           *retPtr = *ptr;
 975         }
 976
 977       retPtr++;
 978       ptr++;
 979
 980     }/* end while */
 981   retPtr = '\0';
 982   return ret;
 983 }
 984
 985 static mstring doExpandEscapes (cstring s, /*@out@*/ int * len)
 986 {
 987   char *ptr;
 988   mstring ret;
 989   char * retPtr;
 990
 991
 992   llassert(cstring_isDefined (s));
 993
 994   ret = mstring_create (cstring_length(s));
 995
 996   ptr = s;
 997
 998   retPtr = ret;
 999   while (*ptr != '\0')
1000     {
1001       if (*ptr != '\\')
1002         {
1003           *retPtr = *ptr;
1004           retPtr++;
1005           ptr++;
1006           continue;
1007         }
1008
1009       if (*ptr == '\\')
1010         {
1011           ptr++;
1012           if (*ptr == '\0')
1013             {
1014               /*not a legal escape sequence but try to handle it in a sesible way*/
1015               *retPtr = '\\';
1016               retPtr++;
1017             }
1018
1019           /* Handle Octal escapes  */
1020           else if (*ptr >= '0' && *ptr <= '9' )
1021             {
1022               int total;
1023               total = (int)(*ptr - '0');
1024               ptr++;
1025               /*octal can only be 3 characters long */
1026               if (*ptr != '\0' &&  (*ptr >= '0' && *ptr <= '9' ) )
1027                 {
1028                   total *= 8;
1029                   ptr++;
1030                   if (*ptr != '\0' &&  (*ptr >= '0' && *ptr <= '9' ) )
1031                     {
1032                       total *= 8;
1033                       total += (int) (*ptr - '0');
1034                       ptr++;
1035                     }
1036                 }
1037
1038               *retPtr =  (char) total;
1039               retPtr++;
1040             }
1041
1042           else if (*ptr == 'x')
1043             {
1044               int total;
1045               total = 0;
1046               ptr++;
1047               if (!(*ptr != '\0' &&
1048                     ( (*ptr >= '0' && *ptr <= '9' ) ||
1049                       (toupper(*ptr) >= (int)('A') && toupper(*ptr) <= (int)('F') ) )
1050                       ))
1051                 {
1052                   total = (int)'x';
1053                 }
1054               else
1055                 {
1056                   while (*ptr != '\0' &&
1057                     ( (*ptr >= '0' && *ptr <= '9' ) ||
1058                       (toupper(*ptr) >= ((int)('A')) && toupper(*ptr) <= ((int)'F') ) )
1059                          )
1060                     {
1061                       total *= 16;
1062                       if (*ptr >= '0' && *ptr <= '9' )
1063                         total += (int)(*ptr - '0');
1064                       else
1065                         total += ( (toupper(*ptr) - 'A') + 10);
1066                       ptr++;
1067                     }
1068                 }
1069               *retPtr =  (char) total;
1070               retPtr++;
1071             }
1072           else
1073             {
1074               switch ( *ptr )
1075                 {
1076                 case 'a':
1077                   *retPtr = '\a';
1078                   retPtr++;
1079                   /*@switchbreak@*/ break;
1080
1081                 case 'b':
1082                   *retPtr = '\b';
1083                   retPtr++;
1084                   /*@switchbreak@*/ break;
1085
1086                 case 'f':
1087                   *retPtr = '\f';
1088                   retPtr++;
1089                   /*@switchbreak@*/ break;
1090
1091                 case 'n':
1092                   *retPtr = '\n';
1093                   retPtr++;
1094                   /*@switchbreak@*/ break;
1095
1096                 case 'r':
1097                   *retPtr = '\r';
1098                   retPtr++;
1099                   /*@switchbreak@*/ break;
1100
1101                 case 't':
1102                   *retPtr = '\t';
1103                   retPtr++;
1104                   /*@switchbreak@*/ break;
1105                   /* ' " ? \ */
1106                   /* we assume invalid sequences are handled somewhere else
1107                      so we handle an invalid sequence of the form \char by replacing
1108                      it with char (this is what gcc does) the C standard says a diagnostic is
1109                      required..*/
1110                 default:
1111                   *retPtr = *ptr;
1112                   retPtr++;
1113                 }
1114               ptr++;
1115             }
1116
1117         }/*end outer if*/
1118
1119     }/*end while */
1120
1121   /* add the null character */
1122   *retPtr = '\0';
1123
1124   *len = retPtr - ret;
1125   return ret;
1126 }
1127
1128
1129 /*this function is like sctring_expandEscapses */
1130 mstring cstring_expandEscapes (cstring s)
1131 {
1132   int len;
1133
1134   mstring ret;
1135
1136   ret = doExpandEscapes (s, &len);
1137   return ret;
1138 }
1139
1140 int  cstring_lengthExpandEscapes (cstring s)
1141 {
1142   int len;
1143
1144   mstring tmpStr, tmpStr2;
1145
1146   tmpStr = doMergeString (s);
1147   tmpStr2 = doExpandEscapes (tmpStr, &len);
1148
1149
1150   cstring_free(tmpStr);
1151   cstring_free(tmpStr2);
1152
1153   return len;
1154 }
1155
1156
1157
1158 cstring cstring_replaceChar(/*@returned@*/ cstring c, char oldChar, char newChar)
1159 {
1160   char *ptr;
1161   llassert(oldChar != '\0');
1162   if (cstring_isUndefined(c) )
1163     {
1164       llcontbug(cstring_makeLiteral("cstring_replaceChar called with undefined string"));
1165       return c;
1166     }
1167
1168   ptr = c;
1169   while (*ptr != '\0')
1170     {
1171       if (*ptr == oldChar)
1172         *ptr = newChar;
1173       ptr++;
1174     }
1175
1176   return c;
1177 }