home *** CD-ROM | disk | FTP | other *** search
/ InfoMagic Source Code 1993 July / THE_SOURCE_CODE_CD_ROM.iso / bsd_srcs / usr.bin / gdb / valarith.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-05-08  |  17.3 KB  |  691 lines
  1. /*-
  2.  * This code is derived from software copyrighted by the Free Software
  3.  * Foundation.
  4.  *
  5.  * Modified 1991 by Donn Seeley at UUNET Technologies, Inc.
  6.  * Modified 1990 by Van Jacobson at Lawrence Berkeley Laboratory.
  7.  */
  8.  
  9. #ifndef lint
  10. static char sccsid[] = "@(#)valarith.c    6.3 (Berkeley) 5/8/91";
  11. #endif /* not lint */
  12.  
  13. /* Perform arithmetic and other operations on values, for GDB.
  14.    Copyright (C) 1986, 1989 Free Software Foundation, Inc.
  15.  
  16. This file is part of GDB.
  17.  
  18. GDB is free software; you can redistribute it and/or modify
  19. it under the terms of the GNU General Public License as published by
  20. the Free Software Foundation; either version 1, or (at your option)
  21. any later version.
  22.  
  23. GDB is distributed in the hope that it will be useful,
  24. but WITHOUT ANY WARRANTY; without even the implied warranty of
  25. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  26. GNU General Public License for more details.
  27.  
  28. You should have received a copy of the GNU General Public License
  29. along with GDB; see the file COPYING.  If not, write to
  30. the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  31.  
  32. #include "defs.h"
  33. #include "param.h"
  34. #include "symtab.h"
  35. #include "value.h"
  36. #include "expression.h"
  37.  
  38.  
  39. value value_x_binop ();
  40. value value_subscripted_rvalue ();
  41.  
  42. value
  43. value_add (arg1, arg2)
  44.     value arg1, arg2;
  45. {
  46.   register value val, valint, valptr;
  47.   register int len;
  48.  
  49.   COERCE_ARRAY (arg1);
  50.   COERCE_ARRAY (arg2);
  51.  
  52.   if ((TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_PTR
  53.        || TYPE_CODE (VALUE_TYPE (arg2)) == TYPE_CODE_PTR)
  54.       &&
  55.       (TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_INT
  56.        || TYPE_CODE (VALUE_TYPE (arg2)) == TYPE_CODE_INT))
  57.     /* Exactly one argument is a pointer, and one is an integer.  */
  58.     {
  59.       if (TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_PTR)
  60.     {
  61.       valptr = arg1;
  62.       valint = arg2;
  63.     }
  64.       else
  65.     {
  66.       valptr = arg2;
  67.       valint = arg1;
  68.     }
  69.       len = TYPE_LENGTH (TYPE_TARGET_TYPE (VALUE_TYPE (valptr)));
  70.       if (len == 0) len = 1;    /* For (void *) */
  71.       val = value_from_long (builtin_type_long,
  72.                  value_as_long (valptr)
  73.                  + (len * value_as_long (valint)));
  74.       VALUE_TYPE (val) = VALUE_TYPE (valptr);
  75.       return val;
  76.     }
  77.  
  78.   return value_binop (arg1, arg2, BINOP_ADD);
  79. }
  80.  
  81. value
  82. value_sub (arg1, arg2)
  83.     value arg1, arg2;
  84. {
  85.   register value val;
  86.  
  87.   COERCE_ARRAY (arg1);
  88.   COERCE_ARRAY (arg2);
  89.  
  90.   if (TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_PTR
  91.       && 
  92.       TYPE_CODE (VALUE_TYPE (arg2)) == TYPE_CODE_INT)
  93.     {
  94.       val = value_from_long (builtin_type_long,
  95.                  value_as_long (arg1)
  96.                  - TYPE_LENGTH (TYPE_TARGET_TYPE (VALUE_TYPE (arg1))) * value_as_long (arg2));
  97.       VALUE_TYPE (val) = VALUE_TYPE (arg1);
  98.       return val;
  99.     }
  100.  
  101.   if (TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_PTR
  102.       && 
  103.       VALUE_TYPE (arg1) == VALUE_TYPE (arg2))
  104.     {
  105.       val = value_from_long (builtin_type_long,
  106.                  (value_as_long (arg1) - value_as_long (arg2))
  107.                  / TYPE_LENGTH (TYPE_TARGET_TYPE (VALUE_TYPE (arg1))));
  108.       return val;
  109.     }
  110.  
  111.   return value_binop (arg1, arg2, BINOP_SUB);
  112. }
  113.  
  114. /* Return the value of ARRAY[IDX].  */
  115.  
  116. value
  117. value_subscript (array, idx)
  118.      value array, idx;
  119. {
  120.   if (TYPE_CODE (VALUE_TYPE (array)) == TYPE_CODE_ARRAY
  121.       && VALUE_LVAL (array) != lval_memory)
  122.     return value_subscripted_rvalue (array, idx);
  123.   else
  124.     return value_ind (value_add (array, idx));
  125. }
  126.  
  127. /* Return the value of EXPR[IDX], expr an aggregate rvalue
  128.    (eg, a vector register) */
  129.  
  130. value
  131. value_subscripted_rvalue (array, idx)
  132.      value array, idx;
  133. {
  134.   struct type *elt_type = TYPE_TARGET_TYPE (VALUE_TYPE (array));
  135.   int elt_size = TYPE_LENGTH (elt_type);
  136.   int elt_offs = elt_size * value_as_long (idx);
  137.   value v;
  138.  
  139.   if (elt_offs >= TYPE_LENGTH (VALUE_TYPE (array)))
  140.     error ("no such vector element");
  141.  
  142.   if (TYPE_CODE (elt_type) == TYPE_CODE_FLT) 
  143.     {
  144.       if (elt_size == sizeof (float))
  145.     v = value_from_double (elt_type, (double) *(float *)
  146.                    (VALUE_CONTENTS (array) + elt_offs));
  147.       else
  148.     v = value_from_double (elt_type, *(double *)
  149.                    (VALUE_CONTENTS (array) + elt_offs));
  150.     }
  151.   else
  152.     {
  153.       int offs;
  154.       union {int i; char c;} test;
  155.       test.i = 1;
  156.       if (test.c == 1)
  157.     offs = 0;
  158.       else
  159.     offs = sizeof (LONGEST) - elt_size;
  160.       v = value_from_long (elt_type, *(LONGEST *)
  161.                (VALUE_CONTENTS (array) + elt_offs - offs));
  162.     }
  163.  
  164.   if (VALUE_LVAL (array) == lval_internalvar)
  165.     VALUE_LVAL (v) = lval_internalvar_component;
  166.   else
  167.     VALUE_LVAL (v) = not_lval;
  168.   VALUE_ADDRESS (v) = VALUE_ADDRESS (array);
  169.   VALUE_OFFSET (v) = VALUE_OFFSET (array) + elt_offs;
  170.   VALUE_BITSIZE (v) = elt_size * 8;
  171.   return v;
  172. }
  173.  
  174. /* Check to see if either argument is a structure.  This is called so
  175.    we know whether to go ahead with the normal binop or look for a 
  176.    user defined function instead.
  177.  
  178.    For now, we do not overload the `=' operator.  */
  179.  
  180. int
  181. binop_user_defined_p (op, arg1, arg2)
  182.      enum exp_opcode op;
  183.      value arg1, arg2;
  184. {
  185.   if (op == BINOP_ASSIGN)
  186.     return 0;
  187.   return (TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_STRUCT
  188.       || TYPE_CODE (VALUE_TYPE (arg2)) == TYPE_CODE_STRUCT
  189.       || (TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_REF
  190.           && TYPE_CODE (TYPE_TARGET_TYPE (VALUE_TYPE (arg1))) == TYPE_CODE_STRUCT)
  191.       || (TYPE_CODE (VALUE_TYPE (arg2)) == TYPE_CODE_REF
  192.           && TYPE_CODE (TYPE_TARGET_TYPE (VALUE_TYPE (arg2))) == TYPE_CODE_STRUCT));
  193. }
  194.  
  195. /* Check to see if argument is a structure.  This is called so
  196.    we know whether to go ahead with the normal unop or look for a 
  197.    user defined function instead.
  198.  
  199.    For now, we do not overload the `&' operator.  */
  200.  
  201. int unop_user_defined_p (op, arg1)
  202.      enum exp_opcode op;
  203.      value arg1;
  204. {
  205.   if (op == UNOP_ADDR)
  206.     return 0;
  207.   return (TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_STRUCT
  208.       || (TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_REF
  209.           && TYPE_CODE (TYPE_TARGET_TYPE (VALUE_TYPE (arg1))) == TYPE_CODE_STRUCT));
  210. }
  211.  
  212. /* We know either arg1 or arg2 is a structure, so try to find the right
  213.    user defined function.  Create an argument vector that calls 
  214.    arg1.operator @ (arg1,arg2) and return that value (where '@' is any
  215.    binary operator which is legal for GNU C++).  */
  216.  
  217. value
  218. value_x_binop (arg1, arg2, op, otherop)
  219.      value arg1, arg2;
  220.      int op, otherop;
  221. {
  222.   value * argvec;
  223.   char *ptr;
  224.   char tstr[13];
  225.   int static_memfuncp;
  226.  
  227.   COERCE_ENUM (arg1);
  228.   COERCE_ENUM (arg2);
  229.  
  230.   /* now we know that what we have to do is construct our
  231.      arg vector and find the right function to call it with.  */
  232.  
  233.   if (TYPE_CODE (VALUE_TYPE (arg1)) != TYPE_CODE_STRUCT)
  234.     error ("friend functions not implemented yet");
  235.  
  236.   argvec = (value *) alloca (sizeof (value) * 4);
  237.   argvec[1] = value_addr (arg1);
  238.   argvec[2] = arg2;
  239.   argvec[3] = 0;
  240.  
  241.   /* make the right function name up */  
  242.   strcpy(tstr, "operator __");
  243.   ptr = tstr+9;
  244.   switch (op)
  245.     {
  246.     case BINOP_ADD:    strcpy(ptr,"+"); break;
  247.     case BINOP_SUB:    strcpy(ptr,"-"); break;
  248.     case BINOP_MUL:    strcpy(ptr,"*"); break;
  249.     case BINOP_DIV:    strcpy(ptr,"/"); break;
  250.     case BINOP_REM:    strcpy(ptr,"%"); break;
  251.     case BINOP_LSH:    strcpy(ptr,"<<"); break;
  252.     case BINOP_RSH:    strcpy(ptr,">>"); break;
  253.     case BINOP_LOGAND:    strcpy(ptr,"&"); break;
  254.     case BINOP_LOGIOR:    strcpy(ptr,"|"); break;
  255.     case BINOP_LOGXOR:    strcpy(ptr,"^"); break;
  256.     case BINOP_AND:    strcpy(ptr,"&&"); break;
  257.     case BINOP_OR:    strcpy(ptr,"||"); break;
  258.     case BINOP_MIN:    strcpy(ptr,"<?"); break;
  259.     case BINOP_MAX:    strcpy(ptr,">?"); break;
  260.     case BINOP_ASSIGN:    strcpy(ptr,"="); break;
  261.     case BINOP_ASSIGN_MODIFY:    
  262.       switch (otherop)
  263.     {
  264.     case BINOP_ADD:      strcpy(ptr,"+="); break;
  265.     case BINOP_SUB:      strcpy(ptr,"-="); break;
  266.     case BINOP_MUL:      strcpy(ptr,"*="); break;
  267.     case BINOP_DIV:      strcpy(ptr,"/="); break;
  268.     case BINOP_REM:      strcpy(ptr,"%="); break;
  269.     case BINOP_LOGAND:   strcpy(ptr,"&="); break;
  270.     case BINOP_LOGIOR:   strcpy(ptr,"|="); break;
  271.     case BINOP_LOGXOR:   strcpy(ptr,"^="); break;
  272.     default:
  273.       error ("Invalid binary operation specified.");
  274.     }
  275.       break;
  276.     case BINOP_SUBSCRIPT: strcpy(ptr,"[]"); break;
  277.     case BINOP_EQUAL:      strcpy(ptr,"=="); break;
  278.     case BINOP_NOTEQUAL:  strcpy(ptr,"!="); break;
  279.     case BINOP_LESS:      strcpy(ptr,"<"); break;
  280.     case BINOP_GTR:       strcpy(ptr,">"); break;
  281.     case BINOP_GEQ:       strcpy(ptr,">="); break;
  282.     case BINOP_LEQ:       strcpy(ptr,"<="); break;
  283.     default:
  284.       error ("Invalid binary operation specified.");
  285.     }
  286.   argvec[0] = value_struct_elt (arg1, argvec+1, tstr, &static_memfuncp, "structure");
  287.   if (argvec[0])
  288.     {
  289.       if (static_memfuncp)
  290.     {
  291.       argvec[1] = argvec[0];
  292.       argvec++;
  293.     }
  294.       return call_function (argvec[0], 2 - static_memfuncp, argvec + 1);
  295.     }
  296.   error ("member function %s not found", tstr);
  297. }
  298.  
  299. /* We know that arg1 is a structure, so try to find a unary user
  300.    defined operator that matches the operator in question.  
  301.    Create an argument vector that calls arg1.operator @ (arg1)
  302.    and return that value (where '@' is (almost) any unary operator which
  303.    is legal for GNU C++).  */
  304.  
  305. value
  306. value_x_unop (arg1, op)
  307.      value arg1;
  308.      int op;
  309. {
  310.   value * argvec;
  311.   char *ptr;
  312.   char tstr[13];
  313.   int static_memfuncp;
  314.  
  315.   COERCE_ENUM (arg1);
  316.  
  317.   /* now we know that what we have to do is construct our
  318.      arg vector and find the right function to call it with.  */
  319.  
  320.   if (TYPE_CODE (VALUE_TYPE (arg1)) != TYPE_CODE_STRUCT)
  321.     error ("friend functions not implemented yet");
  322.  
  323.   argvec = (value *) alloca (sizeof (value) * 3);
  324.   argvec[1] = value_addr (arg1);
  325.   argvec[2] = 0;
  326.  
  327.   /* make the right function name up */  
  328.   strcpy(tstr,"operator __");
  329.   ptr = tstr+9;
  330.   switch (op)
  331.     {
  332.     case UNOP_PREINCREMENT:    strcpy(ptr,"++"); break;
  333.     case UNOP_PREDECREMENT:    strcpy(ptr,"++"); break;
  334.     case UNOP_POSTINCREMENT:    strcpy(ptr,"++"); break;
  335.     case UNOP_POSTDECREMENT:    strcpy(ptr,"++"); break;
  336.     case UNOP_ZEROP:    strcpy(ptr,"!"); break;
  337.     case UNOP_LOGNOT:    strcpy(ptr,"~"); break;
  338.     case UNOP_NEG:    strcpy(ptr,"-"); break;
  339.     default:
  340.       error ("Invalid binary operation specified.");
  341.     }
  342.   argvec[0] = value_struct_elt (arg1, argvec+1, tstr, &static_memfuncp, "structure");
  343.   if (argvec[0])
  344.     {
  345.       if (static_memfuncp)
  346.     {
  347.       argvec[1] = argvec[0];
  348.       argvec++;
  349.     }
  350.       return call_function (argvec[0], 1 - static_memfuncp, argvec + 1);
  351.     }
  352.   error ("member function %s not found", tstr);
  353. }
  354.  
  355. /* Perform a binary operation on two integers or two floats.
  356.    Does not support addition and subtraction on pointers;
  357.    use value_add or value_sub if you want to handle those possibilities.  */
  358.  
  359. value
  360. value_binop (arg1, arg2, op)
  361.      value arg1, arg2;
  362.      int op;
  363. {
  364.   register value val;
  365.  
  366.   COERCE_ENUM (arg1);
  367.   COERCE_ENUM (arg2);
  368.  
  369.   if ((TYPE_CODE (VALUE_TYPE (arg1)) != TYPE_CODE_FLT
  370.        &&
  371.        TYPE_CODE (VALUE_TYPE (arg1)) != TYPE_CODE_INT)
  372.       ||
  373.       (TYPE_CODE (VALUE_TYPE (arg2)) != TYPE_CODE_FLT
  374.        &&
  375.        TYPE_CODE (VALUE_TYPE (arg2)) != TYPE_CODE_INT))
  376.     error ("Argument to arithmetic operation not a number.");
  377.  
  378.   if (TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_FLT
  379.       ||
  380.       TYPE_CODE (VALUE_TYPE (arg2)) == TYPE_CODE_FLT)
  381.     {
  382.       double v1, v2, v;
  383.       v1 = value_as_double (arg1);
  384.       v2 = value_as_double (arg2);
  385.       switch (op)
  386.     {
  387.     case BINOP_ADD:
  388.       v = v1 + v2;
  389.       break;
  390.  
  391.     case BINOP_SUB:
  392.       v = v1 - v2;
  393.       break;
  394.  
  395.     case BINOP_MUL:
  396.       v = v1 * v2;
  397.       break;
  398.  
  399.     case BINOP_DIV:
  400.       v = v1 / v2;
  401.       break;
  402.  
  403.     default:
  404.       error ("Integer-only operation on floating point number.");
  405.     }
  406.  
  407.       val = allocate_value (builtin_type_double);
  408.       *(double *) VALUE_CONTENTS (val) = v;
  409.     }
  410.   else
  411.     /* Integral operations here.  */
  412.     {
  413.       /* Should we promote to unsigned longest?  */
  414.       if ((TYPE_UNSIGNED (VALUE_TYPE (arg1))
  415.        || TYPE_UNSIGNED (VALUE_TYPE (arg2)))
  416.       && (TYPE_LENGTH (VALUE_TYPE (arg1)) >= sizeof (unsigned LONGEST)
  417.           || TYPE_LENGTH (VALUE_TYPE (arg2)) >= sizeof (unsigned LONGEST)))
  418.     {
  419.       unsigned LONGEST v1, v2, v;
  420.       v1 = (unsigned LONGEST) value_as_long (arg1);
  421.       v2 = (unsigned LONGEST) value_as_long (arg2);
  422.       
  423.       switch (op)
  424.         {
  425.         case BINOP_ADD:
  426.           v = v1 + v2;
  427.           break;
  428.           
  429.         case BINOP_SUB:
  430.           v = v1 - v2;
  431.           break;
  432.           
  433.         case BINOP_MUL:
  434.           v = v1 * v2;
  435.           break;
  436.           
  437.         case BINOP_DIV:
  438.           v = v1 / v2;
  439.           break;
  440.           
  441.         case BINOP_REM:
  442.           v = v1 % v2;
  443.           break;
  444.           
  445.         case BINOP_LSH:
  446.           v = v1 << v2;
  447.           break;
  448.           
  449.         case BINOP_RSH:
  450.           v = v1 >> v2;
  451.           break;
  452.           
  453.         case BINOP_LOGAND:
  454.           v = v1 & v2;
  455.           break;
  456.           
  457.         case BINOP_LOGIOR:
  458.           v = v1 | v2;
  459.           break;
  460.           
  461.         case BINOP_LOGXOR:
  462.           v = v1 ^ v2;
  463.           break;
  464.           
  465.         case BINOP_AND:
  466.           v = v1 && v2;
  467.           break;
  468.           
  469.         case BINOP_OR:
  470.           v = v1 || v2;
  471.           break;
  472.           
  473.         case BINOP_MIN:
  474.           v = v1 < v2 ? v1 : v2;
  475.           break;
  476.           
  477.         case BINOP_MAX:
  478.           v = v1 > v2 ? v1 : v2;
  479.           break;
  480.           
  481.         default:
  482.           error ("Invalid binary operation on numbers.");
  483.         }
  484.  
  485.       val = allocate_value (BUILTIN_TYPE_UNSIGNED_LONGEST);
  486.       *(unsigned LONGEST *) VALUE_CONTENTS (val) = v;
  487.     }
  488.       else
  489.     {
  490.       LONGEST v1, v2, v;
  491.       v1 = value_as_long (arg1);
  492.       v2 = value_as_long (arg2);
  493.       
  494.       switch (op)
  495.         {
  496.         case BINOP_ADD:
  497.           v = v1 + v2;
  498.           break;
  499.           
  500.         case BINOP_SUB:
  501.           v = v1 - v2;
  502.           break;
  503.           
  504.         case BINOP_MUL:
  505.           v = v1 * v2;
  506.           break;
  507.           
  508.         case BINOP_DIV:
  509.           v = v1 / v2;
  510.           break;
  511.           
  512.         case BINOP_REM:
  513.           v = v1 % v2;
  514.           break;
  515.           
  516.         case BINOP_LSH:
  517.           v = v1 << v2;
  518.           break;
  519.           
  520.         case BINOP_RSH:
  521.           v = v1 >> v2;
  522.           break;
  523.           
  524.         case BINOP_LOGAND:
  525.           v = v1 & v2;
  526.           break;
  527.           
  528.         case BINOP_LOGIOR:
  529.           v = v1 | v2;
  530.           break;
  531.           
  532.         case BINOP_LOGXOR:
  533.           v = v1 ^ v2;
  534.           break;
  535.           
  536.         case BINOP_AND:
  537.           v = v1 && v2;
  538.           break;
  539.           
  540.         case BINOP_OR:
  541.           v = v1 || v2;
  542.           break;
  543.           
  544.         case BINOP_MIN:
  545.           v = v1 < v2 ? v1 : v2;
  546.           break;
  547.           
  548.         case BINOP_MAX:
  549.           v = v1 > v2 ? v1 : v2;
  550.           break;
  551.           
  552.         default:
  553.           error ("Invalid binary operation on numbers.");
  554.         }
  555.       
  556.       val = allocate_value (BUILTIN_TYPE_LONGEST);
  557.       *(LONGEST *) VALUE_CONTENTS (val) = v;
  558.     }
  559.     }
  560.  
  561.   return val;
  562. }
  563.  
  564. /* Simulate the C operator ! -- return 1 if ARG1 contains zeros.  */
  565.  
  566. int
  567. value_zerop (arg1)
  568.      value arg1;
  569. {
  570.   register int len;
  571.   register char *p;
  572.  
  573.   COERCE_ARRAY (arg1);
  574.  
  575.   len = TYPE_LENGTH (VALUE_TYPE (arg1));
  576.   p = VALUE_CONTENTS (arg1);
  577.  
  578.   while (--len >= 0)
  579.     {
  580.       if (*p++)
  581.     break;
  582.     }
  583.  
  584.   return len < 0;
  585. }
  586.  
  587. /* Simulate the C operator == by returning a 1
  588.    iff ARG1 and ARG2 have equal contents.  */
  589.  
  590. int
  591. value_equal (arg1, arg2)
  592.      register value arg1, arg2;
  593.  
  594. {
  595.   register int len;
  596.   register char *p1, *p2;
  597.   enum type_code code1;
  598.   enum type_code code2;
  599.  
  600.   COERCE_ARRAY (arg1);
  601.   COERCE_ARRAY (arg2);
  602.  
  603.   code1 = TYPE_CODE (VALUE_TYPE (arg1));
  604.   code2 = TYPE_CODE (VALUE_TYPE (arg2));
  605.  
  606.   if (code1 == TYPE_CODE_INT && code2 == TYPE_CODE_INT)
  607.     return value_as_long (arg1) == value_as_long (arg2);
  608.   else if ((code1 == TYPE_CODE_FLT || code1 == TYPE_CODE_INT)
  609.        && (code2 == TYPE_CODE_FLT || code2 == TYPE_CODE_INT))
  610.     return value_as_double (arg1) == value_as_double (arg2);
  611.   else if ((code1 == TYPE_CODE_PTR && code2 == TYPE_CODE_INT)
  612.        || (code2 == TYPE_CODE_PTR && code1 == TYPE_CODE_INT))
  613.     return (char *) value_as_long (arg1) == (char *) value_as_long (arg2);
  614.   else if (code1 == code2
  615.        && ((len = TYPE_LENGTH (VALUE_TYPE (arg1)))
  616.            == TYPE_LENGTH (VALUE_TYPE (arg2))))
  617.     {
  618.       p1 = VALUE_CONTENTS (arg1);
  619.       p2 = VALUE_CONTENTS (arg2);
  620.       while (--len >= 0)
  621.     {
  622.       if (*p1++ != *p2++)
  623.         break;
  624.     }
  625.       return len < 0;
  626.     }
  627.   else
  628.     error ("Invalid type combination in equality test.");
  629. }
  630.  
  631. /* Simulate the C operator < by returning 1
  632.    iff ARG1's contents are less than ARG2's.  */
  633.  
  634. int
  635. value_less (arg1, arg2)
  636.      register value arg1, arg2;
  637. {
  638.   register enum type_code code1;
  639.   register enum type_code code2;
  640.  
  641.   COERCE_ARRAY (arg1);
  642.   COERCE_ARRAY (arg2);
  643.  
  644.   code1 = TYPE_CODE (VALUE_TYPE (arg1));
  645.   code2 = TYPE_CODE (VALUE_TYPE (arg2));
  646.  
  647.   if (code1 == TYPE_CODE_INT && code2 == TYPE_CODE_INT)
  648.     return value_as_long (arg1) < value_as_long (arg2);
  649.   else if ((code1 == TYPE_CODE_FLT || code1 == TYPE_CODE_INT)
  650.        && (code2 == TYPE_CODE_FLT || code2 == TYPE_CODE_INT))
  651.     return value_as_double (arg1) < value_as_double (arg2);
  652.   else if ((code1 == TYPE_CODE_PTR || code1 == TYPE_CODE_INT)
  653.        && (code2 == TYPE_CODE_PTR || code2 == TYPE_CODE_INT))
  654.     return (char *) value_as_long (arg1) < (char *) value_as_long (arg2);
  655.   else
  656.     error ("Invalid type combination in ordering comparison.");
  657. }
  658.  
  659. /* The unary operators - and ~.  Both free the argument ARG1.  */
  660.  
  661. value
  662. value_neg (arg1)
  663.      register value arg1;
  664. {
  665.   register struct type *type;
  666.  
  667.   COERCE_ENUM (arg1);
  668.  
  669.   type = VALUE_TYPE (arg1);
  670.  
  671.   if (TYPE_CODE (type) == TYPE_CODE_FLT)
  672.     return value_from_double (type, - value_as_double (arg1));
  673.   else if (TYPE_CODE (type) == TYPE_CODE_INT)
  674.     return value_from_long (type, - value_as_long (arg1));
  675.   else
  676.     error ("Argument to negate operation not a number.");
  677. }
  678.  
  679. value
  680. value_lognot (arg1)
  681.      register value arg1;
  682. {
  683.   COERCE_ENUM (arg1);
  684.  
  685.   if (TYPE_CODE (VALUE_TYPE (arg1)) != TYPE_CODE_INT)
  686.     error ("Argument to complement operation not an integer.");
  687.  
  688.   return value_from_long (VALUE_TYPE (arg1), ~ value_as_long (arg1));
  689. }
  690.  
  691.