1 /* Print in infix form a struct expression.
2 Copyright (C) 1986, 1989, 1991 Free Software Foundation, Inc.
4 This file is part of GDB.
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.
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.
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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
23 #include "expression.h"
26 #include "parser-defs.h"
28 /* Prototypes for local functions */
31 print_subexp
PARAMS ((struct expression
*, int *, GDB_FILE
*, enum precedence
));
34 print_expression (exp
, stream
)
35 struct expression
*exp
;
39 print_subexp (exp
, &pc
, stream
, PREC_NULL
);
42 /* Print the subexpression of EXP that starts in position POS, on STREAM.
43 PREC is the precedence of the surrounding operator;
44 if the precedence of the main operator of this subexpression is less,
45 parentheses are needed here. */
48 print_subexp (exp
, pos
, stream
, prec
)
49 register struct expression
*exp
;
54 register unsigned tem
;
55 register const struct op_print
*op_print_tab
;
58 register char *op_str
;
59 int assign_modify
= 0;
60 enum exp_opcode opcode
;
61 enum precedence myprec
= PREC_NULL
;
62 /* Set to 1 for a right-associative operator. */
67 op_print_tab
= exp
->language_defn
->la_op_print_tab
;
69 opcode
= exp
->elts
[pc
].opcode
;
77 fputs_filtered (type_name_no_tag (exp
->elts
[pc
+ 1].type
), stream
);
78 fputs_filtered ("::", stream
);
79 nargs
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
80 (*pos
) += 4 + BYTES_TO_EXP_ELEM (nargs
+ 1);
81 fputs_filtered (&exp
->elts
[pc
+ 3].string
, stream
);
86 value_print (value_from_longest (exp
->elts
[pc
+ 1].type
,
87 exp
->elts
[pc
+ 2].longconst
),
88 stream
, 0, Val_no_prettyprint
);
93 value_print (value_from_double (exp
->elts
[pc
+ 1].type
,
94 exp
->elts
[pc
+ 2].doubleconst
),
95 stream
, 0, Val_no_prettyprint
);
102 b
= exp
->elts
[pc
+ 1].block
;
104 && BLOCK_FUNCTION (b
) != NULL
105 && SYMBOL_SOURCE_NAME (BLOCK_FUNCTION (b
)) != NULL
)
107 fputs_filtered (SYMBOL_SOURCE_NAME (BLOCK_FUNCTION (b
)), stream
);
108 fputs_filtered ("::", stream
);
110 fputs_filtered (SYMBOL_SOURCE_NAME (exp
->elts
[pc
+ 2].symbol
), stream
);
116 fprintf_filtered (stream
, "$%d",
117 longest_to_int (exp
->elts
[pc
+ 1].longconst
));
122 fprintf_filtered (stream
, "$%s",
123 reg_names
[longest_to_int (exp
->elts
[pc
+ 1].longconst
)]);
128 fprintf_filtered (stream
, "%s",
129 longest_to_int (exp
->elts
[pc
+ 1].longconst
)
135 fprintf_filtered (stream
, "$%s",
136 internalvar_name (exp
->elts
[pc
+ 1].internalvar
));
141 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
142 print_subexp (exp
, pos
, stream
, PREC_SUFFIX
);
143 fputs_filtered (" (", stream
);
144 for (tem
= 0; tem
< nargs
; tem
++)
147 fputs_filtered (", ", stream
);
148 print_subexp (exp
, pos
, stream
, PREC_ABOVE_COMMA
);
150 fputs_filtered (")", stream
);
155 nargs
= longest_to_int (exp
-> elts
[pc
+ 1].longconst
);
156 (*pos
) += 3 + BYTES_TO_EXP_ELEM (nargs
+ 1);
157 fputs_filtered (&exp
->elts
[pc
+ 2].string
, stream
);
161 nargs
= longest_to_int (exp
-> elts
[pc
+ 1].longconst
);
162 (*pos
) += 3 + BYTES_TO_EXP_ELEM (nargs
+ 1);
163 /* LA_PRINT_STRING will print using the current repeat count threshold.
164 If necessary, we can temporarily set it to zero, or pass it as an
165 additional parameter to LA_PRINT_STRING. -fnf */
166 LA_PRINT_STRING (stream
, &exp
->elts
[pc
+ 2].string
, nargs
, 0);
170 nargs
= longest_to_int (exp
-> elts
[pc
+ 1].longconst
);
172 += 3 + BYTES_TO_EXP_ELEM ((nargs
+ HOST_CHAR_BIT
- 1) / HOST_CHAR_BIT
);
173 fprintf (stream
, "B'<unimplemented>'");
178 nargs
= longest_to_int (exp
->elts
[pc
+ 2].longconst
);
179 nargs
-= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
182 if (exp
->elts
[pc
+ 4].opcode
== OP_LONG
183 && exp
->elts
[pc
+ 5].type
== builtin_type_char
184 && exp
->language_defn
->la_language
== language_c
)
186 /* Attempt to print C character arrays using string syntax.
187 Walk through the args, picking up one character from each
188 of the OP_LONG expression elements. If any array element
189 does not match our expection of what we should find for
190 a simple string, revert back to array printing. Note that
191 the last expression element is an explicit null terminator
192 byte, which doesn't get printed. */
193 tempstr
= alloca (nargs
);
197 if (exp
->elts
[pc
].opcode
!= OP_LONG
198 || exp
->elts
[pc
+ 1].type
!= builtin_type_char
)
200 /* Not a simple array of char, use regular array printing. */
207 longest_to_int (exp
->elts
[pc
+ 2].longconst
);
214 LA_PRINT_STRING (stream
, tempstr
, nargs
- 1, 0);
219 int is_chill
= exp
->language_defn
->la_language
== language_chill
;
220 fputs_filtered (is_chill
? " [" : " {", stream
);
221 for (tem
= 0; tem
< nargs
; tem
++)
225 fputs_filtered (", ", stream
);
227 print_subexp (exp
, pos
, stream
, PREC_ABOVE_COMMA
);
229 fputs_filtered (is_chill
? "]" : "}", stream
);
234 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
235 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
237 if (exp
->language_defn
->la_language
== language_chill
)
239 fputs_filtered (".", stream
);
240 fputs_filtered (&exp
->elts
[pc
+ 2].string
, stream
);
241 fputs_filtered (exp
->elts
[*pos
].opcode
== OP_LABELED
? ", "
247 /* Gcc support both these syntaxes. Unsure which is preferred. */
249 fputs_filtered (&exp
->elts
[pc
+ 2].string
, stream
);
250 fputs_filtered (": ", stream
);
252 fputs_filtered (".", stream
);
253 fputs_filtered (&exp
->elts
[pc
+ 2].string
, stream
);
254 fputs_filtered ("=", stream
);
257 print_subexp (exp
, pos
, stream
, PREC_SUFFIX
);
261 if ((int) prec
> (int) PREC_COMMA
)
262 fputs_filtered ("(", stream
);
263 /* Print the subexpressions, forcing parentheses
264 around any binary operations within them.
265 This is more parentheses than are strictly necessary,
266 but it looks clearer. */
267 print_subexp (exp
, pos
, stream
, PREC_HYPER
);
268 fputs_filtered (" ? ", stream
);
269 print_subexp (exp
, pos
, stream
, PREC_HYPER
);
270 fputs_filtered (" : ", stream
);
271 print_subexp (exp
, pos
, stream
, PREC_HYPER
);
272 if ((int) prec
> (int) PREC_COMMA
)
273 fputs_filtered (")", stream
);
277 case TERNOP_SLICE_COUNT
:
278 print_subexp (exp
, pos
, stream
, PREC_SUFFIX
);
279 fputs_filtered ("(", stream
);
280 print_subexp (exp
, pos
, stream
, PREC_ABOVE_COMMA
);
281 fputs_filtered (opcode
== TERNOP_SLICE
? " : " : " UP ", stream
);
282 print_subexp (exp
, pos
, stream
, PREC_ABOVE_COMMA
);
283 fputs_filtered (")", stream
);
286 case STRUCTOP_STRUCT
:
287 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
288 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
289 print_subexp (exp
, pos
, stream
, PREC_SUFFIX
);
290 fputs_filtered (".", stream
);
291 fputs_filtered (&exp
->elts
[pc
+ 2].string
, stream
);
294 /* Will not occur for Modula-2 */
296 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
297 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
298 print_subexp (exp
, pos
, stream
, PREC_SUFFIX
);
299 fputs_filtered ("->", stream
);
300 fputs_filtered (&exp
->elts
[pc
+ 2].string
, stream
);
303 /* start-sanitize-gm */
304 #ifdef GENERAL_MAGIC_HACKS
306 tem
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
307 (*pos
) += 3 + BYTES_TO_EXP_ELEM (tem
+ 1);
308 print_subexp (exp
, pos
, stream
, PREC_SUFFIX
);
309 fputs_filtered ("@", stream
);
310 fputs_filtered (&exp
->elts
[pc
+ 2].string
, stream
);
313 #endif /* GENERAL_MAGIC_HACKS */
314 /* end-sanitize-gm */
316 case BINOP_SUBSCRIPT
:
317 print_subexp (exp
, pos
, stream
, PREC_SUFFIX
);
318 fputs_filtered ("[", stream
);
319 print_subexp (exp
, pos
, stream
, PREC_ABOVE_COMMA
);
320 fputs_filtered ("]", stream
);
323 case UNOP_POSTINCREMENT
:
324 print_subexp (exp
, pos
, stream
, PREC_SUFFIX
);
325 fputs_filtered ("++", stream
);
328 case UNOP_POSTDECREMENT
:
329 print_subexp (exp
, pos
, stream
, PREC_SUFFIX
);
330 fputs_filtered ("--", stream
);
335 if ((int) prec
> (int) PREC_PREFIX
)
336 fputs_filtered ("(", stream
);
337 fputs_filtered ("(", stream
);
338 type_print (exp
->elts
[pc
+ 1].type
, "", stream
, 0);
339 fputs_filtered (") ", stream
);
340 print_subexp (exp
, pos
, stream
, PREC_PREFIX
);
341 if ((int) prec
> (int) PREC_PREFIX
)
342 fputs_filtered (")", stream
);
347 if ((int) prec
> (int) PREC_PREFIX
)
348 fputs_filtered ("(", stream
);
349 if (exp
->elts
[pc
+ 1].type
->code
== TYPE_CODE_FUNC
&&
350 exp
->elts
[pc
+ 3].opcode
== OP_LONG
) {
351 /* We have a minimal symbol fn, probably. It's encoded
352 as a UNOP_MEMVAL (function-type) of an OP_LONG (int, address).
353 Swallow the OP_LONG (including both its opcodes); ignore
354 its type; print the value in the type of the MEMVAL. */
356 val
= value_at_lazy (exp
->elts
[pc
+ 1].type
,
357 (CORE_ADDR
) exp
->elts
[pc
+ 5].longconst
);
358 value_print (val
, stream
, 0, Val_no_prettyprint
);
360 fputs_filtered ("{", stream
);
361 type_print (exp
->elts
[pc
+ 1].type
, "", stream
, 0);
362 fputs_filtered ("} ", stream
);
363 print_subexp (exp
, pos
, stream
, PREC_PREFIX
);
365 if ((int) prec
> (int) PREC_PREFIX
)
366 fputs_filtered (")", stream
);
369 case BINOP_ASSIGN_MODIFY
:
370 opcode
= exp
->elts
[pc
+ 1].opcode
;
372 myprec
= PREC_ASSIGN
;
376 for (tem
= 0; op_print_tab
[tem
].opcode
!= OP_NULL
; tem
++)
377 if (op_print_tab
[tem
].opcode
== opcode
)
379 op_str
= op_print_tab
[tem
].string
;
382 if (op_print_tab
[tem
].opcode
!= opcode
)
383 /* Not found; don't try to keep going because we don't know how
384 to interpret further elements. */
385 error ("Invalid expression");
392 fputs_filtered ("this", stream
);
397 case MULTI_SUBSCRIPT
:
399 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
400 print_subexp (exp
, pos
, stream
, PREC_SUFFIX
);
401 fprintf_unfiltered (stream
, " [");
402 for (tem
= 0; tem
< nargs
; tem
++)
405 fprintf_unfiltered (stream
, ", ");
406 print_subexp (exp
, pos
, stream
, PREC_ABOVE_COMMA
);
408 fprintf_unfiltered (stream
, "]");
413 fprintf_unfiltered(stream
,"VAL(");
414 type_print(exp
->elts
[pc
+1].type
,"",stream
,0);
415 fprintf_unfiltered(stream
,",");
416 print_subexp(exp
,pos
,stream
,PREC_PREFIX
);
417 fprintf_unfiltered(stream
,")");
422 error("print_subexp: Not implemented.");
428 for (tem
= 0; op_print_tab
[tem
].opcode
!= OP_NULL
; tem
++)
429 if (op_print_tab
[tem
].opcode
== opcode
)
431 op_str
= op_print_tab
[tem
].string
;
432 myprec
= op_print_tab
[tem
].precedence
;
433 assoc
= op_print_tab
[tem
].right_assoc
;
436 if (op_print_tab
[tem
].opcode
!= opcode
)
437 /* Not found; don't try to keep going because we don't know how
438 to interpret further elements. For example, this happens
439 if opcode is OP_TYPE. */
440 error ("Invalid expression");
443 /* Note that PREC_BUILTIN will always emit parentheses. */
444 if ((int) myprec
< (int) prec
)
445 fputs_filtered ("(", stream
);
446 if ((int) opcode
> (int) BINOP_END
)
450 /* Unary postfix operator. */
451 print_subexp (exp
, pos
, stream
, PREC_SUFFIX
);
452 fputs_filtered (op_str
, stream
);
456 /* Unary prefix operator. */
457 fputs_filtered (op_str
, stream
);
458 if (myprec
== PREC_BUILTIN_FUNCTION
)
459 fputs_filtered ("(", stream
);
460 print_subexp (exp
, pos
, stream
, PREC_PREFIX
);
461 if (myprec
== PREC_BUILTIN_FUNCTION
)
462 fputs_filtered (")", stream
);
467 /* Binary operator. */
468 /* Print left operand.
469 If operator is right-associative,
470 increment precedence for this operand. */
471 print_subexp (exp
, pos
, stream
,
472 (enum precedence
) ((int) myprec
+ assoc
));
473 /* Print the operator itself. */
475 fprintf_filtered (stream
, " %s= ", op_str
);
476 else if (op_str
[0] == ',')
477 fprintf_filtered (stream
, "%s ", op_str
);
479 fprintf_filtered (stream
, " %s ", op_str
);
480 /* Print right operand.
481 If operator is left-associative,
482 increment precedence for this operand. */
483 print_subexp (exp
, pos
, stream
,
484 (enum precedence
) ((int) myprec
+ !assoc
));
487 if ((int) myprec
< (int) prec
)
488 fputs_filtered (")", stream
);
491 /* Return the operator corresponding to opcode OP as
492 a string. NULL indicates that the opcode was not found in the
493 current language table. */
499 register const struct op_print
*op_print_tab
;
501 op_print_tab
= current_language
->la_op_print_tab
;
502 for (tem
= 0; op_print_tab
[tem
].opcode
!= OP_NULL
; tem
++)
503 if (op_print_tab
[tem
].opcode
== op
)
504 return op_print_tab
[tem
].string
;
508 #ifdef DEBUG_EXPRESSIONS
510 /* Support for dumping the raw data from expressions in a human readable
514 dump_expression (exp
, stream
, note
)
515 struct expression
*exp
;
524 fprintf_filtered (stream
, "Dump of expression @ ");
525 gdb_print_address (exp
, stream
);
526 fprintf_filtered (stream
, ", %s:\n", note
);
527 fprintf_filtered (stream
, "\tLanguage %s, %d elements, %d bytes each.\n",
528 exp
->language_defn
->la_name
, exp
-> nelts
,
529 sizeof (union exp_element
));
530 fprintf_filtered (stream
, "\t%5s %20s %16s %s\n", "Index", "Opcode",
531 "Hex Value", "String Value");
532 for (elt
= 0; elt
< exp
-> nelts
; elt
++)
534 fprintf_filtered (stream
, "\t%5d ", elt
);
535 switch (exp
-> elts
[elt
].opcode
)
537 default: opcode_name
= "<unknown>"; break;
538 case OP_NULL
: opcode_name
= "OP_NULL"; break;
539 case BINOP_ADD
: opcode_name
= "BINOP_ADD"; break;
540 case BINOP_SUB
: opcode_name
= "BINOP_SUB"; break;
541 case BINOP_MUL
: opcode_name
= "BINOP_MUL"; break;
542 case BINOP_DIV
: opcode_name
= "BINOP_DIV"; break;
543 case BINOP_REM
: opcode_name
= "BINOP_REM"; break;
544 case BINOP_MOD
: opcode_name
= "BINOP_MOD"; break;
545 case BINOP_LSH
: opcode_name
= "BINOP_LSH"; break;
546 case BINOP_RSH
: opcode_name
= "BINOP_RSH"; break;
547 case BINOP_LOGICAL_AND
: opcode_name
= "BINOP_LOGICAL_AND"; break;
548 case BINOP_LOGICAL_OR
: opcode_name
= "BINOP_LOGICAL_OR"; break;
549 case BINOP_BITWISE_AND
: opcode_name
= "BINOP_BITWISE_AND"; break;
550 case BINOP_BITWISE_IOR
: opcode_name
= "BINOP_BITWISE_IOR"; break;
551 case BINOP_BITWISE_XOR
: opcode_name
= "BINOP_BITWISE_XOR"; break;
552 case BINOP_EQUAL
: opcode_name
= "BINOP_EQUAL"; break;
553 case BINOP_NOTEQUAL
: opcode_name
= "BINOP_NOTEQUAL"; break;
554 case BINOP_LESS
: opcode_name
= "BINOP_LESS"; break;
555 case BINOP_GTR
: opcode_name
= "BINOP_GTR"; break;
556 case BINOP_LEQ
: opcode_name
= "BINOP_LEQ"; break;
557 case BINOP_GEQ
: opcode_name
= "BINOP_GEQ"; break;
558 case BINOP_REPEAT
: opcode_name
= "BINOP_REPEAT"; break;
559 case BINOP_ASSIGN
: opcode_name
= "BINOP_ASSIGN"; break;
560 case BINOP_COMMA
: opcode_name
= "BINOP_COMMA"; break;
561 case BINOP_SUBSCRIPT
: opcode_name
= "BINOP_SUBSCRIPT"; break;
562 case MULTI_SUBSCRIPT
: opcode_name
= "MULTI_SUBSCRIPT"; break;
563 case BINOP_EXP
: opcode_name
= "BINOP_EXP"; break;
564 case BINOP_MIN
: opcode_name
= "BINOP_MIN"; break;
565 case BINOP_MAX
: opcode_name
= "BINOP_MAX"; break;
566 case BINOP_SCOPE
: opcode_name
= "BINOP_SCOPE"; break;
567 case STRUCTOP_MEMBER
: opcode_name
= "STRUCTOP_MEMBER"; break;
568 case STRUCTOP_MPTR
: opcode_name
= "STRUCTOP_MPTR"; break;
569 case BINOP_INTDIV
: opcode_name
= "BINOP_INTDIV"; break;
570 case BINOP_ASSIGN_MODIFY
: opcode_name
= "BINOP_ASSIGN_MODIFY"; break;
571 case BINOP_VAL
: opcode_name
= "BINOP_VAL"; break;
572 case BINOP_INCL
: opcode_name
= "BINOP_INCL"; break;
573 case BINOP_EXCL
: opcode_name
= "BINOP_EXCL"; break;
574 case BINOP_CONCAT
: opcode_name
= "BINOP_CONCAT"; break;
575 case BINOP_END
: opcode_name
= "BINOP_END"; break;
576 case TERNOP_COND
: opcode_name
= "TERNOP_COND"; break;
577 case TERNOP_SLICE
: opcode_name
= "TERNOP_SLICE"; break;
578 case TERNOP_SLICE_COUNT
: opcode_name
= "TERNOP_SLICE_COUNT"; break;
579 case OP_LONG
: opcode_name
= "OP_LONG"; break;
580 case OP_DOUBLE
: opcode_name
= "OP_DOUBLE"; break;
581 case OP_VAR_VALUE
: opcode_name
= "OP_VAR_VALUE"; break;
582 case OP_LAST
: opcode_name
= "OP_LAST"; break;
583 case OP_REGISTER
: opcode_name
= "OP_REGISTER"; break;
584 case OP_INTERNALVAR
: opcode_name
= "OP_INTERNALVAR"; break;
585 case OP_FUNCALL
: opcode_name
= "OP_FUNCALL"; break;
586 case OP_STRING
: opcode_name
= "OP_STRING"; break;
587 case OP_BITSTRING
: opcode_name
= "OP_BITSTRING"; break;
588 case OP_ARRAY
: opcode_name
= "OP_ARRAY"; break;
589 case UNOP_CAST
: opcode_name
= "UNOP_CAST"; break;
590 case UNOP_MEMVAL
: opcode_name
= "UNOP_MEMVAL"; break;
591 case UNOP_NEG
: opcode_name
= "UNOP_NEG"; break;
592 case UNOP_LOGICAL_NOT
: opcode_name
= "UNOP_LOGICAL_NOT"; break;
593 case UNOP_COMPLEMENT
: opcode_name
= "UNOP_COMPLEMENT"; break;
594 case UNOP_IND
: opcode_name
= "UNOP_IND"; break;
595 case UNOP_ADDR
: opcode_name
= "UNOP_ADDR"; break;
596 case UNOP_PREINCREMENT
: opcode_name
= "UNOP_PREINCREMENT"; break;
597 case UNOP_POSTINCREMENT
: opcode_name
= "UNOP_POSTINCREMENT"; break;
598 case UNOP_PREDECREMENT
: opcode_name
= "UNOP_PREDECREMENT"; break;
599 case UNOP_POSTDECREMENT
: opcode_name
= "UNOP_POSTDECREMENT"; break;
600 case UNOP_SIZEOF
: opcode_name
= "UNOP_SIZEOF"; break;
601 case UNOP_LOWER
: opcode_name
= "UNOP_LOWER"; break;
602 case UNOP_UPPER
: opcode_name
= "UNOP_UPPER"; break;
603 case UNOP_LENGTH
: opcode_name
= "UNOP_LENGTH"; break;
604 case UNOP_PLUS
: opcode_name
= "UNOP_PLUS"; break;
605 case UNOP_CAP
: opcode_name
= "UNOP_CAP"; break;
606 case UNOP_CHR
: opcode_name
= "UNOP_CHR"; break;
607 case UNOP_ORD
: opcode_name
= "UNOP_ORD"; break;
608 case UNOP_ABS
: opcode_name
= "UNOP_ABS"; break;
609 case UNOP_FLOAT
: opcode_name
= "UNOP_FLOAT"; break;
610 case UNOP_HIGH
: opcode_name
= "UNOP_HIGH"; break;
611 case UNOP_MAX
: opcode_name
= "UNOP_MAX"; break;
612 case UNOP_MIN
: opcode_name
= "UNOP_MIN"; break;
613 case UNOP_ODD
: opcode_name
= "UNOP_ODD"; break;
614 case UNOP_TRUNC
: opcode_name
= "UNOP_TRUNC"; break;
615 case OP_BOOL
: opcode_name
= "OP_BOOL"; break;
616 case OP_M2_STRING
: opcode_name
= "OP_M2_STRING"; break;
617 case STRUCTOP_STRUCT
: opcode_name
= "STRUCTOP_STRUCT"; break;
618 case STRUCTOP_PTR
: opcode_name
= "STRUCTOP_PTR"; break;
619 /* start-sanitize-gm */
620 #ifdef GENERAL_MAGIC_HACKS
621 + case STRUCTOP_FIELD
: opcode_name
= "STRUCTOP_FIELD"; break;
622 #endif /* GENERAL_MAGIC_HACKS */
623 /* end-sanitize-gm */
624 case OP_THIS
: opcode_name
= "OP_THIS"; break;
625 case OP_SCOPE
: opcode_name
= "OP_SCOPE"; break;
626 case OP_TYPE
: opcode_name
= "OP_TYPE"; break;
627 case OP_LABELED
: opcode_name
= "OP_LABELED"; break;
629 fprintf_filtered (stream
, "%20s ", opcode_name
);
630 fprintf_filtered (stream
,
631 #if defined (PRINTF_HAS_LONG_LONG)
636 exp
-> elts
[elt
].longconst
);
638 for (eltscan
= (char *) &exp
->elts
[elt
],
639 eltsize
= sizeof (union exp_element
) ;
643 fprintf_filtered (stream
, "%c",
644 isprint (*eltscan
) ? (*eltscan
& 0xFF) : '.');
646 fprintf_filtered (stream
, "\n");
650 #endif /* DEBUG_EXPRESSIONS */
This page took 0.043673 seconds and 4 git commands to generate.