]> git.saurik.com Git - wxWidgets.git/blob - src/common/glob.inc
Made HelpGen compile here.
[wxWidgets.git] / src / common / glob.inc
1 /*
2 * File and other globbing (included by wb_utils.cc)
3 */
4
5 // This file includes:
6 // wxIsWild(const char *pattern)
7 // wxMatchWild(const char *pattern, const char *str, bool dot_special)
8 //
9
10
11 //---------------------------------------------------------------------------------
12 #ifndef UNIX_GLOB
13 # ifdef wx_x
14 # define UNIX_GLOB 1
15 # else
16 # define UNIX_GLOB 0
17 # endif
18 #endif
19
20 #if UNIX_GLOB
21 # ifdef wx_msw
22 # error "Can't use Unix file globbing under Windows!"
23 # endif
24 #endif
25
26 /*************************************************************************
27 *
28 * wxIsWild checks whether the pattern contains wildcards, and
29 * returns TRUE if it does, and FALSE if it does not (or if the
30 * pattern is NULL -- i.e. no string).
31 *
32 * The argument is:
33 *
34 * 1) pattern - a character string
35 */
36 bool
37 wxIsWild (const char *pattern)
38 {
39 while (*pattern)
40 {
41 switch (*pattern++)
42 {
43 case '?':
44 case '*':
45 #if UNIX_GLOB
46 case '[':
47 case '{': /* } */
48 #endif
49 return TRUE;
50 #if UNIX_GLOB
51 case '\\':
52 if (!*pattern++)
53 return FALSE;
54 #endif
55 } /* switch() */
56 } /* while() */
57 return FALSE;
58 }
59
60
61
62 #if UNIX_GLOB
63
64 // Unix Glob()
65 //
66 // Pattern Function
67 // -----------------------------------------------------
68 // '*' = match 0 or more occurances of anything
69 // "[abc]" = match anyof "abc" (ranges supported)
70 // "{xx,yy,zz}" = match anyof "xx", "yy", or "zz"
71 // '?' = match any character
72 //
73 // '\' is used to "escape" special characters
74 // Recursive
75
76 bool
77 wxMatchWild (const char *pattern, const char *str, bool dot_special)
78 {
79 char c;
80 const char *cp;
81 bool done = FALSE, ret_code, ok;
82 // Below is for vi fans
83 const char OB = '{', CB = '}';
84
85 #if 0
86 if (strcmp(pattern, "*.*") == 0)
87 pattern = "*"; // Hack for MS-DOS compat.
88 #endif
89
90 // dot_special means '.' only matches '.'
91 if (dot_special && *str == '.' && *pattern != *str)
92 return FALSE;
93
94 while ((*pattern != '\0') && (!done) && (((*str == '\0') &&
95 ((*pattern == OB) || (*pattern == '*'))) || (*str != '\0')))
96 {
97 switch (*pattern)
98 {
99 case '\\':
100 pattern++;
101 if (*pattern != '\0')
102 pattern++;
103 break;
104 case '*':
105 pattern++;
106 ret_code = FALSE;
107 while ((*str != '\0') && (!(ret_code = wxMatchWild (pattern, str++, FALSE))));
108 if (ret_code)
109 {
110 while (*str != '\0')
111 str++;
112 while (*pattern != '\0')
113 pattern++;
114 }
115 break;
116 case '[':
117 pattern++;
118 repeat:
119 if ((*pattern == '\0') || (*pattern == ']'))
120 {
121 done = TRUE;
122 break;
123 }
124 if (*pattern == '\\')
125 {
126 pattern++;
127 if (*pattern == '\0')
128 {
129 done = TRUE;
130 break;
131 }
132 }
133 if (*(pattern + 1) == '-')
134 {
135 c = *pattern;
136 pattern += 2;
137 if (*pattern == ']')
138 {
139 done = TRUE;
140 break;
141 }
142 if (*pattern == '\\')
143 {
144 pattern++;
145 if (*pattern == '\0')
146 {
147 done = TRUE;
148 break;
149 }
150 }
151 if ((*str < c) || (*str > *pattern))
152 {
153 pattern++;
154 goto repeat;
155 }
156 }
157 else if (*pattern != *str)
158 {
159 pattern++;
160 goto repeat;
161 }
162 pattern++;
163 while ((*pattern != ']') && (*pattern != '\0'))
164 {
165 if ((*pattern == '\\') && (*(pattern + 1) != '\0'))
166 pattern++;
167 pattern++;
168 } // while()
169 if (*pattern != '\0')
170 {
171 pattern++, str++;
172 }
173 break;
174 case '?':
175 pattern++;
176 str++;
177 break;
178 case OB:
179 pattern++;
180 while ((*pattern != CB) && (*pattern != '\0'))
181 {
182 cp = str;
183 ok = TRUE;
184 while (ok && (*cp != '\0') && (*pattern != '\0') &&
185 (*pattern != ',') && (*pattern != CB))
186 {
187 if (*pattern == '\\')
188 pattern++;
189 ok = (*pattern++ == *cp++);
190 } // while()
191 if (*pattern == '\0')
192 {
193 ok = FALSE;
194 done = TRUE;
195 break;
196 }
197 else if (ok)
198 {
199 str = cp;
200 while ((*pattern != CB) && (*pattern != '\0'))
201 {
202 if (*++pattern == '\\')
203 {
204 if (*++pattern == CB)
205 pattern++;
206 }
207 } // while()
208 }
209 else
210 {
211 while (*pattern != CB && *pattern != ',' && *pattern != '\0')
212 {
213 if (*++pattern == '\\')
214 {
215 if (*++pattern == CB || *pattern == ',')
216 pattern++;
217 }
218 } // while()
219 }
220 if (*pattern != '\0')
221 pattern++;
222 } // while()
223 break;
224 default:
225 if (*str == *pattern)
226 {
227 str++, pattern++;
228 }
229 else
230 {
231 done = TRUE;
232 }
233 } // switch()
234 } // while()
235 while (*pattern == '*')
236 pattern++;
237 return ((*str == '\0') && (*pattern == '\0'));
238 }
239
240 #else /* MS-DOS/Windows glob() */
241 /*************************************************************************
242 *
243 * wxMatchWild matches the given pattern string against
244 * a text string, and returns TRUE if it matches, FALSE otherwise.
245 *
246 * A match means that the entire text string is used up in the matching.
247 * The pattern can contain the following wildcards.
248 *
249 * * -- matches any sequence of characters
250 * ? -- matches one character
251 *
252 * If one or other or both of the string arguments to wxMatchWild function is
253 * NULL (i.e. there isn't a string), then the function returns FALSE.
254 *
255 */
256 static bool wxPatternMatch (const char *pattern, const char *text, size_t i, size_t j);
257
258 // @@@@ dotSpecial is ignored by MS-DOS
259 bool
260 wxMatchWild (const char *pattern, const char *text, bool /* dotSpecial */ )
261 {
262 if (pattern == NULL || text == NULL || *pattern == '\0' || *text == '\0')
263 return FALSE;
264 return wxPatternMatch (pattern, text, 0, 0);
265 }
266
267 /*************************************************************************
268 *
269 * wxPatternMatch does the work for wxMatchWild. wxPatternMatch matches
270 * the given pattern string against a text string, and returns TRUE if
271 * it matches, FALSE otherwise. It is assumed that the string arguments
272 * to wxPatternMatch exist.
273 *
274 * A match means that the entire text string is used up in the matching.
275 * The pattern can contain the following wildcards.
276 *
277 * * -- matches any sequence of characters
278 * ? -- matches one character
279 *
280 * wxPatternMatch works by going down the pattern trying to match the
281 * the same index character in the pattern and string arrays, and stops
282 * when the end of the pattern or text string is reached. However, if a
283 * '*' wildcard is met, the algorithm checks to see whether the remaining
284 * pattern (after the wildcard) matches the rest of the text (i.e. the
285 * wxPatternMatch function is called recursively).
286 */
287 // Recursive
288 static bool
289 wxPatternMatch (const char *pattern, const char *text, size_t i, size_t j)
290 {
291 size_t pattern_length = strlen (pattern);
292 size_t text_length = strlen (text);
293 bool match = FALSE;
294
295 #ifdef wx_msw
296 // MS-DOS file system is case INDEPENDENT
297 # define EQU(x,y) (wxToLower(x) == wxToLower(y))
298 #else
299 # define EQU(x,y) ((x) == (y))
300 #endif
301
302 while (j < pattern_length && i < text_length)
303 {
304 if (EQU(text[i], pattern[j]) || pattern[j] == '?')
305 {
306 match = TRUE;
307 i++, j++;
308 }
309 else if (pattern[j] == '*')
310 {
311 // If pattern ends in '*'
312 if (++j == pattern_length)
313 {
314 match = TRUE;
315 i = text_length;
316 }
317 else
318 {
319 match = FALSE;
320 // after wildcard check to see whether rest of pattern matches
321 // up with rest of text
322 while (i < text_length && match != TRUE)
323 {
324 match = wxPatternMatch (pattern, text, i, j);
325 i++;
326 }
327 // text index is decremented so that it points to where
328 // the text string starts to match the rest of the pattern
329 i--;
330 }
331 }
332 else if (! EQU(text[i], pattern[j]))
333 {
334 j = pattern_length;
335 match = FALSE;
336 }
337 }
338 if (j == pattern_length && i == text_length && match == TRUE)
339 {
340 return TRUE;
341 }
342 else
343 // special case where pattern and text are the same except that pattern
344 // also only has '*' wildcards on the end
345 if (i == text_length && pattern[j] == '*' && match == TRUE)
346 {
347 for (; j < pattern_length; j++)
348 {
349 if (pattern[j] != '*')
350 return FALSE;
351 }
352 return TRUE;
353 }
354 else
355 {
356 return FALSE;
357 }
358 }
359
360 #endif /* UNIX_GLOB */
361 //-----------------------------------------------------------------------------