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

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

C static code analysis

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

Filtered: 111 rules found

based-on-misra

Impact

Clean code attribute

Function-like macros should not be invoked without all of their arguments
Bug
The address of an automatic object should not be assigned to another object that may persist after the first object has ceased to exist
Bug
"goto" should jump to labels declared later in the same function
Code Smell
Only standard forms of the "defined" directive should be used
Code Smell
The right-hand operands of && and || should not contain side effects
Code Smell
Digraphs should not be used
Code Smell
Trigraphs should not be used
Code Smell
"goto" statements should not be used to jump into blocks
Code Smell
Switch cases should end with an unconditional "break" statement
Code Smell
"switch" statements should not contain non-case labels
Code Smell
Function exit paths should have appropriate return values
Bug
Relational and subtraction operators should not be used with pointers to different arrays
Bug
Line-splicing should not be used in "//" comments
Bug
Pointers should not be cast to integral types
Bug
"#undef" should be used with caution
Code Smell
Function names should be used either as a call with a parameter list or with the "&" operator
Code Smell
Object and function types should be explicitly stated in their declarations and definitions
Code Smell
Functions should be declared explicitly
Code Smell
"default" clauses should be first or last
Code Smell
"restrict" should not be used
Code Smell
"static" should not be used for the size of an array parameter
Code Smell
Pre-defined macros should not be defined, redefined or undefined
Code Smell
Lines starting with "#" should contain valid preprocessing directives
Bug
"#include" directives should be followed by either <filename> or "filename" sequences
Bug
Non-standard characters should not occur in header file names in "#include" directives
Bug
Non-empty statements should change control flow or have at least one side-effect
Bug
Unary minus should not be applied to an unsigned expression
Bug
Objects with integer type should not be converted to objects with pointer type
Bug
Variables should be initialized before use
Bug
String literals with different prefixes should not be concatenated
Bug
Only escape sequences defined in the ISO C standard should be used
Bug
User-defined types should not be passed as variadic arguments
Bug
Integral operations should not overflow
Bug
Conditionally executed code should be reachable
Bug
Single-bit named bit fields should not be of a signed type
Bug
All code should be reachable
Bug
Loops should not have more than one "break" or "goto" statement
Code Smell
Unused type declarations should be removed
Code Smell
Comma operator should not be used
Code Smell
"bool" expressions should not be used as operands to built-in operators other than =, &&, ||, !, ==, !=, unary &, and the conditional operator
Code Smell
"enum" members other than the first one should not be explicitly initialized unless all members are explicitly initialized
Code Smell
Bit fields should be declared with appropriate types
Code Smell
Unevaluated operands should not have side effects
Code Smell
Keywords shall not be used as macros identifiers
Code Smell
Boolean expressions should not be gratuitous
Code Smell
Sections of code should not be commented out
Code Smell
Unused function parameters should be removed
Code Smell
Unused functions and methods should be removed
Code Smell
Assignments should not be made from within conditions
Code Smell
Variables should not be shadowed
Code Smell
Unused labels should be removed
Code Smell
"for" loop counters should not have essentially floating type
Bug
The three expressions of a "for" statement should only be concerned with loop control
Code Smell
Literal suffix "L" for long integers shall be upper case
Code Smell
Pointer and reference local variables should be "const" if the corresponding object is not modified
Code Smell
Multiple variables should not be declared on the same line
Code Smell
"if" statements should be preferred over "switch" when simpler
Code Smell
Empty statements should be removed
Code Smell
"/*" and "//" should not be used within comments
Code Smell
Reserved identifiers and functions in the C standard library should not be defined or declared
Code Smell
Octal values should not be used
Code Smell
"atof", "atoi" and "atol" from <stdlib.h> should not be used
Bug
"<signal.h>" should not be used
Bug
Dynamic heap memory allocation should not be used
Bug
"<time.h>" should not be used
Code Smell
"<stdio.h>" should not be used in production code
Code Smell
"errno" should not be used
Code Smell
"setjmp" and "longjmp" should not be used
Code Smell
Function-like macros should not be used
Code Smell
Macros should not be #define'd or #undef'd within a block
Code Smell
Unions should not be used
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
Constants of unsigned type should have a "U" suffix
Code Smell
Octal and hexadecimal escape sequences should be terminated
Code Smell
Flexible array members should not be declared
Code Smell
"switch" statements should have "default" clauses
Code Smell
"if ... else if" constructs should end with "else" clauses
Code Smell
Control structures should use curly braces
Code Smell
Macros used in preprocessor directives should be defined before use
Bug
The number of arguments passed to a function should match the number of parameters
Bug
Bitwise operators should not be applied to signed operands
Bug
Boolean operations should not have numeric operands, and vice versa
Bug
Pointer conversions should be restricted to a safe subset
Bug
Function pointers should not be converted to any other type
Bug
Results of ~ and << operations on operands of underlying types unsigned char and unsigned short should immediately be cast to the operand's underlying type
Bug
The "<stdlib.h>" functions "bsearch" and "qsort" should not be used
Bug
Floating point numbers should not be tested for equality
Bug
Parameters in a function prototype should be named
Code Smell
"goto" statement should not be used
Code Smell
Increment (++) and decrement (--) operators should not be used in a method call or mixed with other operators in an expression
Code Smell
"enum" values should not be used as operands to built-in operators other than [ ], =, ==, !=, unary &, and the relational operators <, <=, >, >=
Code Smell
Operands of "&&" and "||" should be primary (C) or postfix (C++) expressions
Code Smell
The value of a complex expression should only be cast to a type that is narrower and of the same signedness as the underlying type of the expression
Code Smell
Braces should be used to indicate and match the structure in the non-zero initialization of arrays and structures
Code Smell
Array declarations should include an explicit size specification
Code Smell
"typedef" names should be unique identifiers
Code Smell
Identifiers should not be longer than 31 characters
Code Smell
All uses of the #pragma directive should be documented
Code Smell
"for" loop stop conditions should be invariant
Code Smell
Function parameters' initial values should not be ignored
Bug
Preprocessor operators "#" and "##" should not be used
Code Smell
Structure and union types should be complete at the end of a translation unit
Code Smell
"continue" should not be used
Code Smell
Tests of non-Boolean values against zero should be explicit
Code Smell
Signed and unsigned types should not be mixed in expressions
Code Smell
typedefs that indicate size and signedness should be used in place of the basic types
Code Smell
Appropriate char types should be used for character and integer values
Code Smell
Source code should only use /* ... */ style comments
Code Smell
A function should have a single point of exit at the end of the function
Code Smell

The number of arguments passed to a function should match the number of parameters

intentionality - logical

reliability

Bug

MajorSonarSource default severity
click to learn more

cwe
based-on-misra
cert

Why is this an issue?

This problem is completely avoided by the use of function prototypes. See MISRA C:2004 Rule 8.1. This rule is retained since compilers may not flag this constraint error.

Resources

MISRA C:2004, 16.6 - The number of arguments passed to a function shall match the number of parameters.
MITRE, CWE-628 - Function Call with Incorrectly Specified Arguments
CERT, DCL07-C. - Include the appropriate type information in function declarators
CERT, EXP37-C. - Call functions with the correct number and type of arguments

Available In:

Catch issues on the fly,
in your IDE

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

Developer
Edition

© 2008-2023 SonarSource S.A., Switzerland. All content is copyright protected. SONAR, SONARSOURCE, SONARLINT, SONARQUBE, and SONARCLOUD are trademarks of SonarSource S.A. All other trademarks and copyrights are the property of their respective owners. All rights are expressly reserved.
Privacy Policy | Cookie Policy

In-IDE

SaaS

Self-Hosted