2011-08-18 23:46:31 +02:00
/*
2010-08-31 20:32:26 +02:00
* Cppcheck - A tool for static C / C + + code analysis
2015-11-18 20:04:50 +01:00
* Copyright ( C ) 2007 - 2015 Cppcheck team .
2010-08-31 20:32:26 +02:00
*
* This program is free software : you can redistribute it and / or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation , either version 3 of the License , or
* ( at your option ) any later version .
*
* This program is distributed in the hope that it will be useful ,
* but WITHOUT ANY WARRANTY ; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE . See the
* GNU General Public License for more details .
*
* You should have received a copy of the GNU General Public License
* along with this program . If not , see < http : //www.gnu.org/licenses/>.
*/
2013-09-04 06:18:22 +02:00
# include "cmdlineparser.h"
# include "cppcheck.h"
2014-05-25 08:47:37 +02:00
# include "cppcheckexecutor.h"
2013-09-04 06:18:22 +02:00
# include "filelister.h"
# include "path.h"
# include "settings.h"
# include "timer.h"
2014-05-23 20:58:28 +02:00
# include "check.h"
2013-09-04 06:18:22 +02:00
2012-01-12 21:21:51 +01:00
# include <algorithm>
2010-08-31 20:32:26 +02:00
# include <iostream>
# include <sstream>
# include <fstream>
# include <string>
2010-09-05 10:47:31 +02:00
# include <cstring>
2013-09-04 06:18:22 +02:00
# include <cstdlib> // EXIT_FAILURE
2010-08-31 20:32:26 +02:00
2011-02-14 19:37:58 +01:00
# ifdef HAVE_RULES
2015-11-15 11:16:12 +01:00
// xml is used for rules
2013-02-16 19:01:34 +01:00
# include <tinyxml2.h>
2011-02-12 08:06:59 +01:00
# endif
2010-08-31 20:32:26 +02:00
static void AddFilesToList ( const std : : string & FileList , std : : vector < std : : string > & PathNames )
{
2015-11-15 11:16:12 +01:00
// To keep things initially simple, if the file can't be opened, just be silent and move on.
2011-09-26 11:04:16 +02:00
std : : istream * Files ;
std : : ifstream Infile ;
2011-10-13 20:53:06 +02:00
if ( FileList . compare ( " - " ) = = 0 ) { // read from stdin
2011-09-26 11:04:16 +02:00
Files = & std : : cin ;
2011-10-13 20:53:06 +02:00
} else {
2011-09-26 11:04:16 +02:00
Infile . open ( FileList . c_str ( ) ) ;
Files = & Infile ;
}
2015-11-15 11:16:12 +01:00
if ( Files & & * Files ) {
2010-08-31 20:32:26 +02:00
std : : string FileName ;
2011-10-13 20:53:06 +02:00
while ( std : : getline ( * Files , FileName ) ) { // next line
if ( ! FileName . empty ( ) ) {
2010-08-31 20:32:26 +02:00
PathNames . push_back ( FileName ) ;
}
}
}
}
2014-03-10 15:49:02 +01:00
static void AddInclPathsToList ( const std : : string & FileList , std : : list < std : : string > * PathNames )
2011-10-22 21:24:23 +02:00
{
2015-11-15 11:16:12 +01:00
// To keep things initially simple, if the file can't be opened, just be silent and move on.
2011-10-22 21:24:23 +02:00
std : : ifstream Files ( FileList . c_str ( ) ) ;
2011-10-23 11:15:12 +02:00
if ( Files ) {
2011-10-22 21:24:23 +02:00
std : : string PathName ;
2011-10-23 11:15:12 +02:00
while ( std : : getline ( Files , PathName ) ) { // next line
if ( ! PathName . empty ( ) ) {
2011-10-22 21:24:23 +02:00
PathName = Path : : fromNativeSeparators ( PathName ) ;
PathName = Path : : removeQuotationMarks ( PathName ) ;
2012-02-05 15:28:37 +01:00
// If path doesn't end with / or \, add it
2015-07-25 17:19:53 +02:00
if ( PathName . back ( ) ! = ' / ' )
2012-02-05 15:28:37 +01:00
PathName + = ' / ' ;
2014-03-10 15:49:02 +01:00
PathNames - > push_back ( PathName ) ;
2011-10-22 21:24:23 +02:00
}
}
}
}
2014-03-10 15:49:02 +01:00
static void AddPathsToSet ( const std : : string & FileName , std : : set < std : : string > * set )
{
std : : list < std : : string > templist ;
AddInclPathsToList ( FileName , & templist ) ;
set - > insert ( templist . begin ( ) , templist . end ( ) ) ;
}
2010-08-31 20:32:26 +02:00
CmdLineParser : : CmdLineParser ( Settings * settings )
: _settings ( settings )
, _showHelp ( false )
, _showVersion ( false )
, _showErrorMessages ( false )
2011-01-27 09:30:53 +01:00
, _exitAfterPrint ( false )
2010-08-31 20:32:26 +02:00
{
}
2012-09-11 19:19:11 +02:00
void CmdLineParser : : PrintMessage ( const std : : string & message )
2010-09-10 17:39:36 +02:00
{
std : : cout < < message < < std : : endl ;
}
2010-08-31 20:32:26 +02:00
bool CmdLineParser : : ParseFromArgs ( int argc , const char * const argv [ ] )
{
2013-06-08 16:46:54 +02:00
bool def = false ;
bool maxconfigs = false ;
2011-10-13 20:53:06 +02:00
for ( int i = 1 ; i < argc ; i + + ) {
2012-12-27 11:51:12 +01:00
if ( std : : strcmp ( argv [ i ] , " --version " ) = = 0 ) {
2010-08-31 20:32:26 +02:00
_showVersion = true ;
2011-01-27 09:30:53 +01:00
_exitAfterPrint = true ;
2010-08-31 20:32:26 +02:00
return true ;
}
2011-08-16 21:58:27 +02:00
2010-08-31 20:32:26 +02:00
// Flag used for various purposes during debugging
2012-12-27 11:51:12 +01:00
else if ( std : : strcmp ( argv [ i ] , " --debug " ) = = 0 )
2010-08-31 20:32:26 +02:00
_settings - > debug = _settings - > debugwarnings = true ;
2015-07-28 12:46:32 +02:00
// Show --debug output after the first simplifications
else if ( std : : strcmp ( argv [ i ] , " --debug-normal " ) = = 0 )
_settings - > debugnormal = true ;
2010-08-31 20:32:26 +02:00
// Show debug warnings
2012-12-27 11:51:12 +01:00
else if ( std : : strcmp ( argv [ i ] , " --debug-warnings " ) = = 0 )
2010-08-31 20:32:26 +02:00
_settings - > debugwarnings = true ;
2011-08-16 21:58:27 +02:00
// Print out code that triggers false positive
2012-12-27 11:51:12 +01:00
else if ( std : : strcmp ( argv [ i ] , " --debug-fp " ) = = 0 )
2011-08-16 21:58:27 +02:00
_settings - > debugFalsePositive = true ;
2014-07-14 15:51:45 +02:00
// dump cppcheck data
else if ( std : : strcmp ( argv [ i ] , " --dump " ) = = 0 )
_settings - > dump = true ;
2014-03-16 12:04:13 +01:00
// (Experimental) exception handling inside cppcheck client
else if ( std : : strcmp ( argv [ i ] , " --exception-handling " ) = = 0 )
_settings - > exceptionHandling = true ;
2014-05-25 08:47:37 +02:00
else if ( std : : strncmp ( argv [ i ] , " --exception-handling= " , 21 ) = = 0 ) {
_settings - > exceptionHandling = true ;
const std : : string exceptionOutfilename = & ( argv [ i ] [ 21 ] ) ;
CppCheckExecutor : : setExceptionOutput ( exceptionOutfilename ) ;
}
2014-03-16 12:04:13 +01:00
2015-07-25 19:17:24 +02:00
// Inconclusive checking
2012-12-27 11:51:12 +01:00
else if ( std : : strcmp ( argv [ i ] , " --inconclusive " ) = = 0 )
2011-04-10 12:52:59 +02:00
_settings - > inconclusive = true ;
2012-09-10 18:51:32 +02:00
// Enforce language (--language=, -x)
2012-12-27 11:51:12 +01:00
else if ( std : : strncmp ( argv [ i ] , " --language= " , 11 ) = = 0 | | std : : strcmp ( argv [ i ] , " -x " ) = = 0 ) {
2012-09-11 08:53:27 +02:00
std : : string str ;
if ( argv [ i ] [ 2 ] ) {
str = argv [ i ] + 11 ;
} else {
i + + ;
if ( i > = argc | | argv [ i ] [ 0 ] = = ' - ' ) {
PrintMessage ( " cppcheck: No language given to '-x' option. " ) ;
return false ;
}
str = argv [ i ] ;
2012-09-10 18:51:32 +02:00
}
2012-09-11 08:53:27 +02:00
if ( str = = " c " )
_settings - > enforcedLang = Settings : : C ;
else if ( str = = " c++ " )
_settings - > enforcedLang = Settings : : CPP ;
else {
PrintMessage ( " cppcheck: Unknown language ' " + str + " ' enforced. " ) ;
2012-09-10 18:51:32 +02:00
return false ;
}
}
2010-12-04 13:13:44 +01:00
// Filter errors
2015-11-15 10:03:20 +01:00
else if ( std : : strncmp ( argv [ i ] , " --exitcode-suppressions= " , 24 ) = = 0 ) {
2011-01-29 18:04:52 +01:00
// exitcode-suppressions=filename.txt
2015-11-15 10:03:20 +01:00
std : : string filename = 24 + argv [ i ] ;
2010-12-04 13:13:44 +01:00
2011-01-29 18:04:52 +01:00
std : : ifstream f ( filename . c_str ( ) ) ;
2011-10-13 20:53:06 +02:00
if ( ! f . is_open ( ) ) {
2012-04-16 19:51:07 +02:00
PrintMessage ( " cppcheck: Couldn't open the file: \" " + filename + " \" . " ) ;
2010-12-04 13:13:44 +01:00
return false ;
}
const std : : string errmsg ( _settings - > nofail . parseFile ( f ) ) ;
2011-10-13 20:53:06 +02:00
if ( ! errmsg . empty ( ) ) {
2010-12-04 13:13:44 +01:00
PrintMessage ( errmsg ) ;
return false ;
}
}
2010-08-31 20:32:26 +02:00
// Filter errors
2012-12-27 11:51:12 +01:00
else if ( std : : strncmp ( argv [ i ] , " --suppressions-list= " , 20 ) = = 0 ) {
2012-01-01 20:17:16 +01:00
std : : string filename = argv [ i ] + 20 ;
2011-01-28 12:18:07 +01:00
std : : ifstream f ( filename . c_str ( ) ) ;
2011-10-13 20:53:06 +02:00
if ( ! f . is_open ( ) ) {
2011-10-29 23:26:35 +02:00
std : : string message ( " cppcheck: Couldn't open the file: \" " ) ;
2012-04-16 19:51:07 +02:00
message + = filename ;
2011-10-29 23:26:35 +02:00
message + = " \" . " ;
2012-12-27 11:51:12 +01:00
if ( std : : count ( filename . begin ( ) , filename . end ( ) , ' , ' ) > 0 | |
std : : count ( filename . begin ( ) , filename . end ( ) , ' . ' ) > 1 ) {
2012-01-12 21:21:51 +01:00
// If user tried to pass multiple files (we can only guess that)
// e.g. like this: --suppressions-list=a.txt,b.txt
// print more detailed error message to tell user how he can solve the problem
message + = " \n If you want to pass two files, you can do it e.g. like this: " ;
message + = " \n cppcheck --suppressions-list=a.txt --suppressions-list=b.txt file.cpp " ;
}
2011-01-28 12:18:07 +01:00
PrintMessage ( message ) ;
return false ;
}
const std : : string errmsg ( _settings - > nomsg . parseFile ( f ) ) ;
2011-10-13 20:53:06 +02:00
if ( ! errmsg . empty ( ) ) {
2011-01-28 12:18:07 +01:00
PrintMessage ( errmsg ) ;
return false ;
}
}
2012-12-27 11:51:12 +01:00
else if ( std : : strncmp ( argv [ i ] , " --suppress= " , 11 ) = = 0 ) {
2012-01-01 20:17:16 +01:00
std : : string suppression = argv [ i ] + 11 ;
2011-02-16 10:26:40 +01:00
const std : : string errmsg ( _settings - > nomsg . addSuppressionLine ( suppression ) ) ;
2011-10-13 20:53:06 +02:00
if ( ! errmsg . empty ( ) ) {
2011-02-16 10:26:40 +01:00
PrintMessage ( errmsg ) ;
return false ;
}
}
2010-08-31 20:32:26 +02:00
// Enables inline suppressions.
2012-12-27 11:51:12 +01:00
else if ( std : : strcmp ( argv [ i ] , " --inline-suppr " ) = = 0 )
2010-08-31 20:32:26 +02:00
_settings - > _inlineSuppressions = true ;
// Verbose error messages (configuration info)
2012-12-27 11:51:12 +01:00
else if ( std : : strcmp ( argv [ i ] , " -v " ) = = 0 | | std : : strcmp ( argv [ i ] , " --verbose " ) = = 0 )
2010-08-31 20:32:26 +02:00
_settings - > _verbose = true ;
// Force checking of files that have "too many" configurations
2012-12-27 11:51:12 +01:00
else if ( std : : strcmp ( argv [ i ] , " -f " ) = = 0 | | std : : strcmp ( argv [ i ] , " --force " ) = = 0 )
2010-08-31 20:32:26 +02:00
_settings - > _force = true ;
2012-04-06 10:49:21 +02:00
// Output relative paths
2012-12-27 11:51:12 +01:00
else if ( std : : strcmp ( argv [ i ] , " -rp " ) = = 0 | | std : : strcmp ( argv [ i ] , " --relative-paths " ) = = 0 )
2012-04-06 10:49:21 +02:00
_settings - > _relativePaths = true ;
2012-12-27 11:51:12 +01:00
else if ( std : : strncmp ( argv [ i ] , " -rp= " , 4 ) = = 0 | | std : : strncmp ( argv [ i ] , " --relative-paths= " , 17 ) = = 0 ) {
2012-04-06 10:49:21 +02:00
_settings - > _relativePaths = true ;
2012-04-14 14:44:15 +02:00
if ( argv [ i ] [ argv [ i ] [ 3 ] = = ' = ' ? 4 : 17 ] ! = 0 ) {
std : : string paths = argv [ i ] + ( argv [ i ] [ 3 ] = = ' = ' ? 4 : 17 ) ;
2014-12-09 23:04:14 +01:00
for ( ; ; ) {
std : : string : : size_type pos = paths . find ( ' ; ' ) ;
if ( pos = = std : : string : : npos ) {
_settings - > _basePaths . push_back ( Path : : fromNativeSeparators ( paths ) ) ;
break ;
} else {
_settings - > _basePaths . push_back ( Path : : fromNativeSeparators ( paths . substr ( 0 , pos ) ) ) ;
paths . erase ( 0 , pos + 1 ) ;
}
}
2012-04-14 14:44:15 +02:00
} else {
PrintMessage ( " cppcheck: No paths specified for the ' " + std : : string ( argv [ i ] ) + " ' option. " ) ;
return false ;
}
2012-04-06 10:49:21 +02:00
}
2010-08-31 20:32:26 +02:00
// Write results in results.xml
2012-12-27 11:51:12 +01:00
else if ( std : : strcmp ( argv [ i ] , " --xml " ) = = 0 )
2010-08-31 20:32:26 +02:00
_settings - > _xml = true ;
2011-02-02 13:04:50 +01:00
// Define the XML file version (and enable XML output)
2012-12-27 11:51:12 +01:00
else if ( std : : strncmp ( argv [ i ] , " --xml-version= " , 14 ) = = 0 ) {
2012-01-01 20:17:16 +01:00
std : : string numberString ( argv [ i ] + 14 ) ;
2011-02-02 13:04:50 +01:00
std : : istringstream iss ( numberString ) ;
2011-10-13 20:53:06 +02:00
if ( ! ( iss > > _settings - > _xml_version ) ) {
2011-10-29 23:26:35 +02:00
PrintMessage ( " cppcheck: argument to '--xml-version' is not a number. " ) ;
2011-02-02 13:04:50 +01:00
return false ;
}
2011-10-13 20:53:06 +02:00
if ( _settings - > _xml_version < 0 | | _settings - > _xml_version > 2 ) {
2011-02-02 13:04:50 +01:00
// We only have xml versions 1 and 2
2011-10-29 23:26:35 +02:00
PrintMessage ( " cppcheck: '--xml-version' can only be 1 or 2. " ) ;
2011-02-02 13:04:50 +01:00
return false ;
}
// Enable also XML if version is set
2010-12-02 17:32:51 +01:00
_settings - > _xml = true ;
}
2010-12-01 21:24:17 +01:00
2010-08-31 20:32:26 +02:00
// Only print something when there are errors
2012-12-27 11:51:12 +01:00
else if ( std : : strcmp ( argv [ i ] , " -q " ) = = 0 | | std : : strcmp ( argv [ i ] , " --quiet " ) = = 0 )
2015-07-25 17:39:44 +02:00
_settings - > quiet = true ;
2010-08-31 20:32:26 +02:00
2015-07-25 19:17:24 +02:00
// Append user-defined code to checked source code
2012-12-27 11:51:12 +01:00
else if ( std : : strncmp ( argv [ i ] , " --append= " , 9 ) = = 0 ) {
2011-11-12 10:43:26 +01:00
const std : : string filename = 9 + argv [ i ] ;
if ( ! _settings - > append ( filename ) ) {
PrintMessage ( " cppcheck: Couldn't open the file: \" " + filename + " \" . " ) ;
return false ;
}
}
2010-08-31 20:32:26 +02:00
2013-07-08 18:26:18 +02:00
// Check configuration
else if ( std : : strcmp ( argv [ i ] , " --check-config " ) = = 0 ) {
_settings - > checkConfiguration = true ;
}
// Check library definitions
else if ( std : : strcmp ( argv [ i ] , " --check-library " ) = = 0 ) {
_settings - > checkLibrary = true ;
}
2012-12-27 11:51:12 +01:00
else if ( std : : strncmp ( argv [ i ] , " --enable= " , 9 ) = = 0 ) {
2010-08-31 20:32:26 +02:00
const std : : string errmsg = _settings - > addEnabled ( argv [ i ] + 9 ) ;
2011-10-13 20:53:06 +02:00
if ( ! errmsg . empty ( ) ) {
2010-09-18 16:11:46 +02:00
PrintMessage ( errmsg ) ;
2010-08-31 20:32:26 +02:00
return false ;
}
2013-02-02 15:48:19 +01:00
// when "style" is enabled, also enable "warning", "performance" and "portability"
2012-01-01 20:17:16 +01:00
if ( _settings - > isEnabled ( " style " ) ) {
2013-02-02 15:48:19 +01:00
_settings - > addEnabled ( " warning " ) ;
2011-09-03 17:25:39 +02:00
_settings - > addEnabled ( " performance " ) ;
_settings - > addEnabled ( " portability " ) ;
}
2010-08-31 20:32:26 +02:00
}
// --error-exitcode=1
2012-12-27 11:51:12 +01:00
else if ( std : : strncmp ( argv [ i ] , " --error-exitcode= " , 17 ) = = 0 ) {
2012-01-01 20:17:16 +01:00
std : : string temp = argv [ i ] + 17 ;
2010-08-31 20:32:26 +02:00
std : : istringstream iss ( temp ) ;
2011-10-13 20:53:06 +02:00
if ( ! ( iss > > _settings - > _exitCode ) ) {
2010-08-31 20:32:26 +02:00
_settings - > _exitCode = 0 ;
2011-10-29 23:26:35 +02:00
PrintMessage ( " cppcheck: Argument must be an integer. Try something like '--error-exitcode=1'. " ) ;
2010-08-31 20:32:26 +02:00
return false ;
}
}
// User define
2012-12-27 11:51:12 +01:00
else if ( std : : strncmp ( argv [ i ] , " -D " , 2 ) = = 0 ) {
2011-01-17 20:03:22 +01:00
std : : string define ;
// "-D define"
2012-12-27 11:51:12 +01:00
if ( std : : strcmp ( argv [ i ] , " -D " ) = = 0 ) {
2011-01-17 20:03:22 +01:00
+ + i ;
2012-01-01 20:17:16 +01:00
if ( i > = argc | | argv [ i ] [ 0 ] = = ' - ' ) {
2011-10-29 23:26:35 +02:00
PrintMessage ( " cppcheck: argument to '-D' is missing. " ) ;
2011-01-17 20:03:22 +01:00
return false ;
}
2011-01-17 20:19:27 +01:00
2011-01-17 20:03:22 +01:00
define = argv [ i ] ;
}
// "-Ddefine"
2011-10-13 20:53:06 +02:00
else {
2011-01-17 20:03:22 +01:00
define = 2 + argv [ i ] ;
}
2012-07-05 19:35:41 +02:00
// No "=", append a "=1"
2015-08-15 20:24:26 +02:00
if ( define . find ( ' = ' ) = = std : : string : : npos )
2012-07-05 19:35:41 +02:00
define + = " =1 " ;
2011-01-17 20:03:22 +01:00
if ( ! _settings - > userDefines . empty ( ) )
_settings - > userDefines + = " ; " ;
_settings - > userDefines + = define ;
2013-06-08 16:46:54 +02:00
def = true ;
2010-08-31 20:32:26 +02:00
}
2011-11-30 20:24:01 +01:00
// User undef
2012-12-27 11:51:12 +01:00
else if ( std : : strncmp ( argv [ i ] , " -U " , 2 ) = = 0 ) {
2011-11-30 20:24:01 +01:00
std : : string undef ;
// "-U undef"
2012-12-27 11:51:12 +01:00
if ( std : : strcmp ( argv [ i ] , " -U " ) = = 0 ) {
2011-11-30 20:24:01 +01:00
+ + i ;
2012-01-01 20:17:16 +01:00
if ( i > = argc | | argv [ i ] [ 0 ] = = ' - ' ) {
2011-11-30 20:24:01 +01:00
PrintMessage ( " cppcheck: argument to '-U' is missing. " ) ;
return false ;
}
undef = argv [ i ] ;
}
// "-Uundef"
2011-11-30 20:35:04 +01:00
else {
2011-11-30 20:24:01 +01:00
undef = 2 + argv [ i ] ;
}
_settings - > userUndefs . insert ( undef ) ;
}
2010-08-31 20:32:26 +02:00
// Include paths
2012-12-27 11:51:12 +01:00
else if ( std : : strncmp ( argv [ i ] , " -I " , 2 ) = = 0 ) {
2010-08-31 20:32:26 +02:00
std : : string path ;
// "-I path/"
2012-12-27 11:51:12 +01:00
if ( std : : strcmp ( argv [ i ] , " -I " ) = = 0 ) {
2010-08-31 20:32:26 +02:00
+ + i ;
2012-01-01 20:17:16 +01:00
if ( i > = argc | | argv [ i ] [ 0 ] = = ' - ' ) {
2011-10-29 23:26:35 +02:00
PrintMessage ( " cppcheck: argument to '-I' is missing. " ) ;
2010-08-31 20:32:26 +02:00
return false ;
}
path = argv [ i ] ;
}
// "-Ipath/"
2011-10-13 20:53:06 +02:00
else {
2011-01-09 09:29:38 +01:00
path = 2 + argv [ i ] ;
2010-08-31 20:32:26 +02:00
}
2011-01-11 20:03:18 +01:00
path = Path : : fromNativeSeparators ( path ) ;
2011-03-28 21:26:14 +02:00
path = Path : : removeQuotationMarks ( path ) ;
2010-08-31 20:32:26 +02:00
// If path doesn't end with / or \, add it
2015-07-25 17:19:53 +02:00
if ( path . back ( ) ! = ' / ' )
2010-08-31 20:32:26 +02:00
path + = ' / ' ;
_settings - > _includePaths . push_back ( path ) ;
2012-12-27 16:52:31 +01:00
} else if ( std : : strncmp ( argv [ i ] , " --include= " , 10 ) = = 0 ) {
std : : string path = argv [ i ] + 10 ;
path = Path : : fromNativeSeparators ( path ) ;
_settings - > userIncludes . push_back ( path ) ;
2012-12-27 11:51:12 +01:00
} else if ( std : : strncmp ( argv [ i ] , " --includes-file= " , 16 ) = = 0 ) {
2011-10-22 21:24:23 +02:00
// open this file and read every input file (1 file name per line)
2014-03-10 15:49:02 +01:00
AddInclPathsToList ( 16 + argv [ i ] , & _settings - > _includePaths ) ;
} else if ( std : : strncmp ( argv [ i ] , " --config-exclude= " , 17 ) = = 0 ) {
std : : string path = argv [ i ] + 17 ;
path = Path : : fromNativeSeparators ( path ) ;
_settings - > configExcludePaths . insert ( path ) ;
} else if ( std : : strncmp ( argv [ i ] , " --config-excludes-file= " , 23 ) = = 0 ) {
// open this file and read every input file (1 file name per line)
AddPathsToSet ( 23 + argv [ i ] , & _settings - > configExcludePaths ) ;
2011-10-22 21:24:23 +02:00
}
2010-08-31 20:32:26 +02:00
// file list specified
2012-12-27 11:51:12 +01:00
else if ( std : : strncmp ( argv [ i ] , " --file-list= " , 12 ) = = 0 ) {
2010-08-31 20:32:26 +02:00
// open this file and read every input file (1 file name per line)
AddFilesToList ( 12 + argv [ i ] , _pathnames ) ;
}
2011-01-31 14:25:51 +01:00
// Ignored paths
2012-12-27 11:51:12 +01:00
else if ( std : : strncmp ( argv [ i ] , " -i " , 2 ) = = 0 ) {
2011-01-31 14:25:51 +01:00
std : : string path ;
// "-i path/"
2012-12-27 11:51:12 +01:00
if ( std : : strcmp ( argv [ i ] , " -i " ) = = 0 ) {
2011-01-31 14:25:51 +01:00
+ + i ;
2012-01-01 20:17:16 +01:00
if ( i > = argc | | argv [ i ] [ 0 ] = = ' - ' ) {
2011-10-29 23:26:35 +02:00
PrintMessage ( " cppcheck: argument to '-i' is missing. " ) ;
2011-01-31 14:25:51 +01:00
return false ;
}
path = argv [ i ] ;
}
2011-02-03 13:43:42 +01:00
// "-ipath/"
2011-10-13 20:53:06 +02:00
else {
2011-01-31 14:25:51 +01:00
path = 2 + argv [ i ] ;
}
2011-10-13 20:53:06 +02:00
if ( ! path . empty ( ) ) {
2011-01-31 14:25:51 +01:00
path = Path : : fromNativeSeparators ( path ) ;
2014-04-02 13:56:34 +02:00
path = Path : : simplifyPath ( path ) ;
2011-03-28 21:26:14 +02:00
path = Path : : removeQuotationMarks ( path ) ;
2011-01-31 14:25:51 +01:00
2012-02-04 19:21:38 +01:00
if ( FileLister : : isDirectory ( path ) ) {
2011-08-06 15:47:57 +02:00
// If directory name doesn't end with / or \, add it
2015-07-25 17:19:53 +02:00
if ( path . back ( ) ! = ' / ' )
2011-02-03 13:43:42 +01:00
path + = ' / ' ;
}
2011-01-31 14:25:51 +01:00
_ignoredPaths . push_back ( path ) ;
}
}
2013-07-08 18:26:18 +02:00
// --library
else if ( std : : strncmp ( argv [ i ] , " --library= " , 10 ) = = 0 ) {
2015-01-10 22:18:57 +01:00
if ( ! CppCheckExecutor : : tryLoadLibrary ( _settings - > library , argv [ 0 ] , argv [ i ] + 10 ) )
2013-07-08 18:26:18 +02:00
return false ;
}
2010-08-31 20:32:26 +02:00
// Report progress
2012-12-27 11:51:12 +01:00
else if ( std : : strcmp ( argv [ i ] , " --report-progress " ) = = 0 ) {
2012-01-02 07:42:39 +01:00
_settings - > reportProgress = true ;
2010-08-31 20:32:26 +02:00
}
2011-08-17 20:08:55 +02:00
// --std
2012-12-27 11:51:12 +01:00
else if ( std : : strcmp ( argv [ i ] , " --std=posix " ) = = 0 ) {
2011-10-22 09:45:48 +02:00
_settings - > standards . posix = true ;
2012-12-27 11:51:12 +01:00
} else if ( std : : strcmp ( argv [ i ] , " --std=c89 " ) = = 0 ) {
2012-08-25 21:57:45 +02:00
_settings - > standards . c = Standards : : C89 ;
2012-12-27 11:51:12 +01:00
} else if ( std : : strcmp ( argv [ i ] , " --std=c99 " ) = = 0 ) {
2012-08-25 21:57:45 +02:00
_settings - > standards . c = Standards : : C99 ;
2012-12-27 11:51:12 +01:00
} else if ( std : : strcmp ( argv [ i ] , " --std=c11 " ) = = 0 ) {
2012-08-25 21:57:45 +02:00
_settings - > standards . c = Standards : : C11 ;
2012-12-27 11:51:12 +01:00
} else if ( std : : strcmp ( argv [ i ] , " --std=c++03 " ) = = 0 ) {
2012-08-25 21:57:45 +02:00
_settings - > standards . cpp = Standards : : CPP03 ;
2012-12-27 11:51:12 +01:00
} else if ( std : : strcmp ( argv [ i ] , " --std=c++11 " ) = = 0 ) {
2012-08-25 21:57:45 +02:00
_settings - > standards . cpp = Standards : : CPP11 ;
2011-10-16 12:54:58 +02:00
}
2010-08-31 20:32:26 +02:00
// Output formatter
2012-12-27 11:51:12 +01:00
else if ( std : : strcmp ( argv [ i ] , " --template " ) = = 0 | |
std : : strncmp ( argv [ i ] , " --template= " , 11 ) = = 0 ) {
2010-08-31 20:32:26 +02:00
// "--template path/"
2011-11-10 20:47:49 +01:00
if ( argv [ i ] [ 10 ] = = ' = ' )
_settings - > _outputFormat = argv [ i ] + 11 ;
2012-01-01 20:17:16 +01:00
else if ( ( i + 1 ) < argc & & argv [ i + 1 ] [ 0 ] ! = ' - ' ) {
2011-11-10 20:47:49 +01:00
+ + i ;
2012-01-01 20:17:16 +01:00
_settings - > _outputFormat = argv [ i ] ;
} else {
2011-10-29 23:26:35 +02:00
PrintMessage ( " cppcheck: argument to '--template' is missing. " ) ;
2010-08-31 20:32:26 +02:00
return false ;
}
if ( _settings - > _outputFormat = = " gcc " )
_settings - > _outputFormat = " {file}:{line}: {severity}: {message} " ;
else if ( _settings - > _outputFormat = = " vs " )
_settings - > _outputFormat = " {file}({line}): {severity}: {message} " ;
2011-10-29 23:26:35 +02:00
else if ( _settings - > _outputFormat = = " edit " )
_settings - > _outputFormat = " {file} +{line}: {severity}: {message} " ;
2010-08-31 20:32:26 +02:00
}
// Checking threads
2012-12-27 11:51:12 +01:00
else if ( std : : strncmp ( argv [ i ] , " -j " , 2 ) = = 0 ) {
2010-08-31 20:32:26 +02:00
std : : string numberString ;
// "-j 3"
2012-12-27 11:51:12 +01:00
if ( std : : strcmp ( argv [ i ] , " -j " ) = = 0 ) {
2010-08-31 20:32:26 +02:00
+ + i ;
2012-01-01 20:17:16 +01:00
if ( i > = argc | | argv [ i ] [ 0 ] = = ' - ' ) {
2011-10-29 23:26:35 +02:00
PrintMessage ( " cppcheck: argument to '-j' is missing. " ) ;
2010-08-31 20:32:26 +02:00
return false ;
}
numberString = argv [ i ] ;
}
// "-j3"
2012-01-01 20:17:16 +01:00
else
numberString = argv [ i ] + 2 ;
2010-08-31 20:32:26 +02:00
std : : istringstream iss ( numberString ) ;
2011-10-13 20:53:06 +02:00
if ( ! ( iss > > _settings - > _jobs ) ) {
2011-10-29 23:26:35 +02:00
PrintMessage ( " cppcheck: argument to '-j' is not a number. " ) ;
2010-08-31 20:32:26 +02:00
return false ;
}
2011-10-13 20:53:06 +02:00
if ( _settings - > _jobs > 10000 ) {
2010-11-21 09:06:43 +01:00
// This limit is here just to catch typos. If someone has
// need for more jobs, this value should be increased.
2011-10-29 23:26:35 +02:00
PrintMessage ( " cppcheck: argument for '-j' is allowed to be 10000 at max. " ) ;
2010-08-31 20:32:26 +02:00
return false ;
}
2014-03-25 18:35:59 +01:00
} else if ( std : : strncmp ( argv [ i ] , " -l " , 2 ) = = 0 ) {
std : : string numberString ;
// "-l 3"
if ( std : : strcmp ( argv [ i ] , " -l " ) = = 0 ) {
+ + i ;
if ( i > = argc | | argv [ i ] [ 0 ] = = ' - ' ) {
PrintMessage ( " cppcheck: argument to '-l' is missing. " ) ;
return false ;
}
numberString = argv [ i ] ;
}
// "-l3"
else
numberString = argv [ i ] + 2 ;
std : : istringstream iss ( numberString ) ;
if ( ! ( iss > > _settings - > _loadAverage ) ) {
PrintMessage ( " cppcheck: argument to '-l' is not a number. " ) ;
return false ;
}
2010-08-31 20:32:26 +02:00
}
// print all possible error messages..
2012-12-27 11:51:12 +01:00
else if ( std : : strcmp ( argv [ i ] , " --errorlist " ) = = 0 ) {
2010-08-31 20:32:26 +02:00
_showErrorMessages = true ;
2010-12-29 12:43:29 +01:00
_settings - > _xml = true ;
2011-01-27 09:30:53 +01:00
_exitAfterPrint = true ;
2010-08-31 20:32:26 +02:00
}
// documentation..
2012-12-27 11:51:12 +01:00
else if ( std : : strcmp ( argv [ i ] , " --doc " ) = = 0 ) {
2010-08-31 20:32:26 +02:00
std : : ostringstream doc ;
// Get documentation..
2011-10-13 20:53:06 +02:00
for ( std : : list < Check * > : : iterator it = Check : : instances ( ) . begin ( ) ; it ! = Check : : instances ( ) . end ( ) ; + + it ) {
2012-11-03 20:42:32 +01:00
const std : : string & name ( ( * it ) - > name ( ) ) ;
2011-12-10 18:39:25 +01:00
const std : : string info ( ( * it ) - > classInfo ( ) ) ;
if ( ! name . empty ( ) & & ! info . empty ( ) )
2014-09-30 14:56:12 +02:00
doc < < " ## " < < name < < " ## \n "
2012-08-26 16:22:46 +02:00
< < info < < " \n " ;
2010-08-31 20:32:26 +02:00
}
2012-08-26 16:22:46 +02:00
std : : cout < < doc . str ( ) ;
2011-01-27 09:30:53 +01:00
_exitAfterPrint = true ;
2010-08-31 20:32:26 +02:00
return true ;
}
// show timing information..
2012-12-27 11:51:12 +01:00
else if ( std : : strncmp ( argv [ i ] , " --showtime= " , 11 ) = = 0 ) {
2010-08-31 20:32:26 +02:00
const std : : string showtimeMode = argv [ i ] + 11 ;
if ( showtimeMode = = " file " )
_settings - > _showtime = SHOWTIME_FILE ;
else if ( showtimeMode = = " summary " )
_settings - > _showtime = SHOWTIME_SUMMARY ;
else if ( showtimeMode = = " top5 " )
_settings - > _showtime = SHOWTIME_TOP5 ;
2014-01-03 10:00:47 +01:00
else if ( showtimeMode . empty ( ) )
2010-08-31 20:32:26 +02:00
_settings - > _showtime = SHOWTIME_NONE ;
2014-01-03 10:00:47 +01:00
else {
std : : string message ( " cppcheck: error: unrecognized showtime mode: \" " ) ;
message + = showtimeMode ;
2014-09-17 12:39:57 +02:00
message + = " \" . Supported modes: file, summary, top5. " ;
2014-01-03 10:00:47 +01:00
PrintMessage ( message ) ;
return false ;
}
2010-08-31 20:32:26 +02:00
}
2011-02-14 19:37:58 +01:00
# ifdef HAVE_RULES
2010-12-12 11:56:22 +01:00
// Rule given at command line
2012-12-27 11:51:12 +01:00
else if ( std : : strncmp ( argv [ i ] , " --rule= " , 7 ) = = 0 ) {
2010-12-12 11:56:22 +01:00
Settings : : Rule rule ;
rule . pattern = 7 + argv [ i ] ;
2015-10-09 21:56:19 +02:00
_settings - > rules . push_back ( rule ) ;
2010-12-12 11:56:22 +01:00
}
// Rule file
2012-12-27 11:51:12 +01:00
else if ( std : : strncmp ( argv [ i ] , " --rule-file= " , 12 ) = = 0 ) {
2013-02-16 19:01:34 +01:00
tinyxml2 : : XMLDocument doc ;
if ( doc . LoadFile ( 12 + argv [ i ] ) = = tinyxml2 : : XML_NO_ERROR ) {
2015-10-09 21:56:19 +02:00
tinyxml2 : : XMLElement * node = doc . FirstChildElement ( ) ;
2013-02-16 19:01:34 +01:00
for ( ; node & & strcmp ( node - > Value ( ) , " rule " ) = = 0 ; node = node - > NextSiblingElement ( ) ) {
2010-12-12 11:56:22 +01:00
Settings : : Rule rule ;
2015-10-09 21:56:19 +02:00
tinyxml2 : : XMLElement * tokenlist = node - > FirstChildElement ( " tokenlist " ) ;
2013-06-09 14:58:56 +02:00
if ( tokenlist )
rule . tokenlist = tokenlist - > GetText ( ) ;
2015-10-09 21:56:19 +02:00
tinyxml2 : : XMLElement * pattern = node - > FirstChildElement ( " pattern " ) ;
2011-10-13 20:53:06 +02:00
if ( pattern ) {
2010-12-12 11:56:22 +01:00
rule . pattern = pattern - > GetText ( ) ;
}
2015-10-09 21:56:19 +02:00
tinyxml2 : : XMLElement * message = node - > FirstChildElement ( " message " ) ;
2011-10-13 20:53:06 +02:00
if ( message ) {
2015-10-09 21:56:19 +02:00
tinyxml2 : : XMLElement * severity = message - > FirstChildElement ( " severity " ) ;
2010-12-12 11:56:22 +01:00
if ( severity )
rule . severity = severity - > GetText ( ) ;
2015-10-09 21:56:19 +02:00
tinyxml2 : : XMLElement * id = message - > FirstChildElement ( " id " ) ;
2010-12-12 11:56:22 +01:00
if ( id )
rule . id = id - > GetText ( ) ;
2015-10-09 21:56:19 +02:00
tinyxml2 : : XMLElement * summary = message - > FirstChildElement ( " summary " ) ;
2010-12-12 11:56:22 +01:00
if ( summary )
2013-07-06 12:01:46 +02:00
rule . summary = summary - > GetText ( ) ? summary - > GetText ( ) : " " ;
2010-12-12 11:56:22 +01:00
}
if ( ! rule . pattern . empty ( ) )
2015-10-09 21:56:19 +02:00
_settings - > rules . push_back ( rule ) ;
2010-12-12 11:56:22 +01:00
}
}
}
2011-02-12 08:06:59 +01:00
# endif
2010-12-12 11:56:22 +01:00
2011-09-18 01:40:52 +02:00
// Specify platform
2012-12-27 11:51:12 +01:00
else if ( std : : strncmp ( argv [ i ] , " --platform= " , 11 ) = = 0 ) {
2011-09-18 01:40:52 +02:00
std : : string platform ( 11 + argv [ i ] ) ;
2011-09-24 20:51:03 +02:00
if ( platform = = " win32A " )
_settings - > platform ( Settings : : Win32A ) ;
else if ( platform = = " win32W " )
_settings - > platform ( Settings : : Win32W ) ;
2011-09-18 01:40:52 +02:00
else if ( platform = = " win64 " )
_settings - > platform ( Settings : : Win64 ) ;
else if ( platform = = " unix32 " )
_settings - > platform ( Settings : : Unix32 ) ;
else if ( platform = = " unix64 " )
_settings - > platform ( Settings : : Unix64 ) ;
2015-03-15 10:02:39 +01:00
else if ( platform = = " native " )
_settings - > platform ( Settings : : Unspecified ) ;
2011-10-13 20:53:06 +02:00
else {
2011-10-29 23:26:35 +02:00
std : : string message ( " cppcheck: error: unrecognized platform: \" " ) ;
2012-04-16 19:51:07 +02:00
message + = platform ;
2011-10-29 23:26:35 +02:00
message + = " \" . " ;
2011-09-18 01:40:52 +02:00
PrintMessage ( message ) ;
return false ;
}
}
2011-10-05 07:37:43 +02:00
// Set maximum number of #ifdef configurations to check
2012-12-27 11:51:12 +01:00
else if ( std : : strncmp ( argv [ i ] , " --max-configs= " , 14 ) = = 0 ) {
2011-10-05 07:37:43 +02:00
_settings - > _force = false ;
std : : istringstream iss ( 14 + argv [ i ] ) ;
2011-10-22 11:11:54 +02:00
if ( ! ( iss > > _settings - > _maxConfigs ) ) {
2011-10-29 23:26:35 +02:00
PrintMessage ( " cppcheck: argument to '--max-configs=' is not a number. " ) ;
2011-10-05 07:37:43 +02:00
return false ;
}
2011-10-22 11:11:54 +02:00
if ( _settings - > _maxConfigs < 1 ) {
2011-10-29 23:26:35 +02:00
PrintMessage ( " cppcheck: argument to '--max-configs=' must be greater than 0. " ) ;
2011-10-05 07:37:43 +02:00
return false ;
}
2013-06-08 16:46:54 +02:00
maxconfigs = true ;
2011-10-05 07:37:43 +02:00
}
2010-08-31 20:32:26 +02:00
// Print help
2012-12-27 11:51:12 +01:00
else if ( std : : strcmp ( argv [ i ] , " -h " ) = = 0 | | std : : strcmp ( argv [ i ] , " --help " ) = = 0 ) {
2010-08-31 20:32:26 +02:00
_pathnames . clear ( ) ;
_showHelp = true ;
2011-01-27 09:30:53 +01:00
_exitAfterPrint = true ;
2010-08-31 20:32:26 +02:00
break ;
}
2010-09-06 19:15:21 +02:00
2015-07-25 17:17:52 +02:00
else if ( argv [ i ] [ 0 ] = = ' - ' ) {
2011-10-29 23:26:35 +02:00
std : : string message ( " cppcheck: error: unrecognized command line option: \" " ) ;
2010-09-10 17:39:36 +02:00
message + = argv [ i ] ;
2011-10-29 23:26:35 +02:00
message + = " \" . " ;
2010-09-10 17:39:36 +02:00
PrintMessage ( message ) ;
2010-09-06 19:12:40 +02:00
return false ;
}
2010-09-06 19:15:21 +02:00
2011-10-13 20:53:06 +02:00
else {
2011-03-28 21:26:14 +02:00
std : : string path = Path : : fromNativeSeparators ( argv [ i ] ) ;
path = Path : : removeQuotationMarks ( path ) ;
_pathnames . push_back ( path ) ;
}
2010-08-31 20:32:26 +02:00
}
2013-06-08 16:46:54 +02:00
if ( def & & ! _settings - > _force & & ! maxconfigs )
_settings - > _maxConfigs = 1U ;
if ( _settings - > _force )
_settings - > _maxConfigs = ~ 0U ;
2011-10-13 20:53:06 +02:00
if ( _settings - > isEnabled ( " unusedFunction " ) & & _settings - > _jobs > 1 ) {
2013-12-31 16:31:34 +01:00
PrintMessage ( " cppcheck: unusedFunction check can't be used with '-j' option. Disabling unusedFunction check. " ) ;
2010-08-31 20:32:26 +02:00
}
2013-05-20 16:19:31 +02:00
if ( _settings - > inconclusive & & _settings - > _xml & & _settings - > _xml_version = = 1U ) {
PrintMessage ( " cppcheck: inconclusive messages will not be shown, because the old xml format is not compatible. It's recommended to use the new xml format (use --xml-version=2). " ) ;
}
2014-05-18 13:45:26 +02:00
if ( argc < = 1 ) {
2010-09-06 21:31:06 +02:00
_showHelp = true ;
2014-05-18 13:45:26 +02:00
_exitAfterPrint = true ;
}
2010-09-06 21:31:06 +02:00
2011-10-13 20:53:06 +02:00
if ( _showHelp ) {
2010-08-31 20:32:26 +02:00
PrintHelp ( ) ;
2011-01-27 10:14:08 +01:00
return true ;
2010-09-06 21:31:06 +02:00
}
2011-01-27 10:14:08 +01:00
// Print error only if we have "real" command and expect files
2011-10-13 20:53:06 +02:00
if ( ! _exitAfterPrint & & _pathnames . empty ( ) ) {
2010-09-10 17:39:36 +02:00
PrintMessage ( " cppcheck: No C or C++ source files found. " ) ;
2010-08-31 20:32:26 +02:00
return false ;
}
2012-04-06 10:49:21 +02:00
// Use paths _pathnames if no base paths for relative path output are given
if ( _settings - > _basePaths . empty ( ) & & _settings - > _relativePaths )
_settings - > _basePaths = _pathnames ;
2010-08-31 20:32:26 +02:00
return true ;
}
2012-09-11 19:19:11 +02:00
void CmdLineParser : : PrintHelp ( )
2010-08-31 20:32:26 +02:00
{
2015-07-25 17:17:52 +02:00
std : : cout < < " Cppcheck - A tool for static C/C++ code analysis \n "
2010-08-31 20:32:26 +02:00
" \n "
" Syntax: \n "
2011-02-05 21:59:26 +01:00
" cppcheck [OPTIONS] [files or paths] \n "
2010-08-31 20:32:26 +02:00
" \n "
2011-07-16 10:19:35 +02:00
" If a directory is given instead of a filename, *.cpp, *.cxx, *.cc, *.c++, *.c, \n "
" *.tpp, and *.txx files are checked recursively from the given directory. \n \n "
2010-08-31 20:32:26 +02:00
" Options: \n "
2011-12-24 11:27:10 +01:00
" --append=<file> This allows you to provide information about functions \n "
" by providing an implementation for them. \n "
2011-05-02 21:28:33 +02:00
" --check-config Check cppcheck configuration. The normal code \n "
" analysis is disabled by this flag. \n "
2013-07-20 09:38:44 +02:00
" --check-library Show information messages when library files have \n "
" incomplete info. \n "
2015-07-25 17:17:52 +02:00
" --config-exclude=<dir> \n "
" Path (prefix) to be excluded from configuration checking. \n "
" Preprocessor configurations defined in headers (but not sources) \n "
" matching the prefix will not be considered for evaluation \n "
" of configuration alternatives \n "
" --config-excludes-file=<file> \n "
" A file that contains a list of config-excludes \n "
2014-07-14 15:51:45 +02:00
" --dump Dump xml data for each translation unit. The dump \n "
" files have the extension .dump and contain ast, \n "
" tokenlist, symboldatabase, valueflow. \n "
2013-06-09 13:00:08 +02:00
" -D<ID> Define preprocessor symbol. Unless --max-configs or \n "
" --force is used, Cppcheck will only check the given \n "
" configuration when -D is used. \n "
2011-10-29 23:26:35 +02:00
" Example: '-DDEBUG=1 -D__cplusplus'. \n "
2013-06-09 13:00:08 +02:00
" -U<ID> Undefine preprocessor symbol. Use -U to explicitly \n "
" hide certain #ifdef <ID> code paths from checking. \n "
2011-11-30 20:24:01 +01:00
" Example: '-UDEBUG' \n "
2011-02-05 21:59:26 +01:00
" --enable=<id> Enable additional checks. The available ids are: \n "
2011-05-02 18:49:40 +02:00
" * all \n "
2013-06-16 11:57:02 +02:00
" Enable all checks. It is recommended to only \n "
" use --enable=all when the whole program is \n "
" scanned, because this enables unusedFunction. \n "
2013-06-09 10:34:45 +02:00
" * warning \n "
2013-06-13 19:57:15 +02:00
" Enable warning messages \n "
2011-05-02 18:49:40 +02:00
" * style \n "
2011-09-03 17:25:39 +02:00
" Enable all coding style checks. All messages \n "
2011-12-24 11:27:10 +01:00
" with the severities 'style', 'performance' and \n "
" 'portability' are enabled. \n "
2011-09-03 15:30:30 +02:00
" * performance \n "
2011-09-03 17:25:39 +02:00
" Enable performance messages \n "
2011-09-03 15:30:30 +02:00
" * portability \n "
2011-09-03 17:25:39 +02:00
" Enable portability messages \n "
2011-05-02 18:49:40 +02:00
" * information \n "
" Enable information messages \n "
" * unusedFunction \n "
2013-06-16 11:57:02 +02:00
" Check for unused functions. It is recommend \n "
" to only enable this when the whole program is \n "
" scanned. \n "
2011-05-02 18:49:40 +02:00
" * missingInclude \n "
2011-10-30 02:29:43 +02:00
" Warn if there are missing includes. For \n "
" detailed information, use '--check-config'. \n "
2011-02-22 20:48:01 +01:00
" Several ids can be given if you separate them with \n "
2012-02-09 17:34:16 +01:00
" commas. See also --std \n "
2011-12-24 11:27:10 +01:00
" --error-exitcode=<n> If errors are found, integer [n] is returned instead of \n "
" the default '0'. ' " < < EXIT_FAILURE < < " ' is returned \n "
2010-08-31 20:32:26 +02:00
" if arguments are not valid or if no input files are \n "
2011-12-24 11:27:10 +01:00
" provided. Note that your operating system can modify \n "
" this value, e.g. '256' can become '0'. \n "
2011-07-16 10:19:35 +02:00
" --errorlist Print a list of all the error messages in XML format. \n "
2011-02-05 21:59:26 +01:00
" --exitcode-suppressions=<file> \n "
2010-08-31 20:32:26 +02:00
" Used when certain messages should be displayed but \n "
" should not cause a non-zero exitcode. \n "
2011-07-16 10:19:35 +02:00
" --file-list=<file> Specify the files to check in a text file. Add one \n "
2011-10-29 23:26:35 +02:00
" filename per line. When file is '-,' the file list will \n "
2011-09-27 08:02:58 +02:00
" be read from standard input. \n "
2011-10-22 11:11:54 +02:00
" -f, --force Force checking of all configurations in files. If used \n "
2012-04-25 19:58:34 +02:00
" together with '--max-configs=', the last option is the \n "
2011-10-30 02:29:43 +02:00
" one that is effective. \n "
2011-02-05 21:59:26 +01:00
" -h, --help Print this help. \n "
2011-12-24 11:27:10 +01:00
" -I <dir> Give path to search for include files. Give several -I \n "
" parameters to give several paths. First given path is \n "
2011-10-30 21:19:16 +01:00
" searched for contained header files first. If paths are \n "
" relative to source files, this is not needed. \n "
2011-10-23 11:15:12 +02:00
" --includes-file=<file> \n "
2011-12-24 11:27:10 +01:00
" Specify directory paths to search for included header \n "
" files in a text file. Add one include path per line. \n "
" First given path is searched for contained header \n "
" files first. If paths are relative to source files, \n "
" this is not needed. \n "
2012-12-27 16:52:31 +01:00
" --include=<file> \n "
2012-12-28 10:37:15 +01:00
" Force inclusion of a file before the checked file. Can \n "
" be used for example when checking the Linux kernel, \n "
" where autoconf.h needs to be included for every file \n "
2013-02-20 17:07:54 +01:00
" compiled. Works the same way as the GCC -include \n "
2012-12-28 10:37:15 +01:00
" option. \n "
2011-08-11 14:47:34 +02:00
" -i <dir or file> Give a source file or source file directory to exclude \n "
" from the check. This applies only to source files so \n "
" header files included by source files are not matched. \n "
" Directory name is matched to all parts of the path. \n "
2012-07-26 09:10:39 +02:00
" --inconclusive Allow that Cppcheck reports even though the analysis is \n "
" inconclusive. \n "
" There are false positives with this option. Each result \n "
" must be carefully investigated before you know if it is \n "
" good or bad. \n "
2010-08-31 20:32:26 +02:00
" --inline-suppr Enable inline suppressions. Use them by placing one or \n "
2011-10-29 23:26:35 +02:00
" more comments, like: '// cppcheck-suppress warningId' \n "
2010-08-31 20:32:26 +02:00
" on the lines before the warning to suppress. \n "
2011-02-05 21:59:26 +01:00
" -j <jobs> Start [jobs] threads to do the checking simultaneously. \n "
2014-03-25 18:35:59 +01:00
" -l <load> Specifies that no new threads should be started if there \n "
" are other threads running and the load average is at least \n "
" load (ignored on non UNIX-like systems) \n "
2012-09-10 18:51:32 +02:00
" --language=<language>, -x <language> \n "
" Forces cppcheck to check all files as the given \n "
2012-10-03 19:19:49 +02:00
" language. Valid values are: c, c++ \n "
2013-07-20 09:38:44 +02:00
" --library=<cfg> \n "
2015-03-08 15:25:00 +01:00
" Load file <cfg> that contains information about types \n "
" and functions. With such information Cppcheck \n "
" understands your your code better and therefore you \n "
" get better results. The std.cfg file that is \n "
" distributed with Cppcheck is loaded automatically. \n "
" For more information about library files, read the \n "
" manual. \n "
2011-10-05 07:37:43 +02:00
" --max-configs=<limit> \n "
2011-10-22 11:11:54 +02:00
" Maximum number of configurations to check in a file \n "
2011-10-29 23:26:35 +02:00
" before skipping it. Default is '12'. If used together \n "
" with '--force', the last option is the one that is \n "
2011-10-05 07:37:43 +02:00
" effective. \n "
2011-09-19 13:31:09 +02:00
" --platform=<type> Specifies platform specific types and sizes. The \n "
" available platforms are: \n "
2011-09-18 01:40:52 +02:00
" * unix32 \n "
" 32 bit unix variant \n "
" * unix64 \n "
" 64 bit unix variant \n "
2011-09-24 20:51:03 +02:00
" * win32A \n "
" 32 bit Windows ASCII character encoding \n "
" * win32W \n "
" 32 bit Windows UNICODE character encoding \n "
2011-09-18 01:40:52 +02:00
" * win64 \n "
" 64 bit Windows \n "
2015-03-15 10:02:39 +01:00
" * native \n "
" Unspecified platform. Type sizes of host system \n "
2015-03-15 10:06:56 +01:00
" are assumed, but no further assumptions. \n "
2015-07-25 17:39:44 +02:00
" -q, --quiet Do not show progress reports. \n "
2012-04-06 10:49:21 +02:00
" -rp, --relative-paths \n "
" -rp=<paths>, --relative-paths=<paths> \n "
" Use relative paths in output. When given, <paths> are \n "
" used as base. You can separate multiple paths by ';'. \n "
" Otherwise path where source files are searched is used. \n "
2012-04-14 16:07:37 +02:00
" We use string comparison to create relative paths, so \n "
" using e.g. ~ for home folder does not work. It is \n "
2012-06-11 11:05:18 +02:00
" currently only possible to apply the base paths to \n "
" files that are on a lower level in the directory tree. \n "
2010-08-31 20:32:26 +02:00
" --report-progress Report progress messages while checking a file. \n "
2011-05-01 11:44:47 +02:00
# ifdef HAVE_RULES
2011-02-05 21:59:26 +01:00
" --rule=<rule> Match regular expression. \n "
" --rule-file=<file> Use given rule file. For more information, see: \n "
" https://sourceforge.net/projects/cppcheck/files/Articles/ \n "
2011-05-01 11:44:47 +02:00
# endif
2012-08-25 21:57:45 +02:00
" --std=<id> Set standard. \n "
2012-02-09 17:34:16 +01:00
" The available options are: \n "
2011-10-16 15:32:40 +02:00
" * posix \n "
2012-08-25 21:57:45 +02:00
" POSIX compatible code \n "
" * c89 \n "
" C code is C89 compatible \n "
2011-10-16 15:32:40 +02:00
" * c99 \n "
2012-08-25 21:57:45 +02:00
" C code is C99 compatible \n "
" * c11 \n "
" C code is C11 compatible (default) \n "
" * c++03 \n "
" C++ code is C++03 compatible \n "
2011-10-16 15:32:40 +02:00
" * c++11 \n "
2012-08-25 21:57:45 +02:00
" C++ code is C++11 compatible (default) \n "
" More than one --std can be used: \n "
" 'cppcheck --std=c99 --std=posix file.c' \n "
2011-08-11 14:54:20 +02:00
" --suppress=<spec> Suppress warnings that match <spec>. The format of \n "
" <spec> is: \n "
2010-08-31 20:32:26 +02:00
" [error id]:[filename]:[line] \n "
2011-08-11 14:54:20 +02:00
" The [filename] and [line] are optional. If [error id] \n "
" is a wildcard '*', all error ids match. \n "
2011-02-23 08:59:30 +01:00
" --suppressions-list=<file> \n "
" Suppress warnings listed in the file. Each suppression \n "
" is in the same format as <spec> above. \n "
2011-11-10 23:00:15 +01:00
" --template='<text>' Format the error messages. E.g. \n "
2010-08-31 20:32:26 +02:00
" '{file}:{line},{severity},{id},{message}' or \n "
2013-07-08 06:44:25 +02:00
" '{file}({line}):({severity}) {message}' or \n "
" '{callstack} {message}' \n "
2011-10-29 23:26:35 +02:00
" Pre-defined templates: gcc, vs, edit. \n "
2011-07-16 10:19:35 +02:00
" -v, --verbose Output more detailed error information. \n "
2011-02-05 21:59:26 +01:00
" --version Print out version number. \n "
2011-07-16 10:19:35 +02:00
" --xml Write results in xml format to error stream (stderr). \n "
2011-02-05 21:59:26 +01:00
" --xml-version=<version> \n "
2011-10-30 02:29:43 +02:00
" Select the XML file version. Currently versions 1 and \n "
" 2 are available. The default version is 1. "
2010-08-31 20:32:26 +02:00
" \n "
" Example usage: \n "
" # Recursively check the current folder. Print the progress on the screen and \n "
2012-07-26 09:10:39 +02:00
" # write errors to a file: \n "
" cppcheck . 2> err.txt \n "
" \n "
2010-08-31 20:32:26 +02:00
" # Recursively check ../myproject/ and don't print progress: \n "
2012-07-26 09:10:39 +02:00
" cppcheck --quiet ../myproject/ \n "
" \n "
" # Check test.cpp, enable all checks: \n "
2012-08-27 19:00:00 +02:00
" cppcheck --enable=all --inconclusive --std=posix test.cpp \n "
2012-07-26 09:10:39 +02:00
" \n "
2010-08-31 20:32:26 +02:00
" # Check f.cpp and search include files from inc1/ and inc2/: \n "
2012-07-26 09:10:39 +02:00
" cppcheck -I inc1/ -I inc2/ f.cpp \n "
2010-08-31 20:32:26 +02:00
" \n "
" For more information: \n "
2013-07-13 19:23:38 +02:00
" http://cppcheck.sourceforge.net/manual.pdf \n " ;
2010-08-31 20:32:26 +02:00
}