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