gdb/language.h

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