summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
-rw-r--r--src/login/login.cpp6
-rw-r--r--src/map/magic-interpreter-lexer.lpp1
-rw-r--r--src/warnings.hpp359
-rwxr-xr-xtools/indenter403
4 files changed, 557 insertions, 212 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
diff --git a/tools/indenter b/tools/indenter
index 0f0f31d..0d93543 100755
--- a/tools/indenter
+++ b/tools/indenter
@@ -59,11 +59,15 @@ if 1:
self._diagnostic('warning', msg, to)
def note(self, msg, to=None):
self._diagnostic('note', msg, to)
+ def fatal(self, msg, to=None):
+ self.error(msg, to)
+ sys.exit(1)
Location._diagnostic = _diagnostic
Location.error = error
Location.warning = warning
Location.note = note
- del _diagnostic, error, warning, note
+ Location.fatal = fatal
+ del _diagnostic, error, warning, note, fatal
class Reader(object):
@@ -144,10 +148,10 @@ def take_slc(b, r):
while True:
c = r.get()
# if c == '\n': return
- r.adv()
- b += c
if c == '\n' and not bs:
return
+ r.adv()
+ b += c
bs = c == '\\'
def take_char(b, r):
@@ -214,7 +218,7 @@ def format_lex_or_yacc_definitions():
'definitions section (mostly used for options actually)'
table = Table()
in_code = False
- code = bytearray()
+ code = ''
for line in sys.stdin:
if line == '%%\n':
break
@@ -241,7 +245,7 @@ def format_lex_or_yacc_definitions():
table.put1('')
elif code:
table.put1('')
- code = bytearray()
+ code = ''
if line.startswith('%'):
# %top is flex, %code and %union are bison
@@ -249,7 +253,7 @@ def format_lex_or_yacc_definitions():
if union or line.startswith('%top') or line.startswith('%code'):
# TODO fix stupidity when in strings or comments
count = line.count('{')
- #code = bytearray()
+ #code = ''
if union:
assert count <= 1
code += line[1:]
@@ -277,7 +281,7 @@ def format_lex_or_yacc_definitions():
else:
for line2 in indent_cpp_slop(code):
table.put1(LexSettings.nested_indent * ' ' + line2)
- code = bytearray()
+ code = ''
else:
table.put1(line)
elif line[0].isalpha() or line[0] == '_':
@@ -337,7 +341,7 @@ def format_lex_rules():
del bs
del p
pattern = line[:i]
- rule = bytearray(line[i:])
+ rule = line[i:]
del i
count = rule.count('{') - rule.count('}')
while count:
@@ -410,7 +414,7 @@ def format_yacc_rules():
continue
if line.startswith('{'):
line += '\n'
- lines = bytearray()
+ lines = ''
# TODO fix braces in comments and strings
lo = 1
behold = 1
@@ -547,7 +551,12 @@ def format_cc():
sys.exit(tail.wait())
def indent_cpp_slop(code):
- return subprocess.Popen(['indenter-cpp'], stdin=subprocess.PIPE, stdout=subprocess.PIPE).communicate(code)[0].strip().split('\n')
+ proc = subprocess.Popen(['indenter-cpp'], stdin=subprocess.PIPE, stdout=subprocess.PIPE)
+ rv = proc.communicate(code)[0].strip().split('\n')
+ prv = proc.wait()
+ if prv:
+ sys.exit(prv)
+ return rv
operators = {
'#', '##',
@@ -578,6 +587,21 @@ operators = {
k: {v[len(k):] for v in operators if v is not k and v.startswith(k)}
for k in operators
}
+# *please* don't use any of these except and, or, and not
+operator_map = {
+ 'and': '&&',
+ 'and_eq': '&=',
+ 'bitand': '&',
+ 'bitor': '|',
+ 'compl': '~',
+ 'not': '!',
+ 'not_eq': '!=',
+ 'or': '||',
+ 'or_eq': '|=',
+ 'xor': '^',
+ 'xor_eq': '^=',
+}
+
num1 = string.digits
num_x = num1 + '.\''
@@ -585,7 +609,7 @@ ident1 = string.ascii_letters + '_$@' # $@ for bison
ident_x = ident1 + string.digits
class CxxLexer(object):
- __slots__ = ('_reader', '_w', '_t', '_f', '_namespaces', '_classes')
+ __slots__ = ('_reader', '_w', '_t', '_l', '_namespaces', '_classes')
def __init__(self, reader):
self._reader = reader
@@ -593,11 +617,11 @@ class CxxLexer(object):
self._namespaces = []
self._classes = []
- def get(self):
- return self._w, self._t, self._f
+ def get2(self):
+ return self._w, self._t, self._l
def adv(self):
- self._w, self._t, self._f = self.pull()
+ self._w, self._t, self._l = self.pull()
def pull(self):
r = self._reader
@@ -606,11 +630,12 @@ class CxxLexer(object):
while True:
c = r.get()
if not c:
- return '\n', None, None
+ return '\n', None, r.loc()
if not c.isspace():
break
white += c
r.adv()
+ white = str(white)
black = bytearray()
black += c
@@ -652,32 +677,352 @@ class CxxLexer(object):
else:
l.error('Unknown character: %r' % c)
sys.exit(1)
+ black = str(black)
+
+ return white, black, l
+
+
+class Flavored(object):
+ __slots__ = ('_str')
+
+ def __init__(self, s):
+ self._str = s
+
+class Control(Flavored):
+ __slots__ = ()
+
+class Binary(Flavored):
+ __slots__ = ()
+
+class Unary(Flavored):
+ __slots__ = ()
+
+class Postfix(Flavored):
+ __slots__ = ()
+
+class Type(Flavored):
+ __slots__ = ()
+
+class Value(Flavored):
+ __slots__ = ()
+
+class Literal(Value):
+ __slots__ = ()
+
+class TypeExpr(Flavored):
+ __slots__ = ()
+
+class Attr(Flavored):
+ __slots__ = ()
+
+class Def(Flavored):
+ __slots__ = ()
+
+class MatchHead(Flavored):
+ __slots__ = ('_tail_char', '_purpose')
+ def __init__(self, s, t, p):
+ Flavored.__init__(self, s)
+ assert isinstance(t, str)
+ self._tail_char = t
+ self._purpose = p
+
+class MatchTail(Flavored):
+ __slots__ = ('_head_obj')
+ def __init__(self, s, head):
+ Flavored.__init__(self, s)
+ assert isinstance(head, MatchHead)
+ self._head_obj = head
+ @property
+ def _purpose(self):
+ return self._head_obj._purpose
+
+class MatchTail2(Flavored):
+ __slots__ = ('_head_inner', '_head_outer')
+ def __init__(self, s, head_inner, head_outer):
+ Flavored.__init__(self, s)
+ assert isinstance(head_inner, MatchHead)
+ assert isinstance(head_outer, MatchHead)
+ self._head_inner = head_inner
+ self._head_outer = head_outer
+
+ @property
+ def _purpose(self):
+ return self._head_outer._purpose
+
+
+class CxxFormatter(object):
+ __slots__ = ('_lexer', '_w', '_t', '_types', '_values', '_type_expressions', '_scopes')
+
+ def __init__(self, lexer):
+ assert isinstance(lexer, CxxLexer)
+ self._lexer = lexer
+ self._w = None
+ self._t = None
+ self._scopes = []
+
+ self._types = {
+ 'auto',
+ 'bool',
+ 'char',
+ 'char16_t',
+ 'char32_t',
+ 'double',
+ 'float',
+ 'int',
+ 'long',
+ 'short',
+ 'signed',
+ 'unsigned',
+ 'void',
+ 'wchar_t',
+ }
+ self._values = {
+ 'alignof',
+ 'const_cast',
+ 'dynamic_cast',
+ 'false',
+ 'nullptr',
+ 'reinterpret_cast',
+ 'sizeof',
+ 'static_cast',
+ 'this',
+ 'typeid',
+ 'true',
+ }
+ self._type_expressions = {
+ 'decltype',
+ }
- # c is the first char of the next thing
- return white, black, None
+ # the following two functions should *generally* not access self
+ # but they do need to a bit
+ def flavor2(self, w, t, l):
+ ''' Given the next token and its whitespace, calculate the flavor.
-def whitespace(w, (t, f), (pt, pf)):
- return w
+ Note: the need to know the preceding whitespace is a hack
+ (but a pretty good one!)
+
+ self.w, self.t, and self.f still contain the previous token.
+ '''
+ if t.startswith('//') or t.startswith('/*') or (t.startswith('#') and len(t) > 2):
+ return None
+ if t[0] in num1 or t[0] == '\'':
+ return Literal(t)
+ if '"' in t:
+ if self._t and self._t._str == 'extern':
+ # extern "C"
+ return Attr(t)
+ return Literal(t)
+ o = operator_map.get(t, t)
+
+ if o in {
+ '#',
+ '!',
+ '~',
+ }:
+ return Unary(t)
+ if o in {
+ '##',
+ '+=',
+ '-=',
+ '->',
+ '->*',
+ '*=',
+ '/',
+ '/=',
+ '%',
+ '%=',
+ '=',
+ '==',
+ '!=',
+ '|',
+ '||',
+ '|=',
+ '&=',
+ '^',
+ '^=',
+ '<=',
+ '<<',
+ '<<=',
+ '>=',
+ '>>=',
+ '.',
+ '..',
+ '.*',
+ '::',
+ }:
+ return Binary(t)
+ if o == '<':
+ if w:
+ return Binary(t)
+ u = {'<': '>', '(': ')', '{': '}', '[': ']'}.get(o)
+ if u is not None:
+ rv = MatchHead(t, u, None) # fix this, it is CRITICAL
+ self._scopes.append(rv)
+ return rv
+ if o == '>' or o == '>>':
+ if not self._scopes or self._scopes[-1]._str != '<':
+ return Binary(t)
+ if o == '>>':
+ assert len(self._scopes) >= 2
+ assert self._scopes[-1]._str == '<'
+ assert self._scopes[-2]._str == '<'
+ return MatchTail2(t, self._scopes.pop(), self._scopes.pop())
+ if o in {'>', ')', '}', ']'}:
+ if not self._scopes:
+ l.fatal('Unexpected %r' % t)
+ if self._scopes[-1]._tail_char != t:
+ l.fatal('Expected %r, got %r' % (self._scopes[-1]._tail_char, t))
+ return MatchTail(t, self._scopes.pop())
+ if o == '...':
+ return Postfix(t)
+ if o in {'*', '&', '&&'}:
+ if isinstance(self._t, Type):
+ return Type(t)
+ if o in {'+', '-', '*', '&', '&&'}:
+ # && is a gcc extension for address-of-a-label
+ if isinstance(self._t, (Unary, Binary, Control, MatchHead)):
+ return Unary(t)
+ elif isinstance(self._t, (Value, Postfix, MatchTail, MatchTail2)):
+ return Binary(t)
+ else:
+ l.fatal('Not sure how to handle ambiguous unary/binary after instance of %r' % self._t.__class__.__name__)
+ if o in {'--', '++'}:
+ if isinstance(self._t, (Unary, Binary, Control, MatchHead)):
+ return Unary(t)
+ elif isinstance(self._t, (Value, Postfix, MatchTail, MatchTail2)):
+ return Postfix(t)
+ else:
+ l.fatal('Not sure how to handle ambiguous prefix/postfix after instance of %r' % self._t.__class__.__name__)
+ if o in {',', ';'}:
+ return Binary(t)
+ if o == '?':
+ return Binary(t)
+ if o == ':':
+ return Binary(t)
+
+ assert t == o
+ assert t[0] in ident1
+ assert all(c in ident_x for c in t[1:])
+
+ # keywords!
+ if t == '__attribute__':
+ return Attr(t)
+ if t in {
+ 'alignas',
+ 'constexpr',
+ 'explicit',
+ 'export',
+ 'extern',
+ 'friend',
+ 'inline',
+ 'mutable',
+ 'register',
+ 'static',
+ 'thread_local',
+ 'virtual',
+ }:
+ return Attr(t)
+ if t in {
+ 'const',
+ 'volatile',
+ }:
+ if self._t is None or isinstance(self._t, (Attr, Binary, MatchTail, MatchTail2)): # ; is binary
+ return Attr(t)
+ if isinstance(self._t, Def):
+ # trailing function
+ return Attr(t)
+ return Type(t)
+ if t in {'final', 'override'}:
+ # theoretically, should only do this for thingy
+ return Attr(t)
+ if t == 'noexcept':
+ if isinstance(self._t, (Attr, MatchTail, MatchTail2)):
+ return Attr(t)
+ else:
+ return Value(t)
+ if t == 'asm':
+ return Value(t)
+ if t in {'delete', 'default'} and isinstance(self._t, Binary): # = delete
+ return Value(t)
+ if t in {'new', 'delete'}:
+ return Unary(t)
+ if t in {'case', 'goto', 'return', 'throw'}:
+ return Unary(t)
+ if t in {'default', 'public', 'private', 'protected'}:
+ return Value(t)
+ if t in {'break', 'continue'}:
+ return Value(t)
+ if t in {'try', 'catch', 'do', 'else', 'for', 'if', 'switch', 'while'}:
+ return Control(t)
+ if t in {'class', 'enum', 'struct', 'typename', 'union'}:
+ return Def(t)
+ if t == 'static_assert':
+ return Value(t)
+ if t == 'operator':
+ return Value(t)
+ if t == 'namespace':
+ return Def(t)
+ if t == 'template':
+ return Def(t)
+ if t == 'typedef':
+ return Def(t)
+ if t == 'using':
+ return Unary(t)
+
+ if t in self._type_expressions:
+ return TypeExpr(t)
+
+ # types, values, and keywords that act like one of those
+ if t in self._types:
+ return Type(t)
+ if t in self._values:
+ return Value(t)
+ u = t.replace('_', '')
+ if u.isupper():
+ return Value(t)
+ if u and u[0].isupper():
+ return Type(t)
+ return Value(t)
+
+ def whitespace(self, pt, t):
+ ''' Given a token and its flavor, calculate its whitespace.
+ '''
+ w = self._w # TODO set to '' instead to force calculation
+ for func in [
+ ]:
+ w = func(w, pt, t)
+ return w
def format_ii():
r = Reader('<stdin>', sys.stdin)
l = CxxLexer(r)
- pt = None
- pf = None
+ f = CxxFormatter(l)
while True:
- w, t, f = l.get()
- if not t:
+ wspace, raw_tok, loc = l.get2()
+ assert isinstance(wspace, str)
+ if raw_tok is None:
break
+ assert isinstance(raw_tok, str)
l.adv()
- w = whitespace(w, (t, f), (pt, pf))
- sys.stdout.writelines([w, t])
- #print('w:', repr(str(w)))
- #print('t:', t)
- pt, pf = t, f
- if not pt.endswith('\n'):
+ prev_tok = f._t
+ cooked_tok = f.flavor2(wspace, raw_tok, loc)
+ if cooked_tok is None:
+ f._w = wspace # or ' '
+ # f._t is unchanged
+ else:
+ f._w = wspace
+ f._t = cooked_tok
+ wspace = f.whitespace(prev_tok, cooked_tok)
+
+ if cooked_tok is None:
+ sys.stdout.writelines([wspace, raw_tok])
+ else:
+ sys.stdout.writelines([wspace, cooked_tok._str])
+ if 1:
sys.stdout.write('\n')
+
exts = {
'-lpp': format_lex,
'-ypp': format_yacc,