*** This commit represents a complete reformatting of the LLDB source code

*** to conform to clang-format’s LLVM style.  This kind of mass change has
*** two obvious implications:

Firstly, merging this particular commit into a downstream fork may be a huge
effort.  Alternatively, it may be worth merging all changes up to this commit,
performing the same reformatting operation locally, and then discarding the
merge for this particular commit.  The commands used to accomplish this
reformatting were as follows (with current working directory as the root of
the repository):

    find . \( -iname "*.c" -or -iname "*.cpp" -or -iname "*.h" -or -iname "*.mm" \) -exec clang-format -i {} +
    find . -iname "*.py" -exec autopep8 --in-place --aggressive --aggressive {} + ;

The version of clang-format used was 3.9.0, and autopep8 was 1.2.4.

Secondly, “blame” style tools will generally point to this commit instead of
a meaningful prior commit.  There are alternatives available that will attempt
to look through this change and find the appropriate prior commit.  YMMV.

llvm-svn: 280751

1 files changed, 297 insertions, 373 deletions

diff --git a/lldb/source/Target/Language.cpp b/lldb/source/Target/Language.cpp
index 20439b4dc55..f62073b3d17 100644
--- a/lldb/source/Target/Language.cpp
+++ b/lldb/source/Target/Language.cpp
@@ -1,4 +1,5 @@
-//===-- Language.cpp -------------------------------------------------*- C++ -*-===//
+//===-- Language.cpp -------------------------------------------------*- C++
+//-*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
@@ -23,442 +24,365 @@ using namespace lldb_private::formatters;
 typedef std::unique_ptr<Language> LanguageUP;
 typedef std::map<lldb::LanguageType, LanguageUP> LanguagesMap;
 
-static LanguagesMap&
-GetLanguagesMap ()
-{
-    static LanguagesMap *g_map = nullptr;
-    static std::once_flag g_initialize;
-    
-    std::call_once(g_initialize, [] {
-        g_map = new LanguagesMap(); // NOTE: INTENTIONAL LEAK due to global destructor chain
-    });
-    
-    return *g_map;
-}
-static std::mutex &
-GetLanguagesMutex()
-{
-    static std::mutex *g_mutex = nullptr;
-    static std::once_flag g_initialize;
+static LanguagesMap &GetLanguagesMap() {
+  static LanguagesMap *g_map = nullptr;
+  static std::once_flag g_initialize;
 
-    std::call_once(g_initialize, [] {
-        g_mutex = new std::mutex(); // NOTE: INTENTIONAL LEAK due to global destructor chain
-    });
+  std::call_once(g_initialize, [] {
+    g_map = new LanguagesMap(); // NOTE: INTENTIONAL LEAK due to global
+                                // destructor chain
+  });
 
-    return *g_mutex;
+  return *g_map;
 }
+static std::mutex &GetLanguagesMutex() {
+  static std::mutex *g_mutex = nullptr;
+  static std::once_flag g_initialize;
 
-Language*
-Language::FindPlugin (lldb::LanguageType language)
-{
-    std::lock_guard<std::mutex> guard(GetLanguagesMutex());
-    LanguagesMap& map(GetLanguagesMap());
-    auto iter = map.find(language), end = map.end();
-    if (iter != end)
-        return iter->second.get();
-    
-    Language *language_ptr = nullptr;
-    LanguageCreateInstance create_callback;
-    
-    for (uint32_t idx = 0;
-         (create_callback = PluginManager::GetLanguageCreateCallbackAtIndex(idx)) != nullptr;
-         ++idx)
-    {
-        language_ptr = create_callback(language);
-        
-        if (language_ptr)
-        {
-            map[language] = std::unique_ptr<Language>(language_ptr);
-            return language_ptr;
-        }
-    }
-    
-    return nullptr;
+  std::call_once(g_initialize, [] {
+    g_mutex = new std::mutex(); // NOTE: INTENTIONAL LEAK due to global
+                                // destructor chain
+  });
+
+  return *g_mutex;
 }
 
-void
-Language::ForEach (std::function<bool(Language*)> callback)
-{
-    std::lock_guard<std::mutex> guard(GetLanguagesMutex());
-    LanguagesMap& map(GetLanguagesMap());
-    for (const auto& entry : map)
-    {
-        if (!callback(entry.second.get()))
-            break;
+Language *Language::FindPlugin(lldb::LanguageType language) {
+  std::lock_guard<std::mutex> guard(GetLanguagesMutex());
+  LanguagesMap &map(GetLanguagesMap());
+  auto iter = map.find(language), end = map.end();
+  if (iter != end)
+    return iter->second.get();
+
+  Language *language_ptr = nullptr;
+  LanguageCreateInstance create_callback;
+
+  for (uint32_t idx = 0;
+       (create_callback =
+            PluginManager::GetLanguageCreateCallbackAtIndex(idx)) != nullptr;
+       ++idx) {
+    language_ptr = create_callback(language);
+
+    if (language_ptr) {
+      map[language] = std::unique_ptr<Language>(language_ptr);
+      return language_ptr;
     }
-}
+  }
 
-bool
-Language::IsTopLevelFunction (Function& function)
-{
-    return false;
+  return nullptr;
 }
 
-lldb::TypeCategoryImplSP
-Language::GetFormatters ()
-{
-    return nullptr;
+void Language::ForEach(std::function<bool(Language *)> callback) {
+  std::lock_guard<std::mutex> guard(GetLanguagesMutex());
+  LanguagesMap &map(GetLanguagesMap());
+  for (const auto &entry : map) {
+    if (!callback(entry.second.get()))
+      break;
+  }
 }
 
-HardcodedFormatters::HardcodedFormatFinder
-Language::GetHardcodedFormats ()
-{
-    return {};
+bool Language::IsTopLevelFunction(Function &function) { return false; }
+
+lldb::TypeCategoryImplSP Language::GetFormatters() { return nullptr; }
+
+HardcodedFormatters::HardcodedFormatFinder Language::GetHardcodedFormats() {
+  return {};
 }
 
-HardcodedFormatters::HardcodedSummaryFinder
-Language::GetHardcodedSummaries ()
-{
-    return {};
+HardcodedFormatters::HardcodedSummaryFinder Language::GetHardcodedSummaries() {
+  return {};
 }
 
 HardcodedFormatters::HardcodedSyntheticFinder
-Language::GetHardcodedSynthetics ()
-{
-    return {};
+Language::GetHardcodedSynthetics() {
+  return {};
 }
 
 HardcodedFormatters::HardcodedValidatorFinder
-Language::GetHardcodedValidators ()
-{
-    return {};
+Language::GetHardcodedValidators() {
+  return {};
 }
 
 std::vector<ConstString>
-Language::GetPossibleFormattersMatches (ValueObject& valobj, lldb::DynamicValueType use_dynamic)
-{
-    return {};
+Language::GetPossibleFormattersMatches(ValueObject &valobj,
+                                       lldb::DynamicValueType use_dynamic) {
+  return {};
 }
 
 lldb_private::formatters::StringPrinter::EscapingHelper
-Language::GetStringPrinterEscapingHelper (lldb_private::formatters::StringPrinter::GetPrintableElementType elem_type)
-{
-    return StringPrinter::GetDefaultEscapingHelper(elem_type);
+Language::GetStringPrinterEscapingHelper(
+    lldb_private::formatters::StringPrinter::GetPrintableElementType
+        elem_type) {
+  return StringPrinter::GetDefaultEscapingHelper(elem_type);
 }
 
 struct language_name_pair {
-    const char *name;
-    LanguageType type;
+  const char *name;
+  LanguageType type;
 };
 
-struct language_name_pair language_names[] =
-{
+struct language_name_pair language_names[] = {
     // To allow GetNameForLanguageType to be a simple array lookup, the first
     // part of this array must follow enum LanguageType exactly.
-    {   "unknown",          eLanguageTypeUnknown        },
-    {   "c89",              eLanguageTypeC89            },
-    {   "c",                eLanguageTypeC              },
-    {   "ada83",            eLanguageTypeAda83          },
-    {   "c++",              eLanguageTypeC_plus_plus    },
-    {   "cobol74",          eLanguageTypeCobol74        },
-    {   "cobol85",          eLanguageTypeCobol85        },
-    {   "fortran77",        eLanguageTypeFortran77      },
-    {   "fortran90",        eLanguageTypeFortran90      },
-    {   "pascal83",         eLanguageTypePascal83       },
-    {   "modula2",          eLanguageTypeModula2        },
-    {   "java",             eLanguageTypeJava           },
-    {   "c99",              eLanguageTypeC99            },
-    {   "ada95",            eLanguageTypeAda95          },
-    {   "fortran95",        eLanguageTypeFortran95      },
-    {   "pli",              eLanguageTypePLI            },
-    {   "objective-c",      eLanguageTypeObjC           },
-    {   "objective-c++",    eLanguageTypeObjC_plus_plus },
-    {   "upc",              eLanguageTypeUPC            },
-    {   "d",                eLanguageTypeD              },
-    {   "python",           eLanguageTypePython         },
-    {   "opencl",           eLanguageTypeOpenCL         },
-    {   "go",               eLanguageTypeGo             },
-    {   "modula3",          eLanguageTypeModula3        },
-    {   "haskell",          eLanguageTypeHaskell        },
-    {   "c++03",            eLanguageTypeC_plus_plus_03 },
-    {   "c++11",            eLanguageTypeC_plus_plus_11 },
-    {   "ocaml",            eLanguageTypeOCaml          },
-    {   "rust",             eLanguageTypeRust           },
-    {   "c11",              eLanguageTypeC11            },
-    {   "swift",            eLanguageTypeSwift          },
-    {   "julia",            eLanguageTypeJulia          },
-    {   "dylan",            eLanguageTypeDylan          },
-    {   "c++14",            eLanguageTypeC_plus_plus_14 },
-    {   "fortran03",        eLanguageTypeFortran03      },
-    {   "fortran08",        eLanguageTypeFortran08      },
+    {"unknown", eLanguageTypeUnknown},
+    {"c89", eLanguageTypeC89},
+    {"c", eLanguageTypeC},
+    {"ada83", eLanguageTypeAda83},
+    {"c++", eLanguageTypeC_plus_plus},
+    {"cobol74", eLanguageTypeCobol74},
+    {"cobol85", eLanguageTypeCobol85},
+    {"fortran77", eLanguageTypeFortran77},
+    {"fortran90", eLanguageTypeFortran90},
+    {"pascal83", eLanguageTypePascal83},
+    {"modula2", eLanguageTypeModula2},
+    {"java", eLanguageTypeJava},
+    {"c99", eLanguageTypeC99},
+    {"ada95", eLanguageTypeAda95},
+    {"fortran95", eLanguageTypeFortran95},
+    {"pli", eLanguageTypePLI},
+    {"objective-c", eLanguageTypeObjC},
+    {"objective-c++", eLanguageTypeObjC_plus_plus},
+    {"upc", eLanguageTypeUPC},
+    {"d", eLanguageTypeD},
+    {"python", eLanguageTypePython},
+    {"opencl", eLanguageTypeOpenCL},
+    {"go", eLanguageTypeGo},
+    {"modula3", eLanguageTypeModula3},
+    {"haskell", eLanguageTypeHaskell},
+    {"c++03", eLanguageTypeC_plus_plus_03},
+    {"c++11", eLanguageTypeC_plus_plus_11},
+    {"ocaml", eLanguageTypeOCaml},
+    {"rust", eLanguageTypeRust},
+    {"c11", eLanguageTypeC11},
+    {"swift", eLanguageTypeSwift},
+    {"julia", eLanguageTypeJulia},
+    {"dylan", eLanguageTypeDylan},
+    {"c++14", eLanguageTypeC_plus_plus_14},
+    {"fortran03", eLanguageTypeFortran03},
+    {"fortran08", eLanguageTypeFortran08},
     // Vendor Extensions
-    {   "mipsassem",        eLanguageTypeMipsAssembler  },
-    {   "renderscript",     eLanguageTypeExtRenderScript},
+    {"mipsassem", eLanguageTypeMipsAssembler},
+    {"renderscript", eLanguageTypeExtRenderScript},
     // Now synonyms, in arbitrary order
-    {   "objc",             eLanguageTypeObjC           },
-    {   "objc++",           eLanguageTypeObjC_plus_plus },
-    {   "pascal",           eLanguageTypePascal83       }
-};
-
-static uint32_t num_languages = sizeof(language_names) / sizeof (struct language_name_pair);
-
-LanguageType
-Language::GetLanguageTypeFromString (const char *string)
-{
-    for (uint32_t i = 0; i < num_languages; i++)
-    {
-        if (strcasecmp (language_names[i].name, string) == 0)
-            return (LanguageType) language_names[i].type;
-    }
-    return eLanguageTypeUnknown;
-}
-
-const char *
-Language::GetNameForLanguageType (LanguageType language)
-{
-    if (language < num_languages)
-        return language_names[language].name;
-    else
-        return language_names[eLanguageTypeUnknown].name;
-}
-
-void
-Language::PrintAllLanguages (Stream &s, const char *prefix, const char *suffix)
-{
-    for (uint32_t i = 1; i < num_languages; i++)
-    {
-        s.Printf("%s%s%s", prefix, language_names[i].name, suffix);
-    }
-}
-
-void
-Language::ForAllLanguages (std::function<bool(lldb::LanguageType)> callback)
-{
-    for (uint32_t i = 1; i < num_languages; i++)
-    {
-        if (!callback(language_names[i].type))
-            break;
-    }
-}
-
-bool
-Language::LanguageIsCPlusPlus (LanguageType language)
-{
-    switch (language)
-    {
-        case eLanguageTypeC_plus_plus:
-        case eLanguageTypeC_plus_plus_03:
-        case eLanguageTypeC_plus_plus_11:
-        case eLanguageTypeC_plus_plus_14:
-        case eLanguageTypeObjC_plus_plus:
-            return true;
-        default:
-            return false;
-    }
-}
-
-bool
-Language::LanguageIsObjC (LanguageType language)
-{
-    switch (language)
-    {
-        case eLanguageTypeObjC:
-        case eLanguageTypeObjC_plus_plus:
-            return true;
-        default:
-            return false;
-    }
-}
-
-bool
-Language::LanguageIsC (LanguageType language)
-{
-    switch (language)
-    {
-        case eLanguageTypeC:
-        case eLanguageTypeC89:
-        case eLanguageTypeC99:
-        case eLanguageTypeC11:
-            return true;
-        default:
-            return false;
-    }
+    {"objc", eLanguageTypeObjC},
+    {"objc++", eLanguageTypeObjC_plus_plus},
+    {"pascal", eLanguageTypePascal83}};
+
+static uint32_t num_languages =
+    sizeof(language_names) / sizeof(struct language_name_pair);
+
+LanguageType Language::GetLanguageTypeFromString(const char *string) {
+  for (uint32_t i = 0; i < num_languages; i++) {
+    if (strcasecmp(language_names[i].name, string) == 0)
+      return (LanguageType)language_names[i].type;
+  }
+  return eLanguageTypeUnknown;
+}
+
+const char *Language::GetNameForLanguageType(LanguageType language) {
+  if (language < num_languages)
+    return language_names[language].name;
+  else
+    return language_names[eLanguageTypeUnknown].name;
+}
+
+void Language::PrintAllLanguages(Stream &s, const char *prefix,
+                                 const char *suffix) {
+  for (uint32_t i = 1; i < num_languages; i++) {
+    s.Printf("%s%s%s", prefix, language_names[i].name, suffix);
+  }
+}
+
+void Language::ForAllLanguages(
+    std::function<bool(lldb::LanguageType)> callback) {
+  for (uint32_t i = 1; i < num_languages; i++) {
+    if (!callback(language_names[i].type))
+      break;
+  }
+}
+
+bool Language::LanguageIsCPlusPlus(LanguageType language) {
+  switch (language) {
+  case eLanguageTypeC_plus_plus:
+  case eLanguageTypeC_plus_plus_03:
+  case eLanguageTypeC_plus_plus_11:
+  case eLanguageTypeC_plus_plus_14:
+  case eLanguageTypeObjC_plus_plus:
+    return true;
+  default:
+    return false;
+  }
 }
 
-bool
-Language::LanguageIsPascal (LanguageType language)
-{
-    switch (language)
-    {
-        case eLanguageTypePascal83:
-            return true;
-        default:
-            return false;
-    }
+bool Language::LanguageIsObjC(LanguageType language) {
+  switch (language) {
+  case eLanguageTypeObjC:
+  case eLanguageTypeObjC_plus_plus:
+    return true;
+  default:
+    return false;
+  }
 }
 
-LanguageType
-Language::GetPrimaryLanguage (LanguageType language)
-{
-    switch (language)
-    {
-        case eLanguageTypeC_plus_plus:
-        case eLanguageTypeC_plus_plus_03:
-        case eLanguageTypeC_plus_plus_11:
-        case eLanguageTypeC_plus_plus_14:
-            return eLanguageTypeC_plus_plus;
-        case eLanguageTypeC:
-        case eLanguageTypeC89:
-        case eLanguageTypeC99:
-        case eLanguageTypeC11:
-            return eLanguageTypeC;
-        case eLanguageTypeObjC:
-        case eLanguageTypeObjC_plus_plus:
-            return eLanguageTypeObjC;
-        case eLanguageTypePascal83:
-        case eLanguageTypeCobol74:
-        case eLanguageTypeCobol85:
-        case eLanguageTypeFortran77:
-        case eLanguageTypeFortran90:
-        case eLanguageTypeFortran95:
-        case eLanguageTypeFortran03:
-        case eLanguageTypeFortran08:
-        case eLanguageTypeAda83:
-        case eLanguageTypeAda95:
-        case eLanguageTypeModula2:
-        case eLanguageTypeJava:
-        case eLanguageTypePLI:
-        case eLanguageTypeUPC:
-        case eLanguageTypeD:
-        case eLanguageTypePython:
-        case eLanguageTypeOpenCL:
-        case eLanguageTypeGo:
-        case eLanguageTypeModula3:
-        case eLanguageTypeHaskell:
-        case eLanguageTypeOCaml:
-        case eLanguageTypeRust:
-        case eLanguageTypeSwift:
-        case eLanguageTypeJulia:
-        case eLanguageTypeDylan:
-        case eLanguageTypeMipsAssembler:
-        case eLanguageTypeExtRenderScript:
-        case eLanguageTypeUnknown:
-        default:
-            return language;
-    }
+bool Language::LanguageIsC(LanguageType language) {
+  switch (language) {
+  case eLanguageTypeC:
+  case eLanguageTypeC89:
+  case eLanguageTypeC99:
+  case eLanguageTypeC11:
+    return true;
+  default:
+    return false;
+  }
 }
 
-void
-Language::GetLanguagesSupportingTypeSystems (std::set<lldb::LanguageType> &languages,
-                                             std::set<lldb::LanguageType> &languages_for_expressions)
-{
-    uint32_t idx = 0;
-    
-    while (TypeSystemEnumerateSupportedLanguages enumerate = PluginManager::GetTypeSystemEnumerateSupportedLanguagesCallbackAtIndex(idx++))
-    {
-        (*enumerate)(languages, languages_for_expressions);
-    }
-}
+bool Language::LanguageIsPascal(LanguageType language) {
+  switch (language) {
+  case eLanguageTypePascal83:
+    return true;
+  default:
+    return false;
+  }
+}
+
+LanguageType Language::GetPrimaryLanguage(LanguageType language) {
+  switch (language) {
+  case eLanguageTypeC_plus_plus:
+  case eLanguageTypeC_plus_plus_03:
+  case eLanguageTypeC_plus_plus_11:
+  case eLanguageTypeC_plus_plus_14:
+    return eLanguageTypeC_plus_plus;
+  case eLanguageTypeC:
+  case eLanguageTypeC89:
+  case eLanguageTypeC99:
+  case eLanguageTypeC11:
+    return eLanguageTypeC;
+  case eLanguageTypeObjC:
+  case eLanguageTypeObjC_plus_plus:
+    return eLanguageTypeObjC;
+  case eLanguageTypePascal83:
+  case eLanguageTypeCobol74:
+  case eLanguageTypeCobol85:
+  case eLanguageTypeFortran77:
+  case eLanguageTypeFortran90:
+  case eLanguageTypeFortran95:
+  case eLanguageTypeFortran03:
+  case eLanguageTypeFortran08:
+  case eLanguageTypeAda83:
+  case eLanguageTypeAda95:
+  case eLanguageTypeModula2:
+  case eLanguageTypeJava:
+  case eLanguageTypePLI:
+  case eLanguageTypeUPC:
+  case eLanguageTypeD:
+  case eLanguageTypePython:
+  case eLanguageTypeOpenCL:
+  case eLanguageTypeGo:
+  case eLanguageTypeModula3:
+  case eLanguageTypeHaskell:
+  case eLanguageTypeOCaml:
+  case eLanguageTypeRust:
+  case eLanguageTypeSwift:
+  case eLanguageTypeJulia:
+  case eLanguageTypeDylan:
+  case eLanguageTypeMipsAssembler:
+  case eLanguageTypeExtRenderScript:
+  case eLanguageTypeUnknown:
+  default:
+    return language;
+  }
+}
+
+void Language::GetLanguagesSupportingTypeSystems(
+    std::set<lldb::LanguageType> &languages,
+    std::set<lldb::LanguageType> &languages_for_expressions) {
+  uint32_t idx = 0;
+
+  while (TypeSystemEnumerateSupportedLanguages enumerate = PluginManager::
+             GetTypeSystemEnumerateSupportedLanguagesCallbackAtIndex(idx++)) {
+    (*enumerate)(languages, languages_for_expressions);
+  }
+}
+
+void Language::GetLanguagesSupportingREPLs(
+    std::set<lldb::LanguageType> &languages) {
+  uint32_t idx = 0;
+
+  while (REPLEnumerateSupportedLanguages enumerate =
+             PluginManager::GetREPLEnumerateSupportedLanguagesCallbackAtIndex(
+                 idx++)) {
+    (*enumerate)(languages);
+  }
+}
+
+std::unique_ptr<Language::TypeScavenger> Language::GetTypeScavenger() {
+  return nullptr;
+}
+
+const char *Language::GetLanguageSpecificTypeLookupHelp() { return nullptr; }
+
+size_t Language::TypeScavenger::Find(ExecutionContextScope *exe_scope,
+                                     const char *key, ResultSet &results,
+                                     bool append) {
+  if (!exe_scope || !exe_scope->CalculateTarget().get())
+    return false;
 
-void
-Language::GetLanguagesSupportingREPLs (std::set<lldb::LanguageType> &languages)
-{
-    uint32_t idx = 0;
-    
-    while (REPLEnumerateSupportedLanguages enumerate = PluginManager::GetREPLEnumerateSupportedLanguagesCallbackAtIndex(idx++))
-    {
-        (*enumerate)(languages);
-    }
-}
+  if (!key || !key[0])
+    return false;
 
-std::unique_ptr<Language::TypeScavenger>
-Language::GetTypeScavenger ()
-{
-    return nullptr;
-}
+  if (!append)
+    results.clear();
 
-const char*
-Language::GetLanguageSpecificTypeLookupHelp ()
-{
-    return nullptr;
-}
+  size_t old_size = results.size();
 
-size_t
-Language::TypeScavenger::Find (ExecutionContextScope *exe_scope,
-                               const char *key,
-                               ResultSet &results,
-                               bool append)
-{
-    if (!exe_scope || !exe_scope->CalculateTarget().get())
-        return false;
-    
-    if (!key || !key[0])
-        return false;
-
-    if (!append)
-        results.clear();
-    
-    size_t old_size = results.size();
-    
-    if (this->Find_Impl(exe_scope, key, results))
-        return results.size() - old_size;
-    return 0;
+  if (this->Find_Impl(exe_scope, key, results))
+    return results.size() - old_size;
+  return 0;
 }
 
-bool
-Language::GetFormatterPrefixSuffix (ValueObject& valobj, ConstString type_hint,
-                                    std::string& prefix, std::string& suffix)
-{
-    return false;
+bool Language::GetFormatterPrefixSuffix(ValueObject &valobj,
+                                        ConstString type_hint,
+                                        std::string &prefix,
+                                        std::string &suffix) {
+  return false;
 }
 
-DumpValueObjectOptions::DeclPrintingHelper
-Language::GetDeclPrintingHelper ()
-{
-    return nullptr;
+DumpValueObjectOptions::DeclPrintingHelper Language::GetDeclPrintingHelper() {
+  return nullptr;
 }
 
-LazyBool
-Language::IsLogicalTrue (ValueObject& valobj,
-                         Error& error)
-{
-    return eLazyBoolCalculate;
+LazyBool Language::IsLogicalTrue(ValueObject &valobj, Error &error) {
+  return eLazyBoolCalculate;
 }
 
-bool
-Language::IsNilReference (ValueObject& valobj)
-{
-    return false;
-}
+bool Language::IsNilReference(ValueObject &valobj) { return false; }
 
-bool
-Language::IsUninitializedReference (ValueObject& valobj)
-{
-    return false;
-}
+bool Language::IsUninitializedReference(ValueObject &valobj) { return false; }
 
-bool
-Language::GetFunctionDisplayName (const SymbolContext *sc,
-                                  const ExecutionContext *exe_ctx,
-                                  FunctionNameRepresentation representation,
-                                  Stream& s)
-{
-    return false;
+bool Language::GetFunctionDisplayName(const SymbolContext *sc,
+                                      const ExecutionContext *exe_ctx,
+                                      FunctionNameRepresentation representation,
+                                      Stream &s) {
+  return false;
 }
 
-void
-Language::GetExceptionResolverDescription(bool catch_on, bool throw_on, Stream &s)
-{
-    GetDefaultExceptionResolverDescription(catch_on, throw_on, s);
+void Language::GetExceptionResolverDescription(bool catch_on, bool throw_on,
+                                               Stream &s) {
+  GetDefaultExceptionResolverDescription(catch_on, throw_on, s);
 }
 
-void
-Language::GetDefaultExceptionResolverDescription(bool catch_on, bool throw_on, Stream &s)
-{
-     s.Printf ("Exception breakpoint (catch: %s throw: %s)",
-               catch_on ? "on" : "off",
-               throw_on ? "on" : "off");
+void Language::GetDefaultExceptionResolverDescription(bool catch_on,
+                                                      bool throw_on,
+                                                      Stream &s) {
+  s.Printf("Exception breakpoint (catch: %s throw: %s)",
+           catch_on ? "on" : "off", throw_on ? "on" : "off");
 }
 //----------------------------------------------------------------------
 // Constructor
 //----------------------------------------------------------------------
-Language::Language()
-{
-}
+Language::Language() {}
 
 //----------------------------------------------------------------------
 // Destructor
 //----------------------------------------------------------------------
-Language::~Language()
-{
-}
+Language::~Language() {}