* python/py-arch.c (gdbpy_initialize_arch): Return 'int'.
authorTom Tromey <tromey@redhat.com>
Mon, 20 May 2013 20:28:52 +0000 (20:28 +0000)
committerTom Tromey <tromey@redhat.com>
Mon, 20 May 2013 20:28:52 +0000 (20:28 +0000)
Check errors.
* python/py-auto-load.c (gdbpy_initialize_auto_load): Return 'int'.
* python/py-block.c (gdbpy_initialize_blocks): Return 'int'.
Check errors.
* python/py-breakpoint.c (gdbpy_initialize_breakpoints): Return 'int'.
Check errors.
* python/py-cmd.c (gdbpy_initialize_commands): Return 'int'.
Check errors.
* python/py-event.c (gdbpy_initialize_event): Return 'int'.
Check errors.
* python/py-event.h (GDBPY_NEW_EVENT_TYPE): Change generated
init function to return 'int'.
* python/py-evtregistry.c (gdbpy_initialize_eventregistry):
Return 'int'.  Check errors.
* python/py-evts.c (gdbpy_initialize_py_events): Return 'int'.
Check errors.
* python/py-finishbreakpoint.c (gdbpy_initialize_finishbreakpoints):
Return 'int'.  Check errors.
* python/py-frame.c (gdbpy_initialize_frames): Return 'int'.
Check errors.
* python/py-function.c (gdbpy_initialize_functions): Return 'int'.
Check errors.
* python/py-gdb-readline.c (gdbpy_initialize_gdb_readline):
Check errors.
* python/py-inferior.c (gdbpy_initialize_inferior): Return 'int'.
Check errors.
* python/py-infthread.c (gdbpy_initialize_thread): Return 'int'.
Check errors.
* python/py-lazy-string.c (gdbpy_initialize_lazy_string): Return 'int'.
Check errors.
* python/py-objfile.c (gdbpy_initialize_objfile): Return 'int'.
Check errors.
* python/py-param.c (gdbpy_initialize_parameters): Return 'int'.
Check errors.
* python/py-progspace.c (gdbpy_initialize_pspace): Return 'int'.
Check errors.
* python/py-symbol.c (gdbpy_initialize_symbols): Return 'int'.
Check errors.
* python/py-symtab.c (gdbpy_initialize_symtabs): Return 'int'.
Check errors.
* python/py-type.c (gdbpy_initialize_types): Return 'int'.
Check errors.
* python/py-value.c (gdbpy_initialize_values): Return 'int'.
Check errors.
* python/python-internal.h (gdbpy_initialize_auto_load,
gdbpy_initialize_values, gdbpy_initialize_frames,
gdbpy_initialize_symtabs, gdbpy_initialize_commands,
gdbpy_initialize_symbols, gdbpy_initialize_symtabs,
gdbpy_initialize_blocks, gdbpy_initialize_types,
gdbpy_initialize_functions, gdbpy_initialize_pspace,
gdbpy_initialize_objfile, gdbpy_initialize_breakpoints,
gdbpy_initialize_finishbreakpoints,
gdbpy_initialize_lazy_string, gdbpy_initialize_parameters,
gdbpy_initialize_thread, gdbpy_initialize_inferior,
gdbpy_initialize_eventregistry, gdbpy_initialize_event,
gdbpy_initialize_py_events, gdbpy_initialize_stop_event,
gdbpy_initialize_signal_event,
gdbpy_initialize_breakpoint_event,
gdbpy_initialize_continue_event,
gdbpy_initialize_exited_event, gdbpy_initialize_thread_event,
gdbpy_initialize_new_objfile_event, gdbpy_initialize_arch):
Update.  Use CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION.
* python/python.c (gdb_python_initialized): New global.
(gdbpy_initialize_events): Return 'int'.  Check errors.
(_initialize_python): Check errors.  Set
gdb_python_initialized.

26 files changed:
gdb/ChangeLog
gdb/python/py-arch.c
gdb/python/py-auto-load.c
gdb/python/py-block.c
gdb/python/py-breakpoint.c
gdb/python/py-cmd.c
gdb/python/py-event.c
gdb/python/py-event.h
gdb/python/py-evtregistry.c
gdb/python/py-evts.c
gdb/python/py-finishbreakpoint.c
gdb/python/py-frame.c
gdb/python/py-function.c
gdb/python/py-gdb-readline.c
gdb/python/py-inferior.c
gdb/python/py-infthread.c
gdb/python/py-lazy-string.c
gdb/python/py-objfile.c
gdb/python/py-param.c
gdb/python/py-progspace.c
gdb/python/py-symbol.c
gdb/python/py-symtab.c
gdb/python/py-type.c
gdb/python/py-value.c
gdb/python/python-internal.h
gdb/python/python.c

index 5103cbc540059c32dec93a79fe3032d44e6d98f7..e2e73ac2627e4d8416a5a3410325af445df6bf43 100644 (file)
@@ -1,3 +1,73 @@
+2013-05-20  Tom Tromey  <tromey@redhat.com>
+
+       * python/py-arch.c (gdbpy_initialize_arch): Return 'int'.
+       Check errors.
+       * python/py-auto-load.c (gdbpy_initialize_auto_load): Return 'int'.
+       * python/py-block.c (gdbpy_initialize_blocks): Return 'int'.
+       Check errors.
+       * python/py-breakpoint.c (gdbpy_initialize_breakpoints): Return 'int'.
+       Check errors.
+       * python/py-cmd.c (gdbpy_initialize_commands): Return 'int'.
+       Check errors.
+       * python/py-event.c (gdbpy_initialize_event): Return 'int'.
+       Check errors.
+       * python/py-event.h (GDBPY_NEW_EVENT_TYPE): Change generated
+       init function to return 'int'.
+       * python/py-evtregistry.c (gdbpy_initialize_eventregistry):
+       Return 'int'.  Check errors.
+       * python/py-evts.c (gdbpy_initialize_py_events): Return 'int'.
+       Check errors.
+       * python/py-finishbreakpoint.c (gdbpy_initialize_finishbreakpoints):
+       Return 'int'.  Check errors.
+       * python/py-frame.c (gdbpy_initialize_frames): Return 'int'.
+       Check errors.
+       * python/py-function.c (gdbpy_initialize_functions): Return 'int'.
+       Check errors.
+       * python/py-gdb-readline.c (gdbpy_initialize_gdb_readline):
+       Check errors.
+       * python/py-inferior.c (gdbpy_initialize_inferior): Return 'int'.
+       Check errors.
+       * python/py-infthread.c (gdbpy_initialize_thread): Return 'int'.
+       Check errors.
+       * python/py-lazy-string.c (gdbpy_initialize_lazy_string): Return 'int'.
+       Check errors.
+       * python/py-objfile.c (gdbpy_initialize_objfile): Return 'int'.
+       Check errors.
+       * python/py-param.c (gdbpy_initialize_parameters): Return 'int'.
+       Check errors.
+       * python/py-progspace.c (gdbpy_initialize_pspace): Return 'int'.
+       Check errors.
+       * python/py-symbol.c (gdbpy_initialize_symbols): Return 'int'.
+       Check errors.
+       * python/py-symtab.c (gdbpy_initialize_symtabs): Return 'int'.
+       Check errors.
+       * python/py-type.c (gdbpy_initialize_types): Return 'int'.
+       Check errors.
+       * python/py-value.c (gdbpy_initialize_values): Return 'int'.
+       Check errors.
+       * python/python-internal.h (gdbpy_initialize_auto_load,
+       gdbpy_initialize_values, gdbpy_initialize_frames,
+       gdbpy_initialize_symtabs, gdbpy_initialize_commands,
+       gdbpy_initialize_symbols, gdbpy_initialize_symtabs,
+       gdbpy_initialize_blocks, gdbpy_initialize_types,
+       gdbpy_initialize_functions, gdbpy_initialize_pspace,
+       gdbpy_initialize_objfile, gdbpy_initialize_breakpoints,
+       gdbpy_initialize_finishbreakpoints,
+       gdbpy_initialize_lazy_string, gdbpy_initialize_parameters,
+       gdbpy_initialize_thread, gdbpy_initialize_inferior,
+       gdbpy_initialize_eventregistry, gdbpy_initialize_event,
+       gdbpy_initialize_py_events, gdbpy_initialize_stop_event,
+       gdbpy_initialize_signal_event,
+       gdbpy_initialize_breakpoint_event,
+       gdbpy_initialize_continue_event,
+       gdbpy_initialize_exited_event, gdbpy_initialize_thread_event,
+       gdbpy_initialize_new_objfile_event, gdbpy_initialize_arch):
+       Update.  Use CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION.
+       * python/python.c (gdb_python_initialized): New global.
+       (gdbpy_initialize_events): Return 'int'.  Check errors.
+       (_initialize_python): Check errors.  Set
+       gdb_python_initialized.
+
 2013-05-20  Tom Tromey  <tromey@redhat.com>
 
        * python/py-finishbreakpoint.c (bpfinishpy_out_of_scope):
index 146a64237ef212d69e95d7cd574358cd0919b4fb..7920fbb3d2cd0e1c10ad0ba0587437ae0790544e 100644 (file)
@@ -231,17 +231,17 @@ archpy_disassemble (PyObject *self, PyObject *args, PyObject *kw)
 
 /* Initializes the Architecture class in the gdb module.  */
 
-void
+int
 gdbpy_initialize_arch (void)
 {
   arch_object_data = gdbarch_data_register_post_init (arch_object_data_init);
   arch_object_type.tp_new = PyType_GenericNew;
   if (PyType_Ready (&arch_object_type) < 0)
-    return;
+    return -1;
 
   Py_INCREF (&arch_object_type);
-  PyModule_AddObject (gdb_module, "Architecture",
-                      (PyObject *) &arch_object_type);
+  return PyModule_AddObject (gdb_module, "Architecture",
+                            (PyObject *) &arch_object_type);
 }
 
 static PyMethodDef arch_object_methods [] = {
index 53a8eb5eb3d525335365749bc59192f100286693..fa0743236f2423ae6a5eabe5f8ad2666c60fd951 100644 (file)
@@ -238,7 +238,7 @@ info_auto_load_python_scripts (char *pattern, int from_tty)
   auto_load_info_scripts (pattern, from_tty, &script_language_python);
 }
 \f
-void
+int
 gdbpy_initialize_auto_load (void)
 {
   struct cmd_list_element *cmd;
@@ -281,6 +281,8 @@ Usage: info auto-load python-scripts [REGEXP]"),
   cmd = add_info ("auto-load-scripts", info_auto_load_python_scripts, _("\
 Print the list of automatically loaded Python scripts, deprecated."));
   deprecate_cmd (cmd, "info auto-load python-scripts");
+
+  return 0;
 }
 
 #else /* ! HAVE_PYTHON */
index afc8959027e5d655819494cc14b029882fc1b6d8..f2d9000bd94168bf491cfce4d8a1d11dc7e72d7b 100644 (file)
@@ -425,16 +425,16 @@ del_objfile_blocks (struct objfile *objfile, void *datum)
     }
 }
 
-void
+int
 gdbpy_initialize_blocks (void)
 {
   block_object_type.tp_new = PyType_GenericNew;
   if (PyType_Ready (&block_object_type) < 0)
-    return;
+    return -1;
 
   block_syms_iterator_object_type.tp_new = PyType_GenericNew;
   if (PyType_Ready (&block_syms_iterator_object_type) < 0)
-    return;
+    return -1;
 
   /* Register an objfile "free" callback so we can properly
      invalidate blocks when an object file is about to be
@@ -443,11 +443,13 @@ gdbpy_initialize_blocks (void)
     = register_objfile_data_with_cleanup (NULL, del_objfile_blocks);
 
   Py_INCREF (&block_object_type);
-  PyModule_AddObject (gdb_module, "Block", (PyObject *) &block_object_type);
+  if (PyModule_AddObject (gdb_module, "Block",
+                         (PyObject *) &block_object_type) < 0)
+    return -1;
 
   Py_INCREF (&block_syms_iterator_object_type);
-  PyModule_AddObject (gdb_module, "BlockIterator",
-                     (PyObject *) &block_syms_iterator_object_type);
+  return PyModule_AddObject (gdb_module, "BlockIterator",
+                            (PyObject *) &block_syms_iterator_object_type);
 }
 
 \f
index 5e5f9b33a1593dd2863d2beaace6f22967ed1eac..b1b6e931feea97e4cd3c8ecb560357e8008436da 100644 (file)
@@ -859,18 +859,19 @@ gdbpy_breakpoint_deleted (struct breakpoint *b)
 \f
 
 /* Initialize the Python breakpoint code.  */
-void
+int
 gdbpy_initialize_breakpoints (void)
 {
   int i;
 
   breakpoint_object_type.tp_new = PyType_GenericNew;
   if (PyType_Ready (&breakpoint_object_type) < 0)
-    return;
+    return -1;
 
   Py_INCREF (&breakpoint_object_type);
-  PyModule_AddObject (gdb_module, "Breakpoint",
-                     (PyObject *) &breakpoint_object_type);
+  if (PyModule_AddObject (gdb_module, "Breakpoint",
+                         (PyObject *) &breakpoint_object_type) < 0)
+    return -1;
 
   observer_attach_breakpoint_created (gdbpy_breakpoint_created);
   observer_attach_breakpoint_deleted (gdbpy_breakpoint_deleted);
@@ -882,7 +883,7 @@ gdbpy_initialize_breakpoints (void)
                                   /* Cast needed for Python 2.4.  */
                                   (char *) pybp_codes[i].name,
                                   pybp_codes[i].code) < 0)
-       return;
+       return -1;
     }
 
   /* Add watchpoint types constants.  */
@@ -892,9 +893,10 @@ gdbpy_initialize_breakpoints (void)
                                   /* Cast needed for Python 2.4.  */
                                   (char *) pybp_watch_types[i].name,
                                   pybp_watch_types[i].code) < 0)
-       return;
+       return -1;
     }
 
+  return 0;
 }
 
 \f
index 26823c7ffff34da99f57486366c910a20b732546..ba765e098a738184740f0fa2972edc106d363494 100644 (file)
@@ -564,14 +564,14 @@ cmdpy_init (PyObject *self, PyObject *args, PyObject *kw)
 
 /* Initialize the 'commands' code.  */
 
-void
+int
 gdbpy_initialize_commands (void)
 {
   int i;
 
   cmdpy_object_type.tp_new = PyType_GenericNew;
   if (PyType_Ready (&cmdpy_object_type) < 0)
-    return;
+    return -1;
 
   /* Note: alias and user are special; pseudo appears to be unused,
      and there is no reason to expose tui or xdb, I think.  */
@@ -592,20 +592,27 @@ gdbpy_initialize_commands (void)
       || PyModule_AddIntConstant (gdb_module, "COMMAND_MAINTENANCE",
                                  class_maintenance) < 0
       || PyModule_AddIntConstant (gdb_module, "COMMAND_USER", class_user) < 0)
-    return;
+    return -1;
 
   for (i = 0; i < N_COMPLETERS; ++i)
     {
       if (PyModule_AddIntConstant (gdb_module, completers[i].name, i) < 0)
-       return;
+       return -1;
     }
 
   Py_INCREF (&cmdpy_object_type);
-  PyModule_AddObject (gdb_module, "Command",
-                     (PyObject *) &cmdpy_object_type);
+  if (PyModule_AddObject (gdb_module, "Command",
+                         (PyObject *) &cmdpy_object_type) < 0)
+    return -1;
 
   invoke_cst = PyString_FromString ("invoke");
+  if (invoke_cst == NULL)
+    return -1;
   complete_cst = PyString_FromString ("complete");
+  if (complete_cst == NULL)
+    return -1;
+
+  return 0;
 }
 
 \f
index 72d57cb8254840ca23cb1de88a44c1a134fc0135..04f33aba45d1ecf2cc92975916b0bd1b50c6d6a0 100644 (file)
@@ -60,11 +60,11 @@ evpy_add_attribute (PyObject *event, char *name, PyObject *attr)
 
 /* Initialize the Python event code.  */
 
-void
+int
 gdbpy_initialize_event (void)
 {
-  gdbpy_initialize_event_generic (&event_object_type,
-                                  "Event");
+  return gdbpy_initialize_event_generic (&event_object_type,
+                                        "Event");
 }
 
 /* Initialize the given event type.  If BASE is not NULL it will
index 4850f1a3e4548160c8c1ea481fe0bc4822e51379..f0ff629875dd22300538ff8b1fca3dac47092ec8 100644 (file)
       0                                           /* tp_alloc */ \
     }; \
 \
-void \
+int \
 gdbpy_initialize_##name##_event (void) \
 { \
-  gdbpy_initialize_event_generic (&name##_event_object_type, \
-                                  py_name); \
+  return gdbpy_initialize_event_generic (&name##_event_object_type, \
+                                        py_name);                  \
 }
 
 typedef struct
index 05c85864e7157128c0e8b9faeb88c7ed40a4b000..d7cbe6427a6b0087a7cacb842c573d2118dcafa0 100644 (file)
@@ -106,15 +106,15 @@ evregpy_dealloc (PyObject *self)
 
 /* Initialize the Python event registry code.  */
 
-void
+int
 gdbpy_initialize_eventregistry (void)
 {
   if (PyType_Ready (&eventregistry_object_type) < 0)
-    return;
+    return -1;
 
   Py_INCREF (&eventregistry_object_type);
-  PyModule_AddObject (gdb_module, "EventRegistry",
-                      (PyObject *) &eventregistry_object_type);
+  return PyModule_AddObject (gdb_module, "EventRegistry",
+                            (PyObject *) &eventregistry_object_type);
 }
 
 /* Retern the number of listeners currently connected to this
index 427b6d5b52e14e3f1f4ccf75fd2ae7ab0f9712f3..bb384e378b66e245d860c6c1832dc330b43b7ca8 100644 (file)
@@ -57,7 +57,7 @@ add_new_registry (eventregistry_object **registryp, char *name)
    return -1;
 }
 
-void
+int
 gdbpy_initialize_py_events (void)
 {
 #ifdef IS_PY3K
@@ -67,19 +67,19 @@ gdbpy_initialize_py_events (void)
 #endif
 
   if (!gdb_py_events.module)
-    goto fail;
+    return -1;
 
   if (add_new_registry (&gdb_py_events.stop, "stop") < 0)
-    goto fail;
+    return -1;
 
   if (add_new_registry (&gdb_py_events.cont, "cont") < 0)
-    goto fail;
+    return -1;
 
   if (add_new_registry (&gdb_py_events.exited, "exited") < 0)
-    goto fail;
+    return -1;
 
   if (add_new_registry (&gdb_py_events.new_objfile, "new_objfile") < 0)
-    goto fail;
+    return -1;
 
 #ifndef IS_PY3K
   Py_INCREF (gdb_py_events.module);
@@ -87,10 +87,7 @@ gdbpy_initialize_py_events (void)
   if (PyModule_AddObject (gdb_module,
                           "events",
                           (PyObject *) gdb_py_events.module) < 0)
-    goto fail;
-
-  return;
+    return -1;
 
-  fail:
-   gdbpy_print_stack ();
+  return 0;
 }
index f65e02658402cfef9c2abb89e951adae68def08c..5fd1f4bc80ccb342b2970699cc29b3f67ce1fa69 100644 (file)
@@ -407,18 +407,21 @@ bpfinishpy_handle_exit (struct inferior *inf)
 
 /* Initialize the Python finish breakpoint code.  */
 
-void
+int
 gdbpy_initialize_finishbreakpoints (void)
 {
   if (PyType_Ready (&finish_breakpoint_object_type) < 0)
-      return;
+    return -1;
   
   Py_INCREF (&finish_breakpoint_object_type);
-  PyModule_AddObject (gdb_module, "FinishBreakpoint",
-                      (PyObject *) &finish_breakpoint_object_type);
+  if (PyModule_AddObject (gdb_module, "FinishBreakpoint",
+                         (PyObject *) &finish_breakpoint_object_type) < 0)
+    return -1;
     
   observer_attach_normal_stop (bpfinishpy_handle_stop);
   observer_attach_inferior_exit (bpfinishpy_handle_exit);
+
+  return 0;
 }
 
 static PyGetSetDef finish_breakpoint_object_getset[] = {
index 9342f45d5b0a07bbcc2639d038f6470e14d30482..5d3a8c271b854f414c7593f283f5e3853ed3835e 100644 (file)
@@ -606,33 +606,41 @@ frapy_richcompare (PyObject *self, PyObject *other, int op)
 
 /* Sets up the Frame API in the gdb module.  */
 
-void
+int
 gdbpy_initialize_frames (void)
 {
   frame_object_type.tp_new = PyType_GenericNew;
   if (PyType_Ready (&frame_object_type) < 0)
-    return;
+    return -1;
 
   /* Note: These would probably be best exposed as class attributes of
      Frame, but I don't know how to do it except by messing with the
      type's dictionary.  That seems too messy.  */
-  PyModule_AddIntConstant (gdb_module, "NORMAL_FRAME", NORMAL_FRAME);
-  PyModule_AddIntConstant (gdb_module, "DUMMY_FRAME", DUMMY_FRAME);
-  PyModule_AddIntConstant (gdb_module, "INLINE_FRAME", INLINE_FRAME);
-  PyModule_AddIntConstant (gdb_module, "TAILCALL_FRAME", TAILCALL_FRAME);
-  PyModule_AddIntConstant (gdb_module, "SIGTRAMP_FRAME", SIGTRAMP_FRAME);
-  PyModule_AddIntConstant (gdb_module, "ARCH_FRAME", ARCH_FRAME);
-  PyModule_AddIntConstant (gdb_module, "SENTINEL_FRAME", SENTINEL_FRAME);
+  if (PyModule_AddIntConstant (gdb_module, "NORMAL_FRAME", NORMAL_FRAME) < 0
+      || PyModule_AddIntConstant (gdb_module, "DUMMY_FRAME", DUMMY_FRAME) < 0
+      || PyModule_AddIntConstant (gdb_module, "INLINE_FRAME", INLINE_FRAME) < 0
+      || PyModule_AddIntConstant (gdb_module, "TAILCALL_FRAME",
+                                 TAILCALL_FRAME) < 0
+      || PyModule_AddIntConstant (gdb_module, "SIGTRAMP_FRAME",
+                                 SIGTRAMP_FRAME) < 0
+      || PyModule_AddIntConstant (gdb_module, "ARCH_FRAME", ARCH_FRAME) < 0
+      || PyModule_AddIntConstant (gdb_module, "SENTINEL_FRAME",
+                                 SENTINEL_FRAME) < 0)
+    return -1;
 
 #define SET(name, description) \
-  PyModule_AddIntConstant (gdb_module, "FRAME_"#name, name);
+  if (PyModule_AddIntConstant (gdb_module, "FRAME_"#name, name) < 0) \
+    return -1;
 #define FIRST_ERROR(name) \
-  PyModule_AddIntConstant (gdb_module, "FRAME_"#name, name);
+  if (PyModule_AddIntConstant (gdb_module, "FRAME_"#name, name) < 0) \
+    return -1;
 #include "unwind_stop_reasons.def"
 #undef SET
+#undef FIRST_ERROR
 
   Py_INCREF (&frame_object_type);
-  PyModule_AddObject (gdb_module, "Frame", (PyObject *) &frame_object_type);
+  return PyModule_AddObject (gdb_module, "Frame",
+                            (PyObject *) &frame_object_type);
 }
 
 \f
index 395eeda9ad3239c32de1a3b036487e4bfb6f7ee1..57cdfaefdd9b5f1720b91ed0385604b3054ccd88 100644 (file)
@@ -200,15 +200,16 @@ fnpy_init (PyObject *self, PyObject *args, PyObject *kwds)
 
 /* Initialize internal function support.  */
 
-void
+int
 gdbpy_initialize_functions (void)
 {
   fnpy_object_type.tp_new = PyType_GenericNew;
   if (PyType_Ready (&fnpy_object_type) < 0)
-    return;
+    return -1;
 
   Py_INCREF (&fnpy_object_type);
-  PyModule_AddObject (gdb_module, "Function", (PyObject *) &fnpy_object_type);
+  return PyModule_AddObject (gdb_module, "Function",
+                            (PyObject *) &fnpy_object_type);
 }
 
 \f
index ca7e4a6086945736ee8a53c29be1d4b9c4ee172c..d6576a32cccd99923ac47b4d335d2cfa43dcffa8 100644 (file)
@@ -93,7 +93,7 @@ gdbpy_initialize_gdb_readline (void)
      and prevent conflicts.  For now, this file implements a
      sys.meta_path finder that simply fails to import the readline
      module.  */
-  PyRun_SimpleString ("\
+  if (PyRun_SimpleString ("\
 import sys\n\
 \n\
 class GdbRemoveReadlineFinder:\n\
@@ -106,8 +106,7 @@ class GdbRemoveReadlineFinder:\n\
     raise ImportError('readline module disabled under GDB')\n\
 \n\
 sys.meta_path.append(GdbRemoveReadlineFinder())\n\
-");
-
-  PyOS_ReadlineFunctionPointer = gdbpy_readline_wrapper;
+") == 0)
+    PyOS_ReadlineFunctionPointer = gdbpy_readline_wrapper;
 }
 
index 4e68cdd230ba7c02365cab5d375326c478079e5e..18ddecde47b125bf21ab399ef9a305f443a337e4 100644 (file)
@@ -760,15 +760,16 @@ gdbpy_selected_inferior (PyObject *self, PyObject *args)
   return inf_obj;
 }
 
-void
+int
 gdbpy_initialize_inferior (void)
 {
   if (PyType_Ready (&inferior_object_type) < 0)
-    return;
+    return -1;
 
   Py_INCREF (&inferior_object_type);
-  PyModule_AddObject (gdb_module, "Inferior",
-                     (PyObject *) &inferior_object_type);
+  if (PyModule_AddObject (gdb_module, "Inferior",
+                         (PyObject *) &inferior_object_type) < 0)
+    return -1;
 
   infpy_inf_data_key =
     register_inferior_data_with_cleanup (NULL, py_free_inferior);
@@ -782,11 +783,11 @@ gdbpy_initialize_inferior (void)
 
   membuf_object_type.tp_new = PyType_GenericNew;
   if (PyType_Ready (&membuf_object_type) < 0)
-    return;
+    return -1;
 
   Py_INCREF (&membuf_object_type);
-  PyModule_AddObject (gdb_module, "Membuf", (PyObject *)
-                     &membuf_object_type);
+  return PyModule_AddObject (gdb_module, "Membuf", (PyObject *)
+                            &membuf_object_type);
 }
 
 static PyGetSetDef inferior_object_getset[] =
index a0545eca74b4bc7049219bb5ab3e4609a84b6b53..7a5f2627c1e657098ed333410aaef9858f9433bb 100644 (file)
@@ -255,15 +255,15 @@ gdbpy_selected_thread (PyObject *self, PyObject *args)
 
 
 
-void
+int
 gdbpy_initialize_thread (void)
 {
   if (PyType_Ready (&thread_object_type) < 0)
-    return;
+    return -1;
 
   Py_INCREF (&thread_object_type);
-  PyModule_AddObject (gdb_module, "InferiorThread",
-                     (PyObject *) &thread_object_type);
+  return PyModule_AddObject (gdb_module, "InferiorThread",
+                            (PyObject *) &thread_object_type);
 }
 
 
index df54cf4a16bcb5b816c66fd41ed7392883958a99..ea193a97f6e67433ecc02f559b03341d06ca061f 100644 (file)
@@ -160,13 +160,14 @@ gdbpy_create_lazy_string_object (CORE_ADDR address, long length,
   return (PyObject *) str_obj;
 }
 
-void
+int
 gdbpy_initialize_lazy_string (void)
 {
   if (PyType_Ready (&lazy_string_object_type) < 0)
-    return;
+    return -1;
 
   Py_INCREF (&lazy_string_object_type);
+  return 0;
 }
 
 /* Determine whether the printer object pointed to by OBJ is a
index 27f346304944c3bbae62a46ea4f3c760ef3dd53d..d8c893ced8ecbcf2290da218a724e0bf7712c68b 100644 (file)
@@ -298,18 +298,18 @@ objfile_to_objfile_object (struct objfile *objfile)
   return (PyObject *) object;
 }
 
-void
+int
 gdbpy_initialize_objfile (void)
 {
   objfpy_objfile_data_key
     = register_objfile_data_with_cleanup (NULL, py_free_objfile);
 
   if (PyType_Ready (&objfile_object_type) < 0)
-    return;
+    return -1;
 
   Py_INCREF (&objfile_object_type);
-  PyModule_AddObject (gdb_module, "Objfile",
-                     (PyObject *) &objfile_object_type);
+  return PyModule_AddObject (gdb_module, "Objfile",
+                            (PyObject *) &objfile_object_type);
 }
 
 \f
index 176bbc2b5de448d9a070f7a70901281e255c7b71..2cc17b6a71d8c213750fdb7287f48363691c6bb5 100644 (file)
@@ -749,33 +749,33 @@ parmpy_init (PyObject *self, PyObject *args, PyObject *kwds)
 \f
 
 /* Initialize the 'parameters' module.  */
-void
+int
 gdbpy_initialize_parameters (void)
 {
   int i;
 
   parmpy_object_type.tp_new = PyType_GenericNew;
   if (PyType_Ready (&parmpy_object_type) < 0)
-    return;
+    return -1;
 
   set_doc_cst = PyString_FromString ("set_doc");
   if (! set_doc_cst)
-    return;
+    return -1;
   show_doc_cst = PyString_FromString ("show_doc");
   if (! show_doc_cst)
-    return;
+    return -1;
 
   for (i = 0; parm_constants[i].name; ++i)
     {
       if (PyModule_AddIntConstant (gdb_module,
                                   parm_constants[i].name,
                                   parm_constants[i].value) < 0)
-       return;
+       return -1;
     }
 
   Py_INCREF (&parmpy_object_type);
-  PyModule_AddObject (gdb_module, "Parameter",
-                     (PyObject *) &parmpy_object_type);
+  return PyModule_AddObject (gdb_module, "Parameter",
+                            (PyObject *) &parmpy_object_type);
 }
 
 \f
index 5d4911a778428124d33e43ed593743eefedb2d77..9913313c838367311e8280e5ef58e54ceca541c6 100644 (file)
@@ -294,18 +294,18 @@ pspace_to_pspace_object (struct program_space *pspace)
   return (PyObject *) object;
 }
 
-void
+int
 gdbpy_initialize_pspace (void)
 {
   pspy_pspace_data_key
     = register_program_space_data_with_cleanup (NULL, py_free_pspace);
 
   if (PyType_Ready (&pspace_object_type) < 0)
-    return;
+    return -1;
 
   Py_INCREF (&pspace_object_type);
-  PyModule_AddObject (gdb_module, "Progspace",
-                     (PyObject *) &pspace_object_type);
+  return PyModule_AddObject (gdb_module, "Progspace",
+                            (PyObject *) &pspace_object_type);
 }
 
 \f
index def0fdd984b7f3ca700735757f6ee7e9504bb560..7629f70b5200190a3c4cbd046d5f6d67979bb0de 100644 (file)
@@ -474,11 +474,11 @@ del_objfile_symbols (struct objfile *objfile, void *datum)
     }
 }
 
-void
+int
 gdbpy_initialize_symbols (void)
 {
   if (PyType_Ready (&symbol_object_type) < 0)
-    return;
+    return -1;
 
   /* Register an objfile "free" callback so we can properly
      invalidate symbol when an object file that is about to be
@@ -486,37 +486,54 @@ gdbpy_initialize_symbols (void)
   sympy_objfile_data_key
     = register_objfile_data_with_cleanup (NULL, del_objfile_symbols);
 
-  PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_UNDEF", LOC_UNDEF);
-  PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_CONST", LOC_CONST);
-  PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_STATIC", LOC_STATIC);
-  PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_REGISTER", LOC_REGISTER);
-  PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_ARG", LOC_ARG);
-  PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_REF_ARG", LOC_REF_ARG);
-  PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_LOCAL", LOC_LOCAL);
-  PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_TYPEDEF", LOC_TYPEDEF);
-  PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_LABEL", LOC_LABEL);
-  PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_BLOCK", LOC_BLOCK);
-  PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_CONST_BYTES",
-                          LOC_CONST_BYTES);
-  PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_UNRESOLVED",
-                          LOC_UNRESOLVED);
-  PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_OPTIMIZED_OUT",
-                          LOC_OPTIMIZED_OUT);
-  PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_COMPUTED", LOC_COMPUTED);
-  PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_REGPARM_ADDR",
-                          LOC_REGPARM_ADDR);
-  PyModule_AddIntConstant (gdb_module, "SYMBOL_UNDEF_DOMAIN", UNDEF_DOMAIN);
-  PyModule_AddIntConstant (gdb_module, "SYMBOL_VAR_DOMAIN", VAR_DOMAIN);
-  PyModule_AddIntConstant (gdb_module, "SYMBOL_STRUCT_DOMAIN", STRUCT_DOMAIN);
-  PyModule_AddIntConstant (gdb_module, "SYMBOL_LABEL_DOMAIN", LABEL_DOMAIN);
-  PyModule_AddIntConstant (gdb_module, "SYMBOL_VARIABLES_DOMAIN",
-                          VARIABLES_DOMAIN);
-  PyModule_AddIntConstant (gdb_module, "SYMBOL_FUNCTIONS_DOMAIN",
-                          FUNCTIONS_DOMAIN);
-  PyModule_AddIntConstant (gdb_module, "SYMBOL_TYPES_DOMAIN", TYPES_DOMAIN);
+  if (PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_UNDEF", LOC_UNDEF) < 0
+      || PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_CONST",
+                                 LOC_CONST) < 0
+      || PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_STATIC",
+                                 LOC_STATIC) < 0
+      || PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_REGISTER",
+                                 LOC_REGISTER) < 0
+      || PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_ARG",
+                                 LOC_ARG) < 0
+      || PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_REF_ARG",
+                                 LOC_REF_ARG) < 0
+      || PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_LOCAL",
+                                 LOC_LOCAL) < 0
+      || PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_TYPEDEF",
+                                 LOC_TYPEDEF) < 0
+      || PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_LABEL",
+                                 LOC_LABEL) < 0
+      || PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_BLOCK",
+                                 LOC_BLOCK) < 0
+      || PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_CONST_BYTES",
+                                 LOC_CONST_BYTES) < 0
+      || PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_UNRESOLVED",
+                                 LOC_UNRESOLVED) < 0
+      || PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_OPTIMIZED_OUT",
+                                 LOC_OPTIMIZED_OUT) < 0
+      || PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_COMPUTED",
+                                 LOC_COMPUTED) < 0
+      || PyModule_AddIntConstant (gdb_module, "SYMBOL_LOC_REGPARM_ADDR",
+                                 LOC_REGPARM_ADDR) < 0
+      || PyModule_AddIntConstant (gdb_module, "SYMBOL_UNDEF_DOMAIN",
+                                 UNDEF_DOMAIN) < 0
+      || PyModule_AddIntConstant (gdb_module, "SYMBOL_VAR_DOMAIN",
+                                 VAR_DOMAIN) < 0
+      || PyModule_AddIntConstant (gdb_module, "SYMBOL_STRUCT_DOMAIN",
+                                 STRUCT_DOMAIN) < 0
+      || PyModule_AddIntConstant (gdb_module, "SYMBOL_LABEL_DOMAIN",
+                                 LABEL_DOMAIN) < 0
+      || PyModule_AddIntConstant (gdb_module, "SYMBOL_VARIABLES_DOMAIN",
+                                 VARIABLES_DOMAIN) < 0
+      || PyModule_AddIntConstant (gdb_module, "SYMBOL_FUNCTIONS_DOMAIN",
+                                 FUNCTIONS_DOMAIN) < 0
+      || PyModule_AddIntConstant (gdb_module, "SYMBOL_TYPES_DOMAIN",
+                                 TYPES_DOMAIN) < 0)
+    return -1;
 
   Py_INCREF (&symbol_object_type);
-  PyModule_AddObject (gdb_module, "Symbol", (PyObject *) &symbol_object_type);
+  return PyModule_AddObject (gdb_module, "Symbol",
+                            (PyObject *) &symbol_object_type);
 }
 
 \f
index 94c05be90a2a6170e6ce1f0867fd3de1273d871d..80a2282e1d4b70c241d282885044515317170559 100644 (file)
@@ -484,16 +484,16 @@ del_objfile_sal (struct objfile *objfile, void *datum)
     }
 }
 
-void
+int
 gdbpy_initialize_symtabs (void)
 {
   symtab_object_type.tp_new = PyType_GenericNew;
   if (PyType_Ready (&symtab_object_type) < 0)
-    return;
+    return -1;
 
   sal_object_type.tp_new = PyType_GenericNew;
   if (PyType_Ready (&sal_object_type) < 0)
-    return;
+    return -1;
 
   /* Register an objfile "free" callback so we can properly
      invalidate symbol tables, and symbol table and line data
@@ -505,12 +505,13 @@ gdbpy_initialize_symtabs (void)
     = register_objfile_data_with_cleanup (NULL, del_objfile_sal);
 
   Py_INCREF (&symtab_object_type);
-  PyModule_AddObject (gdb_module, "Symtab",
-                     (PyObject *) &symtab_object_type);
+  if (PyModule_AddObject (gdb_module, "Symtab",
+                         (PyObject *) &symtab_object_type) < 0)
+    return -1;
 
   Py_INCREF (&sal_object_type);
-  PyModule_AddObject (gdb_module, "Symtab_and_line",
-                     (PyObject *) &sal_object_type);
+  return PyModule_AddObject (gdb_module, "Symtab_and_line",
+                            (PyObject *) &sal_object_type);
 }
 
 \f
index e29ae813e647c263bb0431aca3d003bed6515a26..05e251b023cdaa5651b141c85d8f60d9240c658a 100644 (file)
@@ -1521,7 +1521,7 @@ gdbpy_lookup_type (PyObject *self, PyObject *args, PyObject *kw)
   return (PyObject *) type_to_type_object (type);
 }
 
-void
+int
 gdbpy_initialize_types (void)
 {
   int i;
@@ -1530,11 +1530,11 @@ gdbpy_initialize_types (void)
     = register_objfile_data_with_cleanup (save_objfile_types, NULL);
 
   if (PyType_Ready (&type_object_type) < 0)
-    return;
+    return -1;
   if (PyType_Ready (&field_object_type) < 0)
-    return;
+    return -1;
   if (PyType_Ready (&type_iterator_object_type) < 0)
-    return;
+    return -1;
 
   for (i = 0; pyty_codes[i].name; ++i)
     {
@@ -1542,18 +1542,22 @@ gdbpy_initialize_types (void)
                                   /* Cast needed for Python 2.4.  */
                                   (char *) pyty_codes[i].name,
                                   pyty_codes[i].code) < 0)
-       return;
+       return -1;
     }
 
   Py_INCREF (&type_object_type);
-  PyModule_AddObject (gdb_module, "Type", (PyObject *) &type_object_type);
+  if (PyModule_AddObject (gdb_module, "Type",
+                         (PyObject *) &type_object_type) < 0)
+    return -1;
 
   Py_INCREF (&type_iterator_object_type);
-  PyModule_AddObject (gdb_module, "TypeIterator",
-                     (PyObject *) &type_iterator_object_type);
+  if (PyModule_AddObject (gdb_module, "TypeIterator",
+                         (PyObject *) &type_iterator_object_type) < 0)
+    return -1;
 
   Py_INCREF (&field_object_type);
-  PyModule_AddObject (gdb_module, "Field", (PyObject *) &field_object_type);
+  return PyModule_AddObject (gdb_module, "Field",
+                            (PyObject *) &field_object_type);
 }
 
 \f
index 2cbb0cb551e7498ce5fbbfe63fbbd575fc1427a8..762993bd7145ae394917069649123684f89e4c1f 100644 (file)
@@ -1386,16 +1386,15 @@ gdbpy_is_value_object (PyObject *obj)
   return PyObject_TypeCheck (obj, &value_object_type);
 }
 
-void
+int
 gdbpy_initialize_values (void)
 {
   if (PyType_Ready (&value_object_type) < 0)
-    return;
+    return -1;
 
   Py_INCREF (&value_object_type);
-  PyModule_AddObject (gdb_module, "Value", (PyObject *) &value_object_type);
-
-  values_in_python = NULL;
+  return PyModule_AddObject (gdb_module, "Value",
+                            (PyObject *) &value_object_type);
 }
 
 \f
index 29c22f7dd39aa5d03b2d874db3ee286ab0ff3146..695bcd3627b038e3fd141b5c16165b21ccb4677b 100644 (file)
@@ -324,35 +324,64 @@ struct frame_info *frame_object_to_frame_info (PyObject *frame_obj);
 struct gdbarch *arch_object_to_gdbarch (PyObject *obj);
 
 void gdbpy_initialize_gdb_readline (void);
-void gdbpy_initialize_auto_load (void);
-void gdbpy_initialize_values (void);
-void gdbpy_initialize_frames (void);
-void gdbpy_initialize_symtabs (void);
-void gdbpy_initialize_commands (void);
-void gdbpy_initialize_symbols (void);
-void gdbpy_initialize_symtabs (void);
-void gdbpy_initialize_blocks (void);
-void gdbpy_initialize_types (void);
-void gdbpy_initialize_functions (void);
-void gdbpy_initialize_pspace (void);
-void gdbpy_initialize_objfile (void);
-void gdbpy_initialize_breakpoints (void);
-void gdbpy_initialize_finishbreakpoints (void);
-void gdbpy_initialize_lazy_string (void);
-void gdbpy_initialize_parameters (void);
-void gdbpy_initialize_thread (void);
-void gdbpy_initialize_inferior (void);
-void gdbpy_initialize_eventregistry (void);
-void gdbpy_initialize_event (void);
-void gdbpy_initialize_py_events (void);
-void gdbpy_initialize_stop_event (void);
-void gdbpy_initialize_signal_event (void);
-void gdbpy_initialize_breakpoint_event (void);
-void gdbpy_initialize_continue_event (void);
-void gdbpy_initialize_exited_event (void);
-void gdbpy_initialize_thread_event (void);
-void gdbpy_initialize_new_objfile_event (void);
-void gdbpy_initialize_arch (void);
+int gdbpy_initialize_auto_load (void)
+  CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
+int gdbpy_initialize_values (void)
+  CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
+int gdbpy_initialize_frames (void)
+  CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
+int gdbpy_initialize_symtabs (void)
+  CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
+int gdbpy_initialize_commands (void)
+  CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
+int gdbpy_initialize_symbols (void)
+  CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
+int gdbpy_initialize_symtabs (void)
+  CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
+int gdbpy_initialize_blocks (void)
+  CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
+int gdbpy_initialize_types (void)
+  CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
+int gdbpy_initialize_functions (void)
+  CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
+int gdbpy_initialize_pspace (void)
+  CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
+int gdbpy_initialize_objfile (void)
+  CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
+int gdbpy_initialize_breakpoints (void)
+  CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
+int gdbpy_initialize_finishbreakpoints (void)
+  CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
+int gdbpy_initialize_lazy_string (void)
+  CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
+int gdbpy_initialize_parameters (void)
+  CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
+int gdbpy_initialize_thread (void)
+  CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
+int gdbpy_initialize_inferior (void)
+  CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
+int gdbpy_initialize_eventregistry (void)
+  CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
+int gdbpy_initialize_event (void)
+  CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
+int gdbpy_initialize_py_events (void)
+  CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
+int gdbpy_initialize_stop_event (void)
+  CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
+int gdbpy_initialize_signal_event (void)
+  CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
+int gdbpy_initialize_breakpoint_event (void)
+  CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
+int gdbpy_initialize_continue_event (void)
+  CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
+int gdbpy_initialize_exited_event (void)
+  CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
+int gdbpy_initialize_thread_event (void)
+  CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
+int gdbpy_initialize_new_objfile_event (void)
+  CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
+int gdbpy_initialize_arch (void)
+  CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 
 struct cleanup *make_cleanup_py_decref (PyObject *py);
 struct cleanup *make_cleanup_py_xdecref (PyObject *py);
index 90581e5fec925339cad6335f3442455d037e0924..5b5afcfd8ef5c8b06cc2552f4bc93ad58cd75492 100644 (file)
@@ -73,6 +73,11 @@ static const char *gdbpy_should_print_stack = python_excp_message;
 #include "interps.h"
 #include "event-top.h"
 
+/* True if Python has been successfully initialized, false
+   otherwise.  */
+
+int gdb_python_initialized;
+
 static PyMethodDef GdbMethods[];
 
 #ifdef IS_PY3K
@@ -871,7 +876,7 @@ gdbpy_post_event (PyObject *self, PyObject *args)
 }
 
 /* Initialize the Python event handler.  */
-static void
+static int
 gdbpy_initialize_events (void)
 {
   if (serial_pipe (gdbpy_event_fds) == 0)
@@ -879,6 +884,8 @@ gdbpy_initialize_events (void)
       gdbpy_event_list_end = &gdbpy_event_list;
       serial_async (gdbpy_event_fds[0], gdbpy_run_events, NULL);
     }
+
+  return 0;
 }
 
 \f
@@ -1589,74 +1596,108 @@ message == an error message without a stack will be printed."),
 #else
   gdb_module = Py_InitModule ("_gdb", GdbMethods);
 #endif
+  if (gdb_module == NULL)
+    goto fail;
 
   /* The casts to (char*) are for python 2.4.  */
-  PyModule_AddStringConstant (gdb_module, "VERSION", (char*) version);
-  PyModule_AddStringConstant (gdb_module, "HOST_CONFIG", (char*) host_name);
-  PyModule_AddStringConstant (gdb_module, "TARGET_CONFIG",
-                             (char*) target_name);
+  if (PyModule_AddStringConstant (gdb_module, "VERSION", (char*) version) < 0
+      || PyModule_AddStringConstant (gdb_module, "HOST_CONFIG",
+                                    (char*) host_name) < 0
+      || PyModule_AddStringConstant (gdb_module, "TARGET_CONFIG",
+                                    (char*) target_name) < 0)
+    goto fail;
 
   /* Add stream constants.  */
-  PyModule_AddIntConstant (gdb_module, "STDOUT", 0);
-  PyModule_AddIntConstant (gdb_module, "STDERR", 1);
-  PyModule_AddIntConstant (gdb_module, "STDLOG", 2);
+  if (PyModule_AddIntConstant (gdb_module, "STDOUT", 0) < 0
+      || PyModule_AddIntConstant (gdb_module, "STDERR", 1) < 0
+      || PyModule_AddIntConstant (gdb_module, "STDLOG", 2) < 0)
+    goto fail;
 
   gdbpy_gdb_error = PyErr_NewException ("gdb.error", PyExc_RuntimeError, NULL);
-  PyModule_AddObject (gdb_module, "error", gdbpy_gdb_error);
+  if (gdbpy_gdb_error == NULL
+      || PyModule_AddObject (gdb_module, "error", gdbpy_gdb_error) < 0)
+    goto fail;
 
   gdbpy_gdb_memory_error = PyErr_NewException ("gdb.MemoryError",
                                               gdbpy_gdb_error, NULL);
-  PyModule_AddObject (gdb_module, "MemoryError", gdbpy_gdb_memory_error);
+  if (gdbpy_gdb_memory_error == NULL
+      || PyModule_AddObject (gdb_module, "MemoryError",
+                            gdbpy_gdb_memory_error) < 0)
+    goto fail;
 
   gdbpy_gdberror_exc = PyErr_NewException ("gdb.GdbError", NULL, NULL);
-  PyModule_AddObject (gdb_module, "GdbError", gdbpy_gdberror_exc);
+  if (gdbpy_gdberror_exc == NULL
+      || PyModule_AddObject (gdb_module, "GdbError", gdbpy_gdberror_exc) < 0)
+    goto fail;
 
   gdbpy_initialize_gdb_readline ();
-  gdbpy_initialize_auto_load ();
-  gdbpy_initialize_values ();
-  gdbpy_initialize_frames ();
-  gdbpy_initialize_commands ();
-  gdbpy_initialize_symbols ();
-  gdbpy_initialize_symtabs ();
-  gdbpy_initialize_blocks ();
-  gdbpy_initialize_functions ();
-  gdbpy_initialize_parameters ();
-  gdbpy_initialize_types ();
-  gdbpy_initialize_pspace ();
-  gdbpy_initialize_objfile ();
-  gdbpy_initialize_breakpoints ();
-  gdbpy_initialize_finishbreakpoints ();
-  gdbpy_initialize_lazy_string ();
-  gdbpy_initialize_thread ();
-  gdbpy_initialize_inferior ();
-  gdbpy_initialize_events ();
-
-  gdbpy_initialize_eventregistry ();
-  gdbpy_initialize_py_events ();
-  gdbpy_initialize_event ();
-  gdbpy_initialize_stop_event ();
-  gdbpy_initialize_signal_event ();
-  gdbpy_initialize_breakpoint_event ();
-  gdbpy_initialize_continue_event ();
-  gdbpy_initialize_exited_event ();
-  gdbpy_initialize_thread_event ();
-  gdbpy_initialize_new_objfile_event () ;
-  gdbpy_initialize_arch ();
+
+  if (gdbpy_initialize_auto_load () < 0
+      || gdbpy_initialize_values () < 0
+      || gdbpy_initialize_frames () < 0
+      || gdbpy_initialize_commands () < 0
+      || gdbpy_initialize_symbols () < 0
+      || gdbpy_initialize_symtabs () < 0
+      || gdbpy_initialize_blocks () < 0
+      || gdbpy_initialize_functions () < 0
+      || gdbpy_initialize_parameters () < 0
+      || gdbpy_initialize_types () < 0
+      || gdbpy_initialize_pspace () < 0
+      || gdbpy_initialize_objfile () < 0
+      || gdbpy_initialize_breakpoints () < 0
+      || gdbpy_initialize_finishbreakpoints () < 0
+      || gdbpy_initialize_lazy_string () < 0
+      || gdbpy_initialize_thread () < 0
+      || gdbpy_initialize_inferior () < 0
+      || gdbpy_initialize_events () < 0
+      || gdbpy_initialize_eventregistry () < 0
+      || gdbpy_initialize_py_events () < 0
+      || gdbpy_initialize_event () < 0
+      || gdbpy_initialize_stop_event () < 0
+      || gdbpy_initialize_signal_event () < 0
+      || gdbpy_initialize_breakpoint_event () < 0
+      || gdbpy_initialize_continue_event () < 0
+      || gdbpy_initialize_exited_event () < 0
+      || gdbpy_initialize_thread_event () < 0
+      || gdbpy_initialize_new_objfile_event ()  < 0
+      || gdbpy_initialize_arch () < 0)
+    goto fail;
 
   observer_attach_before_prompt (before_prompt_hook);
 
   gdbpy_to_string_cst = PyString_FromString ("to_string");
+  if (gdbpy_to_string_cst == NULL)
+    goto fail;
   gdbpy_children_cst = PyString_FromString ("children");
+  if (gdbpy_children_cst == NULL)
+    goto fail;
   gdbpy_display_hint_cst = PyString_FromString ("display_hint");
+  if (gdbpy_display_hint_cst == NULL)
+    goto fail;
   gdbpy_doc_cst = PyString_FromString ("__doc__");
+  if (gdbpy_doc_cst == NULL)
+    goto fail;
   gdbpy_enabled_cst = PyString_FromString ("enabled");
+  if (gdbpy_enabled_cst == NULL)
+    goto fail;
   gdbpy_value_cst = PyString_FromString ("value");
+  if (gdbpy_value_cst == NULL)
+    goto fail;
 
   /* Release the GIL while gdb runs.  */
   PyThreadState_Swap (NULL);
   PyEval_ReleaseLock ();
 
   make_final_cleanup (finalize_python, NULL);
+
+  gdb_python_initialized = 1;
+  return;
+
+ fail:
+  gdbpy_print_stack ();
+  /* Do not set 'gdb_python_initialized'.  */
+  return;
+
 #endif /* HAVE_PYTHON */
 }