From 45a73dcb6d7a100a14d9d9d54f3ab60278a05ca1 Mon Sep 17 00:00:00 2001

From: Vladimir 'phcoder' Serbinenko <phcoder@gmail.com>

Date: Wed, 17 Apr 2013 07:00:37 +0200

Subject: [PATCH 321/482] 	* build-aux/snippet: Add missing gnulib files.

---

 ChangeLog                       |   4 +

 build-aux/snippet/_Noreturn.h   |  10 ++

 build-aux/snippet/arg-nonnull.h |  26 ++++

 build-aux/snippet/c++defs.h     | 271 ++++++++++++++++++++++++++++++++++++++++

 build-aux/snippet/warn-on-use.h | 109 ++++++++++++++++

 5 files changed, 420 insertions(+)

 create mode 100644 build-aux/snippet/_Noreturn.h

 create mode 100644 build-aux/snippet/arg-nonnull.h

 create mode 100644 build-aux/snippet/c++defs.h

 create mode 100644 build-aux/snippet/warn-on-use.h

diff --git a/ChangeLog b/ChangeLog

index b60a71d..073207a 100644

--- a/ChangeLog

+++ b/ChangeLog

@@ -1,3 +1,7 @@

+2013-04-17  Vladimir Serbinenko  <phcoder@gmail.com>

+

+	* build-aux/snippet: Add missing gnulib files.

+

 2013-04-16  Andrey Borzenkov <arvidjaar@gmail.com>

 	* grub-core/disk/efi/efidisk.c: Really limit transfer chunk size.

diff --git a/build-aux/snippet/_Noreturn.h b/build-aux/snippet/_Noreturn.h

new file mode 100644

index 0000000..c44ad89

--- /dev/null

+++ b/build-aux/snippet/_Noreturn.h

@@ -0,0 +1,10 @@

+#if !defined _Noreturn && __STDC_VERSION__ < 201112

+# if (3 <= __GNUC__ || (__GNUC__ == 2 && 8 <= __GNUC_MINOR__) \

+      || 0x5110 <= __SUNPRO_C)

+#  define _Noreturn __attribute__ ((__noreturn__))

+# elif 1200 <= _MSC_VER

+#  define _Noreturn __declspec (noreturn)

+# else

+#  define _Noreturn

+# endif

+#endif

diff --git a/build-aux/snippet/arg-nonnull.h b/build-aux/snippet/arg-nonnull.h

new file mode 100644

index 0000000..8ea2a47

--- /dev/null

+++ b/build-aux/snippet/arg-nonnull.h

@@ -0,0 +1,26 @@

+/* A C macro for declaring that specific arguments must not be NULL.

+   Copyright (C) 2009-2013 Free Software Foundation, Inc.

+

+   This program is free software: you can redistribute it and/or modify it

+   under the terms of the GNU General Public License as published

+   by the Free Software Foundation; either version 3 of the License, or

+   (at your option) any later version.

+

+   This program is distributed in the hope that it will be useful,

+   but WITHOUT ANY WARRANTY; without even the implied warranty of

+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

+   General Public License for more details.

+

+   You should have received a copy of the GNU General Public License

+   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */

+

+/* _GL_ARG_NONNULL((n,...,m)) tells the compiler and static analyzer tools

+   that the values passed as arguments n, ..., m must be non-NULL pointers.

+   n = 1 stands for the first argument, n = 2 for the second argument etc.  */

+#ifndef _GL_ARG_NONNULL

+# if (__GNUC__ == 3 && __GNUC_MINOR__ >= 3) || __GNUC__ > 3

+#  define _GL_ARG_NONNULL(params) __attribute__ ((__nonnull__ params))

+# else

+#  define _GL_ARG_NONNULL(params)

+# endif

+#endif

diff --git a/build-aux/snippet/c++defs.h b/build-aux/snippet/c++defs.h

new file mode 100644

index 0000000..b35b933

--- /dev/null

+++ b/build-aux/snippet/c++defs.h

@@ -0,0 +1,271 @@

+/* C++ compatible function declaration macros.

+   Copyright (C) 2010-2013 Free Software Foundation, Inc.

+

+   This program is free software: you can redistribute it and/or modify it

+   under the terms of the GNU General Public License as published

+   by the Free Software Foundation; either version 3 of the License, or

+   (at your option) any later version.

+

+   This program is distributed in the hope that it will be useful,

+   but WITHOUT ANY WARRANTY; without even the implied warranty of

+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

+   General Public License for more details.

+

+   You should have received a copy of the GNU General Public License

+   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */

+

+#ifndef _GL_CXXDEFS_H

+#define _GL_CXXDEFS_H

+

+/* The three most frequent use cases of these macros are:

+

+   * For providing a substitute for a function that is missing on some

+     platforms, but is declared and works fine on the platforms on which

+     it exists:

+

+       #if @GNULIB_FOO@

+       # if !@HAVE_FOO@

+       _GL_FUNCDECL_SYS (foo, ...);

+       # endif

+       _GL_CXXALIAS_SYS (foo, ...);

+       _GL_CXXALIASWARN (foo);

+       #elif defined GNULIB_POSIXCHECK

+       ...

+       #endif

+

+   * For providing a replacement for a function that exists on all platforms,

+     but is broken/insufficient and needs to be replaced on some platforms:

+

+       #if @GNULIB_FOO@

+       # if @REPLACE_FOO@

+       #  if !(defined __cplusplus && defined GNULIB_NAMESPACE)

+       #   undef foo

+       #   define foo rpl_foo

+       #  endif

+       _GL_FUNCDECL_RPL (foo, ...);

+       _GL_CXXALIAS_RPL (foo, ...);

+       # else

+       _GL_CXXALIAS_SYS (foo, ...);

+       # endif

+       _GL_CXXALIASWARN (foo);

+       #elif defined GNULIB_POSIXCHECK

+       ...

+       #endif

+

+   * For providing a replacement for a function that exists on some platforms

+     but is broken/insufficient and needs to be replaced on some of them and

+     is additionally either missing or undeclared on some other platforms:

+

+       #if @GNULIB_FOO@

+       # if @REPLACE_FOO@

+       #  if !(defined __cplusplus && defined GNULIB_NAMESPACE)

+       #   undef foo

+       #   define foo rpl_foo

+       #  endif

+       _GL_FUNCDECL_RPL (foo, ...);

+       _GL_CXXALIAS_RPL (foo, ...);

+       # else

+       #  if !@HAVE_FOO@   or   if !@HAVE_DECL_FOO@

+       _GL_FUNCDECL_SYS (foo, ...);

+       #  endif

+       _GL_CXXALIAS_SYS (foo, ...);

+       # endif

+       _GL_CXXALIASWARN (foo);

+       #elif defined GNULIB_POSIXCHECK

+       ...

+       #endif

+*/

+

+/* _GL_EXTERN_C declaration;

+   performs the declaration with C linkage.  */

+#if defined __cplusplus

+# define _GL_EXTERN_C extern "C"

+#else

+# define _GL_EXTERN_C extern

+#endif

+

+/* _GL_FUNCDECL_RPL (func, rettype, parameters_and_attributes);

+   declares a replacement function, named rpl_func, with the given prototype,

+   consisting of return type, parameters, and attributes.

+   Example:

+     _GL_FUNCDECL_RPL (open, int, (const char *filename, int flags, ...)

+                                  _GL_ARG_NONNULL ((1)));

+ */

+#define _GL_FUNCDECL_RPL(func,rettype,parameters_and_attributes) \

+  _GL_FUNCDECL_RPL_1 (rpl_##func, rettype, parameters_and_attributes)

+#define _GL_FUNCDECL_RPL_1(rpl_func,rettype,parameters_and_attributes) \

+  _GL_EXTERN_C rettype rpl_func parameters_and_attributes

+

+/* _GL_FUNCDECL_SYS (func, rettype, parameters_and_attributes);

+   declares the system function, named func, with the given prototype,

+   consisting of return type, parameters, and attributes.

+   Example:

+     _GL_FUNCDECL_SYS (open, int, (const char *filename, int flags, ...)

+                                  _GL_ARG_NONNULL ((1)));

+ */

+#define _GL_FUNCDECL_SYS(func,rettype,parameters_and_attributes) \

+  _GL_EXTERN_C rettype func parameters_and_attributes

+

+/* _GL_CXXALIAS_RPL (func, rettype, parameters);

+   declares a C++ alias called GNULIB_NAMESPACE::func

+   that redirects to rpl_func, if GNULIB_NAMESPACE is defined.

+   Example:

+     _GL_CXXALIAS_RPL (open, int, (const char *filename, int flags, ...));

+ */

+#define _GL_CXXALIAS_RPL(func,rettype,parameters) \

+  _GL_CXXALIAS_RPL_1 (func, rpl_##func, rettype, parameters)

+#if defined __cplusplus && defined GNULIB_NAMESPACE

+# define _GL_CXXALIAS_RPL_1(func,rpl_func,rettype,parameters) \

+    namespace GNULIB_NAMESPACE                                \

+    {                                                         \

+      rettype (*const func) parameters = ::rpl_func;          \

+    }                                                         \

+    _GL_EXTERN_C int _gl_cxxalias_dummy

+#else

+# define _GL_CXXALIAS_RPL_1(func,rpl_func,rettype,parameters) \

+    _GL_EXTERN_C int _gl_cxxalias_dummy

+#endif

+

+/* _GL_CXXALIAS_RPL_CAST_1 (func, rpl_func, rettype, parameters);

+   is like  _GL_CXXALIAS_RPL_1 (func, rpl_func, rettype, parameters);

+   except that the C function rpl_func may have a slightly different

+   declaration.  A cast is used to silence the "invalid conversion" error

+   that would otherwise occur.  */

+#if defined __cplusplus && defined GNULIB_NAMESPACE

+# define _GL_CXXALIAS_RPL_CAST_1(func,rpl_func,rettype,parameters) \

+    namespace GNULIB_NAMESPACE                                     \

+    {                                                              \

+      rettype (*const func) parameters =                           \

+        reinterpret_cast<rettype(*)parameters>(::rpl_func);        \

+    }                                                              \

+    _GL_EXTERN_C int _gl_cxxalias_dummy

+#else

+# define _GL_CXXALIAS_RPL_CAST_1(func,rpl_func,rettype,parameters) \

+    _GL_EXTERN_C int _gl_cxxalias_dummy

+#endif

+

+/* _GL_CXXALIAS_SYS (func, rettype, parameters);

+   declares a C++ alias called GNULIB_NAMESPACE::func

+   that redirects to the system provided function func, if GNULIB_NAMESPACE

+   is defined.

+   Example:

+     _GL_CXXALIAS_SYS (open, int, (const char *filename, int flags, ...));

+ */

+#if defined __cplusplus && defined GNULIB_NAMESPACE

+  /* If we were to write

+       rettype (*const func) parameters = ::func;

+     like above in _GL_CXXALIAS_RPL_1, the compiler could optimize calls

+     better (remove an indirection through a 'static' pointer variable),

+     but then the _GL_CXXALIASWARN macro below would cause a warning not only

+     for uses of ::func but also for uses of GNULIB_NAMESPACE::func.  */

+# define _GL_CXXALIAS_SYS(func,rettype,parameters) \

+    namespace GNULIB_NAMESPACE                     \

+    {                                              \

+      static rettype (*func) parameters = ::func;  \

+    }                                              \

+    _GL_EXTERN_C int _gl_cxxalias_dummy

+#else

+# define _GL_CXXALIAS_SYS(func,rettype,parameters) \

+    _GL_EXTERN_C int _gl_cxxalias_dummy

+#endif

+

+/* _GL_CXXALIAS_SYS_CAST (func, rettype, parameters);

+   is like  _GL_CXXALIAS_SYS (func, rettype, parameters);

+   except that the C function func may have a slightly different declaration.

+   A cast is used to silence the "invalid conversion" error that would

+   otherwise occur.  */

+#if defined __cplusplus && defined GNULIB_NAMESPACE

+# define _GL_CXXALIAS_SYS_CAST(func,rettype,parameters) \

+    namespace GNULIB_NAMESPACE                          \

+    {                                                   \

+      static rettype (*func) parameters =               \

+        reinterpret_cast<rettype(*)parameters>(::func); \

+    }                                                   \

+    _GL_EXTERN_C int _gl_cxxalias_dummy

+#else

+# define _GL_CXXALIAS_SYS_CAST(func,rettype,parameters) \

+    _GL_EXTERN_C int _gl_cxxalias_dummy

+#endif

+

+/* _GL_CXXALIAS_SYS_CAST2 (func, rettype, parameters, rettype2, parameters2);

+   is like  _GL_CXXALIAS_SYS (func, rettype, parameters);

+   except that the C function is picked among a set of overloaded functions,

+   namely the one with rettype2 and parameters2.  Two consecutive casts

+   are used to silence the "cannot find a match" and "invalid conversion"

+   errors that would otherwise occur.  */

+#if defined __cplusplus && defined GNULIB_NAMESPACE

+  /* The outer cast must be a reinterpret_cast.

+     The inner cast: When the function is defined as a set of overloaded

+     functions, it works as a static_cast<>, choosing the designated variant.

+     When the function is defined as a single variant, it works as a

+     reinterpret_cast<>. The parenthesized cast syntax works both ways.  */

+# define _GL_CXXALIAS_SYS_CAST2(func,rettype,parameters,rettype2,parameters2) \

+    namespace GNULIB_NAMESPACE                                                \

+    {                                                                         \

+      static rettype (*func) parameters =                                     \

+        reinterpret_cast<rettype(*)parameters>(                               \

+          (rettype2(*)parameters2)(::func));                                  \

+    }                                                                         \

+    _GL_EXTERN_C int _gl_cxxalias_dummy

+#else

+# define _GL_CXXALIAS_SYS_CAST2(func,rettype,parameters,rettype2,parameters2) \

+    _GL_EXTERN_C int _gl_cxxalias_dummy

+#endif

+

+/* _GL_CXXALIASWARN (func);

+   causes a warning to be emitted when ::func is used but not when

+   GNULIB_NAMESPACE::func is used.  func must be defined without overloaded

+   variants.  */

+#if defined __cplusplus && defined GNULIB_NAMESPACE

+# define _GL_CXXALIASWARN(func) \

+   _GL_CXXALIASWARN_1 (func, GNULIB_NAMESPACE)

+# define _GL_CXXALIASWARN_1(func,namespace) \

+   _GL_CXXALIASWARN_2 (func, namespace)

+/* To work around GCC bug <http://gcc.gnu.org/bugzilla/show_bug.cgi?id=43881>,

+   we enable the warning only when not optimizing.  */

+# if !__OPTIMIZE__

+#  define _GL_CXXALIASWARN_2(func,namespace) \

+    _GL_WARN_ON_USE (func, \

+                     "The symbol ::" #func " refers to the system function. " \

+                     "Use " #namespace "::" #func " instead.")

+# elif __GNUC__ >= 3 && GNULIB_STRICT_CHECKING

+#  define _GL_CXXALIASWARN_2(func,namespace) \

+     extern __typeof__ (func) func

+# else

+#  define _GL_CXXALIASWARN_2(func,namespace) \

+     _GL_EXTERN_C int _gl_cxxalias_dummy

+# endif

+#else

+# define _GL_CXXALIASWARN(func) \

+    _GL_EXTERN_C int _gl_cxxalias_dummy

+#endif

+

+/* _GL_CXXALIASWARN1 (func, rettype, parameters_and_attributes);

+   causes a warning to be emitted when the given overloaded variant of ::func

+   is used but not when GNULIB_NAMESPACE::func is used.  */

+#if defined __cplusplus && defined GNULIB_NAMESPACE

+# define _GL_CXXALIASWARN1(func,rettype,parameters_and_attributes) \

+   _GL_CXXALIASWARN1_1 (func, rettype, parameters_and_attributes, \

+                        GNULIB_NAMESPACE)

+# define _GL_CXXALIASWARN1_1(func,rettype,parameters_and_attributes,namespace) \

+   _GL_CXXALIASWARN1_2 (func, rettype, parameters_and_attributes, namespace)

+/* To work around GCC bug <http://gcc.gnu.org/bugzilla/show_bug.cgi?id=43881>,

+   we enable the warning only when not optimizing.  */

+# if !__OPTIMIZE__

+#  define _GL_CXXALIASWARN1_2(func,rettype,parameters_and_attributes,namespace) \

+    _GL_WARN_ON_USE_CXX (func, rettype, parameters_and_attributes, \

+                         "The symbol ::" #func " refers to the system function. " \

+                         "Use " #namespace "::" #func " instead.")

+# elif __GNUC__ >= 3 && GNULIB_STRICT_CHECKING

+#  define _GL_CXXALIASWARN1_2(func,rettype,parameters_and_attributes,namespace) \

+     extern __typeof__ (func) func

+# else

+#  define _GL_CXXALIASWARN1_2(func,rettype,parameters_and_attributes,namespace) \

+     _GL_EXTERN_C int _gl_cxxalias_dummy

+# endif

+#else

+# define _GL_CXXALIASWARN1(func,rettype,parameters_and_attributes) \

+    _GL_EXTERN_C int _gl_cxxalias_dummy

+#endif

+

+#endif /* _GL_CXXDEFS_H */

diff --git a/build-aux/snippet/warn-on-use.h b/build-aux/snippet/warn-on-use.h

new file mode 100644

index 0000000..1736a1b

--- /dev/null

+++ b/build-aux/snippet/warn-on-use.h

@@ -0,0 +1,109 @@

+/* A C macro for emitting warnings if a function is used.

+   Copyright (C) 2010-2013 Free Software Foundation, Inc.

+

+   This program is free software: you can redistribute it and/or modify it

+   under the terms of the GNU General Public License as published

+   by the Free Software Foundation; either version 3 of the License, or

+   (at your option) any later version.

+

+   This program is distributed in the hope that it will be useful,

+   but WITHOUT ANY WARRANTY; without even the implied warranty of

+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

+   General Public License for more details.

+

+   You should have received a copy of the GNU General Public License

+   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */

+

+/* _GL_WARN_ON_USE (function, "literal string") issues a declaration

+   for FUNCTION which will then trigger a compiler warning containing

+   the text of "literal string" anywhere that function is called, if

+   supported by the compiler.  If the compiler does not support this

+   feature, the macro expands to an unused extern declaration.

+

+   This macro is useful for marking a function as a potential

+   portability trap, with the intent that "literal string" include

+   instructions on the replacement function that should be used

+   instead.  However, one of the reasons that a function is a

+   portability trap is if it has the wrong signature.  Declaring

+   FUNCTION with a different signature in C is a compilation error, so

+   this macro must use the same type as any existing declaration so

+   that programs that avoid the problematic FUNCTION do not fail to

+   compile merely because they included a header that poisoned the

+   function.  But this implies that _GL_WARN_ON_USE is only safe to

+   use if FUNCTION is known to already have a declaration.  Use of

+   this macro implies that there must not be any other macro hiding

+   the declaration of FUNCTION; but undefining FUNCTION first is part

+   of the poisoning process anyway (although for symbols that are

+   provided only via a macro, the result is a compilation error rather

+   than a warning containing "literal string").  Also note that in

+   C++, it is only safe to use if FUNCTION has no overloads.

+

+   For an example, it is possible to poison 'getline' by:

+   - adding a call to gl_WARN_ON_USE_PREPARE([[#include <stdio.h>]],

+     [getline]) in configure.ac, which potentially defines

+     HAVE_RAW_DECL_GETLINE

+   - adding this code to a header that wraps the system <stdio.h>:

+     #undef getline

+     #if HAVE_RAW_DECL_GETLINE

+     _GL_WARN_ON_USE (getline, "getline is required by POSIX 2008, but"

+       "not universally present; use the gnulib module getline");

+     #endif

+

+   It is not possible to directly poison global variables.  But it is

+   possible to write a wrapper accessor function, and poison that

+   (less common usage, like &environ, will cause a compilation error

+   rather than issue the nice warning, but the end result of informing

+   the developer about their portability problem is still achieved):

+   #if HAVE_RAW_DECL_ENVIRON

+   static char ***rpl_environ (void) { return &environ; }

+   _GL_WARN_ON_USE (rpl_environ, "environ is not always properly declared");

+   # undef environ

+   # define environ (*rpl_environ ())

+   #endif

+   */

+#ifndef _GL_WARN_ON_USE

+

+# if 4 < __GNUC__ || (__GNUC__ == 4 && 3 <= __GNUC_MINOR__)

+/* A compiler attribute is available in gcc versions 4.3.0 and later.  */

+#  define _GL_WARN_ON_USE(function, message) \

+extern __typeof__ (function) function __attribute__ ((__warning__ (message)))

+# elif __GNUC__ >= 3 && GNULIB_STRICT_CHECKING

+/* Verify the existence of the function.  */

+#  define _GL_WARN_ON_USE(function, message) \

+extern __typeof__ (function) function

+# else /* Unsupported.  */

+#  define _GL_WARN_ON_USE(function, message) \

+_GL_WARN_EXTERN_C int _gl_warn_on_use

+# endif

+#endif

+

+/* _GL_WARN_ON_USE_CXX (function, rettype, parameters_and_attributes, "string")

+   is like _GL_WARN_ON_USE (function, "string"), except that the function is

+   declared with the given prototype, consisting of return type, parameters,

+   and attributes.

+   This variant is useful for overloaded functions in C++. _GL_WARN_ON_USE does

+   not work in this case.  */

+#ifndef _GL_WARN_ON_USE_CXX

+# if 4 < __GNUC__ || (__GNUC__ == 4 && 3 <= __GNUC_MINOR__)

+#  define _GL_WARN_ON_USE_CXX(function,rettype,parameters_and_attributes,msg) \

+extern rettype function parameters_and_attributes \

+     __attribute__ ((__warning__ (msg)))

+# elif __GNUC__ >= 3 && GNULIB_STRICT_CHECKING

+/* Verify the existence of the function.  */

+#  define _GL_WARN_ON_USE_CXX(function,rettype,parameters_and_attributes,msg) \

+extern rettype function parameters_and_attributes

+# else /* Unsupported.  */

+#  define _GL_WARN_ON_USE_CXX(function,rettype,parameters_and_attributes,msg) \

+_GL_WARN_EXTERN_C int _gl_warn_on_use

+# endif

+#endif

+

+/* _GL_WARN_EXTERN_C declaration;

+   performs the declaration with C linkage.  */

+#ifndef _GL_WARN_EXTERN_C

+# if defined __cplusplus

+#  define _GL_WARN_EXTERN_C extern "C"

+# else

+#  define _GL_WARN_EXTERN_C extern

+# endif

+#endif

-- 

1.8.2.1