1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
|
#ifndef PATTERN_H
#define PATTERN_H
#ifdef REGEX_PCRE
// Statically link pcre on Windows
#if defined(TARGET_OS_WINDOWS) || defined(TARGET_OS_DOS)
#define PCRE_STATIC
#endif
#include <pcre.h>
#endif
#ifdef REGEX_POSIX
// Do we still need to include sys/types.h?
#include <sys/types.h>
#include <regex.h>
#endif
// Pattern matching
void *compile_pattern(const char *pattern, bool ignore_case = false);
void free_compiled_pattern(void *cp);
bool pattern_match(void *compiled_pattern, const char *text, int length);
// Globs are always available.
void *compile_glob_pattern(const char *pattern, bool ignore_case = false);
void free_compiled_glob_pattern(void *cp);
bool glob_pattern_match(void *compiled_pattern, const char *text, int length);
typedef void *(*p_compile)(const char *pattern, bool ignore_case);
typedef void (*p_free)(void *cp);
typedef bool (*p_match)(void *compiled_pattern, const char *text, int length);
class base_pattern
{
public:
virtual ~base_pattern() { }
virtual bool valid() const = 0;
virtual bool matches(const std::string &s) const = 0;
};
template <p_compile pcomp, p_free pfree, p_match pmatch>
class basic_text_pattern : public base_pattern
{
public:
basic_text_pattern(const std::string &s, bool icase = false)
: pattern(s), compiled_pattern(NULL),
isvalid(true), ignore_case(icase)
{
}
basic_text_pattern()
: pattern(), compiled_pattern(NULL),
isvalid(false), ignore_case(false)
{
}
basic_text_pattern(const basic_text_pattern &tp)
: base_pattern(tp),
pattern(tp.pattern),
compiled_pattern(NULL),
isvalid(tp.isvalid),
ignore_case(tp.ignore_case)
{
}
~basic_text_pattern()
{
if (compiled_pattern)
pfree(compiled_pattern);
}
const basic_text_pattern &operator= (const basic_text_pattern &tp)
{
if (this == &tp)
return tp;
if (compiled_pattern)
pfree(compiled_pattern);
pattern = tp.pattern;
compiled_pattern = NULL;
isvalid = tp.isvalid;
ignore_case = tp.ignore_case;
return *this;
}
const basic_text_pattern &operator= (const std::string &spattern)
{
if (pattern == spattern)
return *this;
if (compiled_pattern)
pfree(compiled_pattern);
pattern = spattern;
compiled_pattern = NULL;
isvalid = true;
// We don't change ignore_case
return *this;
}
bool compile() const
{
return !empty()?
!!(compiled_pattern = pcomp(pattern.c_str(), ignore_case))
: false;
}
bool empty() const
{
return !pattern.length();
}
bool valid() const
{
return isvalid
&& (compiled_pattern || (isvalid = compile()));
}
bool matches(const char *s, int length) const
{
return valid() && pmatch(compiled_pattern, s, length);
}
bool matches(const char *s) const
{
return matches(std::string(s));
}
bool matches(const std::string &s) const
{
return matches(s.c_str(), s.length());
}
const std::string &tostring() const
{
return pattern;
}
private:
std::string pattern;
mutable void *compiled_pattern;
mutable bool isvalid;
bool ignore_case;
};
typedef
basic_text_pattern<compile_pattern,
free_compiled_pattern, pattern_match> text_pattern;
typedef
basic_text_pattern<compile_glob_pattern,
free_compiled_glob_pattern,
glob_pattern_match> glob_pattern;
#endif
|
