PC-lint/FlexeLint Version 9.00 has more than 800 error messages. For detailed information, browse through the ASCII file, msg.txt which is a listing of all the error messages that PC-lint/FlexeLint will generate.

• order of initialization dependencies
• class members not initialized by constructor
• pointer members not deleted by destructors
• base class destructors that are not virtual
• names hiding other names
• improperly formed or missing assignment operators and copy constructors
• missing destructors from classes using dynamic allocation
• out-of-order constructor initializers
• creation of temporaries
• undefined and unreferenced class members initialization of a non-const reference with a non-lvalue
• assignment operator not first checking for assignment to this
• inconsistent use of extern "C"
• operator delete not checking argument for NULL
• static variables in in-line functions in headers
• exposing privileged data
• failure to copy a base class, or to use the base class copy constructor
• failure to assign members and base classes
• issuing throw within a destructor
• assignment of an array to a base class pointer
• inconsistent or incomplete exception specifications
• failure to reference a virtual member function
• a virtual function with a default parameter
• redundant access specifiers
• binary operators that should be non-member functions or that return references, or that shouldn't be user defined or operators that should be defined
• function parameters that could be declared const reference
• ill-defined increment and decrement operators
• catch parameters that are not references
• An examination is made of all the base class hierarchies in the entire project to determine non-virtual classes included twice, or virtual classes not included twice in any class hierarchy.
• non-POD classes being passed to functions that require POD data
• out-of-order or missing reference initializations
• conflicting function specifiers
• conflicting exception specifications in declaration of overriding functions
• expressions bearing C/C++ incompatibilities
• suspicious assignments to bool
• constructors having incomplete data initialization
• binding reference variables to objects whose lifetime may be shorter than the reference
• misplaced generic templates that can trigger unintended ADL calls
• misplaced explicit template specializations or partial template specializations
• destructors which fail to delete pointer members
• suspicious or non-portable uses of new
• const unsafe practices
• suspicious uses of reference to const
• implicit conversions involving bool
• unused String variables
• misleading member templates
• base classes that do not follow common object oriented precepts
• unusual return statements
• use of non-lvalues in initializing references
• ambiguous using declarations
• unused templates
• explicit template function specializations that could pertain to two or more function templates
• missing idenitifiers for template non-type parameters

• from value tracking information we can detect under many circumstances:
• use of NULL pointer in unary * or ->
• creation and access of out-of-bounds pointers
• subscript out-of-bounds
• division by zero
• passing NULL pointers to selected library functions
• data over-run conditions on selected library functions
• booleans that always evaluate true or evaluate false
• inappropriate deallocation
• memory leaks
• unusual values passed to functions based on user-defined semantic specifications
• from a special macro scan we can find
• passing an expression to an unparenthesized macro parameter
• passing an expression with side effects to a repeated macro parameter
• unparenthesized expression-like macros
• intermodule type inconsistencies
• uninitialized variables (auto, static and global scalars, arrays and structs)
• unused variables and functions
• assigned but not accessed variables (including globals)
• unreachable code
• unusual expressions such as: flags & 4 == 0 (precedence error)
• constant Booleans as in: if( x = 0 ) ...
• indentation checking
• suspicious use of semi-colons as in if( a > b ); not followed by else
• strict and loose enumeration checking
• printf - scanf format checking
• order of evaluation errors as in: a[i] = i++;
• unsigned comparisons with 0
• wide variety of loss of precision errors such as int to char featuring our exclusive precision tracking
• excessive shift values
• loss of sign
• suspicious cast
• mixed signed and unsigned quantities
• comments within comments
• unused compile time objects, including macros, typedefs, declarations, classes, unions, enums
• ANSI quiet changes
• unused headers
• returning pointers to auto addresses and assigning auto address to static
• externals that can be made static and hence hidden
• declarations that can be offloaded from headers
• name clashes within the first count characters
• strong type checking based on typedef types.
• possibly uninitialized variables based on flow of control.
• overflow while processing arithmetic constants (E.g. for 16 bit integers, 200*200 overflows)
• constant expressions that reduce to zero
• suspicious truncations
• suspicious loss of fraction
• initialization irregularities (too few, too many, incorrect shape, string concatenations in)
• unused assigned values
• for clause irregularities
• extraneous white space in filenames
• accessing past the nul character
• absence of standard include guards
• unsynchronized mutex locking and unlocking
• multiple thread access to unprotected variables
• thread unsafe functions
• buffers copied onto themselves
• loss of information using getc
• user-deprecated symbols
• predeterminable Boolean expressions
• order of evaluation dependencies in expressions involving a static variable and a function call
• unsafe practices involving printf and non-constant formats
• statically detectable memory leaks
• commas masquerading as semi-colons
• suspicious uses of back slash in macros
• suspicious looking octal or hexadecimal escape sequences
• dialect dependent integer constants
• out of range comparisons
• arguments inconsistent with a printf or scanf format
• mixing narrow and wide string literals
• variables (including global variables) that could be declared const or as pointing to const
• implementation defined bit fields
• unusual expressions using sizeof

 

Home | Contact | Order PC-lint and FlexeLint are trademarks of Gimpel Software Copyright © 2011, Gimpel Software, All rights reserved.