ae9720bfb96f6f8f4c8d6737d3648f977aab06a2
1 /* Evaluate expressions for GDB.
2 Copyright (C) 1986, 1987 Free Software Foundation, Inc.
4 GDB is distributed in the hope that it will be useful, but WITHOUT ANY
5 WARRANTY. No author or distributor accepts responsibility to anyone
6 for the consequences of using it or for whether it serves any
7 particular purpose or works at all, unless he says so in writing.
8 Refer to the GDB General Public License for full details.
10 Everyone is granted permission to copy, modify and redistribute GDB,
11 but only under the conditions described in the GDB General Public
12 License. A copy of this license is supposed to have been given to you
13 along with GDB so you can know your rights and responsibilities. It
14 should be in a file named COPYING. Among other things, the copyright
15 notice and this notice must be preserved on all copies.
17 In other words, go ahead and share GDB, but don't try to stop
18 anyone else from sharing it farther. Help stamp out software hoarding!
25 #include "expression.h"
28 /* Parse the string EXP as a C expression, evaluate it,
29 and return the result as a number. */
32 parse_and_eval_address (exp
)
35 struct expression
*expr
= parse_c_expression (exp
);
36 register CORE_ADDR addr
;
37 register struct cleanup
*old_chain
38 = make_cleanup (free_current_contents
, &expr
);
40 addr
= (CORE_ADDR
) value_as_long (evaluate_expression (expr
));
41 do_cleanups (old_chain
);
45 /* Like parse_and_eval_address but takes a pointer to a char * variable
46 and advanced that variable across the characters parsed. */
49 parse_and_eval_address_1 (expptr
)
52 struct expression
*expr
= parse_c_1 (expptr
, 0, 0);
53 register CORE_ADDR addr
;
54 register struct cleanup
*old_chain
55 = make_cleanup (free_current_contents
, &expr
);
57 addr
= value_as_long (evaluate_expression (expr
));
58 do_cleanups (old_chain
);
66 struct expression
*expr
= parse_c_expression (exp
);
68 register struct cleanup
*old_chain
69 = make_cleanup (free_current_contents
, &expr
);
71 val
= evaluate_expression (expr
);
72 do_cleanups (old_chain
);
76 /* Parse up to a comma (or to a closeparen)
77 in the string EXPP as an expression, evaluate it, and return the value.
78 EXPP is advanced to point to the comma. */
81 parse_to_comma_and_eval (expp
)
84 struct expression
*expr
= parse_c_1 (expp
, 0, 1);
86 register struct cleanup
*old_chain
87 = make_cleanup (free_current_contents
, &expr
);
89 val
= evaluate_expression (expr
);
90 do_cleanups (old_chain
);
94 /* Evaluate an expression in internal prefix form
95 such as is constructed by expread.y.
97 See expression.h for info on the format of an expression. */
99 static value
evaluate_subexp ();
100 static value
evaluate_subexp_for_address ();
101 static value
evaluate_subexp_for_sizeof ();
102 static value
evaluate_subexp_with_coercion ();
104 /* Values of NOSIDE argument to eval_subexp. */
107 EVAL_SKIP
, /* Only effect is to increment pos. */
108 EVAL_AVOID_SIDE_EFFECTS
, /* Don't modify any variables or
109 call any functions. Correct type
114 evaluate_expression (exp
)
115 struct expression
*exp
;
118 return evaluate_subexp (0, exp
, &pc
, EVAL_NORMAL
);
121 /* Evaluate an expression, avoiding all memory references
122 and getting a value whose type alone is correct. */
126 struct expression
*exp
;
129 return evaluate_subexp (0, exp
, &pc
, EVAL_AVOID_SIDE_EFFECTS
);
133 evaluate_subexp (expect_type
, exp
, pos
, noside
)
134 struct type
*expect_type
;
135 register struct expression
*exp
;
141 register int pc
, pc2
, oldpos
;
142 register value arg1
, arg2
, arg3
;
147 op
= exp
->elts
[pc
].opcode
;
152 tem
= strlen (&exp
->elts
[pc
+ 2].string
);
153 (*pos
) += 3 + (tem
+ sizeof (union exp_element
)) / sizeof (union exp_element
);
154 return value_static_field (exp
->elts
[pc
+ 1].type
,
155 &exp
->elts
[pc
+ 2].string
, -1);
159 return value_from_long (exp
->elts
[pc
+ 1].type
,
160 exp
->elts
[pc
+ 2].longconst
);
164 return value_from_double (exp
->elts
[pc
+ 1].type
,
165 exp
->elts
[pc
+ 2].doubleconst
);
169 if (noside
== EVAL_SKIP
)
171 return value_of_variable (exp
->elts
[pc
+ 1].symbol
);
175 return access_value_history ((int) exp
->elts
[pc
+ 1].longconst
);
179 return value_of_register ((int) exp
->elts
[pc
+ 1].longconst
);
183 return value_of_internalvar (exp
->elts
[pc
+ 1].internalvar
);
186 tem
= strlen (&exp
->elts
[pc
+ 1].string
);
187 (*pos
) += 2 + (tem
+ sizeof (union exp_element
)) / sizeof (union exp_element
);
188 if (noside
== EVAL_SKIP
)
190 return value_string (&exp
->elts
[pc
+ 1].string
, tem
);
193 /* Skip third and second args to evaluate the first one. */
194 arg1
= evaluate_subexp (0, exp
, pos
, noside
);
195 if (value_zerop (arg1
))
197 evaluate_subexp (0, exp
, pos
, EVAL_SKIP
);
198 return evaluate_subexp (0, exp
, pos
, noside
);
202 arg2
= evaluate_subexp (0, exp
, pos
, noside
);
203 evaluate_subexp (0, exp
, pos
, EVAL_SKIP
);
209 op
= exp
->elts
[*pos
].opcode
;
210 if (op
== STRUCTOP_MEMBER
|| op
== STRUCTOP_MPTR
)
215 nargs
= (int) exp
->elts
[pc
+ 1].longconst
+ 1;
216 /* First, evaluate the structure into arg2 */
219 if (noside
== EVAL_SKIP
)
222 if (op
== STRUCTOP_MEMBER
)
224 arg2
= evaluate_subexp_for_address (exp
, pos
, noside
);
228 arg2
= evaluate_subexp (0, exp
, pos
, noside
);
231 /* If the function is a virtual function, then the
232 aggregate value (providing the structure) plays
233 its part by providing the vtable. Otherwise,
234 it is just along for the ride: call the function
237 arg1
= evaluate_subexp (0, exp
, pos
, noside
);
239 fnptr
= (int) value_as_long (arg1
);
242 struct type
*basetype
;
244 basetype
= TYPE_TARGET_TYPE (VALUE_TYPE (arg2
));
245 basetype
= TYPE_VPTR_BASETYPE (basetype
);
246 for (i
= TYPE_NFN_FIELDS (basetype
) - 1; i
>= 0; i
--)
248 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (basetype
, i
);
249 /* If one is virtual, then all are virtual. */
250 if (TYPE_FN_FIELD_VIRTUAL_P (f
, 0))
251 for (j
= TYPE_FN_FIELDLIST_LENGTH (basetype
, i
) - 1; j
>= 0; --j
)
252 if (TYPE_FN_FIELD_VOFFSET (f
, j
) == fnptr
)
255 value base
= value_ind (arg2
);
256 struct type
*fntype
= lookup_pointer_type (TYPE_FN_FIELD_TYPE (f
, j
));
258 if (TYPE_VPTR_FIELDNO (basetype
) < 0)
259 TYPE_VPTR_FIELDNO (basetype
)
260 = fill_in_vptr_fieldno (basetype
);
262 VALUE_TYPE (base
) = basetype
;
263 vtbl
= value_field (base
, TYPE_VPTR_FIELDNO (basetype
));
264 VALUE_TYPE (vtbl
) = lookup_pointer_type (fntype
);
265 VALUE_TYPE (arg1
) = builtin_type_int
;
266 arg1
= value_subscript (vtbl
, arg1
);
267 VALUE_TYPE (arg1
) = fntype
;
272 error ("virtual function at index %d not found", fnptr
);
276 VALUE_TYPE (arg1
) = lookup_pointer_type (TYPE_TARGET_TYPE (VALUE_TYPE (arg1
)));
280 /* Now, say which argument to start evaluating from */
283 else if (op
== STRUCTOP_STRUCT
|| op
== STRUCTOP_PTR
)
285 /* Hair for method invocations */
288 nargs
= (int) exp
->elts
[pc
+ 1].longconst
+ 1;
289 /* First, evaluate the structure into arg2 */
291 tem2
= strlen (&exp
->elts
[pc2
+ 1].string
);
292 *pos
+= 2 + (tem2
+ sizeof (union exp_element
)) / sizeof (union exp_element
);
293 if (noside
== EVAL_SKIP
)
296 if (op
== STRUCTOP_STRUCT
)
298 arg2
= evaluate_subexp_for_address (exp
, pos
, noside
);
302 arg2
= evaluate_subexp (0, exp
, pos
, noside
);
304 /* Now, say which argument to start evaluating from */
309 nargs
= (int) exp
->elts
[pc
+ 1].longconst
;
312 argvec
= (value
*) alloca (sizeof (value
) * (nargs
+ 2));
313 for (; tem
<= nargs
; tem
++)
314 /* Ensure that array expressions are coerced into pointer objects. */
315 argvec
[tem
] = evaluate_subexp_with_coercion (exp
, pos
, noside
);
317 /* signal end of arglist */
320 if (op
== STRUCTOP_STRUCT
|| op
== STRUCTOP_PTR
)
324 value_struct_elt (arg2
, argvec
+1, &exp
->elts
[pc2
+ 1].string
,
325 op
== STRUCTOP_STRUCT
326 ? "structure" : "structure pointer");
328 else if (op
== STRUCTOP_MEMBER
|| op
== STRUCTOP_MPTR
)
334 if (noside
== EVAL_SKIP
)
336 if (noside
== EVAL_AVOID_SIDE_EFFECTS
)
338 /* If the return type doesn't look like a function type, call an
339 error. This can happen if somebody tries to turn a variable into
340 a function call. This is here because people often want to
341 call, eg, strcmp, which gdb doesn't know is a function. If
342 gdb isn't asked for it's opinion (ie. through "whatis"),
343 it won't offer it. */
346 TYPE_TARGET_TYPE (VALUE_TYPE (argvec
[0]));
349 return allocate_value (TYPE_TARGET_TYPE (VALUE_TYPE (argvec
[0])));
351 error ("Expression of type other than \"Function returning ...\" used as function");
353 return call_function (argvec
[0], nargs
, argvec
+ 1);
355 case STRUCTOP_STRUCT
:
356 tem
= strlen (&exp
->elts
[pc
+ 1].string
);
357 (*pos
) += 2 + (tem
+ sizeof (union exp_element
)) / sizeof (union exp_element
);
358 arg1
= evaluate_subexp (0, exp
, pos
, noside
);
359 if (noside
== EVAL_SKIP
)
361 return value_struct_elt (arg1
, 0, &exp
->elts
[pc
+ 1].string
,
365 tem
= strlen (&exp
->elts
[pc
+ 1].string
);
366 (*pos
) += 2 + (tem
+ sizeof (union exp_element
)) / sizeof (union exp_element
);
367 arg1
= evaluate_subexp (0, exp
, pos
, noside
);
368 if (noside
== EVAL_SKIP
)
370 return value_struct_elt (arg1
, 0, &exp
->elts
[pc
+ 1].string
,
371 "structure pointer");
373 case STRUCTOP_MEMBER
:
374 arg1
= evaluate_subexp_for_address (exp
, pos
, noside
);
375 arg2
= evaluate_subexp (0, exp
, pos
, noside
);
376 if (noside
== EVAL_SKIP
)
378 /* Now, convert these values to an address. */
379 arg3
= value_from_long (builtin_type_long
,
380 value_as_long (arg1
) + value_as_long (arg2
));
381 VALUE_TYPE (arg3
) = lookup_pointer_type (TYPE_TARGET_TYPE (VALUE_TYPE (arg2
)));
382 return value_ind (arg3
);
385 arg1
= evaluate_subexp (0, exp
, pos
, noside
);
386 arg2
= evaluate_subexp (0, exp
, pos
, noside
);
387 if (noside
== EVAL_SKIP
)
389 /* Now, convert these values to an address. */
390 arg3
= value_from_long (builtin_type_long
,
391 value_as_long (arg1
) + value_as_long (arg2
));
392 VALUE_TYPE (arg3
) = lookup_pointer_type (TYPE_TARGET_TYPE (VALUE_TYPE (arg2
)));
393 return value_ind (arg3
);
396 arg1
= evaluate_subexp (0, exp
, pos
, noside
);
397 arg2
= evaluate_subexp (VALUE_TYPE (arg1
), exp
, pos
, noside
);
398 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
400 if (binop_user_defined_p (op
, arg1
, arg2
))
401 return value_x_binop (arg1
, arg2
, op
, 0);
403 return value_assign (arg1
, arg2
);
405 case BINOP_ASSIGN_MODIFY
:
407 arg1
= evaluate_subexp (0, exp
, pos
, noside
);
408 arg2
= evaluate_subexp (VALUE_TYPE (arg1
), exp
, pos
, noside
);
409 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
411 op
= exp
->elts
[pc
+ 1].opcode
;
412 if (binop_user_defined_p (op
, arg1
, arg2
))
413 return value_x_binop (arg1
, arg2
, BINOP_ASSIGN_MODIFY
, op
);
414 else if (op
== BINOP_ADD
)
415 arg2
= value_add (arg1
, arg2
);
416 else if (op
== BINOP_SUB
)
417 arg2
= value_sub (arg1
, arg2
);
419 arg2
= value_binop (arg1
, arg2
, op
);
420 return value_assign (arg1
, arg2
);
423 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
424 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
425 if (noside
== EVAL_SKIP
)
427 if (binop_user_defined_p (op
, arg1
, arg2
))
428 return value_x_binop (arg1
, arg2
, op
, 0);
430 return value_add (arg1
, arg2
);
433 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
434 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
435 if (noside
== EVAL_SKIP
)
437 if (binop_user_defined_p (op
, arg1
, arg2
))
438 return value_x_binop (arg1
, arg2
, op
, 0);
440 return value_sub (arg1
, arg2
);
450 arg1
= evaluate_subexp (0, exp
, pos
, noside
);
451 arg2
= evaluate_subexp (0, exp
, pos
, noside
);
452 if (noside
== EVAL_SKIP
)
454 if (binop_user_defined_p (op
, arg1
, arg2
))
455 return value_x_binop (arg1
, arg2
, op
, 0);
457 return value_binop (arg1
, arg2
, op
);
459 case BINOP_SUBSCRIPT
:
460 arg1
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
461 arg2
= evaluate_subexp_with_coercion (exp
, pos
, noside
);
462 if (noside
== EVAL_SKIP
)
464 if (binop_user_defined_p (op
, arg1
, arg2
))
465 return value_x_binop (arg1
, arg2
, op
, 0);
467 return value_subscript (arg1
, arg2
, op
);
470 arg1
= evaluate_subexp (0, exp
, pos
, noside
);
471 if (noside
== EVAL_SKIP
)
473 arg2
= evaluate_subexp (0, exp
, pos
, noside
);
478 arg2
= evaluate_subexp (0, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
481 if (binop_user_defined_p (op
, arg1
, arg2
))
483 arg2
= evaluate_subexp (0, exp
, pos
, noside
);
484 return value_x_binop (arg1
, arg2
, op
, 0);
488 tem
= value_zerop (arg1
);
489 arg2
= evaluate_subexp (0, exp
, pos
,
490 (tem
? EVAL_SKIP
: noside
));
491 return value_from_long (builtin_type_int
,
492 (LONGEST
) (!tem
&& !value_zerop (arg2
)));
496 arg1
= evaluate_subexp (0, exp
, pos
, noside
);
497 if (noside
== EVAL_SKIP
)
499 arg2
= evaluate_subexp (0, exp
, pos
, noside
);
504 arg2
= evaluate_subexp (0, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
507 if (binop_user_defined_p (op
, arg1
, arg2
))
509 arg2
= evaluate_subexp (0, exp
, pos
, noside
);
510 return value_x_binop (arg1
, arg2
, op
, 0);
514 tem
= value_zerop (arg1
);
515 arg2
= evaluate_subexp (0, exp
, pos
,
516 (!tem
? EVAL_SKIP
: noside
));
517 return value_from_long (builtin_type_int
,
518 (LONGEST
) (!tem
|| !value_zerop (arg2
)));
522 arg1
= evaluate_subexp (0, exp
, pos
, noside
);
523 arg2
= evaluate_subexp (VALUE_TYPE (arg1
), exp
, pos
, noside
);
524 if (noside
== EVAL_SKIP
)
526 if (binop_user_defined_p (op
, arg1
, arg2
))
528 return value_x_binop (arg1
, arg2
, op
, 0);
532 tem
= value_equal (arg1
, arg2
);
533 return value_from_long (builtin_type_int
, (LONGEST
) tem
);
537 arg1
= evaluate_subexp (0, exp
, pos
, noside
);
538 arg2
= evaluate_subexp (VALUE_TYPE (arg1
), exp
, pos
, noside
);
539 if (noside
== EVAL_SKIP
)
541 if (binop_user_defined_p (op
, arg1
, arg2
))
543 return value_x_binop (arg1
, arg2
, op
, 0);
547 tem
= value_equal (arg1
, arg2
);
548 return value_from_long (builtin_type_int
, (LONGEST
) ! tem
);
552 arg1
= evaluate_subexp (0, exp
, pos
, noside
);
553 arg2
= evaluate_subexp (VALUE_TYPE (arg1
), exp
, pos
, noside
);
554 if (noside
== EVAL_SKIP
)
556 if (binop_user_defined_p (op
, arg1
, arg2
))
558 return value_x_binop (arg1
, arg2
, op
, 0);
562 tem
= value_less (arg1
, arg2
);
563 return value_from_long (builtin_type_int
, (LONGEST
) tem
);
567 arg1
= evaluate_subexp (0, exp
, pos
, noside
);
568 arg2
= evaluate_subexp (VALUE_TYPE (arg1
), exp
, pos
, noside
);
569 if (noside
== EVAL_SKIP
)
571 if (binop_user_defined_p (op
, arg1
, arg2
))
573 return value_x_binop (arg1
, arg2
, op
, 0);
577 tem
= value_less (arg2
, arg1
);
578 return value_from_long (builtin_type_int
, (LONGEST
) tem
);
582 arg1
= evaluate_subexp (0, exp
, pos
, noside
);
583 arg2
= evaluate_subexp (VALUE_TYPE (arg1
), exp
, pos
, noside
);
584 if (noside
== EVAL_SKIP
)
586 if (binop_user_defined_p (op
, arg1
, arg2
))
588 return value_x_binop (arg1
, arg2
, op
, 0);
592 tem
= value_less (arg1
, arg2
);
593 return value_from_long (builtin_type_int
, (LONGEST
) ! tem
);
597 arg1
= evaluate_subexp (0, exp
, pos
, noside
);
598 arg2
= evaluate_subexp (VALUE_TYPE (arg1
), exp
, pos
, noside
);
599 if (noside
== EVAL_SKIP
)
601 if (binop_user_defined_p (op
, arg1
, arg2
))
603 return value_x_binop (arg1
, arg2
, op
, 0);
607 tem
= value_less (arg2
, arg1
);
608 return value_from_long (builtin_type_int
, (LONGEST
) ! tem
);
612 arg1
= evaluate_subexp (0, exp
, pos
, noside
);
613 arg2
= evaluate_subexp (0, exp
, pos
, noside
);
614 if (noside
== EVAL_SKIP
)
616 return value_repeat (arg1
, (int) value_as_long (arg2
));
619 evaluate_subexp (0, exp
, pos
, noside
);
620 return evaluate_subexp (0, exp
, pos
, noside
);
623 arg1
= evaluate_subexp (0, exp
, pos
, noside
);
624 if (noside
== EVAL_SKIP
)
626 if (unop_user_defined_p (op
, arg1
))
627 return value_x_unop (arg1
, op
, 0);
629 return value_neg (arg1
);
632 arg1
= evaluate_subexp (0, exp
, pos
, noside
);
633 if (noside
== EVAL_SKIP
)
635 if (unop_user_defined_p (op
, arg1
))
636 return value_x_unop (arg1
, op
, 0);
638 return value_lognot (arg1
);
641 arg1
= evaluate_subexp (0, exp
, pos
, noside
);
642 if (noside
== EVAL_SKIP
)
644 if (unop_user_defined_p (op
, arg1
))
645 return value_x_unop (arg1
, op
, 0);
647 return value_from_long (builtin_type_int
,
648 (LONGEST
) value_zerop (arg1
));
651 if (expect_type
&& TYPE_CODE (expect_type
) == TYPE_CODE_PTR
)
652 expect_type
= TYPE_TARGET_TYPE (expect_type
);
653 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
654 if (noside
== EVAL_SKIP
)
656 return value_ind (arg1
);
659 /* C++: check for and handle pointer to members. */
661 op
= exp
->elts
[*pos
].opcode
;
663 if (noside
== EVAL_SKIP
)
667 char *name
= &exp
->elts
[pc
+3].string
;
668 int tem
= strlen (name
);
669 (*pos
) += 2 + (tem
+ sizeof (union exp_element
)) / sizeof (union exp_element
);
672 evaluate_subexp (expect_type
, exp
, pos
, EVAL_SKIP
);
678 char *name
= &exp
->elts
[pc
+3].string
;
679 int tem
= strlen (name
);
680 struct type
*domain
= exp
->elts
[pc
+2].type
;
681 (*pos
) += 2 + (tem
+ sizeof (union exp_element
)) / sizeof (union exp_element
);
682 arg1
= value_struct_elt_for_address (domain
, expect_type
, name
);
685 error ("no field `%s' in structure", name
);
688 return evaluate_subexp_for_address (exp
, pos
, noside
);
691 if (noside
== EVAL_SKIP
)
693 evaluate_subexp (0, exp
, pos
, EVAL_SKIP
);
696 return evaluate_subexp_for_sizeof (exp
, pos
);
700 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
701 if (noside
== EVAL_SKIP
)
703 return value_cast (exp
->elts
[pc
+ 1].type
, arg1
);
707 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
708 if (noside
== EVAL_SKIP
)
710 return value_at (exp
->elts
[pc
+ 1].type
,
711 (CORE_ADDR
) value_as_long (arg1
));
713 case UNOP_PREINCREMENT
:
714 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
715 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
717 else if (unop_user_defined_p (op
, arg1
))
719 return value_x_unop (arg1
, op
, 0);
723 arg2
= value_add (arg1
, value_from_long (builtin_type_char
,
725 return value_assign (arg1
, arg2
);
728 case UNOP_PREDECREMENT
:
729 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
730 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
732 else if (unop_user_defined_p (op
, arg1
))
734 return value_x_unop (arg1
, op
, 0);
738 arg2
= value_sub (arg1
, value_from_long (builtin_type_char
,
740 return value_assign (arg1
, arg2
);
743 case UNOP_POSTINCREMENT
:
744 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
745 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
747 else if (unop_user_defined_p (op
, arg1
))
749 return value_x_unop (arg1
, op
, 0);
753 arg2
= value_add (arg1
, value_from_long (builtin_type_char
,
755 value_assign (arg1
, arg2
);
759 case UNOP_POSTDECREMENT
:
760 arg1
= evaluate_subexp (expect_type
, exp
, pos
, noside
);
761 if (noside
== EVAL_SKIP
|| noside
== EVAL_AVOID_SIDE_EFFECTS
)
763 else if (unop_user_defined_p (op
, arg1
))
765 return value_x_unop (arg1
, op
, 0);
769 arg2
= value_sub (arg1
, value_from_long (builtin_type_char
,
771 value_assign (arg1
, arg2
);
777 return value_of_this (1);
780 error ("internal error: I do not know how to evaluate what you gave me");
784 return value_from_long (builtin_type_long
, (LONGEST
) 1);
787 /* Evaluate a subexpression of EXP, at index *POS,
788 and return the address of that subexpression.
789 Advance *POS over the subexpression.
790 If the subexpression isn't an lvalue, get an error.
791 NOSIDE may be EVAL_AVOID_SIDE_EFFECTS;
792 then only the type of the result need be correct. */
795 evaluate_subexp_for_address (exp
, pos
, noside
)
796 register struct expression
*exp
;
804 op
= exp
->elts
[pc
].opcode
;
810 return evaluate_subexp (0, exp
, pos
, noside
);
814 return value_cast (lookup_pointer_type (exp
->elts
[pc
+ 1].type
),
815 evaluate_subexp (0, exp
, pos
, noside
));
819 return locate_var_value (exp
->elts
[pc
+ 1].symbol
, (CORE_ADDR
) 0);
822 return value_addr (evaluate_subexp (0, exp
, pos
, noside
));
826 /* Evaluate like `evaluate_subexp' except coercing arrays to pointers.
827 When used in contexts where arrays will be coerced anyway,
828 this is equivalent to `evaluate_subexp'
829 but much faster because it avoids actually fetching array contents. */
832 evaluate_subexp_with_coercion (exp
, pos
, noside
)
833 register struct expression
*exp
;
837 register enum exp_opcode op
;
842 op
= exp
->elts
[pc
].opcode
;
847 if (TYPE_CODE (SYMBOL_TYPE (exp
->elts
[pc
+ 1].symbol
)) == TYPE_CODE_ARRAY
)
850 val
= locate_var_value (exp
->elts
[pc
+ 1].symbol
, (CORE_ADDR
) 0);
851 return value_cast (lookup_pointer_type (TYPE_TARGET_TYPE (SYMBOL_TYPE (exp
->elts
[pc
+ 1].symbol
))),
856 return evaluate_subexp (0, exp
, pos
, noside
);
859 /* Evaluate a subexpression of EXP, at index *POS,
860 and return a value for the size of that subexpression.
861 Advance *POS over the subexpression. */
864 evaluate_subexp_for_sizeof (exp
, pos
)
865 register struct expression
*exp
;
873 op
= exp
->elts
[pc
].opcode
;
877 /* This case is handled specially
878 so that we avoid creating a value for the result type.
879 If the result type is very big, it's desirable not to
880 create a value unnecessarily. */
883 val
= evaluate_subexp (0, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
884 return value_from_long (builtin_type_int
, (LONGEST
)
885 TYPE_LENGTH (TYPE_TARGET_TYPE (VALUE_TYPE (val
))));
889 return value_from_long (builtin_type_int
,
890 (LONGEST
) TYPE_LENGTH (exp
->elts
[pc
+ 1].type
));
894 return value_from_long (builtin_type_int
,
895 (LONGEST
) TYPE_LENGTH (SYMBOL_TYPE (exp
->elts
[pc
+ 1].symbol
)));
898 val
= evaluate_subexp (0, exp
, pos
, EVAL_AVOID_SIDE_EFFECTS
);
899 return value_from_long (builtin_type_int
,
900 (LONGEST
) TYPE_LENGTH (VALUE_TYPE (val
)));
This page took 0.04832 seconds and 4 git commands to generate.