gdb/python/py-utils.c

   1 /* General utility routines for GDB/Python.
   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 "charset.h"
  22 #include "python-internal.h"
  23
  24
  25 /* This is a cleanup function which decrements the refcount on a
  26    Python object.  */
  27
  28 static void
  29 py_decref (void *p)
  30 {
  31   PyObject *py = p;
  32   /* Note that we need the extra braces in this 'if' to avoid a
  33      warning from gcc.  */
  34   if (py)
  35     {
  36       Py_DECREF (py);
  37     }
  38 }
  39
  40 /* Return a new cleanup which will decrement the Python object's
  41    refcount when run.  */
  42
  43 struct cleanup *
  44 make_cleanup_py_decref (PyObject *py)
  45 {
  46   return make_cleanup (py_decref, (void *) py);
  47 }
  48
  49 /* Converts a Python 8-bit string to a unicode string object.  Assumes the
  50    8-bit string is in the host charset.  If an error occurs during conversion,
  51    returns NULL with a python exception set.
  52
  53    As an added bonus, the functions accepts a unicode string and returns it
  54    right away, so callers don't need to check which kind of string they've
  55    got.
  56
  57    If the given object is not one of the mentioned string types, NULL is
  58    returned, with the TypeError python exception set.  */
  59 PyObject *
  60 python_string_to_unicode (PyObject *obj)
  61 {
  62   PyObject *unicode_str;
  63
  64   /* If obj is already a unicode string, just return it.
  65      I wish life was always that simple...  */
  66   if (PyUnicode_Check (obj))
  67     {
  68       unicode_str = obj;
  69       Py_INCREF (obj);
  70     }
  71
  72   else if (PyString_Check (obj))
  73     unicode_str = PyUnicode_FromEncodedObject (obj, host_charset (), NULL);
  74   else
  75     {
  76       PyErr_SetString (PyExc_TypeError,
  77                        _("Expected a string or unicode object."));
  78       unicode_str = NULL;
  79     }
  80
  81   return unicode_str;
  82 }
  83
  84 /* Returns a newly allocated string with the contents of the given unicode
  85    string object converted to CHARSET.  If an error occurs during the
  86    conversion, NULL will be returned and a python exception will be set.
  87
  88    The caller is responsible for xfree'ing the string.  */
  89 static char *
  90 unicode_to_encoded_string (PyObject *unicode_str, const char *charset)
  91 {
  92   char *result;
  93   PyObject *string;
  94
  95   /* Translate string to named charset.  */
  96   string = PyUnicode_AsEncodedString (unicode_str, charset, NULL);
  97   if (string == NULL)
  98     return NULL;
  99
 100   result = xstrdup (PyString_AsString (string));
 101
 102   Py_DECREF (string);
 103
 104   return result;
 105 }
 106
 107 /* Returns a PyObject with the contents of the given unicode string
 108    object converted to a named charset.  If an error occurs during
 109    the conversion, NULL will be returned and a python exception will
 110    be set.  */
 111 static PyObject *
 112 unicode_to_encoded_python_string (PyObject *unicode_str, const char *charset)
 113 {
 114   PyObject *string;
 115
 116   /* Translate string to named charset.  */
 117   string = PyUnicode_AsEncodedString (unicode_str, charset, NULL);
 118   if (string == NULL)
 119     return NULL;
 120
 121   return string;
 122 }
 123
 124 /* Returns a newly allocated string with the contents of the given unicode
 125    string object converted to the target's charset.  If an error occurs during
 126    the conversion, NULL will be returned and a python exception will be set.
 127
 128    The caller is responsible for xfree'ing the string.  */
 129 char *
 130 unicode_to_target_string (PyObject *unicode_str)
 131 {
 132   return unicode_to_encoded_string (unicode_str, target_charset ());
 133 }
 134
 135 /* Returns a PyObject with the contents of the given unicode string
 136    object converted to the target's charset.  If an error occurs
 137    during the conversion, NULL will be returned and a python exception
 138    will be set.  */
 139 PyObject *
 140 unicode_to_target_python_string (PyObject *unicode_str)
 141 {
 142   return unicode_to_encoded_python_string (unicode_str, target_charset ());
 143 }
 144
 145 /* Converts a python string (8-bit or unicode) to a target string in
 146    the target's charset.  Returns NULL on error, with a python exception set.
 147
 148    The caller is responsible for xfree'ing the string.  */
 149 char *
 150 python_string_to_target_string (PyObject *obj)
 151 {
 152   PyObject *str;
 153   char *result;
 154
 155   str = python_string_to_unicode (obj);
 156   if (str == NULL)
 157     return NULL;
 158
 159   result = unicode_to_target_string (str);
 160   Py_DECREF (str);
 161   return result;
 162 }
 163
 164 /* Converts a python string (8-bit or unicode) to a target string in the
 165    target's charset.  Returns NULL on error, with a python exception
 166    set.  */
 167 PyObject *
 168 python_string_to_target_python_string (PyObject *obj)
 169 {
 170   PyObject *str;
 171   PyObject *result;
 172
 173   str = python_string_to_unicode (obj);
 174   if (str == NULL)
 175     return NULL;
 176
 177   result = unicode_to_target_python_string (str);
 178   Py_DECREF (str);
 179   return result;
 180 }
 181
 182 /* Converts a python string (8-bit or unicode) to a target string in
 183    the host's charset.  Returns NULL on error, with a python exception set.
 184
 185    The caller is responsible for xfree'ing the string.  */
 186 char *
 187 python_string_to_host_string (PyObject *obj)
 188 {
 189   PyObject *str;
 190   char *result;
 191
 192   str = python_string_to_unicode (obj);
 193   if (str == NULL)
 194     return NULL;
 195
 196   result = unicode_to_encoded_string (str, host_charset ());
 197   Py_DECREF (str);
 198   return result;
 199 }
 200
 201 /* Converts a target string of LENGTH bytes in the target's charset to a
 202    Python Unicode string. If LENGTH is -1, convert until a null byte is found.
 203
 204    Returns NULL on error, with a python exception set.  */
 205 PyObject *
 206 target_string_to_unicode (const gdb_byte *str, int length)
 207 {
 208   if (length == -1)
 209     length = strlen (str);
 210
 211   return PyUnicode_Decode (str, length, target_charset (), NULL);
 212 }
 213
 214 /* Return true if OBJ is a Python string or unicode object, false
 215    otherwise.  */
 216
 217 int
 218 gdbpy_is_string (PyObject *obj)
 219 {
 220   return PyString_Check (obj) || PyUnicode_Check (obj);
 221 }