kolan
/
CMake
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Merge topic 'readability-named-parameter' 

e7b842e1 Make sure unnused parameters are /*named*/
This commit is contained in:
Brad King 2016-08-17 10:46:35 -04:00 committed by CMake Topic Stage
parent 29593b79a2 e7b842e189
commit 67a7dcef45
55 changed files with 245 additions and 190 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Source/CPack/cmCPackArchiveGenerator.cxx
View File

@ -259,7 +259,7 @@ int cmCPackArchiveGenerator::PackageFiles()
return 1;
}
int cmCPackArchiveGenerator::GenerateHeader(std::ostream*)
int cmCPackArchiveGenerator::GenerateHeader(std::ostream* /*unused*/)
{
return 1;
}

2
Source/CPack/cpack.cxx
View File

@ -50,7 +50,7 @@ static const char* cmDocumentationOptions[][2] = {
{ CM_NULLPTR, CM_NULLPTR }
};
int cpackUnknownArgument(const char*, void*)
int cpackUnknownArgument(const char* /*unused*/, void* /*unused*/)
{
return 1;
}

6
Source/CTest/cmCTestBZR.cxx
View File

@ -19,7 +19,7 @@
#include <cm_expat.h>
extern "C" int cmBZRXMLParserUnknownEncodingHandler(void*,
extern "C" int cmBZRXMLParserUnknownEncodingHandler(void* /*unused*/,
const XML_Char* name,
XML_Encoding* info)
{
@ -215,7 +215,7 @@ private:
return true;
}
void StartElement(const std::string& name, const char**) CM_OVERRIDE
void StartElement(const std::string& name, const char** /*atts*/) CM_OVERRIDE
{
this->CData.clear();
if (name == "log") {
@ -275,7 +275,7 @@ private:
this->CData.clear();
}
void ReportError(int, int, const char* msg) CM_OVERRIDE
void ReportError(int /*line*/, int /*column*/, const char* msg) CM_OVERRIDE
{
this->BZR->Log << "Error parsing bzr log xml: " << msg << "\n";
}

5
Source/CTest/cmCTestBuildAndTestHandler.cxx
View File

@ -123,14 +123,15 @@ int cmCTestBuildAndTestHandler::RunCMake(std::string* outstring,
return 0;
}
void CMakeMessageCallback(const char* m, const char*, bool&, void* s)
void CMakeMessageCallback(const char* m, const char* /*unused*/,
bool& /*unused*/, void* s)
{
std::string* out = (std::string*)s;
*out += m;
*out += "\n";
}
void CMakeProgressCallback(const char* msg, float, void* s)
void CMakeProgressCallback(const char* msg, float /*unused*/, void* s)
{
std::string* out = (std::string*)s;
*out += msg;

4
Source/CTest/cmCTestCurl.cxx
View File

@ -54,8 +54,8 @@ static size_t curlWriteMemoryCallback(void* ptr, size_t size, size_t nmemb,
return realsize;
}
static size_t curlDebugCallback(CURL*, curl_infotype, char* chPtr, size_t size,
void* data)
static size_t curlDebugCallback(CURL* /*unused*/, curl_infotype /*unused*/,
char* chPtr, size_t size, void* data)
{
std::vector<char>* vec = static_cast<std::vector<char>*>(data);
vec->insert(vec->end(), chPtr, chPtr + size);

2
Source/CTest/cmCTestEmptyBinaryDirectoryCommand.cxx
View File

@ -14,7 +14,7 @@
#include "cmCTestScriptHandler.h"
bool cmCTestEmptyBinaryDirectoryCommand::InitialPass(
std::vector<std::string> const& args, cmExecutionStatus&)
std::vector<std::string> const& args, cmExecutionStatus& /*unused*/)
{
if (args.size() != 1) {
this->SetError("called with incorrect number of arguments");

2
Source/CTest/cmCTestHG.cxx
View File

@ -261,7 +261,7 @@ private:
return output;
}
void ReportError(int, int, const char* msg) CM_OVERRIDE
void ReportError(int /*line*/, int /*column*/, const char* msg) CM_OVERRIDE
{
this->HG->Log << "Error parsing hg log xml: " << msg << "\n";
}

2
Source/CTest/cmCTestHandlerCommand.cxx
View File

@ -32,7 +32,7 @@ cmCTestHandlerCommand::cmCTestHandlerCommand()
}
bool cmCTestHandlerCommand::InitialPass(std::vector<std::string> const& args,
cmExecutionStatus&)
cmExecutionStatus& /*unused*/)
{
// Allocate space for argument values.
this->Values.clear();

2
Source/CTest/cmCTestMemCheckHandler.cxx
View File

@ -78,7 +78,7 @@ public:
ostr << "\n";
this->Log += ostr.str();
}
void EndElement(const std::string&) CM_OVERRIDE {}
void EndElement(const std::string& /*name*/) CM_OVERRIDE {}
const char* GetAttribute(const char* name, const char** atts)
{

2
Source/CTest/cmCTestReadCustomFilesCommand.cxx
View File

@ -14,7 +14,7 @@
#include "cmCTest.h"
bool cmCTestReadCustomFilesCommand::InitialPass(
std::vector<std::string> const& args, cmExecutionStatus&)
std::vector<std::string> const& args, cmExecutionStatus& /*unused*/)
{
if (args.empty()) {
this->SetError("called with incorrect number of arguments");

2
Source/CTest/cmCTestRunScriptCommand.cxx
View File

@ -14,7 +14,7 @@
#include "cmCTestScriptHandler.h"
bool cmCTestRunScriptCommand::InitialPass(std::vector<std::string> const& args,
cmExecutionStatus&)
cmExecutionStatus& /*unused*/)
{
if (args.empty()) {
this->CTestScriptHandler->RunCurrentScript();

2
Source/CTest/cmCTestSVN.cxx
View File

@ -372,7 +372,7 @@ private:
this->CData.clear();
}
void ReportError(int, int, const char* msg) CM_OVERRIDE
void ReportError(int /*line*/, int /*column*/, const char* msg) CM_OVERRIDE
{
this->SVN->Log << "Error parsing svn log xml: " << msg << "\n";
}

11
Source/CTest/cmCTestScriptHandler.cxx
View File

@ -61,7 +61,7 @@ public:
cmCTestScriptFunctionBlocker() {}
~cmCTestScriptFunctionBlocker() CM_OVERRIDE {}
bool IsFunctionBlocked(const cmListFileFunction& lff, cmMakefile& mf,
cmExecutionStatus&) CM_OVERRIDE;
cmExecutionStatus& /*status*/) CM_OVERRIDE;
// virtual bool ShouldRemove(const cmListFileFunction& lff, cmMakefile &mf);
// virtual void ScopeEnded(cmMakefile &mf);
@ -69,9 +69,9 @@ public:
};
// simply update the time and don't block anything
bool cmCTestScriptFunctionBlocker::IsFunctionBlocked(const cmListFileFunction&,
cmMakefile&,
cmExecutionStatus&)
bool cmCTestScriptFunctionBlocker::IsFunctionBlocked(
const cmListFileFunction& /*lff*/, cmMakefile& /*mf*/,
cmExecutionStatus& /*status*/)
{
this->CTestScriptHandler->UpdateElapsedTime();
return false;
@ -265,7 +265,8 @@ int cmCTestScriptHandler::ExecuteScript(const std::string& total_script_arg)
return retVal;
}
static void ctestScriptProgressCallback(const char* m, float, void* cd)
static void ctestScriptProgressCallback(const char* m, float /*unused*/,
void* cd)
{
cmCTest* ctest = static_cast<cmCTest*>(cd);
if (m && *m) {

2
Source/CTest/cmCTestSleepCommand.cxx
View File

@ -15,7 +15,7 @@
#include <stdlib.h> // required for atoi
bool cmCTestSleepCommand::InitialPass(std::vector<std::string> const& args,
cmExecutionStatus&)
cmExecutionStatus& /*unused*/)
{
if (args.empty()) {
this->SetError("called with incorrect number of arguments");

2
Source/CTest/cmCTestStartCommand.cxx
View File

@ -23,7 +23,7 @@ cmCTestStartCommand::cmCTestStartCommand()
}
bool cmCTestStartCommand::InitialPass(std::vector<std::string> const& args,
cmExecutionStatus&)
cmExecutionStatus& /*unused*/)
{
if (args.empty()) {
this->SetError("called with incorrect number of arguments");

10
Source/CTest/cmCTestSubmitHandler.cxx
View File

@ -116,7 +116,8 @@ static size_t cmCTestSubmitHandlerWriteMemoryCallback(void* ptr, size_t size,
return realsize;
}
static size_t cmCTestSubmitHandlerCurlDebugCallback(CURL*, curl_infotype,
static size_t cmCTestSubmitHandlerCurlDebugCallback(CURL* /*unused*/,
curl_infotype /*unused*/,
char* chPtr, size_t size,
void* data)
{
@ -976,10 +977,9 @@ bool cmCTestSubmitHandler::SubmitUsingXMLRPC(
return true;
}
#else
bool cmCTestSubmitHandler::SubmitUsingXMLRPC(std::string const&,
std::set<std::string> const&,
std::string const&,
std::string const&)
bool cmCTestSubmitHandler::SubmitUsingXMLRPC(
std::string const& /*unused*/, std::set<std::string> const& /*unused*/,
std::string const& /*unused*/, std::string const& /*unused*/)
{
return false;
}

23
Source/CTest/cmCTestTestHandler.cxx
View File

@ -54,7 +54,7 @@ public:
* the CMakeLists.txt file.
*/
bool InitialPass(std::vector<std::string> const& args,
cmExecutionStatus&) CM_OVERRIDE;
cmExecutionStatus& /*unused*/) CM_OVERRIDE;
/**
* The name of the command as specified in CMakeList.txt.
@ -67,7 +67,7 @@ public:
};
bool cmCTestSubdirCommand::InitialPass(std::vector<std::string> const& args,
cmExecutionStatus&)
cmExecutionStatus& /*unused*/)
{
if (args.empty()) {
this->SetError("called with incorrect number of arguments");
@ -135,7 +135,7 @@ public:
* the CMakeLists.txt file.
*/
bool InitialPass(std::vector<std::string> const& args,
cmExecutionStatus&) CM_OVERRIDE;
cmExecutionStatus& /*unused*/) CM_OVERRIDE;
/**
* The name of the command as specified in CMakeList.txt.
@ -148,7 +148,7 @@ public:
};
bool cmCTestAddSubdirectoryCommand::InitialPass(
std::vector<std::string> const& args, cmExecutionStatus&)
std::vector<std::string> const& args, cmExecutionStatus& /*unused*/)
{
if (args.empty()) {
this->SetError("called with incorrect number of arguments");
@ -208,8 +208,8 @@ public:
* This is called when the command is first encountered in
* the CMakeLists.txt file.
*/
bool InitialPass(std::vector<std::string> const&,
cmExecutionStatus&) CM_OVERRIDE;
bool InitialPass(std::vector<std::string> const& /*args*/,
cmExecutionStatus& /*unused*/) CM_OVERRIDE;
/**
* The name of the command as specified in CMakeList.txt.
@ -222,7 +222,7 @@ public:
};
bool cmCTestAddTestCommand::InitialPass(std::vector<std::string> const& args,
cmExecutionStatus&)
cmExecutionStatus& /*unused*/)
{
if (args.size() < 2) {
this->SetError("called with incorrect number of arguments");
@ -248,8 +248,8 @@ public:
* This is called when the command is first encountered in
* the CMakeLists.txt file.
*/
bool InitialPass(std::vector<std::string> const&,
cmExecutionStatus&) CM_OVERRIDE;
bool InitialPass(std::vector<std::string> const& /*args*/,
cmExecutionStatus& /*unused*/) CM_OVERRIDE;
/**
* The name of the command as specified in CMakeList.txt.
@ -262,7 +262,7 @@ public:
};
bool cmCTestSetTestsPropertiesCommand::InitialPass(
std::vector<std::string> const& args, cmExecutionStatus&)
std::vector<std::string> const& args, cmExecutionStatus& /*unused*/)
{
return this->TestHandler->SetTestsProperties(args);
}
@ -986,7 +986,8 @@ void cmCTestTestHandler::ProcessDirectory(std::vector<std::string>& passed,
*this->LogFile << "End testing: " << this->CTest->CurrentTime() << std::endl;
}
void cmCTestTestHandler::GenerateTestCommand(std::vector<std::string>&, int)
void cmCTestTestHandler::GenerateTestCommand(
std::vector<std::string>& /*unused*/, int /*unused*/)
{
}

2
Source/CTest/cmCTestVC.cxx
View File

@ -185,7 +185,7 @@ bool cmCTestVC::WriteXML(cmXMLWriter& xml)
return result;
}
bool cmCTestVC::WriteXMLUpdates(cmXMLWriter&)
bool cmCTestVC::WriteXMLUpdates(cmXMLWriter& /*unused*/)
{
cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
"* CTest cannot extract updates for this VCS tool.\n");

2
Source/CTest/cmParseJacocoCoverage.cxx
View File

@ -23,7 +23,7 @@ public:
~XMLParser() CM_OVERRIDE {}
protected:
void EndElement(const std::string&) CM_OVERRIDE {}
void EndElement(const std::string& /*name*/) CM_OVERRIDE {}
void StartElement(const std::string& name, const char** atts) CM_OVERRIDE
{

6
Source/CursesDialog/ccmake.cxx
View File

@ -51,7 +51,7 @@ cmCursesForm* cmCursesForm::CurrentForm = CM_NULLPTR;
extern "C" {
void onsig(int)
void onsig(int /*unused*/)
{
if (cmCursesForm::CurrentForm) {
endwin();
@ -70,8 +70,8 @@ void onsig(int)
}
}
void CMakeMessageHandler(const char* message, const char* title, bool&,
void* clientData)
void CMakeMessageHandler(const char* message, const char* title,
bool& /*unused*/, void* clientData)
{
cmCursesForm* self = static_cast<cmCursesForm*>(clientData);
self->AddError(message, title);

3
Source/CursesDialog/cmCursesBoolWidget.cxx
View File

@ -24,7 +24,8 @@ cmCursesBoolWidget::cmCursesBoolWidget(int width, int height, int left,
this->SetValueAsBool(false);
}
bool cmCursesBoolWidget::HandleInput(int& key, cmCursesMainForm*, WINDOW* w)
bool cmCursesBoolWidget::HandleInput(int& key, cmCursesMainForm* /*fm*/,
WINDOW* w)
{
// toggle boolean values with enter or space

3
Source/CursesDialog/cmCursesDummyWidget.cxx
View File

@ -18,7 +18,8 @@ cmCursesDummyWidget::cmCursesDummyWidget(int width, int height, int left,
this->Type = cmState::INTERNAL;
}
bool cmCursesDummyWidget::HandleInput(int&, cmCursesMainForm*, WINDOW*)
bool cmCursesDummyWidget::HandleInput(int& /*key*/, cmCursesMainForm* /*fm*/,
WINDOW* /*w*/)
{
return false;
}

3
Source/CursesDialog/cmCursesLabelWidget.cxx
View File

@ -25,7 +25,8 @@ cmCursesLabelWidget::~cmCursesLabelWidget()
{
}
bool cmCursesLabelWidget::HandleInput(int&, cmCursesMainForm*, WINDOW*)
bool cmCursesLabelWidget::HandleInput(int& /*key*/, cmCursesMainForm* /*fm*/,
WINDOW* /*w*/)
{
// Static text. No input is handled here.
return false;

3
Source/CursesDialog/cmCursesLongMessageForm.cxx
View File

@ -102,7 +102,8 @@ void cmCursesLongMessageForm::PrintKeys()
pos_form_cursor(this->Form);
}
void cmCursesLongMessageForm::Render(int, int, int, int)
void cmCursesLongMessageForm::Render(int /*left*/, int /*top*/, int /*width*/,
int /*height*/)
{
int x, y;
getmaxyx(stdscr, y, x);

4
Source/CursesDialog/cmCursesMainForm.cxx
View File

@ -675,7 +675,7 @@ int cmCursesMainForm::Generate()
return 0;
}
void cmCursesMainForm::AddError(const char* message, const char*)
void cmCursesMainForm::AddError(const char* message, const char* /*unused*/)
{
this->Errors.push_back(message);
}
@ -1028,7 +1028,7 @@ void cmCursesMainForm::HandleInput()
}
}
int cmCursesMainForm::LoadCache(const char*)
int cmCursesMainForm::LoadCache(const char* /*unused*/)
{
int r = this->CMakeInstance->LoadCache();

3
Source/CursesDialog/cmCursesOptionsWidget.cxx
View File

@ -31,7 +31,8 @@ cmCursesOptionsWidget::cmCursesOptionsWidget(int width, int height, int left,
field_opts_off(this->Field, O_STATIC);
}
bool cmCursesOptionsWidget::HandleInput(int& key, cmCursesMainForm*, WINDOW* w)
bool cmCursesOptionsWidget::HandleInput(int& key, cmCursesMainForm* /*fm*/,
WINDOW* w)
{
// 10 == enter

8
Source/CursesDialog/cmCursesStringWidget.cxx
View File

@ -29,12 +29,13 @@ cmCursesStringWidget::cmCursesStringWidget(int width, int height, int left,
field_opts_off(this->Field, O_STATIC);
}
void cmCursesStringWidget::OnTab(cmCursesMainForm*, WINDOW*)
void cmCursesStringWidget::OnTab(cmCursesMainForm* /*unused*/,
WINDOW* /*unused*/)
{
// FORM* form = fm->GetForm();
}
void cmCursesStringWidget::OnReturn(cmCursesMainForm* fm, WINDOW*)
void cmCursesStringWidget::OnReturn(cmCursesMainForm* fm, WINDOW* /*unused*/)
{
FORM* form = fm->GetForm();
if (this->InEdit) {
@ -56,7 +57,8 @@ void cmCursesStringWidget::OnReturn(cmCursesMainForm* fm, WINDOW*)
}
}
void cmCursesStringWidget::OnType(int& key, cmCursesMainForm* fm, WINDOW*)
void cmCursesStringWidget::OnType(int& key, cmCursesMainForm* fm,
WINDOW* /*unused*/)
{
form_driver(fm->GetForm(), key);
}

3
Source/cmArchiveWrite.cxx
View File

@ -64,7 +64,8 @@ public:
struct cmArchiveWrite::Callback
{
// archive_write_callback
static __LA_SSIZE_T Write(struct archive*, void* cd, const void* b, size_t n)
static __LA_SSIZE_T Write(struct archive* /*unused*/, void* cd,
const void* b, size_t n)
{
cmArchiveWrite* self = static_cast<cmArchiveWrite*>(cd);
if (self->Stream.write(static_cast<const char*>(b),

9
Source/cmDepends.cxx
View File

@ -72,7 +72,7 @@ bool cmDepends::Write(std::ostream& makeDepends, std::ostream& internalDepends)
return this->Finalize(makeDepends, internalDepends);
}
bool cmDepends::Finalize(std::ostream&, std::ostream&)
bool cmDepends::Finalize(std::ostream& /*unused*/, std::ostream& /*unused*/)
{
return true;
}
@ -123,9 +123,10 @@ void cmDepends::Clear(const char* file)
<< std::endl;
}
bool cmDepends::WriteDependencies(const std::set<std::string>&,
const std::string&, std::ostream&,
std::ostream&)
bool cmDepends::WriteDependencies(const std::set<std::string>& /*unused*/,
const std::string& /*unused*/,
std::ostream& /*unused*/,
std::ostream& /*unused*/)
{
// This should be implemented by the subclass.
return false;

5
Source/cmDependsFortran.cxx
View File

@ -91,8 +91,9 @@ cmDependsFortran::~cmDependsFortran()
}
bool cmDependsFortran::WriteDependencies(const std::set<std::string>& sources,
const std::string& obj, std::ostream&,
std::ostream&)
const std::string& obj,
std::ostream& /*makeDepends*/,
std::ostream& /*internalDepends*/)
{
// Make sure this is a scanning instance.
if (sources.empty() || sources.begin()->empty()) {

10
Source/cmDependsJava.cxx
View File

@ -23,8 +23,9 @@ cmDependsJava::~cmDependsJava()
}
bool cmDependsJava::WriteDependencies(const std::set<std::string>& sources,
const std::string&, std::ostream&,
std::ostream&)
const std::string& /*obj*/,
std::ostream& /*makeDepends*/,
std::ostream& /*internalDepends*/)
{
// Make sure this is a scanning instance.
if (sources.empty() || sources.begin()->empty()) {
@ -35,8 +36,9 @@ bool cmDependsJava::WriteDependencies(const std::set<std::string>& sources,
return true;
}
bool cmDependsJava::CheckDependencies(std::istream&, const char*,
std::map<std::string, DependencyVector>&)
bool cmDependsJava::CheckDependencies(
std::istream& /*internalDepends*/, const char* /*internalDependsFileName*/,
std::map<std::string, DependencyVector>& /*validDeps*/)
{
return true;
}

6
Source/cmDynamicLoader.cxx
View File

@ -15,8 +15,10 @@ class cmDynamicLoaderCache
{
public:
~cmDynamicLoaderCache();
void CacheFile(const char* path, const cmsys::DynamicLoader::LibraryHandle&);
bool GetCacheFile(const char* path, cmsys::DynamicLoader::LibraryHandle&);
void CacheFile(const char* path,
const cmsys::DynamicLoader::LibraryHandle& /*p*/);
bool GetCacheFile(const char* path,
cmsys::DynamicLoader::LibraryHandle& /*p*/);
bool FlushCache(const char* path);
void FlushCache();
static cmDynamicLoaderCache* GetInstance();

8
Source/cmELF.cxx
View File

@ -55,17 +55,17 @@ template <size_t s>
struct cmELFByteSwapSize
{
};
void cmELFByteSwap(char*, cmELFByteSwapSize<1> const&)
void cmELFByteSwap(char* /*unused*/, cmELFByteSwapSize<1> const& /*unused*/)
{
}
void cmELFByteSwap(char* data, cmELFByteSwapSize<2> const&)
void cmELFByteSwap(char* data, cmELFByteSwapSize<2> const& /*unused*/)
{
char one_byte;
one_byte = data[0];
data[0] = data[1];
data[1] = one_byte;
}
void cmELFByteSwap(char* data, cmELFByteSwapSize<4> const&)
void cmELFByteSwap(char* data, cmELFByteSwapSize<4> const& /*unused*/)
{
char one_byte;
one_byte = data[0];
@ -75,7 +75,7 @@ void cmELFByteSwap(char* data, cmELFByteSwapSize<4> const&)
data[1] = data[2];
data[2] = one_byte;
}
void cmELFByteSwap(char* data, cmELFByteSwapSize<8> const&)
void cmELFByteSwap(char* data, cmELFByteSwapSize<8> const& /*unused*/)
{
char one_byte;
one_byte = data[0];

2
Source/cmExportFileGenerator.cxx
View File

@ -679,7 +679,7 @@ void cmExportFileGenerator::ResolveTargetsInGeneratorExpression(
}
}
void cmExportFileGenerator::ReplaceInstallPrefix(std::string&)
void cmExportFileGenerator::ReplaceInstallPrefix(std::string& /*unused*/)
{
// Do nothing
}

2
Source/cmExportInstallFileGenerator.cxx
View File

@ -468,7 +468,7 @@ void cmExportInstallFileGenerator::ComplainAboutMissingTarget(
}
std::string cmExportInstallFileGenerator::InstallNameDir(
cmGeneratorTarget* target, const std::string&)
cmGeneratorTarget* target, const std::string& /*config*/)
{
std::string install_name_dir;

3
Source/cmExternalMakefileProjectGenerator.cxx
View File

@ -15,7 +15,8 @@
#include <assert.h>
void cmExternalMakefileProjectGenerator::EnableLanguage(
std::vector<std::string> const&, cmMakefile*, bool)
std::vector<std::string> const& /*unused*/, cmMakefile* /*unused*/,
bool /*unused*/)
{
}

3
Source/cmExtraEclipseCDT4Generator.cxx
View File

@ -77,7 +77,8 @@ cmExtraEclipseCDT4Generator::GetFactory()
}
void cmExtraEclipseCDT4Generator::EnableLanguage(
std::vector<std::string> const& languages, cmMakefile*, bool)
std::vector<std::string> const& languages, cmMakefile* /*unused*/,
bool /*optional*/)
{
for (std::vector<std::string>::const_iterator lit = languages.begin();
lit != languages.end(); ++lit) {

3
Source/cmExtraSublimeTextGenerator.cxx
View File

@ -206,8 +206,7 @@ void cmExtraSublimeTextGenerator::AppendAllTargets(
void cmExtraSublimeTextGenerator::AppendTarget(
cmGeneratedFileStream& fout, const std::string& targetName,
cmLocalGenerator* lg, cmGeneratorTarget* target, const char* make,
const cmMakefile* makefile,
const char*, // compiler
const cmMakefile* makefile, const char* /*compiler*/,
MapSourceFileFlags& sourceFileFlags, bool firstTarget)
{

2
Source/cmFortranParserImpl.cxx
View File

@ -161,7 +161,7 @@ int cmFortranParser_GetOldStartcond(cmFortranParser* parser)
return parser->OldStartcond;
}
void cmFortranParser_Error(cmFortranParser*, const char*)
void cmFortranParser_Error(cmFortranParser* /*unused*/, const char* /*unused*/)
{
// If there is a parser error just ignore it. The source will not
// compile and the user will edit it. Then dependencies will have

2
Source/cmGeneratorExpressionDAGChecker.cxx
View File

@ -198,7 +198,7 @@ enum TransitiveProperty
};
template <TransitiveProperty>
bool additionalTest(const char* const)
bool additionalTest(const char* const /*unused*/)
{
return false;
}

177
Source/cmGeneratorExpressionNode.cxx
View File

@ -46,10 +46,11 @@ static const struct ZeroNode : public cmGeneratorExpressionNode
bool AcceptsArbitraryContentParameter() const CM_OVERRIDE { return true; }
std::string Evaluate(const std::vector<std::string>&,
cmGeneratorExpressionContext*,
const GeneratorExpressionContent*,
cmGeneratorExpressionDAGChecker*) const CM_OVERRIDE
std::string Evaluate(const std::vector<std::string>& /*parameters*/,
cmGeneratorExpressionContext* /*context*/,
const GeneratorExpressionContent* /*content*/,
cmGeneratorExpressionDAGChecker* /*dagChecker*/) const
CM_OVERRIDE
{
return std::string();
}
@ -62,9 +63,10 @@ static const struct OneNode : public cmGeneratorExpressionNode
bool AcceptsArbitraryContentParameter() const CM_OVERRIDE { return true; }
std::string Evaluate(const std::vector<std::string>& parameters,
cmGeneratorExpressionContext*,
const GeneratorExpressionContent*,
cmGeneratorExpressionDAGChecker*) const CM_OVERRIDE
cmGeneratorExpressionContext* /*context*/,
const GeneratorExpressionContent* /*content*/,
cmGeneratorExpressionDAGChecker* /*dagChecker*/) const
CM_OVERRIDE
{
return parameters.front();
}
@ -113,7 +115,8 @@ static const struct NotNode : public cmGeneratorExpressionNode
std::string Evaluate(const std::vector<std::string>& parameters,
cmGeneratorExpressionContext* context,
const GeneratorExpressionContent* content,
cmGeneratorExpressionDAGChecker*) const CM_OVERRIDE
cmGeneratorExpressionDAGChecker* /*dagChecker*/) const
CM_OVERRIDE
{
if (*parameters.begin() != "0" && *parameters.begin() != "1") {
reportError(
@ -132,9 +135,10 @@ static const struct BoolNode : public cmGeneratorExpressionNode
int NumExpectedParameters() const CM_OVERRIDE { return 1; }
std::string Evaluate(const std::vector<std::string>& parameters,
cmGeneratorExpressionContext*,
const GeneratorExpressionContent*,
cmGeneratorExpressionDAGChecker*) const CM_OVERRIDE
cmGeneratorExpressionContext* /*context*/,
const GeneratorExpressionContent* /*content*/,
cmGeneratorExpressionDAGChecker* /*dagChecker*/) const
CM_OVERRIDE
{
return !cmSystemTools::IsOff(parameters.begin()->c_str()) ? "1" : "0";
}
@ -147,9 +151,10 @@ static const struct StrEqualNode : public cmGeneratorExpressionNode
int NumExpectedParameters() const CM_OVERRIDE { return 2; }
std::string Evaluate(const std::vector<std::string>& parameters,
cmGeneratorExpressionContext*,
const GeneratorExpressionContent*,
cmGeneratorExpressionDAGChecker*) const CM_OVERRIDE
cmGeneratorExpressionContext* /*context*/,
const GeneratorExpressionContent* /*content*/,
cmGeneratorExpressionDAGChecker* /*dagChecker*/) const
CM_OVERRIDE
{
return *parameters.begin() == parameters[1] ? "1" : "0";
}
@ -164,7 +169,8 @@ static const struct EqualNode : public cmGeneratorExpressionNode
std::string Evaluate(const std::vector<std::string>& parameters,
cmGeneratorExpressionContext* context,
const GeneratorExpressionContent* content,
cmGeneratorExpressionDAGChecker*) const CM_OVERRIDE
cmGeneratorExpressionDAGChecker* /*dagChecker*/) const
CM_OVERRIDE
{
char* pEnd;
@ -239,9 +245,10 @@ static const struct LowerCaseNode : public cmGeneratorExpressionNode
bool AcceptsArbitraryContentParameter() const CM_OVERRIDE { return true; }
std::string Evaluate(const std::vector<std::string>& parameters,
cmGeneratorExpressionContext*,
const GeneratorExpressionContent*,
cmGeneratorExpressionDAGChecker*) const CM_OVERRIDE
cmGeneratorExpressionContext* /*context*/,
const GeneratorExpressionContent* /*content*/,
cmGeneratorExpressionDAGChecker* /*dagChecker*/) const
CM_OVERRIDE
{
return cmSystemTools::LowerCase(parameters.front());
}
@ -254,9 +261,10 @@ static const struct UpperCaseNode : public cmGeneratorExpressionNode
bool AcceptsArbitraryContentParameter() const CM_OVERRIDE { return true; }
std::string Evaluate(const std::vector<std::string>& parameters,
cmGeneratorExpressionContext*,
const GeneratorExpressionContent*,
cmGeneratorExpressionDAGChecker*) const CM_OVERRIDE
cmGeneratorExpressionContext* /*context*/,
const GeneratorExpressionContent* /*content*/,
cmGeneratorExpressionDAGChecker* /*dagChecker*/) const
CM_OVERRIDE
{
return cmSystemTools::UpperCase(parameters.front());
}
@ -269,9 +277,10 @@ static const struct MakeCIdentifierNode : public cmGeneratorExpressionNode
bool AcceptsArbitraryContentParameter() const CM_OVERRIDE { return true; }
std::string Evaluate(const std::vector<std::string>& parameters,
cmGeneratorExpressionContext*,
const GeneratorExpressionContent*,
cmGeneratorExpressionDAGChecker*) const CM_OVERRIDE
cmGeneratorExpressionContext* /*context*/,
const GeneratorExpressionContent* /*content*/,
cmGeneratorExpressionDAGChecker* /*dagChecker*/) const
CM_OVERRIDE
{
return cmSystemTools::MakeCidentifier(parameters.front());
}
@ -283,10 +292,11 @@ static const struct Angle_RNode : public cmGeneratorExpressionNode
int NumExpectedParameters() const CM_OVERRIDE { return 0; }
std::string Evaluate(const std::vector<std::string>&,
cmGeneratorExpressionContext*,
const GeneratorExpressionContent*,
cmGeneratorExpressionDAGChecker*) const CM_OVERRIDE
std::string Evaluate(const std::vector<std::string>& /*parameters*/,
cmGeneratorExpressionContext* /*context*/,
const GeneratorExpressionContent* /*content*/,
cmGeneratorExpressionDAGChecker* /*dagChecker*/) const
CM_OVERRIDE
{
return ">";
}
@ -298,10 +308,11 @@ static const struct CommaNode : public cmGeneratorExpressionNode
int NumExpectedParameters() const CM_OVERRIDE { return 0; }
std::string Evaluate(const std::vector<std::string>&,
cmGeneratorExpressionContext*,
const GeneratorExpressionContent*,
cmGeneratorExpressionDAGChecker*) const CM_OVERRIDE
std::string Evaluate(const std::vector<std::string>& /*parameters*/,
cmGeneratorExpressionContext* /*context*/,
const GeneratorExpressionContent* /*content*/,
cmGeneratorExpressionDAGChecker* /*dagChecker*/) const
CM_OVERRIDE
{
return ",";
}
@ -313,10 +324,11 @@ static const struct SemicolonNode : public cmGeneratorExpressionNode
int NumExpectedParameters() const CM_OVERRIDE { return 0; }
std::string Evaluate(const std::vector<std::string>&,
cmGeneratorExpressionContext*,
const GeneratorExpressionContent*,
cmGeneratorExpressionDAGChecker*) const CM_OVERRIDE
std::string Evaluate(const std::vector<std::string>& /*parameters*/,
cmGeneratorExpressionContext* /*context*/,
const GeneratorExpressionContent* /*content*/,
cmGeneratorExpressionDAGChecker* /*dagChecker*/) const
CM_OVERRIDE
{
return ";";
}
@ -331,7 +343,7 @@ struct CompilerIdNode : public cmGeneratorExpressionNode
std::string EvaluateWithLanguage(const std::vector<std::string>& parameters,
cmGeneratorExpressionContext* context,
const GeneratorExpressionContent* content,
cmGeneratorExpressionDAGChecker*,
cmGeneratorExpressionDAGChecker* /*unused*/,
const std::string& lang) const
{
const char* compilerId = context->LG->GetMakefile()->GetSafeDefinition(
@ -426,7 +438,7 @@ struct CompilerVersionNode : public cmGeneratorExpressionNode
std::string EvaluateWithLanguage(const std::vector<std::string>& parameters,
cmGeneratorExpressionContext* context,
const GeneratorExpressionContent* content,
cmGeneratorExpressionDAGChecker*,
cmGeneratorExpressionDAGChecker* /*unused*/,
const std::string& lang) const
{
const char* compilerVersion =
@ -506,8 +518,9 @@ struct PlatformIdNode : public cmGeneratorExpressionNode
std::string Evaluate(const std::vector<std::string>& parameters,
cmGeneratorExpressionContext* context,
const GeneratorExpressionContent*,
cmGeneratorExpressionDAGChecker*) const CM_OVERRIDE
const GeneratorExpressionContent* /*content*/,
cmGeneratorExpressionDAGChecker* /*dagChecker*/) const
CM_OVERRIDE
{
const char* platformId =
context->LG->GetMakefile()->GetSafeDefinition("CMAKE_SYSTEM_NAME");
@ -533,9 +546,10 @@ static const struct VersionGreaterNode : public cmGeneratorExpressionNode
int NumExpectedParameters() const CM_OVERRIDE { return 2; }
std::string Evaluate(const std::vector<std::string>& parameters,
cmGeneratorExpressionContext*,
const GeneratorExpressionContent*,
cmGeneratorExpressionDAGChecker*) const CM_OVERRIDE
cmGeneratorExpressionContext* /*context*/,
const GeneratorExpressionContent* /*content*/,
cmGeneratorExpressionDAGChecker* /*dagChecker*/) const
CM_OVERRIDE
{
return cmSystemTools::VersionCompare(cmSystemTools::OP_GREATER,
parameters.front().c_str(),
@ -552,9 +566,10 @@ static const struct VersionGreaterEqNode : public cmGeneratorExpressionNode
int NumExpectedParameters() const CM_OVERRIDE { return 2; }
std::string Evaluate(const std::vector<std::string>& parameters,
cmGeneratorExpressionContext*,
const GeneratorExpressionContent*,
cmGeneratorExpressionDAGChecker*) const CM_OVERRIDE
cmGeneratorExpressionContext* /*context*/,
const GeneratorExpressionContent* /*content*/,
cmGeneratorExpressionDAGChecker* /*dagChecker*/) const
CM_OVERRIDE
{
return cmSystemTools::VersionCompare(cmSystemTools::OP_GREATER_EQUAL,
parameters.front().c_str(),
@ -571,9 +586,10 @@ static const struct VersionLessNode : public cmGeneratorExpressionNode
int NumExpectedParameters() const CM_OVERRIDE { return 2; }
std::string Evaluate(const std::vector<std::string>& parameters,
cmGeneratorExpressionContext*,
const GeneratorExpressionContent*,
cmGeneratorExpressionDAGChecker*) const CM_OVERRIDE
cmGeneratorExpressionContext* /*context*/,
const GeneratorExpressionContent* /*content*/,
cmGeneratorExpressionDAGChecker* /*dagChecker*/) const
CM_OVERRIDE
{
return cmSystemTools::VersionCompare(cmSystemTools::OP_LESS,
parameters.front().c_str(),
@ -590,9 +606,10 @@ static const struct VersionLessEqNode : public cmGeneratorExpressionNode
int NumExpectedParameters() const CM_OVERRIDE { return 2; }
std::string Evaluate(const std::vector<std::string>& parameters,
cmGeneratorExpressionContext*,
const GeneratorExpressionContent*,
cmGeneratorExpressionDAGChecker*) const CM_OVERRIDE
cmGeneratorExpressionContext* /*context*/,
const GeneratorExpressionContent* /*content*/,
cmGeneratorExpressionDAGChecker* /*dagChecker*/) const
CM_OVERRIDE
{
return cmSystemTools::VersionCompare(cmSystemTools::OP_LESS_EQUAL,
parameters.front().c_str(),
@ -609,9 +626,10 @@ static const struct VersionEqualNode : public cmGeneratorExpressionNode
int NumExpectedParameters() const CM_OVERRIDE { return 2; }
std::string Evaluate(const std::vector<std::string>& parameters,
cmGeneratorExpressionContext*,
const GeneratorExpressionContent*,
cmGeneratorExpressionDAGChecker*) const CM_OVERRIDE
cmGeneratorExpressionContext* /*context*/,
const GeneratorExpressionContent* /*content*/,
cmGeneratorExpressionDAGChecker* /*dagChecker*/) const
CM_OVERRIDE
{
return cmSystemTools::VersionCompare(cmSystemTools::OP_EQUAL,
parameters.front().c_str(),
@ -625,10 +643,11 @@ static const struct LinkOnlyNode : public cmGeneratorExpressionNode
{
LinkOnlyNode() {}
std::string Evaluate(
const std::vector<std::string>& parameters, cmGeneratorExpressionContext*,
const GeneratorExpressionContent*,
cmGeneratorExpressionDAGChecker* dagChecker) const CM_OVERRIDE
std::string Evaluate(const std::vector<std::string>& parameters,
cmGeneratorExpressionContext* /*context*/,
const GeneratorExpressionContent* /*content*/,
cmGeneratorExpressionDAGChecker* dagChecker) const
CM_OVERRIDE
{
if (!dagChecker->GetTransitivePropertiesOnly()) {
return parameters.front();
@ -643,10 +662,11 @@ static const struct ConfigurationNode : public cmGeneratorExpressionNode
int NumExpectedParameters() const CM_OVERRIDE { return 0; }
std::string Evaluate(const std::vector<std::string>&,
std::string Evaluate(const std::vector<std::string>& /*parameters*/,
cmGeneratorExpressionContext* context,
const GeneratorExpressionContent*,
cmGeneratorExpressionDAGChecker*) const CM_OVERRIDE
const GeneratorExpressionContent* /*content*/,
cmGeneratorExpressionDAGChecker* /*dagChecker*/) const
CM_OVERRIDE
{
context->HadContextSensitiveCondition = true;
return context->Config;
@ -662,7 +682,8 @@ static const struct ConfigurationTestNode : public cmGeneratorExpressionNode
std::string Evaluate(const std::vector<std::string>& parameters,
cmGeneratorExpressionContext* context,
const GeneratorExpressionContent* content,
cmGeneratorExpressionDAGChecker*) const CM_OVERRIDE
cmGeneratorExpressionDAGChecker* /*dagChecker*/) const
CM_OVERRIDE
{
if (parameters.empty()) {
return configurationNode.Evaluate(parameters, context, content,
@ -721,9 +742,10 @@ static const struct JoinNode : public cmGeneratorExpressionNode
bool AcceptsArbitraryContentParameter() const CM_OVERRIDE { return true; }
std::string Evaluate(const std::vector<std::string>& parameters,
cmGeneratorExpressionContext*,
const GeneratorExpressionContent*,
cmGeneratorExpressionDAGChecker*) const CM_OVERRIDE
cmGeneratorExpressionContext* /*context*/,
const GeneratorExpressionContent* /*content*/,
cmGeneratorExpressionDAGChecker* /*dagChecker*/) const
CM_OVERRIDE
{
std::vector<std::string> list;
cmSystemTools::ExpandListArgument(parameters.front(), list);
@ -1138,9 +1160,10 @@ static const struct TargetNameNode : public cmGeneratorExpressionNode
bool RequiresLiteralInput() const CM_OVERRIDE { return true; }
std::string Evaluate(const std::vector<std::string>& parameters,
cmGeneratorExpressionContext*,
const GeneratorExpressionContent*,
cmGeneratorExpressionDAGChecker*) const CM_OVERRIDE
cmGeneratorExpressionContext* /*context*/,
const GeneratorExpressionContent* /*content*/,
cmGeneratorExpressionDAGChecker* /*dagChecker*/) const
CM_OVERRIDE
{
return parameters.front();
}
@ -1156,7 +1179,8 @@ static const struct TargetObjectsNode : public cmGeneratorExpressionNode
std::string Evaluate(const std::vector<std::string>& parameters,
cmGeneratorExpressionContext* context,
const GeneratorExpressionContent* content,
cmGeneratorExpressionDAGChecker*) const CM_OVERRIDE
cmGeneratorExpressionDAGChecker* /*dagChecker*/) const
CM_OVERRIDE
{
if (!context->EvaluateForBuildsystem) {
std::ostringstream e;
@ -1357,7 +1381,8 @@ static const struct TargetPolicyNode : public cmGeneratorExpressionNode
std::string Evaluate(const std::vector<std::string>& parameters,
cmGeneratorExpressionContext* context,
const GeneratorExpressionContent* content,
cmGeneratorExpressionDAGChecker*) const CM_OVERRIDE
cmGeneratorExpressionDAGChecker* /*dagChecker*/) const
CM_OVERRIDE
{
if (!context->HeadTarget) {
reportError(
@ -1414,10 +1439,11 @@ static const struct InstallPrefixNode : public cmGeneratorExpressionNode
bool GeneratesContent() const CM_OVERRIDE { return true; }
int NumExpectedParameters() const CM_OVERRIDE { return 0; }
std::string Evaluate(const std::vector<std::string>&,
std::string Evaluate(const std::vector<std::string>& /*parameters*/,
cmGeneratorExpressionContext* context,
const GeneratorExpressionContent* content,
cmGeneratorExpressionDAGChecker*) const CM_OVERRIDE
cmGeneratorExpressionDAGChecker* /*dagChecker*/) const
CM_OVERRIDE
{
reportError(context, content->GetOriginalExpression(),
"INSTALL_PREFIX is a marker for install(EXPORT) only. It "
@ -1534,7 +1560,7 @@ struct TargetFilesystemArtifactResultCreator<ArtifactNameTag>
{
static std::string Create(cmGeneratorTarget* target,
cmGeneratorExpressionContext* context,
const GeneratorExpressionContent*)
const GeneratorExpressionContent* /*unused*/)
{
return target->GetFullPath(context->Config, false, true);
}
@ -1653,7 +1679,8 @@ static const struct ShellPathNode : public cmGeneratorExpressionNode
std::string Evaluate(const std::vector<std::string>& parameters,
cmGeneratorExpressionContext* context,
const GeneratorExpressionContent* content,
cmGeneratorExpressionDAGChecker*) const CM_OVERRIDE
cmGeneratorExpressionDAGChecker* /*dagChecker*/) const
CM_OVERRIDE
{
if (!cmSystemTools::FileIsFullPath(parameters.front())) {
reportError(context, content->GetOriginalExpression(),

19
Source/cmGeneratorTarget.cxx
View File

@ -128,7 +128,7 @@ template <bool>
struct DoAccept
{
template <typename T>
static void Do(T&, cmSourceFile*)
static void Do(T& /*unused*/, cmSourceFile* /*unused*/)
{
}
};
@ -3271,7 +3271,8 @@ template <>
bool getLinkInterfaceDependentProperty(cmGeneratorTarget const* tgt,
const std::string& prop,
const std::string& config,
CompatibleType, bool*)
CompatibleType /*unused*/,
bool* /*unused*/)
{
return tgt->GetLinkInterfaceDependentBoolProperty(prop, config);
}
@ -3280,7 +3281,8 @@ template <>
const char* getLinkInterfaceDependentProperty(cmGeneratorTarget const* tgt,
const std::string& prop,
const std::string& config,
CompatibleType t, const char**)
CompatibleType t,
const char** /*unused*/)
{
switch (t) {
case BoolType:
@ -3303,7 +3305,7 @@ void checkPropertyConsistency(cmGeneratorTarget const* depender,
const std::string& propName,
std::set<std::string>& emitted,
const std::string& config, CompatibleType t,
PropertyType*)
PropertyType* /*unused*/)
{
const char* prop = dependee->GetProperty(propName);
if (!prop) {
@ -3536,12 +3538,12 @@ std::string valueAsString<const char*>(const char* value)
template <typename PropertyType>
PropertyType impliedValue(PropertyType);
template <>
bool impliedValue<bool>(bool)
bool impliedValue<bool>(bool /*unused*/)
{
return false;
}
template <>
const char* impliedValue<const char*>(const char*)
const char* impliedValue<const char*>(const char* /*unused*/)
{
return "";
}
@ -3552,7 +3554,8 @@ std::pair<bool, PropertyType> consistentProperty(PropertyType lhs,
CompatibleType t);
template <>
std::pair<bool, bool> consistentProperty(bool lhs, bool rhs, CompatibleType)
std::pair<bool, bool> consistentProperty(bool lhs, bool rhs,
CompatibleType /*unused*/)
{
return std::make_pair(lhs == rhs, lhs);
}
@ -3626,7 +3629,7 @@ PropertyType checkInterfacePropertyCompatibility(cmGeneratorTarget const* tgt,
const std::string& config,
const char* defaultValue,
CompatibleType t,
PropertyType*)
PropertyType* /*unused*/)
{
PropertyType propContent = getTypedProperty<PropertyType>(tgt, p);
std::vector<std::string> headPropKeys = tgt->GetPropertyKeys();

21
Source/cmGlobalGenerator.cxx
View File

@ -1515,7 +1515,8 @@ void cmGlobalGenerator::ClearGeneratorMembers()
this->BinaryDirectories.clear();
}
void cmGlobalGenerator::ComputeTargetObjectDirectory(cmGeneratorTarget*) const
void cmGlobalGenerator::ComputeTargetObjectDirectory(
cmGeneratorTarget* /*unused*/) const
{
}
@ -1644,15 +1645,17 @@ int cmGlobalGenerator::TryCompile(const std::string& srcdir,
}
void cmGlobalGenerator::GenerateBuildCommand(
std::vector<std::string>& makeCommand, const std::string&,
const std::string&, const std::string&, const std::string&,
const std::string&, bool, bool, std::vector<std::string> const&)
std::vector<std::string>& makeCommand, const std::string& /*unused*/,
const std::string& /*unused*/, const std::string& /*unused*/,
const std::string& /*unused*/, const std::string& /*unused*/,
bool /*unused*/, bool /*unused*/, std::vector<std::string> const& /*unused*/)
{
makeCommand.push_back(
"cmGlobalGenerator::GenerateBuildCommand not implemented");
}
int cmGlobalGenerator::Build(const std::string&, const std::string& bindir,
int cmGlobalGenerator::Build(const std::string& /*unused*/,
const std::string& bindir,
const std::string& projectName,
const std::string& target, std::string& output,
const std::string& makeCommandCSTR,
@ -2372,10 +2375,10 @@ std::string cmGlobalGenerator::GetSharedLibFlagsForLanguage(
return "";
}
void cmGlobalGenerator::AppendDirectoryForConfig(const std::string&,
const std::string&,
const std::string&,
std::string&)
void cmGlobalGenerator::AppendDirectoryForConfig(const std::string& /*unused*/,
const std::string& /*unused*/,
const std::string& /*unused*/,
std::string& /*unused*/)
{
// Subclasses that support multiple configurations should implement
// this method to append the subdirectory for the given build

9
Source/cmLocalGenerator.cxx
View File

@ -1371,8 +1371,8 @@ void cmLocalGenerator::GetTargetDefines(cmGeneratorTarget const* target,
this->AddCompileDefinitions(defines, target, config, lang.c_str());
}
std::string cmLocalGenerator::GetTargetFortranFlags(cmGeneratorTarget const*,
std::string const&)
std::string cmLocalGenerator::GetTargetFortranFlags(
cmGeneratorTarget const* /*unused*/, std::string const& /*unused*/)
{
// Implemented by specific generators that override this.
return std::string();
@ -2478,7 +2478,8 @@ std::string& cmLocalGenerator::CreateSafeUniqueObjectFileName(
}
void cmLocalGenerator::ComputeObjectFilenames(
std::map<cmSourceFile const*, std::string>&, cmGeneratorTarget const*)
std::map<cmSourceFile const*, std::string>& /*unused*/,
cmGeneratorTarget const* /*unused*/)
{
}
@ -2613,7 +2614,7 @@ const char* cmLocalGenerator::GetCurrentSourceDirectory() const
}
std::string cmLocalGenerator::GetTargetDirectory(
const cmGeneratorTarget*) const
const cmGeneratorTarget* /*unused*/) const
{
cmSystemTools::Error("GetTargetDirectory"
" called on cmLocalGenerator");

3
Source/cmPolicies.cxx
View File

@ -293,7 +293,8 @@ std::string cmPolicies::GetRequiredPolicyError(cmPolicies::PolicyID id)
}
///! Get the default status for a policy
cmPolicies::PolicyStatus cmPolicies::GetPolicyStatus(cmPolicies::PolicyID)
cmPolicies::PolicyStatus cmPolicies::GetPolicyStatus(
cmPolicies::PolicyID /*unused*/)
{
return cmPolicies::WARN;
}

6
Source/cmScriptGenerator.cxx
View File

@ -117,9 +117,9 @@ void cmScriptGenerator::GenerateScriptActions(std::ostream& os,
}
}
void cmScriptGenerator::GenerateScriptForConfig(std::ostream&,
const std::string&,
Indent const&)
void cmScriptGenerator::GenerateScriptForConfig(std::ostream& /*unused*/,
const std::string& /*unused*/,
Indent const& /*unused*/)
{
// No actions for this generator.
}

3
Source/cmSystemTools.cxx
View File

@ -191,7 +191,8 @@ void cmSystemTools::ExpandRegistryValues(std::string& source, KeyWOW64 view)
}
}
#else
void cmSystemTools::ExpandRegistryValues(std::string& source, KeyWOW64)
void cmSystemTools::ExpandRegistryValues(std::string& source,
KeyWOW64 /*unused*/)
{
cmsys::RegularExpression regEntry("\\[(HKEY[^]]*)\\]");
while (regEntry.find(source)) {

2
Source/cmXMLParser.cxx
View File

@ -200,7 +200,7 @@ void cmXMLParser::ReportXmlParseError()
XML_ErrorString(XML_GetErrorCode(parser)));
}
void cmXMLParser::ReportError(int line, int, const char* msg)
void cmXMLParser::ReportError(int line, int /*unused*/, const char* msg)
{
if (this->ReportCallback) {
this->ReportCallback(line, msg, this->ReportCallbackData);

5
Source/cmake.cxx
View File

@ -129,8 +129,9 @@ typedef cmsys::hash_map<std::string, Json::Value> JsonValueMapType;
static bool cmakeCheckStampFile(const char* stampName);
static bool cmakeCheckStampList(const char* stampName);
void cmWarnUnusedCliWarning(const std::string& variable, int, void* ctx,
const char*, const cmMakefile*)
void cmWarnUnusedCliWarning(const std::string& variable, int /*unused*/,
void* ctx, const char* /*unused*/,
const cmMakefile* /*unused*/)
{
cmake* cm = reinterpret_cast<cmake*>(ctx);
cm->MarkCliAsUsed(variable);

4
Source/cmakemain.cxx
View File

@ -124,8 +124,8 @@ static std::string cmakemainGetStack(void* clientdata)
return msg;
}
static void cmakemainMessageCallback(const char* m, const char*, bool&,
void* clientdata)
static void cmakemainMessageCallback(const char* m, const char* /*unused*/,
bool& /*unused*/, void* clientdata)
{
std::cerr << m << cmakemainGetStack(clientdata) << std::endl << std::flush;
}

2
Tests/CMakeLib/testGeneratedFileStream.cxx
View File

@ -16,7 +16,7 @@
std::cout << "FAILED: " << m1 << m2 << "\n"; \
failed = 1
int testGeneratedFileStream(int, char* [])
int testGeneratedFileStream(int /*unused*/, char* /*unused*/ [])
{
int failed = 0;
cmGeneratedFileStream gm;

2
Tests/CMakeLib/testSystemTools.cxx
View File

@ -19,7 +19,7 @@
std::cout << "FAILED: " << m << "\n"; \
failed = 1
int testSystemTools(int, char* [])
int testSystemTools(int /*unused*/, char* /*unused*/ [])
{
int failed = 0;
// ----------------------------------------------------------------------

2
Tests/CMakeLib/testUTF8.cxx
View File

@ -97,7 +97,7 @@ static bool decode_bad(test_utf8_char const s)
return true;
}
int testUTF8(int, char* [])
int testUTF8(int /*unused*/, char* /*unused*/ [])
{
int result = 0;
for (test_utf8_entry const* e = good_entry; e->n; ++e) {

2
Tests/CMakeLib/testXMLParser.cxx
View File

@ -4,7 +4,7 @@
#include <iostream>
int testXMLParser(int, char* [])
int testXMLParser(int /*unused*/, char* /*unused*/ [])
{
// TODO: Derive from parser and check attributes.
cmXMLParser parser;

2
Tests/CMakeLib/testXMLSafe.cxx
View File

@ -28,7 +28,7 @@ static test_pair const pairs[] = {
{ 0, 0 }
};
int testXMLSafe(int, char* [])
int testXMLSafe(int /*unused*/, char* /*unused*/ [])
{
int result = 0;
for (test_pair const* p = pairs; p->in; ++p) {