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 } 402