Merge GDB 7.5.1

gdb/python/py-symbol.c

 /* Python interface to symbols.
 
    Copyright (C) 2008-2012 Free Software Foundation, Inc.
 
    This file is part of GDB.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
@@ skipping 165 matching lines @@
   SYMPY_REQUIRE_VALID (self, symbol);
 
   class = SYMBOL_CLASS (symbol);
 
   return PyBool_FromLong (!SYMBOL_IS_ARGUMENT (symbol)
                           && (class == LOC_LOCAL || class == LOC_REGISTER
                               || class == LOC_STATIC || class == LOC_COMPUTED
                               || class == LOC_OPTIMIZED_OUT));
 }
 
+/* Implementation of gdb.Symbol.needs_frame -> Boolean.
+   Returns true iff the symbol needs a frame for evaluation.  */
+
+static PyObject *
+sympy_needs_frame (PyObject *self, void *closure)
+{
+  struct symbol *symbol = NULL;
+  volatile struct gdb_exception except;
+  int result = 0;
+
+  SYMPY_REQUIRE_VALID (self, symbol);
+
+  TRY_CATCH (except, RETURN_MASK_ALL)
+    {
+      result = symbol_read_needs_frame (symbol);
+    }
+  GDB_PY_HANDLE_EXCEPTION (except);
+
+  if (result)
+    Py_RETURN_TRUE;
+  Py_RETURN_FALSE;
+}
+
+/* Implementation of gdb.Symbol.line -> int.
+   Returns the line number at which the symbol was defined.  */
+
+static PyObject *
+sympy_line (PyObject *self, void *closure)
+{
+  struct symbol *symbol = NULL;
+
+  SYMPY_REQUIRE_VALID (self, symbol);
+
+  return PyInt_FromLong (SYMBOL_LINE (symbol));
+}
+
 /* Implementation of gdb.Symbol.is_valid (self) -> Boolean.
    Returns True if this Symbol still exists in GDB.  */
 
 static PyObject *
 sympy_is_valid (PyObject *self, PyObject *args)
 {
   struct symbol *symbol = NULL;
 
   symbol = symbol_object_to_symbol (self);
   if (symbol == NULL)
     Py_RETURN_FALSE;
 
   Py_RETURN_TRUE;
 }
 
+/* Implementation of gdb.Symbol.value (self[, frame]) -> gdb.Value.  Returns
+   the value of the symbol, or an error in various circumstances.  */
+
+static PyObject *
+sympy_value (PyObject *self, PyObject *args)
+{
+  struct symbol *symbol = NULL;
+  struct frame_info *frame_info = NULL;
+  PyObject *frame_obj = NULL;
+  struct value *value = NULL;
+  volatile struct gdb_exception except;
+
+  if (!PyArg_ParseTuple (args, "|O", &frame_obj))
+    return NULL;
+
+  if (frame_obj != NULL && !PyObject_TypeCheck (frame_obj, &frame_object_type))
+    {
+      PyErr_SetString (PyExc_TypeError, "argument is not a frame");
+      return NULL;
+    }
+
+  SYMPY_REQUIRE_VALID (self, symbol);
+  if (SYMBOL_CLASS (symbol) == LOC_TYPEDEF)
+    {
+      PyErr_SetString (PyExc_TypeError, "cannot get the value of a typedef");
+      return NULL;
+    }
+
+  TRY_CATCH (except, RETURN_MASK_ALL)
+    {
+      if (frame_obj != NULL)
+        {
+          frame_info = frame_object_to_frame_info (frame_obj);
+          if (frame_info == NULL)
+            error (_("invalid frame"));
+        }
+      
+      if (symbol_read_needs_frame (symbol) && frame_info == NULL)
+        error (_("symbol requires a frame to compute its value"));
+
+      value = read_var_value (symbol, frame_info);
+    }
+  GDB_PY_HANDLE_EXCEPTION (except);
+
+  return value_to_value_object (value);
+}
+
 /* Given a symbol, and a symbol_object that has previously been
    allocated and initialized, populate the symbol_object with the
    struct symbol data.  Also, register the symbol_object life-cycle
    with the life-cycle of the object file associated with this
    symbol, if needed.  */
 static void
 set_symbol (symbol_object *obj, struct symbol *symbol)
 {
   obj->symbol = symbol;
   obj->prev = NULL;
@@ skipping 239 matching lines @@
     NULL },
   { "print_name", sympy_get_print_name, NULL,
     "Name of the symbol in a form suitable for output.\n\
 This is either name or linkage_name, depending on whether the user asked GDB\n\
 to display demangled or mangled names.", NULL },
   { "addr_class", sympy_get_addr_class, NULL, "Address class of the symbol." },
   { "is_argument", sympy_is_argument, NULL,
     "True if the symbol is an argument of a function." },
   { "is_constant", sympy_is_constant, NULL,
     "True if the symbol is a constant." },