usr/src/lib/libeti/form/common/regex.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License, Version 1.0 only
   6  * (the "License").  You may not use this file except in compliance
   7  * with the License.
   8  *
   9  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
  10  * or http://www.opensolaris.org/os/licensing.
  11  * See the License for the specific language governing permissions
  12  * and limitations under the License.
  13  *
  14  * When distributing Covered Code, include this CDDL HEADER in each
  15  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  16  * If applicable, add the following below this CDDL HEADER, with the
  17  * fields enclosed by brackets "[]" replaced with your own identifying
  18  * information: Portions Copyright [yyyy] [name of copyright owner]
  19  *
  20  * CDDL HEADER END
  21  */
  22 /*      Copyright (c) 1988 AT&T */
  23 /*        All Rights Reserved   */
  24
  25
  26 /*
  27  * Copyright 2004 Sun Microsystems, Inc.  All rights reserved.
  28  * Use is subject to license terms.
  29  */
  30
  31 #pragma ident   "%Z%%M% %I%     %E% SMI"
  32
  33 /*LINTLIBRARY*/
  34
  35 #include <sys/types.h>
  36 #include <stdlib.h>
  37 #include <unistd.h>
  38 #include "utility.h"
  39
  40 /*
  41  *      this code was taken from REGCMP(3X)
  42  */
  43 /*VARARGS*/
  44 /*ARGSUSED*/
  45
  46 #define SSIZE   50
  47 #define TGRP    48
  48 #define A256    01
  49 #define A512    02
  50 #define A768    03
  51 #define NBRA    10
  52 #define CIRCFL  32
  53
  54 #define CBRA    60
  55 #define GRP     40
  56 #define SGRP    56
  57 #define PGRP    68
  58 #define EGRP    44
  59 #define RNGE    03
  60 #define CCHR    20
  61 #define CDOT    64
  62 #define CCL     24
  63 #define NCCL    8
  64 #define CDOL    28
  65 #define FCEOF   52 /* This was originally CEOF but it clashes with the header */
  66                         /* definition so it was changed to FCEOF */
  67 #define CKET    12
  68
  69 #define STAR    01
  70 #define PLUS    02
  71 #define MINUS   16
  72
  73 char    *__braslist[NBRA];
  74 char    *__braelist[NBRA];
  75 char    *__loc1;
  76 intptr_t        __bravar[NBRA];
  77 intptr_t        *__st[SSIZE + 1];
  78 intptr_t        *__eptr_, *__lptr_;
  79 intptr_t        __cflg;
  80
  81 char *
  82 libform_regex(char *addrc, char *addrl, char *a1)
  83 {
  84         intptr_t cur, in;
  85         intptr_t *adx;
  86         char *p1, *p2;
  87
  88         for (in = 0; in < NBRA; in++) {
  89                 __braslist[in] = 0;
  90                 __bravar[in] = -1;
  91         }
  92         __cflg = 0;
  93         cur = __execute(addrc, addrl);
  94         adx = (intptr_t *)&a1;
  95         for (in = 0; in < NBRA; in++) {
  96                 if (((p1 = __braslist[in]) != 0) && (__bravar[in] >= 0)) {
  97                         p2 = (char *)adx[__bravar[in]];
  98                         while (p1 < __braelist[in]) *p2++ = *p1++;
  99                         *p2 = '\0';
 100                 }
 101         }
 102         if (!__cflg)
 103                 return ((addrl == (char *)cur) ? (char *)0 : (char *)cur);
 104         else
 105                 return ((char *)cur);
 106 }
 107
 108 intptr_t
 109 __execute(char *addrc, char *addrl)
 110 {
 111         char *p1, *p2, c;
 112         intptr_t i;
 113
 114         p1 = addrl;
 115         p2 = addrc;
 116         __eptr_ = (intptr_t *)&__st[SSIZE];
 117         __lptr_ = (intptr_t *)&__st[0];
 118         if (*p2 == CIRCFL) {
 119                 __loc1 = p1;
 120                 return ((i = __advance(p1, ++p2)) ? i : (intptr_t)addrl);
 121         }
 122         /* fast check for first character */
 123         if (*p2 == CCHR) {
 124                 c = p2[1];
 125                 do {
 126                         if (*p1 != c)
 127                                 continue;
 128                         __eptr_ = (intptr_t *)&__st[SSIZE];
 129                         __lptr_ = (intptr_t *)&__st[0];
 130                         if (i = __advance(p1, p2))  {
 131                                 __loc1 = p1;
 132                                 return (i);
 133                         }
 134                 } while (*p1++);
 135                 return ((intptr_t)addrl);
 136         }
 137         /* regular algorithm */
 138         do {
 139         __eptr_ = (intptr_t *)&__st[SSIZE];
 140         __lptr_ = (intptr_t *)&__st[0];
 141                 if (i = __advance(p1, p2))  {
 142                         __loc1 = p1;
 143                         return (i);
 144                 }
 145         } while (*p1++);
 146         return ((intptr_t)addrl);
 147 }
 148
 149 intptr_t
 150 __advance(char *alp, char *aep)
 151 {
 152         char *lp, *ep, *curlp;
 153         char *sep, *dp;
 154         intptr_t i, lcnt, dcnt, gflg;
 155
 156         lp = alp;
 157         ep = aep;
 158         gflg = 0;
 159         for (; ; ) {
 160                 switch (*ep++) {
 161
 162         case CCHR:
 163                 if (*ep++ == *lp++)
 164                         continue;
 165                 return (0);
 166
 167         case EGRP|RNGE:
 168                 return ((intptr_t)lp);
 169         case EGRP:
 170         case GRP:
 171                 ep++;
 172                 continue;
 173
 174         case EGRP|STAR:
 175                 (void) __xpop(0);
 176         case EGRP|PLUS:
 177                 (void) __xpush(0, ++ep);
 178                 return ((intptr_t)lp);
 179
 180         case CDOT:
 181                 if (*lp++)
 182                         continue;
 183                 return (0);
 184
 185         case CDOL:
 186                 if (*lp == 0)
 187                         continue;
 188                 lp++;
 189                 return (0);
 190
 191         case FCEOF:
 192                 __cflg = 1;
 193                 return ((intptr_t)lp);
 194
 195         case TGRP:
 196         case TGRP|A768:
 197         case TGRP|A512:
 198         case TGRP|A256:
 199                 i = (((ep[-1] & 03) << 8) + (*ep) & 0377);
 200                 ep++;
 201                 (void) __xpush(0, ep + i + 2);
 202                 (void) __xpush(0, ++ep);
 203                 (void) __xpush(0, ++ep);
 204                 gflg = 1;
 205                 (void) __getrnge(&lcnt, &dcnt, &ep[i]);
 206                 while (lcnt--)
 207                         if (!(lp = (char *)__advance(lp, ep)))
 208                                 return (0);
 209                 (void) __xpush(1, curlp = lp);
 210                 while (dcnt--)
 211                         if (!(dp = (char *)__advance(lp, ep))) break;
 212                         else
 213                                 (void) __xpush(1, lp = dp);
 214                 ep = (char *)__xpop(0);
 215                 goto star;
 216         case CCHR|RNGE:
 217                 sep = ep++;
 218                 (void) __getrnge(&lcnt, &dcnt, ep);
 219                 while (lcnt--)
 220                         if (*lp++ != *sep)
 221                                 return (0);
 222                 curlp = lp;
 223                 while (dcnt--)
 224                         if (*lp++ != *sep) break;
 225                 if (dcnt < 0) lp++;
 226                 ep += 2;
 227                 goto star;
 228         case CDOT|RNGE:
 229                 (void) __getrnge(&lcnt, &dcnt, ep);
 230                 while (lcnt--)
 231                         if (*lp++ == '\0')
 232                                 return (0);
 233                 curlp = lp;
 234                 while (dcnt--)
 235                         if (*lp++ == '\0') break;
 236                 if (dcnt < 0) lp++;
 237                 ep += 2;
 238                 goto star;
 239         case CCL|RNGE:
 240         case NCCL|RNGE:
 241                 (void) __getrnge(&lcnt, &dcnt, (ep + (*ep & 0377)));
 242                 while (lcnt--)
 243                         if (!__cclass(ep, *lp++, ep[-1] == (CCL | RNGE)))
 244                                 return (0);
 245                 curlp = lp;
 246                 while (dcnt--)
 247                         if (!__cclass(ep, *lp++, ep[-1] == (CCL|RNGE)))
 248                                 break;
 249                 if (dcnt < 0) lp++;
 250                 ep += (*ep + 2);
 251                 goto star;
 252         case CCL:
 253                 if (__cclass(ep, *lp++, 1)) {
 254                         ep += *ep;
 255                         continue;
 256                 }
 257                 return (0);
 258
 259         case NCCL:
 260                 if (__cclass(ep, *lp++, 0)) {
 261                         ep += *ep;
 262                         continue;
 263                 }
 264                 return (0);
 265
 266         case CBRA:
 267                 __braslist[*ep++] = lp;
 268                 continue;
 269
 270         case CKET:
 271                 __braelist[*ep] = lp;
 272                 __bravar[*ep] = ep[1];
 273                 ep += 2;
 274                 continue;
 275
 276         case CDOT|PLUS:
 277                 if (*lp++ == '\0')
 278                         return (0);
 279         case CDOT|STAR:
 280                 curlp = lp;
 281                 while (*lp++);
 282                 goto star;
 283
 284         case CCHR|PLUS:
 285                 if (*lp++ != *ep)
 286                         return (0);
 287         case CCHR|STAR:
 288                 curlp = lp;
 289                 while (*lp++ == *ep);
 290                 ep++;
 291                 goto star;
 292
 293         case PGRP:
 294         case PGRP|A256:
 295         case PGRP|A512:
 296         case PGRP|A768:
 297                 if (!(lp = (char *)__advance(lp, ep+1)))
 298                         return (0);
 299         case SGRP|A768:
 300         case SGRP|A512:
 301         case SGRP|A256:
 302         case SGRP:
 303                 i = (((ep[-1]&03) << 8) + (*ep & 0377));
 304                 ep++;
 305                 (void) __xpush(0, ep + i);
 306                 (void) __xpush(1, curlp = lp);
 307                 while (i = __advance(lp, ep))
 308                         (void) __xpush(1, lp = (char *)i);
 309                 ep = (char *)__xpop(0);
 310                 gflg = 1;
 311                 goto star;
 312
 313         case CCL|PLUS:
 314         case NCCL|PLUS:
 315                 if (!__cclass(ep, *lp++, ep[-1] == (CCL | PLUS)))
 316                         return (0);
 317         case CCL|STAR:
 318         case NCCL|STAR:
 319                 curlp = lp;
 320                 while (__cclass(ep, *lp++, ((ep[-1] == (CCL | STAR)) ||
 321                         (ep[-1] == (CCL | PLUS)))));
 322                 ep += *ep;
 323                 goto star;
 324
 325         star:
 326                 do {
 327                         if (!gflg) lp--;
 328                         else if (!(lp = (char *)__xpop(1))) break;
 329                         if (i = __advance(lp, ep))
 330                                 return (i);
 331                 } while (lp > curlp);
 332                 return (0);
 333
 334         default:
 335                 return (0);
 336         }
 337         }
 338 }
 339
 340 intptr_t
 341 __cclass(char *aset, char ac, intptr_t af)
 342 {
 343         char *set, c;
 344         intptr_t n;
 345
 346         set = (char *)aset;
 347         if ((c = ac) == 0)
 348                 return (0);
 349         n = *set++;
 350         while (--n) {
 351                 if (*set == MINUS) {
 352                         if ((set[2] - set[1]) < 0)
 353                                 return (0);
 354                         if (*++set <= c) {
 355                                 if (c <= *++set)
 356                                         return (af);
 357                         } else
 358                                 ++set;
 359                         ++set;
 360                         n -= 2;
 361                         continue;
 362                 }
 363                 if (*set++ == c)
 364                         return (af);
 365         }
 366         return (!af);
 367 }
 368
 369 intptr_t
 370 __xpush(intptr_t i, char *p)
 371 {
 372         if (__lptr_ >= __eptr_) {
 373                 (void) write(2, "stack overflow\n", 15);
 374                 (void) exit(1);
 375         }
 376         if (i)
 377                 *__lptr_++ = (intptr_t)p;
 378         else
 379                 *__eptr_-- = (intptr_t)p;
 380         return (1);
 381 }
 382
 383 intptr_t
 384 __xpop(intptr_t i)
 385 {
 386         if (i)
 387                 return ((__lptr_ < (intptr_t *)&__st[0]) ? 0 : *--__lptr_);
 388         else
 389                 return ((__eptr_ > (intptr_t *)&__st[SSIZE]) ? 0 : *++__eptr_);
 390 }
 391
 392 intptr_t
 393 __getrnge(intptr_t *i, intptr_t *j, char *k)
 394 {
 395         *i = (*k++&0377);
 396         if (*k == (char)-1)
 397                 *j = 20000;
 398         else
 399                 *j = ((*k&0377) - *i);
 400         return (1);
 401 }