/usr/src/gnu/usr.bin/binutils/gdb/ada-typeprint.c

Bug Summary

File:	src/gnu/usr.bin/binutils/gdb/ada-typeprint.c
Warning:	line 241, column 3 Null pointer passed as 1st argument to string copy function

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple amd64-unknown-openbsd7.0 -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name ada-typeprint.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 1 -pic-is-pie -mframe-pointer=all -relaxed-aliasing -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -target-feature +retpoline-indirect-calls -target-feature +retpoline-indirect-branches -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/gnu/usr.bin/binutils/obj/gdb -resource-dir /usr/local/lib/clang/13.0.0 -D PIE_DEFAULT=1 -I . -I /usr/src/gnu/usr.bin/binutils/gdb -I /usr/src/gnu/usr.bin/binutils/gdb/config -D LOCALEDIR="/usr/share/locale" -D HAVE_CONFIG_H -I /usr/src/gnu/usr.bin/binutils/gdb/../include/opcode -I ../bfd -I /usr/src/gnu/usr.bin/binutils/gdb/../bfd -I /usr/src/gnu/usr.bin/binutils/gdb/../include -I ../intl -I /usr/src/gnu/usr.bin/binutils/gdb/../intl -D MI_OUT=1 -D TUI=1 -internal-isystem /usr/local/lib/clang/13.0.0/include -internal-externc-isystem /usr/include -O2 -fdebug-compilation-dir=/usr/src/gnu/usr.bin/binutils/obj/gdb -ferror-limit 19 -fwrapv -D_RET_PROTECTOR -ret-protector -fgnuc-version=4.2.1 -fcommon -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /home/ben/Projects/vmm/scan-build/2022-01-12-194120-40624-1 -x c /usr/src/gnu/usr.bin/binutils/gdb/ada-typeprint.c

1/* Support for printing Ada types for GDB, the GNU debugger.
 Copyright 1986, 1988, 1989, 1991, 1997, 1998, 1999, 2000, 
 2001, 2002, 2003, 2004 Free Software Foundation, Inc.

5This file is part of GDB.

7This program is free software; you can redistribute it and/or modify
8it under the terms of the GNU General Public License as published by
9the Free Software Foundation; either version 2 of the License, or
10(at your option) any later version.

12This program is distributed in the hope that it will be useful,
13but WITHOUT ANY WARRANTY; without even the implied warranty of
14MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15GNU General Public License for more details.

17You should have received a copy of the GNU General Public License
18along with this program; if not, write to the Free Software
19Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */

21#include "defs.h"
22#include "gdb_obstack.h"
23#include "bfd.h"		/* Binary File Description */
24#include "symtab.h"
25#include "gdbtypes.h"
26#include "expression.h"
27#include "value.h"
28#include "gdbcore.h"
29#include "target.h"
30#include "command.h"
31#include "gdbcmd.h"
32#include "language.h"
33#include "demangle.h"
34#include "c-lang.h"
35#include "typeprint.h"
36#include "ada-lang.h"

38#include <ctype.h>
39#include "gdb_string.h"
40#include <errno(*__errno()).h>

42static int print_record_field_types (struct type *, struct type *,
		     struct ui_file *, int, int);

45static void print_array_type (struct type *, struct ui_file *, int, int);

47static void print_choices (struct type *, int, struct ui_file *,
	   struct type *);

50static void print_range (struct type *, struct ui_file *);

52static void print_range_bound (struct type *, char *, int *,
	       struct ui_file *);

55static void
56print_dynamic_range_bound (struct type *, const char *, int,
	   const char *, struct ui_file *);

59static void print_range_type_named (char *, struct ui_file *);
60


63static char *name_buffer;
64static int name_buffer_len;

66/* The (decoded) Ada name of TYPE.  This value persists until the
 next call.  */

69static char *
70decoded_type_name (struct type *type)
71{
if (ada_type_name (type) == NULL((void*)0))
  return NULL((void*)0);
else
  {
    char *raw_name = ada_type_name (type);
    char *s, *q;

    if (name_buffer == NULL((void*)0) || name_buffer_len <= strlen (raw_name))
{
 name_buffer_len = 16 + 2 * strlen (raw_name);
 name_buffer = xrealloc (name_buffer, name_buffer_len);
}
    strcpy (name_buffer, raw_name);

    s = (char *) strstr (name_buffer, "___");
    if (s != NULL((void*)0))
*s = '\0';

    s = name_buffer + strlen (name_buffer) - 1;
    while (s > name_buffer && (s[0] != '_' || s[-1] != '_'))
s -= 1;

    if (s == name_buffer)
return name_buffer;

    if (!islower (s[1]))
return NULL((void*)0);

    for (s = q = name_buffer; *s != '\0'; q += 1)
{
 if (s[0] == '_' && s[1] == '_')
   {
     *q = '.';
     s += 2;
   }
 else
   {
     *q = *s;
     s += 1;
   }
}
    *q = '\0';
    return name_buffer;
  }
116}


119/* Print a description of a type in the format of a
 typedef for the current language.
 NEW is the new name for a type TYPE.  */

123void
124ada_typedef_print (struct type *type, struct symbol *new,
   struct ui_file *stream)
126{
fprintf_filtered (stream, "type %.*s is ",
    ada_name_prefix_len (SYMBOL_PRINT_NAME (new)(demangle ? (symbol_natural_name (&(new)->ginfo)) : (new
)->ginfo.name)),
    SYMBOL_PRINT_NAME (new)(demangle ? (symbol_natural_name (&(new)->ginfo)) : (new
)->ginfo.name));
type_print (type, "", stream, 1);
131}

133/* Print range type TYPE on STREAM.  */

135static void
136print_range (struct type *type, struct ui_file *stream)
137{
struct type *target_type;
target_type = TYPE_TARGET_TYPE (type)(type)->main_type->target_type;
if (target_type == NULL((void*)0))
  target_type = type;

switch (TYPE_CODE (target_type)(target_type)->main_type->code)
  {
  case TYPE_CODE_RANGE:
  case TYPE_CODE_INT:
  case TYPE_CODE_BOOL:
  case TYPE_CODE_CHAR:
  case TYPE_CODE_ENUM:
    break;
  default:
    target_type = builtin_type_int;
    break;
  }

if (TYPE_NFIELDS (type)(type)->main_type->nfields < 2)
  {
    /* A range needs at least 2 bounds to be printed.  If there are less
       than 2, just print the type name instead of the range itself.
       This check handles cases such as characters, for example.

       Note that if the name is not defined, then we don't print anything.
     */
    fprintf_filtered (stream, "%.*s",
	ada_name_prefix_len (TYPE_NAME (type)(type)->main_type->name),
	TYPE_NAME (type)(type)->main_type->name);
  }
else
  {
    /* We extract the range type bounds respectively from the first element
       and the last element of the type->fields array */
    const LONGESTlong lower_bound = (LONGESTlong) TYPE_LOW_BOUND (type)(((type)->main_type->fields[0]).loc.bitpos);
    const LONGESTlong upper_bound =
(LONGESTlong) TYPE_FIELD_BITPOS (type, TYPE_NFIELDS (type) - 1)(((type)->main_type->fields[(type)->main_type->nfields
 - 1]).loc.bitpos);

    ada_print_scalar (target_type, lower_bound, stream);
    fprintf_filtered (stream, " .. ");
    ada_print_scalar (target_type, upper_bound, stream);
  }
180}

182/* Print the number or discriminant bound at BOUNDS+*N on STREAM, and
 set *N past the bound and its delimiter, if any.  */

185static void
186print_range_bound (struct type *type, char *bounds, int *n,
   struct ui_file *stream)
188{
LONGESTlong B;
if (ada_scan_number (bounds, *n, &B, n))
  {
    /* STABS decodes all range types which bounds are 0 .. -1 as
       unsigned integers (ie. the type code is TYPE_CODE_INT, not
       TYPE_CODE_RANGE).  Unfortunately, ada_print_scalar() relies
       on the unsigned flag to determine whether the bound should
       be printed as a signed or an unsigned value.  This causes
       the upper bound of the 0 .. -1 range types to be printed as
       a very large unsigned number instead of -1.
       To workaround this stabs deficiency, we replace the TYPE by
       builtin_type_long when we detect that the bound is negative,
       and the type is a TYPE_CODE_INT.  The bound is negative when
       'm' is the last character of the number scanned in BOUNDS.  */
    if (bounds[*n - 1] == 'm' && TYPE_CODE (type)(type)->main_type->code == TYPE_CODE_INT)
type = builtin_type_long;
    ada_print_scalar (type, B, stream);
    if (bounds[*n] == '_')
*n += 2;
  }
else
  {
    int bound_len;
    char *bound = bounds + *n;
    char *pend;

    pend = strstr (bound, "__");
    if (pend == NULL((void*)0))
*n += bound_len = strlen (bound);
    else
{
 bound_len = pend - bound;
 *n += bound_len + 2;
}
    fprintf_filtered (stream, "%.*s", bound_len, bound);
  }
225}

227/* 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
 "___U") according to the ___XD conventions.  */

231static void
232print_dynamic_range_bound (struct type *type, const char *name, int name_len,
	   const char *suffix, struct ui_file *stream)
234{
static char *name_buf = NULL((void*)0);
22
←
'name_buf' initialized to a null pointer value→
static size_t name_buf_len = 0;
LONGESTlong B;
int OK;

GROW_VECT (name_buf, name_buf_len, name_len + strlen (suffix) + 1)if ((name_buf_len) < (name_len + strlen (suffix) + 1)) grow_vect
 ((void**) &(name_buf), &(name_buf_len), (name_len + strlen
 (suffix) + 1), sizeof(*(name_buf)));;
23
←
Assuming the condition is false→
24
←
Taking false branch→
strncpy (name_buf, name, name_len);
25
←
Null pointer passed as 1st argument to string copy function
strcpy (name_buf + name_len, suffix);

B = get_int_var_value (name_buf, &OK);
if (OK)
  ada_print_scalar (type, B, stream);
else
  fprintf_filtered (stream, "?");
249}

251/* Print the range type named NAME.  */

253static void
254print_range_type_named (char *name, struct ui_file *stream)
255{
struct type *raw_type = ada_find_any_type (name);
struct type *base_type;
char *subtype_info;

if (raw_type == NULL((void*)0))
15
←
Assuming 'raw_type' is equal to NULL→
16
←
Taking true branch→
  base_type = builtin_type_int;
else if (TYPE_CODE (raw_type)(raw_type)->main_type->code == TYPE_CODE_RANGE)
  base_type = TYPE_TARGET_TYPE (raw_type)(raw_type)->main_type->target_type;
else
  base_type = raw_type;

subtype_info = strstr (name, "___XD");
if (subtype_info == NULL((void*)0) && raw_type == NULL((void*)0))
17
←
Assuming 'subtype_info' is not equal to NULL→
  fprintf_filtered (stream, "? .. ?");
else if (subtype_info17.1
'subtype_info' is not equal to NULL
 == NULL((void*)0))
18
←
Taking false branch→
  print_range (raw_type, stream);
else
  {
    int prefix_len = subtype_info - name;
    char *bounds_str;
    int n;

    subtype_info += 5;
    bounds_str = strchr (subtype_info, '_');
    n = 1;

    if (*subtype_info == 'L')
19
←
Assuming the condition is false→
20
←
Taking false branch→
{
 print_range_bound (base_type, bounds_str, &n, stream);
 subtype_info += 1;
}
    else
print_dynamic_range_bound (base_type, name, prefix_len, "___L",
21
←
Calling 'print_dynamic_range_bound'→
		   stream);

    fprintf_filtered (stream, " .. ");

    if (*subtype_info == 'U')
print_range_bound (base_type, bounds_str, &n, stream);
    else
print_dynamic_range_bound (base_type, name, prefix_len, "___U",
		   stream);
  }
299}

301/* Print enumerated type TYPE on STREAM.  */

303static void
304print_enum_type (struct type *type, struct ui_file *stream)
305{
int len = TYPE_NFIELDS (type)(type)->main_type->nfields;
int i, lastval;

fprintf_filtered (stream, "(");
wrap_here (" ");

lastval = 0;
for (i = 0; i < len; i++)
  {
    QUIT{ if (quit_flag) quit (); if (deprecated_interactive_hook) deprecated_interactive_hook
 (); };
    if (i)
fprintf_filtered (stream, ", ");
    wrap_here ("    ");
    fputs_filtered (ada_enum_name (TYPE_FIELD_NAME (type, i)(((type)->main_type->fields[i]).name)), stream);
    if (lastval != TYPE_FIELD_BITPOS (type, i)(((type)->main_type->fields[i]).loc.bitpos))
{
 fprintf_filtered (stream, " => %d", TYPE_FIELD_BITPOS (type, i)(((type)->main_type->fields[i]).loc.bitpos));
 lastval = TYPE_FIELD_BITPOS (type, i)(((type)->main_type->fields[i]).loc.bitpos);
}
    lastval += 1;
  }
fprintf_filtered (stream, ")");
328}

330/* Print representation of Ada fixed-point type TYPE on STREAM.  */

332static void
333print_fixed_point_type (struct type *type, struct ui_file *stream)
334{
DOUBLEST delta = ada_delta (type);
DOUBLEST small = ada_fixed_to_float (type, 1.0);

if (delta < 0.0)
  fprintf_filtered (stream, "delta ??");
else
  {
    fprintf_filtered (stream, "delta %g", (double) delta);
    if (delta != small)
fprintf_filtered (stream, " <'small = %g>", (double) small);
  }
346}

348/* Print representation of special VAX floating-point type TYPE on STREAM.  */

350static void
351print_vax_floating_point_type (struct type *type, struct ui_file *stream)
352{
fprintf_filtered (stream, "<float format %c>",
    ada_vax_float_type_suffix (type));
355}

357/* Print simple (constrained) array type TYPE on STREAM.  LEVEL is the
 recursion (indentation) 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).  */

362static void
363print_array_type (struct type *type, struct ui_file *stream, int show,
  int level)
365{
int bitsize;
int n_indices;

bitsize = 0;
fprintf_filtered (stream, "array (");

n_indices = -1;
if (show < 0)
1
Assuming 'show' is >= 0→
2
←
Taking false branch→
  fprintf_filtered (stream, "...");
else
  {
    if (ada_is_packed_array_type (type))
3
←
Assuming the condition is false→
4
←
Taking false branch→
type = ada_coerce_to_simple_array_type (type);
    if (type == NULL((void*)0))
5
←
Assuming 'type' is not equal to NULL→
6
←
Taking false branch→
      {
        fprintf_filtered (stream, "<undecipherable array type>");
        return;
      }
    if (ada_is_simple_array_type (type))
7
←
Assuming the condition is true→
8
←
Taking true branch→
{
 struct type *range_desc_type =
   ada_find_parallel_type (type, "___XA");
 struct type *arr_type;

 bitsize = 0;
 if (range_desc_type == NULL((void*)0))
9
←
Assuming 'range_desc_type' is not equal to NULL→
10
←
Taking false branch→
   {
     for (arr_type = type; TYPE_CODE (arr_type)(arr_type)->main_type->code == TYPE_CODE_ARRAY;
   arr_type = TYPE_TARGET_TYPE (arr_type)(arr_type)->main_type->target_type)
{
  if (arr_type != type)
    fprintf_filtered (stream, ", ");
  print_range (TYPE_INDEX_TYPE (arr_type)(((arr_type)->main_type->fields[0]).type), stream);
  if (TYPE_FIELD_BITSIZE (arr_type, 0)(((arr_type)->main_type->fields[0]).bitsize) > 0)
    bitsize = TYPE_FIELD_BITSIZE (arr_type, 0)(((arr_type)->main_type->fields[0]).bitsize);
}
   }
 else
   {
     int k;
     n_indices = TYPE_NFIELDS (range_desc_type)(range_desc_type)->main_type->nfields;
     for (k = 0, arr_type = type;
12
←
Loop condition is true.  Entering loop body→
   k < n_indices;
11
←
Assuming 'k' is < 'n_indices'→
   k += 1, arr_type = TYPE_TARGET_TYPE (arr_type)(arr_type)->main_type->target_type)
{
  if (k12.1
'k' is <= 0
 > 0)
13
←
Taking false branch→
    fprintf_filtered (stream, ", ");
  print_range_type_named (TYPE_FIELD_NAME(((range_desc_type)->main_type->fields[k]).name)
14
←
Calling 'print_range_type_named'→
			  (range_desc_type, k)(((range_desc_type)->main_type->fields[k]).name), stream);
  if (TYPE_FIELD_BITSIZE (arr_type, 0)(((arr_type)->main_type->fields[0]).bitsize) > 0)
    bitsize = TYPE_FIELD_BITSIZE (arr_type, 0)(((arr_type)->main_type->fields[0]).bitsize);
}
   }
}
    else
{
 int i, i0;
 for (i = i0 = ada_array_arity (type); i > 0; i -= 1)
   fprintf_filtered (stream, "%s<>", i == i0 ? "" : ", ");
}
  }

fprintf_filtered (stream, ") of ");
wrap_here ("");
ada_print_type (ada_array_element_type (type, n_indices), "", stream,
  show == 0 ? 0 : show - 1, level + 1);
if (bitsize > 0)
  fprintf_filtered (stream, " <packed: %d-bit elements>", bitsize);
434}

436/* Print the choices encoded by field FIELD_NUM of variant-part TYPE on
 STREAM, assuming the VAL_TYPE is the type of the values.  */

439static void
440print_choices (struct type *type, int field_num, struct ui_file *stream,
      struct type *val_type)
442{
int have_output;
int p;
const char *name = TYPE_FIELD_NAME (type, field_num)(((type)->main_type->fields[field_num]).name);

have_output = 0;

/* Skip over leading 'V': NOTE soon to be obsolete.  */
if (name[0] == 'V')
  {
    if (!ada_scan_number (name, 1, NULL((void*)0), &p))
goto Huh;
  }
else
  p = 0;

while (1)
  {
    switch (name[p])
{
default:
 return;
case 'S':
case 'R':
case 'O':
 if (have_output)
   fprintf_filtered (stream, " | ");
 have_output = 1;
 break;
}

    switch (name[p])
{
case 'S':
 {
   LONGESTlong W;
   if (!ada_scan_number (name, p + 1, &W, &p))
     goto Huh;
   ada_print_scalar (val_type, W, stream);
   break;
 }
case 'R':
 {
   LONGESTlong L, U;
   if (!ada_scan_number (name, p + 1, &L, &p)
|| name[p] != 'T' || !ada_scan_number (name, p + 1, &U, &p))
     goto Huh;
   ada_print_scalar (val_type, L, stream);
   fprintf_filtered (stream, " .. ");
   ada_print_scalar (val_type, U, stream);
   break;
 }
case 'O':
 fprintf_filtered (stream, "others");
 p += 1;
 break;
}
  }

501Huh:
fprintf_filtered (stream, "??");

504}

506/* Assuming that field FIELD_NUM of TYPE is a VARIANTS field whose
 discriminant is contained in OUTER_TYPE, print its variants on STREAM.
 LEVEL is the recursion
 (indentation) level, in case any 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 purpose, fields nested in a
 variant part are taken to be at the same level as the fields
 immediately outside the variant part.  */

515static void
516print_variant_clauses (struct type *type, int field_num,
       struct type *outer_type, struct ui_file *stream,
       int show, int level)
519{
int i;
struct type *var_type, *par_type;
struct type *discr_type;

var_type = TYPE_FIELD_TYPE (type, field_num)(((type)->main_type->fields[field_num]).type);
discr_type = ada_variant_discrim_type (var_type, outer_type);

if (TYPE_CODE (var_type)(var_type)->main_type->code == TYPE_CODE_PTR)
  {
    var_type = TYPE_TARGET_TYPE (var_type)(var_type)->main_type->target_type;
    if (var_type == NULL((void*)0) || TYPE_CODE (var_type)(var_type)->main_type->code != TYPE_CODE_UNION)
return;
  }

par_type = ada_find_parallel_type (var_type, "___XVU");
if (par_type != NULL((void*)0))
  var_type = par_type;

for (i = 0; i < TYPE_NFIELDS (var_type)(var_type)->main_type->nfields; i += 1)
  {
    fprintf_filtered (stream, "\n%*swhen ", level + 4, "");
    print_choices (var_type, i, stream, discr_type);
    fprintf_filtered (stream, " =>");
    if (print_record_field_types (TYPE_FIELD_TYPE (var_type, i)(((var_type)->main_type->fields[i]).type),
		    outer_type, stream, show, level + 4) <= 0)
fprintf_filtered (stream, " null;");
  }
547}

549/* Assuming that field FIELD_NUM of TYPE is a variant part whose
 discriminants are contained in OUTER_TYPE, print a description of it
 on STREAM.  LEVEL is the recursion (indentation) level, in case any 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
 purpose, fields nested in a variant part are taken to be at the same
 level as the fields immediately outside the variant part.  */

557static void
558print_variant_part (struct type *type, int field_num, struct type *outer_type,
    struct ui_file *stream, int show, int level)
560{
fprintf_filtered (stream, "\n%*scase %s is", level + 4, "",
    ada_variant_discrim_name
    (TYPE_FIELD_TYPE (type, field_num)(((type)->main_type->fields[field_num]).type)));
print_variant_clauses (type, field_num, outer_type, stream, show,
	 level + 4);
fprintf_filtered (stream, "\n%*send case;", level + 4, "");
567}

569/* Print a description on STREAM of the fields in record type TYPE, whose
 discriminants are in OUTER_TYPE.  LEVEL is the recursion (indentation)
 level, in case any of the fields themselves have nested structure,
 and SHOW is the number of levels of internal structure to show
 (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.
 Prints each field beginning on a new line, but does not put a new line at
 end.  */

578static int
579print_record_field_types (struct type *type, struct type *outer_type,
	  struct ui_file *stream, int show, int level)
581{
int len, i, flds;

flds = 0;
len = TYPE_NFIELDS (type)(type)->main_type->nfields;

if (len == 0 && (TYPE_FLAGS (type)(type)->main_type->flags & TYPE_FLAG_STUB(1 << 2)) != 0)
  return -1;

for (i = 0; i < len; i += 1)
  {
    QUIT{ if (quit_flag) quit (); if (deprecated_interactive_hook) deprecated_interactive_hook
 (); };

    if (ada_is_parent_field (type, i) || ada_is_ignored_field (type, i))
;
    else if (ada_is_wrapper_field (type, i))
flds += print_record_field_types (TYPE_FIELD_TYPE (type, i)(((type)->main_type->fields[i]).type), type,
			  stream, show, level);
    else if (ada_is_variant_part (type, i))
{
 print_variant_part (type, i, outer_type, stream, show, level);
 flds = 1;
}
    else
{
 flds += 1;
 fprintf_filtered (stream, "\n%*s", level + 4, "");
 ada_print_type (TYPE_FIELD_TYPE (type, i)(((type)->main_type->fields[i]).type),
	  TYPE_FIELD_NAME (type, i)(((type)->main_type->fields[i]).name),
	  stream, show - 1, level + 4);
 fprintf_filtered (stream, ";");
}
  }

return flds;
616}

618/* Print record type TYPE on STREAM.  LEVEL is the recursion (indentation)
 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).  */

622static void
623print_record_type (struct type *type0, struct ui_file *stream, int show,
   int level)
625{
struct type *parent_type;
struct type *type;

type = ada_find_parallel_type (type0, "___XVE");
if (type == NULL((void*)0))
  type = type0;

parent_type = ada_parent_type (type);
if (ada_type_name (parent_type) != NULL((void*)0))
  fprintf_filtered (stream, "new %s with ",
      decoded_type_name (parent_type));
else if (parent_type == NULL((void*)0) && ada_is_tagged_type (type, 0))
  fprintf_filtered (stream, "tagged ");

fprintf_filtered (stream, "record");

if (show < 0)
  fprintf_filtered (stream, " ... end record");
else
  {
    int flds;

    flds = 0;
    if (parent_type != NULL((void*)0) && ada_type_name (parent_type) == NULL((void*)0))
flds += print_record_field_types (parent_type, parent_type,
			  stream, show, level);
    flds += print_record_field_types (type, type, stream, show, level);

    if (flds > 0)
fprintf_filtered (stream, "\n%*send record", level, "");
    else if (flds < 0)
fprintf_filtered (stream, " <incomplete type> end record");
    else
fprintf_filtered (stream, " null; end record");
  }
661}

663/* Print the unchecked union type TYPE in something resembling Ada
 format on STREAM.  LEVEL is the recursion (indentation) 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).  */
667static void
668print_unchecked_union_type (struct type *type, struct ui_file *stream,
	    int show, int level)
670{
fprintf_filtered (stream, "record (?) is");

if (show < 0)
  fprintf_filtered (stream, " ... end record");
else if (TYPE_NFIELDS (type)(type)->main_type->nfields == 0)
  fprintf_filtered (stream, " null; end record");
else
  {
    int i;

    fprintf_filtered (stream, "\n%*scase ? is", level + 4, "");

    for (i = 0; i < TYPE_NFIELDS (type)(type)->main_type->nfields; i += 1)
{
 fprintf_filtered (stream, "\n%*swhen ? =>\n%*s", level + 8, "",
	    level + 12, "");
 ada_print_type (TYPE_FIELD_TYPE (type, i)(((type)->main_type->fields[i]).type),
	  TYPE_FIELD_NAME (type, i)(((type)->main_type->fields[i]).name),
	  stream, show - 1, level + 12);
 fprintf_filtered (stream, ";");
}

    fprintf_filtered (stream, "\n%*send case;\n%*send record",
	level + 4, "", level, "");
  }
696}



700/* Print function or procedure type TYPE on STREAM.  Make it a header
 for function or procedure NAME if NAME is not null.  */

703static void
704print_func_type (struct type *type, struct ui_file *stream, char *name)
705{
int i, len = TYPE_NFIELDS (type)(type)->main_type->nfields;

if (TYPE_CODE (TYPE_TARGET_TYPE (type))((type)->main_type->target_type)->main_type->code == TYPE_CODE_VOID)
  fprintf_filtered (stream, "procedure");
else
  fprintf_filtered (stream, "function");

if (name != NULL((void*)0) && name[0] != '\0')
  fprintf_filtered (stream, " %s", name);

if (len > 0)
  {
    fprintf_filtered (stream, " (");
    for (i = 0; i < len; i += 1)
{
 if (i > 0)
   {
     fputs_filtered ("; ", stream);
     wrap_here ("    ");
   }
 fprintf_filtered (stream, "a%d: ", i + 1);
 ada_print_type (TYPE_FIELD_TYPE (type, i)(((type)->main_type->fields[i]).type), "", stream, -1, 0);
}
    fprintf_filtered (stream, ")");
  }

if (TYPE_CODE (TYPE_TARGET_TYPE (type))((type)->main_type->target_type)->main_type->code != TYPE_CODE_VOID)
  {
    fprintf_filtered (stream, " return ");
    ada_print_type (TYPE_TARGET_TYPE (type)(type)->main_type->target_type, "", stream, 0, 0);
  }
737}


740/* Print a description of a type TYPE0.
 Output goes to STREAM (via stdio).
 If VARSTRING is a non-empty string, print as an Ada variable/field
     declaration.
 SHOW+1 is the maximum number of levels of internal type structure
    to show (this applies to record types, enumerated types, and
    array types).
 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
    outer level).
 When SHOW<0, no inner structure is shown.
 LEVEL indicates level of recursion (for nested definitions).  */

753void
754ada_print_type (struct type *type0, char *varstring, struct ui_file *stream,
int show, int level)
756{
struct type *type = ada_check_typedef (ada_get_base_type (type0));
char *type_name = decoded_type_name (type);
int is_var_decl = (varstring != NULL((void*)0) && varstring[0] != '\0');

if (type == NULL((void*)0))
  {
    if (is_var_decl)
fprintf_filtered (stream, "%.*s: ",
	  ada_name_prefix_len (varstring), varstring);
    fprintf_filtered (stream, "<null type?>");
    return;
  }

if (show > 0)
  type = ada_check_typedef (type);

if (is_var_decl && TYPE_CODE (type)(type)->main_type->code != TYPE_CODE_FUNC)
  fprintf_filtered (stream, "%.*s: ",
      ada_name_prefix_len (varstring), varstring);

if (type_name != NULL((void*)0) && show <= 0)
  {
    fprintf_filtered (stream, "%.*s",
	ada_name_prefix_len (type_name), type_name);
    return;
  }

if (ada_is_aligner_type (type))
  ada_print_type (ada_aligned_type (type), "", stream, show, level);
else if (ada_is_packed_array_type (type))
  print_array_type (type, stream, show, level);
else
  switch (TYPE_CODE (type)(type)->main_type->code)
    {
    default:
fprintf_filtered (stream, "<");
c_print_type (type, "", stream, show, level);
fprintf_filtered (stream, ">");
break;
    case TYPE_CODE_PTR:
fprintf_filtered (stream, "access ");
ada_print_type (TYPE_TARGET_TYPE (type)(type)->main_type->target_type, "", stream, show, level);
break;
    case TYPE_CODE_REF:
fprintf_filtered (stream, "<ref> ");
ada_print_type (TYPE_TARGET_TYPE (type)(type)->main_type->target_type, "", stream, show, level);
break;
    case TYPE_CODE_ARRAY:
print_array_type (type, stream, show, level);
break;
    case TYPE_CODE_INT:
if (ada_is_fixed_point_type (type))
 print_fixed_point_type (type, stream);
else if (ada_is_vax_floating_type (type))
 print_vax_floating_point_type (type, stream);
else
 {
   char *name = ada_type_name (type);
   if (!ada_is_range_type_name (name))
     fprintf_filtered (stream, "<%d-byte integer>",
		TYPE_LENGTH (type)(type)->length);
   else
     {
fprintf_filtered (stream, "range ");
print_range_type_named (name, stream);
     }
 }
break;
    case TYPE_CODE_RANGE:
if (ada_is_fixed_point_type (type))
 print_fixed_point_type (type, stream);
else if (ada_is_vax_floating_type (type))
 print_vax_floating_point_type (type, stream);
else if (ada_is_modular_type (type))
 fprintf_filtered (stream, "mod %ld", (long) ada_modulus (type));
else
 {
   fprintf_filtered (stream, "range ");
   print_range (type, stream);
 }
break;
    case TYPE_CODE_FLT:
fprintf_filtered (stream, "<%d-byte float>", TYPE_LENGTH (type)(type)->length);
break;
    case TYPE_CODE_ENUM:
if (show < 0)
 fprintf_filtered (stream, "(...)");
else
 print_enum_type (type, stream);
break;
    case TYPE_CODE_STRUCT:
if (ada_is_array_descriptor_type (type))
 print_array_type (type, stream, show, level);
else if (ada_is_bogus_array_descriptor (type))
 fprintf_filtered (stream,
	    "array (?) of ? (<mal-formed descriptor>)");
else
 print_record_type (type, stream, show, level);
break;
    case TYPE_CODE_UNION:
print_unchecked_union_type (type, stream, show, level);
break;
    case TYPE_CODE_FUNC:
print_func_type (type, stream, varstring);
break;
    }
863}