Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 1 | //===-- CommandObjectExpression.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 "CommandObjectExpression.h" |
| 11 | |
| 12 | // C Includes |
| 13 | // C++ Includes |
| 14 | // Other libraries and framework includes |
| 15 | // Project includes |
Sean Callanan | 841026f | 2010-07-23 00:16:21 +0000 | [diff] [blame] | 16 | #include "lldb/Interpreter/Args.h" |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 17 | #include "lldb/Core/Value.h" |
| 18 | #include "lldb/Core/InputReader.h" |
Jim Ingham | 324067b | 2010-09-30 00:54:27 +0000 | [diff] [blame] | 19 | #include "lldb/Core/ValueObjectVariable.h" |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 20 | #include "lldb/Expression/ClangExpressionVariable.h" |
Sean Callanan | 65dafa8 | 2010-08-27 01:01:44 +0000 | [diff] [blame] | 21 | #include "lldb/Expression/ClangUserExpression.h" |
Stephen Wilson | 63c468c | 2010-07-23 21:47:22 +0000 | [diff] [blame] | 22 | #include "lldb/Expression/ClangFunction.h" |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 23 | #include "lldb/Expression/DWARFExpression.h" |
| 24 | #include "lldb/Host/Host.h" |
Sean Callanan | 841026f | 2010-07-23 00:16:21 +0000 | [diff] [blame] | 25 | #include "lldb/Core/Debugger.h" |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 26 | #include "lldb/Interpreter/CommandInterpreter.h" |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 27 | #include "lldb/Interpreter/CommandReturnObject.h" |
Jim Ingham | 324067b | 2010-09-30 00:54:27 +0000 | [diff] [blame] | 28 | #include "lldb/Target/ObjCLanguageRuntime.h" |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 29 | #include "lldb/Symbol/ObjectFile.h" |
| 30 | #include "lldb/Symbol/Variable.h" |
| 31 | #include "lldb/Target/Process.h" |
| 32 | #include "lldb/Target/StackFrame.h" |
| 33 | #include "lldb/Target/Target.h" |
Greg Clayton | abe0fed | 2011-04-18 08:33:37 +0000 | [diff] [blame] | 34 | #include "lldb/Target/Thread.h" |
Sean Callanan | 841026f | 2010-07-23 00:16:21 +0000 | [diff] [blame] | 35 | #include "llvm/ADT/StringRef.h" |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 36 | |
| 37 | using namespace lldb; |
| 38 | using namespace lldb_private; |
| 39 | |
Greg Clayton | a42880a | 2011-10-25 06:44:01 +0000 | [diff] [blame] | 40 | CommandObjectExpression::CommandOptions::CommandOptions () : |
| 41 | OptionGroup() |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 42 | { |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 43 | } |
| 44 | |
| 45 | |
| 46 | CommandObjectExpression::CommandOptions::~CommandOptions () |
| 47 | { |
| 48 | } |
| 49 | |
Greg Clayton | a42880a | 2011-10-25 06:44:01 +0000 | [diff] [blame] | 50 | OptionDefinition |
| 51 | CommandObjectExpression::CommandOptions::g_option_table[] = |
| 52 | { |
| 53 | { LLDB_OPT_SET_1 | LLDB_OPT_SET_2, false, "dynamic-value", 'd', required_argument, NULL, 0, eArgTypeBoolean, "Upcast the value resulting from the expression to its dynamic type if available."}, |
| 54 | { LLDB_OPT_SET_1 | LLDB_OPT_SET_2, false, "unwind-on-error", 'u', required_argument, NULL, 0, eArgTypeBoolean, "Clean up program state if the expression causes a crash, breakpoint hit or signal."}, |
| 55 | { LLDB_OPT_SET_2 , false, "object-description", 'o', no_argument, NULL, 0, eArgTypeNone, "Print the object description of the value resulting from the expression."}, |
| 56 | }; |
| 57 | |
| 58 | |
| 59 | uint32_t |
| 60 | CommandObjectExpression::CommandOptions::GetNumDefinitions () |
| 61 | { |
| 62 | return sizeof(g_option_table)/sizeof(OptionDefinition); |
| 63 | } |
| 64 | |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 65 | Error |
Greg Clayton | a42880a | 2011-10-25 06:44:01 +0000 | [diff] [blame] | 66 | CommandObjectExpression::CommandOptions::SetOptionValue (CommandInterpreter &interpreter, |
| 67 | uint32_t option_idx, |
| 68 | const char *option_arg) |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 69 | { |
| 70 | Error error; |
| 71 | |
Greg Clayton | a42880a | 2011-10-25 06:44:01 +0000 | [diff] [blame] | 72 | const char short_option = (char) g_option_table[option_idx].short_option; |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 73 | |
| 74 | switch (short_option) |
| 75 | { |
Caroline Tice | c1ad82e | 2010-09-07 22:38:08 +0000 | [diff] [blame] | 76 | //case 'l': |
| 77 | //if (language.SetLanguageFromCString (option_arg) == false) |
| 78 | //{ |
Greg Clayton | 9c23673 | 2011-10-26 00:56:27 +0000 | [diff] [blame] | 79 | // error.SetErrorStringWithFormat("invalid language option argument '%s'", option_arg); |
Caroline Tice | c1ad82e | 2010-09-07 22:38:08 +0000 | [diff] [blame] | 80 | //} |
| 81 | //break; |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 82 | |
Jim Ingham | 324067b | 2010-09-30 00:54:27 +0000 | [diff] [blame] | 83 | case 'o': |
| 84 | print_object = true; |
| 85 | break; |
Jim Ingham | ea9d426 | 2010-11-05 19:25:48 +0000 | [diff] [blame] | 86 | |
Jim Ingham | e41494a | 2011-04-16 00:01:13 +0000 | [diff] [blame] | 87 | case 'd': |
| 88 | { |
| 89 | bool success; |
| 90 | bool result; |
| 91 | result = Args::StringToBoolean(option_arg, true, &success); |
| 92 | if (!success) |
Greg Clayton | 9c23673 | 2011-10-26 00:56:27 +0000 | [diff] [blame] | 93 | error.SetErrorStringWithFormat("invalid dynamic value setting: \"%s\"", option_arg); |
Jim Ingham | e41494a | 2011-04-16 00:01:13 +0000 | [diff] [blame] | 94 | else |
| 95 | { |
| 96 | if (result) |
Greg Clayton | 82f0746 | 2011-05-30 00:49:24 +0000 | [diff] [blame] | 97 | use_dynamic = eLazyBoolYes; |
Jim Ingham | e41494a | 2011-04-16 00:01:13 +0000 | [diff] [blame] | 98 | else |
| 99 | use_dynamic = eLazyBoolNo; |
| 100 | } |
| 101 | } |
| 102 | break; |
| 103 | |
Jim Ingham | ea9d426 | 2010-11-05 19:25:48 +0000 | [diff] [blame] | 104 | case 'u': |
Sean Callanan | 47dc457 | 2011-09-15 02:13:07 +0000 | [diff] [blame] | 105 | { |
| 106 | bool success; |
| 107 | unwind_on_error = Args::StringToBoolean(option_arg, true, &success); |
| 108 | if (!success) |
Greg Clayton | 9c23673 | 2011-10-26 00:56:27 +0000 | [diff] [blame] | 109 | error.SetErrorStringWithFormat("could not convert \"%s\" to a boolean value.", option_arg); |
Sean Callanan | 47dc457 | 2011-09-15 02:13:07 +0000 | [diff] [blame] | 110 | break; |
| 111 | } |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 112 | default: |
Greg Clayton | 9c23673 | 2011-10-26 00:56:27 +0000 | [diff] [blame] | 113 | error.SetErrorStringWithFormat("invalid short option character '%c'", short_option); |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 114 | break; |
| 115 | } |
| 116 | |
| 117 | return error; |
| 118 | } |
| 119 | |
| 120 | void |
Greg Clayton | a42880a | 2011-10-25 06:44:01 +0000 | [diff] [blame] | 121 | CommandObjectExpression::CommandOptions::OptionParsingStarting (CommandInterpreter &interpreter) |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 122 | { |
Jim Ingham | e41494a | 2011-04-16 00:01:13 +0000 | [diff] [blame] | 123 | use_dynamic = eLazyBoolCalculate; |
Greg Clayton | a42880a | 2011-10-25 06:44:01 +0000 | [diff] [blame] | 124 | print_object = false; |
Jim Ingham | ea9d426 | 2010-11-05 19:25:48 +0000 | [diff] [blame] | 125 | unwind_on_error = true; |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 126 | show_types = true; |
| 127 | show_summary = true; |
| 128 | } |
| 129 | |
Greg Clayton | b344843 | 2011-03-24 21:19:54 +0000 | [diff] [blame] | 130 | const OptionDefinition* |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 131 | CommandObjectExpression::CommandOptions::GetDefinitions () |
| 132 | { |
| 133 | return g_option_table; |
| 134 | } |
| 135 | |
Greg Clayton | 238c0a1 | 2010-09-18 01:14:36 +0000 | [diff] [blame] | 136 | CommandObjectExpression::CommandObjectExpression (CommandInterpreter &interpreter) : |
Jim Ingham | da26bd2 | 2012-06-08 21:56:10 +0000 | [diff] [blame] | 137 | CommandObjectRaw (interpreter, |
| 138 | "expression", |
| 139 | "Evaluate a C/ObjC/C++ expression in the current program context, using variables currently in scope.", |
| 140 | NULL, |
| 141 | eFlagProcessMustBePaused), |
Greg Clayton | a42880a | 2011-10-25 06:44:01 +0000 | [diff] [blame] | 142 | m_option_group (interpreter), |
| 143 | m_format_options (eFormatDefault), |
| 144 | m_command_options (), |
Johnny Chen | cc112ac | 2010-09-30 18:30:25 +0000 | [diff] [blame] | 145 | m_expr_line_count (0), |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 146 | m_expr_lines () |
| 147 | { |
| 148 | SetHelpLong( |
| 149 | "Examples: \n\ |
| 150 | \n\ |
| 151 | expr my_struct->a = my_array[3] \n\ |
| 152 | expr -f bin -- (index * 8) + 5 \n\ |
| 153 | expr char c[] = \"foo\"; c[0]\n"); |
Caroline Tice | 43b014a | 2010-10-04 22:28:36 +0000 | [diff] [blame] | 154 | |
| 155 | CommandArgumentEntry arg; |
| 156 | CommandArgumentData expression_arg; |
| 157 | |
| 158 | // Define the first (and only) variant of this arg. |
| 159 | expression_arg.arg_type = eArgTypeExpression; |
| 160 | expression_arg.arg_repetition = eArgRepeatPlain; |
| 161 | |
| 162 | // There is only one variant this argument could be; put it into the argument entry. |
| 163 | arg.push_back (expression_arg); |
| 164 | |
| 165 | // Push the data for the first argument into the m_arguments vector. |
| 166 | m_arguments.push_back (arg); |
Greg Clayton | a42880a | 2011-10-25 06:44:01 +0000 | [diff] [blame] | 167 | |
Greg Clayton | 24a6bd9 | 2011-10-27 17:55:14 +0000 | [diff] [blame] | 168 | // Add the "--format" and "--gdb-format" |
| 169 | m_option_group.Append (&m_format_options, OptionGroupFormat::OPTION_GROUP_FORMAT | OptionGroupFormat::OPTION_GROUP_GDB_FMT, LLDB_OPT_SET_1); |
Greg Clayton | a42880a | 2011-10-25 06:44:01 +0000 | [diff] [blame] | 170 | m_option_group.Append (&m_command_options); |
| 171 | m_option_group.Finalize(); |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 172 | } |
| 173 | |
| 174 | CommandObjectExpression::~CommandObjectExpression () |
| 175 | { |
| 176 | } |
| 177 | |
| 178 | Options * |
| 179 | CommandObjectExpression::GetOptions () |
| 180 | { |
Greg Clayton | a42880a | 2011-10-25 06:44:01 +0000 | [diff] [blame] | 181 | return &m_option_group; |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 182 | } |
| 183 | |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 184 | size_t |
| 185 | CommandObjectExpression::MultiLineExpressionCallback |
| 186 | ( |
| 187 | void *baton, |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 188 | InputReader &reader, |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 189 | lldb::InputReaderAction notification, |
| 190 | const char *bytes, |
| 191 | size_t bytes_len |
| 192 | ) |
| 193 | { |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 194 | CommandObjectExpression *cmd_object_expr = (CommandObjectExpression *) baton; |
Caroline Tice | 892fadd | 2011-06-16 16:27:19 +0000 | [diff] [blame] | 195 | bool batch_mode = reader.GetDebugger().GetCommandInterpreter().GetBatchCommandMode(); |
| 196 | |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 197 | switch (notification) |
| 198 | { |
| 199 | case eInputReaderActivate: |
Caroline Tice | 892fadd | 2011-06-16 16:27:19 +0000 | [diff] [blame] | 200 | if (!batch_mode) |
Caroline Tice | 2b5e4e6 | 2011-06-15 19:35:17 +0000 | [diff] [blame] | 201 | { |
Greg Clayton | 234981a | 2011-07-20 03:41:06 +0000 | [diff] [blame] | 202 | StreamSP async_strm_sp(reader.GetDebugger().GetAsyncOutputStream()); |
| 203 | if (async_strm_sp) |
| 204 | { |
| 205 | async_strm_sp->PutCString("Enter expressions, then terminate with an empty line to evaluate:\n"); |
| 206 | async_strm_sp->Flush(); |
| 207 | } |
Caroline Tice | 2b5e4e6 | 2011-06-15 19:35:17 +0000 | [diff] [blame] | 208 | } |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 209 | // Fall through |
| 210 | case eInputReaderReactivate: |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 211 | break; |
| 212 | |
| 213 | case eInputReaderDeactivate: |
| 214 | break; |
| 215 | |
Caroline Tice | 4a34808 | 2011-05-02 20:41:46 +0000 | [diff] [blame] | 216 | case eInputReaderAsynchronousOutputWritten: |
| 217 | break; |
| 218 | |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 219 | case eInputReaderGotToken: |
| 220 | ++cmd_object_expr->m_expr_line_count; |
| 221 | if (bytes && bytes_len) |
| 222 | { |
| 223 | cmd_object_expr->m_expr_lines.append (bytes, bytes_len + 1); |
| 224 | } |
| 225 | |
| 226 | if (bytes_len == 0) |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 227 | reader.SetIsDone(true); |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 228 | break; |
| 229 | |
Caroline Tice | c4f55fe | 2010-11-19 20:47:54 +0000 | [diff] [blame] | 230 | case eInputReaderInterrupt: |
| 231 | cmd_object_expr->m_expr_lines.clear(); |
| 232 | reader.SetIsDone (true); |
Caroline Tice | 892fadd | 2011-06-16 16:27:19 +0000 | [diff] [blame] | 233 | if (!batch_mode) |
Caroline Tice | 2b5e4e6 | 2011-06-15 19:35:17 +0000 | [diff] [blame] | 234 | { |
Greg Clayton | 234981a | 2011-07-20 03:41:06 +0000 | [diff] [blame] | 235 | StreamSP async_strm_sp (reader.GetDebugger().GetAsyncOutputStream()); |
| 236 | if (async_strm_sp) |
| 237 | { |
| 238 | async_strm_sp->PutCString("Expression evaluation cancelled.\n"); |
| 239 | async_strm_sp->Flush(); |
| 240 | } |
Caroline Tice | 2b5e4e6 | 2011-06-15 19:35:17 +0000 | [diff] [blame] | 241 | } |
Caroline Tice | c4f55fe | 2010-11-19 20:47:54 +0000 | [diff] [blame] | 242 | break; |
| 243 | |
| 244 | case eInputReaderEndOfFile: |
| 245 | reader.SetIsDone (true); |
| 246 | break; |
| 247 | |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 248 | case eInputReaderDone: |
Caroline Tice | c4f55fe | 2010-11-19 20:47:54 +0000 | [diff] [blame] | 249 | if (cmd_object_expr->m_expr_lines.size() > 0) |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 250 | { |
Caroline Tice | 87e1f77 | 2011-06-13 20:20:29 +0000 | [diff] [blame] | 251 | StreamSP output_stream = reader.GetDebugger().GetAsyncOutputStream(); |
| 252 | StreamSP error_stream = reader.GetDebugger().GetAsyncErrorStream(); |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 253 | cmd_object_expr->EvaluateExpression (cmd_object_expr->m_expr_lines.c_str(), |
Caroline Tice | 87e1f77 | 2011-06-13 20:20:29 +0000 | [diff] [blame] | 254 | output_stream.get(), |
| 255 | error_stream.get()); |
| 256 | output_stream->Flush(); |
| 257 | error_stream->Flush(); |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 258 | } |
| 259 | break; |
| 260 | } |
| 261 | |
| 262 | return bytes_len; |
| 263 | } |
| 264 | |
| 265 | bool |
Greg Clayton | 66ed2fb | 2010-10-05 00:00:42 +0000 | [diff] [blame] | 266 | CommandObjectExpression::EvaluateExpression |
| 267 | ( |
| 268 | const char *expr, |
Caroline Tice | 87e1f77 | 2011-06-13 20:20:29 +0000 | [diff] [blame] | 269 | Stream *output_stream, |
| 270 | Stream *error_stream, |
Greg Clayton | 66ed2fb | 2010-10-05 00:00:42 +0000 | [diff] [blame] | 271 | CommandReturnObject *result |
| 272 | ) |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 273 | { |
Greg Clayton | f75e391 | 2012-01-27 18:18:23 +0000 | [diff] [blame] | 274 | Target *target = m_interpreter.GetExecutionContext().GetTargetPtr(); |
Sean Callanan | f35a96c | 2011-10-27 21:22:25 +0000 | [diff] [blame] | 275 | |
| 276 | if (!target) |
| 277 | target = Host::GetDummyTarget(m_interpreter.GetDebugger()).get(); |
| 278 | |
Greg Clayton | 567e7f3 | 2011-09-22 04:58:26 +0000 | [diff] [blame] | 279 | if (target) |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 280 | { |
Greg Clayton | 427f290 | 2010-12-14 02:59:59 +0000 | [diff] [blame] | 281 | lldb::ValueObjectSP result_valobj_sp; |
Greg Clayton | 11730f3 | 2010-10-06 03:09:11 +0000 | [diff] [blame] | 282 | |
Greg Clayton | b344843 | 2011-03-24 21:19:54 +0000 | [diff] [blame] | 283 | ExecutionResults exe_results; |
Sean Callanan | 6a92553 | 2011-01-13 08:53:35 +0000 | [diff] [blame] | 284 | |
| 285 | bool keep_in_memory = true; |
Jim Ingham | 10de7d1 | 2011-05-04 03:43:18 +0000 | [diff] [blame] | 286 | lldb::DynamicValueType use_dynamic; |
Jim Ingham | e41494a | 2011-04-16 00:01:13 +0000 | [diff] [blame] | 287 | // If use dynamic is not set, get it from the target: |
Greg Clayton | a42880a | 2011-10-25 06:44:01 +0000 | [diff] [blame] | 288 | switch (m_command_options.use_dynamic) |
Jim Ingham | e41494a | 2011-04-16 00:01:13 +0000 | [diff] [blame] | 289 | { |
| 290 | case eLazyBoolCalculate: |
Greg Clayton | 567e7f3 | 2011-09-22 04:58:26 +0000 | [diff] [blame] | 291 | use_dynamic = target->GetPreferDynamicValue(); |
Jim Ingham | e41494a | 2011-04-16 00:01:13 +0000 | [diff] [blame] | 292 | break; |
| 293 | case eLazyBoolYes: |
Jim Ingham | 10de7d1 | 2011-05-04 03:43:18 +0000 | [diff] [blame] | 294 | use_dynamic = lldb::eDynamicCanRunTarget; |
Jim Ingham | e41494a | 2011-04-16 00:01:13 +0000 | [diff] [blame] | 295 | break; |
| 296 | case eLazyBoolNo: |
Jim Ingham | 10de7d1 | 2011-05-04 03:43:18 +0000 | [diff] [blame] | 297 | use_dynamic = lldb::eNoDynamicValues; |
Jim Ingham | e41494a | 2011-04-16 00:01:13 +0000 | [diff] [blame] | 298 | break; |
| 299 | } |
Sean Callanan | 6a92553 | 2011-01-13 08:53:35 +0000 | [diff] [blame] | 300 | |
Enrico Granata | d27026e | 2012-09-05 20:41:26 +0000 | [diff] [blame] | 301 | Target::EvaluateExpressionOptions options; |
| 302 | options.SetCoerceToId(m_command_options.print_object) |
| 303 | .SetUnwindOnError(m_command_options.unwind_on_error) |
| 304 | .SetKeepInMemory(keep_in_memory) |
| 305 | .SetUseDynamic(use_dynamic) |
| 306 | .SetSingleThreadTimeoutUsec(0); |
| 307 | |
Greg Clayton | 567e7f3 | 2011-09-22 04:58:26 +0000 | [diff] [blame] | 308 | exe_results = target->EvaluateExpression (expr, |
Greg Clayton | f75e391 | 2012-01-27 18:18:23 +0000 | [diff] [blame] | 309 | m_interpreter.GetExecutionContext().GetFramePtr(), |
Enrico Granata | 6cca969 | 2012-07-16 23:10:35 +0000 | [diff] [blame] | 310 | result_valobj_sp, |
Enrico Granata | d27026e | 2012-09-05 20:41:26 +0000 | [diff] [blame] | 311 | options); |
Greg Clayton | 427f290 | 2010-12-14 02:59:59 +0000 | [diff] [blame] | 312 | |
Greg Clayton | a42880a | 2011-10-25 06:44:01 +0000 | [diff] [blame] | 313 | if (exe_results == eExecutionInterrupted && !m_command_options.unwind_on_error) |
Jim Ingham | 360f53f | 2010-11-30 02:22:11 +0000 | [diff] [blame] | 314 | { |
Greg Clayton | abe0fed | 2011-04-18 08:33:37 +0000 | [diff] [blame] | 315 | uint32_t start_frame = 0; |
| 316 | uint32_t num_frames = 1; |
| 317 | uint32_t num_frames_with_source = 0; |
Greg Clayton | f75e391 | 2012-01-27 18:18:23 +0000 | [diff] [blame] | 318 | Thread *thread = m_interpreter.GetExecutionContext().GetThreadPtr(); |
Greg Clayton | 567e7f3 | 2011-09-22 04:58:26 +0000 | [diff] [blame] | 319 | if (thread) |
Greg Clayton | abe0fed | 2011-04-18 08:33:37 +0000 | [diff] [blame] | 320 | { |
Greg Clayton | 567e7f3 | 2011-09-22 04:58:26 +0000 | [diff] [blame] | 321 | thread->GetStatus (result->GetOutputStream(), |
| 322 | start_frame, |
| 323 | num_frames, |
| 324 | num_frames_with_source); |
Greg Clayton | abe0fed | 2011-04-18 08:33:37 +0000 | [diff] [blame] | 325 | } |
Greg Clayton | 567e7f3 | 2011-09-22 04:58:26 +0000 | [diff] [blame] | 326 | else |
Greg Clayton | abe0fed | 2011-04-18 08:33:37 +0000 | [diff] [blame] | 327 | { |
Greg Clayton | f75e391 | 2012-01-27 18:18:23 +0000 | [diff] [blame] | 328 | Process *process = m_interpreter.GetExecutionContext().GetProcessPtr(); |
Greg Clayton | 567e7f3 | 2011-09-22 04:58:26 +0000 | [diff] [blame] | 329 | if (process) |
| 330 | { |
| 331 | bool only_threads_with_stop_reason = true; |
| 332 | process->GetThreadStatus (result->GetOutputStream(), |
| 333 | only_threads_with_stop_reason, |
| 334 | start_frame, |
| 335 | num_frames, |
| 336 | num_frames_with_source); |
| 337 | } |
Greg Clayton | abe0fed | 2011-04-18 08:33:37 +0000 | [diff] [blame] | 338 | } |
Greg Clayton | 427f290 | 2010-12-14 02:59:59 +0000 | [diff] [blame] | 339 | } |
Sean Callanan | 96abc62 | 2012-08-08 17:35:10 +0000 | [diff] [blame] | 340 | |
Greg Clayton | 427f290 | 2010-12-14 02:59:59 +0000 | [diff] [blame] | 341 | if (result_valobj_sp) |
| 342 | { |
Sean Callanan | 96abc62 | 2012-08-08 17:35:10 +0000 | [diff] [blame] | 343 | Format format = m_format_options.GetFormat(); |
| 344 | |
Greg Clayton | 427f290 | 2010-12-14 02:59:59 +0000 | [diff] [blame] | 345 | if (result_valobj_sp->GetError().Success()) |
| 346 | { |
Sean Callanan | 96abc62 | 2012-08-08 17:35:10 +0000 | [diff] [blame] | 347 | if (format != eFormatVoid) |
| 348 | { |
| 349 | if (format != eFormatDefault) |
| 350 | result_valobj_sp->SetFormat (format); |
Greg Clayton | 427f290 | 2010-12-14 02:59:59 +0000 | [diff] [blame] | 351 | |
Sean Callanan | 96abc62 | 2012-08-08 17:35:10 +0000 | [diff] [blame] | 352 | ValueObject::DumpValueObjectOptions options; |
| 353 | options.SetMaximumPointerDepth(0) |
| 354 | .SetMaximumDepth(UINT32_MAX) |
| 355 | .SetShowLocation(false) |
| 356 | .SetShowTypes(m_command_options.show_types) |
| 357 | .SetUseObjectiveC(m_command_options.print_object) |
| 358 | .SetUseDynamicType(use_dynamic) |
| 359 | .SetScopeChecked(true) |
| 360 | .SetFlatOutput(false) |
| 361 | .SetUseSyntheticValue(true) |
| 362 | .SetIgnoreCap(false) |
| 363 | .SetFormat(format) |
| 364 | .SetSummary() |
Enrico Granata | 1221358 | 2012-08-09 16:51:25 +0000 | [diff] [blame] | 365 | .SetShowSummary(!m_command_options.print_object) |
| 366 | .SetHideRootType(m_command_options.print_object); |
Sean Callanan | 96abc62 | 2012-08-08 17:35:10 +0000 | [diff] [blame] | 367 | |
| 368 | ValueObject::DumpValueObject (*(output_stream), |
| 369 | result_valobj_sp.get(), // Variable object to dump |
| 370 | options); |
| 371 | if (result) |
| 372 | result->SetStatus (eReturnStatusSuccessFinishResult); |
| 373 | } |
Greg Clayton | 427f290 | 2010-12-14 02:59:59 +0000 | [diff] [blame] | 374 | } |
| 375 | else |
| 376 | { |
Sean Callanan | 2431244 | 2011-08-23 21:20:51 +0000 | [diff] [blame] | 377 | if (result_valobj_sp->GetError().GetError() == ClangUserExpression::kNoResult) |
Greg Clayton | fe1b47d | 2011-06-24 22:31:10 +0000 | [diff] [blame] | 378 | { |
Sean Callanan | 1e1e6cb | 2012-08-09 18:18:47 +0000 | [diff] [blame] | 379 | if (format != eFormatVoid && m_interpreter.GetDebugger().GetNotifyVoid()) |
Sean Callanan | 96abc62 | 2012-08-08 17:35:10 +0000 | [diff] [blame] | 380 | { |
Sean Callanan | 1e1e6cb | 2012-08-09 18:18:47 +0000 | [diff] [blame] | 381 | error_stream->PutCString("(void)\n"); |
Sean Callanan | 96abc62 | 2012-08-08 17:35:10 +0000 | [diff] [blame] | 382 | } |
Sean Callanan | 1e1e6cb | 2012-08-09 18:18:47 +0000 | [diff] [blame] | 383 | |
| 384 | if (result) |
| 385 | result->SetStatus (eReturnStatusSuccessFinishResult); |
Greg Clayton | fe1b47d | 2011-06-24 22:31:10 +0000 | [diff] [blame] | 386 | } |
| 387 | else |
| 388 | { |
Sean Callanan | 2431244 | 2011-08-23 21:20:51 +0000 | [diff] [blame] | 389 | const char *error_cstr = result_valobj_sp->GetError().AsCString(); |
| 390 | if (error_cstr && error_cstr[0]) |
| 391 | { |
| 392 | int error_cstr_len = strlen (error_cstr); |
| 393 | const bool ends_with_newline = error_cstr[error_cstr_len - 1] == '\n'; |
| 394 | if (strstr(error_cstr, "error:") != error_cstr) |
| 395 | error_stream->PutCString ("error: "); |
| 396 | error_stream->Write(error_cstr, error_cstr_len); |
| 397 | if (!ends_with_newline) |
| 398 | error_stream->EOL(); |
| 399 | } |
| 400 | else |
| 401 | { |
| 402 | error_stream->PutCString ("error: unknown error\n"); |
| 403 | } |
| 404 | |
| 405 | if (result) |
| 406 | result->SetStatus (eReturnStatusFailed); |
Greg Clayton | fe1b47d | 2011-06-24 22:31:10 +0000 | [diff] [blame] | 407 | } |
Jim Ingham | 360f53f | 2010-11-30 02:22:11 +0000 | [diff] [blame] | 408 | } |
| 409 | } |
Greg Clayton | 427f290 | 2010-12-14 02:59:59 +0000 | [diff] [blame] | 410 | } |
| 411 | else |
| 412 | { |
Caroline Tice | 87e1f77 | 2011-06-13 20:20:29 +0000 | [diff] [blame] | 413 | error_stream->Printf ("error: invalid execution context for expression\n"); |
Greg Clayton | 427f290 | 2010-12-14 02:59:59 +0000 | [diff] [blame] | 414 | return false; |
Sean Callanan | 841026f | 2010-07-23 00:16:21 +0000 | [diff] [blame] | 415 | } |
Sean Callanan | 82b74c8 | 2010-08-12 01:56:52 +0000 | [diff] [blame] | 416 | |
Sean Callanan | 841026f | 2010-07-23 00:16:21 +0000 | [diff] [blame] | 417 | return true; |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 418 | } |
| 419 | |
| 420 | bool |
Jim Ingham | da26bd2 | 2012-06-08 21:56:10 +0000 | [diff] [blame] | 421 | CommandObjectExpression::DoExecute |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 422 | ( |
| 423 | const char *command, |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 424 | CommandReturnObject &result |
| 425 | ) |
| 426 | { |
Greg Clayton | a42880a | 2011-10-25 06:44:01 +0000 | [diff] [blame] | 427 | m_option_group.NotifyOptionParsingStarting(); |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 428 | |
| 429 | const char * expr = NULL; |
| 430 | |
| 431 | if (command[0] == '\0') |
| 432 | { |
| 433 | m_expr_lines.clear(); |
| 434 | m_expr_line_count = 0; |
| 435 | |
Greg Clayton | 238c0a1 | 2010-09-18 01:14:36 +0000 | [diff] [blame] | 436 | InputReaderSP reader_sp (new InputReader(m_interpreter.GetDebugger())); |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 437 | if (reader_sp) |
| 438 | { |
| 439 | Error err (reader_sp->Initialize (CommandObjectExpression::MultiLineExpressionCallback, |
| 440 | this, // baton |
| 441 | eInputReaderGranularityLine, // token size, to pass to callback function |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 442 | NULL, // end token |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 443 | NULL, // prompt |
| 444 | true)); // echo input |
| 445 | if (err.Success()) |
| 446 | { |
Greg Clayton | 238c0a1 | 2010-09-18 01:14:36 +0000 | [diff] [blame] | 447 | m_interpreter.GetDebugger().PushInputReader (reader_sp); |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 448 | result.SetStatus (eReturnStatusSuccessFinishNoResult); |
| 449 | } |
| 450 | else |
| 451 | { |
| 452 | result.AppendError (err.AsCString()); |
| 453 | result.SetStatus (eReturnStatusFailed); |
| 454 | } |
| 455 | } |
| 456 | else |
| 457 | { |
| 458 | result.AppendError("out of memory"); |
| 459 | result.SetStatus (eReturnStatusFailed); |
| 460 | } |
| 461 | return result.Succeeded(); |
| 462 | } |
| 463 | |
| 464 | if (command[0] == '-') |
| 465 | { |
| 466 | // We have some options and these options MUST end with --. |
| 467 | const char *end_options = NULL; |
| 468 | const char *s = command; |
| 469 | while (s && s[0]) |
| 470 | { |
| 471 | end_options = ::strstr (s, "--"); |
| 472 | if (end_options) |
| 473 | { |
| 474 | end_options += 2; // Get past the "--" |
| 475 | if (::isspace (end_options[0])) |
| 476 | { |
| 477 | expr = end_options; |
| 478 | while (::isspace (*expr)) |
| 479 | ++expr; |
| 480 | break; |
| 481 | } |
| 482 | } |
| 483 | s = end_options; |
| 484 | } |
| 485 | |
| 486 | if (end_options) |
| 487 | { |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 488 | Args args (command, end_options - command); |
Greg Clayton | 238c0a1 | 2010-09-18 01:14:36 +0000 | [diff] [blame] | 489 | if (!ParseOptions (args, result)) |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 490 | return false; |
Greg Clayton | 143fcc3 | 2011-04-13 00:18:08 +0000 | [diff] [blame] | 491 | |
Greg Clayton | a42880a | 2011-10-25 06:44:01 +0000 | [diff] [blame] | 492 | Error error (m_option_group.NotifyOptionParsingFinished()); |
Greg Clayton | 143fcc3 | 2011-04-13 00:18:08 +0000 | [diff] [blame] | 493 | if (error.Fail()) |
| 494 | { |
| 495 | result.AppendError (error.AsCString()); |
| 496 | result.SetStatus (eReturnStatusFailed); |
| 497 | return false; |
| 498 | } |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 499 | } |
| 500 | } |
| 501 | |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 502 | if (expr == NULL) |
| 503 | expr = command; |
Sean Callanan | 46b6249 | 2010-06-24 00:16:27 +0000 | [diff] [blame] | 504 | |
Caroline Tice | 87e1f77 | 2011-06-13 20:20:29 +0000 | [diff] [blame] | 505 | if (EvaluateExpression (expr, &(result.GetOutputStream()), &(result.GetErrorStream()), &result)) |
Johnny Chen | 0deefc7 | 2010-08-13 00:42:30 +0000 | [diff] [blame] | 506 | return true; |
| 507 | |
| 508 | result.SetStatus (eReturnStatusFailed); |
| 509 | return false; |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 510 | } |
| 511 | |