← Back to branch summary

~darkmuggle-deactivatedaccount/ubuntu/quantal/grub2/fix-872244

« back to all changes in this revision

Viewing changes to gnulib/fnmatch.c

  • Committer: Bazaar Package Importer
  • Author(s): Colin Watson, Colin Watson, Evan Broder, Mario Limonciello
  • Date: 2010-11-24 13:59:55 UTC
  • mfrom: (1.17.6 upstream) (17.6.15 experimental)
  • Revision ID: james.westby@ubuntu.com-20101124135955-r6ii5sepayr7jt53
Tags: 1.99~20101124-1ubuntu1
https://launchpad.net/bugs/677758
[ Colin Watson ]
* Resynchronise with Debian experimental.  Remaining changes:
  - Adjust for default Ubuntu boot options ("quiet splash").
  - Default to hiding the menu; holding down Shift at boot will show it.
  - Set a monochromatic theme for Ubuntu.
  - Apply Ubuntu GRUB Legacy changes to legacy update-grub script: title,
    recovery mode, quiet option, tweak how memtest86+ is displayed, and
    use UUIDs where appropriate.
  - Fix backslash-escaping in merge_debconf_into_conf.
  - Remove "GNU/Linux" from default distributor string.
  - Add crashkernel= options if kdump and makedumpfile are available.
  - If other operating systems are installed, then automatically unhide
    the menu.  Otherwise, if GRUB_HIDDEN_TIMEOUT is 0, then use keystatus
    if available to check whether Shift is pressed.  If it is, show the
    menu, otherwise boot immediately.  If keystatus is not available, then
    fall back to a short delay interruptible with Escape.
  - Allow Shift to interrupt 'sleep --interruptible'.
  - Don't display introductory message about line editing unless we're
    actually offering a shell prompt.  Don't clear the screen just before
    booting if we never drew the menu in the first place.
  - Remove some verbose messages printed before reading the configuration
    file.
  - Suppress progress messages as the kernel and initrd load for
    non-recovery kernel menu entries.
  - Change prepare_grub_to_access_device to handle filesystems
    loop-mounted on file images.
  - Ignore devices loop-mounted from files in 10_linux.
  - Show the boot menu if the previous boot failed, that is if it failed
    to get to the end of one of the normal runlevels.
  - Don't generate /boot/grub/device.map during grub-install or
    grub-mkconfig by default.
  - Adjust upgrade version checks for Ubuntu.
  - Don't display "GRUB loading" unless Shift is held down.
  - Adjust versions of grub-doc and grub-legacy-doc conflicts to tolerate
    our backport of the grub-doc split.
  - Fix LVM/RAID probing in the absence of /boot/grub/device.map.
  - Look for .mo files in /usr/share/locale-langpack as well, in
    preference.
  - Make sure GRUB_TIMEOUT isn't quoted unnecessarily.
  - Probe all devices in 'grub-probe --target=drive' if
    /boot/grub/device.map is missing.
  - Build-depend on qemu-kvm rather than qemu-system for grub-pc tests.
  - Use qemu rather than qemu-system-i386.
  - Program vesafb on BIOS systems rather than efifb.
  - Add a grub-rescue-efi-amd64 package containing a rescue CD-ROM image
    for EFI-AMD64.
  - On Wubi, don't ask for an install device, but just update wubildr
    using the diverted grub-install.
  - When embedding the core image in a post-MBR gap, check for and avoid
    sectors matching any of a list of known signatures.
  - Disable video_bochs and video_cirrus on PC BIOS systems, as probing
    PCI space seems to break on some systems.
* Downgrade "ACPI shutdown failed" error to a debug message, since it can
  cause spurious test failures.

[ Evan Broder ]
* Enable lua from grub-extras.
* Incorporate the bitop library into lua.
* Add enum_pci function to grub module in lua.
* Switch back to gfxpayload=keep by default, unless the video hardware
  is known to not support it.

[ Mario Limonciello ]
* Built part_msdos and vfat into bootx64.efi (LP: #677758)

Show diffs side-by-side

added added

removed removed

Lines of Context:
gnulib/fnmatch.c
1
 
/* Copyright (C) 1991, 1992, 1993, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
2
 
   2003, 2004, 2005, 2006, 2007, 2009, 2010 Free Software Foundation, Inc.
3
 
 
4
 
   This program is free software; you can redistribute it and/or modify
5
 
   it under the terms of the GNU General Public License as published by
6
 
   the Free Software Foundation; either version 2, or (at your option)
7
 
   any later version.
8
 
 
9
 
   This program 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
12
 
   GNU General Public License for more details.
13
 
 
14
 
   You should have received a copy of the GNU General Public License
15
 
   along with this program; if not, write to the Free Software Foundation,
16
 
   Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.  */
17
 
 
18
 
#ifndef _LIBC
19
 
# include <config.h>
20
 
#endif
21
 
 
22
 
/* Enable GNU extensions in fnmatch.h.  */
23
 
#ifndef _GNU_SOURCE
24
 
# define _GNU_SOURCE    1
25
 
#endif
26
 
 
27
 
#if ! defined __builtin_expect && __GNUC__ < 3
28
 
# define __builtin_expect(expr, expected) (expr)
29
 
#endif
30
 
 
31
 
#include <fnmatch.h>
32
 
 
33
 
#include <alloca.h>
34
 
#include <assert.h>
35
 
#include <ctype.h>
36
 
#include <errno.h>
37
 
#include <stddef.h>
38
 
#include <stdbool.h>
39
 
#include <stdlib.h>
40
 
#include <string.h>
41
 
 
42
 
#define WIDE_CHAR_SUPPORT \
43
 
  (HAVE_WCTYPE_H && HAVE_BTOWC && HAVE_ISWCTYPE \
44
 
   && HAVE_WMEMCHR && (HAVE_WMEMCPY || HAVE_WMEMPCPY))
45
 
 
46
 
/* For platform which support the ISO C amendement 1 functionality we
47
 
   support user defined character classes.  */
48
 
#if defined _LIBC || WIDE_CHAR_SUPPORT
49
 
# include <wctype.h>
50
 
# include <wchar.h>
51
 
#endif
52
 
 
53
 
/* We need some of the locale data (the collation sequence information)
54
 
   but there is no interface to get this information in general.  Therefore
55
 
   we support a correct implementation only in glibc.  */
56
 
#ifdef _LIBC
57
 
# include "../locale/localeinfo.h"
58
 
# include "../locale/elem-hash.h"
59
 
# include "../locale/coll-lookup.h"
60
 
# include <shlib-compat.h>
61
 
 
62
 
# define CONCAT(a,b) __CONCAT(a,b)
63
 
# define mbsrtowcs __mbsrtowcs
64
 
# define fnmatch __fnmatch
65
 
extern int fnmatch (const char *pattern, const char *string, int flags);
66
 
#endif
67
 
 
68
 
#ifndef SIZE_MAX
69
 
# define SIZE_MAX ((size_t) -1)
70
 
#endif
71
 
 
72
 
/* We often have to test for FNM_FILE_NAME and FNM_PERIOD being both set.  */
73
 
#define NO_LEADING_PERIOD(flags) \
74
 
  ((flags & (FNM_FILE_NAME | FNM_PERIOD)) == (FNM_FILE_NAME | FNM_PERIOD))
75
 
 
76
 
/* Comment out all this code if we are using the GNU C Library, and are not
77
 
   actually compiling the library itself, and have not detected a bug
78
 
   in the library.  This code is part of the GNU C
79
 
   Library, but also included in many other GNU distributions.  Compiling
80
 
   and linking in this code is a waste when using the GNU C library
81
 
   (especially if it is a shared library).  Rather than having every GNU
82
 
   program understand `configure --with-gnu-libc' and omit the object files,
83
 
   it is simpler to just do this in the source for each such file.  */
84
 
 
85
 
#if defined _LIBC || !defined __GNU_LIBRARY__ || !HAVE_FNMATCH_GNU
86
 
 
87
 
 
88
 
# if ! (defined isblank || (HAVE_ISBLANK && HAVE_DECL_ISBLANK))
89
 
#  define isblank(c) ((c) == ' ' || (c) == '\t')
90
 
# endif
91
 
 
92
 
# define STREQ(s1, s2) (strcmp (s1, s2) == 0)
93
 
 
94
 
# if defined _LIBC || WIDE_CHAR_SUPPORT
95
 
/* The GNU C library provides support for user-defined character classes
96
 
   and the functions from ISO C amendement 1.  */
97
 
#  ifdef CHARCLASS_NAME_MAX
98
 
#   define CHAR_CLASS_MAX_LENGTH CHARCLASS_NAME_MAX
99
 
#  else
100
 
/* This shouldn't happen but some implementation might still have this
101
 
   problem.  Use a reasonable default value.  */
102
 
#   define CHAR_CLASS_MAX_LENGTH 256
103
 
#  endif
104
 
 
105
 
#  ifdef _LIBC
106
 
#   define IS_CHAR_CLASS(string) __wctype (string)
107
 
#  else
108
 
#   define IS_CHAR_CLASS(string) wctype (string)
109
 
#  endif
110
 
 
111
 
#  ifdef _LIBC
112
 
#   define ISWCTYPE(WC, WT)     __iswctype (WC, WT)
113
 
#  else
114
 
#   define ISWCTYPE(WC, WT)     iswctype (WC, WT)
115
 
#  endif
116
 
 
117
 
#  if (HAVE_MBSTATE_T && HAVE_MBSRTOWCS) || _LIBC
118
 
/* In this case we are implementing the multibyte character handling.  */
119
 
#   define HANDLE_MULTIBYTE     1
120
 
#  endif
121
 
 
122
 
# else
123
 
#  define CHAR_CLASS_MAX_LENGTH  6 /* Namely, `xdigit'.  */
124
 
 
125
 
#  define IS_CHAR_CLASS(string)                                               \
126
 
   (STREQ (string, "alpha") || STREQ (string, "upper")                        \
127
 
    || STREQ (string, "lower") || STREQ (string, "digit")                     \
128
 
    || STREQ (string, "alnum") || STREQ (string, "xdigit")                    \
129
 
    || STREQ (string, "space") || STREQ (string, "print")                     \
130
 
    || STREQ (string, "punct") || STREQ (string, "graph")                     \
131
 
    || STREQ (string, "cntrl") || STREQ (string, "blank"))
132
 
# endif
133
 
 
134
 
/* Avoid depending on library functions or files
135
 
   whose names are inconsistent.  */
136
 
 
137
 
/* Global variable.  */
138
 
static int posixly_correct;
139
 
 
140
 
# ifndef internal_function
141
 
/* Inside GNU libc we mark some function in a special way.  In other
142
 
   environments simply ignore the marking.  */
143
 
#  define internal_function
144
 
# endif
145
 
 
146
 
/* Note that this evaluates C many times.  */
147
 
# define FOLD(c) ((flags & FNM_CASEFOLD) ? tolower (c) : (c))
148
 
# define CHAR   char
149
 
# define UCHAR  unsigned char
150
 
# define INT    int
151
 
# define FCT    internal_fnmatch
152
 
# define EXT    ext_match
153
 
# define END    end_pattern
154
 
# define L_(CS) CS
155
 
# ifdef _LIBC
156
 
#  define BTOWC(C)      __btowc (C)
157
 
# else
158
 
#  define BTOWC(C)      btowc (C)
159
 
# endif
160
 
# define STRLEN(S) strlen (S)
161
 
# define STRCAT(D, S) strcat (D, S)
162
 
# ifdef _LIBC
163
 
#  define MEMPCPY(D, S, N) __mempcpy (D, S, N)
164
 
# else
165
 
#  if HAVE_MEMPCPY
166
 
#   define MEMPCPY(D, S, N) mempcpy (D, S, N)
167
 
#  else
168
 
#   define MEMPCPY(D, S, N) ((void *) ((char *) memcpy (D, S, N) + (N)))
169
 
#  endif
170
 
# endif
171
 
# define MEMCHR(S, C, N) memchr (S, C, N)
172
 
# define STRCOLL(S1, S2) strcoll (S1, S2)
173
 
# include "fnmatch_loop.c"
174
 
 
175
 
 
176
 
# if HANDLE_MULTIBYTE
177
 
#  define FOLD(c) ((flags & FNM_CASEFOLD) ? towlower (c) : (c))
178
 
#  define CHAR  wchar_t
179
 
#  define UCHAR wint_t
180
 
#  define INT   wint_t
181
 
#  define FCT   internal_fnwmatch
182
 
#  define EXT   ext_wmatch
183
 
#  define END   end_wpattern
184
 
#  define L_(CS)        L##CS
185
 
#  define BTOWC(C)      (C)
186
 
#  ifdef _LIBC
187
 
#   define STRLEN(S) __wcslen (S)
188
 
#   define STRCAT(D, S) __wcscat (D, S)
189
 
#   define MEMPCPY(D, S, N) __wmempcpy (D, S, N)
190
 
#  else
191
 
#   define STRLEN(S) wcslen (S)
192
 
#   define STRCAT(D, S) wcscat (D, S)
193
 
#   if HAVE_WMEMPCPY
194
 
#    define MEMPCPY(D, S, N) wmempcpy (D, S, N)
195
 
#   else
196
 
#    define MEMPCPY(D, S, N) (wmemcpy (D, S, N) + (N))
197
 
#   endif
198
 
#  endif
199
 
#  define MEMCHR(S, C, N) wmemchr (S, C, N)
200
 
#  define STRCOLL(S1, S2) wcscoll (S1, S2)
201
 
#  define WIDE_CHAR_VERSION 1
202
 
 
203
 
#  undef IS_CHAR_CLASS
204
 
/* We have to convert the wide character string in a multibyte string.  But
205
 
   we know that the character class names consist of alphanumeric characters
206
 
   from the portable character set, and since the wide character encoding
207
 
   for a member of the portable character set is the same code point as
208
 
   its single-byte encoding, we can use a simplified method to convert the
209
 
   string to a multibyte character string.  */
210
 
static wctype_t
211
 
is_char_class (const wchar_t *wcs)
212
 
{
213
 
  char s[CHAR_CLASS_MAX_LENGTH + 1];
214
 
  char *cp = s;
215
 
 
216
 
  do
217
 
    {
218
 
      /* Test for a printable character from the portable character set.  */
219
 
#  ifdef _LIBC
220
 
      if (*wcs < 0x20 || *wcs > 0x7e
221
 
          || *wcs == 0x24 || *wcs == 0x40 || *wcs == 0x60)
222
 
        return (wctype_t) 0;
223
 
#  else
224
 
      switch (*wcs)
225
 
        {
226
 
        case L' ': case L'!': case L'"': case L'#': case L'%':
227
 
        case L'&': case L'\'': case L'(': case L')': case L'*':
228
 
        case L'+': case L',': case L'-': case L'.': case L'/':
229
 
        case L'0': case L'1': case L'2': case L'3': case L'4':
230
 
        case L'5': case L'6': case L'7': case L'8': case L'9':
231
 
        case L':': case L';': case L'<': case L'=': case L'>':
232
 
        case L'?':
233
 
        case L'A': case L'B': case L'C': case L'D': case L'E':
234
 
        case L'F': case L'G': case L'H': case L'I': case L'J':
235
 
        case L'K': case L'L': case L'M': case L'N': case L'O':
236
 
        case L'P': case L'Q': case L'R': case L'S': case L'T':
237
 
        case L'U': case L'V': case L'W': case L'X': case L'Y':
238
 
        case L'Z':
239
 
        case L'[': case L'\\': case L']': case L'^': case L'_':
240
 
        case L'a': case L'b': case L'c': case L'd': case L'e':
241
 
        case L'f': case L'g': case L'h': case L'i': case L'j':
242
 
        case L'k': case L'l': case L'm': case L'n': case L'o':
243
 
        case L'p': case L'q': case L'r': case L's': case L't':
244
 
        case L'u': case L'v': case L'w': case L'x': case L'y':
245
 
        case L'z': case L'{': case L'|': case L'}': case L'~':
246
 
          break;
247
 
        default:
248
 
          return (wctype_t) 0;
249
 
        }
250
 
#  endif
251
 
 
252
 
      /* Avoid overrunning the buffer.  */
253
 
      if (cp == s + CHAR_CLASS_MAX_LENGTH)
254
 
        return (wctype_t) 0;
255
 
 
256
 
      *cp++ = (char) *wcs++;
257
 
    }
258
 
  while (*wcs != L'\0');
259
 
 
260
 
  *cp = '\0';
261
 
 
262
 
#  ifdef _LIBC
263
 
  return __wctype (s);
264
 
#  else
265
 
  return wctype (s);
266
 
#  endif
267
 
}
268
 
#  define IS_CHAR_CLASS(string) is_char_class (string)
269
 
 
270
 
#  include "fnmatch_loop.c"
271
 
# endif
272
 
 
273
 
 
274
 
int
275
 
fnmatch (const char *pattern, const char *string, int flags)
276
 
{
277
 
# if HANDLE_MULTIBYTE
278
 
#  define ALLOCA_LIMIT 2000
279
 
  if (__builtin_expect (MB_CUR_MAX, 1) != 1)
280
 
    {
281
 
      mbstate_t ps;
282
 
      size_t patsize;
283
 
      size_t strsize;
284
 
      size_t totsize;
285
 
      wchar_t *wpattern;
286
 
      wchar_t *wstring;
287
 
      int res;
288
 
 
289
 
      /* Calculate the size needed to convert the strings to
290
 
         wide characters.  */
291
 
      memset (&ps, '\0', sizeof (ps));
292
 
      patsize = mbsrtowcs (NULL, &pattern, 0, &ps) + 1;
293
 
      if (__builtin_expect (patsize != 0, 1))
294
 
        {
295
 
          assert (mbsinit (&ps));
296
 
          strsize = mbsrtowcs (NULL, &string, 0, &ps) + 1;
297
 
          if (__builtin_expect (strsize != 0, 1))
298
 
            {
299
 
              assert (mbsinit (&ps));
300
 
              totsize = patsize + strsize;
301
 
              if (__builtin_expect (! (patsize <= totsize
302
 
                                       && totsize <= SIZE_MAX / sizeof (wchar_t)),
303
 
                                    0))
304
 
                {
305
 
                  errno = ENOMEM;
306
 
                  return -1;
307
 
                }
308
 
 
309
 
              /* Allocate room for the wide characters.  */
310
 
              if (__builtin_expect (totsize < ALLOCA_LIMIT, 1))
311
 
                wpattern = (wchar_t *) alloca (totsize * sizeof (wchar_t));
312
 
              else
313
 
                {
314
 
                  wpattern = malloc (totsize * sizeof (wchar_t));
315
 
                  if (__builtin_expect (! wpattern, 0))
316
 
                    {
317
 
                      errno = ENOMEM;
318
 
                      return -1;
319
 
                    }
320
 
                }
321
 
              wstring = wpattern + patsize;
322
 
 
323
 
              /* Convert the strings into wide characters.  */
324
 
              mbsrtowcs (wpattern, &pattern, patsize, &ps);
325
 
              assert (mbsinit (&ps));
326
 
              mbsrtowcs (wstring, &string, strsize, &ps);
327
 
 
328
 
              res = internal_fnwmatch (wpattern, wstring, wstring + strsize - 1,
329
 
                                       flags & FNM_PERIOD, flags);
330
 
 
331
 
              if (__builtin_expect (! (totsize < ALLOCA_LIMIT), 0))
332
 
                free (wpattern);
333
 
              return res;
334
 
            }
335
 
        }
336
 
    }
337
 
 
338
 
# endif /* HANDLE_MULTIBYTE */
339
 
 
340
 
  return internal_fnmatch (pattern, string, string + strlen (string),
341
 
                           flags & FNM_PERIOD, flags);
342
 
}
343
 
 
344
 
# ifdef _LIBC
345
 
#  undef fnmatch
346
 
versioned_symbol (libc, __fnmatch, fnmatch, GLIBC_2_2_3);
347
 
#  if SHLIB_COMPAT(libc, GLIBC_2_0, GLIBC_2_2_3)
348
 
strong_alias (__fnmatch, __fnmatch_old)
349
 
compat_symbol (libc, __fnmatch_old, fnmatch, GLIBC_2_0);
350
 
#  endif
351
 
libc_hidden_ver (__fnmatch, fnmatch)
352
 
# endif
353
 
 
354
 
#endif  /* _LIBC or not __GNU_LIBRARY__.  */