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

Subversion Repositories or1k

[/] [or1k/] [trunk/] [gdb-5.0/] [gdb/] [f-typeprint.c] - Blame information for rev 1765

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 104 markom
/* Support for printing Fortran types for GDB, the GNU debugger.
2
   Copyright 1986, 1988, 1989, 1991, 1993, 1994, 2000 Free Software Foundation, Inc.
3
   Contributed by Motorola.  Adapted from the C version by Farooq Butt
4
   (fmbutt@engage.sps.mot.com).
5
 
6
   This file is part of GDB.
7
 
8
   This program is free software; you can redistribute it and/or modify
9
   it under the terms of the GNU General Public License as published by
10
   the Free Software Foundation; either version 2 of the License, or
11
   (at your option) any later version.
12
 
13
   This program is distributed in the hope that it will be useful,
14
   but WITHOUT ANY WARRANTY; without even the implied warranty of
15
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16
   GNU General Public License for more details.
17
 
18
   You should have received a copy of the GNU General Public License
19
   along with this program; if not, write to the Free Software
20
   Foundation, Inc., 59 Temple Place - Suite 330,
21
   Boston, MA 02111-1307, USA.  */
22
 
23
#include "defs.h"
24
#include "obstack.h"
25
#include "bfd.h"
26
#include "symtab.h"
27
#include "gdbtypes.h"
28
#include "expression.h"
29
#include "value.h"
30
#include "gdbcore.h"
31
#include "target.h"
32
#include "command.h"
33
#include "gdbcmd.h"
34
#include "language.h"
35
#include "demangle.h"
36
#include "f-lang.h"
37
#include "typeprint.h"
38
#include "frame.h"              /* ??? */
39
 
40
#include "gdb_string.h"
41
#include <errno.h>
42
 
43
#if 0                           /* Currently unused */
44
static void f_type_print_args (struct type *, struct ui_file *);
45
#endif
46
 
47
static void print_equivalent_f77_float_type (struct type *,
48
                                             struct ui_file *);
49
 
50
static void f_type_print_varspec_suffix (struct type *, struct ui_file *,
51
                                         int, int, int);
52
 
53
void f_type_print_varspec_prefix (struct type *, struct ui_file *,
54
                                  int, int);
55
 
56
void f_type_print_base (struct type *, struct ui_file *, int, int);
57
 
58
 
59
/* LEVEL is the depth to indent lines by.  */
60
 
61
void
62
f_print_type (type, varstring, stream, show, level)
63
     struct type *type;
64
     char *varstring;
65
     struct ui_file *stream;
66
     int show;
67
     int level;
68
{
69
  register enum type_code code;
70
  int demangled_args;
71
 
72
  f_type_print_base (type, stream, show, level);
73
  code = TYPE_CODE (type);
74
  if ((varstring != NULL && *varstring != '\0')
75
      ||
76
  /* Need a space if going to print stars or brackets;
77
     but not if we will print just a type name.  */
78
      ((show > 0 || TYPE_NAME (type) == 0)
79
       &&
80
       (code == TYPE_CODE_PTR || code == TYPE_CODE_FUNC
81
        || code == TYPE_CODE_METHOD
82
        || code == TYPE_CODE_ARRAY
83
        || code == TYPE_CODE_MEMBER
84
        || code == TYPE_CODE_REF)))
85
    fputs_filtered (" ", stream);
86
  f_type_print_varspec_prefix (type, stream, show, 0);
87
 
88
  fputs_filtered (varstring, stream);
89
 
90
  /* For demangled function names, we have the arglist as part of the name,
91
     so don't print an additional pair of ()'s */
92
 
93
  demangled_args = varstring[strlen (varstring) - 1] == ')';
94
  f_type_print_varspec_suffix (type, stream, show, 0, demangled_args);
95
}
96
 
97
/* Print any asterisks or open-parentheses needed before the
98
   variable name (to describe its type).
99
 
100
   On outermost call, pass 0 for PASSED_A_PTR.
101
   On outermost call, SHOW > 0 means should ignore
102
   any typename for TYPE and show its details.
103
   SHOW is always zero on recursive calls.  */
104
 
105
void
106
f_type_print_varspec_prefix (type, stream, show, passed_a_ptr)
107
     struct type *type;
108
     struct ui_file *stream;
109
     int show;
110
     int passed_a_ptr;
111
{
112
  if (type == 0)
113
    return;
114
 
115
  if (TYPE_NAME (type) && show <= 0)
116
    return;
117
 
118
  QUIT;
119
 
120
  switch (TYPE_CODE (type))
121
    {
122
    case TYPE_CODE_PTR:
123
      f_type_print_varspec_prefix (TYPE_TARGET_TYPE (type), stream, 0, 1);
124
      break;
125
 
126
    case TYPE_CODE_FUNC:
127
      f_type_print_varspec_prefix (TYPE_TARGET_TYPE (type), stream, 0, 0);
128
      if (passed_a_ptr)
129
        fprintf_filtered (stream, "(");
130
      break;
131
 
132
    case TYPE_CODE_ARRAY:
133
      f_type_print_varspec_prefix (TYPE_TARGET_TYPE (type), stream, 0, 0);
134
      break;
135
 
136
    case TYPE_CODE_UNDEF:
137
    case TYPE_CODE_STRUCT:
138
    case TYPE_CODE_UNION:
139
    case TYPE_CODE_ENUM:
140
    case TYPE_CODE_INT:
141
    case TYPE_CODE_FLT:
142
    case TYPE_CODE_VOID:
143
    case TYPE_CODE_ERROR:
144
    case TYPE_CODE_CHAR:
145
    case TYPE_CODE_BOOL:
146
    case TYPE_CODE_SET:
147
    case TYPE_CODE_RANGE:
148
    case TYPE_CODE_STRING:
149
    case TYPE_CODE_BITSTRING:
150
    case TYPE_CODE_METHOD:
151
    case TYPE_CODE_MEMBER:
152
    case TYPE_CODE_REF:
153
    case TYPE_CODE_COMPLEX:
154
    case TYPE_CODE_TYPEDEF:
155
      /* These types need no prefix.  They are listed here so that
156
         gcc -Wall will reveal any types that haven't been handled.  */
157
      break;
158
    }
159
}
160
 
161
#if 0                           /* Currently unused */
162
 
163
static void
164
f_type_print_args (type, stream)
165
     struct type *type;
166
     struct ui_file *stream;
167
{
168
  int i;
169
  struct type **args;
170
 
171
  fprintf_filtered (stream, "(");
172
  args = TYPE_ARG_TYPES (type);
173
  if (args != NULL)
174
    {
175
      if (args[1] == NULL)
176
        {
177
          fprintf_filtered (stream, "...");
178
        }
179
      else
180
        {
181
          for (i = 1; args[i] != NULL && args[i]->code != TYPE_CODE_VOID; i++)
182
            {
183
              f_print_type (args[i], "", stream, -1, 0);
184
              if (args[i + 1] == NULL)
185
                fprintf_filtered (stream, "...");
186
              else if (args[i + 1]->code != TYPE_CODE_VOID)
187
                {
188
                  fprintf_filtered (stream, ",");
189
                  wrap_here ("    ");
190
                }
191
            }
192
        }
193
    }
194
  fprintf_filtered (stream, ")");
195
}
196
 
197
#endif /* 0 */
198
 
199
/* Print any array sizes, function arguments or close parentheses
200
   needed after the variable name (to describe its type).
201
   Args work like c_type_print_varspec_prefix.  */
202
 
203
static void
204
f_type_print_varspec_suffix (type, stream, show, passed_a_ptr, demangled_args)
205
     struct type *type;
206
     struct ui_file *stream;
207
     int show;
208
     int passed_a_ptr;
209
     int demangled_args;
210
{
211
  int upper_bound, lower_bound;
212
  int lower_bound_was_default = 0;
213
  static int arrayprint_recurse_level = 0;
214
  int retcode;
215
 
216
  if (type == 0)
217
    return;
218
 
219
  if (TYPE_NAME (type) && show <= 0)
220
    return;
221
 
222
  QUIT;
223
 
224
  switch (TYPE_CODE (type))
225
    {
226
    case TYPE_CODE_ARRAY:
227
      arrayprint_recurse_level++;
228
 
229
      if (arrayprint_recurse_level == 1)
230
        fprintf_filtered (stream, "(");
231
 
232
      if (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_ARRAY)
233
        f_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, 0, 0, 0);
234
 
235
      retcode = f77_get_dynamic_lowerbound (type, &lower_bound);
236
 
237
      lower_bound_was_default = 0;
238
 
239
      if (retcode == BOUND_FETCH_ERROR)
240
        fprintf_filtered (stream, "???");
241
      else if (lower_bound == 1)        /* The default */
242
        lower_bound_was_default = 1;
243
      else
244
        fprintf_filtered (stream, "%d", lower_bound);
245
 
246
      if (lower_bound_was_default)
247
        lower_bound_was_default = 0;
248
      else
249
        fprintf_filtered (stream, ":");
250
 
251
      /* Make sure that, if we have an assumed size array, we
252
         print out a warning and print the upperbound as '*' */
253
 
254
      if (TYPE_ARRAY_UPPER_BOUND_TYPE (type) == BOUND_CANNOT_BE_DETERMINED)
255
        fprintf_filtered (stream, "*");
256
      else
257
        {
258
          retcode = f77_get_dynamic_upperbound (type, &upper_bound);
259
 
260
          if (retcode == BOUND_FETCH_ERROR)
261
            fprintf_filtered (stream, "???");
262
          else
263
            fprintf_filtered (stream, "%d", upper_bound);
264
        }
265
 
266
      if (TYPE_CODE (TYPE_TARGET_TYPE (type)) != TYPE_CODE_ARRAY)
267
        f_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, 0, 0, 0);
268
      if (arrayprint_recurse_level == 1)
269
        fprintf_filtered (stream, ")");
270
      else
271
        fprintf_filtered (stream, ",");
272
      arrayprint_recurse_level--;
273
      break;
274
 
275
    case TYPE_CODE_PTR:
276
    case TYPE_CODE_REF:
277
      f_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, 0, 1, 0);
278
      fprintf_filtered (stream, ")");
279
      break;
280
 
281
    case TYPE_CODE_FUNC:
282
      f_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, 0,
283
                                   passed_a_ptr, 0);
284
      if (passed_a_ptr)
285
        fprintf_filtered (stream, ")");
286
 
287
      fprintf_filtered (stream, "()");
288
      break;
289
 
290
    case TYPE_CODE_UNDEF:
291
    case TYPE_CODE_STRUCT:
292
    case TYPE_CODE_UNION:
293
    case TYPE_CODE_ENUM:
294
    case TYPE_CODE_INT:
295
    case TYPE_CODE_FLT:
296
    case TYPE_CODE_VOID:
297
    case TYPE_CODE_ERROR:
298
    case TYPE_CODE_CHAR:
299
    case TYPE_CODE_BOOL:
300
    case TYPE_CODE_SET:
301
    case TYPE_CODE_RANGE:
302
    case TYPE_CODE_STRING:
303
    case TYPE_CODE_BITSTRING:
304
    case TYPE_CODE_METHOD:
305
    case TYPE_CODE_MEMBER:
306
    case TYPE_CODE_COMPLEX:
307
    case TYPE_CODE_TYPEDEF:
308
      /* These types do not need a suffix.  They are listed so that
309
         gcc -Wall will report types that may not have been considered.  */
310
      break;
311
    }
312
}
313
 
314
static void
315
print_equivalent_f77_float_type (type, stream)
316
     struct type *type;
317
     struct ui_file *stream;
318
{
319
  /* Override type name "float" and make it the
320
     appropriate real. XLC stupidly outputs -12 as a type
321
     for real when it really should be outputting -18 */
322
 
323
  fprintf_filtered (stream, "real*%d", TYPE_LENGTH (type));
324
}
325
 
326
/* Print the name of the type (or the ultimate pointer target,
327
   function value or array element), or the description of a
328
   structure or union.
329
 
330
   SHOW nonzero means don't print this type as just its name;
331
   show its real definition even if it has a name.
332
   SHOW zero means print just typename or struct tag if there is one
333
   SHOW negative means abbreviate structure elements.
334
   SHOW is decremented for printing of structure elements.
335
 
336
   LEVEL is the depth to indent by.
337
   We increase it for some recursive calls.  */
338
 
339
void
340
f_type_print_base (type, stream, show, level)
341
     struct type *type;
342
     struct ui_file *stream;
343
     int show;
344
     int level;
345
{
346
  int retcode;
347
  int upper_bound;
348
 
349
  QUIT;
350
 
351
  wrap_here ("    ");
352
  if (type == NULL)
353
    {
354
      fputs_filtered ("<type unknown>", stream);
355
      return;
356
    }
357
 
358
  /* When SHOW is zero or less, and there is a valid type name, then always
359
     just print the type name directly from the type. */
360
 
361
  if ((show <= 0) && (TYPE_NAME (type) != NULL))
362
    {
363
      if (TYPE_CODE (type) == TYPE_CODE_FLT)
364
        print_equivalent_f77_float_type (type, stream);
365
      else
366
        fputs_filtered (TYPE_NAME (type), stream);
367
      return;
368
    }
369
 
370
  if (TYPE_CODE (type) != TYPE_CODE_TYPEDEF)
371
    CHECK_TYPEDEF (type);
372
 
373
  switch (TYPE_CODE (type))
374
    {
375
    case TYPE_CODE_TYPEDEF:
376
      f_type_print_base (TYPE_TARGET_TYPE (type), stream, 0, level);
377
      break;
378
 
379
    case TYPE_CODE_ARRAY:
380
    case TYPE_CODE_FUNC:
381
      f_type_print_base (TYPE_TARGET_TYPE (type), stream, show, level);
382
      break;
383
 
384
    case TYPE_CODE_PTR:
385
      fprintf_filtered (stream, "PTR TO -> ( ");
386
      f_type_print_base (TYPE_TARGET_TYPE (type), stream, 0, level);
387
      break;
388
 
389
    case TYPE_CODE_VOID:
390
      fprintf_filtered (stream, "VOID");
391
      break;
392
 
393
    case TYPE_CODE_UNDEF:
394
      fprintf_filtered (stream, "struct <unknown>");
395
      break;
396
 
397
    case TYPE_CODE_ERROR:
398
      fprintf_filtered (stream, "<unknown type>");
399
      break;
400
 
401
    case TYPE_CODE_RANGE:
402
      /* This should not occur */
403
      fprintf_filtered (stream, "<range type>");
404
      break;
405
 
406
    case TYPE_CODE_CHAR:
407
      /* Override name "char" and make it "character" */
408
      fprintf_filtered (stream, "character");
409
      break;
410
 
411
    case TYPE_CODE_INT:
412
      /* There may be some character types that attempt to come
413
         through as TYPE_CODE_INT since dbxstclass.h is so
414
         C-oriented, we must change these to "character" from "char".  */
415
 
416
      if (STREQ (TYPE_NAME (type), "char"))
417
        fprintf_filtered (stream, "character");
418
      else
419
        goto default_case;
420
      break;
421
 
422
    case TYPE_CODE_COMPLEX:
423
      fprintf_filtered (stream, "complex*%d", TYPE_LENGTH (type));
424
      break;
425
 
426
    case TYPE_CODE_FLT:
427
      print_equivalent_f77_float_type (type, stream);
428
      break;
429
 
430
    case TYPE_CODE_STRING:
431
      /* Strings may have dynamic upperbounds (lengths) like arrays. */
432
 
433
      if (TYPE_ARRAY_UPPER_BOUND_TYPE (type) == BOUND_CANNOT_BE_DETERMINED)
434
        fprintf_filtered (stream, "character*(*)");
435
      else
436
        {
437
          retcode = f77_get_dynamic_upperbound (type, &upper_bound);
438
 
439
          if (retcode == BOUND_FETCH_ERROR)
440
            fprintf_filtered (stream, "character*???");
441
          else
442
            fprintf_filtered (stream, "character*%d", upper_bound);
443
        }
444
      break;
445
 
446
    default_case:
447
    default:
448
      /* Handle types not explicitly handled by the other cases,
449
         such as fundamental types.  For these, just print whatever
450
         the type name is, as recorded in the type itself.  If there
451
         is no type name, then complain. */
452
      if (TYPE_NAME (type) != NULL)
453
        fputs_filtered (TYPE_NAME (type), stream);
454
      else
455
        error ("Invalid type code (%d) in symbol table.", TYPE_CODE (type));
456
      break;
457
    }
458
}

powered by: WebSVN 2.1.0

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