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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gdb-6.8/] [gdb/] [language.h] - Blame information for rev 840

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 24 jeremybenn
/* Source-language-related definitions for GDB.
2
 
3
   Copyright (C) 1991, 1992, 1993, 1994, 1995, 1998, 1999, 2000, 2003, 2004,
4
   2007, 2008 Free Software Foundation, Inc.
5
 
6
   Contributed by the Department of Computer Science at the State University
7
   of New York at Buffalo.
8
 
9
   This file is part of GDB.
10
 
11
   This program is free software; you can redistribute it and/or modify
12
   it under the terms of the GNU General Public License as published by
13
   the Free Software Foundation; either version 3 of the License, or
14
   (at your option) any later version.
15
 
16
   This program is distributed in the hope that it will be useful,
17
   but WITHOUT ANY WARRANTY; without even the implied warranty of
18
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19
   GNU General Public License for more details.
20
 
21
   You should have received a copy of the GNU General Public License
22
   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
23
 
24
#if !defined (LANGUAGE_H)
25
#define LANGUAGE_H 1
26
 
27
/* Forward decls for prototypes */
28
struct value;
29
struct objfile;
30
struct frame_info;
31
struct expression;
32
struct ui_file;
33
 
34
/* This used to be included to configure GDB for one or more specific
35
   languages.  Now it is left out to configure for all of them.  FIXME.  */
36
/* #include "lang_def.h" */
37
#define _LANG_c
38
#define _LANG_m2
39
#define  _LANG_fortran
40
#define  _LANG_pascal
41
 
42
#define MAX_FORTRAN_DIMS  7     /* Maximum number of F77 array dims */
43
 
44
/* range_mode ==
45
   range_mode_auto:   range_check set automatically to default of language.
46
   range_mode_manual: range_check set manually by user.  */
47
 
48
extern enum range_mode
49
  {
50
    range_mode_auto, range_mode_manual
51
  }
52
range_mode;
53
 
54
/* range_check ==
55
   range_check_on:    Ranges are checked in GDB expressions, producing errors.
56
   range_check_warn:  Ranges are checked, producing warnings.
57
   range_check_off:   Ranges are not checked in GDB expressions.  */
58
 
59
extern enum range_check
60
  {
61
    range_check_off, range_check_warn, range_check_on
62
  }
63
range_check;
64
 
65
/* type_mode ==
66
   type_mode_auto:   type_check set automatically to default of language
67
   type_mode_manual: type_check set manually by user. */
68
 
69
extern enum type_mode
70
  {
71
    type_mode_auto, type_mode_manual
72
  }
73
type_mode;
74
 
75
/* type_check ==
76
   type_check_on:    Types are checked in GDB expressions, producing errors.
77
   type_check_warn:  Types are checked, producing warnings.
78
   type_check_off:   Types are not checked in GDB expressions.  */
79
 
80
extern enum type_check
81
  {
82
    type_check_off, type_check_warn, type_check_on
83
  }
84
type_check;
85
 
86
/* case_mode ==
87
   case_mode_auto:   case_sensitivity set upon selection of scope
88
   case_mode_manual: case_sensitivity set only by user.  */
89
 
90
extern enum case_mode
91
  {
92
    case_mode_auto, case_mode_manual
93
  }
94
case_mode;
95
 
96
/* array_ordering ==
97
   array_row_major:     Arrays are in row major order
98
   array_column_major:  Arrays are in column major order.*/
99
 
100
extern enum array_ordering
101
  {
102
    array_row_major, array_column_major
103
  }
104
array_ordering;
105
 
106
 
107
/* case_sensitivity ==
108
   case_sensitive_on:   Case sensitivity in name matching is used
109
   case_sensitive_off:  Case sensitivity in name matching is not used  */
110
 
111
extern enum case_sensitivity
112
  {
113
    case_sensitive_on, case_sensitive_off
114
  }
115
case_sensitivity;
116
 
117
/* Per architecture (OS/ABI) language information.  */
118
 
119
struct language_arch_info
120
{
121
  /* Its primitive types.  This is a vector ended by a NULL pointer.
122
     These types can be specified by name in parsing types in
123
     expressions, regardless of whether the program being debugged
124
     actually defines such a type.  */
125
  struct type **primitive_type_vector;
126
  /* Type of elements of strings. */
127
  struct type *string_char_type;
128
};
129
 
130
/* Structure tying together assorted information about a language.  */
131
 
132
struct language_defn
133
  {
134
    /* Name of the language */
135
 
136
    char *la_name;
137
 
138
    /* its symtab language-enum (defs.h) */
139
 
140
    enum language la_language;
141
 
142
    /* Default range checking */
143
 
144
    enum range_check la_range_check;
145
 
146
    /* Default type checking */
147
 
148
    enum type_check la_type_check;
149
 
150
    /* Default case sensitivity */
151
    enum case_sensitivity la_case_sensitivity;
152
 
153
    /* Multi-dimensional array ordering */
154
    enum array_ordering la_array_ordering;
155
 
156
    /* Definitions related to expression printing, prefixifying, and
157
       dumping */
158
 
159
    const struct exp_descriptor *la_exp_desc;
160
 
161
    /* Parser function. */
162
 
163
    int (*la_parser) (void);
164
 
165
    /* Parser error function */
166
 
167
    void (*la_error) (char *);
168
 
169
    /* Given an expression *EXPP created by prefixifying the result of
170
       la_parser, perform any remaining processing necessary to complete
171
       its translation.  *EXPP may change; la_post_parser is responsible
172
       for releasing its previous contents, if necessary.  If
173
       VOID_CONTEXT_P, then no value is expected from the expression.  */
174
 
175
    void (*la_post_parser) (struct expression ** expp, int void_context_p);
176
 
177
    void (*la_printchar) (int ch, struct ui_file * stream);
178
 
179
    void (*la_printstr) (struct ui_file * stream, const gdb_byte *string,
180
                         unsigned int length, int width,
181
                         int force_ellipses);
182
 
183
    void (*la_emitchar) (int ch, struct ui_file * stream, int quoter);
184
 
185
    /* Print a type using syntax appropriate for this language. */
186
 
187
    void (*la_print_type) (struct type *, char *, struct ui_file *, int,
188
                           int);
189
 
190
    /* Print a value using syntax appropriate for this language. */
191
 
192
    int (*la_val_print) (struct type *, const gdb_byte *, int, CORE_ADDR,
193
                         struct ui_file *, int, int, int,
194
                         enum val_prettyprint);
195
 
196
    /* Print a top-level value using syntax appropriate for this language. */
197
 
198
    int (*la_value_print) (struct value *, struct ui_file *,
199
                           int, enum val_prettyprint);
200
 
201
    /* PC is possibly an unknown languages trampoline.
202
       If that PC falls in a trampoline belonging to this language,
203
       return the address of the first pc in the real function, or 0
204
       if it isn't a language tramp for this language.  */
205
    CORE_ADDR (*skip_trampoline) (struct frame_info *, CORE_ADDR);
206
 
207
    /* Now come some hooks for lookup_symbol.  */
208
 
209
    /* If this is non-NULL, lookup_symbol will do the 'field_of_this'
210
       check, using this function to find the value of this.  */
211
 
212
    /* FIXME: carlton/2003-05-19: Audit all the language_defn structs
213
       to make sure we're setting this appropriately: I'm sure it
214
       could be NULL in more languages.  */
215
 
216
    struct value *(*la_value_of_this) (int complain);
217
 
218
    /* This is a function that lookup_symbol will call when it gets to
219
       the part of symbol lookup where C looks up static and global
220
       variables.  */
221
 
222
    struct symbol *(*la_lookup_symbol_nonlocal) (const char *,
223
                                                 const char *,
224
                                                 const struct block *,
225
                                                 const domain_enum,
226
                                                 struct symtab **);
227
 
228
    /* Find the definition of the type with the given name.  */
229
    struct type *(*la_lookup_transparent_type) (const char *);
230
 
231
    /* Return demangled language symbol, or NULL.  */
232
    char *(*la_demangle) (const char *mangled, int options);
233
 
234
    /* Return class name of a mangled method name or NULL.  */
235
    char *(*la_class_name_from_physname) (const char *physname);
236
 
237
    /* Table for printing expressions */
238
 
239
    const struct op_print *la_op_print_tab;
240
 
241
    /* Zero if the language has first-class arrays.  True if there are no
242
       array values, and array objects decay to pointers, as in C. */
243
 
244
    char c_style_arrays;
245
 
246
    /* Index to use for extracting the first element of a string. */
247
    char string_lower_bound;
248
 
249
    /* The list of characters forming word boundaries.  */
250
    char *(*la_word_break_characters) (void);
251
 
252
    /* Should return a NULL terminated array of all symbols which
253
       are possible completions for TEXT.  WORD is the entire command
254
       on which the completion is being made.  */
255
    char **(*la_make_symbol_completion_list) (char *text, char *word);
256
 
257
    /* The per-architecture (OS/ABI) language information.  */
258
    void (*la_language_arch_info) (struct gdbarch *,
259
                                   struct language_arch_info *);
260
 
261
    /* Print the index of an element of an array.  */
262
    void (*la_print_array_index) (struct value *index_value,
263
                                  struct ui_file *stream,
264
                                  int format,
265
                                  enum val_prettyprint pretty);
266
 
267
    /* Return non-zero if TYPE should be passed (and returned) by
268
       reference at the language level.  */
269
    int (*la_pass_by_reference) (struct type *type);
270
 
271
    /* Add fields above this point, so the magic number is always last. */
272
    /* Magic number for compat checking */
273
 
274
    long la_magic;
275
 
276
  };
277
 
278
#define LANG_MAGIC      910823L
279
 
280
/* Pointer to the language_defn for our current language.  This pointer
281
   always points to *some* valid struct; it can be used without checking
282
   it for validity.
283
 
284
   The current language affects expression parsing and evaluation
285
   (FIXME: it might be cleaner to make the evaluation-related stuff
286
   separate exp_opcodes for each different set of semantics.  We
287
   should at least think this through more clearly with respect to
288
   what happens if the language is changed between parsing and
289
   evaluation) and printing of things like types and arrays.  It does
290
   *not* affect symbol-reading-- each source file in a symbol-file has
291
   its own language and we should keep track of that regardless of the
292
   language when symbols are read.  If we want some manual setting for
293
   the language of symbol files (e.g. detecting when ".c" files are
294
   C++), it should be a separate setting from the current_language.  */
295
 
296
extern const struct language_defn *current_language;
297
 
298
/* Pointer to the language_defn expected by the user, e.g. the language
299
   of main(), or the language we last mentioned in a message, or C.  */
300
 
301
extern const struct language_defn *expected_language;
302
 
303
/* language_mode ==
304
   language_mode_auto:   current_language automatically set upon selection
305
   of scope (e.g. stack frame)
306
   language_mode_manual: current_language set only by user.  */
307
 
308
extern enum language_mode
309
  {
310
    language_mode_auto, language_mode_manual
311
  }
312
language_mode;
313
 
314
struct type *language_string_char_type (const struct language_defn *l,
315
                                        struct gdbarch *gdbarch);
316
 
317
struct type *language_lookup_primitive_type_by_name (const struct language_defn *l,
318
                                                     struct gdbarch *gdbarch,
319
                                                     const char *name);
320
 
321
 
322
/* These macros define the behaviour of the expression
323
   evaluator.  */
324
 
325
/* Should we strictly type check expressions? */
326
#define STRICT_TYPE (type_check != type_check_off)
327
 
328
/* Should we range check values against the domain of their type? */
329
#define RANGE_CHECK (range_check != range_check_off)
330
 
331
/* "cast" really means conversion */
332
/* FIXME -- should be a setting in language_defn */
333
#define CAST_IS_CONVERSION (current_language->la_language == language_c  || \
334
                            current_language->la_language == language_cplus || \
335
                            current_language->la_language == language_objc)
336
 
337
extern void language_info (int);
338
 
339
extern enum language set_language (enum language);
340
 
341
 
342
/* This page contains functions that return things that are
343
   specific to languages.  Each of these functions is based on
344
   the current setting of working_lang, which the user sets
345
   with the "set language" command. */
346
 
347
#define LA_PRINT_TYPE(type,varstring,stream,show,level) \
348
  (current_language->la_print_type(type,varstring,stream,show,level))
349
 
350
#define LA_VAL_PRINT(type,valaddr,offset,addr,stream,fmt,deref,recurse,pretty) \
351
  (current_language->la_val_print(type,valaddr,offset,addr,stream,fmt,deref, \
352
                                  recurse,pretty))
353
#define LA_VALUE_PRINT(val,stream,fmt,pretty) \
354
  (current_language->la_value_print(val,stream,fmt,pretty))
355
 
356
#define LA_PRINT_CHAR(ch, stream) \
357
  (current_language->la_printchar(ch, stream))
358
#define LA_PRINT_STRING(stream, string, length, width, force_ellipses) \
359
  (current_language->la_printstr(stream, string, length, width, force_ellipses))
360
#define LA_EMIT_CHAR(ch, stream, quoter) \
361
  (current_language->la_emitchar(ch, stream, quoter))
362
 
363
#define LA_PRINT_ARRAY_INDEX(index_value, stream, format, pretty) \
364
  (current_language->la_print_array_index(index_value, stream, format, pretty))
365
 
366
/* Test a character to decide whether it can be printed in literal form
367
   or needs to be printed in another representation.  For example,
368
   in C the literal form of the character with octal value 141 is 'a'
369
   and the "other representation" is '\141'.  The "other representation"
370
   is program language dependent. */
371
 
372
#define PRINT_LITERAL_FORM(c)           \
373
  ((c) >= 0x20                          \
374
   && ((c) < 0x7F || (c) >= 0xA0)       \
375
   && (!sevenbit_strings || (c) < 0x80))
376
 
377
#if 0
378
/* FIXME: cagney/2000-03-04: This function does not appear to be used.
379
   It can be deleted once 5.0 has been released. */
380
/* Return a string that contains the hex digits of the number.  No preceeding
381
   "0x" */
382
 
383
extern char *longest_raw_hex_string (LONGEST);
384
#endif
385
 
386
/* Type predicates */
387
 
388
extern int simple_type (struct type *);
389
 
390
extern int ordered_type (struct type *);
391
 
392
extern int same_type (struct type *, struct type *);
393
 
394
extern int integral_type (struct type *);
395
 
396
extern int numeric_type (struct type *);
397
 
398
extern int character_type (struct type *);
399
 
400
extern int boolean_type (struct type *);
401
 
402
extern int float_type (struct type *);
403
 
404
extern int pointer_type (struct type *);
405
 
406
extern int structured_type (struct type *);
407
 
408
/* Checks Binary and Unary operations for semantic type correctness */
409
/* FIXME:  Does not appear to be used */
410
#define unop_type_check(v,o) binop_type_check((v),NULL,(o))
411
 
412
extern void binop_type_check (struct value *, struct value *, int);
413
 
414
/* Error messages */
415
 
416
extern void type_error (const char *, ...) ATTR_FORMAT (printf, 1, 2);
417
 
418
extern void range_error (const char *, ...) ATTR_FORMAT (printf, 1, 2);
419
 
420
/* Data:  Does this value represent "truth" to the current language?  */
421
 
422
extern int value_true (struct value *);
423
 
424
extern struct type *lang_bool_type (void);
425
 
426
/* The type used for Boolean values in the current language. */
427
#define LA_BOOL_TYPE lang_bool_type ()
428
 
429
/* Misc:  The string representing a particular enum language.  */
430
 
431
extern enum language language_enum (char *str);
432
 
433
extern const struct language_defn *language_def (enum language);
434
 
435
extern char *language_str (enum language);
436
 
437
/* Add a language to the set known by GDB (at initialization time).  */
438
 
439
extern void add_language (const struct language_defn *);
440
 
441
extern enum language get_frame_language (void); /* In stack.c */
442
 
443
/* Check for a language-specific trampoline. */
444
 
445
extern CORE_ADDR skip_language_trampoline (struct frame_info *, CORE_ADDR pc);
446
 
447
/* Return demangled language symbol, or NULL.  */
448
extern char *language_demangle (const struct language_defn *current_language,
449
                                const char *mangled, int options);
450
 
451
/* Return class name from physname, or NULL.  */
452
extern char *language_class_name_from_physname (const struct language_defn *,
453
                                                const char *physname);
454
 
455
/* Splitting strings into words.  */
456
extern char *default_word_break_characters (void);
457
 
458
/* Print the index of an array element using the C99 syntax.  */
459
extern void default_print_array_index (struct value *index_value,
460
                                       struct ui_file *stream,
461
                                       int format,
462
                                       enum val_prettyprint pretty);
463
 
464
/* Return non-zero if TYPE should be passed (and returned) by
465
   reference at the language level.  */
466
int language_pass_by_reference (struct type *type);
467
 
468
/* Return zero; by default, types are passed by value at the language
469
   level.  The target ABI may pass or return some structs by reference
470
   independent of this.  */
471
int default_pass_by_reference (struct type *type);
472
 
473
#endif /* defined (LANGUAGE_H) */

powered by: WebSVN 2.1.0

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