posix/fnmatch_loop.c

   1 /* Copyright (C) 1991-1993, 1996-2000, 2001 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 #ifdef _LIBC
  35 # if WIDE_CHAR_VERSION
  36   const char *collseq = (const char *)
  37     _NL_CURRENT(LC_COLLATE, _NL_COLLATE_COLLSEQWC);
  38 # else
  39   const UCHAR *collseq = (const UCHAR *)
  40     _NL_CURRENT(LC_COLLATE, _NL_COLLATE_COLLSEQMB);
  41 # endif
  42 #endif
  43
  44   while ((c = *p++) != L('\0'))
  45     {
  46       c = FOLD (c);
  47
  48       switch (c)
  49         {
  50         case L('?'):
  51           if (*n == L('\0'))
  52             return FNM_NOMATCH;
  53           else if (*n == L('/') && (flags & FNM_FILE_NAME))
  54             return FNM_NOMATCH;
  55           else if (*n == L('.') && no_leading_period
  56                    && (n == string
  57                        || (n[-1] == L('/') && (flags & FNM_FILE_NAME))))
  58             return FNM_NOMATCH;
  59           break;
  60
  61         case L('\\'):
  62           if (!(flags & FNM_NOESCAPE))
  63             {
  64               c = *p++;
  65               if (c == L('\0'))
  66                 /* Trailing \ loses.  */
  67                 return FNM_NOMATCH;
  68               c = FOLD (c);
  69             }
  70           if (FOLD ((UCHAR) *n) != c)
  71             return FNM_NOMATCH;
  72           break;
  73
  74         case L('*'):
  75           if (*n == L('.') && no_leading_period
  76               && (n == string
  77                   || (n[-1] == L('/') && (flags & FNM_FILE_NAME))))
  78             return FNM_NOMATCH;
  79
  80           for (c = *p++; c == L('?') || c == L('*'); c = *p++)
  81             {
  82               if (*n == L('/') && (flags & FNM_FILE_NAME))
  83                 /* A slash does not match a wildcard under FNM_FILE_NAME.  */
  84                 return FNM_NOMATCH;
  85               else if (c == L('?'))
  86                 {
  87                   /* A ? needs to match one character.  */
  88                   if (*n == L('\0'))
  89                     /* There isn't another character; no match.  */
  90                     return FNM_NOMATCH;
  91                   else
  92                     /* One character of the string is consumed in matching
  93                        this ? wildcard, so *??? won't match if there are
  94                        less than three characters.  */
  95                     ++n;
  96                 }
  97             }
  98
  99           if (c == L('\0'))
 100             /* The wildcard(s) is/are the last element of the pattern.
 101                If the name is a file name and contains another slash
 102                this means it cannot match, unless the FNM_LEADING_DIR
 103                flag is set.  */
 104             {
 105               int result = (flags & FNM_FILE_NAME) == 0 ? 0 : FNM_NOMATCH;
 106
 107               if (flags & FNM_FILE_NAME)
 108                 {
 109                   if (flags & FNM_LEADING_DIR)
 110                     result = 0;
 111                   else
 112                     {
 113                       if (STRCHR (n, L('/')) == NULL)
 114                         result = 0;
 115                     }
 116                 }
 117
 118               return result;
 119             }
 120           else
 121             {
 122               const CHAR *endp;
 123
 124               endp = STRCHRNUL (n, (flags & FNM_FILE_NAME) ? L('/') : L('\0'));
 125
 126               if (c == L('['))
 127                 {
 128                   int flags2 = ((flags & FNM_FILE_NAME)
 129                                 ? flags : (flags & ~FNM_PERIOD));
 130
 131                   for (--p; n < endp; ++n)
 132                     if (FCT (p, n, (no_leading_period
 133                                     && (n == string
 134                                         || (n[-1] == L('/')
 135                                             && (flags & FNM_FILE_NAME)))),
 136                              flags2) == 0)
 137                       return 0;
 138                 }
 139               else if (c == L('/') && (flags & FNM_FILE_NAME))
 140                 {
 141                   while (*n != L('\0') && *n != L('/'))
 142                     ++n;
 143                   if (*n == L('/')
 144                       && (FCT (p, n + 1, flags & FNM_PERIOD, flags) == 0))
 145                     return 0;
 146                 }
 147               else
 148                 {
 149                   int flags2 = ((flags & FNM_FILE_NAME)
 150                                 ? flags : (flags & ~FNM_PERIOD));
 151
 152                   if (c == L('\\') && !(flags & FNM_NOESCAPE))
 153                     c = *p;
 154                   c = FOLD (c);
 155                   for (--p; n < endp; ++n)
 156                     if (FOLD ((UCHAR) *n) == c
 157                         && (FCT (p, n, (no_leading_period
 158                                         && (n == string
 159                                             || (n[-1] == L('/')
 160                                                 && (flags & FNM_FILE_NAME)))),
 161                                  flags2) == 0))
 162                       return 0;
 163                 }
 164             }
 165
 166           /* If we come here no match is possible with the wildcard.  */
 167           return FNM_NOMATCH;
 168
 169         case L('['):
 170           {
 171             static int posixly_correct;
 172             /* Nonzero if the sense of the character class is inverted.  */
 173             register int not;
 174             CHAR cold;
 175
 176             if (posixly_correct == 0)
 177               posixly_correct = getenv ("POSIXLY_CORRECT") != NULL ? 1 : -1;
 178
 179             if (*n == L('\0'))
 180               return FNM_NOMATCH;
 181
 182             if (*n == L('.') && no_leading_period
 183                 && (n == string
 184                     || (n[-1] == L('/') && (flags & FNM_FILE_NAME))))
 185               return FNM_NOMATCH;
 186
 187             if (*n == L('/') && (flags & FNM_FILE_NAME))
 188               /* `/' cannot be matched.  */
 189               return FNM_NOMATCH;
 190
 191             not = (*p == L('!') || (posixly_correct < 0 && *p == L('^')));
 192             if (not)
 193               ++p;
 194
 195             c = *p++;
 196             for (;;)
 197               {
 198                 UCHAR fn = FOLD ((UCHAR) *n);
 199
 200                 if (!(flags & FNM_NOESCAPE) && c == L('\\'))
 201                   {
 202                     if (*p == L('\0'))
 203                       return FNM_NOMATCH;
 204                     c = FOLD ((UCHAR) *p);
 205                     ++p;
 206
 207                     if (c == fn)
 208                       goto matched;
 209                   }
 210                 else if (c == L('[') && *p == L(':'))
 211                   {
 212                     /* Leave room for the null.  */
 213                     CHAR str[CHAR_CLASS_MAX_LENGTH + 1];
 214                     size_t c1 = 0;
 215 #if defined _LIBC || (defined HAVE_WCTYPE_H && defined HAVE_WCHAR_H)
 216                     wctype_t wt;
 217 #endif
 218                     const CHAR *startp = p;
 219
 220                     for (;;)
 221                       {
 222                         if (c1 == CHAR_CLASS_MAX_LENGTH)
 223                           /* The name is too long and therefore the pattern
 224                              is ill-formed.  */
 225                           return FNM_NOMATCH;
 226
 227                         c = *++p;
 228                         if (c == L(':') && p[1] == L(']'))
 229                           {
 230                             p += 2;
 231                             break;
 232                           }
 233                         if (c < L('a') || c >= L('z'))
 234                           {
 235                             /* This cannot possibly be a character class name.
 236                                Match it as a normal range.  */
 237                             p = startp;
 238                             c = L('[');
 239                             goto normal_bracket;
 240                           }
 241                         str[c1++] = c;
 242                       }
 243                     str[c1] = L('\0');
 244
 245 #if defined _LIBC || (defined HAVE_WCTYPE_H && defined HAVE_WCHAR_H)
 246                     wt = IS_CHAR_CLASS (str);
 247                     if (wt == 0)
 248                       /* Invalid character class name.  */
 249                       return FNM_NOMATCH;
 250
 251 # if defined _LIBC && ! WIDE_CHAR_VERSION
 252                     /* The following code is glibc specific but does
 253                        there a good job in speeding up the code since
 254                        we can avoid the btowc() call.  */
 255                     if (_ISCTYPE ((UCHAR) *n, wt))
 256                       goto matched;
 257 # else
 258                     if (ISWCTYPE (BTOWC ((UCHAR) *n), wt))
 259                       goto matched;
 260 # endif
 261 #else
 262                     if ((STREQ (str, L("alnum")) && ISALNUM ((UCHAR) *n))
 263                         || (STREQ (str, L("alpha")) && ISALPHA ((UCHAR) *n))
 264                         || (STREQ (str, L("blank")) && ISBLANK ((UCHAR) *n))
 265                         || (STREQ (str, L("cntrl")) && ISCNTRL ((UCHAR) *n))
 266                         || (STREQ (str, L("digit")) && ISDIGIT ((UCHAR) *n))
 267                         || (STREQ (str, L("graph")) && ISGRAPH ((UCHAR) *n))
 268                         || (STREQ (str, L("lower")) && ISLOWER ((UCHAR) *n))
 269                         || (STREQ (str, L("print")) && ISPRINT ((UCHAR) *n))
 270                         || (STREQ (str, L("punct")) && ISPUNCT ((UCHAR) *n))
 271                         || (STREQ (str, L("space")) && ISSPACE ((UCHAR) *n))
 272                         || (STREQ (str, L("upper")) && ISUPPER ((UCHAR) *n))
 273                         || (STREQ (str, L("xdigit")) && ISXDIGIT ((UCHAR) *n)))
 274                       goto matched;
 275 #endif
 276                     c = *p++;
 277                   }
 278 #ifdef _LIBC
 279                 else if (c == L('[') && *p == L('='))
 280                   {
 281                     UCHAR str[1];
 282                     uint32_t nrules =
 283                       _NL_CURRENT_WORD (LC_COLLATE, _NL_COLLATE_NRULES);
 284                     const CHAR *startp = p;
 285
 286                     c = *++p;
 287                     if (c == L('\0'))
 288                       {
 289                         p = startp;
 290                         c = L('[');
 291                         goto normal_bracket;
 292                       }
 293                     str[0] = c;
 294
 295                     c = *++p;
 296                     if (c != L('=') || p[1] != L(']'))
 297                       {
 298                         p = startp;
 299                         c = L('[');
 300                         goto normal_bracket;
 301                       }
 302                     p += 2;
 303
 304                     if (nrules == 0)
 305                       {
 306                         if ((UCHAR) *n == str[0])
 307                           goto matched;
 308                       }
 309                     else
 310                       {
 311                         const int32_t *table;
 312 # if WIDE_CHAR_VERSION
 313                         const int32_t *weights;
 314                         const int32_t *extra;
 315 # else
 316                         const unsigned char *weights;
 317                         const unsigned char *extra;
 318 # endif
 319                         const int32_t *indirect;
 320                         int32_t idx;
 321                         const UCHAR *cp = (const UCHAR *) str;
 322
 323                         /* This #include defines a local function!  */
 324 # if WIDE_CHAR_VERSION
 325 #  include <locale/weightwc.h>
 326 # else
 327 #  include <locale/weight.h>
 328 # endif
 329
 330 # if WIDE_CHAR_VERSION
 331                         table = (const int32_t *)
 332                           _NL_CURRENT (LC_COLLATE, _NL_COLLATE_TABLEWC);
 333                         weights = (const int32_t *)
 334                           _NL_CURRENT (LC_COLLATE, _NL_COLLATE_WEIGHTWC);
 335                         extra = (const int32_t *)
 336                           _NL_CURRENT (LC_COLLATE, _NL_COLLATE_EXTRAWC);
 337                         indirect = (const int32_t *)
 338                           _NL_CURRENT (LC_COLLATE, _NL_COLLATE_INDIRECTWC);
 339 # else
 340                         table = (const int32_t *)
 341                           _NL_CURRENT (LC_COLLATE, _NL_COLLATE_TABLEMB);
 342                         weights = (const unsigned char *)
 343                           _NL_CURRENT (LC_COLLATE, _NL_COLLATE_WEIGHTMB);
 344                         extra = (const unsigned char *)
 345                           _NL_CURRENT (LC_COLLATE, _NL_COLLATE_EXTRAMB);
 346                         indirect = (const int32_t *)
 347                           _NL_CURRENT (LC_COLLATE, _NL_COLLATE_INDIRECTMB);
 348 # endif
 349
 350                         idx = findidx (&cp);
 351                         if (idx != 0)
 352                           {
 353                             /* We found a table entry.  Now see whether the
 354                                character we are currently at has the same
 355                                equivalance class value.  */
 356                             int len = weights[idx];
 357                             int32_t idx2;
 358                             const UCHAR *np = (const UCHAR *) n;
 359
 360                             idx2 = findidx (&np);
 361                             if (idx2 != 0 && len == weights[idx2])
 362                               {
 363                                 int cnt = 0;
 364
 365                                 while (cnt < len
 366                                        && (weights[idx + 1 + cnt]
 367                                            == weights[idx2 + 1 + cnt]))
 368                                   ++cnt;
 369
 370                                 if (cnt == len)
 371                                   goto matched;
 372                               }
 373                           }
 374                       }
 375
 376                     c = *p++;
 377                   }
 378 #endif
 379                 else if (c == L('\0'))
 380                   /* [ (unterminated) loses.  */
 381                   return FNM_NOMATCH;
 382                 else
 383                   {
 384                     int is_range = 0;
 385
 386 #ifdef _LIBC
 387                     int is_seqval = 0;
 388
 389                     if (c == L('[') && *p == L('.'))
 390                       {
 391                         uint32_t nrules =
 392                           _NL_CURRENT_WORD (LC_COLLATE, _NL_COLLATE_NRULES);
 393                         const CHAR *startp = p;
 394                         size_t c1 = 0;
 395
 396                         while (1)
 397                           {
 398                             c = *++p;
 399                             if (c == L('.') && p[1] == L(']'))
 400                               {
 401                                 p += 2;
 402                                 break;
 403                               }
 404                             if (c == '\0')
 405                               return FNM_NOMATCH;
 406                             ++c1;
 407                           }
 408
 409                         /* We have to handling the symbols differently in
 410                            ranges since then the collation sequence is
 411                            important.  */
 412                         is_range = *p == L('-') && p[1] != L('\0');
 413
 414                         if (nrules == 0)
 415                           {
 416                             /* There are no names defined in the collation
 417                                data.  Therefore we only accept the trivial
 418                                names consisting of the character itself.  */
 419                             if (c1 != 1)
 420                               return FNM_NOMATCH;
 421
 422                             if (!is_range && *n == startp[1])
 423                               goto matched;
 424
 425                             cold = startp[1];
 426                             c = *p++;
 427                           }
 428                         else
 429                           {
 430                             int32_t table_size;
 431                             const int32_t *symb_table;
 432 # ifdef WIDE_CHAR_VERSION
 433                             char str[c1];
 434                             unsigned int strcnt;
 435 # else
 436 #  define str (startp + 1)
 437 # endif
 438                             const unsigned char *extra;
 439                             int32_t idx;
 440                             int32_t elem;
 441                             int32_t second;
 442                             int32_t hash;
 443
 444 # ifdef WIDE_CHAR_VERSION
 445                             /* We have to convert the name to a single-byte
 446                                string.  This is possible since the names
 447                                consist of ASCII characters and the internal
 448                                representation is UCS4.  */
 449                             for (strcnt = 0; strcnt < c1; ++strcnt)
 450                               str[strcnt] = startp[1 + strcnt];
 451 #endif
 452
 453                             table_size =
 454                               _NL_CURRENT_WORD (LC_COLLATE,
 455                                                 _NL_COLLATE_SYMB_HASH_SIZEMB);
 456                             symb_table = (const int32_t *)
 457                               _NL_CURRENT (LC_COLLATE,
 458                                            _NL_COLLATE_SYMB_TABLEMB);
 459                             extra = (const unsigned char *)
 460                               _NL_CURRENT (LC_COLLATE,
 461                                            _NL_COLLATE_SYMB_EXTRAMB);
 462
 463                             /* Locate the character in the hashing table.  */
 464                             hash = elem_hash (str, c1);
 465
 466                             idx = 0;
 467                             elem = hash % table_size;
 468                             second = hash % (table_size - 2);
 469                             while (symb_table[2 * elem] != 0)
 470                               {
 471                                 /* First compare the hashing value.  */
 472                                 if (symb_table[2 * elem] == hash
 473                                     && c1 == extra[symb_table[2 * elem + 1]]
 474                                     && memcmp (str,
 475                                                &extra[symb_table[2 * elem + 1]
 476                                                      + 1], c1) == 0)
 477                                   {
 478                                     /* Yep, this is the entry.  */
 479                                     idx = symb_table[2 * elem + 1];
 480                                     idx += 1 + extra[idx];
 481                                     break;
 482                                   }
 483
 484                                 /* Next entry.  */
 485                                 elem += second;
 486                               }
 487
 488                             if (symb_table[2 * elem] != 0)
 489                               {
 490                                 /* Compare the byte sequence but only if
 491                                    this is not part of a range.  */
 492 # ifdef WIDE_CHAR_VERSION
 493                                 int32_t *wextra;
 494
 495                                 idx += 1 + extra[idx];
 496                                 /* Adjust for the alignment.  */
 497                                 idx = (idx + 3) & ~4;
 498
 499                                 wextra = (int32_t *) &extra[idx + 4];
 500 # endif
 501
 502                                 if (! is_range)
 503                                   {
 504 # ifdef WIDE_CHAR_VERSION
 505                                     for (c1 = 0; c1 < wextra[idx]; ++c1)
 506                                       if (n[c1] != wextra[1 + c1])
 507                                         break;
 508
 509                                     if (c1 == wextra[idx])
 510                                       goto matched;
 511 # else
 512                                     for (c1 = 0; c1 < extra[idx]; ++c1)
 513                                       if (n[c1] != extra[1 + c1])
 514                                         break;
 515
 516                                     if (c1 == extra[idx])
 517                                       goto matched;
 518 # endif
 519                                   }
 520
 521                                 /* Get the collation sequence value.  */
 522                                 is_seqval = 1;
 523 # ifdef WIDE_CHAR_VERSION
 524                                 cold = wextra[1 + wextra[idx]];
 525 # else
 526                                 /* Adjust for the alignment.  */
 527                                 idx += 1 + extra[idx];
 528                                 idx = (idx + 3) & ~4;
 529                                 cold = *((int32_t *) &extra[idx]);
 530 # endif
 531
 532                                 c = *p++;
 533                               }
 534                             else if (c1 == 1)
 535                               {
 536                                 /* No valid character.  Match it as a
 537                                    single byte.  */
 538                                 if (!is_range && *n == str[0])
 539                                   goto matched;
 540
 541                                 cold = str[0];
 542                                 c = *p++;
 543                               }
 544                             else
 545                               return FNM_NOMATCH;
 546                           }
 547                       }
 548                     else
 549 # undef str
 550 #endif
 551                       {
 552                         c = FOLD (c);
 553                       normal_bracket:
 554
 555                         /* We have to handling the symbols differently in
 556                            ranges since then the collation sequence is
 557                            important.  */
 558                         is_range = *p == L('-') && p[1] != L('\0');
 559
 560                         if (!is_range && c == fn)
 561                           goto matched;
 562
 563                         cold = c;
 564                         c = *p++;
 565                       }
 566
 567                     if (c == L('-') && *p != L(']'))
 568                       {
 569 #if _LIBC
 570                         /* We have to find the collation sequence
 571                            value for C.  Collation sequence is nothing
 572                            we can regularly access.  The sequence
 573                            value is defined by the order in which the
 574                            definitions of the collation values for the
 575                            various characters appear in the source
 576                            file.  A strange concept, nowhere
 577                            documented.  */
 578                         uint32_t fcollseq;
 579                         uint32_t lcollseq;
 580                         UCHAR cend = *p++;
 581
 582 # ifdef WIDE_CHAR_VERSION
 583                         /* Search in the `names' array for the characters.  */
 584                         fcollseq = collseq_table_lookup (collseq, fn);
 585                         if (fcollseq == ~((uint32_t) 0))
 586                           /* XXX We don't know anything about the character
 587                              we are supposed to match.  This means we are
 588                              failing.  */
 589                           goto range_not_matched;
 590
 591                         if (is_seqval)
 592                           lcollseq = cold;
 593                         else
 594                           lcollseq = collseq_table_lookup (collseq, cold);
 595 # else
 596                         fcollseq = collseq[fn];
 597                         lcollseq = is_seqval ? cold : collseq[(UCHAR) cold];
 598 # endif
 599
 600                         is_seqval = 0;
 601                         if (cend == L('[') && *p == L('.'))
 602                           {
 603                             uint32_t nrules =
 604                               _NL_CURRENT_WORD (LC_COLLATE,
 605                                                 _NL_COLLATE_NRULES);
 606                             const CHAR *startp = p;
 607                             size_t c1 = 0;
 608
 609                             while (1)
 610                               {
 611                                 c = *++p;
 612                                 if (c == L('.') && p[1] == L(']'))
 613                                   {
 614                                     p += 2;
 615                                     break;
 616                                   }
 617                                 if (c == '\0')
 618                                   return FNM_NOMATCH;
 619                                 ++c1;
 620                               }
 621
 622                             if (nrules == 0)
 623                               {
 624                                 /* There are no names defined in the
 625                                    collation data.  Therefore we only
 626                                    accept the trivial names consisting
 627                                    of the character itself.  */
 628                                 if (c1 != 1)
 629                                   return FNM_NOMATCH;
 630
 631                                 cend = startp[1];
 632                               }
 633                             else
 634                               {
 635                                 int32_t table_size;
 636                                 const int32_t *symb_table;
 637 # ifdef WIDE_CHAR_VERSION
 638                                 char str[c1];
 639                                 unsigned int strcnt;
 640 # else
 641 #  define str (startp + 1)
 642 # endif
 643                                 const unsigned char *extra;
 644                                 int32_t idx;
 645                                 int32_t elem;
 646                                 int32_t second;
 647                                 int32_t hash;
 648
 649 # ifdef WIDE_CHAR_VERSION
 650                                 /* We have to convert the name to a single-byte
 651                                    string.  This is possible since the names
 652                                    consist of ASCII characters and the internal
 653                                    representation is UCS4.  */
 654                                 for (strcnt = 0; strcnt < c1; ++strcnt)
 655                                   str[strcnt] = startp[1 + strcnt];
 656 # endif
 657
 658                                 table_size =
 659                                   _NL_CURRENT_WORD (LC_COLLATE,
 660                                                     _NL_COLLATE_SYMB_HASH_SIZEMB);
 661                                 symb_table = (const int32_t *)
 662                                   _NL_CURRENT (LC_COLLATE,
 663                                                _NL_COLLATE_SYMB_TABLEMB);
 664                                 extra = (const unsigned char *)
 665                                   _NL_CURRENT (LC_COLLATE,
 666                                                _NL_COLLATE_SYMB_EXTRAMB);
 667
 668                                 /* Locate the character in the hashing
 669                                    table.  */
 670                                 hash = elem_hash (str, c1);
 671
 672                                 idx = 0;
 673                                 elem = hash % table_size;
 674                                 second = hash % (table_size - 2);
 675                                 while (symb_table[2 * elem] != 0)
 676                                   {
 677                                 /* First compare the hashing value.  */
 678                                     if (symb_table[2 * elem] == hash
 679                                         && (c1
 680                                             == extra[symb_table[2 * elem + 1]])
 681                                         && memcmp (str,
 682                                                    &extra[symb_table[2 * elem + 1]
 683                                                          + 1], c1) == 0)
 684                                       {
 685                                         /* Yep, this is the entry.  */
 686                                         idx = symb_table[2 * elem + 1];
 687                                         idx += 1 + extra[idx];
 688                                         break;
 689                                       }
 690
 691                                     /* Next entry.  */
 692                                     elem += second;
 693                                   }
 694
 695                                 if (symb_table[2 * elem] != 0)
 696                                   {
 697                                     /* Compare the byte sequence but only if
 698                                        this is not part of a range.  */
 699 # ifdef WIDE_CHAR_VERSION
 700                                     int32_t *wextra;
 701
 702                                     idx += 1 + extra[idx];
 703                                     /* Adjust for the alignment.  */
 704                                     idx = (idx + 3) & ~4;
 705
 706                                     wextra = (int32_t *) &extra[idx + 4];
 707 # endif
 708                                     /* Get the collation sequence value.  */
 709                                     is_seqval = 1;
 710 # ifdef WIDE_CHAR_VERSION
 711                                     cend = wextra[1 + wextra[idx]];
 712 # else
 713                                     /* Adjust for the alignment.  */
 714                                     idx += 1 + extra[idx];
 715                                     idx = (idx + 3) & ~4;
 716                                     cend = *((int32_t *) &extra[idx]);
 717 # endif
 718                                   }
 719                                 else if (symb_table[2 * elem] != 0 && c1 == 1)
 720                                   {
 721                                     cend = str[0];
 722                                     c = *p++;
 723                                   }
 724                                 else
 725                                   return FNM_NOMATCH;
 726                               }
 727 # undef str
 728                           }
 729                         else
 730                           {
 731                             if (!(flags & FNM_NOESCAPE) && cend == L('\\'))
 732                               cend = *p++;
 733                             if (cend == L('\0'))
 734                               return FNM_NOMATCH;
 735                             cend = FOLD (cend);
 736                           }
 737
 738                         /* XXX It is not entirely clear to me how to handle
 739                            characters which are not mentioned in the
 740                            collation specification.  */
 741                         if (
 742 # ifdef WIDE_CHAR_VERSION
 743                             lcollseq == 0xffffffff ||
 744 # endif
 745                             lcollseq <= fcollseq)
 746                           {
 747                             /* We have to look at the upper bound.  */
 748                             uint32_t hcollseq;
 749
 750                             if (is_seqval)
 751                               hcollseq = cend;
 752                             else
 753                               {
 754 # ifdef WIDE_CHAR_VERSION
 755                                 hcollseq =
 756                                   collseq_table_lookup (collseq, cend);
 757                                 if (hcollseq == ~((uint32_t) 0))
 758                                   {
 759                                     /* Hum, no information about the upper
 760                                        bound.  The matching succeeds if the
 761                                        lower bound is matched exactly.  */
 762                                     if (lcollseq != fcollseq)
 763                                       goto range_not_matched;
 764
 765                                     goto matched;
 766                                   }
 767 # else
 768                                 hcollseq = collseq[cend];
 769 # endif
 770                               }
 771
 772                             if (lcollseq <= hcollseq && fcollseq <= hcollseq)
 773                               goto matched;
 774                           }
 775 # ifdef WIDE_CHAR_VERSION
 776                       range_not_matched:
 777 # endif
 778 #else
 779                         /* We use a boring value comparison of the character
 780                            values.  This is better than comparing using
 781                            `strcoll' since the latter would have surprising
 782                            and sometimes fatal consequences.  */
 783                         UCHAR cend = *p++;
 784
 785                         if (!(flags & FNM_NOESCAPE) && cend == L('\\'))
 786                           cend = *p++;
 787                         if (cend == L('\0'))
 788                           return FNM_NOMATCH;
 789
 790                         /* It is a range.  */
 791                         if (cold <= fn && fn <= c)
 792                           goto matched;
 793 #endif
 794
 795                         c = *p++;
 796                       }
 797                   }
 798
 799                 if (c == L(']'))
 800                   break;
 801               }
 802
 803             if (!not)
 804               return FNM_NOMATCH;
 805             break;
 806
 807           matched:
 808             /* Skip the rest of the [...] that already matched.  */
 809             do
 810               {
 811               ignore_next:
 812                 c = *p++;
 813
 814                 if (c == L('\0'))
 815                   /* [... (unterminated) loses.  */
 816                   return FNM_NOMATCH;
 817
 818                 if (!(flags & FNM_NOESCAPE) && c == L('\\'))
 819                   {
 820                     if (*p == L('\0'))
 821                       return FNM_NOMATCH;
 822                     /* XXX 1003.2d11 is unclear if this is right.  */
 823                     ++p;
 824                   }
 825                 else if (c == L('[') && *p == L(':'))
 826                   {
 827                     int c1 = 0;
 828                     const CHAR *startp = p;
 829
 830                     while (1)
 831                       {
 832                         c = *++p;
 833                         if (++c1 == CHAR_CLASS_MAX_LENGTH)
 834                           return FNM_NOMATCH;
 835
 836                         if (*p == L(':') && p[1] == L(']'))
 837                           break;
 838
 839                         if (c < L('a') || c >= L('z'))
 840                           {
 841                             p = startp;
 842                             goto ignore_next;
 843                           }
 844                       }
 845                     p += 2;
 846                     c = *p++;
 847                   }
 848                 else if (c == L('[') && *p == L('='))
 849                   {
 850                     c = *++p;
 851                     if (c == L('\0'))
 852                       return FNM_NOMATCH;
 853                     c = *++p;
 854                     if (c != L('=') || p[1] != L(']'))
 855                       return FNM_NOMATCH;
 856                     p += 2;
 857                     c = *p++;
 858                   }
 859                 else if (c == L('[') && *p == L('.'))
 860                   {
 861                     ++p;
 862                     while (1)
 863                       {
 864                         c = *++p;
 865                         if (c == '\0')
 866                           return FNM_NOMATCH;
 867
 868                         if (*p == L('.') && p[1] == L(']'))
 869                           break;
 870                       }
 871                     p += 2;
 872                     c = *p++;
 873                   }
 874               }
 875             while (c != L(']'));
 876             if (not)
 877               return FNM_NOMATCH;
 878           }
 879           break;
 880
 881         default:
 882           if (c != FOLD ((UCHAR) *n))
 883             return FNM_NOMATCH;
 884         }
 885
 886       ++n;
 887     }
 888
 889   if (*n == '\0')
 890     return 0;
 891
 892   if ((flags & FNM_LEADING_DIR) && *n == L('/'))
 893     /* The FNM_LEADING_DIR flag says that "foo*" matches "foobar/frobozz".  */
 894     return 0;
 895
 896   return FNM_NOMATCH;
 897 }
 898
 899 #undef FOLD
 900 #undef CHAR
 901 #undef UCHAR
 902 #undef FCT
 903 #undef STRCHR
 904 #undef STRCHRNUL
 905 #undef STRCOLL
 906 #undef L
 907 #undef BTOWC