From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 328 invoked by alias); 5 Dec 2009 09:19:55 -0000 Received: (qmail 32738 invoked by uid 22791); 5 Dec 2009 09:19:53 -0000 X-SWARE-Spam-Status: No, hits=-2.5 required=5.0 tests=AWL,BAYES_00,SPF_HELO_PASS,SPF_PASS X-Spam-Check-By: sourceware.org Received: from mx1.redhat.com (HELO mx1.redhat.com) (209.132.183.28) by sourceware.org (qpsmtpd/0.43rc1) with ESMTP; Sat, 05 Dec 2009 09:19:47 +0000 Received: from int-mx01.intmail.prod.int.phx2.redhat.com (int-mx01.intmail.prod.int.phx2.redhat.com [10.5.11.11]) by mx1.redhat.com (8.13.8/8.13.8) with ESMTP id nB59Jknc012712 (version=TLSv1/SSLv3 cipher=DHE-RSA-AES256-SHA bits=256 verify=OK) for ; Sat, 5 Dec 2009 04:19:46 -0500 Received: from localhost.localdomain (ovpn01.gateway.prod.ext.phx2.redhat.com [10.5.9.1]) by int-mx01.intmail.prod.int.phx2.redhat.com (8.13.8/8.13.8) with ESMTP id nB59JiqD002121; Sat, 5 Dec 2009 04:19:45 -0500 Message-ID: <4B1A25B0.1090903@redhat.com> Date: Sat, 05 Dec 2009 09:19:00 -0000 From: Phil Muldoon User-Agent: Mozilla/5.0 (X11; U; Linux x86_64; en-US; rv:1.9.1.4pre) Gecko/20090922 Fedora/3.0-3.9.b4.fc12 Lightning/1.0pre Thunderbird/3.0b4 MIME-Version: 1.0 To: tromey@redhat.com CC: gdb-patches ml Subject: Re: [python][patch] And range method to type References: <4B1929DC.7070809@redhat.com> In-Reply-To: Content-Type: text/plain; charset=ISO-8859-1 Content-Transfer-Encoding: 7bit X-IsSubscribed: yes Mailing-List: contact gdb-patches-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: gdb-patches-owner@sourceware.org X-SW-Source: 2009-12/txt/msg00066.txt.bz2 On 12/04/2009 06:13 PM, Tom Tromey wrote: >>>>>> "Phil" == Phil Muldoon writes: > > Phil> This patch adds a "range" method for GDB.Types. It only supports types > Phil> that support a range, or the range type itself. > > Phil> + if (TYPE_CODE (type) != TYPE_CODE_ARRAY && > Phil> + TYPE_CODE (type) != TYPE_CODE_STRING && > Phil> + TYPE_CODE (type) != TYPE_CODE_RANGE) > > In the GNU style, the "&&"s go at the start of the line. OK. > > I think this code should check for failures from PyLong_FromLong and > PyTuple_SetItem. I realize that is a pain, but if one of those does > fail, a failure to check will yield weird problems. OK, the new code has more robust error checking. > Phil> Return a type of pointer to this type." }, > Phil> + { "range", typy_range, METH_NOARGS, > Phil> + "range () -> Tuple\n\ > > It should be "tuple", as that is the name of the returned type. OK. I've regenerated the patch. Thanks for the review! What do you think? Cheers, Phil -- Index: doc/gdb.texinfo =================================================================== RCS file: /cvs/src/src/gdb/doc/gdb.texinfo,v retrieving revision 1.647 diff -u -r1.647 gdb.texinfo --- doc/gdb.texinfo 3 Dec 2009 21:19:48 -0000 1.647 +++ doc/gdb.texinfo 5 Dec 2009 09:11:25 -0000 @@ -19654,6 +19654,13 @@ @code{volatile}. @end defmethod +@defmethod Type range +Return a Python @code{Tuple} object that contains two elements: the +low bound of the argument type and the high bound of that type. If +the type does not have a range, @value{GDBN} will raise a +@code{RuntimeError} exception. +@end defmethod + @defmethod Type reference Return a new @code{gdb.Type} object which represents a reference to this type. Index: python/py-type.c =================================================================== RCS file: /cvs/src/src/gdb/python/py-type.c,v retrieving revision 1.3 diff -u -r1.3 py-type.c --- python/py-type.c 3 Dec 2009 21:19:49 -0000 1.3 +++ python/py-type.c 5 Dec 2009 09:11:25 -0000 @@ -273,6 +273,70 @@ return type_to_type_object (type); } +/* Return the range of a type represented by SELF. The return type is + a tuple. The first element of the tuple contains the low bound, + while the second element of the tuple contains the high bound. */ +static PyObject * +typy_range (PyObject *self, PyObject *args) +{ + struct type *type = ((type_object *) self)->type; + PyObject *result; + PyObject *low_bound = NULL, *high_bound = NULL; + LONGEST low, high; + + if (TYPE_CODE (type) != TYPE_CODE_ARRAY + && TYPE_CODE (type) != TYPE_CODE_STRING + && TYPE_CODE (type) != TYPE_CODE_RANGE) + { + PyErr_SetString (PyExc_RuntimeError, + "This type does not have a range."); + return NULL; + } + + switch (TYPE_CODE (type)) + { + case TYPE_CODE_ARRAY: + case TYPE_CODE_STRING: + low = TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type)); + high = TYPE_HIGH_BOUND (TYPE_INDEX_TYPE (type)); + break; + case TYPE_CODE_RANGE: + low = TYPE_LOW_BOUND (type); + high = TYPE_HIGH_BOUND (type); + break; + } + + low_bound = PyLong_FromLong (low); + if (!low_bound) + goto failarg; + + high_bound = PyLong_FromLong (high); + if (!high_bound) + goto failarg; + + result = PyTuple_New (2); + if (!result) + goto failarg; + + if (PyTuple_SetItem (result, 0, low_bound) != 0) + { + Py_DECREF (result); + goto failarg; + } + if (PyTuple_SetItem (result, 1, high_bound) != 0) + { + Py_DECREF (high_bound); + Py_DECREF (result); + return NULL; + } + return result; + + failarg: + Py_XDECREF (high_bound); + Py_XDECREF (low_bound); + return NULL; +} + /* Return a Type object which represents a reference to SELF. */ static PyObject * typy_reference (PyObject *self, PyObject *args) @@ -699,6 +763,9 @@ { "pointer", typy_pointer, METH_NOARGS, "pointer () -> Type\n\ Return a type of pointer to this type." }, + { "range", typy_range, METH_NOARGS, + "range () -> tuple\n\ +Return a tuple containing the lower and upper range for this type."}, { "reference", typy_reference, METH_NOARGS, "reference () -> Type\n\ Return a type of reference to this type." }, Index: testsuite/gdb.python/py-type.exp =================================================================== RCS file: /cvs/src/src/gdb/testsuite/gdb.python/py-type.exp,v retrieving revision 1.1 diff -u -r1.1 py-type.exp --- testsuite/gdb.python/py-type.exp 3 Dec 2009 21:19:49 -0000 1.1 +++ testsuite/gdb.python/py-type.exp 5 Dec 2009 09:11:26 -0000 @@ -102,6 +102,28 @@ gdb_test "python print fields\[1\].is_base_class" "False" "Check base class" } +proc test_range {} { + + # Test a valid range request. + gdb_py_test_silent_cmd "print ar" "print value" 1 + gdb_py_test_silent_cmd "python ar = gdb.history (0)" "get value from history" 1 + gdb_test "python print len(ar.type.range())" "2" "Check correct tuple length" + gdb_test "python print ar.type.range()\[0\]" "0" "Check low range" + gdb_test "python print ar.type.range()\[1\]" "1" "Check high range" + + # Test a range request on a ranged type. + gdb_py_test_silent_cmd "print ar" "print value" 1 + gdb_py_test_silent_cmd "python ar = gdb.history (0)" "get value from history" 1 + gdb_py_test_silent_cmd "python fields = ar.type.fields()" "get fields" 1 + gdb_test "python print fields\[0\].type.range()\[0\]" "0" "Check range type low bound" + gdb_test "python print fields\[0\].type.range()\[1\]" "1" "Check range type high bound" + + # Test where a range does not exist. + gdb_py_test_silent_cmd "print st" "print value" 1 + gdb_py_test_silent_cmd "python st = gdb.history (0)" "get value from history" 1 + gdb_test "python print st.type.range()" "RuntimeError: This type does not have a range.*" "Check range for non ranged type." +} + # Perform C Tests. build_inferior "c" restart_gdb "break to inspect struct and array." @@ -112,3 +134,4 @@ restart_gdb "break to inspect struct and array." test_fields "c++" test_base_class +test_range