cppcheck-py 2.9__py3-none-win_amd64.whl

cppcheck/data/addons/namingng.py

@@ -0,0 +1,253 @@
+#!/usr/bin/env python3
+#
+# cppcheck addon for naming conventions
+# An enhanced version. Configuration is taken from a json file
+# It supports to check for type-based prefixes in function or variable names.
+#
+# Example usage (variable name must start with lowercase, function name must start with uppercase):
+# $ cppcheck --dump path-to-src/
+# $ python namingng.py test.c.dump
+#
+# JSON format:
+#
+# {
+#    "RE_VARNAME": "[a-z]*[a-zA-Z0-9_]*\\Z",
+#    "RE_PRIVATE_MEMBER_VARIABLE": null,
+#    "RE_FUNCTIONNAME": "[a-z0-9A-Z]*\\Z",
+#    "var_prefixes": {"uint32_t": "ui32"},
+#    "function_prefixes": {"uint16_t": "ui16",
+#                          "uint32_t": "ui32"}
+# }
+#
+# RE_VARNAME, RE_PRIVATE_MEMBER_VARIABLE and RE_FUNCTIONNAME are regular expressions to cover the basic names
+# In var_prefixes and function_prefixes there are the variable-type/prefix pairs
+
+import cppcheckdata
+import sys
+import re
+import argparse
+import json
+
+
+# Auxiliary class
+class DataStruct:
+    def __init__(self, file, linenr, string):
+        self.file = file
+        self.linenr = linenr
+        self.str = string
+
+
+def reportError(filename, linenr, severity, msg):
+    message = "[{filename}:{linenr}] ( {severity} ) naming.py: {msg}\n".format(
+        filename=filename,
+        linenr=linenr,
+        severity=severity,
+        msg=msg
+    )
+    sys.stderr.write(message)
+    return message
+
+
+def loadConfig(configfile):
+    with open(configfile) as fh:
+        data = json.load(fh)
+    return data
+
+
+def checkTrueRegex(data, expr, msg, errors):
+    res = re.match(expr, data.str)
+    if res:
+        errors.append(reportError(data.file, data.linenr, 'style', msg))
+
+
+def checkFalseRegex(data, expr, msg, errors):
+    res = re.match(expr, data.str)
+    if not res:
+        errors.append(reportError(data.file, data.linenr, 'style', msg))
+
+
+def evalExpr(conf, exp, mockToken, msgType, errors):
+    if isinstance(conf, dict):
+        if conf[exp][0]:
+            msg = msgType + ' ' + mockToken.str + ' violates naming convention : ' + conf[exp][1]
+            checkTrueRegex(mockToken, exp, msg, errors)
+        elif ~conf[exp][0]:
+            msg = msgType + ' ' + mockToken.str + ' violates naming convention : ' + conf[exp][1]
+            checkFalseRegex(mockToken, exp, msg, errors)
+        else:
+            msg = msgType + ' ' + mockToken.str + ' violates naming convention : ' + conf[exp][0]
+            checkFalseRegex(mockToken, exp, msg, errors)
+    else:
+        msg = msgType + ' ' + mockToken.str + ' violates naming convention'
+        checkFalseRegex(mockToken, exp, msg, errors)
+
+
+def process(dumpfiles, configfile, debugprint=False):
+
+    errors = []
+
+    conf = loadConfig(configfile)
+
+    for afile in dumpfiles:
+        if not afile[-5:] == '.dump':
+            continue
+        print('Checking ' + afile + '...')
+        data = cppcheckdata.CppcheckData(afile)
+
+        # Check File naming
+        if "RE_FILE" in conf and conf["RE_FILE"]:
+            mockToken = DataStruct(afile[:-5], "0", afile[afile.rfind('/') + 1:-5])
+            msgType = 'File name'
+            for exp in conf["RE_FILE"]:
+                evalExpr(conf["RE_FILE"], exp, mockToken, msgType, errors)
+
+        # Check Namespace naming
+        if "RE_NAMESPACE" in conf and conf["RE_NAMESPACE"]:
+            for tk in data.rawTokens:
+                if tk.str == 'namespace':
+                    mockToken = DataStruct(tk.next.file, tk.next.linenr, tk.next.str)
+                    msgType = 'Namespace'
+                    for exp in conf["RE_NAMESPACE"]:
+                        evalExpr(conf["RE_NAMESPACE"], exp, mockToken, msgType, errors)
+
+        for cfg in data.configurations:
+            print('Checking %s, config %s...' % (afile, cfg.name))
+            if "RE_VARNAME" in conf and conf["RE_VARNAME"]:
+                for var in cfg.variables:
+                    if var.nameToken and var.access != 'Global' and var.access != 'Public' and var.access != 'Private':
+                        prev = var.nameToken.previous
+                        varType = prev.str
+                        while "*" in varType and len(varType.replace("*", "")) == 0:
+                            prev = prev.previous
+                            varType = prev.str + varType
+
+                        if debugprint:
+                            print("Variable Name: " + str(var.nameToken.str))
+                            print("original Type Name: " + str(var.nameToken.valueType.originalTypeName))
+                            print("Type Name: " + var.nameToken.valueType.type)
+                            print("Sign: " + str(var.nameToken.valueType.sign))
+                            print("variable type: " + varType)
+                            print("\n")
+                            print("\t-- {} {}".format(varType, str(var.nameToken.str)))
+
+                        if conf["skip_one_char_variables"] and len(var.nameToken.str) == 1:
+                            continue
+                        if varType in conf["var_prefixes"]:
+                            if not var.nameToken.str.startswith(conf["var_prefixes"][varType]):
+                                errors.append(reportError(
+                                                    var.typeStartToken.file,
+                                                    var.typeStartToken.linenr,
+                                                    'style',
+                                                    'Variable ' +
+                                                    var.nameToken.str +
+                                                    ' violates naming convention'))
+
+                        mockToken = DataStruct(var.typeStartToken.file, var.typeStartToken.linenr, var.nameToken.str)
+                        msgType = 'Variable'
+                        for exp in conf["RE_VARNAME"]:
+                            evalExpr(conf["RE_VARNAME"], exp, mockToken, msgType, errors)
+
+            # Check Private Variable naming
+            if "RE_PRIVATE_MEMBER_VARIABLE" in conf and conf["RE_PRIVATE_MEMBER_VARIABLE"]:
+                # TODO: Not converted yet
+                for var in cfg.variables:
+                    if (var.access is None) or var.access != 'Private':
+                        continue
+                    mockToken = DataStruct(var.typeStartToken.file, var.typeStartToken.linenr, var.nameToken.str)
+                    msgType = 'Private member variable'
+                    for exp in conf["RE_PRIVATE_MEMBER_VARIABLE"]:
+                        evalExpr(conf["RE_PRIVATE_MEMBER_VARIABLE"], exp, mockToken, msgType, errors)
+
+            # Check Public Member Variable naming
+            if "RE_PUBLIC_MEMBER_VARIABLE" in conf and conf["RE_PUBLIC_MEMBER_VARIABLE"]:
+                for var in cfg.variables:
+                    if (var.access is None) or var.access != 'Public':
+                        continue
+                    mockToken = DataStruct(var.typeStartToken.file, var.typeStartToken.linenr, var.nameToken.str)
+                    msgType = 'Public member variable'
+                    for exp in conf["RE_PUBLIC_MEMBER_VARIABLE"]:
+                        evalExpr(conf["RE_PUBLIC_MEMBER_VARIABLE"], exp, mockToken, msgType, errors)
+
+            # Check Global Variable naming
+            if "RE_GLOBAL_VARNAME" in conf and conf["RE_GLOBAL_VARNAME"]:
+                for var in cfg.variables:
+                    if (var.access is None) or var.access != 'Global':
+                        continue
+                    mockToken = DataStruct(var.typeStartToken.file, var.typeStartToken.linenr, var.nameToken.str)
+                    msgType = 'Public member variable'
+                    for exp in conf["RE_GLOBAL_VARNAME"]:
+                        evalExpr(conf["RE_GLOBAL_VARNAME"], exp, mockToken, msgType, errors)
+
+            # Check Functions naming
+            if "RE_FUNCTIONNAME" in conf and conf["RE_FUNCTIONNAME"]:
+                for token in cfg.tokenlist:
+                    if token.function:
+                        if token.function.type in ('Constructor', 'Destructor', 'CopyConstructor', 'MoveConstructor'):
+                            continue
+                        retval = token.previous.str
+                        prev = token.previous
+                        while "*" in retval and len(retval.replace("*", "")) == 0:
+                            prev = prev.previous
+                            retval = prev.str + retval
+                        if debugprint:
+                            print("\t:: {} {}".format(retval, token.function.name))
+
+                        if retval and retval in conf["function_prefixes"]:
+                            if not token.function.name.startswith(conf["function_prefixes"][retval]):
+                                errors.append(reportError(
+                                    token.file, token.linenr, 'style', 'Function ' + token.function.name + ' violates naming convention'))
+                        mockToken = DataStruct(token.file, token.linenr, token.function.name)
+                        msgType = 'Function'
+                        for exp in conf["RE_FUNCTIONNAME"]:
+                            evalExpr(conf["RE_FUNCTIONNAME"], exp, mockToken, msgType, errors)
+
+            # Check Class naming
+            if "RE_CLASS_NAME" in conf and conf["RE_CLASS_NAME"]:
+                for fnc in cfg.functions:
+                    # Check if it is Constructor/Destructor
+                    if fnc.type == 'Constructor' or fnc.type == 'Destructor':
+                        mockToken = DataStruct(fnc.tokenDef.file, fnc.tokenDef.linenr, fnc.name)
+                        msgType = 'Class ' + fnc.type
+                        for exp in conf["RE_CLASS_NAME"]:
+                            evalExpr(conf["RE_CLASS_NAME"], exp, mockToken, msgType, errors)
+    return errors
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description='Naming verification')
+    parser.add_argument('dumpfiles', type=str, nargs='+',
+                        help='A set of dumpfiles to process')
+    parser.add_argument("--debugprint", action="store_true", default=False,
+                        help="Add debug prints")
+    parser.add_argument("--configfile", type=str, default="naming.json",
+                        help="Naming check config file")
+    parser.add_argument("--verify", action="store_true", default=False,
+                        help="verify this script. Must be executed in test folder !")
+
+    args = parser.parse_args()
+    errors = process(args.dumpfiles, args.configfile, args.debugprint)
+
+    if args.verify:
+        print(errors)
+        if len(errors) < 6:
+            print("Not enough errors found")
+            sys.exit(1)
+        target = [
+         '[namingng_test.c:8] ( style ) naming.py: Variable badui32 violates naming convention\n',
+         '[namingng_test.c:11] ( style ) naming.py: Variable a violates naming convention\n',
+         '[namingng_test.c:29] ( style ) naming.py: Variable badui32 violates naming convention\n',
+         '[namingng_test.c:20] ( style ) naming.py: Function ui16bad_underscore violates naming convention\n',
+         '[namingng_test.c:25] ( style ) naming.py: Function u32Bad violates naming convention\n',
+         '[namingng_test.c:37] ( style ) naming.py: Function Badui16 violates naming convention\n']
+        diff = set(errors) - set(target)
+        if len(diff):
+            print("Not the right errors found {}".format(str(diff)))
+            sys.exit(1)
+        print("Verification done\n")
+        sys.exit(0)
+
+    if len(errors):
+        print('Found errors: {}'.format(len(errors)))
+        sys.exit(1)
+
+    sys.exit(0)

cppcheck/data/addons/runaddon.py

@@ -0,0 +1,12 @@
+import cppcheckdata, cppcheck, runpy, sys, os
+
+if __name__ == '__main__':
+    addon = sys.argv[1]
+    __addon_name__ = os.path.splitext(os.path.basename(addon))[0]
+    sys.argv.pop(0)
+
+    runpy.run_path(addon, run_name='__main__')
+
+    # Run registered checkers
+    cppcheck.runcheckers()
+    sys.exit(cppcheckdata.EXIT_CODE)

cppcheck/data/addons/threadsafety.py

@@ -0,0 +1,39 @@
+#!/usr/bin/env python3
+#
+# This script analyses Cppcheck dump files to locate threadsafety issues
+# - warn about static local objects
+#
+
+import cppcheckdata
+import sys
+
+def reportError(token, severity, msg, id):
+    cppcheckdata.reportError(token, severity, msg, 'threadsafety', id)
+
+
+def checkstatic(data):
+    for var in data.variables:
+        if var.isStatic and var.isLocal:
+            type = None
+            if var.isClass:
+                type = 'object'
+            else:
+                type = 'variable'
+            if var.isConst:
+                if data.standards.cpp == 'c++03':
+                    reportError(var.typeStartToken, 'warning', 'Local constant static ' + type + ' \'' + var.nameToken.str + '\', dangerous if it is initialized in parallel threads', 'threadsafety-const')
+            else:
+                reportError(var.typeStartToken, 'warning', 'Local static ' + type + ': ' + var.nameToken.str, 'threadsafety')
+
+for arg in sys.argv[1:]:
+    if arg.startswith('-'):
+        continue
+
+    print('Checking %s...' % arg)
+    data = cppcheckdata.CppcheckData(arg)
+
+    for cfg in data.iterconfigurations():
+        print('Checking %s, config %s...' % (arg, cfg.name))
+        checkstatic(cfg)
+
+    sys.exit(cppcheckdata.EXIT_CODE)

cppcheck/data/addons/y2038.py

@@ -0,0 +1,252 @@
+#!/usr/bin/env python3
+#
+# cppcheck addon for Y2038 safeness detection
+#
+# Detects:
+#
+# 1. _TIME_BITS being defined to something else than 64 bits
+# 2. _USE_TIME_BITS64 being defined when _TIME_BITS is not
+# 3. Any Y2038-unsafe symbol when _USE_TIME_BITS64 is not defined.
+#
+# Example usage:
+# $ cppcheck --dump path-to-src/test.c
+# $ y2038.py path-to-src/test.c.dump
+#
+# y2038.py will walk the source tree for .dump files.
+from __future__ import print_function
+
+import cppcheckdata
+import sys
+import os
+import re
+
+
+# --------------------------------------------
+# #define/#undef detection regular expressions
+# --------------------------------------------
+
+# test for '#define _TIME_BITS 64'
+re_define_time_bits_64 = re.compile(r'^\s*#\s*define\s+_TIME_BITS\s+64\s*$')
+
+# test for '#define _TIME_BITS ...' (combine w/ above to test for 'not 64')
+re_define_time_bits = re.compile(r'^\s*#\s*define\s+_TIME_BITS\s+.*$')
+
+# test for '#undef _TIME_BITS' (if it ever happens)
+re_undef_time_bits = re.compile(r'^\s*#\s*undef\s+_TIME_BITS\s*$')
+
+# test for '#define _USE_TIME_BITS64'
+re_define_use_time_bits64 = re.compile(r'^\s*#\s*define\s+_USE_TIME_BITS64\s*$')
+
+# test for '#undef _USE_TIME_BITS64' (if it ever happens)
+re_undef_use_time_bits64 = re.compile(r'^\s*#\s*undef\s+_USE_TIME_BITS64\s*$')
+
+# --------------------------------
+# List of Y2038-unsafe identifiers
+# --------------------------------
+
+# This is WIP. Eventually it should contain all identifiers (types
+# and functions) which would be affected by the Y2038 bug.
+
+id_Y2038 = {
+    # Y2038-unsafe types by definition
+    'time_t'
+    # Types using Y2038-unsafe types
+    'lastlog',
+    'msqid_ds',
+    'semid_ds',
+    'timeb',
+    'timespec',
+    'timeval',
+    'utimbuf',
+    'itimerspec',
+    'stat',
+    'clnt_ops',
+    'elf_prstatus',
+    'itimerval',
+    'ntptimeval',
+    'rusage',
+    'timex',
+    'utmp',
+    'utmpx',
+    # APIs using 2038-unsafe types
+    'ctime',
+    'ctime_r',
+    'difftime',
+    'gmtime',
+    'gmtime_r',
+    'localtime',
+    'localtime_r',
+    'mktime',
+    'stime',
+    'timegm',
+    'timelocal',
+    'time',
+    'msgctl',
+    'ftime',
+    'aio_suspend',
+    'clock_getres',
+    'clock_gettime',
+    'clock_nanosleep',
+    'clock_settime',
+    'futimens',
+    'mq_timedreceive',
+    'mq_timedsend',
+    'nanosleep',
+    'pselect',
+    'pthread_cond_timedwait',
+    'pthread_mutex_timedlock',
+    'pthread_rwlock_timedrdlock',
+    'pthread_rwlock_timedwrlock',
+    'sched_rr_get_interval',
+    'sem_timedwait',
+    'sigtimedwait',
+    'timespec_get',
+    'utimensat',
+    'adjtime',
+    'pmap_rmtcall',
+    'clntudp_bufcreate',
+    'clntudp_create',
+    'futimes',
+    'gettimeofday',
+    'lutimes',
+    'select',
+    'settimeofday',
+    'utimes',
+    'utime',
+    'timerfd_gettime',
+    'timerfd_settime',
+    'timer_gettime',
+    'timer_settime',
+    'fstatat',
+    'fstat',
+    '__fxstatat',
+    '__fxstat',
+    'lstat',
+    '__lxstat',
+    'stat',
+    '__xstat',
+    'struct itimerval',
+    'setitimer',
+    'getitimer',
+    'ntp_gettime',
+    'getrusage',
+    'wait3',
+    'wait4',
+    'adjtimex',
+    'ntp_adjtime',
+    'getutent_r',
+    'getutent',
+    'getutid_r',
+    'getutid',
+    'getutline_r',
+    'getutline',
+    'login',
+    'pututline',
+    'updwtmp',
+    'getutxent',
+    'getutxid',
+    'getutxline',
+    'pututxline'
+}
+
+
+def check_y2038_safe(dumpfile, quiet=False):
+    # Assume that the code is Y2038 safe until proven otherwise
+    y2038safe = True
+    # load XML from .dump file
+    data = cppcheckdata.CppcheckData(dumpfile)
+
+    # Convert dump file path to source file in format generated by cppcheck.
+    # For example after the following call:
+    # cppcheck ./src/my-src.c --dump
+    # We got 'src/my-src.c' value for 'file' field in cppcheckdata.
+    srcfile = dumpfile.rstrip('.dump')
+    srcfile = os.path.expanduser(srcfile)
+    srcfile = os.path.normpath(srcfile)
+
+    # go through each configuration
+    for cfg in data.iterconfigurations():
+        if not quiet:
+            print('Checking %s, config %s...' % (srcfile, cfg.name))
+        safe_ranges = []
+        safe = -1
+        time_bits_defined = False
+        srclinenr = '0'
+
+        for directive in cfg.directives:
+            # track source line number
+            if directive.file == srcfile:
+                srclinenr = directive.linenr
+            # check for correct _TIME_BITS if present
+            if re_define_time_bits_64.match(directive.str):
+                time_bits_defined = True
+            elif re_define_time_bits.match(directive.str):
+                cppcheckdata.reportError(directive, 'error',
+                                         '_TIME_BITS must be defined equal to 64',
+                                         'y2038',
+                                         'type-bits-not-64')
+                time_bits_defined = False
+                y2038safe = False
+            elif re_undef_time_bits.match(directive.str):
+                time_bits_defined = False
+            # check for _USE_TIME_BITS64 (un)definition
+            if re_define_use_time_bits64.match(directive.str):
+                safe = int(srclinenr)
+                # warn about _TIME_BITS not being defined
+                if not time_bits_defined:
+                    cppcheckdata.reportError(directive, 'warning',
+                                             '_USE_TIME_BITS64 is defined but _TIME_BITS was not',
+                                             'y2038',
+                                             'type-bits-undef')
+            elif re_undef_use_time_bits64.match(directive.str):
+                unsafe = int(srclinenr)
+                # do we have a safe..unsafe area?
+                if unsafe > safe > 0:
+                    safe_ranges.append((safe, unsafe))
+                    safe = -1
+
+        # check end of source beyond last directive
+        if len(cfg.tokenlist) > 0:
+            unsafe = int(cfg.tokenlist[-1].linenr)
+            if unsafe > safe > 0:
+                safe_ranges.append((safe, unsafe))
+
+        # go through all tokens
+        for token in cfg.tokenlist:
+            if token.str in id_Y2038:
+                if not any(lower <= int(token.linenr) <= upper
+                           for (lower, upper) in safe_ranges):
+                    cppcheckdata.reportError(token, 'warning',
+                                             token.str + ' is Y2038-unsafe',
+                                             'y2038',
+                                             'unsafe-call')
+                    y2038safe = False
+            token = token.next
+
+    return y2038safe
+
+
+def get_args_parser():
+    parser = cppcheckdata.ArgumentParser()
+    return parser
+
+
+if __name__ == '__main__':
+    parser = get_args_parser()
+    args = parser.parse_args()
+
+    exit_code = 0
+    quiet = not any((args.quiet, args.cli))
+
+    if not args.dumpfile:
+        if not args.quiet:
+            print("no input files.")
+        sys.exit(0)
+
+    for dumpfile in args.dumpfile:
+        if not args.quiet:
+            print('Checking ' + dumpfile + '...')
+
+        check_y2038_safe(dumpfile, quiet)
+
+    sys.exit(cppcheckdata.EXIT_CODE)