* c-exp.y (exp): Add production to support direct creation

	of array constants using the obvious syntax.
	* c-valprint.c (c_val_print):  Set printed string length.
	* dwarfread.c (read_tag_string_type):  New prototype and
	function that handles TAG_string_type DIEs.
	* dwarfread.c (process_dies):  Add case for TAG_string_type
	that calls new read_tag_string_type function.
	* expprint.c (print_subexp):  Add support for OP_ARRAY.
	* gdbtypes.c (create_range_type, create_array_type):  Inherit
	objfile from the index type.
	**** start-sanitize-chill ****
	* ch-typeprint.c (chill_print_type):  Add case for
	TYPE_CODE_STRING.
	* ch-valprint.c (chill_val_print):  Fix case for
	TYPE_CODE_STRING.
	**** end-sanitize-chill ****

diff --git a/gdb/c-exp.y b/gdb/c-exp.y
index bca3d6d75e10bb32a428b3e95d078d91f77cc720..a7f7320b496c87d0f323b236426ebbb8bfacc41e 100644 (file)
--- a/gdb/c-exp.y
+++ b/gdb/c-exp.y
@@ -318,6 +318,17 @@ arglist    :       arglist ',' exp   %prec ABOVE_COMMA
                        { arglist_len++; }
        ;
 
+exp    :       '{' 
+                       /* This is to save the value of arglist_len
+                          being accumulated by an outer function call.  */
+                       { start_arglist (); }
+               arglist '}'     %prec ARROW
+                       { write_exp_elt_opcode (OP_ARRAY);
+                         write_exp_elt_longcst ((LONGEST) 0);
+                         write_exp_elt_longcst ((LONGEST) end_arglist () - 1);
+                         write_exp_elt_opcode (OP_ARRAY); }
+       ;
+
 exp    :       '{' type '}' exp  %prec UNARY
                        { write_exp_elt_opcode (UNOP_MEMVAL);
                          write_exp_elt_type ($2);

diff --git a/gdb/c-valprint.c b/gdb/c-valprint.c
index 2d13db2ace2b94d3c4e911945fae03508a741355..1df82289035ddda6c769f9152cd5c9da51158893 100644 (file)
--- a/gdb/c-valprint.c
+++ b/gdb/c-valprint.c
@@ -118,6 +118,7 @@ c_val_print (type, valaddr, address, stream, format, deref_ref, recurse,
                  fprintf_filtered (stream, "0x%x ", address);
                }
              LA_PRINT_STRING (stream, valaddr, len, 0);
+             i = len;
            }
          else
            {

diff --git a/gdb/ch-typeprint.c b/gdb/ch-typeprint.c
index cd3dd367d4a13ba8f0f41b322ff7c5df6ecdbc2a..f4119ca149a3c8136df340b239b77521ee5f8885 100644 (file)
--- a/gdb/ch-typeprint.c
+++ b/gdb/ch-typeprint.c
@@ -70,6 +70,16 @@ chill_print_type (type, varstring, stream, show, level)
        fputs_filtered (") ", stream);
        chill_print_type (TYPE_TARGET_TYPE (type), "", stream, show, level);
        break;
+
+      case TYPE_CODE_STRING:
+       range_type = TYPE_FIELD_TYPE (type, 0);
+       index_type = TYPE_TARGET_TYPE (range_type);
+       high_bound = TYPE_FIELD_BITPOS (range_type, 1);
+        fputs_filtered ("char (", stream);
+       print_type_scalar (index_type, high_bound + 1, stream);
+       fputs_filtered (") ", stream);
+       break;
+
       default:
         chill_print_type_base (type, stream, show, level);
        break;

diff --git a/gdb/ch-valprint.c b/gdb/ch-valprint.c
index c465fc319c51ecb295357a505fb5e61c7a664a5e..37730b4837ddfa8224fc786c65ec576284a3175c 100644 (file)
--- a/gdb/ch-valprint.c
+++ b/gdb/ch-valprint.c
@@ -52,7 +52,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;
@@ -156,7 +156,6 @@ chill_val_print (type, valaddr, address, stream, format, deref_ref, recurse,
       
       /* 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')
@@ -178,15 +177,12 @@ 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);
+         fprintf_filtered (stream, "0x%x ", addr);
        }
+      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));

diff --git a/gdb/dwarfread.c b/gdb/dwarfread.c
index 3da9e7673b60031e810eaf5da58e7d8bc082ea90..688976a35d71b1935ea9d7f9c1e0902dee21a383 100644 (file)
--- a/gdb/dwarfread.c
+++ b/gdb/dwarfread.c
@@ -522,6 +522,9 @@ dwarf_read_array_type PARAMS ((struct dieinfo *));
 static void
 read_tag_pointer_type PARAMS ((struct dieinfo *dip));
 
+static void
+read_tag_string_type PARAMS ((struct dieinfo *dip));
+
 static void
 read_subroutine_type PARAMS ((struct dieinfo *, char *, char *));
 
@@ -1524,6 +1527,60 @@ read_tag_pointer_type (dip)
 
 /*
 
+LOCAL FUNCTION
+
+       read_tag_string_type -- read TAG_string_type DIE
+
+SYNOPSIS
+
+       static void read_tag_string_type (struct dieinfo *dip)
+
+DESCRIPTION
+
+       Extract all information from a TAG_string_type DIE and add to
+       the user defined type vector.  It isn't really a user defined
+       type, but it behaves like one, with other DIE's using an
+       AT_user_def_type attribute to reference it.
+ */
+
+static void
+read_tag_string_type (dip)
+     struct dieinfo *dip;
+{
+  struct type *utype;
+  struct type *indextype;
+  struct type *rangetype;
+  unsigned long lowbound = 0;
+  unsigned long highbound;
+
+  if ((utype = lookup_utype (dip -> die_ref)) != NULL)
+    {
+      /* Ack, someone has stuck a type in the slot we want.  Complain
+        about it. */
+      complain (&dup_user_type_definition, DIE_ID, DIE_NAME);
+    }
+  else
+    {
+      if (dip -> has_at_byte_size)
+       {
+         /* A fixed bounds string */
+         highbound = dip -> at_byte_size - 1;
+       }
+      else
+       {
+         /* A varying length string.  Stub for now.  (FIXME) */
+         highbound = 1;
+       }
+      indextype = dwarf_fundamental_type (current_objfile, FT_INTEGER);
+      rangetype = create_range_type ((struct type *) NULL, indextype,
+                                    lowbound, highbound);
+      utype = create_string_type ((struct type *) NULL, rangetype);
+      alloc_utype (dip -> die_ref, utype);
+    }
+}
+
+/*
+
 LOCAL FUNCTION
 
        read_subroutine_type -- process TAG_subroutine_type dies
@@ -2011,6 +2068,9 @@ process_dies (thisdie, enddie, objfile)
            case TAG_pointer_type:
              read_tag_pointer_type (&di);
              break;
+           case TAG_string_type:
+             read_tag_string_type (&di);
+             break;
            default:
              new_symbol (&di, objfile);
              break;

diff --git a/gdb/gdbtypes.c b/gdb/gdbtypes.c
index 525c515def02c298b14b2cbeb76d7c8eaf62ac8b..b5caccff83c415761035daba503c5b8af567e864 100644 (file)
--- a/gdb/gdbtypes.c
+++ b/gdb/gdbtypes.c
@@ -314,8 +314,10 @@ allocate_stub_method (type)
 }
 
 /* Create a range type using either a blank type supplied in RESULT_TYPE,
-   or creating a new type.  Indices will be of type INDEX_TYPE, and will
-   range from LOW_BOUND to HIGH_BOUND, inclusive.
+   or creating a new type, inheriting the objfile from INDEX_TYPE.
+
+   Indices will be of type INDEX_TYPE, and will range from LOW_BOUND to
+   HIGH_BOUND, inclusive.
 
    FIXME:  Maybe we should check the TYPE_CODE of RESULT_TYPE to make
    sure it is TYPE_CODE_UNDEF before we bash it into a range type? */
@@ -348,8 +350,10 @@ create_range_type (result_type, index_type, low_bound, high_bound)
 
 
 /* Create an array type using either a blank type supplied in RESULT_TYPE,
-   or creating a new type.  Elements will be of type ELEMENT_TYPE, the
-   indices will be of type RANGE_TYPE.
+   or creating a new type, inheriting the objfile from RANGE_TYPE.
+
+   Elements will be of type ELEMENT_TYPE, the indices will be of type
+   RANGE_TYPE.
 
    FIXME:  Maybe we should check the TYPE_CODE of RESULT_TYPE to make
    sure it is TYPE_CODE_UNDEF before we bash it into an array type? */
@@ -374,7 +378,7 @@ create_array_type (result_type, element_type, range_type)
     }
   if (result_type == NULL)
     {
-      result_type = alloc_type (TYPE_OBJFILE (element_type));
+      result_type = alloc_type (TYPE_OBJFILE (range_type));
     }
   TYPE_CODE (result_type) = TYPE_CODE_ARRAY;
   TYPE_TARGET_TYPE (result_type) = element_type;