gdb/language.h

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