aixiao/rm_
1
0
Fork 0
Code Issues Pull Requests Projects Releases 3 Wiki Activity
31280c8475
rm_/lib/fnmatch_loop.c

1212 lines
45 KiB
C
Raw Normal View History

coreutils 9.1 version
2022-07-28 14:16:50 +08:00
/* Copyright (C) 1991-2022 Free Software Foundation, Inc.
based on coreutils-8.32
2020-09-02 16:47:03 +08:00
This file is part of the GNU C Library.
coreutils 9.1 version
2022-07-28 14:16:50 +08:00
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
based on coreutils-8.32
2020-09-02 16:47:03 +08:00
coreutils 9.1 version
2022-07-28 14:16:50 +08:00
The GNU C Library is distributed in the hope that it will be useful,
based on coreutils-8.32
2020-09-02 16:47:03 +08:00
but WITHOUT ANY WARRANTY; without even the implied warranty of
coreutils 9.1 version
2022-07-28 14:16:50 +08:00
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
based on coreutils-8.32
2020-09-02 16:47:03 +08:00
coreutils 9.1 version
2022-07-28 14:16:50 +08:00
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<https://www.gnu.org/licenses/>. */
#ifdef _LIBC
# include <stdint.h>
#endif
struct STRUCT
{
const CHAR *pattern;
const CHAR *string;
bool no_leading_period;
};
based on coreutils-8.32
2020-09-02 16:47:03 +08:00
/* Match STRING against the file name pattern PATTERN, returning zero if
it matches, nonzero if not. */
coreutils 9.1 version
2022-07-28 14:16:50 +08:00
static int FCT (const CHAR *pattern, const CHAR *string,
const CHAR *string_end, bool no_leading_period, int flags,
struct STRUCT *ends, size_t alloca_used);
based on coreutils-8.32
2020-09-02 16:47:03 +08:00
static int EXT (INT opt, const CHAR *pattern, const CHAR *string,
coreutils 9.1 version
2022-07-28 14:16:50 +08:00
const CHAR *string_end, bool no_leading_period, int flags,
size_t alloca_used);
static const CHAR *END (const CHAR *patternp);
based on coreutils-8.32
2020-09-02 16:47:03 +08:00
static int
FCT (const CHAR *pattern, const CHAR *string, const CHAR *string_end,
coreutils 9.1 version
2022-07-28 14:16:50 +08:00
bool no_leading_period, int flags, struct STRUCT *ends, size_t alloca_used)
based on coreutils-8.32
2020-09-02 16:47:03 +08:00
{
coreutils 9.1 version
2022-07-28 14:16:50 +08:00
const CHAR *p = pattern, *n = string;
UCHAR c;
based on coreutils-8.32
2020-09-02 16:47:03 +08:00
#ifdef _LIBC
# if WIDE_CHAR_VERSION
const char *collseq = (const char *)
_NL_CURRENT(LC_COLLATE, _NL_COLLATE_COLLSEQWC);
# else
const UCHAR *collseq = (const UCHAR *)
_NL_CURRENT(LC_COLLATE, _NL_COLLATE_COLLSEQMB);
# endif
#endif
while ((c = *p++) != L_('\0'))
{
bool new_no_leading_period = false;
c = FOLD (c);
switch (c)
{
case L_('?'):
coreutils 9.1 version
2022-07-28 14:16:50 +08:00
if (__glibc_unlikely (flags & FNM_EXTMATCH) && *p == '(')
based on coreutils-8.32
2020-09-02 16:47:03 +08:00
{
coreutils 9.1 version
2022-07-28 14:16:50 +08:00
int res = EXT (c, p, n, string_end, no_leading_period,
flags, alloca_used);
based on coreutils-8.32
2020-09-02 16:47:03 +08:00
if (res != -1)
return res;
}
if (n == string_end)
return FNM_NOMATCH;
else if (*n == L_('/') && (flags & FNM_FILE_NAME))
return FNM_NOMATCH;
else if (*n == L_('.') && no_leading_period)
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 (n == string_end || FOLD ((UCHAR) *n) != c)
return FNM_NOMATCH;
break;
case L_('*'):
coreutils 9.1 version
2022-07-28 14:16:50 +08:00
if (__glibc_unlikely (flags & FNM_EXTMATCH) && *p == '(')
based on coreutils-8.32
2020-09-02 16:47:03 +08:00
{
coreutils 9.1 version
2022-07-28 14:16:50 +08:00
int res = EXT (c, p, n, string_end, no_leading_period,
flags, alloca_used);
based on coreutils-8.32
2020-09-02 16:47:03 +08:00
if (res != -1)
return res;
}
coreutils 9.1 version
2022-07-28 14:16:50 +08:00
else if (ends != NULL)
{
ends->pattern = p - 1;
ends->string = n;
ends->no_leading_period = no_leading_period;
return 0;
}
based on coreutils-8.32
2020-09-02 16:47:03 +08:00
if (n != string_end && *n == L_('.') && no_leading_period)
return FNM_NOMATCH;
for (c = *p++; c == L_('?') || c == L_('*'); c = *p++)
{
if (*p == L_('(') && (flags & FNM_EXTMATCH) != 0)
{
const CHAR *endp = END (p);
if (endp != p)
{
/* This is a pattern. Skip over it. */
p = endp;
continue;
}
}
if (c == L_('?'))
{
/* A ? needs to match one character. */
if (n == string_end)
/* There isn't another character; no match. */
return FNM_NOMATCH;
else if (*n == L_('/')
coreutils 9.1 version
2022-07-28 14:16:50 +08:00
&& __glibc_unlikely (flags & FNM_FILE_NAME))
based on coreutils-8.32
2020-09-02 16:47:03 +08:00
/* A slash does not match a wildcard under
FNM_FILE_NAME. */
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 means it cannot match, unless the FNM_LEADING_DIR
flag is set. */
{
int result = (flags & FNM_FILE_NAME) == 0 ? 0 : FNM_NOMATCH;
if (flags & FNM_FILE_NAME)
{
if (flags & FNM_LEADING_DIR)
result = 0;
else
{
if (MEMCHR (n, L_('/'), string_end - n) == NULL)
result = 0;
}
}
return result;
}
else
{
const CHAR *endp;
coreutils 9.1 version
2022-07-28 14:16:50 +08:00
struct STRUCT end;
based on coreutils-8.32
2020-09-02 16:47:03 +08:00
coreutils 9.1 version
2022-07-28 14:16:50 +08:00
end.pattern = NULL;
based on coreutils-8.32
2020-09-02 16:47:03 +08:00
endp = MEMCHR (n, (flags & FNM_FILE_NAME) ? L_('/') : L_('\0'),
string_end - n);
if (endp == NULL)
endp = string_end;
if (c == L_('[')
coreutils 9.1 version
2022-07-28 14:16:50 +08:00
|| (__glibc_unlikely (flags & FNM_EXTMATCH)
based on coreutils-8.32
2020-09-02 16:47:03 +08:00
&& (c == L_('@') || c == L_('+') || c == L_('!'))
&& *p == L_('(')))
{
int flags2 = ((flags & FNM_FILE_NAME)
? flags : (flags & ~FNM_PERIOD));
coreutils 9.1 version
2022-07-28 14:16:50 +08:00
for (--p; n < endp; ++n, no_leading_period = false)
if (FCT (p, n, string_end, no_leading_period, flags2,
&end, alloca_used) == 0)
goto found;
based on coreutils-8.32
2020-09-02 16:47:03 +08:00
}
else if (c == L_('/') && (flags & FNM_FILE_NAME))
{
while (n < string_end && *n != L_('/'))
++n;
if (n < string_end && *n == L_('/')
coreutils 9.1 version
2022-07-28 14:16:50 +08:00
&& (FCT (p, n + 1, string_end, flags & FNM_PERIOD, flags,
NULL, alloca_used) == 0))
based on coreutils-8.32
2020-09-02 16:47:03 +08:00
return 0;
}
else
{
int flags2 = ((flags & FNM_FILE_NAME)
? flags : (flags & ~FNM_PERIOD));
if (c == L_('\\') && !(flags & FNM_NOESCAPE))
c = *p;
c = FOLD (c);
coreutils 9.1 version
2022-07-28 14:16:50 +08:00
for (--p; n < endp; ++n, no_leading_period = false)
based on coreutils-8.32
2020-09-02 16:47:03 +08:00
if (FOLD ((UCHAR) *n) == c
coreutils 9.1 version
2022-07-28 14:16:50 +08:00
&& (FCT (p, n, string_end, no_leading_period, flags2,
&end, alloca_used) == 0))
{
found:
if (end.pattern == NULL)
return 0;
break;
}
if (end.pattern != NULL)
{
p = end.pattern;
n = end.string;
no_leading_period = end.no_leading_period;
continue;
}
based on coreutils-8.32
2020-09-02 16:47:03 +08:00
}
}
/* 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. */
const CHAR *p_init = p;
const CHAR *n_init = n;
coreutils 9.1 version
2022-07-28 14:16:50 +08:00
bool not;
based on coreutils-8.32
2020-09-02 16:47:03 +08:00
CHAR cold;
UCHAR fn;
if (posixly_correct == 0)
posixly_correct = getenv ("POSIXLY_CORRECT") != NULL ? 1 : -1;
if (n == string_end)
return FNM_NOMATCH;
if (*n == L_('.') && no_leading_period)
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;
fn = FOLD ((UCHAR) *n);
c = *p++;
for (;;)
{
if (!(flags & FNM_NOESCAPE) && c == L_('\\'))
{
if (*p == L_('\0'))
return FNM_NOMATCH;
c = FOLD ((UCHAR) *p);
++p;
goto normal_bracket;
}
else if (c == L_('[') && *p == L_(':'))
{
/* Leave room for the null. */
CHAR str[CHAR_CLASS_MAX_LENGTH + 1];
size_t c1 = 0;
wctype_t wt;
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');
wt = IS_CHAR_CLASS (str);
if (wt == 0)
/* Invalid character class name. */
return FNM_NOMATCH;
coreutils 9.1 version
2022-07-28 14:16:50 +08:00
#if defined _LIBC && ! WIDE_CHAR_VERSION
based on coreutils-8.32
2020-09-02 16:47:03 +08:00
/* The following code is glibc specific but does
there a good job in speeding up the code since
we can avoid the btowc() call. */
if (_ISCTYPE ((UCHAR) *n, wt))
goto matched;
#else
coreutils 9.1 version
2022-07-28 14:16:50 +08:00
if (iswctype (BTOWC ((UCHAR) *n), wt))
based on coreutils-8.32
2020-09-02 16:47:03 +08:00
goto matched;
#endif
c = *p++;
}
#ifdef _LIBC
else if (c == L_('[') && *p == L_('='))
{
coreutils 9.1 version
2022-07-28 14:16:50 +08:00
/* It's important that STR be a scalar variable rather
than a one-element array, because GCC (at least 4.9.2
-O2 on x86-64) can be confused by the array and
diagnose a "used initialized" in a dead branch in the
findidx function. */
UCHAR str;
based on coreutils-8.32
2020-09-02 16:47:03 +08:00
uint32_t nrules =
_NL_CURRENT_WORD (LC_COLLATE, _NL_COLLATE_NRULES);
const CHAR *startp = p;
c = *++p;
if (c == L_('\0'))
{
p = startp;
c = L_('[');
goto normal_bracket;
}
coreutils 9.1 version
2022-07-28 14:16:50 +08:00
str = c;
based on coreutils-8.32
2020-09-02 16:47:03 +08:00
c = *++p;
if (c != L_('=') || p[1] != L_(']'))
{
p = startp;
c = L_('[');
goto normal_bracket;
}
p += 2;
if (nrules == 0)
{
coreutils 9.1 version
2022-07-28 14:16:50 +08:00
if ((UCHAR) *n == str)
based on coreutils-8.32
2020-09-02 16:47:03 +08:00
goto matched;
}
else
{
const int32_t *table;
# if WIDE_CHAR_VERSION
const int32_t *weights;
coreutils 9.1 version
2022-07-28 14:16:50 +08:00
const wint_t *extra;
based on coreutils-8.32
2020-09-02 16:47:03 +08:00
# else
const unsigned char *weights;
const unsigned char *extra;
# endif
const int32_t *indirect;
int32_t idx;
coreutils 9.1 version
2022-07-28 14:16:50 +08:00
const UCHAR *cp = (const UCHAR *) &str;
based on coreutils-8.32
2020-09-02 16:47:03 +08:00
# if WIDE_CHAR_VERSION
table = (const int32_t *)
_NL_CURRENT (LC_COLLATE, _NL_COLLATE_TABLEWC);
weights = (const int32_t *)
_NL_CURRENT (LC_COLLATE, _NL_COLLATE_WEIGHTWC);
coreutils 9.1 version
2022-07-28 14:16:50 +08:00
extra = (const wint_t *)
based on coreutils-8.32
2020-09-02 16:47:03 +08:00
_NL_CURRENT (LC_COLLATE, _NL_COLLATE_EXTRAWC);
indirect = (const int32_t *)
_NL_CURRENT (LC_COLLATE, _NL_COLLATE_INDIRECTWC);
# else
table = (const int32_t *)
_NL_CURRENT (LC_COLLATE, _NL_COLLATE_TABLEMB);
weights = (const unsigned char *)
_NL_CURRENT (LC_COLLATE, _NL_COLLATE_WEIGHTMB);
extra = (const unsigned char *)
_NL_CURRENT (LC_COLLATE, _NL_COLLATE_EXTRAMB);
indirect = (const int32_t *)
_NL_CURRENT (LC_COLLATE, _NL_COLLATE_INDIRECTMB);
# endif
coreutils 9.1 version
2022-07-28 14:16:50 +08:00
idx = FINDIDX (table, indirect, extra, &cp, 1);
based on coreutils-8.32
2020-09-02 16:47:03 +08:00
if (idx != 0)
{
/* We found a table entry. Now see whether the
character we are currently at has the same
equivalence class value. */
int len = weights[idx & 0xffffff];
int32_t idx2;
const UCHAR *np = (const UCHAR *) n;
coreutils 9.1 version
2022-07-28 14:16:50 +08:00
idx2 = FINDIDX (table, indirect, extra,
&np, string_end - n);
based on coreutils-8.32
2020-09-02 16:47:03 +08:00
if (idx2 != 0
&& (idx >> 24) == (idx2 >> 24)
&& len == weights[idx2 & 0xffffff])
{
int cnt = 0;
idx &= 0xffffff;
idx2 &= 0xffffff;
while (cnt < len
&& (weights[idx + 1 + cnt]
== weights[idx2 + 1 + cnt]))
++cnt;
if (cnt == len)
goto matched;
}
}
}
c = *p++;
}
#endif
else if (c == L_('\0'))
{
/* [ unterminated, treat as normal character. */
p = p_init;
n = n_init;
c = L_('[');
goto normal_match;
}
else
{
coreutils 9.1 version
2022-07-28 14:16:50 +08:00
bool is_range = false;
based on coreutils-8.32
2020-09-02 16:47:03 +08:00
#ifdef _LIBC
bool is_seqval = false;
if (c == L_('[') && *p == L_('.'))
{
uint32_t nrules =
_NL_CURRENT_WORD (LC_COLLATE, _NL_COLLATE_NRULES);
const CHAR *startp = p;
size_t c1 = 0;
while (1)
{
c = *++p;
if (c == L_('.') && p[1] == L_(']'))
{
p += 2;
break;
}
if (c == '\0')
return FNM_NOMATCH;
++c1;
}
/* We have to handling the symbols differently in
ranges since then the collation sequence is
important. */
is_range = *p == L_('-') && p[1] != L_('\0');
if (nrules == 0)
{
/* There are no names defined in the collation
data. Therefore we only accept the trivial
names consisting of the character itself. */
if (c1 != 1)
return FNM_NOMATCH;
if (!is_range && *n == startp[1])
goto matched;
cold = startp[1];
c = *p++;
}
else
{
int32_t table_size;
const int32_t *symb_table;
const unsigned char *extra;
int32_t idx;
int32_t elem;
coreutils 9.1 version
2022-07-28 14:16:50 +08:00
# if WIDE_CHAR_VERSION
CHAR *wextra;
based on coreutils-8.32
2020-09-02 16:47:03 +08:00
# endif
table_size =
_NL_CURRENT_WORD (LC_COLLATE,
_NL_COLLATE_SYMB_HASH_SIZEMB);
symb_table = (const int32_t *)
_NL_CURRENT (LC_COLLATE,
_NL_COLLATE_SYMB_TABLEMB);
extra = (const unsigned char *)
_NL_CURRENT (LC_COLLATE,
_NL_COLLATE_SYMB_EXTRAMB);
coreutils 9.1 version
2022-07-28 14:16:50 +08:00
for (elem = 0; elem < table_size; elem++)
if (symb_table[2 * elem] != 0)
{
idx = symb_table[2 * elem + 1];
/* Skip the name of collating element. */
idx += 1 + extra[idx];
# if WIDE_CHAR_VERSION
/* Skip the byte sequence of the
collating element. */
idx += 1 + extra[idx];
/* Adjust for the alignment. */
idx = (idx + 3) & ~3;
wextra = (CHAR *) &extra[idx + 4];
if (/* Compare the length of the sequence. */
c1 == wextra[0]
/* Compare the wide char sequence. */
&& (__wmemcmp (startp + 1, &wextra[1],
c1)
== 0))
/* Yep, this is the entry. */
break;
# else
if (/* Compare the length of the sequence. */
c1 == extra[idx]
/* Compare the byte sequence. */
&& memcmp (startp + 1,
&extra[idx + 1], c1) == 0)
/* Yep, this is the entry. */
break;
# endif
}
based on coreutils-8.32
2020-09-02 16:47:03 +08:00
coreutils 9.1 version
2022-07-28 14:16:50 +08:00
if (elem < table_size)
based on coreutils-8.32
2020-09-02 16:47:03 +08:00
{
/* Compare the byte sequence but only if
this is not part of a range. */
coreutils 9.1 version
2022-07-28 14:16:50 +08:00
if (! is_range
based on coreutils-8.32
2020-09-02 16:47:03 +08:00
coreutils 9.1 version
2022-07-28 14:16:50 +08:00
# if WIDE_CHAR_VERSION
&& __wmemcmp (n, &wextra[1], c1) == 0
based on coreutils-8.32
2020-09-02 16:47:03 +08:00
# else
coreutils 9.1 version
2022-07-28 14:16:50 +08:00
&& memcmp (n, &extra[idx + 1], c1) == 0
based on coreutils-8.32
2020-09-02 16:47:03 +08:00
# endif
coreutils 9.1 version
2022-07-28 14:16:50 +08:00
)
{
n += c1 - 1;
goto matched;
based on coreutils-8.32
2020-09-02 16:47:03 +08:00
}
/* Get the collation sequence value. */
is_seqval = true;
coreutils 9.1 version
2022-07-28 14:16:50 +08:00
# if WIDE_CHAR_VERSION
cold = wextra[1 + wextra[0]];
based on coreutils-8.32
2020-09-02 16:47:03 +08:00
# else
idx += 1 + extra[idx];
coreutils 9.1 version
2022-07-28 14:16:50 +08:00
/* Adjust for the alignment. */
idx = (idx + 3) & ~3;
based on coreutils-8.32
2020-09-02 16:47:03 +08:00
cold = *((int32_t *) &extra[idx]);
# endif
c = *p++;
}
else if (c1 == 1)
{
/* No valid character. Match it as a
single byte. */
coreutils 9.1 version
2022-07-28 14:16:50 +08:00
if (!is_range && *n == startp[1])
based on coreutils-8.32
2020-09-02 16:47:03 +08:00
goto matched;
coreutils 9.1 version
2022-07-28 14:16:50 +08:00
cold = startp[1];
based on coreutils-8.32
2020-09-02 16:47:03 +08:00
c = *p++;
}
else
return FNM_NOMATCH;
}
}
else
#endif
{
c = FOLD (c);
normal_bracket:
/* We have to handling the symbols differently in
ranges since then the collation sequence is
important. */
is_range = (*p == L_('-') && p[1] != L_('\0')
&& p[1] != L_(']'));
if (!is_range && c == fn)
goto matched;
#if _LIBC
/* This is needed if we goto normal_bracket; from
outside of is_seqval's scope. */
is_seqval = false;
#endif
cold = c;
c = *p++;
}
if (c == L_('-') && *p != L_(']'))
{
#if _LIBC
/* We have to find the collation sequence
value for C. Collation sequence is nothing
we can regularly access. The sequence
value is defined by the order in which the
definitions of the collation values for the
various characters appear in the source
file. A strange concept, nowhere
documented. */
uint32_t fcollseq;
uint32_t lcollseq;
UCHAR cend = *p++;
coreutils 9.1 version
2022-07-28 14:16:50 +08:00
# if WIDE_CHAR_VERSION
based on coreutils-8.32
2020-09-02 16:47:03 +08:00
/* Search in the 'names' array for the characters. */
fcollseq = __collseq_table_lookup (collseq, fn);
if (fcollseq == ~((uint32_t) 0))
/* XXX We don't know anything about the character
we are supposed to match. This means we are
failing. */
goto range_not_matched;
if (is_seqval)
lcollseq = cold;
else
lcollseq = __collseq_table_lookup (collseq, cold);
# else
fcollseq = collseq[fn];
lcollseq = is_seqval ? cold : collseq[(UCHAR) cold];
# endif
is_seqval = false;
if (cend == L_('[') && *p == L_('.'))
{
uint32_t nrules =
_NL_CURRENT_WORD (LC_COLLATE,
_NL_COLLATE_NRULES);
const CHAR *startp = p;
size_t c1 = 0;
while (1)
{
c = *++p;
if (c == L_('.') && p[1] == L_(']'))
{
p += 2;
break;
}
if (c == '\0')
return FNM_NOMATCH;
++c1;
}
if (nrules == 0)
{
/* There are no names defined in the
collation data. Therefore we only
accept the trivial names consisting
of the character itself. */
if (c1 != 1)
return FNM_NOMATCH;
cend = startp[1];
}
else
{
int32_t table_size;
const int32_t *symb_table;
const unsigned char *extra;
int32_t idx;
int32_t elem;
coreutils 9.1 version
2022-07-28 14:16:50 +08:00
# if WIDE_CHAR_VERSION
CHAR *wextra;
based on coreutils-8.32
2020-09-02 16:47:03 +08:00
# endif
table_size =
_NL_CURRENT_WORD (LC_COLLATE,
_NL_COLLATE_SYMB_HASH_SIZEMB);
symb_table = (const int32_t *)
_NL_CURRENT (LC_COLLATE,
_NL_COLLATE_SYMB_TABLEMB);
extra = (const unsigned char *)
_NL_CURRENT (LC_COLLATE,
_NL_COLLATE_SYMB_EXTRAMB);
coreutils 9.1 version
2022-07-28 14:16:50 +08:00
for (elem = 0; elem < table_size; elem++)
if (symb_table[2 * elem] != 0)
{
idx = symb_table[2 * elem + 1];
/* Skip the name of collating
element. */
idx += 1 + extra[idx];
# if WIDE_CHAR_VERSION
/* Skip the byte sequence of the
collating element. */
idx += 1 + extra[idx];
/* Adjust for the alignment. */
idx = (idx + 3) & ~3;
wextra = (CHAR *) &extra[idx + 4];
if (/* Compare the length of the
sequence. */
c1 == wextra[0]
/* Compare the wide char sequence. */
&& (__wmemcmp (startp + 1,
&wextra[1], c1)
== 0))
/* Yep, this is the entry. */
break;
# else
if (/* Compare the length of the
sequence. */
c1 == extra[idx]
/* Compare the byte sequence. */
&& memcmp (startp + 1,
&extra[idx + 1], c1) == 0)
/* Yep, this is the entry. */
break;
# endif
}
based on coreutils-8.32
2020-09-02 16:47:03 +08:00
coreutils 9.1 version
2022-07-28 14:16:50 +08:00
if (elem < table_size)
based on coreutils-8.32
2020-09-02 16:47:03 +08:00
{
/* Get the collation sequence value. */
is_seqval = true;
coreutils 9.1 version
2022-07-28 14:16:50 +08:00
# if WIDE_CHAR_VERSION
cend = wextra[1 + wextra[0]];
based on coreutils-8.32
2020-09-02 16:47:03 +08:00
# else
idx += 1 + extra[idx];
coreutils 9.1 version
2022-07-28 14:16:50 +08:00
/* Adjust for the alignment. */
idx = (idx + 3) & ~3;
based on coreutils-8.32
2020-09-02 16:47:03 +08:00
cend = *((int32_t *) &extra[idx]);
# endif
}
coreutils 9.1 version
2022-07-28 14:16:50 +08:00
else if (c1 == 1)
based on coreutils-8.32
2020-09-02 16:47:03 +08:00
{
coreutils 9.1 version
2022-07-28 14:16:50 +08:00
cend = startp[1];
based on coreutils-8.32
2020-09-02 16:47:03 +08:00
c = *p++;
}
else
return FNM_NOMATCH;
}
}
else
{
if (!(flags & FNM_NOESCAPE) && cend == L_('\\'))
cend = *p++;
if (cend == L_('\0'))
return FNM_NOMATCH;
cend = FOLD (cend);
}
/* XXX It is not entirely clear to me how to handle
characters which are not mentioned in the
collation specification. */
if (
coreutils 9.1 version
2022-07-28 14:16:50 +08:00
# if WIDE_CHAR_VERSION
based on coreutils-8.32
2020-09-02 16:47:03 +08:00
lcollseq == 0xffffffff ||
# endif
lcollseq <= fcollseq)
{
/* We have to look at the upper bound. */
uint32_t hcollseq;
if (is_seqval)
hcollseq = cend;
else
{
coreutils 9.1 version
2022-07-28 14:16:50 +08:00
# if WIDE_CHAR_VERSION
based on coreutils-8.32
2020-09-02 16:47:03 +08:00
hcollseq =
__collseq_table_lookup (collseq, cend);
if (hcollseq == ~((uint32_t) 0))
{
/* Hum, no information about the upper
bound. The matching succeeds if the
lower bound is matched exactly. */
if (lcollseq != fcollseq)
goto range_not_matched;
goto matched;
}
# else
hcollseq = collseq[cend];
# endif
}
if (lcollseq <= hcollseq && fcollseq <= hcollseq)
goto matched;
}
coreutils 9.1 version
2022-07-28 14:16:50 +08:00
# if WIDE_CHAR_VERSION
based on coreutils-8.32
2020-09-02 16:47:03 +08:00
range_not_matched:
# endif
#else
/* We use a boring value comparison of the character
values. This is better than comparing using
'strcoll' since the latter would have surprising
and sometimes fatal consequences. */
UCHAR cend = *p++;
if (!(flags & FNM_NOESCAPE) && cend == L_('\\'))
cend = *p++;
if (cend == L_('\0'))
return FNM_NOMATCH;
/* It is a range. */
coreutils 9.1 version
2022-07-28 14:16:50 +08:00
if ((UCHAR) cold <= fn && fn <= cend)
based on coreutils-8.32
2020-09-02 16:47:03 +08:00
goto matched;
#endif
c = *p++;
}
}
if (c == L_(']'))
break;
}
if (!not)
return FNM_NOMATCH;
break;
matched:
/* Skip the rest of the [...] that already matched. */
coreutils 9.1 version
2022-07-28 14:16:50 +08:00
while ((c = *p++) != L_(']'))
based on coreutils-8.32
2020-09-02 16:47:03 +08:00
{
if (c == L_('\0'))
/* [... (unterminated) loses. */
return FNM_NOMATCH;
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_(':'))
{
int c1 = 0;
const CHAR *startp = p;
while (1)
{
c = *++p;
if (++c1 == CHAR_CLASS_MAX_LENGTH)
return FNM_NOMATCH;
if (*p == L_(':') && p[1] == L_(']'))
break;
if (c < L_('a') || c >= L_('z'))
{
coreutils 9.1 version
2022-07-28 14:16:50 +08:00
p = startp - 2;
break;
based on coreutils-8.32
2020-09-02 16:47:03 +08:00
}
}
p += 2;
}
else if (c == L_('[') && *p == L_('='))
{
c = *++p;
if (c == L_('\0'))
return FNM_NOMATCH;
c = *++p;
if (c != L_('=') || p[1] != L_(']'))
return FNM_NOMATCH;
p += 2;
}
else if (c == L_('[') && *p == L_('.'))
{
while (1)
{
c = *++p;
coreutils 9.1 version
2022-07-28 14:16:50 +08:00
if (c == L_('\0'))
based on coreutils-8.32
2020-09-02 16:47:03 +08:00
return FNM_NOMATCH;
coreutils 9.1 version
2022-07-28 14:16:50 +08:00
if (c == L_('.') && p[1] == L_(']'))
based on coreutils-8.32
2020-09-02 16:47:03 +08:00
break;
}
p += 2;
}
}
if (not)
return FNM_NOMATCH;
}
break;
case L_('+'):
case L_('@'):
case L_('!'):
coreutils 9.1 version
2022-07-28 14:16:50 +08:00
if (__glibc_unlikely (flags & FNM_EXTMATCH) && *p == '(')
based on coreutils-8.32
2020-09-02 16:47:03 +08:00
{
coreutils 9.1 version
2022-07-28 14:16:50 +08:00
int res = EXT (c, p, n, string_end, no_leading_period, flags,
alloca_used);
based on coreutils-8.32
2020-09-02 16:47:03 +08:00
if (res != -1)
return res;
}
goto normal_match;
case L_('/'):
if (NO_LEADING_PERIOD (flags))
{
if (n == string_end || c != (UCHAR) *n)
return FNM_NOMATCH;
new_no_leading_period = true;
break;
}
FALLTHROUGH;
default:
normal_match:
if (n == string_end || c != FOLD ((UCHAR) *n))
return FNM_NOMATCH;
}
no_leading_period = new_no_leading_period;
++n;
}
if (n == string_end)
return 0;
if ((flags & FNM_LEADING_DIR) && n != string_end && *n == L_('/'))
/* The FNM_LEADING_DIR flag says that "foo*" matches "foobar/frobozz". */
return 0;
return FNM_NOMATCH;
}
static const CHAR *
END (const CHAR *pattern)
{
const CHAR *p = pattern;
while (1)
if (*++p == L_('\0'))
/* This is an invalid pattern. */
return pattern;
else if (*p == L_('['))
{
/* Handle brackets special. */
if (posixly_correct == 0)
posixly_correct = getenv ("POSIXLY_CORRECT") != NULL ? 1 : -1;
/* Skip the not sign. We have to recognize it because of a possibly
following ']'. */
if (*++p == L_('!') || (posixly_correct < 0 && *p == L_('^')))
++p;
/* A leading ']' is recognized as such. */
if (*p == L_(']'))
++p;
/* Skip over all characters of the list. */
while (*p != L_(']'))
if (*p++ == L_('\0'))
/* This is no valid pattern. */
return pattern;
}
else if ((*p == L_('?') || *p == L_('*') || *p == L_('+') || *p == L_('@')
|| *p == L_('!')) && p[1] == L_('('))
coreutils 9.1 version
2022-07-28 14:16:50 +08:00
{
p = END (p + 1);
if (*p == L_('\0'))
/* This is an invalid pattern. */
return pattern;
}
based on coreutils-8.32
2020-09-02 16:47:03 +08:00
else if (*p == L_(')'))
break;
return p + 1;
}
static int
EXT (INT opt, const CHAR *pattern, const CHAR *string, const CHAR *string_end,
coreutils 9.1 version
2022-07-28 14:16:50 +08:00
bool no_leading_period, int flags, size_t alloca_used)
based on coreutils-8.32
2020-09-02 16:47:03 +08:00
{
const CHAR *startp;
coreutils 9.1 version
2022-07-28 14:16:50 +08:00
ptrdiff_t level;
based on coreutils-8.32
2020-09-02 16:47:03 +08:00
struct patternlist
{
struct patternlist *next;
coreutils 9.1 version
2022-07-28 14:16:50 +08:00
CHAR malloced;
CHAR str __flexarr;
based on coreutils-8.32
2020-09-02 16:47:03 +08:00
} *list = NULL;
struct patternlist **lastp = &list;
size_t pattern_len = STRLEN (pattern);
coreutils 9.1 version
2022-07-28 14:16:50 +08:00
bool any_malloced = false;
based on coreutils-8.32
2020-09-02 16:47:03 +08:00
const CHAR *p;
const CHAR *rs;
coreutils 9.1 version
2022-07-28 14:16:50 +08:00
int retval = 0;
based on coreutils-8.32
2020-09-02 16:47:03 +08:00
/* Parse the pattern. Store the individual parts in the list. */
level = 0;
coreutils 9.1 version
2022-07-28 14:16:50 +08:00
for (startp = p = pattern + 1; level >= 0; ++p)
based on coreutils-8.32
2020-09-02 16:47:03 +08:00
if (*p == L_('\0'))
coreutils 9.1 version
2022-07-28 14:16:50 +08:00
{
/* This is an invalid pattern. */
retval = -1;
goto out;
}
based on coreutils-8.32
2020-09-02 16:47:03 +08:00
else if (*p == L_('['))
{
/* Handle brackets special. */
if (posixly_correct == 0)
posixly_correct = getenv ("POSIXLY_CORRECT") != NULL ? 1 : -1;
/* Skip the not sign. We have to recognize it because of a possibly
following ']'. */
if (*++p == L_('!') || (posixly_correct < 0 && *p == L_('^')))
++p;
/* A leading ']' is recognized as such. */
if (*p == L_(']'))
++p;
/* Skip over all characters of the list. */
while (*p != L_(']'))
if (*p++ == L_('\0'))
coreutils 9.1 version
2022-07-28 14:16:50 +08:00
{
/* This is no valid pattern. */
retval = -1;
goto out;
}
based on coreutils-8.32
2020-09-02 16:47:03 +08:00
}
else if ((*p == L_('?') || *p == L_('*') || *p == L_('+') || *p == L_('@')
|| *p == L_('!')) && p[1] == L_('('))
/* Remember the nesting level. */
++level;
else if (*p == L_(')'))
{
if (level-- == 0)
{
/* This means we found the end of the pattern. */
#define NEW_PATTERN \
struct patternlist *newp; \
coreutils 9.1 version
2022-07-28 14:16:50 +08:00
size_t plen = (opt == L_('?') || opt == L_('@') \
? pattern_len : (p - startp + 1UL)); \
idx_t slen = FLEXSIZEOF (struct patternlist, str, 0); \
idx_t new_used = alloca_used + slen; \
idx_t plensize; \
if (INT_MULTIPLY_WRAPV (plen, sizeof (CHAR), &plensize) \
|| INT_ADD_WRAPV (new_used, plensize, &new_used)) \
{ \
retval = -2; \
goto out; \
} \
slen += plensize; \
bool malloced = ! __libc_use_alloca (new_used); \
if (__glibc_unlikely (malloced)) \
{ \
newp = malloc (slen); \
if (newp == NULL) \
{ \
retval = -2; \
goto out; \
} \
any_malloced = true; \
} \
else \
newp = alloca_account (slen, alloca_used); \
based on coreutils-8.32
2020-09-02 16:47:03 +08:00
newp->next = NULL; \
coreutils 9.1 version
2022-07-28 14:16:50 +08:00
newp->malloced = malloced; \
*((CHAR *) MEMPCPY (newp->str, startp, p - startp)) = L_('\0'); \
based on coreutils-8.32
2020-09-02 16:47:03 +08:00
*lastp = newp; \
lastp = &newp->next
NEW_PATTERN;
}
}
else if (*p == L_('|'))
{
if (level == 0)
{
NEW_PATTERN;
startp = p + 1;
}
}
assert (list != NULL);
assert (p[-1] == L_(')'));
#undef NEW_PATTERN
switch (opt)
{
case L_('*'):
coreutils 9.1 version
2022-07-28 14:16:50 +08:00
if (FCT (p, string, string_end, no_leading_period, flags, NULL,
alloca_used) == 0)
goto success;
based on coreutils-8.32
2020-09-02 16:47:03 +08:00
FALLTHROUGH;
case L_('+'):
do
{
for (rs = string; rs <= string_end; ++rs)
/* First match the prefix with the current pattern with the
current pattern. */
if (FCT (list->str, string, rs, no_leading_period,
coreutils 9.1 version
2022-07-28 14:16:50 +08:00
flags & FNM_FILE_NAME ? flags : flags & ~FNM_PERIOD,
NULL, alloca_used) == 0
based on coreutils-8.32
2020-09-02 16:47:03 +08:00
/* This was successful. Now match the rest with the rest
of the pattern. */
&& (FCT (p, rs, string_end,
rs == string
? no_leading_period
: rs[-1] == '/' && NO_LEADING_PERIOD (flags),
flags & FNM_FILE_NAME
coreutils 9.1 version
2022-07-28 14:16:50 +08:00
? flags : flags & ~FNM_PERIOD, NULL, alloca_used) == 0
based on coreutils-8.32
2020-09-02 16:47:03 +08:00
/* This didn't work. Try the whole pattern. */
|| (rs != string
&& FCT (pattern - 1, rs, string_end,
rs == string
? no_leading_period
: rs[-1] == '/' && NO_LEADING_PERIOD (flags),
flags & FNM_FILE_NAME
coreutils 9.1 version
2022-07-28 14:16:50 +08:00
? flags : flags & ~FNM_PERIOD, NULL,
alloca_used) == 0)))
based on coreutils-8.32
2020-09-02 16:47:03 +08:00
/* It worked. Signal success. */
coreutils 9.1 version
2022-07-28 14:16:50 +08:00
goto success;
based on coreutils-8.32
2020-09-02 16:47:03 +08:00
}
while ((list = list->next) != NULL);
/* None of the patterns lead to a match. */
coreutils 9.1 version
2022-07-28 14:16:50 +08:00
retval = FNM_NOMATCH;
break;
based on coreutils-8.32
2020-09-02 16:47:03 +08:00
case L_('?'):
coreutils 9.1 version
2022-07-28 14:16:50 +08:00
if (FCT (p, string, string_end, no_leading_period, flags, NULL,
alloca_used) == 0)
goto success;
based on coreutils-8.32
2020-09-02 16:47:03 +08:00
FALLTHROUGH;
case L_('@'):
do
/* I cannot believe it but 'strcat' is actually acceptable
here. Match the entire string with the prefix from the
pattern list and the rest of the pattern following the
pattern list. */
if (FCT (STRCAT (list->str, p), string, string_end,
no_leading_period,
coreutils 9.1 version
2022-07-28 14:16:50 +08:00
flags & FNM_FILE_NAME ? flags : flags & ~FNM_PERIOD,
NULL, alloca_used) == 0)
based on coreutils-8.32
2020-09-02 16:47:03 +08:00
/* It worked. Signal success. */
coreutils 9.1 version
2022-07-28 14:16:50 +08:00
goto success;
based on coreutils-8.32
2020-09-02 16:47:03 +08:00
while ((list = list->next) != NULL);
/* None of the patterns lead to a match. */
coreutils 9.1 version
2022-07-28 14:16:50 +08:00
retval = FNM_NOMATCH;
break;
based on coreutils-8.32
2020-09-02 16:47:03 +08:00
case L_('!'):
for (rs = string; rs <= string_end; ++rs)
{
struct patternlist *runp;
for (runp = list; runp != NULL; runp = runp->next)
if (FCT (runp->str, string, rs, no_leading_period,
coreutils 9.1 version
2022-07-28 14:16:50 +08:00
flags & FNM_FILE_NAME ? flags : flags & ~FNM_PERIOD,
NULL, alloca_used) == 0)
based on coreutils-8.32
2020-09-02 16:47:03 +08:00
break;
/* If none of the patterns matched see whether the rest does. */
if (runp == NULL
&& (FCT (p, rs, string_end,
rs == string
? no_leading_period
: rs[-1] == '/' && NO_LEADING_PERIOD (flags),
coreutils 9.1 version
2022-07-28 14:16:50 +08:00
flags & FNM_FILE_NAME ? flags : flags & ~FNM_PERIOD,
NULL, alloca_used) == 0))
based on coreutils-8.32
2020-09-02 16:47:03 +08:00
/* This is successful. */
coreutils 9.1 version
2022-07-28 14:16:50 +08:00
goto success;
based on coreutils-8.32
2020-09-02 16:47:03 +08:00
}
/* None of the patterns together with the rest of the pattern
lead to a match. */
coreutils 9.1 version
2022-07-28 14:16:50 +08:00
retval = FNM_NOMATCH;
break;
based on coreutils-8.32
2020-09-02 16:47:03 +08:00
default:
assert (! "Invalid extended matching operator");
coreutils 9.1 version
2022-07-28 14:16:50 +08:00
retval = -1;
based on coreutils-8.32
2020-09-02 16:47:03 +08:00
break;
}
coreutils 9.1 version
2022-07-28 14:16:50 +08:00
success:
out:
if (any_malloced)
while (list != NULL)
{
struct patternlist *old = list;
list = list->next;
if (old->malloced)
free (old);
}
return retval;
based on coreutils-8.32
2020-09-02 16:47:03 +08:00
}
#undef FOLD
#undef CHAR
#undef UCHAR
#undef INT
#undef FCT
#undef EXT
#undef END
coreutils 9.1 version
2022-07-28 14:16:50 +08:00
#undef STRUCT
based on coreutils-8.32
2020-09-02 16:47:03 +08:00
#undef MEMPCPY
#undef MEMCHR
#undef STRLEN
#undef STRCAT
#undef L_
#undef BTOWC
coreutils 9.1 version
2022-07-28 14:16:50 +08:00
#undef WIDE_CHAR_VERSION
#undef FINDIDX
Reference in New Issue Copy Permalink