contrib/tcsh-6/tc.str.c

   1 /* $Header: /p/tcsh/cvsroot/tcsh/tc.str.c,v 3.30 2009/06/25 21:27:38 christos Exp $ */
   2 /*
   3  * tc.str.c: Short string package
   4  *           This has been a lesson of how to write buggy code!
   5  */
   6 /*-
   7  * Copyright (c) 1980, 1991 The Regents of the University of California.
   8  * All rights reserved.
   9  *
  10  * Redistribution and use in source and binary forms, with or without
  11  * modification, are permitted provided that the following conditions
  12  * are met:
  13  * 1. Redistributions of source code must retain the above copyright
  14  *    notice, this list of conditions and the following disclaimer.
  15  * 2. Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in the
  17  *    documentation and/or other materials provided with the distribution.
  18  * 3. Neither the name of the University nor the names of its contributors
  19  *    may be used to endorse or promote products derived from this software
  20  *    without specific prior written permission.
  21  *
  22  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  23  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  24  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  25  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  26  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  27  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  28  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  29  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  30  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  31  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  32  * SUCH DAMAGE.
  33  */
  34 #include "sh.h"
  35
  36 #include <limits.h>
  37
  38 RCSID("$tcsh: tc.str.c,v 3.30 2009/06/25 21:27:38 christos Exp $")
  39
  40 #define MALLOC_INCR     128
  41 #ifdef WIDE_STRINGS
  42 #define MALLOC_SURPLUS  MB_LEN_MAX /* Space for one multibyte character */
  43 #else
  44 #define MALLOC_SURPLUS  0
  45 #endif
  46
  47 #ifdef WIDE_STRINGS
  48 size_t
  49 one_mbtowc(wchar_t *pwc, const char *s, size_t n)
  50 {
  51     int len;
  52
  53     len = rt_mbtowc(pwc, s, n);
  54     if (len == -1) {
  55         reset_mbtowc();
  56         *pwc = (unsigned char)*s | INVALID_BYTE;
  57     }
  58     if (len <= 0)
  59         len = 1;
  60     return len;
  61 }
  62
  63 size_t
  64 one_wctomb(char *s, wchar_t wchar)
  65 {
  66     int len;
  67
  68     if (wchar & INVALID_BYTE) {
  69         s[0] = wchar & 0xFF;
  70         len = 1;
  71     } else {
  72         len = wctomb(s, wchar);
  73         if (len == -1)
  74             s[0] = wchar;
  75         if (len <= 0)
  76             len = 1;
  77     }
  78     return len;
  79 }
  80
  81 int
  82 rt_mbtowc(wchar_t *pwc, const char *s, size_t n)
  83 {
  84     int ret;
  85     char back[MB_LEN_MAX];
  86
  87     ret = mbtowc(pwc, s, n);
  88     if (ret > 0 && (wctomb(back, *pwc) != ret || memcmp(s, back, ret) != 0))
  89         ret = -1;
  90     return ret;
  91 }
  92 #endif
  93
  94 #ifdef SHORT_STRINGS
  95 Char  **
  96 blk2short(char **src)
  97 {
  98     size_t     n;
  99     Char **sdst, **dst;
 100
 101     /*
 102      * Count
 103      */
 104     for (n = 0; src[n] != NULL; n++)
 105         continue;
 106     sdst = dst = xmalloc((n + 1) * sizeof(Char *));
 107
 108     for (; *src != NULL; src++)
 109         *dst++ = SAVE(*src);
 110     *dst = NULL;
 111     return (sdst);
 112 }
 113
 114 char  **
 115 short2blk(Char **src)
 116 {
 117     size_t     n;
 118     char **sdst, **dst;
 119
 120     /*
 121      * Count
 122      */
 123     for (n = 0; src[n] != NULL; n++)
 124         continue;
 125     sdst = dst = xmalloc((n + 1) * sizeof(char *));
 126
 127     for (; *src != NULL; src++)
 128         *dst++ = strsave(short2str(*src));
 129     *dst = NULL;
 130     return (sdst);
 131 }
 132
 133 Char   *
 134 str2short(const char *src)
 135 {
 136     static struct Strbuf buf; /* = Strbuf_INIT; */
 137
 138     if (src == NULL)
 139         return (NULL);
 140
 141     buf.len = 0;
 142     while (*src) {
 143         Char wc;
 144
 145         src += one_mbtowc(&wc, src, MB_LEN_MAX);
 146         Strbuf_append1(&buf, wc);
 147     }
 148     Strbuf_terminate(&buf);
 149     return buf.s;
 150 }
 151
 152 char   *
 153 short2str(const Char *src)
 154 {
 155     static char *sdst = NULL;
 156     static size_t dstsize = 0;
 157     char *dst, *edst;
 158
 159     if (src == NULL)
 160         return (NULL);
 161
 162     if (sdst == NULL) {
 163         dstsize = MALLOC_INCR;
 164         sdst = xmalloc((dstsize + MALLOC_SURPLUS) * sizeof(char));
 165     }
 166     dst = sdst;
 167     edst = &dst[dstsize];
 168     while (*src) {
 169         dst += one_wctomb(dst, *src & CHAR);
 170         src++;
 171         if (dst >= edst) {
 172             char *wdst = dst;
 173             char *wedst = edst;
 174
 175             dstsize += MALLOC_INCR;
 176             sdst = xrealloc(sdst, (dstsize + MALLOC_SURPLUS) * sizeof(char));
 177             edst = &sdst[dstsize];
 178             dst = &edst[-MALLOC_INCR];
 179             while (wdst > wedst) {
 180                 dst++;
 181                 wdst--;
 182             }
 183         }
 184     }
 185     *dst = 0;
 186     return (sdst);
 187 }
 188
 189 #ifndef WIDE_STRINGS
 190 Char   *
 191 s_strcpy(Char *dst, const Char *src)
 192 {
 193     Char *sdst;
 194
 195     sdst = dst;
 196     while ((*dst++ = *src++) != '\0')
 197         continue;
 198     return (sdst);
 199 }
 200
 201 Char   *
 202 s_strncpy(Char *dst, const Char *src, size_t n)
 203 {
 204     Char *sdst;
 205
 206     if (n == 0)
 207         return(dst);
 208
 209     sdst = dst;
 210     do
 211         if ((*dst++ = *src++) == '\0') {
 212             while (--n != 0)
 213                 *dst++ = '\0';
 214             return(sdst);
 215         }
 216     while (--n != 0);
 217     return (sdst);
 218 }
 219
 220 Char   *
 221 s_strcat(Char *dst, const Char *src)
 222 {
 223     Strcpy(Strend(dst), src);
 224     return dst;
 225 }
 226
 227 #ifdef NOTUSED
 228 Char   *
 229 s_strncat(Char *dst, const Char *src, size_t n)
 230 {
 231     Char *sdst;
 232
 233     if (n == 0)
 234         return (dst);
 235
 236     sdst = dst;
 237
 238     while (*dst)
 239         dst++;
 240
 241     do
 242         if ((*dst++ = *src++) == '\0')
 243             return(sdst);
 244     while (--n != 0)
 245         continue;
 246
 247     *dst = '\0';
 248     return (sdst);
 249 }
 250
 251 #endif
 252
 253 Char   *
 254 s_strchr(const Char *str, int ch)
 255 {
 256     do
 257         if (*str == ch)
 258             return ((Char *)(intptr_t)str);
 259     while (*str++);
 260     return (NULL);
 261 }
 262
 263 Char   *
 264 s_strrchr(const Char *str, int ch)
 265 {
 266     const Char *rstr;
 267
 268     rstr = NULL;
 269     do
 270         if (*str == ch)
 271             rstr = str;
 272     while (*str++);
 273     return ((Char *)(intptr_t)rstr);
 274 }
 275
 276 size_t
 277 s_strlen(const Char *str)
 278 {
 279     size_t n;
 280
 281     for (n = 0; *str++; n++)
 282         continue;
 283     return (n);
 284 }
 285
 286 int
 287 s_strcmp(const Char *str1, const Char *str2)
 288 {
 289     for (; *str1 && *str1 == *str2; str1++, str2++)
 290         continue;
 291     /*
 292      * The following case analysis is necessary so that characters which look
 293      * negative collate low against normal characters but high against the
 294      * end-of-string NUL.
 295      */
 296     if (*str1 == '\0' && *str2 == '\0')
 297         return (0);
 298     else if (*str1 == '\0')
 299         return (-1);
 300     else if (*str2 == '\0')
 301         return (1);
 302     else
 303         return (*str1 - *str2);
 304 }
 305
 306 int
 307 s_strncmp(const Char *str1, const Char *str2, size_t n)
 308 {
 309     if (n == 0)
 310         return (0);
 311     do {
 312         if (*str1 != *str2) {
 313             /*
 314              * The following case analysis is necessary so that characters
 315              * which look negative collate low against normal characters
 316              * but high against the end-of-string NUL.
 317              */
 318             if (*str1 == '\0')
 319                 return (-1);
 320             else if (*str2 == '\0')
 321                 return (1);
 322             else
 323                 return (*str1 - *str2);
 324         }
 325         if (*str1 == '\0')
 326             return(0);
 327         str1++, str2++;
 328     } while (--n != 0);
 329     return(0);
 330 }
 331 #endif /* not WIDE_STRINGS */
 332
 333 int
 334 s_strcasecmp(const Char *str1, const Char *str2)
 335 {
 336 #ifdef WIDE_STRINGS
 337     wchar_t l1 = 0, l2 = 0;
 338     for (; *str1 && ((*str1 == *str2 && (l1 = l2 = 0) == 0) ||
 339         (l1 = towlower(*str1)) == (l2 = towlower(*str2))); str1++, str2++)
 340         continue;
 341
 342 #else
 343     unsigned char c1, c2, l1 = 0, l2 = 0;
 344     for (; *str1 && ((*str1 == *str2 && (l1 = l2 = 0) == 0) ||
 345         ((c1 = (unsigned char)*str1) == *str1 &&
 346          (c2 = (unsigned char)*str2) == *str2 &&
 347         (l1 = tolower(c1)) == (l2 = tolower(c2)))); str1++, str2++)
 348         continue;
 349 #endif
 350     /*
 351      * The following case analysis is necessary so that characters which look
 352      * negative collate low against normal characters but high against the
 353      * end-of-string NUL.
 354      */
 355     if (*str1 == '\0' && *str2 == '\0')
 356         return (0);
 357     else if (*str1 == '\0')
 358         return (-1);
 359     else if (*str2 == '\0')
 360         return (1);
 361     else if (l1 == l2)  /* They are zero when they are equal */
 362         return (*str1 - *str2);
 363     else
 364         return (l1 - l2);
 365 }
 366
 367 Char   *
 368 s_strnsave(const Char *s, size_t len)
 369 {
 370     Char *n;
 371
 372     n = xmalloc((len + 1) * sizeof (*n));
 373     memcpy(n, s, len * sizeof (*n));
 374     n[len] = '\0';
 375     return n;
 376 }
 377
 378 Char   *
 379 s_strsave(const Char *s)
 380 {
 381     Char   *n;
 382     size_t size;
 383
 384     if (s == NULL)
 385         s = STRNULL;
 386     size = (Strlen(s) + 1) * sizeof(*n);
 387     n = xmalloc(size);
 388     memcpy(n, s, size);
 389     return (n);
 390 }
 391
 392 Char   *
 393 s_strspl(const Char *cp, const Char *dp)
 394 {
 395     Char *res, *ep;
 396     const Char *p, *q;
 397
 398     if (!cp)
 399         cp = STRNULL;
 400     if (!dp)
 401         dp = STRNULL;
 402     for (p = cp; *p++;)
 403         continue;
 404     for (q = dp; *q++;)
 405         continue;
 406     res = xmalloc(((p - cp) + (q - dp) - 1) * sizeof(Char));
 407     for (ep = res, q = cp; (*ep++ = *q++) != '\0';)
 408         continue;
 409     for (ep--, q = dp; (*ep++ = *q++) != '\0';)
 410         continue;
 411     return (res);
 412 }
 413
 414 Char   *
 415 s_strend(const Char *cp)
 416 {
 417     if (!cp)
 418         return ((Char *)(intptr_t) cp);
 419     while (*cp)
 420         cp++;
 421     return ((Char *)(intptr_t) cp);
 422 }
 423
 424 Char   *
 425 s_strstr(const Char *s, const Char *t)
 426 {
 427     do {
 428         const Char *ss = s;
 429         const Char *tt = t;
 430
 431         do
 432             if (*tt == '\0')
 433                 return ((Char *)(intptr_t) s);
 434         while (*ss++ == *tt++);
 435     } while (*s++ != '\0');
 436     return (NULL);
 437 }
 438
 439 #else /* !SHORT_STRINGS */
 440 char *
 441 caching_strip(const char *s)
 442 {
 443     static char *buf = NULL;
 444     static size_t buf_size = 0;
 445     size_t size;
 446
 447     if (s == NULL)
 448       return NULL;
 449     size = strlen(s) + 1;
 450     if (buf_size < size) {
 451         buf = xrealloc(buf, size);
 452         buf_size = size;
 453     }
 454     memcpy(buf, s, size);
 455     strip(buf);
 456     return buf;
 457 }
 458 #endif
 459
 460 char   *
 461 short2qstr(const Char *src)
 462 {
 463     static char *sdst = NULL;
 464     static size_t dstsize = 0;
 465     char *dst, *edst;
 466
 467     if (src == NULL)
 468         return (NULL);
 469
 470     if (sdst == NULL) {
 471         dstsize = MALLOC_INCR;
 472         sdst = xmalloc((dstsize + MALLOC_SURPLUS) * sizeof(char));
 473     }
 474     dst = sdst;
 475     edst = &dst[dstsize];
 476     while (*src) {
 477         if (*src & QUOTE) {
 478             *dst++ = '\\';
 479             if (dst == edst) {
 480                 dstsize += MALLOC_INCR;
 481                 sdst = xrealloc(sdst,
 482                                 (dstsize + MALLOC_SURPLUS) * sizeof(char));
 483                 edst = &sdst[dstsize];
 484                 dst = &edst[-MALLOC_INCR];
 485             }
 486         }
 487         dst += one_wctomb(dst, *src & CHAR);
 488         src++;
 489         if (dst >= edst) {
 490             ptrdiff_t i = dst - edst;
 491             dstsize += MALLOC_INCR;
 492             sdst = xrealloc(sdst, (dstsize + MALLOC_SURPLUS) * sizeof(char));
 493             edst = &sdst[dstsize];
 494             dst = &edst[-MALLOC_INCR + i];
 495         }
 496     }
 497     *dst = 0;
 498     return (sdst);
 499 }
 500
 501 struct blk_buf *
 502 bb_alloc()
 503 {
 504     return xcalloc(1, sizeof(struct blk_buf));
 505 }
 506
 507 static void
 508 bb_store(struct blk_buf *bb, Char *str)
 509 {
 510     if (bb->len == bb->size) { /* Keep space for terminating NULL */
 511         if (bb->size == 0)
 512             bb->size = 16; /* Arbitrary */
 513         else
 514             bb->size *= 2;
 515         bb->vec = xrealloc(bb->vec, bb->size * sizeof (*bb->vec));
 516     }
 517     bb->vec[bb->len] = str;
 518 }
 519
 520 void
 521 bb_append(struct blk_buf *bb, Char *str)
 522 {
 523     bb_store(bb, str);
 524     bb->len++;
 525 }
 526
 527 void
 528 bb_cleanup(void *xbb)
 529 {
 530     struct blk_buf *bb;
 531     size_t i;
 532
 533     bb = xbb;
 534     for (i = 0; i < bb->len; i++)
 535         xfree(bb->vec[i]);
 536     xfree(bb->vec);
 537 }
 538
 539 void
 540 bb_free(void *bb)
 541 {
 542     bb_cleanup(bb);
 543     xfree(bb);
 544 }
 545
 546 Char **
 547 bb_finish(struct blk_buf *bb)
 548 {
 549     bb_store(bb, NULL);
 550     return xrealloc(bb->vec, (bb->len + 1) * sizeof (*bb->vec));
 551 }
 552
 553 #define DO_STRBUF(STRBUF, CHAR, STRLEN)                         \
 554                                                                 \
 555 struct STRBUF *                                                 \
 556 STRBUF##_alloc(void)                                            \
 557 {                                                               \
 558     return xcalloc(1, sizeof(struct STRBUF));                   \
 559 }                                                               \
 560                                                                 \
 561 static void                                                     \
 562 STRBUF##_store1(struct STRBUF *buf, CHAR c)                     \
 563 {                                                               \
 564     if (buf->size == buf->len) {                                \
 565         if (buf->size == 0)                                     \
 566             buf->size = 64; /* Arbitrary */                     \
 567         else                                                    \
 568             buf->size *= 2;                                     \
 569         buf->s = xrealloc(buf->s, buf->size * sizeof(*buf->s)); \
 570     }                                                           \
 571     buf->s[buf->len] = c;                                       \
 572 }                                                               \
 573                                                                 \
 574 /* Like strbuf_append1(buf, '\0'), but don't advance len */     \
 575 void                                                            \
 576 STRBUF##_terminate(struct STRBUF *buf)                          \
 577 {                                                               \
 578     STRBUF##_store1(buf, '\0');                                 \
 579 }                                                               \
 580                                                                 \
 581 void                                                            \
 582 STRBUF##_append1(struct STRBUF *buf, CHAR c)                    \
 583 {                                                               \
 584     STRBUF##_store1(buf, c);                                    \
 585     buf->len++;                                                 \
 586 }                                                               \
 587                                                                 \
 588 void                                                            \
 589 STRBUF##_appendn(struct STRBUF *buf, const CHAR *s, size_t len) \
 590 {                                                               \
 591     if (buf->size < buf->len + len) {                           \
 592         if (buf->size == 0)                                     \
 593             buf->size = 64; /* Arbitrary */                     \
 594         while (buf->size < buf->len + len)                      \
 595             buf->size *= 2;                                     \
 596         buf->s = xrealloc(buf->s, buf->size * sizeof(*buf->s)); \
 597     }                                                           \
 598     memcpy(buf->s + buf->len, s, len * sizeof(*buf->s));        \
 599     buf->len += len;                                            \
 600 }                                                               \
 601                                                                 \
 602 void                                                            \
 603 STRBUF##_append(struct STRBUF *buf, const CHAR *s)              \
 604 {                                                               \
 605     STRBUF##_appendn(buf, s, STRLEN(s));                        \
 606 }                                                               \
 607                                                                 \
 608 CHAR *                                                          \
 609 STRBUF##_finish(struct STRBUF *buf)                             \
 610 {                                                               \
 611     STRBUF##_append1(buf, 0);                                   \
 612     return xrealloc(buf->s, buf->len * sizeof(*buf->s));        \
 613 }                                                               \
 614                                                                 \
 615 void                                                            \
 616 STRBUF##_cleanup(void *xbuf)                                    \
 617 {                                                               \
 618     struct STRBUF *buf;                                         \
 619                                                                 \
 620     buf = xbuf;                                                 \
 621     xfree(buf->s);                                              \
 622 }                                                               \
 623                                                                 \
 624 void                                                            \
 625 STRBUF##_free(void *xbuf)                                       \
 626 {                                                               \
 627     STRBUF##_cleanup(xbuf);                                     \
 628     xfree(xbuf);                                                \
 629 }                                                               \
 630                                                                 \
 631 const struct STRBUF STRBUF##_init /* = STRBUF##_INIT; */
 632
 633 DO_STRBUF(strbuf, char, strlen);
 634 DO_STRBUF(Strbuf, Char, Strlen);