gdb/eval.c

   1 /* Evaluate expressions for GDB.
   2    Copyright (C) 1986, 1987 Free Software Foundation, Inc.
   3
   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.
   9
  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.
  16
  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!
  19 */
  20
  21 #include "defs.h"
  22 #include "param.h"
  23 #include "symtab.h"
  24 #include "value.h"
  25 #include "expression.h"
  26
  27 \f
  28 /* Parse the string EXP as a C expression, evaluate it,
  29    and return the result as a number.  */
  30
  31 CORE_ADDR
  32 parse_and_eval_address (exp)
  33      char *exp;
  34 {
  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);
  39
  40   addr = (CORE_ADDR) value_as_long (evaluate_expression (expr));
  41   do_cleanups (old_chain);
  42   return addr;
  43 }
  44
  45 /* Like parse_and_eval_address but takes a pointer to a char * variable
  46    and advanced that variable across the characters parsed.  */
  47
  48 CORE_ADDR
  49 parse_and_eval_address_1 (expptr)
  50      char **expptr;
  51 {
  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);
  56
  57   addr = value_as_long (evaluate_expression (expr));
  58   do_cleanups (old_chain);
  59   return addr;
  60 }
  61
  62 value
  63 parse_and_eval (exp)
  64      char *exp;
  65 {
  66   struct expression *expr = parse_c_expression (exp);
  67   register value val;
  68   register struct cleanup *old_chain
  69     = make_cleanup (free_current_contents, &expr);
  70
  71   val = evaluate_expression (expr);
  72   do_cleanups (old_chain);
  73   return val;
  74 }
  75
  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.  */
  79
  80 value
  81 parse_to_comma_and_eval (expp)
  82      char **expp;
  83 {
  84   struct expression *expr = parse_c_1 (expp, 0, 1);
  85   register value val;
  86   register struct cleanup *old_chain
  87     = make_cleanup (free_current_contents, &expr);
  88
  89   val = evaluate_expression (expr);
  90   do_cleanups (old_chain);
  91   return val;
  92 }
  93 \f
  94 /* Evaluate an expression in internal prefix form
  95    such as is constructed by expread.y.
  96
  97    See expression.h for info on the format of an expression.  */
  98
  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 ();
 103
 104 /* Values of NOSIDE argument to eval_subexp.  */
 105 enum noside
 106 { EVAL_NORMAL,
 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
 110                                    is returned.  */
 111 };
 112
 113 value
 114 evaluate_expression (exp)
 115      struct expression *exp;
 116 {
 117   int pc = 0;
 118   return evaluate_subexp (0, exp, &pc, EVAL_NORMAL);
 119 }
 120
 121 /* Evaluate an expression, avoiding all memory references
 122    and getting a value whose type alone is correct.  */
 123
 124 value
 125 evaluate_type (exp)
 126      struct expression *exp;
 127 {
 128   int pc = 0;
 129   return evaluate_subexp (0, exp, &pc, EVAL_AVOID_SIDE_EFFECTS);
 130 }
 131
 132 static value
 133 evaluate_subexp (expect_type, exp, pos, noside)
 134      struct type *expect_type;
 135      register struct expression *exp;
 136      register int *pos;
 137      enum noside noside;
 138 {
 139   enum exp_opcode op;
 140   int tem;
 141   register int pc, pc2, oldpos;
 142   register value arg1, arg2, arg3;
 143   int nargs;
 144   value *argvec;
 145
 146   pc = (*pos)++;
 147   op = exp->elts[pc].opcode;
 148
 149   switch (op)
 150     {
 151     case OP_SCOPE:
 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);
 156
 157     case OP_LONG:
 158       (*pos) += 3;
 159       return value_from_long (exp->elts[pc + 1].type,
 160                               exp->elts[pc + 2].longconst);
 161
 162     case OP_DOUBLE:
 163       (*pos) += 3;
 164       return value_from_double (exp->elts[pc + 1].type,
 165                                 exp->elts[pc + 2].doubleconst);
 166
 167     case OP_VAR_VALUE:
 168       (*pos) += 2;
 169       if (noside == EVAL_SKIP)
 170         goto nosideret;
 171       return value_of_variable (exp->elts[pc + 1].symbol);
 172
 173     case OP_LAST:
 174       (*pos) += 2;
 175       return access_value_history ((int) exp->elts[pc + 1].longconst);
 176
 177     case OP_REGISTER:
 178       (*pos) += 2;
 179       return value_of_register ((int) exp->elts[pc + 1].longconst);
 180
 181     case OP_INTERNALVAR:
 182       (*pos) += 2;
 183       return value_of_internalvar (exp->elts[pc + 1].internalvar);
 184
 185     case OP_STRING:
 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)
 189         goto nosideret;
 190       return value_string (&exp->elts[pc + 1].string, tem);
 191
 192     case TERNOP_COND:
 193       /* Skip third and second args to evaluate the first one.  */
 194       arg1 = evaluate_subexp (0, exp, pos, noside);
 195       if (value_zerop (arg1))
 196         {
 197           evaluate_subexp (0, exp, pos, EVAL_SKIP);
 198           return evaluate_subexp (0, exp, pos, noside);
 199         }
 200       else
 201         {
 202           arg2 = evaluate_subexp (0, exp, pos, noside);
 203           evaluate_subexp (0, exp, pos, EVAL_SKIP);
 204           return arg2;
 205         }
 206
 207     case OP_FUNCALL:
 208       (*pos) += 2;
 209       op = exp->elts[*pos].opcode;
 210       if (op == STRUCTOP_MEMBER || op == STRUCTOP_MPTR)
 211         {
 212           int fnptr;
 213           int tem2;
 214
 215           nargs = (int) exp->elts[pc + 1].longconst + 1;
 216           /* First, evaluate the structure into arg2 */
 217           pc2 = (*pos)++;
 218
 219           if (noside == EVAL_SKIP)
 220             goto nosideret;
 221
 222           if (op == STRUCTOP_MEMBER)
 223             {
 224               arg2 = evaluate_subexp_for_address (exp, pos, noside);
 225             }
 226           else
 227             {
 228               arg2 = evaluate_subexp (0, exp, pos, noside);
 229             }
 230
 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
 235              directly.  */
 236
 237           arg1 = evaluate_subexp (0, exp, pos, noside);
 238
 239           fnptr = (int) value_as_long (arg1);
 240           if (fnptr < 128)
 241             {
 242               struct type *basetype;
 243               int i, j;
 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--)
 247                 {
 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)
 253                         {
 254                           value vtbl;
 255                           value base = value_ind (arg2);
 256                           struct type *fntype = lookup_pointer_type (TYPE_FN_FIELD_TYPE (f, j));
 257
 258                           if (TYPE_VPTR_FIELDNO (basetype) < 0)
 259                             TYPE_VPTR_FIELDNO (basetype)
 260                               = fill_in_vptr_fieldno (basetype);
 261
 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;
 268                           goto got_it;
 269                         }
 270                 }
 271               if (i < 0)
 272                 error ("virtual function at index %d not found", fnptr);
 273             }
 274           else
 275             {
 276               VALUE_TYPE (arg1) = lookup_pointer_type (TYPE_TARGET_TYPE (VALUE_TYPE (arg1)));
 277             }
 278         got_it:
 279
 280           /* Now, say which argument to start evaluating from */
 281           tem = 2;
 282         }
 283       else if (op == STRUCTOP_STRUCT || op == STRUCTOP_PTR)
 284         {
 285           /* Hair for method invocations */
 286           int tem2;
 287
 288           nargs = (int) exp->elts[pc + 1].longconst + 1;
 289           /* First, evaluate the structure into arg2 */
 290           pc2 = (*pos)++;
 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)
 294             goto nosideret;
 295
 296           if (op == STRUCTOP_STRUCT)
 297             {
 298               arg2 = evaluate_subexp_for_address (exp, pos, noside);
 299             }
 300           else
 301             {
 302               arg2 = evaluate_subexp (0, exp, pos, noside);
 303             }
 304           /* Now, say which argument to start evaluating from */
 305           tem = 2;
 306         }
 307       else
 308         {
 309           nargs = (int) exp->elts[pc + 1].longconst;
 310           tem = 0;
 311         }
 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);
 316
 317       /* signal end of arglist */
 318       argvec[tem] = 0;
 319
 320       if (op == STRUCTOP_STRUCT || op == STRUCTOP_PTR)
 321         {
 322           argvec[1] = arg2;
 323           argvec[0] =
 324             value_struct_elt (arg2, argvec+1, &exp->elts[pc2 + 1].string,
 325                               op == STRUCTOP_STRUCT
 326                               ? "structure" : "structure pointer");
 327         }
 328       else if (op == STRUCTOP_MEMBER || op == STRUCTOP_MPTR)
 329         {
 330           argvec[1] = arg2;
 331           argvec[0] = arg1;
 332         }
 333
 334       if (noside == EVAL_SKIP)
 335         goto nosideret;
 336       if (noside == EVAL_AVOID_SIDE_EFFECTS)
 337         {
 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. */
 344
 345           struct type *ftype =
 346             TYPE_TARGET_TYPE (VALUE_TYPE (argvec[0]));
 347
 348           if (ftype)
 349             return allocate_value (TYPE_TARGET_TYPE (VALUE_TYPE (argvec[0])));
 350           else
 351             error ("Expression of type other than \"Function returning ...\" used as function");
 352         }
 353       return call_function (argvec[0], nargs, argvec + 1);
 354
 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)
 360         goto nosideret;
 361       return value_struct_elt (arg1, 0, &exp->elts[pc + 1].string,
 362                                "structure");
 363
 364     case STRUCTOP_PTR:
 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)
 369         goto nosideret;
 370       return value_struct_elt (arg1, 0, &exp->elts[pc + 1].string,
 371                                "structure pointer");
 372
 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)
 377         goto nosideret;
 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);
 383
 384     case STRUCTOP_MPTR:
 385       arg1 = evaluate_subexp (0, exp, pos, noside);
 386       arg2 = evaluate_subexp (0, exp, pos, noside);
 387       if (noside == EVAL_SKIP)
 388         goto nosideret;
 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);
 394
 395     case BINOP_ASSIGN:
 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)
 399         return arg1;
 400       if (binop_user_defined_p (op, arg1, arg2))
 401         return value_x_binop (arg1, arg2, op, 0);
 402       else
 403         return value_assign (arg1, arg2);
 404
 405     case BINOP_ASSIGN_MODIFY:
 406       (*pos) += 2;
 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)
 410         return arg1;
 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);
 418       else
 419         arg2 = value_binop (arg1, arg2, op);
 420       return value_assign (arg1, arg2);
 421
 422     case BINOP_ADD:
 423       arg1 = evaluate_subexp_with_coercion (exp, pos, noside);
 424       arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
 425       if (noside == EVAL_SKIP)
 426         goto nosideret;
 427       if (binop_user_defined_p (op, arg1, arg2))
 428         return value_x_binop (arg1, arg2, op, 0);
 429       else
 430         return value_add (arg1, arg2);
 431
 432     case BINOP_SUB:
 433       arg1 = evaluate_subexp_with_coercion (exp, pos, noside);
 434       arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
 435       if (noside == EVAL_SKIP)
 436         goto nosideret;
 437       if (binop_user_defined_p (op, arg1, arg2))
 438         return value_x_binop (arg1, arg2, op, 0);
 439       else
 440         return value_sub (arg1, arg2);
 441
 442     case BINOP_MUL:
 443     case BINOP_DIV:
 444     case BINOP_REM:
 445     case BINOP_LSH:
 446     case BINOP_RSH:
 447     case BINOP_LOGAND:
 448     case BINOP_LOGIOR:
 449     case BINOP_LOGXOR:
 450       arg1 = evaluate_subexp (0, exp, pos, noside);
 451       arg2 = evaluate_subexp (0, exp, pos, noside);
 452       if (noside == EVAL_SKIP)
 453         goto nosideret;
 454       if (binop_user_defined_p (op, arg1, arg2))
 455         return value_x_binop (arg1, arg2, op, 0);
 456       else
 457         return value_binop (arg1, arg2, op);
 458
 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)
 463         goto nosideret;
 464       if (binop_user_defined_p (op, arg1, arg2))
 465         return value_x_binop (arg1, arg2, op, 0);
 466       else
 467         return value_subscript (arg1, arg2, op);
 468
 469     case BINOP_AND:
 470       arg1 = evaluate_subexp (0, exp, pos, noside);
 471       if (noside == EVAL_SKIP)
 472         {
 473           arg2 = evaluate_subexp (0, exp, pos, noside);
 474           goto nosideret;
 475         }
 476
 477       oldpos = *pos;
 478       arg2 = evaluate_subexp (0, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
 479       *pos = oldpos;
 480
 481       if (binop_user_defined_p (op, arg1, arg2))
 482         {
 483           arg2 = evaluate_subexp (0, exp, pos, noside);
 484           return value_x_binop (arg1, arg2, op, 0);
 485         }
 486       else
 487         {
 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)));
 493         }
 494
 495     case BINOP_OR:
 496       arg1 = evaluate_subexp (0, exp, pos, noside);
 497       if (noside == EVAL_SKIP)
 498         {
 499           arg2 = evaluate_subexp (0, exp, pos, noside);
 500           goto nosideret;
 501         }
 502
 503       oldpos = *pos;
 504       arg2 = evaluate_subexp (0, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
 505       *pos = oldpos;
 506
 507       if (binop_user_defined_p (op, arg1, arg2))
 508         {
 509           arg2 = evaluate_subexp (0, exp, pos, noside);
 510           return value_x_binop (arg1, arg2, op, 0);
 511         }
 512       else
 513         {
 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)));
 519         }
 520
 521     case BINOP_EQUAL:
 522       arg1 = evaluate_subexp (0, exp, pos, noside);
 523       arg2 = evaluate_subexp (VALUE_TYPE (arg1), exp, pos, noside);
 524       if (noside == EVAL_SKIP)
 525         goto nosideret;
 526       if (binop_user_defined_p (op, arg1, arg2))
 527         {
 528           return value_x_binop (arg1, arg2, op, 0);
 529         }
 530       else
 531         {
 532           tem = value_equal (arg1, arg2);
 533           return value_from_long (builtin_type_int, (LONGEST) tem);
 534         }
 535
 536     case BINOP_NOTEQUAL:
 537       arg1 = evaluate_subexp (0, exp, pos, noside);
 538       arg2 = evaluate_subexp (VALUE_TYPE (arg1), exp, pos, noside);
 539       if (noside == EVAL_SKIP)
 540         goto nosideret;
 541       if (binop_user_defined_p (op, arg1, arg2))
 542         {
 543           return value_x_binop (arg1, arg2, op, 0);
 544         }
 545       else
 546         {
 547           tem = value_equal (arg1, arg2);
 548           return value_from_long (builtin_type_int, (LONGEST) ! tem);
 549         }
 550
 551     case BINOP_LESS:
 552       arg1 = evaluate_subexp (0, exp, pos, noside);
 553       arg2 = evaluate_subexp (VALUE_TYPE (arg1), exp, pos, noside);
 554       if (noside == EVAL_SKIP)
 555         goto nosideret;
 556       if (binop_user_defined_p (op, arg1, arg2))
 557         {
 558           return value_x_binop (arg1, arg2, op, 0);
 559         }
 560       else
 561         {
 562           tem = value_less (arg1, arg2);
 563           return value_from_long (builtin_type_int, (LONGEST) tem);
 564         }
 565
 566     case BINOP_GTR:
 567       arg1 = evaluate_subexp (0, exp, pos, noside);
 568       arg2 = evaluate_subexp (VALUE_TYPE (arg1), exp, pos, noside);
 569       if (noside == EVAL_SKIP)
 570         goto nosideret;
 571       if (binop_user_defined_p (op, arg1, arg2))
 572         {
 573           return value_x_binop (arg1, arg2, op, 0);
 574         }
 575       else
 576         {
 577           tem = value_less (arg2, arg1);
 578           return value_from_long (builtin_type_int, (LONGEST) tem);
 579         }
 580
 581     case BINOP_GEQ:
 582       arg1 = evaluate_subexp (0, exp, pos, noside);
 583       arg2 = evaluate_subexp (VALUE_TYPE (arg1), exp, pos, noside);
 584       if (noside == EVAL_SKIP)
 585         goto nosideret;
 586       if (binop_user_defined_p (op, arg1, arg2))
 587         {
 588           return value_x_binop (arg1, arg2, op, 0);
 589         }
 590       else
 591         {
 592           tem = value_less (arg1, arg2);
 593           return value_from_long (builtin_type_int, (LONGEST) ! tem);
 594         }
 595
 596     case BINOP_LEQ:
 597       arg1 = evaluate_subexp (0, exp, pos, noside);
 598       arg2 = evaluate_subexp (VALUE_TYPE (arg1), exp, pos, noside);
 599       if (noside == EVAL_SKIP)
 600         goto nosideret;
 601       if (binop_user_defined_p (op, arg1, arg2))
 602         {
 603           return value_x_binop (arg1, arg2, op, 0);
 604         }
 605       else
 606         {
 607           tem = value_less (arg2, arg1);
 608           return value_from_long (builtin_type_int, (LONGEST) ! tem);
 609         }
 610
 611     case BINOP_REPEAT:
 612       arg1 = evaluate_subexp (0, exp, pos, noside);
 613       arg2 = evaluate_subexp (0, exp, pos, noside);
 614       if (noside == EVAL_SKIP)
 615         goto nosideret;
 616       return value_repeat (arg1, (int) value_as_long (arg2));
 617
 618     case BINOP_COMMA:
 619       evaluate_subexp (0, exp, pos, noside);
 620       return evaluate_subexp (0, exp, pos, noside);
 621
 622     case UNOP_NEG:
 623       arg1 = evaluate_subexp (0, exp, pos, noside);
 624       if (noside == EVAL_SKIP)
 625         goto nosideret;
 626       if (unop_user_defined_p (op, arg1))
 627         return value_x_unop (arg1, op, 0);
 628       else
 629         return value_neg (arg1);
 630
 631     case UNOP_LOGNOT:
 632       arg1 = evaluate_subexp (0, exp, pos, noside);
 633       if (noside == EVAL_SKIP)
 634         goto nosideret;
 635       if (unop_user_defined_p (op, arg1))
 636         return value_x_unop (arg1, op, 0);
 637       else
 638         return value_lognot (arg1);
 639
 640     case UNOP_ZEROP:
 641       arg1 = evaluate_subexp (0, exp, pos, noside);
 642       if (noside == EVAL_SKIP)
 643         goto nosideret;
 644       if (unop_user_defined_p (op, arg1))
 645         return value_x_unop (arg1, op, 0);
 646       else
 647         return value_from_long (builtin_type_int,
 648                                 (LONGEST) value_zerop (arg1));
 649
 650     case UNOP_IND:
 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)
 655         goto nosideret;
 656       return value_ind (arg1);
 657
 658     case UNOP_ADDR:
 659       /* C++: check for and handle pointer to members.  */
 660
 661       op = exp->elts[*pos].opcode;
 662
 663       if (noside == EVAL_SKIP)
 664         {
 665           if (op == OP_SCOPE)
 666             {
 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);
 670             }
 671           else
 672             evaluate_subexp (expect_type, exp, pos, EVAL_SKIP);
 673           goto nosideret;
 674         }
 675
 676       if (op == OP_SCOPE)
 677         {
 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);
 683           if (arg1)
 684             return arg1;
 685           error ("no field `%s' in structure", name);
 686         }
 687       else
 688         return evaluate_subexp_for_address (exp, pos, noside);
 689
 690     case UNOP_SIZEOF:
 691       if (noside == EVAL_SKIP)
 692         {
 693           evaluate_subexp (0, exp, pos, EVAL_SKIP);
 694           goto nosideret;
 695         }
 696       return evaluate_subexp_for_sizeof (exp, pos);
 697
 698     case UNOP_CAST:
 699       (*pos) += 2;
 700       arg1 = evaluate_subexp (expect_type, exp, pos, noside);
 701       if (noside == EVAL_SKIP)
 702         goto nosideret;
 703       return value_cast (exp->elts[pc + 1].type, arg1);
 704
 705     case UNOP_MEMVAL:
 706       (*pos) += 2;
 707       arg1 = evaluate_subexp (expect_type, exp, pos, noside);
 708       if (noside == EVAL_SKIP)
 709         goto nosideret;
 710       return value_at (exp->elts[pc + 1].type,
 711                        (CORE_ADDR) value_as_long (arg1));
 712
 713     case UNOP_PREINCREMENT:
 714       arg1 = evaluate_subexp (expect_type, exp, pos, noside);
 715       if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
 716         return arg1;
 717       else if (unop_user_defined_p (op, arg1))
 718         {
 719           return value_x_unop (arg1, op, 0);
 720         }
 721       else
 722         {
 723           arg2 = value_add (arg1, value_from_long (builtin_type_char,
 724                                                    (LONGEST) 1));
 725           return value_assign (arg1, arg2);
 726         }
 727
 728     case UNOP_PREDECREMENT:
 729       arg1 = evaluate_subexp (expect_type, exp, pos, noside);
 730       if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
 731         return arg1;
 732       else if (unop_user_defined_p (op, arg1))
 733         {
 734           return value_x_unop (arg1, op, 0);
 735         }
 736       else
 737         {
 738           arg2 = value_sub (arg1, value_from_long (builtin_type_char,
 739                                                    (LONGEST) 1));
 740           return value_assign (arg1, arg2);
 741         }
 742
 743     case UNOP_POSTINCREMENT:
 744       arg1 = evaluate_subexp (expect_type, exp, pos, noside);
 745       if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
 746         return arg1;
 747       else if (unop_user_defined_p (op, arg1))
 748         {
 749           return value_x_unop (arg1, op, 0);
 750         }
 751       else
 752         {
 753           arg2 = value_add (arg1, value_from_long (builtin_type_char,
 754                                                    (LONGEST) 1));
 755           value_assign (arg1, arg2);
 756           return arg1;
 757         }
 758
 759     case UNOP_POSTDECREMENT:
 760       arg1 = evaluate_subexp (expect_type, exp, pos, noside);
 761       if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
 762         return arg1;
 763       else if (unop_user_defined_p (op, arg1))
 764         {
 765           return value_x_unop (arg1, op, 0);
 766         }
 767       else
 768         {
 769           arg2 = value_sub (arg1, value_from_long (builtin_type_char,
 770                                                    (LONGEST) 1));
 771           value_assign (arg1, arg2);
 772           return arg1;
 773         }
 774
 775     case OP_THIS:
 776       (*pos) += 1;
 777       return value_of_this (1);
 778
 779     default:
 780       error ("internal error: I do not know how to evaluate what you gave me");
 781     }
 782
 783  nosideret:
 784   return value_from_long (builtin_type_long, (LONGEST) 1);
 785 }
 786 \f
 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.  */
 793
 794 static value
 795 evaluate_subexp_for_address (exp, pos, noside)
 796      register struct expression *exp;
 797      register int *pos;
 798      enum noside noside;
 799 {
 800   enum exp_opcode op;
 801   register int pc;
 802
 803   pc = (*pos);
 804   op = exp->elts[pc].opcode;
 805
 806   switch (op)
 807     {
 808     case UNOP_IND:
 809       (*pos)++;
 810       return evaluate_subexp (0, exp, pos, noside);
 811
 812     case UNOP_MEMVAL:
 813       (*pos) += 3;
 814       return value_cast (lookup_pointer_type (exp->elts[pc + 1].type),
 815                          evaluate_subexp (0, exp, pos, noside));
 816
 817     case OP_VAR_VALUE:
 818       (*pos) += 3;
 819       return locate_var_value (exp->elts[pc + 1].symbol, (CORE_ADDR) 0);
 820
 821     default:
 822       return value_addr (evaluate_subexp (0, exp, pos, noside));
 823     }
 824 }
 825
 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.  */
 830
 831 static value
 832 evaluate_subexp_with_coercion (exp, pos, noside)
 833      register struct expression *exp;
 834      register int *pos;
 835      enum noside noside;
 836 {
 837   register enum exp_opcode op;
 838   register int pc;
 839   register value val;
 840
 841   pc = (*pos);
 842   op = exp->elts[pc].opcode;
 843
 844   switch (op)
 845     {
 846     case OP_VAR_VALUE:
 847       if (TYPE_CODE (SYMBOL_TYPE (exp->elts[pc + 1].symbol)) == TYPE_CODE_ARRAY)
 848         {
 849           (*pos) += 3;
 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))),
 852                              val);
 853         }
 854     }
 855
 856   return evaluate_subexp (0, exp, pos, noside);
 857 }
 858
 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.  */
 862
 863 static value
 864 evaluate_subexp_for_sizeof (exp, pos)
 865      register struct expression *exp;
 866      register int *pos;
 867 {
 868   enum exp_opcode op;
 869   register int pc;
 870   value val;
 871
 872   pc = (*pos);
 873   op = exp->elts[pc].opcode;
 874
 875   switch (op)
 876     {
 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.  */
 881     case UNOP_IND:
 882       (*pos)++;
 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))));
 886
 887     case UNOP_MEMVAL:
 888       (*pos) += 3;
 889       return value_from_long (builtin_type_int,
 890                               (LONGEST) TYPE_LENGTH (exp->elts[pc + 1].type));
 891
 892     case OP_VAR_VALUE:
 893       (*pos) += 3;
 894       return value_from_long (builtin_type_int,
 895          (LONGEST) TYPE_LENGTH (SYMBOL_TYPE (exp->elts[pc + 1].symbol)));
 896
 897     default:
 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)));
 901     }
 902 }