usr/src/cmd/tr/str.c

   1 /*
   2  * Copyright (c) 1991, 1993
   3  *      The Regents of the University of California.  All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  * 3. All advertising materials mentioning features or use of this software
  14  *    must display the following acknowledgement:
  15  *      This product includes software developed by the University of
  16  *      California, Berkeley and its contributors.
  17  * 4. 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
  34 #include <sys/types.h>
  35
  36 #include <ctype.h>
  37 #include <err.h>
  38 #include <errno.h>
  39 #include <stddef.h>
  40 #include <stdio.h>
  41 #include <stdlib.h>
  42 #include <string.h>
  43 #include <strings.h>
  44 #include <wchar.h>
  45 #include <wctype.h>
  46
  47 #include "extern.h"
  48
  49 static int      backslash(STR *, int *);
  50 static int      bracket(STR *);
  51 static void     genclass(STR *);
  52 static void     genequiv(STR *);
  53 static int      genrange(STR *, int);
  54 static void     genseq(STR *);
  55
  56 wint_t
  57 next(s)
  58         STR *s;
  59 {
  60         int is_octal;
  61         wint_t ch;
  62         wchar_t wch;
  63         size_t clen;
  64
  65         switch (s->state) {
  66         case EOS:
  67                 return (0);
  68         case INFINITE:
  69                 return (1);
  70         case NORMAL:
  71                 switch (*s->str) {
  72                 case '\0':
  73                         s->state = EOS;
  74                         return (0);
  75                 case '\\':
  76                         s->lastch = backslash(s, &is_octal);
  77                         break;
  78                 case '[':
  79                         if (bracket(s))
  80                                 return (next(s));
  81                         /* FALLTHROUGH */
  82                 default:
  83                         clen = mbrtowc(&wch, s->str, MB_LEN_MAX, NULL);
  84                         if (clen == (size_t)-1 || clen == (size_t)-2 ||
  85                             clen == 0)
  86                                 errx(1, "illegal sequence");
  87                         is_octal = 0;
  88                         s->lastch = wch;
  89                         s->str += clen;
  90                         break;
  91                 }
  92
  93                 /* We can start a range at any time. */
  94                 if (s->str[0] == '-' && genrange(s, is_octal))
  95                         return (next(s));
  96                 return (1);
  97         case RANGE:
  98                 if (s->cnt-- == 0) {
  99                         s->state = NORMAL;
 100                         return (next(s));
 101                 }
 102                 ++s->lastch;
 103                 return (1);
 104         case SEQUENCE:
 105                 if (s->cnt-- == 0) {
 106                         s->state = NORMAL;
 107                         return (next(s));
 108                 }
 109                 return (1);
 110         case CCLASS:
 111         case CCLASS_UPPER:
 112         case CCLASS_LOWER:
 113                 s->cnt++;
 114                 ch = nextwctype(s->lastch, s->cclass);
 115                 if (ch == -1) {
 116                         s->state = NORMAL;
 117                         return (next(s));
 118                 }
 119                 s->lastch = ch;
 120                 return (1);
 121         case SET:
 122                 if ((ch = s->set[s->cnt++]) == OOBCH) {
 123                         s->state = NORMAL;
 124                         return (next(s));
 125                 }
 126                 s->lastch = ch;
 127                 return (1);
 128         default:
 129                 return (0);
 130         }
 131         /* NOTREACHED */
 132 }
 133
 134 static int
 135 bracket(s)
 136         STR *s;
 137 {
 138         char *p;
 139
 140         switch (s->str[1]) {
 141         case ':':                               /* "[:class:]" */
 142                 if ((p = strchr(s->str + 2, ']')) == NULL)
 143                         return (0);
 144                 if (*(p - 1) != ':' || p - s->str < 4)
 145                         goto repeat;
 146                 *(p - 1) = '\0';
 147                 s->str += 2;
 148                 genclass(s);
 149                 s->str = p + 1;
 150                 return (1);
 151         case '=':                               /* "[=equiv=]" */
 152                 if ((p = strchr(s->str + 3, ']')) == NULL)
 153                         return (0);
 154                 if (*(p - 1) != '=' || p - s->str < 4)
 155                         goto repeat;
 156                 s->str += 2;
 157                 genequiv(s);
 158                 return (1);
 159         default:                                /* "[\###*n]" or "[#*n]" */
 160         repeat:
 161                 if ((p = strpbrk(s->str + 2, "*]")) == NULL)
 162                         return (0);
 163                 if (p[0] != '*' || index(p, ']') == NULL)
 164                         return (0);
 165                 s->str += 1;
 166                 genseq(s);
 167                 return (1);
 168         }
 169         /* NOTREACHED */
 170 }
 171
 172 static void
 173 genclass(s)
 174         STR *s;
 175 {
 176
 177         if ((s->cclass = wctype(s->str)) == 0)
 178                 errx(1, "unknown class %s", s->str);
 179         s->cnt = 0;
 180         s->lastch = -1;         /* incremented before check in next() */
 181         if (strcmp(s->str, "upper") == 0)
 182                 s->state = CCLASS_UPPER;
 183         else if (strcmp(s->str, "lower") == 0)
 184                 s->state = CCLASS_LOWER;
 185         else
 186                 s->state = CCLASS;
 187 }
 188
 189 static void
 190 genequiv(s)
 191         STR *s;
 192 {
 193         int i, p, pri;
 194         char src[2], dst[3];
 195         size_t clen;
 196         wchar_t wc;
 197
 198         if (*s->str == '\\') {
 199                 s->equiv[0] = backslash(s, NULL);
 200                 if (*s->str != '=')
 201                         errx(1, "misplaced equivalence equals sign");
 202                 s->str += 2;
 203         } else {
 204                 clen = mbrtowc(&wc, s->str, MB_LEN_MAX, NULL);
 205                 if (clen == (size_t)-1 || clen == (size_t)-2 || clen == 0) {
 206                         errno = EILSEQ;
 207                         err(1, NULL);
 208                 }
 209                 s->equiv[0] = wc;
 210                 if (s->str[clen] != '=')
 211                         errx(1, "misplaced equivalence equals sign");
 212                 s->str += clen + 2;
 213         }
 214
 215         /*
 216          * Calculate the set of all characters in the same equivalence class
 217          * as the specified character (they will have the same primary
 218          * collation weights).
 219          * XXX Knows too much about how strxfrm() is implemented. Assumes
 220          * it fills the string with primary collation weight bytes. Only one-
 221          * to-one mappings are supported.
 222          * XXX Equivalence classes not supported in multibyte locales.
 223          */
 224         src[0] = (char)s->equiv[0];
 225         src[1] = '\0';
 226         if (MB_CUR_MAX == 1 && strxfrm(dst, src, sizeof (dst)) == 1) {
 227                 pri = (unsigned char)*dst;
 228                 for (p = 1, i = 1; i < NCHARS_SB; i++) {
 229                         *src = i;
 230                         if (strxfrm(dst, src, sizeof (dst)) == 1 && pri &&
 231                             pri == (unsigned char)*dst)
 232                                 s->equiv[p++] = i;
 233                 }
 234                 s->equiv[p] = OOBCH;
 235         }
 236
 237         s->cnt = 0;
 238         s->state = SET;
 239         s->set = s->equiv;
 240 }
 241
 242 static int
 243 genrange(STR *s, int was_octal)
 244 {
 245         int stopval, octal;
 246         char *savestart;
 247         int n, cnt, *p;
 248         size_t clen;
 249         wchar_t wc;
 250
 251         octal = 0;
 252         savestart = s->str;
 253         if (*++s->str == '\\')
 254                 stopval = backslash(s, &octal);
 255         else {
 256                 clen = mbrtowc(&wc, s->str, MB_LEN_MAX, NULL);
 257                 if (clen == (size_t)-1 || clen == (size_t)-2) {
 258                         errno = EILSEQ;
 259                         err(1, NULL);
 260                 }
 261                 stopval = wc;
 262                 s->str += clen;
 263         }
 264         /*
 265          * XXX Characters are not ordered according to collating sequence in
 266          * multibyte locales.
 267          */
 268         if (octal || was_octal || MB_CUR_MAX > 1) {
 269                 if (stopval < s->lastch) {
 270                         s->str = savestart;
 271                         return (0);
 272                 }
 273                 s->cnt = stopval - s->lastch + 1;
 274                 s->state = RANGE;
 275                 --s->lastch;
 276                 return (1);
 277         }
 278         if (charcoll((const void *)&stopval, (const void *)&(s->lastch)) < 0) {
 279                 s->str = savestart;
 280                 return (0);
 281         }
 282         p = malloc((NCHARS_SB + 1) * sizeof (int));
 283         if ((s->set = (void *)p) == NULL)
 284                 err(1, "genrange() malloc");
 285         for (cnt = 0; cnt < NCHARS_SB; cnt++)
 286                 if (charcoll((const void *)&cnt, (const void *)&(s->lastch)) >=
 287                     0 &&
 288                     charcoll((const void *)&cnt, (const void *)&stopval) <= 0)
 289                         *p++ = cnt;
 290         *p = OOBCH;
 291         n = (int *)p - (int *)s->set;
 292
 293         s->cnt = 0;
 294         s->state = SET;
 295         if (n > 1)
 296                 qsort(s->set, n, sizeof (*(s->set)), charcoll);
 297         return (1);
 298 }
 299
 300 static void
 301 genseq(s)
 302         STR *s;
 303 {
 304         char *ep;
 305         wchar_t wc;
 306         size_t clen;
 307
 308         if (s->which == STRING1)
 309                 errx(1, "sequences only valid in string2");
 310
 311         if (*s->str == '\\')
 312                 s->lastch = backslash(s, NULL);
 313         else {
 314                 clen = mbrtowc(&wc, s->str, MB_LEN_MAX, NULL);
 315                 if (clen == (size_t)-1 || clen == (size_t)-2) {
 316                         errno = EILSEQ;
 317                         err(1, NULL);
 318                 }
 319                 s->lastch = wc;
 320                 s->str += clen;
 321         }
 322         if (*s->str != '*')
 323                 errx(1, "misplaced sequence asterisk");
 324
 325         switch (*++s->str) {
 326         case '\\':
 327                 s->cnt = backslash(s, NULL);
 328                 break;
 329         case ']':
 330                 s->cnt = 0;
 331                 ++s->str;
 332                 break;
 333         default:
 334                 if (isdigit((uchar_t)*s->str)) {
 335                         s->cnt = strtol(s->str, &ep, 0);
 336                         if (*ep == ']') {
 337                                 s->str = ep + 1;
 338                                 break;
 339                         }
 340                 }
 341                 errx(1, "illegal sequence count");
 342                 /* NOTREACHED */
 343         }
 344
 345         s->state = s->cnt ? SEQUENCE : INFINITE;
 346 }
 347
 348 /*
 349  * Translate \??? into a character.  Up to 3 octal digits, if no digits either
 350  * an escape code or a literal character.
 351  */
 352 static int
 353 backslash(STR *s, int *is_octal)
 354 {
 355         int ch, cnt, val;
 356
 357         if (is_octal != NULL)
 358                 *is_octal = 0;
 359         for (cnt = val = 0; ; ) {
 360                 ch = (uchar_t)*++s->str;
 361                 if (!isdigit(ch) || ch > '7')
 362                         break;
 363                 val = val * 8 + ch - '0';
 364                 if (++cnt == 3) {
 365                         ++s->str;
 366                         break;
 367                 }
 368         }
 369         if (cnt) {
 370                 if (is_octal != NULL)
 371                         *is_octal = 1;
 372                 return (val);
 373         }
 374         if (ch != '\0')
 375                 ++s->str;
 376         switch (ch) {
 377         case 'a':                       /* escape characters */
 378                 return ('\7');
 379         case 'b':
 380                 return ('\b');
 381         case 'f':
 382                 return ('\f');
 383         case 'n':
 384                 return ('\n');
 385         case 'r':
 386                 return ('\r');
 387         case 't':
 388                 return ('\t');
 389         case 'v':
 390                 return ('\13');
 391         case '\0':                      /*  \" -> \ */
 392                 s->state = EOS;
 393                 return ('\\');
 394         default:                        /* \x" -> x */
 395                 return (ch);
 396         }
 397 }