Understanding CppDepend Support for MISRA C++ Compliance

Introduction

In today's rapidly evolving automotive industry, the importance of reliable and safe software cannot be overstated. The Motor Industry Software Reliability Association (MISRA) plays a crucial role in establishing best practices for developing safety-related electronic systems in road vehicles and other embedded systems. As a collaborative effort between vehicle manufacturers, component suppliers, and engineering consultancies, MISRA aims to ensure the highest standards in software reliability.

One essential tool for achieving MISRA C++ compliance is CppDepend, which helps developers adhere to these stringent guidelines. In this comprehensive guide, we will explore the pivotal role of MISRA in the automotive industry and how CppDepend can support developers in creating safer, more reliable software for vehicles and embedded systems.

To learn Misra C++ Standards, you can print the official Misra C++ 2008 Standard documentation.

Using Misra Rules in CppDepend

When you create a new CppDepend Project, a pop-up will appear displaying all the coding standards you would like to include in your analysis. To include MISRA C++ coding standards, check the MISRA option and choose MISRA C++.

After analyzing your project, Navigate to the Queries and Rules Explorer section, and select the Misra Rules from the left-hand menu (Highlighted in red in the image below). This will display all the related Misra rules on the right. Upon clicking a Rule, the corresponding CQLinq query and the relevant source code will be automatically generated. Additionally, the Metrics View section provides a visualization of the issue's location and significance.

Incorporating Misra Rules into the HTML Report

To include the Misra rules in the generated HTML Report (available in the DevOps Edition), simply right-click on the Misra group and select "List Code Queries of this Group in a dedicated section in Report."

List of Misra C++ Rules

CppDepend offers support for 103 Misra C++ standard queries.

To gain a deeper understanding of each rule and its functionality, please consult the official Misra C++ 2008 Standard documentation.

• 9 Uncessary Constructs,
• 1 Storage,
• 8 Lexical Conventions,
• 7 Basic Concepts,
• 4 Standard Conversions,
• 17 Expressions,
• 15 Statements,
• 8 Declarations,
• 6 Declarators,
• 7 Classes,
• 5 Exceptions,
• 4 Preprocessor,
• 12 Library.

Uncessary Constructs

• Rule 0–1–1
  

  This coding standard is computed with the following query:

  warnif count > 0         
  from issue in ImportedIssues where issue.ToolName=="Clang" && issue.Type=="warn_unreachable" select 
  new { issue,issue.FilePath,Line=issue.BeginLine}

• Rule 0–1–2

  This coding standard is computed with the following query:

  warnif count > 0         
  from issue in ImportedIssues where issue.ToolName=="CppCheck" && issue.Type=="knownConditionTrueFalse" select 
  new { issue,issue.FilePath,Line=issue.BeginLine}

• Rule 0–1–3
  

  This coding standard is computed with the following query:

  warnif count > 0 
  from issue in ImportedIssues where issue.ToolName=="Clang" && issue.Type=="warn_unused_variable" select 
  new { issue,issue.FilePath,Line=issue.BeginLine}

• Rule 0–1–4

  This coding standard is computed with the following query:

  warnif count > 0 
  from issue in ImportedIssues where issue.ToolName=="CppCheck" && issue.Type=="unreadVariable" select 
  new { issue,issue.FilePath,Line=issue.BeginLine}

• Rule 0–1–5

  This coding standard is computed with the following query:

  warnif count > 0 
  from issue in ImportedIssues where issue.ToolName=="Clang" && issue.Type=="warn_unused_local_typedef" select 
  new { issue,issue.FilePath,Line=issue.BeginLine}

• Rule 0-1-7

  This coding standard is computed with the following query:

  warnif count > 0 
  from issue in ImportedIssues where issue.ToolName=="Misra" && issue.Type=="Rule0-1-7" select 
  new { issue,issue.FilePath,Line=issue.BeginLine}

• Rule 0-1-9

  This coding standard is computed with the following query:

  warnif count > 0         
  from issue in ImportedIssues where issue.ToolName=="Clang" && issue.Type=="warn_unreachable" select 
  new { issue,issue.FilePath,Line=issue.BeginLine}

• Rule 0–1–11

  This coding standard is computed with the following query:

  warnif count > 0 
  from issue in ImportedIssues 
  where issue.ToolName=="Clang" && issue.Type=="warn_unused_parameter" 
  && issue.RelatedMethod!=null && issue.RelatedMethod.IsVirtual
  select 
  new { issue,issue.FilePath,Line=issue.BeginLine}

• Rule 0-1-12

  This coding standard is computed with the following query:

  warnif count > 0 
  from issue in ImportedIssues 
  where issue.ToolName=="Clang" && issue.Type=="warn_unused_parameter" 
  && issue.RelatedMethod!=null && !issue.RelatedMethod.IsVirtual
  select  new { issue,issue.FilePath,Line=issue.BeginLine}

Storage

• Rule 0–2–1

  This coding standard is computed with the following query:

  warnif count > 0         
  from issue in ImportedIssues where issue.ToolName=="Clang-Tidy" && issue.Type=="cppcoreguidelines-pro-type-union-access" select 
  new { issue,issue.FilePath,Line=issue.BeginLine}

Lexical Conventions

• Rule 2–3–1

  This coding standard is computed with the following query:

  warnif count > 0 
  from issue in ImportedIssues where issue.ToolName=="Clang" && issue.Type=="trigraph_ignored" select 
  new { issue,issue.FilePath,Line=issue.BeginLine}

• Rule 2-5-1

  This coding standard is computed with the following query:

  warnif count > 0 
  from issue in ImportedIssues where issue.ToolName=="Clang" && issue.Type=="warn_cxx98_compat_less_colon_colon" select 
  new { issue,issue.FilePath,Line=issue.BeginLine}

• Rule 2–7–1

  This coding standard is computed with the following query:

  warnif count > 0 
  from issue in ImportedIssues where issue.ToolName=="Clang" && issue.Type=="warn_nested_block_comment" select 
  new { issue,issue.FilePath,Line=issue.BeginLine}

• Rule 2–10–2

  This coding standard is computed with the following query:

  warnif count > 0 
  from issue in ImportedIssues where issue.ToolName=="Clang" && issue.Type=="warn_decl_shadow" select 
  new { issue,issue.FilePath,Line=issue.BeginLine}

• Rule 2-10-6

  This coding standard is computed with the following query:

  warnif count > 0 
  from issue in ImportedIssues where issue.ToolName=="Clang" && issue.Type=="err_redefinition_different_kind" select 
  new { issue,issue.FilePath,Line=issue.BeginLine}

• Rule 2–13–1

  This coding standard is computed with the following query:

  warnif count > 0 
  from issue in ImportedIssues where issue.ToolName=="Clang" && issue.Type=="ext_unknown_escape" select 
  new { issue,issue.FilePath,Line=issue.BeginLine}

• Rule 2–13–3

  This coding standard is computed with the following query:

  warnif count > 0 
  from issue in ImportedIssues where  issue.Type=="Rule2-13-3" select 
  new { issue,issue.FilePath,Line=issue.BeginLine}

• Rule 2–13–4

  This coding standard is computed with the following query:

  warnif count > 0 
  from issue in ImportedIssues where  issue.Type=="Rule2-13-4" select 
  new { issue,issue.FilePath,Line=issue.BeginLine}

Basic Concepts

• Rule 3–1–1

  This coding standard is computed with the following query:

  warnif count > 0 
  from m in JustMyCode.Methods where m.NbLinesOfCode>0 
  && m.SourceDecls.First().SourceFile.FileNameExtension.StartsWith("h")
  select new { m,IncludeFile=m.SourceDecls.First().SourceFile.FilePathString }

• Rule 3–1–2

  This coding standard is computed with the following query:

  warnif count > 0 
  from issue in ImportedIssues where issue.Type=="Rule3-1-2"
  select new { issue,issue.FilePath,Line=issue.BeginLine}

• Rule 3–1–3

  This coding standard is computed with the following query:

  warnif count > 0 
  from issue in ImportedIssues where issue.Type=="Rule3-1-3"
  select new { issue,issue.FilePath,Line=issue.BeginLine}

• Rule 3–3–1

  This coding standard is computed with the following query:

  warnif count > 0 
  from issue in ImportedIssues where issue.Type=="Rule3-3-1"
  select new { issue,issue.FilePath,Line=issue.BeginLine}

• Rule 3–3–2

  This coding standard is computed with the following query:

  warnif count > 0 
  from issue in ImportedIssues where issue.Type=="Rule3-3-2"
  select new { issue,issue.FilePath,Line=issue.BeginLine}

• Rule 3–4–1

  This coding standard is computed with the following query:

  warnif count > 0 
  from issue in ImportedIssues where issue.ToolName=="CppCheck" && issue.Type=="variableScope"
  select new { issue,issue.FilePath,Line=issue.BeginLine}

• Rule 3–9–2

  This coding standard is computed with the following query:

  warnif count > 0 
  from issue in ImportedIssues where issue.Type=="Rule3-9-2"
  select new { issue,issue.FilePath,Line=issue.BeginLine}

Standard Conversions

• Rule 4–5–1

  This coding standard is computed with the following query:

  warnif count > 0 
  from issue in ImportedIssues where issue.Type=="Rule4-5-1"
  select new { issue,issue.FilePath,Line=issue.BeginLine}

• Rule 4–5–2

  This coding standard is computed with the following query:

  warnif count > 0 
  from issue in ImportedIssues where issue.Type=="Rule4-5-2"
  select new { issue,issue.FilePath,Line=issue.BeginLine}

• Rule 4–5–3

  This coding standard is computed with the following query:

  warnif count > 0 
  from issue in ImportedIssues where issue.Type=="Rule4-5-3"
  select new { issue,issue.FilePath,Line=issue.BeginLine}

• Rule 4–10–2

  This coding standard is computed with the following query:

  warnif count > 0 
  from issue in ImportedIssues where issue.Type=="Rule4-10-2"
  select new { issue,issue.FilePath,Line=issue.BeginLine}

Expressions

• Rule 5–0–1

  This coding standard is computed with the following query:

  warnif count > 0 
  from issue in ImportedIssues where issue.ToolName=="Clang" && issue.Type=="warn_unsequence_mod_use" select 
  new { issue,issue.FilePath,Line=issue.BeginLine}

• Rule 5–0–4

  This coding standard is computed with the following query:

  warnif count > 0 
  from issue in ImportedIssues where issue.ToolName=="Clang" && issue.Type=="warn_impcast_integer_sign" select 
  new { issue,issue.FilePath,Line=issue.BeginLine}

• Rule 5–0–5

  This coding standard is computed with the following query:

  warnif count > 0 
  from issue in ImportedIssues where issue.ToolName=="Clang" && issue.Type=="warn_impcast_float_integer" select 
  new { issue,issue.FilePath,Line=issue.BeginLine}

• Rule 5–0–6

  This coding standard is computed with the following query:

  warnif count > 0 
  from issue in ImportedIssues where issue.ToolName=="Clang" && issue.Type=="warn_impcast_integer_precision" select 
  new { issue,issue.FilePath,Line=issue.BeginLine}

• Rule 5-0-7

  This coding standard is computed with the following query:

  warnif count > 0 
  from issue in ImportedIssues where issue.ToolName=="Clang-Tidy" && issue.Type=="bugprone-integer-division" select 
  new { issue,issue.FilePath,Line=issue.BeginLine}

• Rule 5–0–9

  This coding standard is computed with the following query:

  warnif count > 0 
  from issue in ImportedIssues where issue.ToolName=="Clang" && issue.Type=="warn_impcast_integer_sign" select 
  new { issue,issue.FilePath,Line=issue.BeginLine}

• Rule 5–0–15

  This coding standard is computed with the following query:

  warnif count > 0 
  from issue in ImportedIssues where issue.ToolName=="Clang-Tidy" && issue.Type=="cppcoreguidelines-pro-bounds-pointer-arithmetic" select 
  new { issue,issue.FilePath,Line=issue.BeginLine}

• Rule 5–0–18

  This coding standard is computed with the following query:

  warnif count > 0 
  from issue in ImportedIssues where issue.ToolName=="CppCheck" && issue.Type=="comparePointers" select 
  new { issue,issue.FilePath,Line=issue.BeginLine}

• Rule 5–2–2

  This coding standard is computed with the following query:

  warnif count > 0 
  from issue in ImportedIssues where issue.ToolName=="Clang" && issue.Type=="err_static_downcast_via_virtual" select 
  new { issue,issue.FilePath,Line=issue.BeginLine}

• Rule 5–2–4

  This coding standard is computed with the following query:

  warnif count > 0 
  from issue in ImportedIssues where issue.ToolName=="Clang" && issue.Type=="warn_old_style_cast" select 
  new { issue,issue.FilePath,Line=issue.BeginLine}

• Rule 5–2–6

  This coding standard is computed with the following query:

  warnif count > 0 
  from issue in ImportedIssues where issue.ToolName=="Clang" && issue.Type=="warn_cxx98_compat_cast_fn_obj" select 
  new { issue,issue.FilePath,Line=issue.BeginLine}

• Rule 5–3–3

  This coding standard is computed with the following query:

  warnif count > 0 
  from m in JustMyCode.Methods where m.SimpleName== "operator&"
  select m

• Rule 5–3–4

  This coding standard is computed with the following query:

  warnif count > 0 
  from issue in ImportedIssues where issue.ToolName=="Clang" && issue.Type=="warn_side_effects_unevaluated_context_sizeof" select 
  new { issue,issue.FilePath,Line=issue.BeginLine}

• Rule 5–8–1

  This coding standard is computed with the following query:

  warnif count > 0 
  from issue in ImportedIssues where issue.Type=="Rule5-8-1"
  select new { issue,issue.FilePath,Line=issue.BeginLine}

• Rule 5–14–1

  This coding standard is computed with the following query:

  warnif count > 0 
  from issue in ImportedIssues where issue.Type=="Rule5-14-1"
  select new { issue,issue.FilePath,Line=issue.BeginLine}

• Rule 5–18–1

  This coding standard is computed with the following query:

  warnif count > 0 
  from issue in ImportedIssues where issue.Type=="Rule5-18-1"
  select new { issue,issue.FilePath,Line=issue.BeginLine}

• Rule 5-2-11

  This coding standard is computed with the following query:

  warnif count > 0 
  from m in JustMyCode.Methods where m.SimpleName== "operator&"
  select m

Statements

• Rule 6–2–1

  This coding standard is computed with the following query:

  warnif count > 0 
  from issue in ImportedIssues where issue.Type=="Rule6-2-1"
  select new { issue,issue.FilePath,Line=issue.BeginLine}

• Rule 6–2–2

  This coding standard is computed with the following query:

  warnif count > 0 
  from issue in ImportedIssues where issue.ToolName=="Clang" && issue.Type=="warn_floatingpoint_eq" select 
  new { issue,issue.FilePath,Line=issue.BeginLine}

• Rule 6–2–3

  This coding standard is computed with the following query:

  warnif count > 0 
  from issue in ImportedIssues where issue.Type=="Rule6-2-3"
  select new { issue,issue.FilePath,Line=issue.BeginLine}

• Rule 6–3–1

  This coding standard is computed with the following query:

  warnif count > 0 
  from issue in ImportedIssues where issue.Type=="Rule6-3-1"
  select new { issue,issue.FilePath,Line=issue.BeginLine}

• Rule 6–4–1

  This coding standard is computed with the following query:

  warnif count > 0 
  from issue in ImportedIssues where issue.Type=="Rule6-4-1"
  select new { issue,issue.FilePath,Line=issue.BeginLine}

• Rule 6–4–2

  This coding standard is computed with the following query:

  warnif count > 0 
  from issue in ImportedIssues where issue.Type=="Rule6-4-2"
  select new { issue,issue.FilePath,Line=issue.BeginLine}

• Rule 6-4-3

  This coding standard is computed with the following query:

  warnif count > 0 
  from issue in ImportedIssues where  issue.Type=="warn_jump_out_of_scope" || issue.Type=="Rule6-6-2" select 
  new { issue,issue.FilePath,Line=issue.BeginLine}

• Rule 6–4–4

  This coding standard is computed with the following query:

  warnif count > 0 
  from issue in ImportedIssues where issue.Type=="Rule6-4-4"
  select new { issue,issue.FilePath,Line=issue.BeginLine}

• Rule 6–4–5

  This coding standard is computed with the following query:

  warnif count > 0 
  from issue in ImportedIssues where issue.ToolName=="Clang" && issue.Type=="warn_unannotated_fallthrough" select 
  new { issue,issue.FilePath,Line=issue.BeginLine}

• Rule 6–4–6

  This coding standard is computed with the following query:

  warnif count > 0 
  from issue in ImportedIssues where issue.Type=="Rule6-4-6"
  select new { issue,issue.FilePath,Line=issue.BeginLine}

• Rule 6–4–7

  This coding standard is computed with the following query:

  warnif count > 0 
  from issue in ImportedIssues where issue.ToolName=="Clang" && issue.Type=="warn_bool_switch_condition" select 
  new { issue,issue.FilePath,Line=issue.BeginLine}

• Rule 6–4–8

  This coding standard is computed with the following query:

  warnif count > 0 
  from issue in ImportedIssues where issue.Type=="Rule6-4-8"
  select new { issue,issue.FilePath,Line=issue.BeginLine}

• Rule 6–6–1

  This coding standard is computed with the following query:

  warnif count > 0 
  from issue in ImportedIssues where issue.ToolName=="Clang" && issue.Type=="warn_jump_out_of_scope" select 
  new { issue,issue.FilePath,Line=issue.BeginLine}

• Rule 6–6–2

  This coding standard is computed with the following query:

  warnif count > 0 
  from issue in ImportedIssues where  issue.Type=="Rule6-6-2" select 
  new { issue,issue.FilePath,Line=issue.BeginLine}

• Rule 6–6–5

  This coding standard is computed with the following query:

  warnif count > 0 
  from issue in ImportedIssues where  issue.Type=="Rule6-6-5" select 
  new { issue,issue.FilePath,Line=issue.BeginLine}

Declarations

• Rule 7-2-1

  This coding standard is computed with the following query:

  warnif count > 0 
  from m in JustMyCode.Methods where m.SimpleName=="main" && m.ParentNamespace.Name!=""
  select m

• Rule 7-3-1

  This coding standard is computed with the following query:

  warnif count > 0 
  from m in JustMyCode.Methods where m.SimpleName=="main" && m.ParentNamespace.Name!=""
  select m

• Rule 7–3–2

  This coding standard is computed with the following query:

  warnif count > 0 
  from m in JustMyCode.Methods where m.SimpleName=="main" && m.ParentNamespace.Name!=""
  select m

• Rule 7–3–3

  This coding standard is computed with the following query:

  warnif count > 0 
  from issue in ImportedIssues where issue.Type=="Rule7-3-3"
  select new { issue,issue.FilePath,Line=issue.BeginLine}

• Rule 7–3–4

  This coding standard is computed with the following query:

  warnif count > 0 
  from issue in ImportedIssues where issue.Type=="Rule7-3-4"
  select new { issue,issue.FilePath,Line=issue.BeginLine}

• Rule 7–4–2

  This coding standard is computed with the following query:

  warnif count > 0 
  from m in JustMyCode.Methods where m.SimpleName=="main" && m.ParentNamespace.Name!=""
  select m

• Rule 7–5–1

  This coding standard is computed with the following query:

  warnif count > 0 
  from issue in ImportedIssues where issue.ToolName=="CppCheck" && issue.Type=="returnAddressOfAutoVariable" select 
  new { issue,issue.FilePath,Line=issue.BeginLine}

• Rule 7–5–2

  This coding standard is computed with the following query:

  warnif count > 0 
  from issue in ImportedIssues where issue.ToolName=="CppCheck" && issue.Type=="deadpointer" select 
  new { issue,issue.FilePath,Line=issue.BeginLine}

Declarators

• Rule 8–4–1

  This coding standard is computed with the following query:

  warnif count > 0 
  from m in JustMyCode.Methods where m.IsVariadic
  select m

• Rule 8–4–3

  This coding standard is computed with the following query:

  warnif count > 0 
  from issue in ImportedIssues where issue.ToolName=="Clang" && issue.Type=="warn_maybe_falloff_nonvoid_function" select 
  new { issue,issue.FilePath,Line=issue.BeginLine}

• Rule 8–4–4

  This coding standard is computed with the following query:

  warnif count > 0 
  from issue in ImportedIssues where issue.ToolName=="Clang" && issue.Type=="warn_duplicate_enum_values" select 
  new { issue,issue.FilePath,Line=issue.BeginLine}

• Rule 8–5–1

  This coding standard is computed with the following query:

  warnif count > 0 
  from issue in ImportedIssues where issue.ToolName=="Clang" && issue.Type=="warn_uninit_var" select 
  new { issue,issue.FilePath,Line=issue.BeginLine}

• Rule 8–5–2

  This coding standard is computed with the following query:

  warnif count > 0 
  from issue in ImportedIssues where issue.ToolName=="Clang" && issue.Type=="warn_missing_braces" select 
  new { issue,issue.FilePath,Line=issue.BeginLine}

• Rule 8–5–3

  This coding standard is computed with the following query:

  warnif count > 0 
  from issue in ImportedIssues where issue.ToolName=="Clang" && issue.Type=="warn_duplicate_enum_values" select 
  new { issue,issue.FilePath,Line=issue.BeginLine}

Classes

• Rule 9–5–1

  This coding standard is computed with the following query:

  warnif count > 0 
  from issue in ImportedIssues where issue.Type=="Rule9-5-1"
  select new { issue,issue.FilePath,Line=issue.BeginLine}

• Rule 10–1–1

  This coding standard is computed with the following query:

  warnif count > 0 
  from issue in ImportedIssues where issue.Type=="Rule10-1-1"
  select new { issue,issue.FilePath,Line=issue.BeginLine}

• Rule 10–3–2

  This coding standard is computed with the following query:

  warnif count > 0 
  from issue in ImportedIssues where issue.Type=="Rule10-3-2"
  select new { issue,issue.FilePath,Line=issue.BeginLine}

• Rule 11–0–1

  This coding standard is computed with the following query:

  warnif count > 0 
  from f in JustMyCode.Fields where !f.ParentType.IsPOD && f.IsPublic
  select f

• Rule 12–1–1

  This coding standard is computed with the following query:

  warnif count > 0 
  from m in JustMyCode.Methods where 
  (m.IsConstructor || m.IsDestructor)
  && (m.MethodsCalled.Where(vm=>vm.IsVirtual).Count()>0 || m.IsUsing("Keywords.dynamic_cast".AllowNoMatch()))
  select m

• Rule 12–1–2

  This coding standard is computed with the following query:

  warnif count > 0 
  from m in JustMyCode.Methods where m.IsConstructor && m.Params.Count()==1 && m.Params.First().ParamType!=null
  && m.Params.First().ParamType.Name=="int" && !m.IsExplicitConstructor
  select m

• Rule 12–8–2

  This coding standard is computed with the following query:

  warnif count > 0 
  from m in JustMyCode.Methods where m.SimpleName== "operator==" 
  && m.ParentType.IsAbstract && m.IsPublic 
  select m

Exceptions

• Rule 15–0–2

  This coding standard is computed with the following query:

  warnif count > 0 
  from issue in ImportedIssues where issue.Type=="Rule15-0-2"
  select new { issue,issue.FilePath,Line=issue.BeginLine}

• Rule 15–3–2

  This coding standard is computed with the following query:

  warnif count > 0 
  from m in JustMyCode.Methods where m.IsEntryPoint
  && m.IsUsing("Keywords.generic_catch".AllowNoMatch()) select m

• Rule 15–3–5

  This coding standard is computed with the following query:

  warnif count > 0 
  from issue in ImportedIssues where issue.Type=="catchExceptionByValue"
  select new { issue,issue.FilePath,Line=issue.BeginLine}

• Rule 15–3–7

  This coding standard is computed with the following query:

  warnif count > 0 
  from issue in ImportedIssues where issue.ToolName=="Clang" && issue.Type=="warn_exception_caught_by_earlier_handler" select 
  new { issue,issue.FilePath,Line=issue.BeginLine}

• Rule 15–5–1

  This coding standard is computed with the following query:

  warnif count > 0 
  from issue in ImportedIssues where issue.Type=="exceptThrowInDestructor"
  select new { issue,issue.FilePath,Line=issue.BeginLine}

Preprocessor

• Rule 16–0–3

  This coding standard is computed with the following query:

  warnif count > 0 
  from issue in ImportedIssues where issue.ToolName=="Clang" && issue.Type=="warn_undef_used" select 
  new { issue,issue.FilePath,Line=issue.BeginLine}

• Rule 16–0–7

  This coding standard is computed with the following query:

  warnif count > 0 
  from issue in ImportedIssues where issue.ToolName=="Clang" && issue.Type=="warn_pp_undef_identifier" select 
  new { issue,issue.FilePath,Line=issue.BeginLine}

• Rule 16–3–1

  This coding standard is computed with the following query:

  warnif count > 0 
  from issue in ImportedIssues where issue.ToolName=="Clang" && issue.Type=="warn_pp_hashhash_used" select 
  new { issue,issue.FilePath,Line=issue.BeginLine}

• Rule 16–3–2

  This coding standard is computed with the following query:

  warnif count > 0 
  from issue in ImportedIssues where issue.ToolName=="Clang" && issue.Type=="warn_pp_hash_used" select 
  new { issue,issue.FilePath,Line=issue.BeginLine}

Library

• Rule 17–0–1

  This coding standard is computed with the following query:

  warnif count > 0 
  from issue in ImportedIssues where issue.ToolName=="Clang" && issue.Type=="warn_reserved_id_macro" select 
  new { issue,issue.FilePath,Line=issue.BeginLine}

• Rule 17–0–5

  This coding standard is computed with the following query:

  warnif count > 0 
  from issue in ImportedIssues where issue.Type=="Rule17-0-5"
  select new { issue,issue.FilePath,Line=issue.BeginLine}

• Rule 18–0–1

  This coding standard is computed with the following query:

  warnif count > 0 
  from issue in ImportedIssues where issue.Type=="Rule18-0-1"
  select new { issue,issue.FilePath,Line=issue.BeginLine}

• Rule 18–0–2

  This coding standard is computed with the following query:

  warnif count > 0 
  from issue in ImportedIssues where issue.Type=="Rule18-0-2"
  select new { issue,issue.FilePath,Line=issue.BeginLine}

• Rule 18–0–3

  This coding standard is computed with the following query:

  warnif count > 0 
  from issue in ImportedIssues where issue.Type=="Rule18-0-3"
  select new { issue,issue.FilePath,Line=issue.BeginLine}

• Rule 18–0–4

  This coding standard is computed with the following query:

  warnif count > 0 
  from issue in ImportedIssues where issue.Type=="Rule18-0-4"
  select new { issue,issue.FilePath,Line=issue.BeginLine}

• Rule 18–0–5

  This coding standard is computed with the following query:

  warnif count > 0 
  from issue in ImportedIssues where issue.Type=="Rule18-0-5"
  select new { issue,issue.FilePath,Line=issue.BeginLine}

• Rule 18–2–1

  This coding standard is computed with the following query:

  warnif count > 0 
  from issue in ImportedIssues where issue.Type=="Rule18-2-1"
  select new { issue,issue.FilePath,Line=issue.BeginLine}

• Rule 18–4–1

  This coding standard is computed with the following query:

  warnif count > 0 
  from issue in ImportedIssues where issue.Type=="Rule18-4-1"
  select new { issue,issue.FilePath,Line=issue.BeginLine}

• Rule 18–7–1

  This coding standard is computed with the following query:

  warnif count > 0 
  from issue in ImportedIssues where issue.Type=="Rule18-7-1"
  select new { issue,issue.FilePath,Line=issue.BeginLine}

• Rule 19–3–1

  This coding standard is computed with the following query:

  warnif count > 0 
  from issue in ImportedIssues where issue.Type=="Rule19-3-1"
  select new { issue,issue.FilePath,Line=issue.BeginLine}

• Rule 27–0–1

  This coding standard is computed with the following query:

  warnif count > 0 
  from issue in ImportedIssues where issue.Type=="Rule18-4-1"
  select new { issue,issue.FilePath,Line=issue.BeginLine}

Go to top