OpenCores
URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [trunk/] [gdb-5.0/] [gdb/] [valarith.c] - Blame information for rev 1765

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 104 markom
/* Perform arithmetic and other operations on values, for GDB.
2
   Copyright 1986, 89, 91, 92, 93, 94, 95, 96, 97, 1998
3
   Free Software Foundation, Inc.
4
 
5
   This file is part of GDB.
6
 
7
   This program is free software; you can redistribute it and/or modify
8
   it under the terms of the GNU General Public License as published by
9
   the Free Software Foundation; either version 2 of the License, or
10
   (at your option) any later version.
11
 
12
   This program is distributed in the hope that it will be useful,
13
   but WITHOUT ANY WARRANTY; without even the implied warranty of
14
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15
   GNU General Public License for more details.
16
 
17
   You should have received a copy of the GNU General Public License
18
   along with this program; if not, write to the Free Software
19
   Foundation, Inc., 59 Temple Place - Suite 330,
20
   Boston, MA 02111-1307, USA.  */
21
 
22
#include "defs.h"
23
#include "value.h"
24
#include "symtab.h"
25
#include "gdbtypes.h"
26
#include "expression.h"
27
#include "target.h"
28
#include "language.h"
29
#include "demangle.h"
30
#include "gdb_string.h"
31
#include <math.h>
32
 
33
/* Define whether or not the C operator '/' truncates towards zero for
34
   differently signed operands (truncation direction is undefined in C). */
35
 
36
#ifndef TRUNCATION_TOWARDS_ZERO
37
#define TRUNCATION_TOWARDS_ZERO ((-5 / 2) == -2)
38
#endif
39
 
40
static value_ptr value_subscripted_rvalue PARAMS ((value_ptr, value_ptr, int));
41
 
42
void _initialize_valarith PARAMS ((void));
43
 
44
 
45
value_ptr
46
value_add (arg1, arg2)
47
     value_ptr arg1, arg2;
48
{
49
  register value_ptr valint, valptr;
50
  register int len;
51
  struct type *type1, *type2, *valptrtype;
52
 
53
  COERCE_NUMBER (arg1);
54
  COERCE_NUMBER (arg2);
55
  type1 = check_typedef (VALUE_TYPE (arg1));
56
  type2 = check_typedef (VALUE_TYPE (arg2));
57
 
58
  if ((TYPE_CODE (type1) == TYPE_CODE_PTR
59
       || TYPE_CODE (type2) == TYPE_CODE_PTR)
60
      &&
61
      (TYPE_CODE (type1) == TYPE_CODE_INT
62
       || TYPE_CODE (type2) == TYPE_CODE_INT))
63
    /* Exactly one argument is a pointer, and one is an integer.  */
64
    {
65
      value_ptr retval;
66
 
67
      if (TYPE_CODE (type1) == TYPE_CODE_PTR)
68
        {
69
          valptr = arg1;
70
          valint = arg2;
71
          valptrtype = type1;
72
        }
73
      else
74
        {
75
          valptr = arg2;
76
          valint = arg1;
77
          valptrtype = type2;
78
        }
79
      len = TYPE_LENGTH (check_typedef (TYPE_TARGET_TYPE (valptrtype)));
80
      if (len == 0)
81
        len = 1;                /* For (void *) */
82
      retval = value_from_longest (valptrtype,
83
                                   value_as_long (valptr)
84
                                   + (len * value_as_long (valint)));
85
      VALUE_BFD_SECTION (retval) = VALUE_BFD_SECTION (valptr);
86
      return retval;
87
    }
88
 
89
  return value_binop (arg1, arg2, BINOP_ADD);
90
}
91
 
92
value_ptr
93
value_sub (arg1, arg2)
94
     value_ptr arg1, arg2;
95
{
96
  struct type *type1, *type2;
97
  COERCE_NUMBER (arg1);
98
  COERCE_NUMBER (arg2);
99
  type1 = check_typedef (VALUE_TYPE (arg1));
100
  type2 = check_typedef (VALUE_TYPE (arg2));
101
 
102
  if (TYPE_CODE (type1) == TYPE_CODE_PTR)
103
    {
104
      if (TYPE_CODE (type2) == TYPE_CODE_INT)
105
        {
106
          /* pointer - integer.  */
107
          LONGEST sz = TYPE_LENGTH (check_typedef (TYPE_TARGET_TYPE (type1)));
108
          return value_from_longest
109
            (VALUE_TYPE (arg1),
110
             value_as_long (arg1) - (sz * value_as_long (arg2)));
111
        }
112
      else if (TYPE_CODE (type2) == TYPE_CODE_PTR
113
               && TYPE_LENGTH (TYPE_TARGET_TYPE (type1))
114
               == TYPE_LENGTH (TYPE_TARGET_TYPE (type2)))
115
        {
116
          /* pointer to <type x> - pointer to <type x>.  */
117
          LONGEST sz = TYPE_LENGTH (check_typedef (TYPE_TARGET_TYPE (type1)));
118
          return value_from_longest
119
            (builtin_type_long, /* FIXME -- should be ptrdiff_t */
120
             (value_as_long (arg1) - value_as_long (arg2)) / sz);
121
        }
122
      else
123
        {
124
          error ("\
125
First argument of `-' is a pointer and second argument is neither\n\
126
an integer nor a pointer of the same type.");
127
        }
128
    }
129
 
130
  return value_binop (arg1, arg2, BINOP_SUB);
131
}
132
 
133
/* Return the value of ARRAY[IDX].
134
   See comments in value_coerce_array() for rationale for reason for
135
   doing lower bounds adjustment here rather than there.
136
   FIXME:  Perhaps we should validate that the index is valid and if
137
   verbosity is set, warn about invalid indices (but still use them). */
138
 
139
value_ptr
140
value_subscript (array, idx)
141
     value_ptr array, idx;
142
{
143
  value_ptr bound;
144
  int c_style = current_language->c_style_arrays;
145
  struct type *tarray;
146
 
147
  COERCE_REF (array);
148
  tarray = check_typedef (VALUE_TYPE (array));
149
  COERCE_VARYING_ARRAY (array, tarray);
150
 
151
  if (TYPE_CODE (tarray) == TYPE_CODE_ARRAY
152
      || TYPE_CODE (tarray) == TYPE_CODE_STRING)
153
    {
154
      struct type *range_type = TYPE_INDEX_TYPE (tarray);
155
      LONGEST lowerbound, upperbound;
156
      get_discrete_bounds (range_type, &lowerbound, &upperbound);
157
 
158
      if (VALUE_LVAL (array) != lval_memory)
159
        return value_subscripted_rvalue (array, idx, lowerbound);
160
 
161
      if (c_style == 0)
162
        {
163
          LONGEST index = value_as_long (idx);
164
          if (index >= lowerbound && index <= upperbound)
165
            return value_subscripted_rvalue (array, idx, lowerbound);
166
          warning ("array or string index out of range");
167
          /* fall doing C stuff */
168
          c_style = 1;
169
        }
170
 
171
      if (lowerbound != 0)
172
        {
173
          bound = value_from_longest (builtin_type_int, (LONGEST) lowerbound);
174
          idx = value_sub (idx, bound);
175
        }
176
 
177
      array = value_coerce_array (array);
178
    }
179
 
180
  if (TYPE_CODE (tarray) == TYPE_CODE_BITSTRING)
181
    {
182
      struct type *range_type = TYPE_INDEX_TYPE (tarray);
183
      LONGEST index = value_as_long (idx);
184
      value_ptr v;
185
      int offset, byte, bit_index;
186
      LONGEST lowerbound, upperbound;
187
      get_discrete_bounds (range_type, &lowerbound, &upperbound);
188
      if (index < lowerbound || index > upperbound)
189
        error ("bitstring index out of range");
190
      index -= lowerbound;
191
      offset = index / TARGET_CHAR_BIT;
192
      byte = *((char *) VALUE_CONTENTS (array) + offset);
193
      bit_index = index % TARGET_CHAR_BIT;
194
      byte >>= (BITS_BIG_ENDIAN ? TARGET_CHAR_BIT - 1 - bit_index : bit_index);
195
      v = value_from_longest (LA_BOOL_TYPE, byte & 1);
196
      VALUE_BITPOS (v) = bit_index;
197
      VALUE_BITSIZE (v) = 1;
198
      VALUE_LVAL (v) = VALUE_LVAL (array);
199
      if (VALUE_LVAL (array) == lval_internalvar)
200
        VALUE_LVAL (v) = lval_internalvar_component;
201
      VALUE_ADDRESS (v) = VALUE_ADDRESS (array);
202
      VALUE_OFFSET (v) = offset + VALUE_OFFSET (array);
203
      return v;
204
    }
205
 
206
  if (c_style)
207
    return value_ind (value_add (array, idx));
208
  else
209
    error ("not an array or string");
210
}
211
 
212
/* Return the value of EXPR[IDX], expr an aggregate rvalue
213
   (eg, a vector register).  This routine used to promote floats
214
   to doubles, but no longer does.  */
215
 
216
static value_ptr
217
value_subscripted_rvalue (array, idx, lowerbound)
218
     value_ptr array, idx;
219
     int lowerbound;
220
{
221
  struct type *array_type = check_typedef (VALUE_TYPE (array));
222
  struct type *elt_type = check_typedef (TYPE_TARGET_TYPE (array_type));
223
  unsigned int elt_size = TYPE_LENGTH (elt_type);
224
  LONGEST index = value_as_long (idx);
225
  unsigned int elt_offs = elt_size * longest_to_int (index - lowerbound);
226
  value_ptr v;
227
 
228
  if (index < lowerbound || elt_offs >= TYPE_LENGTH (array_type))
229
    error ("no such vector element");
230
 
231
  v = allocate_value (elt_type);
232
  if (VALUE_LAZY (array))
233
    VALUE_LAZY (v) = 1;
234
  else
235
    memcpy (VALUE_CONTENTS (v), VALUE_CONTENTS (array) + elt_offs, elt_size);
236
 
237
  if (VALUE_LVAL (array) == lval_internalvar)
238
    VALUE_LVAL (v) = lval_internalvar_component;
239
  else
240
    VALUE_LVAL (v) = VALUE_LVAL (array);
241
  VALUE_ADDRESS (v) = VALUE_ADDRESS (array);
242
  VALUE_OFFSET (v) = VALUE_OFFSET (array) + elt_offs;
243
  return v;
244
}
245
 
246
/* Check to see if either argument is a structure.  This is called so
247
   we know whether to go ahead with the normal binop or look for a
248
   user defined function instead.
249
 
250
   For now, we do not overload the `=' operator.  */
251
 
252
int
253
binop_user_defined_p (op, arg1, arg2)
254
     enum exp_opcode op;
255
     value_ptr arg1, arg2;
256
{
257
  struct type *type1, *type2;
258
  if (op == BINOP_ASSIGN || op == BINOP_CONCAT)
259
    return 0;
260
  type1 = check_typedef (VALUE_TYPE (arg1));
261
  type2 = check_typedef (VALUE_TYPE (arg2));
262
  return (TYPE_CODE (type1) == TYPE_CODE_STRUCT
263
          || TYPE_CODE (type2) == TYPE_CODE_STRUCT
264
          || (TYPE_CODE (type1) == TYPE_CODE_REF
265
              && TYPE_CODE (TYPE_TARGET_TYPE (type1)) == TYPE_CODE_STRUCT)
266
          || (TYPE_CODE (type2) == TYPE_CODE_REF
267
              && TYPE_CODE (TYPE_TARGET_TYPE (type2)) == TYPE_CODE_STRUCT));
268
}
269
 
270
/* Check to see if argument is a structure.  This is called so
271
   we know whether to go ahead with the normal unop or look for a
272
   user defined function instead.
273
 
274
   For now, we do not overload the `&' operator.  */
275
 
276
int
277
unop_user_defined_p (op, arg1)
278
     enum exp_opcode op;
279
     value_ptr arg1;
280
{
281
  struct type *type1;
282
  if (op == UNOP_ADDR)
283
    return 0;
284
  type1 = check_typedef (VALUE_TYPE (arg1));
285
  for (;;)
286
    {
287
      if (TYPE_CODE (type1) == TYPE_CODE_STRUCT)
288
        return 1;
289
      else if (TYPE_CODE (type1) == TYPE_CODE_REF)
290
        type1 = TYPE_TARGET_TYPE (type1);
291
      else
292
        return 0;
293
    }
294
}
295
 
296
/* We know either arg1 or arg2 is a structure, so try to find the right
297
   user defined function.  Create an argument vector that calls
298
   arg1.operator @ (arg1,arg2) and return that value (where '@' is any
299
   binary operator which is legal for GNU C++).
300
 
301
   OP is the operatore, and if it is BINOP_ASSIGN_MODIFY, then OTHEROP
302
   is the opcode saying how to modify it.  Otherwise, OTHEROP is
303
   unused.  */
304
 
305
value_ptr
306
value_x_binop (arg1, arg2, op, otherop, noside)
307
     value_ptr arg1, arg2;
308
     enum exp_opcode op, otherop;
309
     enum noside noside;
310
{
311
  value_ptr *argvec;
312
  char *ptr;
313
  char tstr[13];
314
  int static_memfuncp;
315
 
316
  COERCE_REF (arg1);
317
  COERCE_REF (arg2);
318
  COERCE_ENUM (arg1);
319
  COERCE_ENUM (arg2);
320
 
321
  /* now we know that what we have to do is construct our
322
     arg vector and find the right function to call it with.  */
323
 
324
  if (TYPE_CODE (check_typedef (VALUE_TYPE (arg1))) != TYPE_CODE_STRUCT)
325
    error ("Can't do that binary op on that type");     /* FIXME be explicit */
326
 
327
  argvec = (value_ptr *) alloca (sizeof (value_ptr) * 4);
328
  argvec[1] = value_addr (arg1);
329
  argvec[2] = arg2;
330
  argvec[3] = 0;
331
 
332
  /* make the right function name up */
333
  strcpy (tstr, "operator__");
334
  ptr = tstr + 8;
335
  switch (op)
336
    {
337
    case BINOP_ADD:
338
      strcpy (ptr, "+");
339
      break;
340
    case BINOP_SUB:
341
      strcpy (ptr, "-");
342
      break;
343
    case BINOP_MUL:
344
      strcpy (ptr, "*");
345
      break;
346
    case BINOP_DIV:
347
      strcpy (ptr, "/");
348
      break;
349
    case BINOP_REM:
350
      strcpy (ptr, "%");
351
      break;
352
    case BINOP_LSH:
353
      strcpy (ptr, "<<");
354
      break;
355
    case BINOP_RSH:
356
      strcpy (ptr, ">>");
357
      break;
358
    case BINOP_BITWISE_AND:
359
      strcpy (ptr, "&");
360
      break;
361
    case BINOP_BITWISE_IOR:
362
      strcpy (ptr, "|");
363
      break;
364
    case BINOP_BITWISE_XOR:
365
      strcpy (ptr, "^");
366
      break;
367
    case BINOP_LOGICAL_AND:
368
      strcpy (ptr, "&&");
369
      break;
370
    case BINOP_LOGICAL_OR:
371
      strcpy (ptr, "||");
372
      break;
373
    case BINOP_MIN:
374
      strcpy (ptr, "<?");
375
      break;
376
    case BINOP_MAX:
377
      strcpy (ptr, ">?");
378
      break;
379
    case BINOP_ASSIGN:
380
      strcpy (ptr, "=");
381
      break;
382
    case BINOP_ASSIGN_MODIFY:
383
      switch (otherop)
384
        {
385
        case BINOP_ADD:
386
          strcpy (ptr, "+=");
387
          break;
388
        case BINOP_SUB:
389
          strcpy (ptr, "-=");
390
          break;
391
        case BINOP_MUL:
392
          strcpy (ptr, "*=");
393
          break;
394
        case BINOP_DIV:
395
          strcpy (ptr, "/=");
396
          break;
397
        case BINOP_REM:
398
          strcpy (ptr, "%=");
399
          break;
400
        case BINOP_BITWISE_AND:
401
          strcpy (ptr, "&=");
402
          break;
403
        case BINOP_BITWISE_IOR:
404
          strcpy (ptr, "|=");
405
          break;
406
        case BINOP_BITWISE_XOR:
407
          strcpy (ptr, "^=");
408
          break;
409
        case BINOP_MOD: /* invalid */
410
        default:
411
          error ("Invalid binary operation specified.");
412
        }
413
      break;
414
    case BINOP_SUBSCRIPT:
415
      strcpy (ptr, "[]");
416
      break;
417
    case BINOP_EQUAL:
418
      strcpy (ptr, "==");
419
      break;
420
    case BINOP_NOTEQUAL:
421
      strcpy (ptr, "!=");
422
      break;
423
    case BINOP_LESS:
424
      strcpy (ptr, "<");
425
      break;
426
    case BINOP_GTR:
427
      strcpy (ptr, ">");
428
      break;
429
    case BINOP_GEQ:
430
      strcpy (ptr, ">=");
431
      break;
432
    case BINOP_LEQ:
433
      strcpy (ptr, "<=");
434
      break;
435
    case BINOP_MOD:             /* invalid */
436
    default:
437
      error ("Invalid binary operation specified.");
438
    }
439
 
440
  argvec[0] = value_struct_elt (&arg1, argvec + 1, tstr, &static_memfuncp, "structure");
441
 
442
  if (argvec[0])
443
    {
444
      if (static_memfuncp)
445
        {
446
          argvec[1] = argvec[0];
447
          argvec++;
448
        }
449
      if (noside == EVAL_AVOID_SIDE_EFFECTS)
450
        {
451
          struct type *return_type;
452
          return_type
453
            = TYPE_TARGET_TYPE (check_typedef (VALUE_TYPE (argvec[0])));
454
          return value_zero (return_type, VALUE_LVAL (arg1));
455
        }
456
      return call_function_by_hand (argvec[0], 2 - static_memfuncp, argvec + 1);
457
    }
458
  error ("member function %s not found", tstr);
459
#ifdef lint
460
  return call_function_by_hand (argvec[0], 2 - static_memfuncp, argvec + 1);
461
#endif
462
}
463
 
464
/* We know that arg1 is a structure, so try to find a unary user
465
   defined operator that matches the operator in question.
466
   Create an argument vector that calls arg1.operator @ (arg1)
467
   and return that value (where '@' is (almost) any unary operator which
468
   is legal for GNU C++).  */
469
 
470
value_ptr
471
value_x_unop (arg1, op, noside)
472
     value_ptr arg1;
473
     enum exp_opcode op;
474
     enum noside noside;
475
{
476
  value_ptr *argvec;
477
  char *ptr, *mangle_ptr;
478
  char tstr[13], mangle_tstr[13];
479
  int static_memfuncp;
480
 
481
  COERCE_REF (arg1);
482
  COERCE_ENUM (arg1);
483
 
484
  /* now we know that what we have to do is construct our
485
     arg vector and find the right function to call it with.  */
486
 
487
  if (TYPE_CODE (check_typedef (VALUE_TYPE (arg1))) != TYPE_CODE_STRUCT)
488
    error ("Can't do that unary op on that type");      /* FIXME be explicit */
489
 
490
  argvec = (value_ptr *) alloca (sizeof (value_ptr) * 3);
491
  argvec[1] = value_addr (arg1);
492
  argvec[2] = 0;
493
 
494
  /* make the right function name up */
495
  strcpy (tstr, "operator__");
496
  ptr = tstr + 8;
497
  strcpy (mangle_tstr, "__");
498
  mangle_ptr = mangle_tstr + 2;
499
  switch (op)
500
    {
501
    case UNOP_PREINCREMENT:
502
      strcpy (ptr, "++");
503
      break;
504
    case UNOP_PREDECREMENT:
505
      strcpy (ptr, "++");
506
      break;
507
    case UNOP_POSTINCREMENT:
508
      strcpy (ptr, "++");
509
      break;
510
    case UNOP_POSTDECREMENT:
511
      strcpy (ptr, "++");
512
      break;
513
    case UNOP_LOGICAL_NOT:
514
      strcpy (ptr, "!");
515
      break;
516
    case UNOP_COMPLEMENT:
517
      strcpy (ptr, "~");
518
      break;
519
    case UNOP_NEG:
520
      strcpy (ptr, "-");
521
      break;
522
    case UNOP_IND:
523
      strcpy (ptr, "*");
524
      break;
525
    default:
526
      error ("Invalid unary operation specified.");
527
    }
528
 
529
  argvec[0] = value_struct_elt (&arg1, argvec + 1, tstr, &static_memfuncp, "structure");
530
 
531
  if (argvec[0])
532
    {
533
      if (static_memfuncp)
534
        {
535
          argvec[1] = argvec[0];
536
          argvec++;
537
        }
538
      if (noside == EVAL_AVOID_SIDE_EFFECTS)
539
        {
540
          struct type *return_type;
541
          return_type
542
            = TYPE_TARGET_TYPE (check_typedef (VALUE_TYPE (argvec[0])));
543
          return value_zero (return_type, VALUE_LVAL (arg1));
544
        }
545
      return call_function_by_hand (argvec[0], 1 - static_memfuncp, argvec + 1);
546
    }
547
  error ("member function %s not found", tstr);
548
  return 0;                      /* For lint -- never reached */
549
}
550
 
551
 
552
/* Concatenate two values with the following conditions:
553
 
554
   (1)  Both values must be either bitstring values or character string
555
   values and the resulting value consists of the concatenation of
556
   ARG1 followed by ARG2.
557
 
558
   or
559
 
560
   One value must be an integer value and the other value must be
561
   either a bitstring value or character string value, which is
562
   to be repeated by the number of times specified by the integer
563
   value.
564
 
565
 
566
   (2)  Boolean values are also allowed and are treated as bit string
567
   values of length 1.
568
 
569
   (3)  Character values are also allowed and are treated as character
570
   string values of length 1.
571
 */
572
 
573
value_ptr
574
value_concat (arg1, arg2)
575
     value_ptr arg1, arg2;
576
{
577
  register value_ptr inval1, inval2, outval = NULL;
578
  int inval1len, inval2len;
579
  int count, idx;
580
  char *ptr;
581
  char inchar;
582
  struct type *type1 = check_typedef (VALUE_TYPE (arg1));
583
  struct type *type2 = check_typedef (VALUE_TYPE (arg2));
584
 
585
  COERCE_VARYING_ARRAY (arg1, type1);
586
  COERCE_VARYING_ARRAY (arg2, type2);
587
 
588
  /* First figure out if we are dealing with two values to be concatenated
589
     or a repeat count and a value to be repeated.  INVAL1 is set to the
590
     first of two concatenated values, or the repeat count.  INVAL2 is set
591
     to the second of the two concatenated values or the value to be
592
     repeated. */
593
 
594
  if (TYPE_CODE (type2) == TYPE_CODE_INT)
595
    {
596
      struct type *tmp = type1;
597
      type1 = tmp;
598
      tmp = type2;
599
      inval1 = arg2;
600
      inval2 = arg1;
601
    }
602
  else
603
    {
604
      inval1 = arg1;
605
      inval2 = arg2;
606
    }
607
 
608
  /* Now process the input values. */
609
 
610
  if (TYPE_CODE (type1) == TYPE_CODE_INT)
611
    {
612
      /* We have a repeat count.  Validate the second value and then
613
         construct a value repeated that many times. */
614
      if (TYPE_CODE (type2) == TYPE_CODE_STRING
615
          || TYPE_CODE (type2) == TYPE_CODE_CHAR)
616
        {
617
          count = longest_to_int (value_as_long (inval1));
618
          inval2len = TYPE_LENGTH (type2);
619
          ptr = (char *) alloca (count * inval2len);
620
          if (TYPE_CODE (type2) == TYPE_CODE_CHAR)
621
            {
622
              inchar = (char) unpack_long (type2,
623
                                           VALUE_CONTENTS (inval2));
624
              for (idx = 0; idx < count; idx++)
625
                {
626
                  *(ptr + idx) = inchar;
627
                }
628
            }
629
          else
630
            {
631
              for (idx = 0; idx < count; idx++)
632
                {
633
                  memcpy (ptr + (idx * inval2len), VALUE_CONTENTS (inval2),
634
                          inval2len);
635
                }
636
            }
637
          outval = value_string (ptr, count * inval2len);
638
        }
639
      else if (TYPE_CODE (type2) == TYPE_CODE_BITSTRING
640
               || TYPE_CODE (type2) == TYPE_CODE_BOOL)
641
        {
642
          error ("unimplemented support for bitstring/boolean repeats");
643
        }
644
      else
645
        {
646
          error ("can't repeat values of that type");
647
        }
648
    }
649
  else if (TYPE_CODE (type1) == TYPE_CODE_STRING
650
           || TYPE_CODE (type1) == TYPE_CODE_CHAR)
651
    {
652
      /* We have two character strings to concatenate. */
653
      if (TYPE_CODE (type2) != TYPE_CODE_STRING
654
          && TYPE_CODE (type2) != TYPE_CODE_CHAR)
655
        {
656
          error ("Strings can only be concatenated with other strings.");
657
        }
658
      inval1len = TYPE_LENGTH (type1);
659
      inval2len = TYPE_LENGTH (type2);
660
      ptr = (char *) alloca (inval1len + inval2len);
661
      if (TYPE_CODE (type1) == TYPE_CODE_CHAR)
662
        {
663
          *ptr = (char) unpack_long (type1, VALUE_CONTENTS (inval1));
664
        }
665
      else
666
        {
667
          memcpy (ptr, VALUE_CONTENTS (inval1), inval1len);
668
        }
669
      if (TYPE_CODE (type2) == TYPE_CODE_CHAR)
670
        {
671
          *(ptr + inval1len) =
672
            (char) unpack_long (type2, VALUE_CONTENTS (inval2));
673
        }
674
      else
675
        {
676
          memcpy (ptr + inval1len, VALUE_CONTENTS (inval2), inval2len);
677
        }
678
      outval = value_string (ptr, inval1len + inval2len);
679
    }
680
  else if (TYPE_CODE (type1) == TYPE_CODE_BITSTRING
681
           || TYPE_CODE (type1) == TYPE_CODE_BOOL)
682
    {
683
      /* We have two bitstrings to concatenate. */
684
      if (TYPE_CODE (type2) != TYPE_CODE_BITSTRING
685
          && TYPE_CODE (type2) != TYPE_CODE_BOOL)
686
        {
687
          error ("Bitstrings or booleans can only be concatenated with other bitstrings or booleans.");
688
        }
689
      error ("unimplemented support for bitstring/boolean concatenation.");
690
    }
691
  else
692
    {
693
      /* We don't know how to concatenate these operands. */
694
      error ("illegal operands for concatenation.");
695
    }
696
  return (outval);
697
}
698
 
699
 
700
 
701
/* Perform a binary operation on two operands which have reasonable
702
   representations as integers or floats.  This includes booleans,
703
   characters, integers, or floats.
704
   Does not support addition and subtraction on pointers;
705
   use value_add or value_sub if you want to handle those possibilities.  */
706
 
707
value_ptr
708
value_binop (arg1, arg2, op)
709
     value_ptr arg1, arg2;
710
     enum exp_opcode op;
711
{
712
  register value_ptr val;
713
  struct type *type1, *type2;
714
 
715
  COERCE_REF (arg1);
716
  COERCE_REF (arg2);
717
  COERCE_ENUM (arg1);
718
  COERCE_ENUM (arg2);
719
  type1 = check_typedef (VALUE_TYPE (arg1));
720
  type2 = check_typedef (VALUE_TYPE (arg2));
721
 
722
  if ((TYPE_CODE (type1) != TYPE_CODE_FLT
723
       && TYPE_CODE (type1) != TYPE_CODE_CHAR
724
       && TYPE_CODE (type1) != TYPE_CODE_INT
725
       && TYPE_CODE (type1) != TYPE_CODE_BOOL
726
       && TYPE_CODE (type1) != TYPE_CODE_RANGE)
727
      ||
728
      (TYPE_CODE (type2) != TYPE_CODE_FLT
729
       && TYPE_CODE (type2) != TYPE_CODE_CHAR
730
       && TYPE_CODE (type2) != TYPE_CODE_INT
731
       && TYPE_CODE (type2) != TYPE_CODE_BOOL
732
       && TYPE_CODE (type2) != TYPE_CODE_RANGE))
733
    error ("Argument to arithmetic operation not a number or boolean.");
734
 
735
  if (TYPE_CODE (type1) == TYPE_CODE_FLT
736
      ||
737
      TYPE_CODE (type2) == TYPE_CODE_FLT)
738
    {
739
      /* FIXME-if-picky-about-floating-accuracy: Should be doing this
740
         in target format.  real.c in GCC probably has the necessary
741
         code.  */
742
      DOUBLEST v1, v2, v = 0;
743
      v1 = value_as_double (arg1);
744
      v2 = value_as_double (arg2);
745
      switch (op)
746
        {
747
        case BINOP_ADD:
748
          v = v1 + v2;
749
          break;
750
 
751
        case BINOP_SUB:
752
          v = v1 - v2;
753
          break;
754
 
755
        case BINOP_MUL:
756
          v = v1 * v2;
757
          break;
758
 
759
        case BINOP_DIV:
760
          v = v1 / v2;
761
          break;
762
 
763
        case BINOP_EXP:
764
          v = pow (v1, v2);
765
          if (errno)
766
            error ("Cannot perform exponentiation: %s", strerror (errno));
767
          break;
768
 
769
        default:
770
          error ("Integer-only operation on floating point number.");
771
        }
772
 
773
      /* If either arg was long double, make sure that value is also long
774
         double.  */
775
 
776
      if (TYPE_LENGTH (type1) * 8 > TARGET_DOUBLE_BIT
777
          || TYPE_LENGTH (type2) * 8 > TARGET_DOUBLE_BIT)
778
        val = allocate_value (builtin_type_long_double);
779
      else
780
        val = allocate_value (builtin_type_double);
781
 
782
      store_floating (VALUE_CONTENTS_RAW (val), TYPE_LENGTH (VALUE_TYPE (val)),
783
                      v);
784
    }
785
  else if (TYPE_CODE (type1) == TYPE_CODE_BOOL
786
           &&
787
           TYPE_CODE (type2) == TYPE_CODE_BOOL)
788
    {
789
      LONGEST v1, v2, v = 0;
790
      v1 = value_as_long (arg1);
791
      v2 = value_as_long (arg2);
792
 
793
      switch (op)
794
        {
795
        case BINOP_BITWISE_AND:
796
          v = v1 & v2;
797
          break;
798
 
799
        case BINOP_BITWISE_IOR:
800
          v = v1 | v2;
801
          break;
802
 
803
        case BINOP_BITWISE_XOR:
804
          v = v1 ^ v2;
805
          break;
806
 
807
        case BINOP_EQUAL:
808
          v = v1 == v2;
809
          break;
810
 
811
        case BINOP_NOTEQUAL:
812
          v = v1 != v2;
813
          break;
814
 
815
        default:
816
          error ("Invalid operation on booleans.");
817
        }
818
 
819
      val = allocate_value (type1);
820
      store_signed_integer (VALUE_CONTENTS_RAW (val),
821
                            TYPE_LENGTH (type1),
822
                            v);
823
    }
824
  else
825
    /* Integral operations here.  */
826
    /* FIXME:  Also mixed integral/booleans, with result an integer. */
827
    /* FIXME: This implements ANSI C rules (also correct for C++).
828
       What about FORTRAN and chill?  */
829
    {
830
      unsigned int promoted_len1 = TYPE_LENGTH (type1);
831
      unsigned int promoted_len2 = TYPE_LENGTH (type2);
832
      int is_unsigned1 = TYPE_UNSIGNED (type1);
833
      int is_unsigned2 = TYPE_UNSIGNED (type2);
834
      unsigned int result_len;
835
      int unsigned_operation;
836
 
837
      /* Determine type length and signedness after promotion for
838
         both operands.  */
839
      if (promoted_len1 < TYPE_LENGTH (builtin_type_int))
840
        {
841
          is_unsigned1 = 0;
842
          promoted_len1 = TYPE_LENGTH (builtin_type_int);
843
        }
844
      if (promoted_len2 < TYPE_LENGTH (builtin_type_int))
845
        {
846
          is_unsigned2 = 0;
847
          promoted_len2 = TYPE_LENGTH (builtin_type_int);
848
        }
849
 
850
      /* Determine type length of the result, and if the operation should
851
         be done unsigned.
852
         Use the signedness of the operand with the greater length.
853
         If both operands are of equal length, use unsigned operation
854
         if one of the operands is unsigned.  */
855
      if (promoted_len1 > promoted_len2)
856
        {
857
          unsigned_operation = is_unsigned1;
858
          result_len = promoted_len1;
859
        }
860
      else if (promoted_len2 > promoted_len1)
861
        {
862
          unsigned_operation = is_unsigned2;
863
          result_len = promoted_len2;
864
        }
865
      else
866
        {
867
          unsigned_operation = is_unsigned1 || is_unsigned2;
868
          result_len = promoted_len1;
869
        }
870
 
871
      if (unsigned_operation)
872
        {
873
          ULONGEST v1, v2, v = 0;
874
          v1 = (ULONGEST) value_as_long (arg1);
875
          v2 = (ULONGEST) value_as_long (arg2);
876
 
877
          /* Truncate values to the type length of the result.  */
878
          if (result_len < sizeof (ULONGEST))
879
            {
880
              v1 &= ((LONGEST) 1 << HOST_CHAR_BIT * result_len) - 1;
881
              v2 &= ((LONGEST) 1 << HOST_CHAR_BIT * result_len) - 1;
882
            }
883
 
884
          switch (op)
885
            {
886
            case BINOP_ADD:
887
              v = v1 + v2;
888
              break;
889
 
890
            case BINOP_SUB:
891
              v = v1 - v2;
892
              break;
893
 
894
            case BINOP_MUL:
895
              v = v1 * v2;
896
              break;
897
 
898
            case BINOP_DIV:
899
              v = v1 / v2;
900
              break;
901
 
902
            case BINOP_EXP:
903
              v = pow (v1, v2);
904
              if (errno)
905
                error ("Cannot perform exponentiation: %s", strerror (errno));
906
              break;
907
 
908
            case BINOP_REM:
909
              v = v1 % v2;
910
              break;
911
 
912
            case BINOP_MOD:
913
              /* Knuth 1.2.4, integer only.  Note that unlike the C '%' op,
914
                 v1 mod 0 has a defined value, v1. */
915
              /* Chill specifies that v2 must be > 0, so check for that. */
916
              if (current_language->la_language == language_chill
917
                  && value_as_long (arg2) <= 0)
918
                {
919
                  error ("Second operand of MOD must be greater than zero.");
920
                }
921
              if (v2 == 0)
922
                {
923
                  v = v1;
924
                }
925
              else
926
                {
927
                  v = v1 / v2;
928
                  /* Note floor(v1/v2) == v1/v2 for unsigned. */
929
                  v = v1 - (v2 * v);
930
                }
931
              break;
932
 
933
            case BINOP_LSH:
934
              v = v1 << v2;
935
              break;
936
 
937
            case BINOP_RSH:
938
              v = v1 >> v2;
939
              break;
940
 
941
            case BINOP_BITWISE_AND:
942
              v = v1 & v2;
943
              break;
944
 
945
            case BINOP_BITWISE_IOR:
946
              v = v1 | v2;
947
              break;
948
 
949
            case BINOP_BITWISE_XOR:
950
              v = v1 ^ v2;
951
              break;
952
 
953
            case BINOP_LOGICAL_AND:
954
              v = v1 && v2;
955
              break;
956
 
957
            case BINOP_LOGICAL_OR:
958
              v = v1 || v2;
959
              break;
960
 
961
            case BINOP_MIN:
962
              v = v1 < v2 ? v1 : v2;
963
              break;
964
 
965
            case BINOP_MAX:
966
              v = v1 > v2 ? v1 : v2;
967
              break;
968
 
969
            case BINOP_EQUAL:
970
              v = v1 == v2;
971
              break;
972
 
973
            case BINOP_NOTEQUAL:
974
              v = v1 != v2;
975
              break;
976
 
977
            case BINOP_LESS:
978
              v = v1 < v2;
979
              break;
980
 
981
            default:
982
              error ("Invalid binary operation on numbers.");
983
            }
984
 
985
          /* This is a kludge to get around the fact that we don't
986
             know how to determine the result type from the types of
987
             the operands.  (I'm not really sure how much we feel the
988
             need to duplicate the exact rules of the current
989
             language.  They can get really hairy.  But not to do so
990
             makes it hard to document just what we *do* do).  */
991
 
992
          /* Can't just call init_type because we wouldn't know what
993
             name to give the type.  */
994
          val = allocate_value
995
            (result_len > TARGET_LONG_BIT / HOST_CHAR_BIT
996
             ? builtin_type_unsigned_long_long
997
             : builtin_type_unsigned_long);
998
          store_unsigned_integer (VALUE_CONTENTS_RAW (val),
999
                                  TYPE_LENGTH (VALUE_TYPE (val)),
1000
                                  v);
1001
        }
1002
      else
1003
        {
1004
          LONGEST v1, v2, v = 0;
1005
          v1 = value_as_long (arg1);
1006
          v2 = value_as_long (arg2);
1007
 
1008
          switch (op)
1009
            {
1010
            case BINOP_ADD:
1011
              v = v1 + v2;
1012
              break;
1013
 
1014
            case BINOP_SUB:
1015
              v = v1 - v2;
1016
              break;
1017
 
1018
            case BINOP_MUL:
1019
              v = v1 * v2;
1020
              break;
1021
 
1022
            case BINOP_DIV:
1023
              v = v1 / v2;
1024
              break;
1025
 
1026
            case BINOP_EXP:
1027
              v = pow (v1, v2);
1028
              if (errno)
1029
                error ("Cannot perform exponentiation: %s", strerror (errno));
1030
              break;
1031
 
1032
            case BINOP_REM:
1033
              v = v1 % v2;
1034
              break;
1035
 
1036
            case BINOP_MOD:
1037
              /* Knuth 1.2.4, integer only.  Note that unlike the C '%' op,
1038
                 X mod 0 has a defined value, X. */
1039
              /* Chill specifies that v2 must be > 0, so check for that. */
1040
              if (current_language->la_language == language_chill
1041
                  && v2 <= 0)
1042
                {
1043
                  error ("Second operand of MOD must be greater than zero.");
1044
                }
1045
              if (v2 == 0)
1046
                {
1047
                  v = v1;
1048
                }
1049
              else
1050
                {
1051
                  v = v1 / v2;
1052
                  /* Compute floor. */
1053
                  if (TRUNCATION_TOWARDS_ZERO && (v < 0) && ((v1 % v2) != 0))
1054
                    {
1055
                      v--;
1056
                    }
1057
                  v = v1 - (v2 * v);
1058
                }
1059
              break;
1060
 
1061
            case BINOP_LSH:
1062
              v = v1 << v2;
1063
              break;
1064
 
1065
            case BINOP_RSH:
1066
              v = v1 >> v2;
1067
              break;
1068
 
1069
            case BINOP_BITWISE_AND:
1070
              v = v1 & v2;
1071
              break;
1072
 
1073
            case BINOP_BITWISE_IOR:
1074
              v = v1 | v2;
1075
              break;
1076
 
1077
            case BINOP_BITWISE_XOR:
1078
              v = v1 ^ v2;
1079
              break;
1080
 
1081
            case BINOP_LOGICAL_AND:
1082
              v = v1 && v2;
1083
              break;
1084
 
1085
            case BINOP_LOGICAL_OR:
1086
              v = v1 || v2;
1087
              break;
1088
 
1089
            case BINOP_MIN:
1090
              v = v1 < v2 ? v1 : v2;
1091
              break;
1092
 
1093
            case BINOP_MAX:
1094
              v = v1 > v2 ? v1 : v2;
1095
              break;
1096
 
1097
            case BINOP_EQUAL:
1098
              v = v1 == v2;
1099
              break;
1100
 
1101
            case BINOP_LESS:
1102
              v = v1 < v2;
1103
              break;
1104
 
1105
            default:
1106
              error ("Invalid binary operation on numbers.");
1107
            }
1108
 
1109
          /* This is a kludge to get around the fact that we don't
1110
             know how to determine the result type from the types of
1111
             the operands.  (I'm not really sure how much we feel the
1112
             need to duplicate the exact rules of the current
1113
             language.  They can get really hairy.  But not to do so
1114
             makes it hard to document just what we *do* do).  */
1115
 
1116
          /* Can't just call init_type because we wouldn't know what
1117
             name to give the type.  */
1118
          val = allocate_value
1119
            (result_len > TARGET_LONG_BIT / HOST_CHAR_BIT
1120
             ? builtin_type_long_long
1121
             : builtin_type_long);
1122
          store_signed_integer (VALUE_CONTENTS_RAW (val),
1123
                                TYPE_LENGTH (VALUE_TYPE (val)),
1124
                                v);
1125
        }
1126
    }
1127
 
1128
  return val;
1129
}
1130
 
1131
/* Simulate the C operator ! -- return 1 if ARG1 contains zero.  */
1132
 
1133
int
1134
value_logical_not (arg1)
1135
     value_ptr arg1;
1136
{
1137
  register int len;
1138
  register char *p;
1139
  struct type *type1;
1140
 
1141
  COERCE_NUMBER (arg1);
1142
  type1 = check_typedef (VALUE_TYPE (arg1));
1143
 
1144
  if (TYPE_CODE (type1) == TYPE_CODE_FLT)
1145
    return 0 == value_as_double (arg1);
1146
 
1147
  len = TYPE_LENGTH (type1);
1148
  p = VALUE_CONTENTS (arg1);
1149
 
1150
  while (--len >= 0)
1151
    {
1152
      if (*p++)
1153
        break;
1154
    }
1155
 
1156
  return len < 0;
1157
}
1158
 
1159
/* Perform a comparison on two string values (whose content are not
1160
   necessarily null terminated) based on their length */
1161
 
1162
static int
1163
value_strcmp (arg1, arg2)
1164
     register value_ptr arg1, arg2;
1165
{
1166
  int len1 = TYPE_LENGTH (VALUE_TYPE (arg1));
1167
  int len2 = TYPE_LENGTH (VALUE_TYPE (arg2));
1168
  char *s1 = VALUE_CONTENTS (arg1);
1169
  char *s2 = VALUE_CONTENTS (arg2);
1170
  int i, len = len1 < len2 ? len1 : len2;
1171
 
1172
  for (i = 0; i < len; i++)
1173
    {
1174
      if (s1[i] < s2[i])
1175
        return -1;
1176
      else if (s1[i] > s2[i])
1177
        return 1;
1178
      else
1179
        continue;
1180
    }
1181
 
1182
  if (len1 < len2)
1183
    return -1;
1184
  else if (len1 > len2)
1185
    return 1;
1186
  else
1187
    return 0;
1188
}
1189
 
1190
/* Simulate the C operator == by returning a 1
1191
   iff ARG1 and ARG2 have equal contents.  */
1192
 
1193
int
1194
value_equal (arg1, arg2)
1195
     register value_ptr arg1, arg2;
1196
 
1197
{
1198
  register int len;
1199
  register char *p1, *p2;
1200
  struct type *type1, *type2;
1201
  enum type_code code1;
1202
  enum type_code code2;
1203
 
1204
  COERCE_NUMBER (arg1);
1205
  COERCE_NUMBER (arg2);
1206
 
1207
  type1 = check_typedef (VALUE_TYPE (arg1));
1208
  type2 = check_typedef (VALUE_TYPE (arg2));
1209
  code1 = TYPE_CODE (type1);
1210
  code2 = TYPE_CODE (type2);
1211
 
1212
  if ((code1 == TYPE_CODE_INT || code1 == TYPE_CODE_BOOL) &&
1213
      (code2 == TYPE_CODE_INT || code2 == TYPE_CODE_BOOL))
1214
    return longest_to_int (value_as_long (value_binop (arg1, arg2,
1215
                                                       BINOP_EQUAL)));
1216
  else if ((code1 == TYPE_CODE_FLT || code1 == TYPE_CODE_INT || code1 == TYPE_CODE_BOOL)
1217
           && (code2 == TYPE_CODE_FLT || code2 == TYPE_CODE_INT || code2 == TYPE_CODE_BOOL))
1218
    return value_as_double (arg1) == value_as_double (arg2);
1219
 
1220
  /* FIXME: Need to promote to either CORE_ADDR or LONGEST, whichever
1221
     is bigger.  */
1222
  else if (code1 == TYPE_CODE_PTR && (code2 == TYPE_CODE_INT || code2 == TYPE_CODE_BOOL))
1223
    return value_as_pointer (arg1) == (CORE_ADDR) value_as_long (arg2);
1224
  else if (code2 == TYPE_CODE_PTR && (code1 == TYPE_CODE_INT || code1 == TYPE_CODE_BOOL))
1225
    return (CORE_ADDR) value_as_long (arg1) == value_as_pointer (arg2);
1226
 
1227
  else if (code1 == code2
1228
           && ((len = (int) TYPE_LENGTH (type1))
1229
               == (int) TYPE_LENGTH (type2)))
1230
    {
1231
      p1 = VALUE_CONTENTS (arg1);
1232
      p2 = VALUE_CONTENTS (arg2);
1233
      while (--len >= 0)
1234
        {
1235
          if (*p1++ != *p2++)
1236
            break;
1237
        }
1238
      return len < 0;
1239
    }
1240
  else if (code1 == TYPE_CODE_STRING && code2 == TYPE_CODE_STRING)
1241
    {
1242
      return value_strcmp (arg1, arg2) == 0;
1243
    }
1244
  else
1245
    {
1246
      error ("Invalid type combination in equality test.");
1247
      return 0;                  /* For lint -- never reached */
1248
    }
1249
}
1250
 
1251
/* Simulate the C operator < by returning 1
1252
   iff ARG1's contents are less than ARG2's.  */
1253
 
1254
int
1255
value_less (arg1, arg2)
1256
     register value_ptr arg1, arg2;
1257
{
1258
  register enum type_code code1;
1259
  register enum type_code code2;
1260
  struct type *type1, *type2;
1261
 
1262
  COERCE_NUMBER (arg1);
1263
  COERCE_NUMBER (arg2);
1264
 
1265
  type1 = check_typedef (VALUE_TYPE (arg1));
1266
  type2 = check_typedef (VALUE_TYPE (arg2));
1267
  code1 = TYPE_CODE (type1);
1268
  code2 = TYPE_CODE (type2);
1269
 
1270
  if ((code1 == TYPE_CODE_INT || code1 == TYPE_CODE_BOOL) &&
1271
      (code2 == TYPE_CODE_INT || code2 == TYPE_CODE_BOOL))
1272
    return longest_to_int (value_as_long (value_binop (arg1, arg2,
1273
                                                       BINOP_LESS)));
1274
  else if ((code1 == TYPE_CODE_FLT || code1 == TYPE_CODE_INT || code1 == TYPE_CODE_BOOL)
1275
           && (code2 == TYPE_CODE_FLT || code2 == TYPE_CODE_INT || code2 == TYPE_CODE_BOOL))
1276
    return value_as_double (arg1) < value_as_double (arg2);
1277
  else if (code1 == TYPE_CODE_PTR && code2 == TYPE_CODE_PTR)
1278
    return value_as_pointer (arg1) < value_as_pointer (arg2);
1279
 
1280
  /* FIXME: Need to promote to either CORE_ADDR or LONGEST, whichever
1281
     is bigger.  */
1282
  else if (code1 == TYPE_CODE_PTR && (code2 == TYPE_CODE_INT || code2 == TYPE_CODE_BOOL))
1283
    return value_as_pointer (arg1) < (CORE_ADDR) value_as_long (arg2);
1284
  else if (code2 == TYPE_CODE_PTR && (code1 == TYPE_CODE_INT || code1 == TYPE_CODE_BOOL))
1285
    return (CORE_ADDR) value_as_long (arg1) < value_as_pointer (arg2);
1286
  else if (code1 == TYPE_CODE_STRING && code2 == TYPE_CODE_STRING)
1287
    return value_strcmp (arg1, arg2) < 0;
1288
  else
1289
    {
1290
      error ("Invalid type combination in ordering comparison.");
1291
      return 0;
1292
    }
1293
}
1294
 
1295
/* The unary operators - and ~.  Both free the argument ARG1.  */
1296
 
1297
value_ptr
1298
value_neg (arg1)
1299
     register value_ptr arg1;
1300
{
1301
  register struct type *type;
1302
  register struct type *result_type = VALUE_TYPE (arg1);
1303
 
1304
  COERCE_REF (arg1);
1305
  COERCE_ENUM (arg1);
1306
 
1307
  type = check_typedef (VALUE_TYPE (arg1));
1308
 
1309
  if (TYPE_CODE (type) == TYPE_CODE_FLT)
1310
    return value_from_double (result_type, -value_as_double (arg1));
1311
  else if (TYPE_CODE (type) == TYPE_CODE_INT || TYPE_CODE (type) == TYPE_CODE_BOOL)
1312
    {
1313
      /* Perform integral promotion for ANSI C/C++.
1314
         FIXME: What about FORTRAN and chill ?  */
1315
      if (TYPE_LENGTH (type) < TYPE_LENGTH (builtin_type_int))
1316
        result_type = builtin_type_int;
1317
 
1318
      return value_from_longest (result_type, -value_as_long (arg1));
1319
    }
1320
  else
1321
    {
1322
      error ("Argument to negate operation not a number.");
1323
      return 0;                  /* For lint -- never reached */
1324
    }
1325
}
1326
 
1327
value_ptr
1328
value_complement (arg1)
1329
     register value_ptr arg1;
1330
{
1331
  register struct type *type;
1332
  register struct type *result_type = VALUE_TYPE (arg1);
1333
  int typecode;
1334
 
1335
  COERCE_REF (arg1);
1336
  COERCE_ENUM (arg1);
1337
 
1338
  type = check_typedef (VALUE_TYPE (arg1));
1339
 
1340
  typecode = TYPE_CODE (type);
1341
  if ((typecode != TYPE_CODE_INT) && (typecode != TYPE_CODE_BOOL))
1342
    error ("Argument to complement operation not an integer or boolean.");
1343
 
1344
  /* Perform integral promotion for ANSI C/C++.
1345
     FIXME: What about FORTRAN ?  */
1346
  if (TYPE_LENGTH (type) < TYPE_LENGTH (builtin_type_int))
1347
    result_type = builtin_type_int;
1348
 
1349
  return value_from_longest (result_type, ~value_as_long (arg1));
1350
}
1351
 
1352
/* The INDEX'th bit of SET value whose VALUE_TYPE is TYPE,
1353
   and whose VALUE_CONTENTS is valaddr.
1354
   Return -1 if out of range, -2 other error. */
1355
 
1356
int
1357
value_bit_index (type, valaddr, index)
1358
     struct type *type;
1359
     char *valaddr;
1360
     int index;
1361
{
1362
  LONGEST low_bound, high_bound;
1363
  LONGEST word;
1364
  unsigned rel_index;
1365
  struct type *range = TYPE_FIELD_TYPE (type, 0);
1366
  if (get_discrete_bounds (range, &low_bound, &high_bound) < 0)
1367
    return -2;
1368
  if (index < low_bound || index > high_bound)
1369
    return -1;
1370
  rel_index = index - low_bound;
1371
  word = unpack_long (builtin_type_unsigned_char,
1372
                      valaddr + (rel_index / TARGET_CHAR_BIT));
1373
  rel_index %= TARGET_CHAR_BIT;
1374
  if (BITS_BIG_ENDIAN)
1375
    rel_index = TARGET_CHAR_BIT - 1 - rel_index;
1376
  return (word >> rel_index) & 1;
1377
}
1378
 
1379
value_ptr
1380
value_in (element, set)
1381
     value_ptr element, set;
1382
{
1383
  int member;
1384
  struct type *settype = check_typedef (VALUE_TYPE (set));
1385
  struct type *eltype = check_typedef (VALUE_TYPE (element));
1386
  if (TYPE_CODE (eltype) == TYPE_CODE_RANGE)
1387
    eltype = TYPE_TARGET_TYPE (eltype);
1388
  if (TYPE_CODE (settype) != TYPE_CODE_SET)
1389
    error ("Second argument of 'IN' has wrong type");
1390
  if (TYPE_CODE (eltype) != TYPE_CODE_INT
1391
      && TYPE_CODE (eltype) != TYPE_CODE_CHAR
1392
      && TYPE_CODE (eltype) != TYPE_CODE_ENUM
1393
      && TYPE_CODE (eltype) != TYPE_CODE_BOOL)
1394
    error ("First argument of 'IN' has wrong type");
1395
  member = value_bit_index (settype, VALUE_CONTENTS (set),
1396
                            value_as_long (element));
1397
  if (member < 0)
1398
    error ("First argument of 'IN' not in range");
1399
  return value_from_longest (LA_BOOL_TYPE, member);
1400
}
1401
 
1402
void
1403
_initialize_valarith ()
1404
{
1405
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.