![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to dogre.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / gre|
Return to dogre.c CVS log | Up to [Research Unix] / researchv10no / cmd / gre |
1.1 root 1: #include <ctype.h>
2: #include "re.h"
3: #include "lre.h"
4: #include "hdr.h"
5:
6: static void gresucc(char*, char*); /* does reg exp match after bm */
7: static int reader(void*, RDFN, MATCHFN);/* plain analog of bmfind, cwfind */
8: static void readin(char*, char*, unsigned char**, unsigned char**);
9:
10: void
11: dogre(Parsetype parser, char *input, char *finput, unsigned char *map, PROCFN *pprocfn, void **pat, RDFN *prdfn, MATCHFN *pmatchfn)
12: {
13: unsigned char *lb, *le;
14:
15: readin(input, finput, &lb, &le);
16: *pat = 0;
17: globre = egprep(parser, lb, le, map, 1);
18: *prdfn = greprd;
19: *pmatchfn = grepmatch;
20: if(sflag || lflag || Lflag || oneflag){
21: if(vflag == 0)
22: succ2fn = oneshot, failfn = count_m;
23: else
24: succ2fn = count, failfn = oneshot;
25: } else if(cflag){
26: if(vflag == 0)
27: succ2fn = inc, failfn = null;
28: else
29: succ2fn = null, failfn = inc_m;
30: } else if(vflag){
31: if(bflag||nflag)
32: succ2fn = count;
33: else
34: succ2fn = null;
35: failfn = pr_m;
36: } else {
37: succ2fn = pr;
38: if(bflag||nflag)
39: failfn = count_m;
40: else
41: failfn = null;
42: }
43: if(re_lit(globre, &lb, &le)){
44: *pat = (void *)re_bmcomp((char *)lb, (char *)le, map);
45: *pprocfn = re_bmexec;
46: succfn = gresucc;
47: } else {
48: if(*pat = (void *)re_recw(globre, map))
49: *pprocfn = re_cwexec;
50: else
51: *pprocfn = reader;
52: succfn = succ2fn;
53: }
54: }
55:
56: static
57: reader(void *UNUSED, RDFN rdfn, MATCHFN matchfn)
58: {
59: unsigned char *b, *e;
60: unsigned char *nl;
61: int k;
62: #pragma ref UNUSED
63:
64: b = 0;
65: while((k = (*rdfn)((char**)&b, (char**)&e)) > 0){
66: while(nl = (unsigned char *)memchr((char *)b, '\n', e-b)){
67: if(eg_match(globre, b, nl, (unsigned char **)0, (unsigned char **)0)){
68: e = nl;
69: if((k = (*matchfn)((char**)&b, (char**)&e)) <= 0)
70: return(k);
71: } else
72: b = nl+1;
73: }
74: }
75: return(k);
76: }
77:
78: static void
79: readin(char *in, char *fin, unsigned char **beg, unsigned char **end)
80: {
81: int size, n, fd, left;
82: char *base, *p;
83:
84: if(in){
85: if(xflag){
86: size = 4+strlen(in)+1;
87: *beg = (unsigned char *)malloc(size);
88: if (!*beg){
89: EPR "%s: can't malloc %d bytes for -x\n", progname, size);
90: exit(2);
91: }
92: p = (char *)*beg;
93: *p++ = '^';
94: *p++ = '(';
95: memmove(p, in, n = strlen(in));
96: p += n;
97: *p++ = ')';
98: *p++ = '$';
99: *end = (unsigned char *)p;
100: } else {
101: *beg = (unsigned char *)in;
102: *end = *beg + strlen(in);
103: }
104: return;
105: }
106: /* we know fin is nonzero */
107: if((fd = open(fin, 0)) < 0){
108: perror(fin);
109: exit(2);
110: }
111: /*
112: i object to calling stat; the following crap is not painful
113: and at worst involves copying twice the number of bytes.
114: */
115: size = 128;
116: if((base = malloc(size)) == 0){
117: EPR "%s: can't malloc %d bytes for -f %s\n", progname, size, fin);
118: exit(2);
119: }
120: left = size;
121: p = base;
122: if(xflag){
123: *p++ = '^';
124: left--;
125: }
126: for(; (n = read(fd, p, left)) > 0;){
127: p += n;
128: left -= n;
129: if(left == 0){
130: size *= 2;
131: if((base = realloc(base, size+2)) == 0){
132: EPR "%s: can't malloc %d bytes for -f %s\n", progname, size, fin);
133: exit(2);
134: }
135: p = base+size/2;
136: left = size/2;
137: }
138: }
139: if(n < 0){
140: perror(fin);
141: exit(2);
142: }
143: close(fd);
144: if(xflag){
145: *p++ = '$';
146: }
147: *beg = (unsigned char *)base;
148: *end = (unsigned char *)p;
149: }
150:
151: static void
152: gresucc(char *b, char *e)
153: {
154: if(eg_match(globre, (unsigned char*)b, (unsigned char*)(e-1), (unsigned char **)0, (unsigned char **)0))
155: (*succ2fn)(b, e);
156: else
157: (*failfn)(b, e);
158: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.