2174 lines
76 KiB
Plaintext
Executable File
2174 lines
76 KiB
Plaintext
Executable File
/* Date Stamp */ -d"_lint_au_misra3_lnt=au-misra3.lnt modified 12-Jun-2014"
|
|
/* To document usage use: -message( "Using " _lint_au_misra3_lnt ) */
|
|
|
|
// ---------------------------------------------------------------------
|
|
// This file is provided by Gimpel Software (www.gimpel.com) for use with
|
|
// its products PC-lint and FlexeLint.
|
|
//
|
|
// Redistribution and use of this file, with or without modification, is
|
|
// permitted provided that any such redistribution retains this notice.
|
|
// ---------------------------------------------------------------------
|
|
|
|
// au-misra3.lnt -- Author options - MISRA C 2012
|
|
|
|
/*
|
|
This options file can be used to explicitly activate those
|
|
checks advocated by the Motor Industry Software Reliability
|
|
Association.
|
|
|
|
You can use this file directly when linting your programs as in:
|
|
|
|
lin au-misra3 files
|
|
|
|
Gimpel Software relies on the document, "MISRA-C:2012
|
|
Guidelines for the use of the C language in critical systems",
|
|
copyright 2012 by MIRA Limited, as the primary source for this
|
|
file. Gimpel Software makes no warranty as to the completeness
|
|
or applicability of this options file and reserves the right to
|
|
amend or alter the official contents of such at any time.
|
|
|
|
"MISRA" is a registered trademark of MIRA Limited, held on
|
|
behalf of the MISRA Consortium.
|
|
|
|
*/
|
|
-misra(3) // Activate MISRA Essential Type model
|
|
|
|
/**** Dir 1.1 (Req) ************/
|
|
|
|
/* not statically checkable */
|
|
|
|
/**** Dir 2.1 (Req) ************/
|
|
|
|
-A(C99) /* strict ISO C99 */
|
|
/* Note: if you code to the C90 standard instead, you may
|
|
want to comment out the above option and uncomment the
|
|
following option. You will also want to do likewise for
|
|
other uses of the '-A(C99)' option throughout this file. */
|
|
// -A(C90) /* strict ANSI */
|
|
+e950 /* flag non-standard word or construct */
|
|
+elib(950)
|
|
-append(950,[MISRA 2012 Directive 2.1, required])
|
|
|
|
/**** Dir 3.1 (Req) ************/
|
|
|
|
/* not statically checkable */
|
|
|
|
/**** Dir 4.1 (Req) ************/
|
|
|
|
/* not statically checkable */
|
|
|
|
/**** Dir 4.2 (Adv) ************/
|
|
|
|
/* not statically checkable */
|
|
|
|
/**** Dir 4.3 (Req) ************/
|
|
|
|
+e586 /* to activate the deprecation message */
|
|
+elib(586)
|
|
-deprecate(keyword,asm,[MISRA 2012 4.3, required])
|
|
|
|
/**** Dir 4.4 (Adv) ************/
|
|
|
|
/* This requirement (that there be no commented-out code) is, in
|
|
principle, not statically checkable. The reason given for the
|
|
requirement is that comments do not nest. Thus a commented
|
|
out section of code that happens to use slash-star commenting
|
|
could inadvertently introduce unwanted code. Rule 3.1, however,
|
|
addresses the nested comment issue and hence the major concern
|
|
that this requirement seeks to address is indeed checkable.
|
|
*/
|
|
-fnc /* flag nested comments */
|
|
+e602 /* comment within comment */
|
|
+elib(602)
|
|
-append(602,[MISRA 2012 Directive 4.4, advisory])
|
|
|
|
/**** Dir 4.5 (Adv) ************/
|
|
|
|
// While Lint can enforce this directive with the following four
|
|
// options, doing so can increase the run time of Lint depending
|
|
// upon the number of identifiers in your program. If you want
|
|
// this checking, uncomment each of the following four options.
|
|
//
|
|
// +fta
|
|
// +e9046 /* typographical ambiguity */
|
|
// +elib(9046)
|
|
// -append(9046,[MISRA 2012 Directive 4.5, advisory])
|
|
|
|
/**** Dir 4.6 (Adv) ************/
|
|
|
|
+e970 /* flag modifiers used outside of typedefs */
|
|
+elib(970)
|
|
-append(970,[MISRA 2012 Directive 4.6, advisory])
|
|
// For the duration, we are presuming MISRA does not want
|
|
// diagnostics for the bool type.
|
|
-esym(970,bool)
|
|
-esym(970,char)
|
|
|
|
/**** Dir 4.7 (Req) ************/
|
|
|
|
+e534 /* ignoring return value of function */
|
|
+elib(534)
|
|
-append(534,[MISRA 2012 Directive 4.7, required])
|
|
|
|
/**** Dir 4.8 (Adv) ************/
|
|
|
|
+e9045 /* non-hidden definition of type */
|
|
+elib(9045)
|
|
-append(9045,[MISRA 2012 Directive 4.8, advisory])
|
|
|
|
/**** Dir 4.9 (Adv) ************/
|
|
|
|
+e9026 /* function-like macro defined */
|
|
+elib(9026)
|
|
-append(9026,[MISRA 2012 Directive 4.9, advisory])
|
|
|
|
/**** Dir 4.10 (Req) ************/
|
|
|
|
+e451 /* Header repeatedly included without guard */
|
|
+elib(451)
|
|
-append(451,[MISRA 2012 Directive 4.10, required])
|
|
|
|
/**** Dir 4.11 (Req) ************/
|
|
|
|
/* The arguments to over 100 calls to standard library functions
|
|
are monitored; users can specify additional constraints for
|
|
other functions.
|
|
*/
|
|
|
|
/**** Dir 4.12 (Req) ************/
|
|
|
|
+e586 /* Symbol is deprecated */
|
|
+elib(586)
|
|
-deprecate(function,calloc,[MISRA 2012 Directive 4.12, required])
|
|
-deprecate(function,malloc,[MISRA 2012 Directive 4.12, required])
|
|
-deprecate(function,realloc,[MISRA 2012 Directive 4.12, required])
|
|
-deprecate(function,free,[MISRA 2012 Directive 4.12, required])
|
|
|
|
/**** Dir 4.13 (Adv) ************/
|
|
|
|
/* supported by uncommenting the next six options and use of the
|
|
-function_pair() option */
|
|
// +e480
|
|
// +elib(480)
|
|
// -append(480,[MISRA 2012 Directive 4.13, advisory])
|
|
// +e481
|
|
// +elib(481)
|
|
// -append(481,[MISRA 2012 Directive 4.13, advisory])
|
|
|
|
/**** Rule 1.1 (Req) ************/
|
|
|
|
/* While MISRA has declared this rule to be "undecidable", Gimpel
|
|
* Software provides the following options to assist:
|
|
*/
|
|
-A(C99) /* strict ISO C99 */
|
|
/* Note: if you code to the C90 standard instead, you may
|
|
want to comment out the above option and uncomment the
|
|
following option. You will also want to do likewise for
|
|
other uses of the '-A(C99)' option throughout this file. */
|
|
// -A(C90) /* strict ANSI */
|
|
+e950 /* flag non-standard word or construct */
|
|
+elib(950)
|
|
-append(950,[MISRA 2012 Rule 1.1, required])
|
|
|
|
/**** Rule 1.2 (Adv) ************/
|
|
|
|
/* While MISRA has declared this rule to be "undecidable", Gimpel
|
|
* Software provides the following options to assist:
|
|
*/
|
|
-A(C99) /* strict ISO C99 */
|
|
/* Note: if you code to the C90 standard instead, you may
|
|
want to comment out the above option and uncomment the
|
|
following option. You will also want to do likewise for
|
|
other uses of the '-A(C99)' option throughout this file. */
|
|
// -A(C90) /* strict ANSI */
|
|
+e950 /* flag non-ANSI word or construct */
|
|
+elib(950)
|
|
-append(950,[MISRA 2012 Rule 1.2, advisory])
|
|
|
|
/**** Rule 1.3 (Req) ************/
|
|
|
|
/* While MISRA has declared this rule to be "undecidable", Gimpel
|
|
* Software provides the following options to assist:
|
|
*/
|
|
|
|
/* Avoid the use of undefined or unspecified behavior as described
|
|
in ISO C, Appendix A.6.1 and Appendix A.6.2 */
|
|
|
|
/* Source file not ending in a new-line character, ending in
|
|
new-line character immediately preceded by a backslash
|
|
character, or ending in a partial preprocessing token or
|
|
comment (ISO C, Appendix A.6.2, point 1).
|
|
*/
|
|
+e406 /* unclosed comment */
|
|
+elib(406)
|
|
-append(406,[MISRA 2012 Rule 1.3, required])
|
|
|
|
/* Non-standard character usage (ISO C, Appendix A.6.2, point 2).
|
|
*/
|
|
+e27 /* illegal character */
|
|
+elib(27)
|
|
-append(27,[MISRA 2012 Rule 1.3, required])
|
|
|
|
/* Unclosed quotes (ISO C, Appendix A.6.2, point 4).
|
|
*/
|
|
+e2 /* unclosed quote */
|
|
+elib(2)
|
|
-append(2,[MISRA 2012 Rule 1.3, required])
|
|
|
|
/* Repeated label within a function (ISO C, Appendix A.6.2, point
|
|
5).
|
|
*/
|
|
+e31 /* symbol redefinition */
|
|
+elib(31)
|
|
-append(31,[MISRA 2012 Rule 1.3, required])
|
|
|
|
/* Non-visible identifier used (ISO C, Appendix A.6.2, point 6).
|
|
*/
|
|
+e40 /* undeclared identifier */
|
|
+elib(40)
|
|
-append(40,[MISRA 2012 Rule 1.3, required])
|
|
|
|
/* Identifiers for the same entity differ beyond the minimal
|
|
significant characters (ISO C, Appendix A.6.2, point 7).
|
|
See Rules 5.1, 5.2, 5.4, and 5.5.
|
|
*/
|
|
|
|
/* The same identifier has both internal and external linkage in
|
|
the same translation unit (ISO C, Appendix A.6.2, point 8).
|
|
*/
|
|
+e401 /* symbol not previously declared static */
|
|
+elib(401)
|
|
-append(401,[MISRA 2012 Rule 1.3, required])
|
|
|
|
/* Multiple definitions for the same externally linked identifier
|
|
(ISO C, Appendix A.6.2, point 9).
|
|
*/
|
|
+e31 /* symbol redefinition */
|
|
+elib(31)
|
|
|
|
/* Using automatic storage data via a pointer after the data's
|
|
lifetime (ISO C, Appendix A.6.2, point 10).
|
|
*/
|
|
+e604 /* returning address of auto variable */
|
|
+elib(604)
|
|
-append(604,[MISRA 2012 Rule 1.3, required])
|
|
+e934 /* taking address of near auto variable */
|
|
+elib(934)
|
|
-append(934,[MISRA 2012 Rule 1.3, required])
|
|
|
|
/* Incompatible redeclarations (ISO C, Appendix A.6.2, point 11).
|
|
See Rule 8.3
|
|
*/
|
|
|
|
/* Non-standard escape sequence (ISO C, Appendix A.6.2, point 12).
|
|
*/
|
|
+e606 /* non-ANSI escape sequence */
|
|
+elib(606)
|
|
-append(606,[MISRA 2012 Rule 1.3, required])
|
|
|
|
/* Non-standard character in header name (ISO C, Appendix A.6.2,
|
|
point 15).
|
|
See Rule 20.2
|
|
*/
|
|
+e9020 /* header name with non-standard character */
|
|
+elib(9020)
|
|
-append(9020,[MISRA 2012 Rule 1.3, required])
|
|
|
|
/* No complete type available (ISO C, Appendix A.6.2, point 16).
|
|
*/
|
|
+e86 /* structure has no data elements */
|
|
+elib(86)
|
|
-append(86,[MISRA 2012 Rule 1.3, required])
|
|
|
|
/* Using or converting a void expression (ISO C, Appendix A.6.2,
|
|
point 17).
|
|
*/
|
|
+e64 /* type mismatch */
|
|
+elib(64)
|
|
-append(64,[MISRA 2012 Rule 1.3, required])
|
|
+e67 /* cannot cast between types */
|
|
+elib(67)
|
|
-append(67,[MISRA 2012 Rule 1.3, required])
|
|
+e144 /* non-existent return value */
|
|
+elib(144)
|
|
-append(144,[MISRA 2012 Rule 1.3, required])
|
|
|
|
/* Modifying an object more than once or modifying and accessing
|
|
between two sequence points (ISO C, Appendix A.6.2, point 18).
|
|
See Rule 13.2
|
|
*/
|
|
+e564 /* variable depends on order of evaluation */
|
|
+elib(564)
|
|
-append(564,[MISRA 2012 Rule 1.3, required])
|
|
|
|
/* Invalid arithmetic operations or unrepresentable results
|
|
(ISO C, Appendix A.6.2, point 19).
|
|
*/
|
|
+e54 /* division by 0 */
|
|
+elib(54)
|
|
-append(54,[MISRA 2012 Rule 1.3, required])
|
|
+e414 /* possible division by 0 */
|
|
+elib(414)
|
|
-append(414,[MISRA 2012 Rule 1.3, required])
|
|
+e795 /* conceivable division by 0 */
|
|
+elib(795)
|
|
-append(795,[MISRA 2012 Rule 1.3, required])
|
|
/* Also, see Rule 12.4 */
|
|
|
|
/* Passing a void argument to a function (ISO C, Appendix A.6.2,
|
|
point 20).
|
|
*/
|
|
+e64 /* type mismatch */
|
|
+elib(64)
|
|
|
|
/* Incompatible function redeclaration (ISO C, Appendix A.6.2,
|
|
point 22).
|
|
See Rule 8.3
|
|
*/
|
|
|
|
/* An invalid array reference, null pointer reference, or
|
|
reference to an object declared with automatic storage duration in
|
|
a terminated block occurs (ISO C, Appendix A.6.2, point 24).
|
|
*/
|
|
+e64 /* type mismatch */
|
|
+elib(64)
|
|
+e413 /* likely use of null pointer */
|
|
+elib(413)
|
|
-append(413,[MISRA 2012 Rule 1.3, required])
|
|
+e415 /* out-of-bounds pointer */
|
|
+elib(415)
|
|
-append(415,[MISRA 2012 Rule 1.3, required])
|
|
+e416 /* out-of-bounds pointer */
|
|
+elib(416)
|
|
-append(416,[MISRA 2012 Rule 1.3, required])
|
|
+e428 /* negative subscript */
|
|
+elib(428)
|
|
-append(428,[MISRA 2012 Rule 1.3, required])
|
|
/* Also, see Rule 17.6 */
|
|
|
|
/* A pointer to a function is converted to a pointer to an object
|
|
or a pointer to an object is converted to a pointer to a function
|
|
(ISO C, Appendix A.6.2, point 26).
|
|
*/
|
|
+e64 /* type mismatch */
|
|
+elib(64)
|
|
+e740 /* unusual pointer cast */
|
|
+elib(740)
|
|
-append(740,[MISRA 2012 Rule 1.3, required])
|
|
/* Also, see Rule 11.1 and 11.2 */
|
|
|
|
/* A pointer is converted to other than an integral or pointer
|
|
type (ISO C, Appendix A.6.2, point 27).
|
|
*/
|
|
+e64 /* type mismatch */
|
|
+elib(64)
|
|
+e71 /* cannot cast */
|
|
+elib(71)
|
|
|
|
/* An expression is shifted by a negative number or by an amount
|
|
greater than or equal to the width in bits of the expression being
|
|
shifted (ISO C, Appendix A.6.2, point 30).
|
|
*/
|
|
+e504 /* unusual shift */
|
|
+elib(504)
|
|
-append(504,[MISRA 2012 Rule 1.3, required])
|
|
|
|
/* An identifier for an object is declared with no linkage and the
|
|
type of the object is incomplete after its declarator, or after its
|
|
init-declarator if it has an initializer (ISO C, Appendix
|
|
A.6.2, point 33).
|
|
*/
|
|
+e86 /* structure has no data elements */
|
|
+elib(86)
|
|
|
|
/* Declaring a function at block scope with a storage-class
|
|
specifier other than extern (ISO C, Appendix A.6.2, point 34).
|
|
*/
|
|
+e629 /* static class for function */
|
|
+elib(629)
|
|
-append(629,[MISRA 2012 Rule 1.3, required])
|
|
|
|
/* A bit-field is declared with a type other than int, signed int,
|
|
or unsigned int (ISO C, Appendix A.6.2, point 35).
|
|
See Rule 6.1.
|
|
*/
|
|
|
|
/* Attempting to modify an object with const-qualified type by
|
|
means of an lvalue with non-const-qualified type (ISO C,
|
|
Appendix A.6.2, point 36).
|
|
*/
|
|
+e158 /* assignment increases capability */
|
|
+elib(158)
|
|
-append(158,[MISRA 2012 Rule 1.3, required])
|
|
|
|
/* Attempting to refer to an object with volatile-qualified type
|
|
by means of an lvalue with non-volatile-qualified type (ISO C,
|
|
Appendix A.6.2, point 37).
|
|
*/
|
|
+e158 /* assignment increases capability */
|
|
+elib(158)
|
|
|
|
/* Using the value of uninitialized automatic object (ISO C,
|
|
Appendix A.6.2, point 38).
|
|
See Rule 9.1
|
|
*/
|
|
|
|
/* An object with aggregate or union type with static storage
|
|
duration has a non-brace-enclosed initializer, or an object
|
|
with aggregate or union type with automatic storage duration
|
|
has either a single expression initializer with a type other
|
|
than that of the object or a non-brace-enclosed initializer
|
|
(ISO C, Appendix A.6.2, point 39).
|
|
Also, see Rule 9.2
|
|
*/
|
|
+e64 /* type mismatch */
|
|
+elib(64)
|
|
|
|
/* The value of a function is used, but no value was returned
|
|
(ISO C, Appendix A.6.2, point 40).
|
|
See Rule 17.4.
|
|
*/
|
|
|
|
/* A function that accepts a variable number of arguments is
|
|
defined without a parameter type list that ends with the
|
|
ellipsis notation (ISO C, Appendix A.6.2, point 41).
|
|
*/
|
|
|
|
/* An identifier for an object with internal linkage and an
|
|
incomplete type is declared with a tentative definition (ISO C,
|
|
Appendix A.6.2, point 42).
|
|
*/
|
|
+e86 /* structure has no data elements */
|
|
+elib(86)
|
|
|
|
/* Non-standard #include preprocessing directive (ISO C, Appendix
|
|
A.6.2, point 44).
|
|
See Rule 20.3.
|
|
*/
|
|
|
|
/* Non-standard #line directive (ISO C, Appendix A.6.2, point 49).
|
|
*/
|
|
+"estring(10,a numeric constant)" /* expecting a numeric constant */
|
|
|
|
/* #defining or #undefing any of: defined, __LINE__, __FILE__,
|
|
__DATE__, __TIME__, or __STDC__ (ISO C, Appendix A.6.2, point 50).
|
|
*/
|
|
+e136 /* illegal macro name */
|
|
+elib(136)
|
|
-append(136,[MISRA 2012 Rule 1.3, required])
|
|
|
|
/* Format-argument mismatch in an fprintf or fscanf type of
|
|
function (ISO C, Appendix A.6.2, point 75).
|
|
*/
|
|
+e558 /* too few arguments */
|
|
+elib(558)
|
|
-append(558,[MISRA 2012 Rule 1.3, required])
|
|
+e719 /* too many arguments */
|
|
+elib(719)
|
|
-append(719,[MISRA 2012 Rule 1.3, required])
|
|
|
|
/* A %% conversion specification for the fprintf or fscanf
|
|
function contains characters between the pair of % characters
|
|
(ISO C, Appendix A.6.2, point 77).
|
|
*/
|
|
+e557 /* unrecognized format */
|
|
+elib(557)
|
|
-append(557,[MISRA 2012 Rule 1.3, required])
|
|
|
|
/* An aggregate or union, or a pointer to an aggregate or union is
|
|
an argument to the fprintf function, except for the conversion
|
|
specifiers %s (for an array of character type) or %p (for a pointer
|
|
to void) (ISO C, Appendix A.6.2, point 81).
|
|
*/
|
|
+e437 /* passing struct to ellipsis */
|
|
+elib(437)
|
|
-append(437,[MISRA 2012 Rule 1.3, required])
|
|
|
|
/* Referring to deallocated space (ISO C, Appendix A.6.2, point
|
|
87).
|
|
*/
|
|
+e449 /* previously deallocated pointer */
|
|
+elib(449)
|
|
-append(449,[MISRA 2012 Rule 1.3, required])
|
|
|
|
/* Misuse of free or realloc (ISO C, Appendix A.6.2, point 88).
|
|
*/
|
|
+esym(424,free) /* inappropriate deallocation */
|
|
-append(424,[MISRA 2012 Rule 1.3, required])
|
|
|
|
/* An array written to by a copying or concatenation function is
|
|
too small (ISO C, Appendix A.6.2, point 91).
|
|
*/
|
|
+e419 /* data overrun */
|
|
+elib(419)
|
|
-append(419,[MISRA 2012 Rule 1.3, required])
|
|
|
|
/* Order of evaluation (ISO C, Appendix A.6.1, point 7).
|
|
*/
|
|
+e564 /* variable depends on order of evaluation */
|
|
+elib(564)
|
|
-append(564,[MISRA 2012 Rule 1.3, required])
|
|
|
|
/* Side effects order (ISO C, Appendix A.6.1, point 8).
|
|
*/
|
|
+e931 /* both sides of an expression have side-effects */
|
|
+elib(931)
|
|
-append(931,[MISRA 2012 Rule 1.3, required])
|
|
|
|
/* Function argument evaluation (ISO C, Appendix A.6.1, point 9).
|
|
*/
|
|
+e564 /* variable depends on order of evaluation */
|
|
+elib(564)
|
|
|
|
/* The order in which # and ## operations are evaluated during
|
|
macro substitution (ISO C, Appendix A.6.1, point 12).
|
|
*/
|
|
+e9023 /* multiple '#/##' operators in macro definition */
|
|
+elib(9023)
|
|
-append(9023,[MISRA 2012 Rule 1.3, required])
|
|
|
|
/* Whether setjmp is a macro or an external identifier (ISO C,
|
|
Appendix A.6.1, point 14).
|
|
See Rule 21.2.
|
|
*/
|
|
|
|
/**** Rule 2.1 (Req) ************/
|
|
|
|
/* While MISRA has declared this rule to be "undecidable", Gimpel
|
|
* Software provides the following options to assist:
|
|
*/
|
|
+e506 /* constant value boolean */
|
|
+elib(506)
|
|
-append(506,[MISRA 2012 Rule 2.1, required])
|
|
+e527 /* unreachable */
|
|
+elib(527)
|
|
-append(527,[MISRA 2012 Rule 2.1, required])
|
|
+e681 /* loop not entered */
|
|
+elib(681)
|
|
-append(681,[MISRA 2012 Rule 2.1, required])
|
|
+e827 /* loop not reachable */
|
|
+elib(827)
|
|
-append(827,[MISRA 2012 Rule 2.1, required])
|
|
|
|
/**** Rule 2.2 (Req) ************/
|
|
|
|
/* While MISRA has declared this rule to be "undecidable", Gimpel
|
|
* Software provides the following options to assist:
|
|
*/
|
|
+e438 /* value not used */
|
|
+elib(438)
|
|
-append(438,[MISRA 2012 Rule 2.2, required])
|
|
+e505 /* redundant argument to comma */
|
|
+elib(505)
|
|
-append(505,[MISRA 2012 Rule 2.2, required])
|
|
+e520 /* highest operator has no side effects */
|
|
+elib(520)
|
|
-append(520,[MISRA 2012 Rule 2.2, required])
|
|
+e521 /* highest operator has no side effects */
|
|
+elib(521)
|
|
-append(521,[MISRA 2012 Rule 2.2, required])
|
|
+e522 /* highest operator has no side effects */
|
|
+elib(522)
|
|
-append(522,[MISRA 2012 Rule 2.2, required])
|
|
|
|
/**** Rule 2.3 (Adv) ************/
|
|
|
|
+e751 /* local typedef not referenced */
|
|
+elib(751)
|
|
-append(751,[MISRA 2012 Rule 2.3, advisory])
|
|
+e756 /* global not referenced */
|
|
+elib(756)
|
|
-append(756,[MISRA 2012 Rule 2.3, advisory])
|
|
|
|
/**** Rule 2.4 (Adv) ************/
|
|
|
|
+e753 /* local tag not referenced */
|
|
+elib(753)
|
|
-append(753,[MISRA 2012 Rule 2.4, advisory])
|
|
+e9058
|
|
+elibsym(9058)
|
|
-append(9058,[MISRA 2012 Rule 2.4, advisory])
|
|
|
|
/**** Rule 2.5 (Adv) ************/
|
|
|
|
+e750 /* local macro not referenced */
|
|
+elib(750)
|
|
-append(750,[MISRA 2012 Rule 2.5, advisory])
|
|
+e755 /* global macro not referenced */
|
|
+elib(755)
|
|
-append(755,[MISRA 2012 Rule 2.5, advisory])
|
|
|
|
/**** Rule 2.6 (Adv) ************/
|
|
|
|
+e563 /* label not referenced */
|
|
+elib(563)
|
|
-append(563,[MISRA 2012 Rule 2.6, advisory])
|
|
|
|
/**** Rule 2.7 (Adv) ************/
|
|
|
|
+e715 /* not referenced */
|
|
+elib(715)
|
|
-append(715,[MISRA 2012 Rule 2.7, advisory])
|
|
|
|
/**** Rule 3.1 (Req) ************/
|
|
|
|
-fnc /* flag nested comments */
|
|
+e602 /* comment within comment */
|
|
+elib(602)
|
|
-append(602,[MISRA 2012 Rule 3.1, required])
|
|
+e9059
|
|
+elib(9059)
|
|
-append(9059,[MISRA 2012 Rule 3.1, required])
|
|
+e9066
|
|
+elib(9066)
|
|
-append(9066,[MISRA 2012 Rule 3.1, required])
|
|
|
|
/**** Rule 3.2 (Req) ************/
|
|
|
|
+e427 /* C++ comment ends in \\ */
|
|
+elib(427)
|
|
-append(427,[MISRA 2012 Rule 3.2, required])
|
|
|
|
/**** Rule 4.1 (Req) ************/
|
|
|
|
+e9039 /* prohibited escape sequence */
|
|
+elib(9039)
|
|
-append(9039,[MISRA 2012 Rule 4.1, required])
|
|
|
|
/**** Rule 4.2 (Adv) ************/
|
|
|
|
-ftg /* inhibit use of trigraphs */
|
|
+e584 /* activate trigraph detected message */
|
|
+elib(584)
|
|
-append(584,[MISRA 2012 Rule 4.2, advisory])
|
|
+e739 /* activate trigraph in string message */
|
|
+elib(739)
|
|
-append(739,[MISRA 2012 Rule 4.2, advisory])
|
|
+e9060 /* trigraph in comment */
|
|
+elib(9060)
|
|
-append(9060,[MISRA 2012 Rule 4.2, advisory])
|
|
|
|
/**** Rule 5.1 (Req) ************/
|
|
|
|
-idlen(31) /* flag names identical in the first 31 characters */
|
|
+e621 /* Identifier clash - length set by -idlen */
|
|
+elib(621)
|
|
-append(621,[MISRA 2012 Rule 5.1, required])
|
|
|
|
/**** Rule 5.2 (Req) ************/
|
|
|
|
-idlen(31) /* flag names identical in the first 31 characters */
|
|
+e621 /* Identifier clash - length set by -idlen */
|
|
+elib(621)
|
|
-append(621,[MISRA 2012 Rule 5.2, required])
|
|
|
|
/**** Rule 5.3 (Req) ************/
|
|
|
|
+e578 /* enable reports of name hiding */
|
|
+elib(578)
|
|
-append(578,[MISRA 2012 Rule 5.3, required])
|
|
|
|
/**** Rule 5.4 (Req) ************/
|
|
|
|
-idlen(31) /* flag names identical in the first 31 characters */
|
|
+e621 /* Identifier clash - length set by -idlen */
|
|
+elib(621)
|
|
-append(621,[MISRA 2012 Rule 5.4, required])
|
|
|
|
/**** Rule 5.5 (Req) ************/
|
|
|
|
+e123 /* macro defined with arguments */
|
|
+elib(123)
|
|
-append(123,[MISRA 2012 Rule 5.5, required])
|
|
-idlen(31) /* flag names identical in the first 31 characters */
|
|
+e621 /* Identifier clash - length set by -idlen */
|
|
+elib(621)
|
|
-append(621,[MISRA 2012 Rule 5.5, required])
|
|
+e9061 /* non-distinct identifier */
|
|
+elib(9061)
|
|
-append(9061,[MISRA 2012 Rule 5.5, required])
|
|
|
|
/**** Rule 5.6 (Req) ************/
|
|
|
|
+e578 /* enable reports of name hiding */
|
|
+elib(578)
|
|
-append(578,[MISRA 2012 Rule 5.6, required])
|
|
+e623 /* redefining the storage class of symbol */
|
|
+elib(623)
|
|
-append(623,[MISRA 2012 Rule 5.6, required])
|
|
+estring(9062,typedef) /* non-unique typedef */
|
|
+elib(9062)
|
|
-append(9062(typedef),[MISRA 2012 Rule 5.6, required])
|
|
|
|
/**** Rule 5.7 (Req) ************/
|
|
|
|
+e407 /* Inconsistent use of tag */
|
|
+elib(407)
|
|
-append(407,[MISRA 2012 Rule 5.7, required])
|
|
+e578 /* Declaration of Symbol hides Symbol */
|
|
+elib(578)
|
|
-append(578,[MISRA 2012 Rule 5.7, required])
|
|
+e14 /* Symbol previously defined */
|
|
+elib(14)
|
|
-append(14,[MISRA 2012 Rule 5.7, required])
|
|
+e15 /* Symbol redeclared */
|
|
+elib(15)
|
|
-append(15,[MISRA 2012 Rule 5.7, required])
|
|
+e631 /* Tag defined differently */
|
|
+elib(631)
|
|
-append(631,[MISRA 2012 Rule 5.7, required])
|
|
+e9062 /* non-unique tag */
|
|
+elib(9062)
|
|
-append(9062(tag),[MISRA 2012 Rule 5.7, required])
|
|
|
|
/**** Rule 5.8 (Req) ************/
|
|
|
|
+e401 /* Symbol not previously declared static */
|
|
+elib(401)
|
|
-append(401,[MISRA 2012 Rule 5.8, required])
|
|
+e578 /* Declaration of Symbol hides Symbol */
|
|
+elib(578)
|
|
-append(578,[MISRA 2012 Rule 5.8, required])
|
|
+e580 /* enable reports of name hiding */
|
|
+elib(580)
|
|
-append(580,[MISRA 2012 Rule 5.8, required])
|
|
|
|
/**** Rule 5.9 (Adv) ************/
|
|
|
|
+e578 /* enable reports of name hiding */
|
|
+elib(578)
|
|
-append(578,[MISRA 2012 Rule 5.9, advisory])
|
|
+e580 /* enable reports of name hiding */
|
|
+elib(580)
|
|
-append(580,[MISRA 2012 Rule 5.9, advisory])
|
|
|
|
/**** Rule 6.1 (Req) ************/
|
|
|
|
+e46 /* field type should be int */
|
|
+elib(46)
|
|
-append(46,[MISRA 2012 Rule 6.1, required])
|
|
+e806 /* small bit field is signed rather than unsigned */
|
|
+elib(806)
|
|
-append(806,[MISRA 2012 Rule 6.1, required])
|
|
|
|
/**** Rule 6.2 (Req) ************/
|
|
|
|
+e9088 /* named signed single-bit bit-field */
|
|
+elib(9088)
|
|
-append(9088,[MISRA 2012 Rule 6.2, required])
|
|
|
|
/**** Rule 7.1 (Req) ************/
|
|
|
|
+e9001 /* Octal constant used */
|
|
+elib(9001)
|
|
-append(9001,[MISRA 2012 Rule 7.1, required])
|
|
|
|
/**** Rule 7.2 (Req) ************/
|
|
|
|
+e9048 /* unsigned literal without 'U' suffix */
|
|
+elib(9048)
|
|
-append(9048,[MISRA 2012 Rule 7.2, required])
|
|
|
|
/**** Rule 7.3 (Req) ************/
|
|
|
|
+e620 /* suspicious constant */
|
|
+elib(620)
|
|
-append(620,[MISRA 2012 Rule 7.3, required])
|
|
+e9057 /* "l" after "u" in literal suffix */
|
|
+elib(9057)
|
|
-append(9057,[MISRA 2012 Rule 7.3, required])
|
|
|
|
/**** Rule 7.4 (Req) ************/
|
|
|
|
+fsc
|
|
+e489 /* attempting to modify a string literal */
|
|
+elib(489)
|
|
-append(489,[MISRA 2012 Rule 7.4, required])
|
|
+e1776 /* string literal not const safe */
|
|
+elib(1776)
|
|
-append(1776,[MISRA 2012 Rule 7.4, required])
|
|
+e1778 /* assignment of string literal not const safe */
|
|
+elib(1778)
|
|
-append(1778,[MISRA 2012 Rule 7.4, required])
|
|
|
|
/**** Rule 8.1 (Req) ************/
|
|
|
|
+e601 /* no explicit type */
|
|
+elib(601)
|
|
-append(601,[MISRA 2012 Rule 8.1, required])
|
|
+e745 /* function has no explicit type */
|
|
+elib(745)
|
|
-append(745,[MISRA 2012 Rule 8.1, required])
|
|
+e808 /* no explicit type */
|
|
+elib(808)
|
|
-append(808,[MISRA 2012 Rule 8.1, required])
|
|
+e832 /* parameter has no explicit type */
|
|
+elib(832)
|
|
-append(832,[MISRA 2012 Rule 8.1, required])
|
|
+e939 /* return type defaults to int */
|
|
+elib(939)
|
|
-append(939,[MISRA 2012 Rule 8.1, required])
|
|
|
|
/**** Rule 8.2 (Req) ************/
|
|
|
|
+e937 /* old-style function declaration */
|
|
+elib(937)
|
|
-append(937,[MISRA 2012 Rule 8.2, required])
|
|
+e745 /* function has no explicit type */
|
|
+elib(745)
|
|
-append(745,[MISRA 2012 Rule 8.2, required])
|
|
+e939 /* return type defaults to int */
|
|
+elib(939)
|
|
-append(939,[MISRA 2012 Rule 8.2, required])
|
|
-fvr /* varying return mode not allowed */
|
|
-strong() /* enable strong typing for
|
|
declarations */
|
|
+e18 /* symbol redeclared */
|
|
+elib(18)
|
|
-append(18,[MISRA 2012 Rule 8.2, required])
|
|
|
|
+e936 /* old-style function definition */
|
|
+elib(936)
|
|
-append(936,[MISRA 2012 Rule 8.2, required])
|
|
|
|
+e955 /* param name missing from prototype */
|
|
+elib(955)
|
|
-append(955,[MISRA 2012 Rule 8.2, required])
|
|
|
|
/**** Rule 8.3 (Req) ************/
|
|
|
|
-fvr /* varying return mode not allowed */
|
|
-strong() /* enable strong typing for declarations */
|
|
+e18 /* symbol redeclared */
|
|
+elib(18)
|
|
-append(18,[MISRA 2012 Rule 8.3, required])
|
|
+e516 /* argument type conflict */
|
|
+elib(516)
|
|
-append(516,[MISRA 2012 Rule 8.3, required])
|
|
+e532 /* return mode of symbol inconsistent */
|
|
+elib(532)
|
|
-append(532,[MISRA 2012 Rule 8.3, required])
|
|
+e9072 /* parameter list differs */
|
|
+elib(9072)
|
|
-append(9072,[MISRA 2012 Rule 8.3, required])
|
|
|
|
/**** Rule 8.4 (Req) ************/
|
|
|
|
+e15 /* symbol redeclared */
|
|
+elib(15)
|
|
-append(15,[MISRA 2012 Rule 8.4, required])
|
|
+e64 /* flag type mismatch */
|
|
+elib(64)
|
|
-append(64,[MISRA 2012 Rule 8.4, required])
|
|
+e516 /* argument type mismatch */
|
|
+elib(516)
|
|
-append(516,[MISRA 2012 Rule 8.4, required])
|
|
+e9075 /* extern defined without prior declaration */
|
|
+elib(9075)
|
|
-append(9075,[MISRA 2012 Rule 8.4, required])
|
|
|
|
/**** Rule 8.5 (Req) ************/
|
|
|
|
+e9004 /* object/function previously declared */
|
|
+elib(9004)
|
|
-append(9004,[MISRA 2012 Rule 8.5, required])
|
|
|
|
/**** Rule 8.6 (Req) ************/
|
|
|
|
--fmd /* diallow multiple definitions */
|
|
+e14 /* Symbol previously defined */
|
|
+elib(14)
|
|
-append(14,[MISRA 2012 Rule 8.6, required])
|
|
|
|
/**** Rule 8.7 (Adv) ************/
|
|
|
|
+e765 /* could be made static */
|
|
+elib(765)
|
|
-append(765,[MISRA 2012 Rule 8.7, advisory])
|
|
|
|
/**** Rule 8.8 (Req) ************/
|
|
|
|
+e839 /* storage class assumed static */
|
|
+elib(839)
|
|
-append(839,[MISRA 2012 Rule 8.8, required])
|
|
|
|
/**** Rule 8.9 (Adv) ************/
|
|
|
|
+e9003 /* could define variable at block scope */
|
|
+elib(9003)
|
|
-append(9003,[MISRA 2012 Rule 8.9, advisory])
|
|
|
|
/**** Rule 8.10 (Req) ************/
|
|
|
|
+e695 /* inline function without storage-class specifier */
|
|
+elib(695)
|
|
-append(695,[MISRA 2012 Rule 8.10, required])
|
|
+estring(9056,extern) /* inline function defined with extern */
|
|
-append(9056,[MISRA 2012 Rule 8.10, required])
|
|
|
|
/**** Rule 8.11 (Adv) ************/
|
|
|
|
+e9067 /* array has no dimension or initializer */
|
|
+elib(9067)
|
|
-append(9067,[MISRA 2012 Rule 8.11, advisory])
|
|
|
|
/**** Rule 8.12 (Req) ************/
|
|
|
|
+e488 /* duplicate enumerator values */
|
|
+elib(488)
|
|
-append(488,[MISRA 2012 Rule 8.12, required])
|
|
|
|
/**** Rule 8.13 (Adv) ************/
|
|
|
|
/* While MISRA has declared this rule to be "undecidable", Gimpel
|
|
* Software provides the following options to assist:
|
|
*/
|
|
+e818 /* pointer could be declared pointing to const */
|
|
+elib(818)
|
|
-append(818,[MISRA 2012 Rule 8.13, advisory])
|
|
+e844 /* pointer could be declared pointing to const */
|
|
+elib(844)
|
|
-append(844,[MISRA 2012 Rule 8.13, advisory])
|
|
+e954 /* pointer could be declared pointing to const */
|
|
+elib(954)
|
|
-append(954,[MISRA 2012 Rule 8.13, advisory])
|
|
|
|
/**** Rule 8.14 (Req) ************/
|
|
|
|
+e586 /* Symbol is deprecated */
|
|
+elib(586)
|
|
-deprecate(keyword,restrict,[MISRA 2012 Rule 8.14, required])
|
|
|
|
/**** Rule 9.1 (Mand) ************/
|
|
|
|
/* While MISRA has declared this rule to be "undecidable", Gimpel
|
|
* Software provides the following options to assist:
|
|
*/
|
|
+e644 /* Symbol may not have been initialized */
|
|
+elib(644)
|
|
-append(644,[MISRA 2012 Rule 9.1, mandatory])
|
|
+e771 /* Symbol conceivably not initialized */
|
|
+elib(771)
|
|
-append(771,[MISRA 2012 Rule 9.1, mandatory])
|
|
+e530 /* Symbol not initialized */
|
|
+elib(530)
|
|
-append(530,[MISRA 2012 Rule 9.1, mandatory])
|
|
-specific(+e644 +e771 +e530,)
|
|
|
|
/**** Rule 9.2 (Req) ************/
|
|
|
|
+e9069 /* omitted braces within an initializer */
|
|
+elib(9069)
|
|
-append(9069,[MISRA 2012 Rule 9.2, required])
|
|
|
|
/**** Rule 9.3 (Req) ************/
|
|
|
|
+e9068 /* too few initializers */
|
|
+elib(9068)
|
|
-append(9068,[MISRA 2012 Rule 9.3, required])
|
|
|
|
/**** Rule 9.4 (Req) ************/
|
|
|
|
+e485 /* duplicate initialization */
|
|
+elib(485)
|
|
-append(485,[MISRA 2012 Rule 9.4, required])
|
|
|
|
/**** Rule 9.5 (Req) ************/
|
|
|
|
+e9054 /* designated initializer and dimensionless array */
|
|
+elib(9054)
|
|
-append(9054,[MISRA 2012 Rule 9.5, required])
|
|
|
|
/**** Rule 10.1 (Req) ************/
|
|
|
|
+e48 /* bad type */
|
|
+elib(48)
|
|
-append(48,[MISRA 2012 Rule 10.1, required])
|
|
+e9027 /* unpermitted operand */
|
|
+elib(9027)
|
|
-append(9027,[MISRA 2012 Rule 10.1, required])
|
|
|
|
/**** Rule 10.2 (Req) ************/
|
|
|
|
+e9028 /* unpermitted arithmetic */
|
|
+elib(9028)
|
|
-append(9028,[MISRA 2012 Rule 10.2, required])
|
|
|
|
/**** Rule 10.3 (Req) ************/
|
|
|
|
+e9034 /* expression assigned to narrower or different essential type */
|
|
+elib(9034)
|
|
// Note: the following -d options for true and false don't apply
|
|
// to C90 and should be commented out if not using C99
|
|
+"dtrue=/*lint -save -e921 */(_Bool) 1/*lint -restore */" // exception
|
|
+"dfalse=/*lint -save -e921 */(_Bool) 0/*lint -restore */" // exception
|
|
-append(9034,[MISRA 2012 Rule 10.3, required])
|
|
|
|
/**** Rule 10.4 (Req) ************/
|
|
|
|
+e9029 /* mismatched essential type */
|
|
+elib(9029)
|
|
-append(9029,[MISRA 2012 Rule 10.4, required])
|
|
|
|
/**** Rule 10.5 (Adv) ************/
|
|
|
|
+e9030 /* impermissible cast */
|
|
+elib(9030)
|
|
-append(9030,[MISRA 2012 Rule 10.5, advisory])
|
|
|
|
/**** Rule 10.6 (Req) ************/
|
|
|
|
+e9031 /* composite expression assigned to wider essential type */
|
|
+elib(9031)
|
|
-append(9031,[MISRA 2012 Rule 10.6, required])
|
|
|
|
/**** Rule 10.7 (Req) ************/
|
|
|
|
+e9032 /* composite expression with smaller essential type than other operand*/
|
|
+elib(9032)
|
|
-append(9032,[MISRA 2012 Rule 10.7, required])
|
|
|
|
/**** Rule 10.8 (Req) ************/
|
|
|
|
+e9033 /* impermissible cast of composite expression */
|
|
+elib(9033)
|
|
-append(9033,[MISRA 2012 Rule 10.8, required])
|
|
|
|
/**** Rule 11.1 (Req) ************/
|
|
|
|
+e9074 /* conversion between a pointer to function and another type */
|
|
+elib(9074)
|
|
--emacro((9074),NULL) /* explicit exception */
|
|
-append(9074,[MISRA 2012 Rule 11.1, required])
|
|
|
|
/**** Rule 11.2 (Req) ************/
|
|
|
|
+e9076 /* conversion between a pointer to incomplete type and another type */
|
|
+elib(9076)
|
|
--emacro((9076),NULL) /* explicit exception */
|
|
-append(9076,[MISRA 2012 Rule 11.2, required])
|
|
|
|
/**** Rule 11.3 (Req) ************/
|
|
|
|
+e9087 /* cast from pointer to pointer */
|
|
+elib(9087)
|
|
-append(9087,[MISRA 2012 Rule 11.3, required])
|
|
|
|
/**** Rule 11.4 (Adv) ************/
|
|
|
|
+e9078 /* cast pointer/integer */
|
|
+elib(9078)
|
|
-append(9078,[MISRA 2012 Rule 11.4, advisory])
|
|
|
|
/**** Rule 11.5 (Adv) ************/
|
|
|
|
+e9079 /* cast from pointer to pointer */
|
|
+elib(9079)
|
|
-append(9079,[MISRA 2012 Rule 11.5, advisory])
|
|
|
|
/**** Rule 11.6 (Req) ************/
|
|
|
|
+e923 /* cast pointer/non-pointer */
|
|
+elib(923)
|
|
-append(923,[MISRA 2012 Rule 11.6, required])
|
|
|
|
/**** Rule 11.7 (Req) ************/
|
|
|
|
+e68 /* cast pointer/float */
|
|
+elib(68)
|
|
-append(68,[MISRA 2012 Rule 11.7, required])
|
|
+e70 /* cast pointer/float */
|
|
+elib(70)
|
|
-append(70,[MISRA 2012 Rule 11.7, required])
|
|
|
|
/**** Rule 11.8 (Req) ************/
|
|
|
|
+e9005 /* attempt to cast away const/volatile from pointer or reference */
|
|
+elib(9005)
|
|
-append(9005,[MISRA 2012 Rule 11.8, required])
|
|
|
|
/**** Rule 11.9 (Req) ************/
|
|
|
|
+e910 /* conversion from 0 to pointer */
|
|
+elib(910)
|
|
--emacro((910),NULL) /* explicit exception */
|
|
-append(910,[MISRA 2012 Rule 11.9, required])
|
|
+e9080 /* integer null pointer constant */
|
|
+elib(9080)
|
|
-append(9080,[MISRA 2012 Rule 11.9, required])
|
|
|
|
/**** Rule 12.1 (Adv) ************/
|
|
|
|
+e9050 /* dependence placed on precedence */
|
|
+elib(9050)
|
|
-append(9050,[MISRA 2012 Rule 12.1, advisory])
|
|
|
|
/**** Rule 12.2 (Req) ************/
|
|
|
|
/* While MISRA has declared this rule to be "undecidable", Gimpel
|
|
* Software provides the following options to assist:
|
|
*/
|
|
+e598 /* excessive left shift */
|
|
+elib(598)
|
|
-append(598,[MISRA 2012 Rule 12.2, required])
|
|
+e9053 /* shift value exceeds size of LHS */
|
|
+elib(9053)
|
|
-append(9053,[MISRA 2012 Rule 12.2, required])
|
|
|
|
/**** Rule 12.3 (Adv) ************/
|
|
|
|
+e9008 /* comma operator used */
|
|
+elib(9008)
|
|
-append(9008,[MISRA 2012 Rule 12.3, advisory])
|
|
|
|
/**** Rule 12.4 (Adv) ************/
|
|
|
|
+elib(648) /* Overflow in computing constant */
|
|
+estring(648,unsigned addition)
|
|
+estring(648,unsigned multiplication)
|
|
+estring(648,unsigned sub.)
|
|
+estring(648,unsigned shift left)
|
|
+estring(648,unsigned shift right)
|
|
-append(648,[MISRA 2012 Rule 12.4, advisory])
|
|
|
|
/**** Rule 13.1 (Req) ************/
|
|
|
|
/* While MISRA has declared this rule to be "undecidable", Gimpel
|
|
* Software provides the following options to assist:
|
|
*/
|
|
+e446 /* side effect in initializer */
|
|
+elib(446)
|
|
-append(446,[MISRA 2012 Rule 13.1, required])
|
|
|
|
/**** Rule 13.2 (Req) ************/
|
|
|
|
/* While MISRA has declared this rule to be "undecidable", Gimpel
|
|
* Software provides the following options to assist:
|
|
*/
|
|
+e564 /* variable depends on order of evaluation */
|
|
+elib(564)
|
|
-append(564,[MISRA 2012 Rule 13.2, required])
|
|
+e864 /* variable possibly depends on order of evaluation */
|
|
+elib(864)
|
|
-append(864,[MISRA 2012 Rule 13.2, required])
|
|
+e931 /* both sides have side effects */
|
|
+elib(931)
|
|
-append(931,[MISRA 2012 Rule 13.2, required])
|
|
|
|
/**** Rule 13.3 (Adv) ************/
|
|
|
|
+e9049 /* increment/decrement combined with other operations */
|
|
+elib(9049)
|
|
-append(9049,[MISRA 2012 Rule 13.3, advisory])
|
|
|
|
/**** Rule 13.4 (Adv) ************/
|
|
|
|
+e720 /* Boolean test of assignment */
|
|
+elib(720)
|
|
-append(720,[MISRA 2012 Rule 13.4, advisory])
|
|
+e820 /* Boolean test of parenthesized assignment */
|
|
+elib(820)
|
|
-append(820,[MISRA 2012 Rule 13.4, advisory])
|
|
+e9084 /* assignment used inside larger
|
|
expression */
|
|
+elib(9084)
|
|
-append(9084,[MISRA 2012 Rule 13.4, advisory])
|
|
|
|
/**** Rule 13.5 (Req) ************/
|
|
|
|
/* While MISRA has declared this rule to be "undecidable", Gimpel
|
|
* Software provides the following options to assist:
|
|
*/
|
|
+e9007 /* side effects on right hand side of logical operator */
|
|
+elib(9007)
|
|
-append(9007,[MISRA 2012 Rule 13.5, required])
|
|
|
|
/**** Rule 13.6 (Mand) ************/
|
|
|
|
+e9006 /* sizeof used with expression with side effect */
|
|
+elib(9006)
|
|
-append(9006,[MISRA 2012 Rule 13.6, mandatory])
|
|
+e9089 /* potential side-effect in argument to sizeof */
|
|
+elib(9089)
|
|
-append(9089,[MISRA 2012 Rule 13.6, mandatory])
|
|
|
|
/**** Rule 14.1 (Req) ************/
|
|
|
|
/* While MISRA has declared this rule to be "undecidable", Gimpel
|
|
* Software provides the following options to assist:
|
|
*/
|
|
+e9009 /* floating point variable used as loop counter */
|
|
+elib(9009)
|
|
-append(9009,[MISRA 2012 Rule 14.1, required])
|
|
|
|
/**** Rule 14.2 (Req) ************/
|
|
|
|
/* While MISRA has declared this rule to be "undecidable", Gimpel
|
|
* Software provides the following options to assist:
|
|
*/
|
|
+e850 /* index variable modified in body of for loop */
|
|
+elib(850)
|
|
-append(850,[MISRA 2012 Rule 14.2, required])
|
|
|
|
/**** Rule 14.3 (Req) ************/
|
|
|
|
/* While MISRA has declared this rule to be "undecidable", Gimpel
|
|
* Software provides the following options to assist:
|
|
*/
|
|
+e685 /* relational always evaluates to true/false */
|
|
+elib(685)
|
|
-append(685,[MISRA 2012 Rule 14.3, required])
|
|
+e774 /* boolean always evaluates to true/false */
|
|
+elib(774)
|
|
-append(774,[MISRA 2012 Rule 14.3, required])
|
|
+e650 /* constant out of range for operator */
|
|
+elib(650)
|
|
-append(650,[MISRA 2012 Rule 14.3, required])
|
|
|
|
/**** Rule 14.4 (Req) ************/
|
|
|
|
+e9036 /* condition should have essentially Boolean type */
|
|
+elib(9036)
|
|
-append(9036,[MISRA 2012 Rule 14.4, required])
|
|
|
|
/**** Rule 15.1 (Adv) ************/
|
|
|
|
+e801 /* use of 'goto' is deprecated */
|
|
+elib(801)
|
|
-append(801,[MISRA 2012 Rule 15.1, advisory])
|
|
|
|
/**** Rule 15.2 (Req) ************/
|
|
|
|
+e9064 /* goto references earlier label */
|
|
+elib(9064)
|
|
-append(9064,[MISRA 2012 Rule 15.2, required])
|
|
|
|
/**** Rule 15.3 (Req) ************/
|
|
|
|
+e9041 /* goto not nested in the same block as label */
|
|
+elib(9041)
|
|
-append(9041,[MISRA 2012 Rule 15.3, required])
|
|
|
|
/**** Rule 15.4 (Adv) ************/
|
|
|
|
+e9011 /* more than one 'break' terminates loop */
|
|
+elib(9011)
|
|
-append(9011,[MISRA 2012 Rule 15.4, advisory])
|
|
|
|
/**** Rule 15.5 (Adv) ************/
|
|
|
|
+e904 /* return before function end */
|
|
+elib(904)
|
|
-append(904,[MISRA 2012 Rule 15.5, advisory])
|
|
|
|
/**** Rule 15.6 (Req) ************/
|
|
|
|
+e9012 /* sub-statement should be a compound statement */
|
|
+elib(9012)
|
|
-append(9012,[MISRA 2012 Rule 15.6, required])
|
|
|
|
/**** Rule 15.7 (Req) ************/
|
|
|
|
+e9013 /* no 'else' at end of 'if ... else if' chain */
|
|
+elib(9013)
|
|
-append(9013,[MISRA 2012 Rule 15.7, required])
|
|
+e9063 /* no comment or action in else-branch */
|
|
+elib(9063)
|
|
-append(9063,[MISRA 2012 Rule 15.7, required])
|
|
|
|
/**** Rule 16.1 (Req) ************/
|
|
|
|
+e616 /* control flows into case/default */
|
|
+elib(616)
|
|
-append(616,[MISRA 2012 Rule 16.1, required])
|
|
+e744 /* switch statement has no default */
|
|
+elib(744)
|
|
-append(744,[MISRA 2012 Rule 16.1, required])
|
|
+e764 /* switch does not have a case */
|
|
+elib(764)
|
|
-append(764,[MISRA 2012 Rule 16.1, required])
|
|
+e825 /* control flows into case/default without -fallthrough comment */
|
|
+elib(825)
|
|
-append(825,[MISRA 2012 Rule 16.1, required])
|
|
+e9014 /* default missing from switch */
|
|
+elib(9014)
|
|
-append(9014,[MISRA 2012 Rule 16.1, required])
|
|
+e9042 /* departure from MISRA switch syntax */
|
|
+elib(9042)
|
|
-append(9042,[MISRA 2012 Rule 16.1, required])
|
|
+e9077 /* missing unconditional break */
|
|
+elib(9077)
|
|
-append(9077,[MISRA 2012 Rule 16.1, required])
|
|
+e9081 /* too few independent cases for switch */
|
|
+elib(9081)
|
|
-append(9081,[MISRA 2012 Rule 16.1, required])
|
|
+e9082 /* switch statement should either begin or end with default label */
|
|
+elib(9082)
|
|
-append(9082,[MISRA 2012 Rule 16.1, required])
|
|
+e9085 /* statement or comment should appear in default case */
|
|
+elib(9085)
|
|
-append(9085,[MISRA 2012 Rule 16.1, required])
|
|
|
|
/**** Rule 16.2 (Req) ************/
|
|
|
|
+e44 /* Need a switch */
|
|
+elib(44)
|
|
-append(44,[MISRA 2012 Rule 16.2, required])
|
|
+e9055 /* enclosing statement is not a switch */
|
|
+elib(9055)
|
|
-append(9055,[MISRA 2012 Rule 16.2, required])
|
|
|
|
/**** Rule 16.3 (Req) ************/
|
|
|
|
+e616 /* control flows into case/default */
|
|
+elib(616)
|
|
-append(616,[MISRA 2012 Rule 16.3, required])
|
|
+e825 /* control flows into case/default without -fallthrough comment */
|
|
+elib(825)
|
|
-append(825,[MISRA 2012 Rule 16.3, required])
|
|
+e9077 /* missing unconditional break */
|
|
+elib(9077)
|
|
-append(9077,[MISRA 2012 Rule 16.3, required])
|
|
+e9090 /* missing unconditional break */
|
|
+elib(9090)
|
|
-append(9090,[MISRA 2012 Rule 16.3, required])
|
|
|
|
/**** Rule 16.4 (Req) ************/
|
|
|
|
+e744 /* switch statement has no default */
|
|
+elib(744)
|
|
-append(744,[MISRA 2012 Rule 16.4, required])
|
|
+e9014 /* switch statement has no default */
|
|
+elib(9014)
|
|
-append(9014,[MISRA 2012 Rule 16.4, required])
|
|
+e9085 /* default case has no statement nor comment */
|
|
+elib(9085)
|
|
-append(9085,[MISRA 2012 Rule 16.4, required])
|
|
|
|
/**** Rule 16.5 (Req) ************/
|
|
|
|
+e9082 /* default should be first or last */
|
|
+elib(9082)
|
|
-append(9082,[MISRA 2012 Rule 16.5, required])
|
|
|
|
/**** Rule 16.6 (Req) ************/
|
|
|
|
+e764 /* switch does not have a case */
|
|
+elib(764)
|
|
-append(764,[MISRA 2012 Rule 16.6, required])
|
|
+e9081 /* too few cases */
|
|
+elib(9081)
|
|
-append(9081,[MISRA 2012 Rule 16.6, required])
|
|
|
|
/**** Rule 16.7 (Req) ************/
|
|
|
|
+e483 /* boolean value in switch expression */
|
|
+elib(483)
|
|
-append(483,[MISRA 2012 Rule 16.7, required])
|
|
|
|
/**** Rule 17.1 (Req) ************/
|
|
|
|
+e829 /* warn on header usage */
|
|
+elib(829)
|
|
+headerwarn(stdarg.h)
|
|
-append(829(stdarg.h),[MISRA 2012 Rule 17.1, required])
|
|
-deprecate(macro,va_arg,[MISRA 2012 Rule 17.1, required])
|
|
-deprecate(macro,va_start,[MISRA 2012 Rule 17.1, required])
|
|
-deprecate(macro,va_end,[MISRA 2012 Rule 17.1, required])
|
|
-deprecate(macro,va_copy,[MISRA 2012 Rule 17.1, required])
|
|
|
|
/**** Rule 17.2 (Req) ************/
|
|
|
|
/* While MISRA has declared this rule to be "undecidable", Gimpel
|
|
* Software provides the following options to assist:
|
|
*/
|
|
+e9070
|
|
-append(9070,[MISRA 2012 Rule 17.2, required])
|
|
|
|
/**** Rule 17.3 (Mand) ************/
|
|
|
|
+e718 /* symbol undeclared, assumed to return int */
|
|
+elib(718)
|
|
-append(718,[MISRA 2012 Rule 17.3, mandatory])
|
|
|
|
/**** Rule 17.4 (Mand) ************/
|
|
|
|
+e533 /* function should return a value */
|
|
+elib(533)
|
|
-append(533,[MISRA 2012 Rule 17.4, mandatory])
|
|
|
|
/**** Rule 17.5 (Adv) ************/
|
|
|
|
/* MISRA has declared this rule to be "undecidable". */
|
|
|
|
/**** Rule 17.6 (Mand) ************/
|
|
|
|
+e9043 /* static between brackets of array declaration */
|
|
+elib(9043)
|
|
-append(9043,[MISRA 2012 Rule 17.6, mandatory])
|
|
|
|
/**** Rule 17.7 (Req) ************/
|
|
|
|
+e534 /* ignoring return value of function */
|
|
+elib(534)
|
|
-append(534,[MISRA 2012 Rule 17.7, required])
|
|
|
|
/**** Rule 17.8 (Adv) ************/
|
|
|
|
/* While MISRA has declared this rule to be "undecidable", Gimpel
|
|
* Software provides the following options to assist:
|
|
*/
|
|
+e9044 /* function parameter modified */
|
|
+elib(9044)
|
|
-append(9044,[MISRA 2012 Rule 17.8, advisory])
|
|
|
|
/**** Rule 18.1 (Req) ************/
|
|
|
|
/* While MISRA has declared this rule to be "undecidable", Gimpel
|
|
* Software provides the following options to assist:
|
|
*/
|
|
+e415 /* out-of-bounds pointer */
|
|
+elib(415)
|
|
-append(415,[MISRA 2012 Rule 18.1, required])
|
|
+e416 /* out-of-bounds pointer */
|
|
+elib(416)
|
|
-append(416,[MISRA 2012 Rule 18.1, required])
|
|
+e428 /* out-of-bounds pointer */
|
|
+elib(428)
|
|
-append(428,[MISRA 2012 Rule 18.1, required])
|
|
+e661 /* out-of-bounds pointer */
|
|
+elib(661)
|
|
-append(661,[MISRA 2012 Rule 18.1, required])
|
|
+e662 /* out-of-bounds pointer */
|
|
+elib(662)
|
|
-append(662,[MISRA 2012 Rule 18.1, required])
|
|
+e676 /* out-of-bounds pointer */
|
|
+elib(676)
|
|
-append(676,[MISRA 2012 Rule 18.1, required])
|
|
+e796 /* out-of-bounds pointer */
|
|
+elib(796)
|
|
-append(796,[MISRA 2012 Rule 18.1, required])
|
|
+e797 /* out-of-bounds pointer */
|
|
+elib(797)
|
|
-append(797,[MISRA 2012 Rule 18.1, required])
|
|
+e817 /* out-of-bounds pointer */
|
|
+elib(817)
|
|
-append(817,[MISRA 2012 Rule 18.1, required])
|
|
|
|
/**** Rule 18.2 (Req) ************/
|
|
|
|
/* While MISRA has declared this rule to be "undecidable", Gimpel
|
|
* Software provides the following options to assist:
|
|
*/
|
|
+e946 /* relational or subtract operator applied to pointers */
|
|
+elib(946)
|
|
-append(946,[MISRA 2012 Rule 18.2, required])
|
|
+e947 /* relational or subtract operator applied to pointers */
|
|
+elib(947)
|
|
-append(947,[MISRA 2012 Rule 18.2, required])
|
|
|
|
/**** Rule 18.3 (Req) ************/
|
|
|
|
/* While MISRA has declared this rule to be "undecidable", Gimpel
|
|
* Software provides the following options to assist:
|
|
*/
|
|
+e946 /* relational or subtract operator applied to pointers */
|
|
+elib(946)
|
|
-append(946,[MISRA 2012 Rule 18.3, required])
|
|
+e947 /* relational or subtract operator applied to pointers */
|
|
+elib(947)
|
|
-append(947,[MISRA 2012 Rule 18.3, required])
|
|
|
|
/**** Rule 18.4 (Adv) ************/
|
|
|
|
+e9016 /* pointer arithmetic other than array indexing used */
|
|
+elib(9016)
|
|
-append(9016,[MISRA 2012 Rule 18.4, advisory])
|
|
|
|
/**** Rule 18.5 (Adv) ************/
|
|
|
|
+e9025 /* more than two pointer indirection levels used */
|
|
+elib(9025)
|
|
-append(9025,[MISRA 2012 Rule 18.5, advisory])
|
|
|
|
/**** Rule 18.6 (Req) ************/
|
|
|
|
/* While MISRA has declared this rule to be "undecidable", Gimpel
|
|
* Software provides the following options to assist:
|
|
*/
|
|
+e733 /* assigning address of auto to outer scope symbol */
|
|
+elib(733)
|
|
-append(733,[MISRA 2012 Rule 18.6, required])
|
|
+e789 /* assigning address of auto to static */
|
|
+elib(789)
|
|
-append(789,[MISRA 2012 Rule 18.6, required])
|
|
+e604 /* returning address of auto variable */
|
|
+elib(604)
|
|
-append(604,[MISRA 2012 Rule 18.6, required])
|
|
|
|
/**** Rule 18.7 (Req) ************/
|
|
|
|
+e9038 /* flexible array member declared */
|
|
+elib(9038)
|
|
-append(9038,[MISRA 2012 Rule 18.7, required])
|
|
|
|
/**** Rule 18.8 (Req) ************/
|
|
|
|
+e9035 /* variable length array declared */
|
|
+elib(9035)
|
|
-append(9035,[MISRA 2012 Rule 18.8, required])
|
|
|
|
/**** Rule 19.1 (Mand) ************/
|
|
|
|
/* MISRA has declared this rule to be "undecidable". */
|
|
|
|
/**** Rule 19.2 (Adv) ************/
|
|
|
|
+e9018 /* union type/object declared */
|
|
+elib(9018)
|
|
-append(9018,[MISRA 2012 Rule 19.2, advisory])
|
|
|
|
/**** Rule 20.1 (Adv) ************/
|
|
|
|
+e9019 /* declaration before #include */
|
|
+elib(9019)
|
|
-append(9019,[MISRA 2012 Rule 20.1, advisory])
|
|
|
|
/**** Rule 20.2 (Req) ************/
|
|
|
|
+e9020 /* header file name with non-standard character */
|
|
+elib(9020)
|
|
-append(9020,[MISRA 2012 Rule 20.2, required])
|
|
/* Note: If your system requires the '\' be used as a directory
|
|
separator, uncomment the following option.
|
|
*/
|
|
// -estring(9020,\)
|
|
|
|
/**** Rule 20.3 (Req) ************/
|
|
|
|
+e12 /* Need < or " after #include */
|
|
+elib(12)
|
|
-append(12,[MISRA 2012 Rule 20.3, required])
|
|
+e9086 /* multiple arguments after #include */
|
|
+elib(9086)
|
|
-append(9086,[MISRA 2012 Rule 20.3, required])
|
|
|
|
/**** Rule 20.4 (Req) ************/
|
|
|
|
+e9051 /* macro with same name as a keyword */
|
|
+elib(9051)
|
|
-append(9051,[MISRA 2012 Rule 20.4, required])
|
|
|
|
/**** Rule 20.5 (Adv) ************/
|
|
|
|
+e9021 /* use of '#undef' is discouraged */
|
|
+elib(9021)
|
|
-append(9021,[MISRA 2012 Rule 20.5, advisory])
|
|
|
|
/**** Rule 20.6 (Req) ************/
|
|
|
|
+e436 /* preprocessor directive in invocation of macro */
|
|
+elib(436)
|
|
-append(436,[MISRA 2012 Rule 20.6, required])
|
|
|
|
/**** Rule 20.7 (Req) ************/
|
|
|
|
+e665 /* expression passed to unparenthesized macro */
|
|
+elib(665)
|
|
-append(665,[MISRA 2012 Rule 20.7, required])
|
|
|
|
/**** Rule 20.8 (Req) ************/
|
|
|
|
+e9037 /* conditional of #if/#elif does not evaluate to 0 or 1 */
|
|
+elib(9037)
|
|
-append(9037,[MISRA 2012 Rule 20.8, required])
|
|
|
|
/**** Rule 20.9 (Req) ************/
|
|
|
|
+e553 /* Undefined preprocessor variable, assumed 0 */
|
|
+elib(553)
|
|
-append(553,[MISRA 2012 Rule 20.9, required])
|
|
|
|
/**** Rule 20.10 (Adv) ************/
|
|
|
|
+e9024 /* '#/##' operators used */
|
|
+elib(9024)
|
|
-append(9024,[MISRA 2012 Rule 20.10, advisory])
|
|
|
|
/**** Rule 20.11 (Req) ************/
|
|
|
|
+e484 /* stringize operator followed by macro parameter followed by pasting operator */
|
|
+elib(484)
|
|
-append(484,[MISRA 2012 Rule 20.11, required])
|
|
|
|
/**** Rule 20.12 (Req) ************/
|
|
|
|
+e9015 /* macro argument is used both with and without '#/##' and is subject to further replacement */
|
|
+elib(9015)
|
|
-append(9015,[MISRA 2012 Rule 20.12, required])
|
|
|
|
/**** Rule 20.13 (Req) ************/
|
|
|
|
+e544 /* endif or else not followed by EOL */
|
|
+elib(544)
|
|
-append(544,[MISRA 2012 Rule 20.13, required])
|
|
+e16 /* # directive not followed by recognizable word */
|
|
+elib(16)
|
|
-append(16,[MISRA 2012 Rule 20.13, required])
|
|
/* other parts of this rule such as a syntax check of the disabled
|
|
portions of the code do not seem to be statically checkable
|
|
*/
|
|
|
|
/**** Rule 20.14 (Req) ************/
|
|
|
|
+e405 /* #if/#ifdef/#ifndef not closed off */
|
|
+elib(405)
|
|
-append(405,[MISRA 2012 Rule 20.14, required])
|
|
|
|
/**** Rule 21.1 (Req) ************/
|
|
|
|
+e136 /* Illegal macro name */
|
|
+elib(136)
|
|
-append(136,[MISRA 2012 Rule 21.1, required])
|
|
/* Undefining standard library macros is covered by rule 20.5. */
|
|
/* Defining/redefining reserved/standard identifiers is covered
|
|
by rules 20.4 and 21.2.
|
|
*/
|
|
+e9071 /* defined macro reserved to the compiler */
|
|
+elib(9071)
|
|
-append(9071,[MISRA 2012 Rule 21.1, required])
|
|
// explicit exemptions
|
|
-estring(9071,* because *)
|
|
-estring(9071,cerf)
|
|
-estring(9071,cerfc)
|
|
-estring(9071,cexp2)
|
|
-estring(9071,cexpm1)
|
|
-estring(9071,clog10)
|
|
-estring(9071,clog1p)
|
|
-estring(9071,clog2)
|
|
-estring(9071,clgamma)
|
|
-estring(9071,ctgamma)
|
|
-estring(9071,cerff)
|
|
-estring(9071,cerfcf)
|
|
-estring(9071,cexp2f)
|
|
-estring(9071,cexpm1f)
|
|
-estring(9071,clog10f)
|
|
-estring(9071,clog1pf)
|
|
-estring(9071,clog2f)
|
|
-estring(9071,clgammaf)
|
|
-estring(9071,ctgammaf)
|
|
-estring(9071,cerfl)
|
|
-estring(9071,cerfcl)
|
|
-estring(9071,cexp2l)
|
|
-estring(9071,cexpm1l)
|
|
-estring(9071,clog10l)
|
|
-estring(9071,clog1pl)
|
|
-estring(9071,clog2l)
|
|
-estring(9071,clgammal)
|
|
-estring(9071,ctgammal)
|
|
-estring(9071,E0*)
|
|
-estring(9071,E1*)
|
|
-estring(9071,E2*)
|
|
-estring(9071,E3*)
|
|
-estring(9071,E4*)
|
|
-estring(9071,E5*)
|
|
-estring(9071,E6*)
|
|
-estring(9071,E7*)
|
|
-estring(9071,E8*)
|
|
-estring(9071,E9*)
|
|
-estring(9071,NDEBUG)
|
|
-estring(9071,PRIa*)
|
|
-estring(9071,PRIb*)
|
|
-estring(9071,PRIc*)
|
|
-estring(9071,PRId*)
|
|
-estring(9071,PRIe*)
|
|
-estring(9071,PRIf*)
|
|
-estring(9071,PRIg*)
|
|
-estring(9071,PRIh*)
|
|
-estring(9071,PRIi*)
|
|
-estring(9071,PRIj*)
|
|
-estring(9071,PRIk*)
|
|
-estring(9071,PRIl*)
|
|
-estring(9071,PRIm*)
|
|
-estring(9071,PRIn*)
|
|
-estring(9071,PRIo*)
|
|
-estring(9071,PRIp*)
|
|
-estring(9071,PRIq*)
|
|
-estring(9071,PRIr*)
|
|
-estring(9071,PRIs*)
|
|
-estring(9071,PRIt*)
|
|
-estring(9071,PRIu*)
|
|
-estring(9071,PRIv*)
|
|
-estring(9071,PRIw*)
|
|
-estring(9071,PRIx*)
|
|
-estring(9071,PRIy*)
|
|
-estring(9071,PRIz*)
|
|
-estring(9071,PRIX*)
|
|
-estring(9071,SCNa*)
|
|
-estring(9071,SCNb*)
|
|
-estring(9071,SCNc*)
|
|
-estring(9071,SCNd*)
|
|
-estring(9071,SCNe*)
|
|
-estring(9071,SCNf*)
|
|
-estring(9071,SCNg*)
|
|
-estring(9071,SCNh*)
|
|
-estring(9071,SCNi*)
|
|
-estring(9071,SCNj*)
|
|
-estring(9071,SCNk*)
|
|
-estring(9071,SCNl*)
|
|
-estring(9071,SCNm*)
|
|
-estring(9071,SCNn*)
|
|
-estring(9071,SCNo*)
|
|
-estring(9071,SCNp*)
|
|
-estring(9071,SCNq*)
|
|
-estring(9071,SCNr*)
|
|
-estring(9071,SCNs*)
|
|
-estring(9071,SCNt*)
|
|
-estring(9071,SCNu*)
|
|
-estring(9071,SCNv*)
|
|
-estring(9071,SCNw*)
|
|
-estring(9071,SCNx*)
|
|
-estring(9071,SCNy*)
|
|
-estring(9071,SCNz*)
|
|
-estring(9071,SCNX*)
|
|
+e9083 /* undefined macro reserved to the compiler */
|
|
+elib(9083)
|
|
-append(9083,[MISRA 2012 Rule 21.1, required])
|
|
// explicit exemptions
|
|
-estring(9083,* because *)
|
|
-estring(9083,cerf)
|
|
-estring(9083,cerfc)
|
|
-estring(9083,cexp2)
|
|
-estring(9083,cexpm1)
|
|
-estring(9083,clog10)
|
|
-estring(9083,clog1p)
|
|
-estring(9083,clog2)
|
|
-estring(9083,clgamma)
|
|
-estring(9083,ctgamma)
|
|
-estring(9083,cerff)
|
|
-estring(9083,cerfcf)
|
|
-estring(9083,cexp2f)
|
|
-estring(9083,cexpm1f)
|
|
-estring(9083,clog10f)
|
|
-estring(9083,clog1pf)
|
|
-estring(9083,clog2f)
|
|
-estring(9083,clgammaf)
|
|
-estring(9083,ctgammaf)
|
|
-estring(9083,cerfl)
|
|
-estring(9083,cerfcl)
|
|
-estring(9083,cexp2l)
|
|
-estring(9083,cexpm1l)
|
|
-estring(9083,clog10l)
|
|
-estring(9083,clog1pl)
|
|
-estring(9083,clog2l)
|
|
-estring(9083,clgammal)
|
|
-estring(9083,ctgammal)
|
|
-estring(9083,E0*)
|
|
-estring(9083,E1*)
|
|
-estring(9083,E2*)
|
|
-estring(9083,E3*)
|
|
-estring(9083,E4*)
|
|
-estring(9083,E5*)
|
|
-estring(9083,E6*)
|
|
-estring(9083,E7*)
|
|
-estring(9083,E8*)
|
|
-estring(9083,E9*)
|
|
-estring(9083,NDEBUG)
|
|
-estring(9083,PRIa*)
|
|
-estring(9083,PRIb*)
|
|
-estring(9083,PRIc*)
|
|
-estring(9083,PRId*)
|
|
-estring(9083,PRIe*)
|
|
-estring(9083,PRIf*)
|
|
-estring(9083,PRIg*)
|
|
-estring(9083,PRIh*)
|
|
-estring(9083,PRIi*)
|
|
-estring(9083,PRIj*)
|
|
-estring(9083,PRIk*)
|
|
-estring(9083,PRIl*)
|
|
-estring(9083,PRIm*)
|
|
-estring(9083,PRIn*)
|
|
-estring(9083,PRIo*)
|
|
-estring(9083,PRIp*)
|
|
-estring(9083,PRIq*)
|
|
-estring(9083,PRIr*)
|
|
-estring(9083,PRIs*)
|
|
-estring(9083,PRIt*)
|
|
-estring(9083,PRIu*)
|
|
-estring(9083,PRIv*)
|
|
-estring(9083,PRIw*)
|
|
-estring(9083,PRIx*)
|
|
-estring(9083,PRIy*)
|
|
-estring(9083,PRIz*)
|
|
-estring(9083,PRIX*)
|
|
-estring(9083,SCNa*)
|
|
-estring(9083,SCNb*)
|
|
-estring(9083,SCNc*)
|
|
-estring(9083,SCNd*)
|
|
-estring(9083,SCNe*)
|
|
-estring(9083,SCNf*)
|
|
-estring(9083,SCNg*)
|
|
-estring(9083,SCNh*)
|
|
-estring(9083,SCNi*)
|
|
-estring(9083,SCNj*)
|
|
-estring(9083,SCNk*)
|
|
-estring(9083,SCNl*)
|
|
-estring(9083,SCNm*)
|
|
-estring(9083,SCNn*)
|
|
-estring(9083,SCNo*)
|
|
-estring(9083,SCNp*)
|
|
-estring(9083,SCNq*)
|
|
-estring(9083,SCNr*)
|
|
-estring(9083,SCNs*)
|
|
-estring(9083,SCNt*)
|
|
-estring(9083,SCNu*)
|
|
-estring(9083,SCNv*)
|
|
-estring(9083,SCNw*)
|
|
-estring(9083,SCNx*)
|
|
-estring(9083,SCNy*)
|
|
-estring(9083,SCNz*)
|
|
-estring(9083,SCNX*)
|
|
|
|
/**** Rule 21.2 (Req) ************/
|
|
|
|
+e683 /* complain about #define standard functions */
|
|
+elib(683)
|
|
-append(683,[MISRA 2012 Rule 21.2, required])
|
|
/* Undefining standard library macros is covered by rule 20.5. */
|
|
/* Defining/redefining reserved/standard identifiers is covered
|
|
by rule 20.4 and 21.2.
|
|
*/
|
|
|
|
/**** Rule 21.3 (Req) ************/
|
|
|
|
+e586 /* Symbol is deprecated */
|
|
+elib(586)
|
|
-deprecate(function,calloc,[MISRA 2012 Rule 21.3, required])
|
|
-deprecate(macro,calloc,[MISRA 2012 Rule 21.3, required])
|
|
-deprecate(function,malloc,[MISRA 2012 Rule 21.3, required])
|
|
-deprecate(macro,malloc,[MISRA 2012 Rule 21.3, required])
|
|
-deprecate(function,realloc,[MISRA 2012 Rule 21.3, required])
|
|
-deprecate(macro,realloc,[MISRA 2012 Rule 21.3, required])
|
|
-deprecate(function,free,[MISRA 2012 Rule 21.3, required])
|
|
-deprecate(macro,free,[MISRA 2012 Rule 21.3, required])
|
|
|
|
/**** Rule 21.4 (Req) ************/
|
|
|
|
+e829 /* warn on header usage */
|
|
+elib(829)
|
|
+headerwarn(setjmp.h)
|
|
-append(829(setjmp.h),[MISRA 2012 Rule 21.4, required])
|
|
-deprecate(function,setjmp,[MISRA 2012 Rule 21.4, required])
|
|
-deprecate(function,longjmp,[MISRA 2012 Rule 21.4, required])
|
|
-deprecate(macro,setjmp,[MISRA 2012 Rule 21.4, required])
|
|
-deprecate(macro,longjmp,[MISRA 2012 Rule 21.4, required])
|
|
|
|
/**** Rule 21.5 (Req) ************/
|
|
|
|
+e586 /* Symbol is deprecated */
|
|
+elib(586)
|
|
-deprecate(function,signal,[MISRA 2012 Rule 21.5, required])
|
|
-deprecate(function,raise,[MISRA 2012 Rule 21.5, required])
|
|
-deprecate(macro,SIGABRT,[MISRA 2012 Rule 21.5, required])
|
|
-deprecate(macro,SIGFPE,[MISRA 2012 Rule 21.5, required])
|
|
-deprecate(macro,SIGILL,[MISRA 2012 Rule 21.5, required])
|
|
-deprecate(macro,SIGINT,[MISRA 2012 Rule 21.5, required])
|
|
-deprecate(macro,SIGSEGV,[MISRA 2012 Rule 21.5, required])
|
|
-deprecate(macro,SIGTERM,[MISRA 2012 Rule 21.5, required])
|
|
-deprecate(macro,SIG_DFL,[MISRA 2012 Rule 21.5, required])
|
|
-deprecate(macro,SIG_ERR,[MISRA 2012 Rule 21.5, required])
|
|
-deprecate(macro,SIG_IGN,[MISRA 2012 Rule 21.5, required])
|
|
+e829 /* warn on header usage */
|
|
+elib(829)
|
|
+headerwarn(signal.h)
|
|
-append(829(signal.h),[MISRA 2012 Rule 21.5, required])
|
|
|
|
/**** Rule 21.6 (Req) ************/
|
|
|
|
+e586 /* Symbol is deprecated */
|
|
+elib(586)
|
|
-deprecate(function,clearerr,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(function,fclose,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(function,feof,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(function,ferror,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(function,fflush,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(function,fgetc,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(function,fgetpos,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(function,fgets,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(function,fgetwc,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(function,fgetws,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(function,fopen,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(function,fprintf,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(function,fputc,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(function,fputs,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(function,fputwc,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(function,fputws,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(function,fread,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(function,fscanf,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(function,fseek,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(function,fsetpos,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(function,freopen,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(function,ftell,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(function,fwide,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(function,fwprintf,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(function,fwrite,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(function,fwscanf,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(function,getc,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(function,getchar,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(function,gets,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(function,getwc,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(function,getwchar,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(function,perror,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(function,printf,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(function,putc,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(function,putchar,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(function,puts,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(function,putwc,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(function,putwchar,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(function,remove,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(function,rename,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(function,rewind,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(function,scanf,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(function,setbuf,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(function,setvbuf,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(function,snprintf,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(function,sprintf,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(function,sscanf,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(function,swprintf,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(function,swscanf,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(function,tmpfile,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(function,tmpnam,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(function,ungetc,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(function,ungetwc,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(function,vfprintf,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(function,vfscanf,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(function,vfwprintf,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(function,vfwscanf,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(function,vprintf,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(function,vscanf,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(function,vsnprintf,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(function,vsprintf,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(function,vsscanf,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(function,vswprintf,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(function,vswscanf,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(function,vwprintf,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(function,vwscanf,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(function,wprintf,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(function,wscanf,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(macro,clearerr,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(macro,fclose,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(macro,feof,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(macro,ferror,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(macro,fflush,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(macro,fgetc,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(macro,fgets,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(macro,fgetpos,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(macro,fgetwc,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(macro,fgetws,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(macro,fopen,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(macro,fprintf,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(macro,fputc,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(macro,fputs,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(macro,fputwc,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(macro,fputws,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(macro,fread,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(macro,fscanf,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(macro,fseek,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(macro,fsetpos,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(macro,freopen,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(macro,ftell,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(macro,fwide,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(macro,fwprintf,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(macro,fwrite,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(macro,fwscanf,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(macro,getc,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(macro,getchar,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(macro,gets,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(macro,getwc,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(macro,getwchar,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(macro,perror,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(macro,printf,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(macro,putc,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(macro,putchar,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(macro,puts,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(macro,putwc,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(macro,putwchar,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(macro,remove,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(macro,rename,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(macro,rewind,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(macro,scanf,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(macro,setbuf,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(macro,setvbuf,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(macro,snprintf,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(macro,sprintf,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(macro,sscanf,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(macro,swprintf,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(macro,swscanf,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(macro,tmpfile,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(macro,tmpnam,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(macro,ungetc,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(macro,ungetwc,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(macro,vfprintf,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(macro,vfscanf,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(macro,vfwprintf,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(macro,vfwscanf,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(macro,vprintf,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(macro,vscanf,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(macro,vsnprintf,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(macro,vsprintf,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(macro,vsscanf,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(macro,vswprintf,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(macro,vswscanf,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(macro,vwprintf,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(macro,vwscanf,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(macro,wprintf,[MISRA 2012 Rule 21.6, required])
|
|
-deprecate(macro,wscanf,[MISRA 2012 Rule 21.6, required])
|
|
|
|
/**** Rule 21.7 (Req) ************/
|
|
|
|
+e586 /* Symbol is deprecated */
|
|
+elib(586)
|
|
-deprecate(function,atof,[MISRA 2012 Rule 21.7, required])
|
|
-deprecate(function,atoi,[MISRA 2012 Rule 21.7, required])
|
|
-deprecate(function,atol,[MISRA 2012 Rule 21.7, required])
|
|
-deprecate(function,atoll,[MISRA 2012 Rule 21.7, required])
|
|
-deprecate(macro,atof,[MISRA 2012 Rule 21.7, required])
|
|
-deprecate(macro,atoi,[MISRA 2012 Rule 21.7, required])
|
|
-deprecate(macro,atol,[MISRA 2012 Rule 21.7, required])
|
|
-deprecate(macro,atoll,[MISRA 2012 Rule 21.7, required])
|
|
|
|
/**** Rule 21.8 (Req) ************/
|
|
|
|
+e586 /* Symbol is deprecated */
|
|
+elib(586)
|
|
-deprecate(function,abort,[MISRA 2012 Rule 21.8, required])
|
|
-deprecate(function,exit,[MISRA 2012 Rule 21.8, required])
|
|
-deprecate(function,getenv,[MISRA 2012 Rule 21.8, required])
|
|
-deprecate(function,system,[MISRA 2012 Rule 21.8, required])
|
|
-deprecate(macro,abort,[MISRA 2012 Rule 21.8, required])
|
|
-deprecate(macro,exit,[MISRA 2012 Rule 21.8, required])
|
|
-deprecate(macro,getenv,[MISRA 2012 Rule 21.8, required])
|
|
-deprecate(macro,system,[MISRA 2012 Rule 21.8, required])
|
|
|
|
/**** Rule 21.9 (Req) ************/
|
|
|
|
+e586 /* Symbol is deprecated */
|
|
+elib(586)
|
|
-deprecate(function,bsearch,[MISRA 2012 Rule 21.9, required])
|
|
-deprecate(function,qsort,[MISRA 2012 Rule 21.9, required])
|
|
-deprecate(macro,bsearch,[MISRA 2012 Rule 21.9, required])
|
|
-deprecate(macro,qsort,[MISRA 2012 Rule 21.9, required])
|
|
|
|
/**** Rule 21.10 (Req) ************/
|
|
|
|
+e586 /* Symbol is deprecated */
|
|
+elib(586)
|
|
-deprecate(macro,wcsftime,[MISRA 2012 Rule 21.10, required])
|
|
-deprecate(function,wcsftime,[MISRA 2012 Rule 21.10, required])
|
|
-deprecate(macro,clock,[MISRA 2012 Rule 21.10, required])
|
|
-deprecate(function,clock,[MISRA 2012 Rule 21.10, required])
|
|
-deprecate(macro,difftime,[MISRA 2012 Rule 21.10, required])
|
|
-deprecate(function,difftime,[MISRA 2012 Rule 21.10, required])
|
|
-deprecate(macro,mktime,[MISRA 2012 Rule 21.10, required])
|
|
-deprecate(function,mktime,[MISRA 2012 Rule 21.10, required])
|
|
-deprecate(macro,time,[MISRA 2012 Rule 21.10, required])
|
|
-deprecate(function,time,[MISRA 2012 Rule 21.10, required])
|
|
-deprecate(macro,asctime,[MISRA 2012 Rule 21.10, required])
|
|
-deprecate(function,asctime,[MISRA 2012 Rule 21.10, required])
|
|
-deprecate(macro,ctime,[MISRA 2012 Rule 21.10, required])
|
|
-deprecate(function,ctime,[MISRA 2012 Rule 21.10, required])
|
|
-deprecate(macro,gmtime,[MISRA 2012 Rule 21.10, required])
|
|
-deprecate(function,gmtime,[MISRA 2012 Rule 21.10, required])
|
|
-deprecate(macro,localtime,[MISRA 2012 Rule 21.10, required])
|
|
-deprecate(function,localtime,[MISRA 2012 Rule 21.10, required])
|
|
-deprecate(macro,strftime,[MISRA 2012 Rule 21.10, required])
|
|
-deprecate(function,strftime,[MISRA 2012 Rule 21.10, required])
|
|
-deprecate(macro,CLOCKS_PER_SEC,[MISRA 2012 Rule 21.10, required])
|
|
+e829 /* warn on header usage */
|
|
+elib(829)
|
|
+headerwarn(time.h)
|
|
-append(829(time.h),[MISRA 2012 Rule 21.10, required])
|
|
|
|
/**** Rule 21.11 (Req) ************/
|
|
|
|
+e829 /* warn on header usage */
|
|
+elib(829)
|
|
+headerwarn(tgmath.h)
|
|
-append(829(tgmath.h),[MISRA 2012 Rule 21.11, required])
|
|
|
|
/**** Rule 21.12 (Adv) ************/
|
|
|
|
+e586 /* Symbol is deprecated */
|
|
+elib(586)
|
|
-deprecate(function,feclearexcept,[MISRA 2012 Rule 21.12, advisory])
|
|
-deprecate(macro,feclearexcept,[MISRA 2012 Rule 21.12, advisory])
|
|
-deprecate(function,fegetexceptflag,[MISRA 2012 Rule 21.12, advisory])
|
|
-deprecate(macro,fegetexceptflag,[MISRA 2012 Rule 21.12, advisory])
|
|
-deprecate(function,feraiseexcept,[MISRA 2012 Rule 21.12, advisory])
|
|
-deprecate(macro,feraiseexcept,[MISRA 2012 Rule 21.12, advisory])
|
|
-deprecate(function,fesetexceptflag,[MISRA 2012 Rule 21.12, advisory])
|
|
-deprecate(macro,fesetexceptflag,[MISRA 2012 Rule 21.12, advisory])
|
|
-deprecate(function,fetestexcept,[MISRA 2012 Rule 21.12, advisory])
|
|
-deprecate(macro,fetestexcept,[MISRA 2012 Rule 21.12, advisory])
|
|
-deprecate(macro,FE_INEXACT,[MISRA 2012 Rule 21.12, advisory])
|
|
-deprecate(macro,FE_DIVBYZERO,[MISRA 2012 Rule 21.12, advisory])
|
|
-deprecate(macro,FE_UNDERFLOW,[MISRA 2012 Rule 21.12, advisory])
|
|
-deprecate(macro,FE_OVERFLOW,[MISRA 2012 Rule 21.12, advisory])
|
|
-deprecate(macro,FE_INVALID,[MISRA 2012 Rule 21.12, advisory])
|
|
-deprecate(macro,FE_ALL_EXCEPT,[MISRA 2012 Rule 21.12, advisory])
|
|
|
|
/**** Rule 22.1 (Req) ************/
|
|
|
|
/* While MISRA has declared this rule to be "undecidable", Gimpel
|
|
* Software provides the following options to assist:
|
|
*/
|
|
+e429 /* custodial pointer neither free'd nor returned */
|
|
+elib(429)
|
|
-append(429,[MISRA 2012 Rule 22.1, required])
|
|
-function_pair(fopen,fclose)
|
|
+e480 /* no balancing call */
|
|
+elib(480)
|
|
-append(480,[MISRA 2012 Rule 22.1, required])
|
|
+e481 /* different balance call states */
|
|
+elib(481)
|
|
-append(481,[MISRA 2012 Rule 22.1, required])
|
|
|
|
/**** Rule 22.2 (Mand) ************/
|
|
|
|
/* While MISRA has declared this rule to be "undecidable", Gimpel
|
|
* Software provides the following options to assist:
|
|
*/
|
|
+e424 /* inappropriate deallocation */
|
|
+elib(424)
|
|
-append(424,[MISRA 2012 Rule 22.2, mandatory])
|
|
+e449 /* pointer previously deallocated */
|
|
+elib(449)
|
|
-append(449,[MISRA 2012 Rule 22.2, mandatory])
|
|
|
|
/**** Rule 22.3 (Req) ************/
|
|
|
|
/* MISRA has declared this rule to be "undecidable". */
|
|
|
|
/**** Rule 22.4 (Mand) ************/
|
|
|
|
/* MISRA has declared this rule to be "undecidable". */
|
|
|
|
/**** Rule 22.5 (Mand) ************/
|
|
|
|
/* While MISRA has declared this rule to be "undecidable", Gimpel
|
|
Software provides the following message to assist:
|
|
*/
|
|
+e9047 /* FILE pointer dereferenced */
|
|
+elib(9047)
|
|
-append(9047,[MISRA 2012 Rule 22.5, mandatory])
|
|
|
|
|
|
/**** Rule 22.6 (Mand) ************/
|
|
|
|
/* While MISRA has declared this rule to be "undecidable", Gimpel
|
|
* Software provides the following options to assist:
|
|
*/
|
|
+e449 /* previously deallocated pointer */
|
|
+elib(449)
|
|
-append(449,[MISRA 2012 Rule 22.6, mandatory])
|