1 //===-- CommandObjectRegexCommand.cpp ---------------------------*- C++ -*-===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9
10 #include "lldb/Interpreter/CommandObjectRegexCommand.h"
11
12 // C Includes
13 // C++ Includes
14 // Other libraries and framework includes
15 // Project includes
16 #include "lldb/Interpreter/CommandInterpreter.h"
17 #include "lldb/Interpreter/CommandReturnObject.h"
18
19 using namespace lldb;
20 using namespace lldb_private;
21
22 //----------------------------------------------------------------------
23 // CommandObjectRegexCommand constructor
24 //----------------------------------------------------------------------
CommandObjectRegexCommand(CommandInterpreter & interpreter,const char * name,const char * help,const char * syntax,uint32_t max_matches,uint32_t completion_type_mask,bool is_removable)25 CommandObjectRegexCommand::CommandObjectRegexCommand
26 (
27 CommandInterpreter &interpreter,
28 const char *name,
29 const char *help,
30 const char *syntax,
31 uint32_t max_matches,
32 uint32_t completion_type_mask,
33 bool is_removable
34 ) :
35 CommandObjectRaw (interpreter, name, help, syntax),
36 m_max_matches (max_matches),
37 m_completion_type_mask (completion_type_mask),
38 m_entries (),
39 m_is_removable (is_removable)
40 {
41 }
42
43 //----------------------------------------------------------------------
44 // Destructor
45 //----------------------------------------------------------------------
~CommandObjectRegexCommand()46 CommandObjectRegexCommand::~CommandObjectRegexCommand()
47 {
48 }
49
50
51 bool
DoExecute(const char * command,CommandReturnObject & result)52 CommandObjectRegexCommand::DoExecute
53 (
54 const char *command,
55 CommandReturnObject &result
56 )
57 {
58 if (command)
59 {
60 EntryCollection::const_iterator pos, end = m_entries.end();
61 for (pos = m_entries.begin(); pos != end; ++pos)
62 {
63 RegularExpression::Match regex_match(m_max_matches);
64
65 if (pos->regex.Execute (command, ®ex_match))
66 {
67 std::string new_command(pos->command);
68 std::string match_str;
69 char percent_var[8];
70 size_t idx, percent_var_idx;
71 for (uint32_t match_idx=1; match_idx <= m_max_matches; ++match_idx)
72 {
73 if (regex_match.GetMatchAtIndex (command, match_idx, match_str))
74 {
75 const int percent_var_len = ::snprintf (percent_var, sizeof(percent_var), "%%%u", match_idx);
76 for (idx = 0; (percent_var_idx = new_command.find(percent_var, idx)) != std::string::npos; )
77 {
78 new_command.erase(percent_var_idx, percent_var_len);
79 new_command.insert(percent_var_idx, match_str);
80 idx += percent_var_idx + match_str.size();
81 }
82 }
83 }
84 // Interpret the new command and return this as the result!
85 if (m_interpreter.GetExpandRegexAliases())
86 result.GetOutputStream().Printf("%s\n", new_command.c_str());
87 // Pass in true for "no context switching". The command that called us should have set up the context
88 // appropriately, we shouldn't have to redo that.
89 return m_interpreter.HandleCommand(new_command.c_str(), eLazyBoolCalculate, result, nullptr, true, true);
90 }
91 }
92 result.SetStatus(eReturnStatusFailed);
93 if (GetSyntax() != nullptr)
94 result.AppendError (GetSyntax());
95 else
96 result.AppendErrorWithFormat ("Command contents '%s' failed to match any regular expression in the '%s' regex command.\n",
97 command,
98 m_cmd_name.c_str());
99 return false;
100 }
101 result.AppendError("empty command passed to regular expression command");
102 result.SetStatus(eReturnStatusFailed);
103 return false;
104 }
105
106
107 bool
AddRegexCommand(const char * re_cstr,const char * command_cstr)108 CommandObjectRegexCommand::AddRegexCommand (const char *re_cstr, const char *command_cstr)
109 {
110 m_entries.resize(m_entries.size() + 1);
111 // Only add the regular expression if it compiles
112 if (m_entries.back().regex.Compile (re_cstr))
113 {
114 m_entries.back().command.assign (command_cstr);
115 return true;
116 }
117 // The regex didn't compile...
118 m_entries.pop_back();
119 return false;
120 }
121
122 int
HandleCompletion(Args & input,int & cursor_index,int & cursor_char_position,int match_start_point,int max_return_elements,bool & word_complete,StringList & matches)123 CommandObjectRegexCommand::HandleCompletion (Args &input,
124 int &cursor_index,
125 int &cursor_char_position,
126 int match_start_point,
127 int max_return_elements,
128 bool &word_complete,
129 StringList &matches)
130 {
131 if (m_completion_type_mask)
132 {
133 std::string completion_str (input.GetArgumentAtIndex (cursor_index), cursor_char_position);
134 CommandCompletions::InvokeCommonCompletionCallbacks (m_interpreter,
135 m_completion_type_mask,
136 completion_str.c_str(),
137 match_start_point,
138 max_return_elements,
139 nullptr,
140 word_complete,
141 matches);
142 return matches.GetSize();
143 }
144 else
145 {
146 matches.Clear();
147 word_complete = false;
148 }
149 return 0;
150 }
151