1 /* Copyright (C) 1991,1992,1993,1996,1997,1998,1999,2000,2001,2003,2004,2005,
2 2007 Free Software Foundation, Inc.
3 This file is part of the GNU C Library.
5 The GNU C Library is free software; you can redistribute it and/or
6 modify it under the terms of the GNU Lesser General Public
7 License as published by the Free Software Foundation; either
8 version 2.1 of the License, or (at your option) any later version.
10 The GNU C Library is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 Lesser General Public License for more details.
15 You should have received a copy of the GNU Lesser General Public
16 License along with the GNU C Library; if not, write to the Free
17 Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
24 int no_leading_period
;
27 /* Match STRING against the filename pattern PATTERN, returning zero if
28 it matches, nonzero if not. */
29 static int FCT (const CHAR
*pattern
, const CHAR
*string
,
30 const CHAR
*string_end
, int no_leading_period
, int flags
,
33 static int EXT (INT opt
, const CHAR
*pattern
, const CHAR
*string
,
34 const CHAR
*string_end
, int no_leading_period
, int flags
)
36 static const CHAR
*END (const CHAR
*patternp
) internal_function
;
40 FCT (pattern
, string
, string_end
, no_leading_period
, flags
, ends
)
43 const CHAR
*string_end
;
44 int no_leading_period
;
48 register const CHAR
*p
= pattern
, *n
= string
;
51 # if WIDE_CHAR_VERSION
52 const char *collseq
= (const char *)
53 _NL_CURRENT(LC_COLLATE
, _NL_COLLATE_COLLSEQWC
);
55 const UCHAR
*collseq
= (const UCHAR
*)
56 _NL_CURRENT(LC_COLLATE
, _NL_COLLATE_COLLSEQMB
);
60 while ((c
= *p
++) != L('\0'))
62 int new_no_leading_period
= 0;
68 if (__builtin_expect (flags
& FNM_EXTMATCH
, 0) && *p
== '(')
72 res
= EXT (c
, p
, n
, string_end
, no_leading_period
,
80 else if (*n
== L('/') && (flags
& FNM_FILE_NAME
))
82 else if (*n
== L('.') && no_leading_period
)
87 if (!(flags
& FNM_NOESCAPE
))
91 /* Trailing \ loses. */
95 if (n
== string_end
|| FOLD ((UCHAR
) *n
) != c
)
100 if (__builtin_expect (flags
& FNM_EXTMATCH
, 0) && *p
== '(')
104 res
= EXT (c
, p
, n
, string_end
, no_leading_period
,
109 else if (ends
!= NULL
)
111 ends
->pattern
= p
- 1;
113 ends
->no_leading_period
= no_leading_period
;
117 if (n
!= string_end
&& *n
== L('.') && no_leading_period
)
120 for (c
= *p
++; c
== L('?') || c
== L('*'); c
= *p
++)
122 if (*p
== L('(') && (flags
& FNM_EXTMATCH
) != 0)
124 const CHAR
*endp
= END (p
);
127 /* This is a pattern. Skip over it. */
135 /* A ? needs to match one character. */
137 /* There isn't another character; no match. */
139 else if (*n
== L('/')
140 && __builtin_expect (flags
& FNM_FILE_NAME
, 0))
141 /* A slash does not match a wildcard under
145 /* One character of the string is consumed in matching
146 this ? wildcard, so *??? won't match if there are
147 less than three characters. */
153 /* The wildcard(s) is/are the last element of the pattern.
154 If the name is a file name and contains another slash
155 this means it cannot match, unless the FNM_LEADING_DIR
158 int result
= (flags
& FNM_FILE_NAME
) == 0 ? 0 : FNM_NOMATCH
;
160 if (flags
& FNM_FILE_NAME
)
162 if (flags
& FNM_LEADING_DIR
)
166 if (MEMCHR (n
, L('/'), string_end
- n
) == NULL
)
179 endp
= MEMCHR (n
, (flags
& FNM_FILE_NAME
) ? L('/') : L('\0'),
185 || (__builtin_expect (flags
& FNM_EXTMATCH
, 0) != 0
186 && (c
== L('@') || c
== L('+') || c
== L('!'))
189 int flags2
= ((flags
& FNM_FILE_NAME
)
190 ? flags
: (flags
& ~FNM_PERIOD
));
192 for (--p
; n
< endp
; ++n
, no_leading_period
= 0)
193 if (FCT (p
, n
, string_end
, no_leading_period
, flags2
,
197 else if (c
== L('/') && (flags
& FNM_FILE_NAME
))
199 while (n
< string_end
&& *n
!= L('/'))
201 if (n
< string_end
&& *n
== L('/')
202 && (FCT (p
, n
+ 1, string_end
, flags
& FNM_PERIOD
, flags
,
208 int flags2
= ((flags
& FNM_FILE_NAME
)
209 ? flags
: (flags
& ~FNM_PERIOD
));
211 if (c
== L('\\') && !(flags
& FNM_NOESCAPE
))
214 for (--p
; n
< endp
; ++n
, no_leading_period
= 0)
215 if (FOLD ((UCHAR
) *n
) == c
216 && (FCT (p
, n
, string_end
, no_leading_period
, flags2
,
220 if (end
.pattern
== NULL
)
224 if (end
.pattern
!= NULL
)
228 no_leading_period
= end
.no_leading_period
;
234 /* If we come here no match is possible with the wildcard. */
239 /* Nonzero if the sense of the character class is inverted. */
244 if (posixly_correct
== 0)
245 posixly_correct
= getenv ("POSIXLY_CORRECT") != NULL
? 1 : -1;
250 if (*n
== L('.') && no_leading_period
)
253 if (*n
== L('/') && (flags
& FNM_FILE_NAME
))
254 /* `/' cannot be matched. */
257 not = (*p
== L('!') || (posixly_correct
< 0 && *p
== L('^')));
261 fn
= FOLD ((UCHAR
) *n
);
266 if (!(flags
& FNM_NOESCAPE
) && c
== L('\\'))
270 c
= FOLD ((UCHAR
) *p
);
275 else if (c
== L('[') && *p
== L(':'))
277 /* Leave room for the null. */
278 CHAR str
[CHAR_CLASS_MAX_LENGTH
+ 1];
280 #if defined _LIBC || (defined HAVE_WCTYPE_H && defined HAVE_WCHAR_H)
283 const CHAR
*startp
= p
;
287 if (c1
== CHAR_CLASS_MAX_LENGTH
)
288 /* The name is too long and therefore the pattern
293 if (c
== L(':') && p
[1] == L(']'))
298 if (c
< L('a') || c
>= L('z'))
300 /* This cannot possibly be a character class name.
301 Match it as a normal range. */
310 #if defined _LIBC || (defined HAVE_WCTYPE_H && defined HAVE_WCHAR_H)
311 wt
= IS_CHAR_CLASS (str
);
313 /* Invalid character class name. */
316 # if defined _LIBC && ! WIDE_CHAR_VERSION
317 /* The following code is glibc specific but does
318 there a good job in speeding up the code since
319 we can avoid the btowc() call. */
320 if (_ISCTYPE ((UCHAR
) *n
, wt
))
323 if (ISWCTYPE (BTOWC ((UCHAR
) *n
), wt
))
327 if ((STREQ (str
, L("alnum")) && ISALNUM ((UCHAR
) *n
))
328 || (STREQ (str
, L("alpha")) && ISALPHA ((UCHAR
) *n
))
329 || (STREQ (str
, L("blank")) && ISBLANK ((UCHAR
) *n
))
330 || (STREQ (str
, L("cntrl")) && ISCNTRL ((UCHAR
) *n
))
331 || (STREQ (str
, L("digit")) && ISDIGIT ((UCHAR
) *n
))
332 || (STREQ (str
, L("graph")) && ISGRAPH ((UCHAR
) *n
))
333 || (STREQ (str
, L("lower")) && ISLOWER ((UCHAR
) *n
))
334 || (STREQ (str
, L("print")) && ISPRINT ((UCHAR
) *n
))
335 || (STREQ (str
, L("punct")) && ISPUNCT ((UCHAR
) *n
))
336 || (STREQ (str
, L("space")) && ISSPACE ((UCHAR
) *n
))
337 || (STREQ (str
, L("upper")) && ISUPPER ((UCHAR
) *n
))
338 || (STREQ (str
, L("xdigit")) && ISXDIGIT ((UCHAR
) *n
)))
344 else if (c
== L('[') && *p
== L('='))
348 _NL_CURRENT_WORD (LC_COLLATE
, _NL_COLLATE_NRULES
);
349 const CHAR
*startp
= p
;
361 if (c
!= L('=') || p
[1] != L(']'))
371 if ((UCHAR
) *n
== str
[0])
376 const int32_t *table
;
377 # if WIDE_CHAR_VERSION
378 const int32_t *weights
;
379 const int32_t *extra
;
381 const unsigned char *weights
;
382 const unsigned char *extra
;
384 const int32_t *indirect
;
386 const UCHAR
*cp
= (const UCHAR
*) str
;
388 /* This #include defines a local function! */
389 # if WIDE_CHAR_VERSION
390 # include <locale/weightwc.h>
392 # include <locale/weight.h>
395 # if WIDE_CHAR_VERSION
396 table
= (const int32_t *)
397 _NL_CURRENT (LC_COLLATE
, _NL_COLLATE_TABLEWC
);
398 weights
= (const int32_t *)
399 _NL_CURRENT (LC_COLLATE
, _NL_COLLATE_WEIGHTWC
);
400 extra
= (const int32_t *)
401 _NL_CURRENT (LC_COLLATE
, _NL_COLLATE_EXTRAWC
);
402 indirect
= (const int32_t *)
403 _NL_CURRENT (LC_COLLATE
, _NL_COLLATE_INDIRECTWC
);
405 table
= (const int32_t *)
406 _NL_CURRENT (LC_COLLATE
, _NL_COLLATE_TABLEMB
);
407 weights
= (const unsigned char *)
408 _NL_CURRENT (LC_COLLATE
, _NL_COLLATE_WEIGHTMB
);
409 extra
= (const unsigned char *)
410 _NL_CURRENT (LC_COLLATE
, _NL_COLLATE_EXTRAMB
);
411 indirect
= (const int32_t *)
412 _NL_CURRENT (LC_COLLATE
, _NL_COLLATE_INDIRECTMB
);
418 /* We found a table entry. Now see whether the
419 character we are currently at has the same
420 equivalance class value. */
421 int len
= weights
[idx
];
423 const UCHAR
*np
= (const UCHAR
*) n
;
425 idx2
= findidx (&np
);
426 if (idx2
!= 0 && len
== weights
[idx2
])
431 && (weights
[idx
+ 1 + cnt
]
432 == weights
[idx2
+ 1 + cnt
]))
444 else if (c
== L('\0'))
445 /* [ (unterminated) loses. */
454 if (c
== L('[') && *p
== L('.'))
457 _NL_CURRENT_WORD (LC_COLLATE
, _NL_COLLATE_NRULES
);
458 const CHAR
*startp
= p
;
464 if (c
== L('.') && p
[1] == L(']'))
474 /* We have to handling the symbols differently in
475 ranges since then the collation sequence is
477 is_range
= *p
== L('-') && p
[1] != L('\0');
481 /* There are no names defined in the collation
482 data. Therefore we only accept the trivial
483 names consisting of the character itself. */
487 if (!is_range
&& *n
== startp
[1])
496 const int32_t *symb_table
;
497 # ifdef WIDE_CHAR_VERSION
501 # define str (startp + 1)
503 const unsigned char *extra
;
509 # ifdef WIDE_CHAR_VERSION
510 /* We have to convert the name to a single-byte
511 string. This is possible since the names
512 consist of ASCII characters and the internal
513 representation is UCS4. */
514 for (strcnt
= 0; strcnt
< c1
; ++strcnt
)
515 str
[strcnt
] = startp
[1 + strcnt
];
519 _NL_CURRENT_WORD (LC_COLLATE
,
520 _NL_COLLATE_SYMB_HASH_SIZEMB
);
521 symb_table
= (const int32_t *)
522 _NL_CURRENT (LC_COLLATE
,
523 _NL_COLLATE_SYMB_TABLEMB
);
524 extra
= (const unsigned char *)
525 _NL_CURRENT (LC_COLLATE
,
526 _NL_COLLATE_SYMB_EXTRAMB
);
528 /* Locate the character in the hashing table. */
529 hash
= elem_hash (str
, c1
);
532 elem
= hash
% table_size
;
533 if (symb_table
[2 * elem
] != 0)
535 second
= hash
% (table_size
- 2) + 1;
539 /* First compare the hashing value. */
540 if (symb_table
[2 * elem
] == hash
542 == extra
[symb_table
[2 * elem
+ 1]])
544 &extra
[symb_table
[2 * elem
548 /* Yep, this is the entry. */
549 idx
= symb_table
[2 * elem
+ 1];
550 idx
+= 1 + extra
[idx
];
557 while (symb_table
[2 * elem
] != 0);
560 if (symb_table
[2 * elem
] != 0)
562 /* Compare the byte sequence but only if
563 this is not part of a range. */
564 # ifdef WIDE_CHAR_VERSION
567 idx
+= 1 + extra
[idx
];
568 /* Adjust for the alignment. */
569 idx
= (idx
+ 3) & ~3;
571 wextra
= (int32_t *) &extra
[idx
+ 4];
576 # ifdef WIDE_CHAR_VERSION
578 (int32_t) c1
< wextra
[idx
];
580 if (n
[c1
] != wextra
[1 + c1
])
583 if ((int32_t) c1
== wextra
[idx
])
586 for (c1
= 0; c1
< extra
[idx
]; ++c1
)
587 if (n
[c1
] != extra
[1 + c1
])
590 if (c1
== extra
[idx
])
595 /* Get the collation sequence value. */
597 # ifdef WIDE_CHAR_VERSION
598 cold
= wextra
[1 + wextra
[idx
]];
600 /* Adjust for the alignment. */
601 idx
+= 1 + extra
[idx
];
602 idx
= (idx
+ 3) & ~4;
603 cold
= *((int32_t *) &extra
[idx
]);
610 /* No valid character. Match it as a
612 if (!is_range
&& *n
== str
[0])
629 /* We have to handling the symbols differently in
630 ranges since then the collation sequence is
632 is_range
= (*p
== L('-') && p
[1] != L('\0')
635 if (!is_range
&& c
== fn
)
638 /* This is needed if we goto normal_bracket; from
639 outside of is_seqval's scope. */
645 if (c
== L('-') && *p
!= L(']'))
648 /* We have to find the collation sequence
649 value for C. Collation sequence is nothing
650 we can regularly access. The sequence
651 value is defined by the order in which the
652 definitions of the collation values for the
653 various characters appear in the source
654 file. A strange concept, nowhere
660 # ifdef WIDE_CHAR_VERSION
661 /* Search in the `names' array for the characters. */
662 fcollseq
= __collseq_table_lookup (collseq
, fn
);
663 if (fcollseq
== ~((uint32_t) 0))
664 /* XXX We don't know anything about the character
665 we are supposed to match. This means we are
667 goto range_not_matched
;
672 lcollseq
= __collseq_table_lookup (collseq
, cold
);
674 fcollseq
= collseq
[fn
];
675 lcollseq
= is_seqval
? cold
: collseq
[(UCHAR
) cold
];
679 if (cend
== L('[') && *p
== L('.'))
682 _NL_CURRENT_WORD (LC_COLLATE
,
684 const CHAR
*startp
= p
;
690 if (c
== L('.') && p
[1] == L(']'))
702 /* There are no names defined in the
703 collation data. Therefore we only
704 accept the trivial names consisting
705 of the character itself. */
714 const int32_t *symb_table
;
715 # ifdef WIDE_CHAR_VERSION
719 # define str (startp + 1)
721 const unsigned char *extra
;
727 # ifdef WIDE_CHAR_VERSION
728 /* We have to convert the name to a single-byte
729 string. This is possible since the names
730 consist of ASCII characters and the internal
731 representation is UCS4. */
732 for (strcnt
= 0; strcnt
< c1
; ++strcnt
)
733 str
[strcnt
] = startp
[1 + strcnt
];
737 _NL_CURRENT_WORD (LC_COLLATE
,
738 _NL_COLLATE_SYMB_HASH_SIZEMB
);
739 symb_table
= (const int32_t *)
740 _NL_CURRENT (LC_COLLATE
,
741 _NL_COLLATE_SYMB_TABLEMB
);
742 extra
= (const unsigned char *)
743 _NL_CURRENT (LC_COLLATE
,
744 _NL_COLLATE_SYMB_EXTRAMB
);
746 /* Locate the character in the hashing
748 hash
= elem_hash (str
, c1
);
751 elem
= hash
% table_size
;
752 if (symb_table
[2 * elem
] != 0)
754 second
= hash
% (table_size
- 2) + 1;
758 /* First compare the hashing value. */
759 if (symb_table
[2 * elem
] == hash
761 == extra
[symb_table
[2 * elem
+ 1]])
763 &extra
[symb_table
[2 * elem
+ 1]
766 /* Yep, this is the entry. */
767 idx
= symb_table
[2 * elem
+ 1];
768 idx
+= 1 + extra
[idx
];
775 while (symb_table
[2 * elem
] != 0);
778 if (symb_table
[2 * elem
] != 0)
780 /* Compare the byte sequence but only if
781 this is not part of a range. */
782 # ifdef WIDE_CHAR_VERSION
785 idx
+= 1 + extra
[idx
];
786 /* Adjust for the alignment. */
787 idx
= (idx
+ 3) & ~4;
789 wextra
= (int32_t *) &extra
[idx
+ 4];
791 /* Get the collation sequence value. */
793 # ifdef WIDE_CHAR_VERSION
794 cend
= wextra
[1 + wextra
[idx
]];
796 /* Adjust for the alignment. */
797 idx
+= 1 + extra
[idx
];
798 idx
= (idx
+ 3) & ~4;
799 cend
= *((int32_t *) &extra
[idx
]);
802 else if (symb_table
[2 * elem
] != 0 && c1
== 1)
814 if (!(flags
& FNM_NOESCAPE
) && cend
== L('\\'))
821 /* XXX It is not entirely clear to me how to handle
822 characters which are not mentioned in the
823 collation specification. */
825 # ifdef WIDE_CHAR_VERSION
826 lcollseq
== 0xffffffff ||
828 lcollseq
<= fcollseq
)
830 /* We have to look at the upper bound. */
837 # ifdef WIDE_CHAR_VERSION
839 __collseq_table_lookup (collseq
, cend
);
840 if (hcollseq
== ~((uint32_t) 0))
842 /* Hum, no information about the upper
843 bound. The matching succeeds if the
844 lower bound is matched exactly. */
845 if (lcollseq
!= fcollseq
)
846 goto range_not_matched
;
851 hcollseq
= collseq
[cend
];
855 if (lcollseq
<= hcollseq
&& fcollseq
<= hcollseq
)
858 # ifdef WIDE_CHAR_VERSION
862 /* We use a boring value comparison of the character
863 values. This is better than comparing using
864 `strcoll' since the latter would have surprising
865 and sometimes fatal consequences. */
868 if (!(flags
& FNM_NOESCAPE
) && cend
== L('\\'))
874 if (cold
<= fn
&& fn
<= cend
)
891 /* Skip the rest of the [...] that already matched. */
898 /* [... (unterminated) loses. */
901 if (!(flags
& FNM_NOESCAPE
) && c
== L('\\'))
905 /* XXX 1003.2d11 is unclear if this is right. */
908 else if (c
== L('[') && *p
== L(':'))
911 const CHAR
*startp
= p
;
916 if (++c1
== CHAR_CLASS_MAX_LENGTH
)
919 if (*p
== L(':') && p
[1] == L(']'))
922 if (c
< L('a') || c
>= L('z'))
931 else if (c
== L('[') && *p
== L('='))
937 if (c
!= L('=') || p
[1] != L(']'))
942 else if (c
== L('[') && *p
== L('.'))
951 if (*p
== L('.') && p
[1] == L(']'))
967 if (__builtin_expect (flags
& FNM_EXTMATCH
, 0) && *p
== '(')
971 res
= EXT (c
, p
, n
, string_end
, no_leading_period
, flags
);
978 if (NO_LEADING_PERIOD (flags
))
980 if (n
== string_end
|| c
!= (UCHAR
) *n
)
983 new_no_leading_period
= 1;
989 if (n
== string_end
|| c
!= FOLD ((UCHAR
) *n
))
993 no_leading_period
= new_no_leading_period
;
1000 if ((flags
& FNM_LEADING_DIR
) && n
!= string_end
&& *n
== L('/'))
1001 /* The FNM_LEADING_DIR flag says that "foo*" matches "foobar/frobozz". */
1010 END (const CHAR
*pattern
)
1012 const CHAR
*p
= pattern
;
1015 if (*++p
== L('\0'))
1016 /* This is an invalid pattern. */
1018 else if (*p
== L('['))
1020 /* Handle brackets special. */
1021 if (posixly_correct
== 0)
1022 posixly_correct
= getenv ("POSIXLY_CORRECT") != NULL
? 1 : -1;
1024 /* Skip the not sign. We have to recognize it because of a possibly
1026 if (*++p
== L('!') || (posixly_correct
< 0 && *p
== L('^')))
1028 /* A leading ']' is recognized as such. */
1031 /* Skip over all characters of the list. */
1032 while (*p
!= L(']'))
1033 if (*p
++ == L('\0'))
1034 /* This is no valid pattern. */
1037 else if ((*p
== L('?') || *p
== L('*') || *p
== L('+') || *p
== L('@')
1038 || *p
== L('!')) && p
[1] == L('('))
1040 else if (*p
== L(')'))
1049 EXT (INT opt
, const CHAR
*pattern
, const CHAR
*string
, const CHAR
*string_end
,
1050 int no_leading_period
, int flags
)
1056 struct patternlist
*next
;
1059 struct patternlist
**lastp
= &list
;
1060 size_t pattern_len
= STRLEN (pattern
);
1064 /* Parse the pattern. Store the individual parts in the list. */
1066 for (startp
= p
= pattern
+ 1; level
>= 0; ++p
)
1068 /* This is an invalid pattern. */
1070 else if (*p
== L('['))
1072 /* Handle brackets special. */
1073 if (posixly_correct
== 0)
1074 posixly_correct
= getenv ("POSIXLY_CORRECT") != NULL
? 1 : -1;
1076 /* Skip the not sign. We have to recognize it because of a possibly
1078 if (*++p
== L('!') || (posixly_correct
< 0 && *p
== L('^')))
1080 /* A leading ']' is recognized as such. */
1083 /* Skip over all characters of the list. */
1084 while (*p
!= L(']'))
1085 if (*p
++ == L('\0'))
1086 /* This is no valid pattern. */
1089 else if ((*p
== L('?') || *p
== L('*') || *p
== L('+') || *p
== L('@')
1090 || *p
== L('!')) && p
[1] == L('('))
1091 /* Remember the nesting level. */
1093 else if (*p
== L(')'))
1097 /* This means we found the end of the pattern. */
1098 #define NEW_PATTERN \
1099 struct patternlist *newp; \
1101 if (opt == L('?') || opt == L('@')) \
1102 newp = alloca (sizeof (struct patternlist) \
1103 + (pattern_len * sizeof (CHAR))); \
1105 newp = alloca (sizeof (struct patternlist) \
1106 + ((p - startp + 1) * sizeof (CHAR))); \
1107 *((CHAR *) MEMPCPY (newp->str, startp, p - startp)) = L('\0'); \
1108 newp->next = NULL; \
1114 else if (*p
== L('|'))
1122 assert (list
!= NULL
);
1123 assert (p
[-1] == L(')'));
1129 if (FCT (p
, string
, string_end
, no_leading_period
, flags
, NULL
) == 0)
1136 for (rs
= string
; rs
<= string_end
; ++rs
)
1137 /* First match the prefix with the current pattern with the
1139 if (FCT (list
->str
, string
, rs
, no_leading_period
,
1140 flags
& FNM_FILE_NAME
? flags
: flags
& ~FNM_PERIOD
,
1142 /* This was successful. Now match the rest with the rest
1144 && (FCT (p
, rs
, string_end
,
1147 : rs
[-1] == '/' && NO_LEADING_PERIOD (flags
) ? 1 : 0,
1148 flags
& FNM_FILE_NAME
1149 ? flags
: flags
& ~FNM_PERIOD
, NULL
) == 0
1150 /* This didn't work. Try the whole pattern. */
1152 && FCT (pattern
- 1, rs
, string_end
,
1155 : (rs
[-1] == '/' && NO_LEADING_PERIOD (flags
)
1157 flags
& FNM_FILE_NAME
1158 ? flags
: flags
& ~FNM_PERIOD
, NULL
) == 0)))
1159 /* It worked. Signal success. */
1162 while ((list
= list
->next
) != NULL
);
1164 /* None of the patterns lead to a match. */
1168 if (FCT (p
, string
, string_end
, no_leading_period
, flags
, NULL
) == 0)
1174 /* I cannot believe it but `strcat' is actually acceptable
1175 here. Match the entire string with the prefix from the
1176 pattern list and the rest of the pattern following the
1178 if (FCT (STRCAT (list
->str
, p
), string
, string_end
,
1180 flags
& FNM_FILE_NAME
? flags
: flags
& ~FNM_PERIOD
,
1182 /* It worked. Signal success. */
1184 while ((list
= list
->next
) != NULL
);
1186 /* None of the patterns lead to a match. */
1190 for (rs
= string
; rs
<= string_end
; ++rs
)
1192 struct patternlist
*runp
;
1194 for (runp
= list
; runp
!= NULL
; runp
= runp
->next
)
1195 if (FCT (runp
->str
, string
, rs
, no_leading_period
,
1196 flags
& FNM_FILE_NAME
? flags
: flags
& ~FNM_PERIOD
,
1200 /* If none of the patterns matched see whether the rest does. */
1202 && (FCT (p
, rs
, string_end
,
1205 : rs
[-1] == '/' && NO_LEADING_PERIOD (flags
) ? 1 : 0,
1206 flags
& FNM_FILE_NAME
? flags
: flags
& ~FNM_PERIOD
,
1208 /* This is successful. */
1212 /* None of the patterns together with the rest of the pattern
1217 assert (! "Invalid extended matching operator");