home *** CD-ROM | disk | FTP | other *** search
/ Skunkware 5 / Skunkware 5.iso / src / Tools / glimpse-2.1 / agrep / asearch1.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-05-16  |  13.2 KB  |  427 lines
  1. /* Copyright (c) 1994 Sun Wu, Udi Manber, Burra Gopal.  All Rights Reserved. */
  2. #include "agrep.h"
  3.  
  4. extern unsigned Init1, Init[], Mask[], endposition, D_endpos;
  5. extern unsigned NO_ERR_MASK;
  6. extern int TRUNCATE, DELIMITER, AND, I, S, DD, INVERSE, FILENAMEONLY ;
  7. extern char CurrentFileName[];
  8. extern int num_of_matched;
  9.  
  10. extern int CurrentByteOffset;
  11. extern CHAR *agrep_inbuffer;
  12. extern int agrep_inlen;
  13.  
  14. extern FILE *agrep_finalfp;
  15. extern CHAR *agrep_outbuffer;
  16. extern int agrep_outlen;
  17. extern int agrep_outpointer;
  18.  
  19. extern int NEW_FILE, POST_FILTER;
  20.  
  21. extern int LIMITOUTPUT;
  22.  
  23. asearch1(old_D_pat, Text, D)
  24. char old_D_pat[]; 
  25. int Text; 
  26. register unsigned D;
  27. {
  28.     register unsigned end, i, r1, r3, r4, r5, CMask, D_Mask, k, endpos; 
  29.     register unsigned r_NO_ERR;
  30.     unsigned A[MaxError*2+1], B[MaxError*2+1];
  31.     int D_length, ResidueSize, lasti, num_read,  FIRSTROUND=1, j=0;
  32.     CHAR *buffer;
  33.     /* CHAR *tempbuf = NULL;*/    /* used only when Text == -1 */
  34.  
  35.     if(I == 0) Init1 = (unsigned)037777777777;
  36.     if(DD > D) DD = D+1;
  37.     if(I  > D) I  = D+1;
  38.     if(S  > D) S  = D+1;
  39.     D_length = strlen(old_D_pat);
  40.  
  41.     r_NO_ERR = NO_ERR_MASK;
  42.  
  43.     D_Mask = D_endpos;
  44.     for(i=1; i<D_length; i++) D_Mask = (D_Mask << 1) | D_Mask;
  45.     D_Mask = ~D_Mask;
  46.     endpos = D_endpos;
  47.     r3 = D+1; 
  48.     r4 = D*2;  /* to make sure in register */
  49.     for(k=0; k < D;   k++) A[k] = B[k] = 0;
  50.     for(k=D; k <= r4; k++) A[k] = B[k] = Init[0];
  51.  
  52. #if    AGREP_POINTER
  53.     if (Text != -1) {
  54. #endif    /*AGREP_POINTER*/
  55.         lasti = Max_record;
  56.         alloc_buf(Text, &buffer, BlockSize+Max_record+1);
  57.         buffer[Max_record-1] = '\n';
  58.  
  59.         while ((num_read = fill_buf(Text, buffer + Max_record, BlockSize)) > 0)
  60.         {
  61.             i=Max_record; 
  62.             end = Max_record + num_read;
  63.             if(FIRSTROUND) { 
  64.                 i = Max_record -1 ;
  65.                 if(DELIMITER) {
  66.                     for(k=0; k<D_length; k++) {
  67.                         if(old_D_pat[k] != buffer[Max_record+k]) break;
  68.                     }
  69.                     if(k>=D_length) j--;
  70.                 }
  71.                 FIRSTROUND = 0; 
  72.             }
  73.             if(num_read < BlockSize) {
  74.                 strncpy(buffer+Max_record+num_read, old_D_pat, D_length);
  75.                 end = end + D_length;
  76.                 buffer[end] = '\0';
  77.             }
  78.  
  79.             /* ASEARCH1_PROCESS: the while-loop below */
  80.             while (i < end)
  81.             {
  82.                 CMask = Mask[buffer[i++]];
  83.                 CurrentByteOffset ++;
  84.                 r1 = Init1 & B[D];
  85.                 A[D] = ((B[D] >> 1) & CMask )  | r1;
  86.                 for(k = r3; k <= r4; k++)  /* r3 = D+1, r4 = 2*D */
  87.                 { 
  88.                     r5 = B[k];
  89.                     r1 = Init1 & r5;
  90.                     A[k] = ((r5 >> 1) & CMask) | B[k-I] | (((A[k-DD] | B[k-S]) >>1) & r_NO_ERR) | r1 ; 
  91.                 }
  92.                 if(A[D] & endpos) {  
  93.                     j++;
  94.                     if (DELIMITER) CurrentByteOffset -= D_length;
  95.                     else CurrentByteOffset -= 1;
  96.                     if(((AND == 1) && ((A[D*2] & endposition) == endposition)) || ((AND == 0) && (A[D*2] & endposition)) ^ INVERSE )
  97.                     { 
  98.                         if(FILENAMEONLY && (NEW_FILE || !POST_FILTER)) {
  99.                             num_of_matched++;
  100.                             if (agrep_finalfp != NULL) 
  101.                                 fprintf(agrep_finalfp, "%s\n", CurrentFileName);
  102.                             else {
  103.                                 int outindex;
  104.                                 for(outindex=0; (outindex+agrep_outpointer<agrep_outlen) && 
  105.                                         (CurrentFileName[outindex] != '\0'); outindex++) {
  106.                                     agrep_outbuffer[agrep_outpointer+outindex] = CurrentFileName[outindex];
  107.                                 }
  108.                                 if ((CurrentFileName[outindex] != '\0') || (outindex+agrep_outpointer+1>=agrep_outlen)) {
  109.                                     OUTPUT_OVERFLOW;
  110.                                     /*
  111.                                     if (Text == -1) {
  112.                                         memcpy(buffer+end-D_length, tempbuf, D_length+1);
  113.                                     }
  114.                                     */
  115.                                     free_buf(Text, buffer);
  116.                                     return -1;
  117.                                 }
  118.                                 else agrep_outbuffer[agrep_outpointer+outindex++] = '\n';
  119.                                 agrep_outpointer += outindex;
  120.                             }
  121.                             /*
  122.                             if (Text == -1) {
  123.                                 memcpy(buffer+end-D_length, tempbuf, D_length+1);
  124.                             }
  125.                             */
  126.                             free_buf(Text, buffer);
  127.                             NEW_FILE = OFF;
  128.                             return 0;       
  129.                         } 
  130.                         if((Text != -1) && !(lasti >= Max_record + num_read - 1)) {
  131.                             if (-1 == output(buffer, lasti, i-D_length-1, j)) {free_buf(Text, buffer); return -1;}
  132.                         }
  133.                         else if ((Text == -1) && !(lasti >= num_read)) {
  134.                             if (-1 == output(buffer, lasti, i-D_length-1, j)) {free_buf(Text, buffer); return -1;}
  135.                         }
  136.                         if ((LIMITOUTPUT > 0) && (LIMITOUTPUT <= num_of_matched)) {
  137.                             free_buf(Text, buffer);
  138.                             return 0;    /* done */
  139.                         }
  140.                     }
  141.                     lasti = i - D_length;
  142.                     TRUNCATE = OFF;
  143.                     for(k = D; k <= r4 ; k++) A[k] = B[k] = Init[0];
  144.                     r1 = Init1 & B[D];
  145.                     A[D] = (((B[D] >> 1) & CMask )  | r1) & D_Mask;
  146.                     for(k = r3; k <= r4; k++)  /* r3 = D+1, r4 = 2*D */
  147.                     { 
  148.                         r5 = B[k];
  149.                         r1 = Init1 & r5;
  150.                         A[k] = ((r5 >> 1) & CMask) | B[k-I] | (((A[k-DD] | B[k-S]) >>1) & r_NO_ERR) | r1 ; 
  151.                     }
  152.                     if (DELIMITER) CurrentByteOffset += 1*D_length;
  153.                     else CurrentByteOffset += 1*1;
  154.                 }  /* end if (A[D]&endpos) */
  155.                 CMask = Mask[buffer[i++]];
  156.                 CurrentByteOffset ++;
  157.                 r1 = A[D] & Init1;
  158.                 B[D] = ((A[D] >> 1) & CMask) | r1;
  159.                 for(k = r3; k <= r4; k++)
  160.                 { 
  161.                     r1 = A[k] & Init1;
  162.                     B[k] = ((A[k] >> 1) & CMask) | A[k-I] | (((B[k-DD] | A[k-S]) >>1)&r_NO_ERR) | r1 ; 
  163.                 }
  164.                 if(B[D] & endpos)  {  
  165.                     j++;
  166.                     if (DELIMITER) CurrentByteOffset -= D_length;
  167.                     else CurrentByteOffset -= 1;
  168.                     if(((AND == 1) && ((B[r4] & endposition) == endposition)) || ((AND == 0) && (B[r4] & endposition)) ^ INVERSE )
  169.                     { 
  170.                         if(FILENAMEONLY && (NEW_FILE || !POST_FILTER)) {
  171.                             num_of_matched++;
  172.                             if (agrep_finalfp != NULL) 
  173.                                 fprintf(agrep_finalfp, "%s\n", CurrentFileName);
  174.                             else {
  175.                                 int outindex;
  176.                                 for(outindex=0; (outindex+agrep_outpointer<agrep_outlen) && 
  177.                                         (CurrentFileName[outindex] != '\0'); outindex++) {
  178.                                     agrep_outbuffer[agrep_outpointer+outindex] = CurrentFileName[outindex];
  179.                                 }
  180.                                 if ((CurrentFileName[outindex] != '\0') || (outindex+agrep_outpointer+1>=agrep_outlen)) {
  181.                                     OUTPUT_OVERFLOW;
  182.                                     /*
  183.                                     if (Text == -1) {
  184.                                         memcpy(buffer+end-D_length, tempbuf, D_length+1);
  185.                                     }
  186.                                     */
  187.                                     free_buf(Text, buffer);
  188.                                     return -1;
  189.                                 }
  190.                                 else agrep_outbuffer[agrep_outpointer+outindex++] = '\n';
  191.                                 agrep_outpointer += outindex;
  192.                             }
  193.                             /*
  194.                             if (Text == -1) {
  195.                                 memcpy(buffer+end-D_length, tempbuf, D_length+1);
  196.                             }
  197.                             */
  198.                             free_buf(Text, buffer);
  199.                             NEW_FILE = OFF;
  200.                             return 0;
  201.                         }
  202.                         if((Text != -1) && !(lasti >= Max_record + num_read - 1)) {
  203.                             if (-1 == output(buffer, lasti, i-D_length-1, j)) {free_buf(Text, buffer); return -1;}
  204.                         }
  205.                         else if ((Text == -1) && !(lasti >= num_read)) {
  206.                             if (-1 == output(buffer, lasti, i-D_length-1, j)) {free_buf(Text, buffer); return -1;}
  207.                         }
  208.                         if ((LIMITOUTPUT > 0) && (LIMITOUTPUT <= num_of_matched)) {
  209.                             free_buf(Text, buffer);
  210.                             return 0;    /* done */
  211.                         }
  212.                     } 
  213.                     lasti = i-D_length; 
  214.                     TRUNCATE = OFF;
  215.                     for(k=D; k <= r4; k++) A[k] = B[k] = Init[0];
  216.                     r1 = Init1 & A[D];
  217.                     B[D] = (((A[D] >> 1) & CMask )  | r1) & D_Mask;
  218.                     for(k = r3; k <= r4; k++)  /* r3 = D+1, r4 = 2*D */
  219.                     { 
  220.                         r5 = A[k];
  221.                         r1 = Init1 & r5;
  222.                         B[k] = ((r5 >> 1) & CMask) | A[k-I] | (((B[k-DD] | A[k-S]) >>1) & r_NO_ERR) | r1 ; 
  223.                     }
  224.                     if (DELIMITER) CurrentByteOffset += 1*D_length;
  225.                     else CurrentByteOffset += 1*1;
  226.                 }  /* end if (B[D]&endpos) */
  227.             }
  228.  
  229.             ResidueSize = Max_record + num_read - lasti;
  230.             if(ResidueSize > Max_record) {
  231.                 ResidueSize = Max_record;
  232.                 TRUNCATE = ON;   
  233.             }
  234.             strncpy(buffer+Max_record-ResidueSize, buffer+lasti, ResidueSize);
  235.             lasti = Max_record - ResidueSize;
  236.             if(lasti < 0) lasti = 1;
  237.             if(num_read < BlockSize) lasti = Max_record;
  238.         }
  239.         free_buf(Text, buffer);
  240.         return 0;
  241. #if    AGREP_POINTER
  242.     }
  243.     else {
  244.         lasti = 1;
  245.         /* if (DELIMITER) tempbuf = (CHAR*)malloc(D_length + 1); */
  246.         buffer = (CHAR *)agrep_inbuffer;
  247.         num_read = agrep_inlen;
  248.         end = num_read;
  249.         /* buffer[end-1] = '\n';*/ /* at end of the text. */
  250.         /* buffer[0] = '\n';*/  /* in front of the  text. */
  251.         i = 0;
  252.  
  253.         if(DELIMITER) {
  254.             for(k=0; k<D_length; k++) {
  255.                 if(old_D_pat[k] != buffer[k]) break;
  256.             }
  257.             if(k>=D_length) j--;
  258.             /*
  259.             memcpy(tempbuf, buffer+end, D_length+1);
  260.             strncpy(buffer+end, old_D_pat, D_length);
  261.             buffer[end+D_length] = '\0';
  262.             end = end + D_length;
  263.             */
  264.         }
  265.  
  266.             /* An exact copy of the above ASEARCH1_PROCESS: the while-loop below */
  267.             while (i < end)
  268.             {
  269.                 CMask = Mask[buffer[i++]];
  270.                 CurrentByteOffset ++;
  271.                 r1 = Init1 & B[D];
  272.                 A[D] = ((B[D] >> 1) & CMask )  | r1;
  273.                 for(k = r3; k <= r4; k++)  /* r3 = D+1, r4 = 2*D */
  274.                 { 
  275.                     r5 = B[k];
  276.                     r1 = Init1 & r5;
  277.                     A[k] = ((r5 >> 1) & CMask) | B[k-I] | (((A[k-DD] | B[k-S]) >>1) & r_NO_ERR) | r1 ; 
  278.                 }
  279.                 if(A[D] & endpos) {  
  280.                     j++;
  281.                     if (DELIMITER) CurrentByteOffset -= D_length;
  282.                     else CurrentByteOffset -= 1;
  283.                     if(((AND == 1) && ((A[D*2] & endposition) == endposition)) || ((AND == 0) && (A[D*2] & endposition)) ^ INVERSE )
  284.                     { 
  285.                         if(FILENAMEONLY && (NEW_FILE || !POST_FILTER)) {
  286.                             num_of_matched++;
  287.                             if (agrep_finalfp != NULL) 
  288.                                 fprintf(agrep_finalfp, "%s\n", CurrentFileName);
  289.                             else {
  290.                                 int outindex;
  291.                                 for(outindex=0; (outindex+agrep_outpointer<agrep_outlen) && 
  292.                                         (CurrentFileName[outindex] != '\0'); outindex++) {
  293.                                     agrep_outbuffer[agrep_outpointer+outindex] = CurrentFileName[outindex];
  294.                                 }
  295.                                 if ((CurrentFileName[outindex] != '\0') || (outindex+agrep_outpointer+1>=agrep_outlen)) {
  296.                                     OUTPUT_OVERFLOW;
  297.                                     /*
  298.                                     if (Text == -1) {
  299.                                         memcpy(buffer+end-D_length, tempbuf, D_length+1);
  300.                                     }
  301.                                     */
  302.                                     free_buf(Text, buffer);
  303.                                     return -1;
  304.                                 }
  305.                                 else agrep_outbuffer[agrep_outpointer+outindex++] = '\n';
  306.                                 agrep_outpointer += outindex;
  307.                             }
  308.                             /*
  309.                             if (Text == -1) {
  310.                                 memcpy(buffer+end-D_length, tempbuf, D_length+1);
  311.                             }
  312.                             */
  313.                             free_buf(Text, buffer);
  314.                             NEW_FILE = OFF;
  315.                             return 0;       
  316.                         } 
  317.                         if((Text != -1) && !(lasti >= Max_record + num_read - 1)) {
  318.                             if (-1 == output(buffer, lasti, i-D_length-1, j)) {free_buf(Text, buffer); return -1;}
  319.                         }
  320.                         else if ((Text == -1) && !(lasti >= num_read)) {
  321.                             if (-1 == output(buffer, lasti, i-D_length-1, j)) {free_buf(Text, buffer); return -1;}
  322.                         }
  323.                         if ((LIMITOUTPUT > 0) && (LIMITOUTPUT <= num_of_matched)) {
  324.                             free_buf(Text, buffer);
  325.                             return 0;    /* done */
  326.                         }
  327.                     }
  328.                     lasti = i - D_length;
  329.                     TRUNCATE = OFF;
  330.                     for(k = D; k <= r4 ; k++) A[k] = B[k] = Init[0];
  331.                     r1 = Init1 & B[D];
  332.                     A[D] = (((B[D] >> 1) & CMask )  | r1) & D_Mask;
  333.                     for(k = r3; k <= r4; k++)  /* r3 = D+1, r4 = 2*D */
  334.                     { 
  335.                         r5 = B[k];
  336.                         r1 = Init1 & r5;
  337.                         A[k] = ((r5 >> 1) & CMask) | B[k-I] | (((A[k-DD] | B[k-S]) >>1) & r_NO_ERR) | r1 ; 
  338.                     }
  339.                     if (DELIMITER) CurrentByteOffset += 1*D_length;
  340.                     else CurrentByteOffset += 1*1;
  341.                 }  /* end if (A[D]&endpos) */
  342.                 CMask = Mask[buffer[i++]];
  343.                 CurrentByteOffset ++;
  344.                 r1 = A[D] & Init1;
  345.                 B[D] = ((A[D] >> 1) & CMask) | r1;
  346.                 for(k = r3; k <= r4; k++)
  347.                 { 
  348.                     r1 = A[k] & Init1;
  349.                     B[k] = ((A[k] >> 1) & CMask) | A[k-I] | (((B[k-DD] | A[k-S]) >>1)&r_NO_ERR) | r1 ; 
  350.                 }
  351.                 if(B[D] & endpos)  {  
  352.                     j++;
  353.                     if (DELIMITER) CurrentByteOffset -= D_length;
  354.                     else CurrentByteOffset -= 1;
  355.                     if(((AND == 1) && ((B[r4] & endposition) == endposition)) || ((AND == 0) && (B[r4] & endposition)) ^ INVERSE )
  356.                     { 
  357.                         if(FILENAMEONLY && (NEW_FILE || !POST_FILTER)) {
  358.                             num_of_matched++;
  359.                             if (agrep_finalfp != NULL) 
  360.                                 fprintf(agrep_finalfp, "%s\n", CurrentFileName);
  361.                             else {
  362.                                 int outindex;
  363.                                 for(outindex=0; (outindex+agrep_outpointer<agrep_outlen) && 
  364.                                         (CurrentFileName[outindex] != '\0'); outindex++) {
  365.                                     agrep_outbuffer[agrep_outpointer+outindex] = CurrentFileName[outindex];
  366.                                 }
  367.                                 if ((CurrentFileName[outindex] != '\0') || (outindex+agrep_outpointer+1>=agrep_outlen)) {
  368.                                     OUTPUT_OVERFLOW;
  369.                                     /*
  370.                                     if (Text == -1) {
  371.                                         memcpy(buffer+end-D_length, tempbuf, D_length+1);
  372.                                     }
  373.                                     */
  374.                                     free_buf(Text, buffer);
  375.                                     return -1;
  376.                                 }
  377.                                 else agrep_outbuffer[agrep_outpointer+outindex++] = '\n';
  378.                                 agrep_outpointer += outindex;
  379.                             }
  380.                             /*
  381.                             if (Text == -1) {
  382.                                 memcpy(buffer+end-D_length, tempbuf, D_length+1);
  383.                             }
  384.                             */
  385.                             free_buf(Text, buffer);
  386.                             NEW_FILE = OFF;
  387.                             return 0;
  388.                         }
  389.                         if((Text != -1) && !(lasti >= Max_record + num_read - 1)) {
  390.                             if (-1 == output(buffer, lasti, i-D_length-1, j)) {free_buf(Text, buffer); return -1;}
  391.                         }
  392.                         else if ((Text == -1) && !(lasti >= num_read)) {
  393.                             if (-1 == output(buffer, lasti, i-D_length-1, j)) {free_buf(Text, buffer); return -1;}
  394.                         }
  395.                         if ((LIMITOUTPUT > 0) && (LIMITOUTPUT <= num_of_matched)) {
  396.                             free_buf(Text, buffer);
  397.                             return 0;    /* done */
  398.                         }
  399.                     } 
  400.                     lasti = i-D_length; 
  401.                     TRUNCATE = OFF;
  402.                     for(k=D; k <= r4; k++) A[k] = B[k] = Init[0];
  403.                     r1 = Init1 & A[D];
  404.                     B[D] = (((A[D] >> 1) & CMask )  | r1) & D_Mask;
  405.                     for(k = r3; k <= r4; k++)  /* r3 = D+1, r4 = 2*D */
  406.                     { 
  407.                         r5 = A[k];
  408.                         r1 = Init1 & r5;
  409.                         B[k] = ((r5 >> 1) & CMask) | A[k-I] | (((B[k-DD] | A[k-S]) >>1) & r_NO_ERR) | r1 ; 
  410.                     }
  411.                     if (DELIMITER) CurrentByteOffset += 1*D_length;
  412.                     else CurrentByteOffset += 1*1;
  413.                 }  /* end if (B[D]&endpos) */
  414.             }
  415.  
  416.         /*
  417.         if (DELIMITER) {
  418.             memcpy(buffer+end, tempbuf, D_length+1);
  419.             free(tempbuf);
  420.         }
  421.         */
  422.         return 0;
  423.     }
  424. #endif    /*AGREP_POINTER*/
  425. }
  426.  
  427.