« back to all changes in this revision
Viewing changes to asearch.c
- browse files at revision 4
- compare with another revision
- download diff
- download tarball
- view history from revision 4
- Committer: Bazaar Package Importer
- Author(s): Daniel Baumann
- Date: 2006-07-05 13:29:00 UTC
- mfrom: (3.1.1 dapper)
- Revision ID: james.westby@ubuntu.com-20060705132900-j24rz8zdk4xqdmoz
Tags: 4.17-3
* New email address.
* Some packaging style changes.
* Some packaging style changes.
- files added:
- Makefile.NeXT
- debian/doc
- debian/patches
- save
- files removed:
- agrep.ps.1
- files modified:
- COPYRIGHT
added
removed
asearch.c
1
/* Copyright (c) 1991 Sun Wu and Udi Manber. All Rights Reserved. */
1
/* Copyright (c) 1994 Sun Wu, Udi Manber, Burra Gopal. All Rights Reserved. */
2
2
#include "agrep.h"
3
#include <errno.h>
3
4
4
5
extern unsigned Init1, Init[], Mask[], endposition, D_endpos, AND, NO_ERR_MASK;
5
extern int DELIMITER, FILENAMEONLY, INVERSE;
6
extern int DELIMITER, FILENAMEONLY, INVERSE, PRINTFILETIME;
6
7
extern CHAR CurrentFileName[];
7
extern int I, num_of_matched, TRUNCATE;
8
8
extern long CurrentFileTime;
9
extern int I, num_of_matched, prev_num_of_matched, TRUNCATE;
10
11
extern int CurrentByteOffset;
12
extern int errno;
13
extern CHAR *agrep_inbuffer;
14
extern int agrep_inlen;
15
extern int agrep_initialfd;
16
extern int EXITONERROR;
17
extern int agrep_inpointer;
18
19
extern FILE *agrep_finalfp;
20
extern CHAR *agrep_outbuffer;
21
extern int agrep_outlen;
22
extern int agrep_outpointer;
23
24
extern int NEW_FILE, POST_FILTER;
25
26
extern int LIMITOUTPUT, LIMITPERFILE;
27
28
int
9
29
asearch(old_D_pat, text, D)
10
CHAR old_D_pat[]; int text; register unsigned D;
30
CHAR old_D_pat[];
31
int text;
32
register unsigned D;
11
33
{
12
register unsigned i, c, r1, r2, CMask, r_NO_ERR, r_Init1;
13
register unsigned A0, B0, A1, B1, endpos;
14
unsigned A2, B2, A3, B3, A4, B4;
15
unsigned A[MaxError+1], B[MaxError+1];
16
unsigned D_Mask;
17
unsigned end;
18
int D_length, FIRSTROUND, ResidueSize, lasti, l, k, buffer_end, j=0;
19
int printout_end;
20
CHAR buffer[2*Max_record+1];
21
22
if (I == 0) Init1 = 037777777777;
23
if(D > 4) {
24
asearch0(old_D_pat, text, D);
25
return; }
26
D_length = strlen(old_D_pat);
27
buffer[Max_record-1] = '\n';
28
D_Mask = D_endpos;
29
for ( i=1; i<D_length; i++) D_Mask = (D_Mask<<1) | D_Mask;
30
D_Mask = ~D_Mask;
31
32
r_Init1 = Init1; /* put Init1 in register */
33
r_NO_ERR = NO_ERR_MASK; /* put NO_ERR_MASK in register */
34
endpos = D_endpos;
35
FIRSTROUND = ON;
36
A0 = B0 = A1 = B1 = A2 = B2 = A3 = B3 = A4 = B4 = Init[0];
37
for(k=0; k<=D; k++) A[k] = B[k] = Init[0];
38
lasti = Max_record;
39
40
while ((l = fill_buf(text, buffer + Max_record, Max_record)) > 0)
41
{ i = Max_record; end = Max_record + l ;
42
if (FIRSTROUND) {
43
i = Max_record - 1;
44
if(DELIMITER) {
45
for(k=0; k<D_length; k++) {
46
if(old_D_pat[k] != buffer[Max_record+k]) break;
47
}
48
if(k>=D_length) j--;
49
}
50
FIRSTROUND = OFF; }
51
if (l < BlockSize) {
52
strncpy(buffer+end, old_D_pat, D_length);
53
buffer[end+D_length] = '\0';
54
end = end + D_length; }
55
while (i < end )
56
{
57
c = buffer[i];
58
CMask = Mask[c];
59
r1 = r_Init1 & B0;
60
A0 = ((B0 >>1 ) & CMask) | r1;
61
r1 = r_Init1 & B1;
62
r2 = B0 | (((A0 | B0) >> 1) & r_NO_ERR);
63
A1 = ((B1 >>1 ) & CMask) | r2 | r1 ;
64
if(D == 1) goto Nextchar;
65
r1 = r_Init1 & B2;
66
r2 = B1 | (((A1 | B1) >> 1) & r_NO_ERR);
67
A2 = ((B2 >>1 ) & CMask) | r2 | r1 ;
68
if(D == 2) goto Nextchar;
69
r1 = r_Init1 & B3;
70
r2 = B2 | (((A2 | B2) >> 1) & r_NO_ERR);
71
A3 = ((B3 >>1 ) & CMask) | r2 | r1 ;
72
if(D == 3) goto Nextchar;
73
r1 = r_Init1 & B4;
74
r2 = B3 | (((A3 | B3) >> 1) & r_NO_ERR);
75
A4 = ((B4 >>1 ) & CMask) | r2 | r1 ;
76
if(D == 4) goto Nextchar;
77
Nextchar: i=i+1;
78
if(A0 & endpos) {
79
j++; r1 = A0;
80
if ( D == 1) r1 = A1;
81
if ( D == 2) r1 = A2;
82
if ( D == 3) r1 = A3;
83
if ( D == 4) r1 = A4;
84
if(((AND == 1) && ((r1 & endposition) == endposition)) || ((AND == 0) && (r1 & endposition)) ^ INVERSE )
85
{
86
if(FILENAMEONLY) {
87
num_of_matched++;
88
printf("%s\n", CurrentFileName);
89
return; }
90
printout_end = i - D_length - 1;
91
if(!(lasti >= Max_record + l - 1))
92
output(buffer, lasti, printout_end, j);
93
}
94
lasti = i - D_length; /* point to starting position of D_pat */
95
TRUNCATE = OFF;
96
for(k=0; k<= D; k++) {
97
B[k] = Init[0];
98
}
99
r1 = B[0] & Init1;
100
A[0] = (((B[0]>>1) & CMask) | r1) & D_Mask;
101
for(k=1; k<= D; k++) {
102
r1 = Init1 & B[k];
103
r2 = B[k-1] | (((A[k-1] | B[k-1])>>1)&r_NO_ERR);
104
A[k] = (((B[k]>>1)&CMask) | r1 | r2) ;
105
}
106
A0 = A[0]; B0 = B[0]; A1 = A[1]; B1 = B[1]; A2 = A[2]; B2 = B[2];
107
A3 = A[3]; B3 = B[3]; A4 = A[4]; B4 = B[4];
108
}
109
c = buffer[i];
110
CMask = Mask[c];
111
r1 = r_Init1 & A0;
112
B0 = ((A0 >> 1 ) & CMask) | r1;
113
#ifdef DEBUG
114
printf("Mask = %o, B0 = %o\n", CMask, B0);
115
#endif
116
r1 = r_Init1 & A1;
117
r2 = A0 | (((A0 | B0) >> 1) & r_NO_ERR);
118
B1 = ((A1 >>1 ) & CMask) | r2 | r1 ;
119
if(D == 1) goto Nextchar1;
120
r1 = r_Init1 & A2;
121
r2 = A1 | (((A1 | B1) >> 1) & r_NO_ERR);
122
B2 = ((A2 >>1 ) & CMask) | r2 | r1 ;
123
if(D == 2) goto Nextchar1;
124
r1 = r_Init1 & A3;
125
r2 = A2 | (((A2 | B2) >> 1) & r_NO_ERR);
126
B3 = ((A3 >>1 ) & CMask) | r2 | r1 ;
127
if(D == 3) goto Nextchar1;
128
r1 = r_Init1 & A4;
129
r2 = A3 | (((A3 | B3) >> 1) & r_NO_ERR);
130
B4 = ((A4 >>1 ) & CMask) | r2 | r1 ;
131
if(D == 4) goto Nextchar1;
132
Nextchar1: i=i+1;
133
if(B0 & endpos) {
134
j++; r1 = B0;
135
if ( D == 1) r1 = B1;
136
if ( D == 2) r1 = B2;
137
if ( D == 3) r1 = B3;
138
if ( D == 4) r1 = B4;
139
if(((AND == 1) && ((r1 & endposition) == endposition)) || ((AND == 0) && (r1 & endposition)) ^ INVERSE )
140
{
141
if(FILENAMEONLY) {
142
num_of_matched++;
143
printf("%s\n", CurrentFileName);
144
return; }
145
printout_end = i - D_length -1 ;
146
if(!(lasti >= Max_record + l - 1))
147
output(buffer, lasti, printout_end, j);
148
}
149
lasti = i - D_length ;
150
TRUNCATE = OFF;
151
for(k=0; k<= D; k++) {
152
A[k] = Init[0];
153
}
154
r1 = A[0] & Init1;
155
B[0] = (((A[0]>>1)&CMask) | r1) & D_Mask;
156
for(k=1; k<= D; k++) {
157
r1 = Init1 & A[k];
158
r2 = A[k-1] | (((A[k-1] | B[k-1])>>1)&r_NO_ERR);
159
B[k] = (((A[k]>>1)&CMask) | r1 | r2) ;
160
}
161
A0 = A[0]; B0 = B[0]; A1 = A[1]; B1 = B[1]; A2 = A[2]; B2 = B[2];
162
A3 = A[3]; B3 = B[3]; A4 = A[4]; B4 = B[4];
163
}
164
}
165
if(l < BlockSize) {
166
lasti = Max_record ;
167
}
168
else {
169
ResidueSize = Max_record + l - lasti;
170
if(ResidueSize > Max_record) {
171
ResidueSize = Max_record;
172
TRUNCATE = ON; }
173
strncpy(buffer+Max_record-ResidueSize, buffer+lasti, ResidueSize);
174
lasti = Max_record - ResidueSize;
175
if(lasti == 0) lasti = 1;
176
}
177
}
178
return;
34
register unsigned i, c, r1, r2, CMask, r_NO_ERR, r_Init1;
35
register unsigned A0, B0, A1, B1, endpos;
36
unsigned A2, B2, A3, B3, A4, B4;
37
unsigned A[MaxError+1], B[MaxError+1];
38
unsigned D_Mask;
39
int end;
40
int D_length, FIRSTROUND, ResidueSize, lasti, l, k, j=0;
41
int printout_end;
42
CHAR *buffer;
43
/* CHAR *tempbuf = NULL; */ /* used only when text == -1 */
44
45
if (I == 0) Init1 = (unsigned)037777777777;
46
if(D > 4) {
47
return asearch0(old_D_pat, text, D);
48
}
49
50
D_length = strlen(old_D_pat);
51
D_Mask = D_endpos;
52
for ( i=1; i<D_length; i++) D_Mask = (D_Mask<<1) | D_Mask;
53
D_Mask = ~D_Mask;
54
55
r_Init1 = Init1; /* put Init1 in register */
56
r_NO_ERR = NO_ERR_MASK; /* put NO_ERR_MASK in register */
57
endpos = D_endpos;
58
FIRSTROUND = ON;
59
A0 = B0 = A1 = B1 = A2 = B2 = A3 = B3 = A4 = B4 = Init[0];
60
for(k=0; k<=D; k++) A[k] = B[k] = Init[0];
61
62
#if AGREP_POINTER
63
if (text != -1) {
64
#endif /*AGREP_POINTER*/
65
lasti = Max_record;
66
alloc_buf(text, &buffer, Max_record+BlockSize+1);
67
buffer[Max_record-1] = '\n';
68
69
while ((l = fill_buf(text, buffer + Max_record, BlockSize)) > 0)
70
{
71
i = Max_record;
72
end = Max_record + l ;
73
if (FIRSTROUND) {
74
i = Max_record - 1;
75
if(DELIMITER) {
76
for(k=0; k<D_length; k++) {
77
if(old_D_pat[k] != buffer[Max_record+k]) break;
78
}
79
if(k>=D_length) j--;
80
}
81
FIRSTROUND = OFF;
82
}
83
if (l < BlockSize) { /* copy pattern and '\0' at end of buffer */
84
strncpy(buffer+end, old_D_pat, D_length);
85
buffer[end+D_length] = '\0';
86
end = end + D_length;
87
}
88
89
/* ASEARCH_PROCESS: the while-loop below */
90
while (i < end )
91
{
92
c = buffer[i];
93
CMask = Mask[c];
94
r1 = r_Init1 & B0;
95
A0 = ((B0 >>1 ) & CMask) | r1;
96
r1 = r_Init1 & B1;
97
r2 = B0 | (((A0 | B0) >> 1) & r_NO_ERR);
98
A1 = ((B1 >>1 ) & CMask) | r2 | r1 ;
99
if(D == 1) goto Nextcharfile;
100
r1 = r_Init1 & B2;
101
r2 = B1 | (((A1 | B1) >> 1) & r_NO_ERR);
102
A2 = ((B2 >>1 ) & CMask) | r2 | r1 ;
103
if(D == 2) goto Nextcharfile;
104
r1 = r_Init1 & B3;
105
r2 = B2 | (((A2 | B2) >> 1) & r_NO_ERR);
106
A3 = ((B3 >>1 ) & CMask) | r2 | r1 ;
107
if(D == 3) goto Nextcharfile;
108
r1 = r_Init1 & B4;
109
r2 = B3 | (((A3 | B3) >> 1) & r_NO_ERR);
110
A4 = ((B4 >>1 ) & CMask) | r2 | r1 ;
111
if(D == 4) goto Nextcharfile;
112
Nextcharfile:
113
i=i+1;
114
CurrentByteOffset ++;
115
if(A0 & endpos) {
116
j++;
117
if (DELIMITER) CurrentByteOffset -= D_length;
118
else CurrentByteOffset -= 1;
119
r1 = A0;
120
if ( D == 1) r1 = A1;
121
if ( D == 2) r1 = A2;
122
if ( D == 3) r1 = A3;
123
if ( D == 4) r1 = A4;
124
if(((AND == 1) && ((r1 & endposition) == endposition)) || ((AND == 0) && (r1 & endposition)) ^ INVERSE )
125
{
126
if(FILENAMEONLY && (NEW_FILE || !POST_FILTER)) {
127
num_of_matched++;
128
129
if (agrep_finalfp != NULL)
130
fprintf(agrep_finalfp, "%s", CurrentFileName);
131
else {
132
int outindex;
133
for(outindex=0; (outindex+agrep_outpointer<agrep_outlen) &&
134
(CurrentFileName[outindex] != '\0'); outindex++) {
135
agrep_outbuffer[agrep_outpointer+outindex] = CurrentFileName[outindex];
136
}
137
if ((CurrentFileName[outindex] != '\0') || (outindex+agrep_outpointer>=agrep_outlen)) {
138
OUTPUT_OVERFLOW;
139
free_buf(text, buffer);
140
return -1;
141
}
142
agrep_outpointer += outindex;
143
}
144
if (PRINTFILETIME) {
145
char *s = aprint_file_time(CurrentFileTime);
146
if (agrep_finalfp != NULL)
147
fprintf(agrep_finalfp, "%s", s);
148
else {
149
int outindex;
150
for(outindex=0; (outindex+agrep_outpointer<agrep_outlen) &&
151
(s[outindex] != '\0'); outindex++) {
152
agrep_outbuffer[agrep_outpointer+outindex] = s[outindex];
153
}
154
if ((s[outindex] != '\0') || (outindex+agrep_outpointer>=agrep_outlen)) {
155
OUTPUT_OVERFLOW;
156
free_buf(text, buffer);
157
return -1;
158
}
159
agrep_outpointer += outindex;
160
}
161
}
162
if (agrep_finalfp != NULL)
163
fprintf(agrep_finalfp, "\n");
164
else {
165
if (agrep_outpointer+1>=agrep_outlen) {
166
OUTPUT_OVERFLOW;
167
free_buf(text, buffer);
168
return -1;
169
}
170
else agrep_outbuffer[agrep_outpointer++] = '\n';
171
}
172
173
/*
174
if (text == -1) {
175
memcpy(buffer+end-D_length, tempbuf, D_length+1);
176
}
177
*/
178
free_buf(text, buffer);
179
NEW_FILE = OFF;
180
return 0;
181
}
182
printout_end = i - D_length - 1 ;
183
if ((text != -1) && !(lasti >= Max_record + l - 1)) {
184
if (-1 == output(buffer, lasti, printout_end, j)) {free_buf(text, buffer); return -1;}
185
}
186
else if ((text == -1) && !(lasti >= l)) {
187
if (-1 == output(buffer, lasti, printout_end, j)) {free_buf(text, buffer); return -1;}
188
}
189
if (((LIMITOUTPUT > 0) && (LIMITOUTPUT <= num_of_matched)) ||
190
((LIMITPERFILE > 0) && (LIMITPERFILE <= num_of_matched - prev_num_of_matched))) {
191
free_buf(text, buffer);
192
return 0; /* done */
193
}
194
}
195
lasti = i - D_length; /* point to starting position of D_pat */
196
TRUNCATE = OFF;
197
for(k=0; k<= D; k++) {
198
B[k] = Init[0];
199
}
200
r1 = B[0] & Init1;
201
A[0] = (((B[0]>>1) & CMask) | r1) & D_Mask;
202
for(k=1; k<= D; k++) {
203
r1 = Init1 & B[k];
204
r2 = B[k-1] | (((A[k-1] | B[k-1])>>1)&r_NO_ERR);
205
A[k] = (((B[k]>>1)&CMask) | r1 | r2) ;
206
}
207
A0 = A[0];
208
B0 = B[0];
209
A1 = A[1];
210
B1 = B[1];
211
A2 = A[2];
212
B2 = B[2];
213
A3 = A[3];
214
B3 = B[3];
215
A4 = A[4];
216
B4 = B[4];
217
if (DELIMITER) CurrentByteOffset += 1*D_length;
218
else CurrentByteOffset += 1*1;
219
}
220
c = buffer[i];
221
CMask = Mask[c];
222
r1 = r_Init1 & A0;
223
B0 = ((A0 >> 1 ) & CMask) | r1;
224
/* printf("Mask = %o, B0 = %on", CMask, B0); */
225
r1 = r_Init1 & A1;
226
r2 = A0 | (((A0 | B0) >> 1) & r_NO_ERR);
227
B1 = ((A1 >>1 ) & CMask) | r2 | r1 ;
228
if(D == 1) goto Nextchar1file;
229
r1 = r_Init1 & A2;
230
r2 = A1 | (((A1 | B1) >> 1) & r_NO_ERR);
231
B2 = ((A2 >>1 ) & CMask) | r2 | r1 ;
232
if(D == 2) goto Nextchar1file;
233
r1 = r_Init1 & A3;
234
r2 = A2 | (((A2 | B2) >> 1) & r_NO_ERR);
235
B3 = ((A3 >>1 ) & CMask) | r2 | r1 ;
236
if(D == 3) goto Nextchar1file;
237
r1 = r_Init1 & A4;
238
r2 = A3 | (((A3 | B3) >> 1) & r_NO_ERR);
239
B4 = ((A4 >>1 ) & CMask) | r2 | r1 ;
240
if(D == 4) goto Nextchar1file;
241
Nextchar1file:
242
i=i+1;
243
CurrentByteOffset ++;
244
if(B0 & endpos) {
245
j++;
246
if (DELIMITER) CurrentByteOffset -= D_length;
247
else CurrentByteOffset -= 1;
248
r1 = B0;
249
if ( D == 1) r1 = B1;
250
if ( D == 2) r1 = B2;
251
if ( D == 3) r1 = B3;
252
if ( D == 4) r1 = B4;
253
if(((AND == 1) && ((r1 & endposition) == endposition)) || ((AND == 0) && (r1 & endposition)) ^ INVERSE )
254
{
255
if(FILENAMEONLY && (NEW_FILE || !POST_FILTER)) {
256
num_of_matched++;
257
free_buf(text, buffer);
258
259
if (agrep_finalfp != NULL)
260
fprintf(agrep_finalfp, "%s", CurrentFileName);
261
else {
262
int outindex;
263
for(outindex=0; (outindex+agrep_outpointer<agrep_outlen) &&
264
(CurrentFileName[outindex] != '\0'); outindex++) {
265
agrep_outbuffer[agrep_outpointer+outindex] = CurrentFileName[outindex];
266
}
267
if ((CurrentFileName[outindex] != '\0') || (outindex+agrep_outpointer>=agrep_outlen)) {
268
OUTPUT_OVERFLOW;
269
free_buf(text, buffer);
270
return -1;
271
}
272
agrep_outpointer += outindex;
273
}
274
if (PRINTFILETIME) {
275
char *s = aprint_file_time(CurrentFileTime);
276
if (agrep_finalfp != NULL)
277
fprintf(agrep_finalfp, "%s", s);
278
else {
279
int outindex;
280
for(outindex=0; (outindex+agrep_outpointer<agrep_outlen) &&
281
(s[outindex] != '\0'); outindex++) {
282
agrep_outbuffer[agrep_outpointer+outindex] = s[outindex];
283
}
284
if ((s[outindex] != '\0') || (outindex+agrep_outpointer>=agrep_outlen)) {
285
OUTPUT_OVERFLOW;
286
free_buf(text, buffer);
287
return -1;
288
}
289
agrep_outpointer += outindex;
290
}
291
}
292
if (agrep_finalfp != NULL)
293
fprintf(agrep_finalfp, "\n");
294
else {
295
if (agrep_outpointer+1>=agrep_outlen) {
296
OUTPUT_OVERFLOW;
297
free_buf(text, buffer);
298
return -1;
299
}
300
else agrep_outbuffer[agrep_outpointer++] = '\n';
301
}
302
303
/*
304
if (text == -1) {
305
memcpy(buffer+end-D_length, tempbuf, D_length+1);
306
}
307
*/
308
free_buf(text, buffer);
309
NEW_FILE = OFF;
310
return 0;
311
}
312
printout_end = i - D_length - 1 ;
313
if((text != -1) && !(lasti >= Max_record + l - 1)) {
314
if (-1 == output(buffer, lasti, printout_end, j)) {free_buf(text, buffer); return -1;}
315
}
316
else if ((text == -1) && !(lasti >= l)) {
317
if (-1 == output(buffer, lasti, printout_end, j)) {free_buf(text, buffer); return -1;}
318
}
319
if (((LIMITOUTPUT > 0) && (LIMITOUTPUT <= num_of_matched)) ||
320
((LIMITPERFILE > 0) && (LIMITPERFILE <= num_of_matched - prev_num_of_matched))) {
321
free_buf(text, buffer);
322
return 0; /* done */
323
}
324
}
325
lasti = i - D_length ;
326
TRUNCATE = OFF;
327
for(k=0; k<= D; k++) {
328
A[k] = Init[0];
329
}
330
r1 = A[0] & Init1;
331
B[0] = (((A[0]>>1)&CMask) | r1) & D_Mask;
332
for(k=1; k<= D; k++) {
333
r1 = Init1 & A[k];
334
r2 = A[k-1] | (((A[k-1] | B[k-1])>>1)&r_NO_ERR);
335
B[k] = (((A[k]>>1)&CMask) | r1 | r2) ;
336
}
337
A0 = A[0];
338
B0 = B[0];
339
A1 = A[1];
340
B1 = B[1];
341
A2 = A[2];
342
B2 = B[2];
343
A3 = A[3];
344
B3 = B[3];
345
A4 = A[4];
346
B4 = B[4];
347
if (DELIMITER) CurrentByteOffset += 1*D_length;
348
else CurrentByteOffset += 1*1;
349
}
350
}
351
352
if(l < BlockSize) {
353
lasti = Max_record ;
354
}
355
else {
356
ResidueSize = Max_record + l - lasti;
357
if(ResidueSize > Max_record) {
358
ResidueSize = Max_record;
359
TRUNCATE = ON;
360
}
361
strncpy(buffer+Max_record-ResidueSize, buffer+lasti, ResidueSize);
362
lasti = Max_record - ResidueSize;
363
if(lasti == 0) lasti = 1;
364
}
365
}
366
free_buf(text, buffer);
367
return 0;
368
#if AGREP_POINTER
369
}
370
else {
371
lasti = 1;
372
/* if (DELIMITER) tempbuf = (CHAR*)malloc(D_length + 1); */
373
buffer = (CHAR *)agrep_inbuffer;
374
l = agrep_inlen;
375
end = l;
376
/* buffer[end-1] = '\n'; */ /* at end of the text. */
377
/* buffer[0] = '\n'; */ /* in front of the text. */
378
i = 0;
379
if(DELIMITER) {
380
for(k=0; k<D_length; k++) {
381
if(old_D_pat[k] != buffer[k]) break;
382
}
383
if(k>=D_length) j--;
384
/*
385
memcpy(tempbuf, buffer+end, D_length+1);
386
strncpy(buffer+end, old_D_pat, D_length);
387
buffer[end+D_length] = '\0';
388
end = end + D_length;
389
*/
390
}
391
392
/* An exact copy of the above ASEARCH_PROCESS: the while-loop below */
393
while (i < end )
394
{
395
c = buffer[i];
396
CMask = Mask[c];
397
r1 = r_Init1 & B0;
398
A0 = ((B0 >>1 ) & CMask) | r1;
399
r1 = r_Init1 & B1;
400
r2 = B0 | (((A0 | B0) >> 1) & r_NO_ERR);
401
A1 = ((B1 >>1 ) & CMask) | r2 | r1 ;
402
if(D == 1) goto Nextcharmem;
403
r1 = r_Init1 & B2;
404
r2 = B1 | (((A1 | B1) >> 1) & r_NO_ERR);
405
A2 = ((B2 >>1 ) & CMask) | r2 | r1 ;
406
if(D == 2) goto Nextcharmem;
407
r1 = r_Init1 & B3;
408
r2 = B2 | (((A2 | B2) >> 1) & r_NO_ERR);
409
A3 = ((B3 >>1 ) & CMask) | r2 | r1 ;
410
if(D == 3) goto Nextcharmem;
411
r1 = r_Init1 & B4;
412
r2 = B3 | (((A3 | B3) >> 1) & r_NO_ERR);
413
A4 = ((B4 >>1 ) & CMask) | r2 | r1 ;
414
if(D == 4) goto Nextcharmem;
415
Nextcharmem:
416
i=i+1;
417
CurrentByteOffset ++;
418
if(A0 & endpos) {
419
j++;
420
if (DELIMITER) CurrentByteOffset -= D_length;
421
else CurrentByteOffset -= 1;
422
r1 = A0;
423
if ( D == 1) r1 = A1;
424
if ( D == 2) r1 = A2;
425
if ( D == 3) r1 = A3;
426
if ( D == 4) r1 = A4;
427
if(((AND == 1) && ((r1 & endposition) == endposition)) || ((AND == 0) && (r1 & endposition)) ^ INVERSE )
428
{
429
if(FILENAMEONLY && (NEW_FILE || !POST_FILTER)) {
430
num_of_matched++;
431
432
if (agrep_finalfp != NULL)
433
fprintf(agrep_finalfp, "%s", CurrentFileName);
434
else {
435
int outindex;
436
for(outindex=0; (outindex+agrep_outpointer<agrep_outlen) &&
437
(CurrentFileName[outindex] != '\0'); outindex++) {
438
agrep_outbuffer[agrep_outpointer+outindex] = CurrentFileName[outindex];
439
}
440
if ((CurrentFileName[outindex] != '\0') || (outindex+agrep_outpointer>=agrep_outlen)) {
441
OUTPUT_OVERFLOW;
442
free_buf(text, buffer);
443
return -1;
444
}
445
agrep_outpointer += outindex;
446
}
447
if (PRINTFILETIME) {
448
char *s = aprint_file_time(CurrentFileTime);
449
if (agrep_finalfp != NULL)
450
fprintf(agrep_finalfp, "%s", s);
451
else {
452
int outindex;
453
for(outindex=0; (outindex+agrep_outpointer<agrep_outlen) &&
454
(s[outindex] != '\0'); outindex++) {
455
agrep_outbuffer[agrep_outpointer+outindex] = s[outindex];
456
}
457
if ((s[outindex] != '\0') || (outindex+agrep_outpointer>=agrep_outlen)) {
458
OUTPUT_OVERFLOW;
459
free_buf(text, buffer);
460
return -1;
461
}
462
agrep_outpointer += outindex;
463
}
464
}
465
if (agrep_finalfp != NULL)
466
fprintf(agrep_finalfp, "\n");
467
else {
468
if (agrep_outpointer+1>=agrep_outlen) {
469
OUTPUT_OVERFLOW;
470
free_buf(text, buffer);
471
return -1;
472
}
473
else agrep_outbuffer[agrep_outpointer++] = '\n';
474
}
475
476
/*
477
if (text == -1) {
478
memcpy(buffer+end-D_length, tempbuf, D_length+1);
479
}
480
*/
481
free_buf(text, buffer);
482
NEW_FILE = OFF;
483
return 0;
484
}
485
printout_end = i - D_length - 1 ;
486
if ((text != -1) && !(lasti >= Max_record + l - 1)) {
487
if (-1 == output(buffer, lasti, printout_end, j)) {free_buf(text, buffer); return -1;}
488
}
489
else if ((text == -1) && !(lasti >= l)) {
490
if (-1 == output(buffer, lasti, printout_end, j)) {free_buf(text, buffer); return -1;}
491
}
492
if (((LIMITOUTPUT > 0) && (LIMITOUTPUT <= num_of_matched)) ||
493
((LIMITPERFILE > 0) && (LIMITPERFILE <= num_of_matched - prev_num_of_matched))) {
494
free_buf(text, buffer);
495
return 0; /* done */
496
}
497
}
498
lasti = i - D_length; /* point to starting position of D_pat */
499
TRUNCATE = OFF;
500
for(k=0; k<= D; k++) {
501
B[k] = Init[0];
502
}
503
r1 = B[0] & Init1;
504
A[0] = (((B[0]>>1) & CMask) | r1) & D_Mask;
505
for(k=1; k<= D; k++) {
506
r1 = Init1 & B[k];
507
r2 = B[k-1] | (((A[k-1] | B[k-1])>>1)&r_NO_ERR);
508
A[k] = (((B[k]>>1)&CMask) | r1 | r2) ;
509
}
510
A0 = A[0];
511
B0 = B[0];
512
A1 = A[1];
513
B1 = B[1];
514
A2 = A[2];
515
B2 = B[2];
516
A3 = A[3];
517
B3 = B[3];
518
A4 = A[4];
519
B4 = B[4];
520
if (DELIMITER) CurrentByteOffset += 1*D_length;
521
else CurrentByteOffset += 1*1;
522
}
523
c = buffer[i];
524
CMask = Mask[c];
525
r1 = r_Init1 & A0;
526
B0 = ((A0 >> 1 ) & CMask) | r1;
527
/* printf("Mask = %o, B0 = %on", CMask, B0); */
528
r1 = r_Init1 & A1;
529
r2 = A0 | (((A0 | B0) >> 1) & r_NO_ERR);
530
B1 = ((A1 >>1 ) & CMask) | r2 | r1 ;
531
if(D == 1) goto Nextchar1mem;
532
r1 = r_Init1 & A2;
533
r2 = A1 | (((A1 | B1) >> 1) & r_NO_ERR);
534
B2 = ((A2 >>1 ) & CMask) | r2 | r1 ;
535
if(D == 2) goto Nextchar1mem;
536
r1 = r_Init1 & A3;
537
r2 = A2 | (((A2 | B2) >> 1) & r_NO_ERR);
538
B3 = ((A3 >>1 ) & CMask) | r2 | r1 ;
539
if(D == 3) goto Nextchar1mem;
540
r1 = r_Init1 & A4;
541
r2 = A3 | (((A3 | B3) >> 1) & r_NO_ERR);
542
B4 = ((A4 >>1 ) & CMask) | r2 | r1 ;
543
if(D == 4) goto Nextchar1mem;
544
Nextchar1mem:
545
i=i+1;
546
CurrentByteOffset ++;
547
if(B0 & endpos) {
548
j++;
549
if (DELIMITER) CurrentByteOffset -= D_length;
550
else CurrentByteOffset -= 1;
551
r1 = B0;
552
if ( D == 1) r1 = B1;
553
if ( D == 2) r1 = B2;
554
if ( D == 3) r1 = B3;
555
if ( D == 4) r1 = B4;
556
if(((AND == 1) && ((r1 & endposition) == endposition)) || ((AND == 0) && (r1 & endposition)) ^ INVERSE )
557
{
558
if(FILENAMEONLY && (NEW_FILE || !POST_FILTER)) {
559
num_of_matched++;
560
free_buf(text, buffer);
561
562
if (agrep_finalfp != NULL)
563
fprintf(agrep_finalfp, "%s", CurrentFileName);
564
else {
565
int outindex;
566
for(outindex=0; (outindex+agrep_outpointer<agrep_outlen) &&
567
(CurrentFileName[outindex] != '\0'); outindex++) {
568
agrep_outbuffer[agrep_outpointer+outindex] = CurrentFileName[outindex];
569
}
570
if ((CurrentFileName[outindex] != '\0') || (outindex+agrep_outpointer>=agrep_outlen)) {
571
OUTPUT_OVERFLOW;
572
free_buf(text, buffer);
573
return -1;
574
}
575
agrep_outpointer += outindex;
576
}
577
if (PRINTFILETIME) {
578
char *s = aprint_file_time(CurrentFileTime);
579
if (agrep_finalfp != NULL)
580
fprintf(agrep_finalfp, "%s", s);
581
else {
582
int outindex;
583
for(outindex=0; (outindex+agrep_outpointer<agrep_outlen) &&
584
(s[outindex] != '\0'); outindex++) {
585
agrep_outbuffer[agrep_outpointer+outindex] = s[outindex];
586
}
587
if ((s[outindex] != '\0') || (outindex+agrep_outpointer>=agrep_outlen)) {
588
OUTPUT_OVERFLOW;
589
free_buf(text, buffer);
590
return -1;
591
}
592
agrep_outpointer += outindex;
593
}
594
}
595
if (agrep_finalfp != NULL)
596
fprintf(agrep_finalfp, "\n");
597
else {
598
if (agrep_outpointer+1>=agrep_outlen) {
599
OUTPUT_OVERFLOW;
600
free_buf(text, buffer);
601
return -1;
602
}
603
else agrep_outbuffer[agrep_outpointer++] = '\n';
604
}
605
606
/*
607
if (text == -1) {
608
memcpy(buffer+end-D_length, tempbuf, D_length+1);
609
}
610
*/
611
free_buf(text, buffer);
612
NEW_FILE = OFF;
613
return 0;
614
}
615
printout_end = i - D_length - 1 ;
616
if((text != -1) && !(lasti >= Max_record + l - 1)) {
617
if (-1 == output(buffer, lasti, printout_end, j)) {free_buf(text, buffer); return -1;}
618
}
619
else if ((text == -1) && !(lasti >= l)) {
620
if (-1 == output(buffer, lasti, printout_end, j)) {free_buf(text, buffer); return -1;}
621
}
622
if (((LIMITOUTPUT > 0) && (LIMITOUTPUT <= num_of_matched)) ||
623
((LIMITPERFILE > 0) && (LIMITPERFILE <= num_of_matched - prev_num_of_matched))) {
624
free_buf(text, buffer);
625
return 0; /* done */
626
}
627
}
628
lasti = i - D_length ;
629
TRUNCATE = OFF;
630
for(k=0; k<= D; k++) {
631
A[k] = Init[0];
632
}
633
r1 = A[0] & Init1;
634
B[0] = (((A[0]>>1)&CMask) | r1) & D_Mask;
635
for(k=1; k<= D; k++) {
636
r1 = Init1 & A[k];
637
r2 = A[k-1] | (((A[k-1] | B[k-1])>>1)&r_NO_ERR);
638
B[k] = (((A[k]>>1)&CMask) | r1 | r2) ;
639
}
640
A0 = A[0];
641
B0 = B[0];
642
A1 = A[1];
643
B1 = B[1];
644
A2 = A[2];
645
B2 = B[2];
646
A3 = A[3];
647
B3 = B[3];
648
A4 = A[4];
649
B4 = B[4];
650
if (DELIMITER) CurrentByteOffset += 1*D_length;
651
else CurrentByteOffset += 1*1;
652
}
653
}
654
655
/*
656
if (DELIMITER) {
657
memcpy(buffer+end, tempbuf, D_length+1);
658
free(tempbuf);
659
}
660
*/
661
return 0;
662
}
663
#endif /*AGREP_POINTER*/
179
664
}
180
665
666
int
181
667
asearch0(old_D_pat, text, D)
182
CHAR old_D_pat[]; int text; register unsigned D;
183
{
184
register unsigned i, c, r1, r2, r3, CMask, r_NO_ERR, r_Init1, end, endpos;
185
unsigned A[MaxError+2], B[MaxError+2];
186
unsigned D_Mask;
187
int D_length, FIRSTROUND, ResidueSize, lasti, l, k, buffer_end, j=0;
188
int printout_end;
189
CHAR buffer[BlockSize+Max_record+1];
190
191
D_length = strlen(old_D_pat);
192
buffer[Max_record-1] = '\n';
193
D_Mask = D_endpos;
194
for ( i=1; i<D_length; i++) D_Mask = (D_Mask<<1) | D_Mask;
195
D_Mask = ~D_Mask;
196
197
r_Init1 = Init1; /* put Init1 in register */
198
r_NO_ERR = NO_ERR_MASK; /* put NO_ERR_MASK in register */
199
endpos = D_endpos;
200
FIRSTROUND = ON;
201
for(k=0; k<=D; k++) A[k] = B[k] = Init[0];
202
lasti = Max_record;
203
204
while ((l = fill_buf(text, buffer + Max_record, Max_record)) > 0)
205
{ i = Max_record; end = Max_record + l ;
206
if (FIRSTROUND) {
207
i = Max_record - 1;
208
FIRSTROUND = OFF; }
209
if (l < BlockSize) {
210
strncpy(buffer+end, old_D_pat, D_length);
211
buffer[end+D_length] = '\0';
212
end = end + D_length; }
213
while (i < end )
214
{
215
c = buffer[i++];
216
CMask = Mask[c];
217
r1 = B[0] & r_Init1;
218
A[0] = (((B[0] >> 1)) & CMask | r1 ) ;
219
for(k=1; k<=D; k++) {
220
r1 = r_Init1 & B[k];
221
r2 = B[k-1] | (((A[k-1]|B[k-1])>>1) & r_NO_ERR);
222
A[k] = ((B[k] >> 1) & CMask) | r2 | r1;
223
}
224
if(A[0] & endpos) {
225
j++;
226
r1 = A[D];
227
if(((AND == 1) && ((r1 & endposition) == endposition)) || ((AND == 0) && (r1 & endposition)) ^ INVERSE )
228
{
229
if(FILENAMEONLY) {
230
num_of_matched++;
231
printf("%s\n", CurrentFileName);
232
return; }
233
printout_end = i - D_length - 1;
234
if(!(lasti >= Max_record + l - 1))
235
output(buffer, lasti, printout_end, j);
236
}
237
lasti = i - D_length; /* point to starting position of D_pat */
238
for(k=0; k<= D; k++) {
239
B[k] = Init[0];
240
}
241
r1 = B[0] & r_Init1;
242
A[0] = (((B[0]>>1) & CMask) | r1) & D_Mask;
243
for(k=1; k<= D; k++) {
244
r1 = Init1 & B[k];
245
r2 = B[k-1] | (((A[k-1] | B[k-1])>>1)&r_NO_ERR);
246
A[k] = (((B[k]>>1)&CMask) | r1 | r2) ;
247
}
248
}
249
c = buffer[i++];
250
CMask = Mask[c];
251
r1 = r_Init1 & A[0];
252
B[0] = ((A[0] >> 1 ) & CMask) | r1;
253
for(k=1; k<=D; k++) {
254
r1 = r_Init1 & A[k];
255
r2 = A[k-1] | (((A[k-1]|B[k-1])>>1) & r_NO_ERR);
256
B[k] = ((A[k] >> 1) & CMask) | r2 | r1;
257
}
258
if(B[0] & endpos) {
259
j++;
260
r1 = B[D];
261
if(((AND == 1) && ((r1 & endposition) == endposition)) || ((AND == 0) && (r1 & endposition)) ^ INVERSE )
262
{
263
if(FILENAMEONLY) {
264
num_of_matched++;
265
printf("%s\n", CurrentFileName);
266
return; }
267
printout_end = i - D_length -1 ;
268
if(!(lasti >= Max_record + l - 1))
269
output(buffer, lasti, printout_end, j);
270
}
271
lasti = i - D_length ;
272
for(k=0; k<= D; k++) {
273
A[k] = Init[0];
274
}
275
r1 = A[0] & r_Init1;
276
B[0] = (((A[0]>>1)&CMask) | r1) & D_Mask;
277
for(k=1; k<= D; k++) {
278
r1 = r_Init1 & A[k];
279
r2 = A[k-1] | (((A[k-1] | B[k-1])>>1)&r_NO_ERR);
280
B[k] = (((A[k]>>1)&CMask) | r1 | r2) ;
281
}
282
}
283
}
284
if(l < BlockSize) {
285
lasti = Max_record;
286
}
287
else {
288
ResidueSize = Max_record + l - lasti;
289
if(ResidueSize > Max_record) {
290
ResidueSize = Max_record;
291
TRUNCATE = ON; }
292
strncpy(buffer+Max_record-ResidueSize, buffer+lasti, ResidueSize);
293
lasti = Max_record - ResidueSize;
294
if(lasti == 0) lasti = 1;
295
}
296
}
297
return;
298
}
299
300
301
/*
302
fill_buf(fd, buf, record_size)
303
int fd, record_size; unsigned char *buf;
304
{
305
int num_read=1;
306
int total_read=0;
307
while(total_read < record_size && num_read > 0) {
308
num_read = read(fd, buf+total_read, 4096);
309
total_read = total_read + num_read;
310
}
311
return(total_read);
312
}
313
*/
668
CHAR old_D_pat[];
669
int text;
670
register unsigned D;
671
{
672
register unsigned i, c, r1, r2, CMask, r_NO_ERR, r_Init1, end, endpos;
673
unsigned A[MaxError+2], B[MaxError+2];
674
unsigned D_Mask;
675
int D_length, FIRSTROUND, ResidueSize, lasti, l, k, j=0;
676
int printout_end;
677
CHAR *buffer;
678
/* CHAR *tempbuf = NULL;*/ /* used only when text == -1 */
679
680
D_length = strlen(old_D_pat);
681
D_Mask = D_endpos;
682
for ( i=1; i<D_length; i++) D_Mask = (D_Mask<<1) | D_Mask;
683
D_Mask = ~D_Mask;
684
685
r_Init1 = Init1; /* put Init1 in register */
686
r_NO_ERR = NO_ERR_MASK; /* put NO_ERR_MASK in register */
687
endpos = D_endpos;
688
FIRSTROUND = ON;
689
for(k=0; k<=D; k++) A[k] = B[k] = Init[0];
690
691
#if AGREP_POINTER
692
if (text != -1) {
693
#endif /*AGREP_POINTER*/
694
lasti = Max_record;
695
alloc_buf(text, &buffer, BlockSize+Max_record+1);
696
buffer[Max_record-1] = '\n';
697
while ((l = fill_buf(text, buffer + Max_record, BlockSize)) > 0)
698
{
699
i = Max_record;
700
end = Max_record + l ;
701
if (FIRSTROUND) {
702
i = Max_record - 1;
703
FIRSTROUND = OFF;
704
}
705
if (l < BlockSize) {
706
strncpy(buffer+end, old_D_pat, D_length);
707
buffer[end+D_length] = '\0';
708
end = end + D_length;
709
}
710
711
/* ASEARCH0_PROCESS: the while-loop below */
712
while (i < end )
713
{
714
c = buffer[i++];
715
CurrentByteOffset ++;
716
CMask = Mask[c];
717
r1 = B[0] & r_Init1;
718
A[0] = (((B[0] >> 1)) & CMask | r1 ) ;
719
for(k=1; k<=D; k++) {
720
r1 = r_Init1 & B[k];
721
r2 = B[k-1] | (((A[k-1]|B[k-1])>>1) & r_NO_ERR);
722
A[k] = ((B[k] >> 1) & CMask) | r2 | r1;
723
}
724
if(A[0] & endpos) {
725
j++;
726
if (DELIMITER) CurrentByteOffset -= D_length;
727
else CurrentByteOffset -= 1;
728
r1 = A[D];
729
if(((AND == 1) && ((r1 & endposition) == endposition)) || ((AND == 0) && (r1 & endposition)) ^ INVERSE )
730
{
731
if(FILENAMEONLY && (NEW_FILE || !POST_FILTER)) {
732
num_of_matched++;
733
734
if (agrep_finalfp != NULL)
735
fprintf(agrep_finalfp, "%s", CurrentFileName);
736
else {
737
int outindex;
738
for(outindex=0; (outindex+agrep_outpointer<agrep_outlen) &&
739
(CurrentFileName[outindex] != '\0'); outindex++) {
740
agrep_outbuffer[agrep_outpointer+outindex] = CurrentFileName[outindex];
741
}
742
if ((CurrentFileName[outindex] != '\0') || (outindex+agrep_outpointer>=agrep_outlen)) {
743
OUTPUT_OVERFLOW;
744
free_buf(text, buffer);
745
return -1;
746
}
747
agrep_outpointer += outindex;
748
}
749
if (PRINTFILETIME) {
750
char *s = aprint_file_time(CurrentFileTime);
751
if (agrep_finalfp != NULL)
752
fprintf(agrep_finalfp, "%s", s);
753
else {
754
int outindex;
755
for(outindex=0; (outindex+agrep_outpointer<agrep_outlen) &&
756
(s[outindex] != '\0'); outindex++) {
757
agrep_outbuffer[agrep_outpointer+outindex] = s[outindex];
758
}
759
if ((s[outindex] != '\0') || (outindex+agrep_outpointer>=agrep_outlen)) {
760
OUTPUT_OVERFLOW;
761
free_buf(text, buffer);
762
return -1;
763
}
764
agrep_outpointer += outindex;
765
}
766
}
767
if (agrep_finalfp != NULL)
768
fprintf(agrep_finalfp, "\n");
769
else {
770
if (agrep_outpointer+1>=agrep_outlen) {
771
OUTPUT_OVERFLOW;
772
free_buf(text, buffer);
773
return -1;
774
}
775
else agrep_outbuffer[agrep_outpointer++] = '\n';
776
}
777
778
/*
779
if (text == -1) {
780
memcpy(buffer+end-D_length, tempbuf, D_length+1);
781
}
782
*/
783
free_buf(text, buffer);
784
NEW_FILE = OFF;
785
return 0;
786
}
787
printout_end = i - D_length - 1;
788
if((text != -1) && !(lasti >= Max_record + l - 1)) {
789
if (-1 == output(buffer, lasti, printout_end, j)) {free_buf(text, buffer); return -1;}
790
}
791
else if ((text == -1) && !(lasti >= l)) {
792
if (-1 == output(buffer, lasti, printout_end, j)) {free_buf(text, buffer); return -1;}
793
}
794
if (((LIMITOUTPUT > 0) && (LIMITOUTPUT <= num_of_matched)) ||
795
((LIMITPERFILE > 0) && (LIMITPERFILE <= num_of_matched - prev_num_of_matched))) {
796
free_buf(text, buffer);
797
return 0; /* done */
798
}
799
}
800
lasti = i - D_length; /* point to starting position of D_pat */
801
for(k=0; k<= D; k++) {
802
B[k] = Init[0];
803
}
804
r1 = B[0] & r_Init1;
805
A[0] = (((B[0]>>1) & CMask) | r1) & D_Mask;
806
for(k=1; k<= D; k++) {
807
r1 = Init1 & B[k];
808
r2 = B[k-1] | (((A[k-1] | B[k-1])>>1)&r_NO_ERR);
809
A[k] = (((B[k]>>1)&CMask) | r1 | r2) ;
810
}
811
if (DELIMITER) CurrentByteOffset += 1*D_length;
812
else CurrentByteOffset += 1*1;
813
}
814
c = buffer[i++];
815
CurrentByteOffset ++;
816
CMask = Mask[c];
817
r1 = r_Init1 & A[0];
818
B[0] = ((A[0] >> 1 ) & CMask) | r1;
819
for(k=1; k<=D; k++) {
820
r1 = r_Init1 & A[k];
821
r2 = A[k-1] | (((A[k-1]|B[k-1])>>1) & r_NO_ERR);
822
B[k] = ((A[k] >> 1) & CMask) | r2 | r1;
823
}
824
if(B[0] & endpos) {
825
j++;
826
if (DELIMITER) CurrentByteOffset -= D_length;
827
else CurrentByteOffset -= 1;
828
r1 = B[D];
829
if(((AND == 1) && ((r1 & endposition) == endposition)) || ((AND == 0) && (r1 & endposition)) ^ INVERSE )
830
{
831
if(FILENAMEONLY && (NEW_FILE || !POST_FILTER)) {
832
num_of_matched++;
833
834
if (agrep_finalfp != NULL)
835
fprintf(agrep_finalfp, "%s", CurrentFileName);
836
else {
837
int outindex;
838
for(outindex=0; (outindex+agrep_outpointer<agrep_outlen) &&
839
(CurrentFileName[outindex] != '\0'); outindex++) {
840
agrep_outbuffer[agrep_outpointer+outindex] = CurrentFileName[outindex];
841
}
842
if ((CurrentFileName[outindex] != '\0') || (outindex+agrep_outpointer>=agrep_outlen)) {
843
OUTPUT_OVERFLOW;
844
free_buf(text, buffer);
845
return -1;
846
}
847
agrep_outpointer += outindex;
848
}
849
if (PRINTFILETIME) {
850
char *s = aprint_file_time(CurrentFileTime);
851
if (agrep_finalfp != NULL)
852
fprintf(agrep_finalfp, "%s", s);
853
else {
854
int outindex;
855
for(outindex=0; (outindex+agrep_outpointer<agrep_outlen) &&
856
(s[outindex] != '\0'); outindex++) {
857
agrep_outbuffer[agrep_outpointer+outindex] = s[outindex];
858
}
859
if ((s[outindex] != '\0') || (outindex+agrep_outpointer>=agrep_outlen)) {
860
OUTPUT_OVERFLOW;
861
free_buf(text, buffer);
862
return -1;
863
}
864
agrep_outpointer += outindex;
865
}
866
}
867
if (agrep_finalfp != NULL)
868
fprintf(agrep_finalfp, "\n");
869
else {
870
if (agrep_outpointer+1>=agrep_outlen) {
871
OUTPUT_OVERFLOW;
872
free_buf(text, buffer);
873
return -1;
874
}
875
else agrep_outbuffer[agrep_outpointer++] = '\n';
876
}
877
878
/*
879
if (text == -1) {
880
memcpy(buffer+end-D_length, tempbuf, D_length+1);
881
}
882
*/
883
free_buf(text, buffer);
884
NEW_FILE = OFF;
885
return 0;
886
}
887
printout_end = i - D_length -1 ;
888
if((text != -1) && !(lasti >= Max_record + l - 1)) {
889
if (-1 == output(buffer, lasti, printout_end, j)) {free_buf(text, buffer); return -1;}
890
}
891
else if ((text == -1) && !(lasti >= l)) {
892
if (-1 == output(buffer, lasti, printout_end, j)) {free_buf(text, buffer); return -1;}
893
}
894
if (((LIMITOUTPUT > 0) && (LIMITOUTPUT <= num_of_matched)) ||
895
((LIMITPERFILE > 0) && (LIMITPERFILE <= num_of_matched - prev_num_of_matched))) {
896
free_buf(text, buffer);
897
return 0; /* done */
898
}
899
}
900
lasti = i - D_length ;
901
for(k=0; k<= D; k++) {
902
A[k] = Init[0];
903
}
904
r1 = A[0] & r_Init1;
905
B[0] = (((A[0]>>1)&CMask) | r1) & D_Mask;
906
for(k=1; k<= D; k++) {
907
r1 = r_Init1 & A[k];
908
r2 = A[k-1] | (((A[k-1] | B[k-1])>>1)&r_NO_ERR);
909
B[k] = (((A[k]>>1)&CMask) | r1 | r2) ;
910
}
911
if (DELIMITER) CurrentByteOffset += 1*D_length;
912
else CurrentByteOffset += 1*1;
913
}
914
}
915
916
if(l < BlockSize) {
917
lasti = Max_record;
918
}
919
else {
920
ResidueSize = Max_record + l - lasti;
921
if(ResidueSize > Max_record) {
922
ResidueSize = Max_record;
923
TRUNCATE = ON;
924
}
925
strncpy(buffer+Max_record-ResidueSize, buffer+lasti, ResidueSize);
926
lasti = Max_record - ResidueSize;
927
if(lasti == 0) lasti = 1;
928
}
929
}
930
free_buf(text, buffer);
931
return 0;
932
#if AGREP_POINTER
933
}
934
else {
935
lasti = 1;
936
/* if (DELIMITER) tempbuf = (CHAR*)malloc(D_length + 1); */
937
buffer = (CHAR *)agrep_inbuffer;
938
l = agrep_inlen;
939
end = l;
940
/* buffer[end-1] = '\n';*/ /* at end of the text. */
941
/* buffer[0] = '\n';*/ /* in front of the text. */
942
i = 0;
943
if(DELIMITER) {
944
for(k=0; k<D_length; k++) {
945
if(old_D_pat[k] != buffer[k]) break;
946
}
947
if(k>=D_length) j--;
948
/*
949
memcpy(tempbuf, buffer+end, D_length+1);
950
strncpy(buffer+end, old_D_pat, D_length);
951
buffer[end+D_length] = '\0';
952
end = end + D_length;
953
*/
954
}
955
956
/* An exact copy of the above ASEARCH0_PROCESS: the while-loop below */
957
while (i < end )
958
{
959
c = buffer[i++];
960
CurrentByteOffset ++;
961
CMask = Mask[c];
962
r1 = B[0] & r_Init1;
963
A[0] = (((B[0] >> 1)) & CMask | r1 ) ;
964
for(k=1; k<=D; k++) {
965
r1 = r_Init1 & B[k];
966
r2 = B[k-1] | (((A[k-1]|B[k-1])>>1) & r_NO_ERR);
967
A[k] = ((B[k] >> 1) & CMask) | r2 | r1;
968
}
969
if(A[0] & endpos) {
970
if (DELIMITER) CurrentByteOffset -= D_length;
971
else CurrentByteOffset -= 1;
972
j++;
973
r1 = A[D];
974
if(((AND == 1) && ((r1 & endposition) == endposition)) || ((AND == 0) && (r1 & endposition)) ^ INVERSE )
975
{
976
if(FILENAMEONLY && (NEW_FILE || !POST_FILTER)) {
977
num_of_matched++;
978
979
if (agrep_finalfp != NULL)
980
fprintf(agrep_finalfp, "%s", CurrentFileName);
981
else {
982
int outindex;
983
for(outindex=0; (outindex+agrep_outpointer<agrep_outlen) &&
984
(CurrentFileName[outindex] != '\0'); outindex++) {
985
agrep_outbuffer[agrep_outpointer+outindex] = CurrentFileName[outindex];
986
}
987
if ((CurrentFileName[outindex] != '\0') || (outindex+agrep_outpointer>=agrep_outlen)) {
988
OUTPUT_OVERFLOW;
989
free_buf(text, buffer);
990
return -1;
991
}
992
agrep_outpointer += outindex;
993
}
994
if (PRINTFILETIME) {
995
char *s = aprint_file_time(CurrentFileTime);
996
if (agrep_finalfp != NULL)
997
fprintf(agrep_finalfp, "%s", s);
998
else {
999
int outindex;
1000
for(outindex=0; (outindex+agrep_outpointer<agrep_outlen) &&
1001
(s[outindex] != '\0'); outindex++) {
1002
agrep_outbuffer[agrep_outpointer+outindex] = s[outindex];
1003
}
1004
if ((s[outindex] != '\0') || (outindex+agrep_outpointer>=agrep_outlen)) {
1005
OUTPUT_OVERFLOW;
1006
free_buf(text, buffer);
1007
return -1;
1008
}
1009
agrep_outpointer += outindex;
1010
}
1011
}
1012
if (agrep_finalfp != NULL)
1013
fprintf(agrep_finalfp, "\n");
1014
else {
1015
if (agrep_outpointer+1>=agrep_outlen) {
1016
OUTPUT_OVERFLOW;
1017
free_buf(text, buffer);
1018
return -1;
1019
}
1020
else agrep_outbuffer[agrep_outpointer++] = '\n';
1021
}
1022
1023
/*
1024
if (text == -1) {
1025
memcpy(buffer+end-D_length, tempbuf, D_length+1);
1026
}
1027
*/
1028
free_buf(text, buffer);
1029
NEW_FILE = OFF;
1030
return 0;
1031
}
1032
printout_end = i - D_length - 1;
1033
if((text != -1) && !(lasti >= Max_record + l - 1)) {
1034
if (-1 == output(buffer, lasti, printout_end, j)) {free_buf(text, buffer); return -1;}
1035
}
1036
else if ((text == -1) && !(lasti >= l)) {
1037
if (-1 == output(buffer, lasti, printout_end, j)) {free_buf(text, buffer); return -1;}
1038
}
1039
if (((LIMITOUTPUT > 0) && (LIMITOUTPUT <= num_of_matched)) ||
1040
((LIMITPERFILE > 0) && (LIMITPERFILE <= num_of_matched - prev_num_of_matched))) {
1041
free_buf(text, buffer);
1042
return 0; /* done */
1043
}
1044
}
1045
lasti = i - D_length; /* point to starting position of D_pat */
1046
for(k=0; k<= D; k++) {
1047
B[k] = Init[0];
1048
}
1049
r1 = B[0] & r_Init1;
1050
A[0] = (((B[0]>>1) & CMask) | r1) & D_Mask;
1051
for(k=1; k<= D; k++) {
1052
r1 = Init1 & B[k];
1053
r2 = B[k-1] | (((A[k-1] | B[k-1])>>1)&r_NO_ERR);
1054
A[k] = (((B[k]>>1)&CMask) | r1 | r2) ;
1055
}
1056
if (DELIMITER) CurrentByteOffset += 1*D_length;
1057
else CurrentByteOffset += 1*1;
1058
}
1059
c = buffer[i++];
1060
CurrentByteOffset ++;
1061
CMask = Mask[c];
1062
r1 = r_Init1 & A[0];
1063
B[0] = ((A[0] >> 1 ) & CMask) | r1;
1064
for(k=1; k<=D; k++) {
1065
r1 = r_Init1 & A[k];
1066
r2 = A[k-1] | (((A[k-1]|B[k-1])>>1) & r_NO_ERR);
1067
B[k] = ((A[k] >> 1) & CMask) | r2 | r1;
1068
}
1069
if(B[0] & endpos) {
1070
j++;
1071
if (DELIMITER) CurrentByteOffset -= D_length;
1072
else CurrentByteOffset -= 1;
1073
r1 = B[D];
1074
if(((AND == 1) && ((r1 & endposition) == endposition)) || ((AND == 0) && (r1 & endposition)) ^ INVERSE )
1075
{
1076
if(FILENAMEONLY && (NEW_FILE || !POST_FILTER)) {
1077
num_of_matched++;
1078
1079
if (agrep_finalfp != NULL)
1080
fprintf(agrep_finalfp, "%s", CurrentFileName);
1081
else {
1082
int outindex;
1083
for(outindex=0; (outindex+agrep_outpointer<agrep_outlen) &&
1084
(CurrentFileName[outindex] != '\0'); outindex++) {
1085
agrep_outbuffer[agrep_outpointer+outindex] = CurrentFileName[outindex];
1086
}
1087
if ((CurrentFileName[outindex] != '\0') || (outindex+agrep_outpointer>=agrep_outlen)) {
1088
OUTPUT_OVERFLOW;
1089
free_buf(text, buffer);
1090
return -1;
1091
}
1092
agrep_outpointer += outindex;
1093
}
1094
if (PRINTFILETIME) {
1095
char *s = aprint_file_time(CurrentFileTime);
1096
if (agrep_finalfp != NULL)
1097
fprintf(agrep_finalfp, "%s", s);
1098
else {
1099
int outindex;
1100
for(outindex=0; (outindex+agrep_outpointer<agrep_outlen) &&
1101
(s[outindex] != '\0'); outindex++) {
1102
agrep_outbuffer[agrep_outpointer+outindex] = s[outindex];
1103
}
1104
if ((s[outindex] != '\0') || (outindex+agrep_outpointer>=agrep_outlen)) {
1105
OUTPUT_OVERFLOW;
1106
free_buf(text, buffer);
1107
return -1;
1108
}
1109
agrep_outpointer += outindex;
1110
}
1111
}
1112
if (agrep_finalfp != NULL)
1113
fprintf(agrep_finalfp, "\n");
1114
else {
1115
if (agrep_outpointer+1>=agrep_outlen) {
1116
OUTPUT_OVERFLOW;
1117
free_buf(text, buffer);
1118
return -1;
1119
}
1120
else agrep_outbuffer[agrep_outpointer++] = '\n';
1121
}
1122
1123
/*
1124
if (text == -1) {
1125
memcpy(buffer+end-D_length, tempbuf, D_length+1);
1126
}
1127
*/
1128
free_buf(text, buffer);
1129
NEW_FILE = OFF;
1130
return 0;
1131
}
1132
printout_end = i - D_length -1 ;
1133
if((text != -1) && !(lasti >= Max_record + l - 1)) {
1134
if (-1 == output(buffer, lasti, printout_end, j)) {free_buf(text, buffer); return -1;}
1135
}
1136
else if ((text == -1) && !(lasti >= l)) {
1137
if (-1 == output(buffer, lasti, printout_end, j)) {free_buf(text, buffer); return -1;}
1138
}
1139
if (((LIMITOUTPUT > 0) && (LIMITOUTPUT <= num_of_matched)) ||
1140
((LIMITPERFILE > 0) && (LIMITPERFILE <= num_of_matched - prev_num_of_matched))) {
1141
free_buf(text, buffer);
1142
return 0; /* done */
1143
}
1144
}
1145
lasti = i - D_length ;
1146
for(k=0; k<= D; k++) {
1147
A[k] = Init[0];
1148
}
1149
r1 = A[0] & r_Init1;
1150
B[0] = (((A[0]>>1)&CMask) | r1) & D_Mask;
1151
for(k=1; k<= D; k++) {
1152
r1 = r_Init1 & A[k];
1153
r2 = A[k-1] | (((A[k-1] | B[k-1])>>1)&r_NO_ERR);
1154
B[k] = (((A[k]>>1)&CMask) | r1 | r2) ;
1155
}
1156
if (DELIMITER) CurrentByteOffset += 1*D_length;
1157
else CurrentByteOffset += 1*1;
1158
}
1159
}
1160
1161
/*
1162
if (DELIMITER) {
1163
memcpy(buffer+end, tempbuf, D_length+1);
1164
free(tempbuf);
1165
}
1166
*/
1167
return 0;
1168
}
1169
#endif /*AGREP_POINTER*/
1170
}
Loggerhead is a web-based interface for Breezy
Version: 2.0.1