1 /* Print in infix form a struct expression.
2 Copyright (C) 1986, 1989 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., 675 Mass Ave, Cambridge, MA 02139, USA. */
24 #include "expression.h"
28 /* These codes indicate operator precedences, least tightly binding first. */
29 /* Adding 1 to a precedence value is done for binary operators,
30 on the operand which is more tightly bound, so that operators
31 of equal precedence within that operand will get parentheses. */
32 /* PREC_HYPER and PREC_ABOVE_COMMA are not the precedence of any operator;
33 they are used as the "surrounding precedence" to force
34 various kinds of things to be parenthesized. */
36 { PREC_NULL
, PREC_COMMA
, PREC_ABOVE_COMMA
, PREC_ASSIGN
, PREC_OR
, PREC_AND
,
37 PREC_LOGIOR
, PREC_LOGAND
, PREC_LOGXOR
, PREC_EQUAL
, PREC_ORDER
,
38 PREC_SHIFT
, PREC_ADD
, PREC_MUL
, PREC_REPEAT
,
39 PREC_HYPER
, PREC_PREFIX
, PREC_SUFFIX
};
41 /* Table mapping opcodes into strings for printing operators
42 and precedences of the operators. */
47 enum exp_opcode opcode
;
48 /* Precedence of operator. These values are used only by comparisons. */
49 enum precedence precedence
;
53 const static struct op_print op_print_tab
[] =
55 {",", BINOP_COMMA
, PREC_COMMA
, 0},
56 {"=", BINOP_ASSIGN
, PREC_ASSIGN
, 1},
57 {"||", BINOP_OR
, PREC_OR
, 0},
58 {"&&", BINOP_AND
, PREC_AND
, 0},
59 {"|", BINOP_LOGIOR
, PREC_LOGIOR
, 0},
60 {"&", BINOP_LOGAND
, PREC_LOGAND
, 0},
61 {"^", BINOP_LOGXOR
, PREC_LOGXOR
, 0},
62 {"==", BINOP_EQUAL
, PREC_EQUAL
, 0},
63 {"!=", BINOP_NOTEQUAL
, PREC_EQUAL
, 0},
64 {"<=", BINOP_LEQ
, PREC_ORDER
, 0},
65 {">=", BINOP_GEQ
, PREC_ORDER
, 0},
66 {">", BINOP_GTR
, PREC_ORDER
, 0},
67 {"<", BINOP_LESS
, PREC_ORDER
, 0},
68 {">>", BINOP_RSH
, PREC_SHIFT
, 0},
69 {"<<", BINOP_LSH
, PREC_SHIFT
, 0},
70 {"+", BINOP_ADD
, PREC_ADD
, 0},
71 {"-", BINOP_SUB
, PREC_ADD
, 0},
72 {"*", BINOP_MUL
, PREC_MUL
, 0},
73 {"/", BINOP_DIV
, PREC_MUL
, 0},
74 {"%", BINOP_REM
, PREC_MUL
, 0},
75 {"@", BINOP_REPEAT
, PREC_REPEAT
, 0},
76 {"-", UNOP_NEG
, PREC_PREFIX
, 0},
77 {"!", UNOP_ZEROP
, PREC_PREFIX
, 0},
78 {"~", UNOP_LOGNOT
, PREC_PREFIX
, 0},
79 {"*", UNOP_IND
, PREC_PREFIX
, 0},
80 {"&", UNOP_ADDR
, PREC_PREFIX
, 0},
81 {"sizeof ", UNOP_SIZEOF
, PREC_PREFIX
, 0},
82 {"++", UNOP_PREINCREMENT
, PREC_PREFIX
, 0},
83 {"--", UNOP_PREDECREMENT
, PREC_PREFIX
, 0},
85 {"::", BINOP_SCOPE
, PREC_PREFIX
, 0},
88 static void print_subexp ();
91 print_expression (exp
, stream
)
92 struct expression
*exp
;
96 print_subexp (exp
, &pc
, stream
, PREC_NULL
);
99 /* Print the subexpression of EXP that starts in position POS, on STREAM.
100 PREC is the precedence of the surrounding operator;
101 if the precedence of the main operator of this subexpression is less,
102 parentheses are needed here. */
105 print_subexp (exp
, pos
, stream
, prec
)
106 register struct expression
*exp
;
109 enum precedence prec
;
111 register unsigned tem
;
114 register char *op_str
;
115 int assign_modify
= 0;
116 enum exp_opcode opcode
;
117 enum precedence myprec
;
118 /* Set to 1 for a right-associative operator. */
122 opcode
= exp
->elts
[pc
].opcode
;
126 myprec
= PREC_PREFIX
;
129 print_subexp (exp
, pos
, stream
,
130 (enum precedence
) ((int) myprec
+ assoc
));
131 fputs_filtered (" :: ", stream
);
132 nargs
= strlen (&exp
->elts
[pc
+ 2].string
);
133 (*pos
) += 1 + (nargs
+ sizeof (union exp_element
)) / sizeof (union exp_element
);
135 fputs_filtered (&exp
->elts
[pc
+ 2].string
, stream
);
140 value_print (value_from_long (exp
->elts
[pc
+ 1].type
,
141 exp
->elts
[pc
+ 2].longconst
),
142 stream
, 0, Val_no_prettyprint
);
147 value_print (value_from_double (exp
->elts
[pc
+ 1].type
,
148 exp
->elts
[pc
+ 2].doubleconst
),
149 stream
, 0, Val_no_prettyprint
);
154 fputs_filtered (SYMBOL_NAME (exp
->elts
[pc
+ 1].symbol
), stream
);
159 fprintf_filtered (stream
, "$%d",
160 longest_to_int (exp
->elts
[pc
+ 1].longconst
));
165 fprintf_filtered (stream
, "$%s",
166 longest_to_int (reg_names
[exp
->elts
[pc
+ 1].longconst
]));
171 fprintf_filtered (stream
, "$%s",
172 internalvar_name (exp
->elts
[pc
+ 1].internalvar
));
177 nargs
= longest_to_int (exp
->elts
[pc
+ 1].longconst
);
178 print_subexp (exp
, pos
, stream
, PREC_SUFFIX
);
179 fputs_filtered (" (", stream
);
180 for (tem
= 0; tem
< nargs
; tem
++)
183 fputs_filtered (", ", stream
);
184 print_subexp (exp
, pos
, stream
, PREC_ABOVE_COMMA
);
186 fputs_filtered (")", stream
);
190 nargs
= strlen (&exp
->elts
[pc
+ 1].string
);
191 (*pos
) += 2 + (nargs
+ sizeof (union exp_element
)) / sizeof (union exp_element
);
192 fputs_filtered ("\"", stream
);
193 for (tem
= 0; tem
< nargs
; tem
++)
194 printchar ((&exp
->elts
[pc
+ 1].string
)[tem
], stream
, '"');
195 fputs_filtered ("\"", stream
);
199 if ((int) prec
> (int) PREC_COMMA
)
200 fputs_filtered ("(", stream
);
201 /* Print the subexpressions, forcing parentheses
202 around any binary operations within them.
203 This is more parentheses than are strictly necessary,
204 but it looks clearer. */
205 print_subexp (exp
, pos
, stream
, PREC_HYPER
);
206 fputs_filtered (" ? ", stream
);
207 print_subexp (exp
, pos
, stream
, PREC_HYPER
);
208 fputs_filtered (" : ", stream
);
209 print_subexp (exp
, pos
, stream
, PREC_HYPER
);
210 if ((int) prec
> (int) PREC_COMMA
)
211 fputs_filtered (")", stream
);
214 case STRUCTOP_STRUCT
:
215 tem
= strlen (&exp
->elts
[pc
+ 1].string
);
216 (*pos
) += 2 + (tem
+ sizeof (union exp_element
)) / sizeof (union exp_element
);
217 print_subexp (exp
, pos
, stream
, PREC_SUFFIX
);
218 fputs_filtered (".", stream
);
219 fputs_filtered (&exp
->elts
[pc
+ 1].string
, stream
);
223 tem
= strlen (&exp
->elts
[pc
+ 1].string
);
224 (*pos
) += 2 + (tem
+ sizeof (union exp_element
)) / sizeof (union exp_element
);
225 print_subexp (exp
, pos
, stream
, PREC_SUFFIX
);
226 fputs_filtered ("->", stream
);
227 fputs_filtered (&exp
->elts
[pc
+ 1].string
, stream
);
230 case BINOP_SUBSCRIPT
:
231 print_subexp (exp
, pos
, stream
, PREC_SUFFIX
);
232 fputs_filtered ("[", stream
);
233 print_subexp (exp
, pos
, stream
, PREC_ABOVE_COMMA
);
234 fputs_filtered ("]", stream
);
237 case UNOP_POSTINCREMENT
:
238 print_subexp (exp
, pos
, stream
, PREC_SUFFIX
);
239 fputs_filtered ("++", stream
);
242 case UNOP_POSTDECREMENT
:
243 print_subexp (exp
, pos
, stream
, PREC_SUFFIX
);
244 fputs_filtered ("--", stream
);
249 if ((int) prec
> (int) PREC_PREFIX
)
250 fputs_filtered ("(", stream
);
251 fputs_filtered ("(", stream
);
252 type_print (exp
->elts
[pc
+ 1].type
, "", stream
, 0);
253 fputs_filtered (") ", stream
);
254 print_subexp (exp
, pos
, stream
, PREC_PREFIX
);
255 if ((int) prec
> (int) PREC_PREFIX
)
256 fputs_filtered (")", stream
);
261 if ((int) prec
> (int) PREC_PREFIX
)
262 fputs_filtered ("(", stream
);
263 fputs_filtered ("{", stream
);
264 type_print (exp
->elts
[pc
+ 1].type
, "", stream
, 0);
265 fputs_filtered ("} ", stream
);
266 print_subexp (exp
, pos
, stream
, PREC_PREFIX
);
267 if ((int) prec
> (int) PREC_PREFIX
)
268 fputs_filtered (")", stream
);
271 case BINOP_ASSIGN_MODIFY
:
272 opcode
= exp
->elts
[pc
+ 1].opcode
;
274 myprec
= PREC_ASSIGN
;
277 for (tem
= 0; tem
< sizeof op_print_tab
/ sizeof op_print_tab
[0]; tem
++)
278 if (op_print_tab
[tem
].opcode
== opcode
)
280 op_str
= op_print_tab
[tem
].string
;
287 fputs_filtered ("this", stream
);
291 for (tem
= 0; tem
< sizeof op_print_tab
/ sizeof op_print_tab
[0]; tem
++)
292 if (op_print_tab
[tem
].opcode
== opcode
)
294 op_str
= op_print_tab
[tem
].string
;
295 myprec
= op_print_tab
[tem
].precedence
;
296 assoc
= op_print_tab
[tem
].right_assoc
;
301 if ((int) myprec
< (int) prec
)
302 fputs_filtered ("(", stream
);
303 if ((int) opcode
> (int) BINOP_END
)
305 /* Unary prefix operator. */
306 fputs_filtered (op_str
, stream
);
307 print_subexp (exp
, pos
, stream
, PREC_PREFIX
);
311 /* Binary operator. */
312 /* Print left operand.
313 If operator is right-associative,
314 increment precedence for this operand. */
315 print_subexp (exp
, pos
, stream
,
316 (enum precedence
) ((int) myprec
+ assoc
));
317 /* Print the operator itself. */
319 fprintf_filtered (stream
, " %s= ", op_str
);
320 else if (op_str
[0] == ',')
321 fprintf_filtered (stream
, "%s ", op_str
);
323 fprintf_filtered (stream
, " %s ", op_str
);
324 /* Print right operand.
325 If operator is left-associative,
326 increment precedence for this operand. */
327 print_subexp (exp
, pos
, stream
,
328 (enum precedence
) ((int) myprec
+ !assoc
));
330 if ((int) myprec
< (int) prec
)
331 fputs_filtered (")", stream
);
This page took 0.057091 seconds and 4 git commands to generate.