dilim/CMake
1
0
Fork 0
mirror of https://github.com/Kitware/CMake.git synced 2026-08-04 23:00:54 +00:00
Code Issues Packages Projects Releases Wiki Activity

cmRST: Convert enum types to enum class

Browse Source 
This improves readability and avoids unintended conversions.
This commit is contained in:
Brad King
2023-03-09 15:07:35 -05:00
parent b6ffbffaf2
commit 6a84717d17
2 changed files with 48 additions and 47 deletions
Download Patch File Download Diff File Expand all files Collapse all files

59
Source/cmRST.cxx
View File

@@ -126,27 +126,27 @@ void cmRST::Reset()
if (!this->MarkupLines.empty()) {
cmRST::UnindentLines(this->MarkupLines);
}
switch (this->Directive) {
case DirectiveNone:
switch (this->DirectiveType) {
case Directive::None:
break;
case DirectiveParsedLiteral:
case Directive::ParsedLiteral:
this->ProcessDirectiveParsedLiteral();
break;
case DirectiveLiteralBlock:
case Directive::LiteralBlock:
this->ProcessDirectiveLiteralBlock();
break;
case DirectiveCodeBlock:
case Directive::CodeBlock:
this->ProcessDirectiveCodeBlock();
break;
case DirectiveReplace:
case Directive::Replace:
this->ProcessDirectiveReplace();
break;
case DirectiveTocTree:
case Directive::TocTree:
this->ProcessDirectiveTocTree();
break;
}
this->Markup = MarkupNone;
this->Directive = DirectiveNone;
this->MarkupType = Markup::None;
this->DirectiveType = Directive::None;
this->MarkupLines.clear();
}
@@ -160,9 +160,9 @@ void cmRST::ProcessLine(std::string const& line)
(line.size() >= 3 && line[0] == '.' && line[1] == '.' &&
isspace(line[2]))) {
this->Reset();
this->Markup =
(line.find_first_not_of(" \t", 2) == std::string::npos ? MarkupEmpty
: MarkupNormal);
this->MarkupType =
(line.find_first_not_of(" \t", 2) == std::string::npos ? Markup::Empty
: Markup::Normal);
// XXX(clang-tidy): https://bugs.llvm.org/show_bug.cgi?id=44165
// NOLINTNEXTLINE(bugprone-branch-clone)
if (this->CMakeDirective.find(line)) {
@@ -171,33 +171,33 @@ void cmRST::ProcessLine(std::string const& line)
} else if (this->CMakeModuleDirective.find(line)) {
// Process cmake-module directive: scan .cmake file comments.
std::string file = this->CMakeModuleDirective.match(1);
if (file.empty() || !this->ProcessInclude(file, IncludeModule)) {
if (file.empty() || !this->ProcessInclude(file, Include::Module)) {
this->NormalLine(line);
}
} else if (this->ParsedLiteralDirective.find(line)) {
// Record the literal lines to output after whole block.
this->Directive = DirectiveParsedLiteral;
this->DirectiveType = Directive::ParsedLiteral;
this->MarkupLines.push_back(this->ParsedLiteralDirective.match(1));
} else if (this->CodeBlockDirective.find(line)) {
// Record the literal lines to output after whole block.
// Ignore the language spec and record the opening line as blank.
this->Directive = DirectiveCodeBlock;
this->DirectiveType = Directive::CodeBlock;
this->MarkupLines.emplace_back();
} else if (this->ReplaceDirective.find(line)) {
// Record the replace directive content.
this->Directive = DirectiveReplace;
this->DirectiveType = Directive::Replace;
this->ReplaceName = this->ReplaceDirective.match(1);
this->MarkupLines.push_back(this->ReplaceDirective.match(2));
} else if (this->IncludeDirective.find(line)) {
// Process the include directive or output the directive and its
// content normally if it fails.
std::string file = this->IncludeDirective.match(1);
if (file.empty() || !this->ProcessInclude(file, IncludeNormal)) {
if (file.empty() || !this->ProcessInclude(file, Include::Normal)) {
this->NormalLine(line);
}
} else if (this->TocTreeDirective.find(line)) {
// Record the toctree entries to process after whole block.
this->Directive = DirectiveTocTree;
this->DirectiveType = Directive::TocTree;
this->MarkupLines.push_back(this->TocTreeDirective.match(1));
} else if (this->ProductionListDirective.find(line)) {
// Output productionlist directives and their content normally.
@@ -213,12 +213,13 @@ void cmRST::ProcessLine(std::string const& line)
}
// An explicit markup start followed nothing but whitespace and a
// blank line does not consume any indented text following.
else if (this->Markup == MarkupEmpty && line.empty()) {
else if (this->MarkupType == Markup::Empty && line.empty()) {
this->NormalLine(line);
}
// Indented lines following an explicit markup start are explicit markup.
else if (this->Markup && (line.empty() || isspace(line[0]))) {
this->Markup = MarkupNormal;
else if (this->MarkupType != Markup::None &&
(line.empty() || isspace(line[0]))) {
this->MarkupType = Markup::Normal;
// Record markup lines if the start line was recorded.
if (!this->MarkupLines.empty()) {
this->MarkupLines.push_back(line);
@@ -227,8 +228,8 @@ void cmRST::ProcessLine(std::string const& line)
// A blank line following a paragraph ending in "::" starts a literal block.
else if (lastLineEndedInColonColon && line.empty()) {
// Record the literal lines to output after whole block.
this->Markup = MarkupNormal;
this->Directive = DirectiveLiteralBlock;
this->MarkupType = Markup::Normal;
this->DirectiveType = Directive::LiteralBlock;
this->MarkupLines.emplace_back();
this->OutputLine("", false);
}
@@ -354,14 +355,14 @@ void cmRST::OutputMarkupLines(bool inlineMarkup)
this->OutputLinePending = true;
}
bool cmRST::ProcessInclude(std::string file, IncludeType type)
bool cmRST::ProcessInclude(std::string file, Include type)
{
bool found = false;
if (this->IncludeDepth < 10) {
cmRST r(this->OS, this->DocRoot);
r.IncludeDepth = this->IncludeDepth + 1;
r.OutputLinePending = this->OutputLinePending;
if (type != IncludeTocTree) {
if (type != Include::TocTree) {
r.Replace = this->Replace;
}
if (file[0] == '/') {
@@ -369,8 +370,8 @@ bool cmRST::ProcessInclude(std::string file, IncludeType type)
} else {
file = this->DocDir + "/" + file;
}
found = r.ProcessFile(file, type == IncludeModule);
if (type != IncludeTocTree) {
found = r.ProcessFile(file, type == Include::Module);
if (type != Include::TocTree) {
this->Replace = r.Replace;
}
this->OutputLinePending = r.OutputLinePending;
@@ -408,9 +409,9 @@ void cmRST::ProcessDirectiveTocTree()
if (!line.empty() && line[0] != ':') {
if (this->TocTreeLink.find(line)) {
std::string const& link = this->TocTreeLink.match(1);
this->ProcessInclude(link + ".rst", IncludeTocTree);
this->ProcessInclude(link + ".rst", Include::TocTree);
} else {
this->ProcessInclude(line + ".rst", IncludeTocTree);
this->ProcessInclude(line + ".rst", Include::TocTree);
}
}
}

36
Source/cmRST.h
View File

@@ -29,26 +29,26 @@ public:
bool ProcessFile(std::string const& fname, bool isModule = false);
private:
enum IncludeType
enum class Include
{
IncludeNormal,
IncludeModule,
IncludeTocTree
Normal,
Module,
TocTree
};
enum MarkupType
enum class Markup
{
MarkupNone,
MarkupNormal,
MarkupEmpty
None,
Normal,
Empty
};
enum DirectiveType
enum class Directive
{
DirectiveNone,
DirectiveParsedLiteral,
DirectiveLiteralBlock,
DirectiveCodeBlock,
DirectiveReplace,
DirectiveTocTree
None,
ParsedLiteral,
LiteralBlock,
CodeBlock,
Replace,
TocTree
};
void ProcessRST(std::istream& is);
@@ -59,7 +59,7 @@ private:
void OutputLine(std::string const& line, bool inlineMarkup);
std::string ReplaceSubstitutions(std::string const& line);
void OutputMarkupLines(bool inlineMarkup);
bool ProcessInclude(std::string file, IncludeType type);
bool ProcessInclude(std::string file, Include type);
void ProcessDirectiveParsedLiteral();
void ProcessDirectiveLiteralBlock();
void ProcessDirectiveCodeBlock();
@@ -72,8 +72,8 @@ private:
int IncludeDepth = 0;
bool OutputLinePending = false;
bool LastLineEndedInColonColon = false;
MarkupType Markup = MarkupNone;
DirectiveType Directive = DirectiveNone;
Markup MarkupType = Markup::None;
Directive DirectiveType = Directive::None;
cmsys::RegularExpression CMakeDirective;
cmsys::RegularExpression CMakeModuleDirective;
cmsys::RegularExpression ParsedLiteralDirective;