You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
714 lines
23 KiB
714 lines
23 KiB
/*============================================================================
|
|
CMake - Cross Platform Makefile Generator
|
|
Copyright 2000-2013 Kitware, Inc., Insight Software Consortium
|
|
|
|
Distributed under the OSI-approved BSD License (the "License");
|
|
see accompanying file Copyright.txt for details.
|
|
|
|
This software is distributed WITHOUT ANY WARRANTY; without even the
|
|
implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
|
See the License for more information.
|
|
============================================================================*/
|
|
#include "cmVisualStudioSlnParser.h"
|
|
|
|
#include "cmSystemTools.h"
|
|
#include "cmVisualStudioSlnData.h"
|
|
#include <cmsys/FStream.hxx>
|
|
|
|
#include <cassert>
|
|
#include <stack>
|
|
|
|
//----------------------------------------------------------------------------
|
|
namespace
|
|
{
|
|
enum LineFormat
|
|
{
|
|
LineMultiValueTag,
|
|
LineSingleValueTag,
|
|
LineKeyValuePair,
|
|
LineVerbatim
|
|
};
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
class cmVisualStudioSlnParser::ParsedLine
|
|
{
|
|
public:
|
|
bool IsComment() const;
|
|
bool IsKeyValuePair() const;
|
|
|
|
const std::string& GetTag() const { return this->Tag; }
|
|
const std::string& GetArg() const { return this->Arg.first; }
|
|
std::string GetArgVerbatim() const;
|
|
size_t GetValueCount() const { return this->Values.size(); }
|
|
const std::string& GetValue(size_t idxValue) const;
|
|
std::string GetValueVerbatim(size_t idxValue) const;
|
|
|
|
void SetTag(const std::string& tag) { this->Tag = tag; }
|
|
void SetArg(const std::string& arg) { this->Arg = StringData(arg, false); }
|
|
void SetQuotedArg(const std::string& arg)
|
|
{ this->Arg = StringData(arg, true); }
|
|
void AddValue(const std::string& value)
|
|
{ this->Values.push_back(StringData(value, false)); }
|
|
void AddQuotedValue(const std::string& value)
|
|
{ this->Values.push_back(StringData(value, true)); }
|
|
|
|
void CopyVerbatim(const std::string& line) { this->Tag = line; }
|
|
|
|
private:
|
|
typedef std::pair<std::string, bool> StringData;
|
|
std::string Tag;
|
|
StringData Arg;
|
|
std::vector<StringData> Values;
|
|
static const std::string BadString;
|
|
static const std::string Quote;
|
|
};
|
|
|
|
//----------------------------------------------------------------------------
|
|
const std::string cmVisualStudioSlnParser::ParsedLine::BadString;
|
|
const std::string cmVisualStudioSlnParser::ParsedLine::Quote("\"");
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool cmVisualStudioSlnParser::ParsedLine::IsComment() const
|
|
{
|
|
assert(!this->Tag.empty());
|
|
return (this->Tag[0]== '#');
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool cmVisualStudioSlnParser::ParsedLine::IsKeyValuePair() const
|
|
{
|
|
assert(!this->Tag.empty());
|
|
return this->Arg.first.empty() && this->Values.size() == 1;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
std::string cmVisualStudioSlnParser::ParsedLine::GetArgVerbatim() const
|
|
{
|
|
if (this->Arg.second)
|
|
return Quote + this->Arg.first + Quote;
|
|
else
|
|
return this->Arg.first;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
const std::string&
|
|
cmVisualStudioSlnParser::ParsedLine::GetValue(size_t idxValue) const
|
|
{
|
|
if (idxValue < this->Values.size())
|
|
return this->Values[idxValue].first;
|
|
else
|
|
return BadString;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
std::string
|
|
cmVisualStudioSlnParser::ParsedLine::GetValueVerbatim(size_t idxValue) const
|
|
{
|
|
if (idxValue < this->Values.size())
|
|
{
|
|
const StringData& data = this->Values[idxValue];
|
|
if (data.second)
|
|
return Quote + data.first + Quote;
|
|
else
|
|
return data.first;
|
|
}
|
|
else
|
|
return BadString;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
class cmVisualStudioSlnParser::State
|
|
{
|
|
public:
|
|
explicit State(DataGroupSet requestedData);
|
|
|
|
size_t GetCurrentLine() const { return this->CurrentLine; }
|
|
bool ReadLine(std::istream& input, std::string& line);
|
|
|
|
LineFormat NextLineFormat() const;
|
|
|
|
bool Process(const cmVisualStudioSlnParser::ParsedLine& line,
|
|
cmSlnData& output,
|
|
cmVisualStudioSlnParser::ResultData& result);
|
|
|
|
bool Finished(cmVisualStudioSlnParser::ResultData& result);
|
|
|
|
private:
|
|
enum FileState
|
|
{
|
|
FileStateStart,
|
|
FileStateTopLevel,
|
|
FileStateProject,
|
|
FileStateProjectDependencies,
|
|
FileStateGlobal,
|
|
FileStateSolutionConfigurations,
|
|
FileStateProjectConfigurations,
|
|
FileStateSolutionFilters,
|
|
FileStateGlobalSection,
|
|
FileStateIgnore
|
|
};
|
|
std::stack<FileState> Stack;
|
|
std::string EndIgnoreTag;
|
|
DataGroupSet RequestedData;
|
|
size_t CurrentLine;
|
|
|
|
void IgnoreUntilTag(const std::string& endTag);
|
|
};
|
|
|
|
//----------------------------------------------------------------------------
|
|
cmVisualStudioSlnParser::State::State(DataGroupSet requestedData) :
|
|
RequestedData(requestedData),
|
|
CurrentLine(0)
|
|
{
|
|
if (this->RequestedData.test(DataGroupProjectDependenciesBit))
|
|
this->RequestedData.set(DataGroupProjectsBit);
|
|
this->Stack.push(FileStateStart);
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool cmVisualStudioSlnParser::State::ReadLine(std::istream& input,
|
|
std::string& line)
|
|
{
|
|
++this->CurrentLine;
|
|
return !std::getline(input, line).fail();
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
LineFormat cmVisualStudioSlnParser::State::NextLineFormat() const
|
|
{
|
|
switch (this->Stack.top())
|
|
{
|
|
case FileStateStart: return LineVerbatim;
|
|
case FileStateTopLevel: return LineMultiValueTag;
|
|
case FileStateProject: return LineSingleValueTag;
|
|
case FileStateProjectDependencies: return LineKeyValuePair;
|
|
case FileStateGlobal: return LineSingleValueTag;
|
|
case FileStateSolutionConfigurations: return LineKeyValuePair;
|
|
case FileStateProjectConfigurations: return LineKeyValuePair;
|
|
case FileStateSolutionFilters: return LineKeyValuePair;
|
|
case FileStateGlobalSection: return LineKeyValuePair;
|
|
case FileStateIgnore: return LineVerbatim;
|
|
default:
|
|
assert(false);
|
|
return LineVerbatim;
|
|
}
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool cmVisualStudioSlnParser::State::Process(
|
|
const cmVisualStudioSlnParser::ParsedLine& line,
|
|
cmSlnData& output, cmVisualStudioSlnParser::ResultData& result)
|
|
{
|
|
assert(!line.IsComment());
|
|
switch (this->Stack.top())
|
|
{
|
|
case FileStateStart:
|
|
if (!cmSystemTools::StringStartsWith(
|
|
line.GetTag().c_str(), "Microsoft Visual Studio Solution File"))
|
|
{
|
|
result.SetError(ResultErrorInputStructure, this->GetCurrentLine());
|
|
return false;
|
|
}
|
|
this->Stack.pop();
|
|
this->Stack.push(FileStateTopLevel);
|
|
break;
|
|
case FileStateTopLevel:
|
|
if (line.GetTag().compare("Project") == 0)
|
|
{
|
|
if (line.GetValueCount() != 3)
|
|
{
|
|
result.SetError(ResultErrorInputStructure, this->GetCurrentLine());
|
|
return false;
|
|
}
|
|
if (this->RequestedData.test(DataGroupProjectsBit))
|
|
{
|
|
if (!output.AddProject(line.GetValue(2),
|
|
line.GetValue(0),
|
|
line.GetValue(1)))
|
|
{
|
|
result.SetError(ResultErrorInputData, this->GetCurrentLine());
|
|
return false;
|
|
}
|
|
this->Stack.push(FileStateProject);
|
|
}
|
|
else
|
|
this->IgnoreUntilTag("EndProject");
|
|
}
|
|
else if (line.GetTag().compare("Global") == 0)
|
|
this->Stack.push(FileStateGlobal);
|
|
else
|
|
{
|
|
result.SetError(ResultErrorInputStructure, this->GetCurrentLine());
|
|
return false;
|
|
}
|
|
break;
|
|
case FileStateProject:
|
|
if (line.GetTag().compare("EndProject") == 0)
|
|
this->Stack.pop();
|
|
else if (line.GetTag().compare("ProjectSection") == 0)
|
|
{
|
|
if (line.GetArg().compare("ProjectDependencies") == 0 &&
|
|
line.GetValue(0).compare("postProject") == 0)
|
|
{
|
|
if (this->RequestedData.test(DataGroupProjectDependenciesBit))
|
|
this->Stack.push(FileStateProjectDependencies);
|
|
else
|
|
this->IgnoreUntilTag("EndProjectSection");
|
|
}
|
|
else
|
|
this->IgnoreUntilTag("EndProjectSection");
|
|
}
|
|
else
|
|
{
|
|
result.SetError(ResultErrorInputStructure, this->GetCurrentLine());
|
|
return false;
|
|
}
|
|
break;
|
|
case FileStateProjectDependencies:
|
|
if (line.GetTag().compare("EndProjectSection") == 0)
|
|
this->Stack.pop();
|
|
else if (line.IsKeyValuePair())
|
|
// implement dependency storing here, once needed
|
|
;
|
|
else
|
|
{
|
|
result.SetError(ResultErrorInputStructure, this->GetCurrentLine());
|
|
return false;
|
|
}
|
|
break;
|
|
case FileStateGlobal:
|
|
if (line.GetTag().compare("EndGlobal") == 0)
|
|
this->Stack.pop();
|
|
else if (line.GetTag().compare("GlobalSection") == 0)
|
|
{
|
|
if (line.GetArg().compare("SolutionConfigurationPlatforms") == 0 &&
|
|
line.GetValue(0).compare("preSolution") == 0)
|
|
{
|
|
if (this->RequestedData.test(DataGroupSolutionConfigurationsBit))
|
|
this->Stack.push(FileStateSolutionConfigurations);
|
|
else
|
|
this->IgnoreUntilTag("EndGlobalSection");
|
|
}
|
|
else if (line.GetArg().compare("ProjectConfigurationPlatforms") == 0 &&
|
|
line.GetValue(0).compare("postSolution") == 0)
|
|
{
|
|
if (this->RequestedData.test(DataGroupProjectConfigurationsBit))
|
|
this->Stack.push(FileStateProjectConfigurations);
|
|
else
|
|
this->IgnoreUntilTag("EndGlobalSection");
|
|
}
|
|
else if (line.GetArg().compare("NestedProjects") == 0 &&
|
|
line.GetValue(0).compare("preSolution") == 0)
|
|
{
|
|
if (this->RequestedData.test(DataGroupSolutionFiltersBit))
|
|
this->Stack.push(FileStateSolutionFilters);
|
|
else
|
|
this->IgnoreUntilTag("EndGlobalSection");
|
|
}
|
|
else if (this->RequestedData.test(DataGroupGenericGlobalSectionsBit))
|
|
this->Stack.push(FileStateGlobalSection);
|
|
else
|
|
this->IgnoreUntilTag("EndGlobalSection");
|
|
}
|
|
else
|
|
{
|
|
result.SetError(ResultErrorInputStructure, this->GetCurrentLine());
|
|
return false;
|
|
}
|
|
break;
|
|
case FileStateSolutionConfigurations:
|
|
if (line.GetTag().compare("EndGlobalSection") == 0)
|
|
this->Stack.pop();
|
|
else if (line.IsKeyValuePair())
|
|
// implement configuration storing here, once needed
|
|
;
|
|
else
|
|
{
|
|
result.SetError(ResultErrorInputStructure, this->GetCurrentLine());
|
|
return false;
|
|
}
|
|
break;
|
|
case FileStateProjectConfigurations:
|
|
if (line.GetTag().compare("EndGlobalSection") == 0)
|
|
this->Stack.pop();
|
|
else if (line.IsKeyValuePair())
|
|
// implement configuration storing here, once needed
|
|
;
|
|
else
|
|
{
|
|
result.SetError(ResultErrorInputStructure, this->GetCurrentLine());
|
|
return false;
|
|
}
|
|
break;
|
|
case FileStateSolutionFilters:
|
|
if (line.GetTag().compare("EndGlobalSection") == 0)
|
|
this->Stack.pop();
|
|
else if (line.IsKeyValuePair())
|
|
// implement filter storing here, once needed
|
|
;
|
|
else
|
|
{
|
|
result.SetError(ResultErrorInputStructure, this->GetCurrentLine());
|
|
return false;
|
|
}
|
|
break;
|
|
case FileStateGlobalSection:
|
|
if (line.GetTag().compare("EndGlobalSection") == 0)
|
|
this->Stack.pop();
|
|
else if (line.IsKeyValuePair())
|
|
// implement section storing here, once needed
|
|
;
|
|
else
|
|
{
|
|
result.SetError(ResultErrorInputStructure, this->GetCurrentLine());
|
|
return false;
|
|
}
|
|
break;
|
|
case FileStateIgnore:
|
|
if (line.GetTag() == this->EndIgnoreTag)
|
|
{
|
|
this->Stack.pop();
|
|
this->EndIgnoreTag = "";
|
|
}
|
|
break;
|
|
default:
|
|
result.SetError(ResultErrorBadInternalState, this->GetCurrentLine());
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool cmVisualStudioSlnParser::State::Finished(
|
|
cmVisualStudioSlnParser::ResultData& result)
|
|
{
|
|
if (this->Stack.top() != FileStateTopLevel)
|
|
{
|
|
result.SetError(ResultErrorInputStructure, this->GetCurrentLine());
|
|
return false;
|
|
}
|
|
result.Result = ResultOK;
|
|
return true;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
void cmVisualStudioSlnParser::State::IgnoreUntilTag(const std::string& endTag)
|
|
{
|
|
this->Stack.push(FileStateIgnore);
|
|
this->EndIgnoreTag = endTag;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
cmVisualStudioSlnParser::ResultData::ResultData()
|
|
: Result(ResultOK)
|
|
, ResultLine(0)
|
|
{}
|
|
|
|
//----------------------------------------------------------------------------
|
|
void cmVisualStudioSlnParser::ResultData::Clear()
|
|
{
|
|
*this = ResultData();
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
void cmVisualStudioSlnParser::ResultData::SetError(ParseResult error,
|
|
size_t line)
|
|
{
|
|
this->Result = error;
|
|
this->ResultLine = line;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
const cmVisualStudioSlnParser::DataGroupSet
|
|
cmVisualStudioSlnParser::DataGroupProjects(
|
|
1 << cmVisualStudioSlnParser::DataGroupProjectsBit);
|
|
|
|
const cmVisualStudioSlnParser::DataGroupSet
|
|
cmVisualStudioSlnParser::DataGroupProjectDependencies(
|
|
1 << cmVisualStudioSlnParser::DataGroupProjectDependenciesBit);
|
|
|
|
const cmVisualStudioSlnParser::DataGroupSet
|
|
cmVisualStudioSlnParser::DataGroupSolutionConfigurations(
|
|
1 << cmVisualStudioSlnParser::DataGroupSolutionConfigurationsBit);
|
|
|
|
const cmVisualStudioSlnParser::DataGroupSet
|
|
cmVisualStudioSlnParser::DataGroupProjectConfigurations(
|
|
1 << cmVisualStudioSlnParser::DataGroupProjectConfigurationsBit);
|
|
|
|
const cmVisualStudioSlnParser::DataGroupSet
|
|
cmVisualStudioSlnParser::DataGroupSolutionFilters(
|
|
1 << cmVisualStudioSlnParser::DataGroupSolutionFiltersBit);
|
|
|
|
const cmVisualStudioSlnParser::DataGroupSet
|
|
cmVisualStudioSlnParser::DataGroupGenericGlobalSections(
|
|
1 << cmVisualStudioSlnParser::DataGroupGenericGlobalSectionsBit);
|
|
|
|
const cmVisualStudioSlnParser::DataGroupSet
|
|
cmVisualStudioSlnParser::DataGroupAll(~0);
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool cmVisualStudioSlnParser::Parse(std::istream& input,
|
|
cmSlnData& output,
|
|
DataGroupSet dataGroups)
|
|
{
|
|
this->LastResult.Clear();
|
|
if (!this->IsDataGroupSetSupported(dataGroups))
|
|
{
|
|
this->LastResult.SetError(ResultErrorUnsupportedDataGroup, 0);
|
|
return false;
|
|
}
|
|
State state(dataGroups);
|
|
return this->ParseImpl(input, output, state);
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool cmVisualStudioSlnParser::ParseFile(const std::string& file,
|
|
cmSlnData& output,
|
|
DataGroupSet dataGroups)
|
|
{
|
|
this->LastResult.Clear();
|
|
if (!this->IsDataGroupSetSupported(dataGroups))
|
|
{
|
|
this->LastResult.SetError(ResultErrorUnsupportedDataGroup, 0);
|
|
return false;
|
|
}
|
|
cmsys::ifstream f(file.c_str());
|
|
if (!f)
|
|
{
|
|
this->LastResult.SetError(ResultErrorOpeningInput, 0);
|
|
return false;
|
|
}
|
|
State state(dataGroups);
|
|
return this->ParseImpl(f, output, state);
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
cmVisualStudioSlnParser::ParseResult
|
|
cmVisualStudioSlnParser::GetParseResult() const
|
|
{
|
|
return this->LastResult.Result;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
size_t cmVisualStudioSlnParser::GetParseResultLine() const
|
|
{
|
|
return this->LastResult.ResultLine;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool cmVisualStudioSlnParser::GetParseHadBOM() const
|
|
{
|
|
return this->LastResult.HadBOM;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
cmVisualStudioSlnParser::IsDataGroupSetSupported(DataGroupSet dataGroups) const
|
|
{
|
|
return (dataGroups & DataGroupProjects) == dataGroups;
|
|
//only supporting DataGroupProjects for now
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool cmVisualStudioSlnParser::ParseImpl(std::istream& input,
|
|
cmSlnData& output,
|
|
State& state)
|
|
{
|
|
std::string line;
|
|
// Does the .sln start with a Byte Order Mark?
|
|
if (!this->ParseBOM(input, line, state))
|
|
return false;
|
|
do
|
|
{
|
|
line = cmSystemTools::TrimWhitespace(line);
|
|
if (line.empty())
|
|
continue;
|
|
ParsedLine parsedLine;
|
|
switch (state.NextLineFormat())
|
|
{
|
|
case LineMultiValueTag:
|
|
if (!this->ParseMultiValueTag(line, parsedLine, state))
|
|
return false;
|
|
break;
|
|
case LineSingleValueTag:
|
|
if (!this->ParseSingleValueTag(line, parsedLine, state))
|
|
return false;
|
|
break;
|
|
case LineKeyValuePair:
|
|
if (!this->ParseKeyValuePair(line, parsedLine, state))
|
|
return false;
|
|
break;
|
|
case LineVerbatim:
|
|
parsedLine.CopyVerbatim(line);
|
|
break;
|
|
}
|
|
if (parsedLine.IsComment())
|
|
continue;
|
|
if (!state.Process(parsedLine, output, this->LastResult))
|
|
return false;
|
|
}
|
|
while (state.ReadLine(input, line));
|
|
return state.Finished(this->LastResult);
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool cmVisualStudioSlnParser::ParseBOM(std::istream& input,
|
|
std::string& line,
|
|
State& state)
|
|
{
|
|
char bom[4];
|
|
if (!input.get(bom, 4))
|
|
{
|
|
this->LastResult.SetError(ResultErrorReadingInput, 1);
|
|
return false;
|
|
}
|
|
this->LastResult.HadBOM =
|
|
(bom[0] == char(0xEF) && bom[1] == char(0xBB) && bom[2] == char(0xBF));
|
|
if (!state.ReadLine(input, line))
|
|
{
|
|
this->LastResult.SetError(ResultErrorReadingInput, 1);
|
|
return false;
|
|
}
|
|
if (!this->LastResult.HadBOM)
|
|
line = bom + line; // it wasn't a BOM, prepend it to first line
|
|
return true;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool cmVisualStudioSlnParser::ParseMultiValueTag(const std::string& line,
|
|
ParsedLine& parsedLine,
|
|
State& state)
|
|
{
|
|
size_t idxEqualSign = line.find('=');
|
|
const std::string& fullTag = line.substr(0, idxEqualSign);
|
|
if (!this->ParseTag(fullTag, parsedLine, state))
|
|
return false;
|
|
if (idxEqualSign != line.npos)
|
|
{
|
|
size_t idxFieldStart = idxEqualSign + 1;
|
|
if (idxFieldStart < line.size())
|
|
{
|
|
size_t idxParsing = idxFieldStart;
|
|
bool inQuotes = false;
|
|
for (;;)
|
|
{
|
|
idxParsing = line.find_first_of(",\"", idxParsing);
|
|
bool fieldOver = false;
|
|
if (idxParsing == line.npos)
|
|
{
|
|
fieldOver = true;
|
|
if (inQuotes)
|
|
{
|
|
this->LastResult.SetError(ResultErrorInputStructure,
|
|
state.GetCurrentLine());
|
|
return false;
|
|
}
|
|
}
|
|
else if (line[idxParsing] == ',' && !inQuotes)
|
|
fieldOver = true;
|
|
else if (line[idxParsing] == '"')
|
|
inQuotes = !inQuotes;
|
|
if (fieldOver)
|
|
{
|
|
if (!this->ParseValue(line.substr(idxFieldStart,
|
|
idxParsing - idxFieldStart),
|
|
parsedLine))
|
|
return false;
|
|
if (idxParsing == line.npos)
|
|
break; //end of last field
|
|
idxFieldStart = idxParsing + 1;
|
|
}
|
|
++idxParsing;
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool cmVisualStudioSlnParser::ParseSingleValueTag(const std::string& line,
|
|
ParsedLine& parsedLine,
|
|
State& state)
|
|
{
|
|
size_t idxEqualSign = line.find('=');
|
|
const std::string& fullTag = line.substr(0, idxEqualSign);
|
|
if (!this->ParseTag(fullTag, parsedLine, state))
|
|
return false;
|
|
if (idxEqualSign != line.npos)
|
|
{
|
|
if (!this->ParseValue(line.substr(idxEqualSign + 1), parsedLine))
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool cmVisualStudioSlnParser::ParseKeyValuePair(const std::string& line,
|
|
ParsedLine& parsedLine,
|
|
State& /*state*/)
|
|
{
|
|
size_t idxEqualSign = line.find('=');
|
|
if (idxEqualSign == line.npos)
|
|
{
|
|
parsedLine.CopyVerbatim(line);
|
|
return true;
|
|
}
|
|
const std::string& key = line.substr(0, idxEqualSign);
|
|
parsedLine.SetTag(cmSystemTools::TrimWhitespace(key));
|
|
const std::string& value = line.substr(idxEqualSign + 1);
|
|
parsedLine.AddValue(cmSystemTools::TrimWhitespace(value));
|
|
return true;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool cmVisualStudioSlnParser::ParseTag(const std::string& fullTag,
|
|
ParsedLine& parsedLine,
|
|
State& state)
|
|
{
|
|
size_t idxLeftParen = fullTag.find('(');
|
|
if (idxLeftParen == fullTag.npos)
|
|
{
|
|
parsedLine.SetTag(cmSystemTools::TrimWhitespace(fullTag));
|
|
return true;
|
|
}
|
|
parsedLine.SetTag(
|
|
cmSystemTools::TrimWhitespace(fullTag.substr(0, idxLeftParen)));
|
|
size_t idxRightParen = fullTag.rfind(')');
|
|
if (idxRightParen == fullTag.npos)
|
|
{
|
|
this->LastResult.SetError(ResultErrorInputStructure,
|
|
state.GetCurrentLine());
|
|
return false;
|
|
}
|
|
const std::string& arg = cmSystemTools::TrimWhitespace(
|
|
fullTag.substr(idxLeftParen + 1, idxRightParen - idxLeftParen - 1));
|
|
if (arg[0] == '"')
|
|
{
|
|
if (arg[arg.size() - 1] != '"')
|
|
{
|
|
this->LastResult.SetError(ResultErrorInputStructure,
|
|
state.GetCurrentLine());
|
|
return false;
|
|
}
|
|
parsedLine.SetQuotedArg(arg.substr(1, arg.size() - 2));
|
|
}
|
|
else
|
|
parsedLine.SetArg(arg);
|
|
return true;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool cmVisualStudioSlnParser::ParseValue(const std::string& value,
|
|
ParsedLine& parsedLine)
|
|
{
|
|
const std::string& trimmed = cmSystemTools::TrimWhitespace(value);
|
|
if (trimmed.empty())
|
|
parsedLine.AddValue(trimmed);
|
|
else if (trimmed[0] == '"' && trimmed[trimmed.size() - 1] == '"')
|
|
parsedLine.AddQuotedValue(trimmed.substr(1, trimmed.size() - 2));
|
|
else
|
|
parsedLine.AddValue(trimmed);
|
|
return true;
|
|
}
|