//===-- ScriptInterpreterPython.cpp -----------------------------*- C++ -*-===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// // In order to guarantee correct working with Python, Python.h *MUST* be // the *FIRST* header file included: #if defined (__APPLE__) #include #else #include #endif #include "lldb/Interpreter/ScriptInterpreterPython.h" #include #include #include #include #include #include "lldb/API/SBFrame.h" #include "lldb/API/SBBreakpointLocation.h" #include "lldb/Breakpoint/Breakpoint.h" #include "lldb/Breakpoint/BreakpointLocation.h" #include "lldb/Breakpoint/StoppointCallbackContext.h" #include "lldb/Core/Debugger.h" #include "lldb/Core/FileSpec.h" #include "lldb/Core/InputReader.h" #include "lldb/Core/Stream.h" #include "lldb/Core/StreamString.h" #include "lldb/Core/Timer.h" #include "lldb/Host/Host.h" #include "lldb/Interpreter/CommandInterpreter.h" #include "lldb/Interpreter/CommandReturnObject.h" #include "lldb/Core/Debugger.h" #include "lldb/Target/Process.h" #include "lldb/Target/Thread.h" // This function is in the C++ output file generated by SWIG after it is // run on all of the headers in "lldb/API/SB*.h" extern "C" void init_lldb (void); extern "C" bool LLDBSWIGPythonBreakpointCallbackFunction ( const char *python_function_name, lldb::SBFrame& sb_frame, lldb::SBBreakpointLocation& sb_bp_loc ); using namespace lldb; using namespace lldb_private; const char embedded_interpreter_string[] = "import readline\n\ import code\n\ import sys\n\ import traceback\n\ \n\ class SimpleREPL(code.InteractiveConsole):\n\ def __init__(self, prompt, dict):\n\ code.InteractiveConsole.__init__(self,dict)\n\ self.prompt = prompt\n\ self.loop_exit = False\n\ self.dict = dict\n\ \n\ def interact(self):\n\ try:\n\ sys.ps1\n\ except AttributeError:\n\ sys.ps1 = \">>> \"\n\ try:\n\ sys.ps2\n\ except AttributeError:\n\ sys.ps2 = \"... \"\n\ \n\ while not self.loop_exit:\n\ try:\n\ self.read_py_command()\n\ except (SystemExit, EOFError):\n\ # EOF while in Python just breaks out to top level.\n\ self.write('\\n')\n\ self.loop_exit = True\n\ break\n\ except KeyboardInterrupt:\n\ self.write(\"\\nKeyboardInterrupt\\n\")\n\ self.resetbuffer()\n\ more = 0\n\ except:\n\ traceback.print_exc()\n\ \n\ def process_input (self, in_str):\n\ # Canonicalize the format of the input string\n\ temp_str = in_str\n\ temp_str.strip(' \t')\n\ words = temp_str.split()\n\ temp_str = ('').join(words)\n\ \n\ # Check the input string to see if it was the quit\n\ # command. If so, intercept it, so that it doesn't\n\ # close stdin on us!\n\ if (temp_str.lower() == \"quit()\" or temp_str.lower() == \"exit()\"):\n\ self.loop_exit = True\n\ in_str = \"raise SystemExit \"\n\ return in_str\n\ \n\ def my_raw_input (self, prompt):\n\ stream = sys.stdout\n\ stream.write (prompt)\n\ stream.flush ()\n\ try:\n\ line = sys.stdin.readline()\n\ except KeyboardInterrupt:\n\ line = \" \\n\"\n\ except (SystemExit, EOFError):\n\ line = \"quit()\\n\"\n\ if not line:\n\ raise EOFError\n\ if line[-1] == '\\n':\n\ line = line[:-1]\n\ return line\n\ \n\ def read_py_command(self):\n\ # Read off a complete Python command.\n\ more = 0\n\ while 1:\n\ if more:\n\ prompt = sys.ps2\n\ else:\n\ prompt = sys.ps1\n\ line = self.my_raw_input(prompt)\n\ # Can be None if sys.stdin was redefined\n\ encoding = getattr(sys.stdin, \"encoding\", None)\n\ if encoding and not isinstance(line, unicode):\n\ line = line.decode(encoding)\n\ line = self.process_input (line)\n\ more = self.push(line)\n\ if not more:\n\ break\n\ \n\ def run_python_interpreter (dict):\n\ # Pass in the dictionary, for continuity from one session to the next.\n\ repl = SimpleREPL('>>> ', dict)\n\ repl.interact()\n"; static int _check_and_flush (FILE *stream) { int prev_fail = ferror (stream); return fflush (stream) || prev_fail ? EOF : 0; } ScriptInterpreterPython::ScriptInterpreterPython (CommandInterpreter &interpreter) : ScriptInterpreter (interpreter, eScriptLanguagePython), m_compiled_module (NULL), m_termios_valid (false) { Timer scoped_timer (__PRETTY_FUNCTION__, __PRETTY_FUNCTION__); // Save terminal settings if we can int input_fd; FILE *input_fh = m_interpreter.GetDebugger().GetInputFileHandle(); if (input_fh != NULL) input_fd = ::fileno (input_fh); else input_fd = STDIN_FILENO; m_termios_valid = ::tcgetattr (input_fd, &m_termios) == 0; // Find the module that owns this code and use that path we get to // set the PYTHONPATH appropriately. FileSpec file_spec; char python_dir_path[PATH_MAX]; if (Host::GetLLDBPath (ePathTypePythonDir, file_spec)) { std::string python_path; const char *curr_python_path = ::getenv ("PYTHONPATH"); if (curr_python_path) { // We have a current value for PYTHONPATH, so lets append to it python_path.append (curr_python_path); } if (file_spec.GetPath(python_dir_path, sizeof (python_dir_path))) { if (!python_path.empty()) python_path.append (1, ':'); python_path.append (python_dir_path); } if (Host::GetLLDBPath (ePathTypeLLDBShlibDir, file_spec)) { if (file_spec.GetPath(python_dir_path, sizeof (python_dir_path))) { if (!python_path.empty()) python_path.append (1, ':'); python_path.append (python_dir_path); } } const char *pathon_path_env_cstr = python_path.c_str(); ::setenv ("PYTHONPATH", pathon_path_env_cstr, 1); } Py_Initialize (); PyObject *compiled_module = Py_CompileString (embedded_interpreter_string, "embedded_interpreter.py", Py_file_input); m_compiled_module = static_cast(compiled_module); // This function is in the C++ output file generated by SWIG after it is // run on all of the headers in "lldb/API/SB*.h" init_lldb (); // Update the path python uses to search for modules to include the current directory. int success = PyRun_SimpleString ("import sys"); success = PyRun_SimpleString ("sys.path.append ('.')"); if (success == 0) { // Import the Script Bridge module. success = PyRun_SimpleString ("import lldb"); } const char *pty_slave_name = GetScriptInterpreterPtyName (); FILE *out_fh = interpreter.GetDebugger().GetOutputFileHandle(); PyObject *pmod = PyImport_ExecCodeModule (const_cast ("embedded_interpreter"), static_cast(m_compiled_module)); if (pmod != NULL) { PyRun_SimpleString ("ConsoleDict = locals()"); PyRun_SimpleString ("from embedded_interpreter import run_python_interpreter"); PyRun_SimpleString ("import sys"); PyRun_SimpleString ("from termios import *"); if (out_fh != NULL) { PyObject *new_sysout = PyFile_FromFile (out_fh, (char *) "", (char *) "w", _check_and_flush); PyObject *sysmod = PyImport_AddModule ("sys"); PyObject *sysdict = PyModule_GetDict (sysmod); if ((new_sysout != NULL) && (sysmod != NULL) && (sysdict != NULL)) { PyDict_SetItemString (sysdict, "stdout", new_sysout); } if (PyErr_Occurred()) PyErr_Clear(); } StreamString run_string; run_string.Printf ("new_stdin = open('%s', 'r')", pty_slave_name); PyRun_SimpleString (run_string.GetData()); PyRun_SimpleString ("sys.stdin = new_stdin"); PyRun_SimpleString ("new_mode = tcgetattr(new_stdin)"); PyRun_SimpleString ("new_mode[3] = new_mode[3] | ECHO | ICANON"); PyRun_SimpleString ("new_mode[6][VEOF] = 255"); PyRun_SimpleString ("tcsetattr (new_stdin, TCSANOW, new_mode)"); run_string.Clear(); run_string.Printf ("lldb.debugger_unique_id = %d", interpreter.GetDebugger().GetID()); PyRun_SimpleString (run_string.GetData()); } // Restore terminal settings if they were validly saved if (m_termios_valid) { ::tcsetattr (input_fd, TCSANOW, &m_termios); } } ScriptInterpreterPython::~ScriptInterpreterPython () { Py_Finalize (); } bool ScriptInterpreterPython::ExecuteOneLine (const char *command, CommandReturnObject *result) { if (command) { int success; // Save the current input file handle state before executing the command. int input_fd; struct termios tmp_termios; bool valid_termios = false; FILE *input_fh = m_interpreter.GetDebugger().GetInputFileHandle(); if (input_fh != NULL) { input_fd = ::fileno (input_fh); valid_termios = ::tcgetattr (input_fd, &tmp_termios) == 0; } success = PyRun_SimpleString (command); if (success == 0) return true; // Restore the input file handle state after executing the command. if (valid_termios) ::tcsetattr (input_fd, TCSANOW, &tmp_termios); // The one-liner failed. Append the error message. if (result) result->AppendErrorWithFormat ("python failed attempting to evaluate '%s'\n", command); return false; } if (result) result->AppendError ("empty command passed to python\n"); return false; } size_t ScriptInterpreterPython::InputReaderCallback ( void *baton, InputReader &reader, InputReaderAction notification, const char *bytes, size_t bytes_len ) { if (baton == NULL) return 0; ScriptInterpreterPython *script_interpreter = (ScriptInterpreterPython *) baton; switch (notification) { case eInputReaderActivate: { // Save terminal settings if we can int input_fd; FILE *input_fh = reader.GetDebugger().GetInputFileHandle(); if (input_fh != NULL) input_fd = ::fileno (input_fh); else input_fd = STDIN_FILENO; script_interpreter->m_termios_valid = ::tcgetattr (input_fd, &script_interpreter->m_termios) == 0; if (script_interpreter->m_termios_valid) { struct termios tmp_termios = script_interpreter->m_termios; tmp_termios.c_cc[VEOF] = _POSIX_VDISABLE; ::tcsetattr (input_fd, TCSANOW, &tmp_termios); } } break; case eInputReaderDeactivate: break; case eInputReaderReactivate: break; case eInputReaderGotToken: if (bytes && bytes_len) { if ((int) bytes[0] == 4) ::write (script_interpreter->GetMasterFileDescriptor(), "quit()", 6); else ::write (script_interpreter->GetMasterFileDescriptor(), bytes, bytes_len); } ::write (script_interpreter->GetMasterFileDescriptor(), "\n", 1); break; case eInputReaderDone: // Send a control D to the script interpreter //::write (interpreter->GetMasterFileDescriptor(), "\nquit()\n", strlen("\nquit()\n")); // Write a newline out to the reader output //::fwrite ("\n", 1, 1, out_fh); // Restore terminal settings if they were validly saved if (script_interpreter->m_termios_valid) { int input_fd; FILE *input_fh = reader.GetDebugger().GetInputFileHandle(); if (input_fh != NULL) input_fd = ::fileno (input_fh); else input_fd = STDIN_FILENO; ::tcsetattr (input_fd, TCSANOW, &script_interpreter->m_termios); } break; } return bytes_len; } void ScriptInterpreterPython::ExecuteInterpreterLoop () { Timer scoped_timer (__PRETTY_FUNCTION__, __PRETTY_FUNCTION__); Debugger &debugger = m_interpreter.GetDebugger(); // At the moment, the only time the debugger does not have an input file handle is when this is called // directly from Python, in which case it is both dangerous and unnecessary (not to mention confusing) to // try to embed a running interpreter loop inside the already running Python interpreter loop, so we won't // do it. if (debugger.GetInputFileHandle() == NULL) return; InputReaderSP reader_sp (new InputReader(debugger)); if (reader_sp) { Error error (reader_sp->Initialize (ScriptInterpreterPython::InputReaderCallback, this, // baton eInputReaderGranularityLine, // token size, to pass to callback function NULL, // end token NULL, // prompt true)); // echo input if (error.Success()) { debugger.PushInputReader (reader_sp); ExecuteOneLine ("run_python_interpreter(ConsoleDict)", NULL); debugger.PopInputReader (reader_sp); } } } bool ScriptInterpreterPython::ExecuteOneLineWithReturn (const char *in_string, ScriptInterpreter::ReturnType return_type, void *ret_value) { PyObject *py_return = NULL; PyObject *mainmod = PyImport_AddModule ("__main__"); PyObject *globals = PyModule_GetDict (mainmod); PyObject *locals = globals; PyObject *py_error = NULL; bool ret_success; int success; if (in_string != NULL) { py_return = PyRun_String (in_string, Py_eval_input, globals, locals); if (py_return == NULL) { py_error = PyErr_Occurred (); if (py_error != NULL) PyErr_Clear (); py_return = PyRun_String (in_string, Py_single_input, globals, locals); } if (py_return != NULL) { switch (return_type) { case eCharPtr: // "char *" { const char format[3] = "s#"; success = PyArg_Parse (py_return, format, (char **) &ret_value); break; } case eBool: { const char format[2] = "b"; success = PyArg_Parse (py_return, format, (bool *) ret_value); break; } case eShortInt: { const char format[2] = "h"; success = PyArg_Parse (py_return, format, (short *) ret_value); break; } case eShortIntUnsigned: { const char format[2] = "H"; success = PyArg_Parse (py_return, format, (unsigned short *) ret_value); break; } case eInt: { const char format[2] = "i"; success = PyArg_Parse (py_return, format, (int *) ret_value); break; } case eIntUnsigned: { const char format[2] = "I"; success = PyArg_Parse (py_return, format, (unsigned int *) ret_value); break; } case eLongInt: { const char format[2] = "l"; success = PyArg_Parse (py_return, format, (long *) ret_value); break; } case eLongIntUnsigned: { const char format[2] = "k"; success = PyArg_Parse (py_return, format, (unsigned long *) ret_value); break; } case eLongLong: { const char format[2] = "L"; success = PyArg_Parse (py_return, format, (long long *) ret_value); break; } case eLongLongUnsigned: { const char format[2] = "K"; success = PyArg_Parse (py_return, format, (unsigned long long *) ret_value); break; } case eFloat: { const char format[2] = "f"; success = PyArg_Parse (py_return, format, (float *) ret_value); break; } case eDouble: { const char format[2] = "d"; success = PyArg_Parse (py_return, format, (double *) ret_value); break; } case eChar: { const char format[2] = "c"; success = PyArg_Parse (py_return, format, (char *) ret_value); break; } default: {} } Py_DECREF (py_return); if (success) ret_success = true; else ret_success = false; } } py_error = PyErr_Occurred(); if (py_error != NULL) { if (PyErr_GivenExceptionMatches (py_error, PyExc_SyntaxError)) PyErr_Print (); PyErr_Clear(); ret_success = false; } return ret_success; } bool ScriptInterpreterPython::ExecuteMultipleLines (const char *in_string) { bool success = false; PyObject *py_return = NULL; PyObject *mainmod = PyImport_AddModule ("__main__"); PyObject *globals = PyModule_GetDict (mainmod); PyObject *locals = globals; PyObject *py_error = NULL; if (in_string != NULL) { struct _node *compiled_node = PyParser_SimpleParseString (in_string, Py_file_input); if (compiled_node) { PyCodeObject *compiled_code = PyNode_Compile (compiled_node, "temp.py"); if (compiled_code) { py_return = PyEval_EvalCode (compiled_code, globals, locals); if (py_return != NULL) { success = true; Py_DECREF (py_return); } } } } py_error = PyErr_Occurred (); if (py_error != NULL) { if (PyErr_GivenExceptionMatches (py_error, PyExc_SyntaxError)) PyErr_Print (); PyErr_Clear(); success = false; } return success; } static const char *g_reader_instructions = "Enter your Python command(s). Type 'DONE' to end."; size_t ScriptInterpreterPython::GenerateBreakpointOptionsCommandCallback ( void *baton, InputReader &reader, InputReaderAction notification, const char *bytes, size_t bytes_len ) { static StringList commands_in_progress; FILE *out_fh = reader.GetDebugger().GetOutputFileHandle(); if (out_fh == NULL) out_fh = stdout; switch (notification) { case eInputReaderActivate: { commands_in_progress.Clear(); if (out_fh) { ::fprintf (out_fh, "%s\n", g_reader_instructions); if (reader.GetPrompt()) ::fprintf (out_fh, "%s", reader.GetPrompt()); ::fflush (out_fh); } } break; case eInputReaderDeactivate: break; case eInputReaderReactivate: if (reader.GetPrompt() && out_fh) { ::fprintf (out_fh, "%s", reader.GetPrompt()); ::fflush (out_fh); } break; case eInputReaderGotToken: { std::string temp_string (bytes, bytes_len); commands_in_progress.AppendString (temp_string.c_str()); if (out_fh && !reader.IsDone() && reader.GetPrompt()) { ::fprintf (out_fh, "%s", reader.GetPrompt()); ::fflush (out_fh); } } break; case eInputReaderDone: { BreakpointOptions *bp_options = (BreakpointOptions *)baton; std::auto_ptr data_ap(new BreakpointOptions::CommandData()); data_ap->user_source.AppendList (commands_in_progress); if (data_ap.get()) { ScriptInterpreter *interpreter = reader.GetDebugger().GetCommandInterpreter().GetScriptInterpreter(); if (interpreter) { if (interpreter->GenerateBreakpointCommandCallbackData (data_ap->user_source, data_ap->script_source)) { if (data_ap->script_source.GetSize() == 1) { BatonSP baton_sp (new BreakpointOptions::CommandBaton (data_ap.release())); bp_options->SetCallback (ScriptInterpreterPython::BreakpointCallbackFunction, baton_sp); } } else ::fprintf (out_fh, "Warning: No command attached to breakpoint.\n"); } else { // FIXME: Error processing. } } } break; } return bytes_len; } void ScriptInterpreterPython::CollectDataForBreakpointCommandCallback (BreakpointOptions *bp_options, CommandReturnObject &result) { Debugger &debugger = m_interpreter.GetDebugger(); InputReaderSP reader_sp (new InputReader (debugger)); if (reader_sp) { Error err = reader_sp->Initialize ( ScriptInterpreterPython::GenerateBreakpointOptionsCommandCallback, bp_options, // baton eInputReaderGranularityLine, // token size, for feeding data to callback function "DONE", // end token "> ", // prompt true); // echo input if (err.Success()) debugger.PushInputReader (reader_sp); else { result.AppendError (err.AsCString()); result.SetStatus (eReturnStatusFailed); } } else { result.AppendError("out of memory"); result.SetStatus (eReturnStatusFailed); } } // Set a Python one-liner as the callback for the breakpoint. void ScriptInterpreterPython::SetBreakpointCommandCallback (BreakpointOptions *bp_options, const char *oneliner) { std::auto_ptr data_ap(new BreakpointOptions::CommandData()); // It's necessary to set both user_source and script_source to the oneliner. // The former is used to generate callback description (as in breakpoint command list) // while the latter is used for Python to interpret during the actual callback. data_ap->user_source.AppendString (oneliner); if (GenerateBreakpointCommandCallbackData (data_ap->user_source, data_ap->script_source)) { if (data_ap->script_source.GetSize() == 1) { BatonSP baton_sp (new BreakpointOptions::CommandBaton (data_ap.release())); bp_options->SetCallback (ScriptInterpreterPython::BreakpointCallbackFunction, baton_sp); } } return; } bool ScriptInterpreterPython::ExportFunctionDefinitionToInterpreter (StringList &function_def) { // Convert StringList to one long, newline delimited, const char *. std::string function_def_string; int num_lines = function_def.GetSize(); for (int i = 0; i < num_lines; ++i) { function_def_string.append (function_def.GetStringAtIndex(i)); if (function_def_string.at (function_def_string.length() - 1) != '\n') function_def_string.append ("\n"); } return ExecuteMultipleLines (function_def_string.c_str()); } bool ScriptInterpreterPython::GenerateBreakpointCommandCallbackData (StringList &user_input, StringList &callback_data) { static int num_created_functions = 0; user_input.RemoveBlankLines (); int num_lines = user_input.GetSize (); StreamString sstr; // Take what the user wrote, wrap it all up inside one big auto-generated Python function, passing in the // frame and breakpoint location as parameters to the function. sstr.Printf ("lldb_autogen_python_bp_callback_func_%d", num_created_functions); ++num_created_functions; std::string auto_generated_function_name = sstr.GetData(); sstr.Clear(); StringList auto_generated_function; // Create the function name & definition string. sstr.Printf ("def %s (frame, bp_loc):", auto_generated_function_name.c_str()); auto_generated_function.AppendString (sstr.GetData()); // Wrap everything up inside the function, increasing the indentation. for (int i = 0; i < num_lines; ++i) { sstr.Clear (); sstr.Printf (" %s", user_input.GetStringAtIndex (i)); auto_generated_function.AppendString (sstr.GetData()); } // Verify that the results are valid Python. if (!ExportFunctionDefinitionToInterpreter (auto_generated_function)) { return false; } // Store the name of the auto-generated function to be called. callback_data.AppendString (auto_generated_function_name.c_str()); return true; } bool ScriptInterpreterPython::BreakpointCallbackFunction ( void *baton, StoppointCallbackContext *context, user_id_t break_id, user_id_t break_loc_id ) { BreakpointOptions::CommandData *bp_option_data = (BreakpointOptions::CommandData *) baton; const char *python_function_name = bp_option_data->script_source.GetStringAtIndex (0); if (python_function_name != NULL && python_function_name[0] != '\0') { Thread *thread = context->exe_ctx.thread; Target *target = context->exe_ctx.target; const StackFrameSP stop_frame_sp = thread->GetStackFrameSPForStackFramePtr (context->exe_ctx.frame); BreakpointSP breakpoint_sp = target->GetBreakpointByID (break_id); const BreakpointLocationSP bp_loc_sp = breakpoint_sp->FindLocationByID (break_loc_id); SBFrame sb_frame (stop_frame_sp); SBBreakpointLocation sb_bp_loc (bp_loc_sp); if (sb_bp_loc.IsValid() || sb_frame.IsValid()) return LLDBSWIGPythonBreakpointCallbackFunction (python_function_name, sb_frame, sb_bp_loc); } // We currently always true so we stop in case anything goes wrong when // trying to call the script function return true; }