Commit | Line | Data |
---|---|---|
7843261b TJB |
1 | /* Python interface to values. |
2 | ||
0fb0cc75 | 3 | Copyright (C) 2008, 2009 Free Software Foundation, Inc. |
7843261b TJB |
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" | |
08c637de | 21 | #include "gdb_assert.h" |
7843261b TJB |
22 | #include "charset.h" |
23 | #include "value.h" | |
24 | #include "exceptions.h" | |
25 | #include "language.h" | |
26 | #include "dfp.h" | |
79a45b7d | 27 | #include "valprint.h" |
7843261b TJB |
28 | |
29 | /* List of all values which are currently exposed to Python. It is | |
30 | maintained so that when an objfile is discarded, preserve_values | |
31 | can copy the values' types if needed. This is declared | |
32 | unconditionally to reduce the number of uses of HAVE_PYTHON in the | |
33 | generic code. */ | |
4be15b7a JB |
34 | /* This variable is unnecessarily initialized to NULL in order to |
35 | work around a linker bug on MacOS. */ | |
36 | struct value *values_in_python = NULL; | |
7843261b TJB |
37 | |
38 | #ifdef HAVE_PYTHON | |
39 | ||
40 | #include "python-internal.h" | |
41 | ||
42 | /* Even though Python scalar types directly map to host types, we use | |
43 | target types here to remain consistent with the the values system in | |
44 | GDB (which uses target arithmetic). */ | |
45 | ||
46 | /* Python's integer type corresponds to C's long type. */ | |
47 | #define builtin_type_pyint builtin_type (current_gdbarch)->builtin_long | |
48 | ||
49 | /* Python's float type corresponds to C's double type. */ | |
50 | #define builtin_type_pyfloat builtin_type (current_gdbarch)->builtin_double | |
51 | ||
52 | /* Python's long type corresponds to C's long long type. */ | |
53 | #define builtin_type_pylong builtin_type (current_gdbarch)->builtin_long_long | |
54 | ||
55 | #define builtin_type_pybool \ | |
56 | language_bool_type (current_language, current_gdbarch) | |
57 | ||
58 | typedef struct { | |
59 | PyObject_HEAD | |
60 | struct value *value; | |
61 | int owned_by_gdb; | |
62 | } value_object; | |
63 | ||
7843261b TJB |
64 | /* Called by the Python interpreter when deallocating a value object. */ |
65 | static void | |
66 | valpy_dealloc (PyObject *obj) | |
67 | { | |
68 | value_object *self = (value_object *) obj; | |
69 | ||
70 | value_remove_from_list (&values_in_python, self->value); | |
71 | ||
72 | if (!self->owned_by_gdb) | |
73 | value_free (self->value); | |
74 | self->ob_type->tp_free (self); | |
75 | } | |
76 | ||
77 | /* Called when a new gdb.Value object needs to be allocated. */ | |
78 | static PyObject * | |
79 | valpy_new (PyTypeObject *subtype, PyObject *args, PyObject *keywords) | |
80 | { | |
81 | struct value *value = NULL; /* Initialize to appease gcc warning. */ | |
82 | value_object *value_obj; | |
7843261b TJB |
83 | |
84 | if (PyTuple_Size (args) != 1) | |
85 | { | |
86 | PyErr_SetString (PyExc_TypeError, _("Value object creation takes only " | |
87 | "1 argument")); | |
88 | return NULL; | |
89 | } | |
90 | ||
91 | value_obj = (value_object *) subtype->tp_alloc (subtype, 1); | |
92 | if (value_obj == NULL) | |
93 | { | |
94 | PyErr_SetString (PyExc_MemoryError, _("Could not allocate memory to " | |
95 | "create Value object.")); | |
96 | return NULL; | |
97 | } | |
98 | ||
08c637de TJB |
99 | value = convert_value_from_python (PyTuple_GetItem (args, 0)); |
100 | if (value == NULL) | |
7843261b TJB |
101 | { |
102 | subtype->tp_free (value_obj); | |
08c637de | 103 | return NULL; |
7843261b TJB |
104 | } |
105 | ||
106 | value_obj->value = value; | |
997339e8 | 107 | value_obj->owned_by_gdb = 0; |
7843261b TJB |
108 | release_value (value); |
109 | value_prepend_to_list (&values_in_python, value); | |
110 | ||
111 | return (PyObject *) value_obj; | |
112 | } | |
113 | ||
114 | /* Given a value of a pointer type, apply the C unary * operator to it. */ | |
115 | static PyObject * | |
116 | valpy_dereference (PyObject *self, PyObject *args) | |
117 | { | |
118 | struct value *res_val = NULL; /* Initialize to appease gcc warning. */ | |
119 | volatile struct gdb_exception except; | |
120 | ||
121 | TRY_CATCH (except, RETURN_MASK_ALL) | |
122 | { | |
123 | res_val = value_ind (((value_object *) self)->value); | |
124 | } | |
125 | GDB_PY_HANDLE_EXCEPTION (except); | |
126 | ||
127 | return value_to_value_object (res_val); | |
128 | } | |
129 | ||
08c637de TJB |
130 | /* Return "&value". */ |
131 | static PyObject * | |
132 | valpy_address (PyObject *self, PyObject *args) | |
133 | { | |
134 | struct value *res_val = NULL; /* Initialize to appease gcc warning. */ | |
135 | volatile struct gdb_exception except; | |
136 | ||
137 | TRY_CATCH (except, RETURN_MASK_ALL) | |
138 | { | |
139 | res_val = value_addr (((value_object *) self)->value); | |
140 | } | |
141 | GDB_PY_HANDLE_EXCEPTION (except); | |
142 | ||
143 | return value_to_value_object (res_val); | |
144 | } | |
145 | ||
cc924cad TJB |
146 | /* Implementation of gdb.Value.string ([encoding] [, errors]) -> string |
147 | Return Unicode string with value contents. If ENCODING is not given, | |
148 | the string is assumed to be encoded in the target's charset. */ | |
b6cb8e7d | 149 | static PyObject * |
cc924cad | 150 | valpy_string (PyObject *self, PyObject *args, PyObject *kw) |
b6cb8e7d TJB |
151 | { |
152 | int length, ret = 0; | |
153 | gdb_byte *buffer; | |
154 | struct value *value = ((value_object *) self)->value; | |
155 | volatile struct gdb_exception except; | |
156 | PyObject *unicode; | |
157 | const char *encoding = NULL; | |
158 | const char *errors = NULL; | |
159 | const char *user_encoding = NULL; | |
160 | const char *la_encoding = NULL; | |
cc924cad | 161 | static char *keywords[] = { "encoding", "errors" }; |
b6cb8e7d | 162 | |
cc924cad TJB |
163 | if (!PyArg_ParseTupleAndKeywords (args, kw, "|ss", keywords, |
164 | &user_encoding, &errors)) | |
b6cb8e7d TJB |
165 | return NULL; |
166 | ||
167 | TRY_CATCH (except, RETURN_MASK_ALL) | |
168 | { | |
169 | LA_GET_STRING (value, &buffer, &length, &la_encoding); | |
170 | } | |
171 | GDB_PY_HANDLE_EXCEPTION (except); | |
172 | ||
173 | encoding = (user_encoding && *user_encoding) ? user_encoding : la_encoding; | |
174 | unicode = PyUnicode_Decode (buffer, length, encoding, errors); | |
175 | xfree (buffer); | |
176 | ||
177 | return unicode; | |
178 | } | |
179 | ||
7843261b TJB |
180 | static Py_ssize_t |
181 | valpy_length (PyObject *self) | |
182 | { | |
183 | /* We don't support getting the number of elements in a struct / class. */ | |
184 | PyErr_SetString (PyExc_NotImplementedError, | |
185 | "Invalid operation on gdb.Value."); | |
186 | return -1; | |
187 | } | |
188 | ||
189 | /* Given string name of an element inside structure, return its value | |
190 | object. */ | |
191 | static PyObject * | |
192 | valpy_getitem (PyObject *self, PyObject *key) | |
193 | { | |
194 | value_object *self_value = (value_object *) self; | |
08c637de TJB |
195 | char *field = NULL; |
196 | struct value *idx = NULL; | |
7843261b | 197 | struct value *res_val = NULL; /* Initialize to appease gcc warning. */ |
7843261b TJB |
198 | volatile struct gdb_exception except; |
199 | ||
08c637de TJB |
200 | if (gdbpy_is_string (key)) |
201 | { | |
202 | field = python_string_to_host_string (key); | |
203 | if (field == NULL) | |
204 | return NULL; | |
205 | } | |
7843261b TJB |
206 | |
207 | TRY_CATCH (except, RETURN_MASK_ALL) | |
208 | { | |
3c0ed299 | 209 | struct value *tmp = self_value->value; |
08c637de TJB |
210 | |
211 | if (field) | |
212 | res_val = value_struct_elt (&tmp, NULL, field, 0, NULL); | |
213 | else | |
214 | { | |
215 | /* Assume we are attempting an array access, and let the | |
216 | value code throw an exception if the index has an invalid | |
217 | type. */ | |
218 | struct value *idx = convert_value_from_python (key); | |
219 | if (idx == NULL) | |
220 | return NULL; | |
221 | ||
222 | res_val = value_subscript (tmp, idx); | |
223 | } | |
7843261b | 224 | } |
08c637de TJB |
225 | if (field) |
226 | xfree (field); | |
7843261b TJB |
227 | GDB_PY_HANDLE_EXCEPTION (except); |
228 | ||
7843261b TJB |
229 | return value_to_value_object (res_val); |
230 | } | |
231 | ||
232 | static int | |
233 | valpy_setitem (PyObject *self, PyObject *key, PyObject *value) | |
234 | { | |
235 | PyErr_Format (PyExc_NotImplementedError, | |
236 | _("Setting of struct elements is not currently supported.")); | |
237 | return -1; | |
238 | } | |
239 | ||
240 | /* Called by the Python interpreter to obtain string representation | |
241 | of the object. */ | |
242 | static PyObject * | |
243 | valpy_str (PyObject *self) | |
244 | { | |
245 | char *s = NULL; | |
246 | long dummy; | |
247 | struct ui_file *stb; | |
248 | struct cleanup *old_chain; | |
249 | PyObject *result; | |
79a45b7d | 250 | struct value_print_options opts; |
7843261b TJB |
251 | volatile struct gdb_exception except; |
252 | ||
79a45b7d TT |
253 | get_user_print_options (&opts); |
254 | opts.deref_ref = 0; | |
255 | ||
7843261b TJB |
256 | stb = mem_fileopen (); |
257 | old_chain = make_cleanup_ui_file_delete (stb); | |
258 | ||
259 | TRY_CATCH (except, RETURN_MASK_ALL) | |
260 | { | |
79a45b7d TT |
261 | common_val_print (((value_object *) self)->value, stb, 0, |
262 | &opts, current_language); | |
7843261b TJB |
263 | s = ui_file_xstrdup (stb, &dummy); |
264 | } | |
265 | GDB_PY_HANDLE_EXCEPTION (except); | |
266 | ||
267 | do_cleanups (old_chain); | |
268 | ||
269 | result = PyUnicode_Decode (s, strlen (s), host_charset (), NULL); | |
270 | xfree (s); | |
271 | ||
272 | return result; | |
273 | } | |
274 | ||
275 | enum valpy_opcode | |
276 | { | |
277 | VALPY_ADD, | |
278 | VALPY_SUB, | |
279 | VALPY_MUL, | |
280 | VALPY_DIV, | |
281 | VALPY_REM, | |
08c637de TJB |
282 | VALPY_POW, |
283 | VALPY_LSH, | |
284 | VALPY_RSH, | |
285 | VALPY_BITAND, | |
286 | VALPY_BITOR, | |
287 | VALPY_BITXOR | |
7843261b TJB |
288 | }; |
289 | ||
290 | /* If TYPE is a reference, return the target; otherwise return TYPE. */ | |
291 | #define STRIP_REFERENCE(TYPE) \ | |
292 | ((TYPE_CODE (TYPE) == TYPE_CODE_REF) ? (TYPE_TARGET_TYPE (TYPE)) : (TYPE)) | |
293 | ||
294 | /* Returns a value object which is the result of applying the operation | |
295 | specified by OPCODE to the given arguments. */ | |
296 | static PyObject * | |
297 | valpy_binop (enum valpy_opcode opcode, PyObject *self, PyObject *other) | |
298 | { | |
299 | struct value *res_val = NULL; /* Initialize to appease gcc warning. */ | |
300 | volatile struct gdb_exception except; | |
301 | ||
302 | TRY_CATCH (except, RETURN_MASK_ALL) | |
303 | { | |
304 | struct value *arg1, *arg2; | |
305 | ||
306 | /* If the gdb.Value object is the second operand, then it will be passed | |
307 | to us as the OTHER argument, and SELF will be an entirely different | |
308 | kind of object, altogether. Because of this, we can't assume self is | |
309 | a gdb.Value object and need to convert it from python as well. */ | |
310 | arg1 = convert_value_from_python (self); | |
08c637de | 311 | if (arg1 == NULL) |
cc924cad | 312 | break; |
08c637de | 313 | |
7843261b | 314 | arg2 = convert_value_from_python (other); |
08c637de | 315 | if (arg2 == NULL) |
cc924cad | 316 | break; |
7843261b TJB |
317 | |
318 | switch (opcode) | |
319 | { | |
320 | case VALPY_ADD: | |
321 | { | |
322 | struct type *ltype = value_type (arg1); | |
323 | struct type *rtype = value_type (arg2); | |
324 | ||
325 | CHECK_TYPEDEF (ltype); | |
326 | ltype = STRIP_REFERENCE (ltype); | |
327 | CHECK_TYPEDEF (rtype); | |
328 | rtype = STRIP_REFERENCE (rtype); | |
329 | ||
330 | if (TYPE_CODE (ltype) == TYPE_CODE_PTR) | |
331 | res_val = value_ptradd (arg1, arg2); | |
332 | else if (TYPE_CODE (rtype) == TYPE_CODE_PTR) | |
333 | res_val = value_ptradd (arg2, arg1); | |
334 | else | |
335 | res_val = value_binop (arg1, arg2, BINOP_ADD); | |
336 | } | |
337 | break; | |
338 | case VALPY_SUB: | |
339 | { | |
340 | struct type *ltype = value_type (arg1); | |
341 | struct type *rtype = value_type (arg2); | |
342 | ||
343 | CHECK_TYPEDEF (ltype); | |
344 | ltype = STRIP_REFERENCE (ltype); | |
345 | CHECK_TYPEDEF (rtype); | |
346 | rtype = STRIP_REFERENCE (rtype); | |
347 | ||
348 | if (TYPE_CODE (ltype) == TYPE_CODE_PTR) | |
349 | { | |
350 | if (TYPE_CODE (rtype) == TYPE_CODE_PTR) | |
351 | /* A ptrdiff_t for the target would be preferable | |
352 | here. */ | |
353 | res_val = value_from_longest (builtin_type_pyint, | |
354 | value_ptrdiff (arg1, arg2)); | |
355 | else | |
356 | res_val = value_ptrsub (arg1, arg2); | |
357 | } | |
358 | else | |
359 | res_val = value_binop (arg1, arg2, BINOP_SUB); | |
360 | } | |
361 | break; | |
362 | case VALPY_MUL: | |
363 | res_val = value_binop (arg1, arg2, BINOP_MUL); | |
364 | break; | |
365 | case VALPY_DIV: | |
366 | res_val = value_binop (arg1, arg2, BINOP_DIV); | |
367 | break; | |
368 | case VALPY_REM: | |
369 | res_val = value_binop (arg1, arg2, BINOP_REM); | |
370 | break; | |
371 | case VALPY_POW: | |
372 | res_val = value_binop (arg1, arg2, BINOP_EXP); | |
373 | break; | |
08c637de TJB |
374 | case VALPY_LSH: |
375 | res_val = value_binop (arg1, arg2, BINOP_LSH); | |
376 | break; | |
377 | case VALPY_RSH: | |
378 | res_val = value_binop (arg1, arg2, BINOP_RSH); | |
379 | break; | |
380 | case VALPY_BITAND: | |
381 | res_val = value_binop (arg1, arg2, BINOP_BITWISE_AND); | |
382 | break; | |
383 | case VALPY_BITOR: | |
384 | res_val = value_binop (arg1, arg2, BINOP_BITWISE_IOR); | |
385 | break; | |
386 | case VALPY_BITXOR: | |
387 | res_val = value_binop (arg1, arg2, BINOP_BITWISE_XOR); | |
388 | break; | |
7843261b TJB |
389 | } |
390 | } | |
391 | GDB_PY_HANDLE_EXCEPTION (except); | |
392 | ||
cc924cad | 393 | return res_val ? value_to_value_object (res_val) : NULL; |
7843261b TJB |
394 | } |
395 | ||
396 | static PyObject * | |
397 | valpy_add (PyObject *self, PyObject *other) | |
398 | { | |
399 | return valpy_binop (VALPY_ADD, self, other); | |
400 | } | |
401 | ||
402 | static PyObject * | |
403 | valpy_subtract (PyObject *self, PyObject *other) | |
404 | { | |
405 | return valpy_binop (VALPY_SUB, self, other); | |
406 | } | |
407 | ||
408 | static PyObject * | |
409 | valpy_multiply (PyObject *self, PyObject *other) | |
410 | { | |
411 | return valpy_binop (VALPY_MUL, self, other); | |
412 | } | |
413 | ||
414 | static PyObject * | |
415 | valpy_divide (PyObject *self, PyObject *other) | |
416 | { | |
417 | return valpy_binop (VALPY_DIV, self, other); | |
418 | } | |
419 | ||
420 | static PyObject * | |
421 | valpy_remainder (PyObject *self, PyObject *other) | |
422 | { | |
423 | return valpy_binop (VALPY_REM, self, other); | |
424 | } | |
425 | ||
426 | static PyObject * | |
427 | valpy_power (PyObject *self, PyObject *other, PyObject *unused) | |
428 | { | |
429 | /* We don't support the ternary form of pow. I don't know how to express | |
430 | that, so let's just throw NotImplementedError to at least do something | |
431 | about it. */ | |
432 | if (unused != Py_None) | |
433 | { | |
434 | PyErr_SetString (PyExc_NotImplementedError, | |
435 | "Invalid operation on gdb.Value."); | |
436 | return NULL; | |
437 | } | |
438 | ||
439 | return valpy_binop (VALPY_POW, self, other); | |
440 | } | |
441 | ||
442 | static PyObject * | |
443 | valpy_negative (PyObject *self) | |
444 | { | |
445 | struct value *val = NULL; | |
446 | volatile struct gdb_exception except; | |
447 | ||
448 | TRY_CATCH (except, RETURN_MASK_ALL) | |
449 | { | |
450 | val = value_neg (((value_object *) self)->value); | |
451 | } | |
452 | GDB_PY_HANDLE_EXCEPTION (except); | |
453 | ||
454 | return value_to_value_object (val); | |
455 | } | |
456 | ||
457 | static PyObject * | |
458 | valpy_positive (PyObject *self) | |
459 | { | |
460 | struct value *copy = value_copy (((value_object *) self)->value); | |
461 | ||
462 | return value_to_value_object (copy); | |
463 | } | |
464 | ||
465 | static PyObject * | |
466 | valpy_absolute (PyObject *self) | |
467 | { | |
468 | if (value_less (((value_object *) self)->value, | |
469 | value_from_longest (builtin_type_int8, 0))) | |
470 | return valpy_negative (self); | |
471 | else | |
472 | return valpy_positive (self); | |
473 | } | |
474 | ||
475 | /* Implements boolean evaluation of gdb.Value. */ | |
476 | static int | |
477 | valpy_nonzero (PyObject *self) | |
478 | { | |
479 | value_object *self_value = (value_object *) self; | |
480 | struct type *type; | |
481 | ||
482 | type = check_typedef (value_type (self_value->value)); | |
483 | ||
484 | if (is_integral_type (type) || TYPE_CODE (type) == TYPE_CODE_PTR) | |
485 | return !!value_as_long (self_value->value); | |
486 | else if (TYPE_CODE (type) == TYPE_CODE_FLT) | |
487 | return value_as_double (self_value->value) != 0; | |
488 | else if (TYPE_CODE (type) == TYPE_CODE_DECFLOAT) | |
489 | return !decimal_is_zero (value_contents (self_value->value), | |
490 | TYPE_LENGTH (type)); | |
491 | else | |
492 | { | |
493 | PyErr_SetString (PyExc_TypeError, _("Attempted truth testing on invalid " | |
494 | "gdb.Value type.")); | |
495 | return 0; | |
496 | } | |
497 | } | |
498 | ||
08c637de | 499 | /* Implements ~ for value objects. */ |
7843261b | 500 | static PyObject * |
08c637de | 501 | valpy_invert (PyObject *self) |
7843261b | 502 | { |
08c637de | 503 | struct value *val = NULL; |
7843261b TJB |
504 | volatile struct gdb_exception except; |
505 | ||
08c637de | 506 | TRY_CATCH (except, RETURN_MASK_ALL) |
7843261b | 507 | { |
08c637de TJB |
508 | val = value_complement (((value_object *) self)->value); |
509 | } | |
510 | GDB_PY_HANDLE_EXCEPTION (except); | |
7843261b | 511 | |
08c637de TJB |
512 | return value_to_value_object (val); |
513 | } | |
7843261b | 514 | |
08c637de TJB |
515 | /* Implements left shift for value objects. */ |
516 | static PyObject * | |
517 | valpy_lsh (PyObject *self, PyObject *other) | |
518 | { | |
519 | return valpy_binop (VALPY_LSH, self, other); | |
520 | } | |
7843261b | 521 | |
08c637de TJB |
522 | /* Implements right shift for value objects. */ |
523 | static PyObject * | |
524 | valpy_rsh (PyObject *self, PyObject *other) | |
525 | { | |
526 | return valpy_binop (VALPY_RSH, self, other); | |
527 | } | |
7843261b | 528 | |
08c637de TJB |
529 | /* Implements bitwise and for value objects. */ |
530 | static PyObject * | |
531 | valpy_and (PyObject *self, PyObject *other) | |
532 | { | |
533 | return valpy_binop (VALPY_BITAND, self, other); | |
534 | } | |
7843261b | 535 | |
08c637de TJB |
536 | /* Implements bitwise or for value objects. */ |
537 | static PyObject * | |
538 | valpy_or (PyObject *self, PyObject *other) | |
539 | { | |
540 | return valpy_binop (VALPY_BITOR, self, other); | |
541 | } | |
542 | ||
543 | /* Implements bitwise xor for value objects. */ | |
544 | static PyObject * | |
545 | valpy_xor (PyObject *self, PyObject *other) | |
546 | { | |
547 | return valpy_binop (VALPY_BITXOR, self, other); | |
548 | } | |
549 | ||
550 | /* Implements comparison operations for value objects. */ | |
551 | static PyObject * | |
552 | valpy_richcompare (PyObject *self, PyObject *other, int op) | |
553 | { | |
554 | int result = 0; | |
555 | struct value *value_other; | |
556 | volatile struct gdb_exception except; | |
557 | ||
558 | if (other == Py_None) | |
7843261b TJB |
559 | /* Comparing with None is special. From what I can tell, in Python |
560 | None is smaller than anything else. */ | |
561 | switch (op) { | |
562 | case Py_LT: | |
563 | case Py_LE: | |
564 | case Py_EQ: | |
565 | Py_RETURN_FALSE; | |
566 | case Py_NE: | |
567 | case Py_GT: | |
568 | case Py_GE: | |
569 | Py_RETURN_TRUE; | |
570 | default: | |
571 | /* Can't happen. */ | |
572 | PyErr_SetString (PyExc_NotImplementedError, | |
573 | "Invalid operation on gdb.Value."); | |
574 | return NULL; | |
575 | } | |
7843261b TJB |
576 | |
577 | TRY_CATCH (except, RETURN_MASK_ALL) | |
578 | { | |
08c637de TJB |
579 | value_other = convert_value_from_python (other); |
580 | if (value_other == NULL) | |
581 | return NULL; | |
582 | ||
7843261b TJB |
583 | switch (op) { |
584 | case Py_LT: | |
585 | result = value_less (((value_object *) self)->value, value_other); | |
586 | break; | |
587 | case Py_LE: | |
588 | result = value_less (((value_object *) self)->value, value_other) | |
589 | || value_equal (((value_object *) self)->value, value_other); | |
590 | break; | |
591 | case Py_EQ: | |
592 | result = value_equal (((value_object *) self)->value, value_other); | |
593 | break; | |
594 | case Py_NE: | |
595 | result = !value_equal (((value_object *) self)->value, value_other); | |
596 | break; | |
597 | case Py_GT: | |
598 | result = value_less (value_other, ((value_object *) self)->value); | |
599 | break; | |
600 | case Py_GE: | |
601 | result = value_less (value_other, ((value_object *) self)->value) | |
602 | || value_equal (((value_object *) self)->value, value_other); | |
603 | break; | |
604 | default: | |
605 | /* Can't happen. */ | |
606 | PyErr_SetString (PyExc_NotImplementedError, | |
607 | "Invalid operation on gdb.Value."); | |
608 | return NULL; | |
609 | } | |
610 | } | |
611 | GDB_PY_HANDLE_EXCEPTION (except); | |
612 | ||
613 | if (result == 1) | |
614 | Py_RETURN_TRUE; | |
615 | ||
616 | Py_RETURN_FALSE; | |
617 | } | |
618 | ||
08c637de TJB |
619 | /* Helper function to determine if a type is "int-like". */ |
620 | static int | |
621 | is_intlike (struct type *type, int ptr_ok) | |
622 | { | |
623 | CHECK_TYPEDEF (type); | |
624 | return (TYPE_CODE (type) == TYPE_CODE_INT | |
625 | || TYPE_CODE (type) == TYPE_CODE_ENUM | |
626 | || TYPE_CODE (type) == TYPE_CODE_BOOL | |
627 | || TYPE_CODE (type) == TYPE_CODE_CHAR | |
628 | || (ptr_ok && TYPE_CODE (type) == TYPE_CODE_PTR)); | |
629 | } | |
630 | ||
631 | /* Implements conversion to int. */ | |
632 | static PyObject * | |
633 | valpy_int (PyObject *self) | |
634 | { | |
635 | struct value *value = ((value_object *) self)->value; | |
636 | struct type *type = value_type (value); | |
637 | LONGEST l = 0; | |
638 | volatile struct gdb_exception except; | |
639 | ||
640 | CHECK_TYPEDEF (type); | |
641 | if (!is_intlike (type, 0)) | |
642 | { | |
643 | PyErr_SetString (PyExc_RuntimeError, "cannot convert value to int"); | |
644 | return NULL; | |
645 | } | |
646 | ||
647 | TRY_CATCH (except, RETURN_MASK_ALL) | |
648 | { | |
649 | l = value_as_long (value); | |
650 | } | |
651 | GDB_PY_HANDLE_EXCEPTION (except); | |
652 | ||
653 | return PyInt_FromLong (l); | |
654 | } | |
655 | ||
656 | /* Implements conversion to long. */ | |
657 | static PyObject * | |
658 | valpy_long (PyObject *self) | |
659 | { | |
660 | struct value *value = ((value_object *) self)->value; | |
661 | struct type *type = value_type (value); | |
662 | LONGEST l = 0; | |
663 | volatile struct gdb_exception except; | |
664 | ||
665 | if (!is_intlike (type, 1)) | |
666 | { | |
667 | PyErr_SetString (PyExc_RuntimeError, "cannot convert value to long"); | |
668 | return NULL; | |
669 | } | |
670 | ||
671 | TRY_CATCH (except, RETURN_MASK_ALL) | |
672 | { | |
673 | l = value_as_long (value); | |
674 | } | |
675 | GDB_PY_HANDLE_EXCEPTION (except); | |
676 | ||
677 | return PyLong_FromLong (l); | |
678 | } | |
679 | ||
680 | /* Implements conversion to float. */ | |
681 | static PyObject * | |
682 | valpy_float (PyObject *self) | |
683 | { | |
684 | struct value *value = ((value_object *) self)->value; | |
685 | struct type *type = value_type (value); | |
686 | double d = 0; | |
687 | volatile struct gdb_exception except; | |
688 | ||
689 | CHECK_TYPEDEF (type); | |
690 | if (TYPE_CODE (type) != TYPE_CODE_FLT) | |
691 | { | |
692 | PyErr_SetString (PyExc_RuntimeError, "cannot convert value to float"); | |
693 | return NULL; | |
694 | } | |
695 | ||
696 | TRY_CATCH (except, RETURN_MASK_ALL) | |
697 | { | |
698 | d = value_as_double (value); | |
699 | } | |
700 | GDB_PY_HANDLE_EXCEPTION (except); | |
701 | ||
702 | return PyFloat_FromDouble (d); | |
703 | } | |
704 | ||
7843261b TJB |
705 | /* Returns an object for a value which is released from the all_values chain, |
706 | so its lifetime is not bound to the execution of a command. */ | |
707 | PyObject * | |
708 | value_to_value_object (struct value *val) | |
709 | { | |
710 | value_object *val_obj; | |
711 | ||
712 | val_obj = PyObject_New (value_object, &value_object_type); | |
713 | if (val_obj != NULL) | |
714 | { | |
715 | val_obj->value = val; | |
997339e8 | 716 | val_obj->owned_by_gdb = 0; |
7843261b TJB |
717 | release_value (val); |
718 | value_prepend_to_list (&values_in_python, val); | |
719 | } | |
720 | ||
721 | return (PyObject *) val_obj; | |
722 | } | |
723 | ||
724 | /* Try to convert a Python value to a gdb value. If the value cannot | |
08c637de | 725 | be converted, set a Python exception and return NULL. */ |
7843261b TJB |
726 | |
727 | struct value * | |
728 | convert_value_from_python (PyObject *obj) | |
729 | { | |
730 | struct value *value = NULL; /* -Wall */ | |
731 | PyObject *target_str, *unicode_str; | |
732 | struct cleanup *old; | |
08c637de TJB |
733 | volatile struct gdb_exception except; |
734 | int cmp; | |
7843261b | 735 | |
08c637de | 736 | gdb_assert (obj != NULL); |
7843261b | 737 | |
08c637de | 738 | TRY_CATCH (except, RETURN_MASK_ALL) |
7843261b | 739 | { |
08c637de TJB |
740 | if (PyBool_Check (obj)) |
741 | { | |
742 | cmp = PyObject_IsTrue (obj); | |
743 | if (cmp >= 0) | |
744 | value = value_from_longest (builtin_type_pybool, cmp); | |
745 | } | |
746 | else if (PyInt_Check (obj)) | |
747 | { | |
748 | long l = PyInt_AsLong (obj); | |
7843261b | 749 | |
08c637de TJB |
750 | if (! PyErr_Occurred ()) |
751 | value = value_from_longest (builtin_type_pyint, l); | |
752 | } | |
753 | else if (PyLong_Check (obj)) | |
754 | { | |
755 | LONGEST l = PyLong_AsLongLong (obj); | |
7843261b | 756 | |
08c637de TJB |
757 | if (! PyErr_Occurred ()) |
758 | value = value_from_longest (builtin_type_pylong, l); | |
759 | } | |
760 | else if (PyFloat_Check (obj)) | |
761 | { | |
762 | double d = PyFloat_AsDouble (obj); | |
7843261b | 763 | |
08c637de TJB |
764 | if (! PyErr_Occurred ()) |
765 | value = value_from_double (builtin_type_pyfloat, d); | |
766 | } | |
767 | else if (gdbpy_is_string (obj)) | |
768 | { | |
769 | char *s; | |
770 | ||
771 | s = python_string_to_target_string (obj); | |
772 | if (s != NULL) | |
773 | { | |
774 | old = make_cleanup (xfree, s); | |
775 | value = value_from_string (s); | |
776 | do_cleanups (old); | |
777 | } | |
778 | } | |
779 | else if (PyObject_TypeCheck (obj, &value_object_type)) | |
cc924cad | 780 | value = value_copy (((value_object *) obj)->value); |
08c637de TJB |
781 | else |
782 | PyErr_Format (PyExc_TypeError, _("Could not convert Python object: %s"), | |
783 | PyString_AsString (PyObject_Str (obj))); | |
784 | } | |
785 | if (except.reason < 0) | |
786 | { | |
787 | PyErr_Format (except.reason == RETURN_QUIT | |
788 | ? PyExc_KeyboardInterrupt : PyExc_RuntimeError, | |
789 | "%s", except.message); | |
790 | return NULL; | |
791 | } | |
7843261b TJB |
792 | |
793 | return value; | |
794 | } | |
795 | ||
796 | /* Returns value object in the ARGth position in GDB's history. */ | |
797 | PyObject * | |
08c637de | 798 | gdbpy_history (PyObject *self, PyObject *args) |
7843261b TJB |
799 | { |
800 | int i; | |
801 | struct value *res_val = NULL; /* Initialize to appease gcc warning. */ | |
802 | volatile struct gdb_exception except; | |
803 | ||
804 | if (!PyArg_ParseTuple (args, "i", &i)) | |
805 | return NULL; | |
806 | ||
807 | TRY_CATCH (except, RETURN_MASK_ALL) | |
808 | { | |
809 | res_val = access_value_history (i); | |
810 | } | |
811 | GDB_PY_HANDLE_EXCEPTION (except); | |
812 | ||
813 | return value_to_value_object (res_val); | |
814 | } | |
815 | ||
816 | void | |
817 | gdbpy_initialize_values (void) | |
818 | { | |
7843261b TJB |
819 | if (PyType_Ready (&value_object_type) < 0) |
820 | return; | |
821 | ||
822 | Py_INCREF (&value_object_type); | |
823 | PyModule_AddObject (gdb_module, "Value", (PyObject *) &value_object_type); | |
824 | ||
825 | values_in_python = NULL; | |
826 | } | |
827 | ||
f9176c46 | 828 | static PyMethodDef value_object_methods[] = { |
08c637de | 829 | { "address", valpy_address, METH_NOARGS, "Return the address of the value." }, |
f9176c46 | 830 | { "dereference", valpy_dereference, METH_NOARGS, "Dereferences the value." }, |
cc924cad TJB |
831 | { "string", (PyCFunction) valpy_string, METH_VARARGS | METH_KEYWORDS, |
832 | "string ([encoding] [, errors]) -> string\n\ | |
833 | Return Unicode string representation of the value." }, | |
f9176c46 PA |
834 | {NULL} /* Sentinel */ |
835 | }; | |
836 | ||
837 | static PyNumberMethods value_object_as_number = { | |
838 | valpy_add, | |
839 | valpy_subtract, | |
840 | valpy_multiply, | |
841 | valpy_divide, | |
842 | valpy_remainder, | |
843 | NULL, /* nb_divmod */ | |
844 | valpy_power, /* nb_power */ | |
845 | valpy_negative, /* nb_negative */ | |
846 | valpy_positive, /* nb_positive */ | |
847 | valpy_absolute, /* nb_absolute */ | |
08c637de TJB |
848 | valpy_nonzero, /* nb_nonzero */ |
849 | valpy_invert, /* nb_invert */ | |
850 | valpy_lsh, /* nb_lshift */ | |
851 | valpy_rsh, /* nb_rshift */ | |
852 | valpy_and, /* nb_and */ | |
853 | valpy_xor, /* nb_xor */ | |
854 | valpy_or, /* nb_or */ | |
855 | NULL, /* nb_coerce */ | |
856 | valpy_int, /* nb_int */ | |
857 | valpy_long, /* nb_long */ | |
858 | valpy_float, /* nb_float */ | |
859 | NULL, /* nb_oct */ | |
860 | NULL /* nb_hex */ | |
f9176c46 PA |
861 | }; |
862 | ||
863 | static PyMappingMethods value_object_as_mapping = { | |
864 | valpy_length, | |
865 | valpy_getitem, | |
866 | valpy_setitem | |
867 | }; | |
868 | ||
869 | PyTypeObject value_object_type = { | |
870 | PyObject_HEAD_INIT (NULL) | |
871 | 0, /*ob_size*/ | |
872 | "gdb.Value", /*tp_name*/ | |
873 | sizeof (value_object), /*tp_basicsize*/ | |
874 | 0, /*tp_itemsize*/ | |
875 | valpy_dealloc, /*tp_dealloc*/ | |
876 | 0, /*tp_print*/ | |
877 | 0, /*tp_getattr*/ | |
878 | 0, /*tp_setattr*/ | |
879 | 0, /*tp_compare*/ | |
880 | 0, /*tp_repr*/ | |
881 | &value_object_as_number, /*tp_as_number*/ | |
882 | 0, /*tp_as_sequence*/ | |
883 | &value_object_as_mapping, /*tp_as_mapping*/ | |
884 | 0, /*tp_hash */ | |
885 | 0, /*tp_call*/ | |
886 | valpy_str, /*tp_str*/ | |
887 | 0, /*tp_getattro*/ | |
888 | 0, /*tp_setattro*/ | |
889 | 0, /*tp_as_buffer*/ | |
890 | Py_TPFLAGS_DEFAULT | Py_TPFLAGS_CHECKTYPES, /*tp_flags*/ | |
891 | "GDB value object", /* tp_doc */ | |
892 | 0, /* tp_traverse */ | |
893 | 0, /* tp_clear */ | |
894 | valpy_richcompare, /* tp_richcompare */ | |
895 | 0, /* tp_weaklistoffset */ | |
896 | 0, /* tp_iter */ | |
897 | 0, /* tp_iternext */ | |
08c637de TJB |
898 | value_object_methods, /* tp_methods */ |
899 | 0, /* tp_members */ | |
900 | 0, /* tp_getset */ | |
901 | 0, /* tp_base */ | |
902 | 0, /* tp_dict */ | |
903 | 0, /* tp_descr_get */ | |
904 | 0, /* tp_descr_set */ | |
905 | 0, /* tp_dictoffset */ | |
906 | 0, /* tp_init */ | |
907 | 0, /* tp_alloc */ | |
908 | valpy_new /* tp_new */ | |
f9176c46 PA |
909 | }; |
910 | ||
7843261b | 911 | #endif /* HAVE_PYTHON */ |