Commit | Line | Data |
---|---|---|
22e39759 FF |
1 | /* Chill language support routines for GDB, the GNU debugger. |
2 | Copyright 1992 Free Software Foundation, Inc. | |
3 | ||
4 | This file is part of GDB. | |
5 | ||
6 | This program is free software; you can redistribute it and/or modify | |
7 | it under the terms of the GNU General Public License as published by | |
8 | the Free Software Foundation; either version 2 of the License, or | |
9 | (at your option) any later version. | |
10 | ||
11 | This program is distributed in the hope that it will be useful, | |
12 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
13 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
14 | GNU General Public License for more details. | |
15 | ||
16 | You should have received a copy of the GNU General Public License | |
17 | along with this program; if not, write to the Free Software | |
18 | Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ | |
19 | ||
20 | #include "defs.h" | |
21 | #include "symtab.h" | |
22 | #include "gdbtypes.h" | |
23 | #include "expression.h" | |
24 | #include "parser-defs.h" | |
25 | #include "language.h" | |
26 | #include "ch-lang.h" | |
27 | ||
7532cf10 FF |
28 | |
29 | /* For now, Chill uses a simple mangling algorithm whereby you simply | |
30 | discard everything after the occurance of two successive CPLUS_MARKER | |
31 | characters to derive the demangled form. */ | |
32 | ||
33 | char * | |
34 | chill_demangle (mangled) | |
35 | const char *mangled; | |
36 | { | |
37 | char *joiner; | |
38 | char *demangled; | |
39 | ||
40 | joiner = strchr (mangled, CPLUS_MARKER); | |
41 | if (joiner != NULL && *(joiner + 1) == CPLUS_MARKER) | |
42 | { | |
43 | demangled = savestring (mangled, joiner - mangled); | |
44 | } | |
45 | else | |
46 | { | |
47 | demangled = NULL; | |
48 | } | |
49 | return (demangled); | |
50 | } | |
51 | ||
22e39759 FF |
52 | static void |
53 | chill_printchar (c, stream) | |
54 | register int c; | |
199b2450 | 55 | GDB_FILE *stream; |
22e39759 FF |
56 | { |
57 | c &= 0xFF; /* Avoid sign bit follies */ | |
58 | ||
59 | if (PRINT_LITERAL_FORM (c)) | |
60 | { | |
61 | fprintf_filtered (stream, "'%c'", c); | |
62 | } | |
63 | else | |
64 | { | |
65 | fprintf_filtered (stream, "C'%.2x'", (unsigned int) c); | |
66 | } | |
67 | } | |
68 | ||
69 | /* Print the character string STRING, printing at most LENGTH characters. | |
70 | Printing stops early if the number hits print_max; repeat counts | |
71 | are printed as appropriate. Print ellipses at the end if we | |
72 | had to stop before printing LENGTH characters, or if FORCE_ELLIPSES. | |
73 | Note that gdb maintains the length of strings without counting the | |
74 | terminating null byte, while chill strings are typically written with | |
75 | an explicit null byte. So we always assume an implied null byte | |
76 | until gdb is able to maintain non-null terminated strings as well | |
77 | as null terminated strings (FIXME). | |
78 | */ | |
79 | ||
80 | static void | |
81 | chill_printstr (stream, string, length, force_ellipses) | |
199b2450 | 82 | GDB_FILE *stream; |
22e39759 FF |
83 | char *string; |
84 | unsigned int length; | |
85 | int force_ellipses; | |
86 | { | |
87 | register unsigned int i; | |
88 | unsigned int things_printed = 0; | |
89 | int in_literal_form = 0; | |
90 | int in_control_form = 0; | |
91 | int need_slashslash = 0; | |
92 | unsigned int c; | |
93 | extern int repeat_count_threshold; | |
94 | extern int print_max; | |
95 | ||
96 | if (length == 0) | |
97 | { | |
96b6b765 | 98 | fputs_filtered ("\"\"", stream); |
22e39759 FF |
99 | return; |
100 | } | |
101 | ||
102 | for (i = 0; i < length && things_printed < print_max; ++i) | |
103 | { | |
104 | /* Position of the character we are examining | |
105 | to see whether it is repeated. */ | |
106 | unsigned int rep1; | |
107 | /* Number of repetitions we have detected so far. */ | |
108 | unsigned int reps; | |
109 | ||
110 | QUIT; | |
111 | ||
112 | if (need_slashslash) | |
113 | { | |
114 | fputs_filtered ("//", stream); | |
115 | need_slashslash = 0; | |
116 | } | |
117 | ||
118 | rep1 = i + 1; | |
119 | reps = 1; | |
120 | while (rep1 < length && string[rep1] == string[i]) | |
121 | { | |
122 | ++rep1; | |
123 | ++reps; | |
124 | } | |
125 | ||
126 | c = string[i]; | |
127 | if (reps > repeat_count_threshold) | |
128 | { | |
129 | if (in_control_form || in_literal_form) | |
130 | { | |
cba00921 | 131 | fputs_filtered ("\"//", stream); |
22e39759 FF |
132 | in_control_form = in_literal_form = 0; |
133 | } | |
134 | chill_printchar (c, stream); | |
135 | fprintf_filtered (stream, "<repeats %u times>", reps); | |
136 | i = rep1 - 1; | |
137 | things_printed += repeat_count_threshold; | |
138 | need_slashslash = 1; | |
139 | } | |
140 | else | |
141 | { | |
142 | if (PRINT_LITERAL_FORM (c)) | |
143 | { | |
144 | if (!in_literal_form) | |
145 | { | |
146 | if (in_control_form) | |
147 | { | |
cba00921 | 148 | fputs_filtered ("\"//", stream); |
22e39759 FF |
149 | in_control_form = 0; |
150 | } | |
cba00921 | 151 | fputs_filtered ("\"", stream); |
22e39759 FF |
152 | in_literal_form = 1; |
153 | } | |
154 | fprintf_filtered (stream, "%c", c); | |
155 | } | |
156 | else | |
157 | { | |
158 | if (!in_control_form) | |
159 | { | |
160 | if (in_literal_form) | |
161 | { | |
cba00921 | 162 | fputs_filtered ("\"//", stream); |
22e39759 FF |
163 | in_literal_form = 0; |
164 | } | |
cba00921 | 165 | fputs_filtered ("c\"", stream); |
22e39759 FF |
166 | in_control_form = 1; |
167 | } | |
168 | fprintf_filtered (stream, "%.2x", c); | |
169 | } | |
170 | ++things_printed; | |
171 | } | |
172 | } | |
173 | ||
174 | /* Terminate the quotes if necessary. */ | |
175 | if (in_literal_form || in_control_form) | |
176 | { | |
cba00921 | 177 | fputs_filtered ("\"", stream); |
22e39759 FF |
178 | } |
179 | if (force_ellipses || (i < length)) | |
180 | { | |
181 | fputs_filtered ("...", stream); | |
182 | } | |
183 | } | |
184 | ||
cba00921 PB |
185 | /* Return 1 if TYPE is a varying string or array. */ |
186 | ||
187 | int | |
188 | chill_is_varying_struct (type) | |
189 | struct type *type; | |
190 | { | |
191 | if (TYPE_CODE (type) != TYPE_CODE_STRUCT) | |
192 | return 0; | |
193 | if (TYPE_NFIELDS (type) != 2) | |
194 | return 0; | |
73cd3b49 | 195 | if (strcmp (TYPE_FIELD_NAME (type, 0), "__var_length") != 0) |
cba00921 PB |
196 | return 0; |
197 | return 1; | |
198 | } | |
199 | ||
22e39759 FF |
200 | static struct type * |
201 | chill_create_fundamental_type (objfile, typeid) | |
202 | struct objfile *objfile; | |
203 | int typeid; | |
204 | { | |
205 | register struct type *type = NULL; | |
22e39759 FF |
206 | |
207 | switch (typeid) | |
208 | { | |
209 | default: | |
210 | /* FIXME: For now, if we are asked to produce a type not in this | |
211 | language, create the equivalent of a C integer type with the | |
212 | name "<?type?>". When all the dust settles from the type | |
213 | reconstruction work, this should probably become an error. */ | |
a8a69e63 | 214 | type = init_type (TYPE_CODE_INT, 2, 0, "<?type?>", objfile); |
22e39759 FF |
215 | warning ("internal error: no chill fundamental type %d", typeid); |
216 | break; | |
a8a69e63 FF |
217 | case FT_VOID: |
218 | /* FIXME: Currently the GNU Chill compiler emits some DWARF entries for | |
219 | typedefs, unrelated to anything directly in the code being compiled, | |
220 | that have some FT_VOID types. Just fake it for now. */ | |
221 | type = init_type (TYPE_CODE_VOID, 0, 0, "<?VOID?>", objfile); | |
222 | break; | |
22e39759 FF |
223 | case FT_BOOLEAN: |
224 | type = init_type (TYPE_CODE_BOOL, 1, TYPE_FLAG_UNSIGNED, "BOOL", objfile); | |
225 | break; | |
226 | case FT_CHAR: | |
a8a69e63 | 227 | type = init_type (TYPE_CODE_CHAR, 1, TYPE_FLAG_UNSIGNED, "CHAR", objfile); |
22e39759 FF |
228 | break; |
229 | case FT_SIGNED_CHAR: | |
dda398c3 | 230 | type = init_type (TYPE_CODE_INT, 1, 0, "BYTE", objfile); |
22e39759 FF |
231 | break; |
232 | case FT_UNSIGNED_CHAR: | |
233 | type = init_type (TYPE_CODE_INT, 1, TYPE_FLAG_UNSIGNED, "UBYTE", objfile); | |
234 | break; | |
235 | case FT_SHORT: /* Chill ints are 2 bytes */ | |
dda398c3 | 236 | type = init_type (TYPE_CODE_INT, 2, 0, "INT", objfile); |
22e39759 FF |
237 | break; |
238 | case FT_UNSIGNED_SHORT: /* Chill ints are 2 bytes */ | |
239 | type = init_type (TYPE_CODE_INT, 2, TYPE_FLAG_UNSIGNED, "UINT", objfile); | |
240 | break; | |
b6236d6e FF |
241 | case FT_INTEGER: /* FIXME? */ |
242 | case FT_SIGNED_INTEGER: /* FIXME? */ | |
243 | case FT_LONG: /* Chill longs are 4 bytes */ | |
244 | case FT_SIGNED_LONG: /* Chill longs are 4 bytes */ | |
dda398c3 | 245 | type = init_type (TYPE_CODE_INT, 4, 0, "LONG", objfile); |
22e39759 | 246 | break; |
b6236d6e FF |
247 | case FT_UNSIGNED_INTEGER: /* FIXME? */ |
248 | case FT_UNSIGNED_LONG: /* Chill longs are 4 bytes */ | |
22e39759 FF |
249 | type = init_type (TYPE_CODE_INT, 4, TYPE_FLAG_UNSIGNED, "ULONG", objfile); |
250 | break; | |
251 | case FT_FLOAT: | |
252 | type = init_type (TYPE_CODE_FLT, 4, 0, "REAL", objfile); | |
253 | break; | |
254 | case FT_DBL_PREC_FLOAT: | |
255 | type = init_type (TYPE_CODE_FLT, 8, 0, "LONG_REAL", objfile); | |
256 | break; | |
257 | } | |
258 | return (type); | |
259 | } | |
260 | ||
261 | \f | |
262 | /* Table of operators and their precedences for printing expressions. */ | |
263 | ||
a8a69e63 | 264 | static const struct op_print chill_op_print_tab[] = { |
22e39759 FF |
265 | {"AND", BINOP_LOGICAL_AND, PREC_LOGICAL_AND, 0}, |
266 | {"OR", BINOP_LOGICAL_OR, PREC_LOGICAL_OR, 0}, | |
267 | {"NOT", UNOP_LOGICAL_NOT, PREC_PREFIX, 0}, | |
76a0ffb4 FF |
268 | {"MOD", BINOP_MOD, PREC_MUL, 0}, |
269 | {"REM", BINOP_REM, PREC_MUL, 0}, | |
22e39759 FF |
270 | {":=", BINOP_ASSIGN, PREC_ASSIGN, 1}, |
271 | {"=", BINOP_EQUAL, PREC_EQUAL, 0}, | |
272 | {"/=", BINOP_NOTEQUAL, PREC_EQUAL, 0}, | |
273 | {"<=", BINOP_LEQ, PREC_ORDER, 0}, | |
274 | {">=", BINOP_GEQ, PREC_ORDER, 0}, | |
275 | {">", BINOP_GTR, PREC_ORDER, 0}, | |
276 | {"<", BINOP_LESS, PREC_ORDER, 0}, | |
277 | {"+", BINOP_ADD, PREC_ADD, 0}, | |
278 | {"-", BINOP_SUB, PREC_ADD, 0}, | |
279 | {"*", BINOP_MUL, PREC_MUL, 0}, | |
280 | {"/", BINOP_DIV, PREC_MUL, 0}, | |
fcbadaee | 281 | {"//", BINOP_CONCAT, PREC_PREFIX, 0}, /* FIXME: precedence? */ |
22e39759 FF |
282 | {"-", UNOP_NEG, PREC_PREFIX, 0}, |
283 | {NULL, 0, 0, 0} | |
284 | }; | |
285 | ||
286 | \f | |
287 | /* The built-in types of Chill. */ | |
288 | ||
289 | struct type *builtin_type_chill_bool; | |
290 | struct type *builtin_type_chill_char; | |
291 | struct type *builtin_type_chill_long; | |
292 | struct type *builtin_type_chill_ulong; | |
293 | struct type *builtin_type_chill_real; | |
294 | ||
295 | struct type ** const (chill_builtin_types[]) = | |
296 | { | |
297 | &builtin_type_chill_bool, | |
298 | &builtin_type_chill_char, | |
299 | &builtin_type_chill_long, | |
300 | &builtin_type_chill_ulong, | |
301 | &builtin_type_chill_real, | |
302 | 0 | |
303 | }; | |
304 | ||
305 | const struct language_defn chill_language_defn = { | |
306 | "chill", | |
307 | language_chill, | |
308 | chill_builtin_types, | |
309 | range_check_on, | |
310 | type_check_on, | |
311 | chill_parse, /* parser */ | |
312 | chill_error, /* parser error function */ | |
313 | chill_printchar, /* print a character constant */ | |
314 | chill_printstr, /* function to print a string constant */ | |
315 | chill_create_fundamental_type,/* Create fundamental type in this language */ | |
a8a69e63 FF |
316 | chill_print_type, /* Print a type using appropriate syntax */ |
317 | chill_val_print, /* Print a value using appropriate syntax */ | |
e10cfcaa | 318 | chill_value_print, /* Print a top-levl value */ |
22e39759 FF |
319 | &builtin_type_chill_real, /* longest floating point type */ |
320 | {"", "B'", "", ""}, /* Binary format info */ | |
5573d7d4 JK |
321 | {"O'%lo", "O'", "o", ""}, /* Octal format info */ |
322 | {"D'%ld", "D'", "d", ""}, /* Decimal format info */ | |
323 | {"H'%lx", "H'", "x", ""}, /* Hex format info */ | |
22e39759 FF |
324 | chill_op_print_tab, /* expression operators for printing */ |
325 | LANG_MAGIC | |
326 | }; | |
327 | ||
328 | /* Initialization for Chill */ | |
329 | ||
330 | void | |
d62e7a20 | 331 | _initialize_chill_language () |
22e39759 FF |
332 | { |
333 | builtin_type_chill_bool = | |
334 | init_type (TYPE_CODE_BOOL, TARGET_CHAR_BIT / TARGET_CHAR_BIT, | |
335 | TYPE_FLAG_UNSIGNED, | |
336 | "BOOL", (struct objfile *) NULL); | |
337 | builtin_type_chill_char = | |
338 | init_type (TYPE_CODE_CHAR, TARGET_CHAR_BIT / TARGET_CHAR_BIT, | |
339 | TYPE_FLAG_UNSIGNED, | |
340 | "CHAR", (struct objfile *) NULL); | |
341 | builtin_type_chill_long = | |
342 | init_type (TYPE_CODE_INT, TARGET_LONG_BIT / TARGET_CHAR_BIT, | |
343 | 0, | |
344 | "LONG", (struct objfile *) NULL); | |
345 | builtin_type_chill_ulong = | |
346 | init_type (TYPE_CODE_INT, TARGET_LONG_BIT / TARGET_CHAR_BIT, | |
347 | TYPE_FLAG_UNSIGNED, | |
348 | "ULONG", (struct objfile *) NULL); | |
349 | builtin_type_chill_real = | |
350 | init_type (TYPE_CODE_FLT, TARGET_DOUBLE_BIT / TARGET_CHAR_BIT, | |
351 | 0, | |
352 | "LONG_REAL", (struct objfile *) NULL); | |
353 | ||
354 | add_language (&chill_language_defn); | |
355 | } |