« back to all changes in this revision
Viewing changes to asearch1.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: 2005-12-27 17:01:00 UTC
- mfrom: (1.1.1 upstream)
- Revision ID: james.westby@ubuntu.com-20051227170100-nk2hnq0bnlkbk3q3
Tags: 4.17-2
Added patch to fix FTBS on amd64 (Closes: #344909).
- files added:
- Makefile.NeXT
- debian/patches
- save
- files removed:
- agrep.ps.1
- files modified:
- COPYRIGHT
added
removed
asearch1.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
3
#include <errno.h>
4
4
5
extern unsigned Init1, Init[], Mask[], endposition, D_endpos;
5
6
extern unsigned NO_ERR_MASK;
6
extern int TRUNCATE, DELIMITER, AND, I, S, DD, INVERSE, FILENAMEONLY ;
7
extern int TRUNCATE, DELIMITER, AND, I, S, DD, INVERSE, FILENAMEONLY, PRINTFILETIME ;
7
8
extern char CurrentFileName[];
8
extern int num_of_matched;
9
10
9
extern long CurrentFileTime;
10
extern int num_of_matched, prev_num_of_matched;
11
12
extern int CurrentByteOffset;
13
extern CHAR *agrep_inbuffer;
14
extern int agrep_inlen;
15
16
extern FILE *agrep_finalfp;
17
extern CHAR *agrep_outbuffer;
18
extern int agrep_outlen;
19
extern int agrep_outpointer;
20
21
extern int NEW_FILE, POST_FILTER;
22
23
extern int LIMITOUTPUT, LIMITPERFILE;
24
25
int
11
26
asearch1(old_D_pat, Text, D)
12
char old_D_pat[]; int Text; register unsigned D;
27
char old_D_pat[];
28
int Text;
29
register unsigned D;
13
30
{
14
register unsigned end, i, r1, r2, r3, r4, r5, CMask, D_Mask, Init0, k, endpos;
15
register unsigned r_NO_ERR;
16
unsigned A[MaxError*2+1], B[MaxError*2+1];
17
int D_length, ResidueSize, lasti, num_read, FIRSTROUND, j=0;
18
char buffer[BlockSize+Max_record+1];
19
20
if(I == 0) Init1 = 037777777777;
21
if(DD > D) DD = D+1;
22
if(I > D) I = D+1;
23
if(S > D) S = D+1;
24
D_length = strlen(old_D_pat);
25
buffer[Max_record-1] = '\n';
26
27
lasti = Max_record;
28
r_NO_ERR = NO_ERR_MASK;
29
30
D_Mask = D_endpos;
31
for(i=1 ; i<D_length; i++) D_Mask = (D_Mask << 1) | D_Mask;
32
D_Mask = ~D_Mask;
33
endpos = D_endpos;
34
r3 = D+1; r4 = D*2; /* to make sure in register */
35
for(k=0; k < D; k++) A[k] = B[k] = 0;
36
for(k=D; k <= r4; k++) A[k] = B[k] = Init[0];
37
38
while ((num_read = fill_buf(Text, buffer + Max_record, Max_record)) > 0)
39
{
40
i=Max_record; end = Max_record + num_read;
41
if(FIRSTROUND) { i = Max_record -1 ;
42
if(DELIMITER) {
43
for(k=0; k<D_length; k++) {
44
if(old_D_pat[k] != buffer[Max_record+k]) break;
45
}
46
if(k>=D_length) j--;
47
}
48
FIRSTROUND = 0; }
49
if(num_read < BlockSize) {
50
strncpy(buffer+Max_record+num_read, old_D_pat, D_length);
51
end = end + D_length;
52
buffer[end] = '\0';
53
}
54
while (i < end)
55
{
56
CMask = Mask[buffer[i++]];
57
r1 = Init1 & B[D];
58
A[D] = ((B[D] >> 1) & CMask ) | r1;
59
for(k = r3; k <= r4; k++) /* r3 = D+1, r4 = 2*D */
60
{
61
r5 = B[k];
62
r1 = Init1 & r5;
63
A[k] = ((r5 >> 1) & CMask) | B[k-I] | (((A[k-DD] | B[k-S]) >>1) & r_NO_ERR) | r1 ;
64
}
65
if(A[D] & endpos) {
66
j++;
67
if(((AND == 1) && ((A[D*2] & endposition) == endposition)) || ((AND == 0) && (A[D*2] & endposition)) ^ INVERSE )
68
{
69
if(FILENAMEONLY) {
70
num_of_matched++;
71
printf("%s\n", CurrentFileName);
72
return; }
73
if(lasti < Max_record + num_read)
74
output(buffer, lasti, i-D_length-1, j);
75
}
76
lasti = i - D_length;
77
TRUNCATE = OFF;
78
for(k = D; k <= r4 ; k++) A[k] = B[k] = Init[0];
79
r1 = Init1 & B[D];
80
A[D] = (((B[D] >> 1) & CMask ) | r1) & D_Mask;
81
for(k = r3; k <= r4; k++) /* r3 = D+1, r4 = 2*D */
82
{
83
r5 = B[k];
84
r1 = Init1 & r5;
85
A[k] = ((r5 >> 1) & CMask) | B[k-I] | (((A[k-DD] | B[k-S]) >>1) & r_NO_ERR) | r1 ;
86
}
87
} /* end if (A[D]&endpos) */
88
CMask = Mask[buffer[i++]];
89
r1 = A[D] & Init1;
90
B[D] = ((A[D] >> 1) & CMask) | r1;
91
for(k = r3; k <= r4; k++)
92
{
93
r1 = A[k] & Init1;
94
B[k] = ((A[k] >> 1) & CMask) | A[k-I] | (((B[k-DD] | A[k-S]) >>1)&r_NO_ERR) | r1 ;
95
}
96
if(B[D] & endpos) {
97
j++;
98
if(((AND == 1) && ((B[r4] & endposition) == endposition)) || ((AND == 0) && (B[r4] & endposition)) ^ INVERSE )
99
{ if(FILENAMEONLY) {
100
num_of_matched++;
101
printf("%s\n", CurrentFileName);
102
return; }
103
if(lasti < Max_record + num_read)
104
output(buffer, lasti, i-D_length-1, j);
105
}
106
lasti = i-D_length;
107
TRUNCATE = OFF;
108
for(k=D; k <= r4; k++) A[k] = B[k] = Init[0];
109
r1 = Init1 & A[D];
110
B[D] = (((A[D] >> 1) & CMask ) | r1) & D_Mask;
111
for(k = r3; k <= r4; k++) /* r3 = D+1, r4 = 2*D */
112
{
113
r5 = A[k];
114
r1 = Init1 & r5;
115
B[k] = ((r5 >> 1) & CMask) | A[k-I] | (((B[k-DD] | A[k-S]) >>1) & r_NO_ERR) | r1 ;
116
}
117
} /* end if (B[D]&endpos) */
118
}
119
ResidueSize = Max_record + num_read - lasti;
120
if(ResidueSize > Max_record) {
121
ResidueSize = Max_record;
122
TRUNCATE = ON;
123
}
124
strncpy(buffer+Max_record-ResidueSize, buffer+lasti, ResidueSize);
125
lasti = Max_record - ResidueSize;
126
if(lasti < 0) lasti = 1;
127
if(num_read < BlockSize) lasti = Max_record;
128
}
129
return;
31
register unsigned end, i, r1, r3, r4, r5, CMask, D_Mask, k, endpos;
32
register unsigned r_NO_ERR;
33
unsigned A[MaxError*2+1], B[MaxError*2+1];
34
int D_length, ResidueSize, lasti, num_read, FIRSTROUND=1, j=0;
35
CHAR *buffer;
36
/* CHAR *tempbuf = NULL;*/ /* used only when Text == -1 */
37
38
if(I == 0) Init1 = (unsigned)037777777777;
39
if(DD > D) DD = D+1;
40
if(I > D) I = D+1;
41
if(S > D) S = D+1;
42
D_length = strlen(old_D_pat);
43
44
r_NO_ERR = NO_ERR_MASK;
45
46
D_Mask = D_endpos;
47
for(i=1; i<D_length; i++) D_Mask = (D_Mask << 1) | D_Mask;
48
D_Mask = ~D_Mask;
49
endpos = D_endpos;
50
r3 = D+1;
51
r4 = D*2; /* to make sure in register */
52
for(k=0; k < D; k++) A[k] = B[k] = 0;
53
for(k=D; k <= r4; k++) A[k] = B[k] = Init[0];
54
55
#if AGREP_POINTER
56
if (Text != -1) {
57
#endif /*AGREP_POINTER*/
58
lasti = Max_record;
59
alloc_buf(Text, &buffer, BlockSize+Max_record+1);
60
buffer[Max_record-1] = '\n';
61
62
while ((num_read = fill_buf(Text, buffer + Max_record, BlockSize)) > 0)
63
{
64
i=Max_record;
65
end = Max_record + num_read;
66
if(FIRSTROUND) {
67
i = Max_record -1 ;
68
if(DELIMITER) {
69
for(k=0; k<D_length; k++) {
70
if(old_D_pat[k] != buffer[Max_record+k]) break;
71
}
72
if(k>=D_length) j--;
73
}
74
FIRSTROUND = 0;
75
}
76
if(num_read < BlockSize) {
77
strncpy(buffer+Max_record+num_read, old_D_pat, D_length);
78
end = end + D_length;
79
buffer[end] = '\0';
80
}
81
82
/* ASEARCH1_PROCESS: the while-loop below */
83
while (i < end)
84
{
85
CMask = Mask[buffer[i++]];
86
CurrentByteOffset ++;
87
r1 = Init1 & B[D];
88
A[D] = ((B[D] >> 1) & CMask ) | r1;
89
for(k = r3; k <= r4; k++) /* r3 = D+1, r4 = 2*D */
90
{
91
r5 = B[k];
92
r1 = Init1 & r5;
93
A[k] = ((r5 >> 1) & CMask) | B[k-I] | (((A[k-DD] | B[k-S]) >>1) & r_NO_ERR) | r1 ;
94
}
95
if(A[D] & endpos) {
96
j++;
97
if (DELIMITER) CurrentByteOffset -= D_length;
98
else CurrentByteOffset -= 1;
99
if(((AND == 1) && ((A[D*2] & endposition) == endposition)) || ((AND == 0) && (A[D*2] & endposition)) ^ INVERSE )
100
{
101
if(FILENAMEONLY && (NEW_FILE || !POST_FILTER)) {
102
num_of_matched++;
103
104
if (agrep_finalfp != NULL)
105
fprintf(agrep_finalfp, "%s", CurrentFileName);
106
else {
107
int outindex;
108
for(outindex=0; (outindex+agrep_outpointer<agrep_outlen) &&
109
(CurrentFileName[outindex] != '\0'); outindex++) {
110
agrep_outbuffer[agrep_outpointer+outindex] = CurrentFileName[outindex];
111
}
112
if ((CurrentFileName[outindex] != '\0') || (outindex+agrep_outpointer>=agrep_outlen)) {
113
OUTPUT_OVERFLOW;
114
free_buf(Text, buffer);
115
return -1;
116
}
117
agrep_outpointer += outindex;
118
}
119
if (PRINTFILETIME) {
120
char *s = aprint_file_time(CurrentFileTime);
121
if (agrep_finalfp != NULL)
122
fprintf(agrep_finalfp, "%s", s);
123
else {
124
int outindex;
125
for(outindex=0; (outindex+agrep_outpointer<agrep_outlen) &&
126
(s[outindex] != '\0'); outindex++) {
127
agrep_outbuffer[agrep_outpointer+outindex] = s[outindex];
128
}
129
if ((s[outindex] != '\0') || (outindex+agrep_outpointer>=agrep_outlen)) {
130
OUTPUT_OVERFLOW;
131
free_buf(Text, buffer);
132
return -1;
133
}
134
agrep_outpointer += outindex;
135
}
136
}
137
if (agrep_finalfp != NULL)
138
fprintf(agrep_finalfp, "\n");
139
else {
140
if (agrep_outpointer+1>=agrep_outlen) {
141
OUTPUT_OVERFLOW;
142
free_buf(Text, buffer);
143
return -1;
144
}
145
else agrep_outbuffer[agrep_outpointer++] = '\n';
146
}
147
148
/*
149
if (Text == -1) {
150
memcpy(buffer+end-D_length, tempbuf, D_length+1);
151
}
152
*/
153
free_buf(Text, buffer);
154
NEW_FILE = OFF;
155
return 0;
156
}
157
if((Text != -1) && !(lasti >= Max_record + num_read - 1)) {
158
if (-1 == output(buffer, lasti, i-D_length-1, j)) {free_buf(Text, buffer); return -1;}
159
}
160
else if ((Text == -1) && !(lasti >= num_read)) {
161
if (-1 == output(buffer, lasti, i-D_length-1, j)) {free_buf(Text, buffer); return -1;}
162
}
163
if (((LIMITOUTPUT > 0) && (LIMITOUTPUT <= num_of_matched)) ||
164
((LIMITPERFILE > 0) && (LIMITPERFILE <= num_of_matched - prev_num_of_matched))) {
165
free_buf(Text, buffer);
166
return 0; /* done */
167
}
168
}
169
lasti = i - D_length;
170
TRUNCATE = OFF;
171
for(k = D; k <= r4 ; k++) A[k] = B[k] = Init[0];
172
r1 = Init1 & B[D];
173
A[D] = (((B[D] >> 1) & CMask ) | r1) & D_Mask;
174
for(k = r3; k <= r4; k++) /* r3 = D+1, r4 = 2*D */
175
{
176
r5 = B[k];
177
r1 = Init1 & r5;
178
A[k] = ((r5 >> 1) & CMask) | B[k-I] | (((A[k-DD] | B[k-S]) >>1) & r_NO_ERR) | r1 ;
179
}
180
if (DELIMITER) CurrentByteOffset += 1*D_length;
181
else CurrentByteOffset += 1*1;
182
} /* end if (A[D]&endpos) */
183
CMask = Mask[buffer[i++]];
184
CurrentByteOffset ++;
185
r1 = A[D] & Init1;
186
B[D] = ((A[D] >> 1) & CMask) | r1;
187
for(k = r3; k <= r4; k++)
188
{
189
r1 = A[k] & Init1;
190
B[k] = ((A[k] >> 1) & CMask) | A[k-I] | (((B[k-DD] | A[k-S]) >>1)&r_NO_ERR) | r1 ;
191
}
192
if(B[D] & endpos) {
193
j++;
194
if (DELIMITER) CurrentByteOffset -= D_length;
195
else CurrentByteOffset -= 1;
196
if(((AND == 1) && ((B[r4] & endposition) == endposition)) || ((AND == 0) && (B[r4] & endposition)) ^ INVERSE )
197
{
198
if(FILENAMEONLY && (NEW_FILE || !POST_FILTER)) {
199
num_of_matched++;
200
201
if (agrep_finalfp != NULL)
202
fprintf(agrep_finalfp, "%s", CurrentFileName);
203
else {
204
int outindex;
205
for(outindex=0; (outindex+agrep_outpointer<agrep_outlen) &&
206
(CurrentFileName[outindex] != '\0'); outindex++) {
207
agrep_outbuffer[agrep_outpointer+outindex] = CurrentFileName[outindex];
208
}
209
if ((CurrentFileName[outindex] != '\0') || (outindex+agrep_outpointer>=agrep_outlen)) {
210
OUTPUT_OVERFLOW;
211
free_buf(Text, buffer);
212
return -1;
213
}
214
agrep_outpointer += outindex;
215
}
216
if (PRINTFILETIME) {
217
char *s = aprint_file_time(CurrentFileTime);
218
if (agrep_finalfp != NULL)
219
fprintf(agrep_finalfp, "%s", s);
220
else {
221
int outindex;
222
for(outindex=0; (outindex+agrep_outpointer<agrep_outlen) &&
223
(s[outindex] != '\0'); outindex++) {
224
agrep_outbuffer[agrep_outpointer+outindex] = s[outindex];
225
}
226
if ((s[outindex] != '\0') || (outindex+agrep_outpointer>=agrep_outlen)) {
227
OUTPUT_OVERFLOW;
228
free_buf(Text, buffer);
229
return -1;
230
}
231
agrep_outpointer += outindex;
232
}
233
}
234
if (agrep_finalfp != NULL)
235
fprintf(agrep_finalfp, "\n");
236
else {
237
if (agrep_outpointer+1>=agrep_outlen) {
238
OUTPUT_OVERFLOW;
239
free_buf(Text, buffer);
240
return -1;
241
}
242
else agrep_outbuffer[agrep_outpointer++] = '\n';
243
}
244
245
/*
246
if (Text == -1) {
247
memcpy(buffer+end-D_length, tempbuf, D_length+1);
248
}
249
*/
250
free_buf(Text, buffer);
251
NEW_FILE = OFF;
252
return 0;
253
}
254
if((Text != -1) && !(lasti >= Max_record + num_read - 1)) {
255
if (-1 == output(buffer, lasti, i-D_length-1, j)) {free_buf(Text, buffer); return -1;}
256
}
257
else if ((Text == -1) && !(lasti >= num_read)) {
258
if (-1 == output(buffer, lasti, i-D_length-1, j)) {free_buf(Text, buffer); return -1;}
259
}
260
if (((LIMITOUTPUT > 0) && (LIMITOUTPUT <= num_of_matched)) ||
261
((LIMITPERFILE > 0) && (LIMITPERFILE <= num_of_matched - prev_num_of_matched))) {
262
free_buf(Text, buffer);
263
return 0; /* done */
264
}
265
}
266
lasti = i-D_length;
267
TRUNCATE = OFF;
268
for(k=D; k <= r4; k++) A[k] = B[k] = Init[0];
269
r1 = Init1 & A[D];
270
B[D] = (((A[D] >> 1) & CMask ) | r1) & D_Mask;
271
for(k = r3; k <= r4; k++) /* r3 = D+1, r4 = 2*D */
272
{
273
r5 = A[k];
274
r1 = Init1 & r5;
275
B[k] = ((r5 >> 1) & CMask) | A[k-I] | (((B[k-DD] | A[k-S]) >>1) & r_NO_ERR) | r1 ;
276
}
277
if (DELIMITER) CurrentByteOffset += 1*D_length;
278
else CurrentByteOffset += 1*1;
279
} /* end if (B[D]&endpos) */
280
}
281
282
ResidueSize = Max_record + num_read - lasti;
283
if(ResidueSize > Max_record) {
284
ResidueSize = Max_record;
285
TRUNCATE = ON;
286
}
287
strncpy(buffer+Max_record-ResidueSize, buffer+lasti, ResidueSize);
288
lasti = Max_record - ResidueSize;
289
if(lasti < 0) lasti = 1;
290
if(num_read < BlockSize) lasti = Max_record;
291
}
292
free_buf(Text, buffer);
293
return 0;
294
#if AGREP_POINTER
295
}
296
else {
297
lasti = 1;
298
/* if (DELIMITER) tempbuf = (CHAR*)malloc(D_length + 1); */
299
buffer = (CHAR *)agrep_inbuffer;
300
num_read = agrep_inlen;
301
end = num_read;
302
/* buffer[end-1] = '\n';*/ /* at end of the text. */
303
/* buffer[0] = '\n';*/ /* in front of the text. */
304
i = 0;
305
306
if(DELIMITER) {
307
for(k=0; k<D_length; k++) {
308
if(old_D_pat[k] != buffer[k]) break;
309
}
310
if(k>=D_length) j--;
311
/*
312
memcpy(tempbuf, buffer+end, D_length+1);
313
strncpy(buffer+end, old_D_pat, D_length);
314
buffer[end+D_length] = '\0';
315
end = end + D_length;
316
*/
317
}
318
319
/* An exact copy of the above ASEARCH1_PROCESS: the while-loop below */
320
while (i < end)
321
{
322
CMask = Mask[buffer[i++]];
323
CurrentByteOffset ++;
324
r1 = Init1 & B[D];
325
A[D] = ((B[D] >> 1) & CMask ) | r1;
326
for(k = r3; k <= r4; k++) /* r3 = D+1, r4 = 2*D */
327
{
328
r5 = B[k];
329
r1 = Init1 & r5;
330
A[k] = ((r5 >> 1) & CMask) | B[k-I] | (((A[k-DD] | B[k-S]) >>1) & r_NO_ERR) | r1 ;
331
}
332
if(A[D] & endpos) {
333
j++;
334
if (DELIMITER) CurrentByteOffset -= D_length;
335
else CurrentByteOffset -= 1;
336
if(((AND == 1) && ((A[D*2] & endposition) == endposition)) || ((AND == 0) && (A[D*2] & endposition)) ^ INVERSE )
337
{
338
if(FILENAMEONLY && (NEW_FILE || !POST_FILTER)) {
339
num_of_matched++;
340
341
if (agrep_finalfp != NULL)
342
fprintf(agrep_finalfp, "%s", CurrentFileName);
343
else {
344
int outindex;
345
for(outindex=0; (outindex+agrep_outpointer<agrep_outlen) &&
346
(CurrentFileName[outindex] != '\0'); outindex++) {
347
agrep_outbuffer[agrep_outpointer+outindex] = CurrentFileName[outindex];
348
}
349
if ((CurrentFileName[outindex] != '\0') || (outindex+agrep_outpointer>=agrep_outlen)) {
350
OUTPUT_OVERFLOW;
351
free_buf(Text, buffer);
352
return -1;
353
}
354
agrep_outpointer += outindex;
355
}
356
if (PRINTFILETIME) {
357
char *s = aprint_file_time(CurrentFileTime);
358
if (agrep_finalfp != NULL)
359
fprintf(agrep_finalfp, "%s", s);
360
else {
361
int outindex;
362
for(outindex=0; (outindex+agrep_outpointer<agrep_outlen) &&
363
(s[outindex] != '\0'); outindex++) {
364
agrep_outbuffer[agrep_outpointer+outindex] = s[outindex];
365
}
366
if ((s[outindex] != '\0') || (outindex+agrep_outpointer>=agrep_outlen)) {
367
OUTPUT_OVERFLOW;
368
free_buf(Text, buffer);
369
return -1;
370
}
371
agrep_outpointer += outindex;
372
}
373
}
374
if (agrep_finalfp != NULL)
375
fprintf(agrep_finalfp, "\n");
376
else {
377
if (agrep_outpointer+1>=agrep_outlen) {
378
OUTPUT_OVERFLOW;
379
free_buf(Text, buffer);
380
return -1;
381
}
382
else agrep_outbuffer[agrep_outpointer++] = '\n';
383
}
384
385
/*
386
if (Text == -1) {
387
memcpy(buffer+end-D_length, tempbuf, D_length+1);
388
}
389
*/
390
free_buf(Text, buffer);
391
NEW_FILE = OFF;
392
return 0;
393
}
394
if((Text != -1) && !(lasti >= Max_record + num_read - 1)) {
395
if (-1 == output(buffer, lasti, i-D_length-1, j)) {free_buf(Text, buffer); return -1;}
396
}
397
else if ((Text == -1) && !(lasti >= num_read)) {
398
if (-1 == output(buffer, lasti, i-D_length-1, j)) {free_buf(Text, buffer); return -1;}
399
}
400
if (((LIMITOUTPUT > 0) && (LIMITOUTPUT <= num_of_matched)) ||
401
((LIMITPERFILE > 0) && (LIMITPERFILE <= num_of_matched - prev_num_of_matched))) {
402
free_buf(Text, buffer);
403
return 0; /* done */
404
}
405
}
406
lasti = i - D_length;
407
TRUNCATE = OFF;
408
for(k = D; k <= r4 ; k++) A[k] = B[k] = Init[0];
409
r1 = Init1 & B[D];
410
A[D] = (((B[D] >> 1) & CMask ) | r1) & D_Mask;
411
for(k = r3; k <= r4; k++) /* r3 = D+1, r4 = 2*D */
412
{
413
r5 = B[k];
414
r1 = Init1 & r5;
415
A[k] = ((r5 >> 1) & CMask) | B[k-I] | (((A[k-DD] | B[k-S]) >>1) & r_NO_ERR) | r1 ;
416
}
417
if (DELIMITER) CurrentByteOffset += 1*D_length;
418
else CurrentByteOffset += 1*1;
419
} /* end if (A[D]&endpos) */
420
CMask = Mask[buffer[i++]];
421
CurrentByteOffset ++;
422
r1 = A[D] & Init1;
423
B[D] = ((A[D] >> 1) & CMask) | r1;
424
for(k = r3; k <= r4; k++)
425
{
426
r1 = A[k] & Init1;
427
B[k] = ((A[k] >> 1) & CMask) | A[k-I] | (((B[k-DD] | A[k-S]) >>1)&r_NO_ERR) | r1 ;
428
}
429
if(B[D] & endpos) {
430
j++;
431
if (DELIMITER) CurrentByteOffset -= D_length;
432
else CurrentByteOffset -= 1;
433
if(((AND == 1) && ((B[r4] & endposition) == endposition)) || ((AND == 0) && (B[r4] & endposition)) ^ INVERSE )
434
{
435
if(FILENAMEONLY && (NEW_FILE || !POST_FILTER)) {
436
num_of_matched++;
437
438
if (agrep_finalfp != NULL)
439
fprintf(agrep_finalfp, "%s", CurrentFileName);
440
else {
441
int outindex;
442
for(outindex=0; (outindex+agrep_outpointer<agrep_outlen) &&
443
(CurrentFileName[outindex] != '\0'); outindex++) {
444
agrep_outbuffer[agrep_outpointer+outindex] = CurrentFileName[outindex];
445
}
446
if ((CurrentFileName[outindex] != '\0') || (outindex+agrep_outpointer>=agrep_outlen)) {
447
OUTPUT_OVERFLOW;
448
free_buf(Text, buffer);
449
return -1;
450
}
451
agrep_outpointer += outindex;
452
}
453
if (PRINTFILETIME) {
454
char *s = aprint_file_time(CurrentFileTime);
455
if (agrep_finalfp != NULL)
456
fprintf(agrep_finalfp, "%s", s);
457
else {
458
int outindex;
459
for(outindex=0; (outindex+agrep_outpointer<agrep_outlen) &&
460
(s[outindex] != '\0'); outindex++) {
461
agrep_outbuffer[agrep_outpointer+outindex] = s[outindex];
462
}
463
if ((s[outindex] != '\0') || (outindex+agrep_outpointer>=agrep_outlen)) {
464
OUTPUT_OVERFLOW;
465
free_buf(Text, buffer);
466
return -1;
467
}
468
agrep_outpointer += outindex;
469
}
470
}
471
if (agrep_finalfp != NULL)
472
fprintf(agrep_finalfp, "\n");
473
else {
474
if (agrep_outpointer+1>=agrep_outlen) {
475
OUTPUT_OVERFLOW;
476
free_buf(Text, buffer);
477
return -1;
478
}
479
else agrep_outbuffer[agrep_outpointer++] = '\n';
480
}
481
482
/*
483
if (Text == -1) {
484
memcpy(buffer+end-D_length, tempbuf, D_length+1);
485
}
486
*/
487
free_buf(Text, buffer);
488
NEW_FILE = OFF;
489
return 0;
490
}
491
if((Text != -1) && !(lasti >= Max_record + num_read - 1)) {
492
if (-1 == output(buffer, lasti, i-D_length-1, j)) {free_buf(Text, buffer); return -1;}
493
}
494
else if ((Text == -1) && !(lasti >= num_read)) {
495
if (-1 == output(buffer, lasti, i-D_length-1, j)) {free_buf(Text, buffer); return -1;}
496
}
497
if (((LIMITOUTPUT > 0) && (LIMITOUTPUT <= num_of_matched)) ||
498
((LIMITPERFILE > 0) && (LIMITPERFILE <= num_of_matched - prev_num_of_matched))) {
499
free_buf(Text, buffer);
500
return 0; /* done */
501
}
502
}
503
lasti = i-D_length;
504
TRUNCATE = OFF;
505
for(k=D; k <= r4; k++) A[k] = B[k] = Init[0];
506
r1 = Init1 & A[D];
507
B[D] = (((A[D] >> 1) & CMask ) | r1) & D_Mask;
508
for(k = r3; k <= r4; k++) /* r3 = D+1, r4 = 2*D */
509
{
510
r5 = A[k];
511
r1 = Init1 & r5;
512
B[k] = ((r5 >> 1) & CMask) | A[k-I] | (((B[k-DD] | A[k-S]) >>1) & r_NO_ERR) | r1 ;
513
}
514
if (DELIMITER) CurrentByteOffset += 1*D_length;
515
else CurrentByteOffset += 1*1;
516
} /* end if (B[D]&endpos) */
517
}
518
519
/*
520
if (DELIMITER) {
521
memcpy(buffer+end, tempbuf, D_length+1);
522
free(tempbuf);
523
}
524
*/
525
return 0;
526
}
527
#endif /*AGREP_POINTER*/
130
528
}
131
529
Loggerhead is a web-based interface for Breezy
Version: 2.0.1