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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gdb-7.1/] [gdb/] [language.c] - Blame information for rev 842

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 227 jeremybenn
/* Multiple source language support for GDB.
2
 
3
   Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001,
4
   2002, 2003, 2004, 2005, 2007, 2008, 2009, 2010
5
   Free Software Foundation, Inc.
6
 
7
   Contributed by the Department of Computer Science at the State University
8
   of New York at Buffalo.
9
 
10
   This file is part of GDB.
11
 
12
   This program is free software; you can redistribute it and/or modify
13
   it under the terms of the GNU General Public License as published by
14
   the Free Software Foundation; either version 3 of the License, or
15
   (at your option) any later version.
16
 
17
   This program is distributed in the hope that it will be useful,
18
   but WITHOUT ANY WARRANTY; without even the implied warranty of
19
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
20
   GNU General Public License for more details.
21
 
22
   You should have received a copy of the GNU General Public License
23
   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
24
 
25
/* This file contains functions that return things that are specific
26
   to languages.  Each function should examine current_language if necessary,
27
   and return the appropriate result. */
28
 
29
/* FIXME:  Most of these would be better organized as macros which
30
   return data out of a "language-specific" struct pointer that is set
31
   whenever the working language changes.  That would be a lot faster.  */
32
 
33
#include "defs.h"
34
#include <ctype.h>
35
#include "gdb_string.h"
36
 
37
#include "symtab.h"
38
#include "gdbtypes.h"
39
#include "value.h"
40
#include "gdbcmd.h"
41
#include "expression.h"
42
#include "language.h"
43
#include "target.h"
44
#include "parser-defs.h"
45
#include "jv-lang.h"
46
#include "demangle.h"
47
#include "symfile.h"
48
 
49
extern void _initialize_language (void);
50
 
51
static void unk_lang_error (char *);
52
 
53
static int unk_lang_parser (void);
54
 
55
static void show_check (char *, int);
56
 
57
static void set_check (char *, int);
58
 
59
static void set_type_range_case (void);
60
 
61
static void unk_lang_emit_char (int c, struct type *type,
62
                                struct ui_file *stream, int quoter);
63
 
64
static void unk_lang_printchar (int c, struct type *type,
65
                                struct ui_file *stream);
66
 
67
static void unk_lang_print_type (struct type *, char *, struct ui_file *,
68
                                 int, int);
69
 
70
static int unk_lang_value_print (struct value *, struct ui_file *,
71
                                 const struct value_print_options *);
72
 
73
static CORE_ADDR unk_lang_trampoline (struct frame_info *, CORE_ADDR pc);
74
 
75
/* Forward declaration */
76
extern const struct language_defn unknown_language_defn;
77
 
78
/* The current (default at startup) state of type and range checking.
79
   (If the modes are set to "auto", though, these are changed based
80
   on the default language at startup, and then again based on the
81
   language of the first source file.  */
82
 
83
enum range_mode range_mode = range_mode_auto;
84
enum range_check range_check = range_check_off;
85
enum type_mode type_mode = type_mode_auto;
86
enum type_check type_check = type_check_off;
87
enum case_mode case_mode = case_mode_auto;
88
enum case_sensitivity case_sensitivity = case_sensitive_on;
89
 
90
/* The current language and language_mode (see language.h) */
91
 
92
const struct language_defn *current_language = &unknown_language_defn;
93
enum language_mode language_mode = language_mode_auto;
94
 
95
/* The language that the user expects to be typing in (the language
96
   of main(), or the last language we notified them about, or C).  */
97
 
98
const struct language_defn *expected_language;
99
 
100
/* The list of supported languages.  The list itself is malloc'd.  */
101
 
102
static const struct language_defn **languages;
103
static unsigned languages_size;
104
static unsigned languages_allocsize;
105
#define DEFAULT_ALLOCSIZE 4
106
 
107
/* The current values of the "set language/type/range" enum
108
   commands.  */
109
static const char *language;
110
static const char *type;
111
static const char *range;
112
static const char *case_sensitive;
113
 
114
/* Warning issued when current_language and the language of the current
115
   frame do not match. */
116
char lang_frame_mismatch_warn[] =
117
"Warning: the current language does not match this frame.";
118
 
119
/* This page contains the functions corresponding to GDB commands
120
   and their helpers. */
121
 
122
/* Show command.  Display a warning if the language set
123
   does not match the frame. */
124
static void
125
show_language_command (struct ui_file *file, int from_tty,
126
                       struct cmd_list_element *c, const char *value)
127
{
128
  enum language flang;          /* The language of the current frame */
129
 
130
  if (language_mode == language_mode_auto)
131
    fprintf_filtered (gdb_stdout,
132
                      _("The current source language is "
133
                        "\"auto; currently %s\".\n"),
134
                      current_language->la_name);
135
  else
136
    fprintf_filtered (gdb_stdout, _("The current source language is \"%s\".\n"),
137
                      current_language->la_name);
138
 
139
  flang = get_frame_language ();
140
  if (flang != language_unknown &&
141
      language_mode == language_mode_manual &&
142
      current_language->la_language != flang)
143
    printf_filtered ("%s\n", lang_frame_mismatch_warn);
144
}
145
 
146
/* Set command.  Change the current working language. */
147
static void
148
set_language_command (char *ignore, int from_tty, struct cmd_list_element *c)
149
{
150
  int i;
151
  enum language flang;
152
 
153
  /* Search the list of languages for a match.  */
154
  for (i = 0; i < languages_size; i++)
155
    {
156
      if (strcmp (languages[i]->la_name, language) == 0)
157
        {
158
          /* Found it!  Go into manual mode, and use this language.  */
159
          if (languages[i]->la_language == language_auto)
160
            {
161
              /* Enter auto mode.  Set to the current frame's language, if
162
                 known, or fallback to the initial language.  */
163
              language_mode = language_mode_auto;
164
              flang = get_frame_language ();
165
              if (flang != language_unknown)
166
                set_language (flang);
167
              else
168
                set_initial_language ();
169
              expected_language = current_language;
170
              return;
171
            }
172
          else
173
            {
174
              /* Enter manual mode.  Set the specified language.  */
175
              language_mode = language_mode_manual;
176
              current_language = languages[i];
177
              set_type_range_case ();
178
              expected_language = current_language;
179
              return;
180
            }
181
        }
182
    }
183
 
184
  internal_error (__FILE__, __LINE__,
185
                  "Couldn't find language `%s' in known languages list.",
186
                  language);
187
}
188
 
189
/* Show command.  Display a warning if the type setting does
190
   not match the current language. */
191
static void
192
show_type_command (struct ui_file *file, int from_tty,
193
                   struct cmd_list_element *c, const char *value)
194
{
195
  if (type_mode == type_mode_auto)
196
    {
197
      char *tmp = NULL;
198
 
199
      switch (type_check)
200
        {
201
        case type_check_on:
202
          tmp = "on";
203
          break;
204
        case type_check_off:
205
          tmp = "off";
206
          break;
207
        case type_check_warn:
208
          tmp = "warn";
209
          break;
210
        default:
211
          internal_error (__FILE__, __LINE__,
212
                          "Unrecognized type check setting.");
213
        }
214
 
215
      fprintf_filtered (gdb_stdout,
216
                        _("Type checking is \"auto; currently %s\".\n"),
217
                        tmp);
218
    }
219
  else
220
    fprintf_filtered (gdb_stdout, _("Type checking is \"%s\".\n"),
221
                      value);
222
 
223
   if (type_check != current_language->la_type_check)
224
    warning (_("the current type check setting"
225
               " does not match the language.\n"));
226
}
227
 
228
/* Set command.  Change the setting for type checking. */
229
static void
230
set_type_command (char *ignore, int from_tty, struct cmd_list_element *c)
231
{
232
  if (strcmp (type, "on") == 0)
233
    {
234
      type_check = type_check_on;
235
      type_mode = type_mode_manual;
236
    }
237
  else if (strcmp (type, "warn") == 0)
238
    {
239
      type_check = type_check_warn;
240
      type_mode = type_mode_manual;
241
    }
242
  else if (strcmp (type, "off") == 0)
243
    {
244
      type_check = type_check_off;
245
      type_mode = type_mode_manual;
246
    }
247
  else if (strcmp (type, "auto") == 0)
248
    {
249
      type_mode = type_mode_auto;
250
      set_type_range_case ();
251
      return;
252
    }
253
  else
254
    internal_error (__FILE__, __LINE__,
255
                    _("Unrecognized type check setting: \"%s\""), type);
256
 
257
  if (type_check != current_language->la_type_check)
258
    warning (_("the current type check setting"
259
               " does not match the language.\n"));
260
}
261
 
262
/* Show command.  Display a warning if the range setting does
263
   not match the current language. */
264
static void
265
show_range_command (struct ui_file *file, int from_tty,
266
                    struct cmd_list_element *c, const char *value)
267
{
268
  if (range_mode == range_mode_auto)
269
    {
270
      char *tmp;
271
 
272
      switch (range_check)
273
        {
274
        case range_check_on:
275
          tmp = "on";
276
          break;
277
        case range_check_off:
278
          tmp = "off";
279
          break;
280
        case range_check_warn:
281
          tmp = "warn";
282
          break;
283
        default:
284
          internal_error (__FILE__, __LINE__,
285
                          "Unrecognized range check setting.");
286
        }
287
 
288
      fprintf_filtered (gdb_stdout,
289
                        _("Range checking is \"auto; currently %s\".\n"),
290
                        tmp);
291
    }
292
  else
293
    fprintf_filtered (gdb_stdout, _("Range checking is \"%s\".\n"),
294
                      value);
295
 
296
  if (range_check != current_language->la_range_check)
297
    warning (_("the current range check setting "
298
               "does not match the language.\n"));
299
}
300
 
301
/* Set command.  Change the setting for range checking. */
302
static void
303
set_range_command (char *ignore, int from_tty, struct cmd_list_element *c)
304
{
305
  if (strcmp (range, "on") == 0)
306
    {
307
      range_check = range_check_on;
308
      range_mode = range_mode_manual;
309
    }
310
  else if (strcmp (range, "warn") == 0)
311
    {
312
      range_check = range_check_warn;
313
      range_mode = range_mode_manual;
314
    }
315
  else if (strcmp (range, "off") == 0)
316
    {
317
      range_check = range_check_off;
318
      range_mode = range_mode_manual;
319
    }
320
  else if (strcmp (range, "auto") == 0)
321
    {
322
      range_mode = range_mode_auto;
323
      set_type_range_case ();
324
      return;
325
    }
326
  else
327
    {
328
      internal_error (__FILE__, __LINE__,
329
                      _("Unrecognized range check setting: \"%s\""), range);
330
    }
331
  if (range_check != current_language->la_range_check)
332
    warning (_("the current range check setting "
333
               "does not match the language.\n"));
334
}
335
 
336
/* Show command.  Display a warning if the case sensitivity setting does
337
   not match the current language. */
338
static void
339
show_case_command (struct ui_file *file, int from_tty,
340
                   struct cmd_list_element *c, const char *value)
341
{
342
  if (case_mode == case_mode_auto)
343
    {
344
      char *tmp = NULL;
345
 
346
      switch (case_sensitivity)
347
        {
348
        case case_sensitive_on:
349
          tmp = "on";
350
          break;
351
        case case_sensitive_off:
352
          tmp = "off";
353
          break;
354
        default:
355
          internal_error (__FILE__, __LINE__,
356
                          "Unrecognized case-sensitive setting.");
357
        }
358
 
359
      fprintf_filtered (gdb_stdout,
360
                        _("Case sensitivity in "
361
                          "name search is \"auto; currently %s\".\n"),
362
                        tmp);
363
    }
364
  else
365
    fprintf_filtered (gdb_stdout, _("Case sensitivity in name search is \"%s\".\n"),
366
                      value);
367
 
368
  if (case_sensitivity != current_language->la_case_sensitivity)
369
    warning (_("the current case sensitivity setting does not match "
370
               "the language.\n"));
371
}
372
 
373
/* Set command.  Change the setting for case sensitivity.  */
374
 
375
static void
376
set_case_command (char *ignore, int from_tty, struct cmd_list_element *c)
377
{
378
   if (strcmp (case_sensitive, "on") == 0)
379
     {
380
       case_sensitivity = case_sensitive_on;
381
       case_mode = case_mode_manual;
382
     }
383
   else if (strcmp (case_sensitive, "off") == 0)
384
     {
385
       case_sensitivity = case_sensitive_off;
386
       case_mode = case_mode_manual;
387
     }
388
   else if (strcmp (case_sensitive, "auto") == 0)
389
     {
390
       case_mode = case_mode_auto;
391
       set_type_range_case ();
392
       return;
393
     }
394
   else
395
     {
396
       internal_error (__FILE__, __LINE__,
397
                       "Unrecognized case-sensitive setting: \"%s\"",
398
                       case_sensitive);
399
     }
400
 
401
   if (case_sensitivity != current_language->la_case_sensitivity)
402
     warning (_("the current case sensitivity setting does not match "
403
                "the language.\n"));
404
}
405
 
406
/* Set the status of range and type checking and case sensitivity based on
407
   the current modes and the current language.
408
   If SHOW is non-zero, then print out the current language,
409
   type and range checking status. */
410
static void
411
set_type_range_case (void)
412
{
413
  if (range_mode == range_mode_auto)
414
    range_check = current_language->la_range_check;
415
 
416
  if (type_mode == type_mode_auto)
417
    type_check = current_language->la_type_check;
418
 
419
  if (case_mode == case_mode_auto)
420
    case_sensitivity = current_language->la_case_sensitivity;
421
}
422
 
423
/* Set current language to (enum language) LANG.  Returns previous language. */
424
 
425
enum language
426
set_language (enum language lang)
427
{
428
  int i;
429
  enum language prev_language;
430
 
431
  prev_language = current_language->la_language;
432
 
433
  for (i = 0; i < languages_size; i++)
434
    {
435
      if (languages[i]->la_language == lang)
436
        {
437
          current_language = languages[i];
438
          set_type_range_case ();
439
          break;
440
        }
441
    }
442
 
443
  return prev_language;
444
}
445
 
446
 
447
/* Print out the current language settings: language, range and
448
   type checking.  If QUIETLY, print only what has changed.  */
449
 
450
void
451
language_info (int quietly)
452
{
453
  if (quietly && expected_language == current_language)
454
    return;
455
 
456
  expected_language = current_language;
457
  printf_unfiltered (_("Current language:  %s\n"), language);
458
  show_language_command (NULL, 1, NULL, NULL);
459
 
460
  if (!quietly)
461
    {
462
      printf_unfiltered (_("Type checking:     %s\n"), type);
463
      show_type_command (NULL, 1, NULL, NULL);
464
      printf_unfiltered (_("Range checking:    %s\n"), range);
465
      show_range_command (NULL, 1, NULL, NULL);
466
      printf_unfiltered (_("Case sensitivity:  %s\n"), case_sensitive);
467
      show_case_command (NULL, 1, NULL, NULL);
468
    }
469
}
470
 
471
/* Return the result of a binary operation. */
472
 
473
#if 0                           /* Currently unused */
474
 
475
struct type *
476
binop_result_type (struct value *v1, struct value *v2)
477
{
478
  int size, uns;
479
  struct type *t1 = check_typedef (VALUE_TYPE (v1));
480
  struct type *t2 = check_typedef (VALUE_TYPE (v2));
481
 
482
  int l1 = TYPE_LENGTH (t1);
483
  int l2 = TYPE_LENGTH (t2);
484
 
485
  switch (current_language->la_language)
486
    {
487
    case language_c:
488
    case language_cplus:
489
    case language_objc:
490
      if (TYPE_CODE (t1) == TYPE_CODE_FLT)
491
        return TYPE_CODE (t2) == TYPE_CODE_FLT && l2 > l1 ?
492
          VALUE_TYPE (v2) : VALUE_TYPE (v1);
493
      else if (TYPE_CODE (t2) == TYPE_CODE_FLT)
494
        return TYPE_CODE (t1) == TYPE_CODE_FLT && l1 > l2 ?
495
          VALUE_TYPE (v1) : VALUE_TYPE (v2);
496
      else if (TYPE_UNSIGNED (t1) && l1 > l2)
497
        return VALUE_TYPE (v1);
498
      else if (TYPE_UNSIGNED (t2) && l2 > l1)
499
        return VALUE_TYPE (v2);
500
      else                      /* Both are signed.  Result is the longer type */
501
        return l1 > l2 ? VALUE_TYPE (v1) : VALUE_TYPE (v2);
502
      break;
503
    case language_m2:
504
      /* If we are doing type-checking, l1 should equal l2, so this is
505
         not needed. */
506
      return l1 > l2 ? VALUE_TYPE (v1) : VALUE_TYPE (v2);
507
      break;
508
    }
509
  internal_error (__FILE__, __LINE__, _("failed internal consistency check"));
510
  return (struct type *) 0;      /* For lint */
511
}
512
 
513
#endif /* 0 */
514
#if 0
515
/* This page contains functions that are used in type/range checking.
516
   They all return zero if the type/range check fails.
517
 
518
   It is hoped that these will make extending GDB to parse different
519
   languages a little easier.  These are primarily used in eval.c when
520
   evaluating expressions and making sure that their types are correct.
521
   Instead of having a mess of conjucted/disjuncted expressions in an "if",
522
   the ideas of type can be wrapped up in the following functions.
523
 
524
   Note that some of them are not currently dependent upon which language
525
   is currently being parsed.  For example, floats are the same in
526
   C and Modula-2 (ie. the only floating point type has TYPE_CODE of
527
   TYPE_CODE_FLT), while booleans are different. */
528
 
529
/* Returns non-zero if its argument is a simple type.  This is the same for
530
   both Modula-2 and for C.  In the C case, TYPE_CODE_CHAR will never occur,
531
   and thus will never cause the failure of the test. */
532
int
533
simple_type (struct type *type)
534
{
535
  CHECK_TYPEDEF (type);
536
  switch (TYPE_CODE (type))
537
    {
538
    case TYPE_CODE_INT:
539
    case TYPE_CODE_CHAR:
540
    case TYPE_CODE_ENUM:
541
    case TYPE_CODE_FLT:
542
    case TYPE_CODE_RANGE:
543
    case TYPE_CODE_BOOL:
544
      return 1;
545
 
546
    default:
547
      return 0;
548
    }
549
}
550
 
551
/* Returns non-zero if its argument is of an ordered type.
552
   An ordered type is one in which the elements can be tested for the
553
   properties of "greater than", "less than", etc, or for which the
554
   operations "increment" or "decrement" make sense. */
555
int
556
ordered_type (struct type *type)
557
{
558
  CHECK_TYPEDEF (type);
559
  switch (TYPE_CODE (type))
560
    {
561
    case TYPE_CODE_INT:
562
    case TYPE_CODE_CHAR:
563
    case TYPE_CODE_ENUM:
564
    case TYPE_CODE_FLT:
565
    case TYPE_CODE_RANGE:
566
      return 1;
567
 
568
    default:
569
      return 0;
570
    }
571
}
572
 
573
/* Returns non-zero if the two types are the same */
574
int
575
same_type (struct type *arg1, struct type *arg2)
576
{
577
  CHECK_TYPEDEF (type);
578
  if (structured_type (arg1) ? !structured_type (arg2) : structured_type (arg2))
579
    /* One is structured and one isn't */
580
    return 0;
581
  else if (structured_type (arg1) && structured_type (arg2))
582
    return arg1 == arg2;
583
  else if (numeric_type (arg1) && numeric_type (arg2))
584
    return (TYPE_CODE (arg2) == TYPE_CODE (arg1)) &&
585
      (TYPE_UNSIGNED (arg1) == TYPE_UNSIGNED (arg2))
586
      ? 1 : 0;
587
  else
588
    return arg1 == arg2;
589
}
590
 
591
/* Returns non-zero if the type is integral */
592
int
593
integral_type (struct type *type)
594
{
595
  CHECK_TYPEDEF (type);
596
  switch (current_language->la_language)
597
    {
598
    case language_c:
599
    case language_cplus:
600
    case language_objc:
601
      return (TYPE_CODE (type) != TYPE_CODE_INT) &&
602
        (TYPE_CODE (type) != TYPE_CODE_ENUM) ? 0 : 1;
603
    case language_m2:
604
    case language_pascal:
605
      return TYPE_CODE (type) != TYPE_CODE_INT ? 0 : 1;
606
    default:
607
      error (_("Language not supported."));
608
    }
609
}
610
 
611
/* Returns non-zero if the value is numeric */
612
int
613
numeric_type (struct type *type)
614
{
615
  CHECK_TYPEDEF (type);
616
  switch (TYPE_CODE (type))
617
    {
618
    case TYPE_CODE_INT:
619
    case TYPE_CODE_FLT:
620
      return 1;
621
 
622
    default:
623
      return 0;
624
    }
625
}
626
 
627
/* Returns non-zero if the value is a character type */
628
int
629
character_type (struct type *type)
630
{
631
  CHECK_TYPEDEF (type);
632
  switch (current_language->la_language)
633
    {
634
    case language_m2:
635
    case language_pascal:
636
      return TYPE_CODE (type) != TYPE_CODE_CHAR ? 0 : 1;
637
 
638
    case language_c:
639
    case language_cplus:
640
    case language_objc:
641
      return (TYPE_CODE (type) == TYPE_CODE_INT) &&
642
        TYPE_LENGTH (type) == sizeof (char)
643
      ? 1 : 0;
644
    default:
645
      return (0);
646
    }
647
}
648
 
649
/* Returns non-zero if the value is a string type */
650
int
651
string_type (struct type *type)
652
{
653
  CHECK_TYPEDEF (type);
654
  switch (current_language->la_language)
655
    {
656
    case language_m2:
657
    case language_pascal:
658
      return TYPE_CODE (type) != TYPE_CODE_STRING ? 0 : 1;
659
 
660
    case language_c:
661
    case language_cplus:
662
    case language_objc:
663
      /* C does not have distinct string type. */
664
      return (0);
665
    default:
666
      return (0);
667
    }
668
}
669
 
670
/* Returns non-zero if the value is a boolean type */
671
int
672
boolean_type (struct type *type)
673
{
674
  CHECK_TYPEDEF (type);
675
  if (TYPE_CODE (type) == TYPE_CODE_BOOL)
676
    return 1;
677
  switch (current_language->la_language)
678
    {
679
    case language_c:
680
    case language_cplus:
681
    case language_objc:
682
      /* Might be more cleanly handled by having a
683
         TYPE_CODE_INT_NOT_BOOL for (the deleted) CHILL and such
684
         languages, or a TYPE_CODE_INT_OR_BOOL for C.  */
685
      if (TYPE_CODE (type) == TYPE_CODE_INT)
686
        return 1;
687
    default:
688
      break;
689
    }
690
  return 0;
691
}
692
 
693
/* Returns non-zero if the value is a floating-point type */
694
int
695
float_type (struct type *type)
696
{
697
  CHECK_TYPEDEF (type);
698
  return TYPE_CODE (type) == TYPE_CODE_FLT;
699
}
700
#endif
701
 
702
/* Returns non-zero if the value is a pointer type */
703
int
704
pointer_type (struct type *type)
705
{
706
  return TYPE_CODE (type) == TYPE_CODE_PTR ||
707
    TYPE_CODE (type) == TYPE_CODE_REF;
708
}
709
 
710
#if 0
711
/* Returns non-zero if the value is a structured type */
712
int
713
structured_type (struct type *type)
714
{
715
  CHECK_TYPEDEF (type);
716
  switch (current_language->la_language)
717
    {
718
    case language_c:
719
    case language_cplus:
720
    case language_objc:
721
      return (TYPE_CODE (type) == TYPE_CODE_STRUCT) ||
722
        (TYPE_CODE (type) == TYPE_CODE_UNION) ||
723
        (TYPE_CODE (type) == TYPE_CODE_ARRAY);
724
   case language_pascal:
725
      return (TYPE_CODE(type) == TYPE_CODE_STRUCT) ||
726
         (TYPE_CODE(type) == TYPE_CODE_UNION) ||
727
         (TYPE_CODE(type) == TYPE_CODE_SET) ||
728
            (TYPE_CODE(type) == TYPE_CODE_ARRAY);
729
    case language_m2:
730
      return (TYPE_CODE (type) == TYPE_CODE_STRUCT) ||
731
        (TYPE_CODE (type) == TYPE_CODE_SET) ||
732
        (TYPE_CODE (type) == TYPE_CODE_ARRAY);
733
    default:
734
      return (0);
735
    }
736
}
737
#endif
738
 
739
/* This page contains functions that return info about
740
   (struct value) values used in GDB. */
741
 
742
/* Returns non-zero if the value VAL represents a true value. */
743
int
744
value_true (struct value *val)
745
{
746
  /* It is possible that we should have some sort of error if a non-boolean
747
     value is used in this context.  Possibly dependent on some kind of
748
     "boolean-checking" option like range checking.  But it should probably
749
     not depend on the language except insofar as is necessary to identify
750
     a "boolean" value (i.e. in C using a float, pointer, etc., as a boolean
751
     should be an error, probably).  */
752
  return !value_logical_not (val);
753
}
754
 
755
/* This page contains functions for the printing out of
756
   error messages that occur during type- and range-
757
   checking. */
758
 
759
/* These are called when a language fails a type- or range-check.  The
760
   first argument should be a printf()-style format string, and the
761
   rest of the arguments should be its arguments.  If
762
   [type|range]_check is [type|range]_check_on, an error is printed;
763
   if [type|range]_check_warn, a warning; otherwise just the
764
   message. */
765
 
766
void
767
type_error (const char *string,...)
768
{
769
  va_list args;
770
  va_start (args, string);
771
 
772
  switch (type_check)
773
    {
774
    case type_check_warn:
775
      vwarning (string, args);
776
      break;
777
    case type_check_on:
778
      verror (string, args);
779
      break;
780
    case type_check_off:
781
      /* FIXME: cagney/2002-01-30: Should this function print anything
782
         when type error is off?  */
783
      vfprintf_filtered (gdb_stderr, string, args);
784
      fprintf_filtered (gdb_stderr, "\n");
785
      break;
786
    default:
787
      internal_error (__FILE__, __LINE__, _("bad switch"));
788
    }
789
  va_end (args);
790
}
791
 
792
void
793
range_error (const char *string,...)
794
{
795
  va_list args;
796
  va_start (args, string);
797
 
798
  switch (range_check)
799
    {
800
    case range_check_warn:
801
      vwarning (string, args);
802
      break;
803
    case range_check_on:
804
      verror (string, args);
805
      break;
806
    case range_check_off:
807
      /* FIXME: cagney/2002-01-30: Should this function print anything
808
         when range error is off?  */
809
      vfprintf_filtered (gdb_stderr, string, args);
810
      fprintf_filtered (gdb_stderr, "\n");
811
      break;
812
    default:
813
      internal_error (__FILE__, __LINE__, _("bad switch"));
814
    }
815
  va_end (args);
816
}
817
 
818
 
819
/* This page contains miscellaneous functions */
820
 
821
/* Return the language enum for a given language string. */
822
 
823
enum language
824
language_enum (char *str)
825
{
826
  int i;
827
 
828
  for (i = 0; i < languages_size; i++)
829
    if (strcmp (languages[i]->la_name, str) == 0)
830
      return languages[i]->la_language;
831
 
832
  return language_unknown;
833
}
834
 
835
/* Return the language struct for a given language enum. */
836
 
837
const struct language_defn *
838
language_def (enum language lang)
839
{
840
  int i;
841
 
842
  for (i = 0; i < languages_size; i++)
843
    {
844
      if (languages[i]->la_language == lang)
845
        {
846
          return languages[i];
847
        }
848
    }
849
  return NULL;
850
}
851
 
852
/* Return the language as a string */
853
char *
854
language_str (enum language lang)
855
{
856
  int i;
857
 
858
  for (i = 0; i < languages_size; i++)
859
    {
860
      if (languages[i]->la_language == lang)
861
        {
862
          return languages[i]->la_name;
863
        }
864
    }
865
  return "Unknown";
866
}
867
 
868
static void
869
set_check (char *ignore, int from_tty)
870
{
871
  printf_unfiltered (
872
     "\"set check\" must be followed by the name of a check subcommand.\n");
873
  help_list (setchecklist, "set check ", -1, gdb_stdout);
874
}
875
 
876
static void
877
show_check (char *ignore, int from_tty)
878
{
879
  cmd_show_list (showchecklist, from_tty, "");
880
}
881
 
882
/* Add a language to the set of known languages.  */
883
 
884
void
885
add_language (const struct language_defn *lang)
886
{
887
  /* For the "set language" command.  */
888
  static char **language_names = NULL;
889
  /* For the "help set language" command.  */
890
  char *language_set_doc = NULL;
891
 
892
  int i;
893
  struct ui_file *tmp_stream;
894
 
895
  if (lang->la_magic != LANG_MAGIC)
896
    {
897
      fprintf_unfiltered (gdb_stderr, "Magic number of %s language struct wrong\n",
898
                          lang->la_name);
899
      internal_error (__FILE__, __LINE__, _("failed internal consistency check"));
900
    }
901
 
902
  if (!languages)
903
    {
904
      languages_allocsize = DEFAULT_ALLOCSIZE;
905
      languages = (const struct language_defn **) xmalloc
906
        (languages_allocsize * sizeof (*languages));
907
    }
908
  if (languages_size >= languages_allocsize)
909
    {
910
      languages_allocsize *= 2;
911
      languages = (const struct language_defn **) xrealloc ((char *) languages,
912
                                 languages_allocsize * sizeof (*languages));
913
    }
914
  languages[languages_size++] = lang;
915
 
916
  /* Build the language names array, to be used as enumeration in the
917
     set language" enum command.  */
918
  language_names = xrealloc (language_names,
919
                             (languages_size + 1) * sizeof (const char *));
920
  for (i = 0; i < languages_size; ++i)
921
    language_names[i] = languages[i]->la_name;
922
  language_names[i] = NULL;
923
 
924
  /* Build the "help set language" docs.  */
925
  tmp_stream = mem_fileopen ();
926
 
927
  fprintf_unfiltered (tmp_stream, _("\
928
Set the current source language.\n\
929
The currently understood settings are:\n\n\
930
local or auto    Automatic setting based on source file\n"));
931
 
932
  for (i = 0; i < languages_size; ++i)
933
    {
934
      /* Already dealt with these above.  */
935
      if (languages[i]->la_language == language_unknown
936
          || languages[i]->la_language == language_auto)
937
        continue;
938
 
939
      /* FIXME: i18n: for now assume that the human-readable name
940
         is just a capitalization of the internal name.  */
941
      fprintf_unfiltered (tmp_stream, "%-16s Use the %c%s language\n",
942
                          languages[i]->la_name,
943
                          /* Capitalize first letter of language
944
                             name.  */
945
                          toupper (languages[i]->la_name[0]),
946
                          languages[i]->la_name + 1);
947
    }
948
 
949
  language_set_doc = ui_file_xstrdup (tmp_stream, NULL);
950
  ui_file_delete (tmp_stream);
951
 
952
  add_setshow_enum_cmd ("language", class_support,
953
                        (const char **) language_names,
954
                        &language,
955
                        language_set_doc, _("\
956
Show the current source language."), NULL,
957
                        set_language_command,
958
                        show_language_command,
959
                        &setlist, &showlist);
960
 
961
  xfree (language_set_doc);
962
}
963
 
964
/* Iterate through all registered languages looking for and calling
965
   any non-NULL struct language_defn.skip_trampoline() functions.
966
   Return the result from the first that returns non-zero, or 0 if all
967
   `fail'.  */
968
CORE_ADDR
969
skip_language_trampoline (struct frame_info *frame, CORE_ADDR pc)
970
{
971
  int i;
972
 
973
  for (i = 0; i < languages_size; i++)
974
    {
975
      if (languages[i]->skip_trampoline)
976
        {
977
          CORE_ADDR real_pc = (languages[i]->skip_trampoline) (frame, pc);
978
          if (real_pc)
979
            return real_pc;
980
        }
981
    }
982
 
983
  return 0;
984
}
985
 
986
/* Return demangled language symbol, or NULL.
987
   FIXME: Options are only useful for certain languages and ignored
988
   by others, so it would be better to remove them here and have a
989
   more flexible demangler for the languages that need it.
990
   FIXME: Sometimes the demangler is invoked when we don't know the
991
   language, so we can't use this everywhere.  */
992
char *
993
language_demangle (const struct language_defn *current_language,
994
                                const char *mangled, int options)
995
{
996
  if (current_language != NULL && current_language->la_demangle)
997
    return current_language->la_demangle (mangled, options);
998
  return NULL;
999
}
1000
 
1001
/* Return class name from physname or NULL.  */
1002
char *
1003
language_class_name_from_physname (const struct language_defn *current_language,
1004
                                   const char *physname)
1005
{
1006
  if (current_language != NULL && current_language->la_class_name_from_physname)
1007
    return current_language->la_class_name_from_physname (physname);
1008
  return NULL;
1009
}
1010
 
1011
/* Return non-zero if TYPE should be passed (and returned) by
1012
   reference at the language level.  */
1013
int
1014
language_pass_by_reference (struct type *type)
1015
{
1016
  return current_language->la_pass_by_reference (type);
1017
}
1018
 
1019
/* Return zero; by default, types are passed by value at the language
1020
   level.  The target ABI may pass or return some structs by reference
1021
   independent of this.  */
1022
int
1023
default_pass_by_reference (struct type *type)
1024
{
1025
  return 0;
1026
}
1027
 
1028
/* Return the default string containing the list of characters
1029
   delimiting words.  This is a reasonable default value that
1030
   most languages should be able to use.  */
1031
 
1032
char *
1033
default_word_break_characters (void)
1034
{
1035
  return " \t\n!@#$%^&*()+=|~`}{[]\"';:?/>.<,-";
1036
}
1037
 
1038
/* Print the index of array elements using the C99 syntax.  */
1039
 
1040
void
1041
default_print_array_index (struct value *index_value, struct ui_file *stream,
1042
                           const struct value_print_options *options)
1043
{
1044
  fprintf_filtered (stream, "[");
1045
  LA_VALUE_PRINT (index_value, stream, options);
1046
  fprintf_filtered (stream, "] = ");
1047
}
1048
 
1049
void
1050
default_get_string (struct value *value, gdb_byte **buffer, int *length,
1051
                    struct type **char_type, const char **charset)
1052
{
1053
  error (_("Getting a string is unsupported in this language."));
1054
}
1055
 
1056
/* Define the language that is no language.  */
1057
 
1058
static int
1059
unk_lang_parser (void)
1060
{
1061
  return 1;
1062
}
1063
 
1064
static void
1065
unk_lang_error (char *msg)
1066
{
1067
  error (_("Attempted to parse an expression with unknown language"));
1068
}
1069
 
1070
static void
1071
unk_lang_emit_char (int c, struct type *type, struct ui_file *stream,
1072
                    int quoter)
1073
{
1074
  error (_("internal error - unimplemented function unk_lang_emit_char called."));
1075
}
1076
 
1077
static void
1078
unk_lang_printchar (int c, struct type *type, struct ui_file *stream)
1079
{
1080
  error (_("internal error - unimplemented function unk_lang_printchar called."));
1081
}
1082
 
1083
static void
1084
unk_lang_printstr (struct ui_file *stream, struct type *type,
1085
                   const gdb_byte *string, unsigned int length,
1086
                   const char *encoding, int force_ellipses,
1087
                   const struct value_print_options *options)
1088
{
1089
  error (_("internal error - unimplemented function unk_lang_printstr called."));
1090
}
1091
 
1092
static void
1093
unk_lang_print_type (struct type *type, char *varstring, struct ui_file *stream,
1094
                     int show, int level)
1095
{
1096
  error (_("internal error - unimplemented function unk_lang_print_type called."));
1097
}
1098
 
1099
static int
1100
unk_lang_val_print (struct type *type, const gdb_byte *valaddr,
1101
                    int embedded_offset, CORE_ADDR address,
1102
                    struct ui_file *stream, int recurse,
1103
                    const struct value_print_options *options)
1104
{
1105
  error (_("internal error - unimplemented function unk_lang_val_print called."));
1106
}
1107
 
1108
static int
1109
unk_lang_value_print (struct value *val, struct ui_file *stream,
1110
                      const struct value_print_options *options)
1111
{
1112
  error (_("internal error - unimplemented function unk_lang_value_print called."));
1113
}
1114
 
1115
static CORE_ADDR unk_lang_trampoline (struct frame_info *frame, CORE_ADDR pc)
1116
{
1117
  return 0;
1118
}
1119
 
1120
/* Unknown languages just use the cplus demangler.  */
1121
static char *unk_lang_demangle (const char *mangled, int options)
1122
{
1123
  return cplus_demangle (mangled, options);
1124
}
1125
 
1126
static char *unk_lang_class_name (const char *mangled)
1127
{
1128
  return NULL;
1129
}
1130
 
1131
static const struct op_print unk_op_print_tab[] =
1132
{
1133
  {NULL, OP_NULL, PREC_NULL, 0}
1134
};
1135
 
1136
static void
1137
unknown_language_arch_info (struct gdbarch *gdbarch,
1138
                            struct language_arch_info *lai)
1139
{
1140
  lai->string_char_type = builtin_type (gdbarch)->builtin_char;
1141
  lai->bool_type_default = builtin_type (gdbarch)->builtin_int;
1142
  lai->primitive_type_vector = GDBARCH_OBSTACK_CALLOC (gdbarch, 1,
1143
                                                       struct type *);
1144
}
1145
 
1146
const struct language_defn unknown_language_defn =
1147
{
1148
  "unknown",
1149
  language_unknown,
1150
  range_check_off,
1151
  type_check_off,
1152
  case_sensitive_on,
1153
  array_row_major,
1154
  macro_expansion_no,
1155
  &exp_descriptor_standard,
1156
  unk_lang_parser,
1157
  unk_lang_error,
1158
  null_post_parser,
1159
  unk_lang_printchar,           /* Print character constant */
1160
  unk_lang_printstr,
1161
  unk_lang_emit_char,
1162
  unk_lang_print_type,          /* Print a type using appropriate syntax */
1163
  default_print_typedef,        /* Print a typedef using appropriate syntax */
1164
  unk_lang_val_print,           /* Print a value using appropriate syntax */
1165
  unk_lang_value_print,         /* Print a top-level value */
1166
  unk_lang_trampoline,          /* Language specific skip_trampoline */
1167
  "this",                       /* name_of_this */
1168
  basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
1169
  basic_lookup_transparent_type,/* lookup_transparent_type */
1170
  unk_lang_demangle,            /* Language specific symbol demangler */
1171
  unk_lang_class_name,          /* Language specific class_name_from_physname */
1172
  unk_op_print_tab,             /* expression operators for printing */
1173
  1,                            /* c-style arrays */
1174
  0,                             /* String lower bound */
1175
  default_word_break_characters,
1176
  default_make_symbol_completion_list,
1177
  unknown_language_arch_info,   /* la_language_arch_info.  */
1178
  default_print_array_index,
1179
  default_pass_by_reference,
1180
  default_get_string,
1181
  LANG_MAGIC
1182
};
1183
 
1184
/* These two structs define fake entries for the "local" and "auto" options. */
1185
const struct language_defn auto_language_defn =
1186
{
1187
  "auto",
1188
  language_auto,
1189
  range_check_off,
1190
  type_check_off,
1191
  case_sensitive_on,
1192
  array_row_major,
1193
  macro_expansion_no,
1194
  &exp_descriptor_standard,
1195
  unk_lang_parser,
1196
  unk_lang_error,
1197
  null_post_parser,
1198
  unk_lang_printchar,           /* Print character constant */
1199
  unk_lang_printstr,
1200
  unk_lang_emit_char,
1201
  unk_lang_print_type,          /* Print a type using appropriate syntax */
1202
  default_print_typedef,        /* Print a typedef using appropriate syntax */
1203
  unk_lang_val_print,           /* Print a value using appropriate syntax */
1204
  unk_lang_value_print,         /* Print a top-level value */
1205
  unk_lang_trampoline,          /* Language specific skip_trampoline */
1206
  "this",                       /* name_of_this */
1207
  basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
1208
  basic_lookup_transparent_type,/* lookup_transparent_type */
1209
  unk_lang_demangle,            /* Language specific symbol demangler */
1210
  unk_lang_class_name,          /* Language specific class_name_from_physname */
1211
  unk_op_print_tab,             /* expression operators for printing */
1212
  1,                            /* c-style arrays */
1213
  0,                             /* String lower bound */
1214
  default_word_break_characters,
1215
  default_make_symbol_completion_list,
1216
  unknown_language_arch_info,   /* la_language_arch_info.  */
1217
  default_print_array_index,
1218
  default_pass_by_reference,
1219
  default_get_string,
1220
  LANG_MAGIC
1221
};
1222
 
1223
const struct language_defn local_language_defn =
1224
{
1225
  "local",
1226
  language_auto,
1227
  range_check_off,
1228
  type_check_off,
1229
  case_sensitive_on,
1230
  array_row_major,
1231
  macro_expansion_no,
1232
  &exp_descriptor_standard,
1233
  unk_lang_parser,
1234
  unk_lang_error,
1235
  null_post_parser,
1236
  unk_lang_printchar,           /* Print character constant */
1237
  unk_lang_printstr,
1238
  unk_lang_emit_char,
1239
  unk_lang_print_type,          /* Print a type using appropriate syntax */
1240
  default_print_typedef,        /* Print a typedef using appropriate syntax */
1241
  unk_lang_val_print,           /* Print a value using appropriate syntax */
1242
  unk_lang_value_print,         /* Print a top-level value */
1243
  unk_lang_trampoline,          /* Language specific skip_trampoline */
1244
  "this",                       /* name_of_this */
1245
  basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
1246
  basic_lookup_transparent_type,/* lookup_transparent_type */
1247
  unk_lang_demangle,            /* Language specific symbol demangler */
1248
  unk_lang_class_name,          /* Language specific class_name_from_physname */
1249
  unk_op_print_tab,             /* expression operators for printing */
1250
  1,                            /* c-style arrays */
1251
  0,                             /* String lower bound */
1252
  default_word_break_characters,
1253
  default_make_symbol_completion_list,
1254
  unknown_language_arch_info,   /* la_language_arch_info.  */
1255
  default_print_array_index,
1256
  default_pass_by_reference,
1257
  default_get_string,
1258
  LANG_MAGIC
1259
};
1260
 
1261
/* Per-architecture language information.  */
1262
 
1263
static struct gdbarch_data *language_gdbarch_data;
1264
 
1265
struct language_gdbarch
1266
{
1267
  /* A vector of per-language per-architecture info.  Indexed by "enum
1268
     language".  */
1269
  struct language_arch_info arch_info[nr_languages];
1270
};
1271
 
1272
static void *
1273
language_gdbarch_post_init (struct gdbarch *gdbarch)
1274
{
1275
  struct language_gdbarch *l;
1276
  int i;
1277
 
1278
  l = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct language_gdbarch);
1279
  for (i = 0; i < languages_size; i++)
1280
    {
1281
      if (languages[i] != NULL
1282
          && languages[i]->la_language_arch_info != NULL)
1283
        languages[i]->la_language_arch_info
1284
          (gdbarch, l->arch_info + languages[i]->la_language);
1285
    }
1286
  return l;
1287
}
1288
 
1289
struct type *
1290
language_string_char_type (const struct language_defn *la,
1291
                           struct gdbarch *gdbarch)
1292
{
1293
  struct language_gdbarch *ld = gdbarch_data (gdbarch,
1294
                                              language_gdbarch_data);
1295
  return ld->arch_info[la->la_language].string_char_type;
1296
}
1297
 
1298
struct type *
1299
language_bool_type (const struct language_defn *la,
1300
                    struct gdbarch *gdbarch)
1301
{
1302
  struct language_gdbarch *ld = gdbarch_data (gdbarch,
1303
                                              language_gdbarch_data);
1304
 
1305
  if (ld->arch_info[la->la_language].bool_type_symbol)
1306
    {
1307
      struct symbol *sym;
1308
      sym = lookup_symbol (ld->arch_info[la->la_language].bool_type_symbol,
1309
                           NULL, VAR_DOMAIN, NULL);
1310
      if (sym)
1311
        {
1312
          struct type *type = SYMBOL_TYPE (sym);
1313
          if (type && TYPE_CODE (type) == TYPE_CODE_BOOL)
1314
            return type;
1315
        }
1316
    }
1317
 
1318
  return ld->arch_info[la->la_language].bool_type_default;
1319
}
1320
 
1321
struct type *
1322
language_lookup_primitive_type_by_name (const struct language_defn *la,
1323
                                        struct gdbarch *gdbarch,
1324
                                        const char *name)
1325
{
1326
  struct language_gdbarch *ld = gdbarch_data (gdbarch,
1327
                                              language_gdbarch_data);
1328
  struct type *const *p;
1329
  for (p = ld->arch_info[la->la_language].primitive_type_vector;
1330
       (*p) != NULL;
1331
       p++)
1332
    {
1333
      if (strcmp (TYPE_NAME (*p), name) == 0)
1334
        return (*p);
1335
    }
1336
  return (NULL);
1337
}
1338
 
1339
/* Initialize the language routines */
1340
 
1341
void
1342
_initialize_language (void)
1343
{
1344
  static const char *type_or_range_names[]
1345
    = { "on", "off", "warn", "auto", NULL };
1346
 
1347
  static const char *case_sensitive_names[]
1348
    = { "on", "off", "auto", NULL };
1349
 
1350
  language_gdbarch_data
1351
    = gdbarch_data_register_post_init (language_gdbarch_post_init);
1352
 
1353
  /* GDB commands for language specific stuff */
1354
 
1355
  add_prefix_cmd ("check", no_class, set_check,
1356
                  _("Set the status of the type/range checker."),
1357
                  &setchecklist, "set check ", 0, &setlist);
1358
  add_alias_cmd ("c", "check", no_class, 1, &setlist);
1359
  add_alias_cmd ("ch", "check", no_class, 1, &setlist);
1360
 
1361
  add_prefix_cmd ("check", no_class, show_check,
1362
                  _("Show the status of the type/range checker."),
1363
                  &showchecklist, "show check ", 0, &showlist);
1364
  add_alias_cmd ("c", "check", no_class, 1, &showlist);
1365
  add_alias_cmd ("ch", "check", no_class, 1, &showlist);
1366
 
1367
  add_setshow_enum_cmd ("type", class_support, type_or_range_names, &type, _("\
1368
Set type checking.  (on/warn/off/auto)"), _("\
1369
Show type checking.  (on/warn/off/auto)"), NULL,
1370
                        set_type_command,
1371
                        show_type_command,
1372
                        &setchecklist, &showchecklist);
1373
 
1374
  add_setshow_enum_cmd ("range", class_support, type_or_range_names,
1375
                        &range, _("\
1376
Set range checking.  (on/warn/off/auto)"), _("\
1377
Show range checking.  (on/warn/off/auto)"), NULL,
1378
                        set_range_command,
1379
                        show_range_command,
1380
                        &setchecklist, &showchecklist);
1381
 
1382
  add_setshow_enum_cmd ("case-sensitive", class_support, case_sensitive_names,
1383
                        &case_sensitive, _("\
1384
Set case sensitivity in name search.  (on/off/auto)"), _("\
1385
Show case sensitivity in name search.  (on/off/auto)"), _("\
1386
For Fortran the default is off; for other languages the default is on."),
1387
                        set_case_command,
1388
                        show_case_command,
1389
                        &setlist, &showlist);
1390
 
1391
  add_language (&auto_language_defn);
1392
  add_language (&local_language_defn);
1393
  add_language (&unknown_language_defn);
1394
 
1395
  language = xstrdup ("auto");
1396
  type = xstrdup ("auto");
1397
  range = xstrdup ("auto");
1398
  case_sensitive = xstrdup ("auto");
1399
 
1400
  /* Have the above take effect */
1401
  set_language (language_auto);
1402
}

powered by: WebSVN 2.1.0

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