* Many files: Changes to avoid gcc warnings: Add ATTRIBUTE_UNUSED
[external/binutils.git] / binutils / prdbg.c
1 /* prdbg.c -- Print out generic debugging information.
2    Copyright (C) 1995, 1996, 1999 Free Software Foundation, Inc.
3    Written by Ian Lance Taylor <ian@cygnus.com>.
4
5    This file is part of GNU Binutils.
6
7    This program is free software; you can redistribute it and/or modify
8    it under the terms of the GNU General Public License as published by
9    the Free Software Foundation; either version 2 of the License, or
10    (at your option) any later version.
11
12    This program is distributed in the hope that it will be useful,
13    but WITHOUT ANY WARRANTY; without even the implied warranty of
14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15    GNU General Public License for more details.
16
17    You should have received a copy of the GNU General Public License
18    along with this program; if not, write to the Free Software
19    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
20    02111-1307, USA.  */
21
22 /* This file prints out the generic debugging information, by
23    supplying a set of routines to debug_write.  */
24
25 #include <stdio.h>
26 #include <assert.h>
27
28 #include "bfd.h"
29 #include "bucomm.h"
30 #include "libiberty.h"
31 #include "debug.h"
32 #include "budbg.h"
33
34 /* This is the structure we use as a handle for these routines.  */
35
36 struct pr_handle
37 {
38   /* File to print information to.  */
39   FILE *f;
40   /* Current indentation level.  */
41   unsigned int indent;
42   /* Type stack.  */
43   struct pr_stack *stack;
44   /* Parameter number we are about to output.  */
45   int parameter;
46 };
47
48 /* The type stack.  */
49
50 struct pr_stack
51 {
52   /* Next element on the stack.  */
53   struct pr_stack *next;
54   /* This element.  */
55   char *type;
56   /* Current visibility of fields if this is a class.  */
57   enum debug_visibility visibility;
58   /* Name of the current method we are handling.  */
59   const char *method;
60 };
61
62 static void indent PARAMS ((struct pr_handle *));
63 static boolean push_type PARAMS ((struct pr_handle *, const char *));
64 static boolean prepend_type PARAMS ((struct pr_handle *, const char *));
65 static boolean append_type PARAMS ((struct pr_handle *, const char *));
66 static boolean substitute_type PARAMS ((struct pr_handle *, const char *));
67 static boolean indent_type PARAMS ((struct pr_handle *));
68 static char *pop_type PARAMS ((struct pr_handle *));
69 static void print_vma PARAMS ((bfd_vma, char *, boolean, boolean));
70 static boolean pr_fix_visibility
71   PARAMS ((struct pr_handle *, enum debug_visibility));
72
73 static boolean pr_start_compilation_unit PARAMS ((PTR, const char *));
74 static boolean pr_start_source PARAMS ((PTR, const char *));
75 static boolean pr_empty_type PARAMS ((PTR));
76 static boolean pr_void_type PARAMS ((PTR));
77 static boolean pr_int_type PARAMS ((PTR, unsigned int, boolean));
78 static boolean pr_float_type PARAMS ((PTR, unsigned int));
79 static boolean pr_complex_type PARAMS ((PTR, unsigned int));
80 static boolean pr_bool_type PARAMS ((PTR, unsigned int));
81 static boolean pr_enum_type
82   PARAMS ((PTR, const char *, const char **, bfd_signed_vma *));
83 static boolean pr_pointer_type PARAMS ((PTR));
84 static boolean pr_function_type PARAMS ((PTR, int, boolean));
85 static boolean pr_reference_type PARAMS ((PTR));
86 static boolean pr_range_type PARAMS ((PTR, bfd_signed_vma, bfd_signed_vma));
87 static boolean pr_array_type
88   PARAMS ((PTR, bfd_signed_vma, bfd_signed_vma, boolean));
89 static boolean pr_set_type PARAMS ((PTR, boolean));
90 static boolean pr_offset_type PARAMS ((PTR));
91 static boolean pr_method_type PARAMS ((PTR, boolean, int, boolean));
92 static boolean pr_const_type PARAMS ((PTR));
93 static boolean pr_volatile_type PARAMS ((PTR));
94 static boolean pr_start_struct_type
95   PARAMS ((PTR, const char *, unsigned int, boolean, unsigned int));
96 static boolean pr_struct_field
97   PARAMS ((PTR, const char *, bfd_vma, bfd_vma, enum debug_visibility));
98 static boolean pr_end_struct_type PARAMS ((PTR));
99 static boolean pr_start_class_type
100   PARAMS ((PTR, const char *, unsigned int, boolean, unsigned int, boolean,
101            boolean));
102 static boolean pr_class_static_member
103   PARAMS ((PTR, const char *, const char *, enum debug_visibility));
104 static boolean pr_class_baseclass
105   PARAMS ((PTR, bfd_vma, boolean, enum debug_visibility));
106 static boolean pr_class_start_method PARAMS ((PTR, const char *));
107 static boolean pr_class_method_variant
108   PARAMS ((PTR, const char *, enum debug_visibility, boolean, boolean,
109            bfd_vma, boolean));
110 static boolean pr_class_static_method_variant
111   PARAMS ((PTR, const char *, enum debug_visibility, boolean, boolean));
112 static boolean pr_class_end_method PARAMS ((PTR));
113 static boolean pr_end_class_type PARAMS ((PTR));
114 static boolean pr_typedef_type PARAMS ((PTR, const char *));
115 static boolean pr_tag_type
116   PARAMS ((PTR, const char *, unsigned int, enum debug_type_kind));
117 static boolean pr_typdef PARAMS ((PTR, const char *));
118 static boolean pr_tag PARAMS ((PTR, const char *));
119 static boolean pr_int_constant PARAMS ((PTR, const char *, bfd_vma));
120 static boolean pr_float_constant PARAMS ((PTR, const char *, double));
121 static boolean pr_typed_constant PARAMS ((PTR, const char *, bfd_vma));
122 static boolean pr_variable
123   PARAMS ((PTR, const char *, enum debug_var_kind, bfd_vma));
124 static boolean pr_start_function PARAMS ((PTR, const char *, boolean));
125 static boolean pr_function_parameter
126   PARAMS ((PTR, const char *, enum debug_parm_kind, bfd_vma));
127 static boolean pr_start_block PARAMS ((PTR, bfd_vma));
128 static boolean pr_end_block PARAMS ((PTR, bfd_vma));
129 static boolean pr_end_function PARAMS ((PTR));
130 static boolean pr_lineno PARAMS ((PTR, const char *, unsigned long, bfd_vma));
131
132 static const struct debug_write_fns pr_fns =
133 {
134   pr_start_compilation_unit,
135   pr_start_source,
136   pr_empty_type,
137   pr_void_type,
138   pr_int_type,
139   pr_float_type,
140   pr_complex_type,
141   pr_bool_type,
142   pr_enum_type,
143   pr_pointer_type,
144   pr_function_type,
145   pr_reference_type,
146   pr_range_type,
147   pr_array_type,
148   pr_set_type,
149   pr_offset_type,
150   pr_method_type,
151   pr_const_type,
152   pr_volatile_type,
153   pr_start_struct_type,
154   pr_struct_field,
155   pr_end_struct_type,
156   pr_start_class_type,
157   pr_class_static_member,
158   pr_class_baseclass,
159   pr_class_start_method,
160   pr_class_method_variant,
161   pr_class_static_method_variant,
162   pr_class_end_method,
163   pr_end_class_type,
164   pr_typedef_type,
165   pr_tag_type,
166   pr_typdef,
167   pr_tag,
168   pr_int_constant,
169   pr_float_constant,
170   pr_typed_constant,
171   pr_variable,
172   pr_start_function,
173   pr_function_parameter,
174   pr_start_block,
175   pr_end_block,
176   pr_end_function,
177   pr_lineno
178 };
179 \f
180 /* Print out the generic debugging information recorded in dhandle.  */
181
182 boolean
183 print_debugging_info (f, dhandle)
184      FILE *f;
185      PTR dhandle;
186 {
187   struct pr_handle info;
188
189   info.f = f;
190   info.indent = 0;
191   info.stack = NULL;
192   info.parameter = 0;
193
194   return debug_write (dhandle, &pr_fns, (PTR) &info);
195 }
196 \f
197 /* Indent to the current indentation level.  */
198
199 static void
200 indent (info)
201      struct pr_handle *info;
202 {
203   unsigned int i;
204
205   for (i = 0; i < info->indent; i++)
206     putc (' ', info->f);
207 }
208
209 /* Push a type on the type stack.  */
210
211 static boolean
212 push_type (info, type)
213      struct pr_handle *info;
214      const char *type;
215 {
216   struct pr_stack *n;
217
218   if (type == NULL)
219     return false;
220
221   n = (struct pr_stack *) xmalloc (sizeof *n);
222   memset (n, 0, sizeof *n);
223
224   n->type = xstrdup (type);
225   n->visibility = DEBUG_VISIBILITY_IGNORE;
226   n->method = NULL;
227   n->next = info->stack;
228   info->stack = n;
229
230   return true;
231 }
232
233 /* Prepend a string onto the type on the top of the type stack.  */
234
235 static boolean
236 prepend_type (info, s)
237      struct pr_handle *info;
238      const char *s;
239 {
240   char *n;
241
242   assert (info->stack != NULL);
243
244   n = (char *) xmalloc (strlen (s) + strlen (info->stack->type) + 1);
245   sprintf (n, "%s%s", s, info->stack->type);
246   free (info->stack->type);
247   info->stack->type = n;
248
249   return true;
250 }
251
252 /* Append a string to the type on the top of the type stack.  */
253
254 static boolean
255 append_type (info, s)
256      struct pr_handle *info;
257      const char *s;
258 {
259   unsigned int len;
260
261   if (s == NULL)
262     return false;
263
264   assert (info->stack != NULL);
265
266   len = strlen (info->stack->type);
267   info->stack->type = (char *) xrealloc (info->stack->type,
268                                          len + strlen (s) + 1);
269   strcpy (info->stack->type + len, s);
270
271   return true;
272 }
273
274 /* We use an underscore to indicate where the name should go in a type
275    string.  This function substitutes a string for the underscore.  If
276    there is no underscore, the name follows the type.  */
277
278 static boolean
279 substitute_type (info, s)
280      struct pr_handle *info;
281      const char *s;
282 {
283   char *u;
284
285   assert (info->stack != NULL);
286
287   u = strchr (info->stack->type, '|');
288   if (u != NULL)
289     {
290       char *n;
291
292       n = (char *) xmalloc (strlen (info->stack->type) + strlen (s));
293
294       memcpy (n, info->stack->type, u - info->stack->type);
295       strcpy (n + (u - info->stack->type), s);
296       strcat (n, u + 1);
297
298       free (info->stack->type);
299       info->stack->type = n;
300
301       return true;
302     }
303
304   if (strchr (s, '|') != NULL
305       && (strchr (info->stack->type, '{') != NULL
306           || strchr (info->stack->type, '(') != NULL))
307     {
308       if (! prepend_type (info, "(")
309           || ! append_type (info, ")"))
310         return false;
311     }
312
313   if (*s == '\0')
314     return true;
315
316   return (append_type (info, " ")
317           && append_type (info, s));
318 }
319
320 /* Indent the type at the top of the stack by appending spaces.  */
321
322 static boolean
323 indent_type (info)
324      struct pr_handle *info;
325 {
326   unsigned int i;
327
328   for (i = 0; i < info->indent; i++)
329     {
330       if (! append_type (info, " "))
331         return false;
332     }
333
334   return true;
335 }
336
337 /* Pop a type from the type stack.  */
338
339 static char *
340 pop_type (info)
341      struct pr_handle *info;
342 {
343   struct pr_stack *o;
344   char *ret;
345
346   assert (info->stack != NULL);
347
348   o = info->stack;
349   info->stack = o->next;
350   ret = o->type;
351   free (o);
352
353   return ret;
354 }
355
356 /* Print a VMA value into a string.  */
357
358 static void
359 print_vma (vma, buf, unsignedp, hexp)
360      bfd_vma vma;
361      char *buf;
362      boolean unsignedp;
363      boolean hexp;
364 {
365   if (sizeof (vma) <= sizeof (unsigned long))
366     {
367       if (hexp)
368         sprintf (buf, "0x%lx", (unsigned long) vma);
369       else if (unsignedp)
370         sprintf (buf, "%lu", (unsigned long) vma);
371       else
372         sprintf (buf, "%ld", (long) vma);
373     }
374   else
375     {
376       buf[0] = '0';
377       buf[1] = 'x';
378       sprintf_vma (buf + 2, vma);
379     }
380 }
381 \f
382 /* Start a new compilation unit.  */
383
384 static boolean
385 pr_start_compilation_unit (p, filename)
386      PTR p;
387      const char *filename;
388 {
389   struct pr_handle *info = (struct pr_handle *) p;
390
391   assert (info->indent == 0);
392
393   fprintf (info->f, "%s:\n", filename);
394
395   return true;
396 }
397
398 /* Start a source file within a compilation unit.  */
399
400 static boolean
401 pr_start_source (p, filename)
402      PTR p;
403      const char *filename;
404 {
405   struct pr_handle *info = (struct pr_handle *) p;
406
407   assert (info->indent == 0);
408
409   fprintf (info->f, " %s:\n", filename);
410
411   return true;
412 }
413
414 /* Push an empty type onto the type stack.  */
415
416 static boolean
417 pr_empty_type (p)
418      PTR p;
419 {
420   struct pr_handle *info = (struct pr_handle *) p;
421
422   return push_type (info, "<undefined>");
423 }
424
425 /* Push a void type onto the type stack.  */
426
427 static boolean
428 pr_void_type (p)
429      PTR p;
430 {
431   struct pr_handle *info = (struct pr_handle *) p;
432
433   return push_type (info, "void");
434 }
435
436 /* Push an integer type onto the type stack.  */
437
438 static boolean
439 pr_int_type (p, size, unsignedp)
440      PTR p;
441      unsigned int size;
442      boolean unsignedp;
443 {
444   struct pr_handle *info = (struct pr_handle *) p;
445   char ab[10];
446
447   sprintf (ab, "%sint%d", unsignedp ? "u" : "", size * 8);
448   return push_type (info, ab);
449 }
450
451 /* Push a floating type onto the type stack.  */
452
453 static boolean
454 pr_float_type (p, size)
455      PTR p;
456      unsigned int size;
457 {
458   struct pr_handle *info = (struct pr_handle *) p;
459   char ab[10];
460
461   if (size == 4)
462     return push_type (info, "float");
463   else if (size == 8)
464     return push_type (info, "double");
465
466   sprintf (ab, "float%d", size * 8);
467   return push_type (info, ab);
468 }
469
470 /* Push a complex type onto the type stack.  */
471
472 static boolean
473 pr_complex_type (p, size)
474      PTR p;
475      unsigned int size;
476 {
477   struct pr_handle *info = (struct pr_handle *) p;
478
479   if (! pr_float_type (p, size))
480     return false;
481
482   return prepend_type (info, "complex ");
483 }
484
485 /* Push a boolean type onto the type stack.  */
486
487 static boolean
488 pr_bool_type (p, size)
489      PTR p;
490      unsigned int size;
491 {
492   struct pr_handle *info = (struct pr_handle *) p;
493   char ab[10];
494
495   sprintf (ab, "bool%d", size * 8);
496
497   return push_type (info, ab);
498 }
499
500 /* Push an enum type onto the type stack.  */
501
502 static boolean
503 pr_enum_type (p, tag, names, values)
504      PTR p;
505      const char *tag;
506      const char **names;
507      bfd_signed_vma *values;
508 {
509   struct pr_handle *info = (struct pr_handle *) p;
510   unsigned int i;
511   bfd_signed_vma val;
512
513   if (! push_type (info, "enum "))
514     return false;
515   if (tag != NULL)
516     {
517       if (! append_type (info, tag)
518           || ! append_type (info, " "))
519         return false;
520     }
521   if (! append_type (info, "{ "))
522     return false;
523
524   if (names == NULL)
525     {
526       if (! append_type (info, "/* undefined */"))
527         return false;
528     }
529   else
530     {
531       val = 0;
532       for (i = 0; names[i] != NULL; i++)
533         {
534           if (i > 0)
535             {
536               if (! append_type (info, ", "))
537                 return false;
538             }
539
540           if (! append_type (info, names[i]))
541             return false;
542
543           if (values[i] != val)
544             {
545               char ab[20];
546
547               print_vma (values[i], ab, false, false);
548               if (! append_type (info, " = ")
549                   || ! append_type (info, ab))
550                 return false;
551               val = values[i];
552             }
553
554           ++val;
555         }
556     }
557
558   return append_type (info, " }");
559 }
560
561 /* Turn the top type on the stack into a pointer.  */
562
563 static boolean
564 pr_pointer_type (p)
565      PTR p;
566 {
567   struct pr_handle *info = (struct pr_handle *) p;
568   char *s;
569
570   assert (info->stack != NULL);
571
572   s = strchr (info->stack->type, '|');
573   if (s != NULL && s[1] == '[')
574     return substitute_type (info, "(*|)");
575   return substitute_type (info, "*|");
576 }
577
578 /* Turn the top type on the stack into a function returning that type.  */
579
580 static boolean
581 pr_function_type (p, argcount, varargs)
582      PTR p;
583      int argcount;
584      boolean varargs;
585 {
586   struct pr_handle *info = (struct pr_handle *) p;
587   char **arg_types;
588   unsigned int len;
589   char *s;
590
591   assert (info->stack != NULL);
592
593   len = 10;
594
595   if (argcount <= 0)
596     {
597       arg_types = NULL;
598       len += 15;
599     }
600   else
601     {
602       int i;
603
604       arg_types = (char **) xmalloc (argcount * sizeof *arg_types);
605       for (i = argcount - 1; i >= 0; i--)
606         {
607           if (! substitute_type (info, ""))
608             return false;
609           arg_types[i] = pop_type (info);
610           if (arg_types[i] == NULL)
611             return false;
612           len += strlen (arg_types[i]) + 2;
613         }
614       if (varargs)
615         len += 5;
616     }
617
618   /* Now the return type is on the top of the stack.  */
619
620   s = (char *) xmalloc (len);
621   strcpy (s, "(|) (");
622
623   if (argcount < 0)
624     strcat (s, "/* unknown */");
625   else
626     {
627       int i;
628
629       for (i = 0; i < argcount; i++)
630         {
631           if (i > 0)
632             strcat (s, ", ");
633           strcat (s, arg_types[i]);
634         }
635       if (varargs)
636         {
637           if (i > 0)
638             strcat (s, ", ");
639           strcat (s, "...");
640         }
641       if (argcount > 0)
642         free (arg_types);
643     }
644
645   strcat (s, ")");
646
647   if (! substitute_type (info, s))
648     return false;
649
650   free (s);
651
652   return true;
653 }
654
655 /* Turn the top type on the stack into a reference to that type.  */
656
657 static boolean
658 pr_reference_type (p)
659      PTR p;
660 {
661   struct pr_handle *info = (struct pr_handle *) p;
662
663   assert (info->stack != NULL);
664
665   return substitute_type (info, "&|");
666 }
667
668 /* Make a range type.  */
669
670 static boolean
671 pr_range_type (p, lower, upper)
672      PTR p;
673      bfd_signed_vma lower;
674      bfd_signed_vma upper;
675 {
676   struct pr_handle *info = (struct pr_handle *) p;
677   char abl[20], abu[20];
678
679   assert (info->stack != NULL);
680
681   if (! substitute_type (info, ""))
682     return false;
683
684   print_vma (lower, abl, false, false);
685   print_vma (upper, abu, false, false);
686
687   return (prepend_type (info, "range (")
688           && append_type (info, "):")
689           && append_type (info, abl)
690           && append_type (info, ":")
691           && append_type (info, abu));
692 }
693
694 /* Make an array type.  */
695
696 /*ARGSUSED*/
697 static boolean
698 pr_array_type (p, lower, upper, stringp)
699      PTR p;
700      bfd_signed_vma lower;
701      bfd_signed_vma upper;
702      boolean stringp;
703 {
704   struct pr_handle *info = (struct pr_handle *) p;
705   char *range_type;
706   char abl[20], abu[20], ab[50];
707
708   range_type = pop_type (info);
709   if (range_type == NULL)
710     return false;
711
712   if (lower == 0)
713     {
714       if (upper == -1)
715         sprintf (ab, "|[]");
716       else
717         {
718           print_vma (upper + 1, abu, false, false);
719           sprintf (ab, "|[%s]", abu);
720         }
721     }
722   else
723     {
724       print_vma (lower, abl, false, false);
725       print_vma (upper, abu, false, false);
726       sprintf (ab, "|[%s:%s]", abl, abu);
727     }
728
729   if (! substitute_type (info, ab))
730     return false;
731
732   if (strcmp (range_type, "int") != 0)
733     {
734       if (! append_type (info, ":")
735           || ! append_type (info, range_type))
736         return false;
737     }
738
739   if (stringp)
740     {
741       if (! append_type (info, " /* string */"))
742         return false;
743     }
744
745   return true;
746 }
747
748 /* Make a set type.  */
749
750 /*ARGSUSED*/
751 static boolean
752 pr_set_type (p, bitstringp)
753      PTR p;
754      boolean bitstringp;
755 {
756   struct pr_handle *info = (struct pr_handle *) p;
757
758   if (! substitute_type (info, ""))
759     return false;
760
761   if (! prepend_type (info, "set { ")
762       || ! append_type (info, " }"))
763     return false;
764
765   if (bitstringp)
766     {
767       if (! append_type (info, "/* bitstring */"))
768         return false;
769     }
770
771   return true;
772 }
773
774 /* Make an offset type.  */
775
776 static boolean
777 pr_offset_type (p)
778      PTR p;
779 {
780   struct pr_handle *info = (struct pr_handle *) p;
781   char *t;
782
783   if (! substitute_type (info, ""))
784     return false;
785
786   t = pop_type (info);
787   if (t == NULL)
788     return false;
789
790   return (substitute_type (info, "")
791           && prepend_type (info, " ")
792           && prepend_type (info, t)
793           && append_type (info, "::|"));
794 }
795
796 /* Make a method type.  */
797
798 static boolean
799 pr_method_type (p, domain, argcount, varargs)
800      PTR p;
801      boolean domain;
802      int argcount;
803      boolean varargs;
804 {
805   struct pr_handle *info = (struct pr_handle *) p;
806   unsigned int len;
807   char *domain_type;
808   char **arg_types;
809   char *s;
810
811   len = 10;
812
813   if (! domain)
814     domain_type = NULL;
815   else
816     {
817       if (! substitute_type (info, ""))
818         return false;
819       domain_type = pop_type (info);
820       if (domain_type == NULL)
821         return false;
822       if (strncmp (domain_type, "class ", sizeof "class " - 1) == 0
823           && strchr (domain_type + sizeof "class " - 1, ' ') == NULL)
824         domain_type += sizeof "class " - 1;
825       else if (strncmp (domain_type, "union class ",
826                         sizeof "union class ") == 0
827                && (strchr (domain_type + sizeof "union class " - 1, ' ')
828                    == NULL))
829         domain_type += sizeof "union class " - 1;
830       len += strlen (domain_type);
831     }
832
833   if (argcount <= 0)
834     {
835       arg_types = NULL;
836       len += 15;
837     }
838   else
839     {
840       int i;
841
842       arg_types = (char **) xmalloc (argcount * sizeof *arg_types);
843       for (i = argcount - 1; i >= 0; i--)
844         {
845           if (! substitute_type (info, ""))
846             return false;
847           arg_types[i] = pop_type (info);
848           if (arg_types[i] == NULL)
849             return false;
850           len += strlen (arg_types[i]) + 2;
851         }
852       if (varargs)
853         len += 5;
854     }
855
856   /* Now the return type is on the top of the stack.  */
857
858   s = (char *) xmalloc (len);
859   if (! domain)
860     *s = '\0';
861   else
862     strcpy (s, domain_type);
863   strcat (s, "::| (");
864
865   if (argcount < 0)
866     strcat (s, "/* unknown */");
867   else
868     {
869       int i;
870
871       for (i = 0; i < argcount; i++)
872         {
873           if (i > 0)
874             strcat (s, ", ");
875           strcat (s, arg_types[i]);
876         }
877       if (varargs)
878         {
879           if (i > 0)
880             strcat (s, ", ");
881           strcat (s, "...");
882         }
883       if (argcount > 0)
884         free (arg_types);
885     }
886
887   strcat (s, ")");
888
889   if (! substitute_type (info, s))
890     return false;
891
892   free (s);
893
894   return true;
895 }
896
897 /* Make a const qualified type.  */
898
899 static boolean
900 pr_const_type (p)
901      PTR p;
902 {
903   struct pr_handle *info = (struct pr_handle *) p;
904
905   return substitute_type (info, "const |");
906 }
907
908 /* Make a volatile qualified type.  */
909
910 static boolean
911 pr_volatile_type (p)
912      PTR p;
913 {
914   struct pr_handle *info = (struct pr_handle *) p;
915
916   return substitute_type (info, "volatile |");
917 }
918
919 /* Start accumulating a struct type.  */
920
921 static boolean
922 pr_start_struct_type (p, tag, id, structp, size)
923      PTR p;
924      const char *tag;
925      unsigned int id;
926      boolean structp;
927      unsigned int size;
928 {
929   struct pr_handle *info = (struct pr_handle *) p;
930
931   info->indent += 2;
932
933   if (! push_type (info, structp ? "struct " : "union "))
934     return false;
935   if (tag != NULL)
936     {
937       if (! append_type (info, tag))
938         return false;
939     }
940   else
941     {
942       char idbuf[20];
943
944       sprintf (idbuf, "%%anon%u", id);
945       if (! append_type (info, idbuf))
946         return false;
947     }
948
949   if (! append_type (info, " {"))
950     return false;
951   if (size != 0 || tag != NULL)
952     {
953       char ab[30];
954
955       if (! append_type (info, " /*"))
956         return false;
957
958       if (size != 0)
959         {
960           sprintf (ab, " size %u", size);
961           if (! append_type (info, ab))
962             return false;
963         }
964       if (tag != NULL)
965         {
966           sprintf (ab, " id %u", id);
967           if (! append_type (info, ab))
968             return false;
969         }
970       if (! append_type (info, " */"))
971         return false;
972     }
973   if (! append_type (info, "\n"))
974     return false;
975
976   info->stack->visibility = DEBUG_VISIBILITY_PUBLIC;
977
978   return indent_type (info);
979 }
980
981 /* Output the visibility of a field in a struct.  */
982
983 static boolean
984 pr_fix_visibility (info, visibility)
985      struct pr_handle *info;
986      enum debug_visibility visibility;
987 {
988   const char *s = NULL;
989   char *t;
990   unsigned int len;
991
992   assert (info->stack != NULL);
993
994   if (info->stack->visibility == visibility)
995     return true;
996
997   assert (info->stack->visibility != DEBUG_VISIBILITY_IGNORE);
998
999   switch (visibility)
1000     {
1001     case DEBUG_VISIBILITY_PUBLIC:
1002       s = "public";
1003       break;
1004     case DEBUG_VISIBILITY_PRIVATE:
1005       s = "private";
1006       break;
1007     case DEBUG_VISIBILITY_PROTECTED:
1008       s = "protected";
1009       break;
1010     case DEBUG_VISIBILITY_IGNORE:
1011       s = "/* ignore */";
1012       break;
1013     default:
1014       abort ();
1015       return false;
1016     }
1017
1018   /* Trim off a trailing space in the struct string, to make the
1019      output look a bit better, then stick on the visibility string.  */
1020
1021   t = info->stack->type;
1022   len = strlen (t);
1023   assert (t[len - 1] == ' ');
1024   t[len - 1] = '\0';
1025
1026   if (! append_type (info, s)
1027       || ! append_type (info, ":\n")
1028       || ! indent_type (info))
1029     return false;
1030
1031   info->stack->visibility = visibility;
1032
1033   return true;
1034 }
1035
1036 /* Add a field to a struct type.  */
1037
1038 static boolean
1039 pr_struct_field (p, name, bitpos, bitsize, visibility)
1040      PTR p;
1041      const char *name;
1042      bfd_vma bitpos;
1043      bfd_vma bitsize;
1044      enum debug_visibility visibility;
1045 {
1046   struct pr_handle *info = (struct pr_handle *) p;
1047   char ab[20];
1048   char *t;
1049
1050   if (! substitute_type (info, name))
1051     return false;
1052
1053   if (! append_type (info, "; /* "))
1054     return false;
1055
1056   if (bitsize != 0)
1057     {
1058       print_vma (bitsize, ab, true, false);
1059       if (! append_type (info, "bitsize ")
1060           || ! append_type (info, ab)
1061           || ! append_type (info, ", "))
1062         return false;
1063     }
1064
1065   print_vma (bitpos, ab, true, false);
1066   if (! append_type (info, "bitpos ")
1067       || ! append_type (info, ab)
1068       || ! append_type (info, " */\n")
1069       || ! indent_type (info))
1070     return false;
1071
1072   t = pop_type (info);
1073   if (t == NULL)
1074     return false;
1075
1076   if (! pr_fix_visibility (info, visibility))
1077     return false;
1078
1079   return append_type (info, t);
1080 }
1081
1082 /* Finish a struct type.  */
1083
1084 static boolean
1085 pr_end_struct_type (p)
1086      PTR p;
1087 {
1088   struct pr_handle *info = (struct pr_handle *) p;
1089   char *s;
1090
1091   assert (info->stack != NULL);
1092   assert (info->indent >= 2);
1093
1094   info->indent -= 2;
1095
1096   /* Change the trailing indentation to have a close brace.  */
1097   s = info->stack->type + strlen (info->stack->type) - 2;
1098   assert (s[0] == ' ' && s[1] == ' ' && s[2] == '\0');
1099
1100   *s++ = '}';
1101   *s = '\0';
1102
1103   return true;
1104 }
1105
1106 /* Start a class type.  */
1107
1108 static boolean
1109 pr_start_class_type (p, tag, id, structp, size, vptr, ownvptr)
1110      PTR p;
1111      const char *tag;
1112      unsigned int id;
1113      boolean structp;
1114      unsigned int size;
1115      boolean vptr;
1116      boolean ownvptr;
1117 {
1118   struct pr_handle *info = (struct pr_handle *) p;
1119   char *tv = NULL;
1120
1121   info->indent += 2;
1122
1123   if (vptr && ! ownvptr)
1124     {
1125       tv = pop_type (info);
1126       if (tv == NULL)
1127         return false;
1128     }
1129
1130   if (! push_type (info, structp ? "class " : "union class "))
1131     return false;
1132   if (tag != NULL)
1133     {
1134       if (! append_type (info, tag))
1135         return false;
1136     }
1137   else
1138     {
1139       char idbuf[20];
1140
1141       sprintf (idbuf, "%%anon%u", id);
1142       if (! append_type (info, idbuf))
1143         return false;
1144     }
1145
1146   if (! append_type (info, " {"))
1147     return false;
1148   if (size != 0 || vptr || ownvptr || tag != NULL)
1149     {
1150       if (! append_type (info, " /*"))
1151         return false;
1152
1153       if (size != 0)
1154         {
1155           char ab[20];
1156
1157           sprintf (ab, "%u", size);
1158           if (! append_type (info, " size ")
1159               || ! append_type (info, ab))
1160             return false;
1161         }
1162
1163       if (vptr)
1164         {
1165           if (! append_type (info, " vtable "))
1166             return false;
1167           if (ownvptr)
1168             {
1169               if (! append_type (info, "self "))
1170                 return false;
1171             }
1172           else
1173             {
1174               if (! append_type (info, tv)
1175                   || ! append_type (info, " "))
1176                 return false;
1177             }
1178         }
1179
1180       if (tag != NULL)
1181         {
1182           char ab[30];
1183
1184           sprintf (ab, " id %u", id);
1185           if (! append_type (info, ab))
1186             return false;
1187         }
1188
1189       if (! append_type (info, " */"))
1190         return false;
1191     }
1192
1193   info->stack->visibility = DEBUG_VISIBILITY_PRIVATE;
1194
1195   return (append_type (info, "\n")
1196           && indent_type (info));
1197 }
1198
1199 /* Add a static member to a class.  */
1200
1201 static boolean
1202 pr_class_static_member (p, name, physname, visibility)
1203      PTR p;
1204      const char *name;
1205      const char *physname;
1206      enum debug_visibility visibility;
1207 {
1208   struct pr_handle *info = (struct pr_handle *) p;
1209   char *t;
1210
1211   if (! substitute_type (info, name))
1212     return false;
1213
1214   if (! prepend_type (info, "static ")
1215       || ! append_type (info, "; /* ")
1216       || ! append_type (info, physname)
1217       || ! append_type (info, " */\n")
1218       || ! indent_type (info))
1219     return false;
1220
1221   t = pop_type (info);
1222   if (t == NULL)
1223     return false;
1224
1225   if (! pr_fix_visibility (info, visibility))
1226     return false;
1227
1228   return append_type (info, t);
1229 }
1230
1231 /* Add a base class to a class.  */
1232
1233 static boolean
1234 pr_class_baseclass (p, bitpos, virtual, visibility)
1235      PTR p;
1236      bfd_vma bitpos;
1237      boolean virtual;
1238      enum debug_visibility visibility;
1239 {
1240   struct pr_handle *info = (struct pr_handle *) p;
1241   char *t;
1242   const char *prefix;
1243   char ab[20];
1244   char *s, *l, *n;
1245
1246   assert (info->stack != NULL && info->stack->next != NULL);
1247
1248   if (! substitute_type (info, ""))
1249     return false;
1250
1251   t = pop_type (info);
1252   if (t == NULL)
1253     return false;
1254
1255   if (strncmp (t, "class ", sizeof "class " - 1) == 0)
1256     t += sizeof "class " - 1;
1257
1258   /* Push it back on to take advantage of the prepend_type and
1259      append_type routines.  */
1260   if (! push_type (info, t))
1261     return false;
1262
1263   if (virtual)
1264     {
1265       if (! prepend_type (info, "virtual "))
1266         return false;
1267     }
1268
1269   switch (visibility)
1270     {
1271     case DEBUG_VISIBILITY_PUBLIC:
1272       prefix = "public ";
1273       break;
1274     case DEBUG_VISIBILITY_PROTECTED:
1275       prefix = "protected ";
1276       break;
1277     case DEBUG_VISIBILITY_PRIVATE:
1278       prefix = "private ";
1279       break;
1280     default:
1281       prefix = "/* unknown visibility */ ";
1282       break;
1283     }
1284
1285   if (! prepend_type (info, prefix))
1286     return false;
1287
1288   if (bitpos != 0)
1289     {
1290       print_vma (bitpos, ab, true, false);
1291       if (! append_type (info, " /* bitpos ")
1292           || ! append_type (info, ab)
1293           || ! append_type (info, " */"))
1294         return false;
1295     }
1296
1297   /* Now the top of the stack is something like "public A / * bitpos
1298      10 * /".  The next element on the stack is something like "class
1299      xx { / * size 8 * /\n...".  We want to substitute the top of the
1300      stack in before the {.  */
1301   s = strchr (info->stack->next->type, '{');
1302   assert (s != NULL);
1303   --s;
1304
1305   /* If there is already a ':', then we already have a baseclass, and
1306      we must append this one after a comma.  */
1307   for (l = info->stack->next->type; l != s; l++)
1308     if (*l == ':')
1309       break;
1310   if (! prepend_type (info, l == s ? " : " : ", "))
1311     return false;
1312
1313   t = pop_type (info);
1314   if (t == NULL)
1315     return false;
1316
1317   n = (char *) xmalloc (strlen (info->stack->type) + strlen (t) + 1);
1318   memcpy (n, info->stack->type, s - info->stack->type);
1319   strcpy (n + (s - info->stack->type), t);
1320   strcat (n, s);
1321
1322   free (info->stack->type);
1323   info->stack->type = n;
1324
1325   free (t);
1326
1327   return true;
1328 }
1329
1330 /* Start adding a method to a class.  */
1331
1332 static boolean
1333 pr_class_start_method (p, name)
1334      PTR p;
1335      const char *name;
1336 {
1337   struct pr_handle *info = (struct pr_handle *) p;
1338
1339   assert (info->stack != NULL);
1340   info->stack->method = name;
1341   return true;
1342 }
1343
1344 /* Add a variant to a method.  */
1345
1346 static boolean
1347 pr_class_method_variant (p, physname, visibility, constp, volatilep, voffset,
1348                          context)
1349      PTR p;
1350      const char *physname;
1351      enum debug_visibility visibility;
1352      boolean constp;
1353      boolean volatilep;
1354      bfd_vma voffset;
1355      boolean context;
1356 {
1357   struct pr_handle *info = (struct pr_handle *) p;
1358   char *method_type;
1359   char *context_type;
1360
1361   assert (info->stack != NULL);
1362   assert (info->stack->next != NULL);
1363
1364   /* Put the const and volatile qualifiers on the type.  */
1365   if (volatilep)
1366     {
1367       if (! append_type (info, " volatile"))
1368         return false;
1369     }
1370   if (constp)
1371     {
1372       if (! append_type (info, " const"))
1373         return false;
1374     }
1375
1376   /* Stick the name of the method into its type.  */
1377   if (! substitute_type (info,
1378                          (context
1379                           ? info->stack->next->next->method
1380                           : info->stack->next->method)))
1381     return false;
1382
1383   /* Get the type.  */
1384   method_type = pop_type (info);
1385   if (method_type == NULL)
1386     return false;
1387
1388   /* Pull off the context type if there is one.  */
1389   if (! context)
1390     context_type = NULL;
1391   else
1392     {
1393       context_type = pop_type (info);
1394       if (context_type == NULL)
1395         return false;
1396     }
1397
1398   /* Now the top of the stack is the class.  */
1399
1400   if (! pr_fix_visibility (info, visibility))
1401     return false;
1402
1403   if (! append_type (info, method_type)
1404       || ! append_type (info, " /* ")
1405       || ! append_type (info, physname)
1406       || ! append_type (info, " "))
1407     return false;
1408   if (context || voffset != 0)
1409     {
1410       char ab[20];
1411
1412       if (context)
1413         {
1414           if (! append_type (info, "context ")
1415               || ! append_type (info, context_type)
1416               || ! append_type (info, " "))
1417             return false;
1418         }
1419       print_vma (voffset, ab, true, false);
1420       if (! append_type (info, "voffset ")
1421           || ! append_type (info, ab))
1422         return false;
1423     }
1424
1425   return (append_type (info, " */;\n")
1426           && indent_type (info));
1427 }
1428
1429 /* Add a static variant to a method.  */
1430
1431 static boolean
1432 pr_class_static_method_variant (p, physname, visibility, constp, volatilep)
1433      PTR p;
1434      const char *physname;
1435      enum debug_visibility visibility;
1436      boolean constp;
1437      boolean volatilep;
1438 {
1439   struct pr_handle *info = (struct pr_handle *) p;
1440   char *method_type;
1441
1442   assert (info->stack != NULL);
1443   assert (info->stack->next != NULL);
1444   assert (info->stack->next->method != NULL);
1445
1446   /* Put the const and volatile qualifiers on the type.  */
1447   if (volatilep)
1448     {
1449       if (! append_type (info, " volatile"))
1450         return false;
1451     }
1452   if (constp)
1453     {
1454       if (! append_type (info, " const"))
1455         return false;
1456     }
1457
1458   /* Mark it as static.  */
1459   if (! prepend_type (info, "static "))
1460     return false;
1461
1462   /* Stick the name of the method into its type.  */
1463   if (! substitute_type (info, info->stack->next->method))
1464     return false;
1465
1466   /* Get the type.  */
1467   method_type = pop_type (info);
1468   if (method_type == NULL)
1469     return false;
1470
1471   /* Now the top of the stack is the class.  */
1472
1473   if (! pr_fix_visibility (info, visibility))
1474     return false;
1475
1476   return (append_type (info, method_type)
1477           && append_type (info, " /* ")
1478           && append_type (info, physname)
1479           && append_type (info, " */;\n")
1480           && indent_type (info));
1481 }
1482
1483 /* Finish up a method.  */
1484
1485 static boolean
1486 pr_class_end_method (p)
1487      PTR p;
1488 {
1489   struct pr_handle *info = (struct pr_handle *) p;
1490
1491   info->stack->method = NULL;
1492   return true;
1493 }
1494
1495 /* Finish up a class.  */
1496
1497 static boolean
1498 pr_end_class_type (p)
1499      PTR p;
1500 {
1501   return pr_end_struct_type (p);
1502 }
1503
1504 /* Push a type on the stack using a typedef name.  */
1505
1506 static boolean
1507 pr_typedef_type (p, name)
1508      PTR p;
1509      const char *name;
1510 {
1511   struct pr_handle *info = (struct pr_handle *) p;
1512
1513   return push_type (info, name);
1514 }
1515
1516 /* Push a type on the stack using a tag name.  */
1517
1518 static boolean
1519 pr_tag_type (p, name, id, kind)
1520      PTR p;
1521      const char *name;
1522      unsigned int id;
1523      enum debug_type_kind kind;
1524 {
1525   struct pr_handle *info = (struct pr_handle *) p;
1526   const char *t, *tag;
1527   char idbuf[20];
1528
1529   switch (kind)
1530     {
1531     case DEBUG_KIND_STRUCT:
1532       t = "struct ";
1533       break;
1534     case DEBUG_KIND_UNION:
1535       t = "union ";
1536       break;
1537     case DEBUG_KIND_ENUM:
1538       t = "enum ";
1539       break;
1540     case DEBUG_KIND_CLASS:
1541       t = "class ";
1542       break;
1543     case DEBUG_KIND_UNION_CLASS:
1544       t = "union class ";
1545       break;
1546     default:
1547       abort ();
1548       return false;
1549     }
1550
1551   if (! push_type (info, t))
1552     return false;
1553   if (name != NULL)
1554     tag = name;
1555   else
1556     {
1557       sprintf (idbuf, "%%anon%u", id);
1558       tag = idbuf;
1559     }
1560
1561   if (! append_type (info, tag))
1562     return false;
1563   if (name != NULL && kind != DEBUG_KIND_ENUM)
1564     {
1565       sprintf (idbuf, " /* id %u */", id);
1566       if (! append_type (info, idbuf))
1567         return false;
1568     }
1569
1570   return true;
1571 }
1572
1573 /* Output a typedef.  */
1574
1575 static boolean
1576 pr_typdef (p, name)
1577      PTR p;
1578      const char *name;
1579 {
1580   struct pr_handle *info = (struct pr_handle *) p;
1581   char *s;
1582
1583   if (! substitute_type (info, name))
1584     return false;
1585
1586   s = pop_type (info);
1587   if (s == NULL)
1588     return false;
1589
1590   indent (info);
1591   fprintf (info->f, "typedef %s;\n", s);
1592
1593   free (s);
1594
1595   return true;
1596 }
1597
1598 /* Output a tag.  The tag should already be in the string on the
1599    stack, so all we have to do here is print it out.  */
1600
1601 /*ARGSUSED*/
1602 static boolean
1603 pr_tag (p, name)
1604      PTR p;
1605      const char *name ATTRIBUTE_UNUSED;
1606 {
1607   struct pr_handle *info = (struct pr_handle *) p;
1608   char *t;
1609
1610   t = pop_type (info);
1611   if (t == NULL)
1612     return false;
1613
1614   indent (info);
1615   fprintf (info->f, "%s;\n", t);
1616
1617   free (t);
1618
1619   return true;
1620 }
1621
1622 /* Output an integer constant.  */
1623
1624 static boolean
1625 pr_int_constant (p, name, val)
1626      PTR p;
1627      const char *name;
1628      bfd_vma val;
1629 {
1630   struct pr_handle *info = (struct pr_handle *) p;
1631   char ab[20];
1632
1633   indent (info);
1634   print_vma (val, ab, false, false);
1635   fprintf (info->f, "const int %s = %s;\n", name, ab);
1636   return true;
1637 }
1638
1639 /* Output a floating point constant.  */
1640
1641 static boolean
1642 pr_float_constant (p, name, val)
1643      PTR p;
1644      const char *name;
1645      double val;
1646 {
1647   struct pr_handle *info = (struct pr_handle *) p;
1648
1649   indent (info);
1650   fprintf (info->f, "const double %s = %g;\n", name, val);
1651   return true;
1652 }
1653
1654 /* Output a typed constant.  */
1655
1656 static boolean
1657 pr_typed_constant (p, name, val)
1658      PTR p;
1659      const char *name;
1660      bfd_vma val;
1661 {
1662   struct pr_handle *info = (struct pr_handle *) p;
1663   char *t;
1664   char ab[20];
1665
1666   t = pop_type (info);
1667   if (t == NULL)
1668     return false;
1669
1670   indent (info);
1671   print_vma (val, ab, false, false);
1672   fprintf (info->f, "const %s %s = %s;\n", t, name, ab);
1673
1674   free (t);
1675
1676   return true;
1677 }
1678
1679 /* Output a variable.  */
1680
1681 static boolean
1682 pr_variable (p, name, kind, val)
1683      PTR p;
1684      const char *name;
1685      enum debug_var_kind kind;
1686      bfd_vma val;
1687 {
1688   struct pr_handle *info = (struct pr_handle *) p;
1689   char *t;
1690   char ab[20];
1691
1692   if (! substitute_type (info, name))
1693     return false;
1694
1695   t = pop_type (info);
1696   if (t == NULL)
1697     return false;
1698
1699   indent (info);
1700   switch (kind)
1701     {
1702     case DEBUG_STATIC:
1703     case DEBUG_LOCAL_STATIC:
1704       fprintf (info->f, "static ");
1705       break;
1706     case DEBUG_REGISTER:
1707       fprintf (info->f, "register ");
1708       break;
1709     default:
1710       break;
1711     }
1712   print_vma (val, ab, true, true);
1713   fprintf (info->f, "%s /* %s */;\n", t, ab);
1714
1715   free (t);
1716
1717   return true;
1718 }
1719
1720 /* Start outputting a function.  */
1721
1722 static boolean
1723 pr_start_function (p, name, global)
1724      PTR p;
1725      const char *name;
1726      boolean global;
1727 {
1728   struct pr_handle *info = (struct pr_handle *) p;
1729   char *t;
1730
1731   if (! substitute_type (info, name))
1732     return false;
1733
1734   t = pop_type (info);
1735   if (t == NULL)
1736     return false;
1737
1738   indent (info);
1739   if (! global)
1740     fprintf (info->f, "static ");
1741   fprintf (info->f, "%s (", t);
1742
1743   info->parameter = 1;
1744
1745   return true;
1746 }
1747
1748 /* Output a function parameter.  */
1749
1750 static boolean
1751 pr_function_parameter (p, name, kind, val)
1752      PTR p;
1753      const char *name;
1754      enum debug_parm_kind kind;
1755      bfd_vma val;
1756 {
1757   struct pr_handle *info = (struct pr_handle *) p;
1758   char *t;
1759   char ab[20];
1760
1761   if (kind == DEBUG_PARM_REFERENCE
1762       || kind == DEBUG_PARM_REF_REG)
1763     {
1764       if (! pr_reference_type (p))
1765         return false;
1766     }
1767
1768   if (! substitute_type (info, name))
1769     return false;
1770
1771   t = pop_type (info);
1772   if (t == NULL)
1773     return false;
1774
1775   if (info->parameter != 1)
1776     fprintf (info->f, ", ");
1777
1778   if (kind == DEBUG_PARM_REG || kind == DEBUG_PARM_REF_REG)
1779     fprintf (info->f, "register ");
1780
1781   print_vma (val, ab, true, true);
1782   fprintf (info->f, "%s /* %s */", t, ab);
1783
1784   free (t);
1785
1786   ++info->parameter;
1787
1788   return true;
1789 }
1790
1791 /* Start writing out a block.  */
1792
1793 static boolean
1794 pr_start_block (p, addr)
1795      PTR p;
1796      bfd_vma addr;
1797 {
1798   struct pr_handle *info = (struct pr_handle *) p;
1799   char ab[20];
1800
1801   if (info->parameter > 0)
1802     {
1803       fprintf (info->f, ")\n");
1804       info->parameter = 0;
1805     }
1806
1807   indent (info);
1808   print_vma (addr, ab, true, true);
1809   fprintf (info->f, "{ /* %s */\n", ab);
1810
1811   info->indent += 2;
1812
1813   return true;
1814 }
1815
1816 /* Write out line number information.  */
1817
1818 static boolean
1819 pr_lineno (p, filename, lineno, addr)
1820      PTR p;
1821      const char *filename;
1822      unsigned long lineno;
1823      bfd_vma addr;
1824 {
1825   struct pr_handle *info = (struct pr_handle *) p;
1826   char ab[20];
1827
1828   indent (info);
1829   print_vma (addr, ab, true, true);
1830   fprintf (info->f, "/* file %s line %lu addr %s */\n", filename, lineno, ab);
1831
1832   return true;
1833 }
1834
1835 /* Finish writing out a block.  */
1836
1837 static boolean
1838 pr_end_block (p, addr)
1839      PTR p;
1840      bfd_vma addr;
1841 {
1842   struct pr_handle *info = (struct pr_handle *) p;
1843   char ab[20];
1844
1845   info->indent -= 2;
1846
1847   indent (info);
1848   print_vma (addr, ab, true, true);
1849   fprintf (info->f, "} /* %s */\n", ab);
1850
1851   return true;
1852 }
1853
1854 /* Finish writing out a function.  */
1855
1856 /*ARGSUSED*/
1857 static boolean
1858 pr_end_function (p)
1859      PTR p ATTRIBUTE_UNUSED;
1860 {
1861   return true;
1862 }