{"id":5601,"date":"2018-12-30T18:31:53","date_gmt":"2018-12-30T18:31:53","guid":{"rendered":"https:\/\/www.modernescpp.com\/index.php\/cppdepend-a-review\/"},"modified":"2018-12-30T18:31:53","modified_gmt":"2018-12-30T18:31:53","slug":"cppdepend-a-review","status":"publish","type":"post","link":"https:\/\/www.modernescpp.com\/index.php\/cppdepend-a-review\/","title":{"rendered":"CppDepend – A Review"},"content":{"rendered":"

In my concurrency class, I use more than 60 programs. Most of the programs consist of a single source file. I’m quite curious if the static code analysis tool CppDepend<\/a> can find any issues in my sources. Let me try it out.<\/p>\n

<\/p>\n

 \"cppDepend\"<\/p>\n

My Special Use-Case<\/h2>\n

My use case is unique for two reasons. First, I don’t expect too many issues with my examples for one reason: I give quite often concurrency classes and use these examples in my classes; therefore, I had many code reviewer. Second, my programs are most of the times not really sophisticated and quite short. They should only serve one purpose: show the particular concurrency features in isolation.<\/p>\n

My Strategy<\/h2>\n

Due to my unique circumstances, here are my steps to get the static code analysis with CppDepend.<\/p>\n

    \n
  1. Generate a CMake file for Visual Studio, GCC, and Clang<\/li>\n
  2. Generate a Visual Studio Project from CMake<\/li>\n
  3. Import the Visual Studio Project project into CppDepend<\/li>\n
  4. Make the code analysis in CppDepend<\/li>\n<\/ol>\n

    Here we go.<\/p>\n

    1. Generate a CMake file for Visual Studio, GCC, and Clang<\/h3>\n

    My customers work with Visual Studio, GCC, or Clang. To provide a way to compile all C++ sources to executables automatically, I use CMake.<\/a> In sum, I have more than 300 C++ sources files in various directories. Each source file should become an executable. Writing a CMakeList.txt<\/span> manually for each directory would be a boring step. Additionally, I would have to adapt it each time, if I modified the file names. Terrible!. To automate the boring stuff, I wrote a small python script generateCMakeFile.py<\/span>. generateCMakeFile.py<\/span> generates a CMakeList.txt<\/span> file for the directory, in which I invoke it.<\/p>\n

    Here it is.<\/p>\n

    \n
    # generateCMakeFile.py<\/span>\r\n\r\nimport<\/span> fnmatch<\/span>\r\nimport<\/span> os<\/span>\r\n\r\n# A few constants<\/span>\r\nSUFFIX =<\/span> \"*.cpp\"<\/span>\r\nOUTPUT =<\/span> \"CMakeLists.txt\"<\/span>\r\n\r\n# The output file<\/span>\r\noutputFile =<\/span> open<\/span>(OUTPUT, \"w\"<\/span>)\r\n\r\n# Return the full path to all files respecting the pattern<\/span>\r\ndef<\/span> getFiles<\/span>(dir_, patterns=<\/span>\"*\"<\/span>, recursive=<\/span>True<\/span>):\r\n    patterns =<\/span> patterns.<\/span>split()\r\n    retValue =<\/span> []\r\n    for<\/span> path, dirs, files in<\/span> os.<\/span>walk(dir_):\r\n        for<\/span> file_ in<\/span> files:\r\n            for<\/span> pattern in<\/span> patterns:\r\n                if<\/span> fnmatch.<\/span>fnmatch(file_, pattern):\r\n                    retValue.<\/span>append(os.<\/span>path.<\/span>join(path, file_))\r\n                    break<\/span>\r\n        if<\/span> not<\/span> recursive: break<\/span>\r\n    return<\/span> retValue\r\n\r\n\r\n# Get all files of the current working directory ending with *.cpp<\/span>\r\ndef<\/span> getAllFilenames<\/span>():\r\n    allFiles =<\/span> getFiles(os.<\/span>getcwd(), SUFFIX , False<\/span>) \r\n    return<\/span> [ os.<\/span>path.<\/span>basename(file_)[:-<\/span>len<\/span>(SUFFIX)+<\/span>1<\/span>] for<\/span> file_ in<\/span> allFiles ]\r\n\r\n# Create the CMakeLists.txt header for GCC, Clang, and MSVC<\/span>\r\ndef<\/span> getHeader<\/span>():\r\n    return<\/span> \"\"\"# Require a recent version of cmake<\/span>\r\ncmake_minimum_required(VERSION 2.8.4 FATAL_ERROR)<\/span>\r\n\r\n# This project is C++ based.<\/span>\r\nproject(seminar)<\/span>\r\n\r\nif(${CMAKE_CXX_COMPILER_ID} STREQUAL GNU)<\/span>\r\n    set(CMAKE_CXX_FLAGS \"-O3 -std=c++14 -pthread\")<\/span>\r\n    if (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 5.0)<\/span>\r\n\t    message(WARNING \"!!!! GCC versions must be at least 5.0 !!!!\")<\/span>\r\n        message(WARNING \"!!!! Adust the makefile to build with a different compiler. !!!!\")<\/span>\r\n    endif()<\/span>\r\nelseif (${CMAKE_CXX_COMPILER_ID} STREQUAL Clang)<\/span>\r\n    set(CMAKE_CXX_FLAGS \"-O3 -std=c++14 -pthread\")<\/span>\r\n    if (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 3.5)<\/span>\r\n        message(WARNING \"!!!! Clang version must be at least 3.5 !!!!\")<\/span>\r\n\t\tmessage(WARNING \"!!!! Adust the makefile to build with a different compiler. !!!!\")<\/span>\r\n    endif()<\/span>\r\nelseif (${CMAKE_CXX_COMPILER_ID} STREQUAL MSVC)<\/span>\r\n    set(CMAKE_CXX_FLAGS \"\/Ox \/EHsc\")<\/span>\r\n    if (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 19.10)    <\/span>\r\n        message(WARNING \"!!!! MSVC version must be at least 19.10 !!!!\")<\/span>\r\n    endif()\t<\/span>\r\nelse()<\/span>\r\n    message(WARNING \"!!! You are using an unsupported compiler! Compilation has only been tested with GCC >= 5.0, Clang >= 3.5, or MSVC >= 19.10. !!!\")<\/span>\r\nendif()<\/span>\r\n    <\/span>\r\n\r\nset(CMAKE_RUNTIME_OUTPUT_DIRECTORY \"bin\/\")<\/span>\r\n\r\nset(CMAKE_VERBOSE_MAKEFILE on)<\/span>\r\n\r\n\"\"\"<\/span>\r\n    \r\n# Create the list of all source files    <\/span>\r\ndef<\/span> getAllNames<\/span>(allNames):    \r\n    outNames =<\/span> \"set(example_programs\"<\/span> \r\n    for<\/span> entry in<\/span> allNames:\r\n        outNames +=<\/span> \"    \"<\/span> +<\/span> entry +<\/span> \"<\/span>\\n<\/span>\"<\/span>\r\n    outNames +=<\/span> \"   )\"<\/span>\r\n    outNames +=<\/span> \"<\/span>\\n<\/span>\"<\/span>\r\n    \r\n    return<\/span> outNames\r\n\r\n# Create an executable from the source file<\/span>\r\ndef<\/span> getTail<\/span>():\r\n    tail =<\/span> \"\"\"foreach(example_program ${example_programs})<\/span>\r\n  set(sources ${example_program}.cpp)<\/span>\r\n  source_group(\"Source Files\" FILES{sources})<\/span>\r\n  add_executable(${example_program} ${sources})<\/span>\r\nendforeach()\"\"\"<\/span>\r\n    return<\/span> tail\r\n\r\n\r\n# Create the CMakeLists.txt<\/span>\r\nallNames =<\/span> getAllFilenames()\r\n\r\nprint<\/span> >><\/span> outputFile, getHeader()\r\n\r\nprint<\/span> >><\/span> outputFile, getAllNames(allNames)\r\n\r\nprint<\/span> >><\/span> outputFile, getTail()\r\n<\/pre>\n<\/div>\n
     <\/p>\n
    To understand the program, you should start with the three print statements add the end. The brown font goes directly into CMakeList.txt.<\/span><\/p>\n
    Using the generateCMakeFile.py<\/span> <\/span>is straightforward. I copied the  generateCMakeFile.py <\/span>to the directory, I wanted to use it. This step is not necessary but make the commandline easier to write.<\/p>\n
    \"GenerateCmakeFile\"<\/p>\n
    Finally, this is the autogenerate CMakeList.txt.<\/span><\/p>\n
    \n
    # Require a recent version of cmake<\/span>\r\ncmake_minimum_required<\/span>(VERSION<\/span> 2.8.4<\/span> FATAL_ERROR<\/span>)\r\n\r\n# This project is C++ based.<\/span>\r\nproject<\/span>(seminar<\/span>)\r\n\r\nif<\/span>(${<\/span>CMAKE_CXX_COMPILER_ID<\/span>}<\/span> STREQUAL<\/span> GNU<\/span>)\r\n    set<\/span>(CMAKE_CXX_FLAGS<\/span> \"-O3 -std=c++14 -pthread\"<\/span>)\r\n    if<\/span> (CMAKE_CXX_COMPILER_VERSION<\/span> VERSION_LESS<\/span> 5.0<\/span>)\r\n\t    message<\/span>(WARNING<\/span> \"!!!! GCC versions must be at least 5.0 !!!!\"<\/span>)\r\n        message<\/span>(WARNING<\/span> \"!!!! Adust the makefile to build with a different compiler. !!!!\"<\/span>)\r\n    endif<\/span>()\r\nelseif<\/span> (${<\/span>CMAKE_CXX_COMPILER_ID<\/span>}<\/span> STREQUAL<\/span> Clang<\/span>)\r\n    set<\/span>(CMAKE_CXX_FLAGS<\/span> \"-O3 -std=c++14 -pthread\"<\/span>)\r\n    if<\/span> (CMAKE_CXX_COMPILER_VERSION<\/span> VERSION_LESS<\/span> 3.5<\/span>)\r\n        message<\/span>(WARNING<\/span> \"!!!! Clang version must be at least 3.5 !!!!\"<\/span>)\r\n\t\tmessage<\/span>(WARNING<\/span> \"!!!! Adust the makefile to build with a different compiler. !!!!\"<\/span>)\r\n    endif<\/span>()\r\nelseif<\/span> (${<\/span>CMAKE_CXX_COMPILER_ID<\/span>}<\/span> STREQUAL<\/span> MSVC<\/span>)\r\n    set<\/span>(CMAKE_CXX_FLAGS<\/span> \"\/Ox \/EHsc\"<\/span>)\r\n    if<\/span> (CMAKE_CXX_COMPILER_VERSION<\/span> VERSION_LESS<\/span> 19.10<\/span>)    \r\n        message<\/span>(WARNING<\/span> \"!!!! MSVC version must be at least 19.10 !!!!\"<\/span>)\r\n    endif<\/span>()\t\r\nelse<\/span>()\r\n    message<\/span>(WARNING<\/span> \"!!! You are using an unsupported compiler! Compilation has only been tested with GCC >= 5.0, Clang >= 3.5, or MSVC >= 19.10. !!!\"<\/span>)\r\nendif<\/span>()\r\n    \r\n\r\nset<\/span>(CMAKE_RUNTIME_OUTPUT_DIRECTORY<\/span> \"bin\/\"<\/span>)\r\n\r\nset<\/span>(CMAKE_VERBOSE_MAKEFILE<\/span> on<\/span>)\r\n\r\n\r\nset<\/span>(example_programs<\/span>    acquireConsume<\/span>\r\n    acquireRelease<\/span>\r\n    asyncLazyEager<\/span>\r\n    atomicCondition<\/span>\r\n    atomic<\/span>\r\n    blockingAsync<\/span>\r\n    conditionVariable<\/span>\r\n    dataRaceOnX<\/span>\r\n    dotProduct<\/span>\r\n    fetch_mult<\/span>\r\n    lockGuard<\/span>\r\n    mutex<\/span>\r\n    newAlgorithm<\/span>\r\n    packagedTask<\/span>\r\n    packagedTaskReuse<\/span>\r\n    promiseFuture<\/span>\r\n    promiseFutureSynchronize<\/span>\r\n    readerWriterLock<\/span>\r\n    relaxed<\/span>\r\n    safeInitializationCallOnce<\/span>\r\n    safeInitializationStatic<\/span>\r\n    singleton<\/span>\r\n    spinlockAcquireRelease<\/span>\r\n    spinLock<\/span>\r\n    threadArguments<\/span>\r\n    threadCreate<\/span>\r\n    threadLifetime<\/span>\r\n    threadLocal<\/span>\r\n    threadMethods<\/span>\r\n    time<\/span>\r\n    timeDuration<\/span>\r\n    transitivity<\/span>\r\n    uniqueLock<\/span>\r\n   )\r\n\r\nforeach<\/span>(example_program<\/span> ${<\/span>example_programs<\/span>}<\/span>)\r\n  set<\/span>(sources<\/span> ${<\/span>example_program<\/span>}<\/span>.cpp<\/span>)\r\n  source_group<\/span>(\"Source Files\"<\/span> FILES{sources}<\/span>)\r\n  add_executable<\/span>(${<\/span>example_program<\/span>}<\/span> ${<\/span>sources<\/span>}<\/span>)\r\nendforeach<\/span>()\r\n<\/pre>\n<\/div>\n
     <\/p>\n
    2. Generate a Visual Studio Project from CMake<\/h3>\n
    To make my CppDepend life more comfortable, I switch from Linux to Windows and continue with Visual Studio.<\/p>\n
    \"MakeVisualProject\"<\/p>\n
    This step creates a 64-bit Visual Studio Project in the directory “C:\\Users\\raine\\build<\/span>“. <\/p>\n
    3. Import the Visual Studio Project project into CppDepend<\/h3>\n
    Now, it’s time to start CppDepend and create a new project Concurrency:<\/p>\n
    \"NewProject\"Next, I add Visual Studio to my new project.<\/p>\n
    \"solution\"<\/p>\n
    One step is still missing. I have to press the analyse button. It took my eight cores a few second to analyse the source files.<\/p>\n
    4. Make the code analysis in CppDepend<\/h3>\n
    As I already assumed it, the most checks are green:<\/p>\n
    \"analysis\"<\/p>\n
    Of course, I’m only interested in the red (Error) and yellow (Warning) ones.<\/p>\n
    Error:<\/h4>\n
      \n
    • Quality Gates:\n
        \n
      • This issue boils down to mainly one function: The method is too big, has too many local variables, and is poorly documented. What I liked about CppDepend was that it shows me the metric I violated. <\/li>\n<\/ul>\n
         <\/div>\n<\/li>\n<\/ul>\n
        \"QualityGates\"<\/h4>\n
        Warnings:<\/h4>\n
          \n
        • Code Smells:\n
            \n
          • The previous break of the Quality Gates was also a Code Smell; therefore, I can ignore this warning.<\/li>\n<\/ul>\n<\/li>\n
          • Object Oriented Design:\n
              \n
            • Only one of the thirty rules was violated: three of my constructors taking one argument were not explicit. Honestly, this is a rule I often preach in my seminars. Shame on me. <\/li>\n<\/ul>\n
               <\/div>\n<\/li>\n<\/ul>\n
              \"ExplicitConstructor\"<\/p>\n
               <\/p>\n
                \n
              •  Misc: \n
                  \n
                • This is also an issue I should fix. I passed a std:<\/span>:string by copy.<\/li>\n<\/ul>\n
                   <\/div>\n<\/li>\n<\/ul>\n
                  \"passByReference\"<\/p>\n
                    \n
                  • Dead Code:\n
                      \n
                    • This violation was funny. The violation was that the destructor of the singleton was never called. To my excuse, I only used a singleton to explain the thread-safe initialisation of a variable.<\/li>\n<\/ul>\n<\/li>\n
                    • Naming Conventions:\n
                        \n
                      • I’m not a big fan of Hungarian notation. Therefore, I wouldn’t prefix an instance variable with a m_ or a static with a s_.<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n
                        My Resume<\/h2>\n
                        Here is my short resume. I put not too much effort into the analysis of CppDepend but more in establishing an automated process to create the Visual Studio solution as input for CppDepend. Regardless, I found immediately a few big issues which I’m going to fix. It’s quite comfortable to fix these issues because a double-click on the Error\/Warning in CppDepend opens the source file in Visual Studio.<\/p>\n
                        Although I only scratched at the surface of CppDepend, the analysis of my concurrency source files impressed me. I will, therefore, invest in the future more time to better understand the various metrics of CppDepend and apply them to my other source files. My gut feeling is that I can draw many benefits from CppDepend.<\/p>\n
                         <\/p>\n
                         <\/p>\n
                         <\/p>\n
                         <\/p>\n","protected":false},"excerpt":{"rendered":"
                        In my concurrency class, I use more than 60 programs. Most of the programs consist of a single source file. I’m quite curious if the static code analysis tool CppDepend can find any issues in my sources. Let me try it out.<\/p>\n","protected":false},"author":21,"featured_media":5592,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[373],"tags":[],"class_list":["post-5601","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-review"],"_links":{"self":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/5601","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/users\/21"}],"replies":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/comments?post=5601"}],"version-history":[{"count":0,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/5601\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media\/5592"}],"wp:attachment":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media?parent=5601"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/categories?post=5601"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/tags?post=5601"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}