![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to match.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / b / bin / unzip|
Return to match.c CVS log | Up to [MW Coherent from dump] / coherent / b / bin / unzip |
1.1 root 1: /*---------------------------------------------------------------------------
2:
3: match.c
4:
5: The match() routine recursively compares a string to a "pattern" (regular
6: expression), returning TRUE if a match is found or FALSE if not. This
7: version is specifically for use with unzip.c: as did the previous match()
8: from SEA, it leaves the case (upper, lower, or mixed) of the string alone,
9: but converts any uppercase characters in the pattern to lowercase if indi-
10: cated by the global var pInfo->lcflag (which is to say, string is assumed
11: to have been converted to lowercase already, if such was necessary).
12:
13: ---------------------------------------------------------------------------*/
14:
15:
16: #ifdef ZIPINFO
17: # undef ZIPINFO /* make certain there is only one version of match.o */
18: #endif /* ZIPINFO */
19: #include "unzip.h"
20:
21: static int matche __((register char *p, register char *t));
22: static int matche_after_star __((register char *p, register char *t));
23:
24: /* #include "filmatch.h": */
25: #ifndef BOOLEAN
26: # define BOOLEAN short int /* v1.2 made it short */
27: #endif
28:
29: /* match defines */
30: #define MATCH_PATTERN 6 /* bad pattern */
31: #define MATCH_LITERAL 5 /* match failure on literal match */
32: #define MATCH_RANGE 4 /* match failure on [..] construct */
33: #define MATCH_ABORT 3 /* premature end of text string */
34: #define MATCH_END 2 /* premature end of pattern string */
35: #define MATCH_VALID 1 /* valid match */
36:
37: /* pattern defines */
38: #define PATTERN_VALID 0 /* valid pattern */
39: #define PATTERN_ESC -1 /* literal escape at end of pattern */
40: #define PATTERN_RANGE -2 /* malformed range in [..] construct */
41: #define PATTERN_CLOSE -3 /* no end bracket in [..] construct */
42: #define PATTERN_EMPTY -4 /* [..] contstruct is empty */
43:
44: /*----------------------------------------------------------------------------
45: *
46: * Match the pattern PATTERN against the string TEXT;
47: *
48: * match() returns TRUE if pattern matches, FALSE otherwise.
49: * matche() returns MATCH_VALID if pattern matches, or an errorcode
50: * as follows otherwise:
51: *
52: * MATCH_PATTERN - bad pattern
53: * MATCH_RANGE - match failure on [..] construct
54: * MATCH_ABORT - premature end of text string
55: * MATCH_END - premature end of pattern string
56: * MATCH_VALID - valid match
57: *
58: *
59: * A match means the entire string TEXT is used up in matching.
60: *
61: * In the pattern string:
62: * `*' matches any sequence of characters (zero or more)
63: * `?' matches any character
64: * [SET] matches any character in the specified set,
65: * [!SET] or [^SET] matches any character not in the specified set.
66: *
67: * A set is composed of characters or ranges; a range looks like
68: * character hyphen character (as in 0-9 or A-Z). [0-9a-zA-Z_] is the
69: * minimal set of characters allowed in the [..] pattern construct.
70: * Other characters are allowed (ie. 8 bit characters) if your system
71: * will support them.
72: *
73: * To suppress the special syntactic significance of any of `[]*?!^-\',
74: * in a [..] construct and match the character exactly, precede it
75: * with a `\'.
76: *
77: ----------------------------------------------------------------------------*/
78:
79: /*----------------------------------------------------------------------------
80: *
81: * Match the pattern PATTERN against the string TEXT;
82: *
83: * returns MATCH_VALID if pattern matches, or an errorcode as follows
84: * otherwise:
85: *
86: * MATCH_PATTERN - bad pattern
87: * MATCH_RANGE - match failure on [..] construct
88: * MATCH_ABORT - premature end of text string
89: * MATCH_END - premature end of pattern string
90: * MATCH_VALID - valid match
91: *
92: *
93: * A match means the entire string TEXT is used up in matching.
94: *
95: * In the pattern string:
96: * `*' matches any sequence of characters (zero or more)
97: * `?' matches any character
98: * [SET] matches any character in the specified set,
99: * [!SET] or [^SET] matches any character not in the specified set.
100: * \ is allowed within a set to escape a character like ']' or '-'
101: *
102: * A set is composed of characters or ranges; a range looks like
103: * character hyphen character (as in 0-9 or A-Z). [0-9a-zA-Z_] is the
104: * minimal set of characters allowed in the [..] pattern construct.
105: * Other characters are allowed (ie. 8 bit characters) if your system
106: * will support them.
107: *
108: * To suppress the special syntactic significance of any of `[]*?!^-\',
109: * within a [..] construct and match the character exactly, precede it
110: * with a `\'.
111: *
112: ----------------------------------------------------------------------------*/
113:
114: static int matche(p, t)
115: register char *p;
116: register char *t;
117: {
118: register char range_start, range_end; /* start and end in range */
119:
120: BOOLEAN invert; /* is this [..] or [!..] */
121: BOOLEAN member_match; /* have I matched the [..] construct? */
122: BOOLEAN loop; /* should I terminate? */
123:
124: for (; *p; p++, t++) {
125:
126: /* if this is the end of the text then this is the end of the match */
127: if (!*t)
128: return ((*p == '*') && (*++p == '\0'))? MATCH_VALID : MATCH_ABORT;
129:
130: /* determine and react to pattern type */
131: switch (*p) {
132:
133: /* single any character match */
134: case '?':
135: break;
136:
137: /* multiple any character match */
138: case '*':
139: return matche_after_star (p, t);
140:
141: /* [..] construct, single member/exclusion character match */
142: case '[': {
143:
144: /* move to beginning of range */
145: p++;
146:
147: /* check if this is a member match or exclusion match */
148: invert = FALSE;
149: if ((*p == '!') || (*p == '^')) {
150: invert = TRUE;
151: p++;
152: }
153:
154: /* if closing bracket here or at range start then we have a
155: malformed pattern */
156: if (*p == ']')
157: return MATCH_PATTERN;
158:
159: member_match = FALSE;
160: loop = TRUE;
161:
162: while (loop) {
163:
164: /* if end of construct then loop is done */
165: if (*p == ']') {
166: loop = FALSE;
167: continue;
168: }
169:
170: /* matching a '!', '^', '-', '\' or a ']' */
171: if (*p == '\\')
172: range_start = range_end = *++p;
173: else
174: range_start = range_end = *p;
175:
176: /* if end of pattern then bad pattern (Missing ']') */
177: if (!*p)
178: return MATCH_PATTERN;
179:
180: /* check for range bar */
181: if (*++p == '-') {
182:
183: /* get the range end */
184: range_end = *++p;
185:
186: /* if end of pattern or construct then bad pattern */
187: if ((range_end == '\0') || (range_end == ']'))
188: return MATCH_PATTERN;
189:
190: /* special character range end */
191: if (range_end == '\\') {
192: range_end = *++p;
193:
194: /* if end of text then we have a bad pattern */
195: if (!range_end)
196: return MATCH_PATTERN;
197: }
198:
199: /* move just beyond this range */
200: p++;
201: }
202:
203: /* if the text character is in range then match found.
204: * make sure the range letters have the proper
205: * relationship to one another before comparison
206: */
207: if (range_start < range_end) {
208: if ((*t >= range_start) && (*t <= range_end)) {
209: member_match = TRUE;
210: loop = FALSE;
211: }
212: } else {
213: if ((*t >= range_end) && (*t <= range_start)) {
214: member_match = TRUE;
215: loop = FALSE;
216: }
217: }
218: }
219:
220: /* if there was a match in an exclusion set then no match */
221: /* if there was no match in a member set then no match */
222: if ((invert && member_match) ||
223: !(invert || member_match))
224: return MATCH_RANGE;
225:
226: /* if this is not an exclusion then skip the rest of the [...]
227: construct that already matched. */
228: if (member_match) {
229: while (*p != ']') {
230:
231: /* bad pattern (Missing ']') */
232: if (!*p)
233: return MATCH_PATTERN;
234:
235: /* skip exact match */
236: if (*p == '\\') {
237: p++;
238:
239: /* if end of text then we have a bad pattern */
240: if (!*p)
241: return MATCH_PATTERN;
242: }
243:
244: /* move to next pattern char */
245: p++;
246: }
247: }
248:
249: break;
250: } /* switch '[' */
251:
252: /* must match this character exactly */
253: default:
254: #ifdef OLDSTUFF
255: if (*p != *t)
256: #else /* !OLDSTUFF */
257: /* do it like arcmatch() (old unzip) did it (v1.2) */
258: if (*t != (char) ((pInfo->lcflag && isupper((int)(*p)))?
259: tolower((int)(*p)) : *p))
260: #endif /* ?OLDSTUFF */
261: return MATCH_LITERAL;
262:
263: } /* switch */
264: } /* for */
265:
266: /* if end of text not reached then the pattern fails */
267: if (*t)
268: return MATCH_END;
269: else
270: return MATCH_VALID;
271: }
272:
273:
274: /*----------------------------------------------------------------------------
275: *
276: * recursively call matche() with final segment of PATTERN and of TEXT.
277: *
278: ----------------------------------------------------------------------------*/
279:
280: static int matche_after_star (p,t)
281: register char *p;
282: register char *t;
283: {
284: register int match = 0;
285: register int nextp;
286:
287: /* pass over existing ? and * in pattern */
288: while ((*p == '?') || (*p == '*')) {
289:
290: /* take one char for each ? and +; if end of text then no match */
291: if ((*p == '?') && (!*t++))
292: return MATCH_ABORT;
293:
294: /* move to next char in pattern */
295: p++;
296: }
297:
298: /* if end of pattern we have matched regardless of text left */
299: if (!*p)
300: return MATCH_VALID;
301:
302: /* get the next character to match which must be a literal or '[' */
303: nextp = *p;
304:
305: /* Continue until we run out of text or definite result seen */
306: do {
307: /* a precondition for matching is that the next character
308: * in the pattern match the next character in the text or that
309: * the next pattern char is the beginning of a range. Increment
310: * text pointer as we go here.
311: */
312: if ((nextp == *t) || (nextp == '['))
313: match = matche(p, t);
314:
315: /* if the end of text is reached then no match */
316: if (!*t++)
317: match = MATCH_ABORT;
318:
319: } while ((match != MATCH_VALID) &&
320: (match != MATCH_ABORT) &&
321: (match != MATCH_PATTERN));
322:
323: /* return result */
324: return match;
325: }
326:
327:
328: /*----------------------------------------------------------------------------
329: *
330: * match() is a shell to matche() to return only BOOLEAN values.
331: *
332: ----------------------------------------------------------------------------*/
333:
334: int match(string,pattern)
335: char *string;
336: char *pattern;
337: {
338: int error_type;
339: error_type = matche(pattern,string);
340: return (error_type == MATCH_VALID ) ? TRUE : FALSE;
341: }
342:
343:
344: #ifdef TEST_MATCH
345:
346: /*----------------------------------------------------------------------------
347: *
348: * Return TRUE if PATTERN has any special wildcard characters
349: *
350: ----------------------------------------------------------------------------*/
351:
352: BOOLEAN is_pattern (char *pattern);
353:
354: /*----------------------------------------------------------------------------
355: *
356: * Return TRUE if PATTERN has is a well formed regular expression according
357: * to the above syntax
358: *
359: * error_type is a return code based on the type of pattern error. Zero is
360: * returned in error_type if the pattern is a valid one. error_type return
361: * values are as follows:
362: *
363: * PATTERN_VALID - pattern is well formed
364: * PATTERN_RANGE - [..] construct has a no end range in a '-' pair (ie [a-])
365: * PATTERN_CLOSE - [..] construct has no end bracket (ie [abc-g )
366: * PATTERN_EMPTY - [..] construct is empty (ie [])
367: *
368: ----------------------------------------------------------------------------*/
369:
370: BOOLEAN is_valid_pattern (char *pattern, int *error_type);
371: int fast_match_after_star (register char *pattern, register char *text);
372:
373: /*----------------------------------------------------------------------------
374: *
375: * Return TRUE if PATTERN has any special wildcard characters
376: *
377: ----------------------------------------------------------------------------*/
378:
379: BOOLEAN is_pattern (char *p)
380: {
381: while (*p)
382: switch (*p++) {
383: case '?':
384: case '*':
385: case '[':
386: return TRUE;
387: }
388: return FALSE;
389: }
390:
391:
392: /*----------------------------------------------------------------------------
393: *
394: * Return TRUE if PATTERN has is a well formed regular expression according
395: * to the above syntax
396: *
397: * error_type is a return code based on the type of pattern error. Zero is
398: * returned in error_type if the pattern is a valid one. error_type return
399: * values are as follows:
400: *
401: * PATTERN_VALID - pattern is well formed
402: * PATTERN_RANGE - [..] construct has a no end range in a '-' pair (ie [a-])
403: * PATTERN_CLOSE - [..] construct has no end bracket (ie [abc-g )
404: * PATTERN_EMPTY - [..] construct is empty (ie [])
405: *
406: ----------------------------------------------------------------------------*/
407:
408: BOOLEAN is_valid_pattern (char *p, int *error_type)
409: {
410: /* init error_type */
411: *error_type = PATTERN_VALID;
412:
413: /* loop through pattern to EOS */
414: while (*p) {
415:
416: /* determine pattern type */
417: switch (*p) {
418:
419: /* the [..] construct must be well formed */
420: case '[':
421: p++;
422:
423: /* if the next character is ']' then bad pattern */
424: if (*p == ']') {
425: *error_type = PATTERN_EMPTY;
426: return FALSE;
427: }
428:
429: /* if end of pattern here then bad pattern */
430: if (!*p) {
431: *error_type = PATTERN_CLOSE;
432: return FALSE;
433: }
434:
435: /* loop to end of [..] construct */
436: while (*p != ']') {
437:
438: /* check for literal escape */
439: if (*p == '\\') {
440: p++;
441:
442: /* if end of pattern here then bad pattern */
443: if (!*p++) {
444: *error_type = PATTERN_ESC;
445: return FALSE;
446: }
447: } else
448: p++;
449:
450: /* if end of pattern here then bad pattern */
451: if (!*p) {
452: *error_type = PATTERN_CLOSE;
453: return FALSE;
454: }
455:
456: /* if this a range */
457: if (*p == '-') {
458:
459: /* we must have an end of range */
460: if (!*++p || (*p == ']')) {
461: *error_type = PATTERN_RANGE;
462: return FALSE;
463: } else {
464:
465: /* check for literal escape */
466: if (*p == '\\')
467: p++;
468:
469: /* if end of pattern here then bad pattern */
470: if (!*p++) {
471: *error_type = PATTERN_ESC;
472: return FALSE;
473: }
474: }
475: }
476: }
477: break;
478:
479: /* all other characters are valid pattern elements */
480: case '*':
481: case '?':
482: default:
483: p++; /* "normal" character */
484: break;
485: } /* switch */
486: }
487:
488: return TRUE;
489: }
490:
491:
492: /*
493: * This test main expects as first arg the pattern and as second arg
494: * the match string. Output is yay or nay on match. If nay on
495: * match then the error code is parsed and written.
496: */
497:
498: #include <stdio.h>
499:
500: int main(int argc, char *argv[])
501: {
502: int error;
503: int is_valid_error;
504:
505: if (argc != 3)
506: printf("Usage: MATCH Pattern Text\n");
507: else {
508: printf("Pattern: %s\n", argv[1]);
509: printf("Text : %s\n", argv[2]);
510:
511: if (!is_pattern(argv[1]))
512: printf(" First Argument Is Not A Pattern\n");
513: else {
514: match(argv[1],argv[2]) ? printf("TRUE") : printf("FALSE");
515: error = matche(argv[1],argv[2]);
516: is_valid_pattern(argv[1],&is_valid_error);
517:
518: switch (error) {
519: case MATCH_VALID:
520: printf(" Match Successful");
521: if (is_valid_error != PATTERN_VALID)
522: printf(" -- is_valid_pattern() is complaining\n");
523: else
524: printf("\n");
525: break;
526: case MATCH_RANGE:
527: printf(" Match Failed on [..]\n");
528: break;
529: case MATCH_ABORT:
530: printf(" Match Failed on Early Text Termination\n");
531: break;
532: case MATCH_END:
533: printf(" Match Failed on Early Pattern Termination\n");
534: break;
535: case MATCH_PATTERN:
536: switch (is_valid_error) {
537: case PATTERN_VALID:
538: printf(" Internal Disagreement On Pattern\n");
539: break;
540: case PATTERN_RANGE:
541: printf(" No End of Range in [..] Construct\n");
542: break;
543: case PATTERN_CLOSE:
544: printf(" [..] Construct is Open\n");
545: break;
546: case PATTERN_EMPTY:
547: printf(" [..] Construct is Empty\n");
548: break;
549: default:
550: printf(" Internal Error in is_valid_pattern()\n");
551: }
552: break;
553: default:
554: printf(" Internal Error in matche()\n");
555: break;
556: } /* switch */
557: }
558:
559: }
560: return(0);
561: }
562:
563: #endif /* TEST_MATCH */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.