projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
*** empty log message ***
[deliverable/binutils-gdb.git] / gdb / expprint.c
CommitLineData
c906108c 1/* Print in infix form a struct expression.
1bac305b 2
197e01b6 3 Copyright (C) 1986, 1988, 1989, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
9b254dd1 4 1998, 1999, 2000, 2003, 2007, 2008 Free Software Foundation, Inc.
c906108c 5
c5aa993b 6 This file is part of GDB.
c906108c 7
c5aa993b
JM		 8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
a9762ec7 10 the Free Software Foundation; either version 3 of the License, or
c5aa993b 11 (at your option) any later version.
c906108c 12
c5aa993b
JM		 13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
c906108c 17
c5aa993b 18 You should have received a copy of the GNU General Public License
a9762ec7 19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
c906108c
SS		 20
21#include "defs.h"
22#include "symtab.h"
23#include "gdbtypes.h"
24#include "expression.h"
25#include "value.h"
26#include "language.h"
27#include "parser-defs.h"
eb8bc282 28#include "user-regs.h" /* For user_reg_map_regnum_to_name. */
82eeeb94
AF		 29#include "target.h"
30#include "gdb_string.h"
fe898f56 31#include "block.h"
9e35dae4 32#include "objfiles.h"
fcd776e5 33#include "gdb_assert.h"
c906108c
SS		 34
35#ifdef HAVE_CTYPE_H
36#include <ctype.h>
37#endif
38
c906108c 39void
fba45db2 40print_expression (struct expression *exp, struct ui_file *stream)
c906108c
SS		 41{
42 int pc = 0;
43 print_subexp (exp, &pc, stream, PREC_NULL);
44}
45
46/* Print the subexpression of EXP that starts in position POS, on STREAM.
47 PREC is the precedence of the surrounding operator;
48 if the precedence of the main operator of this subexpression is less,
49 parentheses are needed here. */
50
5f9769d1 51void
f86f5ca3 52print_subexp (struct expression *exp, int *pos,
fba45db2 53 struct ui_file *stream, enum precedence prec)
5f9769d1
PH		 54{
55 exp->language_defn->la_exp_desc->print_subexp (exp, pos, stream, prec);
56}
57
58/* Standard implementation of print_subexp for use in language_defn
59 vectors. */
60void
61print_subexp_standard (struct expression *exp, int *pos,
62 struct ui_file *stream, enum precedence prec)
c906108c 63{
f86f5ca3
PH		 64 unsigned tem;
65 const struct op_print *op_print_tab;
66 int pc;
c906108c 67 unsigned nargs;
f86f5ca3 68 char *op_str;
c906108c
SS		 69 int assign_modify = 0;
70 enum exp_opcode opcode;
71 enum precedence myprec = PREC_NULL;
72 /* Set to 1 for a right-associative operator. */
73 int assoc = 0;
3d6d86c6 74 struct value *val;
c906108c
SS		 75 char *tempstr = NULL;
76
77 op_print_tab = exp->language_defn->la_op_print_tab;
78 pc = (*pos)++;
79 opcode = exp->elts[pc].opcode;
80 switch (opcode)
81 {
c5aa993b 82 /* Common ops */
c906108c
SS		 83
84 case OP_SCOPE:
85 myprec = PREC_PREFIX;
86 assoc = 0;
87 fputs_filtered (type_name_no_tag (exp->elts[pc + 1].type), stream);
88 fputs_filtered ("::", stream);
89 nargs = longest_to_int (exp->elts[pc + 2].longconst);
90 (*pos) += 4 + BYTES_TO_EXP_ELEM (nargs + 1);
91 fputs_filtered (&exp->elts[pc + 3].string, stream);
92 return;
93
94 case OP_LONG:
95 (*pos) += 3;
96 value_print (value_from_longest (exp->elts[pc + 1].type,
97 exp->elts[pc + 2].longconst),
98 stream, 0, Val_no_prettyprint);
99 return;
100
101 case OP_DOUBLE:
102 (*pos) += 3;
103 value_print (value_from_double (exp->elts[pc + 1].type,
104 exp->elts[pc + 2].doubleconst),
105 stream, 0, Val_no_prettyprint);
106 return;
107
108 case OP_VAR_VALUE:
109 {
110 struct block *b;
111 (*pos) += 3;
112 b = exp->elts[pc + 1].block;
113 if (b != NULL
114 && BLOCK_FUNCTION (b) != NULL
de5ad195 115 && SYMBOL_PRINT_NAME (BLOCK_FUNCTION (b)) != NULL)
c906108c 116 {
de5ad195 117 fputs_filtered (SYMBOL_PRINT_NAME (BLOCK_FUNCTION (b)), stream);
c906108c
SS		 118 fputs_filtered ("::", stream);
119 }
de5ad195 120 fputs_filtered (SYMBOL_PRINT_NAME (exp->elts[pc + 2].symbol), stream);
c906108c
SS		 121 }
122 return;
123
124 case OP_LAST:
125 (*pos) += 2;
126 fprintf_filtered (stream, "$%d",
127 longest_to_int (exp->elts[pc + 1].longconst));
128 return;
129
130 case OP_REGISTER:
e36180d7 131 {
67f3407f
DJ		 132 const char *name = &exp->elts[pc + 2].string;
133 (*pos) += 3 + BYTES_TO_EXP_ELEM (exp->elts[pc + 1].longconst + 1);
eb8bc282 134 fprintf_filtered (stream, "$%s", name);
e36180d7
AC		 135 return;
136 }
c906108c
SS		 137
138 case OP_BOOL:
139 (*pos) += 2;
140 fprintf_filtered (stream, "%s",
141 longest_to_int (exp->elts[pc + 1].longconst)
142 ? "TRUE" : "FALSE");
143 return;
144
145 case OP_INTERNALVAR:
146 (*pos) += 2;
147 fprintf_filtered (stream, "$%s",
c5aa993b 148 internalvar_name (exp->elts[pc + 1].internalvar));
c906108c
SS		 149 return;
150
151 case OP_FUNCALL:
152 (*pos) += 2;
153 nargs = longest_to_int (exp->elts[pc + 1].longconst);
154 print_subexp (exp, pos, stream, PREC_SUFFIX);
155 fputs_filtered (" (", stream);
156 for (tem = 0; tem < nargs; tem++)
157 {
158 if (tem != 0)
159 fputs_filtered (", ", stream);
160 print_subexp (exp, pos, stream, PREC_ABOVE_COMMA);
161 }
162 fputs_filtered (")", stream);
163 return;
164
165 case OP_NAME:
c5aa993b 166 nargs = longest_to_int (exp->elts[pc + 1].longconst);
c906108c
SS		 167 (*pos) += 3 + BYTES_TO_EXP_ELEM (nargs + 1);
168 fputs_filtered (&exp->elts[pc + 2].string, stream);
169 return;
170
171 case OP_STRING:
c5aa993b 172 nargs = longest_to_int (exp->elts[pc + 1].longconst);
c906108c
SS		 173 (*pos) += 3 + BYTES_TO_EXP_ELEM (nargs + 1);
174 /* LA_PRINT_STRING will print using the current repeat count threshold.
c5aa993b
JM		 175 If necessary, we can temporarily set it to zero, or pass it as an
176 additional parameter to LA_PRINT_STRING. -fnf */
c906108c
SS		 177 LA_PRINT_STRING (stream, &exp->elts[pc + 2].string, nargs, 1, 0);
178 return;
179
180 case OP_BITSTRING:
c5aa993b 181 nargs = longest_to_int (exp->elts[pc + 1].longconst);
c906108c
SS		 182 (*pos)
183 += 3 + BYTES_TO_EXP_ELEM ((nargs + HOST_CHAR_BIT - 1) / HOST_CHAR_BIT);
184 fprintf_unfiltered (stream, "B'<unimplemented>'");
185 return;
186
82eeeb94
AF		 187 case OP_OBJC_NSSTRING: /* Objective-C Foundation Class NSString constant. */
188 nargs = longest_to_int (exp->elts[pc + 1].longconst);
189 (*pos) += 3 + BYTES_TO_EXP_ELEM (nargs + 1);
190 fputs_filtered ("@\"", stream);
191 LA_PRINT_STRING (stream, &exp->elts[pc + 2].string, nargs, 1, 0);
192 fputs_filtered ("\"", stream);
193 return;
194
195 case OP_OBJC_MSGCALL:
196 { /* Objective C message (method) call. */
197 char *selector;
198 (*pos) += 3;
199 nargs = longest_to_int (exp->elts[pc + 2].longconst);
200 fprintf_unfiltered (stream, "[");
201 print_subexp (exp, pos, stream, PREC_SUFFIX);
202 if (0 == target_read_string (exp->elts[pc + 1].longconst,
203 &selector, 1024, NULL))
204 {
8a3fe4f8 205 error (_("bad selector"));
82eeeb94
AF		 206 return;
207 }
208 if (nargs)
209 {
210 char *s, *nextS;
211 s = alloca (strlen (selector) + 1);
212 strcpy (s, selector);
213 for (tem = 0; tem < nargs; tem++)
214 {
215 nextS = strchr (s, ':');
fcd776e5 216 gdb_assert (nextS); /* Make sure we found ':'. */
82eeeb94
AF		 217 *nextS = '\0';
218 fprintf_unfiltered (stream, " %s: ", s);
219 s = nextS + 1;
220 print_subexp (exp, pos, stream, PREC_ABOVE_COMMA);
221 }
222 }
223 else
224 {
225 fprintf_unfiltered (stream, " %s", selector);
226 }
227 fprintf_unfiltered (stream, "]");
228 /* "selector" was malloc'd by target_read_string. Free it. */
4ef3f3be 229 xfree (selector);
82eeeb94
AF		 230 return;
231 }
232
c906108c
SS		 233 case OP_ARRAY:
234 (*pos) += 3;
235 nargs = longest_to_int (exp->elts[pc + 2].longconst);
236 nargs -= longest_to_int (exp->elts[pc + 1].longconst);
237 nargs++;
238 tem = 0;
239 if (exp->elts[pc + 4].opcode == OP_LONG
b806fb9a
UW		 240 && exp->elts[pc + 5].type
241 == builtin_type (exp->gdbarch)->builtin_char
c906108c
SS		 242 && exp->language_defn->la_language == language_c)
243 {
244 /* Attempt to print C character arrays using string syntax.
245 Walk through the args, picking up one character from each
246 of the OP_LONG expression elements. If any array element
247 does not match our expection of what we should find for
248 a simple string, revert back to array printing. Note that
249 the last expression element is an explicit null terminator
250 byte, which doesn't get printed. */
251 tempstr = alloca (nargs);
252 pc += 4;
253 while (tem < nargs)
254 {
255 if (exp->elts[pc].opcode != OP_LONG
b806fb9a
UW		 256 || exp->elts[pc + 1].type
257 != builtin_type (exp->gdbarch)->builtin_char)
c906108c
SS		 258 {
259 /* Not a simple array of char, use regular array printing. */
260 tem = 0;
261 break;
262 }
263 else
264 {
265 tempstr[tem++] =
266 longest_to_int (exp->elts[pc + 2].longconst);
267 pc += 4;
268 }
269 }
270 }
271 if (tem > 0)
272 {
273 LA_PRINT_STRING (stream, tempstr, nargs - 1, 1, 0);
274 (*pos) = pc;
275 }
276 else
277 {
db034ac5 278 fputs_filtered (" {", stream);
c906108c
SS		 279 for (tem = 0; tem < nargs; tem++)
280 {
281 if (tem != 0)
282 {
283 fputs_filtered (", ", stream);
284 }
285 print_subexp (exp, pos, stream, PREC_ABOVE_COMMA);
286 }
db034ac5 287 fputs_filtered ("}", stream);
c906108c
SS		 288 }
289 return;
290
291 case OP_LABELED:
292 tem = longest_to_int (exp->elts[pc + 1].longconst);
293 (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
1b831c93 294 /* Gcc support both these syntaxes. Unsure which is preferred. */
c906108c 295#if 1
1b831c93
AC		 296 fputs_filtered (&exp->elts[pc + 2].string, stream);
297 fputs_filtered (": ", stream);
c906108c 298#else
1b831c93
AC		 299 fputs_filtered (".", stream);
300 fputs_filtered (&exp->elts[pc + 2].string, stream);
301 fputs_filtered ("=", stream);
c906108c 302#endif
c906108c
SS		 303 print_subexp (exp, pos, stream, PREC_SUFFIX);
304 return;
305
306 case TERNOP_COND:
307 if ((int) prec > (int) PREC_COMMA)
308 fputs_filtered ("(", stream);
309 /* Print the subexpressions, forcing parentheses
c5aa993b
JM		 310 around any binary operations within them.
311 This is more parentheses than are strictly necessary,
312 but it looks clearer. */
c906108c
SS		 313 print_subexp (exp, pos, stream, PREC_HYPER);
314 fputs_filtered (" ? ", stream);
315 print_subexp (exp, pos, stream, PREC_HYPER);
316 fputs_filtered (" : ", stream);
317 print_subexp (exp, pos, stream, PREC_HYPER);
318 if ((int) prec > (int) PREC_COMMA)
319 fputs_filtered (")", stream);
320 return;
321
322 case TERNOP_SLICE:
323 case TERNOP_SLICE_COUNT:
324 print_subexp (exp, pos, stream, PREC_SUFFIX);
325 fputs_filtered ("(", stream);
326 print_subexp (exp, pos, stream, PREC_ABOVE_COMMA);
327 fputs_filtered (opcode == TERNOP_SLICE ? " : " : " UP ", stream);
328 print_subexp (exp, pos, stream, PREC_ABOVE_COMMA);
329 fputs_filtered (")", stream);
330 return;
331
332 case STRUCTOP_STRUCT:
333 tem = longest_to_int (exp->elts[pc + 1].longconst);
334 (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
335 print_subexp (exp, pos, stream, PREC_SUFFIX);
336 fputs_filtered (".", stream);
337 fputs_filtered (&exp->elts[pc + 2].string, stream);
338 return;
339
c5aa993b 340 /* Will not occur for Modula-2 */
c906108c
SS		 341 case STRUCTOP_PTR:
342 tem = longest_to_int (exp->elts[pc + 1].longconst);
343 (*pos) += 3 + BYTES_TO_EXP_ELEM (tem + 1);
344 print_subexp (exp, pos, stream, PREC_SUFFIX);
345 fputs_filtered ("->", stream);
346 fputs_filtered (&exp->elts[pc + 2].string, stream);
347 return;
348
0534816d
DJ		 349 case STRUCTOP_MEMBER:
350 print_subexp (exp, pos, stream, PREC_SUFFIX);
351 fputs_filtered (".*", stream);
352 print_subexp (exp, pos, stream, PREC_SUFFIX);
353 return;
354
355 case STRUCTOP_MPTR:
356 print_subexp (exp, pos, stream, PREC_SUFFIX);
357 fputs_filtered ("->*", stream);
358 print_subexp (exp, pos, stream, PREC_SUFFIX);
359 return;
360
c906108c
SS		 361 case BINOP_SUBSCRIPT:
362 print_subexp (exp, pos, stream, PREC_SUFFIX);
363 fputs_filtered ("[", stream);
364 print_subexp (exp, pos, stream, PREC_ABOVE_COMMA);
365 fputs_filtered ("]", stream);
366 return;
367
368 case UNOP_POSTINCREMENT:
369 print_subexp (exp, pos, stream, PREC_SUFFIX);
370 fputs_filtered ("++", stream);
371 return;
372
373 case UNOP_POSTDECREMENT:
374 print_subexp (exp, pos, stream, PREC_SUFFIX);
375 fputs_filtered ("--", stream);
376 return;
377
378 case UNOP_CAST:
379 (*pos) += 2;
380 if ((int) prec > (int) PREC_PREFIX)
c5aa993b 381 fputs_filtered ("(", stream);
c906108c
SS		 382 fputs_filtered ("(", stream);
383 type_print (exp->elts[pc + 1].type, "", stream, 0);
384 fputs_filtered (") ", stream);
385 print_subexp (exp, pos, stream, PREC_PREFIX);
386 if ((int) prec > (int) PREC_PREFIX)
c5aa993b 387 fputs_filtered (")", stream);
c906108c
SS		 388 return;
389
390 case UNOP_MEMVAL:
391 (*pos) += 2;
392 if ((int) prec > (int) PREC_PREFIX)
c5aa993b 393 fputs_filtered ("(", stream);
0004e5a2 394 if (TYPE_CODE (exp->elts[pc + 1].type) == TYPE_CODE_FUNC &&
c5aa993b
JM		 395 exp->elts[pc + 3].opcode == OP_LONG)
396 {
397 /* We have a minimal symbol fn, probably. It's encoded
398 as a UNOP_MEMVAL (function-type) of an OP_LONG (int, address).
399 Swallow the OP_LONG (including both its opcodes); ignore
400 its type; print the value in the type of the MEMVAL. */
401 (*pos) += 4;
402 val = value_at_lazy (exp->elts[pc + 1].type,
00a4c844 403 (CORE_ADDR) exp->elts[pc + 5].longconst);
c5aa993b
JM		 404 value_print (val, stream, 0, Val_no_prettyprint);
405 }
406 else
407 {
408 fputs_filtered ("{", stream);
409 type_print (exp->elts[pc + 1].type, "", stream, 0);
410 fputs_filtered ("} ", stream);
411 print_subexp (exp, pos, stream, PREC_PREFIX);
412 }
c906108c 413 if ((int) prec > (int) PREC_PREFIX)
c5aa993b 414 fputs_filtered (")", stream);
c906108c
SS		 415 return;
416
9e35dae4
DJ		 417 case UNOP_MEMVAL_TLS:
418 (*pos) += 3;
419 if ((int) prec > (int) PREC_PREFIX)
420 fputs_filtered ("(", stream);
421 fputs_filtered ("{", stream);
422 type_print (exp->elts[pc + 2].type, "", stream, 0);
423 fputs_filtered ("} ", stream);
424 print_subexp (exp, pos, stream, PREC_PREFIX);
425 if ((int) prec > (int) PREC_PREFIX)
426 fputs_filtered (")", stream);
427 return;
428
c906108c
SS		 429 case BINOP_ASSIGN_MODIFY:
430 opcode = exp->elts[pc + 1].opcode;
431 (*pos) += 2;
432 myprec = PREC_ASSIGN;
433 assoc = 1;
434 assign_modify = 1;
435 op_str = "???";
436 for (tem = 0; op_print_tab[tem].opcode != OP_NULL; tem++)
437 if (op_print_tab[tem].opcode == opcode)
438 {
439 op_str = op_print_tab[tem].string;
440 break;
441 }
442 if (op_print_tab[tem].opcode != opcode)
443 /* Not found; don't try to keep going because we don't know how
444 to interpret further elements. */
8a3fe4f8 445 error (_("Invalid expression"));
c906108c
SS		 446 break;
447
c5aa993b 448 /* C++ ops */
c906108c
SS		 449
450 case OP_THIS:
451 ++(*pos);
452 fputs_filtered ("this", stream);
453 return;
454
82eeeb94
AF		 455 /* Objective-C ops */
456
457 case OP_OBJC_SELF:
458 ++(*pos);
459 fputs_filtered ("self", stream); /* The ObjC equivalent of "this". */
460 return;
461
c5aa993b 462 /* Modula-2 ops */
c906108c
SS		 463
464 case MULTI_SUBSCRIPT:
465 (*pos) += 2;
466 nargs = longest_to_int (exp->elts[pc + 1].longconst);
467 print_subexp (exp, pos, stream, PREC_SUFFIX);
468 fprintf_unfiltered (stream, " [");
469 for (tem = 0; tem < nargs; tem++)
470 {
471 if (tem != 0)
472 fprintf_unfiltered (stream, ", ");
473 print_subexp (exp, pos, stream, PREC_ABOVE_COMMA);
474 }
475 fprintf_unfiltered (stream, "]");
476 return;
477
478 case BINOP_VAL:
c5aa993b
JM		 479 (*pos) += 2;
480 fprintf_unfiltered (stream, "VAL(");
481 type_print (exp->elts[pc + 1].type, "", stream, 0);
482 fprintf_unfiltered (stream, ",");
483 print_subexp (exp, pos, stream, PREC_PREFIX);
484 fprintf_unfiltered (stream, ")");
c906108c 485 return;
c5aa993b 486
c906108c
SS		 487 case BINOP_INCL:
488 case BINOP_EXCL:
8a3fe4f8 489 error (_("print_subexp: Not implemented."));
c906108c 490
c5aa993b 491 /* Default ops */
c906108c
SS		 492
493 default:
494 op_str = "???";
495 for (tem = 0; op_print_tab[tem].opcode != OP_NULL; tem++)
496 if (op_print_tab[tem].opcode == opcode)
497 {
498 op_str = op_print_tab[tem].string;
499 myprec = op_print_tab[tem].precedence;
500 assoc = op_print_tab[tem].right_assoc;
501 break;
502 }
503 if (op_print_tab[tem].opcode != opcode)
504 /* Not found; don't try to keep going because we don't know how
505 to interpret further elements. For example, this happens
506 if opcode is OP_TYPE. */
8a3fe4f8 507 error (_("Invalid expression"));
c5aa993b 508 }
c906108c
SS		 509
510 /* Note that PREC_BUILTIN will always emit parentheses. */
511 if ((int) myprec < (int) prec)
512 fputs_filtered ("(", stream);
513 if ((int) opcode > (int) BINOP_END)
514 {
515 if (assoc)
516 {
517 /* Unary postfix operator. */
518 print_subexp (exp, pos, stream, PREC_SUFFIX);
519 fputs_filtered (op_str, stream);
520 }
521 else
522 {
523 /* Unary prefix operator. */
524 fputs_filtered (op_str, stream);
525 if (myprec == PREC_BUILTIN_FUNCTION)
526 fputs_filtered ("(", stream);
527 print_subexp (exp, pos, stream, PREC_PREFIX);
528 if (myprec == PREC_BUILTIN_FUNCTION)
529 fputs_filtered (")", stream);
530 }
531 }
532 else
533 {
534 /* Binary operator. */
535 /* Print left operand.
c5aa993b
JM		 536 If operator is right-associative,
537 increment precedence for this operand. */
c906108c
SS		 538 print_subexp (exp, pos, stream,
539 (enum precedence) ((int) myprec + assoc));
540 /* Print the operator itself. */
541 if (assign_modify)
542 fprintf_filtered (stream, " %s= ", op_str);
543 else if (op_str[0] == ',')
544 fprintf_filtered (stream, "%s ", op_str);
545 else
546 fprintf_filtered (stream, " %s ", op_str);
547 /* Print right operand.
c5aa993b
JM		 548 If operator is left-associative,
549 increment precedence for this operand. */
c906108c
SS		 550 print_subexp (exp, pos, stream,
551 (enum precedence) ((int) myprec + !assoc));
552 }
553
554 if ((int) myprec < (int) prec)
555 fputs_filtered (")", stream);
556}
557
558/* Return the operator corresponding to opcode OP as
559 a string. NULL indicates that the opcode was not found in the
560 current language table. */
561char *
fba45db2 562op_string (enum exp_opcode op)
c906108c
SS		 563{
564 int tem;
f86f5ca3 565 const struct op_print *op_print_tab;
c906108c
SS		 566
567 op_print_tab = current_language->la_op_print_tab;
568 for (tem = 0; op_print_tab[tem].opcode != OP_NULL; tem++)
569 if (op_print_tab[tem].opcode == op)
570 return op_print_tab[tem].string;
571 return NULL;
572}
573
c906108c
SS		 574/* Support for dumping the raw data from expressions in a human readable
575 form. */
576
5f9769d1 577static char *op_name (struct expression *, enum exp_opcode);
24daaebc 578static int dump_subexp_body (struct expression *exp, struct ui_file *, int);
c906108c 579
5f9769d1
PH		 580/* Name for OPCODE, when it appears in expression EXP. */
581
c906108c 582static char *
5f9769d1
PH		 583op_name (struct expression *exp, enum exp_opcode opcode)
584{
585 return exp->language_defn->la_exp_desc->op_name (opcode);
586}
587
588/* Default name for the standard operator OPCODE (i.e., one defined in
589 the definition of enum exp_opcode). */
590
591char *
592op_name_standard (enum exp_opcode opcode)
c906108c
SS		 593{
594 switch (opcode)
595 {
596 default:
597 {
598 static char buf[30];
599
600 sprintf (buf, "<unknown %d>", opcode);
601 return buf;
602 }
c5aa993b
JM		 603 case OP_NULL:
604 return "OP_NULL";
605 case BINOP_ADD:
606 return "BINOP_ADD";
607 case BINOP_SUB:
608 return "BINOP_SUB";
609 case BINOP_MUL:
610 return "BINOP_MUL";
611 case BINOP_DIV:
612 return "BINOP_DIV";
613 case BINOP_REM:
614 return "BINOP_REM";
615 case BINOP_MOD:
616 return "BINOP_MOD";
617 case BINOP_LSH:
618 return "BINOP_LSH";
619 case BINOP_RSH:
620 return "BINOP_RSH";
621 case BINOP_LOGICAL_AND:
622 return "BINOP_LOGICAL_AND";
623 case BINOP_LOGICAL_OR:
624 return "BINOP_LOGICAL_OR";
625 case BINOP_BITWISE_AND:
626 return "BINOP_BITWISE_AND";
627 case BINOP_BITWISE_IOR:
628 return "BINOP_BITWISE_IOR";
629 case BINOP_BITWISE_XOR:
630 return "BINOP_BITWISE_XOR";
631 case BINOP_EQUAL:
632 return "BINOP_EQUAL";
633 case BINOP_NOTEQUAL:
634 return "BINOP_NOTEQUAL";
635 case BINOP_LESS:
636 return "BINOP_LESS";
637 case BINOP_GTR:
638 return "BINOP_GTR";
639 case BINOP_LEQ:
640 return "BINOP_LEQ";
641 case BINOP_GEQ:
642 return "BINOP_GEQ";
643 case BINOP_REPEAT:
644 return "BINOP_REPEAT";
645 case BINOP_ASSIGN:
646 return "BINOP_ASSIGN";
647 case BINOP_COMMA:
648 return "BINOP_COMMA";
649 case BINOP_SUBSCRIPT:
650 return "BINOP_SUBSCRIPT";
651 case MULTI_SUBSCRIPT:
652 return "MULTI_SUBSCRIPT";
653 case BINOP_EXP:
654 return "BINOP_EXP";
655 case BINOP_MIN:
656 return "BINOP_MIN";
657 case BINOP_MAX:
658 return "BINOP_MAX";
c5aa993b
JM		 659 case STRUCTOP_MEMBER:
660 return "STRUCTOP_MEMBER";
661 case STRUCTOP_MPTR:
662 return "STRUCTOP_MPTR";
663 case BINOP_INTDIV:
664 return "BINOP_INTDIV";
665 case BINOP_ASSIGN_MODIFY:
666 return "BINOP_ASSIGN_MODIFY";
667 case BINOP_VAL:
668 return "BINOP_VAL";
669 case BINOP_INCL:
670 return "BINOP_INCL";
671 case BINOP_EXCL:
672 return "BINOP_EXCL";
673 case BINOP_CONCAT:
674 return "BINOP_CONCAT";
675 case BINOP_RANGE:
676 return "BINOP_RANGE";
677 case BINOP_END:
678 return "BINOP_END";
679 case TERNOP_COND:
680 return "TERNOP_COND";
681 case TERNOP_SLICE:
682 return "TERNOP_SLICE";
683 case TERNOP_SLICE_COUNT:
684 return "TERNOP_SLICE_COUNT";
685 case OP_LONG:
686 return "OP_LONG";
687 case OP_DOUBLE:
688 return "OP_DOUBLE";
689 case OP_VAR_VALUE:
690 return "OP_VAR_VALUE";
691 case OP_LAST:
692 return "OP_LAST";
693 case OP_REGISTER:
694 return "OP_REGISTER";
695 case OP_INTERNALVAR:
696 return "OP_INTERNALVAR";
697 case OP_FUNCALL:
698 return "OP_FUNCALL";
699 case OP_STRING:
700 return "OP_STRING";
701 case OP_BITSTRING:
702 return "OP_BITSTRING";
703 case OP_ARRAY:
704 return "OP_ARRAY";
705 case UNOP_CAST:
706 return "UNOP_CAST";
707 case UNOP_MEMVAL:
708 return "UNOP_MEMVAL";
9e35dae4
DJ		 709 case UNOP_MEMVAL_TLS:
710 return "UNOP_MEMVAL_TLS";
c5aa993b
JM		 711 case UNOP_NEG:
712 return "UNOP_NEG";
713 case UNOP_LOGICAL_NOT:
714 return "UNOP_LOGICAL_NOT";
715 case UNOP_COMPLEMENT:
716 return "UNOP_COMPLEMENT";
717 case UNOP_IND:
718 return "UNOP_IND";
719 case UNOP_ADDR:
720 return "UNOP_ADDR";
721 case UNOP_PREINCREMENT:
722 return "UNOP_PREINCREMENT";
723 case UNOP_POSTINCREMENT:
724 return "UNOP_POSTINCREMENT";
725 case UNOP_PREDECREMENT:
726 return "UNOP_PREDECREMENT";
727 case UNOP_POSTDECREMENT:
728 return "UNOP_POSTDECREMENT";
729 case UNOP_SIZEOF:
730 return "UNOP_SIZEOF";
731 case UNOP_LOWER:
732 return "UNOP_LOWER";
733 case UNOP_UPPER:
734 return "UNOP_UPPER";
735 case UNOP_LENGTH:
736 return "UNOP_LENGTH";
737 case UNOP_PLUS:
738 return "UNOP_PLUS";
739 case UNOP_CAP:
740 return "UNOP_CAP";
741 case UNOP_CHR:
742 return "UNOP_CHR";
743 case UNOP_ORD:
744 return "UNOP_ORD";
745 case UNOP_ABS:
746 return "UNOP_ABS";
747 case UNOP_FLOAT:
748 return "UNOP_FLOAT";
749 case UNOP_HIGH:
750 return "UNOP_HIGH";
751 case UNOP_MAX:
752 return "UNOP_MAX";
753 case UNOP_MIN:
754 return "UNOP_MIN";
755 case UNOP_ODD:
756 return "UNOP_ODD";
757 case UNOP_TRUNC:
758 return "UNOP_TRUNC";
759 case OP_BOOL:
760 return "OP_BOOL";
761 case OP_M2_STRING:
762 return "OP_M2_STRING";
763 case STRUCTOP_STRUCT:
764 return "STRUCTOP_STRUCT";
765 case STRUCTOP_PTR:
766 return "STRUCTOP_PTR";
767 case OP_THIS:
768 return "OP_THIS";
82eeeb94
AF		 769 case OP_OBJC_SELF:
770 return "OP_OBJC_SELF";
c5aa993b
JM		 771 case OP_SCOPE:
772 return "OP_SCOPE";
773 case OP_TYPE:
774 return "OP_TYPE";
775 case OP_LABELED:
776 return "OP_LABELED";
c906108c
SS		 777 }
778}
779
780void
24daaebc
PH		 781dump_raw_expression (struct expression *exp, struct ui_file *stream,
782 char *note)
c906108c
SS		 783{
784 int elt;
785 char *opcode_name;
786 char *eltscan;
787 int eltsize;
788
789 fprintf_filtered (stream, "Dump of expression @ ");
d4f3574e 790 gdb_print_host_address (exp, stream);
9d271fd8 791 fprintf_filtered (stream, "'\n\tLanguage %s, %d elements, %ld bytes each.\n",
c5aa993b 792 exp->language_defn->la_name, exp->nelts,
9d271fd8 793 (long) sizeof (union exp_element));
c906108c
SS		 794 fprintf_filtered (stream, "\t%5s %20s %16s %s\n", "Index", "Opcode",
795 "Hex Value", "String Value");
c5aa993b 796 for (elt = 0; elt < exp->nelts; elt++)
c906108c
SS		 797 {
798 fprintf_filtered (stream, "\t%5d ", elt);
5f9769d1 799 opcode_name = op_name (exp, exp->elts[elt].opcode);
c906108c
SS		 800
801 fprintf_filtered (stream, "%20s ", opcode_name);
c5aa993b 802 print_longest (stream, 'd', 0, exp->elts[elt].longconst);
c906108c
SS		 803 fprintf_filtered (stream, " ");
804
805 for (eltscan = (char *) &exp->elts[elt],
c5aa993b 806 eltsize = sizeof (union exp_element);
c906108c
SS		 807 eltsize-- > 0;
808 eltscan++)
809 {
810 fprintf_filtered (stream, "%c",
811 isprint (*eltscan) ? (*eltscan & 0xFF) : '.');
812 }
813 fprintf_filtered (stream, "\n");
814 }
815}
816
24daaebc
PH		 817/* Dump the subexpression of prefix expression EXP whose operator is at
818 position ELT onto STREAM. Returns the position of the next
819 subexpression in EXP. */
c906108c 820
24daaebc 821int
fba45db2 822dump_subexp (struct expression *exp, struct ui_file *stream, int elt)
c906108c
SS		 823{
824 static int indent = 0;
825 int i;
826
827 fprintf_filtered (stream, "\n");
828 fprintf_filtered (stream, "\t%5d ", elt);
829
830 for (i = 1; i <= indent; i++)
831 fprintf_filtered (stream, " ");
832 indent += 2;
833
5f9769d1 834 fprintf_filtered (stream, "%-20s ", op_name (exp, exp->elts[elt].opcode));
c906108c 835
24daaebc
PH		 836 elt = dump_subexp_body (exp, stream, elt);
837
838 indent -= 2;
839
840 return elt;
841}
842
843/* Dump the operands of prefix expression EXP whose opcode is at
844 position ELT onto STREAM. Returns the position of the next
845 subexpression in EXP. */
846
847static int
848dump_subexp_body (struct expression *exp, struct ui_file *stream, int elt)
5f9769d1
PH		 849{
850 return exp->language_defn->la_exp_desc->dump_subexp_body (exp, stream, elt);
851}
852
853/* Default value for subexp_body in exp_descriptor vector. */
854
855int
856dump_subexp_body_standard (struct expression *exp,
857 struct ui_file *stream, int elt)
24daaebc
PH		 858{
859 int opcode = exp->elts[elt++].opcode;
860
861 switch (opcode)
c906108c
SS		 862 {
863 case TERNOP_COND:
864 case TERNOP_SLICE:
865 case TERNOP_SLICE_COUNT:
866 elt = dump_subexp (exp, stream, elt);
867 case BINOP_ADD:
868 case BINOP_SUB:
869 case BINOP_MUL:
870 case BINOP_DIV:
871 case BINOP_REM:
872 case BINOP_MOD:
873 case BINOP_LSH:
874 case BINOP_RSH:
875 case BINOP_LOGICAL_AND:
876 case BINOP_LOGICAL_OR:
877 case BINOP_BITWISE_AND:
878 case BINOP_BITWISE_IOR:
879 case BINOP_BITWISE_XOR:
880 case BINOP_EQUAL:
881 case BINOP_NOTEQUAL:
882 case BINOP_LESS:
883 case BINOP_GTR:
884 case BINOP_LEQ:
885 case BINOP_GEQ:
886 case BINOP_REPEAT:
887 case BINOP_ASSIGN:
888 case BINOP_COMMA:
889 case BINOP_SUBSCRIPT:
890 case BINOP_EXP:
891 case BINOP_MIN:
892 case BINOP_MAX:
c906108c
SS		 893 case BINOP_INTDIV:
894 case BINOP_ASSIGN_MODIFY:
895 case BINOP_VAL:
896 case BINOP_INCL:
897 case BINOP_EXCL:
898 case BINOP_CONCAT:
899 case BINOP_IN:
900 case BINOP_RANGE:
901 case BINOP_END:
0534816d
DJ		 902 case STRUCTOP_MEMBER:
903 case STRUCTOP_MPTR:
c906108c
SS		 904 elt = dump_subexp (exp, stream, elt);
905 case UNOP_NEG:
906 case UNOP_LOGICAL_NOT:
907 case UNOP_COMPLEMENT:
908 case UNOP_IND:
909 case UNOP_ADDR:
910 case UNOP_PREINCREMENT:
911 case UNOP_POSTINCREMENT:
912 case UNOP_PREDECREMENT:
913 case UNOP_POSTDECREMENT:
914 case UNOP_SIZEOF:
915 case UNOP_PLUS:
916 case UNOP_CAP:
917 case UNOP_CHR:
918 case UNOP_ORD:
919 case UNOP_ABS:
920 case UNOP_FLOAT:
921 case UNOP_HIGH:
922 case UNOP_MAX:
923 case UNOP_MIN:
924 case UNOP_ODD:
925 case UNOP_TRUNC:
926 case UNOP_LOWER:
927 case UNOP_UPPER:
928 case UNOP_LENGTH:
929 case UNOP_CARD:
930 case UNOP_CHMAX:
931 case UNOP_CHMIN:
932 elt = dump_subexp (exp, stream, elt);
933 break;
934 case OP_LONG:
d4f3574e
SS		 935 fprintf_filtered (stream, "Type @");
936 gdb_print_host_address (exp->elts[elt].type, stream);
937 fprintf_filtered (stream, " (");
c906108c
SS		 938 type_print (exp->elts[elt].type, NULL, stream, 0);
939 fprintf_filtered (stream, "), value %ld (0x%lx)",
c5aa993b
JM		 940 (long) exp->elts[elt + 1].longconst,
941 (long) exp->elts[elt + 1].longconst);
c906108c
SS		 942 elt += 3;
943 break;
944 case OP_DOUBLE:
d4f3574e
SS		 945 fprintf_filtered (stream, "Type @");
946 gdb_print_host_address (exp->elts[elt].type, stream);
947 fprintf_filtered (stream, " (");
c906108c
SS		 948 type_print (exp->elts[elt].type, NULL, stream, 0);
949 fprintf_filtered (stream, "), value %g",
c5aa993b 950 (double) exp->elts[elt + 1].doubleconst);
c906108c
SS		 951 elt += 3;
952 break;
953 case OP_VAR_VALUE:
d4f3574e
SS		 954 fprintf_filtered (stream, "Block @");
955 gdb_print_host_address (exp->elts[elt].block, stream);
956 fprintf_filtered (stream, ", symbol @");
957 gdb_print_host_address (exp->elts[elt + 1].symbol, stream);
958 fprintf_filtered (stream, " (%s)",
3567439c 959 SYMBOL_PRINT_NAME (exp->elts[elt + 1].symbol));
c906108c
SS		 960 elt += 3;
961 break;
962 case OP_LAST:
963 fprintf_filtered (stream, "History element %ld",
c5aa993b 964 (long) exp->elts[elt].longconst);
c906108c
SS		 965 elt += 2;
966 break;
967 case OP_REGISTER:
67f3407f
DJ		 968 fprintf_filtered (stream, "Register $%s", &exp->elts[elt + 1].string);
969 elt += 3 + BYTES_TO_EXP_ELEM (exp->elts[elt].longconst + 1);
c906108c
SS		 970 break;
971 case OP_INTERNALVAR:
d4f3574e
SS		 972 fprintf_filtered (stream, "Internal var @");
973 gdb_print_host_address (exp->elts[elt].internalvar, stream);
974 fprintf_filtered (stream, " (%s)",
c906108c
SS		 975 exp->elts[elt].internalvar->name);
976 elt += 2;
977 break;
978 case OP_FUNCALL:
979 {
24daaebc 980 int i, nargs;
c906108c
SS		 981
982 nargs = longest_to_int (exp->elts[elt].longconst);
983
984 fprintf_filtered (stream, "Number of args: %d", nargs);
985 elt += 2;
986
987 for (i = 1; i <= nargs + 1; i++)
988 elt = dump_subexp (exp, stream, elt);
989 }
990 break;
991 case OP_ARRAY:
992 {
993 int lower, upper;
994 int i;
995
996 lower = longest_to_int (exp->elts[elt].longconst);
997 upper = longest_to_int (exp->elts[elt + 1].longconst);
998
999 fprintf_filtered (stream, "Bounds [%d:%d]", lower, upper);
1000 elt += 3;
1001
1002 for (i = 1; i <= upper - lower + 1; i++)
1003 elt = dump_subexp (exp, stream, elt);
1004 }
1005 break;
1006 case UNOP_MEMVAL:
1007 case UNOP_CAST:
d4f3574e
SS		 1008 fprintf_filtered (stream, "Type @");
1009 gdb_print_host_address (exp->elts[elt].type, stream);
1010 fprintf_filtered (stream, " (");
c906108c
SS		 1011 type_print (exp->elts[elt].type, NULL, stream, 0);
1012 fprintf_filtered (stream, ")");
1013 elt = dump_subexp (exp, stream, elt + 2);
1014 break;
9e35dae4
DJ		 1015 case UNOP_MEMVAL_TLS:
1016 fprintf_filtered (stream, "TLS type @");
1017 gdb_print_host_address (exp->elts[elt + 1].type, stream);
1018 fprintf_filtered (stream, " (__thread /* \"%s\" */ ",
1019 (exp->elts[elt].objfile == NULL ? "(null)"
1020 : exp->elts[elt].objfile->name));
1021 type_print (exp->elts[elt + 1].type, NULL, stream, 0);
1022 fprintf_filtered (stream, ")");
1023 elt = dump_subexp (exp, stream, elt + 3);
1024 break;
c906108c 1025 case OP_TYPE:
d4f3574e
SS		 1026 fprintf_filtered (stream, "Type @");
1027 gdb_print_host_address (exp->elts[elt].type, stream);
1028 fprintf_filtered (stream, " (");
c906108c
SS		 1029 type_print (exp->elts[elt].type, NULL, stream, 0);
1030 fprintf_filtered (stream, ")");
1031 elt += 2;
1032 break;
1033 case STRUCTOP_STRUCT:
1034 case STRUCTOP_PTR:
1035 {
1036 char *elem_name;
1037 int len;
1038
1039 len = longest_to_int (exp->elts[elt].longconst);
1040 elem_name = &exp->elts[elt + 1].string;
1041
1042 fprintf_filtered (stream, "Element name: `%.*s'", len, elem_name);
1043 elt = dump_subexp (exp, stream, elt + 3 + BYTES_TO_EXP_ELEM (len + 1));
1044 }
1045 break;
1046 case OP_SCOPE:
1047 {
1048 char *elem_name;
1049 int len;
1050
d4f3574e
SS		 1051 fprintf_filtered (stream, "Type @");
1052 gdb_print_host_address (exp->elts[elt].type, stream);
1053 fprintf_filtered (stream, " (");
c906108c
SS		 1054 type_print (exp->elts[elt].type, NULL, stream, 0);
1055 fprintf_filtered (stream, ") ");
1056
1057 len = longest_to_int (exp->elts[elt + 1].longconst);
1058 elem_name = &exp->elts[elt + 2].string;
1059
1060 fprintf_filtered (stream, "Field name: `%.*s'", len, elem_name);
1061 elt += 4 + BYTES_TO_EXP_ELEM (len + 1);
1062 }
1063 break;
1064 default:
1065 case OP_NULL:
c906108c
SS		 1066 case MULTI_SUBSCRIPT:
1067 case OP_F77_UNDETERMINED_ARGLIST:
1068 case OP_COMPLEX:
1069 case OP_STRING:
1070 case OP_BITSTRING:
1071 case OP_BOOL:
1072 case OP_M2_STRING:
1073 case OP_THIS:
1074 case OP_LABELED:
1075 case OP_NAME:
c906108c
SS		 1076 fprintf_filtered (stream, "Unknown format");
1077 }
1078
c906108c
SS		 1079 return elt;
1080}
1081
1082void
24daaebc 1083dump_prefix_expression (struct expression *exp, struct ui_file *stream)
c906108c
SS		 1084{
1085 int elt;
1086
1087 fprintf_filtered (stream, "Dump of expression @ ");
d4f3574e 1088 gdb_print_host_address (exp, stream);
24daaebc 1089 fputs_filtered (", after conversion to prefix form:\nExpression: `", stream);
c906108c
SS		 1090 if (exp->elts[0].opcode != OP_TYPE)
1091 print_expression (exp, stream);
1092 else
1093 fputs_filtered ("Type printing not yet supported....", stream);
9d271fd8 1094 fprintf_filtered (stream, "'\n\tLanguage %s, %d elements, %ld bytes each.\n",
c5aa993b 1095 exp->language_defn->la_name, exp->nelts,
9d271fd8 1096 (long) sizeof (union exp_element));
c906108c
SS		 1097 fputs_filtered ("\n", stream);
1098
c5aa993b 1099 for (elt = 0; elt < exp->nelts;)
c906108c
SS		 1100 elt = dump_subexp (exp, stream, elt);
1101 fputs_filtered ("\n", stream);
1102}
GDB Binutils - Deliverables
This page took 0.619862 seconds and 4 git commands to generate.