summaryrefslogtreecommitdiffstats
path: root/debian/uncrustify-trinity/uncrustify-trinity-0.74.0/scripts/pclint/policy.lnt
diff options
context:
space:
mode:
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.lnt396
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