Gimpel Software
  Order        Patches        Discussion Forum        Blog 
Contact      Site Map       
   Home
   Bug of the Month
   Products
   Order
   Support
   Company
   Links
   Interactive Demo
Google Search box  
Search gimpel.com:

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.

PC-lint/FlexeLint will detect -
For C++
...

  • 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

PC-lint/FlexeLint will detect -
For C and C++ ...

  • 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 © 2013, Gimpel Software, All rights reserved.