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 /* 23 * Copyright 2005 Sun Microsystems, Inc. All rights reserved. 24 * Use is subject to license terms. 25 */ 26 27 /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */ 28 /* All Rights Reserved */ 29 30 /* Copyright (c) 1987, 1988 Microsoft Corporation */ 31 /* All Rights Reserved */ 32 33 #pragma ident "%Z%%M% %I% %E% SMI" 34 35 /* 36 * fgrep -- print all lines containing any of a set of keywords 37 * 38 * status returns: 39 * 0 - ok, and some matches 40 * 1 - ok, but no matches 41 * 2 - some error 42 */ 43 44 #include <stdio.h> 45 #include <ctype.h> 46 #include <sys/types.h> 47 #include <stdlib.h> 48 #include <string.h> 49 #include <locale.h> 50 #include <libintl.h> 51 #include <euc.h> 52 #include <sys/stat.h> 53 #include <fcntl.h> 54 55 #include <getwidth.h> 56 57 eucwidth_t WW; 58 #define WIDTH1 WW._eucw1 59 #define WIDTH2 WW._eucw2 60 #define WIDTH3 WW._eucw3 61 #define MULTI_BYTE WW._multibyte 62 #define GETONE(lc, p) \ 63 cw = ISASCII(lc = (unsigned char)*p++) ? 1 : \ 64 (ISSET2(lc) ? WIDTH2 : \ 65 (ISSET3(lc) ? WIDTH3 : WIDTH1)); \ 66 if (--cw > --ccount) { \ 67 cw -= ccount; \ 68 while (ccount--) \ 69 lc = (lc << 7) | ((*p++) & 0177); \ 70 if (p >= &buf[fw_lBufsiz + BUFSIZ]) { \ 71 if (nlp == buf) { \ 72 /* Increase the buffer size */ \ 73 fw_lBufsiz += BUFSIZ; \ 74 if ((buf = realloc(buf, \ 75 fw_lBufsiz + BUFSIZ)) == NULL) { \ 76 exit(2); /* out of memory */ \ 77 } \ 78 nlp = buf; \ 79 p = &buf[fw_lBufsiz]; \ 80 } else { \ 81 /* shift the buffer contents down */ \ 82 (void) memmove(buf, nlp, \ 83 &buf[fw_lBufsiz + BUFSIZ] - nlp);\ 84 p -= nlp - buf; \ 85 nlp = buf; \ 86 } \ 87 } \ 88 if (p > &buf[fw_lBufsiz]) { \ 89 if ((ccount = fread(p, sizeof (char), \ 90 &buf[fw_lBufsiz + BUFSIZ] - p, fptr))\ 91 <= 0) break; \ 92 } else if ((ccount = fread(p, \ 93 sizeof (char), BUFSIZ, fptr)) <= 0) \ 94 break; \ 95 blkno += (long long)ccount; \ 96 } \ 97 ccount -= cw; \ 98 while (cw--) \ 99 lc = (lc << 7) | ((*p++) & 0177) 100 101 /* 102 * The same() macro and letter() function were inserted to allow for 103 * the -i option work for the multi-byte environment. 104 */ 105 wchar_t letter(); 106 #define same(a, b) \ 107 (a == b || iflag && (!MULTI_BYTE || ISASCII(a)) && (a ^ b) == ' ' && \ 108 letter(a) == letter(b)) 109 110 111 #define QSIZE 400 112 struct words { 113 wchar_t inp; 114 char out; 115 struct words *nst; 116 struct words *link; 117 struct words *fail; 118 } *w = NULL, *smax, *q; 119 120 FILE *fptr; 121 long long lnum; 122 int bflag, cflag, lflag, fflag, nflag, vflag, xflag, eflag, sflag; 123 int hflag, iflag; 124 int retcode = 0; 125 int nfile; 126 long long blkno; 127 int nsucc; 128 long long tln; 129 FILE *wordf; 130 char *argptr; 131 off_t input_size = 0; 132 133 void execute(char *); 134 void cgotofn(void); 135 void overflo(void); 136 void cfail(void); 137 138 static long fw_lBufsiz = 0; 139 140 int 141 main(int argc, char **argv) 142 { 143 int c; 144 int errflg = 0; 145 struct stat file_stat; 146 147 (void) setlocale(LC_ALL, ""); 148 #if !defined(TEXT_DOMAIN) /* Should be defined by cc -D */ 149 #define TEXT_DOMAIN "SYS_TEST" /* Use this only if it weren't */ 150 #endif 151 (void) textdomain(TEXT_DOMAIN); 152 153 while ((c = getopt(argc, argv, "hybcie:f:lnvxs")) != EOF) 154 switch (c) { 155 156 case 's': 157 sflag++; 158 continue; 159 case 'h': 160 hflag++; 161 continue; 162 case 'b': 163 bflag++; 164 continue; 165 166 case 'i': 167 case 'y': 168 iflag++; 169 continue; 170 171 case 'c': 172 cflag++; 173 continue; 174 175 case 'e': 176 eflag++; 177 argptr = optarg; 178 input_size = strlen(argptr); 179 continue; 180 181 case 'f': 182 fflag++; 183 wordf = fopen(optarg, "r"); 184 if (wordf == NULL) { 185 (void) fprintf(stderr, 186 gettext("fgrep: can't open %s\n"), 187 optarg); 188 exit(2); 189 } 190 191 if (fstat(fileno(wordf), &file_stat) == 0) { 192 input_size = file_stat.st_size; 193 } else { 194 (void) fprintf(stderr, 195 gettext("fgrep: can't fstat %s\n"), 196 optarg); 197 exit(2); 198 } 199 200 continue; 201 202 case 'l': 203 lflag++; 204 continue; 205 206 case 'n': 207 nflag++; 208 continue; 209 210 case 'v': 211 vflag++; 212 continue; 213 214 case 'x': 215 xflag++; 216 continue; 217 218 case '?': 219 errflg++; 220 } 221 222 argc -= optind; 223 if (errflg || ((argc <= 0) && !fflag && !eflag)) { 224 (void) printf(gettext("usage: fgrep [ -bchilnsvx ] " 225 "[ -e exp ] [ -f file ] [ strings ] [ file ] ...\n")); 226 exit(2); 227 } 228 if (!eflag && !fflag) { 229 argptr = argv[optind]; 230 input_size = strlen(argptr); 231 input_size++; 232 optind++; 233 argc--; 234 } 235 236 /* 237 * Normally we need one struct words for each letter in the pattern 238 * plus one terminating struct words with outp = 1, but when -x option 239 * is specified we require one more struct words for `\n` character so we 240 * calculate the input_size as below. We add extra 1 because 241 * (input_size/2) rounds off odd numbers 242 */ 243 244 if (xflag) { 245 input_size = input_size + (input_size/2) + 1; 246 } 247 248 input_size++; 249 250 w = (struct words *)calloc(input_size, sizeof (struct words)); 251 if (w == NULL) { 252 (void) fprintf(stderr, 253 gettext("fgrep: could not allocate " 254 "memory for wordlist\n")); 255 exit(2); 256 } 257 258 getwidth(&WW); 259 if ((WIDTH1 == 0) && (WIDTH2 == 0) && 260 (WIDTH3 == 0)) { 261 /* 262 * If non EUC-based locale, 263 * assume WIDTH1 is 1. 264 */ 265 WIDTH1 = 1; 266 } 267 WIDTH2++; 268 WIDTH3++; 269 270 cgotofn(); 271 cfail(); 272 nfile = argc; 273 argv = &argv[optind]; 274 if (argc <= 0) { 275 execute((char *)NULL); 276 } else 277 while (--argc >= 0) { 278 execute(*argv); 279 argv++; 280 } 281 282 if (w != NULL) { 283 free(w); 284 } 285 286 return (retcode != 0 ? retcode : nsucc == 0); 287 } 288 289 void 290 execute(char *file) 291 { 292 char *p; 293 struct words *c; 294 int ccount; 295 static char *buf = NULL; 296 int failed; 297 char *nlp; 298 wchar_t lc; 299 int cw; 300 301 if (buf == NULL) { 302 fw_lBufsiz = BUFSIZ; 303 if ((buf = malloc(fw_lBufsiz + BUFSIZ)) == NULL) { 304 exit(2); /* out of memory */ 305 } 306 } 307 308 if (file) { 309 if ((fptr = fopen(file, "r")) == NULL) { 310 (void) fprintf(stderr, 311 gettext("fgrep: can't open %s\n"), file); 312 retcode = 2; 313 return; 314 } 315 } else { 316 file = "<stdin>"; 317 fptr = stdin; 318 } 319 ccount = 0; 320 failed = 0; 321 lnum = 1; 322 tln = 0; 323 blkno = 0; 324 p = buf; 325 nlp = p; 326 c = w; 327 for (;;) { 328 if (c == 0) 329 break; 330 if (ccount <= 0) { 331 if (p >= &buf[fw_lBufsiz + BUFSIZ]) { 332 if (nlp == buf) { 333 /* increase the buffer size */ 334 fw_lBufsiz += BUFSIZ; 335 if ((buf = realloc(buf, 336 fw_lBufsiz + BUFSIZ)) == NULL) { 337 exit(2); /* out of memory */ 338 } 339 nlp = buf; 340 p = &buf[fw_lBufsiz]; 341 } else { 342 /* shift the buffer down */ 343 (void) memmove(buf, nlp, 344 &buf[fw_lBufsiz + BUFSIZ] 345 - nlp); 346 p -= nlp - buf; 347 nlp = buf; 348 } 349 350 } 351 if (p > &buf[fw_lBufsiz]) { 352 if ((ccount = fread(p, sizeof (char), 353 &buf[fw_lBufsiz + BUFSIZ] - p, fptr)) 354 <= 0) 355 break; 356 } else if ((ccount = fread(p, sizeof (char), 357 BUFSIZ, fptr)) <= 0) 358 break; 359 blkno += (long long)ccount; 360 } 361 GETONE(lc, p); 362 nstate: 363 if (same(c->inp, lc)) { 364 c = c->nst; 365 } else if (c->link != 0) { 366 c = c->link; 367 goto nstate; 368 } else { 369 c = c->fail; 370 failed = 1; 371 if (c == 0) { 372 c = w; 373 istate: 374 if (same(c->inp, lc)) { 375 c = c->nst; 376 } else if (c->link != 0) { 377 c = c->link; 378 goto istate; 379 } 380 } else 381 goto nstate; 382 } 383 384 if (c == 0) 385 break; 386 387 if (c->out) { 388 while (lc != '\n') { 389 if (ccount <= 0) { 390 if (p == &buf[fw_lBufsiz + BUFSIZ]) { 391 if (nlp == buf) { 392 /* increase buffer size */ 393 fw_lBufsiz += BUFSIZ; 394 if ((buf = realloc(buf, fw_lBufsiz + BUFSIZ)) == NULL) { 395 exit(2); /* out of memory */ 396 } 397 nlp = buf; 398 p = &buf[fw_lBufsiz]; 399 } else { 400 /* shift buffer down */ 401 (void) memmove(buf, nlp, &buf[fw_lBufsiz + BUFSIZ] - nlp); 402 p -= nlp - buf; 403 nlp = buf; 404 } 405 } 406 if (p > &buf[fw_lBufsiz]) { 407 if ((ccount = fread(p, sizeof (char), 408 &buf[fw_lBufsiz + BUFSIZ] - p, fptr)) <= 0) break; 409 } else if ((ccount = fread(p, sizeof (char), BUFSIZ, 410 fptr)) <= 0) break; 411 blkno += (long long)ccount; 412 } 413 GETONE(lc, p); 414 } 415 if ((vflag && (failed == 0 || xflag == 0)) || 416 (vflag == 0 && xflag && failed)) 417 goto nomatch; 418 succeed: 419 nsucc = 1; 420 if (cflag) 421 tln++; 422 else if (lflag && !sflag) { 423 (void) printf("%s\n", file); 424 (void) fclose(fptr); 425 return; 426 } else if (!sflag) { 427 if (nfile > 1 && !hflag) 428 (void) printf("%s:", file); 429 if (bflag) 430 (void) printf("%lld:", 431 (blkno - (long long)(ccount-1)) 432 / BUFSIZ); 433 if (nflag) 434 (void) printf("%lld:", lnum); 435 if (p <= nlp) { 436 while (nlp < &buf[fw_lBufsiz + BUFSIZ]) 437 (void) putchar(*nlp++); 438 nlp = buf; 439 } 440 while (nlp < p) 441 (void) putchar(*nlp++); 442 } 443 nomatch: 444 lnum++; 445 nlp = p; 446 c = w; 447 failed = 0; 448 continue; 449 } 450 if (lc == '\n') 451 if (vflag) 452 goto succeed; 453 else { 454 lnum++; 455 nlp = p; 456 c = w; 457 failed = 0; 458 } 459 } 460 (void) fclose(fptr); 461 if (cflag) { 462 if ((nfile > 1) && !hflag) 463 (void) printf("%s:", file); 464 (void) printf("%lld\n", tln); 465 } 466 } 467 468 469 wchar_t 470 getargc(void) 471 { 472 /* appends a newline to shell quoted argument list so */ 473 /* the list looks like it came from an ed style file */ 474 wchar_t c; 475 int cw; 476 int b; 477 static int endflg; 478 479 480 if (wordf) { 481 if ((b = getc(wordf)) == EOF) 482 return (EOF); 483 cw = ISASCII(c = (wchar_t)b) ? 1 : 484 (ISSET2(c) ? WIDTH2 : (ISSET3(c) ? WIDTH3 : WIDTH1)); 485 while (--cw) { 486 if ((b = getc(wordf)) == EOF) 487 return (EOF); 488 c = (c << 7) | (b & 0177); 489 } 490 return (iflag ? letter(c) : c); 491 } 492 493 if (endflg) 494 return (EOF); 495 496 { 497 cw = ISASCII(c = (unsigned char)*argptr++) ? 1 : 498 (ISSET2(c) ? WIDTH2 : (ISSET3(c) ? WIDTH3 : WIDTH1)); 499 500 while (--cw) 501 c = (c << 7) | ((*argptr++) & 0177); 502 if (c == '\0') { 503 endflg++; 504 return ('\n'); 505 } 506 } 507 return (iflag ? letter(c) : c); 508 509 510 } 511 512 void 513 cgotofn(void) 514 { 515 int c; 516 struct words *s; 517 518 s = smax = w; 519 nword: 520 for (;;) { 521 c = getargc(); 522 if (c == EOF) 523 return; 524 if (c == 0) 525 goto enter; 526 if (c == '\n') { 527 if (xflag) { 528 for (;;) { 529 if (s->inp == c) { 530 s = s->nst; 531 break; 532 } 533 if (s->inp == 0) 534 goto nenter; 535 if (s->link == 0) { 536 if (smax >= &w[input_size -1]) 537 overflo(); 538 s->link = ++smax; 539 s = smax; 540 goto nenter; 541 } 542 s = s->link; 543 } 544 } 545 s->out = 1; 546 s = w; 547 } else { 548 loop: 549 if (s->inp == c) { 550 s = s->nst; 551 continue; 552 } 553 if (s->inp == 0) 554 goto enter; 555 if (s->link == 0) { 556 if (smax >= &w[input_size -1]) 557 overflo(); 558 s->link = ++smax; 559 s = smax; 560 goto enter; 561 } 562 s = s->link; 563 goto loop; 564 } 565 } 566 567 enter: 568 do { 569 s->inp = c; 570 if (smax >= &w[input_size -1]) 571 overflo(); 572 s->nst = ++smax; 573 s = smax; 574 } while ((c = getargc()) != '\n' && c != EOF); 575 if (xflag) { 576 nenter: 577 s->inp = '\n'; 578 if (smax >= &w[input_size -1]) 579 overflo(); 580 s->nst = ++smax; 581 } 582 smax->out = 1; 583 s = w; 584 if (c != EOF) 585 goto nword; 586 } 587 588 /* 589 * This function is an unexpected condition, since input_size should have been 590 * calculated correctly before hand. 591 */ 592 593 void 594 overflo(void) 595 { 596 (void) fprintf(stderr, gettext("fgrep: wordlist too large\n")); 597 exit(2); 598 } 599 600 void 601 cfail(void) 602 { 603 int qsize = QSIZE; 604 struct words **queue = NULL; 605 606 /* 607 * front and rear are pointers used to traverse the global words 608 * structure "w" which contains the data of input pattern file 609 */ 610 struct words **front, **rear; 611 struct words *state; 612 unsigned long frontoffset = 0, rearoffset = 0; 613 char c; 614 struct words *s; 615 s = w; 616 if ((queue = (struct words **)calloc(qsize, sizeof (struct words *))) 617 == NULL) { 618 perror("fgrep"); 619 exit(2); 620 } 621 front = rear = queue; 622 init: 623 if ((s->inp) != 0) { 624 *rear++ = s->nst; 625 /* 626 * Reallocates the queue if the number of distinct starting 627 * character of patterns exceeds the qsize value 628 */ 629 if (rear >= &queue[qsize - 1]) { 630 frontoffset = front - queue; 631 rearoffset = rear - queue; 632 qsize += QSIZE; 633 if ((queue = (struct words **)realloc(queue, 634 qsize * sizeof (struct words *))) == NULL) { 635 perror("fgrep"); 636 exit(2); 637 } 638 front = queue + frontoffset; 639 rear = queue + rearoffset; 640 } 641 } 642 if ((s = s->link) != 0) { 643 goto init; 644 } 645 646 while (rear != front) { 647 s = *front++; 648 cloop: 649 if ((c = s->inp) != 0) { 650 *rear++ = (q = s->nst); 651 /* 652 * Reallocate the queue if the rear pointer reaches the end 653 * queue 654 */ 655 if (rear >= &queue[qsize - 1]) { 656 frontoffset = front - queue; 657 rearoffset = rear - queue; 658 qsize += QSIZE; 659 if ((queue = (struct words **)realloc(queue, 660 qsize * sizeof (struct words *))) == NULL) { 661 perror("fgrep"); 662 exit(2); 663 } 664 front = queue + frontoffset; 665 rear = queue + rearoffset; 666 } 667 state = s->fail; 668 floop: 669 if (state == 0) 670 state = w; 671 if (state->inp == c) { 672 qloop: 673 q->fail = state->nst; 674 if ((state->nst)->out == 1) 675 q->out = 1; 676 if ((q = q->link) != 0) 677 goto qloop; 678 } else if ((state = state->link) != 0) 679 goto floop; 680 } 681 if ((s = s->link) != 0) 682 goto cloop; 683 } 684 } 685 686 wchar_t 687 letter(wchar_t c) 688 { 689 if (c >= 'a' && c <= 'z') 690 return (c); 691 if (c >= 'A' && c <= 'Z') 692 return (c + 'a' - 'A'); 693 return (c); 694 }