← Back to branch summary

~hamo/ubuntu/precise/grub2/grub2.hi_res

« back to all changes in this revision

Viewing changes to grub-core/gnulib/argp-fmtstream.h

  • 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:
grub-core/gnulib/argp-fmtstream.h
 
1
/* Word-wrapping and line-truncating streams.
 
2
   Copyright (C) 1997, 2006-2010 Free Software Foundation, Inc.
 
3
   This file is part of the GNU C Library.
 
4
   Written by Miles Bader <miles@gnu.ai.mit.edu>.
 
5
 
 
6
   This program is free software: you can redistribute it and/or modify
 
7
   it under the terms of the GNU General Public License as published by
 
8
   the Free Software Foundation; either version 3 of the License, or
 
9
   (at your option) any later version.
 
10
 
 
11
   This program is distributed in the hope that it will be useful,
 
12
   but WITHOUT ANY WARRANTY; without even the implied warranty of
 
13
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
14
   GNU General Public License for more details.
 
15
 
 
16
   You should have received a copy of the GNU General Public License
 
17
   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
 
18
 
 
19
/* This package emulates glibc `line_wrap_stream' semantics for systems that
 
20
   don't have that.  If the system does have it, it is just a wrapper for
 
21
   that.  This header file is only used internally while compiling argp, and
 
22
   shouldn't be installed.  */
 
23
 
 
24
#ifndef _ARGP_FMTSTREAM_H
 
25
#define _ARGP_FMTSTREAM_H
 
26
 
 
27
#include <stdio.h>
 
28
#include <string.h>
 
29
#include <unistd.h>
 
30
 
 
31
#ifndef __attribute__
 
32
/* The __attribute__ feature is available in gcc versions 2.5 and later.
 
33
   The __-protected variants of the attributes 'format' and 'printf' are
 
34
   accepted by gcc versions 2.6.4 (effectively 2.7) and later.
 
35
   We enable __attribute__ only if these are supported too, because
 
36
   gnulib and libintl do '#define printf __printf__' when they override
 
37
   the 'printf' function.  */
 
38
# if __GNUC__ < 2 || (__GNUC__ == 2 && __GNUC_MINOR__ < 7)
 
39
#  define __attribute__(Spec)   /* empty */
 
40
# endif
 
41
#endif
 
42
 
 
43
#if    (_LIBC - 0 && !defined (USE_IN_LIBIO)) \
 
44
    || (defined (__GNU_LIBRARY__) && defined (HAVE_LINEWRAP_H))
 
45
/* line_wrap_stream is available, so use that.  */
 
46
#define ARGP_FMTSTREAM_USE_LINEWRAP
 
47
#endif
 
48
 
 
49
#ifdef ARGP_FMTSTREAM_USE_LINEWRAP
 
50
/* Just be a simple wrapper for line_wrap_stream; the semantics are
 
51
   *slightly* different, as line_wrap_stream doesn't actually make a new
 
52
   object, it just modifies the given stream (reversibly) to do
 
53
   line-wrapping.  Since we control who uses this code, it doesn't matter.  */
 
54
 
 
55
#include <linewrap.h>
 
56
 
 
57
typedef FILE *argp_fmtstream_t;
 
58
 
 
59
#define argp_make_fmtstream line_wrap_stream
 
60
#define __argp_make_fmtstream line_wrap_stream
 
61
#define argp_fmtstream_free line_unwrap_stream
 
62
#define __argp_fmtstream_free line_unwrap_stream
 
63
 
 
64
#define __argp_fmtstream_putc(fs,ch) putc(ch,fs)
 
65
#define argp_fmtstream_putc(fs,ch) putc(ch,fs)
 
66
#define __argp_fmtstream_puts(fs,str) fputs(str,fs)
 
67
#define argp_fmtstream_puts(fs,str) fputs(str,fs)
 
68
#define __argp_fmtstream_write(fs,str,len) fwrite(str,1,len,fs)
 
69
#define argp_fmtstream_write(fs,str,len) fwrite(str,1,len,fs)
 
70
#define __argp_fmtstream_printf fprintf
 
71
#define argp_fmtstream_printf fprintf
 
72
 
 
73
#define __argp_fmtstream_lmargin line_wrap_lmargin
 
74
#define argp_fmtstream_lmargin line_wrap_lmargin
 
75
#define __argp_fmtstream_set_lmargin line_wrap_set_lmargin
 
76
#define argp_fmtstream_set_lmargin line_wrap_set_lmargin
 
77
#define __argp_fmtstream_rmargin line_wrap_rmargin
 
78
#define argp_fmtstream_rmargin line_wrap_rmargin
 
79
#define __argp_fmtstream_set_rmargin line_wrap_set_rmargin
 
80
#define argp_fmtstream_set_rmargin line_wrap_set_rmargin
 
81
#define __argp_fmtstream_wmargin line_wrap_wmargin
 
82
#define argp_fmtstream_wmargin line_wrap_wmargin
 
83
#define __argp_fmtstream_set_wmargin line_wrap_set_wmargin
 
84
#define argp_fmtstream_set_wmargin line_wrap_set_wmargin
 
85
#define __argp_fmtstream_point line_wrap_point
 
86
#define argp_fmtstream_point line_wrap_point
 
87
 
 
88
#else /* !ARGP_FMTSTREAM_USE_LINEWRAP */
 
89
/* Guess we have to define our own version.  */
 
90
 
 
91
struct argp_fmtstream
 
92
{
 
93
  FILE *stream;                 /* The stream we're outputting to.  */
 
94
 
 
95
  size_t lmargin, rmargin;      /* Left and right margins.  */
 
96
  ssize_t wmargin;              /* Margin to wrap to, or -1 to truncate.  */
 
97
 
 
98
  /* Point in buffer to which we've processed for wrapping, but not output.  */
 
99
  size_t point_offs;
 
100
  /* Output column at POINT_OFFS, or -1 meaning 0 but don't add lmargin.  */
 
101
  ssize_t point_col;
 
102
 
 
103
  char *buf;                    /* Output buffer.  */
 
104
  char *p;                      /* Current end of text in BUF. */
 
105
  char *end;                    /* Absolute end of BUF.  */
 
106
};
 
107
 
 
108
typedef struct argp_fmtstream *argp_fmtstream_t;
 
109
 
 
110
/* Return an argp_fmtstream that outputs to STREAM, and which prefixes lines
 
111
   written on it with LMARGIN spaces and limits them to RMARGIN columns
 
112
   total.  If WMARGIN >= 0, words that extend past RMARGIN are wrapped by
 
113
   replacing the whitespace before them with a newline and WMARGIN spaces.
 
114
   Otherwise, chars beyond RMARGIN are simply dropped until a newline.
 
115
   Returns NULL if there was an error.  */
 
116
extern argp_fmtstream_t __argp_make_fmtstream (FILE *__stream,
 
117
                                               size_t __lmargin,
 
118
                                               size_t __rmargin,
 
119
                                               ssize_t __wmargin);
 
120
extern argp_fmtstream_t argp_make_fmtstream (FILE *__stream,
 
121
                                             size_t __lmargin,
 
122
                                             size_t __rmargin,
 
123
                                             ssize_t __wmargin);
 
124
 
 
125
/* Flush __FS to its stream, and free it (but don't close the stream).  */
 
126
extern void __argp_fmtstream_free (argp_fmtstream_t __fs);
 
127
extern void argp_fmtstream_free (argp_fmtstream_t __fs);
 
128
 
 
129
extern ssize_t __argp_fmtstream_printf (argp_fmtstream_t __fs,
 
130
                                        const char *__fmt, ...)
 
131
     __attribute__ ((__format__ (printf, 2, 3)));
 
132
extern ssize_t argp_fmtstream_printf (argp_fmtstream_t __fs,
 
133
                                      const char *__fmt, ...)
 
134
     __attribute__ ((__format__ (printf, 2, 3)));
 
135
 
 
136
#if _LIBC || !defined __OPTIMIZE__
 
137
extern int __argp_fmtstream_putc (argp_fmtstream_t __fs, int __ch);
 
138
extern int argp_fmtstream_putc (argp_fmtstream_t __fs, int __ch);
 
139
 
 
140
extern int __argp_fmtstream_puts (argp_fmtstream_t __fs, const char *__str);
 
141
extern int argp_fmtstream_puts (argp_fmtstream_t __fs, const char *__str);
 
142
 
 
143
extern size_t __argp_fmtstream_write (argp_fmtstream_t __fs,
 
144
                                      const char *__str, size_t __len);
 
145
extern size_t argp_fmtstream_write (argp_fmtstream_t __fs,
 
146
                                    const char *__str, size_t __len);
 
147
#endif
 
148
 
 
149
/* Access macros for various bits of state.  */
 
150
#define argp_fmtstream_lmargin(__fs) ((__fs)->lmargin)
 
151
#define argp_fmtstream_rmargin(__fs) ((__fs)->rmargin)
 
152
#define argp_fmtstream_wmargin(__fs) ((__fs)->wmargin)
 
153
#define __argp_fmtstream_lmargin argp_fmtstream_lmargin
 
154
#define __argp_fmtstream_rmargin argp_fmtstream_rmargin
 
155
#define __argp_fmtstream_wmargin argp_fmtstream_wmargin
 
156
 
 
157
#if _LIBC || !defined __OPTIMIZE__
 
158
/* Set __FS's left margin to LMARGIN and return the old value.  */
 
159
extern size_t argp_fmtstream_set_lmargin (argp_fmtstream_t __fs,
 
160
                                          size_t __lmargin);
 
161
extern size_t __argp_fmtstream_set_lmargin (argp_fmtstream_t __fs,
 
162
                                            size_t __lmargin);
 
163
 
 
164
/* Set __FS's right margin to __RMARGIN and return the old value.  */
 
165
extern size_t argp_fmtstream_set_rmargin (argp_fmtstream_t __fs,
 
166
                                          size_t __rmargin);
 
167
extern size_t __argp_fmtstream_set_rmargin (argp_fmtstream_t __fs,
 
168
                                            size_t __rmargin);
 
169
 
 
170
/* Set __FS's wrap margin to __WMARGIN and return the old value.  */
 
171
extern size_t argp_fmtstream_set_wmargin (argp_fmtstream_t __fs,
 
172
                                          size_t __wmargin);
 
173
extern size_t __argp_fmtstream_set_wmargin (argp_fmtstream_t __fs,
 
174
                                            size_t __wmargin);
 
175
 
 
176
/* Return the column number of the current output point in __FS.  */
 
177
extern size_t argp_fmtstream_point (argp_fmtstream_t __fs);
 
178
extern size_t __argp_fmtstream_point (argp_fmtstream_t __fs);
 
179
#endif
 
180
 
 
181
/* Internal routines.  */
 
182
extern void _argp_fmtstream_update (argp_fmtstream_t __fs);
 
183
extern void __argp_fmtstream_update (argp_fmtstream_t __fs);
 
184
extern int _argp_fmtstream_ensure (argp_fmtstream_t __fs, size_t __amount);
 
185
extern int __argp_fmtstream_ensure (argp_fmtstream_t __fs, size_t __amount);
 
186
 
 
187
#ifdef __OPTIMIZE__
 
188
/* Inline versions of above routines.  */
 
189
 
 
190
#if !_LIBC
 
191
#define __argp_fmtstream_putc argp_fmtstream_putc
 
192
#define __argp_fmtstream_puts argp_fmtstream_puts
 
193
#define __argp_fmtstream_write argp_fmtstream_write
 
194
#define __argp_fmtstream_set_lmargin argp_fmtstream_set_lmargin
 
195
#define __argp_fmtstream_set_rmargin argp_fmtstream_set_rmargin
 
196
#define __argp_fmtstream_set_wmargin argp_fmtstream_set_wmargin
 
197
#define __argp_fmtstream_point argp_fmtstream_point
 
198
#define __argp_fmtstream_update _argp_fmtstream_update
 
199
#define __argp_fmtstream_ensure _argp_fmtstream_ensure
 
200
#endif
 
201
 
 
202
#ifndef ARGP_FS_EI
 
203
# ifdef __GNUC__
 
204
   /* GCC 4.3 and above with -std=c99 or -std=gnu99 implements ISO C99
 
205
      inline semantics, unless -fgnu89-inline is used.  It defines a macro
 
206
      __GNUC_STDC_INLINE__ to indicate this situation or a macro
 
207
      __GNUC_GNU_INLINE__ to indicate the opposite situation.
 
208
 
 
209
      GCC 4.2 with -std=c99 or -std=gnu99 implements the GNU C inline
 
210
      semantics but warns, unless -fgnu89-inline is used:
 
211
        warning: C99 inline functions are not supported; using GNU89
 
212
        warning: to disable this warning use -fgnu89-inline or the gnu_inline function attribute
 
213
      It defines a macro __GNUC_GNU_INLINE__ to indicate this situation.
 
214
 
 
215
      Whereas Apple GCC 4.0.1 build 5479 without -std=c99 or -std=gnu99
 
216
      implements the GNU C inline semantics and defines the macro
 
217
      __GNUC_GNU_INLINE__, but it does not warn and does not support
 
218
      __attribute__ ((__gnu_inline__)).
 
219
 
 
220
      All in all, these are the possible combinations.  For every compiler,
 
221
      we need to choose ARGP_FS_EI so that the corresponding table cell
 
222
      contains an "ok".
 
223
 
 
224
        \    ARGP_FS_EI                      inline   extern    extern
 
225
          \                                           inline    inline
 
226
      CC    \                                                   __attribute__
 
227
                                                                ((gnu_inline))
 
228
 
 
229
      gcc 4.3.0                              error    ok        ok
 
230
      gcc 4.3.0 -std=gnu99 -fgnu89-inline    error    ok        ok
 
231
      gcc 4.3.0 -std=gnu99                   ok       error     ok
 
232
 
 
233
      gcc 4.2.2                              error    ok        ok
 
234
      gcc 4.2.2 -std=gnu99 -fgnu89-inline    error    ok        ok
 
235
      gcc 4.2.2 -std=gnu99                   error    warning   ok
 
236
 
 
237
      gcc 4.1.2                              error    ok        warning
 
238
      gcc 4.1.2 -std=gnu99                   error    ok        warning
 
239
 
 
240
      Apple gcc 4.0.1                        error    ok        warning
 
241
      Apple gcc 4.0.1 -std=gnu99             ok       error     warning
 
242
    */
 
243
#  if defined __GNUC_STDC_INLINE__
 
244
#   define ARGP_FS_EI inline
 
245
#  elif __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2)
 
246
#   define ARGP_FS_EI extern inline __attribute__ ((__gnu_inline__))
 
247
#  else
 
248
#   define ARGP_FS_EI extern inline
 
249
#  endif
 
250
# else
 
251
   /* With other compilers, assume the ISO C99 meaning of 'inline', if
 
252
      the compiler supports 'inline' at all.  */
 
253
#  define ARGP_FS_EI inline
 
254
# endif
 
255
#endif
 
256
 
 
257
ARGP_FS_EI size_t
 
258
__argp_fmtstream_write (argp_fmtstream_t __fs,
 
259
                        const char *__str, size_t __len)
 
260
{
 
261
  if (__fs->p + __len <= __fs->end || __argp_fmtstream_ensure (__fs, __len))
 
262
    {
 
263
      memcpy (__fs->p, __str, __len);
 
264
      __fs->p += __len;
 
265
      return __len;
 
266
    }
 
267
  else
 
268
    return 0;
 
269
}
 
270
 
 
271
ARGP_FS_EI int
 
272
__argp_fmtstream_puts (argp_fmtstream_t __fs, const char *__str)
 
273
{
 
274
  size_t __len = strlen (__str);
 
275
  if (__len)
 
276
    {
 
277
      size_t __wrote = __argp_fmtstream_write (__fs, __str, __len);
 
278
      return __wrote == __len ? 0 : -1;
 
279
    }
 
280
  else
 
281
    return 0;
 
282
}
 
283
 
 
284
ARGP_FS_EI int
 
285
__argp_fmtstream_putc (argp_fmtstream_t __fs, int __ch)
 
286
{
 
287
  if (__fs->p < __fs->end || __argp_fmtstream_ensure (__fs, 1))
 
288
    return *__fs->p++ = __ch;
 
289
  else
 
290
    return EOF;
 
291
}
 
292
 
 
293
/* Set __FS's left margin to __LMARGIN and return the old value.  */
 
294
ARGP_FS_EI size_t
 
295
__argp_fmtstream_set_lmargin (argp_fmtstream_t __fs, size_t __lmargin)
 
296
{
 
297
  size_t __old;
 
298
  if ((size_t) (__fs->p - __fs->buf) > __fs->point_offs)
 
299
    __argp_fmtstream_update (__fs);
 
300
  __old = __fs->lmargin;
 
301
  __fs->lmargin = __lmargin;
 
302
  return __old;
 
303
}
 
304
 
 
305
/* Set __FS's right margin to __RMARGIN and return the old value.  */
 
306
ARGP_FS_EI size_t
 
307
__argp_fmtstream_set_rmargin (argp_fmtstream_t __fs, size_t __rmargin)
 
308
{
 
309
  size_t __old;
 
310
  if ((size_t) (__fs->p - __fs->buf) > __fs->point_offs)
 
311
    __argp_fmtstream_update (__fs);
 
312
  __old = __fs->rmargin;
 
313
  __fs->rmargin = __rmargin;
 
314
  return __old;
 
315
}
 
316
 
 
317
/* Set FS's wrap margin to __WMARGIN and return the old value.  */
 
318
ARGP_FS_EI size_t
 
319
__argp_fmtstream_set_wmargin (argp_fmtstream_t __fs, size_t __wmargin)
 
320
{
 
321
  size_t __old;
 
322
  if ((size_t) (__fs->p - __fs->buf) > __fs->point_offs)
 
323
    __argp_fmtstream_update (__fs);
 
324
  __old = __fs->wmargin;
 
325
  __fs->wmargin = __wmargin;
 
326
  return __old;
 
327
}
 
328
 
 
329
/* Return the column number of the current output point in __FS.  */
 
330
ARGP_FS_EI size_t
 
331
__argp_fmtstream_point (argp_fmtstream_t __fs)
 
332
{
 
333
  if ((size_t) (__fs->p - __fs->buf) > __fs->point_offs)
 
334
    __argp_fmtstream_update (__fs);
 
335
  return __fs->point_col >= 0 ? __fs->point_col : 0;
 
336
}
 
337
 
 
338
#if !_LIBC
 
339
#undef __argp_fmtstream_putc
 
340
#undef __argp_fmtstream_puts
 
341
#undef __argp_fmtstream_write
 
342
#undef __argp_fmtstream_set_lmargin
 
343
#undef __argp_fmtstream_set_rmargin
 
344
#undef __argp_fmtstream_set_wmargin
 
345
#undef __argp_fmtstream_point
 
346
#undef __argp_fmtstream_update
 
347
#undef __argp_fmtstream_ensure
 
348
#endif
 
349
 
 
350
#endif /* __OPTIMIZE__ */
 
351
 
 
352
#endif /* ARGP_FMTSTREAM_USE_LINEWRAP */
 
353
 
 
354
#endif /* argp-fmtstream.h */