/* prdbg.c -- Print out generic debugging information.

   Copyright (C) 1995-2026 Free Software Foundation, Inc.

   Written by Ian Lance Taylor <ian@cygnus.com>.

   Tags style generation written by Salvador E. Tropea <set@computer.org>.

   This file is part of GNU Binutils.

   This program is free software; you can redistribute it and/or modify

   it under the terms of the GNU General Public License as published by

   the Free Software Foundation; either version 3 of the License, or

   (at your option) any later version.

   This program is distributed in the hope that it will be useful,

   but WITHOUT ANY WARRANTY; without even the implied warranty of

   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License

   along with this program; if not, write to the Free Software

   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA

   02110-1301, USA.  */

/* This file prints out the generic debugging information, by

   supplying a set of routines to debug_write.  */

#include "sysdep.h"

#include <assert.h>

#include "bfd.h"

#include "libiberty.h"

#include "demangle.h"

#include "debug.h"

#include "budbg.h"

/* This is the structure we use as a handle for these routines.  */

struct pr_handle

{

  /* File to print information to.  */

  FILE *f;

  /* Current indentation level.  */

  unsigned int indent;

  /* Type stack.  */

  struct pr_stack *stack;

  /* Parameter number we are about to output.  */

  int parameter;

  /* The following are used only by the tags code (tg_).  */

  /* Name of the file we are using.  */

  char *filename;

  /* The BFD.  */

  bfd *abfd;

  /* The symbols table for this BFD.  */

  asymbol **syms;

  /* Pointer to a function to demangle symbols.  */

  char *(*demangler) (bfd *, const char *, int);

};

/* The type stack.  */

struct pr_stack

{

  /* Next element on the stack.  */

  struct pr_stack *next;

  /* This element.  */

  char *type;

  /* Current visibility of fields if this is a class.  */

  enum debug_visibility visibility;

  /* Name of the current method we are handling.  */

  char *method;

  /* The following are used only by the tags code (tg_).  */

  /* Type for the container (struct, union, class, union class).  */

  const char *flavor;

  /* A comma separated list of parent classes.  */

  char *parents;

};

static bool pr_start_compilation_unit (void *, const char *);

static bool pr_start_source (void *, const char *);

static bool pr_empty_type (void *);

static bool pr_void_type (void *);

static bool pr_int_type (void *, unsigned int, bool);

static bool pr_float_type (void *, unsigned int);

static bool pr_complex_type (void *, unsigned int);

static bool pr_bool_type (void *, unsigned int);

static bool pr_enum_type

  (void *, const char *, const char **, bfd_signed_vma *);

static bool pr_pointer_type (void *);

static bool pr_function_type (void *, int, bool);

static bool pr_reference_type (void *);

static bool pr_range_type (void *, bfd_signed_vma, bfd_signed_vma);

static bool pr_array_type (void *, bfd_signed_vma, bfd_signed_vma, bool);

static bool pr_set_type (void *, bool);

static bool pr_offset_type (void *);

static bool pr_method_type (void *, bool, int, bool);

static bool pr_const_type (void *);

static bool pr_volatile_type (void *);

static bool pr_start_struct_type

  (void *, const char *, unsigned int, bool, unsigned int);

static bool pr_struct_field

  (void *, const char *, bfd_vma, bfd_vma, enum debug_visibility);

static bool pr_end_struct_type (void *);

static bool pr_start_class_type

  (void *, const char *, unsigned int, bool, unsigned int, bool, bool);

static bool pr_class_static_member

  (void *, const char *, const char *, enum debug_visibility);

static bool pr_class_baseclass

  (void *, bfd_vma, bool, enum debug_visibility);

static bool pr_class_start_method (void *, const char *);

static bool pr_class_method_variant

  (void *, const char *, enum debug_visibility, bool, bool, bfd_vma, bool);

static bool pr_class_static_method_variant

  (void *, const char *, enum debug_visibility, bool, bool);

static bool pr_class_end_method (void *);

static bool pr_end_class_type (void *);

static bool pr_typedef_type (void *, const char *);

static bool pr_tag_type

  (void *, const char *, unsigned int, enum debug_type_kind);

static bool pr_typdef (void *, const char *);

static bool pr_tag (void *, const char *);

static bool pr_int_constant (void *, const char *, bfd_vma);

static bool pr_float_constant (void *, const char *, double);

static bool pr_typed_constant (void *, const char *, bfd_vma);

static bool pr_variable (void *, const char *, enum debug_var_kind, bfd_vma);

static bool pr_start_function (void *, const char *, bool);

static bool pr_function_parameter

  (void *, const char *, enum debug_parm_kind, bfd_vma);

static bool pr_start_block (void *, bfd_vma);

static bool pr_end_block (void *, bfd_vma);

static bool pr_end_function (void *);

static bool pr_lineno (void *, const char *, unsigned long, bfd_vma);

static const char *visibility_name (enum debug_visibility);

/* Tags style replacements.  */

static bool tg_start_compilation_unit (void *, const char *);

static bool tg_start_source (void *, const char *);

static bool tg_enum_type

  (void *, const char *, const char **, bfd_signed_vma *);

static bool tg_start_struct_type

  (void *, const char *, unsigned int, bool, unsigned int);

static bool pr_struct_field

  (void *, const char *, bfd_vma, bfd_vma, enum debug_visibility);

static bool tg_struct_field

  (void *, const char *, bfd_vma, bfd_vma, enum debug_visibility);

static bool tg_struct_field

  (void *, const char *, bfd_vma, bfd_vma, enum debug_visibility);

static bool tg_end_struct_type (void *);

static bool tg_start_class_type

  (void *, const char *, unsigned int, bool, unsigned int, bool, bool);

static bool tg_class_static_member

  (void *, const char *, const char *, enum debug_visibility);

static bool tg_class_baseclass (void *, bfd_vma, bool, enum debug_visibility);

static bool tg_class_method_variant

  (void *, const char *, enum debug_visibility, bool, bool, bfd_vma, bool);

static bool tg_class_static_method_variant

  (void *, const char *, enum debug_visibility, bool, bool);

static bool tg_end_class_type (void *);

static bool tg_tag_type

  (void *, const char *, unsigned int, enum debug_type_kind);

static bool tg_typdef (void *, const char *);

static bool tg_tag (void *, const char *);

static bool tg_int_constant (void *, const char *, bfd_vma);

static bool tg_float_constant (void *, const char *, double);

static bool tg_typed_constant (void *, const char *, bfd_vma);

static bool tg_variable (void *, const char *, enum debug_var_kind, bfd_vma);

static bool tg_start_function (void *, const char *, bool);

static bool tg_function_parameter

  (void *, const char *, enum debug_parm_kind, bfd_vma);

static bool tg_start_block (void *, bfd_vma);

static bool tg_end_block (void *, bfd_vma);

static bool tg_lineno (void *, const char *, unsigned long, bfd_vma);

static const struct debug_write_fns pr_fns =

{

  pr_start_compilation_unit,

  pr_start_source,

  pr_empty_type,

  pr_void_type,

  pr_int_type,

  pr_float_type,

  pr_complex_type,

  pr_bool_type,

  pr_enum_type,

  pr_pointer_type,

  pr_function_type,

  pr_reference_type,

  pr_range_type,

  pr_array_type,

  pr_set_type,

  pr_offset_type,

  pr_method_type,

  pr_const_type,

  pr_volatile_type,

  pr_start_struct_type,

  pr_struct_field,

  pr_end_struct_type,

  pr_start_class_type,

  pr_class_static_member,

  pr_class_baseclass,

  pr_class_start_method,

  pr_class_method_variant,

  pr_class_static_method_variant,

  pr_class_end_method,

  pr_end_class_type,

  pr_typedef_type,

  pr_tag_type,

  pr_typdef,

  pr_tag,

  pr_int_constant,

  pr_float_constant,

  pr_typed_constant,

  pr_variable,

  pr_start_function,

  pr_function_parameter,

  pr_start_block,

  pr_end_block,

  pr_end_function,

  pr_lineno

};

static const struct debug_write_fns tg_fns =

{

  tg_start_compilation_unit,

  tg_start_source,

  pr_empty_type,    /* Same, push_type.  */

  pr_void_type,     /* Same, push_type.  */

  pr_int_type,      /* Same, push_type.  */

  pr_float_type,    /* Same, push_type.  */

  pr_complex_type,    /* Same, push_type.  */

  pr_bool_type,     /* Same, push_type.  */

  tg_enum_type,

  pr_pointer_type,    /* Same, changes to pointer.  */

  pr_function_type,   /* Same, push_type.  */

  pr_reference_type,    /* Same, changes to reference.  */

  pr_range_type,    /* FIXME: What's that?.  */

  pr_array_type,    /* Same, push_type.  */

  pr_set_type,      /* FIXME: What's that?.  */

  pr_offset_type,   /* FIXME: What's that?.  */

  pr_method_type,   /* Same.  */

  pr_const_type,    /* Same, changes to const.  */

  pr_volatile_type,   /* Same, changes to volatile.  */

  tg_start_struct_type,

  tg_struct_field,

  tg_end_struct_type,

  tg_start_class_type,

  tg_class_static_member,

  tg_class_baseclass,

  pr_class_start_method,  /* Same, remembers that's a method.  */

  tg_class_method_variant,

  tg_class_static_method_variant,

  pr_class_end_method,    /* Same, forgets that's a method.  */

  tg_end_class_type,

  pr_typedef_type,    /* Same, just push type.  */

  tg_tag_type,

  tg_typdef,

  tg_tag,

  tg_int_constant,    /* Untested.  */

  tg_float_constant,    /* Untested.  */

  tg_typed_constant,    /* Untested.  */

  tg_variable,

  tg_start_function,

  tg_function_parameter,

  tg_start_block,

  tg_end_block,

  pr_end_function,    /* Same, does nothing.  */

  tg_lineno

};

static int demangle_flags = DMGL_ANSI | DMGL_PARAMS;

/* Print out the generic debugging information recorded in dhandle.  */

bool

print_debugging_info (FILE *f, void *dhandle, bfd *abfd, asymbol **syms,

          char * (*demangler) (struct bfd *, const char *, int),

          bool as_tags)

{

  struct pr_handle info;

  info.f = f;

  info.indent = 0;

  info.stack = NULL;

  info.parameter = 0;

  info.filename = NULL;

  info.abfd = abfd;

  info.syms = syms;

  info.demangler = demangler;

  if (as_tags)

    {

      fputs ("!_TAG_FILE_FORMAT\t2\t/extended format/\n", f);

      fputs ("!_TAG_FILE_SORTED\t0\t/0=unsorted, 1=sorted/\n", f);

      fputs ("!_TAG_PROGRAM_AUTHOR\tIan Lance Taylor, Salvador E. Tropea and others\t//\n", f);

      fputs ("!_TAG_PROGRAM_NAME\tobjdump\t/From GNU binutils/\n", f);

    }

  bool ret = debug_write (dhandle, as_tags ? &tg_fns : &pr_fns, &info);

  while (info.stack != NULL)

    {

      struct pr_stack *s = info.stack;

      info.stack = s->next;

      free (s->type);

      free (s->method);

      free (s->parents);

      free (s);

    }

  free (info.filename);

  return ret;

}

/* Indent to the current indentation level.  */

static void

indent (struct pr_handle *info)

{

  unsigned int i;

  for (i = 0; i < info->indent; i++)

    putc (' ', info->f);

}

/* Push a type on the type stack.  */

static bool

push_type (struct pr_handle *info, const char *type)

{

  struct pr_stack *n;

  if (type == NULL)

    return false;

  n = xmalloc (sizeof *n);

  memset (n, 0, sizeof *n);

  n->type = xstrdup (type);

  n->visibility = DEBUG_VISIBILITY_IGNORE;

  n->method = NULL;

  n->next = info->stack;

  info->stack = n;

  return true;

}

/* Prepend a string onto the type on the top of the type stack.  */

static bool

prepend_type (struct pr_handle *info, const char *s)

{

  char *n;

  assert (info->stack != NULL);

  n = xmalloc (strlen (s) + strlen (info->stack->type) + 1);

  sprintf (n, "%s%s", s, info->stack->type);

  free (info->stack->type);

  info->stack->type = n;

  return true;

}

/* Append a string to the type on the top of the type stack.  */

static bool

append_type (struct pr_handle *info, const char *s)

{

  unsigned int len;

  if (s == NULL)

    return false;

  assert (info->stack != NULL);

  len = strlen (info->stack->type);

  info->stack->type = xrealloc (info->stack->type, len + strlen (s) + 1);

  strcpy (info->stack->type + len, s);

  return true;

}

/* Append a string to the parents on the top of the type stack.  */

static bool

append_parent (struct pr_handle *info, const char *s)

{

  unsigned int len;

  if (s == NULL)

    return false;

  assert (info->stack != NULL);

  len = info->stack->parents ? strlen (info->stack->parents) : 0;

  info->stack->parents = xrealloc (info->stack->parents, len + strlen (s) + 1);

  strcpy (info->stack->parents + len, s);

  return true;

}

/* We use an underscore to indicate where the name should go in a type

   string.  This function substitutes a string for the underscore.  If

   there is no underscore, the name follows the type.  */

static bool

substitute_type (struct pr_handle *info, const char *s)

{

  char *u;

  assert (info->stack != NULL);

  u = strchr (info->stack->type, '|');

  if (u != NULL)

    {

      char *n;

      n = xmalloc (strlen (info->stack->type) + strlen (s));

      memcpy (n, info->stack->type, u - info->stack->type);

      strcpy (n + (u - info->stack->type), s);

      strcat (n, u + 1);

      free (info->stack->type);

      info->stack->type = n;

      return true;

    }

  if (strchr (s, '|') != NULL

      && (strchr (info->stack->type, '{') != NULL

    || strchr (info->stack->type, '(') != NULL))

    {

      if (! prepend_type (info, "(")

    || ! append_type (info, ")"))

  return false;

    }

  if (*s == '\0')

    return true;

  return (append_type (info, " ")

    && append_type (info, s));

}

/* Indent the type at the top of the stack by appending spaces.  */

static bool

indent_type (struct pr_handle *info)

{

  unsigned int i;

  for (i = 0; i < info->indent; i++)

    {

      if (! append_type (info, " "))

  return false;

    }

  return true;

}

/* Pop a type from the type stack.  */

static char *

pop_type (struct pr_handle *info)

{

  struct pr_stack *o;

  char *ret;

  assert (info->stack != NULL);

  o = info->stack;

  info->stack = o->next;

  ret = o->type;

  free (o);

  return ret;

}

/* Print a VMA value into a string.  */

static void

print_vma (bfd_vma vma, char *buf, bool unsignedp, bool hexp)

{

  if (hexp)

    sprintf (buf, "%#" PRIx64, (uint64_t) vma);

  else if (unsignedp)

    sprintf (buf, "%" PRIu64, (uint64_t) vma);

  else

    sprintf (buf, "%" PRId64, (int64_t) vma);

}

/* Start a new compilation unit.  */

static bool

pr_start_compilation_unit (void *p, const char *filename)

{

  struct pr_handle *info = (struct pr_handle *) p;

  assert (info->indent == 0);

  fprintf (info->f, "%s:\n", filename);

  return true;

}

/* Start a source file within a compilation unit.  */

static bool

pr_start_source (void *p, const char *filename)

{

  struct pr_handle *info = (struct pr_handle *) p;

  assert (info->indent == 0);

  fprintf (info->f, " %s:\n", filename);

  return true;

}

/* Push an empty type onto the type stack.  */

static bool

pr_empty_type (void *p)

{

  struct pr_handle *info = (struct pr_handle *) p;

  return push_type (info, "<undefined>");

}

/* Push a void type onto the type stack.  */

static bool

pr_void_type (void *p)

{

  struct pr_handle *info = (struct pr_handle *) p;

  return push_type (info, "void");

}

/* Push an integer type onto the type stack.  */

static bool

pr_int_type (void *p, unsigned int size, bool unsignedp)

{

  struct pr_handle *info = (struct pr_handle *) p;

  char ab[40];

  sprintf (ab, "%sint%d", unsignedp ? "u" : "", size * 8);

  return push_type (info, ab);

}

/* Push a floating type onto the type stack.  */

static bool

pr_float_type (void *p, unsigned int size)

{

  struct pr_handle *info = (struct pr_handle *) p;

  char ab[40];

  if (size == 4)

    return push_type (info, "float");

  else if (size == 8)

    return push_type (info, "double");

  sprintf (ab, "float%d", size * 8);

  return push_type (info, ab);

}

/* Push a complex type onto the type stack.  */

static bool

pr_complex_type (void *p, unsigned int size)

{

  struct pr_handle *info = (struct pr_handle *) p;

  if (! pr_float_type (p, size))

    return false;

  return prepend_type (info, "complex ");

}

/* Push a bool type onto the type stack.  */

static bool

pr_bool_type (void *p, unsigned int size)

{

  struct pr_handle *info = (struct pr_handle *) p;

  char ab[40];

  sprintf (ab, "bool%d", size * 8);

  return push_type (info, ab);

}

/* Push an enum type onto the type stack.  */

static bool

pr_enum_type (void *p, const char *tag, const char **names,

        bfd_signed_vma *values)

{

  struct pr_handle *info = (struct pr_handle *) p;

  unsigned int i;

  bfd_signed_vma val;

  if (! push_type (info, "enum "))

    return false;

  if (tag != NULL)

    {

      if (! append_type (info, tag)

    || ! append_type (info, " "))

  return false;

    }

  if (! append_type (info, "{ "))

    return false;

  if (names == NULL)

    {

      if (! append_type (info, "/* undefined */"))

  return false;

    }

  else

    {

      val = 0;

      for (i = 0; names[i] != NULL; i++)

  {

    if (i > 0)

      {

        if (! append_type (info, ", "))

    return false;

      }

    if (! append_type (info, names[i]))

      return false;

    if (values[i] != val)

      {

        char ab[22];

        print_vma (values[i], ab, false, false);

        if (! append_type (info, " = ")

      || ! append_type (info, ab))

    return false;

        val = values[i];

      }

    ++val;

  }

    }

  return append_type (info, " }");

}

/* Turn the top type on the stack into a pointer.  */

static bool

pr_pointer_type (void *p)

{

  struct pr_handle *info = (struct pr_handle *) p;

  char *s;

  assert (info->stack != NULL);

  s = strchr (info->stack->type, '|');

  if (s != NULL && s[1] == '[')

    return substitute_type (info, "(*|)");

  return substitute_type (info, "*|");

}

/* Turn the top type on the stack into a function returning that type.  */

static bool

pr_function_type (void *p, int argcount, bool varargs)

{

  struct pr_handle *info = (struct pr_handle *) p;

  char **arg_types;

  unsigned int len;

  char *s;

  assert (info->stack != NULL);

  len = 10;

  if (argcount <= 0)

    {

      arg_types = NULL;

      len += 15;

    }

  else

    {

      int i;

      arg_types = xmalloc (argcount * sizeof (*arg_types));

      for (i = argcount - 1; i >= 0; i--)

  {

    if (!substitute_type (info, "")

        || (arg_types[i] = pop_type (info)) == NULL)

      {

        for (int j = i + 1; j < argcount; j++)

    free (arg_types[j]);

        free (arg_types);

        return false;

      }

    len += strlen (arg_types[i]) + 2;

  }

      if (varargs)

  len += 5;

    }

  /* Now the return type is on the top of the stack.  */

  s = xmalloc (len);

  strcpy (s, "(|) (");

  if (argcount < 0)

    strcat (s, "/* unknown */");

  else

    {

      int i;

      for (i = 0; i < argcount; i++)

  {

    if (i > 0)

      strcat (s, ", ");

    strcat (s, arg_types[i]);

    free (arg_types[i]);

  }

      if (varargs)

  {

    if (i > 0)

      strcat (s, ", ");

    strcat (s, "...");

  }

      free (arg_types);

    }

  strcat (s, ")");

  bool ret = substitute_type (info, s);

  free (s);

  return ret;

}

/* Turn the top type on the stack into a reference to that type.  */

static bool

pr_reference_type (void *p)

{

  struct pr_handle *info = (struct pr_handle *) p;

  assert (info->stack != NULL);

  return substitute_type (info, "&|");

}

/* Make a range type.  */

static bool

pr_range_type (void *p, bfd_signed_vma lower, bfd_signed_vma upper)

{

  struct pr_handle *info = (struct pr_handle *) p;

  char abl[22], abu[22];

  assert (info->stack != NULL);

  if (! substitute_type (info, ""))

    return false;

  print_vma (lower, abl, false, false);

  print_vma (upper, abu, false, false);

  return (prepend_type (info, "range (")

    && append_type (info, "):")

    && append_type (info, abl)

    && append_type (info, ":")

    && append_type (info, abu));

}

/* Make an array type.  */

static bool

pr_array_type (void *p, bfd_signed_vma lower, bfd_signed_vma upper,

         bool stringp)

{

  struct pr_handle *info = (struct pr_handle *) p;

  char *range_type;

  char abl[22], abu[22], ab[50];

  range_type = pop_type (info);

  if (range_type == NULL)

    return false;

  if (lower == 0)

    {

      if (upper == -1)

  sprintf (ab, "|[]");

      else

  {

    print_vma (upper + 1, abu, false, false);

    sprintf (ab, "|[%s]", abu);

  }

    }

  else

    {

      print_vma (lower, abl, false, false);

      print_vma (upper, abu, false, false);

      sprintf (ab, "|[%s:%s]", abl, abu);

    }

  if (! substitute_type (info, ab))

    goto fail;

  if (strcmp (range_type, "int") != 0)

    {

      if (! append_type (info, ":")

    || ! append_type (info, range_type))

  goto fail;

    }

  if (stringp)

    {

      if (! append_type (info, " /* string */"))

  goto fail;

    }

  free (range_type);

  return true;

 fail:

  free (range_type);

  return false;

}

/* Make a set type.  */

static bool

pr_set_type (void *p, bool bitstringp)

{

  struct pr_handle *info = (struct pr_handle *) p;

  if (! substitute_type (info, ""))

    return false;

  if (! prepend_type (info, "set { ")

      || ! append_type (info, " }"))

    return false;

  if (bitstringp)

    {

      if (! append_type (info, "/* bitstring */"))

  return false;

    }

  return true;

}

/* Make an offset type.  */

static bool

pr_offset_type (void *p)

{

  struct pr_handle *info = (struct pr_handle *) p;

  char *t;

  if (! substitute_type (info, ""))

    return false;

  t = pop_type (info);

  if (t == NULL)

    return false;

  bool ret = (substitute_type (info, "")

        && prepend_type (info, " ")

        && prepend_type (info, t)

        && append_type (info, "::|"));

  free (t);

  return ret;

}

/* Make a method type.  */

static bool

pr_method_type (void *p, bool domain, int argcount, bool varargs)

{

  struct pr_handle *info = (struct pr_handle *) p;

  unsigned int len;

  char *domain_type = NULL, *free_domain = NULL;

  char **arg_types;

  char *s;

  len = 10;

  if (domain)

    {

      if (! substitute_type (info, ""))

  return false;

      domain_type = pop_type (info);

      if (domain_type == NULL)

  return false;

      free_domain = domain_type;

      if (startswith (domain_type, "class ")

    && strchr (domain_type + sizeof "class " - 1, ' ') == NULL)

  domain_type += sizeof "class " - 1;

      else if (startswith (domain_type, "union class ")

         && (strchr (domain_type + sizeof "union class " - 1, ' ')

       == NULL))

  domain_type += sizeof "union class " - 1;

      len += strlen (domain_type);

    }

  if (argcount <= 0)

    {

      arg_types = NULL;

      len += 15;

    }

  else

    {

      int i;

      arg_types = xmalloc (argcount * sizeof (*arg_types));

      for (i = argcount - 1; i >= 0; i--)

  {

    if (!substitute_type (info, "")

        || (arg_types[i] = pop_type (info)) == NULL)

      {

        for (int j = i + 1; j < argcount; ++j)

    free (arg_types[j]);

        free (arg_types);

        return false;

      }

    len += strlen (arg_types[i]) + 2;

  }

      if (varargs)

  len += 5;

    }

  /* Now the return type is on the top of the stack.  */

  s = xmalloc (len);

  *s = 0;

  if (domain)

    {

      strcpy (s, domain_type);

      free (free_domain);

    }

  strcat (s, "::| (");

  if (argcount < 0)

    strcat (s, "/* unknown */");

  else

    {

      int i;

      for (i = 0; i < argcount; i++)

  {

    if (i > 0)

      strcat (s, ", ");

    strcat (s, arg_types[i]);

    free (arg_types[i]);

  }

      if (varargs)

  {

    if (i > 0)

      strcat (s, ", ");

    strcat (s, "...");

  }

      free (arg_types);

    }

  strcat (s, ")");

  bool ret = substitute_type (info, s);

  free (s);

  return ret;

}

/* Make a const qualified type.  */

static bool

pr_const_type (void *p)

{

  struct pr_handle *info = (struct pr_handle *) p;

  return substitute_type (info, "const |");