home *** CD-ROM | disk | FTP | other *** search
/ Dream 52 / Amiga_Dream_52.iso / Atari / Gnu / gdb36p4s.zoo / eval.c < prev    next >
C/C++ Source or Header  |  1989-11-08  |  30KB  |  1,022 lines
  1. /* Evaluate expressions for GDB.
  2.    Copyright (C) 1986, 1987, 1989 Free Software Foundation, Inc.
  3.  
  4. This file is part of GDB.
  5.  
  6. GDB 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 1, or (at your option)
  9. any later version.
  10.  
  11. GDB 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.
  15.  
  16. You should have received a copy of the GNU General Public License
  17. along with GDB; see the file COPYING.  If not, write to
  18. the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  19.  
  20. #include "defs.h"
  21. #include "param.h"
  22. #include "symtab.h"
  23. #include "value.h"
  24. #include "expression.h"
  25.  
  26.  
  27. /* Parse the string EXP as a C expression, evaluate it,
  28.    and return the result as a number.  */
  29.  
  30. CORE_ADDR
  31. parse_and_eval_address (exp)
  32.      char *exp;
  33. {
  34.   struct expression *expr = parse_c_expression (exp);
  35.   register CORE_ADDR addr;
  36.   register struct cleanup *old_chain
  37.     = make_cleanup (free_current_contents, &expr);
  38.  
  39.   addr = (CORE_ADDR) value_as_long (evaluate_expression (expr));
  40.   do_cleanups (old_chain);
  41.   return addr;
  42. }
  43.  
  44. /* Like parse_and_eval_address but takes a pointer to a char * variable
  45.    and advanced that variable across the characters parsed.  */
  46.  
  47. CORE_ADDR
  48. parse_and_eval_address_1 (expptr)
  49.      char **expptr;
  50. {
  51.   struct expression *expr = parse_c_1 (expptr, 0, 0);
  52.   register CORE_ADDR addr;
  53.   register struct cleanup *old_chain
  54.     = make_cleanup (free_current_contents, &expr);
  55.  
  56.   addr = value_as_long (evaluate_expression (expr));
  57.   do_cleanups (old_chain);
  58.   return addr;
  59. }
  60.  
  61. value
  62. parse_and_eval (exp)
  63.      char *exp;
  64. {
  65.   struct expression *expr = parse_c_expression (exp);
  66.   register value val;
  67.   register struct cleanup *old_chain
  68.     = make_cleanup (free_current_contents, &expr);
  69.  
  70.   val = evaluate_expression (expr);
  71.   do_cleanups (old_chain);
  72.   return val;
  73. }
  74.  
  75. /* Parse up to a comma (or to a closeparen)
  76.    in the string EXPP as an expression, evaluate it, and return the value.
  77.    EXPP is advanced to point to the comma.  */
  78.  
  79. value
  80. parse_to_comma_and_eval (expp)
  81.      char **expp;
  82. {
  83.   struct expression *expr = parse_c_1 (expp, 0, 1);
  84.   register value val;
  85.   register struct cleanup *old_chain
  86.     = make_cleanup (free_current_contents, &expr);
  87.  
  88.   val = evaluate_expression (expr);
  89.   do_cleanups (old_chain);
  90.   return val;
  91. }
  92.  
  93. /* Evaluate an expression in internal prefix form
  94.    such as is constructed by expread.y.
  95.  
  96.    See expression.h for info on the format of an expression.  */
  97.  
  98. static value evaluate_subexp ();
  99. static value evaluate_subexp_for_address ();
  100. static value evaluate_subexp_for_sizeof ();
  101. static value evaluate_subexp_with_coercion ();
  102.  
  103. /* Values of NOSIDE argument to eval_subexp.  */
  104. enum noside
  105. { EVAL_NORMAL,
  106.   EVAL_SKIP,            /* Only effect is to increment pos.  */
  107.   EVAL_AVOID_SIDE_EFFECTS,    /* Don't modify any variables or
  108.                    call any functions.  The value
  109.                    returned will have the correct
  110.                    type, and will have an
  111.                    approximately correct lvalue
  112.                    type (inaccuracy: anything that is
  113.                    listed as being in a register in
  114.                    the function in which it was
  115.                    declared will be lval_register).  */
  116. };
  117.  
  118. value
  119. evaluate_expression (exp)
  120.      struct expression *exp;
  121. {
  122.   int pc = 0;
  123.   return evaluate_subexp (0, exp, &pc, EVAL_NORMAL);
  124. }
  125.  
  126. /* Evaluate an expression, avoiding all memory references
  127.    and getting a value whose type alone is correct.  */
  128.  
  129. value
  130. evaluate_type (exp)
  131.      struct expression *exp;
  132. {
  133.   int pc = 0;
  134.   return evaluate_subexp (0, exp, &pc, EVAL_AVOID_SIDE_EFFECTS);
  135. }
  136.  
  137. static value
  138. evaluate_subexp (expect_type, exp, pos, noside)
  139.      struct type *expect_type;
  140.      register struct expression *exp;
  141.      register int *pos;
  142.      enum noside noside;
  143. {
  144.   enum exp_opcode op;
  145.   int tem;
  146.   register int pc, pc2, oldpos;
  147.   register value arg1, arg2, arg3;
  148.   int nargs;
  149.   value *argvec;
  150.  
  151.   pc = (*pos)++;
  152.   op = exp->elts[pc].opcode;
  153.  
  154.   switch (op)
  155.     {
  156.     case OP_SCOPE:
  157.       tem = strlen (&exp->elts[pc + 2].string);
  158.       (*pos) += 3 + ((tem + sizeof (union exp_element))
  159.              / sizeof (union exp_element));
  160.       return value_static_field (exp->elts[pc + 1].type,
  161.                  &exp->elts[pc + 2].string, -1);
  162.  
  163.     case OP_LONG:
  164.       (*pos) += 3;
  165.       return value_from_long (exp->elts[pc + 1].type,
  166.                   exp->elts[pc + 2].longconst);
  167.  
  168.     case OP_DOUBLE:
  169.       (*pos) += 3;
  170.       return value_from_double (exp->elts[pc + 1].type,
  171.                 exp->elts[pc + 2].doubleconst);
  172.  
  173.     case OP_VAR_VALUE:
  174.       (*pos) += 2;
  175.       if (noside == EVAL_SKIP)
  176.     goto nosideret;
  177.       if (noside == EVAL_AVOID_SIDE_EFFECTS)
  178.     {
  179.       struct symbol * sym = exp->elts[pc + 1].symbol;
  180.       enum lval_type lv;
  181.  
  182.       switch (SYMBOL_CLASS (sym))
  183.         {
  184.         case LOC_CONST:
  185.         case LOC_LABEL:
  186.         case LOC_CONST_BYTES:
  187.           lv = not_lval;
  188.         case LOC_REGISTER:
  189.         case LOC_REGPARM:
  190.           lv = lval_register;
  191.         default:
  192.           lv = lval_memory;
  193.         }
  194.  
  195.       return value_zero (SYMBOL_TYPE (sym), lv);
  196.     }
  197.       else
  198.     return value_of_variable (exp->elts[pc + 1].symbol);
  199.  
  200.     case OP_LAST:
  201.       (*pos) += 2;
  202.       return access_value_history ((int) exp->elts[pc + 1].longconst);
  203.  
  204.     case OP_REGISTER:
  205.       (*pos) += 2;
  206.       return value_of_register ((int) exp->elts[pc + 1].longconst);
  207.  
  208.     case OP_INTERNALVAR:
  209.       (*pos) += 2;
  210.       return value_of_internalvar (exp->elts[pc + 1].internalvar);
  211.  
  212.     case OP_STRING:
  213.       tem = strlen (&exp->elts[pc + 1].string);
  214.       (*pos) += 2 + ((tem + sizeof (union exp_element))
  215.              / sizeof (union exp_element));
  216.       if (noside == EVAL_SKIP)
  217.     goto nosideret;
  218.       return value_string (&exp->elts[pc + 1].string, tem);
  219.  
  220.     case TERNOP_COND:
  221.       /* Skip third and second args to evaluate the first one.  */
  222.       arg1 = evaluate_subexp (0, exp, pos, noside);
  223.       if (value_zerop (arg1))
  224.     {
  225.       evaluate_subexp (0, exp, pos, EVAL_SKIP);
  226.       return evaluate_subexp (0, exp, pos, noside);
  227.     }
  228.       else
  229.     {
  230.       arg2 = evaluate_subexp (0, exp, pos, noside);
  231.       evaluate_subexp (0, exp, pos, EVAL_SKIP);
  232.       return arg2;
  233.     }
  234.  
  235.     case OP_FUNCALL:
  236.       (*pos) += 2;
  237.       op = exp->elts[*pos].opcode;
  238.       if (op == STRUCTOP_MEMBER || op == STRUCTOP_MPTR)
  239.     {
  240.       int fnptr;
  241.       int tem2;
  242.  
  243.       nargs = (int) exp->elts[pc + 1].longconst + 1;
  244.       /* First, evaluate the structure into arg2 */
  245.       pc2 = (*pos)++;
  246.  
  247.       if (noside == EVAL_SKIP)
  248.         goto nosideret;
  249.  
  250.       if (op == STRUCTOP_MEMBER)
  251.         {
  252.           arg2 = evaluate_subexp_for_address (exp, pos, noside);
  253.         }
  254.       else
  255.         {
  256.           arg2 = evaluate_subexp (0, exp, pos, noside);
  257.         }
  258.  
  259.       /* If the function is a virtual function, then the
  260.          aggregate value (providing the structure) plays
  261.          its part by providing the vtable.  Otherwise,
  262.          it is just along for the ride: call the function
  263.          directly.  */
  264.  
  265.       arg1 = evaluate_subexp (0, exp, pos, noside);
  266.  
  267.       fnptr = (int) value_as_long (arg1);
  268.       if (fnptr < 128)
  269.         {
  270.           struct type *basetype;
  271.           int i, j;
  272.           basetype = TYPE_TARGET_TYPE (VALUE_TYPE (arg2));
  273.           basetype = TYPE_VPTR_BASETYPE (basetype);
  274.           for (i = TYPE_NFN_FIELDS (basetype) - 1; i >= 0; i--)
  275.         {
  276.           struct fn_field *f = TYPE_FN_FIELDLIST1 (basetype, i);
  277.           /* If one is virtual, then all are virtual.  */
  278.           if (TYPE_FN_FIELD_VIRTUAL_P (f, 0))
  279.             for (j = TYPE_FN_FIELDLIST_LENGTH (basetype, i) - 1; j >= 0; --j)
  280.               if (TYPE_FN_FIELD_VOFFSET (f, j) == fnptr)
  281.             {
  282.               value vtbl;
  283.               value base = value_ind (arg2);
  284.               struct type *fntype = lookup_pointer_type (TYPE_FN_FIELD_TYPE (f, j));
  285.  
  286.               if (TYPE_VPTR_FIELDNO (basetype) < 0)
  287.                 TYPE_VPTR_FIELDNO (basetype)
  288.                   = fill_in_vptr_fieldno (basetype);
  289.  
  290.               VALUE_TYPE (base) = basetype;
  291.               vtbl = value_field (base, TYPE_VPTR_FIELDNO (basetype));
  292.               VALUE_TYPE (vtbl) = lookup_pointer_type (fntype);
  293.               VALUE_TYPE (arg1) = builtin_type_int;
  294.               arg1 = value_subscript (vtbl, arg1);
  295.               VALUE_TYPE (arg1) = fntype;
  296.               goto got_it;
  297.             }
  298.         }
  299.           if (i < 0)
  300.         error ("virtual function at index %d not found", fnptr);
  301.         }
  302.       else
  303.         {
  304.           VALUE_TYPE (arg1) = lookup_pointer_type (TYPE_TARGET_TYPE (VALUE_TYPE (arg1)));
  305.         }
  306.     got_it:
  307.  
  308.       /* Now, say which argument to start evaluating from */
  309.       tem = 2;
  310.     }
  311.       else if (op == STRUCTOP_STRUCT || op == STRUCTOP_PTR)
  312.     {
  313.       /* Hair for method invocations */
  314.       int tem2;
  315.  
  316.       nargs = (int) exp->elts[pc + 1].longconst + 1;
  317.       /* First, evaluate the structure into arg2 */
  318.       pc2 = (*pos)++;
  319.       tem2 = strlen (&exp->elts[pc2 + 1].string);
  320.       *pos += 2 + (tem2 + sizeof (union exp_element)) / sizeof (union exp_element);
  321.       if (noside == EVAL_SKIP)
  322.         goto nosideret;
  323.  
  324.       if (op == STRUCTOP_STRUCT)
  325.         {
  326.           arg2 = evaluate_subexp_for_address (exp, pos, noside);
  327.         }
  328.       else
  329.         {
  330.           arg2 = evaluate_subexp (0, exp, pos, noside);
  331.         }
  332.       /* Now, say which argument to start evaluating from */
  333.       tem = 2;
  334.     }
  335.       else
  336.     {
  337.       nargs = (int) exp->elts[pc + 1].longconst;
  338.       tem = 0;
  339.     }
  340.       argvec = (value *) alloca (sizeof (value) * (nargs + 2));
  341.       for (; tem <= nargs; tem++)
  342.     /* Ensure that array expressions are coerced into pointer objects. */
  343.     argvec[tem] = evaluate_subexp_with_coercion (exp, pos, noside);
  344.  
  345.       /* signal end of arglist */
  346.       argvec[tem] = 0;
  347.  
  348.       if (op == STRUCTOP_STRUCT || op == STRUCTOP_PTR)
  349.     {
  350.       int static_memfuncp;
  351.  
  352.       argvec[1] = arg2;
  353.       argvec[0] =
  354.         value_struct_elt (arg2, argvec+1, &exp->elts[pc2 + 1].string,
  355.                   &static_memfuncp,
  356.                   op == STRUCTOP_STRUCT
  357.                   ? "structure" : "structure pointer");
  358.       if (static_memfuncp)
  359.         {
  360.           argvec[1] = argvec[0];
  361.           nargs--;
  362.           argvec++;
  363.         }
  364.     }
  365.       else if (op == STRUCTOP_MEMBER || op == STRUCTOP_MPTR)
  366.     {
  367.       argvec[1] = arg2;
  368.       argvec[0] = arg1;
  369.     }
  370.  
  371.       if (noside == EVAL_SKIP)
  372.     goto nosideret;
  373.       if (noside == EVAL_AVOID_SIDE_EFFECTS)
  374.     {
  375.       /* If the return type doesn't look like a function type, call an
  376.          error.  This can happen if somebody tries to turn a variable into
  377.          a function call. This is here because people often want to
  378.          call, eg, strcmp, which gdb doesn't know is a function.  If
  379.          gdb isn't asked for it's opinion (ie. through "whatis"),
  380.          it won't offer it. */
  381.  
  382.       struct type *ftype =
  383.         TYPE_TARGET_TYPE (VALUE_TYPE (argvec[0]));
  384.  
  385.       if (ftype)
  386.         return allocate_value (TYPE_TARGET_TYPE (VALUE_TYPE (argvec[0])));
  387.       else
  388.         error ("Expression of type other than \"Function returning ...\" used as function");
  389.     }
  390.       return call_function (argvec[0], nargs, argvec + 1);
  391.  
  392.     case STRUCTOP_STRUCT:
  393.       tem = strlen (&exp->elts[pc + 1].string);
  394.       (*pos) += 2 + ((tem + sizeof (union exp_element))
  395.              / sizeof (union exp_element));
  396.       arg1 = evaluate_subexp (0, exp, pos, noside);
  397.       if (noside == EVAL_SKIP)
  398.     goto nosideret;
  399.       if (noside == EVAL_AVOID_SIDE_EFFECTS)
  400.     return value_zero (lookup_struct_elt_type (VALUE_TYPE (arg1),
  401.                            &exp->elts[pc + 1].string),
  402.                lval_memory);
  403.       else
  404.     return value_struct_elt (arg1, 0, &exp->elts[pc + 1].string, 0,
  405.                  "structure");
  406.  
  407.     case STRUCTOP_PTR:
  408.       tem = strlen (&exp->elts[pc + 1].string);
  409.       (*pos) += 2 + (tem + sizeof (union exp_element)) / sizeof (union exp_element);
  410.       arg1 = evaluate_subexp (0, exp, pos, noside);
  411.       if (noside == EVAL_SKIP)
  412.     goto nosideret;
  413.       if (noside == EVAL_AVOID_SIDE_EFFECTS)
  414.     return value_zero (lookup_struct_elt_type (TYPE_TARGET_TYPE
  415.                            (VALUE_TYPE (arg1)),
  416.                            &exp->elts[pc + 1].string),
  417.                lval_memory);
  418.       else
  419.     return value_struct_elt (arg1, 0, &exp->elts[pc + 1].string, 0,
  420.                  "structure pointer");
  421.  
  422.     case STRUCTOP_MEMBER:
  423.       arg1 = evaluate_subexp_for_address (exp, pos, noside);
  424.       arg2 = evaluate_subexp (0, exp, pos, noside);
  425.       if (noside == EVAL_SKIP)
  426.     goto nosideret;
  427.       /* Now, convert these values to an address.  */
  428.       if (TYPE_CODE (VALUE_TYPE (arg2)) != TYPE_CODE_PTR
  429.       || ((TYPE_CODE (TYPE_TARGET_TYPE (VALUE_TYPE (arg2)))
  430.            != TYPE_CODE_MEMBER)
  431.           && (TYPE_CODE (TYPE_TARGET_TYPE (VALUE_TYPE (arg2)))
  432.           != TYPE_CODE_METHOD)))
  433.     error ("non-pointer-to-member value used in pointer-to-member construct");
  434.       arg3 = value_from_long (builtin_type_long,
  435.                   value_as_long (arg1) + value_as_long (arg2));
  436.       VALUE_TYPE (arg3) =
  437.     lookup_pointer_type (TYPE_TARGET_TYPE (TYPE_TARGET_TYPE (VALUE_TYPE (arg2))));
  438.       return value_ind (arg3);
  439.  
  440.     case STRUCTOP_MPTR:
  441.       arg1 = evaluate_subexp (0, exp, pos, noside);
  442.       arg2 = evaluate_subexp (0, exp, pos, noside);
  443.       if (noside == EVAL_SKIP)
  444.     goto nosideret;
  445.       /* Now, convert these values to an address.  */
  446.       if (TYPE_CODE (VALUE_TYPE (arg2)) != TYPE_CODE_PTR
  447.       || (TYPE_CODE (TYPE_TARGET_TYPE (VALUE_TYPE (arg2))) != TYPE_CODE_MEMBER
  448.           && TYPE_CODE (TYPE_TARGET_TYPE (VALUE_TYPE (arg2))) != TYPE_CODE_METHOD))
  449.     error ("non-pointer-to-member value used in pointer-to-member construct");
  450.       arg3 = value_from_long (builtin_type_long,
  451.                   value_as_long (arg1) + value_as_long (arg2));
  452.       VALUE_TYPE (arg3) =
  453.     lookup_pointer_type (TYPE_TARGET_TYPE (TYPE_TARGET_TYPE (VALUE_TYPE (arg2))));
  454.       return value_ind (arg3);
  455.  
  456.     case BINOP_ASSIGN:
  457.       arg1 = evaluate_subexp (0, exp, pos, noside);
  458.       arg2 = evaluate_subexp (VALUE_TYPE (arg1), exp, pos, noside);
  459.       if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
  460.     return arg1;
  461.       if (binop_user_defined_p (op, arg1, arg2))
  462.     return value_x_binop (arg1, arg2, op, 0);
  463.       else
  464.     return value_assign (arg1, arg2);
  465.  
  466.     case BINOP_ASSIGN_MODIFY:
  467.       (*pos) += 2;
  468.       arg1 = evaluate_subexp (0, exp, pos, noside);
  469.       arg2 = evaluate_subexp (VALUE_TYPE (arg1), exp, pos, noside);
  470.       if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
  471.     return arg1;
  472.       op = exp->elts[pc + 1].opcode;
  473.       if (binop_user_defined_p (op, arg1, arg2))
  474.     return value_x_binop (arg1, arg2, BINOP_ASSIGN_MODIFY, op);
  475.       else if (op == BINOP_ADD)
  476.     arg2 = value_add (arg1, arg2);
  477.       else if (op == BINOP_SUB)
  478.     arg2 = value_sub (arg1, arg2);
  479.       else
  480.     arg2 = value_binop (arg1, arg2, op);
  481.       return value_assign (arg1, arg2);
  482.  
  483.     case BINOP_ADD:
  484.       arg1 = evaluate_subexp_with_coercion (exp, pos, noside);
  485.       arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
  486.       if (noside == EVAL_SKIP)
  487.     goto nosideret;
  488.       if (binop_user_defined_p (op, arg1, arg2))
  489.     return value_x_binop (arg1, arg2, op, 0);
  490.       else
  491.     return value_add (arg1, arg2);
  492.  
  493.     case BINOP_SUB:
  494.       arg1 = evaluate_subexp_with_coercion (exp, pos, noside);
  495.       arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
  496.       if (noside == EVAL_SKIP)
  497.     goto nosideret;
  498.       if (binop_user_defined_p (op, arg1, arg2))
  499.     return value_x_binop (arg1, arg2, op, 0);
  500.       else
  501.     return value_sub (arg1, arg2);
  502.  
  503.     case BINOP_MUL:
  504.     case BINOP_DIV:
  505.     case BINOP_REM:
  506.     case BINOP_LSH:
  507.     case BINOP_RSH:
  508.     case BINOP_LOGAND:
  509.     case BINOP_LOGIOR:
  510.     case BINOP_LOGXOR:
  511.       arg1 = evaluate_subexp (0, exp, pos, noside);
  512.       arg2 = evaluate_subexp (0, exp, pos, noside);
  513.       if (noside == EVAL_SKIP)
  514.     goto nosideret;
  515.       if (binop_user_defined_p (op, arg1, arg2))
  516.     return value_x_binop (arg1, arg2, op, 0);
  517.       else
  518.     if (noside == EVAL_AVOID_SIDE_EFFECTS
  519.         && op == BINOP_DIV)
  520.       return value_zero (VALUE_TYPE (arg1), not_lval);
  521.       else
  522.     return value_binop (arg1, arg2, op);
  523.  
  524.     case BINOP_SUBSCRIPT:
  525.       arg1 = evaluate_subexp_with_coercion (exp, pos, noside);
  526.       arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
  527.       if (noside == EVAL_SKIP)
  528.     goto nosideret;
  529.       if (noside == EVAL_AVOID_SIDE_EFFECTS)
  530.     return value_zero (TYPE_TARGET_TYPE (VALUE_TYPE (arg1)),
  531.                VALUE_LVAL (arg1));
  532.                
  533.       if (binop_user_defined_p (op, arg1, arg2))
  534.     return value_x_binop (arg1, arg2, op, 0);
  535.       else
  536.     return value_subscript (arg1, arg2);
  537.       
  538.     case BINOP_AND:
  539.       arg1 = evaluate_subexp (0, exp, pos, noside);
  540.       if (noside == EVAL_SKIP)
  541.     {
  542.       arg2 = evaluate_subexp (0, exp, pos, noside);
  543.       goto nosideret;
  544.     }
  545.       
  546.       oldpos = *pos;
  547.       arg2 = evaluate_subexp (0, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
  548.       *pos = oldpos;
  549.       
  550.       if (binop_user_defined_p (op, arg1, arg2)) 
  551.     {
  552.       arg2 = evaluate_subexp (0, exp, pos, noside);
  553.       return value_x_binop (arg1, arg2, op, 0);
  554.     }
  555.       else
  556.     {
  557.       tem = value_zerop (arg1);
  558.       arg2 = evaluate_subexp (0, exp, pos,
  559.                   (tem ? EVAL_SKIP : noside));
  560.       return value_from_long (builtin_type_int,
  561.                   (LONGEST) (!tem && !value_zerop (arg2)));
  562.     }
  563.  
  564.     case BINOP_OR:
  565.       arg1 = evaluate_subexp (0, exp, pos, noside);
  566.       if (noside == EVAL_SKIP)
  567.     {
  568.       arg2 = evaluate_subexp (0, exp, pos, noside);
  569.       goto nosideret;
  570.     }
  571.       
  572.       oldpos = *pos;
  573.       arg2 = evaluate_subexp (0, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
  574.       *pos = oldpos;
  575.       
  576.       if (binop_user_defined_p (op, arg1, arg2)) 
  577.     {
  578.       arg2 = evaluate_subexp (0, exp, pos, noside);
  579.       return value_x_binop (arg1, arg2, op, 0);
  580.     }
  581.       else
  582.     {
  583.       tem = value_zerop (arg1);
  584.       arg2 = evaluate_subexp (0, exp, pos,
  585.                   (!tem ? EVAL_SKIP : noside));
  586.       return value_from_long (builtin_type_int,
  587.                   (LONGEST) (!tem || !value_zerop (arg2)));
  588.     }
  589.  
  590.     case BINOP_EQUAL:
  591.       arg1 = evaluate_subexp (0, exp, pos, noside);
  592.       arg2 = evaluate_subexp (VALUE_TYPE (arg1), exp, pos, noside);
  593.       if (noside == EVAL_SKIP)
  594.     goto nosideret;
  595.       if (binop_user_defined_p (op, arg1, arg2))
  596.     {
  597.       return value_x_binop (arg1, arg2, op, 0);
  598.     }
  599.       else
  600.     {
  601.       tem = value_equal (arg1, arg2);
  602.       return value_from_long (builtin_type_int, (LONGEST) tem);
  603.     }
  604.  
  605.     case BINOP_NOTEQUAL:
  606.       arg1 = evaluate_subexp (0, exp, pos, noside);
  607.       arg2 = evaluate_subexp (VALUE_TYPE (arg1), exp, pos, noside);
  608.       if (noside == EVAL_SKIP)
  609.     goto nosideret;
  610.       if (binop_user_defined_p (op, arg1, arg2))
  611.     {
  612.       return value_x_binop (arg1, arg2, op, 0);
  613.     }
  614.       else
  615.     {
  616.       tem = value_equal (arg1, arg2);
  617.       return value_from_long (builtin_type_int, (LONGEST) ! tem);
  618.     }
  619.  
  620.     case BINOP_LESS:
  621.       arg1 = evaluate_subexp (0, exp, pos, noside);
  622.       arg2 = evaluate_subexp (VALUE_TYPE (arg1), exp, pos, noside);
  623.       if (noside == EVAL_SKIP)
  624.     goto nosideret;
  625.       if (binop_user_defined_p (op, arg1, arg2))
  626.     {
  627.       return value_x_binop (arg1, arg2, op, 0);
  628.     }
  629.       else
  630.     {
  631.       tem = value_less (arg1, arg2);
  632.       return value_from_long (builtin_type_int, (LONGEST) tem);
  633.     }
  634.  
  635.     case BINOP_GTR:
  636.       arg1 = evaluate_subexp (0, exp, pos, noside);
  637.       arg2 = evaluate_subexp (VALUE_TYPE (arg1), exp, pos, noside);
  638.       if (noside == EVAL_SKIP)
  639.     goto nosideret;
  640.       if (binop_user_defined_p (op, arg1, arg2))
  641.     {
  642.       return value_x_binop (arg1, arg2, op, 0);
  643.     }
  644.       else
  645.     {
  646.       tem = value_less (arg2, arg1);
  647.       return value_from_long (builtin_type_int, (LONGEST) tem);
  648.     }
  649.  
  650.     case BINOP_GEQ:
  651.       arg1 = evaluate_subexp (0, exp, pos, noside);
  652.       arg2 = evaluate_subexp (VALUE_TYPE (arg1), exp, pos, noside);
  653.       if (noside == EVAL_SKIP)
  654.     goto nosideret;
  655.       if (binop_user_defined_p (op, arg1, arg2))
  656.     {
  657.       return value_x_binop (arg1, arg2, op, 0);
  658.     }
  659.       else
  660.     {
  661.       tem = value_less (arg1, arg2);
  662.       return value_from_long (builtin_type_int, (LONGEST) ! tem);
  663.     }
  664.  
  665.     case BINOP_LEQ:
  666.       arg1 = evaluate_subexp (0, exp, pos, noside);
  667.       arg2 = evaluate_subexp (VALUE_TYPE (arg1), exp, pos, noside);
  668.       if (noside == EVAL_SKIP)
  669.     goto nosideret;
  670.       if (binop_user_defined_p (op, arg1, arg2))
  671.     {
  672.       return value_x_binop (arg1, arg2, op, 0);
  673.     }
  674.       else 
  675.     {
  676.       tem = value_less (arg2, arg1);
  677.       return value_from_long (builtin_type_int, (LONGEST) ! tem);
  678.     }
  679.  
  680.     case BINOP_REPEAT:
  681.       arg1 = evaluate_subexp (0, exp, pos, noside);
  682.       arg2 = evaluate_subexp (0, exp, pos, noside);
  683.       if (noside == EVAL_SKIP)
  684.     goto nosideret;
  685.       if (TYPE_CODE (VALUE_TYPE (arg2)) != TYPE_CODE_INT)
  686.     error ("Non-integral right operand for \"@\" operator.");
  687.       if (noside == EVAL_AVOID_SIDE_EFFECTS)
  688.     return allocate_repeat_value (VALUE_TYPE (arg1),
  689.                        (int) value_as_long (arg2));
  690.       else
  691.     return value_repeat (arg1, (int) value_as_long (arg2));
  692.  
  693.     case BINOP_COMMA:
  694.       evaluate_subexp (0, exp, pos, noside);
  695.       return evaluate_subexp (0, exp, pos, noside);
  696.  
  697.     case UNOP_NEG:
  698.       arg1 = evaluate_subexp (0, exp, pos, noside);
  699.       if (noside == EVAL_SKIP)
  700.     goto nosideret;
  701.       if (unop_user_defined_p (op, arg1))
  702.     return value_x_unop (arg1, op);
  703.       else
  704.     return value_neg (arg1);
  705.  
  706.     case UNOP_LOGNOT:
  707.       arg1 = evaluate_subexp (0, exp, pos, noside);
  708.       if (noside == EVAL_SKIP)
  709.     goto nosideret;
  710.       if (unop_user_defined_p (op, arg1))
  711.     return value_x_unop (arg1, op);
  712.       else
  713.     return value_lognot (arg1);
  714.  
  715.     case UNOP_ZEROP:
  716.       arg1 = evaluate_subexp (0, exp, pos, noside);
  717.       if (noside == EVAL_SKIP)
  718.     goto nosideret;
  719.       if (unop_user_defined_p (op, arg1))
  720.     return value_x_unop (arg1, op);
  721.       else
  722.     return value_from_long (builtin_type_int,
  723.                 (LONGEST) value_zerop (arg1));
  724.  
  725.     case UNOP_IND:
  726.       if (expect_type && TYPE_CODE (expect_type) == TYPE_CODE_PTR)
  727.         expect_type = TYPE_TARGET_TYPE (expect_type);
  728.       arg1 = evaluate_subexp (expect_type, exp, pos, noside);
  729.       if (noside == EVAL_SKIP)
  730.     goto nosideret;
  731.       if (noside == EVAL_AVOID_SIDE_EFFECTS)
  732.     {
  733.       if (TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_PTR
  734.           || TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_REF
  735.           /* In C you can dereference an array to get the 1st elt.  */
  736.           || TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_ARRAY
  737.           )
  738.         return value_zero (TYPE_TARGET_TYPE (VALUE_TYPE (arg1)),
  739.                    lval_memory);
  740.       else if (TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_INT)
  741.         /* GDB allows dereferencing an int.  */
  742.         return value_zero (builtin_type_int, lval_memory);
  743.       else
  744.         error ("Attempt to take contents of a non-pointer value.");
  745.     }
  746.       return value_ind (arg1);
  747.  
  748.     case UNOP_ADDR:
  749.       /* C++: check for and handle pointer to members.  */
  750.       
  751.       op = exp->elts[*pos].opcode;
  752.  
  753.       if (noside == EVAL_SKIP)
  754.     {
  755.       if (op == OP_SCOPE)
  756.         {
  757.           char *name = &exp->elts[pc+3].string;
  758.           int tem = strlen (name);
  759.           (*pos) += 2 + (tem + sizeof (union exp_element)) / sizeof (union exp_element);
  760.         }
  761.       else
  762.         evaluate_subexp (expect_type, exp, pos, EVAL_SKIP);
  763.       goto nosideret;
  764.     }
  765.  
  766.       if (op == OP_SCOPE)
  767.     {
  768.       char *name = &exp->elts[pc+3].string;
  769.       int tem = strlen (name);
  770.       struct type *domain = exp->elts[pc+2].type;
  771.       (*pos) += 2 + (tem + sizeof (union exp_element)) / sizeof (union exp_element);
  772.       arg1 = value_struct_elt_for_address (domain, expect_type, name);
  773.       if (arg1)
  774.         return arg1;
  775.       error ("no field `%s' in structure", name);
  776.     }
  777.       else
  778.     return evaluate_subexp_for_address (exp, pos, noside);
  779.  
  780.     case UNOP_SIZEOF:
  781.       if (noside == EVAL_SKIP)
  782.     {
  783.       evaluate_subexp (0, exp, pos, EVAL_SKIP);
  784.       goto nosideret;
  785.     }
  786.       return evaluate_subexp_for_sizeof (exp, pos);
  787.  
  788.     case UNOP_CAST:
  789.       (*pos) += 2;
  790.       arg1 = evaluate_subexp (expect_type, exp, pos, noside);
  791.       if (noside == EVAL_SKIP)
  792.     goto nosideret;
  793.       return value_cast (exp->elts[pc + 1].type, arg1);
  794.  
  795.     case UNOP_MEMVAL:
  796.       (*pos) += 2;
  797.       arg1 = evaluate_subexp (expect_type, exp, pos, noside);
  798.       if (noside == EVAL_SKIP)
  799.     goto nosideret;
  800.       if (noside == EVAL_AVOID_SIDE_EFFECTS)
  801.     return value_zero (exp->elts[pc + 1].type, lval_memory);
  802.       else
  803.     return value_at (exp->elts[pc + 1].type,
  804.              (CORE_ADDR) value_as_long (arg1));
  805.  
  806.     case UNOP_PREINCREMENT:
  807.       arg1 = evaluate_subexp (expect_type, exp, pos, noside);
  808.       if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
  809.     return arg1;
  810.       else if (unop_user_defined_p (op, arg1))
  811.     {
  812.       return value_x_unop (arg1, op);
  813.     }
  814.       else
  815.     {
  816.       arg2 = value_add (arg1, value_from_long (builtin_type_char, 
  817.                            (LONGEST) 1));
  818.       return value_assign (arg1, arg2);
  819.     }
  820.  
  821.     case UNOP_PREDECREMENT:
  822.       arg1 = evaluate_subexp (expect_type, exp, pos, noside);
  823.       if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
  824.     return arg1;
  825.       else if (unop_user_defined_p (op, arg1))
  826.     {
  827.       return value_x_unop (arg1, op);
  828.     }
  829.       else
  830.     {
  831.       arg2 = value_sub (arg1, value_from_long (builtin_type_char, 
  832.                            (LONGEST) 1));
  833.       return value_assign (arg1, arg2);
  834.     }
  835.  
  836.     case UNOP_POSTINCREMENT:
  837.       arg1 = evaluate_subexp (expect_type, exp, pos, noside);
  838.       if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
  839.     return arg1;
  840.       else if (unop_user_defined_p (op, arg1))
  841.     {
  842.       return value_x_unop (arg1, op);
  843.     }
  844.       else
  845.     {
  846.       arg2 = value_add (arg1, value_from_long (builtin_type_char, 
  847.                            (LONGEST) 1));
  848.       value_assign (arg1, arg2);
  849.       return arg1;
  850.     }
  851.  
  852.     case UNOP_POSTDECREMENT:
  853.       arg1 = evaluate_subexp (expect_type, exp, pos, noside);
  854.       if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
  855.     return arg1;
  856.       else if (unop_user_defined_p (op, arg1))
  857.     {
  858.       return value_x_unop (arg1, op);
  859.     }
  860.       else
  861.     {
  862.       arg2 = value_sub (arg1, value_from_long (builtin_type_char, 
  863.                            (LONGEST) 1));
  864.       value_assign (arg1, arg2);
  865.       return arg1;
  866.     }
  867.     
  868.     case OP_THIS:
  869.       (*pos) += 1;
  870.       return value_of_this (1);
  871.  
  872.     default:
  873.       error ("internal error: I do not know how to evaluate what you gave me");
  874.     }
  875.  
  876.  nosideret:
  877.   return value_from_long (builtin_type_long, (LONGEST) 1);
  878. }
  879.  
  880. /* Evaluate a subexpression of EXP, at index *POS,
  881.    and return the address of that subexpression.
  882.    Advance *POS over the subexpression.
  883.    If the subexpression isn't an lvalue, get an error.
  884.    NOSIDE may be EVAL_AVOID_SIDE_EFFECTS;
  885.    then only the type of the result need be correct.  */
  886.  
  887. static value
  888. evaluate_subexp_for_address (exp, pos, noside)
  889.      register struct expression *exp;
  890.      register int *pos;
  891.      enum noside noside;
  892. {
  893.   enum exp_opcode op;
  894.   register int pc;
  895.  
  896.   pc = (*pos);
  897.   op = exp->elts[pc].opcode;
  898.  
  899.   switch (op)
  900.     {
  901.     case UNOP_IND:
  902.       (*pos)++;
  903.       return evaluate_subexp (0, exp, pos, noside);
  904.  
  905.     case UNOP_MEMVAL:
  906.       (*pos) += 3;
  907.       return value_cast (lookup_pointer_type (exp->elts[pc + 1].type),
  908.              evaluate_subexp (0, exp, pos, noside));
  909.  
  910.     case OP_VAR_VALUE:
  911.       (*pos) += 3;
  912.       if (noside == EVAL_AVOID_SIDE_EFFECTS)
  913.     {
  914.       struct type *type =
  915.         lookup_pointer_type (SYMBOL_TYPE (exp->elts[pc + 1].symbol));
  916.       enum address_class sym_class =
  917.         SYMBOL_CLASS (exp->elts[pc + 1].symbol);
  918.  
  919.       if (sym_class == LOC_CONST
  920.           || sym_class == LOC_CONST_BYTES
  921.           || sym_class == LOC_REGISTER
  922.           || sym_class == LOC_REGPARM)
  923.         error ("Attempt to take address of register or constant.");
  924.  
  925.     return
  926.       value_zero (type, not_lval);
  927.     }
  928.       else
  929.     return locate_var_value (exp->elts[pc + 1].symbol, (CORE_ADDR) 0);
  930.  
  931.     default:
  932.       if (noside == EVAL_AVOID_SIDE_EFFECTS)
  933.     {
  934.       value x = evaluate_subexp (0, exp, pos, noside);
  935.       if (VALUE_LVAL (x) == lval_memory)
  936.         return value_zero (TYPE_POINTER_TYPE (VALUE_TYPE (x)),
  937.                    not_lval);
  938.       else
  939.         error ("Attempt to take address of non-lval");
  940.     }
  941.       return value_addr (evaluate_subexp (0, exp, pos, noside));
  942.     }
  943. }
  944.  
  945. /* Evaluate like `evaluate_subexp' except coercing arrays to pointers.
  946.    When used in contexts where arrays will be coerced anyway,
  947.    this is equivalent to `evaluate_subexp'
  948.    but much faster because it avoids actually fetching array contents.  */
  949.  
  950. static value
  951. evaluate_subexp_with_coercion (exp, pos, noside)
  952.      register struct expression *exp;
  953.      register int *pos;
  954.      enum noside noside;
  955. {
  956.   register enum exp_opcode op;
  957.   register int pc;
  958.   register value val;
  959.  
  960.   pc = (*pos);
  961.   op = exp->elts[pc].opcode;
  962.  
  963.   switch (op)
  964.     {
  965.     case OP_VAR_VALUE:
  966.       if (TYPE_CODE (SYMBOL_TYPE (exp->elts[pc + 1].symbol)) == TYPE_CODE_ARRAY)
  967.     {
  968.       (*pos) += 3;
  969.       val = locate_var_value (exp->elts[pc + 1].symbol, (CORE_ADDR) 0);
  970.       return value_cast (lookup_pointer_type (TYPE_TARGET_TYPE (SYMBOL_TYPE (exp->elts[pc + 1].symbol))),
  971.                  val);
  972.     }
  973.     }
  974.  
  975.   return evaluate_subexp (0, exp, pos, noside);
  976. }
  977.  
  978. /* Evaluate a subexpression of EXP, at index *POS,
  979.    and return a value for the size of that subexpression.
  980.    Advance *POS over the subexpression.  */
  981.  
  982. static value
  983. evaluate_subexp_for_sizeof (exp, pos)
  984.      register struct expression *exp;
  985.      register int *pos;
  986. {
  987.   enum exp_opcode op;
  988.   register int pc;
  989.   value val;
  990.  
  991.   pc = (*pos);
  992.   op = exp->elts[pc].opcode;
  993.  
  994.   switch (op)
  995.     {
  996.       /* This case is handled specially
  997.      so that we avoid creating a value for the result type.
  998.      If the result type is very big, it's desirable not to
  999.      create a value unnecessarily.  */
  1000.     case UNOP_IND:
  1001.       (*pos)++;
  1002.       val = evaluate_subexp (0, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
  1003.       return value_from_long (builtin_type_int, (LONGEST)
  1004.               TYPE_LENGTH (TYPE_TARGET_TYPE (VALUE_TYPE (val))));
  1005.  
  1006.     case UNOP_MEMVAL:
  1007.       (*pos) += 3;
  1008.       return value_from_long (builtin_type_int, 
  1009.                   (LONGEST) TYPE_LENGTH (exp->elts[pc + 1].type));
  1010.  
  1011.     case OP_VAR_VALUE:
  1012.       (*pos) += 3;
  1013.       return value_from_long (builtin_type_int,
  1014.      (LONGEST) TYPE_LENGTH (SYMBOL_TYPE (exp->elts[pc + 1].symbol)));
  1015.  
  1016.     default:
  1017.       val = evaluate_subexp (0, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
  1018.       return value_from_long (builtin_type_int,
  1019.                   (LONGEST) TYPE_LENGTH (VALUE_TYPE (val)));
  1020.     }
  1021. }
  1022.