[thirdparty/glibc.git] / posix / fnmatch_loop.c

/* Copyright (C) 1991-1993, 1996-1999, 2000 Free Software Foundation, Inc.
   This file is part of the GNU C Library.

   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public License as
   published by the Free Software Foundation; either version 2 of the
   License, or (at your option) any later version.

   This library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Library General Public License for more details.

   You should have received a copy of the GNU Library General Public
   License along with this library; see the file COPYING.LIB.  If not,
   write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
   Boston, MA 02111-1307, USA.  */

/* Match STRING against the filename pattern PATTERN, returning zero if
   it matches, nonzero if not.  */
static int FCT (const CHAR *pattern, const CHAR *string,
		int no_leading_period, int flags) internal_function;

static int
internal_function
FCT (pattern, string, no_leading_period, flags)
     const CHAR *pattern;
     const CHAR *string;
     int no_leading_period;
     int flags;
{
  register const CHAR *p = pattern, *n = string;
  register UCHAR c;

  while ((c = *p++) != L('\0'))
    {
      c = FOLD (c);

      switch (c)
	{
	case L('?'):
	  if (*n == L('\0'))
	    return FNM_NOMATCH;
	  else if (*n == L('/') && (flags & FNM_FILE_NAME))
	    return FNM_NOMATCH;
	  else if (*n == L('.') && no_leading_period
		   && (n == string
		       || (n[-1] == L('/') && (flags & FNM_FILE_NAME))))
	    return FNM_NOMATCH;
	  break;

	case L('\\'):
	  if (!(flags & FNM_NOESCAPE))
	    {
	      c = *p++;
	      if (c == L('\0'))
		/* Trailing \ loses.  */
		return FNM_NOMATCH;
	      c = FOLD (c);
	    }
	  if (FOLD ((UCHAR) *n) != c)
	    return FNM_NOMATCH;
	  break;

	case L('*'):
	  if (*n == L('.') && no_leading_period
	      && (n == string
		  || (n[-1] == L('/') && (flags & FNM_FILE_NAME))))
	    return FNM_NOMATCH;

	  for (c = *p++; c == L('?') || c == L('*'); c = *p++)
	    {
	      if (*n == L('/') && (flags & FNM_FILE_NAME))
		/* A slash does not match a wildcard under FNM_FILE_NAME.  */
		return FNM_NOMATCH;
	      else if (c == L('?'))
		{
		  /* A ? needs to match one character.  */
		  if (*n == L('\0'))
		    /* There isn't another character; no match.  */
		    return FNM_NOMATCH;
		  else
		    /* One character of the string is consumed in matching
		       this ? wildcard, so *??? won't match if there are
		       less than three characters.  */
		    ++n;
		}
	    }

	  if (c == L('\0'))
	    /* The wildcard(s) is/are the last element of the pattern.
	       If the name is a file name and contains another slash
	       this does mean it cannot match.  */
	    return ((flags & FNM_FILE_NAME) && STRCHR (n, L('/')) != NULL
		    ? FNM_NOMATCH : 0);
	  else
	    {
	      const CHAR *endp;

	      endp = STRCHRNUL (n, (flags & FNM_FILE_NAME) ? L('/') : L('\0'));

	      if (c == L('['))
		{
		  int flags2 = ((flags & FNM_FILE_NAME)
				? flags : (flags & ~FNM_PERIOD));

		  for (--p; n < endp; ++n)
		    if (FCT (p, n, (no_leading_period
				    && (n == string
					|| (n[-1] == L('/')
					    && (flags & FNM_FILE_NAME)))),
			     flags2) == 0)
		      return 0;
		}
	      else if (c == L('/') && (flags & FNM_FILE_NAME))
		{
		  while (*n != L('\0') && *n != L('/'))
		    ++n;
		  if (*n == L('/')
		      && (FCT (p, n + 1, flags & FNM_PERIOD, flags) == 0))
		    return 0;
		}
	      else
		{
		  int flags2 = ((flags & FNM_FILE_NAME)
				? flags : (flags & ~FNM_PERIOD));

		  if (c == L('\\') && !(flags & FNM_NOESCAPE))
		    c = *p;
		  c = FOLD (c);
		  for (--p; n < endp; ++n)
		    if (FOLD ((UCHAR) *n) == c
			&& (FCT (p, n, (no_leading_period
					&& (n == string
					    || (n[-1] == L('/')
						&& (flags & FNM_FILE_NAME)))),
				 flags2) == 0))
		      return 0;
		}
	    }

	  /* If we come here no match is possible with the wildcard.  */
	  return FNM_NOMATCH;

	case L('['):
	  {
	    /* Nonzero if the sense of the character class is inverted.  */
	    static int posixly_correct;
	    register int not;
	    CHAR cold;

	    if (posixly_correct == 0)
	      posixly_correct = getenv ("POSIXLY_CORRECT") != NULL ? 1 : -1;

	    if (*n == L('\0'))
	      return FNM_NOMATCH;

	    if (*n == L('.') && no_leading_period
		&& (n == string
		    || (n[-1] == L('/') && (flags & FNM_FILE_NAME))))
	      return FNM_NOMATCH;

	    if (*n == L('/') && (flags & FNM_FILE_NAME))
	      /* `/' cannot be matched.  */
	      return FNM_NOMATCH;

	    not = (*p == L('!') || (posixly_correct < 0 && *p == L('^')));
	    if (not)
	      ++p;

	    c = *p++;
	    for (;;)
	      {
		UCHAR fn = FOLD ((UCHAR) *n);

		if (!(flags & FNM_NOESCAPE) && c == L('\\'))
		  {
		    if (*p == L('\0'))
		      return FNM_NOMATCH;
		    c = FOLD ((UCHAR) *p);
		    ++p;

		    if (c == fn)
		      goto matched;
		  }
		else if (c == L('[') && *p == L(':'))
		  {
		    /* Leave room for the null.  */
		    CHAR str[CHAR_CLASS_MAX_LENGTH + 1];
		    size_t c1 = 0;
# if defined _LIBC || (defined HAVE_WCTYPE_H && defined HAVE_WCHAR_H)
		    wctype_t wt;
# endif
		    const CHAR *startp = p;

		    for (;;)
		      {
			if (c1 == CHAR_CLASS_MAX_LENGTH)
			  /* The name is too long and therefore the pattern
			     is ill-formed.  */
			  return FNM_NOMATCH;

			c = *++p;
			if (c == L(':') && p[1] == L(']'))
			  {
			    p += 2;
			    break;
			  }
			if (c < L('a') || c >= L('z'))
			  {
			    /* This cannot possibly be a character class name.
			       Match it as a normal range.  */
			    p = startp;
			    c = L('[');
			    goto normal_bracket;
			  }
			str[c1++] = c;
		      }
		    str[c1] = L('\0');

# if defined _LIBC || (defined HAVE_WCTYPE_H && defined HAVE_WCHAR_H)
		    wt = IS_CHAR_CLASS (str);
		    if (wt == 0)
		      /* Invalid character class name.  */
		      return FNM_NOMATCH;

		    if (__iswctype (__btowc ((UCHAR) *n), wt))
		      goto matched;
# else
		    if ((STREQ (str, L("alnum")) && ISALNUM ((UCHAR) *n))
			|| (STREQ (str, L("alpha")) && ISALPHA ((UCHAR) *n))
			|| (STREQ (str, L("blank")) && ISBLANK ((UCHAR) *n))
			|| (STREQ (str, L("cntrl")) && ISCNTRL ((UCHAR) *n))
			|| (STREQ (str, L("digit")) && ISDIGIT ((UCHAR) *n))
			|| (STREQ (str, L("graph")) && ISGRAPH ((UCHAR) *n))
			|| (STREQ (str, L("lower")) && ISLOWER ((UCHAR) *n))
			|| (STREQ (str, L("print")) && ISPRINT ((UCHAR) *n))
			|| (STREQ (str, L("punct")) && ISPUNCT ((UCHAR) *n))
			|| (STREQ (str, L("space")) && ISSPACE ((UCHAR) *n))
			|| (STREQ (str, L("upper")) && ISUPPER ((UCHAR) *n))
			|| (STREQ (str, L("xdigit")) && ISXDIGIT ((UCHAR) *n)))
		      goto matched;
# endif
		  }
		else if (c == L('\0'))
		  /* [ (unterminated) loses.  */
		  return FNM_NOMATCH;
		else
		  {
		  normal_bracket:
		    if (FOLD (c) == fn)
		      goto matched;

		    cold = c;
		    c = *p++;

		    if (c == L('-') && *p != L(']'))
		      {
			/* It is a range.  */
			UCHAR cend = *p++;
			if (!(flags & FNM_NOESCAPE) && cend == L('\\'))
			  cend = *p++;
			if (cend == L('\0'))
			  return FNM_NOMATCH;

			if (cold <= fn && fn <= FOLD (cend))
			  goto matched;

			c = *p++;
		      }
		  }

		if (c == L(']'))
		  break;
	      }

	    if (!not)
	      return FNM_NOMATCH;
	    break;

	  matched:
	    /* Skip the rest of the [...] that already matched.  */
	    while (c != L(']'))
	      {
		if (c == L('\0'))
		  /* [... (unterminated) loses.  */
		  return FNM_NOMATCH;

		c = *p++;
		if (!(flags & FNM_NOESCAPE) && c == L('\\'))
		  {
		    if (*p == L('\0'))
		      return FNM_NOMATCH;
		    /* XXX 1003.2d11 is unclear if this is right.  */
		    ++p;
		  }
		else if (c == L('[') && *p == L(':'))
		  {
		    do
		      if (*++p == L('\0'))
			return FNM_NOMATCH;
		    while (*p != L(':') || p[1] == L(']'));
		    p += 2;
		    c = *p;
		  }
	      }
	    if (not)
	      return FNM_NOMATCH;
	  }
	  break;

	default:
	  if (c != FOLD ((UCHAR) *n))
	    return FNM_NOMATCH;
	}

      ++n;
    }

  if (*n == '\0')
    return 0;

  if ((flags & FNM_LEADING_DIR) && *n == L('/'))
    /* The FNM_LEADING_DIR flag says that "foo*" matches "foobar/frobozz".  */
    return 0;

  return FNM_NOMATCH;

#undef FOLD
#undef CHAR
#undef UCHAR
#undef FCT
#undef STRCHR
#undef STRCHRNUL
#undef L
}
Commit	Line	Data
1fc82a56 UD	1	/* Copyright (C) 1991-1993, 1996-1999, 2000 Free Software Foundation, Inc.
	2	This file is part of the GNU C Library.
	3
	4	This library is free software; you can redistribute it and/or
	5	modify it under the terms of the GNU Library General Public License as
	6	published by the Free Software Foundation; either version 2 of the
	7	License, or (at your option) any later version.
	8
	9	This library is distributed in the hope that it will be useful,
	10	but WITHOUT ANY WARRANTY; without even the implied warranty of
	11	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	12	Library General Public License for more details.
	13
	14	You should have received a copy of the GNU Library General Public
	15	License along with this library; see the file COPYING.LIB. If not,
	16	write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
	17	Boston, MA 02111-1307, USA. */
	18
	19	/* Match STRING against the filename pattern PATTERN, returning zero if
	20	it matches, nonzero if not. */
	21	static int FCT (const CHAR pattern, const CHAR string,
	22	int no_leading_period, int flags) internal_function;
	23
	24	static int
	25	internal_function
	26	FCT (pattern, string, no_leading_period, flags)
	27	const CHAR *pattern;
	28	const CHAR *string;
	29	int no_leading_period;
	30	int flags;
	31	{
	32	register const CHAR p = pattern, n = string;
	33	register UCHAR c;
	34
	35	while ((c = *p++) != L('\0'))
	36	{
	37	c = FOLD (c);
	38
	39	switch (c)
	40	{
	41	case L('?'):
	42	if (*n == L('\0'))
	43	return FNM_NOMATCH;
	44	else if (*n == L('/') && (flags & FNM_FILE_NAME))
	45	return FNM_NOMATCH;
	46	else if (*n == L('.') && no_leading_period
	47	&& (n == string
	48	\|\| (n[-1] == L('/') && (flags & FNM_FILE_NAME))))
	49	return FNM_NOMATCH;
	50	break;
	51
	52	case L('\\'):
	53	if (!(flags & FNM_NOESCAPE))
	54	{
	55	c = *p++;
	56	if (c == L('\0'))
	57	/* Trailing \ loses. */
	58	return FNM_NOMATCH;
	59	c = FOLD (c);
	60	}
	61	if (FOLD ((UCHAR) *n) != c)
	62	return FNM_NOMATCH;
	63	break;
	64
65	case L('*'):
66	if (*n == L('.') && no_leading_period
67	&& (n == string
68	\|\| (n[-1] == L('/') && (flags & FNM_FILE_NAME))))
69	return FNM_NOMATCH;
70
71	for (c = p++; c == L('?') \|\| c == L(''); c = *p++)
72	{
73	if (*n == L('/') && (flags & FNM_FILE_NAME))
74	/* A slash does not match a wildcard under FNM_FILE_NAME. */
75	return FNM_NOMATCH;
76	else if (c == L('?'))
77	{
78	/* A ? needs to match one character. */
79	if (*n == L('\0'))
80	/* There isn't another character; no match. */
81	return FNM_NOMATCH;
82	else
83	/* One character of the string is consumed in matching
84	this ? wildcard, so *??? won't match if there are
85	less than three characters. */
86	++n;
87	}
88	}
89
90	if (c == L('\0'))
91	/* The wildcard(s) is/are the last element of the pattern.
92	If the name is a file name and contains another slash
93	this does mean it cannot match. */
94	return ((flags & FNM_FILE_NAME) && STRCHR (n, L('/')) != NULL
95	? FNM_NOMATCH : 0);
96	else
97	{
98	const CHAR *endp;
99
100	endp = STRCHRNUL (n, (flags & FNM_FILE_NAME) ? L('/') : L('\0'));
101
102	if (c == L('['))
103	{
104	int flags2 = ((flags & FNM_FILE_NAME)
105	? flags : (flags & ~FNM_PERIOD));
106
107	for (--p; n < endp; ++n)
108	if (FCT (p, n, (no_leading_period
109	&& (n == string
110	\|\| (n[-1] == L('/')
111	&& (flags & FNM_FILE_NAME)))),
112	flags2) == 0)
113	return 0;
114	}
115	else if (c == L('/') && (flags & FNM_FILE_NAME))
116	{
117	while (n != L('\0') && n != L('/'))
118	++n;
119	if (*n == L('/')
120	&& (FCT (p, n + 1, flags & FNM_PERIOD, flags) == 0))
121	return 0;
122	}
123	else
124	{
125	int flags2 = ((flags & FNM_FILE_NAME)
126	? flags : (flags & ~FNM_PERIOD));
127
128	if (c == L('\\') && !(flags & FNM_NOESCAPE))
129	c = *p;
130	c = FOLD (c);
131	for (--p; n < endp; ++n)
132	if (FOLD ((UCHAR) *n) == c
133	&& (FCT (p, n, (no_leading_period
134	&& (n == string
135	\|\| (n[-1] == L('/')
136	&& (flags & FNM_FILE_NAME)))),
137	flags2) == 0))
138	return 0;
139	}
140	}
141
142	/* If we come here no match is possible with the wildcard. */
143	return FNM_NOMATCH;
144
145	case L('['):
146	{
147	/* Nonzero if the sense of the character class is inverted. */
148	static int posixly_correct;
149	register int not;
150	CHAR cold;
151
152	if (posixly_correct == 0)
153	posixly_correct = getenv ("POSIXLY_CORRECT") != NULL ? 1 : -1;
154
155	if (*n == L('\0'))
156	return FNM_NOMATCH;
157
158	if (*n == L('.') && no_leading_period
159	&& (n == string
160	\|\| (n[-1] == L('/') && (flags & FNM_FILE_NAME))))
161	return FNM_NOMATCH;
162
163	if (*n == L('/') && (flags & FNM_FILE_NAME))
164	/* `/' cannot be matched. */
165	return FNM_NOMATCH;
166
167	not = (p == L('!') \|\| (posixly_correct < 0 && p == L('^')));
168	if (not)
169	++p;
170
171	c = *p++;
172	for (;;)
173	{
174	UCHAR fn = FOLD ((UCHAR) *n);
175
176	if (!(flags & FNM_NOESCAPE) && c == L('\\'))
177	{
178	if (*p == L('\0'))
179	return FNM_NOMATCH;
180	c = FOLD ((UCHAR) *p);
181	++p;
182
183	if (c == fn)
184	goto matched;
185	}
186	else if (c == L('[') && *p == L(':'))
187	{
188	/* Leave room for the null. */
189	CHAR str[CHAR_CLASS_MAX_LENGTH + 1];
190	size_t c1 = 0;
191	# if defined _LIBC \|\| (defined HAVE_WCTYPE_H && defined HAVE_WCHAR_H)
192	wctype_t wt;
193	# endif
194	const CHAR *startp = p;
195
196	for (;;)
197	{
198	if (c1 == CHAR_CLASS_MAX_LENGTH)
199	/* The name is too long and therefore the pattern
200	is ill-formed. */
201	return FNM_NOMATCH;
202
203	c = *++p;
204	if (c == L(':') && p[1] == L(']'))
205	{
206	p += 2;
207	break;
208	}
209	if (c < L('a') \|\| c >= L('z'))
210	{
211	/* This cannot possibly be a character class name.
212	Match it as a normal range. */
213	p = startp;
214	c = L('[');
215	goto normal_bracket;
216	}
217	str[c1++] = c;
218	}
219	str[c1] = L('\0');
220
221	# if defined _LIBC \|\| (defined HAVE_WCTYPE_H && defined HAVE_WCHAR_H)
222	wt = IS_CHAR_CLASS (str);
223	if (wt == 0)
224	/* Invalid character class name. */
225	return FNM_NOMATCH;
226
227	if (__iswctype (__btowc ((UCHAR) *n), wt))
228	goto matched;
229	# else
230	if ((STREQ (str, L("alnum")) && ISALNUM ((UCHAR) *n))
231	\|\| (STREQ (str, L("alpha")) && ISALPHA ((UCHAR) *n))
232	\|\| (STREQ (str, L("blank")) && ISBLANK ((UCHAR) *n))
233	\|\| (STREQ (str, L("cntrl")) && ISCNTRL ((UCHAR) *n))
234	\|\| (STREQ (str, L("digit")) && ISDIGIT ((UCHAR) *n))
235	\|\| (STREQ (str, L("graph")) && ISGRAPH ((UCHAR) *n))
236	\|\| (STREQ (str, L("lower")) && ISLOWER ((UCHAR) *n))
237	\|\| (STREQ (str, L("print")) && ISPRINT ((UCHAR) *n))
238	\|\| (STREQ (str, L("punct")) && ISPUNCT ((UCHAR) *n))
239	\|\| (STREQ (str, L("space")) && ISSPACE ((UCHAR) *n))
240	\|\| (STREQ (str, L("upper")) && ISUPPER ((UCHAR) *n))
241	\|\| (STREQ (str, L("xdigit")) && ISXDIGIT ((UCHAR) *n)))
242	goto matched;
243	# endif
244	}
245	else if (c == L('\0'))
246	/* [ (unterminated) loses. */
247	return FNM_NOMATCH;
248	else
249	{
250	normal_bracket:
251	if (FOLD (c) == fn)
252	goto matched;
253
254	cold = c;
255	c = *p++;
256
257	if (c == L('-') && *p != L(']'))
258	{
259	/* It is a range. */
260	UCHAR cend = *p++;
261	if (!(flags & FNM_NOESCAPE) && cend == L('\\'))
262	cend = *p++;
263	if (cend == L('\0'))
264	return FNM_NOMATCH;
265
266	if (cold <= fn && fn <= FOLD (cend))
267	goto matched;
268
269	c = *p++;
270	}
271	}
272
273	if (c == L(']'))
274	break;
275	}
276
277	if (!not)
278	return FNM_NOMATCH;
279	break;
280
281	matched:
282	/* Skip the rest of the [...] that already matched. */
283	while (c != L(']'))
284	{
285	if (c == L('\0'))
286	/* [... (unterminated) loses. */
287	return FNM_NOMATCH;
288
289	c = *p++;
290	if (!(flags & FNM_NOESCAPE) && c == L('\\'))
291	{
292	if (*p == L('\0'))
293	return FNM_NOMATCH;
294	/* XXX 1003.2d11 is unclear if this is right. */
295	++p;
296	}
297	else if (c == L('[') && *p == L(':'))
298	{
299	do
300	if (*++p == L('\0'))
301	return FNM_NOMATCH;
302	while (*p != L(':') \|\| p[1] == L(']'));
303	p += 2;
304	c = *p;
305	}
306	}
307	if (not)
308	return FNM_NOMATCH;
309	}
310	break;
311
312	default:
313	if (c != FOLD ((UCHAR) *n))
314	return FNM_NOMATCH;
315	}
316
317	++n;
318	}
319
320	if (*n == '\0')
321	return 0;
322
323	if ((flags & FNM_LEADING_DIR) && *n == L('/'))
324	/* The FNM_LEADING_DIR flag says that "foo" matches "foobar/frobozz". /
325	return 0;
326
327	return FNM_NOMATCH;
328
329	#undef FOLD
330	#undef CHAR
331	#undef UCHAR
332	#undef FCT
333	#undef STRCHR
334	#undef STRCHRNUL
335	#undef L
336	}