OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gdb-7.1/] [gdb/] [ada-typeprint.c] - Diff between revs 834 and 842

Go to most recent revision | Only display areas with differences | Details | Blame | View Log

Rev 834 Rev 842
/* Support for printing Ada types for GDB, the GNU debugger.
/* Support for printing Ada types for GDB, the GNU debugger.
   Copyright (C) 1986, 1988, 1989, 1991, 1997, 1998, 1999, 2000, 2001, 2002,
   Copyright (C) 1986, 1988, 1989, 1991, 1997, 1998, 1999, 2000, 2001, 2002,
   2003, 2004, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
   2003, 2004, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
 
 
   This file is part of GDB.
   This file is part of GDB.
 
 
   This program is free software; you can redistribute it and/or modify
   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
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 3 of the License, or
   the Free Software Foundation; either version 3 of the License, or
   (at your option) any later version.
   (at your option) any later version.
 
 
   This program is distributed in the hope that it will be useful,
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
   GNU General Public License for more details.
 
 
   You should have received a copy of the GNU General Public License
   You should have received a copy of the GNU General Public License
   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
 
 
#include "defs.h"
#include "defs.h"
#include "gdb_obstack.h"
#include "gdb_obstack.h"
#include "bfd.h"                /* Binary File Description */
#include "bfd.h"                /* Binary File Description */
#include "symtab.h"
#include "symtab.h"
#include "gdbtypes.h"
#include "gdbtypes.h"
#include "expression.h"
#include "expression.h"
#include "value.h"
#include "value.h"
#include "gdbcore.h"
#include "gdbcore.h"
#include "target.h"
#include "target.h"
#include "command.h"
#include "command.h"
#include "gdbcmd.h"
#include "gdbcmd.h"
#include "language.h"
#include "language.h"
#include "demangle.h"
#include "demangle.h"
#include "c-lang.h"
#include "c-lang.h"
#include "typeprint.h"
#include "typeprint.h"
#include "ada-lang.h"
#include "ada-lang.h"
 
 
#include <ctype.h>
#include <ctype.h>
#include "gdb_string.h"
#include "gdb_string.h"
#include <errno.h>
#include <errno.h>
 
 
static int print_record_field_types (struct type *, struct type *,
static int print_record_field_types (struct type *, struct type *,
                                     struct ui_file *, int, int);
                                     struct ui_file *, int, int);
 
 
static void print_array_type (struct type *, struct ui_file *, int, int);
static void print_array_type (struct type *, struct ui_file *, int, int);
 
 
static void print_choices (struct type *, int, struct ui_file *,
static void print_choices (struct type *, int, struct ui_file *,
                           struct type *);
                           struct type *);
 
 
static void print_range (struct type *, struct ui_file *);
static void print_range (struct type *, struct ui_file *);
 
 
static void print_range_bound (struct type *, char *, int *,
static void print_range_bound (struct type *, char *, int *,
                               struct ui_file *);
                               struct ui_file *);
 
 
static void
static void
print_dynamic_range_bound (struct type *, const char *, int,
print_dynamic_range_bound (struct type *, const char *, int,
                           const char *, struct ui_file *);
                           const char *, struct ui_file *);
 
 
static void print_range_type_named (char *, struct type *, struct ui_file *);
static void print_range_type_named (char *, struct type *, struct ui_file *);


 
 
 
 
static char *name_buffer;
static char *name_buffer;
static int name_buffer_len;
static int name_buffer_len;
 
 
/* The (decoded) Ada name of TYPE.  This value persists until the
/* The (decoded) Ada name of TYPE.  This value persists until the
   next call.  */
   next call.  */
 
 
static char *
static char *
decoded_type_name (struct type *type)
decoded_type_name (struct type *type)
{
{
  if (ada_type_name (type) == NULL)
  if (ada_type_name (type) == NULL)
    return NULL;
    return NULL;
  else
  else
    {
    {
      char *raw_name = ada_type_name (type);
      char *raw_name = ada_type_name (type);
      char *s, *q;
      char *s, *q;
 
 
      if (name_buffer == NULL || name_buffer_len <= strlen (raw_name))
      if (name_buffer == NULL || name_buffer_len <= strlen (raw_name))
        {
        {
          name_buffer_len = 16 + 2 * strlen (raw_name);
          name_buffer_len = 16 + 2 * strlen (raw_name);
          name_buffer = xrealloc (name_buffer, name_buffer_len);
          name_buffer = xrealloc (name_buffer, name_buffer_len);
        }
        }
      strcpy (name_buffer, raw_name);
      strcpy (name_buffer, raw_name);
 
 
      s = (char *) strstr (name_buffer, "___");
      s = (char *) strstr (name_buffer, "___");
      if (s != NULL)
      if (s != NULL)
        *s = '\0';
        *s = '\0';
 
 
      s = name_buffer + strlen (name_buffer) - 1;
      s = name_buffer + strlen (name_buffer) - 1;
      while (s > name_buffer && (s[0] != '_' || s[-1] != '_'))
      while (s > name_buffer && (s[0] != '_' || s[-1] != '_'))
        s -= 1;
        s -= 1;
 
 
      if (s == name_buffer)
      if (s == name_buffer)
        return name_buffer;
        return name_buffer;
 
 
      if (!islower (s[1]))
      if (!islower (s[1]))
        return NULL;
        return NULL;
 
 
      for (s = q = name_buffer; *s != '\0'; q += 1)
      for (s = q = name_buffer; *s != '\0'; q += 1)
        {
        {
          if (s[0] == '_' && s[1] == '_')
          if (s[0] == '_' && s[1] == '_')
            {
            {
              *q = '.';
              *q = '.';
              s += 2;
              s += 2;
            }
            }
          else
          else
            {
            {
              *q = *s;
              *q = *s;
              s += 1;
              s += 1;
            }
            }
        }
        }
      *q = '\0';
      *q = '\0';
      return name_buffer;
      return name_buffer;
    }
    }
}
}
 
 
/* Print TYPE on STREAM, preferably as a range.  */
/* Print TYPE on STREAM, preferably as a range.  */
 
 
static void
static void
print_range (struct type *type, struct ui_file *stream)
print_range (struct type *type, struct ui_file *stream)
{
{
  switch (TYPE_CODE (type))
  switch (TYPE_CODE (type))
    {
    {
    case TYPE_CODE_RANGE:
    case TYPE_CODE_RANGE:
    case TYPE_CODE_ENUM:
    case TYPE_CODE_ENUM:
      {
      {
        struct type *target_type;
        struct type *target_type;
        target_type = TYPE_TARGET_TYPE (type);
        target_type = TYPE_TARGET_TYPE (type);
        if (target_type == NULL)
        if (target_type == NULL)
          target_type = type;
          target_type = type;
        ada_print_scalar (target_type, ada_discrete_type_low_bound (type),
        ada_print_scalar (target_type, ada_discrete_type_low_bound (type),
                          stream);
                          stream);
        fprintf_filtered (stream, " .. ");
        fprintf_filtered (stream, " .. ");
        ada_print_scalar (target_type, ada_discrete_type_high_bound (type),
        ada_print_scalar (target_type, ada_discrete_type_high_bound (type),
                          stream);
                          stream);
      }
      }
      break;
      break;
    default:
    default:
      fprintf_filtered (stream, "%.*s",
      fprintf_filtered (stream, "%.*s",
                        ada_name_prefix_len (TYPE_NAME (type)),
                        ada_name_prefix_len (TYPE_NAME (type)),
                        TYPE_NAME (type));
                        TYPE_NAME (type));
      break;
      break;
    }
    }
}
}
 
 
/* Print the number or discriminant bound at BOUNDS+*N on STREAM, and
/* Print the number or discriminant bound at BOUNDS+*N on STREAM, and
   set *N past the bound and its delimiter, if any.  */
   set *N past the bound and its delimiter, if any.  */
 
 
static void
static void
print_range_bound (struct type *type, char *bounds, int *n,
print_range_bound (struct type *type, char *bounds, int *n,
                   struct ui_file *stream)
                   struct ui_file *stream)
{
{
  LONGEST B;
  LONGEST B;
  if (ada_scan_number (bounds, *n, &B, n))
  if (ada_scan_number (bounds, *n, &B, n))
    {
    {
      /* STABS decodes all range types which bounds are 0 .. -1 as
      /* STABS decodes all range types which bounds are 0 .. -1 as
         unsigned integers (ie. the type code is TYPE_CODE_INT, not
         unsigned integers (ie. the type code is TYPE_CODE_INT, not
         TYPE_CODE_RANGE).  Unfortunately, ada_print_scalar() relies
         TYPE_CODE_RANGE).  Unfortunately, ada_print_scalar() relies
         on the unsigned flag to determine whether the bound should
         on the unsigned flag to determine whether the bound should
         be printed as a signed or an unsigned value.  This causes
         be printed as a signed or an unsigned value.  This causes
         the upper bound of the 0 .. -1 range types to be printed as
         the upper bound of the 0 .. -1 range types to be printed as
         a very large unsigned number instead of -1.
         a very large unsigned number instead of -1.
         To workaround this stabs deficiency, we replace the TYPE by NULL
         To workaround this stabs deficiency, we replace the TYPE by NULL
         to indicate default output when we detect that the bound is negative,
         to indicate default output when we detect that the bound is negative,
         and the type is a TYPE_CODE_INT.  The bound is negative when
         and the type is a TYPE_CODE_INT.  The bound is negative when
         'm' is the last character of the number scanned in BOUNDS.  */
         'm' is the last character of the number scanned in BOUNDS.  */
      if (bounds[*n - 1] == 'm' && TYPE_CODE (type) == TYPE_CODE_INT)
      if (bounds[*n - 1] == 'm' && TYPE_CODE (type) == TYPE_CODE_INT)
        type = NULL;
        type = NULL;
      ada_print_scalar (type, B, stream);
      ada_print_scalar (type, B, stream);
      if (bounds[*n] == '_')
      if (bounds[*n] == '_')
        *n += 2;
        *n += 2;
    }
    }
  else
  else
    {
    {
      int bound_len;
      int bound_len;
      char *bound = bounds + *n;
      char *bound = bounds + *n;
      char *pend;
      char *pend;
 
 
      pend = strstr (bound, "__");
      pend = strstr (bound, "__");
      if (pend == NULL)
      if (pend == NULL)
        *n += bound_len = strlen (bound);
        *n += bound_len = strlen (bound);
      else
      else
        {
        {
          bound_len = pend - bound;
          bound_len = pend - bound;
          *n += bound_len + 2;
          *n += bound_len + 2;
        }
        }
      fprintf_filtered (stream, "%.*s", bound_len, bound);
      fprintf_filtered (stream, "%.*s", bound_len, bound);
    }
    }
}
}
 
 
/* Assuming NAME[0 .. NAME_LEN-1] is the name of a range type, print
/* Assuming NAME[0 .. NAME_LEN-1] is the name of a range type, print
   the value (if found) of the bound indicated by SUFFIX ("___L" or
   the value (if found) of the bound indicated by SUFFIX ("___L" or
   "___U") according to the ___XD conventions.  */
   "___U") according to the ___XD conventions.  */
 
 
static void
static void
print_dynamic_range_bound (struct type *type, const char *name, int name_len,
print_dynamic_range_bound (struct type *type, const char *name, int name_len,
                           const char *suffix, struct ui_file *stream)
                           const char *suffix, struct ui_file *stream)
{
{
  static char *name_buf = NULL;
  static char *name_buf = NULL;
  static size_t name_buf_len = 0;
  static size_t name_buf_len = 0;
  LONGEST B;
  LONGEST B;
  int OK;
  int OK;
 
 
  GROW_VECT (name_buf, name_buf_len, name_len + strlen (suffix) + 1);
  GROW_VECT (name_buf, name_buf_len, name_len + strlen (suffix) + 1);
  strncpy (name_buf, name, name_len);
  strncpy (name_buf, name, name_len);
  strcpy (name_buf + name_len, suffix);
  strcpy (name_buf + name_len, suffix);
 
 
  B = get_int_var_value (name_buf, &OK);
  B = get_int_var_value (name_buf, &OK);
  if (OK)
  if (OK)
    ada_print_scalar (type, B, stream);
    ada_print_scalar (type, B, stream);
  else
  else
    fprintf_filtered (stream, "?");
    fprintf_filtered (stream, "?");
}
}
 
 
/* Print the range type named NAME.  If symbol lookup fails, fall back
/* Print the range type named NAME.  If symbol lookup fails, fall back
   to ORIG_TYPE as base type.  */
   to ORIG_TYPE as base type.  */
 
 
static void
static void
print_range_type_named (char *name, struct type *orig_type,
print_range_type_named (char *name, struct type *orig_type,
                        struct ui_file *stream)
                        struct ui_file *stream)
{
{
  struct type *raw_type = ada_find_any_type (name);
  struct type *raw_type = ada_find_any_type (name);
  struct type *base_type;
  struct type *base_type;
  char *subtype_info;
  char *subtype_info;
 
 
  if (raw_type == NULL)
  if (raw_type == NULL)
    raw_type = orig_type;
    raw_type = orig_type;
 
 
  if (TYPE_CODE (raw_type) == TYPE_CODE_RANGE)
  if (TYPE_CODE (raw_type) == TYPE_CODE_RANGE)
    base_type = TYPE_TARGET_TYPE (raw_type);
    base_type = TYPE_TARGET_TYPE (raw_type);
  else
  else
    base_type = raw_type;
    base_type = raw_type;
 
 
  subtype_info = strstr (name, "___XD");
  subtype_info = strstr (name, "___XD");
  if (subtype_info == NULL)
  if (subtype_info == NULL)
    print_range (raw_type, stream);
    print_range (raw_type, stream);
  else
  else
    {
    {
      int prefix_len = subtype_info - name;
      int prefix_len = subtype_info - name;
      char *bounds_str;
      char *bounds_str;
      int n;
      int n;
 
 
      subtype_info += 5;
      subtype_info += 5;
      bounds_str = strchr (subtype_info, '_');
      bounds_str = strchr (subtype_info, '_');
      n = 1;
      n = 1;
 
 
      if (*subtype_info == 'L')
      if (*subtype_info == 'L')
        {
        {
          print_range_bound (base_type, bounds_str, &n, stream);
          print_range_bound (base_type, bounds_str, &n, stream);
          subtype_info += 1;
          subtype_info += 1;
        }
        }
      else
      else
        print_dynamic_range_bound (base_type, name, prefix_len, "___L",
        print_dynamic_range_bound (base_type, name, prefix_len, "___L",
                                   stream);
                                   stream);
 
 
      fprintf_filtered (stream, " .. ");
      fprintf_filtered (stream, " .. ");
 
 
      if (*subtype_info == 'U')
      if (*subtype_info == 'U')
        print_range_bound (base_type, bounds_str, &n, stream);
        print_range_bound (base_type, bounds_str, &n, stream);
      else
      else
        print_dynamic_range_bound (base_type, name, prefix_len, "___U",
        print_dynamic_range_bound (base_type, name, prefix_len, "___U",
                                   stream);
                                   stream);
    }
    }
}
}
 
 
/* Print enumerated type TYPE on STREAM.  */
/* Print enumerated type TYPE on STREAM.  */
 
 
static void
static void
print_enum_type (struct type *type, struct ui_file *stream)
print_enum_type (struct type *type, struct ui_file *stream)
{
{
  int len = TYPE_NFIELDS (type);
  int len = TYPE_NFIELDS (type);
  int i, lastval;
  int i, lastval;
 
 
  fprintf_filtered (stream, "(");
  fprintf_filtered (stream, "(");
  wrap_here (" ");
  wrap_here (" ");
 
 
  lastval = 0;
  lastval = 0;
  for (i = 0; i < len; i++)
  for (i = 0; i < len; i++)
    {
    {
      QUIT;
      QUIT;
      if (i)
      if (i)
        fprintf_filtered (stream, ", ");
        fprintf_filtered (stream, ", ");
      wrap_here ("    ");
      wrap_here ("    ");
      fputs_filtered (ada_enum_name (TYPE_FIELD_NAME (type, i)), stream);
      fputs_filtered (ada_enum_name (TYPE_FIELD_NAME (type, i)), stream);
      if (lastval != TYPE_FIELD_BITPOS (type, i))
      if (lastval != TYPE_FIELD_BITPOS (type, i))
        {
        {
          fprintf_filtered (stream, " => %d", TYPE_FIELD_BITPOS (type, i));
          fprintf_filtered (stream, " => %d", TYPE_FIELD_BITPOS (type, i));
          lastval = TYPE_FIELD_BITPOS (type, i);
          lastval = TYPE_FIELD_BITPOS (type, i);
        }
        }
      lastval += 1;
      lastval += 1;
    }
    }
  fprintf_filtered (stream, ")");
  fprintf_filtered (stream, ")");
}
}
 
 
/* Print representation of Ada fixed-point type TYPE on STREAM.  */
/* Print representation of Ada fixed-point type TYPE on STREAM.  */
 
 
static void
static void
print_fixed_point_type (struct type *type, struct ui_file *stream)
print_fixed_point_type (struct type *type, struct ui_file *stream)
{
{
  DOUBLEST delta = ada_delta (type);
  DOUBLEST delta = ada_delta (type);
  DOUBLEST small = ada_fixed_to_float (type, 1.0);
  DOUBLEST small = ada_fixed_to_float (type, 1.0);
 
 
  if (delta < 0.0)
  if (delta < 0.0)
    fprintf_filtered (stream, "delta ??");
    fprintf_filtered (stream, "delta ??");
  else
  else
    {
    {
      fprintf_filtered (stream, "delta %g", (double) delta);
      fprintf_filtered (stream, "delta %g", (double) delta);
      if (delta != small)
      if (delta != small)
        fprintf_filtered (stream, " <'small = %g>", (double) small);
        fprintf_filtered (stream, " <'small = %g>", (double) small);
    }
    }
}
}
 
 
/* Print simple (constrained) array type TYPE on STREAM.  LEVEL is the
/* Print simple (constrained) array type TYPE on STREAM.  LEVEL is the
   recursion (indentation) level, in case the element type itself has
   recursion (indentation) level, in case the element type itself has
   nested structure, and SHOW is the number of levels of internal
   nested structure, and SHOW is the number of levels of internal
   structure to show (see ada_print_type).  */
   structure to show (see ada_print_type).  */
 
 
static void
static void
print_array_type (struct type *type, struct ui_file *stream, int show,
print_array_type (struct type *type, struct ui_file *stream, int show,
                  int level)
                  int level)
{
{
  int bitsize;
  int bitsize;
  int n_indices;
  int n_indices;
 
 
  if (ada_is_constrained_packed_array_type (type))
  if (ada_is_constrained_packed_array_type (type))
    type = ada_coerce_to_simple_array_type (type);
    type = ada_coerce_to_simple_array_type (type);
 
 
  bitsize = 0;
  bitsize = 0;
  fprintf_filtered (stream, "array (");
  fprintf_filtered (stream, "array (");
 
 
  if (type == NULL)
  if (type == NULL)
    {
    {
      fprintf_filtered (stream, _("<undecipherable array type>"));
      fprintf_filtered (stream, _("<undecipherable array type>"));
      return;
      return;
    }
    }
 
 
  n_indices = -1;
  n_indices = -1;
  if (show < 0)
  if (show < 0)
    fprintf_filtered (stream, "...");
    fprintf_filtered (stream, "...");
  else
  else
    {
    {
      if (ada_is_simple_array_type (type))
      if (ada_is_simple_array_type (type))
        {
        {
          struct type *range_desc_type =
          struct type *range_desc_type =
            ada_find_parallel_type (type, "___XA");
            ada_find_parallel_type (type, "___XA");
          struct type *arr_type;
          struct type *arr_type;
 
 
          bitsize = 0;
          bitsize = 0;
          if (range_desc_type == NULL)
          if (range_desc_type == NULL)
            {
            {
              for (arr_type = type; TYPE_CODE (arr_type) == TYPE_CODE_ARRAY;
              for (arr_type = type; TYPE_CODE (arr_type) == TYPE_CODE_ARRAY;
                   arr_type = TYPE_TARGET_TYPE (arr_type))
                   arr_type = TYPE_TARGET_TYPE (arr_type))
                {
                {
                  if (arr_type != type)
                  if (arr_type != type)
                    fprintf_filtered (stream, ", ");
                    fprintf_filtered (stream, ", ");
                  print_range (TYPE_INDEX_TYPE (arr_type), stream);
                  print_range (TYPE_INDEX_TYPE (arr_type), stream);
                  if (TYPE_FIELD_BITSIZE (arr_type, 0) > 0)
                  if (TYPE_FIELD_BITSIZE (arr_type, 0) > 0)
                    bitsize = TYPE_FIELD_BITSIZE (arr_type, 0);
                    bitsize = TYPE_FIELD_BITSIZE (arr_type, 0);
                }
                }
            }
            }
          else
          else
            {
            {
              int k;
              int k;
              n_indices = TYPE_NFIELDS (range_desc_type);
              n_indices = TYPE_NFIELDS (range_desc_type);
              for (k = 0, arr_type = type;
              for (k = 0, arr_type = type;
                   k < n_indices;
                   k < n_indices;
                   k += 1, arr_type = TYPE_TARGET_TYPE (arr_type))
                   k += 1, arr_type = TYPE_TARGET_TYPE (arr_type))
                {
                {
                  if (k > 0)
                  if (k > 0)
                    fprintf_filtered (stream, ", ");
                    fprintf_filtered (stream, ", ");
                  print_range_type_named (TYPE_FIELD_NAME
                  print_range_type_named (TYPE_FIELD_NAME
                                          (range_desc_type, k),
                                          (range_desc_type, k),
                                          TYPE_INDEX_TYPE (arr_type), stream);
                                          TYPE_INDEX_TYPE (arr_type), stream);
                  if (TYPE_FIELD_BITSIZE (arr_type, 0) > 0)
                  if (TYPE_FIELD_BITSIZE (arr_type, 0) > 0)
                    bitsize = TYPE_FIELD_BITSIZE (arr_type, 0);
                    bitsize = TYPE_FIELD_BITSIZE (arr_type, 0);
                }
                }
            }
            }
        }
        }
      else
      else
        {
        {
          int i, i0;
          int i, i0;
          for (i = i0 = ada_array_arity (type); i > 0; i -= 1)
          for (i = i0 = ada_array_arity (type); i > 0; i -= 1)
            fprintf_filtered (stream, "%s<>", i == i0 ? "" : ", ");
            fprintf_filtered (stream, "%s<>", i == i0 ? "" : ", ");
        }
        }
    }
    }
 
 
  fprintf_filtered (stream, ") of ");
  fprintf_filtered (stream, ") of ");
  wrap_here ("");
  wrap_here ("");
  ada_print_type (ada_array_element_type (type, n_indices), "", stream,
  ada_print_type (ada_array_element_type (type, n_indices), "", stream,
                  show == 0 ? 0 : show - 1, level + 1);
                  show == 0 ? 0 : show - 1, level + 1);
  if (bitsize > 0)
  if (bitsize > 0)
    fprintf_filtered (stream, " <packed: %d-bit elements>", bitsize);
    fprintf_filtered (stream, " <packed: %d-bit elements>", bitsize);
}
}
 
 
/* Print the choices encoded by field FIELD_NUM of variant-part TYPE on
/* Print the choices encoded by field FIELD_NUM of variant-part TYPE on
   STREAM, assuming that VAL_TYPE (if non-NULL) is the type of the values.  */
   STREAM, assuming that VAL_TYPE (if non-NULL) is the type of the values.  */
 
 
static void
static void
print_choices (struct type *type, int field_num, struct ui_file *stream,
print_choices (struct type *type, int field_num, struct ui_file *stream,
               struct type *val_type)
               struct type *val_type)
{
{
  int have_output;
  int have_output;
  int p;
  int p;
  const char *name = TYPE_FIELD_NAME (type, field_num);
  const char *name = TYPE_FIELD_NAME (type, field_num);
 
 
  have_output = 0;
  have_output = 0;
 
 
  /* Skip over leading 'V': NOTE soon to be obsolete.  */
  /* Skip over leading 'V': NOTE soon to be obsolete.  */
  if (name[0] == 'V')
  if (name[0] == 'V')
    {
    {
      if (!ada_scan_number (name, 1, NULL, &p))
      if (!ada_scan_number (name, 1, NULL, &p))
        goto Huh;
        goto Huh;
    }
    }
  else
  else
    p = 0;
    p = 0;
 
 
  while (1)
  while (1)
    {
    {
      switch (name[p])
      switch (name[p])
        {
        {
        default:
        default:
          return;
          return;
        case 'S':
        case 'S':
        case 'R':
        case 'R':
        case 'O':
        case 'O':
          if (have_output)
          if (have_output)
            fprintf_filtered (stream, " | ");
            fprintf_filtered (stream, " | ");
          have_output = 1;
          have_output = 1;
          break;
          break;
        }
        }
 
 
      switch (name[p])
      switch (name[p])
        {
        {
        case 'S':
        case 'S':
          {
          {
            LONGEST W;
            LONGEST W;
            if (!ada_scan_number (name, p + 1, &W, &p))
            if (!ada_scan_number (name, p + 1, &W, &p))
              goto Huh;
              goto Huh;
            ada_print_scalar (val_type, W, stream);
            ada_print_scalar (val_type, W, stream);
            break;
            break;
          }
          }
        case 'R':
        case 'R':
          {
          {
            LONGEST L, U;
            LONGEST L, U;
            if (!ada_scan_number (name, p + 1, &L, &p)
            if (!ada_scan_number (name, p + 1, &L, &p)
                || name[p] != 'T' || !ada_scan_number (name, p + 1, &U, &p))
                || name[p] != 'T' || !ada_scan_number (name, p + 1, &U, &p))
              goto Huh;
              goto Huh;
            ada_print_scalar (val_type, L, stream);
            ada_print_scalar (val_type, L, stream);
            fprintf_filtered (stream, " .. ");
            fprintf_filtered (stream, " .. ");
            ada_print_scalar (val_type, U, stream);
            ada_print_scalar (val_type, U, stream);
            break;
            break;
          }
          }
        case 'O':
        case 'O':
          fprintf_filtered (stream, "others");
          fprintf_filtered (stream, "others");
          p += 1;
          p += 1;
          break;
          break;
        }
        }
    }
    }
 
 
Huh:
Huh:
  fprintf_filtered (stream, "??");
  fprintf_filtered (stream, "??");
 
 
}
}
 
 
/* Assuming that field FIELD_NUM of TYPE is a VARIANTS field whose
/* Assuming that field FIELD_NUM of TYPE is a VARIANTS field whose
   discriminant is contained in OUTER_TYPE, print its variants on STREAM.
   discriminant is contained in OUTER_TYPE, print its variants on STREAM.
   LEVEL is the recursion
   LEVEL is the recursion
   (indentation) level, in case any of the fields themselves have
   (indentation) level, in case any of the fields themselves have
   nested structure, and SHOW is the number of levels of internal structure
   nested structure, and SHOW is the number of levels of internal structure
   to show (see ada_print_type).  For this purpose, fields nested in a
   to show (see ada_print_type).  For this purpose, fields nested in a
   variant part are taken to be at the same level as the fields
   variant part are taken to be at the same level as the fields
   immediately outside the variant part.  */
   immediately outside the variant part.  */
 
 
static void
static void
print_variant_clauses (struct type *type, int field_num,
print_variant_clauses (struct type *type, int field_num,
                       struct type *outer_type, struct ui_file *stream,
                       struct type *outer_type, struct ui_file *stream,
                       int show, int level)
                       int show, int level)
{
{
  int i;
  int i;
  struct type *var_type, *par_type;
  struct type *var_type, *par_type;
  struct type *discr_type;
  struct type *discr_type;
 
 
  var_type = TYPE_FIELD_TYPE (type, field_num);
  var_type = TYPE_FIELD_TYPE (type, field_num);
  discr_type = ada_variant_discrim_type (var_type, outer_type);
  discr_type = ada_variant_discrim_type (var_type, outer_type);
 
 
  if (TYPE_CODE (var_type) == TYPE_CODE_PTR)
  if (TYPE_CODE (var_type) == TYPE_CODE_PTR)
    {
    {
      var_type = TYPE_TARGET_TYPE (var_type);
      var_type = TYPE_TARGET_TYPE (var_type);
      if (var_type == NULL || TYPE_CODE (var_type) != TYPE_CODE_UNION)
      if (var_type == NULL || TYPE_CODE (var_type) != TYPE_CODE_UNION)
        return;
        return;
    }
    }
 
 
  par_type = ada_find_parallel_type (var_type, "___XVU");
  par_type = ada_find_parallel_type (var_type, "___XVU");
  if (par_type != NULL)
  if (par_type != NULL)
    var_type = par_type;
    var_type = par_type;
 
 
  for (i = 0; i < TYPE_NFIELDS (var_type); i += 1)
  for (i = 0; i < TYPE_NFIELDS (var_type); i += 1)
    {
    {
      fprintf_filtered (stream, "\n%*swhen ", level + 4, "");
      fprintf_filtered (stream, "\n%*swhen ", level + 4, "");
      print_choices (var_type, i, stream, discr_type);
      print_choices (var_type, i, stream, discr_type);
      fprintf_filtered (stream, " =>");
      fprintf_filtered (stream, " =>");
      if (print_record_field_types (TYPE_FIELD_TYPE (var_type, i),
      if (print_record_field_types (TYPE_FIELD_TYPE (var_type, i),
                                    outer_type, stream, show, level + 4) <= 0)
                                    outer_type, stream, show, level + 4) <= 0)
        fprintf_filtered (stream, " null;");
        fprintf_filtered (stream, " null;");
    }
    }
}
}
 
 
/* Assuming that field FIELD_NUM of TYPE is a variant part whose
/* Assuming that field FIELD_NUM of TYPE is a variant part whose
   discriminants are contained in OUTER_TYPE, print a description of it
   discriminants are contained in OUTER_TYPE, print a description of it
   on STREAM.  LEVEL is the recursion (indentation) level, in case any of
   on STREAM.  LEVEL is the recursion (indentation) level, in case any of
   the fields themselves have nested structure, and SHOW is the number of
   the fields themselves have nested structure, and SHOW is the number of
   levels of internal structure to show (see ada_print_type).  For this
   levels of internal structure to show (see ada_print_type).  For this
   purpose, fields nested in a variant part are taken to be at the same
   purpose, fields nested in a variant part are taken to be at the same
   level as the fields immediately outside the variant part.  */
   level as the fields immediately outside the variant part.  */
 
 
static void
static void
print_variant_part (struct type *type, int field_num, struct type *outer_type,
print_variant_part (struct type *type, int field_num, struct type *outer_type,
                    struct ui_file *stream, int show, int level)
                    struct ui_file *stream, int show, int level)
{
{
  fprintf_filtered (stream, "\n%*scase %s is", level + 4, "",
  fprintf_filtered (stream, "\n%*scase %s is", level + 4, "",
                    ada_variant_discrim_name
                    ada_variant_discrim_name
                    (TYPE_FIELD_TYPE (type, field_num)));
                    (TYPE_FIELD_TYPE (type, field_num)));
  print_variant_clauses (type, field_num, outer_type, stream, show,
  print_variant_clauses (type, field_num, outer_type, stream, show,
                         level + 4);
                         level + 4);
  fprintf_filtered (stream, "\n%*send case;", level + 4, "");
  fprintf_filtered (stream, "\n%*send case;", level + 4, "");
}
}
 
 
/* Print a description on STREAM of the fields in record type TYPE, whose
/* Print a description on STREAM of the fields in record type TYPE, whose
   discriminants are in OUTER_TYPE.  LEVEL is the recursion (indentation)
   discriminants are in OUTER_TYPE.  LEVEL is the recursion (indentation)
   level, in case any of the fields themselves have nested structure,
   level, in case any of the fields themselves have nested structure,
   and SHOW is the number of levels of internal structure to show
   and SHOW is the number of levels of internal structure to show
   (see ada_print_type).  Does not print parent type information of TYPE.
   (see ada_print_type).  Does not print parent type information of TYPE.
   Returns 0 if no fields printed, -1 for an incomplete type, else > 0.
   Returns 0 if no fields printed, -1 for an incomplete type, else > 0.
   Prints each field beginning on a new line, but does not put a new line at
   Prints each field beginning on a new line, but does not put a new line at
   end.  */
   end.  */
 
 
static int
static int
print_record_field_types (struct type *type, struct type *outer_type,
print_record_field_types (struct type *type, struct type *outer_type,
                          struct ui_file *stream, int show, int level)
                          struct ui_file *stream, int show, int level)
{
{
  int len, i, flds;
  int len, i, flds;
 
 
  flds = 0;
  flds = 0;
  len = TYPE_NFIELDS (type);
  len = TYPE_NFIELDS (type);
 
 
  if (len == 0 && TYPE_STUB (type))
  if (len == 0 && TYPE_STUB (type))
    return -1;
    return -1;
 
 
  for (i = 0; i < len; i += 1)
  for (i = 0; i < len; i += 1)
    {
    {
      QUIT;
      QUIT;
 
 
      if (ada_is_parent_field (type, i) || ada_is_ignored_field (type, i))
      if (ada_is_parent_field (type, i) || ada_is_ignored_field (type, i))
        ;
        ;
      else if (ada_is_wrapper_field (type, i))
      else if (ada_is_wrapper_field (type, i))
        flds += print_record_field_types (TYPE_FIELD_TYPE (type, i), type,
        flds += print_record_field_types (TYPE_FIELD_TYPE (type, i), type,
                                          stream, show, level);
                                          stream, show, level);
      else if (ada_is_variant_part (type, i))
      else if (ada_is_variant_part (type, i))
        {
        {
          print_variant_part (type, i, outer_type, stream, show, level);
          print_variant_part (type, i, outer_type, stream, show, level);
          flds = 1;
          flds = 1;
        }
        }
      else
      else
        {
        {
          flds += 1;
          flds += 1;
          fprintf_filtered (stream, "\n%*s", level + 4, "");
          fprintf_filtered (stream, "\n%*s", level + 4, "");
          ada_print_type (TYPE_FIELD_TYPE (type, i),
          ada_print_type (TYPE_FIELD_TYPE (type, i),
                          TYPE_FIELD_NAME (type, i),
                          TYPE_FIELD_NAME (type, i),
                          stream, show - 1, level + 4);
                          stream, show - 1, level + 4);
          fprintf_filtered (stream, ";");
          fprintf_filtered (stream, ";");
        }
        }
    }
    }
 
 
  return flds;
  return flds;
}
}
 
 
/* Print record type TYPE on STREAM.  LEVEL is the recursion (indentation)
/* Print record type TYPE on STREAM.  LEVEL is the recursion (indentation)
   level, in case the element type itself has nested structure, and SHOW is
   level, in case the element type itself has nested structure, and SHOW is
   the number of levels of internal structure to show (see ada_print_type).  */
   the number of levels of internal structure to show (see ada_print_type).  */
 
 
static void
static void
print_record_type (struct type *type0, struct ui_file *stream, int show,
print_record_type (struct type *type0, struct ui_file *stream, int show,
                   int level)
                   int level)
{
{
  struct type *parent_type;
  struct type *parent_type;
  struct type *type;
  struct type *type;
 
 
  type = ada_find_parallel_type (type0, "___XVE");
  type = ada_find_parallel_type (type0, "___XVE");
  if (type == NULL)
  if (type == NULL)
    type = type0;
    type = type0;
 
 
  parent_type = ada_parent_type (type);
  parent_type = ada_parent_type (type);
  if (ada_type_name (parent_type) != NULL)
  if (ada_type_name (parent_type) != NULL)
    fprintf_filtered (stream, "new %s with record",
    fprintf_filtered (stream, "new %s with record",
                      decoded_type_name (parent_type));
                      decoded_type_name (parent_type));
  else if (parent_type == NULL && ada_is_tagged_type (type, 0))
  else if (parent_type == NULL && ada_is_tagged_type (type, 0))
    fprintf_filtered (stream, "tagged record");
    fprintf_filtered (stream, "tagged record");
  else
  else
    fprintf_filtered (stream, "record");
    fprintf_filtered (stream, "record");
 
 
  if (show < 0)
  if (show < 0)
    fprintf_filtered (stream, " ... end record");
    fprintf_filtered (stream, " ... end record");
  else
  else
    {
    {
      int flds;
      int flds;
 
 
      flds = 0;
      flds = 0;
      if (parent_type != NULL && ada_type_name (parent_type) == NULL)
      if (parent_type != NULL && ada_type_name (parent_type) == NULL)
        flds += print_record_field_types (parent_type, parent_type,
        flds += print_record_field_types (parent_type, parent_type,
                                          stream, show, level);
                                          stream, show, level);
      flds += print_record_field_types (type, type, stream, show, level);
      flds += print_record_field_types (type, type, stream, show, level);
 
 
      if (flds > 0)
      if (flds > 0)
        fprintf_filtered (stream, "\n%*send record", level, "");
        fprintf_filtered (stream, "\n%*send record", level, "");
      else if (flds < 0)
      else if (flds < 0)
        fprintf_filtered (stream, _(" <incomplete type> end record"));
        fprintf_filtered (stream, _(" <incomplete type> end record"));
      else
      else
        fprintf_filtered (stream, " null; end record");
        fprintf_filtered (stream, " null; end record");
    }
    }
}
}
 
 
/* Print the unchecked union type TYPE in something resembling Ada
/* Print the unchecked union type TYPE in something resembling Ada
   format on STREAM.  LEVEL is the recursion (indentation) level
   format on STREAM.  LEVEL is the recursion (indentation) level
   in case the element type itself has nested structure, and SHOW is the
   in case the element type itself has nested structure, and SHOW is the
   number of levels of internal structure to show (see ada_print_type).  */
   number of levels of internal structure to show (see ada_print_type).  */
static void
static void
print_unchecked_union_type (struct type *type, struct ui_file *stream,
print_unchecked_union_type (struct type *type, struct ui_file *stream,
                            int show, int level)
                            int show, int level)
{
{
  if (show < 0)
  if (show < 0)
    fprintf_filtered (stream, "record (?) is ... end record");
    fprintf_filtered (stream, "record (?) is ... end record");
  else if (TYPE_NFIELDS (type) == 0)
  else if (TYPE_NFIELDS (type) == 0)
    fprintf_filtered (stream, "record (?) is null; end record");
    fprintf_filtered (stream, "record (?) is null; end record");
  else
  else
    {
    {
      int i;
      int i;
 
 
      fprintf_filtered (stream, "record (?) is\n%*scase ? is", level + 4, "");
      fprintf_filtered (stream, "record (?) is\n%*scase ? is", level + 4, "");
 
 
      for (i = 0; i < TYPE_NFIELDS (type); i += 1)
      for (i = 0; i < TYPE_NFIELDS (type); i += 1)
        {
        {
          fprintf_filtered (stream, "\n%*swhen ? =>\n%*s", level + 8, "",
          fprintf_filtered (stream, "\n%*swhen ? =>\n%*s", level + 8, "",
                            level + 12, "");
                            level + 12, "");
          ada_print_type (TYPE_FIELD_TYPE (type, i),
          ada_print_type (TYPE_FIELD_TYPE (type, i),
                          TYPE_FIELD_NAME (type, i),
                          TYPE_FIELD_NAME (type, i),
                          stream, show - 1, level + 12);
                          stream, show - 1, level + 12);
          fprintf_filtered (stream, ";");
          fprintf_filtered (stream, ";");
        }
        }
 
 
      fprintf_filtered (stream, "\n%*send case;\n%*send record",
      fprintf_filtered (stream, "\n%*send case;\n%*send record",
                        level + 4, "", level, "");
                        level + 4, "", level, "");
    }
    }
}
}
 
 
 
 
 
 
/* Print function or procedure type TYPE on STREAM.  Make it a header
/* Print function or procedure type TYPE on STREAM.  Make it a header
   for function or procedure NAME if NAME is not null.  */
   for function or procedure NAME if NAME is not null.  */
 
 
static void
static void
print_func_type (struct type *type, struct ui_file *stream, char *name)
print_func_type (struct type *type, struct ui_file *stream, char *name)
{
{
  int i, len = TYPE_NFIELDS (type);
  int i, len = TYPE_NFIELDS (type);
 
 
  if (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_VOID)
  if (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_VOID)
    fprintf_filtered (stream, "procedure");
    fprintf_filtered (stream, "procedure");
  else
  else
    fprintf_filtered (stream, "function");
    fprintf_filtered (stream, "function");
 
 
  if (name != NULL && name[0] != '\0')
  if (name != NULL && name[0] != '\0')
    fprintf_filtered (stream, " %s", name);
    fprintf_filtered (stream, " %s", name);
 
 
  if (len > 0)
  if (len > 0)
    {
    {
      fprintf_filtered (stream, " (");
      fprintf_filtered (stream, " (");
      for (i = 0; i < len; i += 1)
      for (i = 0; i < len; i += 1)
        {
        {
          if (i > 0)
          if (i > 0)
            {
            {
              fputs_filtered ("; ", stream);
              fputs_filtered ("; ", stream);
              wrap_here ("    ");
              wrap_here ("    ");
            }
            }
          fprintf_filtered (stream, "a%d: ", i + 1);
          fprintf_filtered (stream, "a%d: ", i + 1);
          ada_print_type (TYPE_FIELD_TYPE (type, i), "", stream, -1, 0);
          ada_print_type (TYPE_FIELD_TYPE (type, i), "", stream, -1, 0);
        }
        }
      fprintf_filtered (stream, ")");
      fprintf_filtered (stream, ")");
    }
    }
 
 
  if (TYPE_CODE (TYPE_TARGET_TYPE (type)) != TYPE_CODE_VOID)
  if (TYPE_CODE (TYPE_TARGET_TYPE (type)) != TYPE_CODE_VOID)
    {
    {
      fprintf_filtered (stream, " return ");
      fprintf_filtered (stream, " return ");
      ada_print_type (TYPE_TARGET_TYPE (type), "", stream, 0, 0);
      ada_print_type (TYPE_TARGET_TYPE (type), "", stream, 0, 0);
    }
    }
}
}
 
 
 
 
/* Print a description of a type TYPE0.
/* Print a description of a type TYPE0.
   Output goes to STREAM (via stdio).
   Output goes to STREAM (via stdio).
   If VARSTRING is a non-empty string, print as an Ada variable/field
   If VARSTRING is a non-empty string, print as an Ada variable/field
       declaration.
       declaration.
   SHOW+1 is the maximum number of levels of internal type structure
   SHOW+1 is the maximum number of levels of internal type structure
      to show (this applies to record types, enumerated types, and
      to show (this applies to record types, enumerated types, and
      array types).
      array types).
   SHOW is the number of levels of internal type structure to show
   SHOW is the number of levels of internal type structure to show
      when there is a type name for the SHOWth deepest level (0th is
      when there is a type name for the SHOWth deepest level (0th is
      outer level).
      outer level).
   When SHOW<0, no inner structure is shown.
   When SHOW<0, no inner structure is shown.
   LEVEL indicates level of recursion (for nested definitions).  */
   LEVEL indicates level of recursion (for nested definitions).  */
 
 
void
void
ada_print_type (struct type *type0, char *varstring, struct ui_file *stream,
ada_print_type (struct type *type0, char *varstring, struct ui_file *stream,
                int show, int level)
                int show, int level)
{
{
  struct type *type = ada_check_typedef (ada_get_base_type (type0));
  struct type *type = ada_check_typedef (ada_get_base_type (type0));
  char *type_name = decoded_type_name (type0);
  char *type_name = decoded_type_name (type0);
  int is_var_decl = (varstring != NULL && varstring[0] != '\0');
  int is_var_decl = (varstring != NULL && varstring[0] != '\0');
 
 
  if (type == NULL)
  if (type == NULL)
    {
    {
      if (is_var_decl)
      if (is_var_decl)
        fprintf_filtered (stream, "%.*s: ",
        fprintf_filtered (stream, "%.*s: ",
                          ada_name_prefix_len (varstring), varstring);
                          ada_name_prefix_len (varstring), varstring);
      fprintf_filtered (stream, "<null type?>");
      fprintf_filtered (stream, "<null type?>");
      return;
      return;
    }
    }
 
 
  if (show > 0)
  if (show > 0)
    type = ada_check_typedef (type);
    type = ada_check_typedef (type);
 
 
  if (is_var_decl && TYPE_CODE (type) != TYPE_CODE_FUNC)
  if (is_var_decl && TYPE_CODE (type) != TYPE_CODE_FUNC)
    fprintf_filtered (stream, "%.*s: ",
    fprintf_filtered (stream, "%.*s: ",
                      ada_name_prefix_len (varstring), varstring);
                      ada_name_prefix_len (varstring), varstring);
 
 
  if (type_name != NULL && show <= 0)
  if (type_name != NULL && show <= 0)
    {
    {
      fprintf_filtered (stream, "%.*s",
      fprintf_filtered (stream, "%.*s",
                        ada_name_prefix_len (type_name), type_name);
                        ada_name_prefix_len (type_name), type_name);
      return;
      return;
    }
    }
 
 
  if (ada_is_aligner_type (type))
  if (ada_is_aligner_type (type))
    ada_print_type (ada_aligned_type (type), "", stream, show, level);
    ada_print_type (ada_aligned_type (type), "", stream, show, level);
  else if (ada_is_constrained_packed_array_type (type))
  else if (ada_is_constrained_packed_array_type (type))
    {
    {
      if (TYPE_CODE (type) == TYPE_CODE_PTR)
      if (TYPE_CODE (type) == TYPE_CODE_PTR)
        {
        {
          fprintf_filtered (stream, "access ");
          fprintf_filtered (stream, "access ");
          print_array_type (TYPE_TARGET_TYPE (type), stream, show, level);
          print_array_type (TYPE_TARGET_TYPE (type), stream, show, level);
        }
        }
      else
      else
        {
        {
          print_array_type (type, stream, show, level);
          print_array_type (type, stream, show, level);
        }
        }
    }
    }
  else
  else
    switch (TYPE_CODE (type))
    switch (TYPE_CODE (type))
      {
      {
      default:
      default:
        fprintf_filtered (stream, "<");
        fprintf_filtered (stream, "<");
        c_print_type (type, "", stream, show, level);
        c_print_type (type, "", stream, show, level);
        fprintf_filtered (stream, ">");
        fprintf_filtered (stream, ">");
        break;
        break;
      case TYPE_CODE_PTR:
      case TYPE_CODE_PTR:
        fprintf_filtered (stream, "access ");
        fprintf_filtered (stream, "access ");
        ada_print_type (TYPE_TARGET_TYPE (type), "", stream, show, level);
        ada_print_type (TYPE_TARGET_TYPE (type), "", stream, show, level);
        break;
        break;
      case TYPE_CODE_REF:
      case TYPE_CODE_REF:
        fprintf_filtered (stream, "<ref> ");
        fprintf_filtered (stream, "<ref> ");
        ada_print_type (TYPE_TARGET_TYPE (type), "", stream, show, level);
        ada_print_type (TYPE_TARGET_TYPE (type), "", stream, show, level);
        break;
        break;
      case TYPE_CODE_ARRAY:
      case TYPE_CODE_ARRAY:
        print_array_type (type, stream, show, level);
        print_array_type (type, stream, show, level);
        break;
        break;
      case TYPE_CODE_BOOL:
      case TYPE_CODE_BOOL:
        fprintf_filtered (stream, "(false, true)");
        fprintf_filtered (stream, "(false, true)");
        break;
        break;
      case TYPE_CODE_INT:
      case TYPE_CODE_INT:
        if (ada_is_fixed_point_type (type))
        if (ada_is_fixed_point_type (type))
          print_fixed_point_type (type, stream);
          print_fixed_point_type (type, stream);
        else
        else
          {
          {
            char *name = ada_type_name (type);
            char *name = ada_type_name (type);
            if (!ada_is_range_type_name (name))
            if (!ada_is_range_type_name (name))
              fprintf_filtered (stream, _("<%d-byte integer>"),
              fprintf_filtered (stream, _("<%d-byte integer>"),
                                TYPE_LENGTH (type));
                                TYPE_LENGTH (type));
            else
            else
              {
              {
                fprintf_filtered (stream, "range ");
                fprintf_filtered (stream, "range ");
                print_range_type_named (name, type, stream);
                print_range_type_named (name, type, stream);
              }
              }
          }
          }
        break;
        break;
      case TYPE_CODE_RANGE:
      case TYPE_CODE_RANGE:
        if (ada_is_fixed_point_type (type))
        if (ada_is_fixed_point_type (type))
          print_fixed_point_type (type, stream);
          print_fixed_point_type (type, stream);
        else if (ada_is_modular_type (type))
        else if (ada_is_modular_type (type))
          fprintf_filtered (stream, "mod %s",
          fprintf_filtered (stream, "mod %s",
                            int_string (ada_modulus (type), 10, 0, 0, 1));
                            int_string (ada_modulus (type), 10, 0, 0, 1));
        else
        else
          {
          {
            fprintf_filtered (stream, "range ");
            fprintf_filtered (stream, "range ");
            print_range (type, stream);
            print_range (type, stream);
          }
          }
        break;
        break;
      case TYPE_CODE_FLT:
      case TYPE_CODE_FLT:
        fprintf_filtered (stream, _("<%d-byte float>"), TYPE_LENGTH (type));
        fprintf_filtered (stream, _("<%d-byte float>"), TYPE_LENGTH (type));
        break;
        break;
      case TYPE_CODE_ENUM:
      case TYPE_CODE_ENUM:
        if (show < 0)
        if (show < 0)
          fprintf_filtered (stream, "(...)");
          fprintf_filtered (stream, "(...)");
        else
        else
          print_enum_type (type, stream);
          print_enum_type (type, stream);
        break;
        break;
      case TYPE_CODE_STRUCT:
      case TYPE_CODE_STRUCT:
        if (ada_is_array_descriptor_type (type))
        if (ada_is_array_descriptor_type (type))
          print_array_type (type, stream, show, level);
          print_array_type (type, stream, show, level);
        else if (ada_is_bogus_array_descriptor (type))
        else if (ada_is_bogus_array_descriptor (type))
          fprintf_filtered (stream,
          fprintf_filtered (stream,
                            _("array (?) of ? (<mal-formed descriptor>)"));
                            _("array (?) of ? (<mal-formed descriptor>)"));
        else
        else
          print_record_type (type, stream, show, level);
          print_record_type (type, stream, show, level);
        break;
        break;
      case TYPE_CODE_UNION:
      case TYPE_CODE_UNION:
        print_unchecked_union_type (type, stream, show, level);
        print_unchecked_union_type (type, stream, show, level);
        break;
        break;
      case TYPE_CODE_FUNC:
      case TYPE_CODE_FUNC:
        print_func_type (type, stream, varstring);
        print_func_type (type, stream, varstring);
        break;
        break;
      }
      }
}
}
 
 

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.