From patchwork Fri Sep 8 21:05:03 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jan Vrany X-Patchwork-Id: 75587 Return-Path: X-Original-To: patchwork@sourceware.org Delivered-To: patchwork@sourceware.org Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id A6B363857703 for ; Fri, 8 Sep 2023 21:06:03 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org A6B363857703 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=sourceware.org; s=default; t=1694207163; bh=FLMtYMJYCc025lGW2kLofMv5IVXIk8lARANhGEK6ajk=; h=To:CC:Subject:Date:List-Id:List-Unsubscribe:List-Archive: List-Post:List-Help:List-Subscribe:From:Reply-To:From; b=wpUmExBXN17+52vDcSTCMjb9Pi3Su99XrFB4K479YzJRjTmqipAD8W1+mmqwps7uQ wJwPwrli9HO41cdPnzf1xTM6hQ7hGXaoP4BYYXZDDsOcLa0eOJCHue6m2aL0OOl0Cl HJDzYW2AR9/1I6OYyD63Wgm2hV1XBM+Hk4Lz5l2o= X-Original-To: gdb-patches@sourceware.org Delivered-To: gdb-patches@sourceware.org Received: from us-smtp-delivery-114.mimecast.com (us-smtp-delivery-114.mimecast.com [170.10.133.114]) by sourceware.org (Postfix) with ESMTPS id E48013858D38 for ; Fri, 8 Sep 2023 21:05:34 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org E48013858D38 Received: from NAM11-BN8-obe.outbound.protection.outlook.com (mail-bn8nam11lp2169.outbound.protection.outlook.com [104.47.58.169]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id us-mta-94-w36isJerNfeyMPmzXg3Lxw-1; Fri, 08 Sep 2023 17:05:33 -0400 X-MC-Unique: w36isJerNfeyMPmzXg3Lxw-1 Received: from SA0PR17MB4314.namprd17.prod.outlook.com (2603:10b6:806:e7::16) by SA0PR17MB4442.namprd17.prod.outlook.com (2603:10b6:806:e0::17) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.6768.30; Fri, 8 Sep 2023 21:05:30 +0000 Received: from SA0PR17MB4314.namprd17.prod.outlook.com ([fe80::30eb:4c4a:cb5a:dd91]) by SA0PR17MB4314.namprd17.prod.outlook.com ([fe80::30eb:4c4a:cb5a:dd91%4]) with mapi id 15.20.6745.034; Fri, 8 Sep 2023 21:05:30 +0000 To: gdb-patches@sourceware.org CC: Jan Vrany Subject: [PATCH 1/2] gdb/python: generalize serialize_mi_result() Date: Fri, 8 Sep 2023 22:05:03 +0100 Message-ID: <20230908210504.89194-1-jan.vrany@labware.com> X-Mailer: git-send-email 2.40.1 X-ClientProxiedBy: LO2P265CA0309.GBRP265.PROD.OUTLOOK.COM (2603:10a6:600:a5::33) To SA0PR17MB4314.namprd17.prod.outlook.com (2603:10b6:806:e7::16) MIME-Version: 1.0 X-MS-PublicTrafficType: Email X-MS-TrafficTypeDiagnostic: SA0PR17MB4314:EE_|SA0PR17MB4442:EE_ X-MS-Office365-Filtering-Correlation-Id: 5b90c346-a1ba-4c79-be85-08dbb0af5559 X-MS-Exchange-SenderADCheck: 1 X-MS-Exchange-AntiSpam-Relay: 0 X-Microsoft-Antispam: BCL:0 X-Microsoft-Antispam-Message-Info: RdiTgL7Ax9X3CQ2bjgDALMVHqAyjqZYIbXi6aJWdgczDs7Fk6WVfnz9w0bdn52imceERJSu/tnCYgiADpqlpnyO66wjOcZc5By1qdxctfQoha4VTKh4MQrP3kgrqS4JxC1Vk2IyJPrpPKPtDyj2aHQn253jiIm+6QVnHTFq68kf8lYEke9qflr2AxazFOJaJ/ZZ8T+0gwHF/mT1NhWXE+qR1xOXJmDXlBmo9F3MMynJ479g80u6cMuw+x1NyR6bQ30Qrowp9h7r+x6susH6nL0TjaIOlMefp4ZspYFwvMIsiwAm7IpRFQZifsemVqyFWLDd6eE791UdHaSM5JMhb3lPdWpVQB9J5Z0sdDnKJ2rUp2wTLU4jSeD3nMHaQeLNLb4k1BvgrzGw0c43PSLXSisCrOpbl4YFuxicAnayrwHXvjxTiwdbWHNzX48YDPfmwf68n1M25OeEdCzrelpnSaMlEQo//126MF8R1z2hCJkM3K4EC0jvXprOiXdr3Noi1kDWGoZFUEm1TlxpVhUXWWFacal7+j9F21wlLLEuTVucu+PZqdgzv2Mud2bZo+lf5 X-Forefront-Antispam-Report: CIP:255.255.255.255; CTRY:; LANG:en; SCL:1; SRV:; IPV:NLI; SFV:NSPM; H:SA0PR17MB4314.namprd17.prod.outlook.com; PTR:; CAT:NONE; SFS:(13230031)(396003)(346002)(136003)(376002)(366004)(39850400004)(1800799009)(186009)(451199024)(6486002)(6506007)(41300700001)(316002)(36756003)(30864003)(2906002)(86362001)(478600001)(66476007)(66556008)(6916009)(38100700002)(66946007)(6666004)(5660300002)(2616005)(1076003)(83380400001)(107886003)(8676002)(8936002)(4326008)(26005)(44832011)(6512007); DIR:OUT; SFP:1101 X-MS-Exchange-AntiSpam-MessageData-ChunkCount: 1 X-MS-Exchange-AntiSpam-MessageData-0: /DkH06wnhnff7M0KCpxmnz9BLUMPiTMdoC6gSYsgQPxw5gVPsOgxtqL50b2X7SPrVYUz92IQ8RnEyfQAlMHAU7bmOXWloX+QAxrMgI4FLV5b/zxzpvk8Nj39WPsmJtgTyEDXpgAtu4ieFAqHqTk7xIoSqq8Slg5HNWqFhxffJU9CFHnVHHrQWiFACalga2eSqzrfklKm9SLwdBxjPNm7L6uFoEDBetMNjI/f4t8SFzXZh3her489TDnmnC7ZBZ+orS6+2lco9fjNXqPdchXuKXWt7hMOb8NcQTbN4OnTIRWAjD1EQa4ocwHYgc0SPKByXVS87HX/JVwA9LoZra9c4nn30x1ekPL7S3DY/mO8EWkWQkt2ASu8v41z+RWQS0lq7QRyYW/7b+303T8RXwVtJeT1V38iNd2C5Wlg+Kphov9MuZm6IS+q01YYkBP8NIKb4Y7LEPYWP0KcxFRXzKLy20y9GQsQ+ED04rc8XDf1p14QvydnayiBIwXuq3vKD/NlPCwFCBEJ+bKz6NDvcjjHXf0HsZv57nKfEi7kohAKZMg2G3c5hpdFuVO4+h2M5YNxcLkig1CjvAztJVFoO0blmFw+JEdfIuBIsvHGjmWkzXJgWT98cWj0R1bkAvLYLyec9vpKW0PrVO2uYMTNuHoFeYlB1buY2XuMjZQ6yXOAadHejxbkoSgbY5joeZbSCBLI1Tf8iQbPHjvrrcBXLGzDqOnujXxMYH1nY3/c3CYMdOIBhCCN6fkduj3Iu3NAPyvh2/97VjfQw3RbTZMqY0uFdYuj/bXvwdt+5HvB0D7/kBBdKnsDYgIC0rOmQs4mkLNxnNlnkxRQ4yiCFjQdsF+MKadJOKzrvKWMxrwtSpHtf3IE+Kia96Q9bAFD4vqZB38KPAg0ZHz53HCpX/JMIcxvT2doyS6N6vGCdfDxBrgHVJfz9zno1c+lXgu/T5UQO8thReC7jaQiHcpjFqZzEnBLBJIznHFmvOvHSBjdbscD0zm7mk90pv0IhtuiTE6BNTfNUuI3dleJMY8hNyD4mG7DmNoTK398Rjs1YQghcUr7wggMPSzmkyDAqdTn13gHNbnMactMcFfTyXtc3lxOGTpNq41Pb4B3QNeYmv6Sd9ihXtKE9P5lE2LBXV6UPEW+aAOLNSxPEWIN8Q9piQCOX9rCVN8KLqFUkdwCFTqVNMj3ugqlaV2vDzkO2zseduQPdC5EjQ4Bdq1xvBnGzSpsSG0KWdgMYL7eCx2qzynm5BbuUwvrStSwmkHQpc1ZJNXoqNgZtgHf+CA7gj1o9p4Vq6Hzl/qMZVIasUYYNVxvr+y9NCkGZociLPwMmqY/+6WOcMWwaXDa2oU0V0Lw2l4XerJCGPnlUxs/V0PCB7ED0rQzYXZR3oRUkYQe8SLhEXxNfQMnU4a7pnKfy/qxT86V8ASfNdIOFS6qRzvcmMVGIuo0b+YoOszE/yJI2CIg/rAraFTa3ZC6v9F+fw0qjpu2f31xSr+aPLb24F4c7n/S1xtxElQPLCUjkfskti1EcqEwWNR4JAdNOwm1l5j/TlHUp1zbOme/Ls5+8AhnSTJGztq2p1BekPwvRAW7Ce5Se1vOyqwp X-OriginatorOrg: labware.com X-MS-Exchange-CrossTenant-Network-Message-Id: 5b90c346-a1ba-4c79-be85-08dbb0af5559 X-MS-Exchange-CrossTenant-AuthSource: SA0PR17MB4314.namprd17.prod.outlook.com X-MS-Exchange-CrossTenant-AuthAs: Internal X-MS-Exchange-CrossTenant-OriginalArrivalTime: 08 Sep 2023 21:05:30.3108 (UTC) X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-CrossTenant-Id: b5db0322-1aa0-4c0a-859c-ad0f96966f4c X-MS-Exchange-CrossTenant-MailboxType: HOSTED X-MS-Exchange-CrossTenant-UserPrincipalName: XqJbwKvy1JgnixT2a1YKzl3FjhiOZQ9SwtyS1kKuTwpTQUniJtJW0Fy8atNmWgl1vw0KAfxWbSGNEO9nf7aHyA== X-MS-Exchange-Transport-CrossTenantHeadersStamped: SA0PR17MB4442 X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: labware.com X-Spam-Status: No, score=-12.8 required=5.0 tests=BAYES_00, GIT_PATCH_0, KAM_DMARC_STATUS, RCVD_IN_DNSWL_NONE, RCVD_IN_MSPIKE_H5, RCVD_IN_MSPIKE_WL, SPF_HELO_NONE, SPF_PASS, TXREP autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on server2.sourceware.org X-BeenThere: gdb-patches@sourceware.org X-Mailman-Version: 2.1.30 Precedence: list List-Id: Gdb-patches mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-Patchwork-Original-From: Jan Vrany via Gdb-patches From: Jan Vrany Reply-To: Jan Vrany Errors-To: gdb-patches-bounces+patchwork=sourceware.org@sourceware.org Sender: "Gdb-patches" This commit renames serialize_mi_result() to serialize_mi_data() and makes it usable in different contexts than printing result of custom MI command (hence the rename). To do so, the check whether passed Python object is a dictionary has been moved to the caller - at the very least, different usages require different error messages. Also it seemed to me that py-utils.c is a better place for its code as it is now a utility function not specific to Python MI commands. This is a preparation for implementing Python support for sending custom MI async events. --- gdb/python/py-micmd.c | 179 ++--------------------------------- gdb/python/py-utils.c | 145 ++++++++++++++++++++++++++++ gdb/python/python-internal.h | 15 +++ 3 files changed, 166 insertions(+), 173 deletions(-) diff --git a/gdb/python/py-micmd.c b/gdb/python/py-micmd.c index 01fc6060ece..26231fc37e8 100644 --- a/gdb/python/py-micmd.c +++ b/gdb/python/py-micmd.c @@ -173,178 +173,6 @@ extern PyTypeObject micmdpy_object_type static PyObject *invoke_cst; -/* Convert KEY_OBJ into a string that can be used as a field name in MI - output. KEY_OBJ must be a Python string object, and must only contain - characters suitable for use as an MI field name. - - If KEY_OBJ is not a string, or if KEY_OBJ contains invalid characters, - then an error is thrown. Otherwise, KEY_OBJ is converted to a string - and returned. */ - -static gdb::unique_xmalloc_ptr -py_object_to_mi_key (PyObject *key_obj) -{ - /* The key must be a string. */ - if (!PyUnicode_Check (key_obj)) - { - gdbpy_ref<> key_repr (PyObject_Repr (key_obj)); - gdb::unique_xmalloc_ptr key_repr_string; - if (key_repr != nullptr) - key_repr_string = python_string_to_target_string (key_repr.get ()); - if (key_repr_string == nullptr) - gdbpy_handle_exception (); - - gdbpy_error (_("non-string object used as key: %s"), - key_repr_string.get ()); - } - - gdb::unique_xmalloc_ptr key_string - = python_string_to_target_string (key_obj); - if (key_string == nullptr) - gdbpy_handle_exception (); - - /* Predicate function, returns true if NAME is a valid field name for use - in MI result output, otherwise, returns false. */ - auto is_valid_key_name = [] (const char *name) -> bool - { - gdb_assert (name != nullptr); - - if (*name == '\0' || !isalpha (*name)) - return false; - - for (; *name != '\0'; ++name) - if (!isalnum (*name) && *name != '_' && *name != '-') - return false; - - return true; - }; - - if (!is_valid_key_name (key_string.get ())) - { - if (*key_string.get () == '\0') - gdbpy_error (_("Invalid empty key in MI result")); - else - gdbpy_error (_("Invalid key in MI result: %s"), key_string.get ()); - } - - return key_string; -} - -/* Serialize RESULT and print it in MI format to the current_uiout. - FIELD_NAME is used as the name of this result field. - - RESULT can be a dictionary, a sequence, an iterator, or an object that - can be converted to a string, these are converted to the matching MI - output format (dictionaries as tuples, sequences and iterators as lists, - and strings as named fields). - - If anything goes wrong while formatting the output then an error is - thrown. - - This function is the recursive inner core of serialize_mi_result, and - should only be called from that function. */ - -static void -serialize_mi_result_1 (PyObject *result, const char *field_name) -{ - struct ui_out *uiout = current_uiout; - - if (PyDict_Check (result)) - { - PyObject *key, *value; - Py_ssize_t pos = 0; - ui_out_emit_tuple tuple_emitter (uiout, field_name); - while (PyDict_Next (result, &pos, &key, &value)) - { - gdb::unique_xmalloc_ptr key_string - (py_object_to_mi_key (key)); - serialize_mi_result_1 (value, key_string.get ()); - } - } - else if (PySequence_Check (result) && !PyUnicode_Check (result)) - { - ui_out_emit_list list_emitter (uiout, field_name); - Py_ssize_t len = PySequence_Size (result); - if (len == -1) - gdbpy_handle_exception (); - for (Py_ssize_t i = 0; i < len; ++i) - { - gdbpy_ref<> item (PySequence_ITEM (result, i)); - if (item == nullptr) - gdbpy_handle_exception (); - serialize_mi_result_1 (item.get (), nullptr); - } - } - else if (PyIter_Check (result)) - { - gdbpy_ref<> item; - ui_out_emit_list list_emitter (uiout, field_name); - while (true) - { - item.reset (PyIter_Next (result)); - if (item == nullptr) - { - if (PyErr_Occurred () != nullptr) - gdbpy_handle_exception (); - break; - } - serialize_mi_result_1 (item.get (), nullptr); - } - } - else - { - if (PyLong_Check (result)) - { - int overflow = 0; - gdb_py_longest val = gdb_py_long_as_long_and_overflow (result, - &overflow); - if (PyErr_Occurred () != nullptr) - gdbpy_handle_exception (); - if (overflow == 0) - { - uiout->field_signed (field_name, val); - return; - } - /* Fall through to the string case on overflow. */ - } - - gdb::unique_xmalloc_ptr string (gdbpy_obj_to_string (result)); - if (string == nullptr) - gdbpy_handle_exception (); - uiout->field_string (field_name, string.get ()); - } -} - -/* Serialize RESULT and print it in MI format to the current_uiout. - - This function handles the top-level result initially returned from the - invoke method of the Python command implementation. At the top-level - the result must be a dictionary. The values within this dictionary can - be a wider range of types. Handling the values of the top-level - dictionary is done by serialize_mi_result_1, see that function for more - details. - - If anything goes wrong while parsing and printing the MI output then an - error is thrown. */ - -static void -serialize_mi_result (PyObject *result) -{ - /* At the top-level, the result must be a dictionary. */ - - if (!PyDict_Check (result)) - gdbpy_error (_("Result from invoke must be a dictionary")); - - PyObject *key, *value; - Py_ssize_t pos = 0; - while (PyDict_Next (result, &pos, &key, &value)) - { - gdb::unique_xmalloc_ptr key_string - (py_object_to_mi_key (key)); - serialize_mi_result_1 (value, key_string.get ()); - } -} - /* Called when the MI command is invoked. PARSE contains the parsed command line arguments from the user. */ @@ -388,7 +216,12 @@ mi_command_py::invoke (struct mi_parse *parse) const gdbpy_handle_exception (); if (result != Py_None) - serialize_mi_result (result.get ()); + { + /* At the top-level, the result must be a dictionary. */ + if (!PyDict_Check (result.get ())) + gdbpy_error (_("Result from invoke must be a dictionary")); + serialize_mi_data (result.get ()); + } } /* See declaration above. */ diff --git a/gdb/python/py-utils.c b/gdb/python/py-utils.c index d5b07a80d82..72a232f251d 100644 --- a/gdb/python/py-utils.c +++ b/gdb/python/py-utils.c @@ -597,3 +597,148 @@ gdbpy_fix_doc_string_indentation (gdb::unique_xmalloc_ptr doc) return doc; } + +/* Convert KEY_OBJ into a string that can be used as a field name in MI + output. KEY_OBJ must be a Python string object, and must only contain + characters suitable for use as an MI field name. + + If KEY_OBJ is not a string, or if KEY_OBJ contains invalid characters, + then an error is thrown. Otherwise, KEY_OBJ is converted to a string + and returned. */ + +static gdb::unique_xmalloc_ptr +py_object_to_mi_key (PyObject *key_obj) +{ + /* The key must be a string. */ + if (!PyUnicode_Check (key_obj)) + { + gdbpy_ref<> key_repr (PyObject_Repr (key_obj)); + gdb::unique_xmalloc_ptr key_repr_string; + if (key_repr != nullptr) + key_repr_string = python_string_to_target_string (key_repr.get ()); + if (key_repr_string == nullptr) + gdbpy_handle_exception (); + + gdbpy_error (_("non-string object used as key: %s"), + key_repr_string.get ()); + } + + gdb::unique_xmalloc_ptr key_string + = python_string_to_target_string (key_obj); + if (key_string == nullptr) + gdbpy_handle_exception (); + + /* Predicate function, returns true if NAME is a valid field name for use + in MI result output, otherwise, returns false. */ + auto is_valid_key_name = [] (const char *name) -> bool + { + gdb_assert (name != nullptr); + + if (*name == '\0' || !isalpha (*name)) + return false; + + for (; *name != '\0'; ++name) + if (!isalnum (*name) && *name != '_' && *name != '-') + return false; + + return true; + }; + + if (!is_valid_key_name (key_string.get ())) + { + if (*key_string.get () == '\0') + gdbpy_error (_("Invalid empty key in MI result")); + else + gdbpy_error (_("Invalid key in MI result: %s"), key_string.get ()); + } + + return key_string; +} + +static void +serialize_mi_data_1 (PyObject *data, const char *field_name) +{ + struct ui_out *uiout = current_uiout; + + if (PyDict_Check (data)) + { + PyObject *key, *value; + Py_ssize_t pos = 0; + ui_out_emit_tuple tuple_emitter (uiout, field_name); + while (PyDict_Next (data, &pos, &key, &value)) + { + gdb::unique_xmalloc_ptr key_string + (py_object_to_mi_key (key)); + serialize_mi_data_1 (value, key_string.get ()); + } + } + else if (PySequence_Check (data) && !PyUnicode_Check (data)) + { + ui_out_emit_list list_emitter (uiout, field_name); + Py_ssize_t len = PySequence_Size (data); + if (len == -1) + gdbpy_handle_exception (); + for (Py_ssize_t i = 0; i < len; ++i) + { + gdbpy_ref<> item (PySequence_ITEM (data, i)); + if (item == nullptr) + gdbpy_handle_exception (); + serialize_mi_data_1 (item.get (), nullptr); + } + } + else if (PyIter_Check (data)) + { + gdbpy_ref<> item; + ui_out_emit_list list_emitter (uiout, field_name); + while (true) + { + item.reset (PyIter_Next (data)); + if (item == nullptr) + { + if (PyErr_Occurred () != nullptr) + gdbpy_handle_exception (); + break; + } + serialize_mi_data_1 (item.get (), nullptr); + } + } + else + { + if (PyLong_Check (data)) + { + int overflow = 0; + gdb_py_longest val = gdb_py_long_as_long_and_overflow (data, + &overflow); + if (PyErr_Occurred () != nullptr) + gdbpy_handle_exception (); + if (overflow == 0) + { + uiout->field_signed (field_name, val); + return; + } + /* Fall through to the string case on overflow. */ + } + + gdb::unique_xmalloc_ptr string (gdbpy_obj_to_string (data)); + if (string == nullptr) + gdbpy_handle_exception (); + uiout->field_string (field_name, string.get ()); + } +} + +/* See python-internal.h. */ + +void +serialize_mi_data (PyObject *data) +{ + gdb_assert (PyDict_Check (data)); + + PyObject *key, *value; + Py_ssize_t pos = 0; + while (PyDict_Next (data, &pos, &key, &value)) + { + gdb::unique_xmalloc_ptr key_string + (py_object_to_mi_key (key)); + serialize_mi_data_1 (value, key_string.get ()); + } +} diff --git a/gdb/python/python-internal.h b/gdb/python/python-internal.h index 93217375cc5..3f53b0ab6f0 100644 --- a/gdb/python/python-internal.h +++ b/gdb/python/python-internal.h @@ -486,6 +486,21 @@ struct gdbarch *arch_object_to_gdbarch (PyObject *obj); extern PyObject *gdbpy_execute_mi_command (PyObject *self, PyObject *args, PyObject *kw); +/* Serialize DATA and print it in MI format to the current_uiout. + + This function handles the top-level result initially returned from the + invoke method of the Python command implementation. At the top-level + the data must be a dictionary. Caller of this function is responsible + for ensuring that. The values within this dictionary can + be a wider range of types. Handling the values of the top-level + dictionary is done by serialize_mi_data_1, see that function for more + details. + + If anything goes wrong while parsing and printing the MI output then an + error is thrown. */ + +extern void serialize_mi_data (PyObject *result); + /* Convert Python object OBJ to a program_space pointer. OBJ must be a gdb.Progspace reference. Return nullptr if the gdb.Progspace is not valid (see gdb.Progspace.is_valid), otherwise return the program_space