home *** CD-ROM | disk | FTP | other *** search
/ Skunkware 5 / Skunkware 5.iso / src / Tools / glimpse-2.1 / agrep / agrep.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-05-16  |  95.5 KB  |  3,282 lines
  1.  
  2. /*
  3.  * bgopal: (1993-4) added a library interface and removed some bugs: also
  4.  * selectively modified many routines to work with our text-compression algo.
  5.  */
  6. #include "agrep.h"
  7. #include "checkfile.h"
  8.  
  9. #define PRINT(s)
  10.  
  11. extern char **environ;
  12. extern int errno;
  13. int pattern_index;    /* index in argv where the pattern is */
  14.  
  15. int glimpse_isserver=0;    /* so that there is no user interaction */
  16. int glimpse_call = 0;    /* So that usage message is not printed twice */
  17. int glimpse_clientdied=0;/* to quit search if glimpseserver's client dies */
  18. int use_previous_state;    /* VERY DIRTY SOLUTION TO OPTIMIZE GLIMPSE */
  19. int  agrep_initialfd;    /* Where does input come from? File/Memory? */
  20. CHAR *agrep_inbuffer;
  21. int  agrep_inlen;
  22. int  agrep_inpointer;
  23.  
  24. FILE *agrep_finalfp;    /* Where does output go to? File/Memory? */
  25. CHAR *agrep_outbuffer;
  26. int  agrep_outlen;
  27. int  agrep_outpointer;
  28.  
  29. int  execfd;    /* used by exec called within agrep_search, set in agrep_init */
  30. int  multifd = -1; /* fd for multipattern search used in ^^ , set in   ^^^^^^^^ */
  31. extern char *pat_spool, *tc_pat_spool;
  32. char *multibuf=NULL; /* buffer to put the multiple patterns in */
  33. int  multilen = 0; /* length of the multibuf: not the #of multi-patterns! */
  34.  
  35. extern int pos_cnt;    /* to re-initialize it to 0 for reg-exp search */
  36. unsigned Mask[MAXSYM];
  37. unsigned Init1, NO_ERR_MASK, Init[MaxError];
  38. unsigned Bit[WORD+1];
  39. CHAR buffer[BlockSize+Maxline+1];    /* should not be used anywhere: 10/18/93 */
  40. unsigned Next[MaxNext], Next1[MaxNext];
  41. unsigned wildmask, endposition, D_endpos; 
  42. int  LIMITOUTPUT;    /* maximum number of matches we are going to allow */
  43. int  EXITONERROR;    /* return -1 or exit on error? */
  44. int  REGEX, RE_ERR, FNAME, WHOLELINE, SIMPLEPATTERN;
  45. int  COUNT, HEAD, TAIL, LINENUM, INVERSE, I, S, DD, AND, SGREP, JUMP; 
  46. int  NOOUTPUTZERO;
  47. int  Num_Pat, PSIZE, prev_num_of_matched, num_of_matched, SILENT, NOPROMPT, BESTMATCH, NOUPPER;
  48. int  NOMATCH, TRUNCATE, FIRST_IN_RE, FIRSTOUTPUT;
  49. int  WORDBOUND, DELIMITER, D_length, tc_D_length, original_D_length;
  50. int  EATFIRST, OUTTAIL;
  51. int  BYTECOUNT;
  52. int  FILEOUT;
  53. int  DNA;
  54. int  APPROX;
  55. int  PAT_FILE;    /* multiple patterns from a given file */
  56. char PAT_FILE_NAME[MAX_LINE_LEN];
  57. int  PAT_BUFFER; /* multiple patterns from a given buffer */
  58. int  CONSTANT;
  59. int  RECURSIVE;
  60. int  total_line; /* used in mgrep */
  61. int  D;
  62. int  M;
  63. int  TCOMPRESSED;
  64. int  EASYSEARCH;    /* 1 used only for compressed files: LITTLE/BIG */
  65. int  ALWAYSFILENAME = OFF;
  66. int  POST_FILTER = OFF;
  67. int  NEW_FILE = OFF;    /* only when post-filter is used */
  68. int  PRINTPATTERN = OFF;
  69. int  MULTI_OUTPUT = OFF; /* should mgrep print the matched line multiple times for each matched pattern or just once? */
  70. /* invisible to the user, used only by glimpse: cannot use -l since it is incompatible with stdin and -A is used for the index search (done next) */
  71.  
  72. /* Stuff to handle complicated boolean patterns */
  73. int  AComplexBoolean = 0;
  74. ParseTree *AParse = NULL;
  75. int anum_terminals = 0;
  76. ParseTree aterminals[MAXNUM_PAT];
  77. char amatched_terminals[MAXNUM_PAT];
  78.  
  79. #if    MEASURE_TIMES
  80. /* timing variables */
  81. int OUTFILTER_ms;
  82. int FILTERALGO_ms;
  83. int INFILTER_ms;
  84. #endif    /*MEASURE_TIMES*/
  85.  
  86. CHAR **Textfiles = NULL;     /* array of filenames to be searched */
  87. int Numfiles = 0;    /* indicates how many files in Textfiles */
  88. int copied_from_argv = 0; /* were filenames copied from argv (should I free 'em)? */
  89. CHAR old_D_pat[MaxDelimit] = "\n";  /* to hold original D_pattern */
  90. CHAR original_old_D_pat[MaxDelimit] = "\n";
  91. CHAR Pattern[MAXPAT], OldPattern[MAXPAT];
  92. CHAR CurrentFileName[MAX_LINE_LEN]; 
  93. int SetCurrentFileName = 0;    /* dirty glimpse trick to make filters work: output seems to come from another file */
  94. int CurrentByteOffset;
  95. int SetCurrentByteOffset = 0;
  96. CHAR Progname[MAXNAME]; 
  97. CHAR D_pattern[MaxDelimit] = "\n; "; /* string which delimits records -- defaults to newline */
  98. CHAR tc_D_pattern[MaxDelimit * 2] = "\n";
  99. CHAR original_D_pattern[MaxDelimit] = "\n; ";
  100. char COMP_DIR[MAX_LINE_LEN];
  101. char FREQ_FILE[MAX_LINE_LEN], HASH_FILE[MAX_LINE_LEN], STRING_FILE[MAX_LINE_LEN];    /* interfacing with tcompress */
  102.  
  103. int  NOFILENAME,  /* Boolean flag, set for -h option */
  104.      FILENAMEONLY;/* Boolean flag, set for -l option */
  105. extern int init();
  106. int table[WORD][WORD];
  107.  
  108. /* This must be called before every agrep_search to reset agrep globals */
  109. reinit_value()
  110. {
  111.         int i, j;
  112.  
  113.     /* Added on 7th Oct 194 */
  114.     if (AParse) {
  115.         if (AComplexBoolean) destroy_tree(AParse);
  116.         AComplexBoolean = 0;
  117.         AParse = 0;
  118.         PAT_BUFFER = 0;
  119.         if (multibuf != NULL) free(multibuf);    /* this was allocated for arbit booleans, not multipattern search */
  120.         multibuf = NULL;
  121.         multilen = 0;
  122.         /* Cannot free multifd here since that is always allocated for multipattern search */
  123.     }
  124.     for (i=0; i<anum_terminals; i++) {
  125.         free(aterminals[i].data.leaf.value);
  126.         memset(&aterminals[i], '\0', sizeof(ParseTree));
  127.     }
  128.     anum_terminals = 0;
  129.  
  130.     num_of_matched = prev_num_of_matched = 0;
  131.         Bit[WORD] = 1;
  132.         for (i = WORD - 1; i > 0  ; i--)  Bit[i] = Bit[i+1] << 1;
  133.         for (i=0; i< MAXSYM; i++) Mask[i] = 0;
  134.  
  135.         /* bg: new things added on Mar 13 94 */
  136.         Init1 = 0;
  137.         NO_ERR_MASK = 0;
  138.         memset(Init, '\0', MaxError * sizeof(unsigned));
  139.         memset(Next, '\0', MaxNext * sizeof(unsigned));
  140.         memset(Next1, '\0', MaxNext * sizeof(unsigned));
  141.         wildmask = endposition = D_endpos = 0;
  142.         for (i=0; i<WORD; i++)
  143.                 for (j=0; j<WORD; j++)
  144.                         table[i][j] = 0;
  145.  
  146.         errno = 0;
  147.         strcpy(D_pattern, original_D_pattern);
  148.         D_length = original_D_length;
  149.         strcpy(old_D_pat, original_old_D_pat);
  150.  
  151.     /* Changed on Dec 26th: bg */
  152.     REGEX = 0;
  153.     HEAD = TAIL = ON;    /* were off initially */
  154.     RE_ERR = 0;
  155.     AND = 0;
  156.     FIRST_IN_RE = ON;
  157.     M = 0;
  158.     pos_cnt = 0;    /* added 31 Jan 95 */
  159. }
  160.  
  161. /* This must be called before every agrep_init to reset agrep options */
  162. initial_value()
  163. {
  164.     use_previous_state = 0;
  165.     SetCurrentFileName = 0;    /* 16/9/94 */
  166.     SetCurrentByteOffset = 0;    /* 23/9/94 */
  167.  
  168.     /* bg: new stuff on 17/Feb/94 */
  169.     if (multifd != -1) close(multifd);
  170.     multifd = -1;
  171.     if (multibuf != NULL) free(multibuf);
  172.     multibuf = NULL;
  173.     multilen = 0;
  174.     if (pat_spool != NULL) free(pat_spool);
  175.     pat_spool = NULL;
  176.     if (tc_pat_spool != NULL) free(tc_pat_spool);
  177.     tc_pat_spool = NULL;
  178.     LIMITOUTPUT = 0;    /* means infinity = current semantics */
  179.     EASYSEARCH = 1;
  180.     DNA = APPROX = PAT_FILE = PAT_BUFFER = CONSTANT = total_line = D = TCOMPRESSED = 0;
  181.     PAT_FILE_NAME[0] = '\0';
  182.     EXITONERROR = NOFILENAME = FILENAMEONLY = FILEOUT = ALWAYSFILENAME = NEW_FILE = POST_FILTER = 0;
  183.  
  184.         original_old_D_pat[0] = old_D_pat[0] = '\n';
  185.         original_old_D_pat[1] = old_D_pat[1] = '\0';
  186.         original_D_pattern[0] = D_pattern[0] = '\n';
  187.         original_D_pattern[1] = D_pattern[1] = ';';
  188.         original_D_pattern[2] = D_pattern[2] = ' ';
  189.         original_D_pattern[3] = D_pattern[3] = '\0';
  190.  
  191.     strcpy(tc_D_pattern, "\n");
  192.     tc_D_length = 1;
  193.  
  194.     /* the functions agrep_init and agrep_search take care of Textfiles and Numfiles */
  195.     agrep_inpointer = 0;
  196.     agrep_outpointer = 0;
  197.     agrep_outlen = 0;
  198. #if    MEASURE_TIMES
  199.     OUTFILTER_ms = FILTERALGO_ms = INFILTER_ms = 0;
  200. #endif    /*MEASURE_TIMES*/
  201.  
  202.     MULTI_OUTPUT = 0;
  203.     PRINTPATTERN = 0;
  204.     JUMP = FNAME = BESTMATCH = NOPROMPT = NOUPPER = 0;
  205.     RECURSIVE = 0;
  206.     COUNT = LINENUM = WHOLELINE = SGREP = 0;
  207.     NOOUTPUTZERO = 0;
  208.     EATFIRST = INVERSE = TRUNCATE = OUTTAIL = 0; 
  209.     NOMATCH = FIRSTOUTPUT = ON;    /* were off initally */
  210.     I = DD = S = 1;    /* were off initially */
  211.     original_D_length = D_length = 2;    /* was 0 initially */
  212.     SILENT = Num_Pat = PSIZE = SIMPLEPATTERN = prev_num_of_matched = num_of_matched = 0 ;
  213.     WORDBOUND = DELIMITER = 0;
  214.  
  215.     COMP_DIR[0] = '\0';
  216.     FREQ_FILE[0] = '\0';
  217.     HASH_FILE[0] = '\0';
  218.     STRING_FILE[0] = '\0';
  219.     BYTECOUNT = OFF;
  220.  
  221.     /* Pattern, OldPattern, execfd, Numfiles are set in agrep_init: so no need to initialize */
  222.     reinit_value();
  223.  
  224.     glimpse_clientdied = 0;    /* added 15th Feb 95 */
  225. }
  226.  
  227. compute_next(M, Next, Next1)
  228. int M; 
  229. unsigned *Next, *Next1;
  230. {
  231.     int i, j=0, n,  k, temp;
  232.     int mid, pp;
  233.     int MM, base;
  234.     unsigned V[WORD];
  235.  
  236.     base = WORD - M;
  237.     temp = Bit[base]; 
  238.     Bit[base] = 0;
  239.     for (i=0; i<WORD; i++) V[i] = 0;
  240.     for (i=1; i<M; i++)
  241.     {  
  242.         j=0;
  243.         while (table[i][j] > 0 && j < 10) {
  244.             V[i] = V[i] | Bit[base + table[i][j++]];
  245.         }
  246.     }
  247.     Bit[base]=temp;
  248.     if(M <= SHORTREG)
  249.     {
  250.         k = exponen(M);
  251.         pp = 2*k;
  252.         for(i=k; i<pp ; i++)
  253.         {   
  254.             n = i;
  255.             Next[i]= (k>>1);
  256.             for(j=M; j>=1; j--)
  257.             {
  258.                 if(n & Bit[WORD]) Next[i] = Next[i] | V[j];
  259.                 n = (n>>1);
  260.             }
  261.         }      
  262.         return;
  263.     }
  264.     if(M > MAXREG) fprintf(stderr, "%s: regular expression too long\n", Progname);
  265.     MM = M;
  266.     if(M & 1) M=M+1;
  267.     k = exponen(M/2);
  268.     pp = 2*k;
  269.     mid = MM/2;
  270.     for(i=k; i<pp ; i++)
  271.     {     
  272.         n = i;
  273.         Next[i]= (Bit[base]>>1);
  274.         for(j=MM; j>mid ; j--)
  275.         {
  276.             if(n & Bit[WORD]) Next[i] = Next[i] | V[j-mid];
  277.             n = (n>>1);
  278.         }
  279.         n=i-k;
  280.         Next1[i-k] = 0;
  281.         for(j = 0; j<mid; j++)
  282.         {
  283.             if(n & Bit[WORD]) Next1[i-k] = Next1[i-k] | V[MM-j];
  284.             n = (n>>1);
  285.         }
  286.     }      
  287.     return;
  288. }
  289.  
  290. exponen(m)
  291. int m;
  292. { 
  293.     int i, ex;
  294.     ex= 1;
  295.     for (i=0; i<m; i++) ex <<= 1;    /* was ex *= 2 */
  296.     return(ex);
  297. }
  298.  
  299. re1(Text, M, D)
  300. int Text, M, D;
  301. {
  302.     register unsigned i, c, r0, r1, r2, r3, CMask, Newline, Init0, r_NO_ERR; 
  303.     register unsigned end;
  304.     register unsigned hh, LL=0, k;  /* Lower part */
  305.     int  FIRST_TIME=ON, num_read , j=0, base;
  306.     unsigned A[MaxRerror+1], B[MaxRerror+1];
  307.     unsigned Next[MaxNext], Next1[MaxNext];
  308.     CHAR *buffer;
  309.     int FIRST_LOOP = 1;
  310.  
  311.     r_NO_ERR = NO_ERR_MASK;
  312.     if(M > 30) {
  313.         fprintf(stderr, "%s: regular expression too long\n", Progname);
  314.         if (!EXITONERROR){
  315.             errno = 2;
  316.             return -1;
  317.         }
  318.         else exit(2);
  319.     }
  320.     base = WORD - M;
  321.     hh = M/2;
  322.     for(i=WORD, j=0; j < hh ; i--, j++) LL = LL | Bit[i];
  323.     if(FIRST_IN_RE) compute_next(M, Next, Next1); 
  324.     /*SUN: try: change to memory allocation */
  325.     FIRST_IN_RE = 0;
  326.     Newline = '\n';
  327.     Init[0] = Bit[base];
  328.     if(HEAD) Init[0] = Init[0] | Bit[base+1];
  329.     for(i=1; i<= D; i++) Init[i] = Init[i-1] | Next[Init[i-1]>>hh] | Next1[Init[i-1]&LL];
  330.     Init1 = Init[0] | 1; 
  331.     Init0 = Init[0];
  332.     r2 = r3 = Init[0];
  333.     for(k=0; k<= D; k++) { 
  334.         A[k] = B[k] = Init[k]; 
  335.     }
  336.  
  337.     if ( D == 0 )
  338.     {
  339. #if    AGREP_POINTER
  340.         if (Text != -1)
  341.         {
  342. #endif    /*AGREP_POINTER*/
  343.         alloc_buf(Text, &buffer, BlockSize+Maxline+1);
  344.         while ((num_read = fill_buf(Text, buffer + Maxline, BlockSize)) > 0)
  345.         {
  346.             i=Maxline; 
  347.             end = num_read + Maxline;
  348.             if((num_read < BlockSize) && buffer[end-1] != '\n') buffer[end] = '\n';
  349.             if(FIRST_LOOP) {         /* if first time in the loop add a newline */
  350.                 buffer[i-1] = '\n';  /* in front the  text.  */
  351.                 i--;
  352.                 CurrentByteOffset --;
  353.                 FIRST_LOOP = 0;
  354.             }
  355.  
  356.             /* RE1_PROCESS_WHEN_DZERO: the while-loop below */
  357.             while ( i < end )
  358.             {
  359.                 c = buffer[i++];
  360.                 CurrentByteOffset ++;
  361.                 CMask = Mask[c];
  362.                 if(c != Newline)
  363.                 {
  364.                     if(CMask != 0) {
  365.                         r1 = Init1 & r3;
  366.                         r2 = ((Next[r3>>hh] | Next1[r3&LL]) & CMask) | r1;
  367.                     }
  368.                     else  {
  369.                         r2 = r3 & Init1;
  370.                     }
  371.                 }
  372.                 else {
  373.                     j++;
  374.                     if (DELIMITER) CurrentByteOffset -= D_length;
  375.                     else CurrentByteOffset -= 1;
  376.                     r1 = Init1 & r3;            /* match against endofline */
  377.                     r2 = ((Next[r3>>hh] | Next1[r3&LL]) & CMask) | r1;
  378.                     if(TAIL) r2 = (Next[r2>>hh] | Next1[r2&LL]) | r2;                                        /* epsilon move */
  379.                     if(( r2 & 1 ) ^ INVERSE) {
  380.                         if(FILENAMEONLY && (NEW_FILE || !POST_FILTER)) {
  381.                             num_of_matched++;
  382.  
  383.                             if (agrep_finalfp != NULL) 
  384.                                 fprintf(agrep_finalfp, "%s\n", CurrentFileName);
  385.                             else {
  386.                                 int outindex;
  387.                                 for(outindex=0; (outindex+agrep_outpointer<agrep_outlen) &&
  388.                                         (CurrentFileName[outindex] != '\0'); outindex++) {
  389.                                     agrep_outbuffer[agrep_outpointer+outindex] = CurrentFileName[outindex];
  390.                                 }
  391.                                 if ((CurrentFileName[outindex] != '\0') || (outindex+agrep_outpointer+1>=agrep_outlen)) {
  392.                                     OUTPUT_OVERFLOW;
  393.                                     free_buf(Text, buffer);
  394.                                     return -1;
  395.                                 }
  396.                                 else agrep_outbuffer[agrep_outpointer+outindex++] = '\n';
  397.                                 agrep_outpointer += outindex;
  398.                             }
  399.  
  400.                             free_buf(Text, buffer);
  401.                             NEW_FILE = OFF;
  402.                             return 0;
  403.                         }
  404.                         if (-1 == r_output(buffer, i-1, end, j)) {free_buf(Text, buffer); return -1;}
  405.                         if ((LIMITOUTPUT > 0) && (LIMITOUTPUT <= num_of_matched)) {
  406.                             free_buf(Text, buffer);
  407.                             return 0;    /* done */
  408.                         }
  409.                     }
  410.                     r3 = Init0;
  411.                     r2 = (Next[r3>>hh] | Next1[r3&LL]) & CMask | Init0;
  412.                     /* match begin of line */
  413.                     if (DELIMITER) CurrentByteOffset += 1*D_length;
  414.                     else CurrentByteOffset += 1*1;
  415.                 }
  416.                 c = buffer[i++];
  417.                 CurrentByteOffset ++;
  418.                 CMask = Mask[c];
  419.                 if(c != Newline)
  420.                 {
  421.                     if(CMask != 0) {
  422.                         r1 = Init1 & r2;
  423.                         r3 = ((Next[r2>>hh] | Next1[r2&LL]) & CMask) | r1;
  424.                     }
  425.                     else   r3 = r2 & Init1;
  426.                 } /* if(NOT Newline) */
  427.                 else {
  428.                     j++;
  429.                     if (DELIMITER) CurrentByteOffset -= D_length;
  430.                     else CurrentByteOffset -= 1;
  431.                     r1 = Init1 & r2;            /* match against endofline */
  432.                     r3 = ((Next[r2>>hh] | Next1[r2&LL]) & CMask) | r1;
  433.                     if(TAIL) r3 = ( Next[r3>>hh] | Next1[r3&LL] ) | r3;
  434.                     /* epsilon move */
  435.                     if(( r3 & 1 ) ^ INVERSE) {
  436.                         if(FILENAMEONLY && (NEW_FILE || !POST_FILTER)) {
  437.                             num_of_matched++;
  438.  
  439.                             if (agrep_finalfp != NULL)
  440.                                 fprintf(agrep_finalfp, "%s\n", CurrentFileName);
  441.                             else {
  442.                                 int outindex;
  443.                                 for(outindex=0; (outindex+agrep_outpointer<agrep_outlen) && 
  444.                                         (CurrentFileName[outindex] != '\0'); outindex++) {
  445.                                     agrep_outbuffer[agrep_outpointer+outindex] = CurrentFileName[outindex];
  446.                                 }
  447.                                 if ((CurrentFileName[outindex] != '\0') || (outindex+agrep_outpointer+1>=agrep_outlen)) {
  448.                                     OUTPUT_OVERFLOW;
  449.                                     free_buf(Text, buffer);
  450.                                     return -1;
  451.                                 }
  452.                                 else agrep_outbuffer[agrep_outpointer+outindex++] = '\n';
  453.                                 agrep_outpointer += outindex;
  454.                             }
  455.  
  456.                             free_buf(Text, buffer);
  457.                             NEW_FILE = OFF;
  458.                             return 0;
  459.                         }
  460.                         if (-1 == r_output(buffer, i-1, end, j)) {free_buf(Text, buffer); return -1;}
  461.                         if ((LIMITOUTPUT > 0) && (LIMITOUTPUT <= num_of_matched)) {
  462.                             free_buf(Text, buffer);
  463.                             return 0;    /* done */
  464.                         }
  465.                     }
  466.                     r2 = Init0;
  467.                     r3 = ((Next[r2>>hh] | Next1[r2&LL]) & CMask) | Init0;
  468.                     /* match begin of line */
  469.                     if (DELIMITER) CurrentByteOffset += 1*D_length;
  470.                     else CurrentByteOffset += 1*1;
  471.                 }
  472.             } /* while i < end ... */
  473.  
  474.             strncpy(buffer, buffer+num_read, Maxline);
  475.         } /* end while fill_buf()... */
  476.  
  477.         free_buf(Text, buffer);
  478.         return 0;
  479. #if    AGREP_POINTER
  480.         }
  481.         else {    /* within the memory buffer: assume it starts with a newline at position 0, the actual pattern follows that, and it ends with a '\n' */
  482.         num_read = agrep_inlen;
  483.         buffer = (CHAR *)agrep_inbuffer;
  484.         end = num_read;
  485.         /* buffer[end-1] = '\n';*/ /* at end of the text. */
  486.         /* buffer[0] = '\n';*/  /* in front of the  text. */
  487.         i = 0;
  488.  
  489.             /* An exact copy of the above RE1_PROCESS_WHEN_DZERO: the while-loop below */
  490.             while ( i < end )
  491.             {
  492.                 c = buffer[i++];
  493.                 CurrentByteOffset ++;
  494.                 CMask = Mask[c];
  495.                 if(c != Newline)
  496.                 {
  497.                     if(CMask != 0) {
  498.                         r1 = Init1 & r3;
  499.                         r2 = ((Next[r3>>hh] | Next1[r3&LL]) & CMask) | r1;
  500.                     }
  501.                     else  {
  502.                         r2 = r3 & Init1;
  503.                     }
  504.                 }
  505.                 else {
  506.                     j++;
  507.                     if (DELIMITER) CurrentByteOffset -= D_length;
  508.                     else CurrentByteOffset -= 1;
  509.                     r1 = Init1 & r3;            /* match against endofline */
  510.                     r2 = ((Next[r3>>hh] | Next1[r3&LL]) & CMask) | r1;
  511.                     if(TAIL) r2 = (Next[r2>>hh] | Next1[r2&LL]) | r2;                                        /* epsilon move */
  512.                     if(( r2 & 1 ) ^ INVERSE) {
  513.                         if(FILENAMEONLY && (NEW_FILE || !POST_FILTER)) {
  514.                             num_of_matched++;
  515.  
  516.                             if (agrep_finalfp != NULL) 
  517.                                 fprintf(agrep_finalfp, "%s\n", CurrentFileName);
  518.                             else {
  519.                                 int outindex;
  520.                                 for(outindex=0; (outindex+agrep_outpointer<agrep_outlen) &&
  521.                                         (CurrentFileName[outindex] != '\0'); outindex++) {
  522.                                     agrep_outbuffer[agrep_outpointer+outindex] = CurrentFileName[outindex];
  523.                                 }
  524.                                 if ((CurrentFileName[outindex] != '\0') || (outindex+agrep_outpointer+1>=agrep_outlen)) {
  525.                                     OUTPUT_OVERFLOW;
  526.                                     free_buf(Text, buffer);
  527.                                     return -1;
  528.                                 }
  529.                                 else agrep_outbuffer[agrep_outpointer+outindex++] = '\n';
  530.                                 agrep_outpointer += outindex;
  531.                             }
  532.  
  533.                             free_buf(Text, buffer);
  534.                             NEW_FILE = OFF;
  535.                             return 0;
  536.                         }
  537.                         if (-1 == r_output(buffer, i-1, end, j)) {free_buf(Text, buffer); return -1;}
  538.                         if ((LIMITOUTPUT > 0) && (LIMITOUTPUT <= num_of_matched)) {
  539.                             free_buf(Text, buffer);
  540.                             return 0;    /* done */
  541.                         }
  542.                     }
  543.                     r3 = Init0;
  544.                     r2 = (Next[r3>>hh] | Next1[r3&LL]) & CMask | Init0;
  545.                     /* match begin of line */
  546.                     if (DELIMITER) CurrentByteOffset += 1*D_length;
  547.                     else CurrentByteOffset += 1*1;
  548.                 }
  549.                 c = buffer[i++];
  550.                 CurrentByteOffset ++;
  551.                 CMask = Mask[c];
  552.                 if(c != Newline)
  553.                 {
  554.                     if(CMask != 0) {
  555.                         r1 = Init1 & r2;
  556.                         r3 = ((Next[r2>>hh] | Next1[r2&LL]) & CMask) | r1;
  557.                     }
  558.                     else   r3 = r2 & Init1;
  559.                 } /* if(NOT Newline) */
  560.                 else {
  561.                     j++;
  562.                     if (DELIMITER) CurrentByteOffset -= D_length;
  563.                     else CurrentByteOffset -= 1;
  564.                     r1 = Init1 & r2;            /* match against endofline */
  565.                     r3 = ((Next[r2>>hh] | Next1[r2&LL]) & CMask) | r1;
  566.                     if(TAIL) r3 = ( Next[r3>>hh] | Next1[r3&LL] ) | r3;
  567.                     /* epsilon move */
  568.                     if(( r3 & 1 ) ^ INVERSE) {
  569.                         if(FILENAMEONLY && (NEW_FILE || !POST_FILTER)) {
  570.                             num_of_matched++;
  571.  
  572.                             if (agrep_finalfp != NULL)
  573.                                 fprintf(agrep_finalfp, "%s\n", CurrentFileName);
  574.                             else {
  575.                                 int outindex;
  576.                                 for(outindex=0; (outindex+agrep_outpointer<agrep_outlen) && 
  577.                                         (CurrentFileName[outindex] != '\0'); outindex++) {
  578.                                     agrep_outbuffer[agrep_outpointer+outindex] = CurrentFileName[outindex];
  579.                                 }
  580.                                 if ((CurrentFileName[outindex] != '\0') || (outindex+agrep_outpointer+1>=agrep_outlen)) {
  581.                                     OUTPUT_OVERFLOW;
  582.                                     free_buf(Text, buffer);
  583.                                     return -1;
  584.                                 }
  585.                                 else agrep_outbuffer[agrep_outpointer+outindex++] = '\n';
  586.                                 agrep_outpointer += outindex;
  587.                             }
  588.  
  589.                             free_buf(Text, buffer);
  590.                             NEW_FILE = OFF;
  591.                             return 0;
  592.                         }
  593.                         if (-1 == r_output(buffer, i-1, end, j)) {free_buf(Text, buffer); return -1;}
  594.                         if ((LIMITOUTPUT > 0) && (LIMITOUTPUT <= num_of_matched)) {
  595.                             free_buf(Text, buffer);
  596.                             return 0;    /* done */
  597.                         }
  598.                     }
  599.                     r2 = Init0;
  600.                     r3 = ((Next[r2>>hh] | Next1[r2&LL]) & CMask) | Init0;
  601.                     /* match begin of line */
  602.                     if (DELIMITER) CurrentByteOffset += 1*D_length;
  603.                     else CurrentByteOffset += 1*1;
  604.                 }
  605.             } /* while i < end ... */
  606.  
  607.         return 0;
  608.         }
  609. #endif    /*AGREP_POINTER*/
  610.     } /*  end if (D == 0) */
  611.  
  612. #if    AGREP_POINTER
  613.     if (Text != -1)
  614.     {
  615. #endif    /*AGREP_POINTER*/
  616.         while ((num_read = fill_buf(Text, buffer + Maxline, BlockSize)) > 0)
  617.         {
  618.             i=Maxline; 
  619.             end = Maxline + num_read;
  620.             if((num_read < BlockSize) && buffer[end-1] != '\n') buffer[end] = '\n';
  621.             if(FIRST_TIME) {         /* if first time in the loop add a newline */
  622.                 buffer[i-1] = '\n';  /* in front the  text.  */
  623.                 i--;
  624.                 CurrentByteOffset --;
  625.                 FIRST_TIME = 0;
  626.             }
  627.  
  628.             /* RE1_PROCESS_WHEN_DNOTZERO: the while loop below */
  629.             while (i < end )
  630.             {
  631.                 c = buffer[i];
  632.                 CMask = Mask[c];
  633.                 if(c !=  Newline)
  634.                 {
  635.                     if(CMask != 0) {  
  636.                         r2 = B[0];
  637.                         r1 = Init1 & r2;
  638.                         A[0] = ((Next[r2>>hh] | Next1[r2&LL]) & CMask) | r1;
  639.                         r3 = B[1];
  640.                         r1 = Init1 & r3;
  641.                         r0 = r2 | A[0];     /* A[0] | B[0] */
  642.                         A[1] = ((Next[r3>>hh] | Next1[r3&LL]) & CMask) | (( r2 | Next[r0>>hh] | Next1[r0&LL])&r_NO_ERR) | r1 ;  
  643.                         if(D == 1) goto Nextcharfile;
  644.                         r2 = B[2];
  645.                         r1 = Init1 & r2;
  646.                         r0 = r3 | A[1];
  647.                         A[2] = ((Next[r2>>hh] | Next1[r2&LL]) & CMask) | ((r3 | Next[r0>>hh] | Next1[r0&LL])&r_NO_ERR) | r1 ;  
  648.                         if(D == 2) goto Nextcharfile;
  649.                         r3 = B[3];
  650.                         r1 = Init1 & r3;
  651.                         r0 = r2 | A[2];
  652.                         A[3] = ((Next[r3>>hh] | Next1[r3&LL]) & CMask) | ((r2 | Next[r0>>hh] | Next1[r0&LL])&r_NO_ERR) | r1 ;  
  653.                         if(D == 3) goto Nextcharfile;
  654.                         r2 = B[4];
  655.                         r1 = Init1 & r2;
  656.                         r0 = r3 | A[3];
  657.                         A[4] = ((Next[r2>>hh] | Next1[r2&LL]) & CMask) | ((r3 | Next[r0>>hh] | Next1[r0&LL])&r_NO_ERR) | r1 ;  
  658.                         if(D == 4)  goto Nextcharfile;
  659.                     }  /* if(CMask) */
  660.                     else  {
  661.                         r2 = B[0];
  662.                         A[0] = r2 & Init1; 
  663.                         r3 = B[1];
  664.                         r1 = Init1 & r3;
  665.                         r0 = r2 | A[0];
  666.                         A[1] = ((r2 | Next[r0>>hh] | Next1[r0&LL])&r_NO_ERR) | r1 ;  
  667.                         if(D == 1) goto Nextcharfile;
  668.                         r2 = B[2];
  669.                         r1 = Init1 & r2;
  670.                         r0 = r3 | A[1];
  671.                         A[2] = ((r3 | Next[r0>>hh] | Next1[r0&LL])&r_NO_ERR) | r1 ;  
  672.                         if(D == 2) goto Nextcharfile;
  673.                         r3 = B[3];
  674.                         r1 = Init1 & r3;
  675.                         r0 = r2 | A[2];
  676.                         A[3] = ((r2 | Next[r0>>hh] | Next1[r0&LL])&r_NO_ERR) | r1 ;  
  677.                         if(D == 3) goto Nextcharfile;
  678.                         r2 = B[4];
  679.                         r1 = Init1 & r2;
  680.                         r0 = r3 | A[3];
  681.                         A[4] = ((r3 | Next[r0>>hh] | Next1[r0&LL])&r_NO_ERR) | r1 ;  
  682.                         if(D == 4) goto Nextcharfile;
  683.                     }
  684.                 }
  685.                 else {  
  686.                     j++;
  687.                     if (DELIMITER) CurrentByteOffset -= D_length;
  688.                     else CurrentByteOffset -= 1;
  689.                     r1 = Init1 & B[D];            /* match against endofline */
  690.                     A[D] = ((Next[B[D]>>hh] | Next1[B[D]&LL]) & CMask) | r1;
  691.                     if(TAIL) A[D] = ( Next[A[D]>>hh] | Next1[A[D]&LL] ) | A[D]; 
  692.                     /* epsilon move */
  693.                     if(( A[D] & 1 ) ^ INVERSE) {
  694.                         if(FILENAMEONLY && (NEW_FILE || !POST_FILTER)) {
  695.                             num_of_matched++;
  696.  
  697.                             if (agrep_finalfp != NULL) 
  698.                                 fprintf(agrep_finalfp, "%s\n", CurrentFileName);
  699.                             else {
  700.                                 int outindex;
  701.                                 for(outindex=0; (outindex+agrep_outpointer<agrep_outlen) && 
  702.                                         (CurrentFileName[outindex] != '\0'); outindex++) {
  703.                                     agrep_outbuffer[agrep_outpointer+outindex] = CurrentFileName[outindex];
  704.                                 }
  705.                                 if ((CurrentFileName[outindex] != '\0') || (outindex+agrep_outpointer+1>=agrep_outlen)) {
  706.                                     OUTPUT_OVERFLOW;
  707.                                     free_buf(Text, buffer);
  708.                                     return -1;
  709.                                 }
  710.                                 else agrep_outbuffer[agrep_outpointer+outindex++] = '\n';
  711.                                 agrep_outpointer += outindex;
  712.                             }
  713.  
  714.                             free_buf(Text, buffer);
  715.                             NEW_FILE = OFF;
  716.                             return 0;
  717.                         } 
  718.                         if (-1 == r_output(buffer, i, end, j)) {free_buf(Text, buffer); return -1;}
  719.                         if ((LIMITOUTPUT > 0) && (LIMITOUTPUT <= num_of_matched)) {
  720.                             free_buf(Text, buffer);
  721.                             return 0;    /* done */
  722.                         }
  723.                     }
  724.                     for(k=0; k<=D; k++)  B[k] = Init[0];
  725.                     r1 = Init1 & B[0];
  726.                     A[0] = (( Next[B[0]>>hh] | Next1[B[0]&LL]) & CMask) | r1;
  727.                     for(k=1; k<=D; k++) {
  728.                         r3 = B[k];
  729.                         r1 = Init1 & r3;
  730.                         r2 = A[k-1] | B[k-1];
  731.                         A[k] = ((Next[r3>>hh] | Next1[r3&LL]) & CMask) | ((B[k-1] | Next[r2>>hh] | Next1[r2&LL]) & r_NO_ERR) | r1;
  732.                     }
  733.                     if (DELIMITER) CurrentByteOffset += 1*D_length;
  734.                     else CurrentByteOffset += 1*1;
  735.                 }
  736.     Nextcharfile: 
  737.                 i=i+1;
  738.                 CurrentByteOffset ++;
  739.                 c = buffer[i];
  740.                 CMask = Mask[c];
  741.                 if(c != Newline)
  742.                 {
  743.                     if(CMask != 0) {  
  744.                         r2 = A[0];
  745.                         r1 = Init1 & r2;
  746.                         B[0] = ((Next[r2>>hh] | Next1[r2&LL]) & CMask) | r1;
  747.                         r3 = A[1];
  748.                         r1 = Init1 & r3;
  749.                         r0 = B[0] | r2;
  750.                         B[1] = ((Next[r3>>hh] | Next1[r3&LL]) & CMask) | ((r2 | Next[r0>>hh] | Next1[r0&LL]) & r_NO_ERR) | r1 ;  
  751.                         if(D == 1) goto Nextchar1file;
  752.                         r2 = A[2];
  753.                         r1 = Init1 & r2;
  754.                         r0 = B[1] | r3;
  755.                         B[2] = ((Next[r2>>hh] | Next1[r2&LL]) & CMask) | ((r3 | Next[r0>>hh] | Next1[r0&LL])&r_NO_ERR) | r1 ;  
  756.                         if(D == 2) goto Nextchar1file;
  757.                         r3 = A[3];
  758.                         r1 = Init1 & r3;
  759.                         r0 = B[2] | r2;
  760.                         B[3] = ((Next[r3>>hh] | Next1[r3&LL]) & CMask) | ((r2 | Next[r0>>hh] | Next1[r0&LL])&r_NO_ERR) | r1 ;  
  761.                         if(D == 3) goto Nextchar1file;
  762.                         r2 = A[4];
  763.                         r1 = Init1 & r2;
  764.                         r0 = B[3] | r3;
  765.                         B[4] = ((Next[r2>>hh] | Next1[r2&LL]) & CMask) | ((r3 | Next[r0>>hh] | Next1[r0&LL])&r_NO_ERR) | r1 ;  
  766.                         if(D == 4)   goto Nextchar1file;
  767.                     }  /* if(CMask) */
  768.                     else  {
  769.                         r2 = A[0];
  770.                         B[0] = r2 & Init1; 
  771.                         r3 = A[1];
  772.                         r1 = Init1 & r3;
  773.                         r0 = B[0] | r2;
  774.                         B[1] = ((r2 | Next[r0>>hh] | Next1[r0&LL])&r_NO_ERR) | r1 ;  
  775.                         if(D == 1) goto Nextchar1file;
  776.                         r2 = A[2];
  777.                         r1 = Init1 & r2;
  778.                         r0 = B[1] | r3;
  779.                         B[2] = ((r3 | Next[r0>>hh] | Next1[r0&LL])&r_NO_ERR) | r1 ;  
  780.                         if(D == 2) goto Nextchar1file;
  781.                         r3 = A[3];
  782.                         r1 = Init1 & r3;
  783.                         r0 = B[2] | r2;
  784.                         B[3] = ((r2 | Next[r0>>hh] | Next1[r0&LL])&r_NO_ERR) | r1 ;  
  785.                         if(D == 3) goto Nextchar1file;
  786.                         r2 = A[4];
  787.                         r1 = Init1 & r2;
  788.                         r0 = B[3] | r3;
  789.                         B[4] = ((r3 | Next[r0>>hh] | Next1[r0&LL])&r_NO_ERR) | r1 ;  
  790.                         if(D == 4) goto Nextchar1file;
  791.                     }
  792.                 } /* if(NOT Newline) */
  793.                 else {  
  794.                     j++;
  795.                     if (DELIMITER) CurrentByteOffset -= D_length;
  796.                     else CurrentByteOffset -= 1;
  797.                     r1 = Init1 & A[D];            /* match against endofline */
  798.                     B[D] = ((Next[A[D]>>hh] | Next1[A[D]&LL]) & CMask) | r1;
  799.                     if(TAIL) B[D] = ( Next[B[D]>>hh] | Next1[B[D]&LL] ) | B[D]; 
  800.                     /* epsilon move */
  801.                     if(( B[D] & 1 ) ^ INVERSE) {
  802.                         if(FILENAMEONLY && (NEW_FILE || !POST_FILTER)) {
  803.                             num_of_matched++;
  804.  
  805.                             if (agrep_finalfp != NULL) 
  806.                                 fprintf(agrep_finalfp, "%s\n", CurrentFileName);
  807.                             else {
  808.                                 int outindex;
  809.                                 for(outindex=0; (outindex+agrep_outpointer<agrep_outlen) && 
  810.                                         (CurrentFileName[outindex] != '\0'); outindex++) {
  811.                                     agrep_outbuffer[agrep_outpointer+outindex] = CurrentFileName[outindex];
  812.                                 }
  813.                                 if ((CurrentFileName[outindex] != '\0') || (outindex+agrep_outpointer+1>=agrep_outlen)) {
  814.                                     OUTPUT_OVERFLOW;
  815.                                     free_buf(Text, buffer);
  816.                                     return -1;
  817.                                 }
  818.                                 else agrep_outbuffer[agrep_outpointer+outindex++] = '\n';
  819.                                 agrep_outpointer += outindex;
  820.                             }
  821.  
  822.                             free_buf(Text, buffer);
  823.                             NEW_FILE = OFF;
  824.                             return 0;
  825.                         } 
  826.                         if (-1 == r_output(buffer, i, end, j)) {free_buf(Text, buffer); return -1;}
  827.                         if ((LIMITOUTPUT > 0) && (LIMITOUTPUT <= num_of_matched)) {
  828.                             free_buf(Text, buffer);
  829.                             return 0;    /* done */
  830.                         }
  831.                     }
  832.                     for(k=0; k<=D; k++) A[k] = Init0; 
  833.                     r1 = Init1 & A[0];
  834.                     B[0] = ((Next[A[0]>>hh] | Next1[A[0]&LL]) & CMask) | r1;
  835.                     for(k=1; k<=D; k++) {
  836.                         r3 = A[k];
  837.                         r1 = Init1 & r3;
  838.                         r2 = A[k-1] | B[k-1];
  839.                         B[k] = ((Next[r3>>hh] | Next1[r3&LL]) & CMask) | ((A[k-1] | Next[r2>>hh] | Next1[r2&LL]) & r_NO_ERR) | r1;
  840.                     }
  841.                     if (DELIMITER) CurrentByteOffset += 1*D_length;
  842.                     else CurrentByteOffset += 1*1;
  843.                 }
  844.     Nextchar1file: 
  845.                 i=i+1;
  846.                 CurrentByteOffset ++;
  847.             } /* while i < end */
  848.  
  849.             strncpy(buffer, buffer+num_read, Maxline);
  850.         } /* while fill_buf... */
  851.         free_buf(Text, buffer);
  852.         return 0;
  853. #if    AGREP_POINTER
  854.     }
  855.     else {    /* within the memory buffer: assume it starts with a newline at position 0, the actual pattern follows that, and it ends with a '\n' */
  856.         num_read = agrep_inlen;
  857.         buffer = (CHAR *)agrep_inbuffer;
  858.         end = num_read;
  859.         /* buffer[end-1] = '\n';*/ /* at end of the text. */
  860.         /* buffer[0] = '\n';*/  /* in front of the  text. */
  861.         i = 0;
  862.  
  863.             /* An exact copy of the above RE1_PROCESS_WHEN_DNOTZERO: the while loop below */
  864.             while (i < end )
  865.             {
  866.                 c = buffer[i];
  867.                 CMask = Mask[c];
  868.                 if(c !=  Newline)
  869.                 {
  870.                     if(CMask != 0) {  
  871.                         r2 = B[0];
  872.                         r1 = Init1 & r2;
  873.                         A[0] = ((Next[r2>>hh] | Next1[r2&LL]) & CMask) | r1;
  874.                         r3 = B[1];
  875.                         r1 = Init1 & r3;
  876.                         r0 = r2 | A[0];     /* A[0] | B[0] */
  877.                         A[1] = ((Next[r3>>hh] | Next1[r3&LL]) & CMask) | (( r2 | Next[r0>>hh] | Next1[r0&LL])&r_NO_ERR) | r1 ;  
  878.                         if(D == 1) goto Nextcharmem;
  879.                         r2 = B[2];
  880.                         r1 = Init1 & r2;
  881.                         r0 = r3 | A[1];
  882.                         A[2] = ((Next[r2>>hh] | Next1[r2&LL]) & CMask) | ((r3 | Next[r0>>hh] | Next1[r0&LL])&r_NO_ERR) | r1 ;  
  883.                         if(D == 2) goto Nextcharmem;
  884.                         r3 = B[3];
  885.                         r1 = Init1 & r3;
  886.                         r0 = r2 | A[2];
  887.                         A[3] = ((Next[r3>>hh] | Next1[r3&LL]) & CMask) | ((r2 | Next[r0>>hh] | Next1[r0&LL])&r_NO_ERR) | r1 ;  
  888.                         if(D == 3) goto Nextcharmem;
  889.                         r2 = B[4];
  890.                         r1 = Init1 & r2;
  891.                         r0 = r3 | A[3];
  892.                         A[4] = ((Next[r2>>hh] | Next1[r2&LL]) & CMask) | ((r3 | Next[r0>>hh] | Next1[r0&LL])&r_NO_ERR) | r1 ;  
  893.                         if(D == 4)  goto Nextcharmem;
  894.                     }  /* if(CMask) */
  895.                     else  {
  896.                         r2 = B[0];
  897.                         A[0] = r2 & Init1; 
  898.                         r3 = B[1];
  899.                         r1 = Init1 & r3;
  900.                         r0 = r2 | A[0];
  901.                         A[1] = ((r2 | Next[r0>>hh] | Next1[r0&LL])&r_NO_ERR) | r1 ;  
  902.                         if(D == 1) goto Nextcharmem;
  903.                         r2 = B[2];
  904.                         r1 = Init1 & r2;
  905.                         r0 = r3 | A[1];
  906.                         A[2] = ((r3 | Next[r0>>hh] | Next1[r0&LL])&r_NO_ERR) | r1 ;  
  907.                         if(D == 2) goto Nextcharmem;
  908.                         r3 = B[3];
  909.                         r1 = Init1 & r3;
  910.                         r0 = r2 | A[2];
  911.                         A[3] = ((r2 | Next[r0>>hh] | Next1[r0&LL])&r_NO_ERR) | r1 ;  
  912.                         if(D == 3) goto Nextcharmem;
  913.                         r2 = B[4];
  914.                         r1 = Init1 & r2;
  915.                         r0 = r3 | A[3];
  916.                         A[4] = ((r3 | Next[r0>>hh] | Next1[r0&LL])&r_NO_ERR) | r1 ;  
  917.                         if(D == 4) goto Nextcharmem;
  918.                     }
  919.                 }
  920.                 else {  
  921.                     j++;
  922.                     if (DELIMITER) CurrentByteOffset -= D_length;
  923.                     else CurrentByteOffset -= 1;
  924.                     r1 = Init1 & B[D];            /* match against endofline */
  925.                     A[D] = ((Next[B[D]>>hh] | Next1[B[D]&LL]) & CMask) | r1;
  926.                     if(TAIL) A[D] = ( Next[A[D]>>hh] | Next1[A[D]&LL] ) | A[D]; 
  927.                     /* epsilon move */
  928.                     if(( A[D] & 1 ) ^ INVERSE) {
  929.                         if(FILENAMEONLY && (NEW_FILE || !POST_FILTER)) {
  930.                             num_of_matched++;
  931.  
  932.                             if (agrep_finalfp != NULL) 
  933.                                 fprintf(agrep_finalfp, "%s\n", CurrentFileName);
  934.                             else {
  935.                                 int outindex;
  936.                                 for(outindex=0; (outindex+agrep_outpointer<agrep_outlen) && 
  937.                                         (CurrentFileName[outindex] != '\0'); outindex++) {
  938.                                     agrep_outbuffer[agrep_outpointer+outindex] = CurrentFileName[outindex];
  939.                                 }
  940.                                 if ((CurrentFileName[outindex] != '\0') || (outindex+agrep_outpointer+1>=agrep_outlen)) {
  941.                                     OUTPUT_OVERFLOW;
  942.                                     free_buf(Text, buffer);
  943.                                     return -1;
  944.                                 }
  945.                                 else agrep_outbuffer[agrep_outpointer+outindex++] = '\n';
  946.                                 agrep_outpointer += outindex;
  947.                             }
  948.  
  949.                             free_buf(Text, buffer);
  950.                             NEW_FILE = OFF;
  951.                             return 0;
  952.                         } 
  953.                         if (-1 == r_output(buffer, i, end, j)) {free_buf(Text, buffer); return -1;}
  954.                         if ((LIMITOUTPUT > 0) && (LIMITOUTPUT <= num_of_matched)) {
  955.                             free_buf(Text, buffer);
  956.                             return 0;    /* done */
  957.                         }
  958.                     }
  959.                     for(k=0; k<=D; k++)  B[k] = Init[0];
  960.                     r1 = Init1 & B[0];
  961.                     A[0] = (( Next[B[0]>>hh] | Next1[B[0]&LL]) & CMask) | r1;
  962.                     for(k=1; k<=D; k++) {
  963.                         r3 = B[k];
  964.                         r1 = Init1 & r3;
  965.                         r2 = A[k-1] | B[k-1];
  966.                         A[k] = ((Next[r3>>hh] | Next1[r3&LL]) & CMask) | ((B[k-1] | Next[r2>>hh] | Next1[r2&LL]) & r_NO_ERR) | r1;
  967.                     }
  968.                     if (DELIMITER) CurrentByteOffset += 1*D_length;
  969.                     else CurrentByteOffset += 1*1;
  970.                 }
  971.     Nextcharmem: 
  972.                 i=i+1;
  973.                 CurrentByteOffset ++;
  974.                 c = buffer[i];
  975.                 CMask = Mask[c];
  976.                 if(c != Newline)
  977.                 {
  978.                     if(CMask != 0) {  
  979.                         r2 = A[0];
  980.                         r1 = Init1 & r2;
  981.                         B[0] = ((Next[r2>>hh] | Next1[r2&LL]) & CMask) | r1;
  982.                         r3 = A[1];
  983.                         r1 = Init1 & r3;
  984.                         r0 = B[0] | r2;
  985.                         B[1] = ((Next[r3>>hh] | Next1[r3&LL]) & CMask) | ((r2 | Next[r0>>hh] | Next1[r0&LL]) & r_NO_ERR) | r1 ;  
  986.                         if(D == 1) goto Nextchar1mem;
  987.                         r2 = A[2];
  988.                         r1 = Init1 & r2;
  989.                         r0 = B[1] | r3;
  990.                         B[2] = ((Next[r2>>hh] | Next1[r2&LL]) & CMask) | ((r3 | Next[r0>>hh] | Next1[r0&LL])&r_NO_ERR) | r1 ;  
  991.                         if(D == 2) goto Nextchar1mem;
  992.                         r3 = A[3];
  993.                         r1 = Init1 & r3;
  994.                         r0 = B[2] | r2;
  995.                         B[3] = ((Next[r3>>hh] | Next1[r3&LL]) & CMask) | ((r2 | Next[r0>>hh] | Next1[r0&LL])&r_NO_ERR) | r1 ;  
  996.                         if(D == 3) goto Nextchar1mem;
  997.                         r2 = A[4];
  998.                         r1 = Init1 & r2;
  999.                         r0 = B[3] | r3;
  1000.                         B[4] = ((Next[r2>>hh] | Next1[r2&LL]) & CMask) | ((r3 | Next[r0>>hh] | Next1[r0&LL])&r_NO_ERR) | r1 ;  
  1001.                         if(D == 4)   goto Nextchar1mem;
  1002.                     }  /* if(CMask) */
  1003.                     else  {
  1004.                         r2 = A[0];
  1005.                         B[0] = r2 & Init1; 
  1006.                         r3 = A[1];
  1007.                         r1 = Init1 & r3;
  1008.                         r0 = B[0] | r2;
  1009.                         B[1] = ((r2 | Next[r0>>hh] | Next1[r0&LL])&r_NO_ERR) | r1 ;  
  1010.                         if(D == 1) goto Nextchar1mem;
  1011.                         r2 = A[2];
  1012.                         r1 = Init1 & r2;
  1013.                         r0 = B[1] | r3;
  1014.                         B[2] = ((r3 | Next[r0>>hh] | Next1[r0&LL])&r_NO_ERR) | r1 ;  
  1015.                         if(D == 2) goto Nextchar1mem;
  1016.                         r3 = A[3];
  1017.                         r1 = Init1 & r3;
  1018.                         r0 = B[2] | r2;
  1019.                         B[3] = ((r2 | Next[r0>>hh] | Next1[r0&LL])&r_NO_ERR) | r1 ;  
  1020.                         if(D == 3) goto Nextchar1mem;
  1021.                         r2 = A[4];
  1022.                         r1 = Init1 & r2;
  1023.                         r0 = B[3] | r3;
  1024.                         B[4] = ((r3 | Next[r0>>hh] | Next1[r0&LL])&r_NO_ERR) | r1 ;  
  1025.                         if(D == 4) goto Nextchar1mem;
  1026.                     }
  1027.                 } /* if(NOT Newline) */
  1028.                 else {  
  1029.                     j++;
  1030.                     if (DELIMITER) CurrentByteOffset -= D_length;
  1031.                     else CurrentByteOffset -= 1;
  1032.                     r1 = Init1 & A[D];            /* match against endofline */
  1033.                     B[D] = ((Next[A[D]>>hh] | Next1[A[D]&LL]) & CMask) | r1;
  1034.                     if(TAIL) B[D] = ( Next[B[D]>>hh] | Next1[B[D]&LL] ) | B[D]; 
  1035.                     /* epsilon move */
  1036.                     if(( B[D] & 1 ) ^ INVERSE) {
  1037.                         if(FILENAMEONLY && (NEW_FILE || !POST_FILTER)) {
  1038.                             num_of_matched++;
  1039.  
  1040.                             if (agrep_finalfp != NULL) 
  1041.                                 fprintf(agrep_finalfp, "%s\n", CurrentFileName);
  1042.                             else {
  1043.                                 int outindex;
  1044.                                 for(outindex=0; (outindex+agrep_outpointer<agrep_outlen) && 
  1045.                                         (CurrentFileName[outindex] != '\0'); outindex++) {
  1046.                                     agrep_outbuffer[agrep_outpointer+outindex] = CurrentFileName[outindex];
  1047.                                 }
  1048.                                 if ((CurrentFileName[outindex] != '\0') || (outindex+agrep_outpointer+1>=agrep_outlen)) {
  1049.                                     OUTPUT_OVERFLOW;
  1050.                                     free_buf(Text, buffer);
  1051.                                     return -1;
  1052.                                 }
  1053.                                 else agrep_outbuffer[agrep_outpointer+outindex++] = '\n';
  1054.                                 agrep_outpointer += outindex;
  1055.                             }
  1056.  
  1057.                             free_buf(Text, buffer);
  1058.                             NEW_FILE = OFF;
  1059.                             return 0;
  1060.                         } 
  1061.                         if (-1 == r_output(buffer, i, end, j)) {free_buf(Text, buffer); return -1;}
  1062.                         if ((LIMITOUTPUT > 0) && (LIMITOUTPUT <= num_of_matched)) {
  1063.                             free_buf(Text, buffer);
  1064.                             return 0;    /* done */
  1065.                         }
  1066.                     }
  1067.                     for(k=0; k<=D; k++) A[k] = Init0; 
  1068.                     r1 = Init1 & A[0];
  1069.                     B[0] = ((Next[A[0]>>hh] | Next1[A[0]&LL]) & CMask) | r1;
  1070.                     for(k=1; k<=D; k++) {
  1071.                         r3 = A[k];
  1072.                         r1 = Init1 & r3;
  1073.                         r2 = A[k-1] | B[k-1];
  1074.                         B[k] = ((Next[r3>>hh] | Next1[r3&LL]) & CMask) | ((A[k-1] | Next[r2>>hh] | Next1[r2&LL]) & r_NO_ERR) | r1;
  1075.                     }
  1076.                     if (DELIMITER) CurrentByteOffset += 1*D_length;
  1077.                     else CurrentByteOffset += 1*1;
  1078.                 }
  1079.     Nextchar1mem: 
  1080.                 i=i+1;
  1081.                 CurrentByteOffset ++;
  1082.             } /* while i < end */
  1083.  
  1084.         return 0;
  1085.     }
  1086. #endif    /*AGREP_POINTER*/
  1087. } /* re1 */
  1088.  
  1089. re(Text, M, D)
  1090. int Text, M, D;
  1091. {
  1092.     register unsigned i, c, r1, r2, r3, CMask, k, Newline, Init0, Init1, end; 
  1093.     register unsigned r_even, r_odd, r_NO_ERR ;
  1094.     unsigned RMask[MAXSYM];
  1095.     unsigned A[MaxRerror+1], B[MaxRerror+1];
  1096.     int num_read, j=0, lasti, base, ResidueSize; 
  1097.     int FIRST_TIME; /* Flag */
  1098.     CHAR *buffer;
  1099.  
  1100.     base = WORD - M;
  1101.     k = 2*exponen(M);
  1102.     if(FIRST_IN_RE) {
  1103.         compute_next(M, Next, Next1); 
  1104.         FIRST_IN_RE = 0;    
  1105.     }
  1106.     for(i=0; i< MAXSYM; i++) RMask[i] = Mask[i];
  1107.     r_NO_ERR = NO_ERR_MASK;
  1108.     Newline = '\n';
  1109.     Init0 = Init[0] = Bit[base];
  1110.     if(HEAD) Init0  = Init[0] = Init0 | Bit[base+1] ;
  1111.     for(i=1; i<= D; i++) Init[i] = Init[i-1] | Next[Init[i-1]]; /* can be out? */
  1112.     Init1 = Init0 | 1; 
  1113.     r2 = r3 = Init0;
  1114.     for(k=0; k<= D; k++) { 
  1115.         A[k] = B[k] = Init[0]; 
  1116.     }  /* can be out? */
  1117.     FIRST_TIME = ON;
  1118.     alloc_buf(Text, &buffer, BlockSize+Maxline+1);
  1119.     if ( D == 0 )
  1120.     {
  1121. #if    AGREP_POINTER
  1122.         if(Text != -1) {
  1123. #endif    /*AGREP_POINTER*/
  1124.         lasti = Maxline;
  1125.         while ((num_read = fill_buf(Text, buffer + Maxline, BlockSize)) > 0)
  1126.         {
  1127.             i=Maxline; 
  1128.             end = Maxline + num_read ;
  1129.             if((num_read < BlockSize)&&buffer[end-1] != '\n') buffer[end] = '\n';
  1130.             if(FIRST_TIME) {
  1131.                 buffer[i-1] = '\n';
  1132.                 i--;
  1133.                 CurrentByteOffset --;
  1134.                 FIRST_TIME = 0;
  1135.             }
  1136.  
  1137.             /* RE_PROCESS_WHEN_DZERO: the while-loop below */
  1138.             while (i < end) 
  1139.             {
  1140.                 c = buffer[i++];
  1141.                 CurrentByteOffset ++;
  1142.                 CMask = RMask[c];
  1143.                 if(c != Newline)
  1144.                 {  
  1145.                     r1 = Init1 & r3;
  1146.                     r2 = (Next[r3] & CMask) | r1;
  1147.                 }
  1148.                 else {  
  1149.                     r1 = Init1 & r3;            /* match against '\n' */
  1150.                     r2 = Next[r3] & CMask | r1;
  1151.                     j++;
  1152.                     if (DELIMITER) CurrentByteOffset -= D_length;
  1153.                     else CurrentByteOffset -= 1;
  1154.                     if(TAIL) r2 = Next[r2] | r2 ;   /* epsilon move */
  1155.                     if(( r2 & 1) ^ INVERSE) {
  1156.                         if(FILENAMEONLY && (NEW_FILE || !POST_FILTER)) {
  1157.                             num_of_matched++;
  1158.  
  1159.                             if (agrep_finalfp != NULL) 
  1160.                                 fprintf(agrep_finalfp, "%s\n", CurrentFileName);
  1161.                             else {
  1162.                                 int outindex;
  1163.                                 for(outindex=0; (outindex+agrep_outpointer<agrep_outlen) && 
  1164.                                         (CurrentFileName[outindex] != '\0'); outindex++) {
  1165.                                     agrep_outbuffer[agrep_outpointer+outindex] = CurrentFileName[outindex];
  1166.                                 }
  1167.                                 if ((CurrentFileName[outindex] != '\0') || (outindex+agrep_outpointer+1>=agrep_outlen)) {
  1168.                                     OUTPUT_OVERFLOW;
  1169.                                     free_buf(Text, buffer);
  1170.                                     return -1;
  1171.                                 }
  1172.                                 else agrep_outbuffer[agrep_outpointer+outindex++] = '\n';
  1173.                                 agrep_outpointer += outindex;
  1174.                             }
  1175.  
  1176.                             free_buf(Text, buffer);
  1177.                             NEW_FILE = OFF;
  1178.                             return 0;
  1179.                         } 
  1180.                         if (-1 == r_output(buffer, i-1, end, j)) {free_buf(Text, buffer); return -1;}
  1181.                         if ((LIMITOUTPUT > 0) && (LIMITOUTPUT <= num_of_matched)) {
  1182.                             free_buf(Text, buffer);
  1183.                             return 0;    /* done */
  1184.                         }
  1185.                     }
  1186.                     lasti = i - 1;
  1187.                     r3 = Init0;
  1188.                     r2 = (Next[r3] & CMask) | Init0;
  1189.                     if (DELIMITER) CurrentByteOffset += 1*D_length;
  1190.                     else CurrentByteOffset += 1*1;
  1191.                 }
  1192.                 c = buffer[i++];   
  1193.                 CurrentByteOffset ++;
  1194.                 CMask = RMask[c];
  1195.                 if(c != Newline)
  1196.                 {
  1197.                     r1 = Init1 & r2;
  1198.                     r3 = (Next[r2] & CMask) | r1;
  1199.                 }
  1200.                 else {  
  1201.                     j++;
  1202.                     if (DELIMITER) CurrentByteOffset -= D_length;
  1203.                     else CurrentByteOffset -= 1;
  1204.                     r1 = Init1 & r2;            /* match against endofline */
  1205.                     r3 = Next[r2] & CMask | r1;
  1206.                     if(TAIL) r3 = Next[r3] | r3;
  1207.                     if(( r3 & 1) ^ INVERSE) {
  1208.                         if(FILENAMEONLY && (NEW_FILE || !POST_FILTER)) {
  1209.                             num_of_matched++;
  1210.  
  1211.                             if (agrep_finalfp != NULL) 
  1212.                                 fprintf(agrep_finalfp, "%s\n", CurrentFileName);
  1213.                             else {
  1214.                                 int outindex;
  1215.                                 for(outindex=0; (outindex+agrep_outpointer<agrep_outlen) && 
  1216.                                         (CurrentFileName[outindex] != '\0'); outindex++) {
  1217.                                     agrep_outbuffer[agrep_outpointer+outindex] = CurrentFileName[outindex];
  1218.                                 }
  1219.                                 if ((CurrentFileName[outindex] != '\0') || (outindex+agrep_outpointer+1>=agrep_outlen)) {
  1220.                                     OUTPUT_OVERFLOW;
  1221.                                     free_buf(Text, buffer);
  1222.                                     return -1;
  1223.                                 }
  1224.                                 else agrep_outbuffer[agrep_outpointer+outindex++] = '\n';
  1225.                                 agrep_outpointer += outindex;
  1226.                             }
  1227.  
  1228.                             free_buf(Text, buffer);
  1229.                             NEW_FILE = OFF;
  1230.                             return 0;
  1231.                         } 
  1232.                         if (-1 == r_output(buffer, i-1, end, j)) {free_buf(Text, buffer); return -1;}
  1233.                         if ((LIMITOUTPUT > 0) && (LIMITOUTPUT <= num_of_matched)) {
  1234.                             free_buf(Text, buffer);
  1235.                             return 0;    /* done */
  1236.                         }
  1237.                     }
  1238.                     lasti = i - 1;
  1239.                     r2 = Init0; 
  1240.                     r3 = (Next[r2] & CMask) | Init0;  /* match the newline */
  1241.                     if (DELIMITER) CurrentByteOffset += 1*D_length;
  1242.                     else CurrentByteOffset += 1*1;
  1243.                 }
  1244.             } /* while */
  1245.  
  1246.             ResidueSize = Maxline + num_read - lasti;
  1247.             if(ResidueSize > Maxline) {
  1248.                 ResidueSize = Maxline;  
  1249.             }
  1250.             strncpy(buffer+Maxline-ResidueSize, buffer+lasti, ResidueSize);
  1251.             lasti = Maxline - ResidueSize;
  1252.         } /* while fill_buf() */
  1253.         free_buf(Text, buffer);
  1254.         return 0;
  1255. #if    AGREP_POINTER
  1256.         }
  1257.         else {
  1258.         num_read = agrep_inlen;
  1259.         buffer = (CHAR *)agrep_inbuffer;
  1260.         end = num_read;
  1261.         /* buffer[end-1] = '\n';*/ /* at end of the text. */
  1262.         /* buffer[0] = '\n';*/  /* in front of the  text. */
  1263.         i = 0;
  1264.         lasti = 1;
  1265.  
  1266.             /* An exact copy of the above RE_PROCESS_WHEN_DZERO: the while-loop below */
  1267.             while (i < end) 
  1268.             {
  1269.                 c = buffer[i++];
  1270.                 CurrentByteOffset ++;
  1271.                 CMask = RMask[c];
  1272.                 if(c != Newline)
  1273.                 {  
  1274.                     r1 = Init1 & r3;
  1275.                     r2 = (Next[r3] & CMask) | r1;
  1276.                 }
  1277.                 else {  
  1278.                     r1 = Init1 & r3;            /* match against '\n' */
  1279.                     r2 = Next[r3] & CMask | r1;
  1280.                     j++;
  1281.                     if (DELIMITER) CurrentByteOffset -= D_length;
  1282.                     else CurrentByteOffset -= 1;
  1283.                     if(TAIL) r2 = Next[r2] | r2 ;   /* epsilon move */
  1284.                     if(( r2 & 1) ^ INVERSE) {
  1285.                         if(FILENAMEONLY && (NEW_FILE || !POST_FILTER)) {
  1286.                             num_of_matched++;
  1287.  
  1288.                             if (agrep_finalfp != NULL) 
  1289.                                 fprintf(agrep_finalfp, "%s\n", CurrentFileName);
  1290.                             else {
  1291.                                 int outindex;
  1292.                                 for(outindex=0; (outindex+agrep_outpointer<agrep_outlen) && 
  1293.                                         (CurrentFileName[outindex] != '\0'); outindex++) {
  1294.                                     agrep_outbuffer[agrep_outpointer+outindex] = CurrentFileName[outindex];
  1295.                                 }
  1296.                                 if ((CurrentFileName[outindex] != '\0') || (outindex+agrep_outpointer+1>=agrep_outlen)) {
  1297.                                     OUTPUT_OVERFLOW;
  1298.                                     free_buf(Text, buffer);
  1299.                                     return -1;
  1300.                                 }
  1301.                                 else agrep_outbuffer[agrep_outpointer+outindex++] = '\n';
  1302.                                 agrep_outpointer += outindex;
  1303.                             }
  1304.  
  1305.                             free_buf(Text, buffer);
  1306.                             NEW_FILE = OFF;
  1307.                             return 0;
  1308.                         } 
  1309.                         if (-1 == r_output(buffer, i-1, end, j)) {free_buf(Text, buffer); return -1;}
  1310.                         if ((LIMITOUTPUT > 0) && (LIMITOUTPUT <= num_of_matched)) {
  1311.                             free_buf(Text, buffer);
  1312.                             return 0;    /* done */
  1313.                         }
  1314.                     }
  1315.                     lasti = i - 1;
  1316.                     r3 = Init0;
  1317.                     r2 = (Next[r3] & CMask) | Init0;
  1318.                     if (DELIMITER) CurrentByteOffset += 1*D_length;
  1319.                     else CurrentByteOffset += 1*1;
  1320.                 }
  1321.                 c = buffer[i++];   
  1322.                 CurrentByteOffset ++;
  1323.                 CMask = RMask[c];
  1324.                 if(c != Newline)
  1325.                 {
  1326.                     r1 = Init1 & r2;
  1327.                     r3 = (Next[r2] & CMask) | r1;
  1328.                 }
  1329.                 else {  
  1330.                     j++;
  1331.                     if (DELIMITER) CurrentByteOffset -= D_length;
  1332.                     else CurrentByteOffset -= 1;
  1333.                     r1 = Init1 & r2;            /* match against endofline */
  1334.                     r3 = Next[r2] & CMask | r1;
  1335.                     if(TAIL) r3 = Next[r3] | r3;
  1336.                     if(( r3 & 1) ^ INVERSE) {
  1337.                         if(FILENAMEONLY && (NEW_FILE || !POST_FILTER)) {
  1338.                             num_of_matched++;
  1339.  
  1340.                             if (agrep_finalfp != NULL) 
  1341.                                 fprintf(agrep_finalfp, "%s\n", CurrentFileName);
  1342.                             else {
  1343.                                 int outindex;
  1344.                                 for(outindex=0; (outindex+agrep_outpointer<agrep_outlen) && 
  1345.                                         (CurrentFileName[outindex] != '\0'); outindex++) {
  1346.                                     agrep_outbuffer[agrep_outpointer+outindex] = CurrentFileName[outindex];
  1347.                                 }
  1348.                                 if ((CurrentFileName[outindex] != '\0') || (outindex+agrep_outpointer+1>=agrep_outlen)) {
  1349.                                     OUTPUT_OVERFLOW;
  1350.                                     free_buf(Text, buffer);
  1351.                                     return -1;
  1352.                                 }
  1353.                                 else agrep_outbuffer[agrep_outpointer+outindex++] = '\n';
  1354.                                 agrep_outpointer += outindex;
  1355.                             }
  1356.  
  1357.                             free_buf(Text, buffer);
  1358.                             NEW_FILE = OFF;
  1359.                             return 0;
  1360.                         } 
  1361.                         if (-1 == r_output(buffer, i-1, end, j)) {free_buf(Text, buffer); return -1;}
  1362.                         if ((LIMITOUTPUT > 0) && (LIMITOUTPUT <= num_of_matched)) {
  1363.                             free_buf(Text, buffer);
  1364.                             return 0;    /* done */
  1365.                         }
  1366.                     }
  1367.                     lasti = i - 1;
  1368.                     r2 = Init0; 
  1369.                     r3 = (Next[r2] & CMask) | Init0;  /* match the newline */
  1370.                     if (DELIMITER) CurrentByteOffset += 1*D_length;
  1371.                     else CurrentByteOffset += 1*1;
  1372.                 }
  1373.             } /* while */
  1374.  
  1375.         /* If a residue is left for within-memory-buffer, since nothing can be "read" after that, we can ignore it: as if only 1 iteration of while */
  1376.         return 0;
  1377.         }
  1378. #endif    /*AGREP_POINTER*/
  1379.     } /* end if(D==0) */
  1380.  
  1381. #if    AGREP_POINTER
  1382.     if (Text != -1) {
  1383. #endif    /*AGREP_POINTER*/
  1384.         while ((num_read = fill_buf(Text, buffer + Maxline, BlockSize)) > 0)
  1385.         {
  1386.             i=Maxline; 
  1387.             end = Maxline+num_read;
  1388.             if((num_read < BlockSize) && buffer[end-1] != '\n') buffer[end] = '\n';
  1389.             if(FIRST_TIME) {
  1390.                 buffer[i-1] = '\n';
  1391.                 i--;
  1392.                 CurrentByteOffset --;
  1393.                 FIRST_TIME = 0;
  1394.             }
  1395.  
  1396.             /* RE_PROCESS_WHEN_DNOTZERO: the while-loop below */
  1397.             while (i < end)
  1398.             {   
  1399.                 c = buffer[i++];
  1400.                 CurrentByteOffset ++;
  1401.                 CMask = RMask[c];
  1402.                 if (c != Newline)
  1403.                 {  
  1404.                     r_even = B[0];
  1405.                     r1 = Init1 & r_even;
  1406.                     A[0] = (Next[r_even] & CMask) | r1;
  1407.                     r_odd = B[1];
  1408.                     r1 = Init1 & r_odd;
  1409.                     r2 = (r_even | Next[r_even|A[0]]) &r_NO_ERR;
  1410.                     A[1] = (Next[r_odd] & CMask) | r2 | r1 ;  
  1411.                     if(D == 1) goto Nextcharfile;
  1412.                     r_even = B[2];
  1413.                     r1 = Init1 & r_even;
  1414.                     r2 = (r_odd | Next[r_odd|A[1]]) &r_NO_ERR;
  1415.                     A[2] = (Next[r_even] & CMask) | r2 | r1 ;  
  1416.                     if(D == 2) goto Nextcharfile;
  1417.                     r_odd = B[3];
  1418.                     r1 = Init1 & r_odd;
  1419.                     r2 = (r_even | Next[r_even|A[2]]) &r_NO_ERR;
  1420.                     A[3] = (Next[r_odd] & CMask) | r2 | r1 ;  
  1421.                     if(D == 3) goto Nextcharfile;
  1422.                     r_even = B[4];
  1423.                     r1 = Init1 & r_even;
  1424.                     r2 = (r_odd | Next[r_odd|A[3]]) &r_NO_ERR;
  1425.                     A[4] = (Next[r_even] & CMask) | r2 | r1 ;  
  1426.                     goto Nextcharfile;
  1427.                 } /* if NOT Newline */
  1428.                 else {  
  1429.                     j++;
  1430.                     if (DELIMITER) CurrentByteOffset -= D_length;
  1431.                     else CurrentByteOffset -= 1;
  1432.                     r1 = Init1 & B[D];               /* match endofline */
  1433.                     A[D] = (Next[B[D]] & CMask) | r1;
  1434.                     if(TAIL) A[D] = Next[A[D]] | A[D];
  1435.                     if((A[D] & 1) ^ INVERSE )  {
  1436.                         if(FILENAMEONLY && (NEW_FILE || !POST_FILTER)) {
  1437.                             num_of_matched++;    
  1438.  
  1439.                             if (agrep_finalfp != NULL) 
  1440.                                 fprintf(agrep_finalfp, "%s\n", CurrentFileName);
  1441.                             else {
  1442.                                 int outindex;
  1443.                                 for(outindex=0; (outindex+agrep_outpointer<agrep_outlen) && 
  1444.                                         (CurrentFileName[outindex] != '\0'); outindex++) {
  1445.                                     agrep_outbuffer[agrep_outpointer+outindex] = CurrentFileName[outindex];
  1446.                                 }
  1447.                                 if ((CurrentFileName[outindex] != '\0') || (outindex+agrep_outpointer+1>=agrep_outlen)) {
  1448.                                     OUTPUT_OVERFLOW;
  1449.                                     free_buf(Text, buffer);
  1450.                                     return -1;
  1451.                                 }
  1452.                                 else agrep_outbuffer[agrep_outpointer+outindex++] = '\n';
  1453.                                 agrep_outpointer += outindex;
  1454.                             }
  1455.  
  1456.                             free_buf(Text, buffer);
  1457.                             NEW_FILE = OFF;
  1458.                             return 0;
  1459.                         }  
  1460.                         if (-1 == r_output(buffer, i-1, end, j)) {free_buf(Text, buffer); return -1;}
  1461.                         if ((LIMITOUTPUT > 0) && (LIMITOUTPUT <= num_of_matched)) {
  1462.                             free_buf(Text, buffer);
  1463.                             return 0;    /* done */
  1464.                         }
  1465.                     }
  1466.                     for(k=0; k<= D; k++) { 
  1467.                         A[k] = B[k] = Init[k]; 
  1468.                     }
  1469.                     r1 = Init1 & B[0]; 
  1470.                     A[0] = (Next[B[0]] & CMask) | r1;
  1471.                     for(k=1; k<= D; k++) {
  1472.                         r1 = Init1 & B[k];
  1473.                         r2 = (B[k-1] | Next[A[k-1]|B[k-1]]) &r_NO_ERR;
  1474.                         A[k] = (Next[B[k]] & CMask) | r1 | r2;
  1475.                     }
  1476.                     if (DELIMITER) CurrentByteOffset += 1*D_length;
  1477.                     else CurrentByteOffset += 1*1;
  1478.                 }
  1479.     Nextcharfile: 
  1480.                 c = buffer[i];
  1481.                 CMask = RMask[c];
  1482.                 if(c != Newline)
  1483.                 { 
  1484.                     r1 = Init1 & A[0];
  1485.                     B[0] = (Next[A[0]] & CMask) | r1;
  1486.                     r1 = Init1 & A[1];
  1487.                     B[1] = (Next[A[1]] & CMask) | ((A[0] | Next[A[0] | B[0]]) & r_NO_ERR) | r1 ;  
  1488.                     if(D == 1) goto Nextchar1file;
  1489.                     r1 = Init1 & A[2];
  1490.                     B[2] = (Next[A[2]] & CMask) | ((A[1] | Next[A[1] | B[1]]) &r_NO_ERR) | r1 ;  
  1491.                     if(D == 2) goto Nextchar1file;
  1492.                     r1 = Init1 & A[3];
  1493.                     B[3] = (Next[A[3]] & CMask) | ((A[2] | Next[A[2] | B[2]])&r_NO_ERR) | r1 ;  
  1494.                     if(D == 3) goto Nextchar1file;
  1495.                     r1 = Init1 & A[4];
  1496.                     B[4] = (Next[A[4]] & CMask) | ((A[3] | Next[A[3] | B[3]])&r_NO_ERR) | r1 ;  
  1497.                     goto Nextchar1file;
  1498.                 } /* if(NOT Newline) */
  1499.                 else {  
  1500.                     j++;
  1501.                     if (DELIMITER) CurrentByteOffset -= D_length;
  1502.                     else CurrentByteOffset -= 1;
  1503.                     r1 = Init1 & A[D];               /* match endofline */
  1504.                     B[D] = (Next[A[D]] & CMask) | r1;
  1505.                     if(TAIL) B[D] = Next[B[D]] | B[D];
  1506.                     if((B[D] & 1) ^ INVERSE )  {
  1507.                         if(FILENAMEONLY && (NEW_FILE || !POST_FILTER)) {
  1508.                             num_of_matched++;
  1509.  
  1510.                             if (agrep_finalfp != NULL) 
  1511.                                 fprintf(agrep_finalfp, "%s\n", CurrentFileName);
  1512.                             else {
  1513.                                 int outindex;
  1514.                                 for(outindex=0; (outindex+agrep_outpointer<agrep_outlen) && 
  1515.                                         (CurrentFileName[outindex] != '\0'); outindex++) {
  1516.                                     agrep_outbuffer[agrep_outpointer+outindex] = CurrentFileName[outindex];
  1517.                                 }
  1518.                                 if ((CurrentFileName[outindex] != '\0') || (outindex+agrep_outpointer+1>=agrep_outlen)) {
  1519.                                     OUTPUT_OVERFLOW;
  1520.                                     free_buf(Text, buffer);
  1521.                                     return -1;
  1522.                                 }
  1523.                                 else agrep_outbuffer[agrep_outpointer+outindex++] = '\n';
  1524.                                 agrep_outpointer += outindex;
  1525.                             }
  1526.  
  1527.                             free_buf(Text, buffer);
  1528.                             NEW_FILE = OFF;
  1529.                             return 0;
  1530.                         } 
  1531.                         if (-1 == r_output(buffer, i, end, j)) {free_buf(Text, buffer); return -1;}
  1532.                         if ((LIMITOUTPUT > 0) && (LIMITOUTPUT <= num_of_matched)) {
  1533.                             free_buf(Text, buffer);
  1534.                             return 0;    /* done */
  1535.                         }
  1536.                     }
  1537.                     for(k=0; k<= D; k++) { 
  1538.                         A[k] = B[k] = Init[k]; 
  1539.                     }
  1540.                     r1 = Init1 & A[0]; 
  1541.                     B[0] = (Next[A[0]] & CMask) | r1;
  1542.                     for(k=1; k<= D; k++) {
  1543.                         r1 = Init1 & A[k];
  1544.                         r2 = (A[k-1] | Next[A[k-1]|B[k-1]])&r_NO_ERR;
  1545.                         B[k] = (Next[A[k]] & CMask) | r1 | r2;
  1546.                     }
  1547.                     if (DELIMITER) CurrentByteOffset += 1*D_length;
  1548.                     else CurrentByteOffset += 1*1;
  1549.                 }
  1550.     Nextchar1file: 
  1551.                 i++;
  1552.                 CurrentByteOffset ++;
  1553.             } /* while i < end */
  1554.  
  1555.             strncpy(buffer, buffer+num_read, Maxline);
  1556.         } /* while  fill_buf() */
  1557.         free_buf(Text, buffer);
  1558.         return 0;
  1559. #if    AGREP_POINTER
  1560.     }
  1561.     else {
  1562.         num_read = agrep_inlen;
  1563.         buffer = (CHAR *)agrep_inbuffer;
  1564.         end = num_read;
  1565.         /* buffer[end-1] = '\n';*/ /* at end of the text. */
  1566.         /* buffer[0] = '\n';*/  /* in front of the  text. */
  1567.         i = 0;
  1568.  
  1569.             /* An exact copy of the above RE_PROCESS_WHEN_DNOTZERO: the while-loop below */
  1570.             while (i < end)
  1571.             {   
  1572.                 c = buffer[i++];
  1573.                 CurrentByteOffset ++;
  1574.                 CMask = RMask[c];
  1575.                 if (c != Newline)
  1576.                 {  
  1577.                     r_even = B[0];
  1578.                     r1 = Init1 & r_even;
  1579.                     A[0] = (Next[r_even] & CMask) | r1;
  1580.                     r_odd = B[1];
  1581.                     r1 = Init1 & r_odd;
  1582.                     r2 = (r_even | Next[r_even|A[0]]) &r_NO_ERR;
  1583.                     A[1] = (Next[r_odd] & CMask) | r2 | r1 ;  
  1584.                     if(D == 1) goto Nextcharmem;
  1585.                     r_even = B[2];
  1586.                     r1 = Init1 & r_even;
  1587.                     r2 = (r_odd | Next[r_odd|A[1]]) &r_NO_ERR;
  1588.                     A[2] = (Next[r_even] & CMask) | r2 | r1 ;  
  1589.                     if(D == 2) goto Nextcharmem;
  1590.                     r_odd = B[3];
  1591.                     r1 = Init1 & r_odd;
  1592.                     r2 = (r_even | Next[r_even|A[2]]) &r_NO_ERR;
  1593.                     A[3] = (Next[r_odd] & CMask) | r2 | r1 ;  
  1594.                     if(D == 3) goto Nextcharmem;
  1595.                     r_even = B[4];
  1596.                     r1 = Init1 & r_even;
  1597.                     r2 = (r_odd | Next[r_odd|A[3]]) &r_NO_ERR;
  1598.                     A[4] = (Next[r_even] & CMask) | r2 | r1 ;  
  1599.                     goto Nextcharmem;
  1600.                 } /* if NOT Newline */
  1601.                 else {  
  1602.                     j++;
  1603.                     if (DELIMITER) CurrentByteOffset -= D_length;
  1604.                     else CurrentByteOffset -= 1;
  1605.                     r1 = Init1 & B[D];               /* match endofline */
  1606.                     A[D] = (Next[B[D]] & CMask) | r1;
  1607.                     if(TAIL) A[D] = Next[A[D]] | A[D];
  1608.                     if((A[D] & 1) ^ INVERSE )  {
  1609.                         if(FILENAMEONLY && (NEW_FILE || !POST_FILTER)) {
  1610.                             num_of_matched++;    
  1611.  
  1612.                             if (agrep_finalfp != NULL) 
  1613.                                 fprintf(agrep_finalfp, "%s\n", CurrentFileName);
  1614.                             else {
  1615.                                 int outindex;
  1616.                                 for(outindex=0; (outindex+agrep_outpointer<agrep_outlen) && 
  1617.                                         (CurrentFileName[outindex] != '\0'); outindex++) {
  1618.                                     agrep_outbuffer[agrep_outpointer+outindex] = CurrentFileName[outindex];
  1619.                                 }
  1620.                                 if ((CurrentFileName[outindex] != '\0') || (outindex+agrep_outpointer+1>=agrep_outlen)) {
  1621.                                     OUTPUT_OVERFLOW;
  1622.                                     free_buf(Text, buffer);
  1623.                                     return -1;
  1624.                                 }
  1625.                                 else agrep_outbuffer[agrep_outpointer+outindex++] = '\n';
  1626.                                 agrep_outpointer += outindex;
  1627.                             }
  1628.  
  1629.                             free_buf(Text, buffer);
  1630.                             NEW_FILE = OFF;
  1631.                             return 0;
  1632.                         }  
  1633.                         if (-1 == r_output(buffer, i-1, end, j)) {free_buf(Text, buffer); return -1;}
  1634.                         if ((LIMITOUTPUT > 0) && (LIMITOUTPUT <= num_of_matched)) {
  1635.                             free_buf(Text, buffer);
  1636.                             return 0;    /* done */
  1637.                         }
  1638.                     }
  1639.                     for(k=0; k<= D; k++) { 
  1640.                         A[k] = B[k] = Init[k]; 
  1641.                     }
  1642.                     r1 = Init1 & B[0]; 
  1643.                     A[0] = (Next[B[0]] & CMask) | r1;
  1644.                     for(k=1; k<= D; k++) {
  1645.                         r1 = Init1 & B[k];
  1646.                         r2 = (B[k-1] | Next[A[k-1]|B[k-1]]) &r_NO_ERR;
  1647.                         A[k] = (Next[B[k]] & CMask) | r1 | r2;
  1648.                     }
  1649.                     if (DELIMITER) CurrentByteOffset += 1*D_length;
  1650.                     else CurrentByteOffset += 1*1;
  1651.                 }
  1652.     Nextcharmem: 
  1653.                 c = buffer[i];
  1654.                 CMask = RMask[c];
  1655.                 if(c != Newline)
  1656.                 { 
  1657.                     r1 = Init1 & A[0];
  1658.                     B[0] = (Next[A[0]] & CMask) | r1;
  1659.                     r1 = Init1 & A[1];
  1660.                     B[1] = (Next[A[1]] & CMask) | ((A[0] | Next[A[0] | B[0]]) & r_NO_ERR) | r1 ;  
  1661.                     if(D == 1) goto Nextchar1mem;
  1662.                     r1 = Init1 & A[2];
  1663.                     B[2] = (Next[A[2]] & CMask) | ((A[1] | Next[A[1] | B[1]]) &r_NO_ERR) | r1 ;  
  1664.                     if(D == 2) goto Nextchar1mem;
  1665.                     r1 = Init1 & A[3];
  1666.                     B[3] = (Next[A[3]] & CMask) | ((A[2] | Next[A[2] | B[2]])&r_NO_ERR) | r1 ;  
  1667.                     if(D == 3) goto Nextchar1mem;
  1668.                     r1 = Init1 & A[4];
  1669.                     B[4] = (Next[A[4]] & CMask) | ((A[3] | Next[A[3] | B[3]])&r_NO_ERR) | r1 ;  
  1670.                     goto Nextchar1mem;
  1671.                 } /* if(NOT Newline) */
  1672.                 else {  
  1673.                     j++;
  1674.                     if (DELIMITER) CurrentByteOffset -= D_length;
  1675.                     else CurrentByteOffset -= 1;
  1676.                     r1 = Init1 & A[D];               /* match endofline */
  1677.                     B[D] = (Next[A[D]] & CMask) | r1;
  1678.                     if(TAIL) B[D] = Next[B[D]] | B[D];
  1679.                     if((B[D] & 1) ^ INVERSE )  {
  1680.                         if(FILENAMEONLY && (NEW_FILE || !POST_FILTER)) {
  1681.                             num_of_matched++;
  1682.  
  1683.                             if (agrep_finalfp != NULL) 
  1684.                                 fprintf(agrep_finalfp, "%s\n", CurrentFileName);
  1685.                             else {
  1686.                                 int outindex;
  1687.                                 for(outindex=0; (outindex+agrep_outpointer<agrep_outlen) && 
  1688.                                         (CurrentFileName[outindex] != '\0'); outindex++) {
  1689.                                     agrep_outbuffer[agrep_outpointer+outindex] = CurrentFileName[outindex];
  1690.                                 }
  1691.                                 if ((CurrentFileName[outindex] != '\0') || (outindex+agrep_outpointer+1>=agrep_outlen)) {
  1692.                                     OUTPUT_OVERFLOW;
  1693.                                     free_buf(Text, buffer);
  1694.                                     return -1;
  1695.                                 }
  1696.                                 else agrep_outbuffer[agrep_outpointer+outindex++] = '\n';
  1697.                                 agrep_outpointer += outindex;
  1698.                             }
  1699.  
  1700.                             free_buf(Text, buffer);
  1701.                             NEW_FILE = OFF;
  1702.                             return 0;
  1703.                         } 
  1704.                         if (-1 == r_output(buffer, i, end, j)) {free_buf(Text, buffer); return -1;}
  1705.                         if ((LIMITOUTPUT > 0) && (LIMITOUTPUT <= num_of_matched)) {
  1706.                             free_buf(Text, buffer);
  1707.                             return 0;    /* done */
  1708.                         }
  1709.                     }
  1710.                     for(k=0; k<= D; k++) { 
  1711.                         A[k] = B[k] = Init[k]; 
  1712.                     }
  1713.                     r1 = Init1 & A[0]; 
  1714.                     B[0] = (Next[A[0]] & CMask) | r1;
  1715.                     for(k=1; k<= D; k++) {
  1716.                         r1 = Init1 & A[k];
  1717.                         r2 = (A[k-1] | Next[A[k-1]|B[k-1]])&r_NO_ERR;
  1718.                         B[k] = (Next[A[k]] & CMask) | r1 | r2;
  1719.                     }
  1720.                     if (DELIMITER) CurrentByteOffset += 1*D_length;
  1721.                     else CurrentByteOffset += 1*1;
  1722.                 }
  1723.     Nextchar1mem: 
  1724.                 i++;
  1725.                 CurrentByteOffset ++;
  1726.             } /* while i < end */
  1727.  
  1728.         return 0;
  1729.     }
  1730. #endif    /*AGREP_POINTER*/
  1731. } /* re */
  1732.  
  1733.  
  1734. r_output (buffer, i, end, j) 
  1735. int i, end, j; 
  1736. CHAR *buffer;
  1737. {
  1738.     int bp;
  1739.     if(i >= end) return 0;
  1740.     num_of_matched++;
  1741.     if(COUNT)  return; 
  1742.     if(FNAME && (NEW_FILE || !POST_FILTER)) {
  1743.         char    nextchar = (POST_FILTER == ON)?'\n':' ';
  1744.         char    *prevstring = (POST_FILTER == ON)?"\n":"";
  1745.         if (agrep_finalfp != NULL)
  1746.             fprintf(agrep_finalfp, "%s%s:%c", prevstring, CurrentFileName, nextchar);
  1747.         else {
  1748.             int outindex;
  1749.             if (prevstring[0] != '\0') {
  1750.                 if(agrep_outpointer + 1 >= agrep_outlen) {
  1751.                     OUTPUT_OVERFLOW;
  1752.                     return -1;
  1753.                 }
  1754.                 else agrep_outbuffer[agrep_outpointer ++] = prevstring[0];
  1755.             }
  1756.             for(outindex=0; (outindex+agrep_outpointer<agrep_outlen) &&
  1757.                     (CurrentFileName[outindex] != '\0'); outindex++) {
  1758.                 agrep_outbuffer[agrep_outpointer+outindex] = CurrentFileName[outindex];
  1759.             }
  1760.             if ((CurrentFileName[outindex] != '\0') || (outindex+agrep_outpointer+2>=agrep_outlen)) {
  1761.                 OUTPUT_OVERFLOW;
  1762.                 return -1;
  1763.             }
  1764.             else {
  1765.                 agrep_outbuffer[agrep_outpointer+outindex++] = ':';
  1766.                 agrep_outbuffer[agrep_outpointer+outindex++] = nextchar;
  1767.             }
  1768.             agrep_outpointer += outindex;
  1769.         }
  1770.         NEW_FILE = OFF;
  1771.     }
  1772.     bp = i-1;
  1773.     while ((buffer[bp] != '\n') && (bp > 0)) bp--;
  1774.     if(LINENUM) {
  1775.         if (agrep_finalfp != NULL)
  1776.             fprintf(agrep_finalfp, "%d: ", j); 
  1777.         else {
  1778.             char s[32];
  1779.             int  outindex;
  1780.  
  1781.             sprintf(s, "%d: ", j);
  1782.             for(outindex=0; (outindex+agrep_outpointer<agrep_outlen) &&
  1783.                     (s[outindex] != '\0'); outindex++) {
  1784.                 agrep_outbuffer[agrep_outpointer+outindex] = s[outindex];
  1785.             }
  1786.             if (s[outindex] != '\0') {
  1787.                 OUTPUT_OVERFLOW;
  1788.                 return -1;
  1789.             }
  1790.             agrep_outpointer += outindex;
  1791.         }
  1792.     }
  1793.  
  1794.     if(BYTECOUNT) {
  1795.         if (agrep_finalfp != NULL)
  1796.             fprintf(agrep_finalfp, "%d= ", CurrentByteOffset);
  1797.         else {
  1798.             char s[32];
  1799.             int  outindex;
  1800.             sprintf(s, "%d= ", CurrentByteOffset);
  1801.             for(outindex=0; (outindex+agrep_outpointer<agrep_outlen) &&
  1802.                     (s[outindex] != '\0'); outindex++) {
  1803.                 agrep_outbuffer[agrep_outpointer+outindex] = s[outindex];
  1804.             }
  1805.             if (s[outindex] != '\0') {
  1806.                 OUTPUT_OVERFLOW;
  1807.                 return -1;
  1808.             }
  1809.             agrep_outpointer += outindex;
  1810.         }
  1811.     }
  1812.  
  1813.     if(buffer[bp] != '\n') bp = Maxline-1;
  1814.     bp++;
  1815.  
  1816.     if (agrep_finalfp != NULL)
  1817.         while(bp <= i) fputc(buffer[bp++], agrep_finalfp);
  1818.     else {
  1819.         if (i - bp + 1 + agrep_outpointer >= agrep_outlen) {
  1820.             OUTPUT_OVERFLOW;
  1821.             return -1;
  1822.         }
  1823.         while(bp <= i) agrep_outbuffer[agrep_outpointer ++] = buffer[bp++];
  1824.     }
  1825.  
  1826.     return 0;
  1827. }
  1828.  
  1829. /*
  1830.  * Processes the options specified in argc and argv, and fetches the pattern.
  1831.  * Also sets the set of filenames to be searched for internally. Returns: -1
  1832.  * if there is a serious error, 0 if there is no pattern or an error in getting
  1833.  * the file names, the length (> 0) of the pattern if there is no error. When a
  1834.  * 0 is returned, it means that at least the options were processed correctly.
  1835.  */
  1836. int
  1837. agrep_init(argc, argv, initialfd, pattern_len, pattern_buffer)
  1838.     int    argc;
  1839.     char    *argv[];
  1840.     int    initialfd;
  1841.     int    pattern_len;
  1842.     CHAR    *pattern_buffer;
  1843. {
  1844.     int i, j, seenlsq = 0;
  1845.     char c, *p;
  1846.     int filetype;
  1847.     char **original_argv = argv;
  1848.     char *home;
  1849.     int quitwhile;
  1850.     int NOOUTTAIL=OFF;
  1851.  
  1852.     initial_value();
  1853.  
  1854.     if (pattern_len < 1) {
  1855.         fprintf(stderr, "agrep_init: pattern length %d too small\n", pattern_len);
  1856.         errno = 3;
  1857.         return -1;
  1858.     }
  1859.     agrep_initialfd = initialfd;
  1860.     strncpy(Progname, argv[0], MAXNAME);
  1861.     if (argc < 2) return agrep_usage();
  1862.  
  1863.     Pattern[0] = '\0';
  1864.  
  1865.     while(--argc > 0 && (*++argv)[0] == '-') { /* argv is incremented automatically here */
  1866.         p = argv[0]+1;                 /* ptr to first character after '-' */
  1867.         c = *(argv[0]+1); 
  1868.         quitwhile = OFF;
  1869.         while(!quitwhile && (*p != '\0')) {
  1870.             c = *p;
  1871.             switch(c) {
  1872.             case 'z' :
  1873.                 NOOUTPUTZERO = ON;    /* don't output files with 0 matches */
  1874.                 PRINT(printf("z\n");
  1875.                 )
  1876.                     break;
  1877.  
  1878.             case 'c' : 
  1879.                 COUNT = ON;    /* output the # of matches */
  1880.                 PRINT(printf("c\n");
  1881.                 )
  1882.                     break;
  1883.  
  1884.             case 's' : 
  1885.                 SILENT = ON;   /* silent mode  */
  1886.                 PRINT(printf("s\n");
  1887.                 )
  1888.                     break;
  1889.  
  1890.             case 'p' : 
  1891.                 I = 0;         /* insertion cost is 0 */
  1892.                 PRINT(printf("p\n");
  1893.                 )
  1894.                     break; 
  1895.             case 'P' :
  1896.                 PRINTPATTERN = 1;    /* print pattern before every matched line */
  1897.                 PRINT(printf("p\n");
  1898.                 )
  1899.                     break;
  1900.  
  1901.             case 'x' : 
  1902.                 WHOLELINE = ON;  /* match the whole line */
  1903.                 PRINT(printf("x\n");
  1904.                 )
  1905.                     if(WORDBOUND) {
  1906.                         fprintf(stderr, "%s: illegal option combination (-x and -w)\n", Progname);
  1907.                         if (!EXITONERROR) {
  1908.                             errno = 2;
  1909.                             return -1;
  1910.                         }
  1911.                         else exit(2);
  1912.                     }
  1913.                 break;
  1914.  
  1915.             case 'b' : 
  1916.                 BYTECOUNT = ON;
  1917.                 PRINT(printf("b\n");
  1918.                 )
  1919.                 break;
  1920.  
  1921.             case 'L' :
  1922.                 if ( *(p + 1) == '\0') {/* space after -L option */
  1923.                     if(argc <= 1) {
  1924.                         fprintf(stderr, "%s: the -L option must have an output-limit argument\n", Progname);
  1925.                         if (!EXITONERROR) {
  1926.                             errno = 2;
  1927.                             return -1;
  1928.                         }
  1929.                         else exit(2);
  1930.                     }
  1931.                     argv++;
  1932.                     if ((LIMITOUTPUT = atoi(argv[0])) < 0) {
  1933.                         fprintf(stderr, "%s: invalid output limit %s\n", Progname, argv[0]);
  1934.                         if (!EXITONERROR) {
  1935.                             errno = 2;
  1936.                             return -1;
  1937.                         }
  1938.                         else exit(2);
  1939.                     }
  1940.                     argc--;
  1941.                 } 
  1942.                 else {
  1943.                     if ((LIMITOUTPUT = atoi(p + 1)) < 0) {
  1944.                         fprintf(stderr, "%s: invalid output limit %s\n", Progname, p+1);
  1945.                         if (!EXITONERROR) {
  1946.                             errno = 2;
  1947.                             return -1;
  1948.                         }
  1949.                         else exit(2);
  1950.                     }
  1951.                 } /* else */
  1952.                 PRINT(printf("L\n");
  1953.                 )
  1954.                 quitwhile = ON;
  1955.                 break;
  1956.  
  1957.             case 'd' : 
  1958.                 DELIMITER = ON;  /* user defines delimiter */
  1959.                 PRINT(printf("d\n");
  1960.                 )
  1961.                 if ( *(p + 1) == '\0') {/* space after -d option */
  1962.                     if(argc <= 1) {
  1963.                         fprintf(stderr, "%s: the -d option must have a delimiter argument\n", Progname);
  1964.                         if (!EXITONERROR) {
  1965.                             errno = 2;
  1966.                             return -1;
  1967.                         }
  1968.                         else exit(2);
  1969.                     }
  1970.                     argv++;
  1971.                     if ((D_length = strlen(argv[0])) > MaxDelimit) {
  1972.                         fprintf(stderr, "%s: delimiter pattern too long (has > %d chars)\n", Progname, MaxDelimit);
  1973.                         if (!EXITONERROR) {
  1974.                             errno = 2;
  1975.                             return -1;
  1976.                         }
  1977.                         else exit(2);
  1978.                     }
  1979.                     D_pattern[0] = '<';
  1980.                     strcpy(D_pattern+1, argv[0]);
  1981.                     if ((argv[0][D_length-1] == '\n') || (argv[0][D_length-1] == '$') || (argv[0][D_length-1] == '^'))
  1982.                         OUTTAIL = ON;
  1983.                     argc--;
  1984.                     PRINT(printf("space\n");
  1985.                     )
  1986.                 } 
  1987.                 else {
  1988.                     if ((D_length = strlen(p + 1)) > MaxDelimit) {
  1989.                         fprintf(stderr, "%s: delimiter pattern too long (has > %d chars)\n", Progname, MaxDelimit);
  1990.                         if (!EXITONERROR) {
  1991.                             errno = 2;
  1992.                             return -1;
  1993.                         }
  1994.                         else exit(2);
  1995.                     }
  1996.                     D_pattern[0] = '<';
  1997.                     strcpy(D_pattern+1, p + 1);
  1998.                     if (((p+1)[D_length-1] == '\n') || ((p+1)[D_length-1] == '$') || ((p+1)[D_length-1] == '^'))
  1999.                         OUTTAIL = ON;
  2000.                 } /* else */
  2001.                 strcat(D_pattern, ">; ");
  2002.                 D_length++;   /* to count '<' as one */
  2003.                 PRINT(printf("D_pattern=%s\n", D_pattern);
  2004.                 )
  2005.                 strcpy(original_D_pattern, D_pattern);
  2006.                 original_D_length = D_length;
  2007.                 quitwhile = ON;
  2008.                 break;
  2009.  
  2010.             case 'H':
  2011.                 if (*(p + 1) == '\0') {/* space after - option */
  2012.                     if (argc <= 1) {
  2013.                         fprintf(stderr, "%s: a directory name must follow the -H option\n", Progname);
  2014.                         if (!EXITONERROR) {
  2015.                             errno = 2;
  2016.                             return agrep_usage();
  2017.                         }
  2018.                         else exit(2);
  2019.                     }
  2020.                     argv ++;
  2021.                     strcpy(COMP_DIR, argv[0]);
  2022.                     argc --;
  2023.                 }
  2024.                 else {
  2025.                     strcpy(COMP_DIR, p+1);
  2026.                 }
  2027.                 quitwhile = ON;
  2028.                 break;
  2029.  
  2030.             case 'e' : 
  2031.                 if ( *(p + 1) == '\0') {/* space after -e option */
  2032.                     if(argc <= 1) {
  2033.                         fprintf(stderr, "%s: the -e option must have a pattern argument\n", Progname);
  2034.                         if (!EXITONERROR) {
  2035.                             errno = 2;
  2036.                             return -1;
  2037.                         }
  2038.                         else exit(2);
  2039.                     }
  2040.                     argv++;
  2041.                     if(argv[0][0] == '-') {    /* not strictly necessary but no harm done */
  2042.                         Pattern[0] = '\\';
  2043.                         strcat(Pattern, (argv)[0]);
  2044.                     }
  2045.                     else strcat(Pattern, argv[0]);
  2046.                     argc--;
  2047.                 }
  2048.                 else {
  2049.                     if (*(p+1) == '-') {    /* not strictly necessary but no harm done */
  2050.                         Pattern[0] = '\\';
  2051.                         strcat(Pattern, p+1);
  2052.                     }
  2053.                     else strcat (Pattern, p+1);
  2054.                 } /* else */
  2055.  
  2056.                 PRINT(printf("Pattern=%s\n", Pattern);
  2057.                 )
  2058.                 pattern_index = abs(argv - original_argv);
  2059.                 quitwhile = ON;
  2060.                 break;
  2061.  
  2062.             case 'k' : 
  2063.                 CONSTANT = ON;
  2064.                 if ( *(p + 1) == '\0') {/* space after -e option */
  2065.                     if(argc <= 1) {
  2066.                         fprintf(stderr, "%s: the -k option must have a pattern argument\n", Progname);
  2067.                         if (!EXITONERROR) {
  2068.                             errno = 2;
  2069.                             return -1;
  2070.                         }
  2071.                         else exit(2);
  2072.                     }
  2073.                     argv++;
  2074.                     strcat(Pattern, argv[0]);
  2075.                     if((argc > 2) && (argv[1][0] == '-')) {
  2076.                         fprintf(stderr, "%s: -k should be the last option in the command\n", Progname);
  2077.                         if (!EXITONERROR) {
  2078.                             errno = 2;
  2079.                             return -1;
  2080.                         }
  2081.                         else exit(2);
  2082.                     }
  2083.                     argc--;
  2084.                 }
  2085.                 else {
  2086.                     if((argc > 1) && (argv[1][0] == '-')) {
  2087.                         fprintf(stderr, "%s: -k should be the last option in the command\n", Progname);
  2088.                         if (!EXITONERROR) {
  2089.                             errno = 2;
  2090.                             return -1;
  2091.                         }
  2092.                         else exit(2);
  2093.                     }
  2094.                     strcat (Pattern, p+1);
  2095.                 } /* else */
  2096.  
  2097.                 pattern_index = abs(argv - original_argv);
  2098.                 quitwhile = ON;
  2099.                 break;
  2100.  
  2101.             case 'f' : 
  2102.                 if (PAT_FILE == ON) {
  2103.                     fprintf(stderr, "%s: multiple -f options\n", Progname);
  2104.                     if (multifd >= 0) close(multifd);
  2105.                     if (!EXITONERROR) {
  2106.                         errno = 2;
  2107.                         return -1;
  2108.                     }
  2109.                     else exit(2);
  2110.                 }
  2111.                 if (PAT_BUFFER == ON) {
  2112.                     fprintf(stderr, "%s: -f and -m are incompatible\n", Progname);
  2113.                     if (multibuf != NULL) free(multibuf);
  2114.                     multibuf = NULL;
  2115.                     multilen = 0;
  2116.                     if (!EXITONERROR) {
  2117.                         errno = 2;
  2118.                         return -1;
  2119.                     }
  2120.                     else exit(2);
  2121.                 }
  2122.                 PAT_FILE = ON;
  2123.                 PRINT(printf("f\n");
  2124.                 )
  2125.                 argv++;
  2126.                 argc--;
  2127.  
  2128.                 if (argv[0] == NULL) {
  2129.                     /* A -f option with a NULL file name is a NO-OP: stupid, but simplifies glimpse :-) */
  2130.                     PAT_FILE = OFF;
  2131.                     quitwhile = ON;
  2132.                     break;
  2133.                 }
  2134.  
  2135.                 if((multifd = open(argv[0], O_RDONLY)) < 0) {
  2136.                     PAT_FILE = OFF;
  2137.                     fprintf(stderr, "%s: can't open pattern file for reading: %s\n", Progname, argv[0]);
  2138.                     if (!EXITONERROR) {
  2139.                         errno = 2;
  2140.                         return -1;
  2141.                     }
  2142.                     else exit(2);
  2143.                 }
  2144.                 PRINT(printf("file=%s\n", argv[0]);
  2145.                 )
  2146.                 strcpy(PAT_FILE_NAME, argv[0]);
  2147.                 if (prepf(multifd, NULL, 0) <= -1) {
  2148.                     close(multifd);
  2149.                     PAT_FILE = OFF;
  2150.                     fprintf(stderr, "%s: error in processing pattern file: %s\n", Progname, argv[0]);
  2151.                     if (!EXITONERROR) {
  2152.                         errno = 2;
  2153.                         return -1;
  2154.                     }
  2155.                     else exit(2);
  2156.                 }
  2157.                 quitwhile = ON;
  2158.                 break;
  2159.  
  2160.             case 'm' :
  2161.                 if (PAT_BUFFER == ON) {
  2162.                     fprintf(stderr, "%s: multiple -m options\n", Progname);
  2163.                     if (multibuf != NULL) free(multibuf);
  2164.                     multilen = 0;
  2165.                     if (!EXITONERROR) {
  2166.                         errno = 2;
  2167.                         return -1;
  2168.                     }
  2169.                     else exit(2);
  2170.                 }
  2171.                 if (PAT_FILE == ON) {
  2172.                     fprintf(stderr, "%s: -f and -m are incompatible\n", Progname);
  2173.                     if (multifd >= 0) close(multifd);
  2174.                     if (!EXITONERROR) {
  2175.                         errno = 2;
  2176.                         return -1;
  2177.                     }
  2178.                     else exit(2);
  2179.                 }
  2180.                 PAT_BUFFER = ON;
  2181.                 PRINT(printf("m\n");
  2182.                 )
  2183.                 argv ++;
  2184.                 argc --;
  2185.  
  2186.  
  2187.                 if ((argv[0] == NULL) || ((multilen = strlen(argv[0])) <= 0)) {
  2188.                     /* A -m option with a NULL or empty pattern buffer is a NO-OP: stupid, but simplifies glimpse :-) */
  2189.                     PAT_BUFFER = OFF;
  2190.                     multilen = 0;
  2191.                     multibuf = NULL;
  2192.                 }
  2193.                 else {
  2194.                     multibuf = (char *)malloc(multilen + 2);
  2195.                     strcpy(multibuf, argv[0]);
  2196.                     PRINT(printf("patterns=%s\n", multibuf);
  2197.                     )
  2198.                     if (prepf(-1, multibuf, multilen) <= -1) {
  2199.                         free(multibuf);
  2200.                         multilen = 0;
  2201.                         PAT_BUFFER = OFF;
  2202.                         fprintf(stderr, "%s: error in processing pattern buffer\n", Progname);
  2203.                         if (!EXITONERROR) {
  2204.                             errno = 2;
  2205.                             return -1;
  2206.                         }
  2207.                         else exit(2);
  2208.                     }
  2209.                 }
  2210.                 quitwhile = ON;
  2211.                 break;
  2212.  
  2213.             case 'h' : 
  2214.                 NOFILENAME = ON;
  2215.                 PRINT(printf("h\n");
  2216.                 )
  2217.                     break;
  2218.  
  2219.             case 'i' : 
  2220.                 NOUPPER = ON;
  2221.                 PRINT(printf("i\n");
  2222.                 )
  2223.                     break;
  2224.  
  2225.             case 'l' : 
  2226.                 FILENAMEONLY = ON;
  2227.                 PRINT(printf("l\n");
  2228.                 )
  2229.                     break;
  2230.  
  2231.             case 'n' : 
  2232.                 LINENUM = ON;  /* output prefixed by line no*/
  2233.                 PRINT(printf("n\n");
  2234.                 )
  2235.                     break;
  2236.  
  2237.             case 'r' : 
  2238.                 RECURSIVE = ON;
  2239.                 PRINT(printf("r\n");
  2240.                 )
  2241.                     break;
  2242.             
  2243.             case 'V' :
  2244.                 printf("\nThis is agrep version %s, %s.\n\n", AGREP_VERSION, AGREP_DATE);
  2245.                 return 0;
  2246.  
  2247.             case 'v' : 
  2248.                 INVERSE = ON;  /* output no-matched lines */
  2249.                 PRINT(printf("v\n");
  2250.                 )
  2251.                     break;
  2252.  
  2253.             case 't' : 
  2254.                 OUTTAIL = ON;  /* output from tail of delimiter */
  2255.                 PRINT(printf("t\n");
  2256.                 )
  2257.                     break;
  2258.  
  2259.             case 'o' : 
  2260.                 NOOUTTAIL = ON;  /* output from front of delimiter */
  2261.                 PRINT(printf("t\n");
  2262.                 )
  2263.                     break;
  2264.  
  2265.             case 'B' : 
  2266.                 BESTMATCH = ON;
  2267.                 PRINT(printf("B\n");
  2268.                 )
  2269.                     break;
  2270.  
  2271.             case 'w' : 
  2272.                 WORDBOUND = ON;/* match to words */
  2273.                 PRINT(printf("w\n");
  2274.                 )
  2275.                     if(WHOLELINE) {
  2276.                         fprintf(stderr, "%s: illegal option combination (-w and -x)\n", Progname);
  2277.                         if (!EXITONERROR) {
  2278.                             errno = 2;
  2279.                             return -1;
  2280.                         }
  2281.                         else exit(2);
  2282.                     }
  2283.                 break;
  2284.  
  2285.             case 'y' : 
  2286.                 NOPROMPT = ON;
  2287.                 PRINT(printf("y\n");
  2288.                 )
  2289.                     break;
  2290.  
  2291.             case 'I' : 
  2292.                 I = atoi(p + 1);  /* Insertion Cost */
  2293.                 JUMP = ON;
  2294.                 quitwhile = ON;
  2295.                 break;
  2296.  
  2297.             case 'S' : 
  2298.                 S = atoi(p + 1);  /* Substitution Cost */
  2299.                 JUMP = ON;
  2300.                 quitwhile = ON;
  2301.                 break;
  2302.  
  2303.             case 'D' : 
  2304.                 DD = atoi(p + 1); /* Deletion Cost */
  2305.                 JUMP = ON;
  2306.                 quitwhile = ON;
  2307.                 break;
  2308.  
  2309.             case 'G' : 
  2310.                 FILEOUT = ON; 
  2311.                 COUNT = ON;
  2312.                 break;
  2313.  
  2314.             case 'A':
  2315.                 ALWAYSFILENAME = ON;
  2316.                 break;
  2317.  
  2318.             case 'O':
  2319.                 POST_FILTER = ON;
  2320.  
  2321.             case 'M':
  2322.                 MULTI_OUTPUT = ON;
  2323.  
  2324.             case 'Z': break;    /* no-op: used by glimpse */
  2325.             
  2326.             default  : 
  2327.                 if (isdigit(c)) {
  2328.                     APPROX = ON;
  2329.                     D = atoi(p);
  2330.                     if (D > MaxError) {
  2331.                         fprintf(stderr,"%s: the maximum number of errors is %d\n", Progname, MaxError);
  2332.                         if (!EXITONERROR) {
  2333.                             errno = 2;
  2334.                             return -1;
  2335.                         }
  2336.                         else exit(2);
  2337.                     }
  2338.                     quitwhile = ON;    /* note that even a number should occur at the end of a group of options, as f & e */
  2339.                 }
  2340.                 else {
  2341.                     fprintf(stderr, "%s: illegal option  -%c\n",Progname, c);
  2342.                     return agrep_usage();
  2343.                 }
  2344.  
  2345.             } /* switch(c) */
  2346.             p ++;
  2347.         }
  2348.     } /* while (--argc > 0 && (*++argv)[0] == '-') */
  2349.  
  2350.     if (NOOUTTAIL == ON) OUTTAIL = OFF;
  2351.  
  2352.     if (COMP_DIR[0] == '\0') {
  2353.         if ((home = (char *)getenv("HOME")) == NULL) {
  2354.             getcwd(COMP_DIR, MAX_LINE_LEN-1);
  2355.             fprintf(stderr, "using working-directory '%s' to locate dictionaries\n", COMP_DIR);
  2356.         }
  2357.         else strncpy(COMP_DIR, home, MAX_LINE_LEN);
  2358.     }
  2359.  
  2360.     strcpy(FREQ_FILE, COMP_DIR);
  2361.     strcat(FREQ_FILE, "/");
  2362.     strcat(FREQ_FILE, DEF_FREQ_FILE);
  2363.     strcpy(HASH_FILE, COMP_DIR);
  2364.     strcat(HASH_FILE, "/");
  2365.     strcat(HASH_FILE, DEF_HASH_FILE);
  2366.     strcpy(STRING_FILE, COMP_DIR);
  2367.     strcat(STRING_FILE, "/");
  2368.     strcat(STRING_FILE, DEF_STRING_FILE);
  2369.     initialize_common(FREQ_FILE, 0);    /* no error msgs */
  2370.  
  2371.     if (FILENAMEONLY && NOFILENAME) {
  2372.         fprintf(stderr, "%s: -h and -l options are mutually exclusive\n",Progname);
  2373.     }
  2374.     if (COUNT && (FILENAMEONLY || NOFILENAME)) {
  2375.         FILENAMEONLY = OFF; 
  2376.         if(!FILEOUT) NOFILENAME = OFF;
  2377.     }
  2378.  
  2379.     if (!(PAT_FILE || PAT_BUFFER) && Pattern[0] == '\0') { /* Pattern not set with -e option */
  2380.         if (argc <= 0) {
  2381.             agrep_usage();
  2382.             return 0;
  2383.         }
  2384.         strcpy(Pattern, *argv); 
  2385.         pattern_index = abs(argv - original_argv);
  2386.         argc--;
  2387.         argv++;
  2388.     }
  2389.     /* if multi-pattern search, just ignore any specified pattern altogether: treat it as a filename */
  2390.  
  2391.     if (copied_from_argv) {
  2392.         for (i=0; i<Numfiles; i++) free(Textfiles[i]);
  2393.         if (Textfiles != NULL) free(Textfiles);
  2394.     }
  2395.     copied_from_argv = 0;
  2396.     Numfiles = 0; Textfiles = NULL;
  2397.     execfd = agrep_initialfd;
  2398.     if (argc <= 0)  /* check Pattern against stdin */
  2399.         execfd = 0;
  2400.     else {    /* filenames were specified as a part of the command line */
  2401.         if (!(Textfiles = (CHAR **)malloc(argc * sizeof(CHAR *) ))) {
  2402.             fprintf(stderr, "%s: malloc failure in %s:%d\n", Progname, __FILE__, __LINE__);
  2403.             if (!EXITONERROR) {
  2404.                 errno = 2;
  2405.                 return 0;
  2406.             }
  2407.             else exit(2);
  2408.         }
  2409.         copied_from_argv = 1;    /* should I free Textfiles next time? */
  2410.         while (argc--)
  2411.         {    /* one or more filenames on command line -- put the valid filenames in a array of strings */
  2412.  
  2413.             if ((filetype = check_file(*argv)) == NOSUCHFILE) {
  2414.                 if (!glimpse_call) if (!glimpse_call) fprintf(stderr,"%s: '%s' no such file or directory\n",Progname,*argv);
  2415.                 argv++;
  2416.             }
  2417.             else { /* file is ascii*/
  2418.                 if (!(Textfiles[Numfiles] = (CHAR *)malloc((strlen(*argv)+2)))) {
  2419.                     fprintf(stderr, "%s: malloc failure in %s:%d\n", Progname, __FILE__, __LINE__);
  2420.                     if (!EXITONERROR) {
  2421.                         errno = 2;
  2422.                         return 0;
  2423.                     }
  2424.                     else exit(2);
  2425.                 }
  2426.                 strcpy(Textfiles[Numfiles++], *argv++);
  2427.             } /* else */
  2428.         } /* while (argc--) */
  2429.         if (Numfiles <= 0) return 0;
  2430.         /* If user specified wrong filenames, then we quit rather than taking input from stdin! */
  2431.     } /* else */
  2432.  
  2433.     M = strlen(Pattern);
  2434.     if (M<=0) return 0;
  2435.     for (i=0; i<M; i++) {
  2436.         if ( ((unsigned char *)Pattern)[i] > USERRANGE) {
  2437.             fprintf(stderr, "Warning: pattern has non-ascii meta-characters interepreted by agrep!\n");
  2438.             break;
  2439.         }
  2440.         else if (Pattern[i] == '\\') i++;    /* extra */
  2441.         else if (Pattern[i] == '[') seenlsq = 1;
  2442.         else if ((Pattern[i] == '-') && !seenlsq) {
  2443.             for (j=M; j>=i; j--)
  2444.                 Pattern[j+1] = Pattern[j];    /* right shift including '\0' */
  2445.             Pattern[i] = '\\';    /* escape the - */
  2446.             M ++;
  2447.             i++;
  2448.         }
  2449.         else if (Pattern[i] == ']') seenlsq = 0;
  2450.     }
  2451.  
  2452.     if (M > pattern_len - 1) {
  2453.         fprintf(stderr, "%s: pattern '%s' does not fit in specified buffer\n", Progname, Pattern);
  2454.         errno = 3;
  2455.         return 0;
  2456.     }
  2457.     if (pattern_buffer != Pattern)    /* not from mem/file-agrep() */
  2458.         strncpy(pattern_buffer, Pattern, M+1); /* copy \0 */
  2459.     return M;
  2460. }
  2461.  
  2462. /*
  2463.  * User need not bother about initialfd.
  2464.  * Both functions return -1 on error, 0 if there was no pattern,
  2465.  * length (>=1) of pattern otherwise.
  2466.  */
  2467.  
  2468. int
  2469. memagrep_init(argc, argv, pattern_len, pattern_buffer)
  2470.     int    argc;
  2471.     char    *argv[];
  2472.     int    pattern_len;
  2473.     char    *pattern_buffer;
  2474. {
  2475.     return (agrep_init(argc, argv, -1, pattern_len, pattern_buffer));
  2476. }
  2477.  
  2478. int
  2479. fileagrep_init(argc, argv, pattern_len, pattern_buffer)
  2480.     int    argc;
  2481.     char    *argv[];
  2482.     int    pattern_len;
  2483.     char    *pattern_buffer;
  2484. {
  2485.     return (agrep_init(argc, argv, 3, pattern_len, pattern_buffer));
  2486. }
  2487.  
  2488. /* returns -1 on error, num of matches (>=0) otherwise */
  2489. int
  2490. agrep_search(pattern_len, pattern_buffer, initialfd, input_len, input, output_len, output)
  2491. int pattern_len; 
  2492. CHAR *pattern_buffer;
  2493. int initialfd;
  2494. int input_len;
  2495. void *input;
  2496. int output_len;
  2497. void *output;
  2498. {
  2499.     int    i;
  2500.     int    filetype;
  2501.     int    ret;
  2502.  
  2503.     reinit_value();
  2504.  
  2505.     if ((multifd == -1) && (multibuf == NULL) && (pattern_len < 1)) {
  2506.         fprintf(stderr, "%s: pattern length %d too small\n", Progname, pattern_len);
  2507.         errno = 3;
  2508.         return -1;
  2509.     }
  2510.     if (pattern_len >= MAXPAT) {
  2511.         fprintf(stderr, "%s: pattern '%s' too long\n", Progname, pattern_buffer);
  2512.         errno = 3;
  2513.         return -1;
  2514.     }
  2515.     if (pattern_buffer != Pattern)    /* not from mem/file-agrep() */
  2516.         strncpy(Pattern, pattern_buffer, pattern_len+1); /* copy \0 */
  2517.     M = strlen(Pattern);
  2518.  
  2519.     if (output == NULL) {
  2520.         fprintf(stderr, "%s: invalid output descriptor\n", Progname);
  2521.         return -1;
  2522.     }
  2523.     if (output_len <= 0) {
  2524.         agrep_finalfp = (FILE *)output;
  2525.         agrep_outlen = 0;
  2526.         agrep_outbuffer = NULL;
  2527.         agrep_outpointer = 0;
  2528.     }
  2529.     else {
  2530.         agrep_finalfp = NULL;
  2531.         agrep_outlen = output_len;
  2532.         agrep_outbuffer = (CHAR *)output;
  2533.         agrep_outpointer = 0;
  2534.     }
  2535.  
  2536.     agrep_initialfd = initialfd;
  2537.     execfd = initialfd;
  2538.     if (initialfd == -1) {
  2539.         agrep_inbuffer = (CHAR *)input;
  2540.         agrep_inlen = input_len;
  2541.         agrep_inpointer = 0;
  2542.     }
  2543.     else if ((input_len > 0) && (input != NULL)) {
  2544.         /* Copy the set of filenames into Textfiles */
  2545.         if (copied_from_argv) {
  2546.             for (i=0; i<Numfiles; i++) free(Textfiles[i]);
  2547.             if (Textfiles != NULL) free(Textfiles);
  2548.         }
  2549.         copied_from_argv = 0;
  2550.         Numfiles = 0; Textfiles = NULL;
  2551. #if    0
  2552.         if (!(Textfiles = (CHAR **)malloc(input_len * sizeof(CHAR *) ))) {
  2553.             fprintf(stderr, "%s: malloc failure in %s:%d\n", Progname, __FILE__, __LINE__);
  2554.             if (!EXITONERROR) {
  2555.                 errno = 2;
  2556.                 return 0;
  2557.             }
  2558.             else exit(2);
  2559.         }
  2560. #else    /*0*/
  2561.         Textfiles = (CHAR **)input;
  2562. #endif    /*0*/
  2563.  
  2564.         while (input_len --)
  2565.         {    /* one or more filenames on command line -- put the valid filenames in a array of strings */
  2566.  
  2567.             if ((filetype = check_file(*(char **)input)) == NOSUCHFILE) {
  2568.                 if(filetype == NOSUCHFILE) if (!glimpse_call) fprintf(stderr,"%s: '%s' no such file or directory\n",Progname,*(char **)input);
  2569.                 input = (void *)(((long)input) + sizeof(char *));
  2570.             } 
  2571.             else { /* file is ascii*/
  2572. #if    0
  2573.                 if (!(Textfiles[Numfiles] = (CHAR *)malloc((strlen(*(char **)input)+2)))) {
  2574.                     fprintf(stderr, "%s: malloc failure in %s:%d\n", Progname, __FILE__, __LINE__);
  2575.                     if (!EXITONERROR) {
  2576.                         errno = 2;
  2577.                         return 0;
  2578.                     }
  2579.                     else exit(2);
  2580.                 }
  2581.                 strcpy(Textfiles[Numfiles++], *((char **)input));
  2582. #else    /*0*/
  2583.                 Textfiles[Numfiles++] = *((CHAR **)input);
  2584. #endif    /*0*/
  2585.                 input = (void *)(((long)input) + sizeof(char *));
  2586.             } /* else */
  2587.         } /* while (argc--) */
  2588.         if (Numfiles <= 0) return 0;
  2589.         /* If user specified wrong filenames, then we quit rather than taking input from stdin! */
  2590.     }
  2591.     else if (Numfiles <= 0) execfd = 0;
  2592.     /* the old set of files (agrep_init) are used */
  2593.  
  2594. #if    0
  2595.     printf("agrep_search: pat=%s buf=%s\n", Pattern, ((agrep_initialfd == -1) && (agrep_inlen < 20)) ? agrep_inbuffer : NULL);
  2596. #endif    /*0*/
  2597.  
  2598.     if (-1 == checksg(Pattern, D, 1)) return -1;       /* check if the pattern is simple */
  2599.     strcpy(OldPattern, Pattern);
  2600.  
  2601.     /* Must do this everytime since processing depends on the pattern being searched */
  2602.     if (SGREP == 0) {
  2603.         if (-1 == preprocess(D_pattern, Pattern)) return -1;
  2604.         strcpy(old_D_pat, D_pattern);
  2605.         /* fprintf(stderr, "agrep_search: len=%d pat=%s\n", strlen(Pattern), Pattern); */
  2606.         if(!AParse &&  ((M = maskgen(Pattern, D)) == -1)) return -1;
  2607.     }
  2608.     else {    /* sgrep too can handle delimiters */
  2609.         if (DELIMITER) {
  2610.             /* D_pattern is "<PAT>; ", D_length is 1 + length of string PAT: see agrep.c/'d' */
  2611.             preprocess_delimiter(D_pattern+1, D_length - 1, D_pattern, &D_length);
  2612.             /* D_pattern is the exact stuff we want to match, D_length is its strlen */
  2613.             if ((tc_D_length = quick_tcompress(FREQ_FILE, HASH_FILE, D_pattern, D_length, tc_D_pattern, MaxDelimit*2, TC_EASYSEARCH)) <= 0) {
  2614.                 strcpy(tc_D_pattern, D_pattern);
  2615.                 tc_D_length = D_length;
  2616.             }
  2617.             /* printf("sgrep's delim=%s,%d tc_delim=%s,%d\n", D_pattern, D_length, tc_D_pattern, tc_D_length); */
  2618.         }
  2619.         M = strlen(OldPattern);
  2620.     }
  2621.     if (AParse)  {    /* boolean converted to multi-pattern search */
  2622.         if (prepf(-1, multibuf, multilen) <= -1) {
  2623.             if (AComplexBoolean) destroy_tree(AParse);
  2624.             AParse = 0;
  2625.             PAT_BUFFER = 0;
  2626.             if (multibuf != NULL) free(multibuf);    /* this was allocated for arbit booleans, not multipattern search */
  2627.             multilen = 0;
  2628.             /* Cannot free multifd here since that is always allocated for multipattern search */
  2629.             return -1;
  2630.         }
  2631.     }
  2632.     if (Numfiles > 1) FNAME = ON;
  2633.     if (NOFILENAME) FNAME = 0;
  2634.     if (ALWAYSFILENAME) FNAME = ON;    /* used by glimpse ONLY: 15/dec/93 */
  2635.  
  2636.     if (agrep_initialfd == -1) ret = exec(execfd, NULL);
  2637.     else if(RECURSIVE) ret = (recursive(Numfiles, Textfiles));
  2638.     else  ret = (exec(execfd, Textfiles));
  2639.  
  2640.     if (AParse && !use_previous_state) {    /* DIRTY TRICK: glimpse can call exec directly and save lot of time */
  2641.         if (AComplexBoolean) destroy_tree(AParse);
  2642.         AComplexBoolean = 0;
  2643.         AParse = 0;
  2644.         PAT_BUFFER = 0;
  2645.         if (multibuf != NULL) free(multibuf);    /* this was allocated for arbit booleans, not multipattern search */
  2646.         multibuf = NULL;
  2647.         multilen = 0;
  2648.         /* Cannot free multifd here since that is always allocated for multipattern search */
  2649.     }
  2650.     return ret;
  2651. }
  2652.  
  2653. /*
  2654.  * User need not bother about initialfd.
  2655.  * Both functions return -1 on error, 0 otherwise.
  2656.  */
  2657.  
  2658. int
  2659. memagrep_search(pattern_len, pattern_buffer, input_len, input_buffer, output_len, output)
  2660. int pattern_len;
  2661. char *pattern_buffer;
  2662. int input_len;
  2663. char *input_buffer;
  2664. int output_len;
  2665. void *output;
  2666. {
  2667.     return(agrep_search(pattern_len, pattern_buffer, -1, input_len, input_buffer, output_len, output));
  2668. }
  2669.  
  2670. int
  2671. fileagrep_search(pattern_len, pattern_buffer, file_num, file_buffer, output_len, output)
  2672. int pattern_len;
  2673. char *pattern_buffer;
  2674. int file_num;
  2675. char **file_buffer;
  2676. int output_len;
  2677. void *output;
  2678. {
  2679.     return(agrep_search(pattern_len, pattern_buffer, 3, file_num, file_buffer, output_len, output));
  2680. }
  2681.  
  2682. /*
  2683.  * The original agrep_run() routine was split into agrep_search and agrep_init
  2684.  * so that the interface with glimpse could be made cleaner: see glimpse.
  2685.  * Now, the user can specify an initial set of options, and use them in future
  2686.  * searches. If agrep_init does not find the pattern, options are still SET.
  2687.  * In fileagrep_search, the user can specify a NEW set of files to be searched
  2688.  * after the options are processed (this is used in glimpse).
  2689.  *
  2690.  * Both functions return -1 on error, 0 otherwise.
  2691.  *
  2692.  * The arguments are self explanatory. The pattern should be specified in
  2693.  * one of the argvs. Options too can be specified in one of the argvs -- it
  2694.  * is exactly as if the options are being given to agrep at run time.
  2695.  * The only restrictions are that the input_buffer should begin with a '\n'
  2696.  * and after its end, there must be valid memory to store a copy of the pattern.
  2697.  */
  2698.  
  2699. int
  2700. memagrep(argc, argv, input_len, input_buffer, output_len, output)
  2701. int argc; 
  2702. char *argv[];
  2703. int input_len;
  2704. char *input_buffer;
  2705. int output_len;
  2706. void *output;
  2707. {
  2708.     int    ret;
  2709.  
  2710.     if ((ret = memagrep_init(argc, argv, MAXPAT, Pattern)) < 0) return -1;
  2711.     else if ((ret == 0) && (multifd == -1) && (multibuf == NULL)) return -1;
  2712.     /* ^^^ because one need not specify the pattern on the cmd line if -f OR -m */
  2713.     return memagrep_search(ret, Pattern, input_len, input_buffer, output_len, output);
  2714. }
  2715.  
  2716. int
  2717. fileagrep(argc, argv, output_len, output)
  2718. int argc; 
  2719. char *argv[];
  2720. int output_len;
  2721. void *output;
  2722. {
  2723.     int    ret;
  2724.  
  2725.     if ((ret = fileagrep_init(argc, argv, MAXPAT, Pattern)) < 0) return -1;
  2726.     else if ((ret == 0) && (multifd == -1) && (multibuf == NULL)) return -1;
  2727.     /* ^^^ because one need not specify the pattern on the cmd line if -f OR -m */
  2728.     return fileagrep_search(ret, Pattern, 0, NULL, output_len, output);
  2729. }
  2730.  
  2731. /*
  2732.  * RETURNS: total number of matched lines in all files that were searched.
  2733.  *
  2734.  * The pattern(s) remain(s) constant irrespective of the number of files.
  2735.  * Hence, essentially, all the interface routines below have to be changed
  2736.  * so that they DONT do that preprocessing again and again for multiple
  2737.  * files. This bug was found while interfacing agrep with cast.
  2738.  *
  2739.  * At present, sgrep() has been modified to have another parameter,
  2740.  * "samepattern" that tells it whether the pattern is the same as before.
  2741.  * Other funtions too should have such a parameter and should not repeat
  2742.  * preprocessing for all patterns. Since preprocessing for a pattern to
  2743.  * be searched in compressed files is siginificant, this bug was found.
  2744.  *
  2745.  * - bgopal on 15/Nov/93.
  2746.  */
  2747. int
  2748. exec(fd, file_list)
  2749. int fd;
  2750. char **file_list;
  2751. {
  2752.     int i;
  2753.     char c[8];
  2754.     int ret = 0;    /* no error */
  2755.  
  2756.     if ((Numfiles > 1) && (NOFILENAME == OFF)) FNAME = ON;
  2757.     if (!use_previous_state && (-1 == compat())) return -1; /* check compatibility between options */
  2758.  
  2759.     if (fd <= 0) {
  2760.         TCOMPRESSED = ON;    /* there is a possibility that the data might be tuncompressible */
  2761.         if (!SetCurrentByteOffset) CurrentByteOffset = 0;
  2762.         if((fd == 0) && FILENAMEONLY && !use_previous_state) {
  2763.             fprintf(stderr, "%s: -l option is not compatible with standard input\n", Progname);
  2764.             if (!EXITONERROR) {
  2765.                 errno = 2;
  2766.                 return -1;
  2767.             }
  2768.             else exit(2);  
  2769.         }
  2770.         if(PAT_FILE || PAT_BUFFER) mgrep(fd, AParse);
  2771.         else {
  2772.             if(SGREP) ret = sgrep(OldPattern, strlen(OldPattern), fd, D, 0);
  2773.             else      ret = bitap(old_D_pat, Pattern, fd, M, D);
  2774.         }
  2775.         if (ret <= -1) return -1;
  2776.         if (COUNT && !use_previous_state && ret) {    /* dirty solution for glimpse's -b! */
  2777.             if(INVERSE && (PAT_FILE || PAT_BUFFER)) {    /* inverse will never be set in glimpse */
  2778.                 if (agrep_finalfp != NULL)
  2779.                     fprintf(agrep_finalfp, "%d\n", total_line-(num_of_matched - prev_num_of_matched));
  2780.                 else {
  2781.                     char s[32];
  2782.                     int  outindex;
  2783.  
  2784.                     sprintf(s, "%d\n", total_line-(num_of_matched - prev_num_of_matched));
  2785.  
  2786.                     for(outindex=0; (outindex+agrep_outpointer<agrep_outlen) &&
  2787.                             (s[outindex] != '\0'); outindex++) {
  2788.                         agrep_outbuffer[agrep_outpointer+outindex] = s[outindex];
  2789.                     }
  2790.                     if (s[outindex] != '\0') {
  2791.                         OUTPUT_OVERFLOW;
  2792.                         return -1;
  2793.                     }
  2794.                     agrep_outpointer += outindex;
  2795.                 }
  2796.             }
  2797.             else {
  2798.                 if (agrep_finalfp != NULL)
  2799.                     fprintf(agrep_finalfp, "%d\n", (num_of_matched - prev_num_of_matched));
  2800.                 else {
  2801.                     char s[32];
  2802.                     int  outindex;
  2803.  
  2804.                     sprintf(s, "%d\n", (num_of_matched - prev_num_of_matched));
  2805.  
  2806.                     for(outindex=0; (outindex+agrep_outpointer<agrep_outlen) &&
  2807.                             (s[outindex] != '\0'); outindex++) {
  2808.                         agrep_outbuffer[agrep_outpointer+outindex] = s[outindex];
  2809.                     }
  2810.                     if (s[outindex] != '\0') {
  2811.                         OUTPUT_OVERFLOW;
  2812.                         return -1;
  2813.                     }
  2814.                     agrep_outpointer += outindex;
  2815.                 }
  2816.             }
  2817.         }
  2818.     }
  2819.     else {
  2820.         /* fd > 0 => Numfiles > 0 */
  2821.  
  2822.         for (i = 0; i < Numfiles; i++, close(fd)) {
  2823.             prev_num_of_matched = num_of_matched;
  2824.             if (!SetCurrentByteOffset) CurrentByteOffset = 0;
  2825.             if (!SetCurrentFileName) strcpy(CurrentFileName, file_list[i]);
  2826.             TCOMPRESSED = ON;
  2827.             if (!tuncompressible_filename(file_list[i], strlen(file_list[i]))) TCOMPRESSED = OFF;
  2828.             NEW_FILE = ON;
  2829.             if ((fd = open(file_list[i], O_RDONLY)) < /*=*/ 0) {
  2830.                 fprintf(stderr, "%s: can't open file for reading: %s\n",Progname, file_list[i]);
  2831.             } 
  2832.             else { 
  2833.                 if(PAT_FILE || PAT_BUFFER) mgrep(fd, AParse);
  2834.                 else {
  2835.                     if(SGREP) ret = sgrep(OldPattern, strlen(OldPattern), fd, D, i);
  2836.                     else      ret = bitap(old_D_pat, Pattern, fd, M, D);
  2837.                 }
  2838.                 if (ret <= -1) {
  2839.                     close(fd);
  2840.                     return -1;
  2841.                 }
  2842.                 if (num_of_matched - prev_num_of_matched > 0) NOMATCH = OFF;
  2843.  
  2844.                 if (COUNT && !FILEOUT) {
  2845.                     if( (INVERSE && (PAT_FILE || PAT_BUFFER)) && ((total_line - (num_of_matched - prev_num_of_matched)> 0) || !NOOUTPUTZERO) ) {
  2846.                         if(FNAME && (NEW_FILE || !POST_FILTER)) {
  2847.                             if (agrep_finalfp != NULL)
  2848.                                 fprintf(agrep_finalfp, "%s: %d\n", CurrentFileName, total_line - (num_of_matched - prev_num_of_matched));
  2849.                             else {
  2850.                                 char s[32];
  2851.                                 int  outindex;
  2852.  
  2853.                                 sprintf(s, ": %d\n", total_line - (num_of_matched - prev_num_of_matched));
  2854.  
  2855.                                 for(outindex=0; (outindex+agrep_outpointer<agrep_outlen) &&
  2856.                                         (CurrentFileName[outindex] != '\0'); outindex++) {
  2857.                                     agrep_outbuffer[agrep_outpointer+outindex] = CurrentFileName[outindex];
  2858.                                 }
  2859.                                 if (CurrentFileName[outindex] != '\0') {
  2860.                                     OUTPUT_OVERFLOW;
  2861.                                     close(fd);
  2862.                                     return -1;
  2863.                                 }
  2864.                                 agrep_outpointer += outindex;
  2865.  
  2866.                                 for(outindex=0; (outindex+agrep_outpointer<agrep_outlen) &&
  2867.                                         (s[outindex] != '\0'); outindex++) {
  2868.                                     agrep_outbuffer[agrep_outpointer+outindex] = s[outindex];
  2869.                                 }
  2870.                                 if (s[outindex] != '\0') {
  2871.                                     OUTPUT_OVERFLOW;
  2872.                                     close(fd);
  2873.                                     return -1;
  2874.                                 }
  2875.                                 agrep_outpointer += outindex;
  2876.                             }
  2877.                             NEW_FILE = OFF;
  2878.                         }
  2879.                         else if (!FNAME) {
  2880.                             if (agrep_finalfp != NULL)
  2881.                                 fprintf(agrep_finalfp, "%d\n", total_line - (num_of_matched - prev_num_of_matched));
  2882.                             else {
  2883.                                 char s[32];
  2884.                                 int  outindex;
  2885.  
  2886.                                 sprintf(s, "%d\n", total_line - (num_of_matched - prev_num_of_matched));
  2887.  
  2888.                                 for(outindex=0; (outindex+agrep_outpointer<agrep_outlen) &&
  2889.                                         (s[outindex] != '\0'); outindex++) {
  2890.                                     agrep_outbuffer[agrep_outpointer+outindex] = s[outindex];
  2891.                                 }
  2892.                                 if (s[outindex] != '\0') {
  2893.                                     OUTPUT_OVERFLOW;
  2894.                                     close(fd);
  2895.                                     return -1;
  2896.                                 }
  2897.                                 agrep_outpointer += outindex;
  2898.                             }
  2899.                         }
  2900.                     }
  2901.                     else if ( !(INVERSE && (PAT_FILE || PAT_BUFFER)) && (((num_of_matched - prev_num_of_matched) > 0) || !NOOUTPUTZERO) ) {
  2902.                         /* inverse is always 0 in glimpse, so we always come here */
  2903.                         if(FNAME && (NEW_FILE || !POST_FILTER)) {
  2904.                             if (agrep_finalfp != NULL)
  2905.                                 fprintf(agrep_finalfp, "%s: %d\n", CurrentFileName, (num_of_matched - prev_num_of_matched)); 
  2906.                             else {
  2907.                                 char s[32];
  2908.                                 int  outindex;
  2909.  
  2910.                                 sprintf(s, ": %d\n", (num_of_matched - prev_num_of_matched));
  2911.  
  2912.                                 for(outindex=0; (outindex+agrep_outpointer<agrep_outlen) &&
  2913.                                         (CurrentFileName[outindex] != '\0'); outindex++) {
  2914.                                     agrep_outbuffer[agrep_outpointer+outindex] = CurrentFileName[outindex];
  2915.                                 }
  2916.                                 if (CurrentFileName[outindex] != '\0') {
  2917.                                     OUTPUT_OVERFLOW;
  2918.                                     close(fd);
  2919.                                     return -1;
  2920.                                 }
  2921.                                 agrep_outpointer += outindex;
  2922.  
  2923.                                 for(outindex=0; (outindex+agrep_outpointer<agrep_outlen) &&
  2924.                                         (s[outindex] != '\0'); outindex++) {
  2925.                                     agrep_outbuffer[agrep_outpointer+outindex] = s[outindex];
  2926.                                 }
  2927.                                 if (s[outindex] != '\0') {
  2928.                                     OUTPUT_OVERFLOW;
  2929.                                     close(fd);
  2930.                                     return -1;
  2931.                                 }
  2932.                                 agrep_outpointer += outindex;
  2933.                             }
  2934.                             NEW_FILE = OFF;
  2935.                         }
  2936.                         else if (!FNAME) {
  2937.                             if (agrep_finalfp != NULL)
  2938.                                 fprintf(agrep_finalfp, "%d\n", (num_of_matched - prev_num_of_matched));
  2939.                             else {
  2940.                                 char s[32];
  2941.                                 int  outindex;
  2942.  
  2943.                                 sprintf(s, "%d\n", (num_of_matched - prev_num_of_matched));
  2944.  
  2945.                                 for(outindex=0; (outindex+agrep_outpointer<agrep_outlen) &&
  2946.                                         (s[outindex] != '\0'); outindex++) {
  2947.                                     agrep_outbuffer[agrep_outpointer+outindex] = s[outindex];
  2948.                                 }
  2949.                                 if (s[outindex] != '\0') {
  2950.                                     OUTPUT_OVERFLOW;
  2951.                                     close(fd);
  2952.                                     return -1;
  2953.                                 }
  2954.                                 agrep_outpointer += outindex;
  2955.                             }
  2956.                         }
  2957.                     }
  2958.                 }  /* if COUNT */
  2959.                 if(FILEOUT && (num_of_matched - prev_num_of_matched)) {
  2960.                     if (-1 == file_out(CurrentFileName)) {
  2961.                         close(fd);
  2962.                         return -1;
  2963.                     }
  2964.                 }
  2965.             } /* else */
  2966.             if (glimpse_clientdied) {
  2967.                 close(fd);
  2968.                 return -1;
  2969.             }
  2970.             if (agrep_finalfp != NULL) fflush(agrep_finalfp);
  2971.             if ((LIMITOUTPUT > 0) && (LIMITOUTPUT <= num_of_matched)) {
  2972.                 close(fd);
  2973.                 break;    /* done */
  2974.             }
  2975.         }  /* for i < Numfiles */
  2976.  
  2977.         if(NOMATCH && BESTMATCH) {
  2978.             if(WORDBOUND || WHOLELINE || LINENUM || INVERSE) { 
  2979.                 SGREP = 0;    
  2980.                 if(-1 == preprocess(D_pattern, Pattern)) return -1;
  2981.                 strcpy(old_D_pat, D_pattern);
  2982.                 if((M = maskgen(Pattern, D)) == -1) return -1;
  2983.             }
  2984.             COUNT=ON; 
  2985.             D=1;
  2986.             while(D<M && D<=MaxError && (num_of_matched - prev_num_of_matched == 0)) {
  2987.                 for (i = 0; i < Numfiles; i++, close(fd)) {
  2988.                     prev_num_of_matched = num_of_matched;
  2989.                     CurrentByteOffset = 0;
  2990.                     strcpy(CurrentFileName, Textfiles[i]);
  2991.                     NEW_FILE = ON;
  2992.                     if ((fd = open(Textfiles[i], O_RDONLY)) > 0) {
  2993.                         if(PAT_FILE || PAT_BUFFER) mgrep(fd, AParse);
  2994.                         else {
  2995.                             if(SGREP) ret = sgrep(OldPattern,strlen(OldPattern),fd,D, i);
  2996.                             else ret = bitap(old_D_pat,Pattern,fd,M,D);
  2997.                         }
  2998.                         if (ret <= -1) return -1;
  2999.                     }
  3000.                     if (glimpse_clientdied) {
  3001.                         close(fd);
  3002.                         return -1;
  3003.                     }
  3004.                     if (agrep_finalfp != NULL) fflush(agrep_finalfp);
  3005.                     if ((LIMITOUTPUT > 0) && (LIMITOUTPUT <= num_of_matched) && (num_of_matched > prev_num_of_matched)) {
  3006.                         close(fd);
  3007.                         break;
  3008.                     }
  3009.                 }  /* for i < Numfiles */
  3010.                 D++;
  3011.             } /* while */
  3012.  
  3013.             if(num_of_matched - prev_num_of_matched > 0) {
  3014.                 D--; 
  3015.                 errno = D;    /* #of errors if proper return */
  3016.                 COUNT = 0;
  3017.  
  3018.                 if(num_of_matched - prev_num_of_matched == 1) fprintf(stderr,"%s: 1 word matches ", Progname);
  3019.                 else fprintf(stderr,"%s: %d words match ", Progname, num_of_matched - prev_num_of_matched);
  3020.                 if(D==1) fprintf(stderr, "within 1 error");
  3021.                 else fprintf(stderr, "within %d errors", D);
  3022.  
  3023.                 fflush(stderr);
  3024.  
  3025.                 if(NOPROMPT) fprintf(stderr, "\n");
  3026.                 else {
  3027.                     if(num_of_matched - prev_num_of_matched == 1) fprintf(stderr,"; search for it? (y/n)");
  3028.                     else fprintf(stderr,"; search for them? (y/n)");
  3029.                     c[0] = 'y';
  3030.                     if (!glimpse_isserver && (fgets(c, 4, stdin) == NULL)) goto CONT;
  3031.                     if(c[0] != 'y') goto CONT;
  3032.                 }
  3033.  
  3034.                 for (i = 0; i < Numfiles; i++, close(fd)) {
  3035.                     prev_num_of_matched = num_of_matched;
  3036.                     CurrentByteOffset = 0;
  3037.                     strcpy(CurrentFileName, Textfiles[i]);
  3038.                     NEW_FILE = ON;
  3039.                     if ((fd = open(Textfiles[i], O_RDONLY)) > 0) {
  3040.                         if(PAT_FILE || PAT_BUFFER) mgrep(fd, AParse);
  3041.                         else {
  3042.                             if(SGREP) ret = sgrep(OldPattern,strlen(OldPattern),fd,D, i);
  3043.                             else ret = bitap(old_D_pat,Pattern,fd,M,D);
  3044.                         }
  3045.                         if (ret <= -1) {
  3046.                             close(fd);
  3047.                             return -1;
  3048.                         }
  3049.                     }
  3050.                     if (glimpse_clientdied) {
  3051.                         close(fd);
  3052.                         return -1;
  3053.                     }
  3054.                     if (agrep_finalfp != NULL) fflush(agrep_finalfp);
  3055.                     if ((LIMITOUTPUT > 0) && (LIMITOUTPUT <= num_of_matched)) {
  3056.                         close(fd);
  3057.                         break;    /* done */
  3058.                     }
  3059.                 }  /* for i < Numfiles */
  3060.                 NOMATCH = 0;
  3061.             }
  3062.         }
  3063.     }
  3064. CONT:
  3065.     if(EATFIRST) {
  3066.         if (agrep_finalfp != NULL) fprintf(agrep_finalfp, "\n");
  3067.         else if (agrep_outpointer >= agrep_outlen) {
  3068.             OUTPUT_OVERFLOW;
  3069.             return -1;
  3070.         }
  3071.         else agrep_outbuffer[agrep_outpointer++] = '\n';
  3072.         EATFIRST = OFF;
  3073.     }
  3074.     if(num_of_matched - prev_num_of_matched > 0) NOMATCH = OFF;
  3075.     /* if(NOMATCH) return(0); */
  3076.     /*printf("exec=%d\n", num_of_matched);*/
  3077.     return(num_of_matched);
  3078.  
  3079. } /* end of exec() */
  3080.  
  3081.  
  3082. /* Just output the contents of the file fname onto the std output */
  3083. file_out(fname)
  3084. char *fname;
  3085. {
  3086.     int num_read;
  3087.     int fd;
  3088.     int i, len;
  3089.     CHAR buf[SIZE+2];
  3090.     if(FNAME) {
  3091.         len = strlen(fname);
  3092.         if (agrep_finalfp != NULL) {
  3093.             fputc('\n', agrep_finalfp);
  3094.             for(i=0; i< len; i++) fputc(':', agrep_finalfp);
  3095.             fputc('\n', agrep_finalfp);
  3096.             fprintf(agrep_finalfp, "%s\n", CurrentFileName);
  3097.             for(i=0; i< len; i++) fputc(':', agrep_finalfp);
  3098.             fputc('\n', agrep_finalfp);
  3099.             fflush(agrep_finalfp);
  3100.         }
  3101.         else {
  3102.             if (1+len+1+len+1+len+1+agrep_outpointer >= agrep_outlen) {
  3103.                 OUTPUT_OVERFLOW;
  3104.                 return -1;
  3105.             }
  3106.             agrep_outbuffer[agrep_outpointer++] = '\n';
  3107.             for (i=0; i<len; i++) agrep_outbuffer[agrep_outpointer++] = ':';
  3108.             agrep_outbuffer[agrep_outpointer++] = '\n';
  3109.             for (i=0; i<len; i++) agrep_outbuffer[agrep_outpointer++] = CurrentFileName[i];
  3110.             agrep_outbuffer[agrep_outpointer++] = '\n';
  3111.             for (i=0; i<len; i++) agrep_outbuffer[agrep_outpointer++] = ':';
  3112.             agrep_outbuffer[agrep_outpointer++] = '\n';
  3113.         }
  3114.     }
  3115.     fd = open(fname, O_RDONLY);
  3116.     if (agrep_finalfp != NULL) {
  3117.         while((num_read = fill_buf(fd, buf, SIZE)) > 0) 
  3118.             write(1, buf, num_read);
  3119.         if (glimpse_clientdied) {
  3120.             close(fd);
  3121.             return -1;
  3122.         }
  3123.     }
  3124.     else {
  3125.         if ((num_read = fill_buf(fd, agrep_outbuffer + agrep_outpointer, agrep_outlen - agrep_outpointer)) > 0)
  3126.             agrep_outpointer += num_read;
  3127.     }
  3128.     close(fd);
  3129.     return 0;
  3130. }
  3131.  
  3132. output(buffer, i1, i2, j)  
  3133. register CHAR *buffer; 
  3134. int i1, i2, j;
  3135. {
  3136.     register CHAR *bp, *outend;
  3137.     if(i1 > i2) return 0;
  3138.     num_of_matched++;
  3139.     if(COUNT)  return 0;
  3140.     if(SILENT) return 0;
  3141.     if(OUTTAIL || (!DELIMITER && (D_length == 1) && (D_pattern[0] == '\n')) ) {
  3142.         i1 = i1 + D_length;
  3143.         i2 = i2 + D_length;
  3144.     }
  3145.     if(DELIMITER) j = j+1;
  3146.     if(FIRSTOUTPUT) {
  3147.         if (buffer[i1] == '\n')  {
  3148.             i1++;
  3149.             EATFIRST = ON;
  3150.         }
  3151.         FIRSTOUTPUT = 0;
  3152.     }
  3153.     if(TRUNCATE) {
  3154.         fprintf(stderr, "WARNING!  some lines have been truncated in output record #%d\n", num_of_matched-1);
  3155.     }
  3156.  
  3157.     /* Why do we have to do this? */
  3158.     while ((buffer[i1] == '\n') && (i1 <= i2)) {
  3159.         if (agrep_finalfp != NULL) fprintf(agrep_finalfp, "\n");
  3160.         else {
  3161.             if (agrep_outpointer < agrep_outlen)
  3162.                 agrep_outbuffer[agrep_outpointer ++] = '\n';
  3163.             else {
  3164.                 OUTPUT_OVERFLOW;
  3165.                 return -1;
  3166.             }
  3167.         }
  3168.         i1++;
  3169.     }
  3170.  
  3171.     if(FNAME && (NEW_FILE || !POST_FILTER)) {
  3172.         char    nextchar = (POST_FILTER == ON)?'\n':' ';
  3173.         char    *prevstring = (POST_FILTER == ON)?"\n":"";
  3174.         if (agrep_finalfp != NULL)
  3175.             fprintf(agrep_finalfp, "%s%s:%c", prevstring, CurrentFileName, nextchar);
  3176.         else {
  3177.             int outindex;
  3178.             if (prevstring[0] != '\0') {
  3179.                 if(agrep_outpointer + 1 >= agrep_outlen) {
  3180.                     OUTPUT_OVERFLOW;
  3181.                     return -1;
  3182.                 }
  3183.                 else agrep_outbuffer[agrep_outpointer ++] = prevstring[0];
  3184.             }
  3185.             for(outindex=0; (outindex+agrep_outpointer<agrep_outlen) &&
  3186.                     (CurrentFileName[outindex] != '\0'); outindex++) {
  3187.                 agrep_outbuffer[agrep_outpointer+outindex] = CurrentFileName[outindex];
  3188.             }
  3189.             if ((CurrentFileName[outindex] != '\0') || (outindex+agrep_outpointer+2>=agrep_outlen)) {
  3190.                 OUTPUT_OVERFLOW;
  3191.                 return -1;
  3192.             }
  3193.             else {
  3194.                 agrep_outbuffer[agrep_outpointer+outindex++] = ':';
  3195.                 agrep_outbuffer[agrep_outpointer+outindex++] = nextchar;
  3196.             }
  3197.             agrep_outpointer += outindex;
  3198.         }
  3199.         NEW_FILE = OFF;
  3200.     }
  3201.     if(LINENUM) {
  3202.         if (agrep_finalfp != NULL)
  3203.             fprintf(agrep_finalfp, "%d: ", j-1); 
  3204.         else {
  3205.             char s[32];
  3206.             int  outindex;
  3207.  
  3208.             sprintf(s, "%d: ", j-1);
  3209.             for(outindex=0; (outindex+agrep_outpointer<agrep_outlen) &&
  3210.                     (s[outindex] != '\0'); outindex++) {
  3211.                 agrep_outbuffer[agrep_outpointer+outindex] = s[outindex];
  3212.             }
  3213.             if (s[outindex] != '\0') {
  3214.                 OUTPUT_OVERFLOW;
  3215.                 return -1;
  3216.             }
  3217.             agrep_outpointer += outindex;
  3218.         }
  3219.     }
  3220.     if(BYTECOUNT) {
  3221.         if (agrep_finalfp != NULL)
  3222.             fprintf(agrep_finalfp, "%d= ", CurrentByteOffset-1);
  3223.         else {
  3224.             char s[32];
  3225.             int  outindex;
  3226.             sprintf(s, "%d= ", CurrentByteOffset-1);
  3227.             for(outindex=0; (outindex+agrep_outpointer<agrep_outlen) &&
  3228.                     (s[outindex] != '\0'); outindex++) {
  3229.                 agrep_outbuffer[agrep_outpointer+outindex] = s[outindex];
  3230.             }
  3231.             if (s[outindex] != '\0') {
  3232.                 OUTPUT_OVERFLOW;
  3233.                 return -1;
  3234.             }
  3235.             agrep_outpointer += outindex;
  3236.         }
  3237.     }
  3238.  
  3239.     bp = buffer + i1;
  3240.     outend = buffer + i2;
  3241.  
  3242.     if (agrep_finalfp != NULL)
  3243.         while(bp <= outend) fputc(*bp++, agrep_finalfp);
  3244.     else {
  3245.         if (outend - bp + 1 + agrep_outpointer >= agrep_outlen) {
  3246.             OUTPUT_OVERFLOW;
  3247.             return -1;
  3248.         }
  3249.         while(bp <= outend) agrep_outbuffer[agrep_outpointer ++] = *bp++;
  3250.     }
  3251.  
  3252.     return 0;
  3253. }
  3254.  
  3255. agrep_usage()
  3256. {
  3257.     if (glimpse_call) return -1;
  3258.     fprintf(stderr, "usage: %s [-#abcdehiklnoprstvwxyBDGIMSV] [-f patternfile] [-H dir] pattern [files]\n", Progname); 
  3259.     fprintf(stderr, "\n");    
  3260.     fprintf(stderr, "summary of frequently used options:\n");
  3261.     fprintf(stderr, "(For a more detailed listing see 'man agrep'.)\n");
  3262.     fprintf(stderr, "-#: find matches with at most # errors\n");
  3263.     fprintf(stderr, "-c: output the number of matched records\n");
  3264.     fprintf(stderr, "-d: define record delimiter\n");
  3265.     fprintf(stderr, "-h: do not output file names\n");
  3266.     fprintf(stderr, "-i: case-insensitive search, e.g., 'a' = 'A'\n");
  3267.     fprintf(stderr, "-l: output the names of files that contain a match\n");
  3268.     fprintf(stderr, "-n: output record prefixed by record number\n");
  3269.     fprintf(stderr, "-v: output those records that have no matches\n");
  3270.     fprintf(stderr, "-w: pattern has to match as a word, e.g., 'win' will not match 'wind'\n");
  3271.     fprintf(stderr, "-B: best match mode. find the closest matches to the pattern\n"); 
  3272.     fprintf(stderr, "-G: output the files that contain a match\n");
  3273.     fprintf(stderr, "-H 'dir': the cast-dictionary is located in directory 'dir'\n");
  3274.     fprintf(stderr, "\n");    
  3275.  
  3276.     if (!EXITONERROR) {
  3277.         errno = 2;
  3278.         return -1;
  3279.     }
  3280.     else exit(2);
  3281. }
  3282.