GDB (xrefs)
/tmp/gdb-7.10/gdb/m2-typeprint.c
Go to the documentation of this file.
1 /* Support for printing Modula 2 types for GDB, the GNU debugger.
2  Copyright (C) 1986-2015 Free Software Foundation, Inc.
3 
4  This file is part of GDB.
5 
6  This program is free software; you can redistribute it and/or modify
7  it under the terms of the GNU General Public License as published by
8  the Free Software Foundation; either version 3 of the License, or
9  (at your option) any later version.
10 
11  This program is distributed in the hope that it will be useful,
12  but WITHOUT ANY WARRANTY; without even the implied warranty of
13  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14  GNU General Public License for more details.
15 
16  You should have received a copy of the GNU General Public License
17  along with this program. If not, see <http://www.gnu.org/licenses/>. */
18 
19 #include "defs.h"
20 #include "gdb_obstack.h"
21 #include "bfd.h" /* Binary File Description */
22 #include "symtab.h"
23 #include "gdbtypes.h"
24 #include "expression.h"
25 #include "value.h"
26 #include "gdbcore.h"
27 #include "m2-lang.h"
28 #include "target.h"
29 #include "language.h"
30 #include "demangle.h"
31 #include "c-lang.h"
32 #include "typeprint.h"
33 #include "cp-abi.h"
34 
35 static void m2_print_bounds (struct type *type,
36  struct ui_file *stream, int show, int level,
37  int print_high);
38 
39 static void m2_typedef (struct type *, struct ui_file *, int, int,
40  const struct type_print_options *);
41 static void m2_array (struct type *, struct ui_file *, int, int,
42  const struct type_print_options *);
43 static void m2_pointer (struct type *, struct ui_file *, int, int,
44  const struct type_print_options *);
45 static void m2_ref (struct type *, struct ui_file *, int, int,
46  const struct type_print_options *);
47 static void m2_procedure (struct type *, struct ui_file *, int, int,
48  const struct type_print_options *);
49 static void m2_union (struct type *, struct ui_file *);
50 static void m2_enum (struct type *, struct ui_file *, int, int);
51 static void m2_range (struct type *, struct ui_file *, int, int,
52  const struct type_print_options *);
53 static void m2_type_name (struct type *type, struct ui_file *stream);
54 static void m2_short_set (struct type *type, struct ui_file *stream,
55  int show, int level);
56 static int m2_long_set (struct type *type, struct ui_file *stream,
57  int show, int level, const struct type_print_options *flags);
58 static int m2_unbounded_array (struct type *type, struct ui_file *stream,
59  int show, int level,
60  const struct type_print_options *flags);
61 static void m2_record_fields (struct type *type, struct ui_file *stream,
62  int show, int level, const struct type_print_options *flags);
63 static void m2_unknown (const char *s, struct type *type,
64  struct ui_file *stream, int show, int level);
65 
66 int m2_is_long_set (struct type *type);
67 int m2_is_long_set_of_type (struct type *type, struct type **of_type);
68 int m2_is_unbounded_array (struct type *type);
69 
70 
71 void
72 m2_print_type (struct type *type, const char *varstring,
73  struct ui_file *stream,
74  int show, int level,
75  const struct type_print_options *flags)
76 {
77  CHECK_TYPEDEF (type);
78 
79  QUIT;
80 
81  wrap_here (" ");
82  if (type == NULL)
83  {
84  fputs_filtered (_("<type unknown>"), stream);
85  return;
86  }
87 
88  switch (TYPE_CODE (type))
89  {
90  case TYPE_CODE_SET:
91  m2_short_set(type, stream, show, level);
92  break;
93 
94  case TYPE_CODE_STRUCT:
95  if (m2_long_set (type, stream, show, level, flags)
96  || m2_unbounded_array (type, stream, show, level, flags))
97  break;
98  m2_record_fields (type, stream, show, level, flags);
99  break;
100 
101  case TYPE_CODE_TYPEDEF:
102  m2_typedef (type, stream, show, level, flags);
103  break;
104 
105  case TYPE_CODE_ARRAY:
106  m2_array (type, stream, show, level, flags);
107  break;
108 
109  case TYPE_CODE_PTR:
110  m2_pointer (type, stream, show, level, flags);
111  break;
112 
113  case TYPE_CODE_REF:
114  m2_ref (type, stream, show, level, flags);
115  break;
116 
117  case TYPE_CODE_METHOD:
118  m2_unknown (_("method"), type, stream, show, level);
119  break;
120 
121  case TYPE_CODE_FUNC:
122  m2_procedure (type, stream, show, level, flags);
123  break;
124 
125  case TYPE_CODE_UNION:
126  m2_union (type, stream);
127  break;
128 
129  case TYPE_CODE_ENUM:
130  m2_enum (type, stream, show, level);
131  break;
132 
133  case TYPE_CODE_VOID:
134  break;
135 
136  case TYPE_CODE_UNDEF:
137  /* i18n: Do not translate the "struct" part! */
138  m2_unknown (_("undef"), type, stream, show, level);
139  break;
140 
141  case TYPE_CODE_ERROR:
142  m2_unknown (_("error"), type, stream, show, level);
143  break;
144 
145  case TYPE_CODE_RANGE:
146  m2_range (type, stream, show, level, flags);
147  break;
148 
149  default:
150  m2_type_name (type, stream);
151  break;
152  }
153 }
154 
155 /* Print a typedef using M2 syntax. TYPE is the underlying type.
156  NEW_SYMBOL is the symbol naming the type. STREAM is the stream on
157  which to print. */
158 
159 void
161  struct ui_file *stream)
162 {
163  CHECK_TYPEDEF (type);
164  fprintf_filtered (stream, "TYPE ");
165  if (!TYPE_NAME (SYMBOL_TYPE (new_symbol))
166  || strcmp (TYPE_NAME ((SYMBOL_TYPE (new_symbol))),
167  SYMBOL_LINKAGE_NAME (new_symbol)) != 0)
168  fprintf_filtered (stream, "%s = ", SYMBOL_PRINT_NAME (new_symbol));
169  else
170  fprintf_filtered (stream, "<builtin> = ");
171  type_print (type, "", stream, 0);
172  fprintf_filtered (stream, ";\n");
173 }
174 
175 /* m2_type_name - if a, type, has a name then print it. */
176 
177 void
178 m2_type_name (struct type *type, struct ui_file *stream)
179 {
180  if (TYPE_NAME (type) != NULL)
181  fputs_filtered (TYPE_NAME (type), stream);
182 }
183 
184 /* m2_range - displays a Modula-2 subrange type. */
185 
186 void
187 m2_range (struct type *type, struct ui_file *stream, int show,
188  int level, const struct type_print_options *flags)
189 {
190  if (TYPE_HIGH_BOUND (type) == TYPE_LOW_BOUND (type))
191  {
192  /* FIXME: TYPE_TARGET_TYPE used to be TYPE_DOMAIN_TYPE but that was
193  wrong. Not sure if TYPE_TARGET_TYPE is correct though. */
194  m2_print_type (TYPE_TARGET_TYPE (type), "", stream, show, level,
195  flags);
196  }
197  else
198  {
199  struct type *target = TYPE_TARGET_TYPE (type);
200 
201  fprintf_filtered (stream, "[");
202  print_type_scalar (target, TYPE_LOW_BOUND (type), stream);
203  fprintf_filtered (stream, "..");
204  print_type_scalar (target, TYPE_HIGH_BOUND (type), stream);
205  fprintf_filtered (stream, "]");
206  }
207 }
208 
209 static void
210 m2_typedef (struct type *type, struct ui_file *stream, int show,
211  int level, const struct type_print_options *flags)
212 {
213  if (TYPE_NAME (type) != NULL)
214  {
215  fputs_filtered (TYPE_NAME (type), stream);
216  fputs_filtered (" = ", stream);
217  }
218  m2_print_type (TYPE_TARGET_TYPE (type), "", stream, show, level, flags);
219 }
220 
221 /* m2_array - prints out a Modula-2 ARRAY ... OF type. */
222 
223 static void m2_array (struct type *type, struct ui_file *stream,
224  int show, int level, const struct type_print_options *flags)
225 {
226  fprintf_filtered (stream, "ARRAY [");
227  if (TYPE_LENGTH (TYPE_TARGET_TYPE (type)) > 0
229  {
230  if (TYPE_INDEX_TYPE (type) != 0)
231  {
232  m2_print_bounds (TYPE_INDEX_TYPE (type), stream, show, -1, 0);
233  fprintf_filtered (stream, "..");
234  m2_print_bounds (TYPE_INDEX_TYPE (type), stream, show, -1, 1);
235  }
236  else
237  fprintf_filtered (stream, "%d",
238  (TYPE_LENGTH (type)
239  / TYPE_LENGTH (TYPE_TARGET_TYPE (type))));
240  }
241  fprintf_filtered (stream, "] OF ");
242  m2_print_type (TYPE_TARGET_TYPE (type), "", stream, show, level, flags);
243 }
244 
245 static void
246 m2_pointer (struct type *type, struct ui_file *stream, int show,
247  int level, const struct type_print_options *flags)
248 {
249  if (TYPE_CONST (type))
250  fprintf_filtered (stream, "[...] : ");
251  else
252  fprintf_filtered (stream, "POINTER TO ");
253 
254  m2_print_type (TYPE_TARGET_TYPE (type), "", stream, show, level, flags);
255 }
256 
257 static void
258 m2_ref (struct type *type, struct ui_file *stream, int show,
259  int level, const struct type_print_options *flags)
260 {
261  fprintf_filtered (stream, "VAR");
262  m2_print_type (TYPE_TARGET_TYPE (type), "", stream, show, level, flags);
263 }
264 
265 static void
266 m2_unknown (const char *s, struct type *type, struct ui_file *stream,
267  int show, int level)
268 {
269  fprintf_filtered (stream, "%s %s", s, _("is unknown"));
270 }
271 
272 static void m2_union (struct type *type, struct ui_file *stream)
273 {
274  fprintf_filtered (stream, "union");
275 }
276 
277 static void
278 m2_procedure (struct type *type, struct ui_file *stream,
279  int show, int level, const struct type_print_options *flags)
280 {
281  fprintf_filtered (stream, "PROCEDURE ");
282  m2_type_name (type, stream);
283  if (TYPE_CODE (TYPE_TARGET_TYPE (type)) != TYPE_CODE_VOID)
284  {
285  int i, len = TYPE_NFIELDS (type);
286 
287  fprintf_filtered (stream, " (");
288  for (i = 0; i < len; i++)
289  {
290  if (i > 0)
291  {
292  fputs_filtered (", ", stream);
293  wrap_here (" ");
294  }
295  m2_print_type (TYPE_FIELD_TYPE (type, i), "", stream, -1, 0, flags);
296  }
297  if (TYPE_TARGET_TYPE (type) != NULL)
298  {
299  fprintf_filtered (stream, " : ");
300  m2_print_type (TYPE_TARGET_TYPE (type), "", stream, 0, 0, flags);
301  }
302  }
303 }
304 
305 static void
307  struct ui_file *stream, int show, int level,
308  int print_high)
309 {
310  struct type *target = TYPE_TARGET_TYPE (type);
311 
312  if (TYPE_NFIELDS(type) == 0)
313  return;
314 
315  if (print_high)
316  print_type_scalar (target, TYPE_HIGH_BOUND (type), stream);
317  else
318  print_type_scalar (target, TYPE_LOW_BOUND (type), stream);
319 }
320 
321 static void
322 m2_short_set (struct type *type, struct ui_file *stream, int show, int level)
323 {
324  fprintf_filtered(stream, "SET [");
325  m2_print_bounds (TYPE_INDEX_TYPE (type), stream,
326  show - 1, level, 0);
327 
328  fprintf_filtered(stream, "..");
329  m2_print_bounds (TYPE_INDEX_TYPE (type), stream,
330  show - 1, level, 1);
331  fprintf_filtered(stream, "]");
332 }
333 
334 int
336 {
337  LONGEST previous_high = 0; /* Unnecessary initialization
338  keeps gcc -Wall happy. */
339  int len, i;
340  struct type *range;
341 
342  if (TYPE_CODE (type) == TYPE_CODE_STRUCT)
343  {
344 
345  /* check if all fields of the RECORD are consecutive sets. */
346 
347  len = TYPE_NFIELDS (type);
348  for (i = TYPE_N_BASECLASSES (type); i < len; i++)
349  {
350  if (TYPE_FIELD_TYPE (type, i) == NULL)
351  return 0;
352  if (TYPE_CODE (TYPE_FIELD_TYPE (type, i)) != TYPE_CODE_SET)
353  return 0;
354  if (TYPE_FIELD_NAME (type, i) != NULL
355  && (strcmp (TYPE_FIELD_NAME (type, i), "") != 0))
356  return 0;
357  range = TYPE_INDEX_TYPE (TYPE_FIELD_TYPE (type, i));
358  if ((i > TYPE_N_BASECLASSES (type))
359  && previous_high + 1 != TYPE_LOW_BOUND (range))
360  return 0;
361  previous_high = TYPE_HIGH_BOUND (range);
362  }
363  return len>0;
364  }
365  return 0;
366 }
367 
368 /* m2_get_discrete_bounds - a wrapper for get_discrete_bounds which
369  understands that CHARs might be signed.
370  This should be integrated into gdbtypes.c
371  inside get_discrete_bounds. */
372 
373 static int
375 {
376  CHECK_TYPEDEF (type);
377  switch (TYPE_CODE (type))
378  {
379  case TYPE_CODE_CHAR:
380  if (TYPE_LENGTH (type) < sizeof (LONGEST))
381  {
382  if (!TYPE_UNSIGNED (type))
383  {
384  *lowp = -(1 << (TYPE_LENGTH (type) * TARGET_CHAR_BIT - 1));
385  *highp = -*lowp - 1;
386  return 0;
387  }
388  }
389  /* fall through */
390  default:
391  return get_discrete_bounds (type, lowp, highp);
392  }
393 }
394 
395 /* m2_is_long_set_of_type - returns TRUE if the long set was declared as
396  SET OF <oftype> of_type is assigned to the
397  subtype. */
398 
399 int
400 m2_is_long_set_of_type (struct type *type, struct type **of_type)
401 {
402  int len, i;
403  struct type *range;
404  struct type *target;
405  LONGEST l1, l2;
406  LONGEST h1, h2;
407 
408  if (TYPE_CODE (type) == TYPE_CODE_STRUCT)
409  {
410  len = TYPE_NFIELDS (type);
411  i = TYPE_N_BASECLASSES (type);
412  if (len == 0)
413  return 0;
414  range = TYPE_INDEX_TYPE (TYPE_FIELD_TYPE (type, i));
415  target = TYPE_TARGET_TYPE (range);
416 
418  h1 = TYPE_HIGH_BOUND (TYPE_INDEX_TYPE (TYPE_FIELD_TYPE (type, len-1)));
419  *of_type = target;
420  if (m2_get_discrete_bounds (target, &l2, &h2) >= 0)
421  return (l1 == l2 && h1 == h2);
422  error (_("long_set failed to find discrete bounds for its subtype"));
423  return 0;
424  }
425  error (_("expecting long_set"));
426  return 0;
427 }
428 
429 static int
430 m2_long_set (struct type *type, struct ui_file *stream, int show, int level,
431  const struct type_print_options *flags)
432 {
433  struct type *of_type;
434  int i;
435  int len = TYPE_NFIELDS (type);
436  LONGEST low;
437  LONGEST high;
438 
439  if (m2_is_long_set (type))
440  {
441  if (TYPE_TAG_NAME (type) != NULL)
442  {
443  fputs_filtered (TYPE_TAG_NAME (type), stream);
444  if (show == 0)
445  return 1;
446  }
447  else if (TYPE_NAME (type) != NULL)
448  {
449  fputs_filtered (TYPE_NAME (type), stream);
450  if (show == 0)
451  return 1;
452  }
453 
454  if (TYPE_TAG_NAME (type) != NULL || TYPE_NAME (type) != NULL)
455  fputs_filtered (" = ", stream);
456 
457  if (get_long_set_bounds (type, &low, &high))
458  {
459  fprintf_filtered(stream, "SET OF ");
460  i = TYPE_N_BASECLASSES (type);
461  if (m2_is_long_set_of_type (type, &of_type))
462  m2_print_type (of_type, "", stream, show - 1, level, flags);
463  else
464  {
465  fprintf_filtered(stream, "[");
467  stream, show - 1, level, 0);
468 
469  fprintf_filtered(stream, "..");
470 
472  stream, show - 1, level, 1);
473  fprintf_filtered(stream, "]");
474  }
475  }
476  else
477  /* i18n: Do not translate the "SET OF" part! */
478  fprintf_filtered(stream, _("SET OF <unknown>"));
479 
480  return 1;
481  }
482  return 0;
483 }
484 
485 /* m2_is_unbounded_array - returns TRUE if, type, should be regarded
486  as a Modula-2 unbounded ARRAY type. */
487 
488 int
490 {
491  if (TYPE_CODE (type) == TYPE_CODE_STRUCT)
492  {
493  /*
494  * check if we have a structure with exactly two fields named
495  * _m2_contents and _m2_high. It also checks to see if the
496  * type of _m2_contents is a pointer. The TYPE_TARGET_TYPE
497  * of the pointer determines the unbounded ARRAY OF type.
498  */
499  if (TYPE_NFIELDS (type) != 2)
500  return 0;
501  if (strcmp (TYPE_FIELD_NAME (type, 0), "_m2_contents") != 0)
502  return 0;
503  if (strcmp (TYPE_FIELD_NAME (type, 1), "_m2_high") != 0)
504  return 0;
505  if (TYPE_CODE (TYPE_FIELD_TYPE (type, 0)) != TYPE_CODE_PTR)
506  return 0;
507  return 1;
508  }
509  return 0;
510 }
511 
512 /* m2_unbounded_array - if the struct type matches a Modula-2 unbounded
513  parameter type then display the type as an
514  ARRAY OF type. Returns TRUE if an unbounded
515  array type was detected. */
516 
517 static int
518 m2_unbounded_array (struct type *type, struct ui_file *stream, int show,
519  int level, const struct type_print_options *flags)
520 {
521  if (m2_is_unbounded_array (type))
522  {
523  if (show > 0)
524  {
525  fputs_filtered ("ARRAY OF ", stream);
527  "", stream, 0, level, flags);
528  }
529  return 1;
530  }
531  return 0;
532 }
533 
534 void
535 m2_record_fields (struct type *type, struct ui_file *stream, int show,
536  int level, const struct type_print_options *flags)
537 {
538  /* Print the tag if it exists. */
539  if (TYPE_TAG_NAME (type) != NULL)
540  {
541  if (!startswith (TYPE_TAG_NAME (type), "$$"))
542  {
543  fputs_filtered (TYPE_TAG_NAME (type), stream);
544  if (show > 0)
545  fprintf_filtered (stream, " = ");
546  }
547  }
548  wrap_here (" ");
549  if (show < 0)
550  {
551  if (TYPE_CODE (type) == TYPE_CODE_STRUCT)
552  fprintf_filtered (stream, "RECORD ... END ");
553  else if (TYPE_CODE (type) == TYPE_CODE_UNION)
554  fprintf_filtered (stream, "CASE ... END ");
555  }
556  else if (show > 0)
557  {
558  int i;
559  int len = TYPE_NFIELDS (type);
560 
561  if (TYPE_CODE (type) == TYPE_CODE_STRUCT)
562  fprintf_filtered (stream, "RECORD\n");
563  else if (TYPE_CODE (type) == TYPE_CODE_UNION)
564  /* i18n: Do not translate "CASE" and "OF". */
565  fprintf_filtered (stream, _("CASE <variant> OF\n"));
566 
567  for (i = TYPE_N_BASECLASSES (type); i < len; i++)
568  {
569  QUIT;
570 
571  print_spaces_filtered (level + 4, stream);
572  fputs_filtered (TYPE_FIELD_NAME (type, i), stream);
573  fputs_filtered (" : ", stream);
574  m2_print_type (TYPE_FIELD_TYPE (type, i),
575  "",
576  stream, 0, level + 4, flags);
577  if (TYPE_FIELD_PACKED (type, i))
578  {
579  /* It is a bitfield. This code does not attempt
580  to look at the bitpos and reconstruct filler,
581  unnamed fields. This would lead to misleading
582  results if the compiler does not put out fields
583  for such things (I don't know what it does). */
584  fprintf_filtered (stream, " : %d",
585  TYPE_FIELD_BITSIZE (type, i));
586  }
587  fprintf_filtered (stream, ";\n");
588  }
589 
590  fprintfi_filtered (level, stream, "END ");
591  }
592 }
593 
594 void
595 m2_enum (struct type *type, struct ui_file *stream, int show, int level)
596 {
597  LONGEST lastval;
598  int i, len;
599 
600  if (show < 0)
601  {
602  /* If we just printed a tag name, no need to print anything else. */
603  if (TYPE_TAG_NAME (type) == NULL)
604  fprintf_filtered (stream, "(...)");
605  }
606  else if (show > 0 || TYPE_TAG_NAME (type) == NULL)
607  {
608  fprintf_filtered (stream, "(");
609  len = TYPE_NFIELDS (type);
610  lastval = 0;
611  for (i = 0; i < len; i++)
612  {
613  QUIT;
614  if (i > 0)
615  fprintf_filtered (stream, ", ");
616  wrap_here (" ");
617  fputs_filtered (TYPE_FIELD_NAME (type, i), stream);
618  if (lastval != TYPE_FIELD_ENUMVAL (type, i))
619  {
620  fprintf_filtered (stream, " = %s",
621  plongest (TYPE_FIELD_ENUMVAL (type, i)));
622  lastval = TYPE_FIELD_ENUMVAL (type, i);
623  }
624  lastval++;
625  }
626  fprintf_filtered (stream, ")");
627  }
628 }
static int m2_get_discrete_bounds(struct type *type, LONGEST *lowp, LONGEST *highp)
Definition: m2-typeprint.c:374
static const char * range
Definition: language.c:104
void m2_print_type(struct type *type, const char *varstring, struct ui_file *stream, int show, int level, const struct type_print_options *flags)
Definition: m2-typeprint.c:72
#define SYMBOL_PRINT_NAME(symbol)
Definition: symtab.h:260
#define TYPE_FIELD_NAME(thistype, n)
Definition: gdbtypes.h:1369
#define TYPE_N_BASECLASSES(thistype)
Definition: gdbtypes.h:1327
#define TYPE_LOW_BOUND(range_type)
Definition: gdbtypes.h:1246
#define TYPE_NAME(thistype)
Definition: gdbtypes.h:1227
static void m2_print_bounds(struct type *type, struct ui_file *stream, int show, int level, int print_high)
Definition: m2-typeprint.c:306
#define TYPE_HIGH_BOUND(range_type)
Definition: gdbtypes.h:1248
static void m2_typedef(struct type *, struct ui_file *, int, int, const struct type_print_options *)
Definition: m2-typeprint.c:210
void type_print(struct type *type, const char *varstring, struct ui_file *stream, int show)
Definition: typeprint.c:360
static void m2_record_fields(struct type *type, struct ui_file *stream, int show, int level, const struct type_print_options *flags)
Definition: m2-typeprint.c:535
#define _(String)
Definition: gdb_locale.h:40
void m2_print_typedef(struct type *type, struct symbol *new_symbol, struct ui_file *stream)
Definition: m2-typeprint.c:160
#define TYPE_FIELD_ENUMVAL(thistype, n)
Definition: gdbtypes.h:1372
#define TYPE_FIELD_TYPE(thistype, n)
Definition: gdbtypes.h:1368
static void m2_ref(struct type *, struct ui_file *, int, int, const struct type_print_options *)
Definition: m2-typeprint.c:258
mach_port_t kern_return_t mach_port_t msgports mach_port_t kern_return_t pid_t pid mach_port_t kern_return_t mach_port_t task mach_port_t kern_return_t int flags
Definition: gnu-nat.c:1885
void fprintf_filtered(struct ui_file *stream, const char *format,...)
Definition: utils.c:2351
void fputs_filtered(const char *linebuffer, struct ui_file *stream)
Definition: utils.c:2145
#define TARGET_CHAR_BIT
Definition: host-defs.h:29
Definition: gdbtypes.h:749
static void m2_type_name(struct type *type, struct ui_file *stream)
Definition: m2-typeprint.c:178
#define SYMBOL_LINKAGE_NAME(symbol)
Definition: symtab.h:241
static int startswith(const char *string, const char *pattern)
Definition: common-utils.h:75
void print_type_scalar(struct type *type, LONGEST val, struct ui_file *stream)
Definition: typeprint.c:522
static struct symbol * new_symbol(struct die_info *, struct type *, struct dwarf2_cu *)
Definition: dwarf2read.c:18642
void wrap_here(char *indent)
Definition: utils.c:1930
#define TYPE_FIELD_PACKED(thistype, n)
Definition: gdbtypes.h:1378
#define TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED(arraytype)
Definition: gdbtypes.h:1282
#define TYPE_FIELD_BITSIZE(thistype, n)
Definition: gdbtypes.h:1377
static void m2_range(struct type *, struct ui_file *, int, int, const struct type_print_options *)
Definition: m2-typeprint.c:187
static void m2_union(struct type *, struct ui_file *)
Definition: m2-typeprint.c:272
#define TYPE_UNSIGNED(t)
Definition: gdbtypes.h:233
static void m2_procedure(struct type *, struct ui_file *, int, int, const struct type_print_options *)
Definition: m2-typeprint.c:278
void fprintfi_filtered(int spaces, struct ui_file *stream, const char *format,...)
Definition: utils.c:2374
static void m2_pointer(struct type *, struct ui_file *, int, int, const struct type_print_options *)
Definition: m2-typeprint.c:246
void print_spaces_filtered(int n, struct ui_file *stream)
Definition: utils.c:2464
static int m2_long_set(struct type *type, struct ui_file *stream, int show, int level, const struct type_print_options *flags)
Definition: m2-typeprint.c:430
#define TYPE_TARGET_TYPE(thistype)
Definition: gdbtypes.h:1229
static void m2_array(struct type *, struct ui_file *, int, int, const struct type_print_options *)
Definition: m2-typeprint.c:223
#define TYPE_CODE(thistype)
Definition: gdbtypes.h:1240
#define TYPE_INDEX_TYPE(type)
Definition: gdbtypes.h:1244
#define TYPE_NFIELDS(thistype)
Definition: gdbtypes.h:1241
int m2_is_unbounded_array(struct type *type)
Definition: m2-typeprint.c:489
#define CHECK_TYPEDEF(TYPE)
Definition: gdbtypes.h:1817
#define TYPE_TAG_NAME(type)
Definition: gdbtypes.h:1228
#define SYMBOL_TYPE(symbol)
Definition: symtab.h:799
Definition: symtab.h:703
#define TYPE_LENGTH(thistype)
Definition: gdbtypes.h:1237
#define QUIT
Definition: defs.h:160
int get_long_set_bounds(struct type *type, LONGEST *low, LONGEST *high)
Definition: m2-valprint.c:49
static void m2_short_set(struct type *type, struct ui_file *stream, int show, int level)
Definition: m2-typeprint.c:322
#define TYPE_CONST(t)
Definition: gdbtypes.h:345
int get_discrete_bounds(struct type *type, LONGEST *lowp, LONGEST *highp)
Definition: gdbtypes.c:899
void error(const char *fmt,...)
Definition: errors.c:38
static void m2_unknown(const char *s, struct type *type, struct ui_file *stream, int show, int level)
Definition: m2-typeprint.c:266
static int m2_unbounded_array(struct type *type, struct ui_file *stream, int show, int level, const struct type_print_options *flags)
Definition: m2-typeprint.c:518
long long LONGEST
Definition: common-types.h:52
int m2_is_long_set_of_type(struct type *type, struct type **of_type)
Definition: m2-typeprint.c:400
static void m2_enum(struct type *, struct ui_file *, int, int)
Definition: m2-typeprint.c:595
int m2_is_long_set(struct type *type)
Definition: m2-typeprint.c:335
const ULONGEST const LONGEST len
Definition: target.h:309