| /* Copyright (c) 1991 Sun Wu and Udi Manber. All Rights Reserved. */ |
| #include "agrep.h" |
| |
| extern unsigned Init1, Init[], Mask[], endposition, D_endpos; |
| extern unsigned NO_ERR_MASK; |
| extern int TRUNCATE, DELIMITER, AND, I, S, DD, INVERSE, FILENAMEONLY ; |
| extern char CurrentFileName[]; |
| extern int num_of_matched; |
| |
| extern int fill_buf(int fd, unsigned char *buf, int record_size); |
| extern void output(register CHAR *buffer, int i1, int i2, int j); |
| |
| void asearch1(char old_D_pat[], int Text, register unsigned D) |
| { |
| register unsigned end, i, r1, r3, r4, r5, CMask, D_Mask, k, endpos; |
| register unsigned r_NO_ERR; |
| unsigned A[MaxError*2+1], B[MaxError*2+1]; |
| int D_length, ResidueSize, lasti, num_read, FIRSTROUND, j=0; |
| char buffer[BlockSize+Max_record+1]; |
| |
| if(I == 0) Init1 = 037777777777; |
| if(DD > D) DD = D+1; |
| if(I > D) I = D+1; |
| if(S > D) S = D+1; |
| D_length = strlen(old_D_pat); |
| buffer[Max_record-1] = '\n'; |
| |
| lasti = Max_record; |
| r_NO_ERR = NO_ERR_MASK; |
| |
| D_Mask = D_endpos; |
| for(i=1 ; i<D_length; i++) D_Mask = (D_Mask << 1) | D_Mask; |
| D_Mask = ~D_Mask; |
| endpos = D_endpos; |
| r3 = D+1; r4 = D*2; /* to make sure in register */ |
| for(k=0; k < D; k++) A[k] = B[k] = 0; |
| for(k=D; k <= r4; k++) A[k] = B[k] = Init[0]; |
| |
| while ((num_read = fill_buf(Text, buffer + Max_record, Max_record)) > 0) |
| { |
| i=Max_record; end = Max_record + num_read; |
| if(FIRSTROUND) { i = Max_record -1 ; |
| if(DELIMITER) { |
| for(k=0; k<D_length; k++) { |
| if(old_D_pat[k] != buffer[Max_record+k]) break; |
| } |
| if(k>=D_length) j--; |
| } |
| FIRSTROUND = 0; } |
| if(num_read < BlockSize) { |
| strncpy(buffer+Max_record+num_read, old_D_pat, D_length); |
| end = end + D_length; |
| buffer[end] = '\0'; |
| } |
| while (i < end) |
| { |
| CMask = Mask[buffer[i++]]; |
| r1 = Init1 & B[D]; |
| A[D] = ((B[D] >> 1) & CMask ) | r1; |
| for(k = r3; k <= r4; k++) /* r3 = D+1, r4 = 2*D */ |
| { |
| r5 = B[k]; |
| r1 = Init1 & r5; |
| A[k] = ((r5 >> 1) & CMask) | B[k-I] | (((A[k-DD] | B[k-S]) >>1) & r_NO_ERR) | r1 ; |
| } |
| if(A[D] & endpos) { |
| j++; |
| if(((AND == 1) && ((A[D*2] & endposition) == endposition)) || ((AND == 0) && (A[D*2] & endposition)) ^ INVERSE ) |
| { |
| if(FILENAMEONLY) { |
| num_of_matched++; |
| printf("%s\n", CurrentFileName); |
| return; } |
| if(lasti < Max_record + num_read) |
| output(buffer, lasti, i-D_length-1, j); |
| } |
| lasti = i - D_length; |
| TRUNCATE = OFF; |
| for(k = D; k <= r4 ; k++) A[k] = B[k] = Init[0]; |
| r1 = Init1 & B[D]; |
| A[D] = (((B[D] >> 1) & CMask ) | r1) & D_Mask; |
| for(k = r3; k <= r4; k++) /* r3 = D+1, r4 = 2*D */ |
| { |
| r5 = B[k]; |
| r1 = Init1 & r5; |
| A[k] = ((r5 >> 1) & CMask) | B[k-I] | (((A[k-DD] | B[k-S]) >>1) & r_NO_ERR) | r1 ; |
| } |
| } /* end if (A[D]&endpos) */ |
| CMask = Mask[buffer[i++]]; |
| r1 = A[D] & Init1; |
| B[D] = ((A[D] >> 1) & CMask) | r1; |
| for(k = r3; k <= r4; k++) |
| { |
| r1 = A[k] & Init1; |
| B[k] = ((A[k] >> 1) & CMask) | A[k-I] | (((B[k-DD] | A[k-S]) >>1)&r_NO_ERR) | r1 ; |
| } |
| if(B[D] & endpos) { |
| j++; |
| if(((AND == 1) && ((B[r4] & endposition) == endposition)) || ((AND == 0) && (B[r4] & endposition)) ^ INVERSE ) |
| { if(FILENAMEONLY) { |
| num_of_matched++; |
| printf("%s\n", CurrentFileName); |
| return; } |
| if(lasti < Max_record + num_read) |
| output(buffer, lasti, i-D_length-1, j); |
| } |
| lasti = i-D_length; |
| TRUNCATE = OFF; |
| for(k=D; k <= r4; k++) A[k] = B[k] = Init[0]; |
| r1 = Init1 & A[D]; |
| B[D] = (((A[D] >> 1) & CMask ) | r1) & D_Mask; |
| for(k = r3; k <= r4; k++) /* r3 = D+1, r4 = 2*D */ |
| { |
| r5 = A[k]; |
| r1 = Init1 & r5; |
| B[k] = ((r5 >> 1) & CMask) | A[k-I] | (((B[k-DD] | A[k-S]) >>1) & r_NO_ERR) | r1 ; |
| } |
| } /* end if (B[D]&endpos) */ |
| } |
| ResidueSize = Max_record + num_read - lasti; |
| if(ResidueSize > Max_record) { |
| ResidueSize = Max_record; |
| TRUNCATE = ON; |
| } |
| strncpy(buffer+Max_record-ResidueSize, buffer+lasti, ResidueSize); |
| lasti = Max_record - ResidueSize; |
| if(lasti < 0) lasti = 1; |
| if(num_read < BlockSize) lasti = Max_record; |
| } |
| return; |
| } |
| |