Print this page
OS-2834 ship lx brand
| Split |
Close |
| Expand all |
| Collapse all |
--- old/usr/src/head/regexp.h
+++ new/usr/src/head/regexp.h
1 1 /*
2 2 * CDDL HEADER START
3 3 *
4 4 * The contents of this file are subject to the terms of the
5 5 * Common Development and Distribution License (the "License").
6 6 * You may not use this file except in compliance with the License.
7 7 *
8 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 9 * or http://www.opensolaris.org/os/licensing.
10 10 * See the License for the specific language governing permissions
11 11 * and limitations under the License.
12 12 *
13 13 * When distributing Covered Code, include this CDDL HEADER in each
14 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 15 * If applicable, add the following below this CDDL HEADER, with the
16 16 * fields enclosed by brackets "[]" replaced with your own identifying
17 17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 18 *
19 19 * CDDL HEADER END
20 20 */
21 21 /* Copyright (c) 1988 AT&T */
22 22 /* All Rights Reserved */
23 23
24 24 /*
25 25 * Copyright 2014 Garrett D'Amore <garrett@damore.org>
26 26 *
27 27 * Copyright 2006 Sun Microsystems, Inc. All rights reserved.
28 28 * Use is subject to license terms.
29 29 */
30 30
31 31 #ifndef _REGEXP_H
32 32 #define _REGEXP_H
33 33
34 34 #include <string.h>
35 35
36 36 #ifdef __cplusplus
37 37 extern "C" {
38 38 #endif
39 39
40 40 #define CBRA 2
41 41 #define CCHR 4
42 42 #define CDOT 8
43 43 #define CCL 12
44 44 #define CXCL 16
45 45 #define CDOL 20
46 46 #define CCEOF 22
47 47 #define CKET 24
48 48 #define CBACK 36
49 49 #define NCCL 40
50 50
51 51 #define STAR 01
52 52 #define RNGE 03
53 53
54 54 #define NBRA 9
55 55
56 56 #define PLACE(c) ep[c >> 3] |= bittab[c & 07]
57 57 #define ISTHERE(c) (ep[c >> 3] & bittab[c & 07])
58 58 #define ecmp(s1, s2, n) (strncmp(s1, s2, n) == 0)
59 59
60 60 static char *braslist[NBRA];
61 61 static char *braelist[NBRA];
62 62 int sed, nbra;
63 63 char *loc1, *loc2, *locs;
64 64 static int nodelim;
65 65
66 66 int circf;
67 67 static int low;
68 68 static int size;
69 69
70 70 static unsigned char bittab[] = { 1, 2, 4, 8, 16, 32, 64, 128 };
71 71
72 72 int advance(const char *lp, const char *ep);
73 73 static void getrnge(const char *str);
74 74
75 75 char *
76 76 compile(char *instring, char *ep, const char *endbuf, int seof)
77 77 {
78 78 INIT /* Dependent declarations and initializations */
79 79 register int c;
80 80 register int eof = seof;
81 81 char *lastep;
82 82 int cclcnt;
83 83 char bracket[NBRA], *bracketp;
84 84 int closed;
85 85 int neg;
86 86 int lc;
87 87 int i, cflg;
88 88 int iflag; /* used for non-ascii characters in brackets */
89 89
90 90 #ifdef __lint
91 91 /* make lint happy */
92 92 c = nodelim;
93 93 #endif
94 94
95 95 lastep = NULL;
96 96 if ((c = GETC()) == eof || c == '\n') {
97 97 if (c == '\n') {
98 98 UNGETC(c);
99 99 nodelim = 1;
100 100 }
101 101 if (*ep == 0 && !sed)
102 102 ERROR(41);
103 103 RETURN(ep);
104 104 }
105 105 bracketp = bracket;
106 106 circf = closed = nbra = 0;
107 107 if (c == '^')
108 108 circf++;
109 109 else
110 110 UNGETC(c);
111 111 for (;;) {
112 112 if (ep >= endbuf)
113 113 ERROR(50);
114 114 c = GETC();
115 115 if (c != '*' && ((c != '\\') || (PEEKC() != '{')))
116 116 lastep = ep;
117 117 if (c == eof) {
118 118 *ep++ = CCEOF;
119 119 if (bracketp != bracket)
120 120 ERROR(42);
121 121 RETURN(ep);
122 122 }
123 123 switch (c) {
124 124
125 125 case '.':
126 126 *ep++ = CDOT;
127 127 continue;
128 128
129 129 case '\n':
130 130 if (!sed) {
131 131 UNGETC(c);
132 132 *ep++ = CCEOF;
133 133 nodelim = 1;
134 134 if (bracketp != bracket)
135 135 ERROR(42);
136 136 RETURN(ep);
137 137 } else ERROR(36);
138 138 case '*':
139 139 if (lastep == NULL || *lastep == CBRA ||
140 140 *lastep == CKET)
141 141 goto defchar;
142 142 *lastep |= STAR;
143 143 continue;
144 144
145 145 case '$':
146 146 if (PEEKC() != eof && PEEKC() != '\n')
147 147 goto defchar;
148 148 *ep++ = CDOL;
149 149 continue;
150 150
151 151 case '[':
152 152 if (&ep[17] >= endbuf)
153 153 ERROR(50);
154 154
155 155 *ep++ = CCL;
156 156 lc = 0;
157 157 for (i = 0; i < 16; i++)
158 158 ep[i] = 0;
159 159
160 160 neg = 0;
161 161 if ((c = GETC()) == '^') {
162 162 neg = 1;
163 163 c = GETC();
164 164 }
165 165 iflag = 1;
166 166 do {
167 167 c &= 0377;
168 168 if (c == '\0' || c == '\n')
169 169 ERROR(49);
170 170 if ((c & 0200) && iflag) {
171 171 iflag = 0;
172 172 if (&ep[32] >= endbuf)
173 173 ERROR(50);
174 174 ep[-1] = CXCL;
175 175 for (i = 16; i < 32; i++)
176 176 ep[i] = 0;
177 177 }
178 178 if (c == '-' && lc != 0) {
179 179 if ((c = GETC()) == ']') {
180 180 PLACE('-');
181 181 break;
182 182 }
183 183 if ((c & 0200) && iflag) {
184 184 iflag = 0;
185 185 if (&ep[32] >= endbuf)
186 186 ERROR(50);
187 187 ep[-1] = CXCL;
188 188 for (i = 16; i < 32; i++)
189 189 ep[i] = 0;
190 190 }
191 191 while (lc < c) {
192 192 PLACE(lc);
193 193 lc++;
194 194 }
195 195 }
196 196 lc = c;
197 197 PLACE(c);
198 198 } while ((c = GETC()) != ']');
199 199
200 200 if (iflag)
201 201 iflag = 16;
202 202 else
203 203 iflag = 32;
204 204
205 205 if (neg) {
206 206 if (iflag == 32) {
207 207 for (cclcnt = 0; cclcnt < iflag;
208 208 cclcnt++)
209 209 ep[cclcnt] ^= 0377;
210 210 ep[0] &= 0376;
211 211 } else {
212 212 ep[-1] = NCCL;
213 213 /* make nulls match so test fails */
214 214 ep[0] |= 01;
215 215 }
216 216 }
217 217
218 218 ep += iflag;
219 219
220 220 continue;
221 221
222 222 case '\\':
223 223 switch (c = GETC()) {
224 224
225 225 case '(':
226 226 if (nbra >= NBRA)
227 227 ERROR(43);
228 228 *bracketp++ = (char)nbra;
229 229 *ep++ = CBRA;
230 230 *ep++ = (char)nbra++;
231 231 continue;
232 232
233 233 case ')':
234 234 if (bracketp <= bracket)
235 235 ERROR(42);
236 236 *ep++ = CKET;
237 237 *ep++ = *--bracketp;
238 238 closed++;
239 239 continue;
240 240
241 241 case '{':
242 242 if (lastep == NULL)
243 243 goto defchar;
244 244 *lastep |= RNGE;
245 245 cflg = 0;
246 246 nlim:
247 247 c = GETC();
248 248 i = 0;
249 249 do {
250 250 if ('0' <= c && c <= '9')
251 251 i = 10 * i + c - '0';
252 252 else
253 253 ERROR(16);
254 254 } while (((c = GETC()) != '\\') && (c != ','));
255 255 if (i >= 255)
256 256 ERROR(11);
257 257 *ep++ = (char)i;
258 258 if (c == ',') {
259 259 if (cflg++)
260 260 ERROR(44);
261 261 if ((c = GETC()) == '\\')
262 262 *ep++ = (char)255;
263 263 else {
264 264 UNGETC(c);
265 265 goto nlim;
266 266 /* get 2'nd number */
267 267 }
268 268 }
269 269 if (GETC() != '}')
270 270 ERROR(45);
271 271 if (!cflg) /* one number */
272 272 *ep++ = (char)i;
273 273 else if ((ep[-1] & 0377) < (ep[-2] & 0377))
274 274 ERROR(46);
275 275 continue;
276 276
277 277 case '\n':
278 278 ERROR(36);
279 279
280 280 case 'n':
281 281 c = '\n';
282 282 goto defchar;
283 283
284 284 default:
285 285 if (c >= '1' && c <= '9') {
286 286 if ((c -= '1') >= closed)
287 287 ERROR(25);
288 288 *ep++ = CBACK;
289 289 *ep++ = (char)c;
290 290 continue;
291 291 }
292 292 }
293 293 /* Drop through to default to use \ to turn off special chars */
294 294
295 295 defchar:
296 296 default:
297 297 lastep = ep;
298 298 *ep++ = CCHR;
299 299 *ep++ = (char)c;
300 300 }
301 301 }
302 302 /*NOTREACHED*/
303 303 }
304 304
305 305 int
306 306 step(const char *p1, const char *p2)
307 307 {
308 308 char c;
309 309
310 310
311 311 if (circf) {
312 312 loc1 = (char *)p1;
313 313 return (advance(p1, p2));
314 314 }
315 315 /* fast check for first character */
316 316 if (*p2 == CCHR) {
317 317 c = p2[1];
318 318 do {
319 319 if (*p1 != c)
320 320 continue;
321 321 if (advance(p1, p2)) {
322 322 loc1 = (char *)p1;
323 323 return (1);
324 324 }
325 325 } while (*p1++);
326 326 return (0);
327 327 }
328 328 /* regular algorithm */
329 329 do {
330 330 if (advance(p1, p2)) {
331 331 loc1 = (char *)p1;
332 332 return (1);
333 333 }
334 334 } while (*p1++);
335 335 return (0);
336 336 }
337 337
338 338 int
339 339 advance(const char *lp, const char *ep)
340 340 {
341 341 const char *curlp;
342 342 int c;
343 343 char *bbeg;
344 344 register char neg;
345 345 size_t ct;
346 346
347 347 for (;;) {
348 348 neg = 0;
349 349 switch (*ep++) {
350 350
351 351 case CCHR:
352 352 if (*ep++ == *lp++)
353 353 continue;
354 354 return (0);
355 355 /*FALLTHRU*/
356 356
357 357 case CDOT:
358 358 if (*lp++)
359 359 continue;
360 360 return (0);
361 361 /*FALLTHRU*/
362 362
363 363 case CDOL:
364 364 if (*lp == 0)
365 365 continue;
366 366 return (0);
367 367 /*FALLTHRU*/
368 368
369 369 case CCEOF:
370 370 loc2 = (char *)lp;
371 371 return (1);
372 372 /*FALLTHRU*/
373 373
374 374 case CXCL:
375 375 c = (unsigned char)*lp++;
376 376 if (ISTHERE(c)) {
377 377 ep += 32;
378 378 continue;
379 379 }
380 380 return (0);
381 381 /*FALLTHRU*/
382 382
383 383 case NCCL:
384 384 neg = 1;
385 385 /*FALLTHRU*/
386 386
|
↓ open down ↓ |
386 lines elided |
↑ open up ↑ |
387 387 case CCL:
388 388 c = *lp++;
389 389 if (((c & 0200) == 0 && ISTHERE(c)) ^ neg) {
390 390 ep += 16;
391 391 continue;
392 392 }
393 393 return (0);
394 394 /*FALLTHRU*/
395 395
396 396 case CBRA:
397 - braslist[*ep++] = (char *)lp;
397 + braslist[(int)*ep++] = (char *)lp;
398 398 continue;
399 399 /*FALLTHRU*/
400 400
401 401 case CKET:
402 - braelist[*ep++] = (char *)lp;
402 + braelist[(int)*ep++] = (char *)lp;
403 403 continue;
404 404 /*FALLTHRU*/
405 405
406 406 case CCHR | RNGE:
407 407 c = *ep++;
408 408 getrnge(ep);
409 409 while (low--)
410 410 if (*lp++ != c)
411 411 return (0);
412 412 curlp = lp;
413 413 while (size--)
414 414 if (*lp++ != c)
415 415 break;
416 416 if (size < 0)
417 417 lp++;
418 418 ep += 2;
419 419 goto star;
420 420 /*FALLTHRU*/
421 421
422 422 case CDOT | RNGE:
423 423 getrnge(ep);
424 424 while (low--)
425 425 if (*lp++ == '\0')
426 426 return (0);
427 427 curlp = lp;
428 428 while (size--)
429 429 if (*lp++ == '\0')
430 430 break;
431 431 if (size < 0)
432 432 lp++;
433 433 ep += 2;
434 434 goto star;
435 435 /*FALLTHRU*/
436 436
437 437 case CXCL | RNGE:
438 438 getrnge(ep + 32);
439 439 while (low--) {
440 440 c = (unsigned char)*lp++;
441 441 if (!ISTHERE(c))
442 442 return (0);
443 443 }
444 444 curlp = lp;
445 445 while (size--) {
446 446 c = (unsigned char)*lp++;
447 447 if (!ISTHERE(c))
448 448 break;
449 449 }
450 450 if (size < 0)
451 451 lp++;
452 452 ep += 34; /* 32 + 2 */
453 453 goto star;
454 454 /*FALLTHRU*/
455 455
456 456 case NCCL | RNGE:
457 457 neg = 1;
458 458 /*FALLTHRU*/
459 459
460 460 case CCL | RNGE:
461 461 getrnge(ep + 16);
462 462 while (low--) {
463 463 c = *lp++;
464 464 if (((c & 0200) || !ISTHERE(c)) ^ neg)
465 465 return (0);
466 466 }
467 467 curlp = lp;
468 468 while (size--) {
469 469 c = *lp++;
|
↓ open down ↓ |
57 lines elided |
↑ open up ↑ |
470 470 if (((c & 0200) || !ISTHERE(c)) ^ neg)
471 471 break;
472 472 }
473 473 if (size < 0)
474 474 lp++;
475 475 ep += 18; /* 16 + 2 */
476 476 goto star;
477 477 /*FALLTHRU*/
478 478
479 479 case CBACK:
480 - bbeg = braslist[*ep];
481 - ct = braelist[*ep++] - bbeg;
480 + bbeg = braslist[(int)*ep];
481 + ct = braelist[(int)*ep++] - bbeg;
482 482
483 483 if (ecmp(bbeg, lp, ct)) {
484 484 lp += ct;
485 485 continue;
486 486 }
487 487 return (0);
488 488 /*FALLTHRU*/
489 489
490 490 case CBACK | STAR:
491 - bbeg = braslist[*ep];
492 - ct = braelist[*ep++] - bbeg;
491 + bbeg = braslist[(int)*ep];
492 + ct = braelist[(int)*ep++] - bbeg;
493 493 curlp = lp;
494 494 while (ecmp(bbeg, lp, ct))
495 495 lp += ct;
496 496
497 497 while (lp >= curlp) {
498 498 if (advance(lp, ep))
499 499 return (1);
500 500 lp -= ct;
501 501 }
502 502 return (0);
503 503 /*FALLTHRU*/
504 504
505 505 case CDOT | STAR:
506 506 curlp = lp;
507 507 while (*lp++);
508 508 goto star;
509 509 /*FALLTHRU*/
510 510
511 511 case CCHR | STAR:
512 512 curlp = lp;
513 513 while (*lp++ == *ep);
514 514 ep++;
515 515 goto star;
516 516 /*FALLTHRU*/
517 517
518 518 case CXCL | STAR:
519 519 curlp = lp;
520 520 do {
521 521 c = (unsigned char)*lp++;
522 522 } while (ISTHERE(c));
523 523 ep += 32;
524 524 goto star;
525 525 /*FALLTHRU*/
526 526
527 527 case NCCL | STAR:
528 528 neg = 1;
529 529 /*FALLTHRU*/
530 530
531 531 case CCL | STAR:
532 532 curlp = lp;
533 533 do {
534 534 c = *lp++;
535 535 } while (((c & 0200) == 0 && ISTHERE(c)) ^ neg);
536 536 ep += 16;
537 537 goto star;
538 538 /*FALLTHRU*/
539 539
540 540 star:
541 541 do {
542 542 if (--lp == locs)
543 543 break;
544 544 if (advance(lp, ep))
545 545 return (1);
546 546 } while (lp > curlp);
547 547 return (0);
548 548
549 549 }
550 550 }
551 551 /*NOTREACHED*/
552 552 }
553 553
554 554 static void
555 555 getrnge(const char *str)
556 556 {
557 557 low = *str++ & 0377;
558 558 size = ((*str & 0377) == 255)? 20000: (*str &0377) - low;
559 559 }
560 560
561 561 #ifdef __cplusplus
562 562 }
563 563 #endif
564 564
565 565 #endif /* _REGEXP_H */
|
↓ open down ↓ |
63 lines elided |
↑ open up ↑ |
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX