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