diff options
| -rw-r--r-- | src/login/login.cpp | 6 | ||||
| -rw-r--r-- | src/map/magic-interpreter-lexer.lpp | 1 | ||||
| -rw-r--r-- | src/warnings.hpp | 359 | ||||
| -rwxr-xr-x | tools/indenter | 403 |
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, |