home *** CD-ROM | disk | FTP | other *** search
/ Skunkware 5 / Skunkware 5.iso / src / Tools / glimpse-2.1 / agrep / mgrep.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-05-16  |  17.3 KB  |  641 lines
  1. /* Copyright (c) 1994 Sun Wu, Udi Manber, Burra Gopal.  All Rights Reserved. */
  2. /* multipattern matcher */
  3. #include <stdio.h>
  4. #include <ctype.h>
  5. #include "agrep.h"
  6.  
  7. #undef    MAXPAT
  8. #define MAXPAT  256
  9.  
  10. #define MAXLINE 1024
  11. #define MAXSYM  256
  12. #define MAXMEMBER1 4096
  13. #define MAXPATFILE 260000
  14. #define BLOCKSIZE  16384
  15. #define MAXHASH    8192
  16. #define mm        8191
  17. #define max_num    30000
  18. #define W_DELIM       128
  19. #define L_DELIM    10 
  20.  
  21. extern int LIMITOUTPUT;
  22. extern int MULTI_OUTPUT;
  23. extern COUNT, FNAME, SILENT, FILENAMEONLY, prev_num_of_matched, num_of_matched;
  24. extern INVERSE;
  25. extern WORDBOUND, WHOLELINE, NOUPPER;
  26. extern unsigned char  CurrentFileName[], Progname[]; 
  27. extern total_line;
  28. extern agrep_initialfd;
  29. extern int EXITONERROR;
  30. extern int PRINTPATTERN;
  31. extern int agrep_inlen;
  32. extern CHAR *agrep_inbuffer;
  33. extern FILE *agrep_finalfp;
  34. extern int agrep_outpointer;
  35. extern int agrep_outlen;
  36. extern CHAR * agrep_outbuffer;
  37. extern int errno;
  38.  
  39. extern int NEW_FILE, POST_FILTER;
  40.  
  41. int LONG  = 0;
  42. int SHORT = 0;
  43. int p_size=0;
  44. unsigned char SHIFT1[MAXMEMBER1];
  45. unsigned char tr[MAXSYM];
  46. unsigned char tr1[MAXSYM];
  47. struct pat_list {
  48.     int  index;
  49.     struct pat_list *next;
  50. } 
  51. *HASH[MAXHASH];
  52. struct pat_list  *pt, *qt;
  53. unsigned char pat_spool[MAXPATFILE+2*max_num+MAXPAT];
  54. unsigned char *patt[max_num];
  55. unsigned char pat_len[max_num];
  56. int num_pat;
  57.  
  58.  
  59. prepf(mfp, mbuf, mlen)
  60. int mfp, mlen;
  61. unsigned char *mbuf;
  62. {
  63.     int length=0, i, p=1, pdx=0;
  64.     unsigned char *pat_ptr=pat_spool;
  65.     unsigned Mask = 15;
  66.     int num_read;
  67.     unsigned char *buf;
  68.  
  69.     if ((mfp == -1) && ((mbuf == NULL) || (mlen <= 0))) return -1;
  70.  
  71.     if (mfp != -1) {
  72.         alloc_buf(mfp, &buf, MAXPATFILE+2*BLOCKSIZE);
  73.         while((num_read = fill_buf(mfp, buf+length, 2*BLOCKSIZE)) > 0) {
  74.             length = length + num_read;
  75.             if(length > MAXPATFILE) {
  76.                 fprintf(stderr, "%s: maximum pattern file size is %d\n", Progname, MAXPATFILE);
  77.                 if (!EXITONERROR) {
  78.                     errno = 2;
  79.                     free_buf(mfp, buf);
  80.                     return -1;
  81.                 }
  82.                 else exit(2);
  83.             }
  84.         }
  85.     }
  86.     else {
  87.         buf = mbuf;
  88.         length = mlen;
  89.     }
  90.  
  91.     buf[length] = '\n';
  92.  
  93.     i = 0; 
  94.     p=1;
  95.     while(i<length) {
  96.         patt[p] = pat_ptr;
  97.         if(WORDBOUND) *pat_ptr++ = W_DELIM;
  98.         if(WHOLELINE) *pat_ptr++ = L_DELIM;
  99.         while((*pat_ptr = buf[i++]) != '\n') pat_ptr++;
  100.         if(WORDBOUND) *pat_ptr++ = W_DELIM;
  101.         if(WHOLELINE) *pat_ptr++ = L_DELIM;           /* Can't be both on */
  102.         *pat_ptr++ = 0;
  103.         p++;  
  104.     }
  105.     if(p>max_num) {
  106.         fprintf(stderr, "%s: maximum number of patterns is %d\n", Progname, max_num); 
  107.         if (!EXITONERROR) {
  108.             errno = 2;
  109.             free_buf(mfp, buf);
  110.             return -1;
  111.         }
  112.         else exit(2);
  113.     }
  114.     for(i=1; i<20; i++) *pat_ptr = i;  /* boundary safety zone */
  115.     for(i=0; i< MAXSYM; i++) tr[i] = i;
  116.     if(NOUPPER) {
  117.         for (i=0; i<MAXSYM; i++)
  118.             if (isupper(i)) tr[i] = tr[tolower(i)];
  119.         /* for(i='A'; i<= 'Z'; i++) tr[i] = i + 'a' - 'A'; */
  120.     }
  121.     if(WORDBOUND) {
  122.         for(i=0; i<128; i++) if(!isalnum(i)) tr[i] = W_DELIM;
  123.     }
  124.     for(i=0; i< MAXSYM; i++) tr1[i] = tr[i]&Mask;
  125.     num_pat = p-1;
  126.     p_size = MAXPAT;
  127.     for(i=1 ; i <= num_pat; i++) {
  128.         p = strlen(patt[i]);
  129.         pat_len[i] = p;
  130.         if(p!=0 && p < p_size) p_size = p;
  131.     }
  132.     if(p_size == 0) {
  133.         fprintf(stderr, "%s: the pattern file is empty\n");
  134.         if (!EXITONERROR) {
  135.             errno = 2;
  136.             free_buf(mfp, buf);
  137.             return -1;
  138.         }
  139.         else exit(2);
  140.     }
  141.     if(length > 400 && p_size > 2) LONG = 1;
  142.     if(p_size == 1) SHORT = 1;
  143.     for(i=0; i<MAXMEMBER1; i++) SHIFT1[i] = p_size - 2;
  144.     for(i=0; i<MAXHASH; i++) {
  145.         HASH[i] = 0;
  146.     }
  147.     for(i=1; i<= num_pat; i++) f_prep(i, patt[i]);
  148.  
  149.     free_buf(mfp, buf);
  150.     return 0;
  151. }
  152.  
  153.  
  154. mgrep(fd)
  155. int fd;
  156. { 
  157.     register char r_newline = '\n';
  158.     unsigned char *text;
  159.     register int buf_end, num_read, i=0, j, start, end, residue = 0;
  160.  
  161. #if    AGREP_POINTER
  162.     if (fd != -1) {
  163. #endif    /*AGREP_POINTER*/
  164.         alloc_buf(fd, &text, 2*BLOCKSIZE+MAXLINE); 
  165.         text[MAXLINE-1] = '\n';  /* initial case */
  166.         start = MAXLINE-1;
  167.  
  168.         while( (num_read = fill_buf(fd, text+MAXLINE, 2*BLOCKSIZE)) > 0) 
  169.         {
  170.             if(INVERSE && COUNT) countline(text+MAXLINE, num_read);
  171.             buf_end = end = MAXLINE + num_read -1 ;
  172.             while(text[end]  != r_newline && end > MAXLINE) end--;
  173.             residue = buf_end - end  + 1 ;
  174.             text[start-1] = r_newline;
  175.  
  176.             /* MGREP_PROCESS */
  177.             if(SHORT) { if (-1 == m_short(text, start, end)) {free_buf(fd, text); return -1;}}
  178.             else      { if (-1 == monkey1(text, start, end)) {free_buf(fd, text); return -1;}}
  179.             if(FILENAMEONLY && (num_of_matched - prev_num_of_matched) && (NEW_FILE || !POST_FILTER)) {
  180.                 if (agrep_finalfp != NULL)
  181.                     fprintf(agrep_finalfp, "%s\n", CurrentFileName);
  182.                 else {
  183.                     int outindex;
  184.                     for(outindex=0; (outindex+agrep_outpointer<agrep_outlen) &&
  185.                             (CurrentFileName[outindex] != '\0'); outindex++) {
  186.                         agrep_outbuffer[agrep_outpointer+outindex] = CurrentFileName[outindex];
  187.                     }
  188.                     if ((CurrentFileName[outindex] != '\0') || (outindex+agrep_outpointer+1>=agrep_outlen)) {
  189.                         OUTPUT_OVERFLOW;
  190.                         free_buf(fd, text);
  191.                         return -1;
  192.                     }
  193.                     else {
  194.                         agrep_outbuffer[agrep_outpointer+outindex++] = '\n';
  195.                     }
  196.                     agrep_outpointer += outindex;
  197.                 }
  198.                 free_buf(fd, text);
  199.                 NEW_FILE = OFF;
  200.                 return 0;
  201.             }
  202.  
  203.             start = MAXLINE - residue;
  204.             if(start < 0) {
  205.                 start = 1; 
  206.             }
  207.             strncpy(text+start, text+end, residue);
  208.         } /* end of while(num_read = ...) */
  209.         text[MAXLINE] = '\n';
  210.         text[start-1] = '\n';
  211.         if(residue > 1) {
  212.             if(SHORT) m_short(text, start, end);
  213.             else      monkey1(text, start, end);
  214.         }
  215.         free_buf(fd, text);
  216.         return 0;
  217. #if    AGREP_POINTER
  218.     }
  219.     else {
  220.         text = (unsigned char *)agrep_inbuffer;
  221.         num_read = agrep_inlen;
  222.         buf_end = end = num_read - 1;
  223.         text[0] = text[end] = r_newline;
  224.         start = 1;
  225.         if (INVERSE && COUNT) countline(text, num_read);
  226.  
  227.             /* An exact copy of the above MGREP_PROCESS */
  228.             if(SHORT) { if (-1 == m_short(text, start, end)) {free_buf(fd, text); return -1;}}
  229.             else      { if (-1 == monkey1(text, start, end)) {free_buf(fd, text); return -1;}}
  230.             if(FILENAMEONLY && (num_of_matched - prev_num_of_matched) && (NEW_FILE || !POST_FILTER)) {
  231.                 if (agrep_finalfp != NULL)
  232.                     fprintf(agrep_finalfp, "%s\n", CurrentFileName);
  233.                 else {
  234.                     int outindex;
  235.                     for(outindex=0; (outindex+agrep_outpointer<agrep_outlen) &&
  236.                             (CurrentFileName[outindex] != '\0'); outindex++) {
  237.                         agrep_outbuffer[agrep_outpointer+outindex] = CurrentFileName[outindex];
  238.                     }
  239.                     if ((CurrentFileName[outindex] != '\0') || (outindex+agrep_outpointer+1>=agrep_outlen)) {
  240.                         OUTPUT_OVERFLOW;
  241.                         free_buf(fd, text);
  242.                         return -1;
  243.                     }
  244.                     else {
  245.                         agrep_outbuffer[agrep_outpointer+outindex++] = '\n';
  246.                     }
  247.                     agrep_outpointer += outindex;
  248.                 }
  249.                 free_buf(fd, text);
  250.                 NEW_FILE = OFF;
  251.                 return 0;
  252.             }
  253.  
  254.         return 0;
  255.     }
  256. #endif    /*AGREP_POINTER*/
  257. } /* end mgrep */
  258.  
  259. countline(text, len)
  260. unsigned char *text; 
  261. int len;
  262. {
  263.     int i;
  264.     for (i=0; i<len; i++) if(text[i] == '\n') total_line++;
  265. }
  266.  
  267.  
  268. monkey1( text, start, end  ) 
  269. int start, end; 
  270. register unsigned char *text;
  271. {
  272.     unsigned char *oldtext;
  273.     register unsigned char *textend;
  274.     register unsigned hash, i;
  275.     register unsigned char shift; 
  276.     register int  m1, j, Long=LONG; 
  277.     int pat_index, m=p_size; 
  278.     int MATCHED=0;
  279.     register unsigned char *qx;
  280.     register struct pat_list *p;
  281.     unsigned char *lastout;
  282.     int OUT=0;
  283.  
  284.     textend = text + end;
  285.     m1 = m - 1;
  286.     lastout = text+start+1;
  287.     text = text + start + m1 ;
  288.     while (text <= textend) {
  289.         hash=tr1[*text];
  290.         hash=(hash<<4)+(tr1[*(text-1)]);
  291.         if(Long) hash=(hash<<4)+(tr1[*(text-2)]);
  292.         shift = SHIFT1[hash];
  293.         if(shift == 0) {
  294.             for(i=2+Long;i<=m1;i++)  {
  295.                 hash=(hash<<4)+(tr1[*(text-i)]);
  296.             }
  297.             hash=hash&mm;
  298.             p = HASH[hash];
  299.             while(p != 0) {
  300.                 pat_index = p->index;
  301.                 p = p->next;
  302.                 qx = text-m1;
  303.                 j = 0;
  304.                 while(tr[patt[pat_index][j]] == tr[*(qx++)]) j++;
  305.                 if (j > m1 ) { 
  306.                     if((int)(pat_len[pat_index]) <= j) {
  307.                         if(text > textend) return 0;
  308.                         /* Udi: if -P (output the pattern # as well as the matched line) ->
  309.                             print(pat_index:) ========= bg: DONE, see below */
  310.                         num_of_matched ++;
  311.                         if(FILENAMEONLY || SILENT)  return 0;
  312.                         MATCHED=1;
  313.                         oldtext = text;    /* only for MULTI_OUTPUT */
  314.  
  315.                         if(COUNT) {
  316.                             while (*text != '\n') text++;
  317.                         }
  318.                         else {
  319.                             if(FNAME && (NEW_FILE || !POST_FILTER)) {
  320.                                 char    nextchar = (POST_FILTER == ON)?'\n':' ';
  321.                                 char    *prevstring = (POST_FILTER == ON)?"\n":"";
  322.                                 if (agrep_finalfp != NULL)
  323.                                     fprintf(agrep_finalfp, "%s%s:%c", prevstring, CurrentFileName, nextchar);
  324.                                 else {
  325.                                     int outindex;
  326.                                     if (prevstring[0] != '\0') {
  327.                                         if(agrep_outpointer + 1 >= agrep_outlen) {
  328.                                             OUTPUT_OVERFLOW;
  329.                                             return -1;
  330.                                         }
  331.                                         else agrep_outbuffer[agrep_outpointer ++] = prevstring[0];
  332.                                     }
  333.                                     for(outindex=0; (outindex+agrep_outpointer<agrep_outlen) &&
  334.                                             (CurrentFileName[outindex] != '\0'); outindex++) {
  335.                                         agrep_outbuffer[agrep_outpointer+outindex] = CurrentFileName[outindex];
  336.                                     }
  337.                                     if ((CurrentFileName[outindex] != '\0') || (outindex+agrep_outpointer+2>=agrep_outlen)) {
  338.                                         OUTPUT_OVERFLOW;
  339.                                         return -1;
  340.                                     }
  341.                                     else {
  342.                                         agrep_outbuffer[agrep_outpointer+outindex++] = ':';
  343.                                         agrep_outbuffer[agrep_outpointer+outindex++] = nextchar;
  344.                                     }
  345.                                     agrep_outpointer += outindex;
  346.                                 }
  347.                                 NEW_FILE = OFF;
  348.                             }
  349.  
  350.                             if (PRINTPATTERN) {
  351.                                 if (agrep_finalfp != NULL)
  352.                                     fprintf(agrep_finalfp, "%d- ", pat_index);
  353.                                 else {
  354.                                     char s[32];
  355.                                     int outindex;
  356.                                     sprintf(s, "%d- ", pat_index);
  357.                                     for(outindex=0; (outindex+agrep_outpointer<agrep_outlen) &&
  358.                                             (s[outindex] != '\0'); outindex++) {
  359.                                         agrep_outbuffer[agrep_outpointer+outindex] = s[outindex];
  360.                                     }
  361.                                     if (s[outindex] != '\0') {
  362.                                         OUTPUT_OVERFLOW;
  363.                                         return -1;
  364.                                     }
  365.                                     agrep_outpointer += outindex;
  366.                                 }
  367.                             }
  368.  
  369.                             if(!INVERSE) {
  370.                                 while(*(--text) != '\n');
  371.  
  372.                                 if (agrep_finalfp != NULL) {
  373.                                     while((text < textend) && (*(++text) != '\n')) fputc(*text, agrep_finalfp);
  374.                                     fputc('\n', agrep_finalfp);
  375.                                 }
  376.                                 else {
  377.                                     while ((text < textend) && (*(++text) != '\n') && (agrep_outpointer < agrep_outlen))
  378.                                         agrep_outbuffer[agrep_outpointer ++] = *text;
  379.                                     if ((*text != '\n') || (agrep_outpointer + 1 >= agrep_outlen)) {
  380.                                         OUTPUT_OVERFLOW;
  381.                                         return -1;
  382.                                     }
  383.                                     else agrep_outbuffer[agrep_outpointer ++] = '\n';
  384.                                 }
  385.  
  386.                                 if (MULTI_OUTPUT) {    /* next match starting from end of current */
  387.                                     text = oldtext + pat_len[pat_index] - 1;
  388.                                     MATCHED = 0;
  389.                                 }
  390.                             }
  391.                             else {
  392.                                 while(*(--text) != '\n');
  393.                                 if(lastout < text) OUT=1;
  394.                                 if (agrep_finalfp != NULL) {
  395.                                     while(lastout < text) fputc(*lastout++, agrep_finalfp);
  396.                                 }
  397.                                 else {
  398.                                     if (text - lastout + agrep_outpointer >= agrep_outlen) {
  399.                                         OUTPUT_OVERFLOW;
  400.                                         return -1;
  401.                                     }
  402.                                     memcpy(agrep_outbuffer+agrep_outpointer, lastout, text-lastout);
  403.                                     agrep_outpointer += (text-lastout);
  404.                                     lastout = text;
  405.                                 }
  406.                                 if(OUT) {
  407.                                     if (agrep_finalfp != NULL) fputc('\n', agrep_finalfp);
  408.                                     else if (agrep_outpointer >= agrep_outlen) {
  409.                                         OUTPUT_OVERFLOW;
  410.                                         return -1;
  411.                                     }
  412.                                     else agrep_outbuffer[agrep_outpointer ++] = '\n';
  413.                                     OUT=0;
  414.                                 }
  415.                                 while((text < textend) && (*(++text) != '\n'));
  416.                                 lastout=text+1;
  417.                             } /* INVERSE */
  418.                         } /* COUNT */
  419.                         if ((LIMITOUTPUT > 0) && (LIMITOUTPUT <= num_of_matched)) return 0;    /* done */
  420.                     } /* pat_len[pat_index] <= j */
  421.                 } /* j > m1 */
  422.                 if (MATCHED && !MULTI_OUTPUT) break;    /* else look for more possible matches since we never know how many will match */
  423.             }
  424.             /* Udi: I think this should always be shift = 1 */
  425.             if(!MATCHED) shift = 1;
  426.             else {
  427.                 MATCHED = 0;
  428.                 shift = m1;
  429.             }
  430.         }
  431.         text = text + shift;
  432.     }
  433.     if(INVERSE && !COUNT) {
  434.         if (agrep_finalfp != NULL) {
  435.             while(lastout <= textend) fputc(*lastout++, agrep_finalfp);
  436.         }
  437.         else {
  438.             if (textend - lastout + 1 + agrep_outpointer >= agrep_outlen) {
  439.                 OUTPUT_OVERFLOW;
  440.                 return -1;
  441.             }
  442.             memcpy(agrep_outbuffer+agrep_outpointer, lastout, textend-lastout+1);
  443.             agrep_outpointer += (textend-lastout+1);
  444.             lastout = textend;
  445.         }
  446.     }
  447.  
  448.     return 0;
  449. }
  450.  
  451. m_short( text, start, end  ) 
  452. int start, end; 
  453. register unsigned char *text;
  454. {
  455.     unsigned char *oldtext;
  456.     register unsigned char *textend;
  457.     register unsigned i; 
  458.     register int  j; 
  459.     register struct pat_list *p, *q;
  460.     register int pat_index; 
  461.     int MATCHED=0;
  462.     int OUT=0;
  463.     unsigned char *lastout;
  464.     unsigned char *qx;
  465.  
  466.     textend = text + end;
  467.     lastout = text + start + 1;
  468.     text = text + start - 1 ;
  469.     while (++text <= textend) {
  470.         p = HASH[*text];
  471.         while(p != 0) {
  472.             pat_index = p->index;
  473.             p = p->next;
  474.             qx = text;
  475.             j = 0;
  476.             while(tr[patt[pat_index][j]] == tr[*(qx++)]) j++;
  477.             if((int)(pat_len[pat_index]) <= j) {
  478.                 if(text >= textend) return 0;
  479.                 num_of_matched++;
  480.                 if(FILENAMEONLY || SILENT)  return 0;
  481.  
  482.                 if(COUNT) {
  483.                     while (*text != '\n') text++;
  484.                 }
  485.                 else {
  486.                     MATCHED = 1;
  487.                     oldtext = text;    /* used only if MULTI_OUTPUT */
  488.                     if(FNAME && (NEW_FILE || !POST_FILTER)) {
  489.                         char    nextchar = (POST_FILTER == ON)?'\n':' ';
  490.                         char    *prevstring = (POST_FILTER == ON)?"\n":"";
  491.                         if (agrep_finalfp != NULL)
  492.                             fprintf(agrep_finalfp, "%s%s:%c", prevstring, CurrentFileName, nextchar);
  493.                         else {
  494.                             int outindex;
  495.                             if (prevstring[0] != '\0') {
  496.                                 if(agrep_outpointer + 1 >= agrep_outlen) {
  497.                                     OUTPUT_OVERFLOW;
  498.                                     return -1;
  499.                                 }
  500.                                 else agrep_outbuffer[agrep_outpointer ++] = prevstring[0];
  501.                             }
  502.                             for(outindex=0; (outindex+agrep_outpointer<agrep_outlen) &&
  503.                                     (CurrentFileName[outindex] != '\0'); outindex++) {
  504.                                 agrep_outbuffer[agrep_outpointer+outindex] = CurrentFileName[outindex];
  505.                             }
  506.                             if ((CurrentFileName[outindex] != '\0') || (outindex+agrep_outpointer+2>=agrep_outlen)) {
  507.                                 OUTPUT_OVERFLOW;
  508.                                 return -1;
  509.                             }
  510.                             else {
  511.                                 agrep_outbuffer[agrep_outpointer+outindex++] = ':';
  512.                                 agrep_outbuffer[agrep_outpointer+outindex++] = nextchar;
  513.                             }
  514.                             agrep_outpointer += outindex;
  515.                         }
  516.                         NEW_FILE = OFF;
  517.                     }
  518.  
  519.                     if (PRINTPATTERN) {
  520.                         if (agrep_finalfp != NULL)
  521.                             fprintf(agrep_finalfp, "%d- ", pat_index);
  522.                         else {
  523.                             char s[32];
  524.                             int outindex;
  525.                             sprintf(s, "%d- ", pat_index);
  526.                             for(outindex=0; (outindex+agrep_outpointer<agrep_outlen) &&
  527.                                     (s[outindex] != '\0'); outindex++) {
  528.                                 agrep_outbuffer[agrep_outpointer+outindex] = s[outindex];
  529.                             }
  530.                             if (s[outindex] != '\0') {
  531.                                 OUTPUT_OVERFLOW;
  532.                                 return -1;
  533.                             }
  534.                             agrep_outpointer += outindex;
  535.                         }
  536.                     }
  537.  
  538.                     if(!INVERSE) {
  539.                         while(*(--text) != '\n');
  540.                         if (agrep_finalfp != NULL) {
  541.                             while((text < textend) && (*(++text) != '\n')) fputc(*text, agrep_finalfp);
  542.                             fputc('\n', agrep_finalfp);
  543.                         }
  544.                         else {
  545.                             while ((text < textend) && (*(++text) != '\n') && (agrep_outpointer < agrep_outlen))
  546.                                 agrep_outbuffer[agrep_outpointer ++] = *text;
  547.                             if ((*text != '\n') || (agrep_outpointer + 1 >= agrep_outlen)) {
  548.                                 OUTPUT_OVERFLOW;
  549.                                 return -1;
  550.                             }
  551.                             else agrep_outbuffer[agrep_outpointer ++] = '\n';
  552.                         }
  553.                         if (MULTI_OUTPUT) {    /* next match starting from end of current */
  554.                             text = oldtext + pat_len[pat_index] - 1;
  555.                             MATCHED = 0;
  556.                         }
  557.                     }
  558.                     else {
  559.                         while(*(--text) != '\n');
  560.                         if(lastout < text) OUT=1;
  561.  
  562.                         if (agrep_finalfp != NULL) {
  563.                             while(lastout < text) fputc(*lastout++, agrep_finalfp);
  564.                         }
  565.                         else {
  566.                             if (text - lastout + agrep_outpointer >= agrep_outlen) {
  567.                                 OUTPUT_OVERFLOW;
  568.                                 return -1;
  569.                             }
  570.                             memcpy(agrep_outbuffer+agrep_outpointer, lastout, text-lastout);
  571.                             agrep_outpointer += (text-lastout);
  572.                             lastout = text;
  573.                         }
  574.                         if(OUT) {
  575.                             if (agrep_finalfp != NULL) fputc('\n', agrep_finalfp);
  576.                             else if (agrep_outpointer >= agrep_outlen) {
  577.                                 OUTPUT_OVERFLOW;
  578.                                 return -1;
  579.                             }
  580.                             else agrep_outbuffer[agrep_outpointer ++] = '\n';
  581.                             OUT=0;
  582.                         }
  583.                         while((text < textend) && (*(++text) != '\n'));
  584.                         lastout=text+1;
  585.                     }
  586.                 } /* COUNT */
  587.                 if ((LIMITOUTPUT > 0) && (LIMITOUTPUT <= num_of_matched)) return 0;    /* done */
  588.             } /* pat_len[pat_index] <= j */
  589.             if(MATCHED && !MULTI_OUTPUT) break;    /* else look for more possible matches */
  590.         }
  591.         MATCHED = 0;
  592.     } /* while */
  593.     if(INVERSE && !COUNT) {
  594.         if (agrep_finalfp != NULL) {
  595.             while(lastout <= textend) fputc(*lastout++, agrep_finalfp);
  596.         }
  597.         else {
  598.             if (textend - lastout + 1 + agrep_outpointer >= agrep_outlen) {
  599.                 OUTPUT_OVERFLOW;
  600.                 return -1;
  601.             }
  602.             memcpy(agrep_outbuffer+agrep_outpointer, lastout, text-lastout+1);
  603.             agrep_outpointer += (text-lastout+1);
  604.             lastout = textend;
  605.         }
  606.     }
  607.  
  608.     return 0;
  609. }
  610.  
  611. f_prep(pat_index, Pattern)
  612. unsigned char *Pattern ; 
  613. int pat_index;
  614. {
  615.     int i, j, m;
  616.     register unsigned hash, Mask=15;
  617.     m = p_size;
  618.     for (i = m-1; i>=(1+LONG); i--) {
  619.         hash = (Pattern[i] & Mask);
  620.         hash = (hash << 4) + (Pattern[i-1]& Mask);
  621.         if(LONG) hash = (hash << 4) + (Pattern[i-2] & Mask);
  622.         if((int)(SHIFT1[hash]) > m-1-i) SHIFT1[hash] = m-1-i;
  623.     }
  624.     if(SHORT) Mask = 255;  /* 011111111 */
  625.     hash = 0;
  626.     for(i = m-1; i>=0; i--)  {
  627.         hash = (hash << 4) + (tr[Pattern[i]]&Mask);
  628.     }
  629.     /*
  630.         if(INVERSE) hash = Pattern[1];
  631.     */
  632.     hash=hash&mm;
  633.     qt = (struct pat_list *) malloc(sizeof(struct pat_list));
  634.     qt->index = pat_index;
  635.     pt = HASH[hash];
  636.     qt->next = pt;
  637.     HASH[hash] = qt;
  638. }
  639.  
  640.  
  641.