| # python3 |
| # Copyright (C) 2019 The Android Open Source Project |
| # |
| # Licensed under the Apache License, Version 2.0 (the "License"); |
| # you may not use this file except in compliance with the License. |
| # You may obtain a copy of the License at |
| # |
| # http://www.apache.org/licenses/LICENSE-2.0 |
| # |
| # Unless required by applicable law or agreed to in writing, software |
| # distributed under the License is distributed on an "AS IS" BASIS, |
| # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| # See the License for the specific language governing permissions and |
| # limitations under the License. |
| |
| """Warning patterns for C/C++ compiler, but not clang-tidy.""" |
| |
| import re |
| |
| # pylint:disable=relative-beyond-top-level |
| # pylint:disable=g-importing-member |
| from .severity import Severity |
| |
| |
| warn_patterns = [ |
| # pylint:disable=line-too-long,g-inconsistent-quotes |
| {'category': 'C/C++', 'severity': Severity.MEDIUM, 'option': '-Wimplicit-function-declaration', |
| 'description': 'Implicit function declaration', |
| 'patterns': [r".*: warning: implicit declaration of function .+", |
| r".*: warning: implicitly declaring library function"]}, |
| {'category': 'C/C++', 'severity': Severity.SKIP, |
| 'description': 'skip, conflicting types for ...', |
| 'patterns': [r".*: warning: conflicting types for '.+'"]}, |
| {'category': 'C/C++', 'severity': Severity.HIGH, 'option': '-Wtype-limits', |
| 'description': 'Expression always evaluates to true or false', |
| 'patterns': [r".*: warning: comparison is always .+ due to limited range of data type", |
| r".*: warning: comparison of unsigned .*expression .+ is always true", |
| r".*: warning: comparison of unsigned .*expression .+ is always false"]}, |
| {'category': 'C/C++', 'severity': Severity.HIGH, |
| 'description': 'Use transient memory for control value', |
| 'patterns': [r".*: warning: .+Using such transient memory for the control value is .*dangerous."]}, |
| {'category': 'C/C++', 'severity': Severity.HIGH, |
| 'description': 'Return address of stack memory', |
| 'patterns': [r".*: warning: Address of stack memory .+ returned to caller", |
| r".*: warning: Address of stack memory .+ will be a dangling reference"]}, |
| {'category': 'C/C++', 'severity': Severity.HIGH, 'option': 'infinite-recursion', |
| 'description': 'Infinite recursion', |
| 'patterns': [r".*: warning: all paths through this function will call itself"]}, |
| {'category': 'C/C++', 'severity': Severity.HIGH, |
| 'description': 'Potential buffer overflow', |
| 'patterns': [r".*: warning: Size argument is greater than .+ the destination buffer", |
| r".*: warning: Potential buffer overflow.", |
| r".*: warning: String copy function overflows destination buffer"]}, |
| {'category': 'C/C++', 'severity': Severity.MEDIUM, |
| 'description': 'Incompatible pointer types', |
| 'patterns': [r".*: warning: assignment from incompatible pointer type", |
| r".*: warning: return from incompatible pointer type", |
| r".*: warning: passing argument [0-9]+ of '.*' from incompatible pointer type", |
| r".*: warning: initialization from incompatible pointer type"]}, |
| {'category': 'C/C++', 'severity': Severity.HIGH, 'option': '-fno-builtin', |
| 'description': 'Incompatible declaration of built in function', |
| 'patterns': [r".*: warning: incompatible implicit declaration of built-in function .+"]}, |
| {'category': 'C/C++', 'severity': Severity.HIGH, 'option': '-Wincompatible-library-redeclaration', |
| 'description': 'Incompatible redeclaration of library function', |
| 'patterns': [r".*: warning: incompatible redeclaration of library function .+"]}, |
| {'category': 'C/C++', 'severity': Severity.HIGH, |
| 'description': 'Null passed as non-null argument', |
| 'patterns': [r".*: warning: Null passed to a callee that requires a non-null"]}, |
| {'category': 'C/C++', 'severity': Severity.MEDIUM, 'option': '-Wunused-parameter', |
| 'description': 'Unused parameter', |
| 'patterns': [r".*: warning: unused parameter '.*'"]}, |
| {'category': 'C/C++', 'severity': Severity.MEDIUM, 'option': '-Wunused', |
| 'description': 'Unused function, variable, label, comparison, etc.', |
| 'patterns': [r".*: warning: '.+' defined but not used", |
| r".*: warning: unused function '.+'", |
| r".*: warning: unused label '.+'", |
| r".*: warning: relational comparison result unused", |
| r".*: warning: lambda capture .* is not used", |
| r".*: warning: private field '.+' is not used", |
| r".*: warning: unused variable '.+'"]}, |
| {'category': 'C/C++', 'severity': Severity.MEDIUM, 'option': '-Wunused-value', |
| 'description': 'Statement with no effect or result unused', |
| 'patterns': [r".*: warning: statement with no effect", |
| r".*: warning: expression result unused"]}, |
| {'category': 'C/C++', 'severity': Severity.MEDIUM, 'option': '-Wunused-result', |
| 'description': 'Ignoreing return value of function', |
| 'patterns': [r".*: warning: ignoring return value of function .+Wunused-result"]}, |
| {'category': 'C/C++', 'severity': Severity.MEDIUM, 'option': '-Wmissing-field-initializers', |
| 'description': 'Missing initializer', |
| 'patterns': [r".*: warning: missing initializer"]}, |
| {'category': 'C/C++', 'severity': Severity.MEDIUM, 'option': '-Wdelete-non-virtual-dtor', |
| 'description': 'Need virtual destructor', |
| 'patterns': [r".*: warning: delete called .* has virtual functions but non-virtual destructor"]}, |
| {'category': 'cont.', 'severity': Severity.SKIP, |
| 'description': 'skip, near initialization for ...', |
| 'patterns': [r".*: warning: \(near initialization for '.+'\)"]}, |
| {'category': 'C/C++', 'severity': Severity.MEDIUM, 'option': '-Wdate-time', |
| 'description': 'Expansion of data or time macro', |
| 'patterns': [r".*: warning: expansion of date or time macro is not reproducible"]}, |
| {'category': 'C/C++', 'severity': Severity.MEDIUM, 'option': '-Wexpansion-to-defined', |
| 'description': 'Macro expansion has undefined behavior', |
| 'patterns': [r".*: warning: macro expansion .* has undefined behavior"]}, |
| {'category': 'C/C++', 'severity': Severity.MEDIUM, 'option': '-Wformat', |
| 'description': 'Format string does not match arguments', |
| 'patterns': [r".*: warning: format '.+' expects type '.+', but argument [0-9]+ has type '.+'", |
| r".*: warning: more '%' conversions than data arguments", |
| r".*: warning: data argument not used by format string", |
| r".*: warning: incomplete format specifier", |
| r".*: warning: unknown conversion type .* in format", |
| r".*: warning: format .+ expects .+ but argument .+Wformat=", |
| r".*: warning: field precision should have .+ but argument has .+Wformat", |
| r".*: warning: format specifies type .+ but the argument has .*type .+Wformat"]}, |
| {'category': 'C/C++', 'severity': Severity.MEDIUM, 'option': '-Wformat-extra-args', |
| 'description': 'Too many arguments for format string', |
| 'patterns': [r".*: warning: too many arguments for format"]}, |
| {'category': 'C/C++', 'severity': Severity.MEDIUM, |
| 'description': 'Too many arguments in call', |
| 'patterns': [r".*: warning: too many arguments in call to "]}, |
| {'category': 'C/C++', 'severity': Severity.MEDIUM, 'option': '-Wformat-invalid-specifier', |
| 'description': 'Invalid format specifier', |
| 'patterns': [r".*: warning: invalid .+ specifier '.+'.+format-invalid-specifier"]}, |
| {'category': 'C/C++', 'severity': Severity.MEDIUM, 'option': '-Wsign-compare', |
| 'description': 'Comparison between signed and unsigned', |
| 'patterns': [r".*: warning: comparison between signed and unsigned", |
| r".*: warning: comparison of promoted \~unsigned with unsigned", |
| r".*: warning: signed and unsigned type in conditional expression"]}, |
| {'category': 'C/C++', 'severity': Severity.MEDIUM, |
| 'description': 'Comparison between enum and non-enum', |
| 'patterns': [r".*: warning: enumeral and non-enumeral type in conditional expression"]}, |
| {'category': 'libpng', 'severity': Severity.MEDIUM, |
| 'description': 'libpng: zero area', |
| 'patterns': [r".*libpng warning: Ignoring attempt to set cHRM RGB triangle with zero area"]}, |
| {'category': 'C/C++', 'severity': Severity.MEDIUM, 'option': '-Wmissing-braces', |
| 'description': 'Missing braces around initializer', |
| 'patterns': [r".*: warning: missing braces around initializer.*"]}, |
| {'category': 'C/C++', 'severity': Severity.HARMLESS, |
| 'description': 'No newline at end of file', |
| 'patterns': [r".*: warning: no newline at end of file"]}, |
| {'category': 'C/C++', 'severity': Severity.HARMLESS, |
| 'description': 'Missing space after macro name', |
| 'patterns': [r".*: warning: missing whitespace after the macro name"]}, |
| {'category': 'C/C++', 'severity': Severity.LOW, 'option': '-Wcast-align', |
| 'description': 'Cast increases required alignment', |
| 'patterns': [r".*: warning: cast from .* to .* increases required alignment .*"]}, |
| {'category': 'C/C++', 'severity': Severity.MEDIUM, 'option': '-Wcast-qual', |
| 'description': 'Qualifier discarded', |
| 'patterns': [r".*: warning: passing argument [0-9]+ of '.+' discards qualifiers from pointer target type", |
| r".*: warning: assignment discards qualifiers from pointer target type", |
| r".*: warning: passing .+ to parameter of type .+ discards qualifiers", |
| r".*: warning: assigning to .+ from .+ discards qualifiers", |
| r".*: warning: initializing .+ discards qualifiers .+types-discards-qualifiers", |
| r".*: warning: return discards qualifiers from pointer target type"]}, |
| {'category': 'C/C++', 'severity': Severity.MEDIUM, 'option': '-Wunknown-attributes', |
| 'description': 'Unknown attribute', |
| 'patterns': [r".*: warning: unknown attribute '.+'"]}, |
| {'category': 'C/C++', 'severity': Severity.MEDIUM, 'option': '-Wignored-attributes', |
| 'description': 'Attribute ignored', |
| 'patterns': [r".*: warning: '_*packed_*' attribute ignored", |
| r".*: warning: attribute declaration must precede definition .+ignored-attributes"]}, |
| {'category': 'C/C++', 'severity': Severity.MEDIUM, 'option': '-Wvisibility', |
| 'description': 'Visibility problem', |
| 'patterns': [r".*: warning: declaration of '.+' will not be visible outside of this function"]}, |
| {'category': 'C/C++', 'severity': Severity.MEDIUM, 'option': '-Wattributes', |
| 'description': 'Visibility mismatch', |
| 'patterns': [r".*: warning: '.+' declared with greater visibility than the type of its field '.+'"]}, |
| {'category': 'C/C++', 'severity': Severity.MEDIUM, |
| 'description': 'Shift count greater than width of type', |
| 'patterns': [r".*: warning: (left|right) shift count >= width of type"]}, |
| {'category': 'C/C++', 'severity': Severity.MEDIUM, 'option': '-Wextern-initializer', |
| 'description': 'extern <foo> is initialized', |
| 'patterns': [r".*: warning: '.+' initialized and declared 'extern'", |
| r".*: warning: 'extern' variable has an initializer"]}, |
| {'category': 'C/C++', 'severity': Severity.MEDIUM, 'option': '-Wold-style-declaration', |
| 'description': 'Old style declaration', |
| 'patterns': [r".*: warning: 'static' is not at beginning of declaration"]}, |
| {'category': 'C/C++', 'severity': Severity.MEDIUM, 'option': '-Wreturn-type', |
| 'description': 'Missing return value', |
| 'patterns': [r".*: warning: control reaches end of non-void function"]}, |
| {'category': 'C/C++', 'severity': Severity.MEDIUM, 'option': '-Wimplicit-int', |
| 'description': 'Implicit int type', |
| 'patterns': [r".*: warning: type specifier missing, defaults to 'int'", |
| r".*: warning: type defaults to 'int' in declaration of '.+'"]}, |
| {'category': 'C/C++', 'severity': Severity.MEDIUM, 'option': '-Wmain-return-type', |
| 'description': 'Main function should return int', |
| 'patterns': [r".*: warning: return type of 'main' is not 'int'"]}, |
| {'category': 'C/C++', 'severity': Severity.MEDIUM, 'option': '-Wuninitialized', |
| 'description': 'Variable may be used uninitialized', |
| 'patterns': [r".*: warning: '.+' may be used uninitialized in this function"]}, |
| {'category': 'C/C++', 'severity': Severity.HIGH, 'option': '-Wuninitialized', |
| 'description': 'Variable is used uninitialized', |
| 'patterns': [r".*: warning: '.+' is used uninitialized in this function", |
| r".*: warning: variable '.+' is uninitialized when used here"]}, |
| {'category': 'ld', 'severity': Severity.MEDIUM, 'option': '-fshort-enums', |
| 'description': 'ld: possible enum size mismatch', |
| 'patterns': [r".*: warning: .* uses variable-size enums yet the output is to use 32-bit enums; use of enum values across objects may fail"]}, |
| {'category': 'C/C++', 'severity': Severity.MEDIUM, 'option': '-Wpointer-sign', |
| 'description': 'Pointer targets differ in signedness', |
| 'patterns': [r".*: warning: pointer targets in initialization differ in signedness", |
| r".*: warning: pointer targets in assignment differ in signedness", |
| r".*: warning: pointer targets in return differ in signedness", |
| r".*: warning: pointer targets in passing argument [0-9]+ of '.+' differ in signedness"]}, |
| {'category': 'C/C++', 'severity': Severity.MEDIUM, 'option': '-Wstrict-overflow', |
| 'description': 'Assuming overflow does not occur', |
| 'patterns': [r".*: warning: assuming signed overflow does not occur when assuming that .* is always (true|false)"]}, |
| {'category': 'C/C++', 'severity': Severity.MEDIUM, 'option': '-Wempty-body', |
| 'description': 'Suggest adding braces around empty body', |
| 'patterns': [r".*: warning: suggest braces around empty body in an 'if' statement", |
| r".*: warning: empty body in an if-statement", |
| r".*: warning: suggest braces around empty body in an 'else' statement", |
| r".*: warning: empty body in an else-statement"]}, |
| {'category': 'C/C++', 'severity': Severity.MEDIUM, 'option': '-Wparentheses', |
| 'description': 'Suggest adding parentheses', |
| 'patterns': [r".*: warning: suggest explicit braces to avoid ambiguous 'else'", |
| r".*: warning: suggest parentheses around arithmetic in operand of '.+'", |
| r".*: warning: suggest parentheses around comparison in operand of '.+'", |
| r".*: warning: logical not is only applied to the left hand side of this comparison", |
| r".*: warning: using the result of an assignment as a condition without parentheses", |
| r".*: warning: .+ has lower precedence than .+ be evaluated first .+Wparentheses", |
| r".*: warning: suggest parentheses around '.+?' .+ '.+?'", |
| r".*: warning: suggest parentheses around assignment used as truth value"]}, |
| {'category': 'C/C++', 'severity': Severity.MEDIUM, |
| 'description': 'Static variable used in non-static inline function', |
| 'patterns': [r".*: warning: '.+' is static but used in inline function '.+' which is not static"]}, |
| {'category': 'C/C++', 'severity': Severity.MEDIUM, 'option': '-Wimplicit int', |
| 'description': 'No type or storage class (will default to int)', |
| 'patterns': [r".*: warning: data definition has no type or storage class"]}, |
| {'category': 'cont.', 'severity': Severity.SKIP, |
| 'description': 'skip, parameter name (without types) in function declaration', |
| 'patterns': [r".*: warning: parameter names \(without types\) in function declaration"]}, |
| {'category': 'C/C++', 'severity': Severity.MEDIUM, 'option': '-Wstrict-aliasing', |
| 'description': 'Dereferencing <foo> breaks strict aliasing rules', |
| 'patterns': [r".*: warning: dereferencing .* break strict-aliasing rules"]}, |
| {'category': 'C/C++', 'severity': Severity.MEDIUM, 'option': '-Wpointer-to-int-cast', |
| 'description': 'Cast from pointer to integer of different size', |
| 'patterns': [r".*: warning: cast from pointer to integer of different size", |
| r".*: warning: initialization makes pointer from integer without a cast"]}, |
| {'category': 'C/C++', 'severity': Severity.MEDIUM, 'option': '-Wint-to-pointer-cast', |
| 'description': 'Cast to pointer from integer of different size', |
| 'patterns': [r".*: warning: cast to pointer from integer of different size"]}, |
| {'category': 'C/C++', 'severity': Severity.MEDIUM, |
| 'description': 'Macro redefined', |
| 'patterns': [r".*: warning: '.+' macro redefined"]}, |
| {'category': 'cont.', 'severity': Severity.SKIP, |
| 'description': 'skip, ... location of the previous definition', |
| 'patterns': [r".*: warning: this is the location of the previous definition"]}, |
| {'category': 'ld', 'severity': Severity.MEDIUM, |
| 'description': 'ld: type and size of dynamic symbol are not defined', |
| 'patterns': [r".*: warning: type and size of dynamic symbol `.+' are not defined"]}, |
| {'category': 'C/C++', 'severity': Severity.MEDIUM, |
| 'description': 'Pointer from integer without cast', |
| 'patterns': [r".*: warning: assignment makes pointer from integer without a cast"]}, |
| {'category': 'C/C++', 'severity': Severity.MEDIUM, |
| 'description': 'Pointer from integer without cast', |
| 'patterns': [r".*: warning: passing argument [0-9]+ of '.+' makes pointer from integer without a cast"]}, |
| {'category': 'C/C++', 'severity': Severity.MEDIUM, |
| 'description': 'Integer from pointer without cast', |
| 'patterns': [r".*: warning: assignment makes integer from pointer without a cast"]}, |
| {'category': 'C/C++', 'severity': Severity.MEDIUM, |
| 'description': 'Integer from pointer without cast', |
| 'patterns': [r".*: warning: passing argument [0-9]+ of '.+' makes integer from pointer without a cast"]}, |
| {'category': 'C/C++', 'severity': Severity.MEDIUM, |
| 'description': 'Integer from pointer without cast', |
| 'patterns': [r".*: warning: return makes integer from pointer without a cast"]}, |
| {'category': 'C/C++', 'severity': Severity.MEDIUM, 'option': '-Wunknown-pragmas', |
| 'description': 'Ignoring pragma', |
| 'patterns': [r".*: warning: ignoring #pragma .+"]}, |
| {'category': 'C/C++', 'severity': Severity.MEDIUM, 'option': '-W#pragma-messages', |
| 'description': 'Pragma warning messages', |
| 'patterns': [r".*: warning: .+W#pragma-messages"]}, |
| {'category': 'C/C++', 'severity': Severity.MEDIUM, 'option': '-Wclobbered', |
| 'description': 'Variable might be clobbered by longjmp or vfork', |
| 'patterns': [r".*: warning: variable '.+' might be clobbered by 'longjmp' or 'vfork'"]}, |
| {'category': 'C/C++', 'severity': Severity.MEDIUM, 'option': '-Wclobbered', |
| 'description': 'Argument might be clobbered by longjmp or vfork', |
| 'patterns': [r".*: warning: argument '.+' might be clobbered by 'longjmp' or 'vfork'"]}, |
| {'category': 'C/C++', 'severity': Severity.MEDIUM, 'option': '-Wredundant-decls', |
| 'description': 'Redundant declaration', |
| 'patterns': [r".*: warning: redundant redeclaration of '.+'"]}, |
| {'category': 'cont.', 'severity': Severity.SKIP, |
| 'description': 'skip, previous declaration ... was here', |
| 'patterns': [r".*: warning: previous declaration of '.+' was here"]}, |
| {'category': 'C/C++', 'severity': Severity.HIGH, 'option': '-Wswitch-enum', |
| 'description': 'Enum value not handled in switch', |
| 'patterns': [r".*: warning: .*enumeration value.* not handled in switch.+Wswitch"]}, |
| {'category': 'C/C++', 'severity': Severity.MEDIUM, 'option': '-Wuser-defined-warnings', |
| 'description': 'User defined warnings', |
| 'patterns': [r".*: warning: .* \[-Wuser-defined-warnings\]$"]}, |
| {'category': 'C/C++', 'severity': Severity.MEDIUM, |
| 'description': 'Taking address of temporary', |
| 'patterns': [r".*: warning: taking address of temporary"]}, |
| {'category': 'C/C++', 'severity': Severity.MEDIUM, |
| 'description': 'Taking address of packed member', |
| 'patterns': [r".*: warning: taking address of packed member"]}, |
| {'category': 'C/C++', 'severity': Severity.MEDIUM, |
| 'description': 'Possible broken line continuation', |
| 'patterns': [r".*: warning: backslash and newline separated by space"]}, |
| {'category': 'C/C++', 'severity': Severity.MEDIUM, 'option': '-Wundefined-var-template', |
| 'description': 'Undefined variable template', |
| 'patterns': [r".*: warning: instantiation of variable .* no definition is available"]}, |
| {'category': 'C/C++', 'severity': Severity.MEDIUM, 'option': '-Wundefined-inline', |
| 'description': 'Inline function is not defined', |
| 'patterns': [r".*: warning: inline function '.*' is not defined"]}, |
| {'category': 'C/C++', 'severity': Severity.MEDIUM, |
| 'description': 'Excess elements in initializer', |
| 'patterns': [r".*: warning: excess elements in .+ initializer"]}, |
| {'category': 'C/C++', 'severity': Severity.MEDIUM, |
| 'description': 'Decimal constant is unsigned only in ISO C90', |
| 'patterns': [r".*: warning: this decimal constant is unsigned only in ISO C90"]}, |
| {'category': 'C/C++', 'severity': Severity.MEDIUM, 'option': '-Wmain', |
| 'description': 'main is usually a function', |
| 'patterns': [r".*: warning: 'main' is usually a function"]}, |
| {'category': 'C/C++', 'severity': Severity.MEDIUM, |
| 'description': 'Typedef ignored', |
| 'patterns': [r".*: warning: 'typedef' was ignored in this declaration"]}, |
| {'category': 'C/C++', 'severity': Severity.HIGH, 'option': '-Waddress', |
| 'description': 'Address always evaluates to true', |
| 'patterns': [r".*: warning: the address of '.+' will always evaluate as 'true'"]}, |
| {'category': 'C/C++', 'severity': Severity.FIXMENOW, |
| 'description': 'Freeing a non-heap object', |
| 'patterns': [r".*: warning: attempt to free a non-heap object '.+'"]}, |
| {'category': 'C/C++', 'severity': Severity.MEDIUM, 'option': '-Wchar-subscripts', |
| 'description': 'Array subscript has type char', |
| 'patterns': [r".*: warning: array subscript .+ type 'char'.+Wchar-subscripts"]}, |
| {'category': 'C/C++', 'severity': Severity.MEDIUM, |
| 'description': 'Constant too large for type', |
| 'patterns': [r".*: warning: integer constant is too large for '.+' type"]}, |
| {'category': 'C/C++', 'severity': Severity.MEDIUM, 'option': '-Woverflow', |
| 'description': 'Constant too large for type, truncated', |
| 'patterns': [r".*: warning: large integer implicitly truncated to unsigned type"]}, |
| {'category': 'C/C++', 'severity': Severity.MEDIUM, 'option': '-Winteger-overflow', |
| 'description': 'Overflow in expression', |
| 'patterns': [r".*: warning: overflow in expression; .*Winteger-overflow"]}, |
| {'category': 'C/C++', 'severity': Severity.MEDIUM, 'option': '-Woverflow', |
| 'description': 'Overflow in implicit constant conversion', |
| 'patterns': [r".*: warning: overflow in implicit constant conversion"]}, |
| {'category': 'C/C++', 'severity': Severity.MEDIUM, |
| 'description': 'Declaration does not declare anything', |
| 'patterns': [r".*: warning: declaration 'class .+' does not declare anything"]}, |
| {'category': 'C/C++', 'severity': Severity.MEDIUM, 'option': '-Wreorder', |
| 'description': 'Initialization order will be different', |
| 'patterns': [r".*: warning: '.+' will be initialized after", |
| r".*: warning: field .+ will be initialized after .+Wreorder"]}, |
| {'category': 'cont.', 'severity': Severity.SKIP, |
| 'description': 'skip, ....', |
| 'patterns': [r".*: warning: '.+'"]}, |
| {'category': 'cont.', 'severity': Severity.SKIP, |
| 'description': 'skip, base ...', |
| 'patterns': [r".*: warning: base '.+'"]}, |
| {'category': 'cont.', 'severity': Severity.SKIP, |
| 'description': 'skip, when initialized here', |
| 'patterns': [r".*: warning: when initialized here"]}, |
| {'category': 'C/C++', 'severity': Severity.MEDIUM, 'option': '-Wmissing-parameter-type', |
| 'description': 'Parameter type not specified', |
| 'patterns': [r".*: warning: type of '.+' defaults to 'int'"]}, |
| {'category': 'C/C++', 'severity': Severity.MEDIUM, 'option': '-Wmissing-declarations', |
| 'description': 'Missing declarations', |
| 'patterns': [r".*: warning: declaration does not declare anything"]}, |
| {'category': 'C/C++', 'severity': Severity.MEDIUM, 'option': '-Wmissing-noreturn', |
| 'description': 'Missing noreturn', |
| 'patterns': [r".*: warning: function '.*' could be declared with attribute 'noreturn'"]}, |
| {'category': 'C/C++', 'severity': Severity.MEDIUM, |
| 'description': 'User warning', |
| 'patterns': [r".*: warning: #warning "".+"""]}, |
| {'category': 'C/C++', 'severity': Severity.MEDIUM, 'option': '-Wvexing-parse', |
| 'description': 'Vexing parsing problem', |
| 'patterns': [r".*: warning: empty parentheses interpreted as a function declaration"]}, |
| {'category': 'C/C++', 'severity': Severity.MEDIUM, 'option': '-Wextra', |
| 'description': 'Dereferencing void*', |
| 'patterns': [r".*: warning: dereferencing 'void \*' pointer"]}, |
| {'category': 'C/C++', 'severity': Severity.MEDIUM, |
| 'description': 'Comparison of pointer and integer', |
| 'patterns': [r".*: warning: ordered comparison of pointer with integer zero", |
| r".*: warning: .*comparison between pointer and integer"]}, |
| {'category': 'C/C++', 'severity': Severity.MEDIUM, |
| 'description': 'Use of error-prone unary operator', |
| 'patterns': [r".*: warning: use of unary operator that may be intended as compound assignment"]}, |
| {'category': 'C/C++', 'severity': Severity.MEDIUM, 'option': '-Wwrite-strings', |
| 'description': 'Conversion of string constant to non-const char*', |
| 'patterns': [r".*: warning: deprecated conversion from string constant to '.+'"]}, |
| {'category': 'C/C++', 'severity': Severity.MEDIUM, 'option': '-Wstrict-prototypes', |
| 'description': 'Function declaration isn''t a prototype', |
| 'patterns': [r".*: warning: function declaration isn't a prototype"]}, |
| {'category': 'C/C++', 'severity': Severity.MEDIUM, 'option': '-Wignored-qualifiers', |
| 'description': 'Type qualifiers ignored on function return value', |
| 'patterns': [r".*: warning: type qualifiers ignored on function return type", |
| r".*: warning: .+ type qualifier .+ has no effect .+Wignored-qualifiers"]}, |
| {'category': 'C/C++', 'severity': Severity.MEDIUM, |
| 'description': '<foo> declared inside parameter list, scope limited to this definition', |
| 'patterns': [r".*: warning: '.+' declared inside parameter list"]}, |
| {'category': 'cont.', 'severity': Severity.SKIP, |
| 'description': 'skip, its scope is only this ...', |
| 'patterns': [r".*: warning: its scope is only this definition or declaration, which is probably not what you want"]}, |
| {'category': 'C/C++', 'severity': Severity.LOW, 'option': '-Wcomment', |
| 'description': 'Line continuation inside comment', |
| 'patterns': [r".*: warning: multi-line comment"]}, |
| {'category': 'C/C++', 'severity': Severity.LOW, 'option': '-Wcomment', |
| 'description': 'Comment inside comment', |
| 'patterns': [r".*: warning: '.+' within block comment .*-Wcomment"]}, |
| {'category': 'C/C++', 'severity': Severity.LOW, 'option': '-Wdeprecated-declarations', |
| 'description': 'Deprecated declarations', |
| 'patterns': [r".*: warning: .+ is deprecated.+deprecated-declarations"]}, |
| {'category': 'C/C++', 'severity': Severity.LOW, 'option': '-Wdeprecated-register', |
| 'description': 'Deprecated register', |
| 'patterns': [r".*: warning: 'register' storage class specifier is deprecated"]}, |
| {'category': 'C/C++', 'severity': Severity.LOW, 'option': '-Wpointer-sign', |
| 'description': 'Converts between pointers to integer types with different sign', |
| 'patterns': [r".*: warning: .+ converts between pointers to integer types with different sign"]}, |
| {'category': 'C/C++', 'severity': Severity.HARMLESS, |
| 'description': 'Extra tokens after #endif', |
| 'patterns': [r".*: warning: extra tokens at end of #endif directive"]}, |
| {'category': 'C/C++', 'severity': Severity.MEDIUM, 'option': '-Wenum-compare', |
| 'description': 'Comparison between different enums', |
| 'patterns': [r".*: warning: comparison between '.+' and '.+'.+Wenum-compare", |
| r".*: warning: comparison of .* enumeration types .*-Wenum-compare-switch"]}, |
| {'category': 'C/C++', 'severity': Severity.MEDIUM, 'option': '-Wconversion', |
| 'description': 'Conversion may change value', |
| 'patterns': [r".*: warning: converting negative value '.+' to '.+'", |
| r".*: warning: conversion to '.+' .+ may (alter|change)"]}, |
| {'category': 'C/C++', 'severity': Severity.MEDIUM, 'option': '-Wconversion-null', |
| 'description': 'Converting to non-pointer type from NULL', |
| 'patterns': [r".*: warning: converting to non-pointer type '.+' from NULL"]}, |
| {'category': 'C/C++', 'severity': Severity.MEDIUM, 'option': '-Wsign-conversion', |
| 'description': 'Implicit sign conversion', |
| 'patterns': [r".*: warning: implicit conversion changes signedness"]}, |
| {'category': 'C/C++', 'severity': Severity.MEDIUM, 'option': '-Wnull-conversion', |
| 'description': 'Converting NULL to non-pointer type', |
| 'patterns': [r".*: warning: implicit conversion of NULL constant to '.+'"]}, |
| {'category': 'C/C++', 'severity': Severity.MEDIUM, 'option': '-Wnon-literal-null-conversion', |
| 'description': 'Zero used as null pointer', |
| 'patterns': [r".*: warning: expression .* zero treated as a null pointer constant"]}, |
| {'category': 'C/C++', 'severity': Severity.MEDIUM, 'option': '-Wpointer-compare', |
| 'description': 'Compare pointer to null character', |
| 'patterns': [r".*: warning: comparing a pointer to a null character constant"]}, |
| {'category': 'C/C++', 'severity': Severity.MEDIUM, |
| 'description': 'Implicit conversion changes value or loses precision', |
| 'patterns': [r".*: warning: implicit conversion .* changes value from .* to .*-conversion", |
| r".*: warning: implicit conversion loses integer precision:"]}, |
| {'category': 'C/C++', 'severity': Severity.MEDIUM, |
| 'description': 'Passing NULL as non-pointer argument', |
| 'patterns': [r".*: warning: passing NULL to non-pointer argument [0-9]+ of '.+'"]}, |
| {'category': 'C/C++', 'severity': Severity.MEDIUM, 'option': '-Wctor-dtor-privacy', |
| 'description': 'Class seems unusable because of private ctor/dtor', |
| 'patterns': [r".*: warning: all member functions in class '.+' are private"]}, |
| # skip this next one, because it only points out some RefBase-based classes |
| # where having a private destructor is perfectly fine |
| {'category': 'C/C++', 'severity': Severity.SKIP, 'option': '-Wctor-dtor-privacy', |
| 'description': 'Class seems unusable because of private ctor/dtor', |
| 'patterns': [r".*: warning: 'class .+' only defines a private destructor and has no friends"]}, |
| {'category': 'C/C++', 'severity': Severity.MEDIUM, 'option': '-Wctor-dtor-privacy', |
| 'description': 'Class seems unusable because of private ctor/dtor', |
| 'patterns': [r".*: warning: 'class .+' only defines private constructors and has no friends"]}, |
| {'category': 'C/C++', 'severity': Severity.MEDIUM, 'option': '-Wgnu-static-float-init', |
| 'description': 'In-class initializer for static const float/double', |
| 'patterns': [r".*: warning: in-class initializer for static data member of .+const (float|double)"]}, |
| {'category': 'C/C++', 'severity': Severity.MEDIUM, 'option': '-Wpointer-arith', |
| 'description': 'void* used in arithmetic', |
| 'patterns': [r".*: warning: pointer of type 'void \*' used in (arithmetic|subtraction)", |
| r".*: warning: arithmetic on .+ to void is a GNU extension.*Wpointer-arith", |
| r".*: warning: wrong type argument to increment"]}, |
| {'category': 'C/C++', 'severity': Severity.MEDIUM, 'option': '-Wsign-promo', |
| 'description': 'Overload resolution chose to promote from unsigned or enum to signed type', |
| 'patterns': [r".*: warning: passing '.+' chooses '.+' over '.+'.*Wsign-promo"]}, |
| {'category': 'cont.', 'severity': Severity.SKIP, |
| 'description': 'skip, in call to ...', |
| 'patterns': [r".*: warning: in call to '.+'"]}, |
| {'category': 'C/C++', 'severity': Severity.HIGH, 'option': '-Wextra', |
| 'description': 'Base should be explicitly initialized in copy constructor', |
| 'patterns': [r".*: warning: base class '.+' should be explicitly initialized in the copy constructor"]}, |
| {'category': 'C/C++', 'severity': Severity.MEDIUM, |
| 'description': 'Return value from void function', |
| 'patterns': [r".*: warning: 'return' with a value, in function returning void"]}, |
| {'category': 'C/C++', 'severity': Severity.MEDIUM, 'option': 'multichar', |
| 'description': 'Multi-character character constant', |
| 'patterns': [r".*: warning: multi-character character constant"]}, |
| {'category': 'C/C++', 'severity': Severity.MEDIUM, 'option': 'writable-strings', |
| 'description': 'Conversion from string literal to char*', |
| 'patterns': [r".*: warning: .+ does not allow conversion from string literal to 'char \*'"]}, |
| {'category': 'C/C++', 'severity': Severity.LOW, 'option': '-Wextra-semi', |
| 'description': 'Extra \';\'', |
| 'patterns': [r".*: warning: extra ';' .+extra-semi"]}, |
| {'category': 'C/C++', 'severity': Severity.LOW, |
| 'description': 'Useless specifier', |
| 'patterns': [r".*: warning: useless storage class specifier in empty declaration"]}, |
| {'category': 'C/C++', 'severity': Severity.LOW, 'option': '-Wduplicate-decl-specifier', |
| 'description': 'Duplicate declaration specifier', |
| 'patterns': [r".*: warning: duplicate '.+' declaration specifier"]}, |
| {'category': 'C/C++', 'severity': Severity.LOW, 'option': 'tautological-compare', |
| 'description': 'Comparison of self is always false', |
| 'patterns': [r".*: self-comparison always evaluates to false"]}, |
| {'category': 'C/C++', 'severity': Severity.LOW, 'option': 'constant-logical-operand', |
| 'description': 'Logical op with constant operand', |
| 'patterns': [r".*: use of logical '.+' with constant operand"]}, |
| {'category': 'C/C++', 'severity': Severity.LOW, 'option': 'literal-suffix', |
| 'description': 'Needs a space between literal and string macro', |
| 'patterns': [r".*: warning: invalid suffix on literal.+ requires a space .+Wliteral-suffix"]}, |
| {'category': 'C/C++', 'severity': Severity.LOW, 'option': '#warnings', |
| 'description': 'Warnings from #warning', |
| 'patterns': [r".*: warning: .+-W#warnings"]}, |
| {'category': 'C/C++', 'severity': Severity.LOW, 'option': 'absolute-value', |
| 'description': 'Using float/int absolute value function with int/float argument', |
| 'patterns': [r".*: warning: using .+ absolute value function .+ when argument is .+ type .+Wabsolute-value", |
| r".*: warning: absolute value function '.+' given .+ which may cause truncation .+Wabsolute-value"]}, |
| {'category': 'C/C++', 'severity': Severity.LOW, 'option': '-Wc++11-extensions', |
| 'description': 'Using C++11 extensions', |
| 'patterns': [r".*: warning: 'auto' type specifier is a C\+\+11 extension"]}, |
| {'category': 'C/C++', 'severity': Severity.LOW, |
| 'description': 'Refers to implicitly defined namespace', |
| 'patterns': [r".*: warning: using directive refers to implicitly-defined namespace .+"]}, |
| {'category': 'C/C++', 'severity': Severity.LOW, 'option': '-Winvalid-pp-token', |
| 'description': 'Invalid pp token', |
| 'patterns': [r".*: warning: missing .+Winvalid-pp-token"]}, |
| {'category': 'link', 'severity': Severity.LOW, |
| 'description': 'need glibc to link', |
| 'patterns': [r".*: warning: .* requires at runtime .* glibc .* for linking"]}, |
| |
| {'category': 'C/C++', 'severity': Severity.MEDIUM, |
| 'description': 'Operator new returns NULL', |
| 'patterns': [r".*: warning: 'operator new' must not return NULL unless it is declared 'throw\(\)' .+"]}, |
| {'category': 'C/C++', 'severity': Severity.MEDIUM, 'option': '-Wnull-arithmetic', |
| 'description': 'NULL used in arithmetic', |
| 'patterns': [r".*: warning: NULL used in arithmetic", |
| r".*: warning: comparison between NULL and non-pointer"]}, |
| {'category': 'C/C++', 'severity': Severity.MEDIUM, 'option': 'header-guard', |
| 'description': 'Misspelled header guard', |
| 'patterns': [r".*: warning: '.+' is used as a header guard .+ followed by .+ different macro"]}, |
| {'category': 'C/C++', 'severity': Severity.MEDIUM, 'option': 'empty-body', |
| 'description': 'Empty loop body', |
| 'patterns': [r".*: warning: .+ loop has empty body"]}, |
| {'category': 'C/C++', 'severity': Severity.MEDIUM, 'option': 'enum-conversion', |
| 'description': 'Implicit conversion from enumeration type', |
| 'patterns': [r".*: warning: implicit conversion from enumeration type '.+'"]}, |
| {'category': 'C/C++', 'severity': Severity.MEDIUM, 'option': 'switch', |
| 'description': 'case value not in enumerated type', |
| 'patterns': [r".*: warning: case value not in enumerated type '.+'"]}, |
| {'category': 'C/C++', 'severity': Severity.MEDIUM, |
| 'description': 'Use of deprecated method', |
| 'patterns': [r".*: warning: '.+' is deprecated .+"]}, |
| {'category': 'C/C++', 'severity': Severity.MEDIUM, |
| 'description': 'Use of garbage or uninitialized value', |
| 'patterns': [r".*: warning: .+ uninitialized .+\[-Wsometimes-uninitialized\]"]}, |
| {'category': 'C/C++', 'severity': Severity.MEDIUM, 'option': '-Wsizeof-array-argument', |
| 'description': 'Sizeof on array argument', |
| 'patterns': [r".*: warning: sizeof on array function parameter will return"]}, |
| {'category': 'C/C++', 'severity': Severity.MEDIUM, 'option': '-Wsizeof-pointer-memacces', |
| 'description': 'Bad argument size of memory access functions', |
| 'patterns': [r".*: warning: .+\[-Wsizeof-pointer-memaccess\]"]}, |
| {'category': 'C/C++', 'severity': Severity.MEDIUM, |
| 'description': 'Return value not checked', |
| 'patterns': [r".*: warning: The return value from .+ is not checked"]}, |
| {'category': 'C/C++', 'severity': Severity.MEDIUM, |
| 'description': 'Possible heap pollution', |
| 'patterns': [r".*: warning: .*Possible heap pollution from .+ type .+"]}, |
| {'category': 'C/C++', 'severity': Severity.MEDIUM, 'option': '-Wfor-loop-analysis', |
| 'description': 'Variable used in loop condition not modified in loop body', |
| 'patterns': [r".*: warning: variable '.+' used in loop condition.*Wfor-loop-analysis"]}, |
| {'category': 'C/C++', 'severity': Severity.MEDIUM, |
| 'description': 'Closing a previously closed file', |
| 'patterns': [r".*: warning: Closing a previously closed file"]}, |
| {'category': 'C/C++', 'severity': Severity.MEDIUM, 'option': '-Wunnamed-type-template-args', |
| 'description': 'Unnamed template type argument', |
| 'patterns': [r".*: warning: template argument.+Wunnamed-type-template-args"]}, |
| {'category': 'C/C++', 'severity': Severity.MEDIUM, 'option': '-Wimplicit-fallthrough', |
| 'description': 'Unannotated fall-through between switch labels', |
| 'patterns': [r".*: warning: unannotated fall-through between switch labels.+Wimplicit-fallthrough"]}, |
| {'category': 'C/C++', 'severity': Severity.HARMLESS, |
| 'description': 'Discarded qualifier from pointer target type', |
| 'patterns': [r".*: warning: .+ discards '.+' qualifier from pointer target type"]}, |
| {'category': 'C/C++', 'severity': Severity.HARMLESS, |
| 'description': 'Use snprintf instead of sprintf', |
| 'patterns': [r".*: warning: .*sprintf is often misused; please use snprintf"]}, |
| {'category': 'C/C++', 'severity': Severity.HARMLESS, |
| 'description': 'Unsupported optimizaton flag', |
| 'patterns': [r".*: warning: optimization flag '.+' is not supported"]}, |
| {'category': 'C/C++', 'severity': Severity.HARMLESS, |
| 'description': 'Extra or missing parentheses', |
| 'patterns': [r".*: warning: equality comparison with extraneous parentheses", |
| r".*: warning: .+ within .+Wlogical-op-parentheses"]}, |
| {'category': 'C/C++', 'severity': Severity.HARMLESS, 'option': 'mismatched-tags', |
| 'description': 'Mismatched class vs struct tags', |
| 'patterns': [r".*: warning: '.+' defined as a .+ here but previously declared as a .+mismatched-tags", |
| r".*: warning: .+ was previously declared as a .+mismatched-tags"]}, |
| ] |
| |
| |
| def compile_patterns(patterns): |
| """Precompiling every pattern speeds up parsing by about 30x.""" |
| for i in patterns: |
| i['compiled_patterns'] = [] |
| for pat in i['patterns']: |
| i['compiled_patterns'].append(re.compile(pat)) |
| |
| |
| compile_patterns(warn_patterns) |