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