More of the alias refactoring work! CommandAlias is now a CommandObject

llvm-svn: 263468

lldb/include/lldb/Interpreter/CommandAlias.h

@@ -18,16 +18,21 @@
 // Project includes
 #include "lldb/lldb-forward.h"
 #include "lldb/Interpreter/Args.h"
+#include "lldb/Interpreter/CommandObject.h"
 
 namespace lldb_private {
-class CommandAlias
+class CommandAlias : public CommandObject
 {
 public:
     typedef std::unique_ptr<CommandAlias> UniquePointer;
 
-    static UniquePointer
-    GetCommandAlias (lldb::CommandObjectSP cmd_sp,
-                     const char *options_args);
+    CommandAlias (CommandInterpreter &interpreter,
+                  lldb::CommandObjectSP cmd_sp,
+                  const char *options_args,
+                  const char *name,
+                  const char *help = nullptr,
+                  const char *syntax = nullptr,
+                  uint32_t flags = 0);
     
     void
     GetAliasExpansion (StreamString &help_string);
@@ -43,13 +48,18 @@ public:
         return IsValid();
     }
     
+    bool
+    WantsRawCommandString() override;
+    
+    bool
+    IsAlias () override { return true; }
+    
+    bool
+    Execute(const char *args_string, CommandReturnObject &result) override;
+    
     lldb::CommandObjectSP GetUnderlyingCommand() { return m_underlying_command_sp; }
     OptionArgVectorSP GetOptionArguments() { return m_option_args_sp; }
     
-protected:
-    CommandAlias (lldb::CommandObjectSP cmd_sp = nullptr,
-                  OptionArgVectorSP args_sp = nullptr);
-    
 private:
     lldb::CommandObjectSP m_underlying_command_sp;
     OptionArgVectorSP m_option_args_sp ;

lldb/include/lldb/Interpreter/CommandInterpreter.h

@@ -201,7 +201,7 @@ class CommandInterpreter :
     public IOHandlerDelegate
 {
 public:
-    typedef std::map<std::string, CommandAlias::UniquePointer> CommandAliasMap;
+    typedef std::map<std::string, lldb::CommandObjectSP> CommandAliasMap;
     
     enum
     {

lldb/include/lldb/Interpreter/CommandObject.h

@@ -177,6 +177,9 @@ public:
     
     virtual bool
     IsMultiwordObject () { return false; }
+    
+    virtual bool
+    IsAlias () { return false; }
 
     virtual lldb::CommandObjectSP
     GetSubcommandSP(const char *sub_cmd, StringList *matches = nullptr)

lldb/source/Interpreter/CommandAlias.cpp

@@ -9,6 +9,8 @@
 
 #include "lldb/Interpreter/CommandAlias.h"
 
+#include "llvm/Support/ErrorHandling.h"
+
 #include "lldb/Core/StreamString.h"
 #include "lldb/Interpreter/CommandObject.h"
 #include "lldb/Interpreter/CommandReturnObject.h"
@@ -70,22 +72,48 @@ ProcessAliasOptionsArgs (lldb::CommandObjectSP &cmd_obj_sp,
     return success;
 }
 
-CommandAlias::UniquePointer
-CommandAlias::GetCommandAlias (lldb::CommandObjectSP cmd_sp,
-                               const char *options_args)
+CommandAlias::CommandAlias (CommandInterpreter &interpreter,
+                            lldb::CommandObjectSP cmd_sp,
+                            const char *options_args,
+                            const char *name,
+                            const char *help,
+                            const char *syntax,
+                            uint32_t flags) :
+    CommandObject(interpreter,
+                  name,
+                  help,
+                  syntax,
+                  flags),
+m_underlying_command_sp(),
+m_option_args_sp(new OptionArgVector)
 {
-    CommandAlias::UniquePointer ret_val(nullptr);
-    OptionArgVectorSP opt_args_sp(new OptionArgVector);
-    if (ProcessAliasOptionsArgs(cmd_sp, options_args, opt_args_sp))
-        ret_val.reset(new CommandAlias(cmd_sp, opt_args_sp));
-    return ret_val;
+    if (ProcessAliasOptionsArgs(cmd_sp, options_args, m_option_args_sp))
+    {
+        m_underlying_command_sp = cmd_sp;
+        if (!help || !help[0])
+        {
+            StreamString sstr;
+            StreamString translation_and_help;
+            GetAliasExpansion(sstr);
+            
+            translation_and_help.Printf ("(%s)  %s", sstr.GetData(), GetUnderlyingCommand()->GetHelp());
+            SetHelp(translation_and_help.GetData());
+        }
+    }
 }
 
-CommandAlias::CommandAlias (lldb::CommandObjectSP cmd_sp,
-                            OptionArgVectorSP args_sp) :
-m_underlying_command_sp(cmd_sp),
-m_option_args_sp(args_sp)
+bool
+CommandAlias::WantsRawCommandString()
 {
+    if (IsValid())
+        return m_underlying_command_sp->WantsRawCommandString();
+    return false;
+}
+
+bool
+CommandAlias::Execute(const char *args_string, CommandReturnObject &result)
+{
+    llvm_unreachable("CommandAlias::Execute is not to be called");
 }
 
 void

lldb/source/Interpreter/CommandInterpreter.cpp

@@ -772,7 +772,7 @@ CommandInterpreter::GetCommandSP (const char *cmd_cstr, bool include_aliases, bo
     {
         CommandAliasMap::iterator alias_pos = m_alias_dict.find(cmd);
         if (alias_pos != m_alias_dict.end())
-            command_sp = alias_pos->second->GetUnderlyingCommand();
+            command_sp = ((CommandAlias*)alias_pos->second.get())->GetUnderlyingCommand();
     }
 
     if (HasUserCommands())
@@ -823,7 +823,7 @@ CommandInterpreter::GetCommandSP (const char *cmd_cstr, bool include_aliases, bo
             cmd.assign(matches->GetStringAtIndex (num_cmd_matches));
             CommandAliasMap::iterator alias_pos = m_alias_dict.find(cmd);
             if (alias_pos != m_alias_dict.end())
-                alias_match_sp = alias_pos->second->GetUnderlyingCommand();
+                alias_match_sp = ((CommandAlias*)alias_pos->second.get())->GetUnderlyingCommand();
         }
 
         if (HasUserCommands())
@@ -1057,11 +1057,17 @@ CommandInterpreter::AddAlias (const char *alias_name,
     if (command_obj_sp.get())
         assert((this == &command_obj_sp->GetCommandInterpreter()) && "tried to add a CommandObject from a different interpreter");
     
-    if (auto cmd_alias = CommandAlias::GetCommandAlias(command_obj_sp, args_string))
+    std::unique_ptr<CommandAlias> command_alias_up(new CommandAlias(*this,
+                                                                    command_obj_sp,
+                                                                    args_string,
+                                                                    alias_name));
+    
+    if (command_alias_up && command_alias_up->IsValid())
     {
-        m_alias_dict[alias_name] = std::move(cmd_alias);
+        m_alias_dict[alias_name] = CommandObjectSP(command_alias_up.release());
         return true;
     }
+    
     return false;
 }
 
@@ -1144,15 +1150,8 @@ CommandInterpreter::GetHelp (CommandReturnObject &result,
 
         for (auto alias_pos = m_alias_dict.begin(); alias_pos != m_alias_dict.end(); ++alias_pos)
         {
-            StreamString sstr;
-            StreamString translation_and_help;
-            std::string entry_name = alias_pos->first;
-            std::string second_entry = alias_pos->second->GetUnderlyingCommand()->GetCommandName();
-            alias_pos->second->GetAliasExpansion(sstr);
-            
-            translation_and_help.Printf ("(%s)  %s", sstr.GetData(), alias_pos->second->GetUnderlyingCommand()->GetHelp());
-            OutputFormattedHelpText (result.GetOutputStream(), alias_pos->first.c_str(), "--",
-                                     translation_and_help.GetData(), max_len);
+            OutputFormattedHelpText (result.GetOutputStream(), alias_pos->first.c_str(), "--", alias_pos->second->GetHelp(),
+                                     max_len);
         }
         result.AppendMessage("");
     }
@@ -1996,7 +1995,7 @@ CommandInterpreter::GetAlias (const char *alias_name)
 
     auto pos = m_alias_dict.find(alias);
     if (pos != m_alias_dict.end())
-        return pos->second.get();
+        return (CommandAlias*)pos->second.get();
     
     return nullptr;
 }