src/mystring.c

   1 /*-
   2  * Copyright (c) 1991, 1993
   3  *      The Regents of the University of California.  All rights reserved.
   4  * Copyright (c) 1997-2005
   5  *      Herbert Xu <herbert@gondor.apana.org.au>.  All rights reserved.
   6  *
   7  * This code is derived from software contributed to Berkeley by
   8  * Kenneth Almquist.
   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
  35 /*
  36  * String functions.
  37  *
  38  *      equal(s1, s2)           Return true if strings are equal.
  39  *      scopy(from, to)         Copy a string.
  40  *      scopyn(from, to, n)     Like scopy, but checks for overflow.
  41  *      number(s)               Convert a string of digits to an integer.
  42  *      is_number(s)            Return true if s is a string of digits.
  43  */
  44
  45 #include <ctype.h>
  46 #include <errno.h>
  47 #include <inttypes.h>
  48 #include <limits.h>
  49 #include <inttypes.h>
  50 #include <stdlib.h>
  51 #include "shell.h"
  52 #include "syntax.h"
  53 #include "error.h"
  54 #include "mystring.h"
  55 #include "memalloc.h"
  56 #include "parser.h"
  57 #include "system.h"
  58
  59
  60 char nullstr[1];                /* zero length string */
  61 const char spcstr[] = " ";
  62 const char snlfmt[] = "%s\n";
  63 const char dolatstr[] = { CTLQUOTEMARK, CTLVAR, VSNORMAL | VSBIT, '@', '=',
  64                           CTLQUOTEMARK, '\0' };
  65 const char cqchars[] = {
  66 #ifdef HAVE_FNMATCH
  67         '^',
  68 #endif
  69         CTLESC, CTLQUOTEMARK, 0
  70 };
  71 const char illnum[] = "Illegal number: %s";
  72 const char homestr[] = "HOME";
  73
  74 /*
  75  * equal - #defined in mystring.h
  76  */
  77
  78 /*
  79  * scopy - #defined in mystring.h
  80  */
  81
  82
  83 #if 0
  84 /*
  85  * scopyn - copy a string from "from" to "to", truncating the string
  86  *              if necessary.  "To" is always nul terminated, even if
  87  *              truncation is performed.  "Size" is the size of "to".
  88  */
  89
  90 void
  91 scopyn(const char *from, char *to, int size)
  92 {
  93
  94         while (--size > 0) {
  95                 if ((*to++ = *from++) == '\0')
  96                         return;
  97         }
  98         *to = '\0';
  99 }
 100 #endif
 101
 102
 103 /*
 104  * prefix -- see if pfx is a prefix of string.
 105  */
 106
 107 char *
 108 prefix(const char *string, const char *pfx)
 109 {
 110         while (*pfx) {
 111                 if (*pfx++ != *string++)
 112                         return 0;
 113         }
 114         return (char *) string;
 115 }
 116
 117 void badnum(const char *s)
 118 {
 119         sh_error(illnum, s);
 120 }
 121
 122 /*
 123  * Convert a string into an integer of type intmax_t.  Alow trailing spaces.
 124  */
 125 intmax_t atomax(const char *s, int base)
 126 {
 127         char *p;
 128         intmax_t r;
 129
 130         errno = 0;
 131         r = strtoimax(s, &p, base);
 132
 133         if (errno == ERANGE)
 134                 badnum(s);
 135
 136         /*
 137          * Disallow completely blank strings in non-arithmetic (base != 0)
 138          * contexts.
 139          */
 140         if (p == s && base)
 141                 badnum(s);
 142
 143         while (isspace((unsigned char)*p))
 144               p++;
 145
 146         if (*p)
 147                 badnum(s);
 148
 149         return r;
 150 }
 151
 152 intmax_t atomax10(const char *s)
 153 {
 154         return atomax(s, 10);
 155 }
 156
 157 /*
 158  * Convert a string of digits to an integer, printing an error message on
 159  * failure.
 160  */
 161
 162 int
 163 number(const char *s)
 164 {
 165         intmax_t n = atomax10(s);
 166
 167         if (n < 0 || n > INT_MAX)
 168                 badnum(s);
 169
 170         return n;
 171 }
 172
 173
 174
 175 /*
 176  * Check for a valid number.  This should be elsewhere.
 177  */
 178
 179 int
 180 is_number(const char *p)
 181 {
 182         do {
 183                 if (! is_digit(*p))
 184                         return 0;
 185         } while (*++p != '\0');
 186         return 1;
 187 }
 188
 189
 190 /*
 191  * Produce a possibly single quoted string suitable as input to the shell.
 192  * The return string is allocated on the stack.
 193  */
 194
 195 char *
 196 single_quote(const char *s) {
 197         char *p;
 198
 199         STARTSTACKSTR(p);
 200
 201         do {
 202                 char *q;
 203                 size_t len;
 204
 205                 len = strchrnul(s, '\'') - s;
 206
 207                 q = p = makestrspace(len + 3, p);
 208
 209                 *q++ = '\'';
 210                 q = mempcpy(q, s, len);
 211                 *q++ = '\'';
 212                 s += len;
 213
 214                 STADJUST(q - p, p);
 215
 216                 len = strspn(s, "'");
 217                 if (!len)
 218                         break;
 219
 220                 q = p = makestrspace(len + 3, p);
 221
 222                 *q++ = '"';
 223                 q = mempcpy(q, s, len);
 224                 *q++ = '"';
 225                 s += len;
 226
 227                 STADJUST(q - p, p);
 228         } while (*s);
 229
 230         USTPUTC(0, p);
 231
 232         return stackblock();
 233 }
 234
 235 /*
 236  * Like strdup but works with the ash stack.
 237  */
 238
 239 char *
 240 sstrdup(const char *p)
 241 {
 242         size_t len = strlen(p) + 1;
 243         return memcpy(stalloc(len), p, len);
 244 }
 245
 246 /*
 247  * Wrapper around strcmp for qsort/bsearch/...
 248  */
 249 int
 250 pstrcmp(const void *a, const void *b)
 251 {
 252         return strcmp(*(const char *const *) a, *(const char *const *) b);
 253 }
 254
 255 /*
 256  * Find a string is in a sorted array.
 257  */
 258 const char *const *
 259 findstring(const char *s, const char *const *array, size_t nmemb)
 260 {
 261         return bsearch(&s, array, nmemb, sizeof(const char *), pstrcmp);
 262 }