Skip to content

Instantly share code, notes, and snippets.

@TunaCici

TunaCici/misra-2004-pclint-rules.json

Created October 26, 2023 07:40
Show Gist options
  • Save TunaCici/816aa9b21380d8f1858c8e0bd8cf8e35 to your computer and use it in GitHub Desktop.
Save TunaCici/816aa9b21380d8f1858c8e0bd8cf8e35 to your computer and use it in GitHub Desktop.
Download ZIP
MISRA C 2004 PCLint Rules in JSON Format (Referenced from au-misra2.lnt)
Raw
misra-2004-pclint-rules.json
{
"MISRA_C_2004": {
"description": "MISRA C 2004 ruleset.",
"sections": [
{
"name": "1. Environment",
"ruleset": [
{
"name": "Rule 1.1",
"description": "All code shall conform to ISO/IEC 9899:1990.",
"severity": "required",
"pclint-flags": [
"-A(C90)",
"+e950",
"+elib(950)",
"-append(950,[MISRA 2004 Rule 1.1, required])"
]
},
{
"name": "Rule 1.2",
"description": "No reliance shall be placed on undefined or unspecified behaviour.",
"severity": "required",
"pclint-flags": [
"+e406",
"+elib(406)",
"-append(406,[MISRA 2004 Rule 1.2, required])",
"+e27",
"+elib(27)",
"-append(27,[MISRA 2004 Rule 1.2, required])",
"+e2",
"+elib(2)",
"-append(2,[MISRA 2004 Rule 1.2, required])",
"+e31",
"+elib(31)",
"-append(31,[MISRA 2004 Rule 1.2, required])",
"+e40",
"+elib(40)",
"-append(40,[MISRA 2004 Rule 1.2, required])",
"+e401",
"+elib(401)",
"-append(401,[MISRA 2004 Rule 1.2, required])",
"+e604",
"+elib(604)",
"-append(604,[MISRA 2004 Rule 1.2, required])",
"+e934",
"+elib(934)",
"-append(934,[MISRA 2004 Rule 1.2, required])",
"+e86",
"+elib(86)",
"-append(86,[MISRA 2004 Rule 1.2, required])",
"+e64",
"+elib(64)",
"-append(64,[MISRA 2004 Rule 1.2, required])",
"+e67",
"+elib(67)",
"-append(67,[MISRA 2004 Rule 1.2, required])",
"+e144",
"+elib(144)",
"-append(144,[MISRA 2004 Rule 1.2, required])",
"+e54",
"+elib(54)",
"-append(54,[MISRA 2004 Rule 1.2, required])",
"+e414",
"+elib(414)",
"-append(414,[MISRA 2004 Rule 1.2, required])",
"+e795",
"+elib(795)",
"-append(795,[MISRA 2004 Rule 1.2, required])",
"+e413",
"+elib(413)",
"-append(413,[MISRA 2004 Rule 1.2, required])",
"+e415",
"+elib(415)",
"-append(415,[MISRA 2004 Rule 1.2, required])",
"+e416",
"+elib(416)",
"-append(416,[MISRA 2004 Rule 1.2, required])",
"+e428",
"+elib(428)",
"-append(428,[MISRA 2004 Rule 1.2, required])",
"+e740",
"+elib(740)",
"-append(740,[MISRA 2004 Rule 1.2, required])",
"+e71",
"+elib(71)",
"+esym(920,pointer)",
"-append(920,[MISRA 2004 Rule 1.2, required])",
"+e504",
"+elib(504)",
"-append(504,[MISRA 2004 Rule 1.2, required])",
"+e86",
"+elib(86)",
"+e629",
"+elib(629)",
"-append(629,[MISRA 2004 Rule 1.2, required])",
"+e158",
"+elib(158)",
"-append(158,[MISRA 2004 Rule 1.2, required])",
"+e86",
"+elib(86)",
"+\"estring(10,a numeric constant)\"",
"+e136",
"+elib(136)",
"-append(136,[MISRA 2004 Rule 1.2, required])",
"+e558",
"+elib(558)",
"-append(558,[MISRA 2004 Rule 1.2, required])",
"+e719",
"+elib(719)",
"-append(719,[MISRA 2004 Rule 1.2, required])",
"+e557",
"+elib(557)",
"-append(557,[MISRA 2004 Rule 1.2, required])",
"+e437",
"+elib(437)",
"-append(437,[MISRA 2004 Rule 1.2, required])",
"+e449",
"+elib(449)",
"-append(449,[MISRA 2004 Rule 1.2, required])",
"+esym(424,free)",
"-append(424,[MISRA 2004 Rule 1.2, required])",
"+e419",
"+elib(419)",
"-append(419,[MISRA 2004 Rule 1.2, required])",
"+e564",
"+elib(564)",
"-append(564,[MISRA 2004 Rule 1.2, required])",
"+e931",
"+elib(931)",
"-append(931,[MISRA 2004 Rule 1.2, required])"
]
},
{
"name": "Rule 1.3",
"description": "Multiple compilers and/or languages shall only be used if there is a common defined interface standard for object code to which the languages/compilers/assemblers conform.",
"severity": "required",
"pclint-flags": []
},
{
"name": "Rule 1.4",
"description": "The compiler/linker shall be checked to ensure that 31 character significance and case sensitivity are supported for external identifiers.",
"severity": "required",
"pclint-flags": [
"-idlen(31)",
"+e621",
"+elib(621)",
"-append(621,[MISRA 2004 Rule 1.4, required])"
]
},
{
"name": "Rule 1.5",
"description": "Floating-point implementations should comply with a defined floating-point standard.",
"severity": "advisory",
"pclint-flags": []
}
]
},
{
"name": "2. Language extensions",
"ruleset": [
{
"name": "Rule 2.1",
"description": "Assembly language shall be encapsulated and isolated.",
"severity": "required",
"pclint-flags": [
"+e586",
"+elib(586)",
"-append(586,[MISRA 2004 Rule 2.1, required])"
]
},
{
"name": "Rule 2.2",
"description": "Source code shall only use /* ... */ style comments.",
"severity": "required",
"pclint-flags": [
"-A(C90)",
"+e950",
"+elib(950)",
"-append(950,[MISRA 2004 Rule 2.2, required])"
]
},
{
"name": "Rule 2.3",
"description": "The character sequence /* shall not be used within a comment.",
"severity": "required",
"pclint-flags": [
"-fnc",
"+e602",
"+elib(602)",
"-append(602,[MISRA 2004 Rule 2.3, required])"
]
},
{
"name": "Rule 2.4",
"description": "Sections of code should not be \"commented out\".",
"severity": "advisory",
"pclint-flags": [
"-fnc",
"+e602",
"+elib(602)",
"-append(602,[MISRA 2004 Rule 2.4, advisory])"
]
}
]
},
{
"name": "3. Documentation",
"ruleset": [
{
"name": "Rule 3.1",
"description": "All usage of implementation-defined behaviour shall be documented.",
"severity": "required",
"pclint-flags": []
},
{
"name": "Rule 3.2",
"description": "The character set and the corresponding encoding shall be documented.",
"severity": "required",
"pclint-flags": []
},
{
"name": "Rule 3.3",
"description": "The implementation of integer division in the chosen compiler should be determined, documented and taken into account.",
"severity": "advisory",
"pclint-flags": []
},
{
"name": "Rule 3.4",
"description": "All uses of the #pragma directive shall be documented and explained.",
"severity": "required",
"pclint-flags": [
"+e975",
"-pragma( push_macro )",
"-pragma( pop_macro )",
"-append(975,[MISRA 2004 Rule 3.4, required])"
]
},
{
"name": "Rule 3.5",
"description": "If it is being relied upon, the implementation defined behaviour and packing of bitfields shall be documented.",
"severity": "required",
"pclint-flags": []
},
{
"name": "Rule 3.6",
"description": "All libraries used in production code shall be written to comply with the provisions of this document, and shall have been subject to appropriate validation.",
"severity": "required",
"pclint-flags": []
}
]
},
{
"name": "4. Character sets",
"ruleset": [
{
"name": "Rule 4.1",
"description": "Only those escape sequences that are defined in the ISO C standard shall be used.",
"severity": "required",
"pclint-flags": [
"e606",
"+elib(606)",
"-append(606,[MISRA 2004 Rule 4.1, required])"
]
},
{
"name": "Rule 4.2",
"description": "Trigraphs shall not be used.",
"severity": "required",
"pclint-flags": [
"-ftg",
"e584",
"+elib(584)",
"-append(584,[MISRA 2004 Rule 4.2, required])",
"+e739",
"+elib(739)",
"-append(739,[MISRA 2004 Rule 4.2, required])"
]
}
]
},
{
"name": "5. Identifiers",
"ruleset": [
{
"name": "Rule 5.1",
"description": "Identifiers (internal and external) shall not rely on the significance of more than 31 characters.",
"severity": "required",
"pclint-flags": [
"-idlen(31)",
"+e621",
"+elib(621)",
"-append(621,[MISRA 2004 Rule 5.1, required])"
]
},
{
"name": "Rule 5.2",
"description": "Identifiers in an inner scope shall not use the same name as an identifier in an outer scope, and therefore hide that identifier.",
"severity": "required",
"pclint-flags": [
"+e578",
"+elib(578)",
"-append(578,[MISRA 2004 Rule 5.2, required])"
]
},
{
"name": "Rule 5.3",
"description": "A typedef name shall be a unique identifier.",
"severity": "required",
"pclint-flags": [
"+e578",
"+elib(578)",
"-append(578,[MISRA 2004 Rule 5.3, required])",
"+e623",
"+elib(623)",
"-append(623,[MISRA 2004 Rule 5.3, required])"
]
},
{
"name": "Rule 5.4",
"description": "A tag name shall be a unique identifier.",
"severity": "required",
"pclint-flags": [
"+e578",
"+elib(578)",
"-append(578,[MISRA 2004 Rule 5.4, required])",
"+e14",
"+elib(14)",
"-append(14,[MISRA 2004 Rule 5.4, required])",
"+e15",
"+elib(15)",
"-append(15,[MISRA 2004 Rule 5.4, required])"
]
},
{
"name": "Rule 5.5",
"description": "No object or function identifier with static storage duration should be reused.",
"severity": "advisory",
"pclint-flags": [
"+e578",
"+elib(578)",
"-append(578,[MISRA 2004 Rule 5.5, advisory])",
"+e580",
"+elib(580)",
"-append(580,[MISRA 2004 Rule 5.5, advisory])"
]
},
{
"name": "Rule 5.6",
"description": "No identifier in one name space should have the same spelling as an identifier in another name space, with the exception of structure member and union member names.",
"severity": "advisory",
"pclint-flags": [
"+e578",
"+elib(578)",
"-append(578,[MISRA 2004 Rule 5.6, advisory])"
]
},
{
"name": "Rule 5.7",
"description": "No identifier name should be reused.",
"severity": "advisory",
"pclint-flags": [
"+e578",
"+elib(578)",
"-append(578,[MISRA 2004 Rule 5.7, advisory])",
"+e580",
"+elib(580)",
"-append(580,[MISRA 2004 Rule 5.7, advisory])"
]
}
]
},
{
"name": "6. Types",
"ruleset": [
{
"name": "Rule 6.1",
"description": "The plain char type shall be used only for the storage and use of character values.",
"severity": "required",
"pclint-flags": []
},
{
"name": "Rule 6.2",
"description": "signed and unsigned char shall be used only for the storage and use of numeric values.",
"severity": "required",
"pclint-flags": []
},
{
"name": "Rule 6.3",
"description": "typedefs that indicate size and signedness should be used in place of the basic numerical types.",
"severity": "advisory",
"pclint-flags": [
"+e970",
"+elib(970)",
"-append(970,[MISRA 2004 Rule 6.3, advisory])",
"-esym(970,bool)"
]
},
{
"name": "Rule 6.4",
"description": "Bit fields shall only be defined to be of type unsigned int or signed int.",
"severity": "required",
"pclint-flags": [
"+e46",
"+elib(46)",
"-append(46,[MISRA 2004 Rule 6.4, required])"
]
},
{
"name": "Rule 6.5",
"description": "Bit fields of signed type shall be at least 2 bits long.",
"severity": "required",
"pclint-flags": [
"+e806",
"+elib(806)",
"-append(806,[MISRA 2004 Rule 6.5, required])"
]
}
]
},
{
"name": "7. Constants",
"ruleset": [
{
"name": "Rule 7.1",
"description": "Octal constants (other than zero) and octal escape sequences shall not be used.",
"severity": "required",
"pclint-flags": []
}
]
},
{
"name": "8. Declarations and definitions",
"ruleset": [
{
"name": "Rule 8.1",
"description": "Functions shall have prototype declarations and the prototype shall be visible at both the function definition and call.",
"severity": "required",
"pclint-flags": [
"+e718",
"+elib(718)",
"-append(718,[MISRA 2004 Rule 8.1, required])",
"+e746",
"+elib(746)",
"-append(746,[MISRA 2004 Rule 8.1, required])",
"+e937",
"+elib(937)",
"-append(937,[MISRA 2004 Rule 8.1, required])",
"+e957",
"+elib(957)",
"-append(957,[MISRA 2004 Rule 8.1, required])"
]
},
{
"name": "Rule 8.2",
"description": "Whenever an object or function is declared or defined, its type shall be explicitly stated.",
"severity": "required",
"pclint-flags": [
"+e601",
"+elib(601)",
"-append(601,[MISRA 2004 Rule 8.2, required])",
"+e808",
"+elib(808)",
"-append(808,[MISRA 2004 Rule 8.2, required])",
"+e745",
"+elib(745)",
"-append(745,[MISRA 2004 Rule 8.2, required])",
"+e939",
"+elib(939)",
"-append(939,[MISRA 2004 Rule 8.2, required])"
]
},
{
"name": "Rule 8.3",
"description": "For each function parameter the type given in the declaration and definition shall be identical, and the return types shall also be identical.",
"severity": "required",
"pclint-flags": [
"-fvr",
"-strong()",
"+e18",
"+elib(18)",
"-append(18,[Encompasses MISRA 2004 Rule 8.3, required])",
"+e516",
"+elib(516)",
"-append(516, MISRA 2004 Rule 8.3, required])",
"+e532",
"+elib(532)",
"-append(532,[MISRA 2004 Rule 8.3, required])"
]
},
{
"name": "Rule 8.4",
"description": "If objects or functions are declared more than once their types shall be compatible.",
"severity": "required",
"pclint-flags": [
"+e15",
"+elib(15)",
"-append(15,[MISRA 2004 Rule 8.4, required])",
"+e18",
"+elib(18)",
"-append(18,[Encompasses MISRA 2004 Rule 8.4, required])",
"+e64",
"+elib(64)",
"-append(64,[MISRA 2004 Rule 8.4, required])"
]
},
{
"name": "Rule 8.5",
"description": "There shall be no definitions of objects or functions in a header file.",
"severity": "required",
"pclint-flags": []
},
{
"name": "Rule 8.6",
"description": "Functions shall not be declared at block scope.",
"severity": "required",
"pclint-flags": []
},
{
"name": "Rule 8.7",
"description": "Objects shall be defined at block scope if they are only accessed from within a single function.",
"severity": "required",
"pclint-flags": []
},
{
"name": "Rule 8.8",
"description": "An external object or function shall be declared in one and only one file.",
"severity": "required",
"pclint-flags": []
},
{
"name": "Rule 8.9",
"description": "An identifier with external linkage shall have exactly one external definition.",
"severity": "required",
"pclint-flags": [
"+e14",
"+elib(14)",
"-append(14,[MISRA 2004 Rule 8.9, required])"
]
},
{
"name": "Rule 8.10",
"description": "All declarations and definitions of objects or functions at file scope shall have internal linkage unless external linkage is required.",
"severity": "required",
"pclint-flags": [
"+e765",
"+elib(765)",
"-append(765,[MISRA 2004 Rule 8.10, required])"
]
},
{
"name": "Rule 8.11",
"description": "The static storage class specifier shall be used in definitions and declarations of objects and functions that have internal linkage.",
"severity": "required",
"pclint-flags": [
"+e401",
"+elib(401)",
"-append(401,[MISRA 2004 Rule 8.11, required])",
"+e512",
"+elib(512)",
"-append(512,[MISRA 2004 Rule 8.11, required])",
"+e839",
"+elib(839)",
"-append(839,[MISRA 2004 Rule 8.11, required])"
]
},
{
"name": "Rule 8.12",
"description": "When an array is declared with external linkage, its size shall be stated explicitly or defined implicitly by initialisation.",
"severity": "required",
"pclint-flags": [
"+e85",
"+elib(85)",
"-append(85,[MISRA 2004 Rule 8.12, required])"
]
}
]
},
{
"name": "9. Initialisation",
"ruleset": [
{
"name": "Rule 9.1",
"description": "All automatic variables shall have been assigned a value before being used.",
"severity": "required",
"pclint-flags": [
"+e644",
"+elib(644)",
"-append(644,[MISRA 2004 Rule 9.1, required])",
"+e771",
"+elib(771)",
"-append(771,[MISRA 2004 Rule 9.1, required])",
"+e530",
"+elib(530)",
"-append(530,[MISRA 2004 Rule 9.1, required])"
]
},
{
"name": "Rule 9.2",
"description": "Braces shall be used to indicate and match the structure in the non-zero initialisation of arrays and structures.",
"severity": "required",
"pclint-flags": [
"+e785",
"+elib(785)",
"-append(785,[MISRA 2004 Rule 9.2, required])",
"+e940",
"+elib(940)",
"-append(940,[MISRA 2004 Rule 9.2, required])"
]
},
{
"name": "Rule 9.3",
"description": "In an enumerator list, the “=” construct shall not be used to explicitly initialise members other than the first, unless all items are explicitly initialised.",
"severity": "required",
"pclint-flags": []
}
]
},
{
"name": "10. Arithmetic type conversions",
"ruleset": [
{
"name": "Rule 10.1",
"description": "The value of an expression of integer type shall not be implicitly converted to a different underlying type if: ...",
"severity": "required",
"pclint-flags": [
"+e524",
"+elib(524)",
"-append(524,[MISRA 2004 Rule 10.1, required])",
"+e653",
"+elib(653)",
"-append(653,[MISRA 2004 Rule 10.1, required])"
]
},
{
"name": "Rule 10.2",
"description": "The value of an expression of floating type shall not be implicitly converted to a different type if: ...",
"severity": "required",
"pclint-flags": [
"+e747",
"+elib(747)",
"-append(747,[MISRA 2004 Rule 10.2, required])",
"+e918",
"+elib(918)",
"-append(918,[MISRA 2004 Rule 10.2, required])"
]
},
{
"name": "Rule 10.3",
"description": "The value of a complex expression of integer type shall only be cast to a type of the same signedness that is no wider than the underlying type of the expression.",
"severity": "required",
"pclint-flags": []
},
{
"name": "Rule 10.4",
"description": "The value of a complex expression of floating type shall only be cast to a floating type that is narrower or of the same size.",
"severity": "required",
"pclint-flags": []
},
{
"name": "Rule 10.5",
"description": "If the bitwise operators ~ and << are applied to an operand of underlying type unsigned char or unsigned short, the result shall be immediately cast to the underlying type of the operand.",
"severity": "required",
"pclint-flags": [
"+e701",
"+elib(701)",
"-append(701,[MISRA 2004 Rule 10.5, required])",
"+e702",
"+elib(702)",
"-append(702,[MISRA 2004 Rule 10.5, required])"
]
},
{
"name": "Rule 10.6",
"description": "A \"U\" suffix shall be applied to all constants of unsigned type.",
"severity": "required",
"pclint-flags": []
}
]
},
{
"name": "11. Pointer type conversions",
"ruleset": [
{
"name": "Rule 11.1",
"description": "Conversions shall not be performed between a pointer to a function and any type other than an integral type.",
"severity": "required",
"pclint-flags": [
"+esym(68,pointer)",
"-append(68,[MISRA 2004 Rule 11.1, required])",
"+esym(922,pointer)",
"-append(922,[MISRA 2004 Rule 11.1, required])",
"+e923",
"+elib(923)",
"-append(923,[Encompasses MISRA 2004 Rule 11.1, required])"
]
},
{
"name": "Rule 11.2",
"description": "Conversions shall not be performed between a pointer to object and any type other than an integral type, another pointer to object type or a pointer to void.",
"severity": "required",
"pclint-flags": [
"+esym(68,pointer)",
"-append(68,[MISRA 2004 Rule 11.2, required])",
"+e71",
"+elib(71)",
"-append(71,[MISRA 2004 Rule 11.2, required])",
"+esyms(920,pointer)",
"-append(920,[MISRA 2004 Rule 11.2, required])"
]
},
{
"name": "Rule 11.3",
"description": "A cast should not be performed between a pointer type and an integral type.",
"severity": "advisory",
"pclint-flags": [
"+e923",
"+elib(923)",
"-append(923,[MISRA 2004 Rule 11.3, advisory])"
]
},
{
"name": "Rule 11.4",
"description": "A cast should not be performed between a pointer to object type and a different pointer to object type.",
"severity": "advisory",
"pclint-flags": [
"+e926",
"+elib(926)",
"-append(926,[MISRA 2004 Rule 11.4, advisory])",
"+e927",
"+elib(927)",
"-append(927,[MISRA 2004 Rule 11.4, advisory])",
"+e928",
"+elib(928)",
"-append(928,[MISRA 2004 Rule 11.4, advisory])",
"+e929",
"+elib(929)",
"-append(929,[MISRA 2004 Rule 11.4, advisory])"
]
},
{
"name": "Rule 11.5",
"description": "A cast shall not be performed that removes any const or volatile qualification from the type addressed by a pointer.",
"severity": "required",
"pclint-flags": []
}
]
},
{
"name": "12. Expressions",
"ruleset": [
{
"name": "Rule 12.1",
"description": "Limited dependence should be placed on C's operator precedence rules in expressions.",
"severity": "advisory",
"pclint-flags": [
"+e834",
"+elib(834)",
"-append(834,[MISRA 2004 Rule 12.1, advisory])"
]
},
{
"name": "Rule 12.2",
"description": "The value of an expression shall be the same under any order of evaluation that the standard permits.",
"severity": "required",
"pclint-flags": [
"+e564",
"+elib(564)",
"-append(564,[MISRA 2004 Rule 12.2, required])",
"+e864",
"+elib(864)",
"-append(864,[MISRA 2004 Rule 12.2, required])",
"+e931",
"+elib(931)",
"-append(931,[MISRA 2004 Rule 12.2, required])"
]
},
{
"name": "Rule 12.3",
"description": "The sizeof operator shall not be used on expressions that contain side effects.",
"severity": "required",
"pclint-flags": []
},
{
"name": "Rule 12.4",
"description": "The right-hand operand of a logical && or || operator shall not contain side effects.",
"severity": "required",
"pclint-flags": []
},
{
"name": "Rule 12.5",
"description": "The operands of a logical && or || shall be primary-expressions.",
"severity": "required",
"pclint-flags": []
},
{
"name": "Rule 12.6",
"description": "The operands of logical operators (&&, || and !) should be effectively Boolean. Expressions that are effectively Boolean should not be used as operands to operators other than (&&, ||, !, =, ==, != and ?:).",
"severity": "advisory",
"pclint-flags": []
},
{
"name": "Rule 12.7",
"description": "Bitwise operators shall not be applied to operands whose underlying type is signed.",
"severity": "required",
"pclint-flags": []
},
{
"name": "Rule 12.8",
"description": "The right-hand operand of a shift operator shall lie between zero and one less than the width in bits of the underlying type of the left-hand operand.",
"severity": "required",
"pclint-flags": [
"+e572",
"+elib(572)",
"-append(572,[MISRA 2004 Rule 12.8, required])"
]
},
{
"name": "Rule 12.9",
"description": "The unary minus operator shall not be applied to an expression whose underlying type is unsigned.",
"severity": "required",
"pclint-flags": [
"+e501",
"+elib(501)",
"-append(501,[MISRA 2004 Rule 12.9, required])"
]
},
{
"name": "Rule 12.10",
"description": "The comma operator shall not be used.",
"severity": "required",
"pclint-flags": []
},
{
"name": "Rule 12.11",
"description": "Evaluation of constant unsigned integer expressions should not lead to wrap-around.",
"severity": "advisory",
"pclint-flags": [
"+e648",
"+elib(648)",
"-append(648,[MISRA 2004 Rule 12.11, advisory])"
]
},
{
"name": "Rule 12.12",
"description": "The underlying bit representations of floating-point values shall not be used.",
"severity": "required",
"pclint-flags": []
},
{
"name": "Rule 12.13",
"description": "The increment (++) and decrement (--) operators should not be mixed with other operators in an expression.",
"severity": "advisory",
"pclint-flags": []
}
]
},
{
"name": "13. Control statement expressions",
"ruleset": [
{
"name": "Rule 13.1",
"description": "Assignment operators shall not be used in expressions that yield a Boolean value.",
"severity": "required",
"pclint-flags": [
"+e720",
"+elib(720)",
"-append(720,[MISRA 2004 Rule 13.1, required])",
"+e820",
"+elib(820)",
"-append(820,[MISRA 2004 Rule 13.1, required])"
]
},
{
"name": "Rule 13.2",
"description": "Tests of a value against zero should be made explicit, unless the operand is effectively Boolean.",
"severity": "advisory",
"pclint-flags": [
"+e640",
"+elib(640)",
"-append(640,[MISRA 2004 Rule 13.2, advisory])",
"+e720",
"+elib(720)",
"-append(720,[MISRA 2004 Rule 13.2, advisory])"
]
},
{
"name": "Rule 13.3",
"description": "Floating-point expressions shall not be tested for equality or inequality.",
"severity": "required",
"pclint-flags": [
"+e777",
"+elib(777)",
"-append(777,[MISRA 2004 Rule 13.3, required])"
]
},
{
"name": "Rule 13.4",
"description": "The controlling expression of a for statement shall not contain any objects of floating type.",
"severity": "required",
"pclint-flags": []
},
{
"name": "Rule 13.5",
"description": "The three expressions of a for statement shall be concerned only with loop control.",
"severity": "required",
"pclint-flags": [
"+e440",
"+elib(440)",
"-append(440,[MISRA 2004 Rule 13.5, required])",
"+e443",
"+elib(443)",
"-append(443,[MISRA 2004 Rule 13.5, required])"
]
},
{
"name": "Rule 13.6",
"description": "Numeric variables being used within a for loop for iteration counting shall not be modified in the body of the loop.",
"severity": "required",
"pclint-flags": [
"+e850",
"+elib(850)",
"-append(850,[MISRA 2004 Rule 13.6, required])"
]
},
{
"name": "Rule 13.7",
"description": "Boolean operations whose results are invariant shall not be permitted.",
"severity": "required",
"pclint-flags": [
"+e506",
"+elib(506)",
"-append(506,[MISRA 2004 Rule 13.7, required])",
"+e650",
"+elib(650)",
"-append(650,[MISRA 2004 Rule 13.7, required])",
"+e685",
"+elib(685)",
"-append(685,[MISRA 2004 Rule 13.7, required])",
"+e774",
"+elib(774)",
"-append(774,[MISRA 2004 Rule 13.7, required])",
"+esym(845,&&,||)",
"-append(845,[MISRA 2004 Rule 13.7, required])"
]
}
]
},
{
"name": "14. Control flow",
"ruleset": [
{
"name": "Rule 14.1",
"description": "There shall be no unreachable code.",
"severity": "required",
"pclint-flags": [
"+e506",
"+elib(506)",
"-append(506,[MISRA 2004 Rule 14.1, required])",
"+e527",
"+elib(527)",
"-append(527,[MISRA 2004 Rule 14.1, required])",
"+e681",
"+elib(681)",
"-append(681,[MISRA 2004 Rule 14.1, required])",
"+e827",
"+elib(827)",
"-append(827,[MISRA 2004 Rule 14.1, required])"
]
},
{
"name": "Rule 14.2",
"description": "All non-null statements shall either: ...",
"severity": "required",
"pclint-flags": [
"+e505",
"+elib(505)",
"-append(505,[MISRA 2004 Rule 14.2, required])",
"+e522",
"+elib(522)",
"-append(522,[MISRA 2004 Rule 14.2, required])"
]
},
{
"name": "Rule 14.3",
"description": "Before preprocessing, a null statement shall only occur on a line by itself; it may be followed by a comment provided that the first character following the null statement is a white-space character.",
"severity": "required",
"pclint-flags": []
},
{
"name": "Rule 14.4",
"description": "The goto statement shall not be used.",
"severity": "required",
"pclint-flags": [
"+e801",
"+elib(801)",
"-append(801,[MISRA 2004 Rule 14.4, required])"
]
},
{
"name": "Rule 14.5",
"description": "The continue statement shall not be used.",
"severity": "required",
"pclint-flags": []
},
{
"name": "Rule 14.6",
"description": "For any iteration statement there shall be at most one break statement used for loop termination.",
"severity": "required",
"pclint-flags": []
},
{
"name": "Rule 14.7",
"description": "A function shall have a single point of exit at the end of the function.",
"severity": "required",
"pclint-flags": [
"+e904",
"+elib(904)",
"-append(904,[MISRA 2004 Rule 14.7, required])"
]
},
{
"name": "Rule 14.8",
"description": "The statement forming the body of a switch, while, do ... while or for statement shall be a compound statement.",
"severity": "required",
"pclint-flags": []
},
{
"name": "Rule 14.9",
"description": "An if (expression) construct shall be followed by a compound statement. The else keyword shall be followed by either a compound statement, or another if statement.",
"severity": "required",
"pclint-flags": []
},
{
"name": "Rule 14.10",
"description": "All if ... else if constructs shall be terminated with an else clause.",
"severity": "required",
"pclint-flags": []
}
]
},
{
"name": "15. Switch statements",
"ruleset": [
{
"name": "Rule 15.0",
"description": "The MISRA C switch syntax shall be used.",
"severity": "required",
"pclint-flags": []
},
{
"name": "Rule 15.1",
"description": "A switch label shall only be used when the most closely-enclosing compound statement is the body of a switch statement.",
"severity": "required",
"pclint-flags": [
"+e44",
"+elib(44)",
"-append(44,[MISRA 2004 Rule 15.1, required])"
]
},
{
"name": "Rule 15.2",
"description": "An unconditional break statement shall terminate every non-empty switch clause.",
"severity": "required",
"pclint-flags": [
"+e616",
"+elib(616)",
"-append(616,[MISRA 2004 Rule 15.2, required])",
"+e825",
"+elib(825)",
"-append(825,[MISRA 2004 Rule 15.2, required])"
]
},
{
"name": "Rule 15.3",
"description": "The final clause of a switch statement shall be the default clause.",
"severity": "required",
"pclint-flags": [
"+e744",
"+elib(744)",
"-append(744,[MISRA 2004 Rule 15.3, required])"
]
},
{
"name": "Rule 15.4",
"description": "A switch expression shall not represent a value that is effectively Boolean.",
"severity": "required",
"pclint-flags": []
},
{
"name": "Rule 15.5",
"description": "Every switch statement shall have at least one case clause.",
"severity": "required",
"pclint-flags": [
"+e764",
"+elib(764)",
"-append(764,[MISRA 2004 Rule 15.5, required])"
]
}
]
},
{
"name": "16. Functions",
"ruleset": [
{
"name": "Rule 16.1",
"description": "Functions shall not be defined with a variable number of arguments.",
"severity": "required",
"pclint-flags": []
},
{
"name": "Rule 16.2",
"description": "Functions shall not call themselves, either directly or indirectly.",
"severity": "required",
"pclint-flags": [
"+stack()",
"-e974",
"+estring(974,*recursive*)",
"-append(974,[MISRA 2004 Rule 16.2, required])"
]
},
{
"name": "Rule 16.3",
"description": "Identifiers shall be given for all of the parameters in a function prototype declaration.",
"severity": "required",
"pclint-flags": []
},
{
"name": "Rule 16.4",
"description": "The identifiers used in the declaration and definition of a function shall be identical.",
"severity": "required",
"pclint-flags": []
},
{
"name": "Rule 16.5",
"description": "Functions with no parameters shall be declared and defined with the parameter list void.",
"severity": "required",
"pclint-flags": [
"+e937",
"+elib(937)",
"-append(937,[MISRA 2004 Rule 16.5, required])"
]
},
{
"name": "Rule 16.6",
"description": "The number of arguments passed to a function shall match the number of parameters.",
"severity": "required",
"pclint-flags": [
"+e118",
"+elib(118)",
"-append(118,[MISRA 2004 Rule 16.6, required])",
"+e119",
"+elib(119)",
"-append(119,[MISRA 2004 Rule 16.6, required])"
]
},
{
"name": "Rule 16.7",
"description": "A pointer parameter in a function prototype should be declared as pointer to const if the pointer is not used to modify the addressed object.",
"severity": "advisory",
"pclint-flags": [
"+e818",
"+elib(818)",
"-append(818,[MISRA 2004 Rule 16.7, advisory])"
]
},
{
"name": "Rule 16.8",
"description": "All exit paths from a function with non-void return type shall have an explicit return statement with an expression.",
"severity": "required",
"pclint-flags": [
"+e533",
"+elib(533)",
"-append(533,[MISRA 2004 Rule 16.8, required])"
]
},
{
"name": "Rule 16.9",
"description": "A function identifier shall only be used with either a preceding &, or with a parenthesised parameter list, which may be empty.",
"severity": "required",
"pclint-flags": [
"-e546"
]
},
{
"name": "Rule 16.10",
"description": "If a function returns error information, then that error information shall be tested.",
"severity": "required",
"pclint-flags": [
"+e534",
"+elib(534)",
"-append(534,[Encompasses MISRA 2004 Rule 16.10, required])"
]
}
]
},
{
"name": "17. Pointers and arrays",
"ruleset": [
{
"name": "Rule 17.1",
"description": "Pointer arithmetic shall only be applied to pointers that address an array or array element.",
"severity": "required",
"pclint-flags": []
},
{
"name": "Rule 17.2",
"description": "Pointer subtraction shall only be applied to pointers that address elements of the same array.",
"severity": "required",
"pclint-flags": [
"+e946",
"+elib(946)",
"-append(946,[MISRA 2004 Rule 17.2, required])",
"+e947",
"+elib(947)",
"-append(947,[MISRA 2004 Rule 17.2, required])"
]
},
{
"name": "Rule 17.3",
"description": ">, >=, <, <= shall not be applied to pointer types except where they point to the same array.",
"severity": "required",
"pclint-flags": [
"+e946",
"+elib(946)",
"-append(946,[MISRA 2004 Rule 17.3, required])",
"+e947",
"+elib(947)",
"-append(947,[MISRA 2004 Rule 17.3, required])"
]
},
{
"name": "Rule 17.4",
"description": "Array indexing shall be the only allowed form of pointer arithmetic.",
"severity": "required",
"pclint-flags": []
},
{
"name": "Rule 17.5",
"description": "The declaration of objects should contain no more than 2 levels of pointer indirection.",
"severity": "required",
"pclint-flags": []
},
{
"name": "Rule 17.6",
"description": "The address of an object with automatic storage shall not be assigned to another object that may persist after the first object has ceased to exist.",
"severity": "required",
"pclint-flags": [
"+e604",
"+elib(604)",
"-append(604,[MISRA 2004 Rule 17.6, required])",
"+e684",
"+elib(684)",
"-append(684,[MISRA 2004 Rule 17.6, required])",
"+e733",
"+elib(733)",
"-append(733,[MISRA 2004 Rule 17.6, required])",
"+e789",
"+elib(789)",
"-append(789,[MISRA 2004 Rule 17.6, required])"
]
}
]
},
{
"name": "18. Structures and unions",
"ruleset": [
{
"name": "Rule 18.1",
"description": "All structure and union types shall be complete at the end of a translation unit.",
"severity": "required",
"pclint-flags": [
"+e43",
"+elib(43)",
"-append(43,[MISRA 2004 Rule 18.1, required])"
]
},
{
"name": "Rule 18.2",
"description": "An object shall not be assigned to an overlapping object.",
"severity": "required",
"pclint-flags": []
},
{
"name": "Rule 18.3",
"description": "An area of memory shall not be reused for unrelated purposes.",
"severity": "required",
"pclint-flags": []
},
{
"name": "Rule 18.4",
"description": "Unions shall not be used.",
"severity": "required",
"pclint-flags": []
}
]
},
{
"name": "19. Preprocessing directives",
"ruleset": [
{
"name": "Rule 19.1",
"description": "#include statements in a file should only be preceded by other preprocessor directives or comments.",
"severity": "advisory",
"pclint-flags": []
},
{
"name": "Rule 19.2",
"description": "Non-standard characters should not occur in header file names in #include directives.",
"severity": "advisory",
"pclint-flags": []
},
{
"name": "Rule 19.3",
"description": "The #include directive shall be followed by either a <filename> or \"filename\" sequence.",
"severity": "required",
"pclint-flags": [
"+e12",
"+elib(12)",
"-append(12,[MISRA 2004 Rule 19.3, required])"
]
},
{
"name": "Rule 19.4",
"description": "C macros shall only expand to a braced initialiser, a constant, a string literal, a parenthesised expression, a type qualifier, a storage class specifier, or a do-while-zero construct.",
"severity": "required",
"pclint-flags": [
"+e773",
"+elib(773)",
"-append(773,[MISRA 2004 Rule 19.4, required])"
]
},
{
"name": "Rule 19.5",
"description": "Macros shall not be #define’d or #undef’d within a block.",
"severity": "required",
"pclint-flags": []
},
{
"name": "Rule 19.6",
"description": "#undef shall not be used.",
"severity": "required",
"pclint-flags": []
},
{
"name": "Rule 19.7",
"description": "A function should be used in preference to a function-like macro.",
"severity": "advisory",
"pclint-flags": []
},
{
"name": "Rule 19.8",
"description": "A function-like macro shall not be invoked without all of its arguments.",
"severity": "required",
"pclint-flags": [
"+e131",
"+elib(131)",
"-append(131,[MISRA 2004 Rule 19.8, required])"
]
},
{
"name": "Rule 19.9",
"description": "Arguments to a function-like macro shall not contain tokens that look like preprocessing directives.",
"severity": "required",
"pclint-flags": [
"+e436",
"+elib(436)",
"-append(436,[MISRA 2004 Rule 19.9, required])"
]
},
{
"name": "Rule 19.10",
"description": "In the definition of a function-like macro each instance of a parameter shall be enclosed in parentheses unless it is used as the operand of # or ##.",
"severity": "required",
"pclint-flags": [
"+e9022",
"+elib(9022)",
"-append(9022,[MISRA 2004 Rule 19.10, required])"
]
},
{
"name": "Rule 19.11",
"description": "All macro identifiers in preprocessor directives shall be defined before use, except in #ifdef and #ifndef preprocessor directives and the defined() operator.",
"severity": "required",
"pclint-flags": [
"+e553",
"+elib(553)",
"-append(553,[MISRA 2004 Rule 19.11, required])"
]
},
{
"name": "Rule 19.12",
"description": "There shall be at most one occurrence of the # or ## operators in a single macro definition.",
"severity": "required",
"pclint-flags": []
},
{
"name": "Rule 19.13",
"description": "The # and ## operators should not be used",
"severity": "advisory",
"pclint-flags": []
},
{
"name": "Rule 19.14",
"description": "The defined preprocessor operator shall only be used in one of the two standard forms.",
"severity": "required",
"pclint-flags": []
},
{
"name": "Rule 19.15",
"description": "Precautions shall be taken in order to prevent the contents of a header file being included twice.",
"severity": "required",
"pclint-flags": [
"+e451",
"+elib(451)",
"-append(451,[MISRA 2004 Rule 19.15, required])"
]
},
{
"name": "Rule 19.16",
"description": "Preprocessing directives shall be syntactically meaningful even when excluded by the preprocessor.",
"severity": "required",
"pclint-flags": [
"+e544",
"+elib(544)",
"-append(544,[MISRA 2004 Rule 19.16, required])",
"+e16",
"+elib(16)",
"-append(16,[MISRA 2004 Rule 19.16, required])"
]
},
{
"name": "Rule 19.17",
"description": "All #else, #elif and #endif preprocessor directives shall reside in the same file as the #if or #ifdef directive to which they are related.",
"severity": "required",
"pclint-flags": [
"+e405",
"+elib(405)",
"-append(405,[MISRA 2004 Rule 19.17, required])"
]
}
]
},
{
"name": "20. Standard libraries",
"ruleset": [
{
"name": "Rule 20.1",
"description": "Reserved identifiers, macros and functions in the standard library, shall not be defined, redefined or undefined.",
"severity": "required",
"pclint-flags": [
"+e683",
"+elib(683)",
"-append(683,[MISRA 2004 Rule 20.1, required])"
]
},
{
"name": "Rule 20.2",
"description": "The names of standard library macros, objects and functions shall not be reused.",
"severity": "required",
"pclint-flags": []
},
{
"name": "Rule 20.3",
"description": "The validity of values passed to library functions shall be checked.",
"severity": "required",
"pclint-flags": []
},
{
"name": "Rule 20.4",
"description": "Dynamic heap memory allocation shall not be used.",
"severity": "required",
"pclint-flags": [
"+e586",
"+elib(586)",
"-deprecate( function, calloc, [MISRA 2004 Rule 20.4, required] )",
"-deprecate( function, malloc, [MISRA 2004 Rule 20.4, required] )",
"-deprecate( function, realloc, [MISRA 2004 Rule 20.4, required] )",
"-deprecate( function, free, [MISRA 2004 Rule 20.4, required] )"
]
},
{
"name": "Rule 20.5",
"description": "The error indicator errno shall not be used.",
"severity": "required",
"pclint-flags": [
"+e586",
"+elib(586)",
"-deprecate( variable, errno, [MISRA 2004 Rule 20.5, required] )",
"-deprecate( macro, strerror, [MISRA 2004 Rule 20.5, required] )"
]
},
{
"name": "Rule 20.6",
"description": "The macro offsetof, in library <stddef.h>, shall not be used.",
"severity": "required",
"pclint-flags": [
"+e586",
"+elib(586)",
"-deprecate( macro, offsetof, [MISRA 2004 Rule 20.6, required] )"
]
},
{
"name": "Rule 20.7",
"description": "The setjmp macro and the longjmp function shall not be used.",
"severity": "required",
"pclint-flags": [
"+e586",
"+elib(586)",
"-deprecate( function, longjmp, [MISRA 2004 Rule 20.7, required] )",
"-deprecate( macro, setjmp, [MISRA 2004 Rule 20.7, required] )"
]
},
{
"name": "Rule 20.8",
"description": "The signal handling facilities of <signal.h> shall not be used.",
"severity": "required",
"pclint-flags": [
"+e586",
"+elib(586)",
"-deprecate( function, signal, [MISRA 2004 Rule 20.8, required] )",
"-deprecate( function, raise, [MISRA 2004 Rule 20.8, required] )",
"+e829",
"+elib(829)",
"-headerwarn(signal.h)",
"-append(829(signal.h),[MISRA 2004 Rule 20.8, required])",
"-deprecate( macro, SIG_DFL, [MISRA 2004 Rule 20.8, required] )",
"-deprecate( macro, SIG_ERR, [MISRA 2004 Rule 20.8, required] )",
"-deprecate( macro, SIG_IGN, [MISRA 2004 Rule 20.8, required] )",
"-deprecate( macro, SIGABRT, [MISRA 2004 Rule 20.8, required] )",
"-deprecate( macro, SIGFPE, [MISRA 2004 Rule 20.8, required] )",
"-deprecate( macro, SIGILL, [MISRA 2004 Rule 20.8, required] )",
"-deprecate( macro, SIGINT, [MISRA 2004 Rule 20.8, required] )",
"-deprecate( macro, SIGSEGV, [MISRA 2004 Rule 20.8, required] )",
"-deprecate( macro, SIGTERM, [MISRA 2004 Rule 20.8, required] )"
]
},
{
"name": "Rule 20.9",
"description": "The input/output library <stdio.h> shall not be used in production code.",
"severity": "required",
"pclint-flags": [
"+e829",
"+elib(829)",
"-headerwarn(stdio.h)",
"-append(829(stdio.h),[MISRA 2004 Rule 20.9, required])",
"-deprecate( macro, _IOFBF, [MISRA 2004 Rule 20.9, required] )",
"-deprecate( macro, _IOLBF, [MISRA 2004 Rule 20.9, required] )",
"-deprecate( macro, _IONBF, [MISRA 2004 Rule 20.9, required] )",
"-deprecate( macro, BUFSIZ, [MISRA 2004 Rule 20.9, required] )",
"-deprecate( macro, EOF, [MISRA 2004 Rule 20.9, required] )",
"-deprecate( macro, FOPEN_MAX, [MISRA 2004 Rule 20.9, required] )",
"-deprecate( macro, FILENAME_MAX, [MISRA 2004 Rule 20.9, required] )",
"-deprecate( macro, L_tmpnam, [MISRA 2004 Rule 20.9, required] )",
"-deprecate( macro, SEEK_CUR, [MISRA 2004 Rule 20.9, required] )",
"-deprecate( macro, SEEK_END, [MISRA 2004 Rule 20.9, required] )",
"-deprecate( macro, SEEK_SET, [MISRA 2004 Rule 20.9, required] )",
"-deprecate( macro, TMP_MAX, [MISRA 2004 Rule 20.9, required] )",
"-deprecate( macro, stdin, [MISRA 2004 Rule 20.9, required] )",
"-deprecate( macro, stdout, [MISRA 2004 Rule 20.9, required] )",
"-deprecate( macro, stderr, [MISRA 2004 Rule 20.9, required] )",
"-deprecate( function, clearerr, [MISRA 2004 Rule 20.9, required] )",
"-deprecate( function, fclose, [MISRA 2004 Rule 20.9, required] )",
"-deprecate( function, feof, [MISRA 2004 Rule 20.9, required] )",
"-deprecate( function, ferror, [MISRA 2004 Rule 20.9, required] )",
"-deprecate( function, fflush, [MISRA 2004 Rule 20.9, required] )",
"-deprecate( function, fgetc, [MISRA 2004 Rule 20.9, required] )",
"-deprecate( function, fopen, [MISRA 2004 Rule 20.9, required] )",
"-deprecate( function, fprintf, [MISRA 2004 Rule 20.9, required] )",
"-deprecate( function, fputc, [MISRA 2004 Rule 20.9, required] )",
"-deprecate( function, fputs, [MISRA 2004 Rule 20.9, required] )",
"-deprecate( function, fread, [MISRA 2004 Rule 20.9, required] )",
"-deprecate( function, freopen, [MISRA 2004 Rule 20.9, required] )",
"-deprecate( function, fscanf, [MISRA 2004 Rule 20.9, required] )",
"-deprecate( function, fseek, [MISRA 2004 Rule 20.9, required] )",
"-deprecate( function, fsetpos, [MISRA 2004 Rule 20.9, required] )",
"-deprecate( function, ftell, [MISRA 2004 Rule 20.9, required] )",
"-deprecate( function, fwrite, [MISRA 2004 Rule 20.9, required] )",
"-deprecate( function, getc, [MISRA 2004 Rule 20.9, required] )",
"-deprecate( function, getchar, [MISRA 2004 Rule 20.9, required] )",
"-deprecate( function, gets, [MISRA 2004 Rule 20.9, required] )",
"-deprecate( function, perror, [MISRA 2004 Rule 20.9, required] )",
"-deprecate( function, printf, [MISRA 2004 Rule 20.9, required] )",
"-deprecate( function, putc, [MISRA 2004 Rule 20.9, required] )",
"-deprecate( function, putchar, [MISRA 2004 Rule 20.9, required] )",
"-deprecate( function, puts, [MISRA 2004 Rule 20.9, required] )",
"-deprecate( function, remove, [MISRA 2004 Rule 20.9, required] )",
"-deprecate( function, rename, [MISRA 2004 Rule 20.9, required] )",
"-deprecate( function, rewind, [MISRA 2004 Rule 20.9, required] )",
"-deprecate( function, scanf, [MISRA 2004 Rule 20.9, required] )",
"-deprecate( function, setbuf, [MISRA 2004 Rule 20.9, required] )",
"-deprecate( function, setvbuf, [MISRA 2004 Rule 20.9, required] )",
"-deprecate( function, sprintf, [MISRA 2004 Rule 20.9, required] )",
"-deprecate( function, sscanf, [MISRA 2004 Rule 20.9, required] )",
"-deprecate( function, tmpfile, [MISRA 2004 Rule 20.9, required] )",
"-deprecate( function, tmpnam, [MISRA 2004 Rule 20.9, required] )",
"-deprecate( function, ungetc, [MISRA 2004 Rule 20.9, required] )",
"-deprecate( function, vfprintf, [MISRA 2004 Rule 20.9, required] )",
"-deprecate( function, vprintf, [MISRA 2004 Rule 20.9, required] )",
"-deprecate( function, vsprintf, [MISRA 2004 Rule 20.9, required] )"
]
},
{
"name": "Rule 20.10",
"description": "The library functions atof, atoi and atol from library <stdlib.h> shall not be used.",
"severity": "required",
"pclint-flags": [
"+e586",
"+elib(586)",
"-deprecate( function, atof, [MISRA 2004 Rule 20.10, required] )",
"-deprecate( function, atoi, [MISRA 2004 Rule 20.10, required] )",
"-deprecate( function, atol, [MISRA 2004 Rule 20.10, required] )"
]
},
{
"name": "Rule 20.11",
"description": "he library functions abort, exit, getenv and system from library <stdlib.h> shall not be used.",
"severity": "required",
"pclint-flags": [
"+e586",
"+elib(586)",
"-deprecate( function, abort, [MISRA 2004 Rule 20.11, required] )",
"-deprecate( function, exit, [MISRA 2004 Rule 20.11, required] )",
"-deprecate( function, getenv, [MISRA 2004 Rule 20.11, required] )",
"-deprecate( function, system, [MISRA 2004 Rule 20.11, required] )"
]
},
{
"name": "Rule 20.12",
"description": "The time handling functions of library <time.h> shall not be used.",
"severity": "required",
"pclint-flags": [
"+e586",
"+elib(586)",
"-deprecate( function, time, [MISRA 2004 Rule 20.12, required] )",
"-deprecate( function, strftime, [MISRA 2004 Rule 20.12, required] )",
"-deprecate( function, clock, [MISRA 2004 Rule 20.12, required] )",
"-deprecate( function, difftime, [MISRA 2004 Rule 20.12, required] )",
"-deprecate( function, mktime, [MISRA 2004 Rule 20.12, required] )"
]
}
]
},
{
"name": "21. Run-time failures",
"ruleset": [
{
"name": "Rule 21.1",
"description": "Minimisation of run-time failures shall be ensured by the use of at least one of...",
"severity": "required",
"pclint-flags": []
}
]
}
]
}
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment