← Back to branch summary

~ubuntu-branches/ubuntu/dapper/agrep/dapper

« back to all changes in this revision

Viewing changes to parse.c

  • 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
http://bugs.debian.org/344909
Added patch to fix FTBS on amd64 (Closes: #344909).

Show diffs side-by-side

added added

removed removed

Lines of Context:
parse.c
 
1
/* Copyright (c) 1994 Sun Wu, Udi Manber, Burra Gopal.  All Rights Reserved. */
1
2
/* the functions in this file parse a string that represents
2
3
   a regular expression, and return a pointer to a syntax
3
4
   tree for that regular expression.                            */
18
19
extern int Size();
19
20
extern Pset pset_union();
20
21
extern Pset create_pos();
 
22
extern void free_re();
21
23
 
22
24
int final_pos, pos_cnt = 0;
23
25
 
37
39
char ch;
38
40
Ch_Set cset;
39
41
{
40
 
    Re_node node; Re_Lit l;
 
42
        Re_node node; 
 
43
        Re_Lit l;
41
44
 
42
 
    l = (Re_Lit) new_node(l);
43
 
    node = (Re_node) new_node(node);
44
 
    if (l == NULL || node == NULL) return NULL;
45
 
    lit_type(l) = type;
46
 
    lit_pos(l)  = pos_cnt++;
47
 
    if (type == C_SET) lit_cset(l) = cset;
48
 
    else lit_char(l) = ch;                      /* type == C_LIT */
49
 
    Op(node) = opval;
50
 
    Lit(node) = l;
51
 
    Nullable(node) = FALSE;
52
 
    Firstpos(node) = create_pos(lit_pos(l));
53
 
    Lastpos(node) = Firstpos(node);
54
 
    return node;
 
45
        new_node(Re_Lit, l, l);
 
46
        new_node(Re_node, node, node);
 
47
        if (l == NULL || node == NULL) {
 
48
                if (l != NULL) free(l);
 
49
                if (node != NULL) free(node);
 
50
                return NULL;
 
51
        }
 
52
        lit_type(l) = type;
 
53
        lit_pos(l)  = pos_cnt++;
 
54
        if (type == C_SET) lit_cset(l) = cset;
 
55
        else lit_char(l) = ch;                  /* type == C_LIT */
 
56
        Op(node) = opval;
 
57
        Lit(node) = l;
 
58
        Nullable(node) = FALSE;
 
59
        Firstpos(node) = create_pos(lit_pos(l));
 
60
        Lastpos(node) = Firstpos(node);
 
61
        return node;
55
62
}
56
63
 
57
64
/* parse_cset() takes a pointer to a pointer to a string and parses
61
68
Re_node parse_cset(s)
62
69
char **s;
63
70
{
64
 
    Ch_Set cs_ptr, curr_ptr, prev_ptr;
65
 
    char ch;
66
 
    Ch_Range range;
 
71
        Ch_Set cs_ptr, curr_ptr, prev_ptr;
 
72
        char ch;
 
73
        Ch_Range range = NULL;
67
74
 
68
 
    if (Unexpected(s, ']')) return NULL;
69
 
    curr_ptr = (Ch_Set) new_node(curr_ptr); cs_ptr = curr_ptr;
70
 
    while (!Unexpected(s, ']')) {
71
 
        range = (Ch_Range)new_node(range);
72
 
        curr_ptr->elt = range;
73
 
        ch = NextChar(s);
74
 
        if (ch == '-') return NULL;     /* invalid range */
75
 
        range->low_bd = ch;
76
 
        if (**s == NUL) return NULL;
77
 
        else if (**s == '-') {          /* character range */
78
 
            (*s)++;
79
 
            if (Invalid_range(**s, ch)) return NULL;
80
 
            else range->hi_bd = NextChar(s);
81
 
        }
82
 
        else range->hi_bd = ch;
83
 
        prev_ptr = curr_ptr;
84
 
        curr_ptr = (Ch_Set) new_node(curr_ptr);
85
 
        prev_ptr->rest = curr_ptr;
86
 
    };
87
 
    if (**s == ']') {
88
 
        prev_ptr->rest = NULL;
89
 
        return mk_leaf(LITERAL, C_SET, NUL, cs_ptr);
90
 
    }
91
 
    else return NULL;
 
75
        if (Unexpected(s, ']')) return NULL;
 
76
        new_node(Ch_Set, curr_ptr, curr_ptr); 
 
77
        cs_ptr = curr_ptr;
 
78
        while (!Unexpected(s, ']')) {
 
79
                new_node(Ch_Range, range, range);
 
80
                curr_ptr->elt = range;
 
81
                ch = NextChar(s);
 
82
                if (ch == '-') {
 
83
                        free(range);
 
84
                        free(curr_ptr);
 
85
                        return NULL;    /* invalid range */
 
86
                }
 
87
                range->low_bd = ch;
 
88
                if (**s == NUL) {
 
89
                        free(range);
 
90
                        free(curr_ptr);
 
91
                        return NULL;
 
92
                }
 
93
                else if (**s == '-') {          /* character range */
 
94
                        (*s)++;
 
95
                        if (Invalid_range(**s, ch)) {
 
96
                                free(range);
 
97
                                free(curr_ptr);
 
98
                                return NULL;
 
99
                        }
 
100
                        else range->hi_bd = NextChar(s);
 
101
                }
 
102
                else range->hi_bd = ch;
 
103
                prev_ptr = curr_ptr;
 
104
                new_node(Ch_Set, curr_ptr, curr_ptr);
 
105
                prev_ptr->rest = curr_ptr;
 
106
        };
 
107
        if (**s == ']') {
 
108
                prev_ptr->rest = NULL;
 
109
                return mk_leaf(LITERAL, C_SET, NUL, cs_ptr);
 
110
        }
 
111
        else {
 
112
                if (range != NULL) free(range);
 
113
                free(curr_ptr);
 
114
                return NULL;
 
115
        }
92
116
} /* parse_cset */
93
117
 
94
118
 
98
122
 
99
123
Re_node parse_wildcard()
100
124
{
101
 
    Ch_Set s; Ch_Range r;
 
125
        Ch_Set s; 
 
126
        Ch_Range r;
102
127
 
103
 
    r = (Ch_Range) new_node(r);
104
 
    r->low_bd = ASCII_MIN;      /* smallest ASCII value */
105
 
    r->hi_bd  = ASCII_MAX;      /* greatest ASCII value */
106
 
    s = (Ch_Set) new_node(s);
107
 
    s->elt = r;
108
 
    s->rest = NULL;
109
 
    return mk_leaf(LITERAL, C_SET, NUL, s);
 
128
        new_node(Ch_Range, r, r);
 
129
        r->low_bd = ASCII_MIN;  /* smallest ASCII value */
 
130
        r->hi_bd  = ASCII_MAX;  /* greatest ASCII value */
 
131
        new_node(Ch_Set, s, s);
 
132
        s->elt = r;
 
133
        s->rest = NULL;
 
134
        return mk_leaf(LITERAL, C_SET, NUL, s);
110
135
}
111
136
 
112
137
/* parse_chlit() parses a character literal.  It is assumed that the
116
141
Re_node parse_chlit(ch)
117
142
char ch;
118
143
{
119
 
    if (ch == NUL) return NULL;
120
 
    else return mk_leaf(LITERAL, C_LIT, ch, NULL);
 
144
        if (ch == NUL) return NULL;
 
145
        else return mk_leaf(LITERAL, C_LIT, ch, NULL);
121
146
}
122
147
 
 
148
/* routine to free the malloced token */
 
149
void free_tok(next_token)
 
150
Tok_node next_token;
 
151
{
 
152
        if (next_token == NULL) return;
 
153
        switch (tok_type(next_token)) {
 
154
        case LITERAL:
 
155
                free_re(tok_val(next_token));
 
156
        case EOS:
 
157
        case RPAREN:
 
158
        case LPAREN:
 
159
        case OPSTAR:
 
160
        case OPALT:
 
161
        case OPOPT:
 
162
        default:
 
163
                free(next_token);
 
164
                break;
 
165
        }
 
166
}
123
167
 
124
168
/* get_token() returns the next token -- this may be a character
125
169
   literal, a character set, an escaped character, a punctuation (i.e.
131
175
Tok_node get_token(s)
132
176
char **s;
133
177
{
134
 
    Tok_node rn = NULL;
 
178
        Tok_node rn = NULL;
135
179
 
136
 
    if (s == NULL || *s == NULL) return NULL;   /* error */
137
 
    rn = (Tok_node) new_node(rn);
138
 
    if (**s == NUL) tok_type(rn) = EOS; /* end of string */
139
 
    else {
140
 
        switch (**s) {
141
 
            case '.':                   /* wildcard */
142
 
                tok_type(rn) = LITERAL;
143
 
                tok_val(rn) =  parse_wildcard();
144
 
                if (tok_val(rn) == NULL) return NULL;
145
 
                break;
146
 
            case '[':                   /* character set literal */
147
 
                (*s)++;
148
 
                tok_type(rn) = LITERAL;
149
 
                tok_val(rn) = parse_cset(s);
150
 
                if (tok_val(rn) == NULL) return NULL;
151
 
                break;
152
 
            case '(':
153
 
                tok_type(rn) = LPAREN;
154
 
                break;
155
 
            case ')' : 
156
 
                tok_type(rn) = RPAREN;
157
 
                break;
158
 
            case '*' :
159
 
                tok_type(rn) = OPSTAR;
160
 
                break;
161
 
            case '|' :
162
 
                tok_type(rn) = OPALT;
163
 
                break;
164
 
            case '?' : 
165
 
                tok_type(rn) = OPOPT;
166
 
                break;
167
 
            case '\\':                  /* escaped character */
168
 
                (*s)++;
169
 
            default :                   /* must be ordinary character */
170
 
                tok_type(rn) = LITERAL;
171
 
                tok_val(rn) = parse_chlit(**s);
172
 
                if (tok_val(rn) == NULL) return NULL;
173
 
                break;
174
 
        } /* switch (**s) */
175
 
        (*s)++;
176
 
    } /* else */
177
 
    return rn;
 
180
        if (s == NULL || *s == NULL) return NULL;       /* error */
 
181
        new_node(Tok_node, rn, rn);
 
182
        if (**s == NUL) tok_type(rn) = EOS; /* end of string */
 
183
        else {
 
184
                switch (**s) {
 
185
                case '.':                       /* wildcard */
 
186
                        tok_type(rn) = LITERAL;
 
187
                        tok_val(rn) =  parse_wildcard();
 
188
                        if (tok_val(rn) == NULL) {
 
189
                                free_tok(rn);
 
190
                                return NULL;
 
191
                        }
 
192
                        break;
 
193
                case '[':                       /* character set literal */
 
194
                        (*s)++;
 
195
                        tok_type(rn) = LITERAL;
 
196
                        tok_val(rn) = parse_cset(s);
 
197
                        if (tok_val(rn) == NULL) {
 
198
                                free_tok(rn);
 
199
                                return NULL;
 
200
                        }
 
201
                        break;
 
202
                case '(':
 
203
                        tok_type(rn) = LPAREN;
 
204
                        break;
 
205
                case ')' : 
 
206
                        tok_type(rn) = RPAREN;
 
207
                        break;
 
208
                case '*' :
 
209
                        tok_type(rn) = OPSTAR;
 
210
                        break;
 
211
                case '|' :
 
212
                        tok_type(rn) = OPALT;
 
213
                        break;
 
214
                case '?' : 
 
215
                        tok_type(rn) = OPOPT;
 
216
                        break;
 
217
                case '\\':                      /* escaped character */
 
218
                        (*s)++;
 
219
                default :                       /* must be ordinary character */
 
220
                        tok_type(rn) = LITERAL;
 
221
                        tok_val(rn) = parse_chlit(**s);
 
222
                        if (tok_val(rn) == NULL) {
 
223
                                free_tok(rn);
 
224
                                return NULL;
 
225
                        }
 
226
                        break;
 
227
                } /* switch (**s) */
 
228
                (*s)++;
 
229
        } /* else */
 
230
        return rn;
178
231
}
179
232
 
180
233
/* cat2() takes a stack of RE-nodes and, if the stack contains
185
238
Stack cat2(stk)
186
239
Stack *stk;
187
240
{
188
 
    Re_node r;
 
241
        Re_node r;
189
242
 
190
 
    if (stk == NULL) return NULL;
191
 
    if (*stk == NULL || (*stk)->next == NULL) return *stk;
192
 
    r = (Re_node) new_node(r);
193
 
    if (r == NULL) return NULL;     /* can't allocate memory */
194
 
    Op(r) = OPCAT;
195
 
    Rchild(r) = Pop(stk);
196
 
    Lchild(r) = Pop(stk);
197
 
    if (Push(stk, r) == NULL) return NULL;
198
 
    Nullable(r) = Nullable(Lchild(r)) && Nullable(Rchild(r));
199
 
    if (Nullable(Lchild(r)))
200
 
        Firstpos(r) = pset_union(Firstpos(Lchild(r)), Firstpos(Rchild(r)));
201
 
    else Firstpos(r) = Firstpos(Lchild(r));
202
 
    if (Nullable(Rchild(r)))
203
 
        Lastpos(r) = pset_union(Lastpos(Lchild(r)), Lastpos(Rchild(r)));
204
 
    else Lastpos(r) = Lastpos(Rchild(r));
205
 
    return *stk;
 
243
        if (stk == NULL) return NULL;
 
244
        if (*stk == NULL || (*stk)->next == NULL) return *stk;
 
245
        new_node(Re_node, r, r);
 
246
        if (r == NULL) return NULL;         /* can't allocate memory */
 
247
        Op(r) = OPCAT;
 
248
        Rchild(r) = Pop(stk);
 
249
        Lchild(r) = Pop(stk);
 
250
        if (Push(stk, r) == NULL) {
 
251
                free_re(Rchild(r));
 
252
                free_re(Lchild(r));
 
253
                free(r);
 
254
                return NULL;
 
255
        }
 
256
        Nullable(r) = Nullable(Lchild(r)) && Nullable(Rchild(r));
 
257
        if (Nullable(Lchild(r)))
 
258
                Firstpos(r) = pset_union(Firstpos(Lchild(r)), Firstpos(Rchild(r)), 0);
 
259
        else Firstpos(r) = pset_union(Firstpos(Lchild(r)), NULL, 0);    /* added pset_union with NULL 26/Aug/1996 */
 
260
        if (Nullable(Rchild(r)))
 
261
                Lastpos(r) = pset_union(Lastpos(Lchild(r)), Lastpos(Rchild(r)), 0);
 
262
        else Lastpos(r) = pset_union(Lastpos(Rchild(r)), NULL, 0);      /* added pset_union with NULL 26/Aug/1996 */
 
263
        return *stk;
206
264
}
207
265
 
208
266
/* wrap() takes a stack and an operator, takes the top element of the
213
271
Stack *s;
214
272
short opv;
215
273
{
216
 
    Re_node r;
 
274
        Re_node r;
217
275
 
218
 
    if (s == NULL || *s == NULL) return NULL;
219
 
    r = (Re_node) new_node(r);
220
 
    if (r == NULL) return NULL;
221
 
    Op(r) = opv;
222
 
    Child(r) = Pop(s);
223
 
    if (Push(s, r) == NULL) return NULL;
224
 
    Nullable(r) = TRUE;
225
 
    Firstpos(r) = Firstpos(Child(r));
226
 
    Lastpos(r)  = Lastpos(Child(r));
227
 
    return *s;
 
276
        if (s == NULL || *s == NULL) return NULL;
 
277
        new_node(Re_node, r, r);
 
278
        if (r == NULL) return NULL;
 
279
        Op(r) = opv;
 
280
        Child(r) = Pop(s);
 
281
        if (Push(s, r) == NULL) {
 
282
                free_re(Child(r));
 
283
                free(r);
 
284
                return NULL;
 
285
        }
 
286
        Nullable(r) = TRUE;
 
287
        Firstpos(r) = pset_union(Firstpos(Child(r)), NULL, 0);  /* added pset_union with NULL 26/Aug/1996 */
 
288
        Lastpos(r)  = pset_union(Lastpos(Child(r)), NULL, 0);   /* added pset_union with NULL 26/Aug/1996 */
 
289
        return *s;
228
290
}
229
291
 
230
292
/* mk_alt() takes a stack and a regular expression, creates an ALT-node
235
297
Stack *s;
236
298
Re_node r;
237
299
{
238
 
    Re_node node;
 
300
        Re_node node;
239
301
 
240
 
    if (s == NULL || *s == NULL || r == NULL) return NULL;
241
 
    node = (Re_node) new_node(node);
242
 
    if (node == NULL) return NULL;
243
 
    Op(node) = OPALT;
244
 
    Lchild(node) = Pop(s);
245
 
    Rchild(node) = r;
246
 
    if (Push(s, node) == NULL) return NULL;
247
 
    Nullable(node) = Nullable(Lchild(node)) || Nullable(Rchild(node));
248
 
    Firstpos(node) = pset_union(Firstpos(Lchild(node)), Firstpos(Rchild(node)));
249
 
    Lastpos(node) = pset_union(Lastpos(Lchild(node)), Lastpos(Rchild(node)));
250
 
    return *s;
 
302
        if (s == NULL || *s == NULL || r == NULL) return NULL;
 
303
        new_node(Re_node, node, node);
 
304
        if (node == NULL) return NULL;
 
305
        Op(node) = OPALT;
 
306
        Lchild(node) = Pop(s);
 
307
        Rchild(node) = r;
 
308
        if (Push(s, node) == NULL) return NULL;
 
309
        Nullable(node) = Nullable(Lchild(node)) || Nullable(Rchild(node));
 
310
        Firstpos(node) = pset_union(Firstpos(Lchild(node)), Firstpos(Rchild(node)), 0);
 
311
        Lastpos(node) = pset_union(Lastpos(Lchild(node)), Lastpos(Rchild(node)), 0);
 
312
        return *s;
251
313
}
252
314
 
253
315
/* parse_re() takes a pointer to a string and traverses that string,
258
320
char **s;
259
321
short end;
260
322
{
261
 
    Stack stk = NULL, temp;
262
 
    Tok_node next_token;
263
 
    Re_node re = NULL;
 
323
        Stack stk = NULL, ret = NULL, top, temp;
 
324
        Tok_node next_token, t1;
 
325
        Re_node re = NULL, val;
264
326
 
265
 
    if (s == NULL || *s == NULL) return NULL;
266
 
    while (TRUE) {
267
 
        next_token = get_token(s);
268
 
        if (next_token == NULL) return NULL;
269
 
        switch (tok_type(next_token)) {
270
 
            case RPAREN:
271
 
                retract_token(s);
272
 
            case EOS:
273
 
                if (end == tok_type(next_token)) return Top(cat2(&stk));
274
 
                else return NULL;
275
 
            case LPAREN:
276
 
                re = parse_re(s, RPAREN);
277
 
                if (Push(&stk, re) == NULL) return NULL;
278
 
                if (tok_type(get_token(s)) != RPAREN || re == NULL) return NULL;
279
 
                if (Size(stk) > 2) {
280
 
                    temp = stk->next;
281
 
                    stk->next = cat2(&temp);    /* condense CAT nodes */
282
 
                    if (stk->next == NULL) return NULL;
283
 
                    else stk->size = stk->next->size + 1;
284
 
                }
285
 
                break;
286
 
            case OPSTAR:
287
 
                if (wrap(&stk, OPSTAR) == NULL) return NULL;
288
 
                break;
289
 
            case OPOPT:
290
 
                if (wrap(&stk, OPOPT) == NULL) return NULL;
291
 
                break;
292
 
            case OPALT:
293
 
                if (cat2(&stk) == NULL) return NULL;
294
 
                re = parse_re(s, end);
295
 
                if (re == NULL) return NULL;
296
 
                if (mk_alt(&stk, re) == NULL) return NULL;
297
 
                break;
298
 
            case LITERAL:
299
 
                if (Push(&stk, tok_val(next_token)) == NULL) return NULL;
300
 
                if (Size(stk) > 2) {
301
 
                    temp = stk->next;
302
 
                    stk->next = cat2(&temp);    /* condense CAT nodes */
303
 
                    if (stk->next == NULL) return NULL;
304
 
                    else stk->size = stk->next->size + 1;
305
 
                }
306
 
                break;
307
 
            default:
308
 
                printf("parse_re: unknown token type %d\n", tok_type(next_token));
309
 
                break;
 
327
        if (s == NULL || *s == NULL) return NULL;
 
328
        while (TRUE) {
 
329
                ret = NULL;
 
330
                if ((next_token = get_token(s)) == NULL) return NULL;
 
331
                switch (tok_type(next_token)) {
 
332
                case RPAREN:
 
333
                        retract_token(s);
 
334
                case EOS:
 
335
                        if (end == tok_type(next_token)) {
 
336
                                free_tok(next_token);
 
337
                                top = cat2(&stk);
 
338
                                val = Top(top);
 
339
                                free(top);
 
340
                                return val;
 
341
                        }
 
342
                        else {
 
343
                                free_tok(next_token);
 
344
                                return NULL;
 
345
                        }
 
346
                case LPAREN:
 
347
                        free_tok(next_token);
 
348
                        re = parse_re(s, RPAREN);
 
349
                        if ((ret = Push(&stk, re)) == NULL) {
 
350
                                free_re(re);    /* ZZZZZZZZZZZZZZZZZZ */
 
351
                                return NULL;
 
352
                        }
 
353
                        if ((t1 = get_token(s)) == NULL) {
 
354
                                free_re(re);    /* ZZZZZZZZZZZZZZZZZZ */
 
355
                                free(ret);
 
356
                                return NULL;
 
357
                        }
 
358
                        if ((tok_type(t1) != RPAREN) || (re == NULL)) {
 
359
                                free_re(re);    /* ZZZZZZZZZZZZZZZZZZ */
 
360
                                free(ret);
 
361
                                free_tok(t1);
 
362
                                return NULL;
 
363
                        }
 
364
                        free_tok(t1);
 
365
                        if (Size(stk) > 2) {
 
366
                                temp = stk->next;
 
367
                                stk->next = cat2(&temp);        /* condense CAT nodes */
 
368
                                if (stk->next == NULL) {
 
369
                                        free_re(re);    /* ZZZZZZZZZZZZZZZZZZ */
 
370
                                        free(ret);
 
371
                                        return NULL;
 
372
                                }
 
373
                                else stk->size = stk->next->size + 1;
 
374
                        }
 
375
                        break;
 
376
                case OPSTAR:
 
377
                        if ((ret = wrap(&stk, OPSTAR)) == NULL) {
 
378
                                free_tok(next_token);
 
379
                                return NULL;
 
380
                        }
 
381
                        free_tok(next_token);   /* ZZZZZZZZZZZZZZZZZZ */
 
382
                        break;
 
383
                case OPOPT:
 
384
                        if ((ret = wrap(&stk, OPOPT)) == NULL) {
 
385
                                free_tok(next_token);
 
386
                                return NULL;
 
387
                        }
 
388
                        free_tok(next_token);   /* ZZZZZZZZZZZZZZZZZZ */
 
389
                        break;
 
390
                case OPALT:
 
391
                        if ((ret = cat2(&stk)) == NULL) {
 
392
                                free_tok(next_token);
 
393
                                return NULL;
 
394
                        }
 
395
                        re = parse_re(s, end);
 
396
                        if (re == NULL) {
 
397
                                free(ret);
 
398
                                free_tok(next_token);
 
399
                                return NULL;
 
400
                        }
 
401
                        if (mk_alt(&stk, re) == NULL) {
 
402
                                free(ret);
 
403
                                free_tok(next_token);
 
404
                                return NULL;
 
405
                        }
 
406
                        free_tok(next_token);   /* ZZZZZZZZZZZZZZZZZZ */
 
407
                        break;
 
408
                case LITERAL:
 
409
                        if ((ret = Push(&stk, tok_val(next_token))) == NULL) {
 
410
                                free_tok(next_token);
 
411
                                return NULL;
 
412
                        }
 
413
                        free(next_token);
 
414
                        if (Size(stk) > 2) {
 
415
                                temp = stk->next;
 
416
                                stk->next = cat2(&temp);    /* condense CAT nodes */
 
417
                                if (stk->next == NULL) {
 
418
                                        free(ret);
 
419
                                        return NULL;
 
420
                                }
 
421
                                else stk->size = stk->next->size + 1;
 
422
                        }
 
423
                        break;
 
424
                default:
 
425
                        printf("parse_re: unknown token type %d\n", tok_type(next_token));
 
426
                        free_tok(next_token);   /* ZZZZZZZZZZZZZZZZZZ */
 
427
                        break;
 
428
                }
 
429
                /* free_tok(next_token); */
310
430
        }
311
 
    }
312
431
}
313
432
 
314
433
/* parse() essentially just calls parse_re().  Its purpose is to stick an
319
438
Re_node parse(s)
320
439
char *s;
321
440
{
322
 
    Re_node tree, temp;
323
 
    Stack stk = NULL;
 
441
        Re_node val, tree, temp;
 
442
        Stack top, stk = NULL;
324
443
 
325
 
    tree = parse_re(&s, NUL);
326
 
    if (tree == NULL || Push(&stk, tree) == NULL) return NULL;
327
 
    temp = mk_leaf(EOS, C_LIT, NUL, NULL);
328
 
    if (temp == NULL || Push(&stk, temp) == NULL) return NULL;
329
 
    final_pos = --pos_cnt;
330
 
    return Top(cat2(&stk));
 
444
        if ((tree = parse_re(&s, NUL)) == NULL) return NULL;
 
445
        if (Push(&stk, tree) == NULL) return NULL;
 
446
        temp = mk_leaf(EOS, C_LIT, NUL, NULL);
 
447
        if (temp == NULL || Push(&stk, temp) == NULL) return NULL;
 
448
        final_pos = --pos_cnt;
 
449
        top = cat2(&stk);
 
450
        val = Top(top);
 
451
        free(top);
 
452
        return val;
331
453
}
332
454