formatting cleanups
[deliverable/binutils-gdb.git] / gdb / ch-valprint.c
index c465fc319c51ecb295357a505fb5e61c7a664a5e..23891e88fcc80228c59620fd82f5b4e9df01c15e 100644 (file)
@@ -23,7 +23,13 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
 #include "gdbtypes.h"
 #include "valprint.h"
 #include "expression.h"
+#include "value.h"
 #include "language.h"
+#include "demangle.h"
+
+static void
+chill_print_value_fields PARAMS ((struct type *, char *, FILE *, int, int,
+                                 enum val_prettyprint, struct type **));
 
 \f
 /* Print data of type TYPE located at VALADDR (within GDB), which came from
@@ -52,7 +58,7 @@ chill_val_print (type, valaddr, address, stream, format, deref_ref, recurse,
      enum val_prettyprint pretty;
 {
   LONGEST val;
-  unsigned int i;
+  unsigned int i = 0;          /* Number of characters printed.  */
   struct type *elttype;
   unsigned eltlen;
   CORE_ADDR addr;
@@ -151,12 +157,11 @@ chill_val_print (type, valaddr, address, stream, format, deref_ref, recurse,
        }
       if (addressprint && format != 's')
        {
-         fprintf_filtered (stream, "0x%x", addr);
+         fprintf_filtered (stream, "H'%x", addr);
        }
       
       /* For a pointer to char or unsigned char, also print the string
         pointed to, unless pointer is null.  */
-      i = 0;           /* Number of characters printed.  */
       if (TYPE_LENGTH (elttype) == 1
          && TYPE_CODE (elttype) == TYPE_CODE_CHAR
          && (format == 0 || format == 's')
@@ -165,7 +170,7 @@ chill_val_print (type, valaddr, address, stream, format, deref_ref, recurse,
                In that case don't try to print the string.  */
          print_max < UINT_MAX)
          {
-           i = val_print_string (addr, stream);
+           i = val_print_string (addr, 0, stream);
          }
       /* Return number of characters printed, plus one for the
         terminating null if we have "reached the end".  */
@@ -178,36 +183,151 @@ chill_val_print (type, valaddr, address, stream, format, deref_ref, recurse,
          print_scalar_formatted (valaddr, type, format, 0, stream);
          break;
        }
-      addr = unpack_pointer (lookup_pointer_type (builtin_type_char), valaddr);
       if (addressprint && format != 's')
        {
-         fprintf_filtered (stream, "0x%x", addr);
-       }
-      if (addr != 0)
-       {
-         i = val_print_string (addr, TYPE_LENGTH (type), stream);
+         /* This used to say `addr', which is unset at this point.
+            Is `address' what is meant?  */
+         fprintf_filtered (stream, "H'%x ", address);
        }
+      i = TYPE_LENGTH (type);
+      LA_PRINT_STRING (stream, valaddr, i, 0);
       /* Return number of characters printed, plus one for the terminating
         null if we have "reached the end".  */
       return (i + (print_max && i != print_max));
       break;
 
-    case TYPE_CODE_MEMBER:
-    case TYPE_CODE_REF:
-    case TYPE_CODE_UNION:
     case TYPE_CODE_STRUCT:
+      chill_print_value_fields (type, valaddr, stream, format, recurse, pretty,
+                               0);
+      break;
+
+    case TYPE_CODE_REF:
+      if (addressprint)
+        {
+         fprintf_filtered (stream, "LOC(H'%lx)",
+                           unpack_long (builtin_type_int, valaddr));
+         if (deref_ref)
+           fputs_filtered (": ", stream);
+        }
+      /* De-reference the reference.  */
+      if (deref_ref)
+       {
+         if (TYPE_CODE (TYPE_TARGET_TYPE (type)) != TYPE_CODE_UNDEF)
+           {
+             value deref_val =
+               value_at
+                 (TYPE_TARGET_TYPE (type),
+                  unpack_pointer (lookup_pointer_type (builtin_type_void),
+                                  valaddr));
+             val_print (VALUE_TYPE (deref_val),
+                        VALUE_CONTENTS (deref_val),
+                        VALUE_ADDRESS (deref_val), stream, format,
+                        deref_ref, recurse + 1, pretty);
+           }
+         else
+           fputs_filtered ("???", stream);
+       }
+      break;
+
     case TYPE_CODE_ENUM:
+      c_val_print (type, valaddr, address, stream, format,
+                  deref_ref, recurse, pretty);
+      break;
+
+    case TYPE_CODE_MEMBER:
+    case TYPE_CODE_UNION:
     case TYPE_CODE_FUNC:
     case TYPE_CODE_VOID:
     case TYPE_CODE_ERROR:
     case TYPE_CODE_RANGE:
-      error ("Unimplemented chill_val_print support for type %d",
-            TYPE_CODE (type));
-      break;
-
     default:
-      error ("Invalid Chill type code %d in symbol table.", TYPE_CODE (type));
+      /* Let's derfer printing to the C printer, rather than
+        print an error message.  FIXME! */
+      c_val_print (type, valaddr, address, stream, format,
+                  deref_ref, recurse, pretty);
     }
   fflush (stream);
   return (0);
 }
+
+/* Mutually recursive subroutines of cplus_print_value and c_val_print to
+   print out a structure's fields: cp_print_value_fields and cplus_print_value.
+
+   TYPE, VALADDR, STREAM, RECURSE, and PRETTY have the
+   same meanings as in cplus_print_value and c_val_print.
+
+   DONT_PRINT is an array of baseclass types that we
+   should not print, or zero if called from top level.  */
+
+static void
+chill_print_value_fields (type, valaddr, stream, format, recurse, pretty,
+                         dont_print)
+     struct type *type;
+     char *valaddr;
+     FILE *stream;
+     int format;
+     int recurse;
+     enum val_prettyprint pretty;
+     struct type **dont_print;
+{
+  int i, len;
+  int fields_seen = 0;
+
+  check_stub_type (type);
+
+  fprintf_filtered (stream, "[");
+  len = TYPE_NFIELDS (type);
+  if (len == 0)
+    {
+      fprintf_filtered (stream, "<No data fields>");
+    }
+  else
+    {
+      for (i = 0; i < len; i++)
+       {
+         if (fields_seen)
+           {
+             fprintf_filtered (stream, ", ");
+           }
+         fields_seen = 1;
+         if (pretty)
+           {
+             fprintf_filtered (stream, "\n");
+             print_spaces_filtered (2 + 2 * recurse, stream);
+           }
+         else 
+           {
+             wrap_here (n_spaces (2 + 2 * recurse));
+           }
+         fputs_filtered (".", stream);
+         fprintf_symbol_filtered (stream, TYPE_FIELD_NAME (type, i),
+                                  language_chill, DMGL_NO_OPTS);
+         fputs_filtered (": ", stream);
+         if (TYPE_FIELD_PACKED (type, i))
+           {
+             value v;
+
+             /* Bitfields require special handling, especially due to byte
+                order problems.  */
+             v = value_from_longest (TYPE_FIELD_TYPE (type, i),
+                                     unpack_field_as_long (type, valaddr, i));
+
+             chill_val_print (TYPE_FIELD_TYPE (type, i), VALUE_CONTENTS (v), 0,
+                              stream, format, 0, recurse + 1, pretty);
+           }
+         else
+           {
+             chill_val_print (TYPE_FIELD_TYPE (type, i), 
+                              valaddr + TYPE_FIELD_BITPOS (type, i) / 8,
+                              0, stream, format, 0, recurse + 1, pretty);
+           }
+       }
+      if (pretty)
+       {
+         fprintf_filtered (stream, "\n");
+         print_spaces_filtered (2 * recurse, stream);
+       }
+    }
+  fprintf_filtered (stream, "]");
+}
+
This page took 0.024969 seconds and 4 git commands to generate.