| //===-- CommandObjectSource.cpp ---------------------------------*- C++ -*-===// |
| // |
| // The LLVM Compiler Infrastructure |
| // |
| // This file is distributed under the University of Illinois Open Source |
| // License. See LICENSE.TXT for details. |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #include "lldb/lldb-python.h" |
| |
| #include "CommandObjectCommands.h" |
| |
| // C Includes |
| // C++ Includes |
| // Other libraries and framework includes |
| #include "llvm/ADT/StringRef.h" |
| |
| // Project includes |
| #include "lldb/Core/Debugger.h" |
| #include "lldb/Core/IOHandler.h" |
| #include "lldb/Core/StringList.h" |
| #include "lldb/Interpreter/Args.h" |
| #include "lldb/Interpreter/CommandHistory.h" |
| #include "lldb/Interpreter/CommandInterpreter.h" |
| #include "lldb/Interpreter/CommandObjectRegexCommand.h" |
| #include "lldb/Interpreter/CommandReturnObject.h" |
| #include "lldb/Interpreter/OptionValueBoolean.h" |
| #include "lldb/Interpreter/OptionValueUInt64.h" |
| #include "lldb/Interpreter/Options.h" |
| #include "lldb/Interpreter/ScriptInterpreter.h" |
| #include "lldb/Interpreter/ScriptInterpreterPython.h" |
| |
| using namespace lldb; |
| using namespace lldb_private; |
| |
| //------------------------------------------------------------------------- |
| // CommandObjectCommandsSource |
| //------------------------------------------------------------------------- |
| |
| class CommandObjectCommandsHistory : public CommandObjectParsed |
| { |
| public: |
| CommandObjectCommandsHistory(CommandInterpreter &interpreter) : |
| CommandObjectParsed (interpreter, |
| "command history", |
| "Dump the history of commands in this session.", |
| NULL), |
| m_options (interpreter) |
| { |
| } |
| |
| ~CommandObjectCommandsHistory () {} |
| |
| virtual Options * |
| GetOptions () |
| { |
| return &m_options; |
| } |
| |
| protected: |
| |
| class CommandOptions : public Options |
| { |
| public: |
| |
| CommandOptions (CommandInterpreter &interpreter) : |
| Options (interpreter), |
| m_start_idx(0), |
| m_stop_idx(0), |
| m_count(0), |
| m_clear(false) |
| { |
| } |
| |
| virtual |
| ~CommandOptions (){} |
| |
| virtual Error |
| SetOptionValue (uint32_t option_idx, const char *option_arg) |
| { |
| Error error; |
| const int short_option = m_getopt_table[option_idx].val; |
| |
| switch (short_option) |
| { |
| case 'c': |
| error = m_count.SetValueFromCString(option_arg,eVarSetOperationAssign); |
| break; |
| case 's': |
| if (option_arg && strcmp("end", option_arg) == 0) |
| { |
| m_start_idx.SetCurrentValue(UINT64_MAX); |
| m_start_idx.SetOptionWasSet(); |
| } |
| else |
| error = m_start_idx.SetValueFromCString(option_arg,eVarSetOperationAssign); |
| break; |
| case 'e': |
| error = m_stop_idx.SetValueFromCString(option_arg,eVarSetOperationAssign); |
| break; |
| case 'C': |
| m_clear.SetCurrentValue(true); |
| m_clear.SetOptionWasSet(); |
| break; |
| default: |
| error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option); |
| break; |
| } |
| |
| return error; |
| } |
| |
| void |
| OptionParsingStarting () |
| { |
| m_start_idx.Clear(); |
| m_stop_idx.Clear(); |
| m_count.Clear(); |
| m_clear.Clear(); |
| } |
| |
| const OptionDefinition* |
| GetDefinitions () |
| { |
| return g_option_table; |
| } |
| |
| // Options table: Required for subclasses of Options. |
| |
| static OptionDefinition g_option_table[]; |
| |
| // Instance variables to hold the values for command options. |
| |
| OptionValueUInt64 m_start_idx; |
| OptionValueUInt64 m_stop_idx; |
| OptionValueUInt64 m_count; |
| OptionValueBoolean m_clear; |
| }; |
| |
| bool |
| DoExecute (Args& command, CommandReturnObject &result) |
| { |
| if (m_options.m_clear.GetCurrentValue() && m_options.m_clear.OptionWasSet()) |
| { |
| m_interpreter.GetCommandHistory().Clear(); |
| result.SetStatus(lldb::eReturnStatusSuccessFinishNoResult); |
| } |
| else |
| { |
| if (m_options.m_start_idx.OptionWasSet() && m_options.m_stop_idx.OptionWasSet() && m_options.m_count.OptionWasSet()) |
| { |
| result.AppendError("--count, --start-index and --end-index cannot be all specified in the same invocation"); |
| result.SetStatus(lldb::eReturnStatusFailed); |
| } |
| else |
| { |
| std::pair<bool,uint64_t> start_idx(m_options.m_start_idx.OptionWasSet(),m_options.m_start_idx.GetCurrentValue()); |
| std::pair<bool,uint64_t> stop_idx(m_options.m_stop_idx.OptionWasSet(),m_options.m_stop_idx.GetCurrentValue()); |
| std::pair<bool,uint64_t> count(m_options.m_count.OptionWasSet(),m_options.m_count.GetCurrentValue()); |
| |
| const CommandHistory& history(m_interpreter.GetCommandHistory()); |
| |
| if (start_idx.first && start_idx.second == UINT64_MAX) |
| { |
| if (count.first) |
| { |
| start_idx.second = history.GetSize() - count.second; |
| stop_idx.second = history.GetSize() - 1; |
| } |
| else if (stop_idx.first) |
| { |
| start_idx.second = stop_idx.second; |
| stop_idx.second = history.GetSize() - 1; |
| } |
| else |
| { |
| start_idx.second = 0; |
| stop_idx.second = history.GetSize() - 1; |
| } |
| } |
| else |
| { |
| if (!start_idx.first && !stop_idx.first && !count.first) |
| { |
| start_idx.second = 0; |
| stop_idx.second = history.GetSize() - 1; |
| } |
| else if (start_idx.first) |
| { |
| if (count.first) |
| { |
| stop_idx.second = start_idx.second + count.second - 1; |
| } |
| else if (!stop_idx.first) |
| { |
| stop_idx.second = history.GetSize() - 1; |
| } |
| } |
| else if (stop_idx.first) |
| { |
| if (count.first) |
| { |
| if (stop_idx.second >= count.second) |
| start_idx.second = stop_idx.second - count.second + 1; |
| else |
| start_idx.second = 0; |
| } |
| } |
| else /* if (count.first) */ |
| { |
| start_idx.second = 0; |
| stop_idx.second = count.second - 1; |
| } |
| } |
| history.Dump(result.GetOutputStream(), start_idx.second, stop_idx.second); |
| } |
| } |
| return result.Succeeded(); |
| |
| } |
| |
| CommandOptions m_options; |
| }; |
| |
| OptionDefinition |
| CommandObjectCommandsHistory::CommandOptions::g_option_table[] = |
| { |
| { LLDB_OPT_SET_1, false, "count", 'c', OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypeUnsignedInteger, "How many history commands to print."}, |
| { LLDB_OPT_SET_1, false, "start-index", 's', OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypeUnsignedInteger, "Index at which to start printing history commands (or end to mean tail mode)."}, |
| { LLDB_OPT_SET_1, false, "end-index", 'e', OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypeUnsignedInteger, "Index at which to stop printing history commands."}, |
| { LLDB_OPT_SET_2, false, "clear", 'C', OptionParser::eNoArgument, NULL, NULL, 0, eArgTypeBoolean, "Clears the current command history."}, |
| { 0, false, NULL, 0, 0, NULL, NULL, 0, eArgTypeNone, NULL } |
| }; |
| |
| |
| //------------------------------------------------------------------------- |
| // CommandObjectCommandsSource |
| //------------------------------------------------------------------------- |
| |
| class CommandObjectCommandsSource : public CommandObjectParsed |
| { |
| public: |
| CommandObjectCommandsSource(CommandInterpreter &interpreter) : |
| CommandObjectParsed (interpreter, |
| "command source", |
| "Read in debugger commands from the file <filename> and execute them.", |
| NULL), |
| m_options (interpreter) |
| { |
| CommandArgumentEntry arg; |
| CommandArgumentData file_arg; |
| |
| // Define the first (and only) variant of this arg. |
| file_arg.arg_type = eArgTypeFilename; |
| file_arg.arg_repetition = eArgRepeatPlain; |
| |
| // There is only one variant this argument could be; put it into the argument entry. |
| arg.push_back (file_arg); |
| |
| // Push the data for the first argument into the m_arguments vector. |
| m_arguments.push_back (arg); |
| } |
| |
| ~CommandObjectCommandsSource () {} |
| |
| virtual const char* |
| GetRepeatCommand (Args ¤t_command_args, uint32_t index) |
| { |
| return ""; |
| } |
| |
| virtual int |
| HandleArgumentCompletion (Args &input, |
| int &cursor_index, |
| int &cursor_char_position, |
| OptionElementVector &opt_element_vector, |
| int match_start_point, |
| int max_return_elements, |
| bool &word_complete, |
| StringList &matches) |
| { |
| std::string completion_str (input.GetArgumentAtIndex(cursor_index)); |
| completion_str.erase (cursor_char_position); |
| |
| CommandCompletions::InvokeCommonCompletionCallbacks (m_interpreter, |
| CommandCompletions::eDiskFileCompletion, |
| completion_str.c_str(), |
| match_start_point, |
| max_return_elements, |
| NULL, |
| word_complete, |
| matches); |
| return matches.GetSize(); |
| } |
| |
| virtual Options * |
| GetOptions () |
| { |
| return &m_options; |
| } |
| |
| protected: |
| |
| class CommandOptions : public Options |
| { |
| public: |
| |
| CommandOptions (CommandInterpreter &interpreter) : |
| Options (interpreter), |
| m_stop_on_error (true), |
| m_silent_run (false), |
| m_stop_on_continue (true) |
| { |
| } |
| |
| virtual |
| ~CommandOptions (){} |
| |
| virtual Error |
| SetOptionValue (uint32_t option_idx, const char *option_arg) |
| { |
| Error error; |
| const int short_option = m_getopt_table[option_idx].val; |
| |
| switch (short_option) |
| { |
| case 'e': |
| error = m_stop_on_error.SetValueFromCString(option_arg); |
| break; |
| |
| case 'c': |
| error = m_stop_on_continue.SetValueFromCString(option_arg); |
| break; |
| |
| case 's': |
| error = m_silent_run.SetValueFromCString(option_arg); |
| break; |
| |
| default: |
| error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option); |
| break; |
| } |
| |
| return error; |
| } |
| |
| void |
| OptionParsingStarting () |
| { |
| m_stop_on_error.Clear(); |
| m_silent_run.Clear(); |
| m_stop_on_continue.Clear(); |
| } |
| |
| const OptionDefinition* |
| GetDefinitions () |
| { |
| return g_option_table; |
| } |
| |
| // Options table: Required for subclasses of Options. |
| |
| static OptionDefinition g_option_table[]; |
| |
| // Instance variables to hold the values for command options. |
| |
| OptionValueBoolean m_stop_on_error; |
| OptionValueBoolean m_silent_run; |
| OptionValueBoolean m_stop_on_continue; |
| }; |
| |
| bool |
| DoExecute(Args& command, CommandReturnObject &result) |
| { |
| const size_t argc = command.GetArgumentCount(); |
| if (argc == 1) |
| { |
| const char *filename = command.GetArgumentAtIndex(0); |
| |
| FileSpec cmd_file (filename, true); |
| ExecutionContext *exe_ctx = NULL; // Just use the default context. |
| |
| // If any options were set, then use them |
| if (m_options.m_stop_on_error.OptionWasSet() || |
| m_options.m_silent_run.OptionWasSet() || |
| m_options.m_stop_on_continue.OptionWasSet()) |
| { |
| // Use user set settings |
| LazyBool print_command = m_options.m_silent_run.GetCurrentValue() ? eLazyBoolNo : eLazyBoolYes; |
| m_interpreter.HandleCommandsFromFile (cmd_file, |
| exe_ctx, |
| m_options.m_stop_on_continue.GetCurrentValue() ? eLazyBoolYes : eLazyBoolNo, // Stop on continue |
| m_options.m_stop_on_error.GetCurrentValue() ? eLazyBoolYes : eLazyBoolNo, // Stop on error |
| print_command, // Echo command |
| print_command, // Print command output |
| eLazyBoolCalculate, // Add to history |
| result); |
| |
| } |
| else |
| { |
| // No options were set, inherit any settings from nested "command source" commands, |
| // or set to sane default settings... |
| m_interpreter.HandleCommandsFromFile (cmd_file, |
| exe_ctx, |
| eLazyBoolCalculate, // Stop on continue |
| eLazyBoolCalculate, // Stop on error |
| eLazyBoolCalculate, // Echo command |
| eLazyBoolCalculate, // Print command output |
| eLazyBoolCalculate, // Add to history |
| result); |
| |
| } |
| } |
| else |
| { |
| result.AppendErrorWithFormat("'%s' takes exactly one executable filename argument.\n", GetCommandName()); |
| result.SetStatus (eReturnStatusFailed); |
| } |
| return result.Succeeded(); |
| |
| } |
| CommandOptions m_options; |
| }; |
| |
| OptionDefinition |
| CommandObjectCommandsSource::CommandOptions::g_option_table[] = |
| { |
| { LLDB_OPT_SET_ALL, false, "stop-on-error", 'e', OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypeBoolean, "If true, stop executing commands on error."}, |
| { LLDB_OPT_SET_ALL, false, "stop-on-continue", 'c', OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypeBoolean, "If true, stop executing commands on continue."}, |
| { LLDB_OPT_SET_ALL, false, "silent-run", 's', OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypeBoolean, "If true don't echo commands while executing."}, |
| { 0, false, NULL, 0, 0, NULL, NULL, 0, eArgTypeNone, NULL } |
| }; |
| |
| #pragma mark CommandObjectCommandsAlias |
| //------------------------------------------------------------------------- |
| // CommandObjectCommandsAlias |
| //------------------------------------------------------------------------- |
| |
| static const char *g_python_command_instructions = "Enter your Python command(s). Type 'DONE' to end.\n" |
| "You must define a Python function with this signature:\n" |
| "def my_command_impl(debugger, args, result, internal_dict):\n"; |
| |
| |
| class CommandObjectCommandsAlias : public CommandObjectRaw |
| { |
| |
| |
| public: |
| CommandObjectCommandsAlias (CommandInterpreter &interpreter) : |
| CommandObjectRaw (interpreter, |
| "command alias", |
| "Allow users to define their own debugger command abbreviations.", |
| NULL) |
| { |
| SetHelpLong( |
| "'alias' allows the user to create a short-cut or abbreviation for long \n\ |
| commands, multi-word commands, and commands that take particular options. \n\ |
| Below are some simple examples of how one might use the 'alias' command: \n\ |
| \n 'command alias sc script' // Creates the abbreviation 'sc' for the 'script' \n\ |
| // command. \n\ |
| 'command alias bp breakpoint' // Creates the abbreviation 'bp' for the 'breakpoint' \n\ |
| // command. Since breakpoint commands are two-word \n\ |
| // commands, the user will still need to enter the \n\ |
| // second word after 'bp', e.g. 'bp enable' or \n\ |
| // 'bp delete'. \n\ |
| 'command alias bpl breakpoint list' // Creates the abbreviation 'bpl' for the \n\ |
| // two-word command 'breakpoint list'. \n\ |
| \nAn alias can include some options for the command, with the values either \n\ |
| filled in at the time the alias is created, or specified as positional \n\ |
| arguments, to be filled in when the alias is invoked. The following example \n\ |
| shows how to create aliases with options: \n\ |
| \n\ |
| 'command alias bfl breakpoint set -f %1 -l %2' \n\ |
| \nThis creates the abbreviation 'bfl' (for break-file-line), with the -f and -l \n\ |
| options already part of the alias. So if the user wants to set a breakpoint \n\ |
| by file and line without explicitly having to use the -f and -l options, the \n\ |
| user can now use 'bfl' instead. The '%1' and '%2' are positional placeholders \n\ |
| for the actual arguments that will be passed when the alias command is used. \n\ |
| The number in the placeholder refers to the position/order the actual value \n\ |
| occupies when the alias is used. All the occurrences of '%1' in the alias \n\ |
| will be replaced with the first argument, all the occurrences of '%2' in the \n\ |
| alias will be replaced with the second argument, and so on. This also allows \n\ |
| actual arguments to be used multiple times within an alias (see 'process \n\ |
| launch' example below). \n\ |
| Note: the positional arguments must substitute as whole words in the resultant\n\ |
| command, so you can't at present do something like:\n\ |
| \n\ |
| command alias bcppfl breakpoint set -f %1.cpp -l %2\n\ |
| \n\ |
| to get the file extension \".cpp\" automatically appended. For more complex\n\ |
| aliasing, use the \"command regex\" command instead.\n\ |
| \nSo in the 'bfl' case, the actual file value will be \n\ |
| filled in with the first argument following 'bfl' and the actual line number \n\ |
| value will be filled in with the second argument. The user would use this \n\ |
| alias as follows: \n\ |
| \n (lldb) command alias bfl breakpoint set -f %1 -l %2 \n\ |
| <... some time later ...> \n\ |
| (lldb) bfl my-file.c 137 \n\ |
| \nThis would be the same as if the user had entered \n\ |
| 'breakpoint set -f my-file.c -l 137'. \n\ |
| \nAnother example: \n\ |
| \n (lldb) command alias pltty process launch -s -o %1 -e %1 \n\ |
| (lldb) pltty /dev/tty0 \n\ |
| // becomes 'process launch -s -o /dev/tty0 -e /dev/tty0' \n\ |
| \nIf the user always wanted to pass the same value to a particular option, the \n\ |
| alias could be defined with that value directly in the alias as a constant, \n\ |
| rather than using a positional placeholder: \n\ |
| \n command alias bl3 breakpoint set -f %1 -l 3 // Always sets a breakpoint on line \n\ |
| // 3 of whatever file is indicated. \n"); |
| |
| CommandArgumentEntry arg1; |
| CommandArgumentEntry arg2; |
| CommandArgumentEntry arg3; |
| CommandArgumentData alias_arg; |
| CommandArgumentData cmd_arg; |
| CommandArgumentData options_arg; |
| |
| // Define the first (and only) variant of this arg. |
| alias_arg.arg_type = eArgTypeAliasName; |
| alias_arg.arg_repetition = eArgRepeatPlain; |
| |
| // There is only one variant this argument could be; put it into the argument entry. |
| arg1.push_back (alias_arg); |
| |
| // Define the first (and only) variant of this arg. |
| cmd_arg.arg_type = eArgTypeCommandName; |
| cmd_arg.arg_repetition = eArgRepeatPlain; |
| |
| // There is only one variant this argument could be; put it into the argument entry. |
| arg2.push_back (cmd_arg); |
| |
| // Define the first (and only) variant of this arg. |
| options_arg.arg_type = eArgTypeAliasOptions; |
| options_arg.arg_repetition = eArgRepeatOptional; |
| |
| // There is only one variant this argument could be; put it into the argument entry. |
| arg3.push_back (options_arg); |
| |
| // Push the data for the first argument into the m_arguments vector. |
| m_arguments.push_back (arg1); |
| m_arguments.push_back (arg2); |
| m_arguments.push_back (arg3); |
| } |
| |
| ~CommandObjectCommandsAlias () |
| { |
| } |
| |
| protected: |
| virtual bool |
| DoExecute (const char *raw_command_line, CommandReturnObject &result) |
| { |
| Args args (raw_command_line); |
| std::string raw_command_string (raw_command_line); |
| |
| size_t argc = args.GetArgumentCount(); |
| |
| if (argc < 2) |
| { |
| result.AppendError ("'alias' requires at least two arguments"); |
| result.SetStatus (eReturnStatusFailed); |
| return false; |
| } |
| |
| // Get the alias command. |
| |
| const std::string alias_command = args.GetArgumentAtIndex (0); |
| |
| // Strip the new alias name off 'raw_command_string' (leave it on args, which gets passed to 'Execute', which |
| // does the stripping itself. |
| size_t pos = raw_command_string.find (alias_command); |
| if (pos == 0) |
| { |
| raw_command_string = raw_command_string.substr (alias_command.size()); |
| pos = raw_command_string.find_first_not_of (' '); |
| if ((pos != std::string::npos) && (pos > 0)) |
| raw_command_string = raw_command_string.substr (pos); |
| } |
| else |
| { |
| result.AppendError ("Error parsing command string. No alias created."); |
| result.SetStatus (eReturnStatusFailed); |
| return false; |
| } |
| |
| |
| // Verify that the command is alias-able. |
| if (m_interpreter.CommandExists (alias_command.c_str())) |
| { |
| result.AppendErrorWithFormat ("'%s' is a permanent debugger command and cannot be redefined.\n", |
| alias_command.c_str()); |
| result.SetStatus (eReturnStatusFailed); |
| return false; |
| } |
| |
| // Get CommandObject that is being aliased. The command name is read from the front of raw_command_string. |
| // raw_command_string is returned with the name of the command object stripped off the front. |
| CommandObject *cmd_obj = m_interpreter.GetCommandObjectForCommand (raw_command_string); |
| |
| if (!cmd_obj) |
| { |
| result.AppendErrorWithFormat ("invalid command given to 'alias'. '%s' does not begin with a valid command." |
| " No alias created.", raw_command_string.c_str()); |
| result.SetStatus (eReturnStatusFailed); |
| return false; |
| } |
| else if (!cmd_obj->WantsRawCommandString ()) |
| { |
| // Note that args was initialized with the original command, and has not been updated to this point. |
| // Therefore can we pass it to the version of Execute that does not need/expect raw input in the alias. |
| return HandleAliasingNormalCommand (args, result); |
| } |
| else |
| { |
| return HandleAliasingRawCommand (alias_command, raw_command_string, *cmd_obj, result); |
| } |
| return result.Succeeded(); |
| } |
| |
| bool |
| HandleAliasingRawCommand (const std::string &alias_command, std::string &raw_command_string, CommandObject &cmd_obj, CommandReturnObject &result) |
| { |
| // Verify & handle any options/arguments passed to the alias command |
| |
| OptionArgVectorSP option_arg_vector_sp = OptionArgVectorSP (new OptionArgVector); |
| OptionArgVector *option_arg_vector = option_arg_vector_sp.get(); |
| |
| CommandObjectSP cmd_obj_sp = m_interpreter.GetCommandSPExact (cmd_obj.GetCommandName(), false); |
| |
| if (!m_interpreter.ProcessAliasOptionsArgs (cmd_obj_sp, raw_command_string.c_str(), option_arg_vector_sp)) |
| { |
| result.AppendError ("Unable to create requested alias.\n"); |
| result.SetStatus (eReturnStatusFailed); |
| return false; |
| } |
| |
| // Create the alias |
| if (m_interpreter.AliasExists (alias_command.c_str()) |
| || m_interpreter.UserCommandExists (alias_command.c_str())) |
| { |
| OptionArgVectorSP temp_option_arg_sp (m_interpreter.GetAliasOptions (alias_command.c_str())); |
| if (temp_option_arg_sp.get()) |
| { |
| if (option_arg_vector->size() == 0) |
| m_interpreter.RemoveAliasOptions (alias_command.c_str()); |
| } |
| result.AppendWarningWithFormat ("Overwriting existing definition for '%s'.\n", |
| alias_command.c_str()); |
| } |
| |
| if (cmd_obj_sp) |
| { |
| m_interpreter.AddAlias (alias_command.c_str(), cmd_obj_sp); |
| if (option_arg_vector->size() > 0) |
| m_interpreter.AddOrReplaceAliasOptions (alias_command.c_str(), option_arg_vector_sp); |
| result.SetStatus (eReturnStatusSuccessFinishNoResult); |
| } |
| else |
| { |
| result.AppendError ("Unable to create requested alias.\n"); |
| result.SetStatus (eReturnStatusFailed); |
| } |
| return result.Succeeded (); |
| } |
| |
| bool |
| HandleAliasingNormalCommand (Args& args, CommandReturnObject &result) |
| { |
| size_t argc = args.GetArgumentCount(); |
| |
| if (argc < 2) |
| { |
| result.AppendError ("'alias' requires at least two arguments"); |
| result.SetStatus (eReturnStatusFailed); |
| return false; |
| } |
| |
| const std::string alias_command = args.GetArgumentAtIndex(0); |
| const std::string actual_command = args.GetArgumentAtIndex(1); |
| |
| args.Shift(); // Shift the alias command word off the argument vector. |
| args.Shift(); // Shift the old command word off the argument vector. |
| |
| // Verify that the command is alias'able, and get the appropriate command object. |
| |
| if (m_interpreter.CommandExists (alias_command.c_str())) |
| { |
| result.AppendErrorWithFormat ("'%s' is a permanent debugger command and cannot be redefined.\n", |
| alias_command.c_str()); |
| result.SetStatus (eReturnStatusFailed); |
| } |
| else |
| { |
| CommandObjectSP command_obj_sp(m_interpreter.GetCommandSPExact (actual_command.c_str(), true)); |
| CommandObjectSP subcommand_obj_sp; |
| bool use_subcommand = false; |
| if (command_obj_sp.get()) |
| { |
| CommandObject *cmd_obj = command_obj_sp.get(); |
| CommandObject *sub_cmd_obj = NULL; |
| OptionArgVectorSP option_arg_vector_sp = OptionArgVectorSP (new OptionArgVector); |
| OptionArgVector *option_arg_vector = option_arg_vector_sp.get(); |
| |
| while (cmd_obj->IsMultiwordObject() && args.GetArgumentCount() > 0) |
| { |
| if (argc >= 3) |
| { |
| const std::string sub_command = args.GetArgumentAtIndex(0); |
| assert (sub_command.length() != 0); |
| subcommand_obj_sp = cmd_obj->GetSubcommandSP (sub_command.c_str()); |
| if (subcommand_obj_sp.get()) |
| { |
| sub_cmd_obj = subcommand_obj_sp.get(); |
| use_subcommand = true; |
| args.Shift(); // Shift the sub_command word off the argument vector. |
| cmd_obj = sub_cmd_obj; |
| } |
| else |
| { |
| result.AppendErrorWithFormat("'%s' is not a valid sub-command of '%s'. " |
| "Unable to create alias.\n", |
| sub_command.c_str(), actual_command.c_str()); |
| result.SetStatus (eReturnStatusFailed); |
| return false; |
| } |
| } |
| } |
| |
| // Verify & handle any options/arguments passed to the alias command |
| |
| if (args.GetArgumentCount () > 0) |
| { |
| CommandObjectSP tmp_sp = m_interpreter.GetCommandSPExact (cmd_obj->GetCommandName(), false); |
| if (use_subcommand) |
| tmp_sp = m_interpreter.GetCommandSPExact (sub_cmd_obj->GetCommandName(), false); |
| |
| std::string args_string; |
| args.GetCommandString (args_string); |
| |
| if (!m_interpreter.ProcessAliasOptionsArgs (tmp_sp, args_string.c_str(), option_arg_vector_sp)) |
| { |
| result.AppendError ("Unable to create requested alias.\n"); |
| result.SetStatus (eReturnStatusFailed); |
| return false; |
| } |
| } |
| |
| // Create the alias. |
| |
| if (m_interpreter.AliasExists (alias_command.c_str()) |
| || m_interpreter.UserCommandExists (alias_command.c_str())) |
| { |
| OptionArgVectorSP tmp_option_arg_sp (m_interpreter.GetAliasOptions (alias_command.c_str())); |
| if (tmp_option_arg_sp.get()) |
| { |
| if (option_arg_vector->size() == 0) |
| m_interpreter.RemoveAliasOptions (alias_command.c_str()); |
| } |
| result.AppendWarningWithFormat ("Overwriting existing definition for '%s'.\n", |
| alias_command.c_str()); |
| } |
| |
| if (use_subcommand) |
| m_interpreter.AddAlias (alias_command.c_str(), subcommand_obj_sp); |
| else |
| m_interpreter.AddAlias (alias_command.c_str(), command_obj_sp); |
| if (option_arg_vector->size() > 0) |
| m_interpreter.AddOrReplaceAliasOptions (alias_command.c_str(), option_arg_vector_sp); |
| result.SetStatus (eReturnStatusSuccessFinishNoResult); |
| } |
| else |
| { |
| result.AppendErrorWithFormat ("'%s' is not an existing command.\n", actual_command.c_str()); |
| result.SetStatus (eReturnStatusFailed); |
| return false; |
| } |
| } |
| |
| return result.Succeeded(); |
| } |
| |
| }; |
| |
| #pragma mark CommandObjectCommandsUnalias |
| //------------------------------------------------------------------------- |
| // CommandObjectCommandsUnalias |
| //------------------------------------------------------------------------- |
| |
| class CommandObjectCommandsUnalias : public CommandObjectParsed |
| { |
| public: |
| CommandObjectCommandsUnalias (CommandInterpreter &interpreter) : |
| CommandObjectParsed (interpreter, |
| "command unalias", |
| "Allow the user to remove/delete a user-defined command abbreviation.", |
| NULL) |
| { |
| CommandArgumentEntry arg; |
| CommandArgumentData alias_arg; |
| |
| // Define the first (and only) variant of this arg. |
| alias_arg.arg_type = eArgTypeAliasName; |
| alias_arg.arg_repetition = eArgRepeatPlain; |
| |
| // There is only one variant this argument could be; put it into the argument entry. |
| arg.push_back (alias_arg); |
| |
| // Push the data for the first argument into the m_arguments vector. |
| m_arguments.push_back (arg); |
| } |
| |
| ~CommandObjectCommandsUnalias() |
| { |
| } |
| |
| protected: |
| bool |
| DoExecute (Args& args, CommandReturnObject &result) |
| { |
| CommandObject::CommandMap::iterator pos; |
| CommandObject *cmd_obj; |
| |
| if (args.GetArgumentCount() != 0) |
| { |
| const char *command_name = args.GetArgumentAtIndex(0); |
| cmd_obj = m_interpreter.GetCommandObject(command_name); |
| if (cmd_obj) |
| { |
| if (m_interpreter.CommandExists (command_name)) |
| { |
| result.AppendErrorWithFormat ("'%s' is a permanent debugger command and cannot be removed.\n", |
| command_name); |
| result.SetStatus (eReturnStatusFailed); |
| } |
| else |
| { |
| |
| if (m_interpreter.RemoveAlias (command_name) == false) |
| { |
| if (m_interpreter.AliasExists (command_name)) |
| result.AppendErrorWithFormat ("Error occurred while attempting to unalias '%s'.\n", |
| command_name); |
| else |
| result.AppendErrorWithFormat ("'%s' is not an existing alias.\n", command_name); |
| result.SetStatus (eReturnStatusFailed); |
| } |
| else |
| result.SetStatus (eReturnStatusSuccessFinishNoResult); |
| } |
| } |
| else |
| { |
| result.AppendErrorWithFormat ("'%s' is not a known command.\nTry 'help' to see a " |
| "current list of commands.\n", |
| command_name); |
| result.SetStatus (eReturnStatusFailed); |
| } |
| } |
| else |
| { |
| result.AppendError ("must call 'unalias' with a valid alias"); |
| result.SetStatus (eReturnStatusFailed); |
| } |
| |
| return result.Succeeded(); |
| } |
| }; |
| |
| //------------------------------------------------------------------------- |
| // CommandObjectCommandsAddRegex |
| //------------------------------------------------------------------------- |
| #pragma mark CommandObjectCommandsAddRegex |
| |
| class CommandObjectCommandsAddRegex : |
| public CommandObjectParsed, |
| public IOHandlerDelegate |
| { |
| public: |
| CommandObjectCommandsAddRegex (CommandInterpreter &interpreter) : |
| CommandObjectParsed (interpreter, |
| "command regex", |
| "Allow the user to create a regular expression command.", |
| "command regex <cmd-name> [s/<regex>/<subst>/ ...]"), |
| IOHandlerDelegate(IOHandlerDelegate::Completion::LLDBCommand), |
| m_options (interpreter) |
| { |
| SetHelpLong( |
| "This command allows the user to create powerful regular expression commands\n" |
| "with substitutions. The regular expressions and substitutions are specified\n" |
| "using the regular expression substitution format of:\n" |
| "\n" |
| " s/<regex>/<subst>/\n" |
| "\n" |
| "<regex> is a regular expression that can use parenthesis to capture regular\n" |
| "expression input and substitute the captured matches in the output using %1\n" |
| "for the first match, %2 for the second, and so on.\n" |
| "\n" |
| "The regular expressions can all be specified on the command line if more than\n" |
| "one argument is provided. If just the command name is provided on the command\n" |
| "line, then the regular expressions and substitutions can be entered on separate\n" |
| " lines, followed by an empty line to terminate the command definition.\n" |
| "\n" |
| "EXAMPLES\n" |
| "\n" |
| "The following example will define a regular expression command named 'f' that\n" |
| "will call 'finish' if there are no arguments, or 'frame select <frame-idx>' if\n" |
| "a number follows 'f':\n" |
| "\n" |
| " (lldb) command regex f s/^$/finish/ 's/([0-9]+)/frame select %1/'\n" |
| "\n" |
| ); |
| } |
| |
| ~CommandObjectCommandsAddRegex() |
| { |
| } |
| |
| |
| protected: |
| |
| virtual void |
| IOHandlerActivated (IOHandler &io_handler) |
| { |
| StreamFileSP output_sp(io_handler.GetOutputStreamFile()); |
| if (output_sp) |
| { |
| output_sp->PutCString("Enter one of more sed substitution commands in the form: 's/<regex>/<subst>/'.\nTerminate the substitution list with an empty line.\n"); |
| output_sp->Flush(); |
| } |
| } |
| |
| virtual void |
| IOHandlerInputComplete (IOHandler &io_handler, std::string &data) |
| { |
| io_handler.SetIsDone(true); |
| if (m_regex_cmd_ap.get()) |
| { |
| StringList lines; |
| if (lines.SplitIntoLines (data)) |
| { |
| const size_t num_lines = lines.GetSize(); |
| bool check_only = false; |
| for (size_t i=0; i<num_lines; ++i) |
| { |
| printf ("regex[%zu] = %s\n", i, lines[i].c_str()); |
| llvm::StringRef bytes_strref (lines[i]); |
| Error error = AppendRegexSubstitution (bytes_strref, check_only); |
| if (error.Fail()) |
| { |
| if (!m_interpreter.GetDebugger().GetCommandInterpreter().GetBatchCommandMode()) |
| { |
| StreamSP out_stream = m_interpreter.GetDebugger().GetAsyncOutputStream(); |
| out_stream->Printf("error: %s\n", error.AsCString()); |
| } |
| } |
| } |
| } |
| if (m_regex_cmd_ap->HasRegexEntries()) |
| { |
| CommandObjectSP cmd_sp (m_regex_cmd_ap.release()); |
| m_interpreter.AddCommand(cmd_sp->GetCommandName(), cmd_sp, true); |
| } |
| } |
| } |
| |
| virtual LineStatus |
| IOHandlerLinesUpdated (IOHandler &io_handler, |
| StringList &lines, |
| uint32_t line_idx, |
| Error &error) |
| { |
| if (line_idx == UINT32_MAX) |
| { |
| // Return true to indicate we are done getting lines (this |
| // is a "fake" line - the real terminating blank line was |
| // removed during a previous call with the code below) |
| error.Clear(); |
| return LineStatus::Done; |
| } |
| else |
| { |
| const size_t num_lines = lines.GetSize(); |
| if (line_idx + 1 == num_lines) |
| { |
| // The last line was edited, if this line is empty, then we are done |
| // getting our multiple lines. |
| if (lines[line_idx].empty()) |
| { |
| // Remove the last empty line from "lines" so it doesn't appear |
| // in our final expression and return true to indicate we are done |
| // getting lines |
| lines.PopBack(); |
| return LineStatus::Done; |
| } |
| } |
| // Check the current line to make sure it is formatted correctly |
| bool check_only = true; |
| llvm::StringRef regex_sed(lines[line_idx]); |
| error = AppendRegexSubstitution (regex_sed, check_only); |
| if (error.Fail()) |
| { |
| return LineStatus::Error; |
| } |
| else |
| { |
| return LineStatus::Success; |
| } |
| } |
| } |
| |
| bool |
| DoExecute (Args& command, CommandReturnObject &result) |
| { |
| const size_t argc = command.GetArgumentCount(); |
| if (argc == 0) |
| { |
| result.AppendError ("usage: 'command regex <command-name> [s/<regex1>/<subst1>/ s/<regex2>/<subst2>/ ...]'\n"); |
| result.SetStatus (eReturnStatusFailed); |
| } |
| else |
| { |
| Error error; |
| const char *name = command.GetArgumentAtIndex(0); |
| m_regex_cmd_ap.reset (new CommandObjectRegexCommand (m_interpreter, |
| name, |
| m_options.GetHelp (), |
| m_options.GetSyntax (), |
| 10)); |
| |
| if (argc == 1) |
| { |
| Debugger &debugger = m_interpreter.GetDebugger(); |
| const bool multiple_lines = true; // Get multiple lines |
| IOHandlerSP io_handler_sp (new IOHandlerEditline (debugger, |
| "lldb-regex", // Name of input reader for history |
| "\033[K> ", // Prompt and clear line |
| multiple_lines, |
| 0, // Don't show line numbers |
| *this)); |
| |
| if (io_handler_sp) |
| { |
| debugger.PushIOHandler(io_handler_sp); |
| result.SetStatus (eReturnStatusSuccessFinishNoResult); |
| } |
| } |
| else |
| { |
| for (size_t arg_idx = 1; arg_idx < argc; ++arg_idx) |
| { |
| llvm::StringRef arg_strref (command.GetArgumentAtIndex(arg_idx)); |
| bool check_only = false; |
| error = AppendRegexSubstitution (arg_strref, check_only); |
| if (error.Fail()) |
| break; |
| } |
| |
| if (error.Success()) |
| { |
| AddRegexCommandToInterpreter(); |
| } |
| } |
| if (error.Fail()) |
| { |
| result.AppendError (error.AsCString()); |
| result.SetStatus (eReturnStatusFailed); |
| } |
| } |
| |
| return result.Succeeded(); |
| } |
| |
| Error |
| AppendRegexSubstitution (const llvm::StringRef ®ex_sed, bool check_only) |
| { |
| Error error; |
| |
| if (m_regex_cmd_ap.get() == NULL) |
| { |
| error.SetErrorStringWithFormat("invalid regular expression command object for: '%.*s'", |
| (int)regex_sed.size(), |
| regex_sed.data()); |
| return error; |
| } |
| |
| size_t regex_sed_size = regex_sed.size(); |
| |
| if (regex_sed_size <= 1) |
| { |
| error.SetErrorStringWithFormat("regular expression substitution string is too short: '%.*s'", |
| (int)regex_sed.size(), |
| regex_sed.data()); |
| return error; |
| } |
| |
| if (regex_sed[0] != 's') |
| { |
| error.SetErrorStringWithFormat("regular expression substitution string doesn't start with 's': '%.*s'", |
| (int)regex_sed.size(), |
| regex_sed.data()); |
| return error; |
| } |
| const size_t first_separator_char_pos = 1; |
| // use the char that follows 's' as the regex separator character |
| // so we can have "s/<regex>/<subst>/" or "s|<regex>|<subst>|" |
| const char separator_char = regex_sed[first_separator_char_pos]; |
| const size_t second_separator_char_pos = regex_sed.find (separator_char, first_separator_char_pos + 1); |
| |
| if (second_separator_char_pos == std::string::npos) |
| { |
| error.SetErrorStringWithFormat("missing second '%c' separator char after '%.*s'", |
| separator_char, |
| (int)(regex_sed.size() - first_separator_char_pos - 1), |
| regex_sed.data() + (first_separator_char_pos + 1)); |
| return error; |
| } |
| |
| const size_t third_separator_char_pos = regex_sed.find (separator_char, second_separator_char_pos + 1); |
| |
| if (third_separator_char_pos == std::string::npos) |
| { |
| error.SetErrorStringWithFormat("missing third '%c' separator char after '%.*s'", |
| separator_char, |
| (int)(regex_sed.size() - second_separator_char_pos - 1), |
| regex_sed.data() + (second_separator_char_pos + 1)); |
| return error; |
| } |
| |
| if (third_separator_char_pos != regex_sed_size - 1) |
| { |
| // Make sure that everything that follows the last regex |
| // separator char |
| if (regex_sed.find_first_not_of("\t\n\v\f\r ", third_separator_char_pos + 1) != std::string::npos) |
| { |
| error.SetErrorStringWithFormat("extra data found after the '%.*s' regular expression substitution string: '%.*s'", |
| (int)third_separator_char_pos + 1, |
| regex_sed.data(), |
| (int)(regex_sed.size() - third_separator_char_pos - 1), |
| regex_sed.data() + (third_separator_char_pos + 1)); |
| return error; |
| } |
| |
| } |
| else if (first_separator_char_pos + 1 == second_separator_char_pos) |
| { |
| error.SetErrorStringWithFormat("<regex> can't be empty in 's%c<regex>%c<subst>%c' string: '%.*s'", |
| separator_char, |
| separator_char, |
| separator_char, |
| (int)regex_sed.size(), |
| regex_sed.data()); |
| return error; |
| } |
| else if (second_separator_char_pos + 1 == third_separator_char_pos) |
| { |
| error.SetErrorStringWithFormat("<subst> can't be empty in 's%c<regex>%c<subst>%c' string: '%.*s'", |
| separator_char, |
| separator_char, |
| separator_char, |
| (int)regex_sed.size(), |
| regex_sed.data()); |
| return error; |
| } |
| |
| if (check_only == false) |
| { |
| std::string regex(regex_sed.substr(first_separator_char_pos + 1, second_separator_char_pos - first_separator_char_pos - 1)); |
| std::string subst(regex_sed.substr(second_separator_char_pos + 1, third_separator_char_pos - second_separator_char_pos - 1)); |
| m_regex_cmd_ap->AddRegexCommand (regex.c_str(), |
| subst.c_str()); |
| } |
| return error; |
| } |
| |
| void |
| AddRegexCommandToInterpreter() |
| { |
| if (m_regex_cmd_ap.get()) |
| { |
| if (m_regex_cmd_ap->HasRegexEntries()) |
| { |
| CommandObjectSP cmd_sp (m_regex_cmd_ap.release()); |
| m_interpreter.AddCommand(cmd_sp->GetCommandName(), cmd_sp, true); |
| } |
| } |
| } |
| |
| private: |
| std::unique_ptr<CommandObjectRegexCommand> m_regex_cmd_ap; |
| |
| class CommandOptions : public Options |
| { |
| public: |
| |
| CommandOptions (CommandInterpreter &interpreter) : |
| Options (interpreter) |
| { |
| } |
| |
| virtual |
| ~CommandOptions (){} |
| |
| virtual Error |
| SetOptionValue (uint32_t option_idx, const char *option_arg) |
| { |
| Error error; |
| const int short_option = m_getopt_table[option_idx].val; |
| |
| switch (short_option) |
| { |
| case 'h': |
| m_help.assign (option_arg); |
| break; |
| case 's': |
| m_syntax.assign (option_arg); |
| break; |
| |
| default: |
| error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option); |
| break; |
| } |
| |
| return error; |
| } |
| |
| void |
| OptionParsingStarting () |
| { |
| m_help.clear(); |
| m_syntax.clear(); |
| } |
| |
| const OptionDefinition* |
| GetDefinitions () |
| { |
| return g_option_table; |
| } |
| |
| // Options table: Required for subclasses of Options. |
| |
| static OptionDefinition g_option_table[]; |
| |
| const char * |
| GetHelp () |
| { |
| if (m_help.empty()) |
| return NULL; |
| return m_help.c_str(); |
| } |
| const char * |
| GetSyntax () |
| { |
| if (m_syntax.empty()) |
| return NULL; |
| return m_syntax.c_str(); |
| } |
| // Instance variables to hold the values for command options. |
| protected: |
| std::string m_help; |
| std::string m_syntax; |
| }; |
| |
| virtual Options * |
| GetOptions () |
| { |
| return &m_options; |
| } |
| |
| CommandOptions m_options; |
| }; |
| |
| OptionDefinition |
| CommandObjectCommandsAddRegex::CommandOptions::g_option_table[] = |
| { |
| { LLDB_OPT_SET_1, false, "help" , 'h', OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypeNone, "The help text to display for this command."}, |
| { LLDB_OPT_SET_1, false, "syntax", 's', OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypeNone, "A syntax string showing the typical usage syntax."}, |
| { 0 , false, NULL , 0 , 0 , NULL, NULL, 0, eArgTypeNone, NULL } |
| }; |
| |
| |
| class CommandObjectPythonFunction : public CommandObjectRaw |
| { |
| private: |
| std::string m_function_name; |
| ScriptedCommandSynchronicity m_synchro; |
| bool m_fetched_help_long; |
| |
| public: |
| |
| CommandObjectPythonFunction (CommandInterpreter &interpreter, |
| std::string name, |
| std::string funct, |
| ScriptedCommandSynchronicity synch) : |
| CommandObjectRaw (interpreter, |
| name.c_str(), |
| (std::string("Run Python function ") + funct).c_str(), |
| NULL), |
| m_function_name(funct), |
| m_synchro(synch), |
| m_fetched_help_long(false) |
| { |
| } |
| |
| virtual |
| ~CommandObjectPythonFunction () |
| { |
| } |
| |
| virtual bool |
| IsRemovable () const |
| { |
| return true; |
| } |
| |
| const std::string& |
| GetFunctionName () |
| { |
| return m_function_name; |
| } |
| |
| ScriptedCommandSynchronicity |
| GetSynchronicity () |
| { |
| return m_synchro; |
| } |
| |
| virtual const char * |
| GetHelpLong () |
| { |
| if (!m_fetched_help_long) |
| { |
| ScriptInterpreter* scripter = m_interpreter.GetScriptInterpreter(); |
| if (scripter) |
| { |
| std::string docstring; |
| m_fetched_help_long = scripter->GetDocumentationForItem(m_function_name.c_str(),docstring); |
| if (!docstring.empty()) |
| SetHelpLong(docstring); |
| } |
| } |
| return CommandObjectRaw::GetHelpLong(); |
| } |
| |
| protected: |
| virtual bool |
| DoExecute (const char *raw_command_line, CommandReturnObject &result) |
| { |
| ScriptInterpreter* scripter = m_interpreter.GetScriptInterpreter(); |
| |
| Error error; |
| |
| result.SetStatus(eReturnStatusInvalid); |
| |
| if (!scripter || scripter->RunScriptBasedCommand(m_function_name.c_str(), |
| raw_command_line, |
| m_synchro, |
| result, |
| error) == false) |
| { |
| result.AppendError(error.AsCString()); |
| result.SetStatus(eReturnStatusFailed); |
| } |
| else |
| { |
| // Don't change the status if the command already set it... |
| if (result.GetStatus() == eReturnStatusInvalid) |
| { |
| if (result.GetOutputData() == NULL || result.GetOutputData()[0] == '\0') |
| result.SetStatus(eReturnStatusSuccessFinishNoResult); |
| else |
| result.SetStatus(eReturnStatusSuccessFinishResult); |
| } |
| } |
| |
| return result.Succeeded(); |
| } |
| |
| }; |
| |
| //------------------------------------------------------------------------- |
| // CommandObjectCommandsScriptImport |
| //------------------------------------------------------------------------- |
| |
| class CommandObjectCommandsScriptImport : public CommandObjectParsed |
| { |
| public: |
| CommandObjectCommandsScriptImport (CommandInterpreter &interpreter) : |
| CommandObjectParsed (interpreter, |
| "command script import", |
| "Import a scripting module in LLDB.", |
| NULL), |
| m_options(interpreter) |
| { |
| CommandArgumentEntry arg1; |
| CommandArgumentData cmd_arg; |
| |
| // Define the first (and only) variant of this arg. |
| cmd_arg.arg_type = eArgTypeFilename; |
| cmd_arg.arg_repetition = eArgRepeatPlain; |
| |
| // There is only one variant this argument could be; put it into the argument entry. |
| arg1.push_back (cmd_arg); |
| |
| // Push the data for the first argument into the m_arguments vector. |
| m_arguments.push_back (arg1); |
| } |
| |
| ~CommandObjectCommandsScriptImport () |
| { |
| } |
| |
| virtual int |
| HandleArgumentCompletion (Args &input, |
| int &cursor_index, |
| int &cursor_char_position, |
| OptionElementVector &opt_element_vector, |
| int match_start_point, |
| int max_return_elements, |
| bool &word_complete, |
| StringList &matches) |
| { |
| std::string completion_str (input.GetArgumentAtIndex(cursor_index)); |
| completion_str.erase (cursor_char_position); |
| |
| CommandCompletions::InvokeCommonCompletionCallbacks (m_interpreter, |
| CommandCompletions::eDiskFileCompletion, |
| completion_str.c_str(), |
| match_start_point, |
| max_return_elements, |
| NULL, |
| word_complete, |
| matches); |
| return matches.GetSize(); |
| } |
| |
| virtual Options * |
| GetOptions () |
| { |
| return &m_options; |
| } |
| |
| protected: |
| |
| class CommandOptions : public Options |
| { |
| public: |
| |
| CommandOptions (CommandInterpreter &interpreter) : |
| Options (interpreter) |
| { |
| } |
| |
| virtual |
| ~CommandOptions (){} |
| |
| virtual Error |
| SetOptionValue (uint32_t option_idx, const char *option_arg) |
| { |
| Error error; |
| const int short_option = m_getopt_table[option_idx].val; |
| |
| switch (short_option) |
| { |
| case 'r': |
| m_allow_reload = true; |
| break; |
| default: |
| error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option); |
| break; |
| } |
| |
| return error; |
| } |
| |
| void |
| OptionParsingStarting () |
| { |
| m_allow_reload = true; |
| } |
| |
| const OptionDefinition* |
| GetDefinitions () |
| { |
| return g_option_table; |
| } |
| |
| // Options table: Required for subclasses of Options. |
| |
| static OptionDefinition g_option_table[]; |
| |
| // Instance variables to hold the values for command options. |
| |
| bool m_allow_reload; |
| }; |
| |
| bool |
| DoExecute (Args& command, CommandReturnObject &result) |
| { |
| |
| if (m_interpreter.GetDebugger().GetScriptLanguage() != lldb::eScriptLanguagePython) |
| { |
| result.AppendError ("only scripting language supported for module importing is currently Python"); |
| result.SetStatus (eReturnStatusFailed); |
| return false; |
| } |
| |
| size_t argc = command.GetArgumentCount(); |
| |
| if (argc != 1) |
| { |
| result.AppendError ("'command script import' requires one argument"); |
| result.SetStatus (eReturnStatusFailed); |
| return false; |
| } |
| |
| std::string path = command.GetArgumentAtIndex(0); |
| Error error; |
| |
| const bool init_session = true; |
| // FIXME: this is necessary because CommandObject::CheckRequirements() assumes that |
| // commands won't ever be recursively invoked, but it's actually possible to craft |
| // a Python script that does other "command script imports" in __lldb_init_module |
| // the real fix is to have recursive commands possible with a CommandInvocation object |
| // separate from the CommandObject itself, so that recursive command invocations |
| // won't stomp on each other (wrt to execution contents, options, and more) |
| m_exe_ctx.Clear(); |
| if (m_interpreter.GetScriptInterpreter()->LoadScriptingModule(path.c_str(), |
| m_options.m_allow_reload, |
| init_session, |
| error)) |
| { |
| result.SetStatus (eReturnStatusSuccessFinishNoResult); |
| } |
| else |
| { |
| result.AppendErrorWithFormat("module importing failed: %s", error.AsCString()); |
| result.SetStatus (eReturnStatusFailed); |
| } |
| |
| return result.Succeeded(); |
| } |
| |
| CommandOptions m_options; |
| }; |
| |
| OptionDefinition |
| CommandObjectCommandsScriptImport::CommandOptions::g_option_table[] = |
| { |
| { LLDB_OPT_SET_1, false, "allow-reload", 'r', OptionParser::eNoArgument, NULL, NULL, 0, eArgTypeNone, "Allow the script to be loaded even if it was already loaded before. This argument exists for backwards compatibility, but reloading is always allowed, whether you specify it or not."}, |
| { 0, false, NULL, 0, 0, NULL, NULL, 0, eArgTypeNone, NULL } |
| }; |
| |
| |
| //------------------------------------------------------------------------- |
| // CommandObjectCommandsScriptAdd |
| //------------------------------------------------------------------------- |
| |
| class CommandObjectCommandsScriptAdd : |
| public CommandObjectParsed, |
| public IOHandlerDelegateMultiline |
| { |
| public: |
| CommandObjectCommandsScriptAdd(CommandInterpreter &interpreter) : |
| CommandObjectParsed (interpreter, |
| "command script add", |
| "Add a scripted function as an LLDB command.", |
| NULL), |
| IOHandlerDelegateMultiline ("DONE"), |
| m_options (interpreter) |
| { |
| CommandArgumentEntry arg1; |
| CommandArgumentData cmd_arg; |
| |
| // Define the first (and only) variant of this arg. |
| cmd_arg.arg_type = eArgTypeCommandName; |
| cmd_arg.arg_repetition = eArgRepeatPlain; |
| |
| // There is only one variant this argument could be; put it into the argument entry. |
| arg1.push_back (cmd_arg); |
| |
| // Push the data for the first argument into the m_arguments vector. |
| m_arguments.push_back (arg1); |
| } |
| |
| ~CommandObjectCommandsScriptAdd () |
| { |
| } |
| |
| virtual Options * |
| GetOptions () |
| { |
| return &m_options; |
| } |
| |
| protected: |
| |
| class CommandOptions : public Options |
| { |
| public: |
| |
| CommandOptions (CommandInterpreter &interpreter) : |
| Options (interpreter) |
| { |
| } |
| |
| virtual |
| ~CommandOptions (){} |
| |
| virtual Error |
| SetOptionValue (uint32_t option_idx, const char *option_arg) |
| { |
| Error error; |
| const int short_option = m_getopt_table[option_idx].val; |
| |
| switch (short_option) |
| { |
| case 'f': |
| m_funct_name = std::string(option_arg); |
| break; |
| case 's': |
| m_synchronicity = (ScriptedCommandSynchronicity) Args::StringToOptionEnum(option_arg, g_option_table[option_idx].enum_values, 0, error); |
| if (!error.Success()) |
| error.SetErrorStringWithFormat ("unrecognized value for synchronicity '%s'", option_arg); |
| break; |
| default: |
| error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option); |
| break; |
| } |
| |
| return error; |
| } |
| |
| void |
| OptionParsingStarting () |
| { |
| m_funct_name = ""; |
| m_synchronicity = eScriptedCommandSynchronicitySynchronous; |
| } |
| |
| const OptionDefinition* |
| GetDefinitions () |
| { |
| return g_option_table; |
| } |
| |
| // Options table: Required for subclasses of Options. |
| |
| static OptionDefinition g_option_table[]; |
| |
| // Instance variables to hold the values for command options. |
| |
| std::string m_funct_name; |
| ScriptedCommandSynchronicity m_synchronicity; |
| }; |
| |
| virtual void |
| IOHandlerActivated (IOHandler &io_handler) |
| { |
| StreamFileSP output_sp(io_handler.GetOutputStreamFile()); |
| if (output_sp) |
| { |
| output_sp->PutCString(g_python_command_instructions); |
| output_sp->Flush(); |
| } |
| } |
| |
| |
| virtual void |
| IOHandlerInputComplete (IOHandler &io_handler, std::string &data) |
| { |
| StreamFileSP error_sp = io_handler.GetErrorStreamFile(); |
| |
| ScriptInterpreter *interpreter = m_interpreter.GetScriptInterpreter(); |
| if (interpreter) |
| { |
| |
| StringList lines; |
| lines.SplitIntoLines(data); |
| if (lines.GetSize() > 0) |
| { |
| std::string funct_name_str; |
| if (interpreter->GenerateScriptAliasFunction (lines, funct_name_str)) |
| { |
| if (funct_name_str.empty()) |
| { |
| error_sp->Printf ("error: unable to obtain a function name, didn't add python command.\n"); |
| error_sp->Flush(); |
| } |
| else |
| { |
| // everything should be fine now, let's add this alias |
| |
| CommandObjectSP command_obj_sp(new CommandObjectPythonFunction (m_interpreter, |
| m_cmd_name, |
| funct_name_str.c_str(), |
| m_synchronicity)); |
| |
| if (!m_interpreter.AddUserCommand(m_cmd_name, command_obj_sp, true)) |
| { |
| error_sp->Printf ("error: unable to add selected command, didn't add python command.\n"); |
| error_sp->Flush(); |
| } |
| } |
| } |
| else |
| { |
| error_sp->Printf ("error: unable to create function, didn't add python command.\n"); |
| error_sp->Flush(); |
| } |
| } |
| else |
| { |
| error_sp->Printf ("error: empty function, didn't add python command.\n"); |
| error_sp->Flush(); |
| } |
| } |
| else |
| { |
| error_sp->Printf ("error: script interpreter missing, didn't add python command.\n"); |
| error_sp->Flush(); |
| } |
| |
| io_handler.SetIsDone(true); |
| |
| |
| } |
| |
| protected: |
| bool |
| DoExecute (Args& command, CommandReturnObject &result) |
| { |
| |
| if (m_interpreter.GetDebugger().GetScriptLanguage() != lldb::eScriptLanguagePython) |
| { |
| result.AppendError ("only scripting language supported for scripted commands is currently Python"); |
| result.SetStatus (eReturnStatusFailed); |
| return false; |
| } |
| |
| size_t argc = command.GetArgumentCount(); |
| |
| if (argc != 1) |
| { |
| result.AppendError ("'command script add' requires one argument"); |
| result.SetStatus (eReturnStatusFailed); |
| return false; |
| } |
| |
| // Store the command name and synchronicity in case we get multi-line input |
| m_cmd_name = command.GetArgumentAtIndex(0); |
| m_synchronicity = m_options.m_synchronicity; |
| |
| if (m_options.m_funct_name.empty()) |
| { |
| m_interpreter.GetPythonCommandsFromIOHandler (" ", // Prompt |
| *this, // IOHandlerDelegate |
| true, // Run IOHandler in async mode |
| NULL); // Baton for the "io_handler" that will be passed back into our IOHandlerDelegate functions |
| } |
| else |
| { |
| CommandObjectSP new_cmd(new CommandObjectPythonFunction(m_interpreter, |
| m_cmd_name, |
| m_options.m_funct_name, |
| m_synchronicity)); |
| if (m_interpreter.AddUserCommand(m_cmd_name, new_cmd, true)) |
| { |
| result.SetStatus (eReturnStatusSuccessFinishNoResult); |
| } |
| else |
| { |
| result.AppendError("cannot add command"); |
| result.SetStatus (eReturnStatusFailed); |
| } |
| } |
| |
| return result.Succeeded(); |
| |
| } |
| |
| CommandOptions m_options; |
| std::string m_cmd_name; |
| ScriptedCommandSynchronicity m_synchronicity; |
| }; |
| |
| static OptionEnumValueElement g_script_synchro_type[] = |
| { |
| { eScriptedCommandSynchronicitySynchronous, "synchronous", "Run synchronous"}, |
| { eScriptedCommandSynchronicityAsynchronous, "asynchronous", "Run asynchronous"}, |
| { eScriptedCommandSynchronicityCurrentValue, "current", "Do not alter current setting"}, |
| { 0, NULL, NULL } |
| }; |
| |
| OptionDefinition |
| CommandObjectCommandsScriptAdd::CommandOptions::g_option_table[] = |
| { |
| { LLDB_OPT_SET_1, false, "function", 'f', OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypePythonFunction, "Name of the Python function to bind to this command name."}, |
| { LLDB_OPT_SET_1, false, "synchronicity", 's', OptionParser::eRequiredArgument, NULL, g_script_synchro_type, 0, eArgTypeScriptedCommandSynchronicity, "Set the synchronicity of this command's executions with regard to LLDB event system."}, |
| { 0, false, NULL, 0, 0, NULL, NULL, 0, eArgTypeNone, NULL } |
| }; |
| |
| //------------------------------------------------------------------------- |
| // CommandObjectCommandsScriptList |
| //------------------------------------------------------------------------- |
| |
| class CommandObjectCommandsScriptList : public CommandObjectParsed |
| { |
| private: |
| |
| public: |
| CommandObjectCommandsScriptList(CommandInterpreter &interpreter) : |
| CommandObjectParsed (interpreter, |
| "command script list", |
| "List defined scripted commands.", |
| NULL) |
| { |
| } |
| |
| ~CommandObjectCommandsScriptList () |
| { |
| } |
| |
| bool |
| DoExecute (Args& command, CommandReturnObject &result) |
| { |
| |
| m_interpreter.GetHelp(result, |
| CommandInterpreter::eCommandTypesUserDef); |
| |
| result.SetStatus (eReturnStatusSuccessFinishResult); |
| |
| return true; |
| |
| |
| } |
| }; |
| |
| //------------------------------------------------------------------------- |
| // CommandObjectCommandsScriptClear |
| //------------------------------------------------------------------------- |
| |
| class CommandObjectCommandsScriptClear : public CommandObjectParsed |
| { |
| private: |
| |
| public: |
| CommandObjectCommandsScriptClear(CommandInterpreter &interpreter) : |
| CommandObjectParsed (interpreter, |
| "command script clear", |
| "Delete all scripted commands.", |
| NULL) |
| { |
| } |
| |
| ~CommandObjectCommandsScriptClear () |
| { |
| } |
| |
| protected: |
| bool |
| DoExecute (Args& command, CommandReturnObject &result) |
| { |
| |
| m_interpreter.RemoveAllUser(); |
| |
| result.SetStatus (eReturnStatusSuccessFinishResult); |
| |
| return true; |
| } |
| }; |
| |
| //------------------------------------------------------------------------- |
| // CommandObjectCommandsScriptDelete |
| //------------------------------------------------------------------------- |
| |
| class CommandObjectCommandsScriptDelete : public CommandObjectParsed |
| { |
| public: |
| CommandObjectCommandsScriptDelete(CommandInterpreter &interpreter) : |
| CommandObjectParsed (interpreter, |
| "command script delete", |
| "Delete a scripted command.", |
| NULL) |
| { |
| CommandArgumentEntry arg1; |
| CommandArgumentData cmd_arg; |
| |
| // Define the first (and only) variant of this arg. |
| cmd_arg.arg_type = eArgTypeCommandName; |
| cmd_arg.arg_repetition = eArgRepeatPlain; |
| |
| // There is only one variant this argument could be; put it into the argument entry. |
| arg1.push_back (cmd_arg); |
| |
| // Push the data for the first argument into the m_arguments vector. |
| m_arguments.push_back (arg1); |
| } |
| |
| ~CommandObjectCommandsScriptDelete () |
| { |
| } |
| |
| protected: |
| bool |
| DoExecute (Args& command, CommandReturnObject &result) |
| { |
| |
| size_t argc = command.GetArgumentCount(); |
| |
| if (argc != 1) |
| { |
| result.AppendError ("'command script delete' requires one argument"); |
| result.SetStatus (eReturnStatusFailed); |
| return false; |
| } |
| |
| const char* cmd_name = command.GetArgumentAtIndex(0); |
| |
| if (cmd_name && *cmd_name && m_interpreter.HasUserCommands() && m_interpreter.UserCommandExists(cmd_name)) |
| { |
| m_interpreter.RemoveUser(cmd_name); |
| result.SetStatus (eReturnStatusSuccessFinishResult); |
| } |
| else |
| { |
| result.AppendErrorWithFormat ("command %s not found", cmd_name); |
| result.SetStatus (eReturnStatusFailed); |
| } |
| |
| return result.Succeeded(); |
| |
| } |
| }; |
| |
| #pragma mark CommandObjectMultiwordCommandsScript |
| |
| //------------------------------------------------------------------------- |
| // CommandObjectMultiwordCommandsScript |
| //------------------------------------------------------------------------- |
| |
| class CommandObjectMultiwordCommandsScript : public CommandObjectMultiword |
| { |
| public: |
| CommandObjectMultiwordCommandsScript (CommandInterpreter &interpreter) : |
| CommandObjectMultiword (interpreter, |
| "command script", |
| "A set of commands for managing or customizing script commands.", |
| "command script <subcommand> [<subcommand-options>]") |
| { |
| LoadSubCommand ("add", CommandObjectSP (new CommandObjectCommandsScriptAdd (interpreter))); |
| LoadSubCommand ("delete", CommandObjectSP (new CommandObjectCommandsScriptDelete (interpreter))); |
| LoadSubCommand ("clear", CommandObjectSP (new CommandObjectCommandsScriptClear (interpreter))); |
| LoadSubCommand ("list", CommandObjectSP (new CommandObjectCommandsScriptList (interpreter))); |
| LoadSubCommand ("import", CommandObjectSP (new CommandObjectCommandsScriptImport (interpreter))); |
| } |
| |
| ~CommandObjectMultiwordCommandsScript () |
| { |
| } |
| |
| }; |
| |
| |
| #pragma mark CommandObjectMultiwordCommands |
| |
| //------------------------------------------------------------------------- |
| // CommandObjectMultiwordCommands |
| //------------------------------------------------------------------------- |
| |
| CommandObjectMultiwordCommands::CommandObjectMultiwordCommands (CommandInterpreter &interpreter) : |
| CommandObjectMultiword (interpreter, |
| "command", |
| "A set of commands for managing or customizing the debugger commands.", |
| "command <subcommand> [<subcommand-options>]") |
| { |
| LoadSubCommand ("source", CommandObjectSP (new CommandObjectCommandsSource (interpreter))); |
| LoadSubCommand ("alias", CommandObjectSP (new CommandObjectCommandsAlias (interpreter))); |
| LoadSubCommand ("unalias", CommandObjectSP (new CommandObjectCommandsUnalias (interpreter))); |
| LoadSubCommand ("regex", CommandObjectSP (new CommandObjectCommandsAddRegex (interpreter))); |
| LoadSubCommand ("history", CommandObjectSP (new CommandObjectCommandsHistory (interpreter))); |
| LoadSubCommand ("script", CommandObjectSP (new CommandObjectMultiwordCommandsScript (interpreter))); |
| } |
| |
| CommandObjectMultiwordCommands::~CommandObjectMultiwordCommands () |
| { |
| } |
| |
