GitHub/qpc
1
0
Fork 0
mirror of https://github.com/QuantumLeaps/qpc.git synced 2025-01-28 07:03:10 +08:00
Code Issues Projects Releases Wiki Activity
qpc/ports/lint-plus/au-misra3.lnt
QL b9207d7330 6.9.2rc1
2020-12-17 11:37:52 -05:00

2091 lines
72 KiB
Plaintext
Raw Blame History

// ---------------------------------------------------------------------------
// Copyright Gimpel Software LLC 2020. All rights reserved.
//
// This file is provided by Gimpel Software LLC (https://www.gimpel.com) for
// use with PC-lint Plus. Redistribution is permitted but any redistribution
// must preserve this notice and, if the redistributed file has been modified,
// provide notice that the file has been modified from the original.
// ---------------------------------------------------------------------------
// 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:
lint au-misra3.lnt hello.c
Gimpel Software relies on the document, "MISRA-C:2012
Guidelines for the use of the C language in critical systems",
copyright 2012 by MISRA 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.
*/
/* version check */ -cond('%PCLP_NO_LNT_VERSION_CHECK%' != '1' && (%LINT_MAJOR_VERSION% != 1 || %LINT_MINOR_VERSION% != 4),
+fatal_error(This configuration file is intended for PC-lint Plus 1.4.
You are attempting to use it with PC-lint Plus %LINT_MAJOR_VERSION%.%LINT_MINOR_VERSION%.
It is recommended that you use configuration files intended
for PC-lint Plus %LINT_MAJOR_VERSION%.%LINT_MINOR_VERSION%.)
)
/**** Dir 1.1 (Req) ************/
/* not statically checkable */
/**** Dir 2.1 (Req) ************/
-std(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 '-std(c99)' option throughout this file. */
// -std(c90)
/**** 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 Directive 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) ************/
+fta /* enable typographical ambiguity checking */
+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) ************/
/* Not currently supported */
/**** Rule 1.1 (Req) ************/
/* While MISRA has declared this rule to be "undecidable", Gimpel
* Software provides the following options to assist:
*/
-std(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 '-std(c99)' option throughout this file. */
// -std(c90)
/**** Rule 1.2 (Adv) ************/
/* While MISRA has declared this rule to be "undecidable", Gimpel
* Software provides the following options to assist:
*/
-std(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 '-std(c99)' option throughout this file. */
// -std(c90)
/**** 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).
*/
/* 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])
/* 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])
/* 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])
/* Also, see Rule 12.4 */
/* Passing a void argument to a function (ISO C, Appendix A.6.2,
point 20).
*/
/* 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).
*/
+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).
*/
+e2454 /* incompatible pointer types */
+elib(2454)
-append(2454,[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.
*/
/* 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)
-append(64,[MISRA 2012 Rule 1.3, required])
/* 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:
*/
+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])
+e774 /* condition always evaluates to true/false */
+elib(774)
-append(774,[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])
+e9259
+elib(9259)
-append(9259,[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, x) /* Sets the number of significant characters in an external
identifier, update as appropriate for your target. Use
'X' instead of 'x' if external identifiers are not case
sensitive. C90 guarantees 6 characters are significant,
C99 guarantees at least 31 characters are significant. */
+e621 /* identifier clash */
+elib(621)
-append(621("external vs external"), [MISRA 2012 Rule 5.1, required])
/**** Rule 5.2 (Req) ************/
-idlen(63, c) /* Sets the number of significant characters in an internal
identifier, update as appropriate for your target. Use
'C' instead of 'c' if internal identifiers are not case
sensitive. C90 guarantees 31 characters are significant,
C99 guarantees at least 63 characters are significant. */
+e621 /* identifier clash */
+elib(621)
-append(621("tag vs tag"), [MISRA 2012 Rule 5.2, required])
-append(621("field vs field"), [MISRA 2012 Rule 5.2, required])
-append(621("label vs label"), [MISRA 2012 Rule 5.2, required])
-append(621("internal vs internal, same scope"), [MISRA 2012 Rule 5.2, required])
-append(621("internal vs external, same scope"), [MISRA 2012 Rule 5.2, required])
-append(621("external vs internal, same scope"), [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])
/* This rule uses the same -idlen option values as 5.2 */
+e621 /* identifier clash */
+elib(621)
-append(621("internal vs internal, enclosing scope"), [MISRA 2012 Rule 5.3, required])
-append(621("internal vs external, enclosing scope"), [MISRA 2012 Rule 5.3, required])
-append(621("external vs internal, enclosing scope"), [MISRA 2012 Rule 5.3, required])
/**** Rule 5.4 (Req) ************/
-idlen(63, p) /* Sets the number of significant characters in a preprocessor
identifier, update as appropriate for your target. Use
'P' instead of 'p' if preprocessor identifiers are not case
sensitive. C90 guarantees 31 characters are significant,
C99 guarantees at least 63 characters are significant. */
+e547 /* conflicting macro definition */
+elib(547)
-append(547,[MISRA 2012 Rule 5.4, required])
+e760 /* macro redefined identically */
+elib(760)
-append(760,[MISRA 2012 Rule 5.4, required])
+e621 /* identifier clash */
+elib(621)
-append(621("macro vs macro"), [MISRA 2012 Rule 5.4, required])
-append(621("macro vs macro parameter"), [MISRA 2012 Rule 5.4, required])
-append(621("macro parameter vs macro parameter"), [MISRA 2012 Rule 5.4, required])
/**** Rule 5.5 (Req) ************/
/* 9095 - symbol has same name as previously defined macro */
+e9095
+elib(9095)
-append(9095,[MISRA 2012 Rule 5.5, required])
/* 9096 - symbol has same name as subsequently defined macro */
+e9096
+elib(9096)
-append(9096,[MISRA 2012 Rule 5.5, required])
/**** Rule 5.6 (Req) ************/
/* Not currently supported */
/**** Rule 5.7 (Req) ************/
+e407 /* Inconsistent use of tag */
+elib(407)
-append(407,[MISRA 2012 Rule 5.7, required])
+e631 /* Tag defined differently */
+elib(631)
-append(631,[MISRA 2012 Rule 5.7, required])
/**** Rule 5.8 (Req) ************/
/* Not currently supported */
/**** Rule 5.9 (Adv) ************/
/* Not currently supported */
/**** Rule 6.1 (Req) ************/
/* 9149 bit field must be explicitly signed integer, unsigned integer,
or bool */
+e9149
+elib(9149)
-append(9149,[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])
+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])
/**** Rule 8.2 (Req) ************/
+e937 /* old-style function declaration */
+elib(937)
-append(937,[MISRA 2012 Rule 8.2, required])
+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) ************/
+e18 /* symbol redeclared */
+elib(18)
-append(18,[MISRA 2012 Rule 8.3, required])
/* 9072 parameter has different name than previous declaration */
+e9072
+elib(9072)
-append(9072,[MISRA 2012 Rule 8.3, required])
/* 9073 parameter has type alias name type difference with previous
declaration */
+e9073
+elib(9073)
-append(9073,[MISRA 2012 Rule 8.3, required])
/* 9094 return type has type alias name difference with previous
declaration */
+e9094
+elib(9094)
-append(9094,[MISRA 2012 Rule 8.3, required])
/**** Rule 8.4 (Req) ************/
+e15 /* symbol redeclared */
+elib(15)
-append(15,[MISRA 2012 Rule 8.4, required])
/* 957 - function defined without prototype in scope */
+e957
+elib(957)
-append(957,[MISRA 2012 Rule 8.4, required])
/* 9075 external symbol defined without a prior declaration */
+e9075
+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) ************/
/* Not currently supported */
/**** 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])
-fcv /* report parameters even if exclusively cast to void */
/**** 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])
+e530 /* Symbol not initialized */
+elib(530)
-append(530,[MISRA 2012 Rule 9.1, mandatory])
/* 603 - argument to parameter of type pointer to const may be a pointer to
uninitialized memory */
+e603
+elib(603)
-append(603,[MISRA 2012 Rule 9.1, mandatory])
/**** Rule 9.2 (Req) ************/
+e9069 /* aggregate initialize needs braces or designator */
+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)
-estring(9052, true, false)
-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) ************/
/* 176 - cannot cast non-pointer non-integer to function pointer */
+e176
+elib(176)
-append(176,[MISRA 2012 Rule 11.1, required])
/* 178 - cannot cast function pointer to non-pointer non-integer */
+e178
+elib(178)
-append(178,[MISRA 2012 Rule 11.1, required])
+e9074 /* conversion between a pointer to function and another type */
+elib(9074)
-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)
-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) ************/
+elib(923) /* cast pointer/non-pointer */
+etype(923, void *)
-append(923,[MISRA 2012 Rule 11.6, required])
/**** Rule 11.7 (Req) ************/
+e177 /* type cannot be cast to object pointer */
+elib(177)
-append(177,[MISRA 2012 Rule 11.7, required])
+e179 /* object pointer cannot be cast to type */
+elib(179)
-append(179,[MISRA 2012 Rule 11.7, required])
+e9295 /* cast between object pointer and forbidden essential type */
+elib(9295)
-append(9295,[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) ************/
+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])
+e9097 /* unparenthesized argument to sizeof */
+elib(9097)
-append(9097,[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) ************/
/* not currently supported */
/**** 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])
/**** 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) ************/
/* Not currently supported */
/**** 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])
-deprecate(type,va_list,[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". */
+e473 /* argument to array parameter too small */
+elib(473)
-append(473,[MISRA 2012 Rule 17.5, advisory])
/**** 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])
/**** Rule 18.2 (Req) ************/
/* While MISRA has declared this rule to be "undecidable", Gimpel
* Software provides the following options to assist:
*/
+e947 /* pointer subtraction */
+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 operator applied to pointers */
+elib(946)
-append(946,[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])
/* 544 directive not followed by EOL */
+estring(544,include)
+elib(544)
-append(544(include),[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 parameter used with and without '#/##' subject to further replacement */
+elib(9015)
-append(9015,[MISRA 2012 Rule 20.12, required])
/**** Rule 20.13 (Req) ************/
/* 544 - directive not followed by EOL */
+e544
+elib(544)
-append(544,[MISRA 2012 Rule 20.13, required])
/* 16 - unknown preprocessor directive */
+e16
+elib(16)
-append(16,[MISRA 2012 Rule 20.13, required])
/* 9160 - unknown preprocessor directive in conditionally excluded
region */
+e9160
+elib(9160)
-append(9160,[MISRA 2012 Rule 20.13, required])
/**** Rule 20.14 (Req) ************/
+e8 /* unclosed #if */
+elib(8)
-append(8,[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) ************/
+e9093 /* name is reserved to the compiler */
+elib(9093)
-append(9093,[MISRA 2012 Rule 21.2, required])
/**** 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])
-deprecate(type,jmp_buf,[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])
-deprecate(type,sig_atomic_t,[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])
-deprecate(type,clock_t,[MISRA 2012 Rule 21.10, required])
-deprecate(type,time_t,[MISRA 2012 Rule 21.10, required])
-deprecate(type,struct tm,[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])
/* 698 - in-place realloc could cause a memory leak */
+e698
+elib(698)
-append(698,[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) ************/
/* While MISRA has declared this rule to be "undecidable", Gimpel
* Software provides the following options to assist:
*/
+e2477 /* attempt to perform write operation on stream not opened for writing */
+elib(2477)
-append(2477,[MISRA 2012 Rule 22.4, mandatory])
/**** 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:
*/
+e2471 /* operation on stream that has been closed */
+elib(2471)
-append(2471,[MISRA 2012 Rule 22.6, mandatory])
Reference in New Issue View Git Blame Copy Permalink