Revert "Made the REPL choose a default language if only one REPL can be chosen."

[sivachandra]

Summary

This reverts commit babd6dd74e316b1fcd9d171d7d8c83845d51a487.

[sivachandra]

I am going to put this in to fix the build.

lldb/trunk/include/lldb/Core/PluginManager.h

public:
     GetTypeSystemEnumerateSupportedLanguagesCallbackForPluginName (const ConstString &name);
     
     //------------------------------------------------------------------
     // REPL
     //------------------------------------------------------------------
     static bool
     RegisterPlugin (const ConstString &name,
                     const char *description,
-                    REPLCreateInstance create_callback,
-                    REPLEnumerateSupportedLanguages enumerate_languages_callback);
+                    REPLCreateInstance create_callback);
     
     static bool
     UnregisterPlugin (REPLCreateInstance create_callback);
     
     static REPLCreateInstance
     GetREPLCreateCallbackAtIndex (uint32_t idx);
     
     static REPLCreateInstance
     GetREPLCreateCallbackForPluginName (const ConstString &name);
     
-    static REPLEnumerateSupportedLanguages
-    GetREPLEnumerateSupportedLanguagesCallbackAtIndex (uint32_t idx);
-    
-    static REPLEnumerateSupportedLanguages
-    GetREPLSystemEnumerateSupportedLanguagesCallbackForPluginName (const ConstString &name);
-    
     //------------------------------------------------------------------
     // Some plug-ins might register a DebuggerInitializeCallback
     // callback when registering the plug-in. After a new Debugger
     // instance is created, this DebuggerInitialize function will get
     // called. This allows plug-ins to install Properties and do any
     // other initialization that requires a debugger instance.
     //------------------------------------------------------------------
     static void

lldb/trunk/include/lldb/Target/Language.h

public:
     LanguageIsC (lldb::LanguageType language);
     
     static bool
     LanguageIsPascal (lldb::LanguageType language);
     
     static void
     GetLanguagesSupportingTypeSystems (std::set<lldb::LanguageType> &languages,
                                        std::set<lldb::LanguageType> &languages_for_expressions);
     
-    static void
-    GetLanguagesSupportingREPLs (std::set<lldb::LanguageType> &languages);
-    
 protected:
     //------------------------------------------------------------------
     // Classes that inherit from Language can see and modify these
     //------------------------------------------------------------------
     
     Language();
 private:
     
     DISALLOW_COPY_AND_ASSIGN (Language);
 };
     
 } // namespace lldb_private
 
 #endif // liblldb_Language_h_

lldb/trunk/include/lldb/lldb-private-interfaces.h

namespace lldb_private
     typedef lldb::ThreadPlanSP (*ThreadPlanStepFromHereCallback) (ThreadPlan *current_plan, Flags &flags, lldb::FrameComparison operation, void *baton);
     typedef UnwindAssembly* (*UnwindAssemblyCreateInstance) (const ArchSpec &arch);
     typedef lldb::MemoryHistorySP (*MemoryHistoryCreateInstance) (const lldb::ProcessSP &process_sp);
     typedef lldb::InstrumentationRuntimeType (*InstrumentationRuntimeGetType) ();
     typedef lldb::InstrumentationRuntimeSP (*InstrumentationRuntimeCreateInstance) (const lldb::ProcessSP &process_sp);
     typedef lldb::TypeSystemSP (*TypeSystemCreateInstance) (lldb::LanguageType language, Module *module, Target *target);
     typedef lldb::REPLSP (*REPLCreateInstance) (Error &error, lldb::LanguageType language, Debugger *debugger, Target *target, const char *repl_options);
     typedef void (*TypeSystemEnumerateSupportedLanguages) (std::set<lldb::LanguageType> &languages_for_types, std::set<lldb::LanguageType> &languages_for_expressions);
-    typedef void (*REPLEnumerateSupportedLanguages) (std::set<lldb::LanguageType> &languages);
     typedef int (*ComparisonFunction)(const void *, const void *);
     typedef void (*DebuggerInitializeCallback)(Debugger &debugger);
 
 } // namespace lldb_private
 
 #endif  // #if defined(__cplusplus)
 
 #endif  // liblldb_lldb_private_interfaces_h_

lldb/trunk/source/Core/Debugger.cpp

Debugger::GetSelectedOrDummyTarget(bool prefer_dummy)
     return GetDummyTarget();
 }
 
 Error
 Debugger::RunREPL (LanguageType language, const char *repl_options)
 {
     Error err;
     FileSpec repl_executable;
+    if (language == eLanguageTypeUnknown)
+    {
+        err.SetErrorString ("must specify a language for a REPL"); // TODO make it possible to specify a default language
+        return err;
+    }
     
     Target *const target = nullptr; // passing in an empty target means the REPL must create one
     
     REPLSP repl_sp(REPL::Create(err, language, this, target, repl_options));
 
     if (!err.Success())
     {
         return err;

lldb/trunk/source/Core/PluginManager.cpp

struct REPLInstance
     description(),
     create_callback(NULL)
     {
     }
     
     ConstString name;
     std::string description;
     REPLCreateInstance create_callback;
-    REPLEnumerateSupportedLanguages enumerate_languages_callback;
 };
 
 typedef std::vector<REPLInstance> REPLInstances;
 
 static Mutex &
 GetREPLMutex ()
 {
     static Mutex g_instances_mutex (Mutex::eMutexTypeRecursive);
     return g_instances_mutex;
 }
 
 static REPLInstances &
 GetREPLInstances ()
 {
     static REPLInstances g_instances;
     return g_instances;
 }
 
 bool
 PluginManager::RegisterPlugin (const ConstString &name,
                                const char *description,
-                               REPLCreateInstance create_callback,
-                               REPLEnumerateSupportedLanguages enumerate_languages_callback)
+                               REPLCreateInstance create_callback)
 {
     if (create_callback)
     {
         REPLInstance instance;
         assert ((bool)name);
         instance.name = name;
         if (description && description[0])
             instance.description = description;
         instance.create_callback = create_callback;
-        instance.enumerate_languages_callback = enumerate_languages_callback;
         Mutex::Locker locker (GetREPLMutex ());
         GetREPLInstances ().push_back (instance);
     }
     return false;
 }
 
 bool
 PluginManager::UnregisterPlugin (REPLCreateInstance create_callback)

lldb/trunk/source/Target/Language.cpp

Language::GetLanguagesSupportingTypeSystems (std::set<lldb::LanguageType> &languages,
     uint32_t idx = 0;
     
     while (TypeSystemEnumerateSupportedLanguages enumerate = PluginManager::GetTypeSystemEnumerateSupportedLanguagesCallbackAtIndex(idx++))
     {
         (*enumerate)(languages, languages_for_expressions);
     }
 }
 
-static void
-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;
 }
 
 size_t
 Language::TypeScavenger::Find (ExecutionContextScope *exe_scope,

lldb/trunk/source/Target/Target.cpp

Target::GetProcessSP () const
     return m_process_sp;
 }
 
 lldb::REPLSP
 Target::GetREPL (Error &err, lldb::LanguageType language, const char *repl_options, bool can_create)
 {
     if (language == eLanguageTypeUnknown)
     {
-        std::set<LanguageType> repl_languages;
-        
-        Language::GetLanguagesSupportingREPLs(repl_languages);
-        
-        if (repl_languages.size() == 1)
-        {
-            language = *repl_languages.begin();
-        }
-        else
-        {
-            err.SetErrorStringWithFormat("Multiple possible REPL languages.  Please specify a language.");
-            return REPLSP(); // must provide a language
-        }
-    }
     
     REPLMap::iterator pos = m_repl_map.find(language);
     
     if (pos != m_repl_map.end())
     {
         return pos->second;
     }