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

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-7.1/] [gdb/] [python/] [py-utils.c] - Blame information for rev 227

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 227 jeremybenn
/* 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
}

powered by: WebSVN 2.1.0

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