OpenCores
URL https://opencores.org/ocsvn/openrisc_2011-10-31/openrisc_2011-10-31/trunk

Subversion Repositories openrisc_2011-10-31

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-7.1/] [gdb/] [m2-lang.c] - Blame information for rev 227

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 227 jeremybenn
/* Modula 2 language support routines for GDB, the GNU debugger.
2
 
3
   Copyright (C) 1992, 1993, 1994, 1995, 1996, 1998, 2000, 2002, 2003, 2004,
4
   2005, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
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 3 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, see <http://www.gnu.org/licenses/>.  */
20
 
21
#include "defs.h"
22
#include "symtab.h"
23
#include "gdbtypes.h"
24
#include "expression.h"
25
#include "parser-defs.h"
26
#include "language.h"
27
#include "m2-lang.h"
28
#include "c-lang.h"
29
#include "valprint.h"
30
 
31
extern void _initialize_m2_language (void);
32
static void m2_printchar (int, struct type *, struct ui_file *);
33
static void m2_emit_char (int, struct type *, struct ui_file *, int);
34
 
35
/* Print the character C on STREAM as part of the contents of a literal
36
   string whose delimiter is QUOTER.  Note that that format for printing
37
   characters and strings is language specific.
38
   FIXME:  This is a copy of the same function from c-exp.y.  It should
39
   be replaced with a true Modula version.  */
40
 
41
static void
42
m2_emit_char (int c, struct type *type, struct ui_file *stream, int quoter)
43
{
44
 
45
  c &= 0xFF;                    /* Avoid sign bit follies */
46
 
47
  if (PRINT_LITERAL_FORM (c))
48
    {
49
      if (c == '\\' || c == quoter)
50
        {
51
          fputs_filtered ("\\", stream);
52
        }
53
      fprintf_filtered (stream, "%c", c);
54
    }
55
  else
56
    {
57
      switch (c)
58
        {
59
        case '\n':
60
          fputs_filtered ("\\n", stream);
61
          break;
62
        case '\b':
63
          fputs_filtered ("\\b", stream);
64
          break;
65
        case '\t':
66
          fputs_filtered ("\\t", stream);
67
          break;
68
        case '\f':
69
          fputs_filtered ("\\f", stream);
70
          break;
71
        case '\r':
72
          fputs_filtered ("\\r", stream);
73
          break;
74
        case '\033':
75
          fputs_filtered ("\\e", stream);
76
          break;
77
        case '\007':
78
          fputs_filtered ("\\a", stream);
79
          break;
80
        default:
81
          fprintf_filtered (stream, "\\%.3o", (unsigned int) c);
82
          break;
83
        }
84
    }
85
}
86
 
87
/* FIXME:  This is a copy of the same function from c-exp.y.  It should
88
   be replaced with a true Modula version.  */
89
 
90
static void
91
m2_printchar (int c, struct type *type, struct ui_file *stream)
92
{
93
  fputs_filtered ("'", stream);
94
  LA_EMIT_CHAR (c, type, stream, '\'');
95
  fputs_filtered ("'", stream);
96
}
97
 
98
/* Print the character string STRING, printing at most LENGTH characters.
99
   Printing stops early if the number hits print_max; repeat counts
100
   are printed as appropriate.  Print ellipses at the end if we
101
   had to stop before printing LENGTH characters, or if FORCE_ELLIPSES.
102
   FIXME:  This is a copy of the same function from c-exp.y.  It should
103
   be replaced with a true Modula version.  */
104
 
105
static void
106
m2_printstr (struct ui_file *stream, struct type *type, const gdb_byte *string,
107
             unsigned int length, const char *encoding, int force_ellipses,
108
             const struct value_print_options *options)
109
{
110
  unsigned int i;
111
  unsigned int things_printed = 0;
112
  int in_quotes = 0;
113
  int need_comma = 0;
114
  int width = TYPE_LENGTH (type);
115
 
116
  if (length == 0)
117
    {
118
      fputs_filtered ("\"\"", gdb_stdout);
119
      return;
120
    }
121
 
122
  for (i = 0; i < length && things_printed < options->print_max; ++i)
123
    {
124
      /* Position of the character we are examining
125
         to see whether it is repeated.  */
126
      unsigned int rep1;
127
      /* Number of repetitions we have detected so far.  */
128
      unsigned int reps;
129
 
130
      QUIT;
131
 
132
      if (need_comma)
133
        {
134
          fputs_filtered (", ", stream);
135
          need_comma = 0;
136
        }
137
 
138
      rep1 = i + 1;
139
      reps = 1;
140
      while (rep1 < length && string[rep1] == string[i])
141
        {
142
          ++rep1;
143
          ++reps;
144
        }
145
 
146
      if (reps > options->repeat_count_threshold)
147
        {
148
          if (in_quotes)
149
            {
150
              if (options->inspect_it)
151
                fputs_filtered ("\\\", ", stream);
152
              else
153
                fputs_filtered ("\", ", stream);
154
              in_quotes = 0;
155
            }
156
          m2_printchar (string[i], type, stream);
157
          fprintf_filtered (stream, " <repeats %u times>", reps);
158
          i = rep1 - 1;
159
          things_printed += options->repeat_count_threshold;
160
          need_comma = 1;
161
        }
162
      else
163
        {
164
          if (!in_quotes)
165
            {
166
              if (options->inspect_it)
167
                fputs_filtered ("\\\"", stream);
168
              else
169
                fputs_filtered ("\"", stream);
170
              in_quotes = 1;
171
            }
172
          LA_EMIT_CHAR (string[i], type, stream, '"');
173
          ++things_printed;
174
        }
175
    }
176
 
177
  /* Terminate the quotes if necessary.  */
178
  if (in_quotes)
179
    {
180
      if (options->inspect_it)
181
        fputs_filtered ("\\\"", stream);
182
      else
183
        fputs_filtered ("\"", stream);
184
    }
185
 
186
  if (force_ellipses || i < length)
187
    fputs_filtered ("...", stream);
188
}
189
 
190
static struct value *
191
evaluate_subexp_modula2 (struct type *expect_type, struct expression *exp,
192
                         int *pos, enum noside noside)
193
{
194
  enum exp_opcode op = exp->elts[*pos].opcode;
195
  struct value *arg1;
196
  struct value *arg2;
197
  struct type *type;
198
  switch (op)
199
    {
200
    case UNOP_HIGH:
201
      (*pos)++;
202
      arg1 = evaluate_subexp_with_coercion (exp, pos, noside);
203
 
204
      if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
205
        return arg1;
206
      else
207
        {
208
          arg1 = coerce_ref (arg1);
209
          type = check_typedef (value_type (arg1));
210
 
211
          if (m2_is_unbounded_array (type))
212
            {
213
              struct value *temp = arg1;
214
              type = TYPE_FIELD_TYPE (type, 1);
215
              /* i18n: Do not translate the "_m2_high" part!  */
216
              arg1 = value_struct_elt (&temp, NULL, "_m2_high", NULL,
217
                                       _("unbounded structure "
218
                                         "missing _m2_high field"));
219
 
220
              if (value_type (arg1) != type)
221
                arg1 = value_cast (type, arg1);
222
            }
223
        }
224
      return arg1;
225
 
226
    case BINOP_SUBSCRIPT:
227
      (*pos)++;
228
      arg1 = evaluate_subexp_with_coercion (exp, pos, noside);
229
      arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
230
      if (noside == EVAL_SKIP)
231
        goto nosideret;
232
      /* If the user attempts to subscript something that is not an
233
         array or pointer type (like a plain int variable for example),
234
         then report this as an error.  */
235
 
236
      arg1 = coerce_ref (arg1);
237
      type = check_typedef (value_type (arg1));
238
 
239
      if (m2_is_unbounded_array (type))
240
        {
241
          struct value *temp = arg1;
242
          type = TYPE_FIELD_TYPE (type, 0);
243
          if (type == NULL || (TYPE_CODE (type) != TYPE_CODE_PTR)) {
244
            warning (_("internal error: unbounded array structure is unknown"));
245
            return evaluate_subexp_standard (expect_type, exp, pos, noside);
246
          }
247
          /* i18n: Do not translate the "_m2_contents" part!  */
248
          arg1 = value_struct_elt (&temp, NULL, "_m2_contents", NULL,
249
                                   _("unbounded structure "
250
                                     "missing _m2_contents field"));
251
 
252
          if (value_type (arg1) != type)
253
            arg1 = value_cast (type, arg1);
254
 
255
          type = check_typedef (value_type (arg1));
256
          return value_ind (value_ptradd (arg1, value_as_long (arg2)));
257
        }
258
      else
259
        if (TYPE_CODE (type) != TYPE_CODE_ARRAY)
260
          {
261
            if (TYPE_NAME (type))
262
              error (_("cannot subscript something of type `%s'"),
263
                     TYPE_NAME (type));
264
            else
265
              error (_("cannot subscript requested type"));
266
          }
267
 
268
      if (noside == EVAL_AVOID_SIDE_EFFECTS)
269
        return value_zero (TYPE_TARGET_TYPE (type), VALUE_LVAL (arg1));
270
      else
271
        return value_subscript (arg1, value_as_long (arg2));
272
 
273
    default:
274
      return evaluate_subexp_standard (expect_type, exp, pos, noside);
275
    }
276
 
277
 nosideret:
278
  return value_from_longest (builtin_type (exp->gdbarch)->builtin_int, 1);
279
}
280
 
281
 
282
/* Table of operators and their precedences for printing expressions.  */
283
 
284
static const struct op_print m2_op_print_tab[] =
285
{
286
  {"+", BINOP_ADD, PREC_ADD, 0},
287
  {"+", UNOP_PLUS, PREC_PREFIX, 0},
288
  {"-", BINOP_SUB, PREC_ADD, 0},
289
  {"-", UNOP_NEG, PREC_PREFIX, 0},
290
  {"*", BINOP_MUL, PREC_MUL, 0},
291
  {"/", BINOP_DIV, PREC_MUL, 0},
292
  {"DIV", BINOP_INTDIV, PREC_MUL, 0},
293
  {"MOD", BINOP_REM, PREC_MUL, 0},
294
  {":=", BINOP_ASSIGN, PREC_ASSIGN, 1},
295
  {"OR", BINOP_LOGICAL_OR, PREC_LOGICAL_OR, 0},
296
  {"AND", BINOP_LOGICAL_AND, PREC_LOGICAL_AND, 0},
297
  {"NOT", UNOP_LOGICAL_NOT, PREC_PREFIX, 0},
298
  {"=", BINOP_EQUAL, PREC_EQUAL, 0},
299
  {"<>", BINOP_NOTEQUAL, PREC_EQUAL, 0},
300
  {"<=", BINOP_LEQ, PREC_ORDER, 0},
301
  {">=", BINOP_GEQ, PREC_ORDER, 0},
302
  {">", BINOP_GTR, PREC_ORDER, 0},
303
  {"<", BINOP_LESS, PREC_ORDER, 0},
304
  {"^", UNOP_IND, PREC_PREFIX, 0},
305
  {"@", BINOP_REPEAT, PREC_REPEAT, 0},
306
  {"CAP", UNOP_CAP, PREC_BUILTIN_FUNCTION, 0},
307
  {"CHR", UNOP_CHR, PREC_BUILTIN_FUNCTION, 0},
308
  {"ORD", UNOP_ORD, PREC_BUILTIN_FUNCTION, 0},
309
  {"FLOAT", UNOP_FLOAT, PREC_BUILTIN_FUNCTION, 0},
310
  {"HIGH", UNOP_HIGH, PREC_BUILTIN_FUNCTION, 0},
311
  {"MAX", UNOP_MAX, PREC_BUILTIN_FUNCTION, 0},
312
  {"MIN", UNOP_MIN, PREC_BUILTIN_FUNCTION, 0},
313
  {"ODD", UNOP_ODD, PREC_BUILTIN_FUNCTION, 0},
314
  {"TRUNC", UNOP_TRUNC, PREC_BUILTIN_FUNCTION, 0},
315
  {NULL, 0, 0, 0}
316
};
317
 
318
/* The built-in types of Modula-2.  */
319
 
320
enum m2_primitive_types {
321
  m2_primitive_type_char,
322
  m2_primitive_type_int,
323
  m2_primitive_type_card,
324
  m2_primitive_type_real,
325
  m2_primitive_type_bool,
326
  nr_m2_primitive_types
327
};
328
 
329
static void
330
m2_language_arch_info (struct gdbarch *gdbarch,
331
                       struct language_arch_info *lai)
332
{
333
  const struct builtin_m2_type *builtin = builtin_m2_type (gdbarch);
334
 
335
  lai->string_char_type = builtin->builtin_char;
336
  lai->primitive_type_vector
337
    = GDBARCH_OBSTACK_CALLOC (gdbarch, nr_m2_primitive_types + 1,
338
                              struct type *);
339
 
340
  lai->primitive_type_vector [m2_primitive_type_char]
341
    = builtin->builtin_char;
342
  lai->primitive_type_vector [m2_primitive_type_int]
343
    = builtin->builtin_int;
344
  lai->primitive_type_vector [m2_primitive_type_card]
345
    = builtin->builtin_card;
346
  lai->primitive_type_vector [m2_primitive_type_real]
347
    = builtin->builtin_real;
348
  lai->primitive_type_vector [m2_primitive_type_bool]
349
    = builtin->builtin_bool;
350
 
351
  lai->bool_type_symbol = "BOOLEAN";
352
  lai->bool_type_default = builtin->builtin_bool;
353
}
354
 
355
const struct exp_descriptor exp_descriptor_modula2 =
356
{
357
  print_subexp_standard,
358
  operator_length_standard,
359
  op_name_standard,
360
  dump_subexp_body_standard,
361
  evaluate_subexp_modula2
362
};
363
 
364
const struct language_defn m2_language_defn =
365
{
366
  "modula-2",
367
  language_m2,
368
  range_check_on,
369
  type_check_on,
370
  case_sensitive_on,
371
  array_row_major,
372
  macro_expansion_no,
373
  &exp_descriptor_modula2,
374
  m2_parse,                     /* parser */
375
  m2_error,                     /* parser error function */
376
  null_post_parser,
377
  m2_printchar,                 /* Print character constant */
378
  m2_printstr,                  /* function to print string constant */
379
  m2_emit_char,                 /* Function to print a single character */
380
  m2_print_type,                /* Print a type using appropriate syntax */
381
  m2_print_typedef,             /* Print a typedef using appropriate syntax */
382
  m2_val_print,                 /* Print a value using appropriate syntax */
383
  c_value_print,                /* Print a top-level value */
384
  NULL,                         /* Language specific skip_trampoline */
385
  NULL,                         /* name_of_this */
386
  basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
387
  basic_lookup_transparent_type,/* lookup_transparent_type */
388
  NULL,                         /* Language specific symbol demangler */
389
  NULL,                         /* Language specific class_name_from_physname */
390
  m2_op_print_tab,              /* expression operators for printing */
391
  0,                             /* arrays are first-class (not c-style) */
392
  0,                             /* String lower bound */
393
  default_word_break_characters,
394
  default_make_symbol_completion_list,
395
  m2_language_arch_info,
396
  default_print_array_index,
397
  default_pass_by_reference,
398
  default_get_string,
399
  LANG_MAGIC
400
};
401
 
402
static void *
403
build_m2_types (struct gdbarch *gdbarch)
404
{
405
  struct builtin_m2_type *builtin_m2_type
406
    = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct builtin_m2_type);
407
 
408
  /* Modula-2 "pervasive" types.  NOTE:  these can be redefined!!! */
409
  builtin_m2_type->builtin_int
410
    = arch_integer_type (gdbarch, gdbarch_int_bit (gdbarch), 0, "INTEGER");
411
  builtin_m2_type->builtin_card
412
    = arch_integer_type (gdbarch, gdbarch_int_bit (gdbarch), 1, "CARDINAL");
413
  builtin_m2_type->builtin_real
414
    = arch_float_type (gdbarch, gdbarch_float_bit (gdbarch), "REAL", NULL);
415
  builtin_m2_type->builtin_char
416
    = arch_character_type (gdbarch, TARGET_CHAR_BIT, 1, "CHAR");
417
  builtin_m2_type->builtin_bool
418
    = arch_boolean_type (gdbarch, gdbarch_int_bit (gdbarch), 1, "BOOLEAN");
419
 
420
  return builtin_m2_type;
421
}
422
 
423
static struct gdbarch_data *m2_type_data;
424
 
425
const struct builtin_m2_type *
426
builtin_m2_type (struct gdbarch *gdbarch)
427
{
428
  return gdbarch_data (gdbarch, m2_type_data);
429
}
430
 
431
 
432
/* Initialization for Modula-2 */
433
 
434
void
435
_initialize_m2_language (void)
436
{
437
  m2_type_data = gdbarch_data_register_post_init (build_m2_types);
438
 
439
  add_language (&m2_language_defn);
440
}

powered by: WebSVN 2.1.0

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