run_cppcheck.py

#!/usr/bin/env python2
#
# Strelka - Small Variant Caller
# Copyright (c) 2009-2018 Illumina, Inc.
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.
#
#

# if cppcheck is found, run it on all c++ and return an error for *any* warning message:


import os
import sys
import subprocess


def which(searchFile) :
    """
    search the PATH for searchFile

    result should be the similar to *nix 'which' utility
    """
    for searchPath in os.environ["PATH"].split(os.pathsep):
        test=os.path.join(searchPath,searchFile)
        if os.path.isfile(test) : return test

    return None


def getCppcheckVersion() :
    """
    return the cppcheck version number, or None if version cannot be obtained.
    """

    proc=subprocess.Popen(["cppcheck","--version"],stdout=subprocess.PIPE)
    lines = proc.stdout.readlines()
    if len(lines) == 0 : return None
    return lines[0].split()[1]


def compareVersions(version1, version2):
    """
    Compare two version strings.

    Return
      < 0 if version1 is less than version2
      > 0 if version2 is less than version1
      0 if version1 == version2
    """

    def versionToIntArray(version) :
        return [int(i) for i in version.split('.')]

    # parse version components
    version1Nums = versionToIntArray(version1)
    version2Nums = versionToIntArray(version2)

    # pad versions to be the same length:
    maxlen = max(len(version1Nums), len(version2Nums))
    while len(version1Nums) < maxlen : version1Nums.append(0)
    while len(version2Nums) < maxlen : version2Nums.append(0)

    # compare
    for v1,v2 in zip(version1Nums, version2Nums) :
        if v1 < v2 : return -1
        if v1 > v2 : return 1

    return 0


def usage() :

    scriptName=os.path.basename(__file__)

    usageStr="""

    usage: %s cxx_root_directory

    run cppcheck on project c++ source code, return error for any unsupressed cppcheck issue

""" % (scriptName)

    sys.stderr.write(usageStr)
    sys.exit(2)



def main() :

    if len(sys.argv) != 2 :
        usage()

    srcRoot=sys.argv[1]

    cppcheck_path = which("cppcheck")
    if cppcheck_path is None :
        sys.exit(0)

    cppcheckVersion = getCppcheckVersion()

    minCppcheckVersion = "1.69"
    isOldVersion = (compareVersions(cppcheckVersion, minCppcheckVersion) < 0)
    if isOldVersion :
        sys.exit(0)

    # need to trace real path out of any symlinks so that cppcheck can find its runtime config info:
    cppcheck_path = os.path.realpath(cppcheck_path)

    checkCmd=[cppcheck_path]
    checkCmd.append("--enable=all")
    checkCmd.append("--std=c++11")
    checkCmd.append("--force")

    # quiet and verbose together mean:
    # only print error messages, but add more detail to each error message printed
    checkCmd.append("--quiet")
    checkCmd.append("--verbose")

    # add this if any inline suppresssion is going to be used in the code:
    #checkCmd.append("--inline-suppr")

    # manipulate the warning messages so that they look like gcc errors -- this enables IDE parsing of error location:
    checkCmd.append("--template={file}:{line}:1: error: {severity}:{message}")

    suppressList=["unusedFunction", "unmatchedSuppression", "missingInclude", "purgedConfiguration"]

    # extra suppressions only used in strelka
    extraSuppressList=["uninitMemberVar"]
    suppressList.extend(extraSuppressList)

    # In cppcheck versions 1.69 and lower (TODO how low?), there is a bug parsing the use of the '%' character
    # in boost::format as a regular mod operator. For these versions, an extra suppression is required.
    #
    if True :
        maxBoostFormatBugVersion = "1.69"
        isBoostFormatBugVersion = (compareVersions(cppcheckVersion, maxBoostFormatBugVersion) <= 0)
        if isBoostFormatBugVersion :
            suppressList.append("zerodivcond")

    # cppcheck v1.72 the will identify lots of FP unused private method errors
    #
    # cppcheck 1.71 and 1.73 are known to not have this issue
    if True :
        minUnusedPrivateBugVersion = "1.72"
        maxUnusedPrivateBugVersion = "1.72"
        isUnusedPrivateBugVersion = (compareVersions(cppcheckVersion, minUnusedPrivateBugVersion) >= 0) and \
                                    (compareVersions(cppcheckVersion, maxUnusedPrivateBugVersion) <= 0)
        if isUnusedPrivateBugVersion :
            suppressList.append("unusedPrivateFunction")

    # cppcheck v1.71 gives FP unused struct member errors
    if True :
        minUnusedStructMemberBugVersion = "1.71"
        maxUnusedStructMemberBugVersion = "1.71"
        isUnusedStructMemberBugVersion = (compareVersions(cppcheckVersion, minUnusedStructMemberBugVersion) >= 0) and \
                                         (compareVersions(cppcheckVersion, maxUnusedStructMemberBugVersion) <= 0)
        if isUnusedStructMemberBugVersion :
            suppressList.append("unusedStructMember")


    for stype in suppressList :
        checkCmd.append("--suppress="+stype)

    # xml output is usful for getting a warnings id field, which is what you need to suppress it:
    #checkCmd.append("--xml")

    # this is more aggressive  and includes more FPs
    #checkCmd.append("--inconclusive")

    checkCmd.append(srcRoot)

    proc = subprocess.Popen(checkCmd, stderr=subprocess.PIPE)

    includeError="Cppcheck cannot find all the include files"

    errCount=0
    for line in proc.stderr :

        # in cppcheck 1.59 missingInclude supression appears to be broken -- this is a workaround:
        if line.find(includeError) != -1 : continue

        sys.stderr.write(line)
        errCount += 1

    if errCount != 0 : sys.exit(1)

    open("cppcheck.done", 'w').close()



if __name__ == '__main__' :
    main()