diff options
Diffstat (limited to 'debian/uncrustify-trinity/uncrustify-trinity-0.74.0/scripts/pclint/policy.lnt')
| -rw-r--r-- | debian/uncrustify-trinity/uncrustify-trinity-0.74.0/scripts/pclint/policy.lnt | 396 |
1 files changed, 396 insertions, 0 deletions
diff --git a/debian/uncrustify-trinity/uncrustify-trinity-0.74.0/scripts/pclint/policy.lnt b/debian/uncrustify-trinity/uncrustify-trinity-0.74.0/scripts/pclint/policy.lnt new file mode 100644 index 00000000..911e74b7 --- /dev/null +++ b/debian/uncrustify-trinity/uncrustify-trinity-0.74.0/scripts/pclint/policy.lnt @@ -0,0 +1,396 @@ +// uncrustify policy +-passes(2) // number of analysis passes (higher values give better detection but slower) +-static_depth(2) // number of analyzed redirection for static variables +//-w2 // suppress informational messages +// -strong(AJX) // All typedefs must match exactly +-w3 // display informational messages +//-w4 // use the maximum warning level +//+fpn // warns about the use of pointer parameters without first checking for NULL +//+fsc // assumes string constants are const char* + +// all checks from 0 to 599 are enabled by +w2 +-e10 // Expecting identifier or other declarator +-e18 // symbol redefined +-e19 // useless declaration +-e14 // symbol previously defined +-e26 // expected an expression found const/return +-e30 // expected an integer constant +-e31 // redefinition of symbol +-e32 // field size should not be zero +-e36 // redefining the storage class of symbol +-e40 // undeclared identifier +-e46 // field type should be an integral or enumeration type +-e48 // bad type +-e49 // expected a typed +-e50 // attempted to take the address of a non-lvalue +-e52 // expected an lvalue +-e55 // bad type +-e56 // bad type +-e63 // expected an lvalue +-e64 // type mismatch +-e78 // typedef'd symbol used in expression +-e85 // array has dimension 0 +-e96 // unmatched left brace for linkage specification +-e114 // inconsistent +-e119 // too many arguments +-e123 // macro defined with arguments +-e129 // declaration expected +-e200 // internal error +-e438 // last value assignd to variable not used +-e451 // header without include guard +-e457 // enable for checking multithreading +-e458 // enable for checking multithreading +-e459 // enable for checking multithreading +-e506 // allow constant value booleans +-e514 // unusual use of boolean expression +-e516 // symbol has arg type conflict +-e520 // highest operation lacks side effects +-e522 // highest operation lacks side effects +-e526 // symbol not defined +-e528 // symbol not referenced +-e534 // ignoring return value of function +-e537 // do not warn about repeated inclusion +-e574 // signed / unsigned mix with relational +-e578 // Declaration of symbol hides symbol +-e585 // not a valid Trigraph sequence + ++e601 // Expected a type for symbol Symbol ++e602 // Comment within comment ++e603 // Symbol not initialized ++e604 // Returning address of auto variable ++e605 // Increase in pointer capability ++e606 // Non-ANSI escape sequence: ++e607 // Parameter of macro found within string ++e608 // Assigning to an array parameter ++e609 // Suspicious pointer conversion ++e610 // Suspicious pointer combination ++e611 // Suspicious cast ++e612 // Expected a declarator +-e613 // Possible use of null pointer ++e614 // auto aggregate initializer not constant ++e615 // auto aggregate initializer has side effects ++e616 // control flows into case/default ++e617 // String is both a module and an include file ++e618 // Storage class specified after a type ++e619 // Loss of precision (Context) (Pointer to Pointer) ++e620 // Suspicious constant (small L or one?) ++e621 // Identifier clash ++e622 // Size of argument no. Integer inconsistent with format ++e623 // redefining the storage class of symbol ++e624 // typedef redeclared ++e625 // auto symbol has unusual type modifier ++e626 // Integer inconsistent with format ++e627 // indirect object inconsistent with format +-e628 // no argument information provided for function ++e629 // static class for function is non standard ++e630 // ambiguous reference to symbol ++e631 // tag 'Symbol' defined differently at Location ++e632 // Assignment to strong type ++e633 // Assignment from a strong type ++e634 // Strong type mismatch in equality or conditional ++e635 // resetting strong parent of type ++e636 // ptr to strong type versus another type ++e637 // Expected index type for strong type ++e638 // Strong type mismatch for type in relational ++e639 // Strong type mismatch for type in binary operation ++e640 // Expected strong type 'Name' in Boolean context +-e641 // Converting enum to int ++e642 // Format char 'Char' not supported by wsprintf ++e643 // Loss of precision in pointer cast ++e644 // Variable may not have been initialized ++e645 // Symbol may not have been initialized ++e646 // case/default within Kind loop; may have been misplaced ++e647 // Suspicious truncation ++e648 // Overflow in computing constant for operation: ++e649 // Sign fill during constant shift ++e650 // Constant out of range for operator ++e651 // Potentially confusing initializer +-e652 // #define of symbol 'Symbol' declared previously ++e653 // Possible loss of fraction ++e654 // Option String obsolete; use -width(W,I) +-e655 // bit-wise operation uses (compatible) enum's ++e656 // Arithmetic operation uses (compatible) enum's ++e657 // Unusual (nonportable) anonymous struct or union ++e658 // Anonymous union assumed ++e659 // Nothing follows '}' ++e660 // Option requests removing an extent that is not on the list ++e661 // possible access of out-of-bounds pointer ++e662 // possible creation of out-of-bounds pointer ++e663 // Suspicious array to pointer conversion ++e664 // Left side of logical OR (||) or logical AND (&&) does not return ++e665 // Unparenthesized parameter Integer in macro is passed an expression ++e666 // Expression with side effects passed to repeated parameter ++e667 // Inconsistent use of qualifiers for symbol ++e668 // Possibly passing a null pointer to function ++e669 // Possible data overrun for function ++e670 // Possible access beyond array for function ++e671 // Possibly passing to function a negative value ++e672 // Possible memory leak in assignment to pointer ++e673 // Possibly inappropriate deallocation ++e674 // Returning address of auto through variable ++e675 // No prior semantics associated with symbol ++e676 // Possibly negative subscript ++e677 // sizeof used within preprocessor statement ++e678 // Member field length (Integer) too small for enum precision ++e679 // Suspicious Truncation in arithmetic expression combining with pointer ++e680 // Suspicious Truncation in arithmetic expression converted to pointer ++e681 // Loop is not entered ++e682 // sizeof applied to a parameter whose type is a sized array ++e683 // function 'Symbol' #define'd ++e684 // Passing address of auto variable into caller space ++e685 // Relational operator always evaluates to same result ++e686 // Option is suspicious ++e687 // Suspicious use of comma operator ++e688 // Cast used within preprocessor conditional statement ++e689 // Apparent end of comment ignored ++e690 // Possible access of pointer pointing Integer bytes past null character by operator ++e691 // Suspicious use of backslash ++e692 // Decimal character follows octal escape sequence ++e693 // Hexadecimal digit immediately after is suspicious in string literal. ++e694 // The type of constant (precision Integer) is dialect dependent ++e695 // Inline function defined without a storage-class specifier ('static' recommended) ++e696 // Variable has value that is out of range for operator ++e697 // Quasi-boolean values should be equality-compared only with 0 ++e698 // Casual use of realloc can create a memory leak + ++e701 // Shift left of signed int variable +-e702 // Shift right of signed int variable ++e703 // Shift left of signed long variable ++e704 // Shift right of signed long variable ++e705 // Integer nominally inconsistent with format ++e706 // indirect object inconsistent with format ++e707 // Mixing narrow and wide string literals in concatenation ++e708 // union initialization +-e712 // Loss of precision +-e713 // Loss of precision +-e714 // external variable not referenced +-e715 // Symbol not referenced +-e716 // while(1) found, allow endless loops +-e717 // do ... while(0) found ++e718 // Symbol undeclared, assumed to return int ++e719 // Too many arguments for format ++e720 // Boolean test of assignment ++e721 // Suspicious use of ; ++e722 // Suspicious use of ; ++e723 // Suspicious use of = -- A preprocessor definition began with an = sign. ++e725 // Expected positive indentation from Location +-e726 // Extraneous comma ignored ++e727 // local static variable not explicitly initialized ++e728 // global static variable not explicitly initialized ++e729 // exteral variable not explicitly initialized +-e730 // Boolean argument to function +-e731 // Boolean argument to equal/not equal +-e732 // Loss of sign ++e733 // Assigning address of auto variable to outer scope symbol ++e734 // Loss of precision int ++e735 // Loss of precision double ++e736 // Loss of precision float +-e737 // Loss of sign in promotion from Type1 to Type2 ++e738 // Symbol not explicitly initialized ++e739 // Trigraph Sequence in literal (Quiet Change) ++e740 // Unusual pointer cast (incompatible indirect types) ++e741 // Unusual pointer cast (function qualification) ++e742 // Multiple character constant ++e743 // Negative character constant ++e744 // switch statement has no default ++e745 // function has no explicit type or class, int assumed ++e746 // call to function not made in the presence of a prototype +-e747 // (noisy when using bool) Significant prototype coercion Type1 to Type2 ++e748 // Symbol is a register variable used with setjmp +-e749 // check for unused enum values +-e750 // ignore unused local macros +-e751 // check for unused local typedefs +-e752 // check for unused local declarations +-e753 // check for unused local struct, union or enum tag +-e754 // check for unused local structure member +-e755 // ignore unused global macros +-e756 // check for unused global typedefs +-e757 // check for unused global declarations +-e758 // check for unused global struct, union or enum tag +-e759 // check if symbol can be moved from header to module ++e760 // check for redundant macros +-e761 // check for redundant typedefs ++e762 // check for redundantly declared symbol ++e763 // check for redundant declaration for symbol ++e764 // check for switch statement without a case +-e765 // check for external symbols that could be made static ++e766 // check for unused headers ++e767 // check for differing macros +-e768 // check for global struct member that is never referenced +-e769 // check for global enumeration constant that is never referenced ++e770 // tag is defined identically at several locations ++e771 // check for uninitialized symbols ++e772 // check for uninitialized symbols ++e773 // Expression-like macro not parenthesized +-e774 // Boolean within 'String' always evaluates to [True/False] ++e775 // non-negative quantity cannot be less than zero ++e776 // Possible truncation of addition ++e777 // Testing float's for equality +-e778 // Constant expression evaluates to 0 ++e779 // String constant in comparison operator ++e780 // Vacuous array element ++e782 // Line exceeds Integer characters ++e783 // Line does not end with new-line ++e784 // Nul character truncated from string ++e785 // Too few initializers for aggregate ++e786 // String concatenation within initializer ++e787 // enum constant should not be used within switch +-e788 // enum constant not used within defaulted switch ++e789 // Assigning address of auto variable to static ++e790 // Suspicious truncation, integral to float ++e791 // unusual option sequence ++e792 // void cast of void expression ++e793 // ANSI/ISO limit of String 'Name' exceeded ++e794 // Conceivable use of null pointer ++e795 // Conceivable division by 0 ++e796 // Conceivable access of out-of-bounds pointer ++e797 // Conceivable creation of out-of-bounds pointer ++e798 // Redundant character ++e799 // numerical constant 'Integer' larger than unsigned long + +-e801 // Use of goto is deprecated ++e802 // Conceivably passing a null pointer to function ++e803 // Conceivable data overrun for function ++e804 // Conceivable access beyond array for function ++e805 // Expected L"..." to initialize wide char string ++e806 // Small bit field is signed rather than unsigned ++e807 // Conceivably passing to function a negative value ++e808 // No explicit type given to symbol ++e809 // Possible return of address of auto through variable ++e810 // Arithmetic modification of custodial variable ++e811 // Possible deallocation of pointer alias ++e812 // static variable 'Symbol' has size 'Integer' ++e813 // auto variable 'Symbol' in function 'Symbol' has size 'Integer' ++e814 // useless declaration ++e815 // Arithmetic modification of unsaved pointer ++e816 // Non-ANSI format specification ++e817 // Conceivably negative subscript +-e818 // Pointer parameter could be declared ptr to const ++e820 // Boolean test of a parenthesized assignment ++e821 // Right hand side of assignment not parenthesized ++e825 // control flows into case/default without -fallthrough comment ++e826 // Suspicious pointer-to-pointer conversion ++e827 // Loop not reachable ++e828 // redefinition of functions ++e829 // dangerous header was used ++e830 // print error location indicator ++e831 // print error location indicator ++e832 // Parameter 'Symbol' not explicitly declared ++e833 // Symbol is typed differently in another module +-e834 // missing parentheses between operators +-e835 // A zero has been given as [left/right] argument to operator ++e836 // Conceivable access of pointer pointing Integer bytes past nul ++e838 // Previously assigned value to variable has not been used ++e839 // Storage class of symbol 'Symbol' assumed static ++e840 // Use of null character in a string literal +-e843 // Variable 'Symbol' (Location) could be declared as const ++e844 // Pointer variable could be declared as pointing to const +-e845 // The [left/right] argument to operator is certain to be 0 ++e846 // Signedness of bit-field is implementation defined ++e847 // Thread has unprotected call to thread unsafe function ++e849 // Two enumerators have the same value +-e850 // loop index variable is modified in body of the for loop +-e864 // Expression possibly depends on order of evaluation ++e866 // Unusual use of 'String' in argument to sizeof + ++e900 // print total number of errors/warnings +-e904 // Return statement before end of function 'Symbol' ++e905 // Non-literal format specifier used (with arguments) +-e909 // Implicit conversion from Type to bool +-e910 // Implicit conversion (Context) from 0 to pointer +-e911 // (noisy) Implicit expression promotion from Type to Type +-e912 // (noisy) Implicit binary conversion from Type1 to Type2 ++e913 // Implicit adjustment of expected argument type from Type1 to Type2 ++e914 // Implicit adjustment of function return value from Type1 to Type2 +-e915 // (noisy) Implicit conversion (Context) Type1 to Type2 +-e916 // Implicit pointer assignment conversion +-e917 // (noisy) Prototype coercion Type1 to Type2 +-e918 // Prototype coercion (Context) of pointers +-e919 // (noisy) Implicit conversion (Context) Type to Type +-e920 // Cast from Type to void +-e931 // Both sides have side effects ++e932 // Passing near pointer to library function 'Symbol' ++e933 // Passing near pointer to far function (Context) ++e934 // taking address of near auto variable 'Symbol' +-e935 // (noisy) int within struct ++e936 // type is missing for function arguments ++e937 // type is missing for function arguments ++e939 // return type is missing for function ++e940 // omitted braces within an initialize ++e943 // Too few initializers for aggregate ++e945 // Undefined struct used with extern +-e946 // Relational or subtract operator applied to pointers ++e947 // Subtract operator applied to pointers +-e950 // Non-ISO/ANSI reserved word or construct: ++e951 // Pointer to incomplete type employed in operation +-e952 // Parameter could be declared const +-e953 // Variable could be declared as const +-e954 // Pointer variable could be declared as pointing to a const ++e955 // Parameter name missing from prototype for function +-e956 // (use for multithreaded SW) Non const, non volatile static or external variable ++e957 // Function defined without a prototype in scope +-e958 // (can help to save some bytes of memory) Padding of Integer byte(s) is required to align string on Integer byte boundary ++e962 // Macro defined identically at another location ++e963 // expect modifier (const, volatile) before type +-e964 // Header file not directly used in module +-e966 // Indirectly included header file 'FileName' not used in module ++e967 // Header file 'FileName' does not have a standard include guard +-e970 // (noisy) Use of modifier or type outside of a typedef +-e971 // (noisy) Use of 'char' without 'signed' or 'unsigned' ++e974 // print Worst case function for stack usage: +-e1013 // symbol is not a member of class +-e1015 // symbol not found in class +-e1025 // no function or template matches invocation +-e1039 // symbol is not a member of class +-e1040 // symbol is not a legal declaration within class +-e1042 // a least one class like operand is required with operator +-e1048 // expected a constant expression +-e1051 // symbol is both a function and a variable +-e1052 // a type was expected, class assumed +-e1054 // template variable declaration expects a type +-e1055 // symbol undeclared, assumed to return int +-e1057 // member cannot be used without an object +-e1058 // initializing a non-const reference +-e1065 // symbol not declared as "C" +-e1062 // template must be either a class or a function +-e1066 // symbol declared as "C" +-e1075 // Ambiguous reference to symbol +-e1077 // could not evaluate default template parameter +-e1086 // do not warn about compount literals +-e1087 // previous declaration is incompatible +-e1401 // member not initialized by constructor +-e1502 // object has no nonstatic data member +-e1526 // Member function not defined +-e1529 // symbol not first checking for assignment to this +-e1536 // exposing low access member +-e1540 // pointer member neither freed nor zeroed by destructor +-e1551 // function may throw exception in destructor +-e1554 // direct pointer copy of member within copy constructor +-e1561 // reference initialization causes loss of const/volatile +-e1566 // member might have been initialized by a separate function +-e1702 // operator is both an ordinary function and a member function +-e1704 // constructor has private access specification +-e1711 // function needs not to be virtual +-e1712 // default constructor not defined for class +-e1714 // Member function not referenced +-e1725 // class member is a reference +-e1732 // constructor for class has no assignment operator +-e1733 // constructor for class has no copy constructor +-e1736 // redundant access specifier +-e1740 // pointer member not directly freed or zeroed by destructor +-e1746 // parameter could be made const reference +-e1757 // discarded instance of post decrement/increment +-e1762 // member could be made const +-e1764 // reference parameter could be declared const +-e1776 // converting a string literal to char* +-e1786 // implicit conversion to bool +-e1788 // variable is referenced only by its constructor or destructor +-e1795 // Template was defined but not instantiated +-e1904 // allow old style comments +-e1923 // ignore defines that could be const variables +-e1924 // C-style cast + +//scripts/pclint/au-sm123.lnt // also check Scott Meyers rules of all three books +//scripts/pclint/au-misra3.lnt // Misra 2012 rules +//scripts/pclint/au-barr10.lnt // Top 10 Bug-Killing Rules +//scripts/pclint/au-ds.lnt // Dan Saks |