1 /* Copyright (C) 1991,1992,1993,1996,1997,1998,1999,2000,2001,2003,2004
2 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
20 /* Match STRING against the filename pattern PATTERN, returning zero if
21 it matches, nonzero if not. */
22 static int FCT (const CHAR
*pattern
, const CHAR
*string
,
23 const CHAR
*string_end
, int no_leading_period
, int flags
)
25 static int EXT (INT opt
, const CHAR
*pattern
, const CHAR
*string
,
26 const CHAR
*string_end
, int no_leading_period
, int flags
)
28 static const CHAR
*END (const CHAR
*patternp
) internal_function
;
32 FCT (pattern
, string
, string_end
, no_leading_period
, flags
)
35 const CHAR
*string_end
;
36 int no_leading_period
;
39 register const CHAR
*p
= pattern
, *n
= string
;
42 # if WIDE_CHAR_VERSION
43 const char *collseq
= (const char *)
44 _NL_CURRENT(LC_COLLATE
, _NL_COLLATE_COLLSEQWC
);
46 const UCHAR
*collseq
= (const UCHAR
*)
47 _NL_CURRENT(LC_COLLATE
, _NL_COLLATE_COLLSEQMB
);
51 while ((c
= *p
++) != L('\0'))
53 int new_no_leading_period
= 0;
59 if (__builtin_expect (flags
& FNM_EXTMATCH
, 0) && *p
== '(')
63 res
= EXT (c
, p
, n
, string_end
, no_leading_period
,
71 else if (*n
== L('/') && (flags
& FNM_FILE_NAME
))
73 else if (*n
== L('.') && no_leading_period
)
78 if (!(flags
& FNM_NOESCAPE
))
82 /* Trailing \ loses. */
86 if (n
== string_end
|| FOLD ((UCHAR
) *n
) != c
)
91 if (__builtin_expect (flags
& FNM_EXTMATCH
, 0) && *p
== '(')
95 res
= EXT (c
, p
, n
, string_end
, no_leading_period
,
101 if (n
!= string_end
&& *n
== L('.') && no_leading_period
)
104 for (c
= *p
++; c
== L('?') || c
== L('*'); c
= *p
++)
106 if (*p
== L('(') && (flags
& FNM_EXTMATCH
) != 0)
108 const CHAR
*endp
= END (p
);
111 /* This is a pattern. Skip over it. */
119 /* A ? needs to match one character. */
121 /* There isn't another character; no match. */
123 else if (*n
== L('/')
124 && __builtin_expect (flags
& FNM_FILE_NAME
, 0))
125 /* A slash does not match a wildcard under
129 /* One character of the string is consumed in matching
130 this ? wildcard, so *??? won't match if there are
131 less than three characters. */
137 /* The wildcard(s) is/are the last element of the pattern.
138 If the name is a file name and contains another slash
139 this means it cannot match, unless the FNM_LEADING_DIR
142 int result
= (flags
& FNM_FILE_NAME
) == 0 ? 0 : FNM_NOMATCH
;
144 if (flags
& FNM_FILE_NAME
)
146 if (flags
& FNM_LEADING_DIR
)
150 if (MEMCHR (n
, L('/'), string_end
- n
) == NULL
)
161 endp
= MEMCHR (n
, (flags
& FNM_FILE_NAME
) ? L('/') : L('\0'),
167 || (__builtin_expect (flags
& FNM_EXTMATCH
, 0) != 0
168 && (c
== L('@') || c
== L('+') || c
== L('!'))
171 int flags2
= ((flags
& FNM_FILE_NAME
)
172 ? flags
: (flags
& ~FNM_PERIOD
));
173 int no_leading_period2
= no_leading_period
;
175 for (--p
; n
< endp
; ++n
, no_leading_period2
= 0)
176 if (FCT (p
, n
, string_end
, no_leading_period2
, flags2
)
180 else if (c
== L('/') && (flags
& FNM_FILE_NAME
))
182 while (n
< string_end
&& *n
!= L('/'))
184 if (n
< string_end
&& *n
== L('/')
185 && (FCT (p
, n
+ 1, string_end
, flags
& FNM_PERIOD
, flags
)
191 int flags2
= ((flags
& FNM_FILE_NAME
)
192 ? flags
: (flags
& ~FNM_PERIOD
));
193 int no_leading_period2
= no_leading_period
;
195 if (c
== L('\\') && !(flags
& FNM_NOESCAPE
))
198 for (--p
; n
< endp
; ++n
, no_leading_period2
= 0)
199 if (FOLD ((UCHAR
) *n
) == c
200 && (FCT (p
, n
, string_end
, no_leading_period2
, flags2
)
206 /* If we come here no match is possible with the wildcard. */
211 /* Nonzero if the sense of the character class is inverted. */
216 if (posixly_correct
== 0)
217 posixly_correct
= getenv ("POSIXLY_CORRECT") != NULL
? 1 : -1;
222 if (*n
== L('.') && no_leading_period
)
225 if (*n
== L('/') && (flags
& FNM_FILE_NAME
))
226 /* `/' cannot be matched. */
229 not = (*p
== L('!') || (posixly_correct
< 0 && *p
== L('^')));
233 fn
= FOLD ((UCHAR
) *n
);
238 if (!(flags
& FNM_NOESCAPE
) && c
== L('\\'))
242 c
= FOLD ((UCHAR
) *p
);
247 else if (c
== L('[') && *p
== L(':'))
249 /* Leave room for the null. */
250 CHAR str
[CHAR_CLASS_MAX_LENGTH
+ 1];
252 #if defined _LIBC || (defined HAVE_WCTYPE_H && defined HAVE_WCHAR_H)
255 const CHAR
*startp
= p
;
259 if (c1
== CHAR_CLASS_MAX_LENGTH
)
260 /* The name is too long and therefore the pattern
265 if (c
== L(':') && p
[1] == L(']'))
270 if (c
< L('a') || c
>= L('z'))
272 /* This cannot possibly be a character class name.
273 Match it as a normal range. */
282 #if defined _LIBC || (defined HAVE_WCTYPE_H && defined HAVE_WCHAR_H)
283 wt
= IS_CHAR_CLASS (str
);
285 /* Invalid character class name. */
288 # if defined _LIBC && ! WIDE_CHAR_VERSION
289 /* The following code is glibc specific but does
290 there a good job in speeding up the code since
291 we can avoid the btowc() call. */
292 if (_ISCTYPE ((UCHAR
) *n
, wt
))
295 if (ISWCTYPE (BTOWC ((UCHAR
) *n
), wt
))
299 if ((STREQ (str
, L("alnum")) && ISALNUM ((UCHAR
) *n
))
300 || (STREQ (str
, L("alpha")) && ISALPHA ((UCHAR
) *n
))
301 || (STREQ (str
, L("blank")) && ISBLANK ((UCHAR
) *n
))
302 || (STREQ (str
, L("cntrl")) && ISCNTRL ((UCHAR
) *n
))
303 || (STREQ (str
, L("digit")) && ISDIGIT ((UCHAR
) *n
))
304 || (STREQ (str
, L("graph")) && ISGRAPH ((UCHAR
) *n
))
305 || (STREQ (str
, L("lower")) && ISLOWER ((UCHAR
) *n
))
306 || (STREQ (str
, L("print")) && ISPRINT ((UCHAR
) *n
))
307 || (STREQ (str
, L("punct")) && ISPUNCT ((UCHAR
) *n
))
308 || (STREQ (str
, L("space")) && ISSPACE ((UCHAR
) *n
))
309 || (STREQ (str
, L("upper")) && ISUPPER ((UCHAR
) *n
))
310 || (STREQ (str
, L("xdigit")) && ISXDIGIT ((UCHAR
) *n
)))
316 else if (c
== L('[') && *p
== L('='))
320 _NL_CURRENT_WORD (LC_COLLATE
, _NL_COLLATE_NRULES
);
321 const CHAR
*startp
= p
;
333 if (c
!= L('=') || p
[1] != L(']'))
343 if ((UCHAR
) *n
== str
[0])
348 const int32_t *table
;
349 # if WIDE_CHAR_VERSION
350 const int32_t *weights
;
351 const int32_t *extra
;
353 const unsigned char *weights
;
354 const unsigned char *extra
;
356 const int32_t *indirect
;
358 const UCHAR
*cp
= (const UCHAR
*) str
;
360 /* This #include defines a local function! */
361 # if WIDE_CHAR_VERSION
362 # include <locale/weightwc.h>
364 # include <locale/weight.h>
367 # if WIDE_CHAR_VERSION
368 table
= (const int32_t *)
369 _NL_CURRENT (LC_COLLATE
, _NL_COLLATE_TABLEWC
);
370 weights
= (const int32_t *)
371 _NL_CURRENT (LC_COLLATE
, _NL_COLLATE_WEIGHTWC
);
372 extra
= (const int32_t *)
373 _NL_CURRENT (LC_COLLATE
, _NL_COLLATE_EXTRAWC
);
374 indirect
= (const int32_t *)
375 _NL_CURRENT (LC_COLLATE
, _NL_COLLATE_INDIRECTWC
);
377 table
= (const int32_t *)
378 _NL_CURRENT (LC_COLLATE
, _NL_COLLATE_TABLEMB
);
379 weights
= (const unsigned char *)
380 _NL_CURRENT (LC_COLLATE
, _NL_COLLATE_WEIGHTMB
);
381 extra
= (const unsigned char *)
382 _NL_CURRENT (LC_COLLATE
, _NL_COLLATE_EXTRAMB
);
383 indirect
= (const int32_t *)
384 _NL_CURRENT (LC_COLLATE
, _NL_COLLATE_INDIRECTMB
);
390 /* We found a table entry. Now see whether the
391 character we are currently at has the same
392 equivalance class value. */
393 int len
= weights
[idx
];
395 const UCHAR
*np
= (const UCHAR
*) n
;
397 idx2
= findidx (&np
);
398 if (idx2
!= 0 && len
== weights
[idx2
])
403 && (weights
[idx
+ 1 + cnt
]
404 == weights
[idx2
+ 1 + cnt
]))
416 else if (c
== L('\0'))
417 /* [ (unterminated) loses. */
426 if (c
== L('[') && *p
== L('.'))
429 _NL_CURRENT_WORD (LC_COLLATE
, _NL_COLLATE_NRULES
);
430 const CHAR
*startp
= p
;
436 if (c
== L('.') && p
[1] == L(']'))
446 /* We have to handling the symbols differently in
447 ranges since then the collation sequence is
449 is_range
= *p
== L('-') && p
[1] != L('\0');
453 /* There are no names defined in the collation
454 data. Therefore we only accept the trivial
455 names consisting of the character itself. */
459 if (!is_range
&& *n
== startp
[1])
468 const int32_t *symb_table
;
469 # ifdef WIDE_CHAR_VERSION
473 # define str (startp + 1)
475 const unsigned char *extra
;
481 # ifdef WIDE_CHAR_VERSION
482 /* We have to convert the name to a single-byte
483 string. This is possible since the names
484 consist of ASCII characters and the internal
485 representation is UCS4. */
486 for (strcnt
= 0; strcnt
< c1
; ++strcnt
)
487 str
[strcnt
] = startp
[1 + strcnt
];
491 _NL_CURRENT_WORD (LC_COLLATE
,
492 _NL_COLLATE_SYMB_HASH_SIZEMB
);
493 symb_table
= (const int32_t *)
494 _NL_CURRENT (LC_COLLATE
,
495 _NL_COLLATE_SYMB_TABLEMB
);
496 extra
= (const unsigned char *)
497 _NL_CURRENT (LC_COLLATE
,
498 _NL_COLLATE_SYMB_EXTRAMB
);
500 /* Locate the character in the hashing table. */
501 hash
= elem_hash (str
, c1
);
504 elem
= hash
% table_size
;
505 second
= hash
% (table_size
- 2);
506 while (symb_table
[2 * elem
] != 0)
508 /* First compare the hashing value. */
509 if (symb_table
[2 * elem
] == hash
510 && c1
== extra
[symb_table
[2 * elem
+ 1]]
512 &extra
[symb_table
[2 * elem
+ 1]
515 /* Yep, this is the entry. */
516 idx
= symb_table
[2 * elem
+ 1];
517 idx
+= 1 + extra
[idx
];
525 if (symb_table
[2 * elem
] != 0)
527 /* Compare the byte sequence but only if
528 this is not part of a range. */
529 # ifdef WIDE_CHAR_VERSION
532 idx
+= 1 + extra
[idx
];
533 /* Adjust for the alignment. */
534 idx
= (idx
+ 3) & ~3;
536 wextra
= (int32_t *) &extra
[idx
+ 4];
541 # ifdef WIDE_CHAR_VERSION
543 (int32_t) c1
< wextra
[idx
];
545 if (n
[c1
] != wextra
[1 + c1
])
548 if ((int32_t) c1
== wextra
[idx
])
551 for (c1
= 0; c1
< extra
[idx
]; ++c1
)
552 if (n
[c1
] != extra
[1 + c1
])
555 if (c1
== extra
[idx
])
560 /* Get the collation sequence value. */
562 # ifdef WIDE_CHAR_VERSION
563 cold
= wextra
[1 + wextra
[idx
]];
565 /* Adjust for the alignment. */
566 idx
+= 1 + extra
[idx
];
567 idx
= (idx
+ 3) & ~4;
568 cold
= *((int32_t *) &extra
[idx
]);
575 /* No valid character. Match it as a
577 if (!is_range
&& *n
== str
[0])
594 /* We have to handling the symbols differently in
595 ranges since then the collation sequence is
597 is_range
= (*p
== L('-') && p
[1] != L('\0')
600 if (!is_range
&& c
== fn
)
607 if (c
== L('-') && *p
!= L(']'))
610 /* We have to find the collation sequence
611 value for C. Collation sequence is nothing
612 we can regularly access. The sequence
613 value is defined by the order in which the
614 definitions of the collation values for the
615 various characters appear in the source
616 file. A strange concept, nowhere
622 # ifdef WIDE_CHAR_VERSION
623 /* Search in the `names' array for the characters. */
624 fcollseq
= __collseq_table_lookup (collseq
, fn
);
625 if (fcollseq
== ~((uint32_t) 0))
626 /* XXX We don't know anything about the character
627 we are supposed to match. This means we are
629 goto range_not_matched
;
634 lcollseq
= __collseq_table_lookup (collseq
, cold
);
636 fcollseq
= collseq
[fn
];
637 lcollseq
= is_seqval
? cold
: collseq
[(UCHAR
) cold
];
641 if (cend
== L('[') && *p
== L('.'))
644 _NL_CURRENT_WORD (LC_COLLATE
,
646 const CHAR
*startp
= p
;
652 if (c
== L('.') && p
[1] == L(']'))
664 /* There are no names defined in the
665 collation data. Therefore we only
666 accept the trivial names consisting
667 of the character itself. */
676 const int32_t *symb_table
;
677 # ifdef WIDE_CHAR_VERSION
681 # define str (startp + 1)
683 const unsigned char *extra
;
689 # ifdef WIDE_CHAR_VERSION
690 /* We have to convert the name to a single-byte
691 string. This is possible since the names
692 consist of ASCII characters and the internal
693 representation is UCS4. */
694 for (strcnt
= 0; strcnt
< c1
; ++strcnt
)
695 str
[strcnt
] = startp
[1 + strcnt
];
699 _NL_CURRENT_WORD (LC_COLLATE
,
700 _NL_COLLATE_SYMB_HASH_SIZEMB
);
701 symb_table
= (const int32_t *)
702 _NL_CURRENT (LC_COLLATE
,
703 _NL_COLLATE_SYMB_TABLEMB
);
704 extra
= (const unsigned char *)
705 _NL_CURRENT (LC_COLLATE
,
706 _NL_COLLATE_SYMB_EXTRAMB
);
708 /* Locate the character in the hashing
710 hash
= elem_hash (str
, c1
);
713 elem
= hash
% table_size
;
714 second
= hash
% (table_size
- 2);
715 while (symb_table
[2 * elem
] != 0)
717 /* First compare the hashing value. */
718 if (symb_table
[2 * elem
] == hash
720 == extra
[symb_table
[2 * elem
+ 1]])
722 &extra
[symb_table
[2 * elem
+ 1]
725 /* Yep, this is the entry. */
726 idx
= symb_table
[2 * elem
+ 1];
727 idx
+= 1 + extra
[idx
];
735 if (symb_table
[2 * elem
] != 0)
737 /* Compare the byte sequence but only if
738 this is not part of a range. */
739 # ifdef WIDE_CHAR_VERSION
742 idx
+= 1 + extra
[idx
];
743 /* Adjust for the alignment. */
744 idx
= (idx
+ 3) & ~4;
746 wextra
= (int32_t *) &extra
[idx
+ 4];
748 /* Get the collation sequence value. */
750 # ifdef WIDE_CHAR_VERSION
751 cend
= wextra
[1 + wextra
[idx
]];
753 /* Adjust for the alignment. */
754 idx
+= 1 + extra
[idx
];
755 idx
= (idx
+ 3) & ~4;
756 cend
= *((int32_t *) &extra
[idx
]);
759 else if (symb_table
[2 * elem
] != 0 && c1
== 1)
771 if (!(flags
& FNM_NOESCAPE
) && cend
== L('\\'))
778 /* XXX It is not entirely clear to me how to handle
779 characters which are not mentioned in the
780 collation specification. */
782 # ifdef WIDE_CHAR_VERSION
783 lcollseq
== 0xffffffff ||
785 lcollseq
<= fcollseq
)
787 /* We have to look at the upper bound. */
794 # ifdef WIDE_CHAR_VERSION
796 __collseq_table_lookup (collseq
, cend
);
797 if (hcollseq
== ~((uint32_t) 0))
799 /* Hum, no information about the upper
800 bound. The matching succeeds if the
801 lower bound is matched exactly. */
802 if (lcollseq
!= fcollseq
)
803 goto range_not_matched
;
808 hcollseq
= collseq
[cend
];
812 if (lcollseq
<= hcollseq
&& fcollseq
<= hcollseq
)
815 # ifdef WIDE_CHAR_VERSION
819 /* We use a boring value comparison of the character
820 values. This is better than comparing using
821 `strcoll' since the latter would have surprising
822 and sometimes fatal consequences. */
825 if (!(flags
& FNM_NOESCAPE
) && cend
== L('\\'))
831 if (cold
<= fn
&& fn
<= cend
)
848 /* Skip the rest of the [...] that already matched. */
855 /* [... (unterminated) loses. */
858 if (!(flags
& FNM_NOESCAPE
) && c
== L('\\'))
862 /* XXX 1003.2d11 is unclear if this is right. */
865 else if (c
== L('[') && *p
== L(':'))
868 const CHAR
*startp
= p
;
873 if (++c1
== CHAR_CLASS_MAX_LENGTH
)
876 if (*p
== L(':') && p
[1] == L(']'))
879 if (c
< L('a') || c
>= L('z'))
888 else if (c
== L('[') && *p
== L('='))
894 if (c
!= L('=') || p
[1] != L(']'))
899 else if (c
== L('[') && *p
== L('.'))
908 if (*p
== L('.') && p
[1] == L(']'))
924 if (__builtin_expect (flags
& FNM_EXTMATCH
, 0) && *p
== '(')
928 res
= EXT (c
, p
, n
, string_end
, no_leading_period
, flags
);
935 if (NO_LEADING_PERIOD (flags
))
937 if (n
== string_end
|| c
!= (UCHAR
) *n
)
940 new_no_leading_period
= 1;
946 if (n
== string_end
|| c
!= FOLD ((UCHAR
) *n
))
950 no_leading_period
= new_no_leading_period
;
957 if ((flags
& FNM_LEADING_DIR
) && n
!= string_end
&& *n
== L('/'))
958 /* The FNM_LEADING_DIR flag says that "foo*" matches "foobar/frobozz". */
967 END (const CHAR
*pattern
)
969 const CHAR
*p
= pattern
;
973 /* This is an invalid pattern. */
975 else if (*p
== L('['))
977 /* Handle brackets special. */
978 if (posixly_correct
== 0)
979 posixly_correct
= getenv ("POSIXLY_CORRECT") != NULL
? 1 : -1;
981 /* Skip the not sign. We have to recognize it because of a possibly
983 if (*++p
== L('!') || (posixly_correct
< 0 && *p
== L('^')))
985 /* A leading ']' is recognized as such. */
988 /* Skip over all characters of the list. */
991 /* This is no valid pattern. */
994 else if ((*p
== L('?') || *p
== L('*') || *p
== L('+') || *p
== L('@')
995 || *p
== L('!')) && p
[1] == L('('))
997 else if (*p
== L(')'))
1006 EXT (INT opt
, const CHAR
*pattern
, const CHAR
*string
, const CHAR
*string_end
,
1007 int no_leading_period
, int flags
)
1013 struct patternlist
*next
;
1016 struct patternlist
**lastp
= &list
;
1017 size_t pattern_len
= STRLEN (pattern
);
1021 /* Parse the pattern. Store the individual parts in the list. */
1023 for (startp
= p
= pattern
+ 1; level
>= 0; ++p
)
1025 /* This is an invalid pattern. */
1027 else if (*p
== L('['))
1029 /* Handle brackets special. */
1030 if (posixly_correct
== 0)
1031 posixly_correct
= getenv ("POSIXLY_CORRECT") != NULL
? 1 : -1;
1033 /* Skip the not sign. We have to recognize it because of a possibly
1035 if (*++p
== L('!') || (posixly_correct
< 0 && *p
== L('^')))
1037 /* A leading ']' is recognized as such. */
1040 /* Skip over all characters of the list. */
1041 while (*p
!= L(']'))
1042 if (*p
++ == L('\0'))
1043 /* This is no valid pattern. */
1046 else if ((*p
== L('?') || *p
== L('*') || *p
== L('+') || *p
== L('@')
1047 || *p
== L('!')) && p
[1] == L('('))
1048 /* Remember the nesting level. */
1050 else if (*p
== L(')'))
1054 /* This means we found the end of the pattern. */
1055 #define NEW_PATTERN \
1056 struct patternlist *newp; \
1058 if (opt == L('?') || opt == L('@')) \
1059 newp = alloca (sizeof (struct patternlist) \
1060 + (pattern_len * sizeof (CHAR))); \
1062 newp = alloca (sizeof (struct patternlist) \
1063 + ((p - startp + 1) * sizeof (CHAR))); \
1064 *((CHAR *) MEMPCPY (newp->str, startp, p - startp)) = L('\0'); \
1065 newp->next = NULL; \
1071 else if (*p
== L('|'))
1079 assert (list
!= NULL
);
1080 assert (p
[-1] == L(')'));
1086 if (FCT (p
, string
, string_end
, no_leading_period
, flags
) == 0)
1093 for (rs
= string
; rs
<= string_end
; ++rs
)
1094 /* First match the prefix with the current pattern with the
1096 if (FCT (list
->str
, string
, rs
, no_leading_period
,
1097 flags
& FNM_FILE_NAME
? flags
: flags
& ~FNM_PERIOD
) == 0
1098 /* This was successful. Now match the rest with the rest
1100 && (FCT (p
, rs
, string_end
,
1103 : rs
[-1] == '/' && NO_LEADING_PERIOD (flags
) ? 1 : 0,
1104 flags
& FNM_FILE_NAME
1105 ? flags
: flags
& ~FNM_PERIOD
) == 0
1106 /* This didn't work. Try the whole pattern. */
1108 && FCT (pattern
- 1, rs
, string_end
,
1111 : (rs
[-1] == '/' && NO_LEADING_PERIOD (flags
)
1113 flags
& FNM_FILE_NAME
1114 ? flags
: flags
& ~FNM_PERIOD
) == 0)))
1115 /* It worked. Signal success. */
1118 while ((list
= list
->next
) != NULL
);
1120 /* None of the patterns lead to a match. */
1124 if (FCT (p
, string
, string_end
, no_leading_period
, flags
) == 0)
1130 /* I cannot believe it but `strcat' is actually acceptable
1131 here. Match the entire string with the prefix from the
1132 pattern list and the rest of the pattern following the
1134 if (FCT (STRCAT (list
->str
, p
), string
, string_end
,
1136 flags
& FNM_FILE_NAME
? flags
: flags
& ~FNM_PERIOD
) == 0)
1137 /* It worked. Signal success. */
1139 while ((list
= list
->next
) != NULL
);
1141 /* None of the patterns lead to a match. */
1145 for (rs
= string
; rs
<= string_end
; ++rs
)
1147 struct patternlist
*runp
;
1149 for (runp
= list
; runp
!= NULL
; runp
= runp
->next
)
1150 if (FCT (runp
->str
, string
, rs
, no_leading_period
,
1151 flags
& FNM_FILE_NAME
? flags
: flags
& ~FNM_PERIOD
) == 0)
1154 /* If none of the patterns matched see whether the rest does. */
1156 && (FCT (p
, rs
, string_end
,
1159 : rs
[-1] == '/' && NO_LEADING_PERIOD (flags
) ? 1 : 0,
1160 flags
& FNM_FILE_NAME
? flags
: flags
& ~FNM_PERIOD
)
1162 /* This is successful. */
1166 /* None of the patterns together with the rest of the pattern
1171 assert (! "Invalid extended matching operator");