Restoring authorship annotation for <shadchin@yandex-team.ru>. Commit 1 of 2.

1 files changed, 517 insertions, 517 deletions

diff --git a/contrib/libs/llvm12/utils/TableGen/DirectiveEmitter.cpp b/contrib/libs/llvm12/utils/TableGen/DirectiveEmitter.cpp
index c9daa9b241..6da6be1129 100644
--- a/contrib/libs/llvm12/utils/TableGen/DirectiveEmitter.cpp
+++ b/contrib/libs/llvm12/utils/TableGen/DirectiveEmitter.cpp
@@ -11,7 +11,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "llvm/TableGen/DirectiveEmitter.h"
+#include "llvm/TableGen/DirectiveEmitter.h" 
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringSet.h"
@@ -42,13 +42,13 @@ namespace llvm {
 
 // Generate enum class
 void GenerateEnumClass(const std::vector<Record *> &Records, raw_ostream &OS,
-                       StringRef Enum, StringRef Prefix,
-                       const DirectiveLanguage &DirLang) {
+                       StringRef Enum, StringRef Prefix, 
+                       const DirectiveLanguage &DirLang) { 
   OS << "\n";
   OS << "enum class " << Enum << " {\n";
   for (const auto &R : Records) {
-    BaseRecord Rec{R};
-    OS << "  " << Prefix << Rec.getFormattedName() << ",\n";
+    BaseRecord Rec{R}; 
+    OS << "  " << Prefix << Rec.getFormattedName() << ",\n"; 
   }
   OS << "};\n";
   OS << "\n";
@@ -60,130 +60,130 @@ void GenerateEnumClass(const std::vector<Record *> &Records, raw_ostream &OS,
   // At the same time we do not loose the strong type guarantees of the enum
   // class, that is we cannot pass an unsigned as Directive without an explicit
   // cast.
-  if (DirLang.hasMakeEnumAvailableInNamespace()) {
+  if (DirLang.hasMakeEnumAvailableInNamespace()) { 
     OS << "\n";
     for (const auto &R : Records) {
-      BaseRecord Rec{R};
-      OS << "constexpr auto " << Prefix << Rec.getFormattedName() << " = "
-         << "llvm::" << DirLang.getCppNamespace() << "::" << Enum
-         << "::" << Prefix << Rec.getFormattedName() << ";\n";
+      BaseRecord Rec{R}; 
+      OS << "constexpr auto " << Prefix << Rec.getFormattedName() << " = " 
+         << "llvm::" << DirLang.getCppNamespace() << "::" << Enum 
+         << "::" << Prefix << Rec.getFormattedName() << ";\n"; 
     }
   }
 }
 
-// Generate enums for values that clauses can take.
-// Also generate function declarations for get<Enum>Name(StringRef Str).
-void GenerateEnumClauseVal(const std::vector<Record *> &Records,
-                           raw_ostream &OS, const DirectiveLanguage &DirLang,
-                           std::string &EnumHelperFuncs) {
-  for (const auto &R : Records) {
-    Clause C{R};
-    const auto &ClauseVals = C.getClauseVals();
-    if (ClauseVals.size() <= 0)
-      continue;
-
-    const auto &EnumName = C.getEnumName();
-    if (EnumName.size() == 0) {
-      PrintError("enumClauseValue field not set in Clause" +
-                 C.getFormattedName() + ".");
-      return;
-    }
-
-    OS << "\n";
-    OS << "enum class " << EnumName << " {\n";
-    for (const auto &CV : ClauseVals) {
-      ClauseVal CVal{CV};
-      OS << "  " << CV->getName() << "=" << CVal.getValue() << ",\n";
-    }
-    OS << "};\n";
-
-    if (DirLang.hasMakeEnumAvailableInNamespace()) {
-      OS << "\n";
-      for (const auto &CV : ClauseVals) {
-        OS << "constexpr auto " << CV->getName() << " = "
-           << "llvm::" << DirLang.getCppNamespace() << "::" << EnumName
-           << "::" << CV->getName() << ";\n";
-      }
-      EnumHelperFuncs += (llvm::Twine(EnumName) + llvm::Twine(" get") +
-                          llvm::Twine(EnumName) + llvm::Twine("(StringRef);\n"))
-                             .str();
-
-      EnumHelperFuncs +=
-          (llvm::Twine("llvm::StringRef get") + llvm::Twine(DirLang.getName()) +
-           llvm::Twine(EnumName) + llvm::Twine("Name(") +
-           llvm::Twine(EnumName) + llvm::Twine(");\n"))
-              .str();
-    }
-  }
-}
-
-bool HasDuplicateClauses(const std::vector<Record *> &Clauses,
-                         const Directive &Directive,
-                         llvm::StringSet<> &CrtClauses) {
-  bool HasError = false;
-  for (const auto &C : Clauses) {
-    VersionedClause VerClause{C};
-    const auto insRes = CrtClauses.insert(VerClause.getClause().getName());
-    if (!insRes.second) {
-      PrintError("Clause " + VerClause.getClause().getRecordName() +
-                 " already defined on directive " + Directive.getRecordName());
-      HasError = true;
-    }
-  }
-  return HasError;
-}
-
-// Check for duplicate clauses in lists. Clauses cannot appear twice in the
-// three allowed list. Also, since required implies allowed, clauses cannot
-// appear in both the allowedClauses and requiredClauses lists.
-bool HasDuplicateClausesInDirectives(const std::vector<Record *> &Directives) {
-  bool HasDuplicate = false;
-  for (const auto &D : Directives) {
-    Directive Dir{D};
-    llvm::StringSet<> Clauses;
-    // Check for duplicates in the three allowed lists.
-    if (HasDuplicateClauses(Dir.getAllowedClauses(), Dir, Clauses) ||
-        HasDuplicateClauses(Dir.getAllowedOnceClauses(), Dir, Clauses) ||
-        HasDuplicateClauses(Dir.getAllowedExclusiveClauses(), Dir, Clauses)) {
-      HasDuplicate = true;
-    }
-    // Check for duplicate between allowedClauses and required
-    Clauses.clear();
-    if (HasDuplicateClauses(Dir.getAllowedClauses(), Dir, Clauses) ||
-        HasDuplicateClauses(Dir.getRequiredClauses(), Dir, Clauses)) {
-      HasDuplicate = true;
-    }
-    if (HasDuplicate)
-      PrintFatalError("One or more clauses are defined multiple times on"
-                      " directive " +
-                      Dir.getRecordName());
-  }
-
-  return HasDuplicate;
-}
-
-// Check consitency of records. Return true if an error has been detected.
-// Return false if the records are valid.
-bool DirectiveLanguage::HasValidityErrors() const {
-  if (getDirectiveLanguages().size() != 1) {
-    PrintFatalError("A single definition of DirectiveLanguage is needed.");
-    return true;
-  }
-
-  return HasDuplicateClausesInDirectives(getDirectives());
-}
-
+// Generate enums for values that clauses can take. 
+// Also generate function declarations for get<Enum>Name(StringRef Str). 
+void GenerateEnumClauseVal(const std::vector<Record *> &Records, 
+                           raw_ostream &OS, const DirectiveLanguage &DirLang, 
+                           std::string &EnumHelperFuncs) { 
+  for (const auto &R : Records) { 
+    Clause C{R}; 
+    const auto &ClauseVals = C.getClauseVals(); 
+    if (ClauseVals.size() <= 0) 
+      continue; 
+ 
+    const auto &EnumName = C.getEnumName(); 
+    if (EnumName.size() == 0) { 
+      PrintError("enumClauseValue field not set in Clause" + 
+                 C.getFormattedName() + "."); 
+      return; 
+    } 
+ 
+    OS << "\n"; 
+    OS << "enum class " << EnumName << " {\n"; 
+    for (const auto &CV : ClauseVals) { 
+      ClauseVal CVal{CV}; 
+      OS << "  " << CV->getName() << "=" << CVal.getValue() << ",\n"; 
+    } 
+    OS << "};\n"; 
+ 
+    if (DirLang.hasMakeEnumAvailableInNamespace()) { 
+      OS << "\n"; 
+      for (const auto &CV : ClauseVals) { 
+        OS << "constexpr auto " << CV->getName() << " = " 
+           << "llvm::" << DirLang.getCppNamespace() << "::" << EnumName 
+           << "::" << CV->getName() << ";\n"; 
+      } 
+      EnumHelperFuncs += (llvm::Twine(EnumName) + llvm::Twine(" get") + 
+                          llvm::Twine(EnumName) + llvm::Twine("(StringRef);\n")) 
+                             .str(); 
+ 
+      EnumHelperFuncs += 
+          (llvm::Twine("llvm::StringRef get") + llvm::Twine(DirLang.getName()) + 
+           llvm::Twine(EnumName) + llvm::Twine("Name(") + 
+           llvm::Twine(EnumName) + llvm::Twine(");\n")) 
+              .str(); 
+    } 
+  } 
+} 
+ 
+bool HasDuplicateClauses(const std::vector<Record *> &Clauses, 
+                         const Directive &Directive, 
+                         llvm::StringSet<> &CrtClauses) { 
+  bool HasError = false; 
+  for (const auto &C : Clauses) { 
+    VersionedClause VerClause{C}; 
+    const auto insRes = CrtClauses.insert(VerClause.getClause().getName()); 
+    if (!insRes.second) { 
+      PrintError("Clause " + VerClause.getClause().getRecordName() + 
+                 " already defined on directive " + Directive.getRecordName()); 
+      HasError = true; 
+    } 
+  } 
+  return HasError; 
+} 
+ 
+// Check for duplicate clauses in lists. Clauses cannot appear twice in the 
+// three allowed list. Also, since required implies allowed, clauses cannot 
+// appear in both the allowedClauses and requiredClauses lists. 
+bool HasDuplicateClausesInDirectives(const std::vector<Record *> &Directives) { 
+  bool HasDuplicate = false; 
+  for (const auto &D : Directives) { 
+    Directive Dir{D}; 
+    llvm::StringSet<> Clauses; 
+    // Check for duplicates in the three allowed lists. 
+    if (HasDuplicateClauses(Dir.getAllowedClauses(), Dir, Clauses) || 
+        HasDuplicateClauses(Dir.getAllowedOnceClauses(), Dir, Clauses) || 
+        HasDuplicateClauses(Dir.getAllowedExclusiveClauses(), Dir, Clauses)) { 
+      HasDuplicate = true; 
+    } 
+    // Check for duplicate between allowedClauses and required 
+    Clauses.clear(); 
+    if (HasDuplicateClauses(Dir.getAllowedClauses(), Dir, Clauses) || 
+        HasDuplicateClauses(Dir.getRequiredClauses(), Dir, Clauses)) { 
+      HasDuplicate = true; 
+    } 
+    if (HasDuplicate) 
+      PrintFatalError("One or more clauses are defined multiple times on" 
+                      " directive " + 
+                      Dir.getRecordName()); 
+  } 
+ 
+  return HasDuplicate; 
+} 
+ 
+// Check consitency of records. Return true if an error has been detected. 
+// Return false if the records are valid. 
+bool DirectiveLanguage::HasValidityErrors() const { 
+  if (getDirectiveLanguages().size() != 1) { 
+    PrintFatalError("A single definition of DirectiveLanguage is needed."); 
+    return true; 
+  } 
+ 
+  return HasDuplicateClausesInDirectives(getDirectives()); 
+} 
+ 
 // Generate the declaration section for the enumeration in the directive
 // language
 void EmitDirectivesDecl(RecordKeeper &Records, raw_ostream &OS) {
-  const auto DirLang = DirectiveLanguage{Records};
-  if (DirLang.HasValidityErrors())
+  const auto DirLang = DirectiveLanguage{Records}; 
+  if (DirLang.HasValidityErrors()) 
     return;
 
-  OS << "#ifndef LLVM_" << DirLang.getName() << "_INC\n";
-  OS << "#define LLVM_" << DirLang.getName() << "_INC\n";
+  OS << "#ifndef LLVM_" << DirLang.getName() << "_INC\n"; 
+  OS << "#define LLVM_" << DirLang.getName() << "_INC\n"; 
 
-  if (DirLang.hasEnableBitmaskEnumInNamespace())
+  if (DirLang.hasEnableBitmaskEnumInNamespace()) 
     OS << "\n#include \"llvm/ADT/BitmaskEnum.h\"\n";
 
   OS << "\n";
@@ -192,48 +192,48 @@ void EmitDirectivesDecl(RecordKeeper &Records, raw_ostream &OS) {
 
   // Open namespaces defined in the directive language
   llvm::SmallVector<StringRef, 2> Namespaces;
-  llvm::SplitString(DirLang.getCppNamespace(), Namespaces, "::");
+  llvm::SplitString(DirLang.getCppNamespace(), Namespaces, "::"); 
   for (auto Ns : Namespaces)
     OS << "namespace " << Ns << " {\n";
 
-  if (DirLang.hasEnableBitmaskEnumInNamespace())
+  if (DirLang.hasEnableBitmaskEnumInNamespace()) 
     OS << "\nLLVM_ENABLE_BITMASK_ENUMS_IN_NAMESPACE();\n";
 
   // Emit Directive enumeration
-  GenerateEnumClass(DirLang.getDirectives(), OS, "Directive",
-                    DirLang.getDirectivePrefix(), DirLang);
+  GenerateEnumClass(DirLang.getDirectives(), OS, "Directive", 
+                    DirLang.getDirectivePrefix(), DirLang); 
 
   // Emit Clause enumeration
-  GenerateEnumClass(DirLang.getClauses(), OS, "Clause",
-                    DirLang.getClausePrefix(), DirLang);
-
-  // Emit ClauseVal enumeration
-  std::string EnumHelperFuncs;
-  GenerateEnumClauseVal(DirLang.getClauses(), OS, DirLang, EnumHelperFuncs);
+  GenerateEnumClass(DirLang.getClauses(), OS, "Clause", 
+                    DirLang.getClausePrefix(), DirLang); 
 
+  // Emit ClauseVal enumeration 
+  std::string EnumHelperFuncs; 
+  GenerateEnumClauseVal(DirLang.getClauses(), OS, DirLang, EnumHelperFuncs); 
+ 
   // Generic function signatures
   OS << "\n";
   OS << "// Enumeration helper functions\n";
-  OS << "Directive get" << DirLang.getName()
+  OS << "Directive get" << DirLang.getName() 
      << "DirectiveKind(llvm::StringRef Str);\n";
   OS << "\n";
-  OS << "llvm::StringRef get" << DirLang.getName()
+  OS << "llvm::StringRef get" << DirLang.getName() 
      << "DirectiveName(Directive D);\n";
   OS << "\n";
-  OS << "Clause get" << DirLang.getName()
-     << "ClauseKind(llvm::StringRef Str);\n";
+  OS << "Clause get" << DirLang.getName() 
+     << "ClauseKind(llvm::StringRef Str);\n"; 
   OS << "\n";
-  OS << "llvm::StringRef get" << DirLang.getName() << "ClauseName(Clause C);\n";
+  OS << "llvm::StringRef get" << DirLang.getName() << "ClauseName(Clause C);\n"; 
   OS << "\n";
   OS << "/// Return true if \\p C is a valid clause for \\p D in version \\p "
      << "Version.\n";
   OS << "bool isAllowedClauseForDirective(Directive D, "
      << "Clause C, unsigned Version);\n";
   OS << "\n";
-  if (EnumHelperFuncs.length() > 0) {
-    OS << EnumHelperFuncs;
-    OS << "\n";
-  }
+  if (EnumHelperFuncs.length() > 0) { 
+    OS << EnumHelperFuncs; 
+    OS << "\n"; 
+  } 
 
   // Closing namespaces
   for (auto Ns : llvm::reverse(Namespaces))
@@ -241,183 +241,183 @@ void EmitDirectivesDecl(RecordKeeper &Records, raw_ostream &OS) {
 
   OS << "} // namespace llvm\n";
 
-  OS << "#endif // LLVM_" << DirLang.getName() << "_INC\n";
+  OS << "#endif // LLVM_" << DirLang.getName() << "_INC\n"; 
 }
 
 // Generate function implementation for get<Enum>Name(StringRef Str)
 void GenerateGetName(const std::vector<Record *> &Records, raw_ostream &OS,
-                     StringRef Enum, const DirectiveLanguage &DirLang,
-                     StringRef Prefix) {
+                     StringRef Enum, const DirectiveLanguage &DirLang, 
+                     StringRef Prefix) { 
   OS << "\n";
-  OS << "llvm::StringRef llvm::" << DirLang.getCppNamespace() << "::get"
-     << DirLang.getName() << Enum << "Name(" << Enum << " Kind) {\n";
+  OS << "llvm::StringRef llvm::" << DirLang.getCppNamespace() << "::get" 
+     << DirLang.getName() << Enum << "Name(" << Enum << " Kind) {\n"; 
   OS << "  switch (Kind) {\n";
   for (const auto &R : Records) {
-    BaseRecord Rec{R};
-    OS << "    case " << Prefix << Rec.getFormattedName() << ":\n";
+    BaseRecord Rec{R}; 
+    OS << "    case " << Prefix << Rec.getFormattedName() << ":\n"; 
     OS << "      return \"";
-    if (Rec.getAlternativeName().empty())
-      OS << Rec.getName();
+    if (Rec.getAlternativeName().empty()) 
+      OS << Rec.getName(); 
     else
-      OS << Rec.getAlternativeName();
+      OS << Rec.getAlternativeName(); 
     OS << "\";\n";
   }
   OS << "  }\n"; // switch
-  OS << "  llvm_unreachable(\"Invalid " << DirLang.getName() << " " << Enum
+  OS << "  llvm_unreachable(\"Invalid " << DirLang.getName() << " " << Enum 
      << " kind\");\n";
   OS << "}\n";
 }
 
 // Generate function implementation for get<Enum>Kind(StringRef Str)
 void GenerateGetKind(const std::vector<Record *> &Records, raw_ostream &OS,
-                     StringRef Enum, const DirectiveLanguage &DirLang,
-                     StringRef Prefix, bool ImplicitAsUnknown) {
+                     StringRef Enum, const DirectiveLanguage &DirLang, 
+                     StringRef Prefix, bool ImplicitAsUnknown) { 
 
-  auto DefaultIt = llvm::find_if(
-      Records, [](Record *R) { return R->getValueAsBit("isDefault") == true; });
+  auto DefaultIt = llvm::find_if( 
+      Records, [](Record *R) { return R->getValueAsBit("isDefault") == true; }); 
 
   if (DefaultIt == Records.end()) {
-    PrintError("At least one " + Enum + " must be defined as default.");
+    PrintError("At least one " + Enum + " must be defined as default."); 
     return;
   }
 
-  BaseRecord DefaultRec{(*DefaultIt)};
+  BaseRecord DefaultRec{(*DefaultIt)}; 
 
   OS << "\n";
-  OS << Enum << " llvm::" << DirLang.getCppNamespace() << "::get"
-     << DirLang.getName() << Enum << "Kind(llvm::StringRef Str) {\n";
+  OS << Enum << " llvm::" << DirLang.getCppNamespace() << "::get" 
+     << DirLang.getName() << Enum << "Kind(llvm::StringRef Str) {\n"; 
   OS << "  return llvm::StringSwitch<" << Enum << ">(Str)\n";
 
   for (const auto &R : Records) {
-    BaseRecord Rec{R};
+    BaseRecord Rec{R}; 
     if (ImplicitAsUnknown && R->getValueAsBit("isImplicit")) {
-      OS << "    .Case(\"" << Rec.getName() << "\"," << Prefix
-         << DefaultRec.getFormattedName() << ")\n";
+      OS << "    .Case(\"" << Rec.getName() << "\"," << Prefix 
+         << DefaultRec.getFormattedName() << ")\n"; 
     } else {
-      OS << "    .Case(\"" << Rec.getName() << "\"," << Prefix
-         << Rec.getFormattedName() << ")\n";
+      OS << "    .Case(\"" << Rec.getName() << "\"," << Prefix 
+         << Rec.getFormattedName() << ")\n"; 
     }
   }
-  OS << "    .Default(" << Prefix << DefaultRec.getFormattedName() << ");\n";
+  OS << "    .Default(" << Prefix << DefaultRec.getFormattedName() << ");\n"; 
   OS << "}\n";
 }
 
-// Generate function implementation for get<ClauseVal>Kind(StringRef Str)
-void GenerateGetKindClauseVal(const DirectiveLanguage &DirLang,
-                              raw_ostream &OS) {
-  for (const auto &R : DirLang.getClauses()) {
-    Clause C{R};
-    const auto &ClauseVals = C.getClauseVals();
-    if (ClauseVals.size() <= 0)
-      continue;
-
-    auto DefaultIt = llvm::find_if(ClauseVals, [](Record *CV) {
-      return CV->getValueAsBit("isDefault") == true;
-    });
-
-    if (DefaultIt == ClauseVals.end()) {
-      PrintError("At least one val in Clause " + C.getFormattedName() +
-                 " must be defined as default.");
-      return;
-    }
-    const auto DefaultName = (*DefaultIt)->getName();
-
-    const auto &EnumName = C.getEnumName();
-    if (EnumName.size() == 0) {
-      PrintError("enumClauseValue field not set in Clause" +
-                 C.getFormattedName() + ".");
-      return;
-    }
-
-    OS << "\n";
-    OS << EnumName << " llvm::" << DirLang.getCppNamespace() << "::get"
-       << EnumName << "(llvm::StringRef Str) {\n";
-    OS << "  return llvm::StringSwitch<" << EnumName << ">(Str)\n";
-    for (const auto &CV : ClauseVals) {
-      ClauseVal CVal{CV};
-      OS << "    .Case(\"" << CVal.getFormattedName() << "\"," << CV->getName()
-         << ")\n";
-    }
-    OS << "    .Default(" << DefaultName << ");\n";
-    OS << "}\n";
-
-    OS << "\n";
-    OS << "llvm::StringRef llvm::" << DirLang.getCppNamespace() << "::get"
-       << DirLang.getName() << EnumName
-       << "Name(llvm::" << DirLang.getCppNamespace() << "::" << EnumName
-       << " x) {\n";
-    OS << "  switch (x) {\n";
-    for (const auto &CV : ClauseVals) {
-      ClauseVal CVal{CV};
-      OS << "    case " << CV->getName() << ":\n";
-      OS << "      return \"" << CVal.getFormattedName() << "\";\n";
-    }
-    OS << "  }\n"; // switch
-    OS << "  llvm_unreachable(\"Invalid " << DirLang.getName() << " "
-       << EnumName << " kind\");\n";
-    OS << "}\n";
-  }
-}
-
+// Generate function implementation for get<ClauseVal>Kind(StringRef Str) 
+void GenerateGetKindClauseVal(const DirectiveLanguage &DirLang, 
+                              raw_ostream &OS) { 
+  for (const auto &R : DirLang.getClauses()) { 
+    Clause C{R}; 
+    const auto &ClauseVals = C.getClauseVals(); 
+    if (ClauseVals.size() <= 0) 
+      continue; 
+ 
+    auto DefaultIt = llvm::find_if(ClauseVals, [](Record *CV) { 
+      return CV->getValueAsBit("isDefault") == true; 
+    }); 
+ 
+    if (DefaultIt == ClauseVals.end()) { 
+      PrintError("At least one val in Clause " + C.getFormattedName() + 
+                 " must be defined as default."); 
+      return; 
+    } 
+    const auto DefaultName = (*DefaultIt)->getName(); 
+ 
+    const auto &EnumName = C.getEnumName(); 
+    if (EnumName.size() == 0) { 
+      PrintError("enumClauseValue field not set in Clause" + 
+                 C.getFormattedName() + "."); 
+      return; 
+    } 
+ 
+    OS << "\n"; 
+    OS << EnumName << " llvm::" << DirLang.getCppNamespace() << "::get" 
+       << EnumName << "(llvm::StringRef Str) {\n"; 
+    OS << "  return llvm::StringSwitch<" << EnumName << ">(Str)\n"; 
+    for (const auto &CV : ClauseVals) { 
+      ClauseVal CVal{CV}; 
+      OS << "    .Case(\"" << CVal.getFormattedName() << "\"," << CV->getName() 
+         << ")\n"; 
+    } 
+    OS << "    .Default(" << DefaultName << ");\n"; 
+    OS << "}\n"; 
+ 
+    OS << "\n"; 
+    OS << "llvm::StringRef llvm::" << DirLang.getCppNamespace() << "::get" 
+       << DirLang.getName() << EnumName 
+       << "Name(llvm::" << DirLang.getCppNamespace() << "::" << EnumName 
+       << " x) {\n"; 
+    OS << "  switch (x) {\n"; 
+    for (const auto &CV : ClauseVals) { 
+      ClauseVal CVal{CV}; 
+      OS << "    case " << CV->getName() << ":\n"; 
+      OS << "      return \"" << CVal.getFormattedName() << "\";\n"; 
+    } 
+    OS << "  }\n"; // switch 
+    OS << "  llvm_unreachable(\"Invalid " << DirLang.getName() << " " 
+       << EnumName << " kind\");\n"; 
+    OS << "}\n"; 
+  } 
+} 
+ 
 void GenerateCaseForVersionedClauses(const std::vector<Record *> &Clauses,
                                      raw_ostream &OS, StringRef DirectiveName,
-                                     const DirectiveLanguage &DirLang,
+                                     const DirectiveLanguage &DirLang, 
                                      llvm::StringSet<> &Cases) {
   for (const auto &C : Clauses) {
-    VersionedClause VerClause{C};
-
-    const auto ClauseFormattedName = VerClause.getClause().getFormattedName();
-
-    if (Cases.find(ClauseFormattedName) == Cases.end()) {
-      Cases.insert(ClauseFormattedName);
-      OS << "        case " << DirLang.getClausePrefix() << ClauseFormattedName
-         << ":\n";
-      OS << "          return " << VerClause.getMinVersion()
-         << " <= Version && " << VerClause.getMaxVersion() << " >= Version;\n";
+    VersionedClause VerClause{C}; 
+
+    const auto ClauseFormattedName = VerClause.getClause().getFormattedName(); 
+ 
+    if (Cases.find(ClauseFormattedName) == Cases.end()) { 
+      Cases.insert(ClauseFormattedName); 
+      OS << "        case " << DirLang.getClausePrefix() << ClauseFormattedName 
+         << ":\n"; 
+      OS << "          return " << VerClause.getMinVersion() 
+         << " <= Version && " << VerClause.getMaxVersion() << " >= Version;\n"; 
     }
   }
 }
 
 // Generate the isAllowedClauseForDirective function implementation.
-void GenerateIsAllowedClause(const DirectiveLanguage &DirLang,
-                             raw_ostream &OS) {
+void GenerateIsAllowedClause(const DirectiveLanguage &DirLang, 
+                             raw_ostream &OS) { 
   OS << "\n";
-  OS << "bool llvm::" << DirLang.getCppNamespace()
-     << "::isAllowedClauseForDirective("
+  OS << "bool llvm::" << DirLang.getCppNamespace() 
+     << "::isAllowedClauseForDirective(" 
      << "Directive D, Clause C, unsigned Version) {\n";
-  OS << "  assert(unsigned(D) <= llvm::" << DirLang.getCppNamespace()
+  OS << "  assert(unsigned(D) <= llvm::" << DirLang.getCppNamespace() 
      << "::Directive_enumSize);\n";
-  OS << "  assert(unsigned(C) <= llvm::" << DirLang.getCppNamespace()
+  OS << "  assert(unsigned(C) <= llvm::" << DirLang.getCppNamespace() 
      << "::Clause_enumSize);\n";
 
   OS << "  switch (D) {\n";
 
-  for (const auto &D : DirLang.getDirectives()) {
-    Directive Dir{D};
+  for (const auto &D : DirLang.getDirectives()) { 
+    Directive Dir{D}; 
 
-    OS << "    case " << DirLang.getDirectivePrefix() << Dir.getFormattedName()
+    OS << "    case " << DirLang.getDirectivePrefix() << Dir.getFormattedName() 
        << ":\n";
-    if (Dir.getAllowedClauses().size() == 0 &&
-        Dir.getAllowedOnceClauses().size() == 0 &&
-        Dir.getAllowedExclusiveClauses().size() == 0 &&
-        Dir.getRequiredClauses().size() == 0) {
+    if (Dir.getAllowedClauses().size() == 0 && 
+        Dir.getAllowedOnceClauses().size() == 0 && 
+        Dir.getAllowedExclusiveClauses().size() == 0 && 
+        Dir.getRequiredClauses().size() == 0) { 
       OS << "      return false;\n";
     } else {
       OS << "      switch (C) {\n";
 
       llvm::StringSet<> Cases;
 
-      GenerateCaseForVersionedClauses(Dir.getAllowedClauses(), OS,
-                                      Dir.getName(), DirLang, Cases);
+      GenerateCaseForVersionedClauses(Dir.getAllowedClauses(), OS, 
+                                      Dir.getName(), DirLang, Cases); 
 
-      GenerateCaseForVersionedClauses(Dir.getAllowedOnceClauses(), OS,
-                                      Dir.getName(), DirLang, Cases);
+      GenerateCaseForVersionedClauses(Dir.getAllowedOnceClauses(), OS, 
+                                      Dir.getName(), DirLang, Cases); 
 
-      GenerateCaseForVersionedClauses(Dir.getAllowedExclusiveClauses(), OS,
-                                      Dir.getName(), DirLang, Cases);
+      GenerateCaseForVersionedClauses(Dir.getAllowedExclusiveClauses(), OS, 
+                                      Dir.getName(), DirLang, Cases); 
 
-      GenerateCaseForVersionedClauses(Dir.getRequiredClauses(), OS,
-                                      Dir.getName(), DirLang, Cases);
+      GenerateCaseForVersionedClauses(Dir.getRequiredClauses(), OS, 
+                                      Dir.getName(), DirLang, Cases); 
 
       OS << "        default:\n";
       OS << "          return false;\n";
@@ -427,32 +427,32 @@ void GenerateIsAllowedClause(const DirectiveLanguage &DirLang,
   }
 
   OS << "  }\n"; // End of directives switch
-  OS << "  llvm_unreachable(\"Invalid " << DirLang.getName()
+  OS << "  llvm_unreachable(\"Invalid " << DirLang.getName() 
      << " Directive kind\");\n";
   OS << "}\n"; // End of function isAllowedClauseForDirective
 }
 
 // Generate a simple enum set with the give clauses.
 void GenerateClauseSet(const std::vector<Record *> &Clauses, raw_ostream &OS,
-                       StringRef ClauseSetPrefix, Directive &Dir,
-                       const DirectiveLanguage &DirLang) {
+                       StringRef ClauseSetPrefix, Directive &Dir, 
+                       const DirectiveLanguage &DirLang) { 
 
   OS << "\n";
-  OS << "  static " << DirLang.getClauseEnumSetClass() << " " << ClauseSetPrefix
-     << DirLang.getDirectivePrefix() << Dir.getFormattedName() << " {\n";
+  OS << "  static " << DirLang.getClauseEnumSetClass() << " " << ClauseSetPrefix 
+     << DirLang.getDirectivePrefix() << Dir.getFormattedName() << " {\n"; 
 
   for (const auto &C : Clauses) {
-    VersionedClause VerClause{C};
-    OS << "    llvm::" << DirLang.getCppNamespace()
-       << "::Clause::" << DirLang.getClausePrefix()
-       << VerClause.getClause().getFormattedName() << ",\n";
+    VersionedClause VerClause{C}; 
+    OS << "    llvm::" << DirLang.getCppNamespace() 
+       << "::Clause::" << DirLang.getClausePrefix() 
+       << VerClause.getClause().getFormattedName() << ",\n"; 
   }
   OS << "  };\n";
 }
 
 // Generate an enum set for the 4 kinds of clauses linked to a directive.
-void GenerateDirectiveClauseSets(const DirectiveLanguage &DirLang,
-                                 raw_ostream &OS) {
+void GenerateDirectiveClauseSets(const DirectiveLanguage &DirLang, 
+                                 raw_ostream &OS) { 
 
   IfDefScope Scope("GEN_FLANG_DIRECTIVE_CLAUSE_SETS", OS);
 
@@ -461,24 +461,24 @@ void GenerateDirectiveClauseSets(const DirectiveLanguage &DirLang,
 
   // Open namespaces defined in the directive language.
   llvm::SmallVector<StringRef, 2> Namespaces;
-  llvm::SplitString(DirLang.getCppNamespace(), Namespaces, "::");
+  llvm::SplitString(DirLang.getCppNamespace(), Namespaces, "::"); 
   for (auto Ns : Namespaces)
     OS << "namespace " << Ns << " {\n";
 
-  for (const auto &D : DirLang.getDirectives()) {
-    Directive Dir{D};
+  for (const auto &D : DirLang.getDirectives()) { 
+    Directive Dir{D}; 
 
     OS << "\n";
-    OS << "  // Sets for " << Dir.getName() << "\n";
-
-    GenerateClauseSet(Dir.getAllowedClauses(), OS, "allowedClauses_", Dir,
-                      DirLang);
-    GenerateClauseSet(Dir.getAllowedOnceClauses(), OS, "allowedOnceClauses_",
-                      Dir, DirLang);
-    GenerateClauseSet(Dir.getAllowedExclusiveClauses(), OS,
-                      "allowedExclusiveClauses_", Dir, DirLang);
-    GenerateClauseSet(Dir.getRequiredClauses(), OS, "requiredClauses_", Dir,
-                      DirLang);
+    OS << "  // Sets for " << Dir.getName() << "\n"; 
+
+    GenerateClauseSet(Dir.getAllowedClauses(), OS, "allowedClauses_", Dir, 
+                      DirLang); 
+    GenerateClauseSet(Dir.getAllowedOnceClauses(), OS, "allowedOnceClauses_", 
+                      Dir, DirLang); 
+    GenerateClauseSet(Dir.getAllowedExclusiveClauses(), OS, 
+                      "allowedExclusiveClauses_", Dir, DirLang); 
+    GenerateClauseSet(Dir.getRequiredClauses(), OS, "requiredClauses_", Dir, 
+                      DirLang); 
   }
 
   // Closing namespaces
@@ -491,286 +491,286 @@ void GenerateDirectiveClauseSets(const DirectiveLanguage &DirLang,
 // Generate a map of directive (key) with DirectiveClauses struct as values.
 // The struct holds the 4 sets of enumeration for the 4 kinds of clauses
 // allowances (allowed, allowed once, allowed exclusive and required).
-void GenerateDirectiveClauseMap(const DirectiveLanguage &DirLang,
-                                raw_ostream &OS) {
+void GenerateDirectiveClauseMap(const DirectiveLanguage &DirLang, 
+                                raw_ostream &OS) { 
 
   IfDefScope Scope("GEN_FLANG_DIRECTIVE_CLAUSE_MAP", OS);
 
   OS << "\n";
-  OS << "{\n";
+  OS << "{\n"; 
 
-  for (const auto &D : DirLang.getDirectives()) {
-    Directive Dir{D};
-    OS << "  {llvm::" << DirLang.getCppNamespace()
-       << "::Directive::" << DirLang.getDirectivePrefix()
-       << Dir.getFormattedName() << ",\n";
+  for (const auto &D : DirLang.getDirectives()) { 
+    Directive Dir{D}; 
+    OS << "  {llvm::" << DirLang.getCppNamespace() 
+       << "::Directive::" << DirLang.getDirectivePrefix() 
+       << Dir.getFormattedName() << ",\n"; 
     OS << "    {\n";
-    OS << "      llvm::" << DirLang.getCppNamespace() << "::allowedClauses_"
-       << DirLang.getDirectivePrefix() << Dir.getFormattedName() << ",\n";
-    OS << "      llvm::" << DirLang.getCppNamespace() << "::allowedOnceClauses_"
-       << DirLang.getDirectivePrefix() << Dir.getFormattedName() << ",\n";
-    OS << "      llvm::" << DirLang.getCppNamespace()
-       << "::allowedExclusiveClauses_" << DirLang.getDirectivePrefix()
-       << Dir.getFormattedName() << ",\n";
-    OS << "      llvm::" << DirLang.getCppNamespace() << "::requiredClauses_"
-       << DirLang.getDirectivePrefix() << Dir.getFormattedName() << ",\n";
+    OS << "      llvm::" << DirLang.getCppNamespace() << "::allowedClauses_" 
+       << DirLang.getDirectivePrefix() << Dir.getFormattedName() << ",\n"; 
+    OS << "      llvm::" << DirLang.getCppNamespace() << "::allowedOnceClauses_" 
+       << DirLang.getDirectivePrefix() << Dir.getFormattedName() << ",\n"; 
+    OS << "      llvm::" << DirLang.getCppNamespace() 
+       << "::allowedExclusiveClauses_" << DirLang.getDirectivePrefix() 
+       << Dir.getFormattedName() << ",\n"; 
+    OS << "      llvm::" << DirLang.getCppNamespace() << "::requiredClauses_" 
+       << DirLang.getDirectivePrefix() << Dir.getFormattedName() << ",\n"; 
     OS << "    }\n";
     OS << "  },\n";
   }
 
-  OS << "}\n";
-}
-
-// Generate classes entry for Flang clauses in the Flang parse-tree
-// If the clause as a non-generic class, no entry is generated.
-// If the clause does not hold a value, an EMPTY_CLASS is used.
-// If the clause class is generic then a WRAPPER_CLASS is used. When the value
-// is optional, the value class is wrapped into a std::optional.
-void GenerateFlangClauseParserClass(const DirectiveLanguage &DirLang,
-                                    raw_ostream &OS) {
-
-  IfDefScope Scope("GEN_FLANG_CLAUSE_PARSER_CLASSES", OS);
-
-  OS << "\n";
-
-  for (const auto &C : DirLang.getClauses()) {
-    Clause Clause{C};
-    if (!Clause.getFlangClass().empty()) {
-      OS << "WRAPPER_CLASS(" << Clause.getFormattedParserClassName() << ", ";
-      if (Clause.isValueOptional() && Clause.isValueList()) {
-        OS << "std::optional<std::list<" << Clause.getFlangClass() << ">>";
-      } else if (Clause.isValueOptional()) {
-        OS << "std::optional<" << Clause.getFlangClass() << ">";
-      } else if (Clause.isValueList()) {
-        OS << "std::list<" << Clause.getFlangClass() << ">";
-      } else {
-        OS << Clause.getFlangClass();
-      }
-    } else {
-      OS << "EMPTY_CLASS(" << Clause.getFormattedParserClassName();
-    }
-    OS << ");\n";
-  }
-}
-
-// Generate a list of the different clause classes for Flang.
-void GenerateFlangClauseParserClassList(const DirectiveLanguage &DirLang,
-                                        raw_ostream &OS) {
-
-  IfDefScope Scope("GEN_FLANG_CLAUSE_PARSER_CLASSES_LIST", OS);
-
-  OS << "\n";
-  llvm::interleaveComma(DirLang.getClauses(), OS, [&](Record *C) {
-    Clause Clause{C};
-    OS << Clause.getFormattedParserClassName() << "\n";
-  });
+  OS << "}\n"; 
 }
 
-// Generate dump node list for the clauses holding a generic class name.
-void GenerateFlangClauseDump(const DirectiveLanguage &DirLang,
-                             raw_ostream &OS) {
-
-  IfDefScope Scope("GEN_FLANG_DUMP_PARSE_TREE_CLAUSES", OS);
-
-  OS << "\n";
-  for (const auto &C : DirLang.getClauses()) {
-    Clause Clause{C};
-    OS << "NODE(" << DirLang.getFlangClauseBaseClass() << ", "
-       << Clause.getFormattedParserClassName() << ")\n";
-  }
+// Generate classes entry for Flang clauses in the Flang parse-tree 
+// If the clause as a non-generic class, no entry is generated. 
+// If the clause does not hold a value, an EMPTY_CLASS is used. 
+// If the clause class is generic then a WRAPPER_CLASS is used. When the value 
+// is optional, the value class is wrapped into a std::optional. 
+void GenerateFlangClauseParserClass(const DirectiveLanguage &DirLang, 
+                                    raw_ostream &OS) { 
+
+  IfDefScope Scope("GEN_FLANG_CLAUSE_PARSER_CLASSES", OS); 
+
+  OS << "\n"; 
+ 
+  for (const auto &C : DirLang.getClauses()) { 
+    Clause Clause{C}; 
+    if (!Clause.getFlangClass().empty()) { 
+      OS << "WRAPPER_CLASS(" << Clause.getFormattedParserClassName() << ", "; 
+      if (Clause.isValueOptional() && Clause.isValueList()) { 
+        OS << "std::optional<std::list<" << Clause.getFlangClass() << ">>"; 
+      } else if (Clause.isValueOptional()) { 
+        OS << "std::optional<" << Clause.getFlangClass() << ">"; 
+      } else if (Clause.isValueList()) { 
+        OS << "std::list<" << Clause.getFlangClass() << ">"; 
+      } else { 
+        OS << Clause.getFlangClass(); 
+      } 
+    } else { 
+      OS << "EMPTY_CLASS(" << Clause.getFormattedParserClassName(); 
+    } 
+    OS << ");\n"; 
+  } 
 }
 
-// Generate Unparse functions for clauses classes in the Flang parse-tree
-// If the clause is a non-generic class, no entry is generated.
-void GenerateFlangClauseUnparse(const DirectiveLanguage &DirLang,
-                                raw_ostream &OS) {
-
-  IfDefScope Scope("GEN_FLANG_CLAUSE_UNPARSE", OS);
-
-  OS << "\n";
-
-  for (const auto &C : DirLang.getClauses()) {
-    Clause Clause{C};
-    if (!Clause.getFlangClass().empty()) {
-      if (Clause.isValueOptional() && Clause.getDefaultValue().empty()) {
-        OS << "void Unparse(const " << DirLang.getFlangClauseBaseClass()
-           << "::" << Clause.getFormattedParserClassName() << " &x) {\n";
-        OS << "  Word(\"" << Clause.getName().upper() << "\");\n";
-
-        OS << "  Walk(\"(\", x.v, \")\");\n";
-        OS << "}\n";
-      } else if (Clause.isValueOptional()) {
-        OS << "void Unparse(const " << DirLang.getFlangClauseBaseClass()
-           << "::" << Clause.getFormattedParserClassName() << " &x) {\n";
-        OS << "  Word(\"" << Clause.getName().upper() << "\");\n";
-        OS << "  Put(\"(\");\n";
-        OS << "  if (x.v.has_value())\n";
-        if (Clause.isValueList())
-          OS << "    Walk(x.v, \",\");\n";
-        else
-          OS << "    Walk(x.v);\n";
-        OS << "  else\n";
-        OS << "    Put(\"" << Clause.getDefaultValue() << "\");\n";
-        OS << "  Put(\")\");\n";
-        OS << "}\n";
-      } else {
-        OS << "void Unparse(const " << DirLang.getFlangClauseBaseClass()
-           << "::" << Clause.getFormattedParserClassName() << " &x) {\n";
-        OS << "  Word(\"" << Clause.getName().upper() << "\");\n";
-        OS << "  Put(\"(\");\n";
-        if (Clause.isValueList())
-          OS << "  Walk(x.v, \",\");\n";
-        else
-          OS << "  Walk(x.v);\n";
-        OS << "  Put(\")\");\n";
-        OS << "}\n";
-      }
-    } else {
-      OS << "void Before(const " << DirLang.getFlangClauseBaseClass()
-         << "::" << Clause.getFormattedParserClassName() << " &) { Word(\""
-         << Clause.getName().upper() << "\"); }\n";
-    }
+// Generate a list of the different clause classes for Flang. 
+void GenerateFlangClauseParserClassList(const DirectiveLanguage &DirLang, 
+                                        raw_ostream &OS) { 
+
+  IfDefScope Scope("GEN_FLANG_CLAUSE_PARSER_CLASSES_LIST", OS); 
+
+  OS << "\n"; 
+  llvm::interleaveComma(DirLang.getClauses(), OS, [&](Record *C) { 
+    Clause Clause{C}; 
+    OS << Clause.getFormattedParserClassName() << "\n"; 
+  }); 
+} 
+ 
+// Generate dump node list for the clauses holding a generic class name. 
+void GenerateFlangClauseDump(const DirectiveLanguage &DirLang, 
+                             raw_ostream &OS) { 
+ 
+  IfDefScope Scope("GEN_FLANG_DUMP_PARSE_TREE_CLAUSES", OS); 
+ 
+  OS << "\n"; 
+  for (const auto &C : DirLang.getClauses()) { 
+    Clause Clause{C}; 
+    OS << "NODE(" << DirLang.getFlangClauseBaseClass() << ", " 
+       << Clause.getFormattedParserClassName() << ")\n"; 
   }
+} 
+
+// Generate Unparse functions for clauses classes in the Flang parse-tree 
+// If the clause is a non-generic class, no entry is generated. 
+void GenerateFlangClauseUnparse(const DirectiveLanguage &DirLang, 
+                                raw_ostream &OS) { 
+
+  IfDefScope Scope("GEN_FLANG_CLAUSE_UNPARSE", OS); 
+
+  OS << "\n"; 
+ 
+  for (const auto &C : DirLang.getClauses()) { 
+    Clause Clause{C}; 
+    if (!Clause.getFlangClass().empty()) { 
+      if (Clause.isValueOptional() && Clause.getDefaultValue().empty()) { 
+        OS << "void Unparse(const " << DirLang.getFlangClauseBaseClass() 
+           << "::" << Clause.getFormattedParserClassName() << " &x) {\n"; 
+        OS << "  Word(\"" << Clause.getName().upper() << "\");\n"; 
+ 
+        OS << "  Walk(\"(\", x.v, \")\");\n"; 
+        OS << "}\n"; 
+      } else if (Clause.isValueOptional()) { 
+        OS << "void Unparse(const " << DirLang.getFlangClauseBaseClass() 
+           << "::" << Clause.getFormattedParserClassName() << " &x) {\n"; 
+        OS << "  Word(\"" << Clause.getName().upper() << "\");\n"; 
+        OS << "  Put(\"(\");\n"; 
+        OS << "  if (x.v.has_value())\n"; 
+        if (Clause.isValueList()) 
+          OS << "    Walk(x.v, \",\");\n"; 
+        else 
+          OS << "    Walk(x.v);\n"; 
+        OS << "  else\n"; 
+        OS << "    Put(\"" << Clause.getDefaultValue() << "\");\n"; 
+        OS << "  Put(\")\");\n"; 
+        OS << "}\n"; 
+      } else { 
+        OS << "void Unparse(const " << DirLang.getFlangClauseBaseClass() 
+           << "::" << Clause.getFormattedParserClassName() << " &x) {\n"; 
+        OS << "  Word(\"" << Clause.getName().upper() << "\");\n"; 
+        OS << "  Put(\"(\");\n"; 
+        if (Clause.isValueList()) 
+          OS << "  Walk(x.v, \",\");\n"; 
+        else 
+          OS << "  Walk(x.v);\n"; 
+        OS << "  Put(\")\");\n"; 
+        OS << "}\n"; 
+      } 
+    } else { 
+      OS << "void Before(const " << DirLang.getFlangClauseBaseClass() 
+         << "::" << Clause.getFormattedParserClassName() << " &) { Word(\"" 
+         << Clause.getName().upper() << "\"); }\n"; 
+    } 
+  } 
 }
 
-// Generate the implementation section for the enumeration in the directive
-// language
-void EmitDirectivesFlangImpl(const DirectiveLanguage &DirLang,
-                             raw_ostream &OS) {
-
-  GenerateDirectiveClauseSets(DirLang, OS);
-
-  GenerateDirectiveClauseMap(DirLang, OS);
-
-  GenerateFlangClauseParserClass(DirLang, OS);
-
-  GenerateFlangClauseParserClassList(DirLang, OS);
-
-  GenerateFlangClauseDump(DirLang, OS);
-
-  GenerateFlangClauseUnparse(DirLang, OS);
-}
-
-void GenerateClauseClassMacro(const DirectiveLanguage &DirLang,
-                              raw_ostream &OS) {
-  // Generate macros style information for legacy code in clang
-  IfDefScope Scope("GEN_CLANG_CLAUSE_CLASS", OS);
-
-  OS << "\n";
-
-  OS << "#ifndef CLAUSE\n";
-  OS << "#define CLAUSE(Enum, Str, Implicit)\n";
-  OS << "#endif\n";
-  OS << "#ifndef CLAUSE_CLASS\n";
-  OS << "#define CLAUSE_CLASS(Enum, Str, Class)\n";
-  OS << "#endif\n";
-  OS << "#ifndef CLAUSE_NO_CLASS\n";
-  OS << "#define CLAUSE_NO_CLASS(Enum, Str)\n";
-  OS << "#endif\n";
-  OS << "\n";
-  OS << "#define __CLAUSE(Name, Class)                      \\\n";
-  OS << "  CLAUSE(" << DirLang.getClausePrefix()
-     << "##Name, #Name, /* Implicit */ false) \\\n";
-  OS << "  CLAUSE_CLASS(" << DirLang.getClausePrefix()
-     << "##Name, #Name, Class)\n";
-  OS << "#define __CLAUSE_NO_CLASS(Name)                    \\\n";
-  OS << "  CLAUSE(" << DirLang.getClausePrefix()
-     << "##Name, #Name, /* Implicit */ false) \\\n";
-  OS << "  CLAUSE_NO_CLASS(" << DirLang.getClausePrefix() << "##Name, #Name)\n";
-  OS << "#define __IMPLICIT_CLAUSE_CLASS(Name, Str, Class)  \\\n";
-  OS << "  CLAUSE(" << DirLang.getClausePrefix()
-     << "##Name, Str, /* Implicit */ true)    \\\n";
-  OS << "  CLAUSE_CLASS(" << DirLang.getClausePrefix()
-     << "##Name, Str, Class)\n";
-  OS << "#define __IMPLICIT_CLAUSE_NO_CLASS(Name, Str)      \\\n";
-  OS << "  CLAUSE(" << DirLang.getClausePrefix()
-     << "##Name, Str, /* Implicit */ true)    \\\n";
-  OS << "  CLAUSE_NO_CLASS(" << DirLang.getClausePrefix() << "##Name, Str)\n";
-  OS << "\n";
-
-  for (const auto &R : DirLang.getClauses()) {
-    Clause C{R};
-    if (C.getClangClass().empty()) { // NO_CLASS
-      if (C.isImplicit()) {
-        OS << "__IMPLICIT_CLAUSE_NO_CLASS(" << C.getFormattedName() << ", \""
-           << C.getFormattedName() << "\")\n";
-      } else {
-        OS << "__CLAUSE_NO_CLASS(" << C.getFormattedName() << ")\n";
-      }
-    } else { // CLASS
-      if (C.isImplicit()) {
-        OS << "__IMPLICIT_CLAUSE_CLASS(" << C.getFormattedName() << ", \""
-           << C.getFormattedName() << "\", " << C.getClangClass() << ")\n";
-      } else {
-        OS << "__CLAUSE(" << C.getFormattedName() << ", " << C.getClangClass()
-           << ")\n";
-      }
-    }
+// Generate the implementation section for the enumeration in the directive 
+// language 
+void EmitDirectivesFlangImpl(const DirectiveLanguage &DirLang, 
+                             raw_ostream &OS) { 
+
+  GenerateDirectiveClauseSets(DirLang, OS); 
+
+  GenerateDirectiveClauseMap(DirLang, OS); 
+ 
+  GenerateFlangClauseParserClass(DirLang, OS); 
+ 
+  GenerateFlangClauseParserClassList(DirLang, OS); 
+ 
+  GenerateFlangClauseDump(DirLang, OS); 
+ 
+  GenerateFlangClauseUnparse(DirLang, OS); 
+} 
+ 
+void GenerateClauseClassMacro(const DirectiveLanguage &DirLang, 
+                              raw_ostream &OS) { 
+  // Generate macros style information for legacy code in clang 
+  IfDefScope Scope("GEN_CLANG_CLAUSE_CLASS", OS); 
+ 
+  OS << "\n"; 
+ 
+  OS << "#ifndef CLAUSE\n"; 
+  OS << "#define CLAUSE(Enum, Str, Implicit)\n"; 
+  OS << "#endif\n"; 
+  OS << "#ifndef CLAUSE_CLASS\n"; 
+  OS << "#define CLAUSE_CLASS(Enum, Str, Class)\n"; 
+  OS << "#endif\n"; 
+  OS << "#ifndef CLAUSE_NO_CLASS\n"; 
+  OS << "#define CLAUSE_NO_CLASS(Enum, Str)\n"; 
+  OS << "#endif\n"; 
+  OS << "\n"; 
+  OS << "#define __CLAUSE(Name, Class)                      \\\n"; 
+  OS << "  CLAUSE(" << DirLang.getClausePrefix() 
+     << "##Name, #Name, /* Implicit */ false) \\\n"; 
+  OS << "  CLAUSE_CLASS(" << DirLang.getClausePrefix() 
+     << "##Name, #Name, Class)\n"; 
+  OS << "#define __CLAUSE_NO_CLASS(Name)                    \\\n"; 
+  OS << "  CLAUSE(" << DirLang.getClausePrefix() 
+     << "##Name, #Name, /* Implicit */ false) \\\n"; 
+  OS << "  CLAUSE_NO_CLASS(" << DirLang.getClausePrefix() << "##Name, #Name)\n"; 
+  OS << "#define __IMPLICIT_CLAUSE_CLASS(Name, Str, Class)  \\\n"; 
+  OS << "  CLAUSE(" << DirLang.getClausePrefix() 
+     << "##Name, Str, /* Implicit */ true)    \\\n"; 
+  OS << "  CLAUSE_CLASS(" << DirLang.getClausePrefix() 
+     << "##Name, Str, Class)\n"; 
+  OS << "#define __IMPLICIT_CLAUSE_NO_CLASS(Name, Str)      \\\n"; 
+  OS << "  CLAUSE(" << DirLang.getClausePrefix() 
+     << "##Name, Str, /* Implicit */ true)    \\\n"; 
+  OS << "  CLAUSE_NO_CLASS(" << DirLang.getClausePrefix() << "##Name, Str)\n"; 
+  OS << "\n"; 
+ 
+  for (const auto &R : DirLang.getClauses()) { 
+    Clause C{R}; 
+    if (C.getClangClass().empty()) { // NO_CLASS 
+      if (C.isImplicit()) { 
+        OS << "__IMPLICIT_CLAUSE_NO_CLASS(" << C.getFormattedName() << ", \"" 
+           << C.getFormattedName() << "\")\n"; 
+      } else { 
+        OS << "__CLAUSE_NO_CLASS(" << C.getFormattedName() << ")\n"; 
+      } 
+    } else { // CLASS 
+      if (C.isImplicit()) { 
+        OS << "__IMPLICIT_CLAUSE_CLASS(" << C.getFormattedName() << ", \"" 
+           << C.getFormattedName() << "\", " << C.getClangClass() << ")\n"; 
+      } else { 
+        OS << "__CLAUSE(" << C.getFormattedName() << ", " << C.getClangClass() 
+           << ")\n"; 
+      } 
+    } 
   }
 
-  OS << "\n";
-  OS << "#undef __IMPLICIT_CLAUSE_NO_CLASS\n";
-  OS << "#undef __IMPLICIT_CLAUSE_CLASS\n";
-  OS << "#undef __CLAUSE\n";
-  OS << "#undef CLAUSE_NO_CLASS\n";
-  OS << "#undef CLAUSE_CLASS\n";
-  OS << "#undef CLAUSE\n";
-}
-
-// Generate the implementation section for the enumeration in the directive
-// language.
-void EmitDirectivesGen(RecordKeeper &Records, raw_ostream &OS) {
-  const auto DirLang = DirectiveLanguage{Records};
-  if (DirLang.HasValidityErrors())
-    return;
-
-  EmitDirectivesFlangImpl(DirLang, OS);
-
-  GenerateClauseClassMacro(DirLang, OS);
-}
-
-// Generate the implementation for the enumeration in the directive
-// language. This code can be included in library.
-void EmitDirectivesImpl(RecordKeeper &Records, raw_ostream &OS) {
-  const auto DirLang = DirectiveLanguage{Records};
-  if (DirLang.HasValidityErrors())
-    return;
-
-  if (!DirLang.getIncludeHeader().empty())
-    OS << "#include \"" << DirLang.getIncludeHeader() << "\"\n\n";
-
+  OS << "\n"; 
+  OS << "#undef __IMPLICIT_CLAUSE_NO_CLASS\n"; 
+  OS << "#undef __IMPLICIT_CLAUSE_CLASS\n"; 
+  OS << "#undef __CLAUSE\n"; 
+  OS << "#undef CLAUSE_NO_CLASS\n"; 
+  OS << "#undef CLAUSE_CLASS\n"; 
+  OS << "#undef CLAUSE\n"; 
+} 
+
+// Generate the implementation section for the enumeration in the directive 
+// language. 
+void EmitDirectivesGen(RecordKeeper &Records, raw_ostream &OS) { 
+  const auto DirLang = DirectiveLanguage{Records}; 
+  if (DirLang.HasValidityErrors()) 
+    return; 
+
+  EmitDirectivesFlangImpl(DirLang, OS); 
+
+  GenerateClauseClassMacro(DirLang, OS); 
+} 
+ 
+// Generate the implementation for the enumeration in the directive 
+// language. This code can be included in library. 
+void EmitDirectivesImpl(RecordKeeper &Records, raw_ostream &OS) { 
+  const auto DirLang = DirectiveLanguage{Records}; 
+  if (DirLang.HasValidityErrors()) 
+    return; 
+ 
+  if (!DirLang.getIncludeHeader().empty()) 
+    OS << "#include \"" << DirLang.getIncludeHeader() << "\"\n\n"; 
+ 
   OS << "#include \"llvm/ADT/StringRef.h\"\n";
   OS << "#include \"llvm/ADT/StringSwitch.h\"\n";
   OS << "#include \"llvm/Support/ErrorHandling.h\"\n";
   OS << "\n";
   OS << "using namespace llvm;\n";
   llvm::SmallVector<StringRef, 2> Namespaces;
-  llvm::SplitString(DirLang.getCppNamespace(), Namespaces, "::");
+  llvm::SplitString(DirLang.getCppNamespace(), Namespaces, "::"); 
   for (auto Ns : Namespaces)
     OS << "using namespace " << Ns << ";\n";
 
   // getDirectiveKind(StringRef Str)
-  GenerateGetKind(DirLang.getDirectives(), OS, "Directive", DirLang,
-                  DirLang.getDirectivePrefix(), /*ImplicitAsUnknown=*/false);
+  GenerateGetKind(DirLang.getDirectives(), OS, "Directive", DirLang, 
+                  DirLang.getDirectivePrefix(), /*ImplicitAsUnknown=*/false); 
 
   // getDirectiveName(Directive Kind)
-  GenerateGetName(DirLang.getDirectives(), OS, "Directive", DirLang,
-                  DirLang.getDirectivePrefix());
+  GenerateGetName(DirLang.getDirectives(), OS, "Directive", DirLang, 
+                  DirLang.getDirectivePrefix()); 
 
   // getClauseKind(StringRef Str)
-  GenerateGetKind(DirLang.getClauses(), OS, "Clause", DirLang,
-                  DirLang.getClausePrefix(),
-                  /*ImplicitAsUnknown=*/true);
+  GenerateGetKind(DirLang.getClauses(), OS, "Clause", DirLang, 
+                  DirLang.getClausePrefix(), 
+                  /*ImplicitAsUnknown=*/true); 
 
   // getClauseName(Clause Kind)
-  GenerateGetName(DirLang.getClauses(), OS, "Clause", DirLang,
-                  DirLang.getClausePrefix());
-
-  // get<ClauseVal>Kind(StringRef Str)
-  GenerateGetKindClauseVal(DirLang, OS);
+  GenerateGetName(DirLang.getClauses(), OS, "Clause", DirLang, 
+                  DirLang.getClausePrefix()); 
 
+  // get<ClauseVal>Kind(StringRef Str) 
+  GenerateGetKindClauseVal(DirLang, OS); 
+ 
   // isAllowedClauseForDirective(Directive D, Clause C, unsigned Version)
-  GenerateIsAllowedClause(DirLang, OS);
+  GenerateIsAllowedClause(DirLang, OS); 
 }
 
 } // namespace llvm