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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-stable/] [gdb-7.2/] [gdb/] [language.h] - Blame information for rev 841

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 330 jeremybenn
/* Source-language-related definitions for GDB.
2
 
3
   Copyright (C) 1991, 1992, 1993, 1994, 1995, 1998, 1999, 2000, 2003, 2004,
4
   2007, 2008, 2009, 2010 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
struct value_print_options;
34
 
35
#define MAX_FORTRAN_DIMS  7     /* Maximum number of F77 array dims */
36
 
37
/* range_mode ==
38
   range_mode_auto:   range_check set automatically to default of language.
39
   range_mode_manual: range_check set manually by user.  */
40
 
41
extern enum range_mode
42
  {
43
    range_mode_auto, range_mode_manual
44
  }
45
range_mode;
46
 
47
/* range_check ==
48
   range_check_on:    Ranges are checked in GDB expressions, producing errors.
49
   range_check_warn:  Ranges are checked, producing warnings.
50
   range_check_off:   Ranges are not checked in GDB expressions.  */
51
 
52
extern enum range_check
53
  {
54
    range_check_off, range_check_warn, range_check_on
55
  }
56
range_check;
57
 
58
/* type_mode ==
59
   type_mode_auto:   type_check set automatically to default of language
60
   type_mode_manual: type_check set manually by user. */
61
 
62
extern enum type_mode
63
  {
64
    type_mode_auto, type_mode_manual
65
  }
66
type_mode;
67
 
68
/* type_check ==
69
   type_check_on:    Types are checked in GDB expressions, producing errors.
70
   type_check_warn:  Types are checked, producing warnings.
71
   type_check_off:   Types are not checked in GDB expressions.  */
72
 
73
extern enum type_check
74
  {
75
    type_check_off, type_check_warn, type_check_on
76
  }
77
type_check;
78
 
79
/* case_mode ==
80
   case_mode_auto:   case_sensitivity set upon selection of scope
81
   case_mode_manual: case_sensitivity set only by user.  */
82
 
83
extern enum case_mode
84
  {
85
    case_mode_auto, case_mode_manual
86
  }
87
case_mode;
88
 
89
/* array_ordering ==
90
   array_row_major:     Arrays are in row major order
91
   array_column_major:  Arrays are in column major order.*/
92
 
93
extern enum array_ordering
94
  {
95
    array_row_major, array_column_major
96
  }
97
array_ordering;
98
 
99
 
100
/* case_sensitivity ==
101
   case_sensitive_on:   Case sensitivity in name matching is used
102
   case_sensitive_off:  Case sensitivity in name matching is not used  */
103
 
104
extern enum case_sensitivity
105
  {
106
    case_sensitive_on, case_sensitive_off
107
  }
108
case_sensitivity;
109
 
110
 
111
/* macro_expansion ==
112
   macro_expansion_no:  No macro expansion is available
113
   macro_expansion_c:   C-like macro expansion is available  */
114
 
115
enum macro_expansion
116
  {
117
    macro_expansion_no, macro_expansion_c
118
  };
119
 
120
 
121
/* Per architecture (OS/ABI) language information.  */
122
 
123
struct language_arch_info
124
{
125
  /* Its primitive types.  This is a vector ended by a NULL pointer.
126
     These types can be specified by name in parsing types in
127
     expressions, regardless of whether the program being debugged
128
     actually defines such a type.  */
129
  struct type **primitive_type_vector;
130
  /* Type of elements of strings. */
131
  struct type *string_char_type;
132
 
133
  /* Symbol name of type to use as boolean type, if defined.  */
134
  const char *bool_type_symbol;
135
  /* Otherwise, this is the default boolean builtin type.  */
136
  struct type *bool_type_default;
137
};
138
 
139
/* Structure tying together assorted information about a language.  */
140
 
141
struct language_defn
142
  {
143
    /* Name of the language */
144
 
145
    char *la_name;
146
 
147
    /* its symtab language-enum (defs.h) */
148
 
149
    enum language la_language;
150
 
151
    /* Default range checking */
152
 
153
    enum range_check la_range_check;
154
 
155
    /* Default type checking */
156
 
157
    enum type_check la_type_check;
158
 
159
    /* Default case sensitivity */
160
    enum case_sensitivity la_case_sensitivity;
161
 
162
    /* Multi-dimensional array ordering */
163
    enum array_ordering la_array_ordering;
164
 
165
    /* Style of macro expansion, if any, supported by this language.  */
166
    enum macro_expansion la_macro_expansion;
167
 
168
    /* Definitions related to expression printing, prefixifying, and
169
       dumping */
170
 
171
    const struct exp_descriptor *la_exp_desc;
172
 
173
    /* Parser function. */
174
 
175
    int (*la_parser) (void);
176
 
177
    /* Parser error function */
178
 
179
    void (*la_error) (char *);
180
 
181
    /* Given an expression *EXPP created by prefixifying the result of
182
       la_parser, perform any remaining processing necessary to complete
183
       its translation.  *EXPP may change; la_post_parser is responsible
184
       for releasing its previous contents, if necessary.  If
185
       VOID_CONTEXT_P, then no value is expected from the expression.  */
186
 
187
    void (*la_post_parser) (struct expression ** expp, int void_context_p);
188
 
189
    void (*la_printchar) (int ch, struct type *chtype, struct ui_file * stream);
190
 
191
    void (*la_printstr) (struct ui_file * stream, struct type *elttype,
192
                         const gdb_byte *string, unsigned int length,
193
                         const char *encoding, int force_ellipses,
194
                         const struct value_print_options *);
195
 
196
    void (*la_emitchar) (int ch, struct type *chtype,
197
                         struct ui_file * stream, int quoter);
198
 
199
    /* Print a type using syntax appropriate for this language. */
200
 
201
    void (*la_print_type) (struct type *, const char *, struct ui_file *, int,
202
                           int);
203
 
204
    /* Print a typedef using syntax appropriate for this language.
205
       TYPE is the underlying type.  NEW_SYMBOL is the symbol naming
206
       the type.  STREAM is the output stream on which to print.  */
207
 
208
    void (*la_print_typedef) (struct type *type, struct symbol *new_symbol,
209
                              struct ui_file *stream);
210
 
211
    /* Print a value using syntax appropriate for this language.
212
 
213
       TYPE is the type of the sub-object to be printed.
214
 
215
       CONTENTS holds the bits of the value.  This holds the entire
216
       enclosing object.
217
 
218
       EMBEDDED_OFFSET is the offset into the outermost object of the
219
       sub-object represented by TYPE.  This is the object which this
220
       call should print.  Note that the enclosing type is not
221
       available.
222
 
223
       ADDRESS is the address in the inferior of the enclosing object.
224
 
225
       STREAM is the stream on which the value is to be printed.
226
 
227
       RECURSE is the recursion depth.  It is zero-based.
228
 
229
       OPTIONS are the formatting options to be used when
230
       printing.  */
231
 
232
    int (*la_val_print) (struct type *type,
233
                         const gdb_byte *contents,
234
                         int embedded_offset, CORE_ADDR address,
235
                         struct ui_file *stream, int recurse,
236
                         const struct value *val,
237
                         const struct value_print_options *options);
238
 
239
    /* Print a top-level value using syntax appropriate for this language. */
240
 
241
    int (*la_value_print) (struct value *, struct ui_file *,
242
                           const struct value_print_options *);
243
 
244
    /* PC is possibly an unknown languages trampoline.
245
       If that PC falls in a trampoline belonging to this language,
246
       return the address of the first pc in the real function, or 0
247
       if it isn't a language tramp for this language.  */
248
    CORE_ADDR (*skip_trampoline) (struct frame_info *, CORE_ADDR);
249
 
250
    /* Now come some hooks for lookup_symbol.  */
251
 
252
    /* If this is non-NULL, specifies the name that of the implicit
253
       local variable that refers to the current object instance.  */
254
 
255
    char *la_name_of_this;
256
 
257
    /* This is a function that lookup_symbol will call when it gets to
258
       the part of symbol lookup where C looks up static and global
259
       variables.  */
260
 
261
    struct symbol *(*la_lookup_symbol_nonlocal) (const char *,
262
                                                 const struct block *,
263
                                                 const domain_enum);
264
 
265
    /* Find the definition of the type with the given name.  */
266
    struct type *(*la_lookup_transparent_type) (const char *);
267
 
268
    /* Return demangled language symbol, or NULL.  */
269
    char *(*la_demangle) (const char *mangled, int options);
270
 
271
    /* Return class name of a mangled method name or NULL.  */
272
    char *(*la_class_name_from_physname) (const char *physname);
273
 
274
    /* Table for printing expressions */
275
 
276
    const struct op_print *la_op_print_tab;
277
 
278
    /* Zero if the language has first-class arrays.  True if there are no
279
       array values, and array objects decay to pointers, as in C. */
280
 
281
    char c_style_arrays;
282
 
283
    /* Index to use for extracting the first element of a string. */
284
    char string_lower_bound;
285
 
286
    /* The list of characters forming word boundaries.  */
287
    char *(*la_word_break_characters) (void);
288
 
289
    /* Should return a NULL terminated array of all symbols which
290
       are possible completions for TEXT.  WORD is the entire command
291
       on which the completion is being made.  */
292
    char **(*la_make_symbol_completion_list) (char *text, char *word);
293
 
294
    /* The per-architecture (OS/ABI) language information.  */
295
    void (*la_language_arch_info) (struct gdbarch *,
296
                                   struct language_arch_info *);
297
 
298
    /* Print the index of an element of an array.  */
299
    void (*la_print_array_index) (struct value *index_value,
300
                                  struct ui_file *stream,
301
                                  const struct value_print_options *options);
302
 
303
    /* Return non-zero if TYPE should be passed (and returned) by
304
       reference at the language level.  */
305
    int (*la_pass_by_reference) (struct type *type);
306
 
307
    /* Obtain a string from the inferior, storing it in a newly allocated
308
       buffer in BUFFER, which should be freed by the caller.  If the
309
       in- and out-parameter *LENGTH is specified at -1, the string is
310
       read until a null character of the appropriate width is found -
311
       otherwise the string is read to the length of characters specified.
312
       On completion, *LENGTH will hold the size of the string in characters.
313
       If a *LENGTH of -1 was specified it will count only actual
314
       characters, excluding any eventual terminating null character.
315
       Otherwise *LENGTH will include all characters - including any nulls.
316
       CHARSET will hold the encoding used in the string.  */
317
    void (*la_get_string) (struct value *value, gdb_byte **buffer, int *length,
318
                           struct type **chartype, const char **charset);
319
 
320
    /* Add fields above this point, so the magic number is always last. */
321
    /* Magic number for compat checking */
322
 
323
    long la_magic;
324
 
325
  };
326
 
327
#define LANG_MAGIC      910823L
328
 
329
/* Pointer to the language_defn for our current language.  This pointer
330
   always points to *some* valid struct; it can be used without checking
331
   it for validity.
332
 
333
   The current language affects expression parsing and evaluation
334
   (FIXME: it might be cleaner to make the evaluation-related stuff
335
   separate exp_opcodes for each different set of semantics.  We
336
   should at least think this through more clearly with respect to
337
   what happens if the language is changed between parsing and
338
   evaluation) and printing of things like types and arrays.  It does
339
   *not* affect symbol-reading-- each source file in a symbol-file has
340
   its own language and we should keep track of that regardless of the
341
   language when symbols are read.  If we want some manual setting for
342
   the language of symbol files (e.g. detecting when ".c" files are
343
   C++), it should be a separate setting from the current_language.  */
344
 
345
extern const struct language_defn *current_language;
346
 
347
/* Pointer to the language_defn expected by the user, e.g. the language
348
   of main(), or the language we last mentioned in a message, or C.  */
349
 
350
extern const struct language_defn *expected_language;
351
 
352
/* language_mode ==
353
   language_mode_auto:   current_language automatically set upon selection
354
   of scope (e.g. stack frame)
355
   language_mode_manual: current_language set only by user.  */
356
 
357
extern enum language_mode
358
  {
359
    language_mode_auto, language_mode_manual
360
  }
361
language_mode;
362
 
363
struct type *language_bool_type (const struct language_defn *l,
364
                                 struct gdbarch *gdbarch);
365
 
366
struct type *language_string_char_type (const struct language_defn *l,
367
                                        struct gdbarch *gdbarch);
368
 
369
struct type *language_lookup_primitive_type_by_name (const struct language_defn *l,
370
                                                     struct gdbarch *gdbarch,
371
                                                     const char *name);
372
 
373
 
374
/* These macros define the behaviour of the expression
375
   evaluator.  */
376
 
377
/* Should we strictly type check expressions? */
378
#define STRICT_TYPE (type_check != type_check_off)
379
 
380
/* Should we range check values against the domain of their type? */
381
#define RANGE_CHECK (range_check != range_check_off)
382
 
383
/* "cast" really means conversion */
384
/* FIXME -- should be a setting in language_defn */
385
#define CAST_IS_CONVERSION(LANG) ((LANG)->la_language == language_c  || \
386
                                  (LANG)->la_language == language_cplus || \
387
                                  (LANG)->la_language == language_objc)
388
 
389
extern void language_info (int);
390
 
391
extern enum language set_language (enum language);
392
 
393
 
394
/* This page contains functions that return things that are
395
   specific to languages.  Each of these functions is based on
396
   the current setting of working_lang, which the user sets
397
   with the "set language" command. */
398
 
399
#define LA_PRINT_TYPE(type,varstring,stream,show,level) \
400
  (current_language->la_print_type(type,varstring,stream,show,level))
401
 
402
#define LA_PRINT_TYPEDEF(type,new_symbol,stream) \
403
  (current_language->la_print_typedef(type,new_symbol,stream))
404
 
405
#define LA_VAL_PRINT(type,valaddr,offset,addr,stream,val,recurse,options) \
406
  (current_language->la_val_print(type,valaddr,offset,addr,stream, \
407
                                  val,recurse,options))
408
#define LA_VALUE_PRINT(val,stream,options) \
409
  (current_language->la_value_print(val,stream,options))
410
 
411
#define LA_PRINT_CHAR(ch, type, stream) \
412
  (current_language->la_printchar(ch, type, stream))
413
#define LA_PRINT_STRING(stream, elttype, string, length, encoding, force_ellipses,options) \
414
  (current_language->la_printstr(stream, elttype, string, length, \
415
                                 encoding, force_ellipses,options))
416
#define LA_EMIT_CHAR(ch, type, stream, quoter) \
417
  (current_language->la_emitchar(ch, type, stream, quoter))
418
#define LA_GET_STRING(value, buffer, length, chartype, encoding) \
419
  (current_language->la_get_string(value, buffer, length, chartype, encoding))
420
 
421
#define LA_PRINT_ARRAY_INDEX(index_value, stream, optins) \
422
  (current_language->la_print_array_index(index_value, stream, options))
423
 
424
/* Test a character to decide whether it can be printed in literal form
425
   or needs to be printed in another representation.  For example,
426
   in C the literal form of the character with octal value 141 is 'a'
427
   and the "other representation" is '\141'.  The "other representation"
428
   is program language dependent. */
429
 
430
#define PRINT_LITERAL_FORM(c)           \
431
  ((c) >= 0x20                          \
432
   && ((c) < 0x7F || (c) >= 0xA0)       \
433
   && (!sevenbit_strings || (c) < 0x80))
434
 
435
/* Type predicates */
436
 
437
extern int simple_type (struct type *);
438
 
439
extern int ordered_type (struct type *);
440
 
441
extern int same_type (struct type *, struct type *);
442
 
443
extern int integral_type (struct type *);
444
 
445
extern int numeric_type (struct type *);
446
 
447
extern int character_type (struct type *);
448
 
449
extern int boolean_type (struct type *);
450
 
451
extern int float_type (struct type *);
452
 
453
extern int pointer_type (struct type *);
454
 
455
extern int structured_type (struct type *);
456
 
457
/* Checks Binary and Unary operations for semantic type correctness */
458
/* FIXME:  Does not appear to be used */
459
#define unop_type_check(v,o) binop_type_check((v),NULL,(o))
460
 
461
extern void binop_type_check (struct value *, struct value *, int);
462
 
463
/* Error messages */
464
 
465
extern void type_error (const char *, ...) ATTRIBUTE_PRINTF (1, 2);
466
 
467
extern void range_error (const char *, ...) ATTRIBUTE_PRINTF (1, 2);
468
 
469
/* Data:  Does this value represent "truth" to the current language?  */
470
 
471
extern int value_true (struct value *);
472
 
473
/* Misc:  The string representing a particular enum language.  */
474
 
475
extern enum language language_enum (char *str);
476
 
477
extern const struct language_defn *language_def (enum language);
478
 
479
extern char *language_str (enum language);
480
 
481
/* Add a language to the set known by GDB (at initialization time).  */
482
 
483
extern void add_language (const struct language_defn *);
484
 
485
extern enum language get_frame_language (void); /* In stack.c */
486
 
487
/* Check for a language-specific trampoline. */
488
 
489
extern CORE_ADDR skip_language_trampoline (struct frame_info *, CORE_ADDR pc);
490
 
491
/* Return demangled language symbol, or NULL.  */
492
extern char *language_demangle (const struct language_defn *current_language,
493
                                const char *mangled, int options);
494
 
495
/* Return class name from physname, or NULL.  */
496
extern char *language_class_name_from_physname (const struct language_defn *,
497
                                                const char *physname);
498
 
499
/* Splitting strings into words.  */
500
extern char *default_word_break_characters (void);
501
 
502
/* Print the index of an array element using the C99 syntax.  */
503
extern void default_print_array_index (struct value *index_value,
504
                                       struct ui_file *stream,
505
                                       const struct value_print_options *options);
506
 
507
/* Return non-zero if TYPE should be passed (and returned) by
508
   reference at the language level.  */
509
int language_pass_by_reference (struct type *type);
510
 
511
/* Return zero; by default, types are passed by value at the language
512
   level.  The target ABI may pass or return some structs by reference
513
   independent of this.  */
514
int default_pass_by_reference (struct type *type);
515
 
516
/* The default implementation of la_print_typedef.  */
517
void default_print_typedef (struct type *type, struct symbol *new_symbol,
518
                            struct ui_file *stream);
519
 
520
void default_get_string (struct value *value, gdb_byte **buffer, int *length,
521
                         struct type **char_type, const char **charset);
522
 
523
void c_get_string (struct value *value, gdb_byte **buffer, int *length,
524
                   struct type **char_type, const char **charset);
525
 
526
#endif /* defined (LANGUAGE_H) */

powered by: WebSVN 2.1.0

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