← 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, Robert Millan, Updated translations
  • Date: 2010-11-22 12:24:56 UTC
  • mfrom: (1.26.4 upstream) (17.3.36 sid)
  • mto: (17.3.43 sid)
  • mto: This revision was merged to the branch mainline in revision 89.
  • Revision ID: james.westby@ubuntu.com-20101122122456-y82z3sfb7k4zfdcc
Tags: 1.99~20101122-1
http://bugs.debian.org/550658
http://bugs.debian.org/550702
http://bugs.debian.org/591416
http://bugs.debian.org/593347
http://bugs.debian.org/551627
http://bugs.debian.org/589325
http://bugs.debian.org/543924
http://bugs.debian.org/603354
http://bugs.debian.org/604003
http://bugs.debian.org/604102
[ Colin Watson ]
* New Bazaar snapshot.  Too many changes to list in full, but some of the
  more user-visible ones are as follows:
  - GRUB script:
    + Function parameters, "break", "continue", "shift", "setparams",
      "return", and "!".
    + "export" command supports multiple variable names.
    + Multi-line quoted strings support.
    + Wildcard expansion.
  - sendkey support.
  - USB hotunplugging and USB serial support.
  - Rename CD-ROM to cd on BIOS.
  - Add new --boot-directory option to grub-install, grub-reboot, and
    grub-set-default; the old --root-directory option is still accepted
    but was often confusing.
  - Basic btrfs detection/UUID support (but no file reading yet).
  - bash-completion for utilities.
  - If a device is listed in device.map, always assume that it is
    BIOS-visible rather than using extra layers such as LVM or RAID.
  - Add grub-mknetdir script (closes: #550658).
  - Remove deprecated "root" command.
  - Handle RAID devices containing virtio components.
  - GRUB Legacy configuration file support (via grub-menulst2cfg).
  - Keyboard layout support (via grub-mklayout and grub-kbdcomp).
  - Check generated grub.cfg for syntax errors before saving.
  - Pause execution for at most ten seconds if any errors are displayed,
    so that the user has a chance to see them.
  - Support submenus.
  - Write embedding zone using Reed-Solomon, so that it's robust against
    being partially overwritten (closes: #550702, #591416, #593347).
  - GRUB_DISABLE_LINUX_RECOVERY and GRUB_DISABLE_NETBSD_RECOVERY merged
    into a single GRUB_DISABLE_RECOVERY variable.
  - Fix loader memory allocation failure (closes: #551627).
  - Don't call savedefault on recovery entries (closes: #589325).
  - Support triple-indirect blocks on ext2 (closes: #543924).
  - Recognise DDF1 fake RAID (closes: #603354).

[ Robert Millan ]
* Use dpkg architecture wildcards.

[ Updated translations ]
* Slovenian (Vanja Cvelbar).  Closes: #604003
* Dzongkha (dawa pemo via Tenzin Dendup).  Closes: #604102

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 */