1 //===-- CommandObjectExpression.cpp -----------------------------*- C++ -*-===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 9 #include "llvm/ADT/StringRef.h" 10 11 #include "CommandObjectExpression.h" 12 #include "lldb/Core/Debugger.h" 13 #include "lldb/Expression/REPL.h" 14 #include "lldb/Expression/UserExpression.h" 15 #include "lldb/Host/OptionParser.h" 16 #include "lldb/Interpreter/CommandInterpreter.h" 17 #include "lldb/Interpreter/CommandReturnObject.h" 18 #include "lldb/Interpreter/OptionArgParser.h" 19 #include "lldb/Target/Language.h" 20 #include "lldb/Target/Process.h" 21 #include "lldb/Target/StackFrame.h" 22 #include "lldb/Target/Target.h" 23 24 using namespace lldb; 25 using namespace lldb_private; 26 27 CommandObjectExpression::CommandOptions::CommandOptions() : OptionGroup() {} 28 29 CommandObjectExpression::CommandOptions::~CommandOptions() = default; 30 31 static constexpr OptionEnumValueElement g_description_verbosity_type[] = { 32 { 33 eLanguageRuntimeDescriptionDisplayVerbosityCompact, 34 "compact", 35 "Only show the description string", 36 }, 37 { 38 eLanguageRuntimeDescriptionDisplayVerbosityFull, 39 "full", 40 "Show the full output, including persistent variable's name and type", 41 }, 42 }; 43 44 static constexpr OptionEnumValues DescriptionVerbosityTypes() { 45 return OptionEnumValues(g_description_verbosity_type); 46 } 47 48 #define LLDB_OPTIONS_expression 49 #include "CommandOptions.inc" 50 51 Status CommandObjectExpression::CommandOptions::SetOptionValue( 52 uint32_t option_idx, llvm::StringRef option_arg, 53 ExecutionContext *execution_context) { 54 Status error; 55 56 const int short_option = GetDefinitions()[option_idx].short_option; 57 58 switch (short_option) { 59 case 'l': 60 language = Language::GetLanguageTypeFromString(option_arg); 61 if (language == eLanguageTypeUnknown) 62 error.SetErrorStringWithFormat( 63 "unknown language type: '%s' for expression", 64 option_arg.str().c_str()); 65 break; 66 67 case 'a': { 68 bool success; 69 bool result; 70 result = OptionArgParser::ToBoolean(option_arg, true, &success); 71 if (!success) 72 error.SetErrorStringWithFormat( 73 "invalid all-threads value setting: \"%s\"", 74 option_arg.str().c_str()); 75 else 76 try_all_threads = result; 77 } break; 78 79 case 'i': { 80 bool success; 81 bool tmp_value = OptionArgParser::ToBoolean(option_arg, true, &success); 82 if (success) 83 ignore_breakpoints = tmp_value; 84 else 85 error.SetErrorStringWithFormat( 86 "could not convert \"%s\" to a boolean value.", 87 option_arg.str().c_str()); 88 break; 89 } 90 91 case 'j': { 92 bool success; 93 bool tmp_value = OptionArgParser::ToBoolean(option_arg, true, &success); 94 if (success) 95 allow_jit = tmp_value; 96 else 97 error.SetErrorStringWithFormat( 98 "could not convert \"%s\" to a boolean value.", 99 option_arg.str().c_str()); 100 break; 101 } 102 103 case 't': 104 if (option_arg.getAsInteger(0, timeout)) { 105 timeout = 0; 106 error.SetErrorStringWithFormat("invalid timeout setting \"%s\"", 107 option_arg.str().c_str()); 108 } 109 break; 110 111 case 'u': { 112 bool success; 113 bool tmp_value = OptionArgParser::ToBoolean(option_arg, true, &success); 114 if (success) 115 unwind_on_error = tmp_value; 116 else 117 error.SetErrorStringWithFormat( 118 "could not convert \"%s\" to a boolean value.", 119 option_arg.str().c_str()); 120 break; 121 } 122 123 case 'v': 124 if (option_arg.empty()) { 125 m_verbosity = eLanguageRuntimeDescriptionDisplayVerbosityFull; 126 break; 127 } 128 m_verbosity = (LanguageRuntimeDescriptionDisplayVerbosity) 129 OptionArgParser::ToOptionEnum( 130 option_arg, GetDefinitions()[option_idx].enum_values, 0, error); 131 if (!error.Success()) 132 error.SetErrorStringWithFormat( 133 "unrecognized value for description-verbosity '%s'", 134 option_arg.str().c_str()); 135 break; 136 137 case 'g': 138 debug = true; 139 unwind_on_error = false; 140 ignore_breakpoints = false; 141 break; 142 143 case 'p': 144 top_level = true; 145 break; 146 147 case 'X': { 148 bool success; 149 bool tmp_value = OptionArgParser::ToBoolean(option_arg, true, &success); 150 if (success) 151 auto_apply_fixits = tmp_value ? eLazyBoolYes : eLazyBoolNo; 152 else 153 error.SetErrorStringWithFormat( 154 "could not convert \"%s\" to a boolean value.", 155 option_arg.str().c_str()); 156 break; 157 } 158 159 default: 160 llvm_unreachable("Unimplemented option"); 161 } 162 163 return error; 164 } 165 166 void CommandObjectExpression::CommandOptions::OptionParsingStarting( 167 ExecutionContext *execution_context) { 168 auto process_sp = 169 execution_context ? execution_context->GetProcessSP() : ProcessSP(); 170 if (process_sp) { 171 ignore_breakpoints = process_sp->GetIgnoreBreakpointsInExpressions(); 172 unwind_on_error = process_sp->GetUnwindOnErrorInExpressions(); 173 } else { 174 ignore_breakpoints = true; 175 unwind_on_error = true; 176 } 177 178 show_summary = true; 179 try_all_threads = true; 180 timeout = 0; 181 debug = false; 182 language = eLanguageTypeUnknown; 183 m_verbosity = eLanguageRuntimeDescriptionDisplayVerbosityCompact; 184 auto_apply_fixits = eLazyBoolCalculate; 185 top_level = false; 186 allow_jit = true; 187 } 188 189 llvm::ArrayRef<OptionDefinition> 190 CommandObjectExpression::CommandOptions::GetDefinitions() { 191 return llvm::makeArrayRef(g_expression_options); 192 } 193 194 CommandObjectExpression::CommandObjectExpression( 195 CommandInterpreter &interpreter) 196 : CommandObjectRaw(interpreter, "expression", 197 "Evaluate an expression on the current " 198 "thread. Displays any returned value " 199 "with LLDB's default formatting.", 200 "", 201 eCommandProcessMustBePaused | eCommandTryTargetAPILock), 202 IOHandlerDelegate(IOHandlerDelegate::Completion::Expression), 203 m_option_group(), m_format_options(eFormatDefault), 204 m_repl_option(LLDB_OPT_SET_1, false, "repl", 'r', "Drop into REPL", false, 205 true), 206 m_command_options(), m_expr_line_count(0), m_expr_lines() { 207 SetHelpLong( 208 R"( 209 Single and multi-line expressions: 210 211 )" 212 " The expression provided on the command line must be a complete expression \ 213 with no newlines. To evaluate a multi-line expression, \ 214 hit a return after an empty expression, and lldb will enter the multi-line expression editor. \ 215 Hit return on an empty line to end the multi-line expression." 216 217 R"( 218 219 Timeouts: 220 221 )" 222 " If the expression can be evaluated statically (without running code) then it will be. \ 223 Otherwise, by default the expression will run on the current thread with a short timeout: \ 224 currently .25 seconds. If it doesn't return in that time, the evaluation will be interrupted \ 225 and resumed with all threads running. You can use the -a option to disable retrying on all \ 226 threads. You can use the -t option to set a shorter timeout." 227 R"( 228 229 User defined variables: 230 231 )" 232 " You can define your own variables for convenience or to be used in subsequent expressions. \ 233 You define them the same way you would define variables in C. If the first character of \ 234 your user defined variable is a $, then the variable's value will be available in future \ 235 expressions, otherwise it will just be available in the current expression." 236 R"( 237 238 Continuing evaluation after a breakpoint: 239 240 )" 241 " If the \"-i false\" option is used, and execution is interrupted by a breakpoint hit, once \ 242 you are done with your investigation, you can either remove the expression execution frames \ 243 from the stack with \"thread return -x\" or if you are still interested in the expression result \ 244 you can issue the \"continue\" command and the expression evaluation will complete and the \ 245 expression result will be available using the \"thread.completed-expression\" key in the thread \ 246 format." 247 248 R"( 249 250 Examples: 251 252 expr my_struct->a = my_array[3] 253 expr -f bin -- (index * 8) + 5 254 expr unsigned int $foo = 5 255 expr char c[] = \"foo\"; c[0])"); 256 257 CommandArgumentEntry arg; 258 CommandArgumentData expression_arg; 259 260 // Define the first (and only) variant of this arg. 261 expression_arg.arg_type = eArgTypeExpression; 262 expression_arg.arg_repetition = eArgRepeatPlain; 263 264 // There is only one variant this argument could be; put it into the argument 265 // entry. 266 arg.push_back(expression_arg); 267 268 // Push the data for the first argument into the m_arguments vector. 269 m_arguments.push_back(arg); 270 271 // Add the "--format" and "--gdb-format" 272 m_option_group.Append(&m_format_options, 273 OptionGroupFormat::OPTION_GROUP_FORMAT | 274 OptionGroupFormat::OPTION_GROUP_GDB_FMT, 275 LLDB_OPT_SET_1); 276 m_option_group.Append(&m_command_options); 277 m_option_group.Append(&m_varobj_options, LLDB_OPT_SET_ALL, 278 LLDB_OPT_SET_1 | LLDB_OPT_SET_2); 279 m_option_group.Append(&m_repl_option, LLDB_OPT_SET_ALL, LLDB_OPT_SET_3); 280 m_option_group.Finalize(); 281 } 282 283 CommandObjectExpression::~CommandObjectExpression() = default; 284 285 Options *CommandObjectExpression::GetOptions() { return &m_option_group; } 286 287 void CommandObjectExpression::HandleCompletion(CompletionRequest &request) { 288 EvaluateExpressionOptions options; 289 options.SetCoerceToId(m_varobj_options.use_objc); 290 options.SetLanguage(m_command_options.language); 291 options.SetExecutionPolicy(lldb_private::eExecutionPolicyNever); 292 options.SetAutoApplyFixIts(false); 293 options.SetGenerateDebugInfo(false); 294 295 // We need a valid execution context with a frame pointer for this 296 // completion, so if we don't have one we should try to make a valid 297 // execution context. 298 if (m_interpreter.GetExecutionContext().GetFramePtr() == nullptr) 299 m_interpreter.UpdateExecutionContext(nullptr); 300 301 // This didn't work, so let's get out before we start doing things that 302 // expect a valid frame pointer. 303 if (m_interpreter.GetExecutionContext().GetFramePtr() == nullptr) 304 return; 305 306 ExecutionContext exe_ctx(m_interpreter.GetExecutionContext()); 307 308 Target *target = exe_ctx.GetTargetPtr(); 309 310 if (!target) 311 target = &GetDummyTarget(); 312 313 unsigned cursor_pos = request.GetRawCursorPos(); 314 llvm::StringRef code = request.GetRawLine(); 315 316 const std::size_t original_code_size = code.size(); 317 318 // Remove the first token which is 'expr' or some alias/abbreviation of that. 319 code = llvm::getToken(code).second.ltrim(); 320 OptionsWithRaw args(code); 321 code = args.GetRawPart(); 322 323 // The position where the expression starts in the command line. 324 assert(original_code_size >= code.size()); 325 std::size_t raw_start = original_code_size - code.size(); 326 327 // Check if the cursor is actually in the expression string, and if not, we 328 // exit. 329 // FIXME: We should complete the options here. 330 if (cursor_pos < raw_start) 331 return; 332 333 // Make the cursor_pos again relative to the start of the code string. 334 assert(cursor_pos >= raw_start); 335 cursor_pos -= raw_start; 336 337 auto language = exe_ctx.GetFrameRef().GetLanguage(); 338 339 Status error; 340 lldb::UserExpressionSP expr(target->GetUserExpressionForLanguage( 341 code, llvm::StringRef(), language, UserExpression::eResultTypeAny, 342 options, nullptr, error)); 343 if (error.Fail()) 344 return; 345 346 expr->Complete(exe_ctx, request, cursor_pos); 347 } 348 349 static lldb_private::Status 350 CanBeUsedForElementCountPrinting(ValueObject &valobj) { 351 CompilerType type(valobj.GetCompilerType()); 352 CompilerType pointee; 353 if (!type.IsPointerType(&pointee)) 354 return Status("as it does not refer to a pointer"); 355 if (pointee.IsVoidType()) 356 return Status("as it refers to a pointer to void"); 357 return Status(); 358 } 359 360 bool CommandObjectExpression::EvaluateExpression(llvm::StringRef expr, 361 Stream *output_stream, 362 Stream *error_stream, 363 CommandReturnObject *result) { 364 // Don't use m_exe_ctx as this might be called asynchronously after the 365 // command object DoExecute has finished when doing multi-line expression 366 // that use an input reader... 367 ExecutionContext exe_ctx(m_interpreter.GetExecutionContext()); 368 369 Target *target = exe_ctx.GetTargetPtr(); 370 371 if (!target) 372 target = &GetDummyTarget(); 373 374 lldb::ValueObjectSP result_valobj_sp; 375 bool keep_in_memory = true; 376 StackFrame *frame = exe_ctx.GetFramePtr(); 377 378 EvaluateExpressionOptions options; 379 options.SetCoerceToId(m_varobj_options.use_objc); 380 options.SetUnwindOnError(m_command_options.unwind_on_error); 381 options.SetIgnoreBreakpoints(m_command_options.ignore_breakpoints); 382 options.SetKeepInMemory(keep_in_memory); 383 options.SetUseDynamic(m_varobj_options.use_dynamic); 384 options.SetTryAllThreads(m_command_options.try_all_threads); 385 options.SetDebug(m_command_options.debug); 386 options.SetLanguage(m_command_options.language); 387 options.SetExecutionPolicy( 388 m_command_options.allow_jit 389 ? EvaluateExpressionOptions::default_execution_policy 390 : lldb_private::eExecutionPolicyNever); 391 392 bool auto_apply_fixits; 393 if (m_command_options.auto_apply_fixits == eLazyBoolCalculate) 394 auto_apply_fixits = target->GetEnableAutoApplyFixIts(); 395 else 396 auto_apply_fixits = m_command_options.auto_apply_fixits == eLazyBoolYes; 397 398 options.SetAutoApplyFixIts(auto_apply_fixits); 399 400 if (m_command_options.top_level) 401 options.SetExecutionPolicy(eExecutionPolicyTopLevel); 402 403 // If there is any chance we are going to stop and want to see what went 404 // wrong with our expression, we should generate debug info 405 if (!m_command_options.ignore_breakpoints || 406 !m_command_options.unwind_on_error) 407 options.SetGenerateDebugInfo(true); 408 409 if (m_command_options.timeout > 0) 410 options.SetTimeout(std::chrono::microseconds(m_command_options.timeout)); 411 else 412 options.SetTimeout(llvm::None); 413 414 ExpressionResults success = target->EvaluateExpression( 415 expr, frame, result_valobj_sp, options, &m_fixed_expression); 416 417 // We only tell you about the FixIt if we applied it. The compiler errors 418 // will suggest the FixIt if it parsed. 419 if (error_stream && !m_fixed_expression.empty() && 420 target->GetEnableNotifyAboutFixIts()) { 421 if (success == eExpressionCompleted) 422 error_stream->Printf(" Fix-it applied, fixed expression was: \n %s\n", 423 m_fixed_expression.c_str()); 424 } 425 426 if (result_valobj_sp) { 427 Format format = m_format_options.GetFormat(); 428 429 if (result_valobj_sp->GetError().Success()) { 430 if (format != eFormatVoid) { 431 if (format != eFormatDefault) 432 result_valobj_sp->SetFormat(format); 433 434 if (m_varobj_options.elem_count > 0) { 435 Status error(CanBeUsedForElementCountPrinting(*result_valobj_sp)); 436 if (error.Fail()) { 437 result->AppendErrorWithFormat( 438 "expression cannot be used with --element-count %s\n", 439 error.AsCString("")); 440 result->SetStatus(eReturnStatusFailed); 441 return false; 442 } 443 } 444 445 DumpValueObjectOptions options(m_varobj_options.GetAsDumpOptions( 446 m_command_options.m_verbosity, format)); 447 options.SetVariableFormatDisplayLanguage( 448 result_valobj_sp->GetPreferredDisplayLanguage()); 449 450 result_valobj_sp->Dump(*output_stream, options); 451 452 if (result) 453 result->SetStatus(eReturnStatusSuccessFinishResult); 454 } 455 } else { 456 if (result_valobj_sp->GetError().GetError() == 457 UserExpression::kNoResult) { 458 if (format != eFormatVoid && GetDebugger().GetNotifyVoid()) { 459 error_stream->PutCString("(void)\n"); 460 } 461 462 if (result) 463 result->SetStatus(eReturnStatusSuccessFinishResult); 464 } else { 465 const char *error_cstr = result_valobj_sp->GetError().AsCString(); 466 if (error_cstr && error_cstr[0]) { 467 const size_t error_cstr_len = strlen(error_cstr); 468 const bool ends_with_newline = error_cstr[error_cstr_len - 1] == '\n'; 469 if (strstr(error_cstr, "error:") != error_cstr) 470 error_stream->PutCString("error: "); 471 error_stream->Write(error_cstr, error_cstr_len); 472 if (!ends_with_newline) 473 error_stream->EOL(); 474 } else { 475 error_stream->PutCString("error: unknown error\n"); 476 } 477 478 if (result) 479 result->SetStatus(eReturnStatusFailed); 480 } 481 } 482 } 483 484 return true; 485 } 486 487 void CommandObjectExpression::IOHandlerInputComplete(IOHandler &io_handler, 488 std::string &line) { 489 io_handler.SetIsDone(true); 490 // StreamSP output_stream = 491 // io_handler.GetDebugger().GetAsyncOutputStream(); 492 // StreamSP error_stream = io_handler.GetDebugger().GetAsyncErrorStream(); 493 StreamFileSP output_sp = io_handler.GetOutputStreamFileSP(); 494 StreamFileSP error_sp = io_handler.GetErrorStreamFileSP(); 495 496 EvaluateExpression(line.c_str(), output_sp.get(), error_sp.get()); 497 if (output_sp) 498 output_sp->Flush(); 499 if (error_sp) 500 error_sp->Flush(); 501 } 502 503 bool CommandObjectExpression::IOHandlerIsInputComplete(IOHandler &io_handler, 504 StringList &lines) { 505 // An empty lines is used to indicate the end of input 506 const size_t num_lines = lines.GetSize(); 507 if (num_lines > 0 && lines[num_lines - 1].empty()) { 508 // Remove the last empty line from "lines" so it doesn't appear in our 509 // resulting input and return true to indicate we are done getting lines 510 lines.PopBack(); 511 return true; 512 } 513 return false; 514 } 515 516 void CommandObjectExpression::GetMultilineExpression() { 517 m_expr_lines.clear(); 518 m_expr_line_count = 0; 519 520 Debugger &debugger = GetCommandInterpreter().GetDebugger(); 521 bool color_prompt = debugger.GetUseColor(); 522 const bool multiple_lines = true; // Get multiple lines 523 IOHandlerSP io_handler_sp( 524 new IOHandlerEditline(debugger, IOHandler::Type::Expression, 525 "lldb-expr", // Name of input reader for history 526 llvm::StringRef(), // No prompt 527 llvm::StringRef(), // Continuation prompt 528 multiple_lines, color_prompt, 529 1, // Show line numbers starting at 1 530 *this, nullptr)); 531 532 StreamFileSP output_sp = io_handler_sp->GetOutputStreamFileSP(); 533 if (output_sp) { 534 output_sp->PutCString( 535 "Enter expressions, then terminate with an empty line to evaluate:\n"); 536 output_sp->Flush(); 537 } 538 debugger.PushIOHandler(io_handler_sp); 539 } 540 541 static EvaluateExpressionOptions 542 GetExprOptions(ExecutionContext &ctx, 543 CommandObjectExpression::CommandOptions command_options) { 544 command_options.OptionParsingStarting(&ctx); 545 546 // Default certain settings for REPL regardless of the global settings. 547 command_options.unwind_on_error = false; 548 command_options.ignore_breakpoints = false; 549 command_options.debug = false; 550 551 EvaluateExpressionOptions expr_options; 552 expr_options.SetUnwindOnError(command_options.unwind_on_error); 553 expr_options.SetIgnoreBreakpoints(command_options.ignore_breakpoints); 554 expr_options.SetTryAllThreads(command_options.try_all_threads); 555 556 if (command_options.timeout > 0) 557 expr_options.SetTimeout(std::chrono::microseconds(command_options.timeout)); 558 else 559 expr_options.SetTimeout(llvm::None); 560 561 return expr_options; 562 } 563 564 bool CommandObjectExpression::DoExecute(llvm::StringRef command, 565 CommandReturnObject &result) { 566 m_fixed_expression.clear(); 567 auto exe_ctx = GetCommandInterpreter().GetExecutionContext(); 568 m_option_group.NotifyOptionParsingStarting(&exe_ctx); 569 570 if (command.empty()) { 571 GetMultilineExpression(); 572 return result.Succeeded(); 573 } 574 575 OptionsWithRaw args(command); 576 llvm::StringRef expr = args.GetRawPart(); 577 578 if (args.HasArgs()) { 579 if (!ParseOptionsAndNotify(args.GetArgs(), result, m_option_group, exe_ctx)) 580 return false; 581 582 if (m_repl_option.GetOptionValue().GetCurrentValue()) { 583 Target &target = GetSelectedOrDummyTarget(); 584 // Drop into REPL 585 m_expr_lines.clear(); 586 m_expr_line_count = 0; 587 588 Debugger &debugger = target.GetDebugger(); 589 590 // Check if the LLDB command interpreter is sitting on top of a REPL 591 // that launched it... 592 if (debugger.CheckTopIOHandlerTypes(IOHandler::Type::CommandInterpreter, 593 IOHandler::Type::REPL)) { 594 // the LLDB command interpreter is sitting on top of a REPL that 595 // launched it, so just say the command interpreter is done and 596 // fall back to the existing REPL 597 m_interpreter.GetIOHandler(false)->SetIsDone(true); 598 } else { 599 // We are launching the REPL on top of the current LLDB command 600 // interpreter, so just push one 601 bool initialize = false; 602 Status repl_error; 603 REPLSP repl_sp(target.GetREPL(repl_error, m_command_options.language, 604 nullptr, false)); 605 606 if (!repl_sp) { 607 initialize = true; 608 repl_sp = target.GetREPL(repl_error, m_command_options.language, 609 nullptr, true); 610 if (!repl_error.Success()) { 611 result.SetError(repl_error); 612 return result.Succeeded(); 613 } 614 } 615 616 if (repl_sp) { 617 if (initialize) { 618 repl_sp->SetEvaluateOptions( 619 GetExprOptions(exe_ctx, m_command_options)); 620 repl_sp->SetFormatOptions(m_format_options); 621 repl_sp->SetValueObjectDisplayOptions(m_varobj_options); 622 } 623 624 IOHandlerSP io_handler_sp(repl_sp->GetIOHandler()); 625 626 io_handler_sp->SetIsDone(false); 627 628 debugger.PushIOHandler(io_handler_sp); 629 } else { 630 repl_error.SetErrorStringWithFormat( 631 "Couldn't create a REPL for %s", 632 Language::GetNameForLanguageType(m_command_options.language)); 633 result.SetError(repl_error); 634 return result.Succeeded(); 635 } 636 } 637 } 638 // No expression following options 639 else if (expr.empty()) { 640 GetMultilineExpression(); 641 return result.Succeeded(); 642 } 643 } 644 645 Target &target = GetSelectedOrDummyTarget(); 646 if (EvaluateExpression(expr, &(result.GetOutputStream()), 647 &(result.GetErrorStream()), &result)) { 648 649 if (!m_fixed_expression.empty() && target.GetEnableNotifyAboutFixIts()) { 650 CommandHistory &history = m_interpreter.GetCommandHistory(); 651 // FIXME: Can we figure out what the user actually typed (e.g. some alias 652 // for expr???) 653 // If we can it would be nice to show that. 654 std::string fixed_command("expression "); 655 if (args.HasArgs()) { 656 // Add in any options that might have been in the original command: 657 fixed_command.append(args.GetArgStringWithDelimiter()); 658 fixed_command.append(m_fixed_expression); 659 } else 660 fixed_command.append(m_fixed_expression); 661 history.AppendString(fixed_command); 662 } 663 // Increment statistics to record this expression evaluation success. 664 target.IncrementStats(StatisticKind::ExpressionSuccessful); 665 return true; 666 } 667 668 // Increment statistics to record this expression evaluation failure. 669 target.IncrementStats(StatisticKind::ExpressionFailure); 670 result.SetStatus(eReturnStatusFailed); 671 return false; 672 } 673