← Back to branch summary

~vcs-imports/gawk/master

« back to all changes in this revision

Viewing changes to re.c

  • Committer: Arnold D. Robbins
  • Date: 2010-07-16 08:58:26 UTC
  • Revision ID: git-v1:765c7494b3dac62207e6cd57fb839997e237f292
Moving to 2.13.2.

Show diffs side-by-side

added added

removed removed

Lines of Context:
re.c
 
1
/*
 
2
 * re.c - compile regular expressions.
 
3
 */
 
4
 
 
5
/* 
 
6
 * Copyright (C) 1991 the Free Software Foundation, Inc.
 
7
 * 
 
8
 * This file is part of GAWK, the GNU implementation of the
 
9
 * AWK Progamming Language.
 
10
 * 
 
11
 * GAWK is free software; you can redistribute it and/or modify
 
12
 * it under the terms of the GNU General Public License as published by
 
13
 * the Free Software Foundation; either version 1, or (at your option)
 
14
 * any later version.
 
15
 * 
 
16
 * GAWK is distributed in the hope that it will be useful,
 
17
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
18
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
19
 * GNU General Public License for more details.
 
20
 * 
 
21
 * You should have received a copy of the GNU General Public License
 
22
 * along with GAWK; see the file COPYING.  If not, write to
 
23
 * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
 
24
 */
 
25
 
 
26
#include "awk.h"
 
27
 
 
28
/* Generate compiled regular expressions */
 
29
Regexp *
 
30
make_regexp(s, ignorecase, dfa)
 
31
NODE *s;
 
32
int ignorecase;
 
33
int dfa;
 
34
{
 
35
        Regexp *rp;
 
36
        char *err;
 
37
 
 
38
        emalloc(rp, Regexp *, sizeof(*rp), "make_regexp");
 
39
        memset((char *) rp, 0, sizeof(*rp));
 
40
        emalloc(rp->pat.buffer, char *, 16, "make_regexp");
 
41
        rp->pat.allocated = 16;
 
42
        emalloc(rp->pat.fastmap, char *, 256, "make_regexp");
 
43
 
 
44
        if (ignorecase)
 
45
                rp->pat.translate = casetable;
 
46
        else
 
47
                rp->pat.translate = NULL;
 
48
        if ((err = re_compile_pattern(s->stptr, (size_t) s->stlen, &(rp->pat))) != NULL)
 
49
                fatal("%s: /%s/", err, s->stptr);
 
50
        if (dfa && !ignorecase) {
 
51
                regcompile(s->stptr, s->stlen, &(rp->dfareg), 1);
 
52
                rp->dfa = 1;
 
53
        } else
 
54
                rp->dfa = 0;
 
55
        free_temp(s);
 
56
        return rp;
 
57
}
 
58
 
 
59
int
 
60
research(rp, str, len, need_start)
 
61
Regexp *rp;
 
62
register char *str;
 
63
register int len;
 
64
int need_start;
 
65
{
 
66
        int count;
 
67
        int try_backref;
 
68
        char save1;
 
69
        char save2;
 
70
        char *ret = &save2;
 
71
 
 
72
        if (rp->dfa) {
 
73
                save1 = str[len];
 
74
                str[len] = '\n';
 
75
                save2 = str[len+1];
 
76
                ret = regexecute(&(rp->dfareg), str, str+len+1, 0, &count,
 
77
                                        &try_backref);
 
78
                str[len] = save1;
 
79
                str[len+1] = save2;
 
80
        }
 
81
        if (ret) {
 
82
                if (need_start || rp->dfa == 0)
 
83
                        return re_search(&(rp->pat), str, len, 0, len, &(rp->regs));
 
84
                else
 
85
                        return 1;
 
86
         } else
 
87
                return -1;
 
88
}
 
89
 
 
90
void
 
91
refree(rp)
 
92
Regexp *rp;
 
93
{
 
94
        free(rp->pat.buffer);
 
95
        free(rp->pat.fastmap);
 
96
        if (rp->dfa)
 
97
                regfree(&(rp->dfareg));
 
98
        free(rp);
 
99
}
 
100
 
 
101
void
 
102
regerror(s)
 
103
const char *s;
 
104
{
 
105
        fatal(s);
 
106
}
 
107
 
 
108
Regexp *
 
109
re_update(t)
 
110
NODE *t;
 
111
{
 
112
        NODE *t1;
 
113
 
 
114
#       define  CASE    1
 
115
        if ((t->re_flags & CASE) == IGNORECASE) {
 
116
                if (t->re_flags & CONST)
 
117
                        return t->re_reg;
 
118
                t1 = force_string(tree_eval(t->re_exp));
 
119
                if (t->re_text) {
 
120
                        if (cmp_nodes(t->re_text, t1) == 0) {
 
121
                                free_temp(t1);
 
122
                                return t->re_reg;
 
123
                        }
 
124
                        unref(t->re_text);
 
125
                }
 
126
                t->re_text = dupnode(t1);
 
127
                free_temp(t1);
 
128
        }
 
129
        if (t->re_reg)
 
130
                refree(t->re_reg);
 
131
        if (t->re_cnt)
 
132
                t->re_cnt++;
 
133
        if (t->re_cnt > 10)
 
134
                t->re_cnt = 0;
 
135
        if (!t->re_text) {
 
136
                t1 = force_string(tree_eval(t->re_exp));
 
137
                t->re_text = dupnode(t1);
 
138
                free_temp(t1);
 
139
        }
 
140
        t->re_reg = make_regexp(t->re_text, IGNORECASE, t->re_cnt);
 
141
        t->re_flags &= ~CASE;
 
142
        t->re_flags |= IGNORECASE;
 
143
        return t->re_reg;
 
144
}