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 "initialize.h"
  23 #include "symtab.h"
  24 #include "value.h"
  25 #include "expression.h"
  26
  27 START_FILE
  28 \f
  29 /* Parse the string EXP as a C expression, evaluate it,
  30    and return the result as a number.  */
  31
  32 CORE_ADDR
  33 parse_and_eval_address (exp)
  34      char *exp;
  35 {
  36   struct expression *expr = parse_c_expression (exp);
  37   register CORE_ADDR addr;
  38   register struct cleanup *old_chain
  39     = make_cleanup (free_current_contents, &expr);
  40
  41   addr = value_as_long (evaluate_expression (expr));
  42   do_cleanups (old_chain);
  43   return addr;
  44 }
  45
  46 /* Like parse_and_eval_address but takes a pointer to a char * variable
  47    and advanced that variable across the characters parsed.  */
  48
  49 CORE_ADDR
  50 parse_and_eval_address_1 (expptr)
  51      char **expptr;
  52 {
  53   struct expression *expr = parse_c_1 (expptr, 0, 0);
  54   register CORE_ADDR addr;
  55   register struct cleanup *old_chain
  56     = make_cleanup (free_current_contents, &expr);
  57
  58   addr = value_as_long (evaluate_expression (expr));
  59   do_cleanups (old_chain);
  60   return addr;
  61 }
  62
  63 value
  64 parse_and_eval (exp)
  65      char *exp;
  66 {
  67   struct expression *expr = parse_c_expression (exp);
  68   register value val;
  69   register struct cleanup *old_chain
  70     = make_cleanup (free_current_contents, &expr);
  71
  72   val = evaluate_expression (expr);
  73   do_cleanups (old_chain);
  74   return val;
  75 }
  76
  77 /* Parse up to a comma (or to a closeparen)
  78    in the string EXPP as an expression, evaluate it, and return the value.
  79    EXPP is advanced to point to the comma.  */
  80
  81 value
  82 parse_to_comma_and_eval (expp)
  83      char **expp;
  84 {
  85   struct expression *expr = parse_c_1 (expp, 0, 1);
  86   register value val;
  87   register struct cleanup *old_chain
  88     = make_cleanup (free_current_contents, &expr);
  89
  90   val = evaluate_expression (expr);
  91   do_cleanups (old_chain);
  92   return val;
  93 }
  94 \f
  95 /* Evaluate an expression in internal prefix form
  96    such as is constructed by expread.y.
  97
  98    See expression.h for info on the format of an expression.  */
  99
 100 static value evaluate_subexp ();
 101 static value evaluate_subexp_for_address ();
 102 static value evaluate_subexp_for_sizeof ();
 103 static value evaluate_subexp_with_coercion ();
 104
 105 /* Values of NOSIDE argument to eval_subexp.  */
 106 enum noside
 107 { EVAL_NORMAL,
 108   EVAL_SKIP,
 109   EVAL_AVOID_SIDE_EFFECTS,
 110 };
 111
 112 value
 113 evaluate_expression (exp)
 114      struct expression *exp;
 115 {
 116   int pc = 0;
 117   return evaluate_subexp (0, exp, &pc, EVAL_NORMAL);
 118 }
 119
 120 /* Evaluate an expression, avoiding all memory references
 121    and getting a value whose type alone is correct.  */
 122
 123 value
 124 evaluate_type (exp)
 125      struct expression *exp;
 126 {
 127   int pc = 0;
 128   return evaluate_subexp (0, exp, &pc, EVAL_AVOID_SIDE_EFFECTS);
 129 }
 130
 131 static value
 132 evaluate_subexp (expect_type, exp, pos, noside)
 133      struct type *expect_type;
 134      register struct expression *exp;
 135      register int *pos;
 136      enum noside noside;
 137 {
 138   enum exp_opcode op;
 139   int tem;
 140   register int pc, pc2, *oldpos;
 141   register value arg1, arg2, arg3;
 142   int nargs;
 143   value *argvec;
 144
 145   pc = (*pos)++;
 146   op = exp->elts[pc].opcode;
 147
 148   switch (op)
 149     {
 150     case OP_SCOPE:
 151       tem = strlen (&exp->elts[pc + 2].string);
 152       (*pos) += 3 + (tem + sizeof (union exp_element)) / sizeof (union exp_element);
 153       return value_static_field (exp->elts[pc + 1].type,
 154                                  &exp->elts[pc + 2].string, -1);
 155
 156     case OP_LONG:
 157       (*pos) += 3;
 158       return value_from_long (exp->elts[pc + 1].type,
 159                               exp->elts[pc + 2].longconst);
 160
 161     case OP_DOUBLE:
 162       (*pos) += 3;
 163       return value_from_double (exp->elts[pc + 1].type,
 164                                 exp->elts[pc + 2].doubleconst);
 165
 166     case OP_VAR_VALUE:
 167       (*pos) += 2;
 168       if (noside == EVAL_SKIP)
 169         goto nosideret;
 170       return value_of_variable (exp->elts[pc + 1].symbol);
 171
 172     case OP_LAST:
 173       (*pos) += 2;
 174       return access_value_history (exp->elts[pc + 1].longconst);
 175
 176     case OP_REGISTER:
 177       (*pos) += 2;
 178       return value_of_register (exp->elts[pc + 1].longconst);
 179
 180     case OP_INTERNALVAR:
 181       (*pos) += 2;
 182       return value_of_internalvar (exp->elts[pc + 1].internalvar);
 183
 184     case OP_FUNCALL:
 185       (*pos) += 2;
 186       op = exp->elts[*pos].opcode;
 187       if (op == STRUCTOP_MEMBER || op == STRUCTOP_MPTR)
 188         {
 189           int fnptr;
 190           int tem2;
 191
 192           nargs = exp->elts[pc + 1].longconst + 1;
 193           /* First, evaluate the structure into arg2 */
 194           pc2 = (*pos)++;
 195
 196           if (noside == EVAL_SKIP)
 197             goto nosideret;
 198
 199           if (op == STRUCTOP_MEMBER)
 200             {
 201               arg2 = evaluate_subexp_for_address (exp, pos, noside);
 202             }
 203           else
 204             {
 205               arg2 = evaluate_subexp (0, exp, pos, noside);
 206             }
 207
 208           /* If the function is a virtual function, then the
 209              aggregate value (providing the structure) plays
 210              its part by providing the vtable.  Otherwise,
 211              it is just along for the ride: call the function
 212              directly.  */
 213
 214           arg1 = evaluate_subexp (0, exp, pos, noside);
 215
 216           fnptr = value_as_long (arg1);
 217           if (fnptr < 128)
 218             {
 219               struct type *basetype;
 220               int i, j;
 221               basetype = TYPE_TARGET_TYPE (VALUE_TYPE (arg2));
 222               basetype = TYPE_VPTR_BASETYPE (basetype);
 223               for (i = TYPE_NFN_FIELDS (basetype) - 1; i >= 0; i--)
 224                 {
 225                   struct fn_field *f = TYPE_FN_FIELDLIST1 (basetype, i);
 226                   /* If one is virtual, then all are virtual.  */
 227                   if (TYPE_FN_FIELD_VIRTUAL_P (f, 0))
 228                     for (j = TYPE_FN_FIELDLIST_LENGTH (basetype, i) - 1; j >= 0; --j)
 229                       if (TYPE_FN_FIELD_VOFFSET (f, j) == fnptr)
 230                         {
 231                           value vtbl;
 232                           value base = value_ind (arg2);
 233                           struct type *fntype = lookup_pointer_type (TYPE_FN_FIELD_TYPE (f, j));
 234
 235                           if (TYPE_VPTR_FIELDNO (basetype) < 0)
 236                             TYPE_VPTR_FIELDNO (basetype)
 237                               = fill_in_vptr_fieldno (basetype);
 238
 239                           VALUE_TYPE (base) = basetype;
 240                           vtbl = value_field (base, TYPE_VPTR_FIELDNO (basetype));
 241                           VALUE_TYPE (vtbl) = lookup_pointer_type (fntype);
 242                           VALUE_TYPE (arg1) = builtin_type_int;
 243                           arg1 = value_subscript (vtbl, arg1);
 244                           VALUE_TYPE (arg1) = fntype;
 245                           goto got_it;
 246                         }
 247                 }
 248               if (i < 0)
 249                 error ("virtual function at index %d not found", fnptr);
 250             }
 251           else
 252             {
 253               VALUE_TYPE (arg1) = lookup_pointer_type (TYPE_TARGET_TYPE (VALUE_TYPE (arg1)));
 254             }
 255         got_it:
 256
 257           /* Now, say which argument to start evaluating from */
 258           tem = 2;
 259         }
 260       else if (op == STRUCTOP_STRUCT || op == STRUCTOP_PTR)
 261         {
 262           /* Hair for method invocations */
 263           int tem2;
 264
 265           nargs = exp->elts[pc + 1].longconst + 1;
 266           /* First, evaluate the structure into arg2 */
 267           pc2 = (*pos)++;
 268           tem2 = strlen (&exp->elts[pc2 + 1].string);
 269           *pos += 2 + (tem2 + sizeof (union exp_element)) / sizeof (union exp_element);
 270           if (noside == EVAL_SKIP)
 271             goto nosideret;
 272
 273           if (op == STRUCTOP_STRUCT)
 274             {
 275               arg2 = evaluate_subexp_for_address (exp, pos, noside);
 276             }
 277           else
 278             {
 279               arg2 = evaluate_subexp (0, exp, pos, noside);
 280             }
 281           /* Now, say which argument to start evaluating from */
 282           tem = 2;
 283         }
 284       else
 285         {
 286           nargs = exp->elts[pc + 1].longconst;
 287           tem = 0;
 288         }
 289       argvec = (value *) alloca (sizeof (value) * (nargs + 2));
 290       for (; tem <= nargs; tem++)
 291         /* Ensure that array expressions are coerced into pointer objects. */
 292         argvec[tem] = evaluate_subexp_with_coercion (exp, pos, noside);
 293
 294       /* signal end of arglist */
 295       argvec[tem] = 0;
 296
 297       if (op == STRUCTOP_STRUCT || op == STRUCTOP_PTR)
 298         {
 299           argvec[1] = arg2;
 300           argvec[0] =
 301             value_struct_elt (arg2, argvec+1, &exp->elts[pc2 + 1].string,
 302                               op == STRUCTOP_STRUCT
 303                               ? "structure" : "structure pointer");
 304         }
 305       else if (op == STRUCTOP_MEMBER || op == STRUCTOP_MPTR)
 306         {
 307           argvec[1] = arg2;
 308           argvec[0] = arg1;
 309         }
 310
 311       if (noside == EVAL_SKIP)
 312         goto nosideret;
 313       if (noside == EVAL_AVOID_SIDE_EFFECTS)
 314         return allocate_value (TYPE_TARGET_TYPE (VALUE_TYPE (argvec[0])));
 315       return call_function (argvec[0], nargs, argvec + 1);
 316
 317     case OP_STRING:
 318       tem = strlen (&exp->elts[pc + 1].string);
 319       (*pos) += 2 + (tem + sizeof (union exp_element)) / sizeof (union exp_element);
 320       if (noside == EVAL_SKIP)
 321         goto nosideret;
 322       return value_string (&exp->elts[pc + 1].string, tem);
 323
 324     case TERNOP_COND:
 325       /* Skip third and second args to evaluate the first one.  */
 326       arg1 = evaluate_subexp (0, exp, pos, noside);
 327       if (value_zerop (arg1))
 328         {
 329           evaluate_subexp (0, exp, pos, EVAL_SKIP);
 330           return evaluate_subexp (0, exp, pos, noside);
 331         }
 332       else
 333         {
 334           arg2 = evaluate_subexp (0, exp, pos, noside);
 335           evaluate_subexp (0, exp, pos, EVAL_SKIP);
 336           return arg2;
 337         }
 338
 339     case STRUCTOP_STRUCT:
 340       tem = strlen (&exp->elts[pc + 1].string);
 341       (*pos) += 2 + (tem + sizeof (union exp_element)) / sizeof (union exp_element);
 342       arg1 = evaluate_subexp (0, exp, pos, noside);
 343       if (noside == EVAL_SKIP)
 344         goto nosideret;
 345       return value_struct_elt (arg1, 0, &exp->elts[pc + 1].string,
 346                                "structure");
 347
 348     case STRUCTOP_PTR:
 349       tem = strlen (&exp->elts[pc + 1].string);
 350       (*pos) += 2 + (tem + sizeof (union exp_element)) / sizeof (union exp_element);
 351       arg1 = evaluate_subexp (0, exp, pos, noside);
 352       if (noside == EVAL_SKIP)
 353         goto nosideret;
 354       return value_struct_elt (arg1, 0, &exp->elts[pc + 1].string,
 355                                "structure pointer");
 356
 357     case STRUCTOP_MEMBER:
 358       arg1 = evaluate_subexp_for_address (exp, pos, noside);
 359       arg2 = evaluate_subexp (0, exp, pos, noside);
 360       if (noside == EVAL_SKIP)
 361         goto nosideret;
 362       /* Now, convert these values to an address.  */
 363       arg3 = value_from_long (builtin_type_long,
 364                               value_as_long (arg1) + value_as_long (arg2));
 365       VALUE_TYPE (arg3) = lookup_pointer_type (TYPE_TARGET_TYPE (VALUE_TYPE (arg2)));
 366       return value_ind (arg3);
 367
 368     case STRUCTOP_MPTR:
 369       arg1 = evaluate_subexp (0, exp, pos, noside);
 370       arg2 = evaluate_subexp (0, exp, pos, noside);
 371       if (noside == EVAL_SKIP)
 372         goto nosideret;
 373       /* Now, convert these values to an address.  */
 374       arg3 = value_from_long (builtin_type_long,
 375                               value_as_long (arg1) + value_as_long (arg2));
 376       VALUE_TYPE (arg3) = lookup_pointer_type (TYPE_TARGET_TYPE (VALUE_TYPE (arg2)));
 377       return value_ind (arg3);
 378
 379     case BINOP_ASSIGN:
 380       arg1 = evaluate_subexp (0, exp, pos, noside);
 381       arg2 = evaluate_subexp (VALUE_TYPE (arg1), exp, pos, noside);
 382       if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
 383         return arg1;
 384       if (binop_user_defined_p (op, arg1, arg2))
 385         return value_x_binop (arg1, arg2, op, 0);
 386       else
 387         return value_assign (arg1, arg2);
 388
 389     case BINOP_ASSIGN_MODIFY:
 390       (*pos) += 2;
 391       arg1 = evaluate_subexp (0, exp, pos, noside);
 392       arg2 = evaluate_subexp (VALUE_TYPE (arg1), exp, pos, noside);
 393       if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
 394         return arg1;
 395       op = exp->elts[pc + 1].opcode;
 396       if (binop_user_defined_p (op, arg1, arg2))
 397         return value_x_binop (arg1, arg2, BINOP_ASSIGN_MODIFY, op);
 398       else if (op == BINOP_ADD)
 399         arg2 = value_add (arg1, arg2);
 400       else if (op == BINOP_SUB)
 401         arg2 = value_sub (arg1, arg2);
 402       else
 403         arg2 = value_binop (arg1, arg2, op);
 404       return value_assign (arg1, arg2);
 405
 406     case BINOP_ADD:
 407       arg1 = evaluate_subexp_with_coercion (exp, pos, noside);
 408       arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
 409       if (noside == EVAL_SKIP)
 410         goto nosideret;
 411       if (binop_user_defined_p (op, arg1, arg2))
 412         return value_x_binop (arg1, arg2, op, 0);
 413       else
 414         return value_add (arg1, arg2);
 415
 416     case BINOP_SUB:
 417       arg1 = evaluate_subexp_with_coercion (exp, pos, noside);
 418       arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
 419       if (noside == EVAL_SKIP)
 420         goto nosideret;
 421       if (binop_user_defined_p (op, arg1, arg2))
 422         return value_x_binop (arg1, arg2, op, 0);
 423       else
 424         return value_sub (arg1, arg2);
 425
 426     case BINOP_MUL:
 427     case BINOP_DIV:
 428     case BINOP_REM:
 429     case BINOP_LSH:
 430     case BINOP_RSH:
 431     case BINOP_LOGAND:
 432     case BINOP_LOGIOR:
 433     case BINOP_LOGXOR:
 434       arg1 = evaluate_subexp (0, exp, pos, noside);
 435       arg2 = evaluate_subexp (0, exp, pos, noside);
 436       if (noside == EVAL_SKIP)
 437         goto nosideret;
 438       if (binop_user_defined_p (op, arg1, arg2))
 439         return value_x_binop (arg1, arg2, op, 0);
 440       else
 441         return value_binop (arg1, arg2, op);
 442
 443     case BINOP_SUBSCRIPT:
 444       arg1 = evaluate_subexp_with_coercion (exp, pos, noside);
 445       arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
 446       if (noside == EVAL_SKIP)
 447         goto nosideret;
 448       if (binop_user_defined_p (op, arg1, arg2))
 449         return value_x_binop (arg1, arg2, op, 0);
 450       else
 451         return value_subscript (arg1, arg2, op);
 452
 453     case BINOP_AND:
 454       arg1 = evaluate_subexp (0, exp, pos, noside);
 455       if (binop_user_defined_p (op, arg1, arg2))
 456         {
 457           arg2 = evaluate_subexp (0, exp, pos, noside);
 458           return value_x_binop (arg1, arg2, op, 0);
 459         }
 460       else
 461         {
 462           tem = value_zerop (arg1);
 463           arg2 = evaluate_subexp (0, exp, pos,
 464                                   (tem ? EVAL_SKIP : noside));
 465           return value_from_long (builtin_type_int,
 466                                   !tem && !value_zerop (arg2));
 467         }
 468
 469     case BINOP_OR:
 470       arg1 = evaluate_subexp (0, exp, pos, noside);
 471       if (binop_user_defined_p (op, arg1, arg2))
 472         {
 473           arg2 = evaluate_subexp (0, exp, pos, noside);
 474           return value_x_binop (arg1, arg2, op, 0);
 475         }
 476       else
 477         {
 478           tem = value_zerop (arg1);
 479           arg2 = evaluate_subexp (0, exp, pos,
 480                                   (!tem ? EVAL_SKIP : noside));
 481           return value_from_long (builtin_type_int,
 482                                   !tem || !value_zerop (arg2));
 483         }
 484
 485     case BINOP_EQUAL:
 486       arg1 = evaluate_subexp (0, exp, pos, noside);
 487       arg2 = evaluate_subexp (VALUE_TYPE (arg1), exp, pos, noside);
 488       if (noside == EVAL_SKIP)
 489         goto nosideret;
 490       if (binop_user_defined_p (op, arg1, arg2))
 491         {
 492           return value_x_binop (arg1, arg2, op, 0);
 493         }
 494       else
 495         {
 496           tem = value_equal (arg1, arg2);
 497           return value_from_long (builtin_type_int, tem);
 498         }
 499
 500     case BINOP_NOTEQUAL:
 501       arg1 = evaluate_subexp (0, exp, pos, noside);
 502       arg2 = evaluate_subexp (VALUE_TYPE (arg1), exp, pos, noside);
 503       if (noside == EVAL_SKIP)
 504         goto nosideret;
 505       if (binop_user_defined_p (op, arg1, arg2))
 506         {
 507           return value_x_binop (arg1, arg2, op, 0);
 508         }
 509       else
 510         {
 511           tem = value_equal (arg1, arg2);
 512           return value_from_long (builtin_type_int, ! tem);
 513         }
 514
 515     case BINOP_LESS:
 516       arg1 = evaluate_subexp (0, exp, pos, noside);
 517       arg2 = evaluate_subexp (VALUE_TYPE (arg1), exp, pos, noside);
 518       if (noside == EVAL_SKIP)
 519         goto nosideret;
 520       if (binop_user_defined_p (op, arg1, arg2))
 521         {
 522           return value_x_binop (arg1, arg2, op, 0);
 523         }
 524       else
 525         {
 526           tem = value_less (arg1, arg2);
 527           return value_from_long (builtin_type_int, tem);
 528         }
 529
 530     case BINOP_GTR:
 531       arg1 = evaluate_subexp (0, exp, pos, noside);
 532       arg2 = evaluate_subexp (VALUE_TYPE (arg1), exp, pos, noside);
 533       if (noside == EVAL_SKIP)
 534         goto nosideret;
 535       if (binop_user_defined_p (op, arg1, arg2))
 536         {
 537           return value_x_binop (arg1, arg2, op, 0);
 538         }
 539       else
 540         {
 541           tem = value_less (arg2, arg1);
 542           return value_from_long (builtin_type_int, tem);
 543         }
 544
 545     case BINOP_GEQ:
 546       arg1 = evaluate_subexp (0, exp, pos, noside);
 547       arg2 = evaluate_subexp (VALUE_TYPE (arg1), exp, pos, noside);
 548       if (noside == EVAL_SKIP)
 549         goto nosideret;
 550       if (binop_user_defined_p (op, arg1, arg2))
 551         {
 552           return value_x_binop (arg1, arg2, op, 0);
 553         }
 554       else
 555         {
 556           tem = value_less (arg1, arg2);
 557           return value_from_long (builtin_type_int, ! tem);
 558         }
 559
 560     case BINOP_LEQ:
 561       arg1 = evaluate_subexp (0, exp, pos, noside);
 562       arg2 = evaluate_subexp (VALUE_TYPE (arg1), exp, pos, noside);
 563       if (noside == EVAL_SKIP)
 564         goto nosideret;
 565       if (binop_user_defined_p (op, arg1, arg2))
 566         {
 567           return value_x_binop (arg1, arg2, op, 0);
 568         }
 569       else
 570         {
 571           tem = value_less (arg2, arg1);
 572           return value_from_long (builtin_type_int, ! tem);
 573         }
 574
 575     case BINOP_REPEAT:
 576       arg1 = evaluate_subexp (0, exp, pos, noside);
 577       arg2 = evaluate_subexp (0, exp, pos, noside);
 578       if (noside == EVAL_SKIP)
 579         goto nosideret;
 580       return value_repeat (arg1, value_as_long (arg2));
 581
 582     case BINOP_COMMA:
 583       evaluate_subexp (0, exp, pos, noside);
 584       return evaluate_subexp (0, exp, pos, noside);
 585
 586     case UNOP_NEG:
 587       arg1 = evaluate_subexp (0, exp, pos, noside);
 588       if (noside == EVAL_SKIP)
 589         goto nosideret;
 590       if (unop_user_defined_p (op, arg1))
 591         return value_x_unop (arg1, op, 0);
 592       else
 593         return value_neg (arg1);
 594
 595     case UNOP_LOGNOT:
 596       arg1 = evaluate_subexp (0, exp, pos, noside);
 597       if (noside == EVAL_SKIP)
 598         goto nosideret;
 599       if (unop_user_defined_p (op, arg1))
 600         return value_x_unop (arg1, op, 0);
 601       else
 602         return value_lognot (arg1);
 603
 604     case UNOP_ZEROP:
 605       arg1 = evaluate_subexp (0, exp, pos, noside);
 606       if (noside == EVAL_SKIP)
 607         goto nosideret;
 608       if (unop_user_defined_p (op, arg1))
 609         return value_x_unop (arg1, op, 0);
 610       else
 611         return value_from_long (builtin_type_int, value_zerop (arg1));
 612
 613     case UNOP_IND:
 614       if (expect_type && TYPE_CODE (expect_type) == TYPE_CODE_PTR)
 615         expect_type = TYPE_TARGET_TYPE (expect_type);
 616       arg1 = evaluate_subexp (expect_type, exp, pos, noside);
 617       if (noside == EVAL_SKIP)
 618         goto nosideret;
 619       return value_ind (arg1);
 620
 621     case UNOP_ADDR:
 622       /* C++: check for and handle pointer to members.  */
 623
 624       op = exp->elts[*pos].opcode;
 625
 626       if (noside == EVAL_SKIP)
 627         {
 628           if (op == OP_SCOPE)
 629             {
 630               char *name = &exp->elts[pc+3].string;
 631               int tem = strlen (name);
 632               (*pos) += 2 + (tem + sizeof (union exp_element)) / sizeof (union exp_element);
 633             }
 634           else
 635             evaluate_subexp (expect_type, exp, pos, EVAL_SKIP);
 636           goto nosideret;
 637         }
 638
 639       if (op == OP_SCOPE)
 640         {
 641           char *name = &exp->elts[pc+3].string;
 642           int tem = strlen (name);
 643           struct type *domain = exp->elts[pc+2].type;
 644           (*pos) += 2 + (tem + sizeof (union exp_element)) / sizeof (union exp_element);
 645           arg1 = value_struct_elt_for_address (domain, expect_type, name);
 646           if (arg1)
 647             return arg1;
 648           error ("no field `%s' in structure", name);
 649         }
 650       else
 651         return evaluate_subexp_for_address (exp, pos, noside);
 652
 653     case UNOP_SIZEOF:
 654       if (noside == EVAL_SKIP)
 655         {
 656           evaluate_subexp (0, exp, pos, EVAL_SKIP);
 657           goto nosideret;
 658         }
 659       return evaluate_subexp_for_sizeof (exp, pos);
 660
 661     case UNOP_CAST:
 662       (*pos) += 2;
 663       arg1 = evaluate_subexp (expect_type, exp, pos, noside);
 664       if (noside == EVAL_SKIP)
 665         goto nosideret;
 666       return value_cast (exp->elts[pc + 1].type, arg1);
 667
 668     case UNOP_MEMVAL:
 669       (*pos) += 2;
 670       arg1 = evaluate_subexp (expect_type, exp, pos, noside);
 671       if (noside == EVAL_SKIP)
 672         goto nosideret;
 673       return value_at (exp->elts[pc + 1].type, value_as_long (arg1));
 674
 675     case UNOP_PREINCREMENT:
 676       arg1 = evaluate_subexp (expect_type, exp, pos, noside);
 677       if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
 678         return arg1;
 679       else if (unop_user_defined_p (op, arg1))
 680         {
 681           return value_x_unop (arg1, op, 0);
 682         }
 683       else
 684         {
 685           arg2 = value_add (arg1, value_from_long (builtin_type_char, 1));
 686           return value_assign (arg1, arg2);
 687         }
 688
 689     case UNOP_PREDECREMENT:
 690       arg1 = evaluate_subexp (expect_type, exp, pos, noside);
 691       if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
 692         return arg1;
 693       else if (unop_user_defined_p (op, arg1))
 694         {
 695           return value_x_unop (arg1, op, 0);
 696         }
 697       else
 698         {
 699           arg2 = value_sub (arg1, value_from_long (builtin_type_char, 1));
 700           return value_assign (arg1, arg2);
 701         }
 702
 703     case UNOP_POSTINCREMENT:
 704       arg1 = evaluate_subexp (expect_type, exp, pos, noside);
 705       if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
 706         return arg1;
 707       else if (unop_user_defined_p (op, arg1))
 708         {
 709           return value_x_unop (arg1, op, 0);
 710         }
 711       else
 712         {
 713           arg2 = value_add (arg1, value_from_long (builtin_type_char, 1));
 714           value_assign (arg1, arg2);
 715           return arg1;
 716         }
 717
 718     case UNOP_POSTDECREMENT:
 719       arg1 = evaluate_subexp (expect_type, exp, pos, noside);
 720       if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
 721         return arg1;
 722       else if (unop_user_defined_p (op, arg1))
 723         {
 724           return value_x_unop (arg1, op, 0);
 725         }
 726       else
 727         {
 728           arg2 = value_sub (arg1, value_from_long (builtin_type_char, 1));
 729           value_assign (arg1, arg2);
 730           return arg1;
 731         }
 732
 733     case OP_THIS:
 734       (*pos) += 1;
 735       return value_of_this (1);
 736
 737     default:
 738       error ("internal error: I dont know how to evaluation what you gave me");
 739     }
 740
 741  nosideret:
 742   return value_from_long (builtin_type_long, 1);
 743 }
 744 \f
 745 /* Evaluate a subexpression of EXP, at index *POS,
 746    and return the address of that subexpression.
 747    Advance *POS over the subexpression.
 748    If the subexpression isn't an lvalue, get an error.
 749    NOSIDE may be EVAL_AVOID_SIDE_EFFECTS;
 750    then only the type of the result need be correct.  */
 751
 752 static value
 753 evaluate_subexp_for_address (exp, pos, noside)
 754      register struct expression *exp;
 755      register int *pos;
 756      enum noside noside;
 757 {
 758   enum exp_opcode op;
 759   register int pc;
 760
 761   pc = (*pos);
 762   op = exp->elts[pc].opcode;
 763
 764   switch (op)
 765     {
 766     case UNOP_IND:
 767       (*pos)++;
 768       return evaluate_subexp (0, exp, pos, noside);
 769
 770     case UNOP_MEMVAL:
 771       (*pos) += 3;
 772       return value_cast (lookup_pointer_type (exp->elts[pc + 1].type),
 773                          evaluate_subexp (0, exp, pos, noside));
 774
 775     case OP_VAR_VALUE:
 776       (*pos) += 3;
 777       return locate_var_value (exp->elts[pc + 1].symbol, (CORE_ADDR) 0);
 778
 779     default:
 780       return value_addr (evaluate_subexp (0, exp, pos, noside));
 781     }
 782 }
 783
 784 /* Evaluate like `evaluate_subexp' except coercing arrays to pointers.
 785    When used in contexts where arrays will be coerced anyway,
 786    this is equivalent to `evaluate_subexp'
 787    but much faster because it avoids actually fetching array contents.  */
 788
 789 static value
 790 evaluate_subexp_with_coercion (exp, pos, noside)
 791      register struct expression *exp;
 792      register int *pos;
 793      enum noside noside;
 794 {
 795   register enum exp_opcode op;
 796   register int pc;
 797   register value val;
 798
 799   pc = (*pos);
 800   op = exp->elts[pc].opcode;
 801
 802   switch (op)
 803     {
 804     case OP_VAR_VALUE:
 805       if (TYPE_CODE (SYMBOL_TYPE (exp->elts[pc + 1].symbol)) == TYPE_CODE_ARRAY)
 806         {
 807           (*pos) += 3;
 808           val = locate_var_value (exp->elts[pc + 1].symbol, (CORE_ADDR) 0);
 809           return value_cast (lookup_pointer_type (TYPE_TARGET_TYPE (SYMBOL_TYPE (exp->elts[pc + 1].symbol))),
 810                              val);
 811         }
 812     }
 813
 814   return evaluate_subexp (0, exp, pos, noside);
 815 }
 816
 817 /* Evaluate a subexpression of EXP, at index *POS,
 818    and return a value for the size of that subexpression.
 819    Advance *POS over the subexpression.  */
 820
 821 static value
 822 evaluate_subexp_for_sizeof (exp, pos)
 823      register struct expression *exp;
 824      register int *pos;
 825 {
 826   enum exp_opcode op;
 827   register int pc;
 828   value val;
 829
 830   pc = (*pos);
 831   op = exp->elts[pc].opcode;
 832
 833   switch (op)
 834     {
 835       /* This case is handled specially
 836          so that we avoid creating a value for the result type.
 837          If the result type is very big, it's desirable not to
 838          create a value unnecessarily.  */
 839     case UNOP_IND:
 840       (*pos)++;
 841       val = evaluate_subexp (0, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
 842       return value_from_long (builtin_type_int,
 843                               TYPE_LENGTH (TYPE_TARGET_TYPE (VALUE_TYPE (val))));
 844
 845     case UNOP_MEMVAL:
 846       (*pos) += 3;
 847       return value_from_long (builtin_type_int,
 848                               TYPE_LENGTH (exp->elts[pc + 1].type));
 849
 850     case OP_VAR_VALUE:
 851       (*pos) += 3;
 852       return value_from_long (builtin_type_int,
 853                               TYPE_LENGTH (SYMBOL_TYPE (exp->elts[pc + 1].symbol)));
 854
 855     default:
 856       val = evaluate_subexp (0, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
 857       return value_from_long (builtin_type_int,
 858                               TYPE_LENGTH (VALUE_TYPE (val)));
 859     }
 860 }
 861 \f
 862 static
 863 initialize ()
 864 { }
 865
 866 END_FILE