Update copyright to LGPL on all files
[dyninst.git] / parseThat / src / reglist.C
1 /*
2  * Copyright (c) 1996-2009 Barton P. Miller
3  * 
4  * We provide the Paradyn Parallel Performance Tools (below
5  * described as "Paradyn") on an AS IS basis, and do not warrant its
6  * validity or performance.  We reserve the right to update, modify,
7  * or discontinue this software at any time.  We shall have no
8  * obligation to supply such updates or modifications or any other
9  * form of support to you.
10  * 
11  * By your use of Paradyn, you understand and agree that we (or any
12  * other person or entity with proprietary rights in Paradyn) are
13  * under no obligation to provide either maintenance services,
14  * update services, notices of latent defects, or correction of
15  * defects for Paradyn.
16  * 
17  * This library is free software; you can redistribute it and/or
18  * modify it under the terms of the GNU Lesser General Public
19  * License as published by the Free Software Foundation; either
20  * version 2.1 of the License, or (at your option) any later version.
21  * 
22  * This library is distributed in the hope that it will be useful,
23  * but WITHOUT ANY WARRANTY; without even the implied warranty of
24  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
25  * Lesser General Public License for more details.
26  * 
27  * You should have received a copy of the GNU Lesser General Public
28  * License along with this library; if not, write to the Free Software
29  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
30  */
31 #include "reglist.h"
32
33 #include "log.h"
34 #include "utils.h"
35
36 reglist::~reglist()
37 {
38     vector< regrule_t * >::iterator i;
39
40     for (i = only_rules.begin(); i != only_rules.end(); ++i) {
41         regfree( &((*i)->preg) );
42         delete( *i );
43     }
44
45     for (i = skip_rules.begin(); i != skip_rules.end(); ++i) {
46         regfree( &((*i)->preg) );
47         delete( *i );
48     }
49 }
50
51 bool reglist::insert(const char *pattern, rule_t ruletype, bool show_reason)
52 {
53     regrule_t *newrule = new regrule_t;
54
55     if (!newrule) {
56         dlog(ERR, "Could not allocate memory for regrule_t in reglist::insert().");
57         return false;
58     }
59
60     int retval = regcomp(&newrule->preg, pattern, REG_NOSUB);
61     if (retval) {
62         if (!print_regerror(&newrule->preg, retval))
63             dlog(ERR, "    Error in reglist::print_regerror() from reglist::insert()\n");
64         return false;
65     }
66     newrule->pattern = pattern;
67     newrule->show_reason = show_reason;
68
69     switch (ruletype) {
70     case RULE_ONLY: only_rules.push_back(newrule); break;
71     case RULE_SKIP: skip_rules.push_back(newrule); break;
72     }
73
74     return true;
75 }
76
77 const char *reglist::getReason(char *s)
78 {
79     vector< regrule_t * >::iterator i;
80
81     if (only_rules.size() > 0) {
82         for (i = only_rules.begin(); i != only_rules.end(); ++i) {
83             int retval = regexec(&((*i)->preg), s, 0, NULL, 0);
84
85             if (retval == 0) {
86                 if (!(*i)->show_reason) return NULL;
87                 return sprintf_static("Including '%s' because it matched regular expression '%s'", s, (*i)->pattern);
88             }
89
90             if (retval == REG_ENOSYS) {
91                 dlog(ERR, "Error while executing regular expression in reglist::check(): The function is not supported.\n");
92                 return NULL;
93             }
94         }
95         return false;
96     }
97
98     if (skip_rules.size() > 0) {
99         for (i = skip_rules.begin(); i != skip_rules.end(); ++i) {
100             int retval = regexec(&((*i)->preg), s, 0, NULL, 0);
101
102             if (retval == 0 && (*i)->show_reason) {
103                 if (!(*i)->show_reason) return NULL;
104                 return sprintf_static("Skipping '%s' because it matched regular expression '%s'", s, (*i)->pattern);
105             }
106
107             if (retval == REG_ENOSYS) {
108                 dlog(ERR, "Error while executing regular expression in reglist::check(): The function is not supported.\n");
109                 return NULL;
110             }
111         }
112     }
113     return NULL;
114 }
115
116 bool reglist::isValid(const char *s)
117 {
118     vector< regrule_t * >::iterator i;
119
120     if (only_rules.size() > 0) {
121         for (i = only_rules.begin(); i != only_rules.end(); ++i) {
122             int retval = regexec(&((*i)->preg), s, 0, NULL, 0);
123
124             if (retval == 0) 
125                 return true;
126
127             if (retval == REG_ENOSYS) {
128                 dlog(ERR, "Error while executing regular expression in reglist::check(): The function is not supported.\n");
129                 return false;
130             }
131         }
132         return false;
133     }
134
135     if (skip_rules.size() > 0) {
136         for (i = skip_rules.begin(); i != skip_rules.end(); ++i) {
137             int retval = regexec(&((*i)->preg), s, 0, NULL, 0);
138
139             if (retval == 0)
140                 return false;
141
142             if (retval == REG_ENOSYS) {
143                 dlog(ERR, "Error while executing regular expression in reglist::check(): The function is not supported.\n");
144                 return false;
145             }
146         }
147     }
148     return true;
149 }
150
151 bool reglist::print_regerror(regex_t *preg, int num)
152 {
153     static int len;
154     static char *buf = NULL;
155
156     int maxlen = regerror(num, preg, NULL, 0);
157
158     if (maxlen == 0) {
159         dlog(ERR, "Error while processing regular expression, but regerror() not implemented on this platform.\n");
160         return false;
161
162     } else if (maxlen > len) {
163         char *newbuf = (char *)realloc(buf, maxlen);
164         if (!newbuf) {
165             dlog(ERR, "Could not allocate %d bytes of memory for string in reglist::print_regerror().\n", maxlen);
166             return false;
167         }
168         buf = newbuf;
169         len = maxlen;
170     }
171
172     regerror(num, preg, buf, len);
173     dlog(ERR, "Error processing regular expression: %s\n", buf);
174     return true;
175 }