Products
In-IDE
IDE extension that lets you fix coding issues before they exist!
Discover SonarQube for IDE
SaaS
Setup is effortless and analysis is automatic for most languages
Discover SonarQube Cloud
Self-Hosted
Fast, accurate analysis; enterprise scalability
Discover SonarQube Server

Secrets
ABAP
Ansible
Apex
AzureResourceManager
C
C#
C++
CloudFormation
COBOL
CSS
Dart
Docker
Flex
GitHub Actions
Go
HTML
Java
JavaScript
JSON
JCL
Kotlin
Kubernetes
Objective C
PHP
PL/I
PL/SQL
Python
RPG
Ruby
Rust
Scala
Shell
Swift
Terraform
Text
TypeScript
T-SQL
VB.NET
VB6
XML
YAML

C static code analysis

Unique rules to find Bugs, Vulnerabilities, Security Hotspots, and Code Smells in your C code

Filtered: 64 rules found

pitfall

Impact

Clean code attribute

"goto" should jump to labels declared later in the same function
Code Smell
Dynamic heap memory allocation should not be used
Bug
"setjmp" and "longjmp" should not be used
Code Smell
Macros should not be #define'd or #undef'd within a block
Code Smell
Object declarations should contain no more than 2 levels of pointer indirection
Code Smell
Functions without parameters should be declared with parameter type "void"
Code Smell
Recursion should not be used
Code Smell
Functions should not be defined with a variable number of arguments
Code Smell
Constants of unsigned type should have a "U" suffix
Code Smell
If a function has internal linkage then all re-declarations shall include the static storage class specifer
Code Smell
Literal suffix "L" for long integers shall be upper case
Code Smell
Macro arguments should not contain preprocessing directives
Bug
All the elements of an aggregate should be provided with an initial value
Code Smell
Macros should not be used as replacements for "typedef" and "using"
Code Smell
Keywords shall not be used as macros identifiers
Code Smell
Logical operators should not be confused with bitwise operators
Code Smell
Include directives should not rely on non-portable search strategy
Code Smell
"#include" paths should be portable
Code Smell
Array indices should be placed between brackets
Code Smell
Bit fields should not be used
Code Smell
Conditionally executed code should be reachable
Bug
Control characters should not be used in literals
Code Smell
Octal and hexadecimal escape sequences should be terminated
Code Smell
Preprocessor directives should not be indented
Code Smell
"goto" statements should not be used to jump into blocks
Code Smell
Related "if/else if" statements should not have the same condition
Bug
"static" should not be used for the size of an array parameter
Code Smell
"switch" statements should not be nested
Code Smell
The sign of an unsigned variable should not be tested
Code Smell
Octal values should not be used
Code Smell
"for" loop stop conditions should be invariant
Code Smell
Control structures should use curly braces
Code Smell
Variables should not be shadowed
Code Smell
Control should not be transferred into a complex logic block using a "goto" or a "switch" statement
Code Smell
An "integer-literal" of type "long long" shall not use a single "L" or "l" in any suffix
Code Smell
"Integral promotion" and the "usual arithmetic conversions" shall not change the signedness or the "type category" of an operand
Code Smell
The library function "system" from "<cstdlib>" shall not be used
Vulnerability
All variables should be initialized
Code Smell
Octal escape sequences, hexadecimal escape sequences and universal character names shall be terminated
Code Smell
Dynamic memory shall be managed automatically
Code Smell
The facilities provided by the standard "header file" "<csignal>" shall not be used
Code Smell
The macro "offsetof" shall not be used
Code Smell
The standard "header file" "<csetjmp>" shall not be used
Code Smell
Precautions shall be taken in order to prevent the contents of a "header file" being included more than once
Code Smell
Program-terminating functions should not be used
Code Smell
A named bit-field with "signed integer type" shall not have a length of one bit
Bug
A bit-field shall have an appropriate type
Code Smell
Bit-fields should not be declared
Code Smell
The features of "<cstdarg>" shall not be used
Code Smell
Functions shall not call themselves, either directly or indirectly
Code Smell
A function must not return a reference or a pointer to a local variable with automatic storage duration
Bug
The "goto" statement shall jump to a label declared later in the function body
Code Smell
A "goto" statement shall reference a label in a surrounding block
Code Smell
The body of an "iteration-statement" or a "selection-statement" shall be a "compound-statement"
Code Smell
The comma operator should not be used
Code Smell
The "declaration" of an object should contain no more than two levels of pointer indirection
Code Smell
The names of the "standard signed integer types" and "standard unsigned integer types" should not be used
Code Smell
A "header file" shall not contain definitions of functions or objects that are non-inline and have external linkage
Code Smell
Tokens that look like a preprocessing directive shall not occur within a macro argument
Bug
Function-like macros shall not be defined
Code Smell
The lowercase form of "L" shall not be used as the first character in a literal suffix
Code Smell
Unsigned "integer literals" shall be appropriately suffixed
Code Smell
Octal constants shall not be used
Code Smell
A variable declared in an "inner scope" shall not hide a variable declared in an "outer scope"
Code Smell

The facilities provided by the standard "header file" "<csignal>" shall not be used

intentionality - clear

maintainability

Code Smell

pitfall
misra-c++2023
misra-required

Why is this an issue?

More Info

This rule is part of MISRA C++:2023.

Usage of this content is governed by Sonar’s terms and conditions. Redistribution is prohibited.

Rule 21.10.3 - The facilities provided by the standard header file [1] `<csignal>` shall not be used

[C11] / 7.14.1.1; Undefined 3, 5, 7; Implementation 3, 6; Indeterminate 5
[Koenig] 74

Category: Required

Analysis: Decidable,Single Translation Unit

Amplification

None of the facilities that are specified as being provided by <csignal> shall be used.

Note: this rule also applies to the facilities provided by <signal.h>.

Rationale

The inappropriate use of signal handling can lead to undefined and implementation-defined behaviour.

Note: the C++ Standard states that signal handling behaviour is specified in the related version of ISO 9899 .

Exception

Calls to signal with a value of SIG_IGN as the second (func) parameter may be used to disable one or more signals. For example:

signal( SIGTERM, SIG_IGN );

Glossary

[1] Header file

A header file is considered to be any file that is included during preprocessing (for example via the #include directive), regardless of its name or suffix.

Available In:

Catch issues on the fly,
in your IDE

Detect issues in your GitHub, Azure DevOps Services, Bitbucket Cloud, GitLab repositories

Analyze code in your
on-premise CI

In-IDE

SaaS

Self-Hosted