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