GDB (xrefs)

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