[wxWidgets.git] / utils / Install / sfxzip / match.c

/*---------------------------------------------------------------------------

  match.c

  The match() routine recursively compares a string to a "pattern" (regular
  expression), returning TRUE if a match is found or FALSE if not.  This
  version is specifically for use with unzip.c:  as did the previous match()
  routines from SEA and J. Kercheval, it leaves the case (upper, lower, or
  mixed) of the string alone, but converts any uppercase characters in the
  pattern to lowercase if indicated by the global var pInfo->lcflag (which
  is to say, string is assumed to have been converted to lowercase already,
  if such was necessary).

  GRR:  reversed order of text, pattern in matche() (now same as match());
        added ignore_case/ic flags, Case() macro.

  PaulK:  replaced matche() with recmatch() from Zip, modified to have an
          ignore_case argument; replaced test frame with simpler one.

  ---------------------------------------------------------------------------

  Copyright on recmatch() from Zip's util.c (although recmatch() was almost
  certainly written by Mark Adler...ask me how I can tell :-) ):

     Copyright (C) 1990-1992 Mark Adler, Richard B. Wales, Jean-loup Gailly,
     Kai Uwe Rommel and Igor Mandrichenko.

     Permission is granted to any individual or institution to use, copy,
     or redistribute this software so long as all of the original files are
     included unmodified, that it is not sold for profit, and that this copy-
     right notice is retained.

  ---------------------------------------------------------------------------

  Match the pattern (wildcard) against the string (fixed):

     match(string, pattern, ignore_case);

  returns TRUE if string matches pattern, FALSE otherwise.  In the pattern:

     `*' matches any sequence of characters (zero or more)
     `?' matches any single character
     [SET] matches any character in the specified set,
     [!SET] or [^SET] matches any character not in the specified set.

  A set is composed of characters or ranges; a range looks like ``character
  hyphen character'' (as in 0-9 or A-Z).  [0-9a-zA-Z_] is the minimal set of
  characters allowed in the [..] pattern construct.  Other characters are
  allowed (i.e., 8-bit characters) if your system will support them.

  To suppress the special syntactic significance of any of ``[]*?!^-\'', in-
  side or outside a [..] construct, and match the character exactly, precede
  it with a ``\'' (backslash).

  Note that "*.*" and "*." are treated specially under MS-DOS if DOSWILD is
  defined.  See the DOSWILD section below for an explanation.  Note also
  that with VMSWILD defined, '%' is used instead of '?', and sets (ranges)
  are delimited by () instead of [].

  ---------------------------------------------------------------------------*/


/* define ToLower() in here (for Unix, define ToLower to be macro (using
 * isupper()); otherwise just use tolower() */
#define UNZIP_INTERNAL
#include "unzip.h"

#if 0  /* this is not useful until it matches Amiga names insensitively */
#ifdef AMIGA        /* some other platforms might also want to use this */
#  define ANSI_CHARSET       /* MOVE INTO UNZIP.H EVENTUALLY */
#endif
#endif /* 0 */
  
#ifdef ANSI_CHARSET
#  ifdef ToLower
#    undef ToLower
#  endif
   /* uppercase letters are values 41 thru 5A, C0 thru D6, and D8 thru DE */
#  define IsUpper(c) (c>=0xC0 ? c<=0xDE && c!=0xD7 : c>=0x41 && c<=0x5A)
#  define ToLower(c) (IsUpper((uch) c) ? (unsigned) c | 0x20 : (unsigned) c)
#endif
#define Case(x)  (ic? ToLower(x) : (x))

#ifdef VMSWILD
#  define WILDCHAR   '%'
#  define BEG_RANGE  '('
#  define END_RANGE  ')'
#else
#  define WILDCHAR   '?'
#  define BEG_RANGE  '['
#  define END_RANGE  ']'
#endif

#if 0                /* GRR:  add this to unzip.h someday... */
#if !(defined(MSDOS) && defined(DOSWILD))
#define match(s,p,ic)   (recmatch((ZCONST uch *)p,(ZCONST uch *)s,ic) == 1)
int recmatch OF((ZCONST uch *pattern, ZCONST uch *string, int ignore_case));
#endif
#endif /* 0 */
static int recmatch OF((ZCONST uch *pattern, ZCONST uch *string,
                        int ignore_case));


/* match() is a shell to recmatch() to return only Boolean values. */

int match(string, pattern, ignore_case)
    ZCONST char *string, *pattern;
    int ignore_case;
{
#if (defined(MSDOS) && defined(DOSWILD))
    char *dospattern;
    int j = strlen(pattern);

/*---------------------------------------------------------------------------
    Optional MS-DOS preprocessing section:  compare last three chars of the
    wildcard to "*.*" and translate to "*" if found; else compare the last
    two characters to "*." and, if found, scan the non-wild string for dots.
    If in the latter case a dot is found, return failure; else translate the
    "*." to "*".  In either case, continue with the normal (Unix-like) match
    procedure after translation.  (If not enough memory, default to normal
    match.)  This causes "a*.*" and "a*." to behave as MS-DOS users expect.
  ---------------------------------------------------------------------------*/

    if ((dospattern = (char *)malloc(j+1)) != NULL) {
        strcpy(dospattern, pattern);
        if (!strcmp(dospattern+j-3, "*.*")) {
            dospattern[j-2] = '\0';                    /* nuke the ".*" */
        } else if (!strcmp(dospattern+j-2, "*.")) {
            char *p = strchr(string, '.');

            if (p) {   /* found a dot:  match fails */
                free(dospattern);
                return 0;
            }
            dospattern[j-1] = '\0';                    /* nuke the end "." */
        }
        j = recmatch((uch *)dospattern, (uch *)string, ignore_case);
        free(dospattern);
        return j == 1;
    } else
#endif /* MSDOS && DOSWILD */
    return recmatch((uch *)pattern, (uch *)string, ignore_case) == 1;
}


static int recmatch(p, s, ic)
    ZCONST uch *p;        /* sh pattern to match */
    ZCONST uch *s;        /* string to which to match it */
    int ic;               /* true for case insensitivity */
/* Recursively compare the sh pattern p with the string s and return 1 if
 * they match, and 0 or 2 if they don't or if there is a syntax error in the
 * pattern.  This routine recurses on itself no more deeply than the number
 * of characters in the pattern. */
{
    unsigned int c;       /* pattern char or start of range in [-] loop */ 

    /* Get first character, the pattern for new recmatch calls follows */
    c = *p++;

    /* If that was the end of the pattern, match if string empty too */
    if (c == 0)
        return *s == 0;

    /* '?' (or '%') matches any character (but not an empty string) */
    if (c == WILDCHAR)
        return *s ? recmatch(p, s + 1, ic) : 0;

    /* '*' matches any number of characters, including zero */
#ifdef AMIGA
    if (c == '#' && *p == '?')     /* "#?" is Amiga-ese for "*" */
        c = '*', p++;
#endif /* AMIGA */
    if (c == '*') {
        if (*p == 0)
            return 1;
        for (; *s; s++)
            if ((c = recmatch(p, s, ic)) != 0)
                return (int)c;
        return 2;       /* 2 means give up--match will return false */
    }

    /* Parse and process the list of characters and ranges in brackets */
    if (c == BEG_RANGE) {
        int e;          /* flag true if next char to be taken literally */
        ZCONST uch *q;  /* pointer to end of [-] group */
        int r;          /* flag true to match anything but the range */

        if (*s == 0)                           /* need a character to match */
            return 0;
        p += (r = (*p == '!' || *p == '^'));   /* see if reverse */
        for (q = p, e = 0; *q; q++)            /* find closing bracket */
            if (e)
                e = 0;
            else
                if (*q == '\\')      /* GRR:  change to ^ for MS-DOS, OS/2? */
                    e = 1;
                else if (*q == END_RANGE)
                    break;
        if (*q != END_RANGE)         /* nothing matches if bad syntax */
            return 0;
        for (c = 0, e = *p == '-'; p < q; p++) {  /* go through the list */
            if (e == 0 && *p == '\\')             /* set escape flag if \ */
                e = 1;
            else if (e == 0 && *p == '-')         /* set start of range if - */
                c = *(p-1);
            else {
                unsigned int cc = Case(*s);

                if (*(p+1) != '-')
                    for (c = c ? c : *p; c <= *p; c++)  /* compare range */
                        if ((unsigned)Case(c) == cc)  /* typecast for MSC bug */
                            return r ? 0 : recmatch(q + 1, s + 1, ic);
                c = e = 0;   /* clear range, escape flags */
            }
        }
        return r ? recmatch(q + 1, s + 1, ic) : 0;  /* bracket match failed */
    }

    /* if escape ('\'), just compare next character */
    if (c == '\\' && (c = *p++) == 0)     /* if \ at end, then syntax error */
        return 0;

    /* just a character--compare it */
#ifdef QDOS
    return QMatch(Case((uch)c), Case(*s)) ? recmatch(p, ++s, ic) : 0;
#else
    return Case((uch)c) == Case(*s) ? recmatch(p, ++s, ic) : 0;
#endif

} /* end function recmatch() */


int iswild(p)        /* originally only used for stat()-bug workaround in */
    ZCONST char *p;  /*  VAX C, Turbo/Borland C, Watcom C, Atari MiNT libs; */
{                    /*  now used in process_zipfiles() as well */
    for (; *p; ++p)
        if (*p == '\\' && *(p+1))
            ++p;
#ifdef VMS
        else if (*p == '%' || *p == '*')
#else /* !VMS */
#ifdef AMIGA
        else if (*p == '?' || *p == '*' || (*p=='#' && p[1]=='?') || *p == '[')
#else /* !AMIGA */
        else if (*p == '?' || *p == '*' || *p == '[')
#endif /* ?AMIGA */
#endif /* ?VMS */
#ifdef QDOS
            return (int)p;
#else
            return TRUE;
#endif

    return FALSE;

} /* end function iswild() */


#ifdef TEST_MATCH

#define put(s) {fputs(s,stdout); fflush(stdout);}

void main()
{
    char pat[256], str[256];

    for (;;) {
        put("Pattern (return to exit): ");
        gets(pat);
        if (!pat[0])
            break;
        for (;;) {
            put("String (return for new pattern): ");
            gets(str);
            if (!str[0])
                break;
            pipeit("Case sensitive: %s  insensitive: %s\n",
              match(str, pat, 0) ? "YES" : "NO",
              match(str, pat, 1) ? "YES" : "NO");
        }
    }
    EXIT(0);
}

#endif /* TEST_MATCH */
Commit	Line	Data
f6bcfd97 BP	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	routines from SEA and J. Kercheval, it leaves the case (upper, lower, or
	9	mixed) of the string alone, but converts any uppercase characters in the
	10	pattern to lowercase if indicated by the global var pInfo->lcflag (which
	11	is to say, string is assumed to have been converted to lowercase already,
	12	if such was necessary).
	13
	14	GRR: reversed order of text, pattern in matche() (now same as match());
	15	added ignore_case/ic flags, Case() macro.
	16
	17	PaulK: replaced matche() with recmatch() from Zip, modified to have an
	18	ignore_case argument; replaced test frame with simpler one.
	19
	20	---------------------------------------------------------------------------
	21
	22	Copyright on recmatch() from Zip's util.c (although recmatch() was almost
	23	certainly written by Mark Adler...ask me how I can tell :-) ):
	24
	25	Copyright (C) 1990-1992 Mark Adler, Richard B. Wales, Jean-loup Gailly,
	26	Kai Uwe Rommel and Igor Mandrichenko.
	27
	28	Permission is granted to any individual or institution to use, copy,
	29	or redistribute this software so long as all of the original files are
	30	included unmodified, that it is not sold for profit, and that this copy-
	31	right notice is retained.
	32
	33	---------------------------------------------------------------------------
	34
	35	Match the pattern (wildcard) against the string (fixed):
	36
	37	match(string, pattern, ignore_case);
	38
	39	returns TRUE if string matches pattern, FALSE otherwise. In the pattern:
	40
	41	`*' matches any sequence of characters (zero or more)
	42	`?' matches any single character
	43	[SET] matches any character in the specified set,
	44	[!SET] or [^SET] matches any character not in the specified set.
	45
	46	A set is composed of characters or ranges; a range looks like ``character
	47	hyphen character'' (as in 0-9 or A-Z). [0-9a-zA-Z_] is the minimal set of
	48	characters allowed in the [..] pattern construct. Other characters are
	49	allowed (i.e., 8-bit characters) if your system will support them.
	50
	51	To suppress the special syntactic significance of any of ``[]*?!^-\'', in-
	52	side or outside a [..] construct, and match the character exactly, precede
	53	it with a ``\'' (backslash).
	54
	55	Note that "." and "*." are treated specially under MS-DOS if DOSWILD is
	56	defined. See the DOSWILD section below for an explanation. Note also
	57	that with VMSWILD defined, '%' is used instead of '?', and sets (ranges)
	58	are delimited by () instead of [].
	59
	60	---------------------------------------------------------------------------*/
	61
	62
	63
	64	/* define ToLower() in here (for Unix, define ToLower to be macro (using
65	* isupper()); otherwise just use tolower() */
66	#define UNZIP_INTERNAL
67	#include "unzip.h"
68
69	#if 0 /* this is not useful until it matches Amiga names insensitively */
70	#ifdef AMIGA /* some other platforms might also want to use this */
71	# define ANSI_CHARSET /* MOVE INTO UNZIP.H EVENTUALLY */
72	#endif
73	#endif /* 0 */
74
75	#ifdef ANSI_CHARSET
76	# ifdef ToLower
77	# undef ToLower
78	# endif
79	/* uppercase letters are values 41 thru 5A, C0 thru D6, and D8 thru DE */
80	# define IsUpper(c) (c>=0xC0 ? c<=0xDE && c!=0xD7 : c>=0x41 && c<=0x5A)
81	# define ToLower(c) (IsUpper((uch) c) ? (unsigned) c \| 0x20 : (unsigned) c)
82	#endif
83	#define Case(x) (ic? ToLower(x) : (x))
84
85	#ifdef VMSWILD
86	# define WILDCHAR '%'
87	# define BEG_RANGE '('
88	# define END_RANGE ')'
89	#else
90	# define WILDCHAR '?'
91	# define BEG_RANGE '['
92	# define END_RANGE ']'
93	#endif
94
95	#if 0 /* GRR: add this to unzip.h someday... */
96	#if !(defined(MSDOS) && defined(DOSWILD))
97	#define match(s,p,ic) (recmatch((ZCONST uch )p,(ZCONST uch )s,ic) == 1)
98	int recmatch OF((ZCONST uch pattern, ZCONST uch string, int ignore_case));
99	#endif
100	#endif /* 0 */
101	static int recmatch OF((ZCONST uch pattern, ZCONST uch string,
102	int ignore_case));
103
104
105
106	/* match() is a shell to recmatch() to return only Boolean values. */
107
108	int match(string, pattern, ignore_case)
109	ZCONST char string, pattern;
110	int ignore_case;
111	{
112	#if (defined(MSDOS) && defined(DOSWILD))
113	char *dospattern;
114	int j = strlen(pattern);
115
116	/*---------------------------------------------------------------------------
117	Optional MS-DOS preprocessing section: compare last three chars of the
118	wildcard to "." and translate to "*" if found; else compare the last
119	two characters to "*." and, if found, scan the non-wild string for dots.
120	If in the latter case a dot is found, return failure; else translate the
121	"." to "". In either case, continue with the normal (Unix-like) match
122	procedure after translation. (If not enough memory, default to normal
123	match.) This causes "a." and "a*." to behave as MS-DOS users expect.
124	---------------------------------------------------------------------------*/
125
126	if ((dospattern = (char *)malloc(j+1)) != NULL) {
127	strcpy(dospattern, pattern);
128	if (!strcmp(dospattern+j-3, ".")) {
129	dospattern[j-2] = '\0'; /* nuke the "." /
130	} else if (!strcmp(dospattern+j-2, "*.")) {
131	char *p = strchr(string, '.');
132
133	if (p) { /* found a dot: match fails */
134	free(dospattern);
135	return 0;
136	}
137	dospattern[j-1] = '\0'; /* nuke the end "." */
138	}
139	j = recmatch((uch )dospattern, (uch )string, ignore_case);
140	free(dospattern);
141	return j == 1;
142	} else
143	#endif /* MSDOS && DOSWILD */
144	return recmatch((uch )pattern, (uch )string, ignore_case) == 1;
145	}
146
147
148
149	static int recmatch(p, s, ic)
150	ZCONST uch p; / sh pattern to match */
151	ZCONST uch s; / string to which to match it */
152	int ic; /* true for case insensitivity */
153	/* Recursively compare the sh pattern p with the string s and return 1 if
154	* they match, and 0 or 2 if they don't or if there is a syntax error in the
155	* pattern. This routine recurses on itself no more deeply than the number
156	* of characters in the pattern. */
157	{
158	unsigned int c; /* pattern char or start of range in [-] loop */
159
160	/* Get first character, the pattern for new recmatch calls follows */
161	c = *p++;
162
163	/* If that was the end of the pattern, match if string empty too */
164	if (c == 0)
165	return *s == 0;
166
167	/* '?' (or '%') matches any character (but not an empty string) */
168	if (c == WILDCHAR)
169	return *s ? recmatch(p, s + 1, ic) : 0;
170
171	/* '' matches any number of characters, including zero /
172	#ifdef AMIGA
173	if (c == '#' && p == '?') / "#?" is Amiga-ese for "" /
174	c = '*', p++;
175	#endif /* AMIGA */
176	if (c == '*') {
177	if (*p == 0)
178	return 1;
179	for (; *s; s++)
180	if ((c = recmatch(p, s, ic)) != 0)
181	return (int)c;
182	return 2; /* 2 means give up--match will return false */
183	}
184
185	/* Parse and process the list of characters and ranges in brackets */
186	if (c == BEG_RANGE) {
187	int e; /* flag true if next char to be taken literally */
188	ZCONST uch q; / pointer to end of [-] group */
189	int r; /* flag true to match anything but the range */
190
191	if (s == 0) / need a character to match */
192	return 0;
193	p += (r = (p == '!' \|\| p == '^')); /* see if reverse */
194	for (q = p, e = 0; q; q++) / find closing bracket */
195	if (e)
196	e = 0;
197	else
198	if (q == '\\') / GRR: change to ^ for MS-DOS, OS/2? */
199	e = 1;
200	else if (*q == END_RANGE)
201	break;
202	if (q != END_RANGE) / nothing matches if bad syntax */
203	return 0;
204	for (c = 0, e = p == '-'; p < q; p++) { / go through the list */
205	if (e == 0 && p == '\\') / set escape flag if \ */
206	e = 1;
207	else if (e == 0 && p == '-') / set start of range if - */
208	c = *(p-1);
209	else {
210	unsigned int cc = Case(*s);
211
212	if (*(p+1) != '-')
213	for (c = c ? c : p; c <= p; c++) /* compare range */
214	if ((unsigned)Case(c) == cc) /* typecast for MSC bug */
215	return r ? 0 : recmatch(q + 1, s + 1, ic);
216	c = e = 0; /* clear range, escape flags */
217	}
218	}
219	return r ? recmatch(q + 1, s + 1, ic) : 0; /* bracket match failed */
220	}
221
222	/* if escape ('\'), just compare next character */
223	if (c == '\\' && (c = p++) == 0) / if \ at end, then syntax error */
224	return 0;
225
226	/* just a character--compare it */
227	#ifdef QDOS
228	return QMatch(Case((uch)c), Case(*s)) ? recmatch(p, ++s, ic) : 0;
229	#else
230	return Case((uch)c) == Case(*s) ? recmatch(p, ++s, ic) : 0;
231	#endif
232
233	} /* end function recmatch() */
234
235
236
237
238
239	int iswild(p) /* originally only used for stat()-bug workaround in */
240	ZCONST char p; / VAX C, Turbo/Borland C, Watcom C, Atari MiNT libs; */
241	{ /* now used in process_zipfiles() as well */
242	for (; *p; ++p)
243	if (p == '\\' && (p+1))
244	++p;
245	#ifdef VMS
246	else if (p == '%' \|\| p == '*')
247	#else /* !VMS */
248	#ifdef AMIGA
249	else if (p == '?' \|\| p == '' \|\| (p=='#' && p[1]=='?') \|\| *p == '[')
250	#else /* !AMIGA */
251	else if (p == '?' \|\| p == '' \|\| p == '[')
252	#endif /* ?AMIGA */
253	#endif /* ?VMS */
254	#ifdef QDOS
255	return (int)p;
256	#else
257	return TRUE;
258	#endif
259
260	return FALSE;
261
262	} /* end function iswild() */
263
264
265
266
267
268	#ifdef TEST_MATCH
269
270	#define put(s) {fputs(s,stdout); fflush(stdout);}
271
272	void main()
273	{
274	char pat[256], str[256];
275
276	for (;;) {
277	put("Pattern (return to exit): ");
278	gets(pat);
279	if (!pat[0])
280	break;
281	for (;;) {
282	put("String (return for new pattern): ");
283	gets(str);
284	if (!str[0])
285	break;
286	pipeit("Case sensitive: %s insensitive: %s\n",
287	match(str, pat, 0) ? "YES" : "NO",
288	match(str, pat, 1) ? "YES" : "NO");
289	}
290	}
291	EXIT(0);
292	}
293
294	#endif /* TEST_MATCH */