Clang-Tidy: refactoring clang_tidy_warn.py

Authors: Emma Vukelj, Elaina Guan

This CL moves the warn_patterns dictionary and its dependencies into a
seperate file which the original clang_tidy_warn.py imports. This is
done for clarity and easier navigation of the original code.

BUG=None
TEST=No functionality was changed, original tests still work

Change-Id: I248ed2e62cd5192d1d5a900d988424cf24b0047a
Reviewed-on: https://chromium-review.googlesource.com/c/chromiumos/third_party/toolchain-utils/+/1637609
Reviewed-by: George Burgess <gbiv@chromium.org>
Tested-by: Emma Vukelj <emmavukelj@google.com>

2 files changed, 2578 insertions, 2534 deletions

diff --git a/clang_tidy/clang_tidy_warn.py b/clang_tidy/clang_tidy_warn.py
index ee04a43c..28e2b477 100755
--- a/clang_tidy/clang_tidy_warn.py
+++ b/clang_tidy/clang_tidy_warn.py
@@ -93,6 +93,8 @@ import re
 import signal
 import sys
 
+from clang_tidy_warn_patterns import warn_patterns, Severity
+
 # TODO: move the parser code into a function
 parser = argparse.ArgumentParser(description='Convert a build log into HTML')
 parser.add_argument(
@@ -161,2540 +163,6 @@ class Severity(object):
   headers = [a[2] for a in attributes]
 
 
-def tidy_warn_pattern(description, pattern):
-  return {
-      'category': 'C/C++',
-      'severity': Severity.TIDY,
-      'description': 'clang-tidy ' + description,
-      'patterns': [r'.*: .+\[' + pattern + r'\]$']
-  }
-
-
-def simple_tidy_warn_pattern(description):
-  return tidy_warn_pattern(description, description)
-
-
-def group_tidy_warn_pattern(description):
-  return tidy_warn_pattern(description, description + r'-.+')
-
-
-warn_patterns = [
-    {
-        'category': 'C/C++',
-        'severity': Severity.ANALYZER,
-        'description': 'clang-analyzer Security warning',
-        'patterns': [r".*: warning: .+\[clang-analyzer-security.*\]"]
-    },
-    {
-        'category':
-            'make',
-        'severity':
-            Severity.MEDIUM,
-        'description':
-            'make: overriding commands/ignoring old commands',
-        'patterns': [
-            r".*: warning: overriding commands for target .+",
-            r".*: warning: ignoring old commands for target .+"
-        ]
-    },
-    {
-        'category': 'make',
-        'severity': Severity.HIGH,
-        'description': 'make: LOCAL_CLANG is false',
-        'patterns': [r".*: warning: LOCAL_CLANG is set to false"]
-    },
-    {
-        'category':
-            'make',
-        'severity':
-            Severity.HIGH,
-        'description':
-            'SDK App using platform shared library',
-        'patterns': [
-            r".*: warning: .+ \(.*app:sdk.*\) should not link to .+ "
-            r"\(native:platform\)"
-        ]
-    },
-    {
-        'category':
-            'make',
-        'severity':
-            Severity.HIGH,
-        'description':
-            'System module linking to a vendor module',
-        'patterns': [
-            r".*: warning: .+ \(.+\) should not link to .+ \(partition:.+\)"
-        ]
-    },
-    {
-        'category': 'make',
-        'severity': Severity.MEDIUM,
-        'description': 'Invalid SDK/NDK linking',
-        'patterns': [r".*: warning: .+ \(.+\) should not link to .+ \(.+\)"]
-    },
-    {
-        'category': 'make',
-        'severity': Severity.MEDIUM,
-        'description': 'Duplicate header copy',
-        'patterns': [r".*: warning: Duplicate header copy: .+"]
-    },
-    {
-        'category':
-            'C/C++',
-        'severity':
-            Severity.HIGH,
-        '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 "
-            r"data type",
-            r".*: warning: comparison of unsigned .*expression .+ is always "
-            r"true",
-            r".*: warning: comparison of unsigned .*expression .+ is always "
-            r"false"
-        ]
-    },
-    {
-        'category':
-            'C/C++',
-        'severity':
-            Severity.HIGH,
-        'description':
-            'Potential leak of memory, bad free, use after free',
-        'patterns': [
-            r".*: warning: Potential leak of memory",
-            r".*: warning: Potential memory leak",
-            r".*: warning: Memory allocated by alloca\(\) should not be "
-            r"deallocated",
-            r".*: warning: Memory allocated by .+ should be deallocated by "
-            r".+ not .+",
-            r".*: warning: 'delete' applied to a pointer that was allocated",
-            r".*: warning: Use of memory after it is freed",
-            r".*: warning: Argument to .+ is the address of .+ variable",
-            r".*: warning: Argument to free\(\) is offset by .+ of memory "
-            r"allocated by", r".*: warning: Attempt to .+ released memory"
-        ]
-    },
-    {
-        'category':
-            'C/C++',
-        'severity':
-            Severity.HIGH,
-        'description':
-            'Use transient memory for control value',
-        'patterns': [
-            r".*: warning: .+Using such transient memory for the control "
-            r"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 "
-            r"reference"
-        ]
-    },
-    {
-        'category':
-            'C/C++',
-        'severity':
-            Severity.HIGH,
-        'description':
-            'Problem with vfork',
-        'patterns': [
-            r".*: warning: This .+ is prohibited after a successful vfork",
-            r".*: warning: Call to function '.+' is insecure "
-        ]
-    },
-    {
-        '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 "
-            r"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 "
-            r"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 "
-            r"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 "
-            r"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':
-            '-Wformat',
-        'description':
-            'Format string does not match arguments',
-        'patterns': [
-            r".*: warning: format '.+' expects type '.+', but argument "
-            r"[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 "
-            r".+Wformat",
-            r".*: warning: format specifies type .+ but the argument has "
-            r".*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 "
-            r"expression"
-        ]
-    },
-    {
-        'category':
-            'libpng',
-        'severity':
-            Severity.MEDIUM,
-        'description':
-            'libpng: zero area',
-        'patterns': [
-            r".*libpng warning: Ignoring attempt to set cHRM RGB triangle "
-            r"with zero area"
-        ]
-    },
-    {
-        'category': 'aapt',
-        'severity': Severity.MEDIUM,
-        'description': 'aapt: no comment for public symbol',
-        'patterns': [r".*: warning: No comment for public symbol .+"]
-    },
-    {
-        '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 "
-            r"qualifiers from pointer target type",
-            r".*: warning: assignment discards qualifiers from pointer "
-            r"target type",
-            r".*: warning: passing .+ to parameter of type .+ discards "
-            r"qualifiers",
-            r".*: warning: assigning to .+ from .+ discards qualifiers",
-            r".*: warning: initializing .+ discards qualifiers "
-            r".+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 "
-            r".+ignored-attributes"
-        ]
-    },
-    {
-        'category':
-            'C/C++',
-        'severity':
-            Severity.MEDIUM,
-        'option':
-            '-Wvisibility',
-        'description':
-            'Visibility problem',
-        'patterns': [
-            r".*: warning: declaration of '.+' will not be visible outside "
-            r"of this function"
-        ]
-    },
-    {
-        'category':
-            'C/C++',
-        'severity':
-            Severity.MEDIUM,
-        'option':
-            '-Wattributes',
-        'description':
-            'Visibility mismatch',
-        'patterns': [
-            r".*: warning: '.+' declared with greater visibility than the "
-            r"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 "
-            r"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 "
-            r"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 '.+' "
-            r"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 "
-            r"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' "
-            r"statement", r".*: warning: empty body in an if-statement",
-            r".*: warning: suggest braces around empty body in an 'else' "
-            r"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 "
-            r"of '.+'",
-            r".*: warning: suggest parentheses around comparison in operand "
-            r"of '.+'",
-            r".*: warning: logical not is only applied to the left hand "
-            r"side of this comparison",
-            r".*: warning: using the result of an assignment as a condition "
-            r"without parentheses",
-            r".*: warning: .+ has lower precedence than .+ be evaluated "
-            r"first .+Wparentheses",
-            r".*: warning: suggest parentheses around '.+?' .+ '.+?'",
-            r".*: warning: suggest parentheses around assignment used as "
-            r"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 '.+' "
-            r"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':
-            'C/C++',
-        'severity':
-            Severity.MEDIUM,
-        'description':
-            'Null pointer',
-        'patterns': [
-            r".*: warning: Dereference of null pointer",
-            r".*: warning: Called .+ pointer is null",
-            r".*: warning: Forming reference to null pointer",
-            r".*: warning: Returning null reference",
-            r".*: warning: Null pointer passed as an argument to a 'nonnull' "
-            r"parameter",
-            r".*: warning: .+ results in a null pointer dereference",
-            r".*: warning: Access to .+ results in a dereference of a null "
-            r"pointer", r".*: warning: Null pointer argument in"
-        ]
-    },
-    {
-        'category':
-            'cont.',
-        'severity':
-            Severity.SKIP,
-        'description':
-            'skip, parameter name (without types) in function declaration',
-        'patterns': [
-            r".*: warning: parameter names \(without types\) in function "
-            r"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 "
-            r"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': 'Symbol redefined',
-        'patterns': [r".*: warning: "
-                     ".+"
-                     " 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 "
-            r"defined"
-        ]
-    },
-    {
-        'category':
-            'C/C++',
-        'severity':
-            Severity.MEDIUM,
-        'description':
-            'Pointer from integer without cast',
-        'patterns': [
-            r".*: warning: assignment makes pointer from integer without a "
-            r"cast"
-        ]
-    },
-    {
-        'category':
-            'C/C++',
-        'severity':
-            Severity.MEDIUM,
-        'description':
-            'Pointer from integer without cast',
-        'patterns': [
-            r".*: warning: passing argument [0-9]+ of '.+' makes pointer from "
-            r"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 "
-            r"cast"
-        ]
-    },
-    {
-        'category':
-            'C/C++',
-        'severity':
-            Severity.MEDIUM,
-        'description':
-            'Integer from pointer without cast',
-        'patterns': [
-            r".*: warning: passing argument [0-9]+ of '.+' makes integer from "
-            r"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 "
-            r"'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 "
-            r"'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.MEDIUM,
-        'option':
-            '-Wswitch-enum',
-        'description':
-            'Enum value not handled in switch',
-        'patterns': [
-            r".*: warning: .*enumeration value.* not handled in "
-            r"switch.+Wswitch"
-        ]
-    },
-    {
-        'category': 'C/C++',
-        'severity': Severity.MEDIUM,
-        'option': '-Wuser-defined-warnings',
-        'description': 'User defined warnings',
-        'patterns': [r".*: warning: .* \[-Wuser-defined-warnings\]$"]
-    },
-    {
-        'category':
-            'aapt',
-        'severity':
-            Severity.MEDIUM,
-        'description':
-            'aapt: No default translation',
-        'patterns': [
-            r".*: warning: string '.+' has no default translation in .*"
-        ]
-    },
-    {
-        'category':
-            'aapt',
-        'severity':
-            Severity.MEDIUM,
-        'description':
-            'aapt: Missing default or required localization',
-        'patterns': [
-            r".*: warning: \*\*\*\* string '.+' has no default or required "
-            r"localization for '.+' in .+"
-        ]
-    },
-    {
-        'category':
-            'aapt',
-        'severity':
-            Severity.MEDIUM,
-        'description':
-            'aapt: String marked untranslatable, but translation exists',
-        'patterns': [
-            r".*: warning: string '.+' in .* marked untranslatable but exists "
-            r"in locale '??_??'"
-        ]
-    },
-    {
-        'category': 'aapt',
-        'severity': Severity.MEDIUM,
-        'description': 'aapt: empty span in string',
-        'patterns': [r".*: warning: empty '.+' span found in text '.+"]
-    },
-    {
-        '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 "
-            r"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,
-        'option':
-            '-Warray-bounds',
-        'description':
-            'Array subscript out of bounds',
-        'patterns': [
-            r".*: warning: array subscript is above array bounds",
-            r".*: warning: Array subscript is undefined",
-            r".*: warning: array subscript is below array bounds"
-        ]
-    },
-    {
-        '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 "
-            r"'noreturn'"
-        ]
-    },
-    # pylint:disable=anomalous-backslash-in-string
-    # TODO(chh): fix the backslash pylint warning.
-    {
-        'category':
-            'gcc',
-        'severity':
-            Severity.MEDIUM,
-        'description':
-            'Invalid option for C file',
-        'patterns': [
-            r".*: warning: command line option "
-            ".+"
-            " is valid for C\+\+\/ObjC\+\+ but not for C"
-        ]
-    },
-    {
-        '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 "
-            r"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 "
-            r"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 "
-            r".+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, "
-            r"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 comment"]
-    },
-    # Warning "value stored is never read" could be from clang-tidy or clang
-    # static analyzer.
-    {
-        'category':
-            'C/C++',
-        'severity':
-            Severity.ANALYZER,
-        'description':
-            'clang-analyzer Value stored is never read',
-        'patterns': [
-            r".*: warning: Value stored to .+ is never "
-            r"read.*clang-analyzer-deadcode.DeadStores"
-        ]
-    },
-    {
-        'category': 'C/C++',
-        'severity': Severity.LOW,
-        'description': 'Value stored is never read',
-        'patterns': [r".*: warning: Value stored to .+ is never read"]
-    },
-    {
-        '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 "
-            r"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"
-        ]
-    },
-    {
-        '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 "
-            r"constant"
-        ]
-    },
-    {
-        'category':
-            'C/C++',
-        'severity':
-            Severity.MEDIUM,
-        'description':
-            'Implicit conversion changes value',
-        'patterns': [
-            r".*: warning: implicit conversion .* changes value from .* to "
-            r".*-conversion"
-        ]
-    },
-    {
-        '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 "
-            r"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 "
-            r"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 "
-            r".+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 "
-            r"(arithmetic|subtraction)",
-            r".*: warning: arithmetic on .+ to void is a GNU "
-            r"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 "
-            r"in the copy constructor"
-        ]
-    },
-    {
-        'category':
-            'C/C++',
-        'severity':
-            Severity.MEDIUM,
-        'description':
-            'VLA has zero or negative size',
-        'patterns': [
-            r".*: warning: Declared variable-length array \(VLA\) has .+ size"
-        ]
-    },
-    {
-        '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 "
-            r"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 "
-            r"declaration"
-        ]
-    },
-    {
-        'category': 'C/C++',
-        'severity': Severity.LOW,
-        'option': '-Wduplicate-decl-specifier',
-        'description': 'Duplicate declaration specifier',
-        'patterns': [r".*: warning: duplicate '.+' declaration specifier"]
-    },
-    {
-        'category': 'logtags',
-        'severity': Severity.LOW,
-        'description': 'Duplicate logtag',
-        'patterns': [r".*: warning: tag \".+\" \(.+\) duplicated in .+"]
-    },
-    {
-        'category':
-            'logtags',
-        'severity':
-            Severity.LOW,
-        'option':
-            'typedef-redefinition',
-        'description':
-            'Typedef redefinition',
-        'patterns': [
-            r".*: warning: redefinition of typedef '.+' is a C11 feature"
-        ]
-    },
-    {
-        'category':
-            'logtags',
-        'severity':
-            Severity.LOW,
-        'option':
-            'gnu-designator',
-        'description':
-            'GNU old-style field designator',
-        'patterns': [
-            r".*: warning: use of GNU old-style field designator extension"
-        ]
-    },
-    {
-        'category': 'logtags',
-        'severity': Severity.LOW,
-        'option': 'missing-field-initializers',
-        'description': 'Missing field initializers',
-        'patterns': [r".*: warning: missing field '.+' initializer"]
-    },
-    {
-        'category':
-            'logtags',
-        'severity':
-            Severity.LOW,
-        'option':
-            'missing-braces',
-        'description':
-            'Missing braces',
-        'patterns': [
-            r".*: warning: suggest braces around initialization of",
-            r".*: warning: too many braces around scalar initializer "
-            r".+Wmany-braces-around-scalar-init",
-            r".*: warning: braces around scalar initializer"
-        ]
-    },
-    {
-        'category':
-            'logtags',
-        'severity':
-            Severity.LOW,
-        'option':
-            'sign-compare',
-        'description':
-            'Comparison of integers of different signs',
-        'patterns': [
-            r".*: warning: comparison of integers of different "
-            r"signs.+sign-compare"
-        ]
-    },
-    {
-        'category': 'logtags',
-        'severity': Severity.LOW,
-        'option': 'dangling-else',
-        'description': 'Add braces to avoid dangling else',
-        'patterns': [
-            r".*: warning: add explicit braces to avoid dangling else"
-        ]
-    },
-    {
-        'category':
-            'logtags',
-        'severity':
-            Severity.LOW,
-        'option':
-            'initializer-overrides',
-        'description':
-            'Initializer overrides prior initialization',
-        'patterns': [
-            r".*: warning: initializer overrides prior initialization of this "
-            r"subobject"
-        ]
-    },
-    {
-        'category': 'logtags',
-        'severity': Severity.LOW,
-        'option': 'self-assign',
-        'description': 'Assigning value to self',
-        'patterns': [
-            r".*: warning: explicitly assigning value of .+ to itself"
-        ]
-    },
-    {
-        'category':
-            'logtags',
-        'severity':
-            Severity.LOW,
-        'option':
-            'gnu-variable-sized-type-not-at-end',
-        'description':
-            'GNU extension, variable sized type not at end',
-        'patterns': [
-            r".*: warning: field '.+' with variable sized type '.+' not at "
-            r"the end of a struct or class"
-        ]
-    },
-    {
-        'category':
-            'logtags',
-        'severity':
-            Severity.LOW,
-        'option':
-            'tautological-constant-out-of-range-compare',
-        'description':
-            'Comparison of constant is always false/true',
-        'patterns': [
-            r".*: comparison of .+ is always "
-            r".+Wtautological-constant-out-of-range-compare"
-        ]
-    },
-    {
-        'category': 'logtags',
-        'severity': Severity.LOW,
-        'option': 'overloaded-virtual',
-        'description': 'Hides overloaded virtual function',
-        'patterns': [r".*: '.+' hides overloaded virtual function"]
-    },
-    {
-        'category':
-            'logtags',
-        'severity':
-            Severity.LOW,
-        'option':
-            'incompatible-pointer-types',
-        'description':
-            'Incompatible pointer types',
-        'patterns': [
-            r".*: warning: incompatible pointer types "
-            r".+Wincompatible-pointer-types"
-        ]
-    },
-    {
-        'category':
-            'logtags',
-        'severity':
-            Severity.LOW,
-        'option':
-            'asm-operand-widths',
-        'description':
-            'ASM value size does not match register size',
-        'patterns': [
-            r".*: warning: value size does not match register size "
-            r"specified by the constraint and modifier"
-        ]
-    },
-    {
-        '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 "
-            r".+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 "
-            r"is .+ type .+Wabsolute-value",
-            r".*: warning: absolute value function '.+' given .+ which may "
-            r"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 "
-            r"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 "
-            r"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 .+ "
-            r"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':
-            'Undefined result',
-        'patterns': [
-            r".*: warning: The result of .+ is undefined",
-            r".*: warning: passing an object that .+ has undefined behavior "
-            r"\[-Wvarargs\]",
-            r".*: warning: 'this' pointer cannot be null in well-defined "
-            r"C\+\+ code;",
-            r".*: warning: shifting a negative signed value is undefined"
-        ]
-    },
-    {
-        'category': 'C/C++',
-        'severity': Severity.MEDIUM,
-        'description': 'Division by zero',
-        'patterns': [r".*: warning: Division by zero"]
-    },
-    {
-        '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: .+ is a garbage value",
-            r".*: warning: Function call argument is an uninitialized value",
-            r".*: warning: Undefined or garbage value returned to caller",
-            r".*: warning: Called .+ pointer is.+uninitialized",
-            # note that the below matches a typo in compiler message
-            r".*: warning: Called .+ pointer is.+uninitalized",
-            r".*: warning: Use of zero-allocated memory",
-            r".*: warning: Dereference of undefined pointer value",
-            r".*: warning: Passed-by-value .+ contains uninitialized data",
-            r".*: warning: Branch condition evaluates to a garbage value",
-            r".*: warning: The .+ of .+ is an uninitialized value.",
-            r".*: warning: .+ is used uninitialized whenever "
-            r".+sometimes-uninitialized",
-            r".*: warning: Assigned value is garbage or undefined"
-        ]
-    },
-    {
-        'category':
-            'C/C++',
-        'severity':
-            Severity.MEDIUM,
-        'description':
-            'Result of malloc type incompatible with sizeof operand type',
-        'patterns': [
-            r".*: warning: Result of '.+' is converted to .+ incompatible "
-            r"with sizeof operand type"
-        ]
-    },
-    {
-        '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,
-        'description':
-            'Allocation size of 0 byte',
-        'patterns': [
-            r".*: warning: Call to .+ has an allocation size of 0 byte"
-        ]
-    },
-    {
-        'category':
-            'C/C++',
-        'severity':
-            Severity.MEDIUM,
-        'description':
-            'Result of malloc type incompatible with sizeof operand type',
-        'patterns': [
-            r".*: warning: Result of '.+' is converted to .+ incompatible "
-            r"with sizeof operand 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 "
-            r"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 "
-            r"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 "
-            r"as a .+mismatched-tags",
-            r".*: warning: .+ was previously declared as a .+mismatched-tags"
-        ]
-    },
-    {
-        'category': 'FindEmulator',
-        'severity': Severity.HARMLESS,
-        'description': 'FindEmulator: No such file or directory',
-        'patterns': [
-            r".*: warning: FindEmulator: .* No such file or directory"
-        ]
-    },
-    {
-        'category':
-            'google_tests',
-        'severity':
-            Severity.HARMLESS,
-        'description':
-            'google_tests: unknown installed file',
-        'patterns': [
-            r".*: warning: .*_tests: Unknown installed file for module"
-        ]
-    },
-    {
-        'category': 'make',
-        'severity': Severity.HARMLESS,
-        'description': 'unusual tags debug eng',
-        'patterns': [r".*: warning: .*: unusual tags debug eng"]
-    },
-
-    # these next ones are to deal with formatting problems resulting from the
-    # log being mixed up by 'make -j'
-    {
-        'category': 'C/C++',
-        'severity': Severity.SKIP,
-        'description': 'skip, ,',
-        'patterns': [r".*: warning: ,$"]
-    },
-    {
-        'category': 'C/C++',
-        'severity': Severity.SKIP,
-        'description': 'skip,',
-        'patterns': [r".*: warning: $"]
-    },
-    {
-        'category': 'C/C++',
-        'severity': Severity.SKIP,
-        'description': 'skip, In file included from ...',
-        'patterns': [r".*: warning: In file included from .+,"]
-    },
-
-    # warnings from clang-tidy
-    group_tidy_warn_pattern('android'),
-    simple_tidy_warn_pattern('bugprone-argument-comment'),
-    simple_tidy_warn_pattern('bugprone-copy-constructor-init'),
-    simple_tidy_warn_pattern('bugprone-fold-init-type'),
-    simple_tidy_warn_pattern('bugprone-forward-declaration-namespace'),
-    simple_tidy_warn_pattern('bugprone-forwarding-reference-overload'),
-    simple_tidy_warn_pattern('bugprone-inaccurate-erase'),
-    simple_tidy_warn_pattern('bugprone-incorrect-roundings'),
-    simple_tidy_warn_pattern('bugprone-integer-division'),
-    simple_tidy_warn_pattern('bugprone-lambda-function-name'),
-    simple_tidy_warn_pattern('bugprone-macro-parentheses'),
-    simple_tidy_warn_pattern('bugprone-misplaced-widening-cast'),
-    simple_tidy_warn_pattern('bugprone-move-forwarding-reference'),
-    simple_tidy_warn_pattern('bugprone-sizeof-expression'),
-    simple_tidy_warn_pattern('bugprone-string-constructor'),
-    simple_tidy_warn_pattern('bugprone-string-integer-assignment'),
-    simple_tidy_warn_pattern('bugprone-suspicious-enum-usage'),
-    simple_tidy_warn_pattern('bugprone-suspicious-missing-comma'),
-    simple_tidy_warn_pattern('bugprone-suspicious-string-compare'),
-    simple_tidy_warn_pattern('bugprone-suspicious-semicolon'),
-    simple_tidy_warn_pattern('bugprone-undefined-memory-manipulation'),
-    simple_tidy_warn_pattern('bugprone-unused-raii'),
-    simple_tidy_warn_pattern('bugprone-use-after-move'),
-    group_tidy_warn_pattern('bugprone'),
-    group_tidy_warn_pattern('cert'),
-    group_tidy_warn_pattern('clang-diagnostic'),
-    group_tidy_warn_pattern('cppcoreguidelines'),
-    group_tidy_warn_pattern('llvm'),
-    simple_tidy_warn_pattern('google-default-arguments'),
-    simple_tidy_warn_pattern('google-runtime-int'),
-    simple_tidy_warn_pattern('google-runtime-operator'),
-    simple_tidy_warn_pattern('google-runtime-references'),
-    group_tidy_warn_pattern('google-build'),
-    group_tidy_warn_pattern('google-explicit'),
-    group_tidy_warn_pattern('google-redability'),
-    group_tidy_warn_pattern('google-global'),
-    group_tidy_warn_pattern('google-redability'),
-    group_tidy_warn_pattern('google-redability'),
-    group_tidy_warn_pattern('google'),
-    simple_tidy_warn_pattern('hicpp-explicit-conversions'),
-    simple_tidy_warn_pattern('hicpp-function-size'),
-    simple_tidy_warn_pattern('hicpp-invalid-access-moved'),
-    simple_tidy_warn_pattern('hicpp-member-init'),
-    simple_tidy_warn_pattern('hicpp-delete-operators'),
-    simple_tidy_warn_pattern('hicpp-special-member-functions'),
-    simple_tidy_warn_pattern('hicpp-use-equals-default'),
-    simple_tidy_warn_pattern('hicpp-use-equals-delete'),
-    simple_tidy_warn_pattern('hicpp-no-assembler'),
-    simple_tidy_warn_pattern('hicpp-noexcept-move'),
-    simple_tidy_warn_pattern('hicpp-use-override'),
-    group_tidy_warn_pattern('hicpp'),
-    group_tidy_warn_pattern('modernize'),
-    group_tidy_warn_pattern('misc'),
-    simple_tidy_warn_pattern('performance-faster-string-find'),
-    simple_tidy_warn_pattern('performance-for-range-copy'),
-    simple_tidy_warn_pattern('performance-implicit-cast-in-loop'),
-    simple_tidy_warn_pattern('performance-inefficient-string-concatenation'),
-    simple_tidy_warn_pattern('performance-type-promotion-in-math-fn'),
-    simple_tidy_warn_pattern('performance-unnecessary-copy-initialization'),
-    simple_tidy_warn_pattern('performance-unnecessary-value-param'),
-    group_tidy_warn_pattern('performance'),
-    group_tidy_warn_pattern('readability'),
-
-    # warnings from clang-tidy's clang-analyzer checks
-    {
-        'category':
-            'C/C++',
-        'severity':
-            Severity.ANALYZER,
-        'description':
-            'clang-analyzer Unreachable code',
-        'patterns': [
-            r".*: warning: This statement is never executed.*UnreachableCode"
-        ]
-    },
-    {
-        'category':
-            'C/C++',
-        'severity':
-            Severity.ANALYZER,
-        'description':
-            'clang-analyzer Size of malloc may overflow',
-        'patterns': [
-            r".*: warning: .* size of .* may overflow .*MallocOverflow"
-        ]
-    },
-    {
-        'category': 'C/C++',
-        'severity': Severity.ANALYZER,
-        'description': 'clang-analyzer Stream pointer might be NULL',
-        'patterns': [
-            r".*: warning: Stream pointer might be NULL .*unix.Stream"
-        ]
-    },
-    {
-        'category': 'C/C++',
-        'severity': Severity.ANALYZER,
-        'description': 'clang-analyzer Opened file never closed',
-        'patterns': [r".*: warning: Opened File never closed.*unix.Stream"]
-    },
-    {
-        'category':
-            'C/C++',
-        'severity':
-            Severity.ANALYZER,
-        'description':
-            'clang-analyzer sozeof() on a pointer type',
-        'patterns': [
-            r".*: warning: .*calls sizeof.* on a pointer type.*SizeofPtr"
-        ]
-    },
-    {
-        'category':
-            'C/C++',
-        'severity':
-            Severity.ANALYZER,
-        'description':
-            'clang-analyzer Pointer arithmetic on non-array variables',
-        'patterns': [
-            r".*: warning: Pointer arithmetic on non-array variables "
-            r".*PointerArithm"
-        ]
-    },
-    {
-        'category': 'C/C++',
-        'severity': Severity.ANALYZER,
-        'description':
-            'clang-analyzer Subtraction of pointers of different memory '
-            'chunks',
-        'patterns': [r".*: warning: Subtraction of two pointers .*PointerSub"]
-    },
-    {
-        'category':
-            'C/C++',
-        'severity':
-            Severity.ANALYZER,
-        'description':
-            'clang-analyzer Access out-of-bound array element',
-        'patterns': [
-            r".*: warning: Access out-of-bound array element .*ArrayBound"
-        ]
-    },
-    {
-        'category': 'C/C++',
-        'severity': Severity.ANALYZER,
-        'description': 'clang-analyzer Out of bound memory access',
-        'patterns': [r".*: warning: Out of bound memory access .*ArrayBoundV2"]
-    },
-    {
-        'category':
-            'C/C++',
-        'severity':
-            Severity.ANALYZER,
-        'description':
-            'clang-analyzer Possible lock order reversal',
-        'patterns': [
-            r".*: warning: .* Possible lock order reversal.*PthreadLock"
-        ]
-    },
-    {
-        'category':
-            'C/C++',
-        'severity':
-            Severity.ANALYZER,
-        'description':
-            'clang-analyzer Argument is a pointer to uninitialized value',
-        'patterns': [
-            r".*: warning: .* argument is a pointer to uninitialized value "
-            r".*CallAndMessage"
-        ]
-    },
-    {
-        'category':
-            'C/C++',
-        'severity':
-            Severity.ANALYZER,
-        'description':
-            'clang-analyzer cast to struct',
-        'patterns': [
-            r".*: warning: Casting a non-structure type to a structure type "
-            r".*CastToStruct"
-        ]
-    },
-    {
-        'category': 'C/C++',
-        'severity': Severity.ANALYZER,
-        'description': 'clang-analyzer call path problems',
-        'patterns': [r".*: warning: Call Path : .+"]
-    },
-    {
-        'category': 'C/C++',
-        'severity': Severity.ANALYZER,
-        'description': 'clang-analyzer excessive padding',
-        'patterns': [r".*: warning: Excessive padding in '.*'"]
-    },
-    {
-        'category': 'C/C++',
-        'severity': Severity.ANALYZER,
-        'description': 'clang-analyzer other',
-        'patterns': [r".*: .+\[clang-analyzer-.+\]$", r".*: Call Path : .+$"]
-    },
-
-    # catch-all for warnings this script doesn't know about yet
-    {
-        'category': 'C/C++',
-        'severity': Severity.UNKNOWN,
-        'description': 'Unclassified/unrecognized warnings',
-        'patterns': [r".*: warning: .+"]
-    },
-]
-
-
 def project_name_and_pattern(name, pattern):
   return [name, '(^|.*/)' + pattern + '/.*: warning:']
 
diff --git a/clang_tidy/clang_tidy_warn_patterns.py b/clang_tidy/clang_tidy_warn_patterns.py
new file mode 100755
index 00000000..68ddf50f
--- /dev/null
+++ b/clang_tidy/clang_tidy_warn_patterns.py
@@ -0,0 +1,2576 @@
+#!/usr/bin/env python2
+# -*- coding: utf-8 -*-
+# Copyright 2018 The Chromium OS Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+"""Clang_Tidy_Warn Warning Patterns data
+
+This file stores the warn_patterns dictionary used in clang_tidy_warn.py and
+its dependencies. It has been put into this file for easier navigation and
+understanding of the original file.
+"""
+
+
+class Severity(object):
+  """Severity levels and attributes."""
+  # numbered by dump order
+  FIXMENOW = 0
+  HIGH = 1
+  MEDIUM = 2
+  LOW = 3
+  ANALYZER = 4
+  TIDY = 5
+  HARMLESS = 6
+  UNKNOWN = 7
+  SKIP = 8
+  range = range(SKIP + 1)
+  attributes = [
+      # pylint:disable=bad-whitespace
+      ['fuchsia', 'FixNow', 'Critical warnings, fix me now'],
+      ['red', 'High', 'High severity warnings'],
+      ['orange', 'Medium', 'Medium severity warnings'],
+      ['yellow', 'Low', 'Low severity warnings'],
+      ['hotpink', 'Analyzer', 'Clang-Analyzer warnings'],
+      ['peachpuff', 'Tidy', 'Clang-Tidy warnings'],
+      ['limegreen', 'Harmless', 'Harmless warnings'],
+      ['lightblue', 'Unknown', 'Unknown warnings'],
+      ['grey', 'Unhandled', 'Unhandled warnings']
+  ]
+  colors = [a[0] for a in attributes]
+  column_headers = [a[1] for a in attributes]
+  headers = [a[2] for a in attributes]
+
+
+def tidy_warn_pattern(description, pattern):
+  return {
+      'category': 'C/C++',
+      'severity': Severity.TIDY,
+      'description': 'clang-tidy ' + description,
+      'patterns': [r'.*: .+\[' + pattern + r'\]$']
+  }
+
+
+def simple_tidy_warn_pattern(description):
+  return tidy_warn_pattern(description, description)
+
+
+def group_tidy_warn_pattern(description):
+  return tidy_warn_pattern(description, description + r'-.+')
+
+
+warn_patterns = [
+    {
+        'category': 'C/C++',
+        'severity': Severity.ANALYZER,
+        'description': 'clang-analyzer Security warning',
+        'patterns': [r".*: warning: .+\[clang-analyzer-security.*\]"]
+    },
+    {
+        'category':
+            'make',
+        'severity':
+            Severity.MEDIUM,
+        'description':
+            'make: overriding commands/ignoring old commands',
+        'patterns': [
+            r".*: warning: overriding commands for target .+",
+            r".*: warning: ignoring old commands for target .+"
+        ]
+    },
+    {
+        'category': 'make',
+        'severity': Severity.HIGH,
+        'description': 'make: LOCAL_CLANG is false',
+        'patterns': [r".*: warning: LOCAL_CLANG is set to false"]
+    },
+    {
+        'category':
+            'make',
+        'severity':
+            Severity.HIGH,
+        'description':
+            'SDK App using platform shared library',
+        'patterns': [
+            r".*: warning: .+ \(.*app:sdk.*\) should not link to .+ "
+            r"\(native:platform\)"
+        ]
+    },
+    {
+        'category':
+            'make',
+        'severity':
+            Severity.HIGH,
+        'description':
+            'System module linking to a vendor module',
+        'patterns': [
+            r".*: warning: .+ \(.+\) should not link to .+ \(partition:.+\)"
+        ]
+    },
+    {
+        'category': 'make',
+        'severity': Severity.MEDIUM,
+        'description': 'Invalid SDK/NDK linking',
+        'patterns': [r".*: warning: .+ \(.+\) should not link to .+ \(.+\)"]
+    },
+    {
+        'category': 'make',
+        'severity': Severity.MEDIUM,
+        'description': 'Duplicate header copy',
+        'patterns': [r".*: warning: Duplicate header copy: .+"]
+    },
+    {
+        'category':
+            'C/C++',
+        'severity':
+            Severity.HIGH,
+        '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 "
+            r"data type",
+            r".*: warning: comparison of unsigned .*expression .+ is always "
+            r"true",
+            r".*: warning: comparison of unsigned .*expression .+ is always "
+            r"false"
+        ]
+    },
+    {
+        'category':
+            'C/C++',
+        'severity':
+            Severity.HIGH,
+        'description':
+            'Potential leak of memory, bad free, use after free',
+        'patterns': [
+            r".*: warning: Potential leak of memory",
+            r".*: warning: Potential memory leak",
+            r".*: warning: Memory allocated by alloca\(\) should not be "
+            r"deallocated",
+            r".*: warning: Memory allocated by .+ should be deallocated by "
+            r".+ not .+",
+            r".*: warning: 'delete' applied to a pointer that was allocated",
+            r".*: warning: Use of memory after it is freed",
+            r".*: warning: Argument to .+ is the address of .+ variable",
+            r".*: warning: Argument to free\(\) is offset by .+ of memory "
+            r"allocated by", r".*: warning: Attempt to .+ released memory"
+        ]
+    },
+    {
+        'category':
+            'C/C++',
+        'severity':
+            Severity.HIGH,
+        'description':
+            'Use transient memory for control value',
+        'patterns': [
+            r".*: warning: .+Using such transient memory for the control "
+            r"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 "
+            r"reference"
+        ]
+    },
+    {
+        'category':
+            'C/C++',
+        'severity':
+            Severity.HIGH,
+        'description':
+            'Problem with vfork',
+        'patterns': [
+            r".*: warning: This .+ is prohibited after a successful vfork",
+            r".*: warning: Call to function '.+' is insecure "
+        ]
+    },
+    {
+        '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 "
+            r"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 "
+            r"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 "
+            r"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 "
+            r"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':
+            '-Wformat',
+        'description':
+            'Format string does not match arguments',
+        'patterns': [
+            r".*: warning: format '.+' expects type '.+', but argument "
+            r"[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 "
+            r".+Wformat",
+            r".*: warning: format specifies type .+ but the argument has "
+            r".*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 "
+            r"expression"
+        ]
+    },
+    {
+        'category':
+            'libpng',
+        'severity':
+            Severity.MEDIUM,
+        'description':
+            'libpng: zero area',
+        'patterns': [
+            r".*libpng warning: Ignoring attempt to set cHRM RGB triangle "
+            r"with zero area"
+        ]
+    },
+    {
+        'category': 'aapt',
+        'severity': Severity.MEDIUM,
+        'description': 'aapt: no comment for public symbol',
+        'patterns': [r".*: warning: No comment for public symbol .+"]
+    },
+    {
+        '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 "
+            r"qualifiers from pointer target type",
+            r".*: warning: assignment discards qualifiers from pointer "
+            r"target type",
+            r".*: warning: passing .+ to parameter of type .+ discards "
+            r"qualifiers",
+            r".*: warning: assigning to .+ from .+ discards qualifiers",
+            r".*: warning: initializing .+ discards qualifiers "
+            r".+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 "
+            r".+ignored-attributes"
+        ]
+    },
+    {
+        'category':
+            'C/C++',
+        'severity':
+            Severity.MEDIUM,
+        'option':
+            '-Wvisibility',
+        'description':
+            'Visibility problem',
+        'patterns': [
+            r".*: warning: declaration of '.+' will not be visible outside "
+            r"of this function"
+        ]
+    },
+    {
+        'category':
+            'C/C++',
+        'severity':
+            Severity.MEDIUM,
+        'option':
+            '-Wattributes',
+        'description':
+            'Visibility mismatch',
+        'patterns': [
+            r".*: warning: '.+' declared with greater visibility than the "
+            r"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 "
+            r"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 "
+            r"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 '.+' "
+            r"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 "
+            r"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' "
+            r"statement", r".*: warning: empty body in an if-statement",
+            r".*: warning: suggest braces around empty body in an 'else' "
+            r"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 "
+            r"of '.+'",
+            r".*: warning: suggest parentheses around comparison in operand "
+            r"of '.+'",
+            r".*: warning: logical not is only applied to the left hand "
+            r"side of this comparison",
+            r".*: warning: using the result of an assignment as a condition "
+            r"without parentheses",
+            r".*: warning: .+ has lower precedence than .+ be evaluated "
+            r"first .+Wparentheses",
+            r".*: warning: suggest parentheses around '.+?' .+ '.+?'",
+            r".*: warning: suggest parentheses around assignment used as "
+            r"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 '.+' "
+            r"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':
+            'C/C++',
+        'severity':
+            Severity.MEDIUM,
+        'description':
+            'Null pointer',
+        'patterns': [
+            r".*: warning: Dereference of null pointer",
+            r".*: warning: Called .+ pointer is null",
+            r".*: warning: Forming reference to null pointer",
+            r".*: warning: Returning null reference",
+            r".*: warning: Null pointer passed as an argument to a 'nonnull' "
+            r"parameter",
+            r".*: warning: .+ results in a null pointer dereference",
+            r".*: warning: Access to .+ results in a dereference of a null "
+            r"pointer", r".*: warning: Null pointer argument in"
+        ]
+    },
+    {
+        'category':
+            'cont.',
+        'severity':
+            Severity.SKIP,
+        'description':
+            'skip, parameter name (without types) in function declaration',
+        'patterns': [
+            r".*: warning: parameter names \(without types\) in function "
+            r"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 "
+            r"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': 'Symbol redefined',
+        'patterns': [r".*: warning: "
+                     ".+"
+                     " 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 "
+            r"defined"
+        ]
+    },
+    {
+        'category':
+            'C/C++',
+        'severity':
+            Severity.MEDIUM,
+        'description':
+            'Pointer from integer without cast',
+        'patterns': [
+            r".*: warning: assignment makes pointer from integer without a "
+            r"cast"
+        ]
+    },
+    {
+        'category':
+            'C/C++',
+        'severity':
+            Severity.MEDIUM,
+        'description':
+            'Pointer from integer without cast',
+        'patterns': [
+            r".*: warning: passing argument [0-9]+ of '.+' makes pointer from "
+            r"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 "
+            r"cast"
+        ]
+    },
+    {
+        'category':
+            'C/C++',
+        'severity':
+            Severity.MEDIUM,
+        'description':
+            'Integer from pointer without cast',
+        'patterns': [
+            r".*: warning: passing argument [0-9]+ of '.+' makes integer from "
+            r"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 "
+            r"'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 "
+            r"'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.MEDIUM,
+        'option':
+            '-Wswitch-enum',
+        'description':
+            'Enum value not handled in switch',
+        'patterns': [
+            r".*: warning: .*enumeration value.* not handled in "
+            r"switch.+Wswitch"
+        ]
+    },
+    {
+        'category': 'C/C++',
+        'severity': Severity.MEDIUM,
+        'option': '-Wuser-defined-warnings',
+        'description': 'User defined warnings',
+        'patterns': [r".*: warning: .* \[-Wuser-defined-warnings\]$"]
+    },
+    {
+        'category':
+            'aapt',
+        'severity':
+            Severity.MEDIUM,
+        'description':
+            'aapt: No default translation',
+        'patterns': [
+            r".*: warning: string '.+' has no default translation in .*"
+        ]
+    },
+    {
+        'category':
+            'aapt',
+        'severity':
+            Severity.MEDIUM,
+        'description':
+            'aapt: Missing default or required localization',
+        'patterns': [
+            r".*: warning: \*\*\*\* string '.+' has no default or required "
+            r"localization for '.+' in .+"
+        ]
+    },
+    {
+        'category':
+            'aapt',
+        'severity':
+            Severity.MEDIUM,
+        'description':
+            'aapt: String marked untranslatable, but translation exists',
+        'patterns': [
+            r".*: warning: string '.+' in .* marked untranslatable but exists "
+            r"in locale '??_??'"
+        ]
+    },
+    {
+        'category': 'aapt',
+        'severity': Severity.MEDIUM,
+        'description': 'aapt: empty span in string',
+        'patterns': [r".*: warning: empty '.+' span found in text '.+"]
+    },
+    {
+        '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 "
+            r"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,
+        'option':
+            '-Warray-bounds',
+        'description':
+            'Array subscript out of bounds',
+        'patterns': [
+            r".*: warning: array subscript is above array bounds",
+            r".*: warning: Array subscript is undefined",
+            r".*: warning: array subscript is below array bounds"
+        ]
+    },
+    {
+        '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 "
+            r"'noreturn'"
+        ]
+    },
+    # pylint:disable=anomalous-backslash-in-string
+    # TODO(chh): fix the backslash pylint warning.
+    {
+        'category':
+            'gcc',
+        'severity':
+            Severity.MEDIUM,
+        'description':
+            'Invalid option for C file',
+        'patterns': [
+            r".*: warning: command line option "
+            ".+"
+            " is valid for C\+\+\/ObjC\+\+ but not for C"
+        ]
+    },
+    {
+        '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 "
+            r"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 "
+            r"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 "
+            r".+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, "
+            r"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 comment"]
+    },
+    # Warning "value stored is never read" could be from clang-tidy or clang
+    # static analyzer.
+    {
+        'category':
+            'C/C++',
+        'severity':
+            Severity.ANALYZER,
+        'description':
+            'clang-analyzer Value stored is never read',
+        'patterns': [
+            r".*: warning: Value stored to .+ is never "
+            r"read.*clang-analyzer-deadcode.DeadStores"
+        ]
+    },
+    {
+        'category': 'C/C++',
+        'severity': Severity.LOW,
+        'description': 'Value stored is never read',
+        'patterns': [r".*: warning: Value stored to .+ is never read"]
+    },
+    {
+        '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 "
+            r"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"
+        ]
+    },
+    {
+        '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 "
+            r"constant"
+        ]
+    },
+    {
+        'category':
+            'C/C++',
+        'severity':
+            Severity.MEDIUM,
+        'description':
+            'Implicit conversion changes value',
+        'patterns': [
+            r".*: warning: implicit conversion .* changes value from .* to "
+            r".*-conversion"
+        ]
+    },
+    {
+        '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 "
+            r"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 "
+            r"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 "
+            r".+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 "
+            r"(arithmetic|subtraction)",
+            r".*: warning: arithmetic on .+ to void is a GNU "
+            r"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 "
+            r"in the copy constructor"
+        ]
+    },
+    {
+        'category':
+            'C/C++',
+        'severity':
+            Severity.MEDIUM,
+        'description':
+            'VLA has zero or negative size',
+        'patterns': [
+            r".*: warning: Declared variable-length array \(VLA\) has .+ size"
+        ]
+    },
+    {
+        '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 "
+            r"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 "
+            r"declaration"
+        ]
+    },
+    {
+        'category': 'C/C++',
+        'severity': Severity.LOW,
+        'option': '-Wduplicate-decl-specifier',
+        'description': 'Duplicate declaration specifier',
+        'patterns': [r".*: warning: duplicate '.+' declaration specifier"]
+    },
+    {
+        'category': 'logtags',
+        'severity': Severity.LOW,
+        'description': 'Duplicate logtag',
+        'patterns': [r".*: warning: tag \".+\" \(.+\) duplicated in .+"]
+    },
+    {
+        'category':
+            'logtags',
+        'severity':
+            Severity.LOW,
+        'option':
+            'typedef-redefinition',
+        'description':
+            'Typedef redefinition',
+        'patterns': [
+            r".*: warning: redefinition of typedef '.+' is a C11 feature"
+        ]
+    },
+    {
+        'category':
+            'logtags',
+        'severity':
+            Severity.LOW,
+        'option':
+            'gnu-designator',
+        'description':
+            'GNU old-style field designator',
+        'patterns': [
+            r".*: warning: use of GNU old-style field designator extension"
+        ]
+    },
+    {
+        'category': 'logtags',
+        'severity': Severity.LOW,
+        'option': 'missing-field-initializers',
+        'description': 'Missing field initializers',
+        'patterns': [r".*: warning: missing field '.+' initializer"]
+    },
+    {
+        'category':
+            'logtags',
+        'severity':
+            Severity.LOW,
+        'option':
+            'missing-braces',
+        'description':
+            'Missing braces',
+        'patterns': [
+            r".*: warning: suggest braces around initialization of",
+            r".*: warning: too many braces around scalar initializer "
+            r".+Wmany-braces-around-scalar-init",
+            r".*: warning: braces around scalar initializer"
+        ]
+    },
+    {
+        'category':
+            'logtags',
+        'severity':
+            Severity.LOW,
+        'option':
+            'sign-compare',
+        'description':
+            'Comparison of integers of different signs',
+        'patterns': [
+            r".*: warning: comparison of integers of different "
+            r"signs.+sign-compare"
+        ]
+    },
+    {
+        'category': 'logtags',
+        'severity': Severity.LOW,
+        'option': 'dangling-else',
+        'description': 'Add braces to avoid dangling else',
+        'patterns': [
+            r".*: warning: add explicit braces to avoid dangling else"
+        ]
+    },
+    {
+        'category':
+            'logtags',
+        'severity':
+            Severity.LOW,
+        'option':
+            'initializer-overrides',
+        'description':
+            'Initializer overrides prior initialization',
+        'patterns': [
+            r".*: warning: initializer overrides prior initialization of this "
+            r"subobject"
+        ]
+    },
+    {
+        'category': 'logtags',
+        'severity': Severity.LOW,
+        'option': 'self-assign',
+        'description': 'Assigning value to self',
+        'patterns': [
+            r".*: warning: explicitly assigning value of .+ to itself"
+        ]
+    },
+    {
+        'category':
+            'logtags',
+        'severity':
+            Severity.LOW,
+        'option':
+            'gnu-variable-sized-type-not-at-end',
+        'description':
+            'GNU extension, variable sized type not at end',
+        'patterns': [
+            r".*: warning: field '.+' with variable sized type '.+' not at "
+            r"the end of a struct or class"
+        ]
+    },
+    {
+        'category':
+            'logtags',
+        'severity':
+            Severity.LOW,
+        'option':
+            'tautological-constant-out-of-range-compare',
+        'description':
+            'Comparison of constant is always false/true',
+        'patterns': [
+            r".*: comparison of .+ is always "
+            r".+Wtautological-constant-out-of-range-compare"
+        ]
+    },
+    {
+        'category': 'logtags',
+        'severity': Severity.LOW,
+        'option': 'overloaded-virtual',
+        'description': 'Hides overloaded virtual function',
+        'patterns': [r".*: '.+' hides overloaded virtual function"]
+    },
+    {
+        'category':
+            'logtags',
+        'severity':
+            Severity.LOW,
+        'option':
+            'incompatible-pointer-types',
+        'description':
+            'Incompatible pointer types',
+        'patterns': [
+            r".*: warning: incompatible pointer types "
+            r".+Wincompatible-pointer-types"
+        ]
+    },
+    {
+        'category':
+            'logtags',
+        'severity':
+            Severity.LOW,
+        'option':
+            'asm-operand-widths',
+        'description':
+            'ASM value size does not match register size',
+        'patterns': [
+            r".*: warning: value size does not match register size "
+            r"specified by the constraint and modifier"
+        ]
+    },
+    {
+        '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 "
+            r".+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 "
+            r"is .+ type .+Wabsolute-value",
+            r".*: warning: absolute value function '.+' given .+ which may "
+            r"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 "
+            r"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 "
+            r"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 .+ "
+            r"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':
+            'Undefined result',
+        'patterns': [
+            r".*: warning: The result of .+ is undefined",
+            r".*: warning: passing an object that .+ has undefined behavior "
+            r"\[-Wvarargs\]",
+            r".*: warning: 'this' pointer cannot be null in well-defined "
+            r"C\+\+ code;",
+            r".*: warning: shifting a negative signed value is undefined"
+        ]
+    },
+    {
+        'category': 'C/C++',
+        'severity': Severity.MEDIUM,
+        'description': 'Division by zero',
+        'patterns': [r".*: warning: Division by zero"]
+    },
+    {
+        '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: .+ is a garbage value",
+            r".*: warning: Function call argument is an uninitialized value",
+            r".*: warning: Undefined or garbage value returned to caller",
+            r".*: warning: Called .+ pointer is.+uninitialized",
+            # note that the below matches a typo in compiler message
+            r".*: warning: Called .+ pointer is.+uninitalized",
+            r".*: warning: Use of zero-allocated memory",
+            r".*: warning: Dereference of undefined pointer value",
+            r".*: warning: Passed-by-value .+ contains uninitialized data",
+            r".*: warning: Branch condition evaluates to a garbage value",
+            r".*: warning: The .+ of .+ is an uninitialized value.",
+            r".*: warning: .+ is used uninitialized whenever "
+            r".+sometimes-uninitialized",
+            r".*: warning: Assigned value is garbage or undefined"
+        ]
+    },
+    {
+        'category':
+            'C/C++',
+        'severity':
+            Severity.MEDIUM,
+        'description':
+            'Result of malloc type incompatible with sizeof operand type',
+        'patterns': [
+            r".*: warning: Result of '.+' is converted to .+ incompatible "
+            r"with sizeof operand type"
+        ]
+    },
+    {
+        '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,
+        'description':
+            'Allocation size of 0 byte',
+        'patterns': [
+            r".*: warning: Call to .+ has an allocation size of 0 byte"
+        ]
+    },
+    {
+        'category':
+            'C/C++',
+        'severity':
+            Severity.MEDIUM,
+        'description':
+            'Result of malloc type incompatible with sizeof operand type',
+        'patterns': [
+            r".*: warning: Result of '.+' is converted to .+ incompatible "
+            r"with sizeof operand 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 "
+            r"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 "
+            r"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 "
+            r"as a .+mismatched-tags",
+            r".*: warning: .+ was previously declared as a .+mismatched-tags"
+        ]
+    },
+    {
+        'category': 'FindEmulator',
+        'severity': Severity.HARMLESS,
+        'description': 'FindEmulator: No such file or directory',
+        'patterns': [
+            r".*: warning: FindEmulator: .* No such file or directory"
+        ]
+    },
+    {
+        'category':
+            'google_tests',
+        'severity':
+            Severity.HARMLESS,
+        'description':
+            'google_tests: unknown installed file',
+        'patterns': [
+            r".*: warning: .*_tests: Unknown installed file for module"
+        ]
+    },
+    {
+        'category': 'make',
+        'severity': Severity.HARMLESS,
+        'description': 'unusual tags debug eng',
+        'patterns': [r".*: warning: .*: unusual tags debug eng"]
+    },
+
+    # these next ones are to deal with formatting problems resulting from the
+    # log being mixed up by 'make -j'
+    {
+        'category': 'C/C++',
+        'severity': Severity.SKIP,
+        'description': 'skip, ,',
+        'patterns': [r".*: warning: ,$"]
+    },
+    {
+        'category': 'C/C++',
+        'severity': Severity.SKIP,
+        'description': 'skip,',
+        'patterns': [r".*: warning: $"]
+    },
+    {
+        'category': 'C/C++',
+        'severity': Severity.SKIP,
+        'description': 'skip, In file included from ...',
+        'patterns': [r".*: warning: In file included from .+,"]
+    },
+
+    # warnings from clang-tidy
+    group_tidy_warn_pattern('android'),
+    simple_tidy_warn_pattern('bugprone-argument-comment'),
+    simple_tidy_warn_pattern('bugprone-copy-constructor-init'),
+    simple_tidy_warn_pattern('bugprone-fold-init-type'),
+    simple_tidy_warn_pattern('bugprone-forward-declaration-namespace'),
+    simple_tidy_warn_pattern('bugprone-forwarding-reference-overload'),
+    simple_tidy_warn_pattern('bugprone-inaccurate-erase'),
+    simple_tidy_warn_pattern('bugprone-incorrect-roundings'),
+    simple_tidy_warn_pattern('bugprone-integer-division'),
+    simple_tidy_warn_pattern('bugprone-lambda-function-name'),
+    simple_tidy_warn_pattern('bugprone-macro-parentheses'),
+    simple_tidy_warn_pattern('bugprone-misplaced-widening-cast'),
+    simple_tidy_warn_pattern('bugprone-move-forwarding-reference'),
+    simple_tidy_warn_pattern('bugprone-sizeof-expression'),
+    simple_tidy_warn_pattern('bugprone-string-constructor'),
+    simple_tidy_warn_pattern('bugprone-string-integer-assignment'),
+    simple_tidy_warn_pattern('bugprone-suspicious-enum-usage'),
+    simple_tidy_warn_pattern('bugprone-suspicious-missing-comma'),
+    simple_tidy_warn_pattern('bugprone-suspicious-string-compare'),
+    simple_tidy_warn_pattern('bugprone-suspicious-semicolon'),
+    simple_tidy_warn_pattern('bugprone-undefined-memory-manipulation'),
+    simple_tidy_warn_pattern('bugprone-unused-raii'),
+    simple_tidy_warn_pattern('bugprone-use-after-move'),
+    group_tidy_warn_pattern('bugprone'),
+    group_tidy_warn_pattern('cert'),
+    group_tidy_warn_pattern('clang-diagnostic'),
+    group_tidy_warn_pattern('cppcoreguidelines'),
+    group_tidy_warn_pattern('llvm'),
+    simple_tidy_warn_pattern('google-default-arguments'),
+    simple_tidy_warn_pattern('google-runtime-int'),
+    simple_tidy_warn_pattern('google-runtime-operator'),
+    simple_tidy_warn_pattern('google-runtime-references'),
+    group_tidy_warn_pattern('google-build'),
+    group_tidy_warn_pattern('google-explicit'),
+    group_tidy_warn_pattern('google-redability'),
+    group_tidy_warn_pattern('google-global'),
+    group_tidy_warn_pattern('google-redability'),
+    group_tidy_warn_pattern('google-redability'),
+    group_tidy_warn_pattern('google'),
+    simple_tidy_warn_pattern('hicpp-explicit-conversions'),
+    simple_tidy_warn_pattern('hicpp-function-size'),
+    simple_tidy_warn_pattern('hicpp-invalid-access-moved'),
+    simple_tidy_warn_pattern('hicpp-member-init'),
+    simple_tidy_warn_pattern('hicpp-delete-operators'),
+    simple_tidy_warn_pattern('hicpp-special-member-functions'),
+    simple_tidy_warn_pattern('hicpp-use-equals-default'),
+    simple_tidy_warn_pattern('hicpp-use-equals-delete'),
+    simple_tidy_warn_pattern('hicpp-no-assembler'),
+    simple_tidy_warn_pattern('hicpp-noexcept-move'),
+    simple_tidy_warn_pattern('hicpp-use-override'),
+    group_tidy_warn_pattern('hicpp'),
+    group_tidy_warn_pattern('modernize'),
+    group_tidy_warn_pattern('misc'),
+    simple_tidy_warn_pattern('performance-faster-string-find'),
+    simple_tidy_warn_pattern('performance-for-range-copy'),
+    simple_tidy_warn_pattern('performance-implicit-cast-in-loop'),
+    simple_tidy_warn_pattern('performance-inefficient-string-concatenation'),
+    simple_tidy_warn_pattern('performance-type-promotion-in-math-fn'),
+    simple_tidy_warn_pattern('performance-unnecessary-copy-initialization'),
+    simple_tidy_warn_pattern('performance-unnecessary-value-param'),
+    group_tidy_warn_pattern('performance'),
+    group_tidy_warn_pattern('readability'),
+
+    # warnings from clang-tidy's clang-analyzer checks
+    {
+        'category':
+            'C/C++',
+        'severity':
+            Severity.ANALYZER,
+        'description':
+            'clang-analyzer Unreachable code',
+        'patterns': [
+            r".*: warning: This statement is never executed.*UnreachableCode"
+        ]
+    },
+    {
+        'category':
+            'C/C++',
+        'severity':
+            Severity.ANALYZER,
+        'description':
+            'clang-analyzer Size of malloc may overflow',
+        'patterns': [
+            r".*: warning: .* size of .* may overflow .*MallocOverflow"
+        ]
+    },
+    {
+        'category': 'C/C++',
+        'severity': Severity.ANALYZER,
+        'description': 'clang-analyzer Stream pointer might be NULL',
+        'patterns': [
+            r".*: warning: Stream pointer might be NULL .*unix.Stream"
+        ]
+    },
+    {
+        'category': 'C/C++',
+        'severity': Severity.ANALYZER,
+        'description': 'clang-analyzer Opened file never closed',
+        'patterns': [r".*: warning: Opened File never closed.*unix.Stream"]
+    },
+    {
+        'category':
+            'C/C++',
+        'severity':
+            Severity.ANALYZER,
+        'description':
+            'clang-analyzer sozeof() on a pointer type',
+        'patterns': [
+            r".*: warning: .*calls sizeof.* on a pointer type.*SizeofPtr"
+        ]
+    },
+    {
+        'category':
+            'C/C++',
+        'severity':
+            Severity.ANALYZER,
+        'description':
+            'clang-analyzer Pointer arithmetic on non-array variables',
+        'patterns': [
+            r".*: warning: Pointer arithmetic on non-array variables "
+            r".*PointerArithm"
+        ]
+    },
+    {
+        'category': 'C/C++',
+        'severity': Severity.ANALYZER,
+        'description':
+            'clang-analyzer Subtraction of pointers of different memory '
+            'chunks',
+        'patterns': [r".*: warning: Subtraction of two pointers .*PointerSub"]
+    },
+    {
+        'category':
+            'C/C++',
+        'severity':
+            Severity.ANALYZER,
+        'description':
+            'clang-analyzer Access out-of-bound array element',
+        'patterns': [
+            r".*: warning: Access out-of-bound array element .*ArrayBound"
+        ]
+    },
+    {
+        'category': 'C/C++',
+        'severity': Severity.ANALYZER,
+        'description': 'clang-analyzer Out of bound memory access',
+        'patterns': [r".*: warning: Out of bound memory access .*ArrayBoundV2"]
+    },
+    {
+        'category':
+            'C/C++',
+        'severity':
+            Severity.ANALYZER,
+        'description':
+            'clang-analyzer Possible lock order reversal',
+        'patterns': [
+            r".*: warning: .* Possible lock order reversal.*PthreadLock"
+        ]
+    },
+    {
+        'category':
+            'C/C++',
+        'severity':
+            Severity.ANALYZER,
+        'description':
+            'clang-analyzer Argument is a pointer to uninitialized value',
+        'patterns': [
+            r".*: warning: .* argument is a pointer to uninitialized value "
+            r".*CallAndMessage"
+        ]
+    },
+    {
+        'category':
+            'C/C++',
+        'severity':
+            Severity.ANALYZER,
+        'description':
+            'clang-analyzer cast to struct',
+        'patterns': [
+            r".*: warning: Casting a non-structure type to a structure type "
+            r".*CastToStruct"
+        ]
+    },
+    {
+        'category': 'C/C++',
+        'severity': Severity.ANALYZER,
+        'description': 'clang-analyzer call path problems',
+        'patterns': [r".*: warning: Call Path : .+"]
+    },
+    {
+        'category': 'C/C++',
+        'severity': Severity.ANALYZER,
+        'description': 'clang-analyzer excessive padding',
+        'patterns': [r".*: warning: Excessive padding in '.*'"]
+    },
+    {
+        'category': 'C/C++',
+        'severity': Severity.ANALYZER,
+        'description': 'clang-analyzer other',
+        'patterns': [r".*: .+\[clang-analyzer-.+\]$", r".*: Call Path : .+$"]
+    },
+
+    # catch-all for warnings this script doesn't know about yet
+    {
+        'category': 'C/C++',
+        'severity': Severity.UNKNOWN,
+        'description': 'Unclassified/unrecognized warnings',
+        'patterns': [r".*: warning: .+"]
+    },
+]