caio/clang-p2996
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

- Support for Python namespaces:

Browse Source 
If you have a Python module foo, in order to use its contained objects in LLDB you do not need to use
  'from foo import *'. You can use 'import foo', and then refer to items in foo as 'foo.bar', and LLDB
  will know how to resolve bar as a member of foo.
  Accordingly, GNU libstdc++ formatters have been moved from the global namespace to gnu_libstdcpp and a few
  test cases are also updated to reflect the new convention. Python docs suggest using a plain 'import' en lieu of
  'from-import'.

llvm-svn: 138244
This commit is contained in:
Enrico Granata
2011-08-22 17:34:47 +00:00
parent 4b8e8ce37f
commit def5391ae5
5 changed files with 143 additions and 216 deletions
Download Patch File Download Diff File Expand all files Collapse all files

339
lldb/scripts/Python/python-wrapper.swig
View File

@@ -1,5 +1,112 @@
%wrapper %{
class PyErr_Cleaner
{
public:
PyErr_Cleaner(bool print=false) :
m_print(print)
{
}
~PyErr_Cleaner()
{
if (PyErr_Occurred())
{
if(m_print)
PyErr_Print();
PyErr_Clear();
}
}
private:
bool m_print;
};
// resolve a dotted Python name in the form
// foo.bar.baz.Foobar to an actual Python object
// if pmodule is NULL, the __main__ module will be used
// as the starting point for the search
static PyObject*
ResolvePythonName(const char* name,
PyObject* pmodule = NULL)
{
//printf("Resolving %s\n", name);
if (!name || !name[0])
return pmodule;
PyErr_Cleaner pyerr_cleanup(true); // show Python errors
PyObject* main_dict;
if (!pmodule)
{
pmodule = PyImport_AddModule ("__main__");
if (!pmodule)
return NULL;
}
if (!PyDict_Check(pmodule))
{
main_dict = PyModule_GetDict (pmodule);
if (!main_dict)
return NULL;
}
else
main_dict = pmodule;
const char* dot_pos = ::strchr(name, '.');
PyObject *dest_object;
PyObject *key, *value;
Py_ssize_t pos = 0;
if (!dot_pos)
{
if (PyDict_Check (main_dict))
{
dest_object = NULL;
while (PyDict_Next (main_dict, &pos, &key, &value))
{
// We have stolen references to the key and value objects in the dictionary; we need to increment
// them now so that Python's garbage collector doesn't collect them out from under us.
Py_INCREF (key);
Py_INCREF (value);
//printf("Comparing %s and %s\n", name, PyString_AsString (key));
if (strcmp (PyString_AsString (key), name) == 0)
{
dest_object = value;
break;
}
}
}
if (!dest_object || dest_object == Py_None)
return NULL;
return dest_object;
}
// foo.bar.ba
// 0123456789
// len = 3 - 0
size_t len = dot_pos - name;
std::string piece(name,len);
dest_object = ResolvePythonName(piece.c_str(), main_dict);
//printf("Resolved %s to %p\n", piece.c_str(), dest_object);
if (!dest_object)
return NULL;
//printf("Now moving to resolve %s\n", dot_pos+1);
return ResolvePythonName(dot_pos+1,dest_object); // tail recursion.. should be optimized by the compiler
}
static PyObject*
FindSessionDictionary(const char *session_dictionary_name)
{
return ResolvePythonName(session_dictionary_name, NULL);
}
// This function is called by lldb_private::ScriptInterpreterPython::BreakpointCallbackFunction(...)
// and is used when a script command is attached to a breakpoint for execution.
@@ -25,63 +132,18 @@ LLDBSwigPythonBreakpointCallbackFunction
if (!python_function_name || !session_dictionary_name)
return stop_at_breakpoint;
PyObject *pmodule, *main_dict, *session_dict, *pfunc;
PyObject *session_dict, *pfunc;
PyObject *pargs, *pvalue;
pmodule = PyImport_AddModule ("__main__");
if (pmodule != NULL)
session_dict = FindSessionDictionary (session_dictionary_name);
if (session_dict != NULL)
{
main_dict = PyModule_GetDict (pmodule);
if (main_dict != NULL)
pfunc = ResolvePythonName (python_function_name, session_dict);
if (pfunc != NULL)
{
PyObject *key, *value;
Py_ssize_t pos = 0;
// Find the current session's dictionary in the main module's dictionary.
if (PyDict_Check (main_dict))
{
session_dict = NULL;
while (PyDict_Next (main_dict, &pos, &key, &value))
{
// We have stolen references to the key and value objects in the dictionary; we need to increment
// them now so that Python's garbage collector doesn't collect them out from under us.
Py_INCREF (key);
Py_INCREF (value);
if (strcmp (PyString_AsString (key), session_dictionary_name) == 0)
{
session_dict = value;
break;
}
}
}
if (!session_dict || !PyDict_Check (session_dict))
return stop_at_breakpoint;
// Find the function we need to call in the current session's dictionary.
pos = 0;
pfunc = NULL;
while (PyDict_Next (session_dict, &pos, &key, &value))
{
if (PyString_Check (key))
{
// We have stolen references to the key and value objects in the dictionary; we need to increment
// them now so that Python's garbage collector doesn't collect them out from under us.
Py_INCREF (key);
Py_INCREF (value);
if (strcmp (PyString_AsString (key), python_function_name) == 0)
{
pfunc = value;
break;
}
}
}
// Set up the arguments and call the function.
if (pfunc && PyCallable_Check (pfunc))
if (PyCallable_Check (pfunc))
{
pargs = PyTuple_New (3);
if (pargs == NULL)
@@ -144,63 +206,18 @@ LLDBSwigPythonCallTypeScript
if (!python_function_name || !session_dictionary_name)
return retval;
PyObject *pmodule, *main_dict, *session_dict, *pfunc;
PyObject *session_dict, *pfunc;
PyObject *pargs, *pvalue;
pmodule = PyImport_AddModule ("__main__");
if (pmodule != NULL)
session_dict = FindSessionDictionary (session_dictionary_name);
if (session_dict != NULL)
{
main_dict = PyModule_GetDict (pmodule);
if (main_dict != NULL)
pfunc = ResolvePythonName (python_function_name, session_dict);
if (pfunc != NULL)
{
PyObject *key, *value;
Py_ssize_t pos = 0;
// Find the current session's dictionary in the main module's dictionary.
if (PyDict_Check (main_dict))
{
session_dict = NULL;
while (PyDict_Next (main_dict, &pos, &key, &value))
{
// We have stolen references to the key and value objects in the dictionary; we need to increment
// them now so that Python's garbage collector doesn't collect them out from under us.
Py_INCREF (key);
Py_INCREF (value);
if (strcmp (PyString_AsString (key), session_dictionary_name) == 0)
{
session_dict = value;
break;
}
}
}
if (!session_dict || !PyDict_Check (session_dict))
return retval;
// Find the function we need to call in the current session's dictionary.
pos = 0;
pfunc = NULL;
while (PyDict_Next (session_dict, &pos, &key, &value))
{
if (PyString_Check (key))
{
// We have stolen references to the key and value objects in the dictionary; we need to increment
// them now so that Python's garbage collector doesn't collect them out from under us.
Py_INCREF (key);
Py_INCREF (value);
if (strcmp (PyString_AsString (key), python_function_name) == 0)
{
pfunc = value;
break;
}
}
}
// Set up the arguments and call the function.
if (pfunc && PyCallable_Check (pfunc))
if (PyCallable_Check (pfunc))
{
pargs = PyTuple_New (2);
if (pargs == NULL)
@@ -274,63 +291,18 @@ LLDBSwigPythonCreateSyntheticProvider
const char* python_function_name = python_class_name.c_str();
PyObject *pmodule, *main_dict, *session_dict, *pfunc;
PyObject *session_dict, *pfunc;
PyObject *pvalue;
pmodule = PyImport_AddModule ("__main__");
if (pmodule != NULL)
session_dict = FindSessionDictionary (session_dictionary_name);
if (session_dict != NULL)
{
main_dict = PyModule_GetDict (pmodule);
if (main_dict != NULL)
pfunc = ResolvePythonName (python_function_name, session_dict);
if (pfunc != NULL)
{
PyObject *key, *value;
Py_ssize_t pos = 0;
// Find the current session's dictionary in the main module's dictionary.
if (PyDict_Check (main_dict))
{
session_dict = NULL;
while (PyDict_Next (main_dict, &pos, &key, &value))
{
// We have stolen references to the key and value objects in the dictionary; we need to increment
// them now so that Python's garbage collector doesn't collect them out from under us.
Py_INCREF (key);
Py_INCREF (value);
if (strcmp (PyString_AsString (key), session_dictionary_name) == 0)
{
session_dict = value;
break;
}
}
}
if (!session_dict || !PyDict_Check (session_dict))
return retval;
// Find the function we need to call in the current session's dictionary.
pos = 0;
pfunc = NULL;
while (PyDict_Next (session_dict, &pos, &key, &value))
{
if (PyString_Check (key))
{
// We have stolen references to the key and value objects in the dictionary; we need to increment
// them now so that Python's garbage collector doesn't collect them out from under us.
Py_INCREF (key);
Py_INCREF (value);
if (strcmp (PyString_AsString (key), python_function_name) == 0)
{
pfunc = value;
break;
}
}
}
// Set up the arguments and call the function.
if (pfunc && PyCallable_Check (pfunc))
if (PyCallable_Check (pfunc))
{
PyObject *argList = Py_BuildValue("SS", ValObj_PyObj, session_dict);
@@ -638,63 +610,18 @@ LLDBSwigPythonCallCommand
if (!python_function_name || !session_dictionary_name)
return retval;
PyObject *pmodule, *main_dict, *session_dict, *pfunc;
PyObject *session_dict, *pfunc;
PyObject *pargs, *pvalue;
pmodule = PyImport_AddModule ("__main__");
if (pmodule != NULL)
session_dict = FindSessionDictionary (session_dictionary_name);
if (session_dict != NULL)
{
main_dict = PyModule_GetDict (pmodule);
if (main_dict != NULL)
pfunc = ResolvePythonName (python_function_name, session_dict);
if (pfunc != NULL)
{
PyObject *key, *value;
Py_ssize_t pos = 0;
// Find the current session's dictionary in the main module's dictionary.
if (PyDict_Check (main_dict))
{
session_dict = NULL;
while (PyDict_Next (main_dict, &pos, &key, &value))
{
// We have stolen references to the key and value objects in the dictionary; we need to increment
// them now so that Python's garbage collector doesn't collect them out from under us.
Py_INCREF (key);
Py_INCREF (value);
if (strcmp (PyString_AsString (key), session_dictionary_name) == 0)
{
session_dict = value;
break;
}
}
}
if (!session_dict || !PyDict_Check (session_dict))
return retval;
// Find the function we need to call in the current session's dictionary.
pos = 0;
pfunc = NULL;
while (PyDict_Next (session_dict, &pos, &key, &value))
{
if (PyString_Check (key))
{
// We have stolen references to the key and value objects in the dictionary; we need to increment
// them now so that Python's garbage collector doesn't collect them out from under us.
Py_INCREF (key);
Py_INCREF (value);
if (strcmp (PyString_AsString (key), python_function_name) == 0)
{
pfunc = value;
break;
}
}
}
// Set up the arguments and call the function.
if (pfunc && PyCallable_Check (pfunc))
if (PyCallable_Check (pfunc))
{
pargs = PyTuple_New (4);
if (pargs == NULL)