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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gdb-7.1/] [gdb/] [python/] [py-value.c] - Blame information for rev 816

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 227 jeremybenn
/* Python interface to values.
2
 
3
   Copyright (C) 2008, 2009, 2010 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 3 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, see <http://www.gnu.org/licenses/>.  */
19
 
20
#include "defs.h"
21
#include "gdb_assert.h"
22
#include "charset.h"
23
#include "value.h"
24
#include "exceptions.h"
25
#include "language.h"
26
#include "dfp.h"
27
#include "valprint.h"
28
 
29
#ifdef HAVE_PYTHON
30
 
31
#include "python-internal.h"
32
 
33
/* Even though Python scalar types directly map to host types, we use
34
   target types here to remain consistent with the the values system in
35
   GDB (which uses target arithmetic).  */
36
 
37
/* Python's integer type corresponds to C's long type.  */
38
#define builtin_type_pyint builtin_type (python_gdbarch)->builtin_long
39
 
40
/* Python's float type corresponds to C's double type.  */
41
#define builtin_type_pyfloat builtin_type (python_gdbarch)->builtin_double
42
 
43
/* Python's long type corresponds to C's long long type.  */
44
#define builtin_type_pylong builtin_type (python_gdbarch)->builtin_long_long
45
 
46
#define builtin_type_pybool \
47
  language_bool_type (python_language, python_gdbarch)
48
 
49
#define builtin_type_pychar \
50
  language_string_char_type (python_language, python_gdbarch)
51
 
52
typedef struct value_object {
53
  PyObject_HEAD
54
  struct value_object *next;
55
  struct value_object *prev;
56
  struct value *value;
57
  PyObject *address;
58
  PyObject *type;
59
} value_object;
60
 
61
/* List of all values which are currently exposed to Python. It is
62
   maintained so that when an objfile is discarded, preserve_values
63
   can copy the values' types if needed.  */
64
/* This variable is unnecessarily initialized to NULL in order to
65
   work around a linker bug on MacOS.  */
66
static value_object *values_in_python = NULL;
67
 
68
/* Called by the Python interpreter when deallocating a value object.  */
69
static void
70
valpy_dealloc (PyObject *obj)
71
{
72
  value_object *self = (value_object *) obj;
73
 
74
  /* Remove SELF from the global list.  */
75
  if (self->prev)
76
    self->prev->next = self->next;
77
  else
78
    {
79
      gdb_assert (values_in_python == self);
80
      values_in_python = self->next;
81
    }
82
  if (self->next)
83
    self->next->prev = self->prev;
84
 
85
  value_free (self->value);
86
 
87
  if (self->address)
88
    /* Use braces to appease gcc warning.  *sigh*  */
89
    {
90
      Py_DECREF (self->address);
91
    }
92
 
93
  if (self->type)
94
    {
95
      Py_DECREF (self->type);
96
    }
97
 
98
  self->ob_type->tp_free (self);
99
}
100
 
101
/* Helper to push a Value object on the global list.  */
102
static void
103
note_value (value_object *value_obj)
104
{
105
  value_obj->next = values_in_python;
106
  if (value_obj->next)
107
    value_obj->next->prev = value_obj;
108
  value_obj->prev = NULL;
109
  values_in_python = value_obj;
110
}
111
 
112
/* Called when a new gdb.Value object needs to be allocated.  */
113
static PyObject *
114
valpy_new (PyTypeObject *subtype, PyObject *args, PyObject *keywords)
115
{
116
  struct value *value = NULL;   /* Initialize to appease gcc warning.  */
117
  value_object *value_obj;
118
 
119
  if (PyTuple_Size (args) != 1)
120
    {
121
      PyErr_SetString (PyExc_TypeError, _("Value object creation takes only "
122
                                          "1 argument"));
123
      return NULL;
124
    }
125
 
126
  value_obj = (value_object *) subtype->tp_alloc (subtype, 1);
127
  if (value_obj == NULL)
128
    {
129
      PyErr_SetString (PyExc_MemoryError, _("Could not allocate memory to "
130
                                            "create Value object."));
131
      return NULL;
132
    }
133
 
134
  value = convert_value_from_python (PyTuple_GetItem (args, 0));
135
  if (value == NULL)
136
    {
137
      subtype->tp_free (value_obj);
138
      return NULL;
139
    }
140
 
141
  value_obj->value = value;
142
  value_incref (value);
143
  value_obj->address = NULL;
144
  value_obj->type = NULL;
145
  note_value (value_obj);
146
 
147
  return (PyObject *) value_obj;
148
}
149
 
150
/* Iterate over all the Value objects, calling preserve_one_value on
151
   each.  */
152
void
153
preserve_python_values (struct objfile *objfile, htab_t copied_types)
154
{
155
  value_object *iter;
156
 
157
  for (iter = values_in_python; iter; iter = iter->next)
158
    preserve_one_value (iter->value, objfile, copied_types);
159
}
160
 
161
/* Given a value of a pointer type, apply the C unary * operator to it.  */
162
static PyObject *
163
valpy_dereference (PyObject *self, PyObject *args)
164
{
165
  struct value *res_val = NULL;   /* Initialize to appease gcc warning.  */
166
  volatile struct gdb_exception except;
167
 
168
  TRY_CATCH (except, RETURN_MASK_ALL)
169
    {
170
      res_val = value_ind (((value_object *) self)->value);
171
    }
172
  GDB_PY_HANDLE_EXCEPTION (except);
173
 
174
  return value_to_value_object (res_val);
175
}
176
 
177
/* Return "&value".  */
178
static PyObject *
179
valpy_get_address (PyObject *self, void *closure)
180
{
181
  struct value *res_val = NULL;   /* Initialize to appease gcc warning.  */
182
  value_object *val_obj = (value_object *) self;
183
  volatile struct gdb_exception except;
184
 
185
  if (!val_obj->address)
186
    {
187
      TRY_CATCH (except, RETURN_MASK_ALL)
188
        {
189
          res_val = value_addr (val_obj->value);
190
        }
191
      if (except.reason < 0)
192
        {
193
          val_obj->address = Py_None;
194
          Py_INCREF (Py_None);
195
        }
196
      else
197
        val_obj->address = value_to_value_object (res_val);
198
    }
199
 
200
  Py_INCREF (val_obj->address);
201
 
202
  return val_obj->address;
203
}
204
 
205
/* Return type of the value.  */
206
static PyObject *
207
valpy_get_type (PyObject *self, void *closure)
208
{
209
  value_object *obj = (value_object *) self;
210
  if (!obj->type)
211
    {
212
      obj->type = type_to_type_object (value_type (obj->value));
213
      if (!obj->type)
214
        {
215
          obj->type = Py_None;
216
          Py_INCREF (obj->type);
217
        }
218
    }
219
  Py_INCREF (obj->type);
220
  return obj->type;
221
}
222
 
223
/* Implementation of gdb.Value.lazy_string ([encoding] [, length]) ->
224
   string.  Return a PyObject representing a lazy_string_object type.
225
   A lazy string is a pointer to a string with an optional encoding and
226
   length.  If ENCODING is not given, encoding is set to None.  If an
227
   ENCODING is provided the encoding parameter is set to ENCODING, but
228
   the string is not encoded.  If LENGTH is provided then the length
229
   parameter is set to LENGTH, otherwise length will be set to -1 (first
230
   null of appropriate with).  */
231
static PyObject *
232
valpy_lazy_string (PyObject *self, PyObject *args, PyObject *kw)
233
{
234
  int length = -1;
235
  struct value *value = ((value_object *) self)->value;
236
  const char *user_encoding = NULL;
237
  static char *keywords[] = { "encoding", "length", NULL };
238
  PyObject *str_obj;
239
 
240
  if (!PyArg_ParseTupleAndKeywords (args, kw, "|si", keywords,
241
                                    &user_encoding, &length))
242
    return NULL;
243
 
244
  if (TYPE_CODE (value_type (value)) == TYPE_CODE_PTR)
245
    value = value_ind (value);
246
 
247
  str_obj = gdbpy_create_lazy_string_object (value_address (value), length,
248
                                             user_encoding, value_type (value));
249
 
250
  return (PyObject *) str_obj;
251
}
252
 
253
/* Implementation of gdb.Value.string ([encoding] [, errors]
254
   [, length]) -> string.  Return Unicode string with value contents.
255
   If ENCODING is not given, the string is assumed to be encoded in
256
   the target's charset.  If LENGTH is provided, only fetch string to
257
   the length provided.  */
258
 
259
static PyObject *
260
valpy_string (PyObject *self, PyObject *args, PyObject *kw)
261
{
262
  int length = -1, ret = 0;
263
  gdb_byte *buffer;
264
  struct value *value = ((value_object *) self)->value;
265
  volatile struct gdb_exception except;
266
  PyObject *unicode;
267
  const char *encoding = NULL;
268
  const char *errors = NULL;
269
  const char *user_encoding = NULL;
270
  const char *la_encoding = NULL;
271
  struct type *char_type;
272
  static char *keywords[] = { "encoding", "errors", "length", NULL };
273
 
274
  if (!PyArg_ParseTupleAndKeywords (args, kw, "|ssi", keywords,
275
                                    &user_encoding, &errors, &length))
276
    return NULL;
277
 
278
  TRY_CATCH (except, RETURN_MASK_ALL)
279
    {
280
      LA_GET_STRING (value, &buffer, &length, &char_type, &la_encoding);
281
    }
282
  GDB_PY_HANDLE_EXCEPTION (except);
283
 
284
  encoding = (user_encoding && *user_encoding) ? user_encoding : la_encoding;
285
  unicode = PyUnicode_Decode (buffer, length * TYPE_LENGTH (char_type),
286
                              encoding, errors);
287
  xfree (buffer);
288
 
289
  return unicode;
290
}
291
 
292
/* Cast a value to a given type.  */
293
static PyObject *
294
valpy_cast (PyObject *self, PyObject *args)
295
{
296
  PyObject *type_obj;
297
  struct type *type;
298
  struct value *res_val = NULL;   /* Initialize to appease gcc warning.  */
299
  volatile struct gdb_exception except;
300
 
301
  if (! PyArg_ParseTuple (args, "O", &type_obj))
302
    return NULL;
303
 
304
  type = type_object_to_type (type_obj);
305
  if (! type)
306
    {
307
      PyErr_SetString (PyExc_RuntimeError, "argument must be a Type");
308
      return NULL;
309
    }
310
 
311
  TRY_CATCH (except, RETURN_MASK_ALL)
312
    {
313
      res_val = value_cast (type, ((value_object *) self)->value);
314
    }
315
  GDB_PY_HANDLE_EXCEPTION (except);
316
 
317
  return value_to_value_object (res_val);
318
}
319
 
320
static Py_ssize_t
321
valpy_length (PyObject *self)
322
{
323
  /* We don't support getting the number of elements in a struct / class.  */
324
  PyErr_SetString (PyExc_NotImplementedError,
325
                   "Invalid operation on gdb.Value.");
326
  return -1;
327
}
328
 
329
/* Given string name of an element inside structure, return its value
330
   object.  */
331
static PyObject *
332
valpy_getitem (PyObject *self, PyObject *key)
333
{
334
  value_object *self_value = (value_object *) self;
335
  char *field = NULL;
336
  struct value *res_val = NULL;
337
  volatile struct gdb_exception except;
338
 
339
  if (gdbpy_is_string (key))
340
    {
341
      field = python_string_to_host_string (key);
342
      if (field == NULL)
343
        return NULL;
344
    }
345
 
346
  TRY_CATCH (except, RETURN_MASK_ALL)
347
    {
348
      struct value *tmp = self_value->value;
349
 
350
      if (field)
351
        res_val = value_struct_elt (&tmp, NULL, field, 0, NULL);
352
      else
353
        {
354
          /* Assume we are attempting an array access, and let the
355
             value code throw an exception if the index has an invalid
356
             type.  */
357
          struct value *idx = convert_value_from_python (key);
358
          if (idx != NULL)
359
            {
360
              /* Check the value's type is something that can be accessed via
361
                 a subscript.  */
362
              struct type *type;
363
              tmp = coerce_ref (tmp);
364
              type = check_typedef (value_type (tmp));
365
              if (TYPE_CODE (type) != TYPE_CODE_ARRAY
366
                  && TYPE_CODE (type) != TYPE_CODE_PTR)
367
                  error( _("Cannot subscript requested type"));
368
              else
369
                res_val = value_subscript (tmp, value_as_long (idx));
370
            }
371
        }
372
    }
373
 
374
  xfree (field);
375
  GDB_PY_HANDLE_EXCEPTION (except);
376
 
377
  return res_val ? value_to_value_object (res_val) : NULL;
378
}
379
 
380
static int
381
valpy_setitem (PyObject *self, PyObject *key, PyObject *value)
382
{
383
  PyErr_Format (PyExc_NotImplementedError,
384
                _("Setting of struct elements is not currently supported."));
385
  return -1;
386
}
387
 
388
/* Called by the Python interpreter to obtain string representation
389
   of the object.  */
390
static PyObject *
391
valpy_str (PyObject *self)
392
{
393
  char *s = NULL;
394
  struct ui_file *stb;
395
  struct cleanup *old_chain;
396
  PyObject *result;
397
  struct value_print_options opts;
398
  volatile struct gdb_exception except;
399
 
400
  get_user_print_options (&opts);
401
  opts.deref_ref = 0;
402
 
403
  stb = mem_fileopen ();
404
  old_chain = make_cleanup_ui_file_delete (stb);
405
 
406
  TRY_CATCH (except, RETURN_MASK_ALL)
407
    {
408
      common_val_print (((value_object *) self)->value, stb, 0,
409
                        &opts, python_language);
410
      s = ui_file_xstrdup (stb, NULL);
411
    }
412
  GDB_PY_HANDLE_EXCEPTION (except);
413
 
414
  do_cleanups (old_chain);
415
 
416
  result = PyUnicode_Decode (s, strlen (s), host_charset (), NULL);
417
  xfree (s);
418
 
419
  return result;
420
}
421
 
422
/* Implements gdb.Value.is_optimized_out.  */
423
static PyObject *
424
valpy_get_is_optimized_out (PyObject *self, void *closure)
425
{
426
  struct value *value = ((value_object *) self)->value;
427
 
428
  if (value_optimized_out (value))
429
    Py_RETURN_TRUE;
430
 
431
  Py_RETURN_FALSE;
432
}
433
 
434
enum valpy_opcode
435
{
436
  VALPY_ADD,
437
  VALPY_SUB,
438
  VALPY_MUL,
439
  VALPY_DIV,
440
  VALPY_REM,
441
  VALPY_POW,
442
  VALPY_LSH,
443
  VALPY_RSH,
444
  VALPY_BITAND,
445
  VALPY_BITOR,
446
  VALPY_BITXOR
447
};
448
 
449
/* If TYPE is a reference, return the target; otherwise return TYPE.  */
450
#define STRIP_REFERENCE(TYPE) \
451
  ((TYPE_CODE (TYPE) == TYPE_CODE_REF) ? (TYPE_TARGET_TYPE (TYPE)) : (TYPE))
452
 
453
/* Returns a value object which is the result of applying the operation
454
   specified by OPCODE to the given arguments.  */
455
static PyObject *
456
valpy_binop (enum valpy_opcode opcode, PyObject *self, PyObject *other)
457
{
458
  struct value *res_val = NULL;   /* Initialize to appease gcc warning.  */
459
  volatile struct gdb_exception except;
460
 
461
  TRY_CATCH (except, RETURN_MASK_ALL)
462
    {
463
      struct value *arg1, *arg2;
464
 
465
      /* If the gdb.Value object is the second operand, then it will be passed
466
         to us as the OTHER argument, and SELF will be an entirely different
467
         kind of object, altogether.  Because of this, we can't assume self is
468
         a gdb.Value object and need to convert it from python as well.  */
469
      arg1 = convert_value_from_python (self);
470
      if (arg1 == NULL)
471
        break;
472
 
473
      arg2 = convert_value_from_python (other);
474
      if (arg2 == NULL)
475
        break;
476
 
477
      switch (opcode)
478
        {
479
        case VALPY_ADD:
480
          {
481
            struct type *ltype = value_type (arg1);
482
            struct type *rtype = value_type (arg2);
483
 
484
            CHECK_TYPEDEF (ltype);
485
            ltype = STRIP_REFERENCE (ltype);
486
            CHECK_TYPEDEF (rtype);
487
            rtype = STRIP_REFERENCE (rtype);
488
 
489
            if (TYPE_CODE (ltype) == TYPE_CODE_PTR
490
                && is_integral_type (rtype))
491
              res_val = value_ptradd (arg1, value_as_long (arg2));
492
            else if (TYPE_CODE (rtype) == TYPE_CODE_PTR
493
                     && is_integral_type (ltype))
494
              res_val = value_ptradd (arg2, value_as_long (arg1));
495
            else
496
              res_val = value_binop (arg1, arg2, BINOP_ADD);
497
          }
498
          break;
499
        case VALPY_SUB:
500
          {
501
            struct type *ltype = value_type (arg1);
502
            struct type *rtype = value_type (arg2);
503
 
504
            CHECK_TYPEDEF (ltype);
505
            ltype = STRIP_REFERENCE (ltype);
506
            CHECK_TYPEDEF (rtype);
507
            rtype = STRIP_REFERENCE (rtype);
508
 
509
            if (TYPE_CODE (ltype) == TYPE_CODE_PTR
510
                && TYPE_CODE (rtype) == TYPE_CODE_PTR)
511
              /* A ptrdiff_t for the target would be preferable here.  */
512
              res_val = value_from_longest (builtin_type_pyint,
513
                                            value_ptrdiff (arg1, arg2));
514
            else if (TYPE_CODE (ltype) == TYPE_CODE_PTR
515
                     && is_integral_type (rtype))
516
              res_val = value_ptradd (arg1, - value_as_long (arg2));
517
            else
518
              res_val = value_binop (arg1, arg2, BINOP_SUB);
519
          }
520
          break;
521
        case VALPY_MUL:
522
          res_val = value_binop (arg1, arg2, BINOP_MUL);
523
          break;
524
        case VALPY_DIV:
525
          res_val = value_binop (arg1, arg2, BINOP_DIV);
526
          break;
527
        case VALPY_REM:
528
          res_val = value_binop (arg1, arg2, BINOP_REM);
529
          break;
530
        case VALPY_POW:
531
          res_val = value_binop (arg1, arg2, BINOP_EXP);
532
          break;
533
        case VALPY_LSH:
534
          res_val = value_binop (arg1, arg2, BINOP_LSH);
535
          break;
536
        case VALPY_RSH:
537
          res_val = value_binop (arg1, arg2, BINOP_RSH);
538
          break;
539
        case VALPY_BITAND:
540
          res_val = value_binop (arg1, arg2, BINOP_BITWISE_AND);
541
          break;
542
        case VALPY_BITOR:
543
          res_val = value_binop (arg1, arg2, BINOP_BITWISE_IOR);
544
          break;
545
        case VALPY_BITXOR:
546
          res_val = value_binop (arg1, arg2, BINOP_BITWISE_XOR);
547
          break;
548
        }
549
    }
550
  GDB_PY_HANDLE_EXCEPTION (except);
551
 
552
  return res_val ? value_to_value_object (res_val) : NULL;
553
}
554
 
555
static PyObject *
556
valpy_add (PyObject *self, PyObject *other)
557
{
558
  return valpy_binop (VALPY_ADD, self, other);
559
}
560
 
561
static PyObject *
562
valpy_subtract (PyObject *self, PyObject *other)
563
{
564
  return valpy_binop (VALPY_SUB, self, other);
565
}
566
 
567
static PyObject *
568
valpy_multiply (PyObject *self, PyObject *other)
569
{
570
  return valpy_binop (VALPY_MUL, self, other);
571
}
572
 
573
static PyObject *
574
valpy_divide (PyObject *self, PyObject *other)
575
{
576
  return valpy_binop (VALPY_DIV, self, other);
577
}
578
 
579
static PyObject *
580
valpy_remainder (PyObject *self, PyObject *other)
581
{
582
  return valpy_binop (VALPY_REM, self, other);
583
}
584
 
585
static PyObject *
586
valpy_power (PyObject *self, PyObject *other, PyObject *unused)
587
{
588
  /* We don't support the ternary form of pow.  I don't know how to express
589
     that, so let's just throw NotImplementedError to at least do something
590
     about it.  */
591
  if (unused != Py_None)
592
    {
593
      PyErr_SetString (PyExc_NotImplementedError,
594
                       "Invalid operation on gdb.Value.");
595
      return NULL;
596
    }
597
 
598
  return valpy_binop (VALPY_POW, self, other);
599
}
600
 
601
static PyObject *
602
valpy_negative (PyObject *self)
603
{
604
  struct value *val = NULL;
605
  volatile struct gdb_exception except;
606
 
607
  TRY_CATCH (except, RETURN_MASK_ALL)
608
    {
609
      val = value_neg (((value_object *) self)->value);
610
    }
611
  GDB_PY_HANDLE_EXCEPTION (except);
612
 
613
  return value_to_value_object (val);
614
}
615
 
616
static PyObject *
617
valpy_positive (PyObject *self)
618
{
619
  return value_to_value_object (((value_object *) self)->value);
620
}
621
 
622
static PyObject *
623
valpy_absolute (PyObject *self)
624
{
625
  struct value *value = ((value_object *) self)->value;
626
  if (value_less (value, value_zero (value_type (value), not_lval)))
627
    return valpy_negative (self);
628
  else
629
    return valpy_positive (self);
630
}
631
 
632
/* Implements boolean evaluation of gdb.Value.  */
633
static int
634
valpy_nonzero (PyObject *self)
635
{
636
  value_object *self_value = (value_object *) self;
637
  struct type *type;
638
 
639
  type = check_typedef (value_type (self_value->value));
640
 
641
  if (is_integral_type (type) || TYPE_CODE (type) == TYPE_CODE_PTR)
642
    return !!value_as_long (self_value->value);
643
  else if (TYPE_CODE (type) == TYPE_CODE_FLT)
644
    return value_as_double (self_value->value) != 0;
645
  else if (TYPE_CODE (type) == TYPE_CODE_DECFLOAT)
646
    return !decimal_is_zero (value_contents (self_value->value),
647
                             TYPE_LENGTH (type),
648
                             gdbarch_byte_order (get_type_arch (type)));
649
  else
650
    {
651
      PyErr_SetString (PyExc_TypeError, _("Attempted truth testing on invalid "
652
                                          "gdb.Value type."));
653
      return 0;
654
    }
655
}
656
 
657
/* Implements ~ for value objects.  */
658
static PyObject *
659
valpy_invert (PyObject *self)
660
{
661
  struct value *val = NULL;
662
  volatile struct gdb_exception except;
663
 
664
  TRY_CATCH (except, RETURN_MASK_ALL)
665
    {
666
      val = value_complement (((value_object *) self)->value);
667
    }
668
  GDB_PY_HANDLE_EXCEPTION (except);
669
 
670
  return value_to_value_object (val);
671
}
672
 
673
/* Implements left shift for value objects.  */
674
static PyObject *
675
valpy_lsh (PyObject *self, PyObject *other)
676
{
677
  return valpy_binop (VALPY_LSH, self, other);
678
}
679
 
680
/* Implements right shift for value objects.  */
681
static PyObject *
682
valpy_rsh (PyObject *self, PyObject *other)
683
{
684
  return valpy_binop (VALPY_RSH, self, other);
685
}
686
 
687
/* Implements bitwise and for value objects.  */
688
static PyObject *
689
valpy_and (PyObject *self, PyObject *other)
690
{
691
  return valpy_binop (VALPY_BITAND, self, other);
692
}
693
 
694
/* Implements bitwise or for value objects.  */
695
static PyObject *
696
valpy_or (PyObject *self, PyObject *other)
697
{
698
  return valpy_binop (VALPY_BITOR, self, other);
699
}
700
 
701
/* Implements bitwise xor for value objects.  */
702
static PyObject *
703
valpy_xor (PyObject *self, PyObject *other)
704
{
705
  return valpy_binop (VALPY_BITXOR, self, other);
706
}
707
 
708
/* Implements comparison operations for value objects.  */
709
static PyObject *
710
valpy_richcompare (PyObject *self, PyObject *other, int op)
711
{
712
  int result = 0;
713
  struct value *value_other;
714
  volatile struct gdb_exception except;
715
 
716
  if (other == Py_None)
717
    /* Comparing with None is special.  From what I can tell, in Python
718
       None is smaller than anything else.  */
719
    switch (op) {
720
      case Py_LT:
721
      case Py_LE:
722
      case Py_EQ:
723
        Py_RETURN_FALSE;
724
      case Py_NE:
725
      case Py_GT:
726
      case Py_GE:
727
        Py_RETURN_TRUE;
728
      default:
729
        /* Can't happen.  */
730
        PyErr_SetString (PyExc_NotImplementedError,
731
                         "Invalid operation on gdb.Value.");
732
        return NULL;
733
    }
734
 
735
  TRY_CATCH (except, RETURN_MASK_ALL)
736
    {
737
      value_other = convert_value_from_python (other);
738
      if (value_other == NULL)
739
        {
740
          result = -1;
741
          break;
742
        }
743
 
744
      switch (op) {
745
        case Py_LT:
746
          result = value_less (((value_object *) self)->value, value_other);
747
          break;
748
        case Py_LE:
749
          result = value_less (((value_object *) self)->value, value_other)
750
            || value_equal (((value_object *) self)->value, value_other);
751
          break;
752
        case Py_EQ:
753
          result = value_equal (((value_object *) self)->value, value_other);
754
          break;
755
        case Py_NE:
756
          result = !value_equal (((value_object *) self)->value, value_other);
757
          break;
758
        case Py_GT:
759
          result = value_less (value_other, ((value_object *) self)->value);
760
          break;
761
        case Py_GE:
762
          result = value_less (value_other, ((value_object *) self)->value)
763
            || value_equal (((value_object *) self)->value, value_other);
764
          break;
765
        default:
766
          /* Can't happen.  */
767
          PyErr_SetString (PyExc_NotImplementedError,
768
                           "Invalid operation on gdb.Value.");
769
          result = -1;
770
          break;
771
      }
772
    }
773
  GDB_PY_HANDLE_EXCEPTION (except);
774
 
775
  /* In this case, the Python exception has already been set.  */
776
  if (result < 0)
777
    return NULL;
778
 
779
  if (result == 1)
780
    Py_RETURN_TRUE;
781
 
782
  Py_RETURN_FALSE;
783
}
784
 
785
/* Helper function to determine if a type is "int-like".  */
786
static int
787
is_intlike (struct type *type, int ptr_ok)
788
{
789
  CHECK_TYPEDEF (type);
790
  return (TYPE_CODE (type) == TYPE_CODE_INT
791
          || TYPE_CODE (type) == TYPE_CODE_ENUM
792
          || TYPE_CODE (type) == TYPE_CODE_BOOL
793
          || TYPE_CODE (type) == TYPE_CODE_CHAR
794
          || (ptr_ok && TYPE_CODE (type) == TYPE_CODE_PTR));
795
}
796
 
797
/* Implements conversion to int.  */
798
static PyObject *
799
valpy_int (PyObject *self)
800
{
801
  struct value *value = ((value_object *) self)->value;
802
  struct type *type = value_type (value);
803
  LONGEST l = 0;
804
  volatile struct gdb_exception except;
805
 
806
  CHECK_TYPEDEF (type);
807
  if (!is_intlike (type, 0))
808
    {
809
      PyErr_SetString (PyExc_RuntimeError, "cannot convert value to int");
810
      return NULL;
811
    }
812
 
813
  TRY_CATCH (except, RETURN_MASK_ALL)
814
    {
815
      l = value_as_long (value);
816
    }
817
  GDB_PY_HANDLE_EXCEPTION (except);
818
 
819
#ifdef HAVE_LONG_LONG           /* Defined by Python.  */
820
  /* If we have 'long long', and the value overflows a 'long', use a
821
     Python Long; otherwise use a Python Int.  */
822
  if (sizeof (l) > sizeof (long) && (l > PyInt_GetMax ()
823
                                     || l < (- (LONGEST) PyInt_GetMax ()) - 1))
824
    return PyLong_FromLongLong (l);
825
#endif
826
  return PyInt_FromLong (l);
827
}
828
 
829
/* Implements conversion to long.  */
830
static PyObject *
831
valpy_long (PyObject *self)
832
{
833
  struct value *value = ((value_object *) self)->value;
834
  struct type *type = value_type (value);
835
  LONGEST l = 0;
836
  volatile struct gdb_exception except;
837
 
838
  if (!is_intlike (type, 1))
839
    {
840
      PyErr_SetString (PyExc_RuntimeError, "cannot convert value to long");
841
      return NULL;
842
    }
843
 
844
  TRY_CATCH (except, RETURN_MASK_ALL)
845
    {
846
      l = value_as_long (value);
847
    }
848
  GDB_PY_HANDLE_EXCEPTION (except);
849
 
850
#ifdef HAVE_LONG_LONG           /* Defined by Python.  */
851
  return PyLong_FromLongLong (l);
852
#else
853
  return PyLong_FromLong (l);
854
#endif
855
}
856
 
857
/* Implements conversion to float.  */
858
static PyObject *
859
valpy_float (PyObject *self)
860
{
861
  struct value *value = ((value_object *) self)->value;
862
  struct type *type = value_type (value);
863
  double d = 0;
864
  volatile struct gdb_exception except;
865
 
866
  CHECK_TYPEDEF (type);
867
  if (TYPE_CODE (type) != TYPE_CODE_FLT)
868
    {
869
      PyErr_SetString (PyExc_RuntimeError, "cannot convert value to float");
870
      return NULL;
871
    }
872
 
873
  TRY_CATCH (except, RETURN_MASK_ALL)
874
    {
875
      d = value_as_double (value);
876
    }
877
  GDB_PY_HANDLE_EXCEPTION (except);
878
 
879
  return PyFloat_FromDouble (d);
880
}
881
 
882
/* Returns an object for a value which is released from the all_values chain,
883
   so its lifetime is not bound to the execution of a command.  */
884
PyObject *
885
value_to_value_object (struct value *val)
886
{
887
  value_object *val_obj;
888
 
889
  val_obj = PyObject_New (value_object, &value_object_type);
890
  if (val_obj != NULL)
891
    {
892
      val_obj->value = val;
893
      value_incref (val);
894
      val_obj->address = NULL;
895
      val_obj->type = NULL;
896
      note_value (val_obj);
897
    }
898
 
899
  return (PyObject *) val_obj;
900
}
901
 
902
/* Returns a borrowed reference to the struct value corresponding to
903
   the given value object.  */
904
struct value *
905
value_object_to_value (PyObject *self)
906
{
907
  value_object *real;
908
  if (! PyObject_TypeCheck (self, &value_object_type))
909
    return NULL;
910
  real = (value_object *) self;
911
  return real->value;
912
}
913
 
914
/* Try to convert a Python value to a gdb value.  If the value cannot
915
   be converted, set a Python exception and return NULL.  Returns a
916
   reference to a new value on the all_values chain.  */
917
 
918
struct value *
919
convert_value_from_python (PyObject *obj)
920
{
921
  struct value *value = NULL; /* -Wall */
922
  PyObject *target_str, *unicode_str;
923
  struct cleanup *old;
924
  volatile struct gdb_exception except;
925
  int cmp;
926
 
927
  gdb_assert (obj != NULL);
928
 
929
  TRY_CATCH (except, RETURN_MASK_ALL)
930
    {
931
      if (PyBool_Check (obj))
932
        {
933
          cmp = PyObject_IsTrue (obj);
934
          if (cmp >= 0)
935
            value = value_from_longest (builtin_type_pybool, cmp);
936
        }
937
      else if (PyInt_Check (obj))
938
        {
939
          long l = PyInt_AsLong (obj);
940
 
941
          if (! PyErr_Occurred ())
942
            value = value_from_longest (builtin_type_pyint, l);
943
        }
944
      else if (PyLong_Check (obj))
945
        {
946
          LONGEST l = PyLong_AsLongLong (obj);
947
 
948
          if (! PyErr_Occurred ())
949
            value = value_from_longest (builtin_type_pylong, l);
950
        }
951
      else if (PyFloat_Check (obj))
952
        {
953
          double d = PyFloat_AsDouble (obj);
954
 
955
          if (! PyErr_Occurred ())
956
            value = value_from_double (builtin_type_pyfloat, d);
957
        }
958
      else if (gdbpy_is_string (obj))
959
        {
960
          char *s;
961
 
962
          s = python_string_to_target_string (obj);
963
          if (s != NULL)
964
            {
965
              old = make_cleanup (xfree, s);
966
              value = value_cstring (s, strlen (s), builtin_type_pychar);
967
              do_cleanups (old);
968
            }
969
        }
970
      else if (PyObject_TypeCheck (obj, &value_object_type))
971
        value = value_copy (((value_object *) obj)->value);
972
      else if (gdbpy_is_lazy_string (obj))
973
        {
974
          PyObject *result;
975
          PyObject *function = PyString_FromString ("value");
976
          result = PyObject_CallMethodObjArgs (obj, function,  NULL);
977
          value = value_copy (((value_object *) result)->value);
978
        }
979
      else
980
        PyErr_Format (PyExc_TypeError, _("Could not convert Python object: %s"),
981
                      PyString_AsString (PyObject_Str (obj)));
982
    }
983
  if (except.reason < 0)
984
    {
985
      PyErr_Format (except.reason == RETURN_QUIT
986
                    ? PyExc_KeyboardInterrupt : PyExc_RuntimeError,
987
                    "%s", except.message);
988
      return NULL;
989
    }
990
 
991
  return value;
992
}
993
 
994
/* Returns value object in the ARGth position in GDB's history.  */
995
PyObject *
996
gdbpy_history (PyObject *self, PyObject *args)
997
{
998
  int i;
999
  struct value *res_val = NULL;   /* Initialize to appease gcc warning.  */
1000
  volatile struct gdb_exception except;
1001
 
1002
  if (!PyArg_ParseTuple (args, "i", &i))
1003
    return NULL;
1004
 
1005
  TRY_CATCH (except, RETURN_MASK_ALL)
1006
    {
1007
      res_val = access_value_history (i);
1008
    }
1009
  GDB_PY_HANDLE_EXCEPTION (except);
1010
 
1011
  return value_to_value_object (res_val);
1012
}
1013
 
1014
void
1015
gdbpy_initialize_values (void)
1016
{
1017
  if (PyType_Ready (&value_object_type) < 0)
1018
    return;
1019
 
1020
  Py_INCREF (&value_object_type);
1021
  PyModule_AddObject (gdb_module, "Value", (PyObject *) &value_object_type);
1022
 
1023
  values_in_python = NULL;
1024
}
1025
 
1026
 
1027
 
1028
static PyGetSetDef value_object_getset[] = {
1029
  { "address", valpy_get_address, NULL, "The address of the value.",
1030
    NULL },
1031
  { "is_optimized_out", valpy_get_is_optimized_out, NULL,
1032
    "Boolean telling whether the value is optimized out (i.e., not available).",
1033
    NULL },
1034
  { "type", valpy_get_type, NULL, "Type of the value.", NULL },
1035
  {NULL}  /* Sentinel */
1036
};
1037
 
1038
static PyMethodDef value_object_methods[] = {
1039
  { "cast", valpy_cast, METH_VARARGS, "Cast the value to the supplied type." },
1040
  { "dereference", valpy_dereference, METH_NOARGS, "Dereferences the value." },
1041
  { "lazy_string", (PyCFunction) valpy_lazy_string, METH_VARARGS | METH_KEYWORDS,
1042
    "lazy_string ([encoding]  [, length]) -> lazy_string\n\
1043
Return a lazy string representation of the value." },
1044
  { "string", (PyCFunction) valpy_string, METH_VARARGS | METH_KEYWORDS,
1045
    "string ([encoding] [, errors] [, length]) -> string\n\
1046
Return Unicode string representation of the value." },
1047
  {NULL}  /* Sentinel */
1048
};
1049
 
1050
static PyNumberMethods value_object_as_number = {
1051
  valpy_add,
1052
  valpy_subtract,
1053
  valpy_multiply,
1054
  valpy_divide,
1055
  valpy_remainder,
1056
  NULL,                       /* nb_divmod */
1057
  valpy_power,                /* nb_power */
1058
  valpy_negative,             /* nb_negative */
1059
  valpy_positive,             /* nb_positive */
1060
  valpy_absolute,             /* nb_absolute */
1061
  valpy_nonzero,              /* nb_nonzero */
1062
  valpy_invert,               /* nb_invert */
1063
  valpy_lsh,                  /* nb_lshift */
1064
  valpy_rsh,                  /* nb_rshift */
1065
  valpy_and,                  /* nb_and */
1066
  valpy_xor,                  /* nb_xor */
1067
  valpy_or,                   /* nb_or */
1068
  NULL,                       /* nb_coerce */
1069
  valpy_int,                  /* nb_int */
1070
  valpy_long,                 /* nb_long */
1071
  valpy_float,                /* nb_float */
1072
  NULL,                       /* nb_oct */
1073
  NULL                        /* nb_hex */
1074
};
1075
 
1076
static PyMappingMethods value_object_as_mapping = {
1077
  valpy_length,
1078
  valpy_getitem,
1079
  valpy_setitem
1080
};
1081
 
1082
PyTypeObject value_object_type = {
1083
  PyObject_HEAD_INIT (NULL)
1084
  0,                               /*ob_size*/
1085
  "gdb.Value",                    /*tp_name*/
1086
  sizeof (value_object),          /*tp_basicsize*/
1087
  0,                               /*tp_itemsize*/
1088
  valpy_dealloc,                  /*tp_dealloc*/
1089
  0,                               /*tp_print*/
1090
  0,                               /*tp_getattr*/
1091
  0,                               /*tp_setattr*/
1092
  0,                               /*tp_compare*/
1093
  0,                               /*tp_repr*/
1094
  &value_object_as_number,        /*tp_as_number*/
1095
  0,                               /*tp_as_sequence*/
1096
  &value_object_as_mapping,       /*tp_as_mapping*/
1097
  0,                               /*tp_hash */
1098
  0,                               /*tp_call*/
1099
  valpy_str,                      /*tp_str*/
1100
  0,                               /*tp_getattro*/
1101
  0,                               /*tp_setattro*/
1102
  0,                               /*tp_as_buffer*/
1103
  Py_TPFLAGS_DEFAULT | Py_TPFLAGS_CHECKTYPES,   /*tp_flags*/
1104
  "GDB value object",             /* tp_doc */
1105
  0,                               /* tp_traverse */
1106
  0,                               /* tp_clear */
1107
  valpy_richcompare,              /* tp_richcompare */
1108
  0,                               /* tp_weaklistoffset */
1109
  0,                               /* tp_iter */
1110
  0,                               /* tp_iternext */
1111
  value_object_methods,           /* tp_methods */
1112
  0,                               /* tp_members */
1113
  value_object_getset,            /* tp_getset */
1114
  0,                               /* tp_base */
1115
  0,                               /* tp_dict */
1116
  0,                               /* tp_descr_get */
1117
  0,                               /* tp_descr_set */
1118
  0,                               /* tp_dictoffset */
1119
  0,                               /* tp_init */
1120
  0,                               /* tp_alloc */
1121
  valpy_new                       /* tp_new */
1122
};
1123
 
1124
#else
1125
 
1126
void
1127
preserve_python_values (struct objfile *objfile, htab_t copied_types)
1128
{
1129
  /* Nothing.  */
1130
}
1131
 
1132
#endif /* HAVE_PYTHON */

powered by: WebSVN 2.1.0

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