home *** CD-ROM | disk | FTP | other *** search
/ The Fatted Calf / The Fatted Calf.iso / Unix / Shells / tcsh / Source / tc.str.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-02-21  |  8.7 KB  |  426 lines
  1. /* $Header: /u/christos/src/tcsh-6.03/RCS/tc.str.c,v 3.7 1992/08/09 00:13:36 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. All advertising materials mentioning features or use of this software
  19.  *    must display the following acknowledgement:
  20.  *    This product includes software developed by the University of
  21.  *    California, Berkeley and its contributors.
  22.  * 4. Neither the name of the University nor the names of its contributors
  23.  *    may be used to endorse or promote products derived from this software
  24.  *    without specific prior written permission.
  25.  *
  26.  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  27.  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  28.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  29.  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  30.  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  31.  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  32.  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  33.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  34.  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  35.  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  36.  * SUCH DAMAGE.
  37.  */
  38. #include "sh.h"
  39.  
  40. RCSID("$Id: tc.str.c,v 3.7 1992/08/09 00:13:36 christos Exp $")
  41.  
  42. #define MALLOC_INCR    128
  43.  
  44. #ifdef SHORT_STRINGS
  45. Char  **
  46. blk2short(src)
  47.     register char **src;
  48. {
  49.     size_t     n;
  50.     register Char **sdst, **dst;
  51.  
  52.     /*
  53.      * Count
  54.      */
  55.     for (n = 0; src[n] != NULL; n++)
  56.     continue;
  57.     sdst = dst = (Char **) xmalloc((size_t) ((n + 1) * sizeof(Char *)));
  58.  
  59.     for (; *src != NULL; src++)
  60.     *dst++ = SAVE(*src);
  61.     *dst = NULL;
  62.     return (sdst);
  63. }
  64.  
  65. char  **
  66. short2blk(src)
  67.     register Char **src;
  68. {
  69.     size_t     n;
  70.     register char **sdst, **dst;
  71.  
  72.     /*
  73.      * Count
  74.      */
  75.     for (n = 0; src[n] != NULL; n++)
  76.     continue;
  77.     sdst = dst = (char **) xmalloc((size_t) ((n + 1) * sizeof(char *)));
  78.  
  79.     for (; *src != NULL; src++)
  80.     *dst++ = strsave(short2str(*src));
  81.     *dst = NULL;
  82.     return (sdst);
  83. }
  84.  
  85. Char   *
  86. str2short(src)
  87.     register const char *src;
  88. {
  89.     static Char *sdst;
  90.     static size_t dstsize = 0;
  91.     register Char *dst, *edst;
  92.  
  93.     if (src == NULL)
  94.     return (NULL);
  95.  
  96.     if (sdst == (NULL)) {
  97.     dstsize = MALLOC_INCR;
  98.     sdst = (Char *) xmalloc((size_t) (dstsize * sizeof(Char)));
  99.     }
  100.  
  101.     dst = sdst;
  102.     edst = &dst[dstsize];
  103.     while ((unsigned char) *src) {
  104.     *dst++ = (Char) ((unsigned char) *src++);
  105.     if (dst == edst) {
  106.         dstsize += MALLOC_INCR;
  107.         sdst = (Char *) xrealloc((ptr_t) sdst,
  108.                      (size_t) (dstsize * sizeof(Char)));
  109.         edst = &sdst[dstsize];
  110.         dst = &edst[-MALLOC_INCR];
  111.     }
  112.     }
  113.     *dst = 0;
  114.     return (sdst);
  115. }
  116.  
  117. char   *
  118. short2str(src)
  119.     register const Char *src;
  120. {
  121.     static char *sdst = NULL;
  122.     static size_t dstsize = 0;
  123.     register char *dst, *edst;
  124.  
  125.     if (src == NULL)
  126.     return (NULL);
  127.  
  128.     if (sdst == NULL) {
  129.     dstsize = MALLOC_INCR;
  130.     sdst = (char *) xmalloc((size_t) (dstsize * sizeof(char)));
  131.     }
  132.     dst = sdst;
  133.     edst = &dst[dstsize];
  134.     while (*src) {
  135.     *dst++ = (char) *src++;
  136.     if (dst == edst) {
  137.         dstsize += MALLOC_INCR;
  138.         sdst = (char *) xrealloc((ptr_t) sdst,
  139.                      (size_t) (dstsize * sizeof(char)));
  140.         edst = &sdst[dstsize];
  141.         dst = &edst[-MALLOC_INCR];
  142.     }
  143.     }
  144.     *dst = 0;
  145.     return (sdst);
  146. }
  147.  
  148. Char   *
  149. s_strcpy(dst, src)
  150.     register Char *dst;
  151.     register const Char *src;
  152. {
  153.     register Char *sdst;
  154.  
  155.     sdst = dst;
  156.     while ((*dst++ = *src++) != '\0')
  157.     continue;
  158.     return (sdst);
  159. }
  160.  
  161. Char   *
  162. s_strncpy(dst, src, n)
  163.     register Char *dst;
  164.     register const Char *src;
  165.     register size_t n;
  166. {
  167.     register Char *sdst;
  168.  
  169.     if (n == 0)
  170.     return(dst);
  171.  
  172.     sdst = dst;
  173.     do 
  174.     if ((*dst++ = *src++) == '\0') {
  175.         while (--n != 0)
  176.         *dst++ = '\0';
  177.         return(sdst);
  178.     }
  179.     while (--n != 0);
  180.     return (sdst);
  181. }
  182.  
  183. Char   *
  184. s_strcat(dst, src)
  185.     register Char *dst;
  186.     register const Char *src;
  187. {
  188.     register short *sdst;
  189.  
  190.     sdst = dst;
  191.     while (*dst++)
  192.     continue;
  193.     --dst;
  194.     while ((*dst++ = *src++) != '\0')
  195.     continue;
  196.     return (sdst);
  197. }
  198.  
  199. #ifdef NOTUSED
  200. Char   *
  201. s_strncat(dst, src, n)
  202.     register Char *dst;
  203.     register const Char *src;
  204.     register size_t n;
  205. {
  206.     register Char *sdst;
  207.  
  208.     if (n == 0) 
  209.     return (dst);
  210.  
  211.     sdst = dst;
  212.  
  213.     while (*dst++)
  214.     continue;
  215.     --dst;
  216.  
  217.     do 
  218.     if ((*dst++ = *src++) == '\0')
  219.         return(sdst);
  220.     while (--n != 0)
  221.     continue;
  222.  
  223.     *dst = '\0';
  224.     return (sdst);
  225. }
  226.  
  227. #endif
  228.  
  229. Char   *
  230. s_strchr(str, ch)
  231.     register const Char *str;
  232.     int ch;
  233. {
  234.     do
  235.     if (*str == ch)
  236.         return ((Char *) str);
  237.     while (*str++);
  238.     return (NULL);
  239. }
  240.  
  241. Char   *
  242. s_strrchr(str, ch)
  243.     register const Char *str;
  244.     int ch;
  245. {
  246.     register const Char *rstr;
  247.  
  248.     rstr = NULL;
  249.     do
  250.     if (*str == ch)
  251.         rstr = str;
  252.     while (*str++);
  253.     return ((Char *) rstr);
  254. }
  255.  
  256. size_t
  257. s_strlen(str)
  258.     register const Char *str;
  259. {
  260.     register size_t n;
  261.  
  262.     for (n = 0; *str++; n++)
  263.     continue;
  264.     return (n);
  265. }
  266.  
  267. int
  268. s_strcmp(str1, str2)
  269.     register const Char *str1, *str2;
  270. {
  271.     for (; *str1 && *str1 == *str2; str1++, str2++)
  272.     continue;
  273.     /*
  274.      * The following case analysis is necessary so that characters which look
  275.      * negative collate low against normal characters but high against the
  276.      * end-of-string NUL.
  277.      */
  278.     if (*str1 == '\0' && *str2 == '\0')
  279.     return (0);
  280.     else if (*str1 == '\0')
  281.     return (-1);
  282.     else if (*str2 == '\0')
  283.     return (1);
  284.     else
  285.     return (*str1 - *str2);
  286. }
  287.  
  288. int
  289. s_strncmp(str1, str2, n)
  290.     register const Char *str1, *str2;
  291.     register size_t n;
  292. {
  293.     if (n == 0)
  294.     return (0);
  295.     do {
  296.     if (*str1 != *str2) {
  297.         /*
  298.          * The following case analysis is necessary so that characters 
  299.          * which look negative collate low against normal characters
  300.          * but high against the end-of-string NUL.
  301.          */
  302.         if (*str1 == '\0')
  303.         return (-1);
  304.         else if (*str2 == '\0')
  305.         return (1);
  306.         else
  307.         return (*str1 - *str2);
  308.     }
  309.         if (*str1 == '\0')
  310.         return(0);
  311.     str1++, str2++;
  312.     } while (--n != 0);
  313.     return(0);
  314. }
  315.  
  316. Char   *
  317. s_strsave(s)
  318.     register const Char *s;
  319. {
  320.     Char   *n;
  321.     register Char *p;
  322.  
  323.     if (s == 0)
  324.     s = STRNULL;
  325.     for (p = (Char *) s; *p++;)
  326.     continue;
  327.     n = p = (Char *) xmalloc((size_t) ((p - s) * sizeof(Char)));
  328.     while ((*p++ = *s++) != '\0')
  329.     continue;
  330.     return (n);
  331. }
  332.  
  333. Char   *
  334. s_strspl(cp, dp)
  335.     const Char   *cp, *dp;
  336. {
  337.     Char   *ep;
  338.     register Char *p, *q;
  339.  
  340.     if (!cp)
  341.     cp = STRNULL;
  342.     if (!dp)
  343.     dp = STRNULL;
  344.     for (p = (Char *) cp; *p++;)
  345.     continue;
  346.     for (q = (Char *) dp; *q++;)
  347.     continue;
  348.     ep = (Char *) xmalloc((size_t)
  349.               (((p - cp) + (q - dp) - 1) * sizeof(Char)));
  350.     for (p = ep, q = (Char*) cp; (*p++ = *q++) != '\0';)
  351.     continue;
  352.     for (p--, q = (Char *) dp; (*p++ = *q++) != '\0';)
  353.     continue;
  354.     return (ep);
  355. }
  356.  
  357. Char   *
  358. s_strend(cp)
  359.     register const Char *cp;
  360. {
  361.     if (!cp)
  362.     return ((Char *) cp);
  363.     while (*cp)
  364.     cp++;
  365.     return ((Char *) cp);
  366. }
  367.  
  368. Char   *
  369. s_strstr(s, t)
  370.     register const Char *s, *t;
  371. {
  372.     do {
  373.     register const Char *ss = s;
  374.     register const Char *tt = t;
  375.  
  376.     do
  377.         if (*tt == '\0')
  378.         return ((Char *) s);
  379.     while (*ss++ == *tt++);
  380.     } while (*s++ != '\0');
  381.     return (NULL);
  382. }
  383.  
  384. #endif                /* SHORT_STRINGS */
  385.  
  386. char   *
  387. short2qstr(src)
  388.     register const Char *src;
  389. {
  390.     static char *sdst = NULL;
  391.     static size_t dstsize = 0;
  392.     register char *dst, *edst;
  393.  
  394.     if (src == NULL)
  395.     return (NULL);
  396.  
  397.     if (sdst == NULL) {
  398.     dstsize = MALLOC_INCR;
  399.     sdst = (char *) xmalloc((size_t) (dstsize * sizeof(char)));
  400.     }
  401.     dst = sdst;
  402.     edst = &dst[dstsize];
  403.     while (*src) {
  404.     if (*src & QUOTE) {
  405.         *dst++ = '\\';
  406.         if (dst == edst) {
  407.         dstsize += MALLOC_INCR;
  408.         sdst = (char *) xrealloc((ptr_t) sdst,
  409.                      (size_t) (dstsize * sizeof(char)));
  410.         edst = &sdst[dstsize];
  411.         dst = &edst[-MALLOC_INCR];
  412.         }
  413.     }
  414.     *dst++ = (char) *src++;
  415.     if (dst == edst) {
  416.         dstsize += MALLOC_INCR;
  417.         sdst = (char *) xrealloc((ptr_t) sdst,
  418.                      (size_t) (dstsize * sizeof(char)));
  419.         edst = &sdst[dstsize];
  420.         dst = &edst[-MALLOC_INCR];
  421.     }
  422.     }
  423.     *dst = 0;
  424.     return (sdst);
  425. }
  426.