PC-Lint

A static analysis tool for C/C++ programmes that finds bugs and glitches in source code. It runs on Windows, DOS and OS/2 and works with all major compilers.
PC-Lint is a static analysis tool for C/C++ programmes that finds bugs and glitches in source code to make programs more reliable. It runs on Windows, DOS and OS/2 and supports ANSI C, K&R C and ANSI C++, working with all major compilers. It contains numerous features such as precision tracking, strong type checking, initialisation checking and macro analysis and looks for intermodule inconsistencies and redundancies. It provides more than 700 error messages with an associated error number for tracing a more detailed description of the error.

Only the Workstation version is available for purchase through QBS Software.

PC-Lint - Features

New Features in version 9 Features in version 8

PC Lint is a source code checker for C/C++ programs and runs on Windows, DOS and OS/2. PC-Lint will look across multiple modules (possibly mixed C and C++) and find bugs, glitches and inconsistencies to make programs more reliable, more maintainable and more portable.

New Features in Version 9

• Multi-thread support
• Dimensional strong types
• Pre-compiled headers
• Stack usage reports
• Capturing of program elements for import into a database
• Static Variable tracking

Back to top

Features in Version 8

• Inter-function Value Tracking: inter-statement value tracking has been extended to cross function boundaries. Functions called with specific values are later processed with these values used to initialise parameters. A multi-pass operation has been introduced to take full advantage of inter-function tracking enabling the user to control the number of passes
• Machine readable documentation: access message descriptions using one mouse click
• New warnings:
  • pointers to insufficiently large areas
  • the malloc( strlen (s+1) )
  • the new int(10)
  • when 64 bit pointers meet with 32 bit integer arithmetic
  • when pointer parameters can be made pointers to const and when reference parameters can be declared as const
  • when a member function can be made const
  • shallow copies of member pointers within copy constructors and assignment operators
  • when a test of assignment is not surrounded by parentheses
  • confusing unparenthesised operator sequences such as A/B*C
  • returning a temporary via a reference
  • a reference initialisation that can cause a dangerous capability gain
  • exception irregularities
  • cases where the dynamic cast should be used and where it is not appropriate
  • when string literals are placed in harm's way via assignment to char *
  • when white space may intervene between a backslash and a newline creating an invisible ambiguity
  • strange comparisons that can't possibly succeed
• New Elective Notes:
  • use of 0 when NULL is intended
  • situations where const can be added to parameters, and variables, and pointers
  • non const non volatile global variables, locating these can assist multi-threaded applications in detecting non re-entrant situations
  • thorough exception analysis (for C++ users)
  • prototypes missing parameter names
  • suspicious conditions with order-of-initialisation problems
  • pointer subtractions which can be a problem in conditions of maximum memory
  • conditions which can give rise to alignment problems.
• New and revised options of interest
  • -sem enhancements include the ability to specify that return pointers from functions are freshly allocated and that pointer arguments to functions areconsumed (ie the function takes custody of the pointer)
  • user-defined printf and scanf codes
  • a poor-man's class hierarchy for C code
  • better support for defining non-standard preprocessing commands
  • better support for defining and manipulating reserved words.
• Other options and features:
  • immproved support for intelligent editors and IDE's with special additional messages when a given message contains interior location information
  • a complete no-holds-barred C++ exception analysis
  • a specific form of lint comment is required when program flow falls through from one (non-trivial) case to the next.(option -fallthrough)
  • The lint predefined identifier now contains version information. For Version 8.00 it has a value of 800. added explicit support for a subset of the MISRA (Motor Industry Software Reliability Association) standard.
  • Alignment is checked and can be set via a -a option similar to the -s options to set sizes
  • According to the Standard, new (and new[]) do not return NULL when out of storage but rather throw an exception (bad alloc)
  • Support for Microsoft C/C++ and compatible systems include: .dsp processing, #import, and pragmas once and message
  • Support for Gnu C/C++ consists of a -cgnu option, variable macro arguments and a form of 'testable' assignment that non-Gnu users can use
  • Support for CodeGear C++ Builder including truncated file names
  • Continued improvement in support for embedded systems compilers.
• New Error Inhibition Options:
  • -e{ # [,#]… } inhibits messages(s) # for the next statement or declaration
  • --e{ # [,#]… } inhibits messages(s) # within a braced region
  • -etemplate{ # [,#] … } inhibits
  • +etemplate{ # [,#] … } re-enables message(s) # while expanding templates.
• New Verbosity Options:
  • -v…c Issues a verbosity message whenever a unique function call is recorded
  • -v…d Indicates whether modules are processed as C or C++
  • -v…h- If the 'h' is followed immediately by a '-' then the hierarchy will be compressed producing the same tree in half the lines
  • -v…t Indicates when a template is being instantiated
  • -v…w Indicates when a function is being walked with specific arguments.
• New Flag Options:
  • fdl has been enhanced to allow for pointer difference to be long
  • flm Lock Message format
  • fnn new can return Null
  • frl Reference Location information
  • fsp SPecific function call processing
  • fss Sub-struct allows C struct's to be related as in inheritance
  • ftg turns off TRiGraph processing
  • ftr TRuncate flag to support Borland includes.
• New Message Presentation Options:
  • -append(#,string ) can be used to append a trailing message (string) onto an existing error message for error #.
• Additional Options:
  • -background PC-lint/FlexeLint will run at a reduced priority under Windows NT
  • -fallthrough The flow of control is falling through from one case switch to another
  • -headerwarn{ filename [,filename]… } Can be used to alert the user that the specified header file is being used
  • -ident1(string) This option allows the user to define a one-character identifier
  • +libdir Enhanced to support wild cards
  • +libh Enhanced to support wild cards
  • +linebuf This option doubles the size of the line buffer which is initially 600 bytes
  • -passes{ k [,Options1 [,Options2] ] } Allows multiple passes over the set of modules provided as input
  • -ppw asgn( word1, word2 ) Assigns the preprocessor semantics associated with word2 to word1 and activates word1
  • --ppw( word1 [, word2] … ) Removes pre-conceived notions as to the meaning of preprocessor words
  • +pragma{ identifier, once } This option allows the programmer to establish identifier as a pragma code to indicate that the header is t be included. +pragma{ identifier, message } This option allows the programmer to establish an arbitrary identifier as a pragma that will produce a message to standard out
  • -pragma{ identifier } This option will remove the pragma whose name is identifier
  • -printf code{ Code [, Type] } This option allows user-defined printf codes
  • --rw{ word1 [, word2] … } Removes preconceived notions as to what the potential reserved word(s) mean and gives it a default meaning(to ignore it)
  • -rw asgn( word1, word2 ) This option assigns the reserved word semantics of word2 to word1
  • -scanf code( Code [, Type] ) This option allows user-defined scanf codes
  • -sem This option has been enhanced to support a number of new semantics
  • --u This option is like -u except that any module at a lower .lnt level is ignored
  • Compiler Adaptation:
  • -cgnu This option is used for the Gnu compiler.
  • to eol This adds to the suite of special keywords that enable Lint to pass over unusual non-standard constructions
  • support for the @ feature which appears in many embedded systems compilers.
• Pre-Processor Directives:
  • #import supports the Microsoft preprocessor directive of the same name
  • #unassert preprocessor directive undoes the effects of #assert.

Platform support

• Microsoft Windows
• DOS (built-in DOS extender)
• OS/2 (32 bit).

Compatibility:

• supports K&R C, ANSI C, ANSI/ISO C++
• explicit support for Borland, Microsoft, GNU and most other major compilers and libraries
• support for most major embedded-system compilers including bit addressing.
• numerous options to support rogue compilers
• scalars sizes can be specified for cross-compiling.

Features include:

• Message Suppression:
  • by number
  • by number and symbol (including wild cards)
  • one-line suppression
  • by macro
  • for library headers by number (a header is library depending on how it is included; this can be overridden via user options).
• Flexibility:
  • indirect files (nested to any depth) can contain filenames, options, environment variables
  • format of error messages can be customized to support a wide variety of editors/IDE's
  • all options can be embedded in user code.
• Special Checking Facilities:
  • optional B type checking (typedef-based) with a rich option set to detect nominal type differences. You can even form a fully checked type hierarchy of scalar types using only typedef
  • checks flow of control for possibly uninitialisedvariables
  • value tracking to detect subtle initialization and value misuse problems
  • wth value tracking as an enabling technology, it support 'semantics' checking for almost 100 library functions, this checking can be extended to user functions (see function mimicry)
  • find unused macros, typedef's, classes, members, declarations, etc. across the entire project (see weak definials)
  • other special torture tests.
• Performance:
  • fast one-pass operation
  • robust - tables will expand as needed to handle large applications.

Back to top

PC-Lint - System Requirements

Platforms

• Windows Vista / XP / NT / 2000 / ME / 98 / 95
• MS-DOS (built-in DOS extender)
• OS/2