contrib/tcsh/tc.str.c

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