summaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/login/login.cpp6
-rw-r--r--src/map/magic-interpreter-lexer.lpp1
-rw-r--r--src/warnings.hpp359
3 files changed, 183 insertions, 183 deletions
diff --git a/src/login/login.cpp b/src/login/login.cpp
index bd466e1..6ba09d2 100644
--- a/src/login/login.cpp
+++ b/src/login/login.cpp
@@ -534,7 +534,7 @@ bool extract(XString line, AuthData *ad)
static
int mmo_auth_init(void)
{
- int GM_count = 0;
+ int gm_count = 0;
io::ReadFile in(account_filename);
if (!in.is_open())
@@ -570,14 +570,14 @@ int mmo_auth_init(void)
auth_data.push_back(ad);
if (isGM(ad.account_id) > 0)
- GM_count++;
+ gm_count++;
if (ad.account_id >= account_id_count)
account_id_count = ad.account_id + 1;
}
FString str = STRPRINTF("%s has %zu accounts (%d GMs)\n",
- account_filename, auth_data.size(), GM_count);
+ account_filename, auth_data.size(), gm_count);
PRINTF("%s: %s\n", __PRETTY_FUNCTION__, str);
LOGIN_LOG("%s\n", line);
diff --git a/src/map/magic-interpreter-lexer.lpp b/src/map/magic-interpreter-lexer.lpp
index cef1121..83cb36f 100644
--- a/src/map/magic-interpreter-lexer.lpp
+++ b/src/map/magic-interpreter-lexer.lpp
@@ -12,7 +12,6 @@
#define FIXLOC magic_frontend_lloc.first_line = magic_frontend_lineno
#define HEADING(dir) { magic_frontend_lval.i = dir; FIXLOC; return DIR; }
-
%}
%option yylineno
diff --git a/src/warnings.hpp b/src/warnings.hpp
index 9932ce3..61482bf 100644
--- a/src/warnings.hpp
+++ b/src/warnings.hpp
@@ -56,12 +56,13 @@
// BEGIN Macros to make my life easier
// stringification requirement - #sw within #ar
+// this is a lie ^
#define P(ar) _Pragma(#ar)
// Use "GCC diagnostic" for warnings applicable to all versions.
-#define I(sw) P(GCC diagnostic ignored #sw)
-#define W(sw) P(GCC diagnostic warning #sw)
-#define E(sw) P(GCC diagnostic error #sw)
+#define I(sw) P(GCC diagnostic ignored sw)
+#define W(sw) P(GCC diagnostic warning sw)
+#define E(sw) P(GCC diagnostic error sw)
// configurable thing (also change in clang below!)
#define X(sw) I(sw)
@@ -69,26 +70,26 @@
#ifdef __clang__
// Use "clang diagnostic" for warnings specific to clang
-# define IC(sw) P(clang diagnostic ignored #sw)
-# define WC(sw) P(clang diagnostic warning #sw)
-# define EC(sw) P(clang diagnostic error #sw)
+# define IC(sw) P(clang diagnostic ignored sw)
+# define WC(sw) P(clang diagnostic warning sw)
+# define EC(sw) P(clang diagnostic error sw)
# define XC(sw) IC(sw) // this is below
// warning specific to gcc
-# define IG(sw) static_assert('I', #sw "skipped for clang");
-# define WG(sw) static_assert('W', #sw "skipped for clang");
-# define EG(sw) static_assert('E', #sw "skipped for clang");
-# define XG(sw) static_assert('X', #sw "skipped for clang");
+# define IG(sw) static_assert('I', sw "skipped for clang");
+# define WG(sw) static_assert('W', sw "skipped for clang");
+# define EG(sw) static_assert('E', sw "skipped for clang");
+# define XG(sw) static_assert('X', sw "skipped for clang");
-# define IG47(sw) static_assert('I', #sw "only for gcc 4.7+");
-# define WG47(sw) static_assert('W', #sw "only for gcc 4.7+");
-# define EG47(sw) static_assert('E', #sw "only for gcc 4.7+");
-# define XG47(sw) static_assert('X', #sw "only for gcc 4.7+");
+# define IG47(sw) static_assert('I', sw "only for gcc 4.7+");
+# define WG47(sw) static_assert('W', sw "only for gcc 4.7+");
+# define EG47(sw) static_assert('E', sw "only for gcc 4.7+");
+# define XG47(sw) static_assert('X', sw "only for gcc 4.7+");
-# define IG48(sw) static_assert('I', #sw "only for gcc 4.8+");
-# define WG48(sw) static_assert('W', #sw "only for gcc 4.8+");
-# define EG48(sw) static_assert('E', #sw "only for gcc 4.8+");
-# define XG48(sw) static_assert('X', #sw "only for gcc 4.8+");
+# define IG48(sw) static_assert('I', sw "only for gcc 4.8+");
+# define WG48(sw) static_assert('W', sw "only for gcc 4.8+");
+# define EG48(sw) static_assert('E', sw "only for gcc 4.8+");
+# define XG48(sw) static_assert('X', sw "only for gcc 4.8+");
# define I47(sw) I(sw)
# define W47(sw) W(sw)
@@ -103,10 +104,10 @@
#else
// warnings specific to clang
-# define IC(sw) static_assert('I', #sw "skipped for gcc");
-# define WC(sw) static_assert('W', #sw "skipped for gcc");
-# define EC(sw) static_assert('E', #sw "skipped for gcc");
-# define XC(sw) static_assert('X', #sw "skipped for gcc");
+# define IC(sw) static_assert('I', sw "skipped for gcc");
+# define WC(sw) static_assert('W', sw "skipped for gcc");
+# define EC(sw) static_assert('E', sw "skipped for gcc");
+# define XC(sw) static_assert('X', sw "skipped for gcc");
// warnings specific to gcc
# define IG(sw) I(sw)
@@ -128,15 +129,15 @@
# define E47(sw) E(sw)
# define X47(sw) X(sw)
# else
-# define IG47(sw) static_assert('I', #sw "only for gcc 4.7+");
-# define WG47(sw) static_assert('W', #sw "only for gcc 4.7+");
-# define EG47(sw) static_assert('E', #sw "only for gcc 4.7+");
-# define XG47(sw) static_assert('X', #sw "only for gcc 4.7+");
-
-# define I47(sw) static_assert('I', #sw "only for gcc 4.7+ or clang");
-# define W47(sw) static_assert('W', #sw "only for gcc 4.7+ or clang");
-# define E47(sw) static_assert('E', #sw "only for gcc 4.7+ or clang");
-# define X47(sw) static_assert('X', #sw "only for gcc 4.7+ or clang");
+# define IG47(sw) static_assert('I', sw "only for gcc 4.7+");
+# define WG47(sw) static_assert('W', sw "only for gcc 4.7+");
+# define EG47(sw) static_assert('E', sw "only for gcc 4.7+");
+# define XG47(sw) static_assert('X', sw "only for gcc 4.7+");
+
+# define I47(sw) static_assert('I', sw "only for gcc 4.7+ or clang");
+# define W47(sw) static_assert('W', sw "only for gcc 4.7+ or clang");
+# define E47(sw) static_assert('E', sw "only for gcc 4.7+ or clang");
+# define X47(sw) static_assert('X', sw "only for gcc 4.7+ or clang");
# endif // __GNUC_MINOR__
# if __GNUC_MINOR__ >= 8
# define IG48(sw) IG(sw)
@@ -149,15 +150,15 @@
# define E48(sw) EG(sw)
# define X48(sw) XG(sw)
# else
-# define IG48(sw) static_assert('I', #sw "only for gcc 4.8+");
-# define WG48(sw) static_assert('W', #sw "only for gcc 4.8+");
-# define EG48(sw) static_assert('E', #sw "only for gcc 4.8+");
-# define XG48(sw) static_assert('X', #sw "only for gcc 4.8+");
-
-# define I48(sw) static_assert('I', #sw "only for gcc 4.8+ or clang");
-# define W48(sw) static_assert('W', #sw "only for gcc 4.8+ or clang");
-# define E48(sw) static_assert('E', #sw "only for gcc 4.8+ or clang");
-# define X48(sw) static_assert('X', #sw "only for gcc 4.8+ or clang");
+# define IG48(sw) static_assert('I', sw "only for gcc 4.8+");
+# define WG48(sw) static_assert('W', sw "only for gcc 4.8+");
+# define EG48(sw) static_assert('E', sw "only for gcc 4.8+");
+# define XG48(sw) static_assert('X', sw "only for gcc 4.8+");
+
+# define I48(sw) static_assert('I', sw "only for gcc 4.8+ or clang");
+# define W48(sw) static_assert('W', sw "only for gcc 4.8+ or clang");
+# define E48(sw) static_assert('E', sw "only for gcc 4.8+ or clang");
+# define X48(sw) static_assert('X', sw "only for gcc 4.8+ or clang");
# endif // __GNUC_MINOR__
# endif // __GNUC__
#endif // __clang__
@@ -168,56 +169,56 @@
/// Warn about things that will change when compiling
/// with an ABI-compliant compiler
// see note about -fabi-version=6 in the makefile
-E(-Wabi)
+E("-Wabi")
/// Warn if a subobject has an abi_tag attribute that
/// the complete object type does not have
-WG48(-Wabi-tag)
+WG48("-Wabi-tag")
/// Warn about suspicious uses of memory addresses
-E(-Waddress)
+E("-Waddress")
/// Warn about returning structures, unions or arrays
-I(-Waggregate-return)
+I("-Waggregate-return")
/// Warn if an array is accessed out of bounds
-E(-Warray-bounds)
+E("-Warray-bounds")
/// Warn about inappropriate attribute usage
-E(-Wattributes)
+E("-Wattributes")
/// Warn when a built-in preprocessor macro is
// undefined or redefined
-E(-Wbuiltin-macro-redefined)
+E("-Wbuiltin-macro-redefined")
/// Warn about C++ constructs whose meaning differs
/// between ISO C++ 1998 and ISO C++ 2011
// This has gone funky lately. It probably doesn't do anything useful anyway.
-//E(-Wc++0x-compat)
-//W(-Wc++11-compat)
-I(-Wc++0x-compat)
+//E("-Wc++0x-compat")
+//W("-Wc++11-compat")
+I("-Wc++0x-compat")
/// Warn about pointer casts which increase alignment
-X(-Wcast-align)
+X("-Wcast-align")
/// Warn about casts which discard qualifiers
-E(-Wcast-qual)
+E("-Wcast-qual")
/// Warn about subscripts whose type is "char"
-E(-Wchar-subscripts)
+E("-Wchar-subscripts")
/// Warn about variables that might be changed by
/// "longjmp" or "vfork"
-EG(-Wclobbered)
+EG("-Wclobbered")
/// Warn about possibly nested block comments, and
/// C++ comments spanning more than one physical line
-E(-Wcomment)
+E("-Wcomment")
// A fixable difference between c++11 and c++14
#ifdef __clang__
# if __has_warning("-Wconstexpr-not-const")
-EC(-Wconstexpr-not-const)
+EC("-Wconstexpr-not-const")
# else
static_assert('E', "-Wconstexpr-not-const not in this clang version");
# endif
@@ -227,434 +228,434 @@ static_assert('E', "-Wconstexpr-not-const not in GCC");
/// Warn for implicit type conversions that may
/// change a value
-X(-Wconversion)
+X("-Wconversion")
/// Warn for converting NULL from/to a non-pointer
/// type
-E(-Wconversion-null)
+E("-Wconversion-null")
/// Warn in case profiles in -fprofile-use do not
/// match
-WG(-Wcoverage-mismatch)
+WG("-Wcoverage-mismatch")
///
-XC(-Wcovered-switch-default)
+XC("-Wcovered-switch-default")
/// Warn when a #warning directive is encountered
-WG(-Wcpp)
+WG("-Wcpp")
/// Warn when all constructors and destructors are
/// private
-E(-Wctor-dtor-privacy)
+E("-Wctor-dtor-privacy")
/// Warn about deleting polymorphic objects with non-
/// virtual destructors
-E47(-Wdelete-non-virtual-dtor)
+E47("-Wdelete-non-virtual-dtor")
/// Warn if a deprecated compiler feature, class,
/// method, or field is used
-W(-Wdeprecated)
+W("-Wdeprecated")
-/// Warn about uses of __attribute__((deprecated))
+/// Warn about uses of __attribute__((deprecated)")
/// declarations
-W(-Wdeprecated-declarations)
+W("-Wdeprecated-declarations")
#ifdef QUIET
-I(-Wdeprecated-declarations)
+I("-Wdeprecated-declarations")
#endif
/// Warn when an optimization pass is disabled
-W(-Wdisabled-optimization)
+W("-Wdisabled-optimization")
/// Warn about compile-time integer division by zero
-E(-Wdiv-by-zero)
+E("-Wdiv-by-zero")
///
-WC(-Wdocumentation)
+WC("-Wdocumentation")
/// Warn about implicit conversions from "float" to
/// "double"
-IG(-Wdouble-promotion)
+IG("-Wdouble-promotion")
/// Warn about violations of Effective C++ style rules
-I(-Weffc++)
+I("-Weffc++")
/// Warn about an empty body in an if or else
/// statement
-E(-Wempty-body)
+E("-Wempty-body")
/// Warn about stray tokens after #elif and #endif
-E(-Wendif-labels)
+E("-Wendif-labels")
/// Warn about comparison of different enum types
-E(-Wenum-compare)
+E("-Wenum-compare")
///
-EC(-Wextra-semi)
+EC("-Wextra-semi")
/// Warn if testing floating point numbers for
/// equality
-E(-Wfloat-equal)
+E("-Wfloat-equal")
/// Warn about printf/scanf/strftime/strfmon format
/// string anomalies
// see below
-EG(-Wformat)
+EG("-Wformat")
// but gcc 4.8 warns on %ms, since we enabled -Wpedantic.
-//WG48(-Wformat)
+//WG48("-Wformat")
/// Warn about format strings that contain NUL bytes
-EG(-Wformat-contains-nul)
+EG("-Wformat-contains-nul")
/// Warn if passing too many arguments to a function
/// for its format string
-E(-Wformat-extra-args)
+E("-Wformat-extra-args")
/// Warn about format strings that are not literals
-EG(-Wformat-nonliteral)
+EG("-Wformat-nonliteral")
// Available in clang, but not smart enough to handle constexpr.
-IC(-Wformat-nonliteral)
+IC("-Wformat-nonliteral")
/// Warn about possible security problems with format
/// functions
-EG(-Wformat-security)
+EG("-Wformat-security")
// Same.
-IC(-Wformat-security)
+IC("-Wformat-security")
/// Warn about strftime formats yielding 2-digit years
-E(-Wformat-y2k)
+E("-Wformat-y2k")
/// Warn about zero-length formats
-I(-Wformat-zero-length)
+I("-Wformat-zero-length")
/// Warn when attempting to free a non-heap object
-EG47(-Wfree-nonheap-object)
+EG47("-Wfree-nonheap-object")
// -Wgnu is a clang alias for -Wpedantic
/// Warn whenever type qualifiers are ignored.
-E(-Wignored-qualifiers)
+E("-Wignored-qualifiers")
///
-EC(-Wimplicit-fallthrough)
+EC("-Wimplicit-fallthrough")
/// Warn about C++11 inheriting constructors when the
/// base has a variadic constructor
-WG48(-Winherited-variadic-ctor)
+WG48("-Winherited-variadic-ctor")
/// Warn about variables which are initialized to
/// themselves
-E(-Winit-self)
+E("-Winit-self")
/// Warn when an inlined function cannot be inlined
-X(-Winline)
+X("-Winline")
/// Warn when there is a cast to a pointer from an
/// integer of a different size
-E(-Wint-to-pointer-cast)
+E("-Wint-to-pointer-cast")
/// Warn when an atomic memory model parameter is
/// known to be outside the valid range.
-WG47(-Winvalid-memory-model)
+WG47("-Winvalid-memory-model")
/// Warn about invalid uses of the "offsetof" macro
-E(-Winvalid-offsetof)
+E("-Winvalid-offsetof")
/// Warn about PCH files that are found but not used
-E(-Winvalid-pch)
+E("-Winvalid-pch")
/// Warn when a string or character literal is
/// followed by a ud-suffix which does not begin with
/// an underscore.
-WG48(-Wliteral-suffix)
+WG48("-Wliteral-suffix")
/// Warn when a logical operator is suspiciously
/// always evaluating to true or false
-WG(-Wlogical-op)
+WG("-Wlogical-op")
/// Do not warn about using "long long" when -pedantic
-I(-Wlong-long)
+I("-Wlong-long")
/// Warn about suspicious declarations of "main"
-E(-Wmain)
+E("-Wmain")
/// Warn about maybe uninitialized automatic variables
-EG47(-Wmaybe-uninitialized)
+EG47("-Wmaybe-uninitialized")
/// Warn about possibly missing braces around
/// initializers
// beware of things like std::array!
-E(-Wmissing-braces)
+E("-Wmissing-braces")
/// Warn about global functions without previous
/// declarations
// This doesn't work for clang, it wants -Wmissing-prototypes instead.
-E(-Wmissing-declarations)
+E("-Wmissing-declarations")
/// Warn about missing fields in struct initializers
// Actually supported by GCC, but gives warnings when I don't want, e.g.:
// Foo foo = {};
-EC(-Wmissing-field-initializers)
-IG(-Wmissing-field-initializers)
+EC("-Wmissing-field-initializers")
+IG("-Wmissing-field-initializers")
/// Warn about functions which might be candidates
/// for format attributes
-E(-Wmissing-format-attribute)
+E("-Wmissing-format-attribute")
/// Warn about user-specified include directories
/// that do not exist
-E(-Wmissing-include-dirs)
+E("-Wmissing-include-dirs")
/// Warn about functions which might be candidates
-/// for __attribute__((noreturn))
-W(-Wmissing-noreturn)
+/// for __attribute__((noreturn)")
+W("-Wmissing-noreturn")
// clang uses this instead of -Wmissing-declarations
-EC(-Wmissing-prototypes)
+EC("-Wmissing-prototypes")
///
// like -Wmissing-declarations but for variables instead of functions
#ifndef GTEST_HAS_PTHREAD // this is a hack
-EC(-Wmissing-variable-declarations)
+EC("-Wmissing-variable-declarations")
#endif
/// Warn about constructs not instrumented by
/// -fmudflap
-EG(-Wmudflap)
+EG("-Wmudflap")
/// Warn about use of multi-character character
/// constants
-E(-Wmultichar)
+E("-Wmultichar")
/// Warn about narrowing conversions within { } that
/// are ill-formed in C++11
-EG47(-Wnarrowing)
+EG47("-Wnarrowing")
/// Warn when a noexcept expression evaluates to
/// false even though the expression can't actually
/// throw
-WG(-Wnoexcept)
+WG("-Wnoexcept")
/// Warn when non-templatized friend functions are
/// declared within a template
-EG(-Wnon-template-friend)
+EG("-Wnon-template-friend")
/// Warn about non-virtual destructors
-E(-Wnon-virtual-dtor)
+E("-Wnon-virtual-dtor")
/// Warn about NULL being passed to argument slots
/// marked as requiring non-NULL
-E(-Wnonnull)
+E("-Wnonnull")
///
-XC(-Wnull-conversion)
+XC("-Wnull-conversion")
/// Warn if a C-style cast is used in a program
-E(-Wold-style-cast)
+E("-Wold-style-cast")
/// Warn about overflow in arithmetic expressions
-W(-Woverflow)
+W("-Woverflow")
/// Warn if a string is longer than the maximum
/// portable length specified by the standard
-//X(-Woverlength-strings)
+//X("-Woverlength-strings")
/// Warn about overloaded virtual function names
-E(-Woverloaded-virtual)
+E("-Woverloaded-virtual")
/// Warn when the packed attribute has no effect on
/// struct layout
-E(-Wpacked)
+E("-Wpacked")
/// Warn about packed bit-fields whose offset changed
/// in GCC 4.4
-WG(-Wpacked-bitfield-compat)
+WG("-Wpacked-bitfield-compat")
/// Warn when padding is required to align structure
/// members
-I(-Wpadded)
+I("-Wpadded")
/// Warn about possibly missing parentheses
-E(-Wparentheses)
+E("-Wparentheses")
/// Issue warnings needed for strict compliance to
/// the standard
-//EG48(-Wpedantic)
+//EG48("-Wpedantic")
// lots of minor extensions are used
-IG48(-Wpedantic)
+IG48("-Wpedantic")
// a bit too noisy
-XC(-Wpedantic)
+XC("-Wpedantic")
/// Warn when converting the type of pointers to
/// member functions
-EG(-Wpmf-conversions)
+EG("-Wpmf-conversions")
/// Warn about function pointer arithmetic
-E(-Wpointer-arith)
+E("-Wpointer-arith")
/// Warn about misuses of pragmas
-EG(-Wpragmas)
+EG("-Wpragmas")
/// Warn about multiple declarations of the same
/// object
-W(-Wredundant-decls)
+W("-Wredundant-decls")
/// Warn when the compiler reorders code
-E(-Wreorder)
+E("-Wreorder")
/// Warn about returning a pointer/reference to a
/// local or temporary variable.
-WG48(-Wreturn-local-addr)
+WG48("-Wreturn-local-addr")
/// Warn whenever a function's return type defaults
/// to "int" (C), or about inconsistent return types
-/// (C++)
-E(-Wreturn-type)
+/// (C++")
+E("-Wreturn-type")
/// Warn about possible violations of sequence point
/// rules
-E(-Wsequence-point)
+E("-Wsequence-point")
/// Warn when one local variable shadows another
-E(-Wshadow)
+E("-Wshadow")
/// Warn about signed-unsigned comparisons
-X(-Wsign-compare)
+X("-Wsign-compare")
/// Warn when overload promotes from unsigned to
/// signed
-X(-Wsign-promo)
+X("-Wsign-promo")
/// This switch lacks documentation
-WG48(-Wsizeof-pointer-memaccess)
+WG48("-Wsizeof-pointer-memaccess")
/// Warn when not issuing stack smashing protection
/// for some reason
-X(-Wstack-protector)
+X("-Wstack-protector")
/// Warn about code which might break strict aliasing
/// rules
-E(-Wstrict-aliasing)
+E("-Wstrict-aliasing")
/// Warn about uncasted NULL used as sentinel
-WG(-Wstrict-null-sentinel)
+WG("-Wstrict-null-sentinel")
/// Warn about optimizations that assume that signed
/// overflow is undefined
-X(-Wstrict-overflow)
+X("-Wstrict-overflow")
/// Warn about enumerated switches, with no default,
/// missing a case
-X(-Wswitch)
+X("-Wswitch")
/// Warn about enumerated switches missing a
/// "default:" statement
-X(-Wswitch-default)
+X("-Wswitch-default")
/// Warn about all enumerated switches missing a
/// specific case
-X(-Wswitch-enum)
+X("-Wswitch-enum")
/// Warn when __sync_fetch_and_nand and
/// __sync_nand_and_fetch built-in functions are used
-WG(-Wsync-nand)
+WG("-Wsync-nand")
/// Warn whenever a trampoline is generated
-EG(-Wtrampolines)
+EG("-Wtrampolines")
/// Warn if trigraphs are encountered that might
/// affect the meaning of the program
-E(-Wtrigraphs)
+E("-Wtrigraphs")
/// Warn if a comparison is always true or always
/// false due to the limited range of the data type
-E(-Wtype-limits)
+E("-Wtype-limits")
/// Warn if an undefined macro is used in an #if
/// directive
-E(-Wundef)
+E("-Wundef")
/// Warn about uninitialized automatic variables
-E(-Wuninitialized)
+E("-Wuninitialized")
/// Warn about unrecognized pragmas
-E(-Wunknown-pragmas)
+E("-Wunknown-pragmas")
///
// Not an error because of some remaining enum+default
-WC(-Wunreachable-code)
+WC("-Wunreachable-code")
/// Warn if the loop cannot be optimized due to
/// nontrivial assumptions.
-XG(-Wunsafe-loop-optimizations)
+XG("-Wunsafe-loop-optimizations")
/// Warn when a function parameter is only set,
/// otherwise unused
-EG(-Wunused-but-set-parameter)
+EG("-Wunused-but-set-parameter")
/// Warn when a variable is only set, otherwise unused
-EG(-Wunused-but-set-variable)
+EG("-Wunused-but-set-variable")
/// Warn when a function is unused
-E(-Wunused-function)
+E("-Wunused-function")
/// Warn when a label is unused
-E(-Wunused-label)
+E("-Wunused-label")
/// Warn when typedefs locally defined in a function
/// are not used
-EG47(-Wunused-local-typedefs)
+EG47("-Wunused-local-typedefs")
/// Warn about macros defined in the main file that
/// are not used
-W(-Wunused-macros)
+W("-Wunused-macros")
/// Warn when a function parameter is unused
-E(-Wunused-parameter)
+E("-Wunused-parameter")
/// Warn if a caller of a function, marked with
/// attribute warn_unused_result, does not use its
/// return value
-E(-Wunused-result)
+E("-Wunused-result")
/// Warn when an expression value is unused
-E(-Wunused-value)
+E("-Wunused-value")
/// Warn when a variable is unused
-E(-Wunused-variable)
+E("-Wunused-variable")
/// Warn about useless casts
-EG48(-Wuseless-cast)
+EG48("-Wuseless-cast")
/// Warn about questionable usage of the macros used
/// to retrieve variable arguments
-EG48(-Wvarargs)
+EG48("-Wvarargs")
/// Warn about using variadic macros
-W(-Wvariadic-macros)
+W("-Wvariadic-macros")
/// Warn when a vector operation is compiled
/// outside the SIMD
-WG47(-Wvector-operation-performance)
+WG47("-Wvector-operation-performance")
/// Warn if a virtual base has a non-trivial move
/// assignment operator
-EG48(-Wvirtual-move-assign)
+EG48("-Wvirtual-move-assign")
/// Warn if a variable length array is used
-I(-Wvla)
+I("-Wvla")
/// Warn when a register variable is declared volatile
-E(-Wvolatile-register-var)
+E("-Wvolatile-register-var")
/// In C++, nonzero means warn about deprecated
/// conversion from string literals to 'char *'. In
/// C, similar warning, except that the conversion is
/// of course not deprecated by the ISO C standard.
-E(-Wwrite-strings)
+E("-Wwrite-strings")
/// Warn when a literal '0' is used as null
/// pointer
-XG47(-Wzero-as-null-pointer-constant)
+XG47("-Wzero-as-null-pointer-constant")
// clean up after myself