/* Date Stamp */ -d"_lint_au_misra_cpp_lnt=au-misra-cpp.lnt modified 12-Jun-2014"
/* To document usage use: -message( "Using " _lint_au_misra_cpp_lnt ) */
// ---------------------------------------------------------------------
// This file is provided by Gimpel Software (www.gimpel.com) for use with
// its products PC-lint and FlexeLint.
//
// Redistribution and use of this file, with or without modification, is
// permitted provided that any such redistribution retains this notice.
// ---------------------------------------------------------------------
// au-misra-cpp.lnt -- Author options - MISRA C++

/*
    This options file can be used to explicitly activate those
    checks advocated by the Motor Industry Software Reliability
    Association for C++ code.

    You can use this file directly when linting your programs as in:

    lin  au-misra-cpp  files

    Gimpel Software relies on the document, "MISRA-C++:2008
    Guidelines for the use of the C++ language in critical systems",
    copyright 2008 by MIRA Limited, as the primary source for this
    file.  Gimpel Software makes no warranty as to the completeness
    or applicability of this options file and reserves the right to
    amend or alter the official contents of such at any time.

    "MISRA" is a registered trademark of MIRA Limited, held on
    behalf of the MISRA Consortium.

 */

    -misra(C++)
    +e1960                     /* enable special MISRA messages */
    +elib(1960)
    +e1963                     /* enable special MISRA messages */
    +elib(1963)

/* Rule 0-1-1    (req) *********************************/

    +e527                       /* unreachable */
    +elib(527)
    -append(527,[MISRA C++ Rule 0-1-1])
    +e506       /* constant value boolean */
    +elib(506)
    -append(506,[MISRA C++ Rule 0-1-1])
    +e681       /* loop not entered */
    +elib(681)
    -append(681,[MISRA C++ Rule 0-1-1])
    +e827       /* loop not reachable */
    +elib(827)
    -append(827,[MISRA C++ Rule 0-1-1])
    +e685       /* relational operator always evaluates to true/false */
    +elib(685)
    -append(685,[MISRA C++ Rule 0-1-1])
    +e774       /* boolean always evaluates to true/false */
    +elib(774)
    -append(774,[MISRA C++ Rule 0-1-1])
    +e944       /* argument always evaluates to ... */
    +elib(944)
    -append(944,[MISRA C++ Rule 0-1-1])

/* Rule 0-1-2    (req) *********************************/

    +e685       /* relational operator always evaluates to true/false */
    +elib(685)
    -append(685,[MISRA C++ Rule 0-1-2])
    +e774       /* boolean always evaluates to true/false */
    +elib(774)
    -append(774,[MISRA C++ Rule 0-1-2])
    +e827       /* loop not reachable */
    +elib(827)
    -append(827,[MISRA C++ Rule 0-1-2])
    +e944       /* argument always evaluates to ... */
    +elib(944)
    -append(944,[MISRA C++ Rule 0-1-2])

/* Rule 0-1-3    (req) *********************************/

    +e528       /* symbol not referenced */
    +elib(528)
    -append(528,[MISRA C++ Rule 0-1-3])
    +e529       /* symbol not referenced */
    +elib(529)
    -append(529,[MISRA C++ Rule 0-1-3])
    +e714       /* symbol not referenced */
    +elib(714)
    -append(714,[MISRA C++ Rule 0-1-3])
    +e752       /* local declarator not referenced */
    +elib(752)
    -append(752,[MISRA C++ Rule 0-1-3])
    +e757       /* global declarator not referenced */
    +elib(757)
    -append(757,[MISRA C++ Rule 0-1-3])

/* Rule 0-1-4    (req) *********************************/

    +e528       /* symbol not referenced */
    +elib(528)
    -append(528,[MISRA C++ Rule 0-1-4])
    +e529       /* symbol not referenced */
    +elib(529)
    -append(529,[MISRA C++ Rule 0-1-4])
    +e550       /* symbol not accessed */
    +elib(550)
    -append(550,[MISRA C++ Rule 0-1-4])
    +e551       /* symbol not accessed */
    +elib(551)
    -append(551,[MISRA C++ Rule 0-1-4])
    +e552       /* symbol not accessed */
    +elib(552)
    -append(552,[MISRA C++ Rule 0-1-4])

/* Rule 0-1-5    (req) *********************************/

    +e751       /* local typedef not referenced */
    +elib(751)
    -append(751,[MISRA C++ Rule 0-1-5])
    +e753       /* local tag not referenced */
    +elib(753)
    -append(753,[MISRA C++ Rule 0-1-5])
    +e756       /* global typedef not referenced */
    +elib(756)
    -append(756,[MISRA C++ Rule 0-1-5])
    +e758       /* global tag not referenced */
    +elib(758)
    -append(758,[MISRA C++ Rule 0-1-5])

/* Rule 0-1-6    (req) *********************************/

    +e438       /* variable's last value not used */
    +elib(438)
    -append(438,[MISRA C++ Rule 0-1-6])

/* Rule 0-1-7    (req) *********************************/

    +e534       /* return value ignored */
    +elib(534)
    -append(534,[MISRA C++ Rule 0-1-7])

/* Rule 0-1-8    (req) *********************************/

    /* we generate note 1960 as follows
       Note 1960: Violates MISRA C++ Required Rule 0-1-8,
       Void return type for function without external side-effects
     */

/* Rule 0-1-9    (req) *********************************/

    +e438       /* variable's last value not used */
    +elib(438)
    -append(438,[MISRA C++ Rule 0-1-9])
    +e587       /* predicate always evaluates to ... */
    +elib(587)
    -append(587,[MISRA C++ Rule 0-1-9])
    +e685       /* relational operator always evaluates to true/false */
    +elib(685)
    -append(685,[MISRA C++ Rule 0-1-9])
    +e774       /* boolean always evaluates to true/false */
    +elib(774)
    -append(774,[MISRA C++ Rule 0-1-9])
    +e838       /* previous value not used */
    +elib(838)
    -append(838,[MISRA C++ Rule 0-1-9])
    +e944       /* argument always evaluates to ... */
    +elib(944)
    -append(944,[MISRA C++ Rule 0-1-9])
    +e948       /* operator always evaluates to ... */
    +elib(948)
    -append(948,[MISRA C++ Rule 0-1-9])

/* Rule 0-1-10    (req) *********************************/

    +e528       /* symbol not referenced */
    +elib(528)
    -append(528,[MISRA C++ Rule 0-1-10])
    +e714       /* symbol not referenced */
    +elib(714)
    -append(714,[MISRA C++ Rule 0-1-10])
    +e1714       /* member function not referenced */
    +elib(1714)
    -append(1714,[MISRA C++ Rule 0-1-10])
    +e1716       /* virtual member function not referenced */
    +elib(1716)
    -append(1716,[MISRA C++ Rule 0-1-10])
    +e1914       /* default constructor not referenced */
    +elib(1914)
    -append(1914,[MISRA C++ Rule 0-1-10])

/* Rule 0-1-11    (req) *********************************/

    +e715       /* symbol not referenced */
    +elib(715)
    -append(715,[MISRA C++ Rule 0-1-11])

/* Rule 0-1-12    (req) *********************************/

    +e715       /* symbol not referenced */
    +elib(715)
    -append(715,[MISRA C++ Rule 0-1-12])

/* Rule 0-2-1    (req) *********************************/

    /*  See rule 9-5-1.  */

/* Rule 0-3-1    (doc) *********************************/

    /*  Automatically accomplished by using PC-lint/FlexeLint  */

/* Rule 0-3-2   (req) *********************************/

    +e534       /* return value ignored */
    +elib(534)
    -append(534,[MISRA C++ Rule 0-3-2])

/* Rule 0-4-1    (doc) *********************************/

    /* not statically checkable */

/* Rule 0-4-2    (doc) *********************************/

    /* not statically checkable */

/* Rule 0-4-3    (doc) *********************************/

    /* not statically checkable */

/* Rule 1-0-1    (req) *********************************/

    -A(C++2003) /* ensure ISO C++ 2003 compliance */

/* Rule 1-0-2    (req) *********************************/

    /* not statically checkable */

/* Rule 1-0-3    (doc) *********************************/

    /* not statically checkable */

/* Rule 2-2-1    (doc) *********************************/

    /* not statically checkable */

/* Rule 2-3-1    (req) *********************************/

    -ftg
    +e584       /* trigraph sequence detected */
    +elib(584)
    -append(584,[MISRA C++ Rule 2-3-1])
    +e739       /* trigraph sequence in literal */
    +elib(739)
    -append(739,[MISRA C++ Rule 2-3-1])

/* Rule 2-5-1    (adv) *********************************/

    /* we generate note 1963 as follows
       Note 1963: Violates MISRA C++ Required Rule 2-5-1,
       Possible digraph
     */

/* Rule 2-7-1    (req) *********************************/

    -fnc
    +e602       /* comment within comment */
    +elib(602)
    -append(602,[MISRA C++ Rule 2-7-1])

/* Rule 2-7-2    (req) *********************************/

    /* not statically checkable */

/* Rule 2-7-3    (adv) *********************************/

    /* not statically checkable */

/* Rule 2-10-1   (req) *********************************/

    +e620       /* suspicious constant */
    +elib(620)
    -append(620,[MISRA C++ Rule 2-10-1])

/* Rule 2-10-2   (req) *********************************/

    +e578       /* declaration hides symbol */
    +elib(578)
    -append(578,[MISRA C++ Rule 2-10-2])
    +e1411       /* hidden virtual member */
    +elib(1411)
    -append(1411,[MISRA C++ Rule 2-10-2])
    +e1511       /* hidden non-virtual member */
    +elib(1511)
    -append(1511,[MISRA C++ Rule 2-10-2])
    +e1516       /* member hides member */
    +elib(1516)
    -append(1516,[MISRA C++ Rule 2-10-2])
    +e1737       /* hidden operator new */
    +elib(1737)
    -append(1737,[MISRA C++ Rule 2-10-2])
    +e1761       /* hidden overloaded function */
    +elib(1761)
    -append(1761,[MISRA C++ Rule 2-10-2])

/* Rule 2-10-3   (req) *********************************/

    /* we generate note 1960 as follows
       Note 1960: Violates MISRA C++ Required Rule 2-10-3,
       Typedef is not a unique declarator
     */

/* Rule 2-10-4   (req) *********************************/

    /* we generate note 1960 as follows
       Note 1960: Violates MISRA C++ Required Rule 2-10-4,
       Tag is not a unique declarator
     */

/* Rule 2-10-5   (adv) *********************************/

    /* we generate note 1963 as follows
       Note 1963: Violates MISRA C++ Advisory Rule 2-10-5,
       Identifier with static storage is reused
     */

/* Rule 2-10-6   (req) *********************************/

    +e18       /* redeclaration */
    +elib(18)
    -append(18,[MISRA C++ Rule 2-10-6])

/* Rule 2-13-1   (req) *********************************/

    +e606       /* non-ANSI escape sequence */
    +elib(606)
    -append(606,[MISRA C++ Rule 2-13-1])

/* Rule 2-13-2   (req) *********************************/

    /* we generate note 1960 as follows
       Note 1960: Violates MISRA C++ Required Rule 2-13-2,
       Octal constant used
     */

/* Rule 2-13-3   (req) *********************************/

    /* we generate note 1960 as follows
       Note 1960: Violates MISRA C++ Required Rule 2-13-3,
       Unsigned octal and hexadecimal literals require a 'U' suffix
     */

/* Rule 2-13-4   (req) *********************************/

    /* we generate note 1960 as follows
       Note 1960: Violates MISRA C++ Required Rule 2-13-4,
       Lower case literal suffix
     */
    +e620       /* suspicious constant */
    +elib(620)
    -append(620,[MISRA C++ Rule 2-13-4])

/* Rule 2-13-5   (req) *********************************/

    +e707   /* mixing narrow and wide string
               literals in concatenation */
    +elib(707)
    -append(707,[MISRA C++ Rule 2-13-5])

/* Rule 3-1-1    (req) *********************************/

    /* we generate note 1960 as follows
       Note 1960: Violates MISRA C++ Required Rule 3-1-1,
       no object/function definitions in header files
     */

/* Rule 3-1-2    (req) *********************************/

    /* we generate note 1960 as follows
       Note 1960: Violates MISRA C++ Required Rule 3-1-2,
       function not declared at file scope
     */

/* Rule 3-1-3    (req) *********************************/

    +e85       /* zero-dimensioned array */
    +elib(85)
    -append(85,[MISRA C++ Rule 3-1-3])
    /* we generate note 1960 as follows
       Note 1960: Violates MISRA C++ Required Rule 3-1-3.
       extern array declared without size or initializer
     */

/* Rule 3-2-1    (req) *********************************/

    +e18       /* redeclaration */
    +elib(18)
    -append(18,[MISRA C++ Rule 3-2-1])
    +e31       /* redefinition */
    +elib(31)
    -append(31,[MISRA C++ Rule 3-2-1])

/* Rule 3-2-2    (req) *********************************/

    +e15       /* redeclaration */
    +elib(15)
    -append(15,[MISRA C++ Rule 3-2-2])
    +e31       /* redefinition */
    +elib(31)
    -append(31,[MISRA C++ Rule 3-2-2])

/* Rule 3-2-3    (req) *********************************/

    /* we generate note 1960 as follows
       Note 1960: Violates MISRA C++ Required Rule 3-2-3,
       Object/function type previously declared in location
     */

/* Rule 3-2-4    (req) *********************************/

    +e15       /* redeclaration */
    +elib(15)
    -append(15,[MISRA C++ Rule 3-2-4])
    +e31       /* redefinition */
    +elib(31)
    -append(31,[MISRA C++ Rule 3-2-4])

/* Rule 3-3-1    (req) *********************************/

    +e759       /* could move declaration to module */
    +elib(759)
    -append(759,[MISRA C++ Rule 3-3-1])
    +e765       /* could be made static */
    +elib(765)
    -append(765,[MISRA C++ Rule 3-3-1])

/* Rule 3-3-2    (req) *********************************/

    +e401       /* not previously declared static */
    +elib(401)
    -append(401,[MISRA C++ Rule 3-3-2])
    +e512       /* previously used as static */
    +elib(512)
    -append(512,[MISRA C++ Rule 3-3-2])

/* Rule 3-4-1    (req) *********************************/

    /* not currently supported */

/* Rule 3-9-1    (req) *********************************/

    /* not currently supported */

/* Rule 3-9-2    (adv) *********************************/

    +e970       /* type or modifier outside of typedef */
    +elib(970)
    -esym(970,wchar_t)
    -append(970,[MISRA C++ Rule 3-9-2])
    //  For the duration, we are presuming MISRA does not want
    //  diagnostics for the bool type.
    -esym(970,bool)

/* Rule 3-9-3    (req) *********************************/

    /* we generate note 1960 as follows
       Note 1960: Violates MISRA C++ Required Rule 3-9-3,
       Bit representation of a floating point type used
     */

/* Rule 4-5-1    (req) *********************************/

    /* we generate note 1960 as follows
       Note 1960: Violates MISRA C++ Required Rule 4-5-1,
       Boolean expression used with non-permitted operator
     */

/* Rule 4-5-2    (req) *********************************/

    /* not currently supported */

/* Rule 4-5-3    (req) *********************************/

    /* we generate note 1960 as follows
       Note 1960: Violates MISRA C++ Required Rule 4-5-3,
       Plain char used with prohibited operator
     */

/* Rule 4-10-1  (req) *********************************/

    /* not currently supported */

/* Rule 4-10-2  (req) *********************************/

    +e910       /* conversion from 0 to pointer */
    +elib(910)
    -emacro((910), NULL)    /*  explicit exception  */
    -append(910,[MISRA C++ Rule 4-10-2])

/* Rule 5-0-1    (req) *********************************/

    +e564                       /* order of evaluation */
    +elib(564)
    -append(564,[MISRA C++ Rule 5-0-1])
    +e864                       /* order of evaluation */
    +elib(864)
    -append(864,[MISRA C++ Rule 5-0-1])

/* Rule 5-0-2    (adv) *********************************/

    +e834  /* confusing operator sequence (same precedence) */
    +elib(834)
    -append(834,[MISRA C++ Rule 5-0-2])

/* Rule 5-0-3    (req) *********************************/

    /* we generate note 1960 as follows
       Note 1960: Violates MISRA C++ Required Rule 5-0-3,
       Implicit conversion of integer/floating point cvalue expression
     */

/* Rule 5-0-4    (req) *********************************/

    /* we generate note 1960 as follows
       Note 1960: Violates MISRA C++ Required Rule 5-0-4,
       Implicit conversion changes signedness
     */

/* Rule 5-0-5    (req) *********************************/

    /* we generate note 1960 as follows
       Note 1960: Violates MISRA C++ Required Rule 5-0-5,
       Implicit conversion from integer/floating point to floating
       point/integer type
     */

/* Rule 5-0-6    (req) *********************************/

    /* we generate note 1960 as follows
       Note 1960: Violates MISRA C++ Required Rule 5-0-6,
       Implicit conversion of integer/floating point to smaller type
     */

/* Rule 5-0-7    (req) *********************************/

    /* we generate note 1960 as follows
       Note 1960: Violates MISRA C++ Required Rule 5-0-7,
       Cast of cvalue expression from integer/floating point to
       floating point/integer type
     */

/* Rule 5-0-8    (req) *********************************/

    /* we generate note 1960 as follows
       Note 1960: Violates MISRA C++ Required Rule 5-0-8,
       Cast of integer/floating point cvalue expression to larger type
     */

/* Rule 5-0-9    (req) *********************************/

    /* we generate note 1960 as follows
       Note 1960: Violates MISRA C++ Required Rule 5-0-9,
       Cast of cvalue expression changes signedness
     */

/* Rule 5-0-10    (req) *********************************/

    /* we generate note 1960 as follows
       Note 1960: Violates MISRA C++ Required Rule 5-0-10,
       Operators '~' and '<<' require recasting to underlying type for
       sub-integers
     */

/* Rule 5-0-11    (req) *********************************/

    /* we generate note 1960 as follows
       Note 1960: Violates MISRA C++ Required Rule 5-0-11,
       Disallowed use of non-character value, or Plain char mixed with
       type other than plain char
     */

/* Rule 5-0-12    (req) *********************************/

    /* we generate note 1960 as follows
       Note 1960: Violates MISRA C++ Required Rule 5-0-12,
       Disallowed use of non-numeric value
     */

/* Rule 5-0-13    (req) *********************************/

    +e909       /* conversion to bool */
    +elib(909)
    -append(909,[MISRA C++ Rule 5-0-13])

/* Rule 5-0-14    (req) *********************************/

    +e909       /* conversion to bool */
    +elib(909)
    -append(909,[MISRA C++ Rule 5-0-14])

/* Rule 5-0-15    (req) *********************************/

    +e946          /* relational or subtract operator applied to pointers */
    +elib(946)
    -append(946,[MISRA C++ Rule 5-0-15])
    +e947          /* subtract operator applied to pointers */
    +elib(947)
    -append(947,[MISRA C++ Rule 5-0-15])
    /* we generate note 1960 as follows
       Note 1960: Violates MISRA C++ Required Rule 5-0-15,
       Pointer arithmetic other than array indexing used, or
       Pointer arithmetic by increment or decrement used
     */

/* Rule 5-0-16    (req) *********************************/

    +e415   /* out-of-bounds pointer */
    +elib(415)
    -append(415,[MISRA C++ Rule 5-0-16])
    +e416   /* out-of-bounds pointer */
    +elib(416)
    -append(416,[MISRA C++ Rule 5-0-16])
    +e661   /* out-of-bounds pointer */
    +elib(661)
    -append(661,[MISRA C++ Rule 5-0-16])
    +e662   /* out-of-bounds pointer */
    +elib(662)
    -append(662,[MISRA C++ Rule 5-0-16])
    +e796   /* out-of-bounds pointer */
    +elib(796)
    -append(796,[MISRA C++ Rule 5-0-16])
    +e797   /* out-of-bounds pointer */
    +elib(797)
    -append(797,[MISRA C++ Rule 5-0-16])

/* Rule 5-0-17    (req) *********************************/

    +e946          /* relational or subtract operator applied to pointers */
    +elib(946)
    -append(946,[MISRA C++ Rule 5-0-17])
    +e947          /* subtract operator applied to pointers */
    +elib(947)
    -append(947,[MISRA C++ Rule 5-0-17])

/* Rule 5-0-18    (req) *********************************/

    +e946          /* relational or subtract operator applied to pointers */
    +elib(946)
    -append(946,[MISRA C++ Rule 5-0-18])
    +e947          /* subtract operator applied to pointers */
    +elib(947)
    -append(947,[MISRA C++ Rule 5-0-18])

/* Rule 5-0-19    (req) *********************************/

    /* we generate note 1960 as follows
       Note 1960: Violates MISRA C++ Required Rule 5-0-19,
       More than two pointer indirection levels used
     */

/* Rule 5-0-20  (req) *********************************/

    /* not currently supported */

/* Rule 5-0-21  (req) *********************************/

    /* we generate note 1960 as follows
       Note 1960: Violates MISRA C++ Required Rule 5-0-21,
       Bitwise operator applied to signed underlying type
     */

/* Rule 5-2-1  (req) *********************************/

    /* we generate note 1960 as follows
       Note 1960: Violates MISRA C++ Required Rule 5-2-1,
       Non-postfix expression used with logical operator
     */

/* Rule 5-2-2  (req) *********************************/

    +e1774  /* could use dynamic_cast */
    +elib(1774)
    -append(1774,[MISRA C++ Rule 5-2-2])
    +e1939  /* down_cast used */
    +elib(1939)
    -append(1939,[MISRA C++ Rule 5-2-2])

/* Rule 5-2-3  (adv) *********************************/

    /* not currently supported */

/* Rule 5-2-4  (req) *********************************/

    +e1924  /* C-style cast */
    +elib(1924)
    -append(1924,[MISRA C++ Rule 5-2-4])

/* Rule 5-2-5  (req) *********************************/

    +e1773  /* casting away const/volatile */
    +elib(1773)
    -append(1773,[MISRA C++ Rule 5-2-5])
    /* we generate note 1960 as follows
       Note 1960: Violates MISRA C++ Required Rule 5-2-5,
       Attempt to cast away const/volatile from a pointer or reference
     */

/* Rule 5-2-6  (req) *********************************/

    +e611   /* suspicious cast */
    +elib(611)
    -append(611,[MISRA C++ Rule 5-2-6])
    +e740   /* unusual cast */
    +elib(740)
    -append(740,[MISRA C++ Rule 5-2-6])

/* Rule 5-2-7  (req) *********************************/

    +e740   /* unusual cast */
    +elib(740)
    -append(740,[MISRA C++ Rule 5-2-7])
    +e916   /* pointer assignment conversion */
    +elib(916)
    -append(916,[MISRA C++ Rule 5-2-7])
    +e918   /* prototype coercion */
    +elib(918)
    -append(918,[MISRA C++ Rule 5-2-7])
    +esym(920,pointer)   /* implicit conversion */
    +elib(920)
    -append(920,[MISRA C++ Rule 5-2-7])
    +e923   /* cast */
    +elib(923)
    -append(923,[MISRA C++ Rule 5-2-7])
    +e926   /* pointer cast */
    +elib(926)
    -append(926,[MISRA C++ Rule 5-2-7])
    +e927   /* pointer cast */
    +elib(927)
    -append(927,[MISRA C++ Rule 5-2-7])
    +e928   /* pointer cast */
    +elib(928)
    -append(928,[MISRA C++ Rule 5-2-7])
    +e929   /* pointer cast */
    +elib(929)
    -append(929,[MISRA C++ Rule 5-2-7])
    +e930   /* cast */
    +elib(930)
    -append(930,[MISRA C++ Rule 5-2-7])

/* Rule 5-2-8  (adv) *********************************/

    +estring(64,ptrs to void/nonvoid)
    +e923   /* cast */
    +elib(923)
    -append(923,[MISRA C++ Rule 5-2-8])
    +e925               /* cast */
    +elib(925)
    -append(925,[MISRA C++ Rule 5-2-8])
    +esym(930,pointer)   /* cast */
    +elib(930)
    -append(930,[MISRA C++ Rule 5-2-8])

/* Rule 5-2-9  (adv) *********************************/

    +e925               /* cast */
    +elib(925)
    -append(925,[MISRA C++ Rule 5-2-9])
    +e9091               /* cast */
    +elib(9091)
    -append(9091,[MISRA C++ Rule 5-2-9])

/* Rule 5-2-10  (adv) *********************************/

    +e564   /* order of evaluation */
    +elib(564)
    -append(564,[MISRA C++ Rule 5-2-10])
    +e591   /* order of evaluation */
    +elib(591)
    -append(591,[MISRA C++ Rule 5-2-10])
    +e864   /* order of evaluation */
    +elib(864)
    -append(864,[MISRA C++ Rule 5-2-10])
    /* we generate note 1963 as follows
       Note 1963: Violates MISRA C++ Advisory Rule 5-2-10,
       Increment or decrement combined with another operator
     */

/* Rule 5-2-11  (req) *********************************/

    +e1753  /* operator overloaded */
    +elib(1753)
    -append(1753,[MISRA C++ Rule 5-2-11])

/* Rule 5-2-12  (req) *********************************/

    /* we generate note 1960 as follows
       Note 1960: Violates MISRA C++ Required Rule 5-2-12,
       Array type passed to function expecting a pointer
     */

/* Rule 5-3-1  (req) *********************************/

    +e909       /* conversion to bool */
    +elib(909)
    -append(909,[MISRA C++ Rule 5-3-1])
    /* we generate note 1960 as follows
       Note 1960: Violates MISRA C++ Required Rule 5-3-1,
       Boolean expression required for operator
     */

/* Rule 5-3-2  (req) *********************************/

    +e501                        /* expected signed type */
    +elib(501)
    -append(501,[MISRA C++ Rule 5-3-2])
    /* we generate note 1960 as follows
       Note 1960: Violates MISRA C++ Required Rule 5-3-2,
       Prohibited operator applied to unsigned underlying type: -
     */

/* Rule 5-3-3  (req) *********************************/

    /* we generate note 1960 as follows
       Note 1960: Violates MISRA C++ Required Rule 5-3-3,
       Unary operator & overloaded
     */

/* Rule 5-3-4    (req) *********************************/

    /* we generate note 1960 as follows
       Note 1960: Violates MISRA C++ Required Rule 5-3-4,
       'sizeof' used on expressions with side effect
     */

/* Rule 5-8-1  (req) *********************************/

    +e572                        /* excessive shift value */
    +elib(572)
    -append(572,[MISRA C++ Rule 5-8-1])
    /* we generate note 1960 as follows
       Note 1960: Violates MISRA C++ Required Rule 5-8-1,
       out of bounds value for right hand side of shift operator
     */

/* Rule 5-14-1   (req) *********************************/

    /* we generate note 1960 as follows
       Note 1960: Violates MISRA C++ Required Rule 5-14-1,
       side effects on right hand side of logical operator
     */

/* Rule 5-17-1  (req) *********************************/

    /* not currently supported */

/* Rule 5-18-1  (req) *********************************/

    /* we generate note 1960 as follows
       Note 1960: Violates MISRA C++ Required Rule 5-18-1,
       comma operator used
     */

/* Rule 5-19-1  (adv) *********************************/

    +e648   /* overflow in computing constant */
    +elib(648)
    -append(648,[MISRA C++ Rule 5-19-1])

/* Rule 6-2-1  (req) *********************************/

    +e720                         /* Boolean test of assignment */
    +elib(720)
    -append(720,[MISRA C++ Rule 6-2-1])
    +e820       /* boolean test of parenthesized assignment */
    +elib(820)
    -append(820,[MISRA C++ Rule 6-2-1])
    /* we generate note 1960 as follows
       Note 1960: Violates MISRA C++ Required Rule 6-2-1,
       assignment operator used in sub-expression
     */

/* Rule 6-2-2  (req) *********************************/

    +e777       /* testing floats for equality */
    +elib(777)
    -append(777,[MISRA C++ Rule 6-2-2])
    /* we generate note 1960 as follows
       Note 1960: Violates MISRA C++ Required Rule 6-2-2,
       floating point test for equality or inequality
     */

/* Rule 6-2-3  (req) *********************************/

    /* we generate note 1960 as follows
       Note 1960: Violates MISRA C++ Required Rule 6-2-3,
       null statement not in line by itself
     */

/* Rule 6-3-1  (req) *********************************/

    /* we generate note 1960 as follows
       Note 1960: Violates MISRA C++ Required Rule 6-3-1,
       left brace expected for switch, while, do...while, and for
     */

/* Rule 6-4-1  (req) *********************************/

    /* we generate note 1960 as follows
       Note 1960: Violates MISRA C++ Required Rule 6-4-1,
       left brace expected for if and else
     */

/* Rule 6-4-2  (req) *********************************/

    /* we generate note 1960 as follows
       Note 1960: Violates MISRA C++ Required Rule 6-4-2,
       no 'else' at end of 'if ... else if' chain
     */

/* Rule 6-4-3  (req) *********************************/

    /* we generate note 1960 as follows
       Note 1960: Violates MISRA C++ Required Rule 6-4-3,
       departure from MISRA switch syntax
     */

/* Rule 6-4-4  (req) *********************************/

    /* we generate note 1960 as follows
       Note 1960: Violates MISRA C++ Required Rule 6-4-4,
       most closely enclosing compound statement of a case/default is
       not of a switch
     */

/* Rule 6-4-5  (req) *********************************/

    +e616       /* control flows into case/default */
    +elib(616)
    -append(616,[MISRA C++ Rule 6-4-5])
    +e825       /* control flows into case/default without -fallthrough */
    +elib(825)
    -append(825,[MISRA C++ Rule 6-4-5])
    /* we generate note 1960 as follows
       Note 1960: Violates MISRA C++ Required Rule 6-4-5,
       missing unconditional break from switch case
     */

/* Rule 6-4-6  (req) *********************************/

    +e744                         /* switch statement has no default */
    +elib(744)
    -append(744,[MISRA C++ Rule 6-4-6])

    /* we also generate note 1960 as follows:
       Note 1960: Violates MISRA C++ Required Rule 6-4-6,
       case label follows default in switch statement
     */

/* Rule 6-4-7  (req) *********************************/

    /* we generate note 1960 as follows
       Note 1960: Violates MISRA C++ Required Rule 6-4-7,
       boolean value in switch statement
     */

/* Rule 6-4-8  (req) *********************************/

    +e764       /* no case */
    +elib(764)
    -append(764,[MISRA C++ Rule 6-4-8])

/* Rule 6-5-1  (req) *********************************/

    /* not currently supported */

/* Rule 6-5-2  (req) *********************************/

    /* not currently supported */

/* Rule 6-5-3  (req) *********************************/

    +e850       /* loop variable modified in body */
    +elib(850)
    -append(850,[MISRA C++ Rule 6-5-3])

/* Rule 6-5-4  (req) *********************************/

    /* not currently supported */

/* Rule 6-5-5  (req) *********************************/

    /* not currently supported */

/* Rule 6-5-6  (req) *********************************/

    /* not currently supported */

/* Rule 6-6-1  (req) *********************************/

    /* not currently supported */

/* Rule 6-6-2  (req) *********************************/

    +e107   /* label not defined */
    +elib(107)
    -append(107,[MISRA C++ Rule 6-6-2])
    /* we generate note 1960 as follows
       Note 1960: Violates MISRA C++ Required Rule 6-6-2,
       Goto jumps to an earlier point in the code
     */

/* Rule 6-6-3  (req) *********************************/

    /* we generate note 1960 as follows
       Note 1960: Violates MISRA C++ Required Rule 6-6-3,
       continue statement detected
     */

/* Rule 6-6-4  (req) *********************************/

    /* we generate note 1960 as follows
       Note 1960: Violates MISRA C++ Required Rule 6-6-4,
       more than one 'break' terminates loop
     */

/* Rule 6-6-5  (req) *********************************/

    +e904   /* return before function end */
    +elib(904)
    -append(904,[MISRA C++ Rule 6-6-5])

/* Rule 7-1-1  (req) *********************************/

    +e952                      /* use const on paramaters where appropriate */
    +elib(952)
    -append(952,[MISRA C++ Rule 7-1-1])

/* Rule 7-1-2  (req) *********************************/

    +e818                       /* use const on paramaters where appropriate */
    +elib(818)
    -append(818,[MISRA C++ Rule 7-1-2])

/* Rule 7-2-1  (req) *********************************/

    /* not currently supported */

/* Rule 7-3-1  (req) *********************************/

    /* we generate note 1960 as follows
       Note 1960: Violates MISRA C++ Required Rule 7-3-1,
       Global declaration
     */

/* Rule 7-3-2  (req) *********************************/

    /* we generate note 1960 as follows
       Note 1960: Violates MISRA C++ Required Rule 7-3-2,
       Non-global function, main, declared
     */

/* Rule 7-3-3  (req) *********************************/

    /* we generate note 1960 as follows
       Note 1960: Violates MISRA C++ Required Rule 7-3-3,
       Unnamed namespace in header
     */

/* Rule 7-3-4  (req) *********************************/

    /* we generate note 1960 as follows
       Note 1960: Violates MISRA C++ Required Rule 7-3-4,
       Using-directive used
     */

/* Rule 7-3-5  (req) *********************************/

    /* not currently supported */

/* Rule 7-3-6  (req) *********************************/

    /* we generate note 1960 as follows
       Note 1960: Violates MISRA C++ Required Rule 7-3-6,
       Using-directive/declaration in header file
     */

/* Rule 7-4-1  (doc) *********************************/

    /* not statically checkable */

/* Rule 7-4-2  (req) *********************************/

    /*  only use the asm declaration to introduce assembly code  */
    -rw(_asm)
    -rw(__asm)
    -pragma(asm)
    -pragma(endasm)
    -ppw(asm)
    -ppw(endasm)

/* Rule 7-4-3  (req) *********************************/

    /* not currently supported */

/* Rule 7-5-1  (req) *********************************/

    +e604   /* returning address of auto variable */
    +elib(604)
    -append(604,[MISRA C++ Rule 7-5-1)

/* Rule 7-5-2  (req) *********************************/

    +e789   /* assigning auto address to static */
    +elib(789)
    -append(789,[MISRA C++ Rule 7-5-2])
    +e604   /* returning address of auto variable */
    +elib(604)
    -append(604,[MISRA C++ Rule 7-5-2])

/* Rule 7-5-3  (req) *********************************/

    +e1780  /*  returning address of reference
                to a const parameter */
    +elib(1780)
    -append(1780,[MISRA C++ Rule 7-5-3])
    +e1940  /*  address of reference parameter transferred outside of
                function */
    +elib(1940)
    -append(1940,[MISRA C++ Rule 7-5-3])

/* Rule 7-5-4  (req) *********************************/

    +stack()
    -e974
    +estring(974,*recursive*)   /* worst case stack usage */
    -append(974,[MISRA C++ Rule 7-5-4])

/* Rule 8-0-1  (req) *********************************/

    /* we generate note 1960 as follows
       Note 1960: Violates MISRA C++ Required Rule 8-0-1,
       Multiple declarators in a declaration
     */

/* Rule 8-3-1  (req) *********************************/

    +e1735  /* virtual function has default parameter */
    +elib(1735)
    -append(1735,[Potentially Violates MISRA C++ Rule 8-3-1])

/* Rule 8-4-1  (req) *********************************/

    +e1916  /* ellipsis */
    +elib(1916)
    -append(1916,[MISRA C++ Rule 8-4-1])
    /* we generate note 1960 as follows
       Note 1960: Violates MISRA C++ Required Rule 8-4-1,
       Function has variable number of arguments
     */

/* Rule 8-4-2  (req) *********************************/

    /* we generate note 1960 as follows
       Note 1960: Violates MISRA C++ Required Rule 8-4-2,
       Function parameter list differs
     */

/* Rule 8-4-3  (req) *********************************/

    +e533   /* missing/extraneous return value */
    +elib(533)
    -append(533,[MISRA C++ Rule 8-4-3])

/* Rule 8-4-4  (req) *********************************/

    /* we generate note 1960 as follows
       Note 1960: Violates MISRA C++ Required Rule 8-4-4,
       Function identifier used without & or parenthesized parameter
       list
     */

/* Rule 8-5-1  (req) *********************************/

    +e530   /* symbol not initialized */
    +elib(530)
    -append(530,[MISRA C++ Rule 8-5-1])
    +e1744  /* possibly not initialized */
    +elib(1744)
    -append(1744,[MISRA C++ Rule 8-5-1])
    +e1401  /* member not initialized */
    +elib(1401)
    -append(1401,[MISRA C++ Rule 8-5-1])

/* Rule 8-5-2  (req) *********************************/

    +e940   /* omitted braces */
    +elib(940)
    -append(940,[MISRA C++ Rule 8-5-2])

/* Rule 8-5-3  (req) *********************************/

    /* we generate note 1960 as follows
       Note 1960: Violates MISRA C++ Required Rule 8-5-3,
       should initialize either all enum members or only the first
     */

/* Rule 9-3-1  (req) *********************************/

    +e605   /* increase in pointer capability */
    +elib(605)
    -append(605,[MISRA C++ Rule 9-3-1])
    +e1536  /* exposing member */
    +elib(1536)
    -append(1536,[MISRA C++ Rule 9-3-1])
    +e1763  /* const function modifies member */
    +elib(1763)
    -append(1763,[MISRA C++ Rule 9-3-1])

/* Rule 9-3-2  (req) *********************************/

    +e1536  /* exposing member */
    +elib(1536)
    -append(1536,[MISRA C++ Rule 9-3-2])

/* Rule 9-3-3  (req) *********************************/

    +e1762  /* member could be const */
    +elib(1762)
    -append(1762,[MISRA C++ Rule 9-3-3])

/* Rule 9-5-1  (req) *********************************/

    /* we generate note 1960 as follows
       Note 1960: Violates MISRA C++ Required Rule 9-5-1,
       unions shall not be used
     */

/* Rule 9-6-1  (doc) *********************************/

    /* not statically checkable */

/* Rule 9-6-2  (req) *********************************/

    +e46    /* bit field should be int */
    +elib(46)
    -append(46,[MISRA C++ Rule 9-6-2])
    /* we generate note 1960 as follows
       Note 1960: Violates MISRA C++ Required Rule 9-6-2,
       Bit field must be explicitly signed int, unsigned int, or bool
     */

/* Rule 9-6-3  (req) *********************************/

    +e46    /* bit field should be int */
    +elib(46)
    -append(46,[MISRA C++ Rule 9-6-3])

/* Rule 9-6-4  (req) *********************************/

    +e806   /* signed small bit field */
    +elib(806)
    -append(806,[MISRA C++ Rule 9-6-4])
    /* we generate note 1960 as follows
       Note 1960: Violates MISRA C++ Required Rule 9-6-4,
       Signed bit field is too small
     */

/* Rule 10-1-1  (adv) *********************************/

    +e1749  /* base class need not be virtual */
    +elib(1749)
    -append(1749,[MISRA C++ Rule 10-1-1])

/* Rule 10-1-2  (req) *********************************/

    /* not currently supported */

/* Rule 10-1-3  (req) *********************************/

    +e1748  /* multiple inclusion of non-virtual base class */
    +elib(1748)
    -append(1748,[MISRA C++ Rule 10-1-3])

/* Rule 10-2-1  (adv) *********************************/

    /* not currently supported */

/* Rule 10-3-1  (req) *********************************/

    /* not currently supported */

/* Rule 10-3-2  (req) *********************************/

    +e1909  /* 'virtual' assumed */
    +elib(1909)
    -append(1909,[MISRA C++ Rule 10-3-2])

/* Rule 10-3-3  (req) *********************************/

    /* not currently supported */

/* Rule 11-0-1  (req) *********************************/

    /* we generate note 1960 as follows
       Note 1960: Violates MISRA C++ Required Rule 11-0-1,
       Non-private data member within a non-POD structure
     */

/* Rule 12-1-1  (req) *********************************/

    +e1506  /* virtual function called inside constructor */
    +elib(1506)
    -append(1506,[MISRA C++ Rule 12-1-1])

/* Rule 12-1-2  (adv) *********************************/

    +e1928  /* symbol not in constructor initializer list */
    +elib(1928)
    -append(1928,[MISRA C++ Rule 12-1-2])

/* Rule 12-1-3  (req) *********************************/

    /* not currently supported */

/* Rule 12-8-1  (req) *********************************/

    +e1938  /* constructor access global data */
    +elib(1938)
    -append(1938,[MISRA C++ Rule 12-8-1])

/* Rule 12-8-2  (req) *********************************/

    /* we generate note 1960 as follows
       Note 1960: Violates MISRA C++ Required Rule 12-8-2,
       Public copy constructor in abstract class
     */

/* Rule 14-5-1  (req) *********************************/

    +e1573  /* generic function template declared in namespace
               associated with type
             */
    +elib(1573)
    -append(1573,[MISRA C++ Rule 14-5-1])

/* Rule 14-5-2  (req) *********************************/

    +e1789  /* template constructor cannot be copy constructor */
    +elib(1789)
    -append(1789,[MISRA C++ Rule 14-5-2])

/* Rule 14-5-3  (req) *********************************/

    +e1721  /* non-assignment operator=() */
    +elib(1721)
    -append(1721,[MISRA C++ Rule 14-5-3])

/* Rule 14-6-1  (req) *********************************/

    +e1942  /* possible misinterpretation of name */
    +elib(1942)
    -append(1942,[MISRA C++ Rule 14-6-1])

/* Rule 14-6-2  (req) *********************************/

    /* awaiting clarification from MISRA */

/* Rule 14-7-1  (req) *********************************/

    +e1795  /* template not instantiated */
    +elib(1795)
    -append(1795,[MISRA C++ Rule 14-7-1])

/* Rule 14-7-2  (req) *********************************/

    /* not currently supported */

/* Rule 14-7-3  (req) *********************************/

    +e1576  /* specialization occurs in different file than template
               definition
             */
    +elib(1576)
    -append(1576,[MISRA C++ Rule 14-7-3])
    +e1577  /* specialization occurs in different file than template
               definition
             */
    +elib(1577)
    -append(1577,[MISRA C++ Rule 14-7-3])

/* Rule 14-8-1  (req) *********************************/

    /* we generate note 1960 as follows
       Note 1960: Violates MISRA C++ Required Rule 14-8-1,
       Explicit specialization of overloaded function templates
     */

/* Rule 14-8-2  (adv) *********************************/

    /* we generate note 1963 as follows
       Note 1963: Violates MISRA C++ Advisory Rule 14-8-2,
       Viable set contains both function and template
     */

/* Rule 15-0-1  (doc) *********************************/

    /* not statically checkable */

/* Rule 15-0-2  (adv) *********************************/

    /* we generate note 1963 as follows
       Note 1963: Violates MISRA C++ Advisory Rule 15-0-2,
       dependence placed on C's operator precedence
     */

/* Rule 15-0-3  (req) *********************************/

    +estring(646,try,catch) /* misplaced case? */
    -append(646,[MISRA C++ Rule 15-0-3])

/* Rule 15-1-1  (req) *********************************/

    /* not currently supported */

/* Rule 15-1-2  (req) *********************************/

    /* we generate note 1960 as follows
       Note 1960: Violates MISRA C++ Required Rule 15-1-2,
       Explicit throw of the NULL macro
     */

/* Rule 15-1-3  (req) *********************************/

    /* we generate note 1960 as follows
       Note 1960: Violates MISRA C++ Required Rule 15-1-3,
       Empty throw outside of a catch block
     */

/* Rule 15-3-1  (req) *********************************/

    +e1546  /* throw() inside destructor */
    +elib(1546)
    -append(1546,[MISRA C++ Rule 15-3-1])

/* Rule 15-3-2  (adv) *********************************/

    /* not currently supported */

/* Rule 15-3-3  (req) *********************************/

    /* not currently supported */

/* Rule 15-3-4  (req) *********************************/

    +e1560  /* uncaught exception */
    +elib(1560)
    -append(1560,[MISRA C++ Rule 15-3-4])

/* Rule 15-3-5  (req) *********************************/

    +e1752  /* non-reference catch parameter */
    +elib(1752)
    -append(1752,[MISRA C++ Rule 15-3-5])

/* Rule 15-3-6  (req) *********************************/

    /* not currently supported */

/* Rule 15-3-7  (req) *********************************/

    /* we generate note 1960 as follows
       Note 1960: Violates MISRA C++ Required Rule 15-3-7,
       Catch handler after catch(...)
     */

/* Rule 15-4-1  (req) *********************************/

    +e1548  /* conflicting exception specifications */
    +elib(1548)
    -append(1548,[MISRA C++ Rule 15-4-1])

/* Rule 15-5-1  (req) *********************************/

    +e1546  /* throw() inside destructor */
    +elib(1546)
    -append(1546,[MISRA C++ Rule 15-5-1])
    +e1559  /* uncaught exception */
    +elib(1559)
    -append(1559,[MISRA C++ Rule 15-5-1])

/* Rule 15-5-2  (req) *********************************/

    +e1549  /* exception thrown in no-throw function */
    +elib(1549)
    -append(1549,[MISRA C++ Rule 15-5-2])

/* Rule 15-5-3  (req) *********************************/

    +e1546  /* throw() inside destructor */
    +elib(1546)
    -append(1546,[MISRA C++ Rule 15-5-3])
    +e1560  /* uncaught exception */
    +elib(1560)
    -append(1560,[MISRA C++ Rule 15-5-3])
    +e1559  /* uncaught exception */
    +elib(1559)
    -append(1559,[MISRA C++ Rule 15-5-3])

/* Rule 16-0-1  (req) *********************************/

    /* we generate note 1960 as follows
       Note 1960: Violates MISRA C++ Required Rule 16-0-1,
       only preprocessor statements and comments before '#include'
     */

/* Rule 16-0-2  (req) *********************************/

    /* we generate note 1960 as follows
       Note 1960: Violates MISRA C++ Required Rule 16-0-2,
       '#undef'/'#define' used within a block
     */

/* Rule 16-0-3  (req) *********************************/

    /* we generate note 1960 as follows
       Note 1960: Violates MISRA C++ Required Rule 16-0-3,
       '#undef' is discouraged
     */

/* Rule 16-0-4  (req) *********************************/

    /* we generate note 1960 as follows
       Note 1960: Violates MISRA C++ Required Rule 16-0-4,
       function-like macro defined
     */

/* Rule 16-0-5  (req) *********************************/

    +e436   /* preprocessor directive in invocation of macro */
    +elib(436)
    -append(436,[MISRA C++ Rule 16-0-5])

/* Rule 16-0-6  (req) *********************************/

    +e665   /* unparenthesized macro parameter */
    +elib(665)
    -append(665,[MISRA C++ Rule 16-0-6])
    /* we generate note 1960 as follows
       Note 1960: Violates MISRA C++ Required Rule 16-0-6,
       unparenthesized macro parameter in definition of macro
     */

/* Rule 16-0-7  (req) *********************************/

    +e553              /* undefined preprocessor variable */
    +elib(553)
    -append(553,[MISRA C++ Rule 16-0-7])

/* Rule 16-0-8  (req) *********************************/

    +e16        /* # directive not followed by recognizable word */
    +elib(16)
    -append(16,[MISRA C++ Rule 16-0-8])
    +e544       /* endif or else not followed by EOL */
    +elib(544)
    -append(544,[MISRA C++ Rule 16-0-8])
    /* we generate note 1960 as follows
       Note 1960: Violates MISRA C++ Required Rule 16-0-8,
       all preprocessing directives must be valid
     */

/* Rule 16-1-1  (req) *********************************/

    /* we generate note 1960 as follows
       Note 1960: Violates MISRA C++ Required Rule 16-1-1,
       Non-standard use of 'defined' preprocessor statement
     */

/* Rule 16-1-2  (req) *********************************/

    +e405       /* #if not closed off */
    +elib(405)
    -append(405,[MISRA C++ Rule 16-1-2])

/* Rule 16-2-1  (req) *********************************/

    /* not currently supported */

/* Rule 16-2-2  (req) *********************************/

    +e1923  /* macro could be const variable */
    +elib(1923)
    -append(1923,[MISRA C++ Rule 16-2-2])

/* Rule 16-2-3  (req) *********************************/

    +e967   /* no standard include guard */
    +elib(967)
    -append(967,[MISRA C++ Rule 16-2-3])

/* Rule 16-2-4  (req) *********************************/

    /* we generate note 1960 as follows
       Note 1960: Violates MISRA C++ Required Rule 16-2-4,
       header file name with non-standard character
     */

/* Rule 16-2-5  (adv) *********************************/

    /* we generate note 1963 as follows
       Note 1963: Violates MISRA C++ Advisory Rule 16-2-5,
       header file name with non-standard character
     */
    /*  Note: If your system requires the '\' be used as a directory
        separator, uncomment the following option.
     */
    //  -estring(1963,\)

/* Rule 16-2-6  (req) *********************************/

    +e12                    /* Need < or " after #include */
    +elib(12)
    -append(12,[MISRA C++ Rule 16-2-6])

/* Rule 16-3-1  (req) *********************************/

    /* we generate note 1960 as follows
       Note 1960: Violates MISRA C++ Required Rule 16-3-1,
       Multiple use of '#/##' operators in macro definition
     */

/* Rule 16-3-2  (adv) *********************************/

    /* we generate note 1963 as follows
       Note 1963: Violates MISRA C++ Advisory Rule 16-3-2,
       '#/##' operator used
     */

/* Rule 16-6-1  (doc) *********************************/

    /* not statically checkable */

/* Rule 17-0-1  (req) *********************************/

    +e683       /* complain about #define standard functions */
    +elib(683)
    -append(683,[MISRA C++ Rule 17-0-1])

/* Rule 17-0-2  (req) *********************************/

    /* we generate note 1960 as follows
       Note 1960: Violates MISRA C++ Required Rule 17-0-2,
       Re-use of reserved identifier
     */

/* Rule 17-0-3  (req) *********************************/

    /* not currently supported */

/* Rule 17-0-4  (req) *********************************/

    /* See various +elib options throughout this file. */

/* Rule 17-0-5  (req) *********************************/

    +e586       /* Symbol is deprecated */
    +elib(586)
    -deprecate( function, longjmp, [MISRA C++ Rule 17-0-5] )
    -deprecate( macro, setjmp, [MISRA C++ Rule 17-0-5] )

/* Rule 18-0-1  (req) *********************************/

    +e829   /* header warning */
    +elib(829)
    +headerwarn(time.h)
    +headerwarn(limits.h)
    +headerwarn(float.h)
    +headerwarn(stddef.h)
    +headerwarn(errno.h)
    +headerwarn(locale.h)
    +headerwarn(stdio.h)
    +headerwarn(ctype.h)
    +headerwarn(string.h)
    +headerwarn(math.h)
    +headerwarn(stdlib.h)
    +headerwarn(assert.h)
    +headerwarn(stdarg.h)
    +headerwarn(setjmp.h)
    +headerwarn(signal.h)
    -append(829,[MISRA C++ Rule 18-0-1])

/* Rule 18-0-2  (req) *********************************/

    +e586       /* Symbol is deprecated */
    +elib(586)
    -deprecate( function, atof, [MISRA C++ Rule 18-0-2] )
    -deprecate( function, atoi, [MISRA C++ Rule 18-0-2] )
    -deprecate( function, atol, [MISRA C++ Rule 18-0-2] )

/* Rule 18-0-3  (req) *********************************/

    +e586       /* Symbol is deprecated */
    +elib(586)
    -deprecate( function, abort, [MISRA C++ Rule 18-0-3] )
    -deprecate( function, exit, [MISRA C++ Rule 18-0-3] )
    -deprecate( function, getenv, [MISRA C++ Rule 18-0-3] )
    -deprecate( function, system, [MISRA C++ Rule 18-0-3] )

/* Rule 18-0-4  (req) *********************************/

    +e829   /* header warning */
    +elib(829)
    +headerwarn(ctime)
    -append(829,[MISRA C++ Rule 18-0-4])

/* Rule 18-0-5  (req) *********************************/

    +e586       /* Symbol is deprecated */
    +elib(586)
    -deprecate( function, strcpy, [MISRA C++ Rule 18-0-5] )
    -deprecate( function, strcmp, [MISRA C++ Rule 18-0-5] )
    -deprecate( function, strcat, [MISRA C++ Rule 18-0-5] )
    -deprecate( function, strchr, [MISRA C++ Rule 18-0-5] )
    -deprecate( function, strspn, [MISRA C++ Rule 18-0-5] )
    -deprecate( function, strcspn, [MISRA C++ Rule 18-0-5] )
    -deprecate( function, strpbrk, [MISRA C++ Rule 18-0-5] )
    -deprecate( function, strrchr, [MISRA C++ Rule 18-0-5] )
    -deprecate( function, strstr, [MISRA C++ Rule 18-0-5] )
    -deprecate( function, strtok, [MISRA C++ Rule 18-0-5] )
    -deprecate( function, strlen, [MISRA C++ Rule 18-0-5] )

/* Rule 18-2-1  (req) *********************************/

    +e586       /* Symbol is deprecated */
    +elib(586)
    -deprecate( macro, offsetof, [MISRA C++ Rule 18-2-1] )

/* Rule 18-4-1  (req) *********************************/

    +e586       /* Symbol is deprecated */
    +elib(586)
    -deprecate( function, operator new, [MISRA C++ Rule 18-4-1] )
    -deprecate( function, operator delete, [MISRA C++ Rule 18-4-1] )
    -deprecate( function, calloc, [MISRA C++ Rule 18-4-1] )
    -deprecate( function, malloc, [MISRA C++ Rule 18-4-1] )
    -deprecate( function, realloc, [MISRA C++ Rule 18-4-1] )
    -deprecate( function, free, [MISRA C++ Rule 18-4-1] )

/* Rule 18-7-1  (req) *********************************/

    +e829   /* header warning */
    +elib(829)
    +headerwarn(csignal)
    -append(829,[MISRA C++ Rule 18-7-1])

/* Rule 19-3-1  (req) *********************************/

    +e586       /* Symbol is deprecated */
    +elib(586)
    -deprecate( variable, errno, [MISRA C++ Rule 19-3-1] )

/* Rule 27-0-1  (req) *********************************/

    +e829   /* header warning */
    +elib(829)
    +headerwarn(cstdio)
    -append(829,[MISRA C++ Rule 27-0-1])
