PyAPI_FUNC(void) _Py_BreakPoint(void);
PyAPI_FUNC(void) _PyObject_Dump(PyObject *);
PyAPI_FUNC(PyObject *) PyObject_Repr(PyObject *);
+PyAPI_FUNC(PyObject *) PyObject_ReprStr8(PyObject *);
PyAPI_FUNC(PyObject *) _PyObject_Str(PyObject *);
PyAPI_FUNC(PyObject *) PyObject_Str(PyObject *);
PyAPI_FUNC(PyObject *) PyObject_Unicode(PyObject *);
PyAPI_FUNC(long) _Py_HashPointer(void*);
/* Helper for passing objects to printf and the like */
-#define PyObject_REPR(obj) PyString_AS_STRING(PyObject_Repr(obj))
+#define PyObject_REPR(obj) PyString_AS_STRING(PyObject_ReprStr8(obj))
/* Flag bits for printing: */
#define Py_PRINT_RAW 1 /* No string quotes etc. */
# define PyUnicode_AsWideChar PyUnicodeUCS2_AsWideChar
# define PyUnicode_Compare PyUnicodeUCS2_Compare
# define PyUnicode_Concat PyUnicodeUCS2_Concat
+# define PyUnicode_Append PyUnicodeUCS2_Append
+# define PyUnicode_AppendAndDel PyUnicodeUCS2_AppendAndDel
# define PyUnicode_Contains PyUnicodeUCS2_Contains
# define PyUnicode_Count PyUnicodeUCS2_Count
# define PyUnicode_Decode PyUnicodeUCS2_Decode
# define PyUnicode_AsWideChar PyUnicodeUCS4_AsWideChar
# define PyUnicode_Compare PyUnicodeUCS4_Compare
# define PyUnicode_Concat PyUnicodeUCS4_Concat
+# define PyUnicode_Append PyUnicodeUCS4_Append
+# define PyUnicode_AppendAndDel PyUnicodeUCS4_AppendAndDel
# define PyUnicode_Contains PyUnicodeUCS4_Contains
# define PyUnicode_Count PyUnicodeUCS4_Count
# define PyUnicode_Decode PyUnicodeUCS4_Decode
PyObject *right /* Right string */
);
+/* Concat two strings and put the result in *pleft
+ (sets *pleft to NULL on error) */
+
+PyAPI_FUNC(void) PyUnicode_Append(
+ PyObject **pleft, /* Pointer to left string */
+ PyObject *right /* Right string */
+ );
+
+/* Concat two strings, put the result in *pleft and drop the right object
+ (sets *pleft to NULL on error) */
+
+PyAPI_FUNC(void) PyUnicode_AppendAndDel(
+ PyObject **pleft, /* Pointer to left string */
+ PyObject *right /* Right string */
+ );
+
/* Split a string giving a list of Unicode strings.
If sep is NULL, splitting will be done at all whitespace
{
char buf[100];
sprintf(buf, "<CFTypeRef type-%d object at 0x%8.8x for 0x%8.8x>", (int)CFGetTypeID(self->ob_itself), (unsigned)self, (unsigned)self->ob_itself);
- return PyString_FromString(buf);
+ return PyUnicode_FromString(buf);
}
static int CFTypeRefObj_hash(CFTypeRefObject *self)
{
char buf[100];
sprintf(buf, "<CFArrayRef object at 0x%8.8x for 0x%8.8x>", (unsigned)self, (unsigned)self->ob_itself);
- return PyString_FromString(buf);
+ return PyUnicode_FromString(buf);
}
static int CFArrayRefObj_hash(CFArrayRefObject *self)
{
char buf[100];
sprintf(buf, "<CFMutableArrayRef object at 0x%8.8x for 0x%8.8x>", (unsigned)self, (unsigned)self->ob_itself);
- return PyString_FromString(buf);
+ return PyUnicode_FromString(buf);
}
static int CFMutableArrayRefObj_hash(CFMutableArrayRefObject *self)
{
char buf[100];
sprintf(buf, "<CFDictionaryRef object at 0x%8.8x for 0x%8.8x>", (unsigned)self, (unsigned)self->ob_itself);
- return PyString_FromString(buf);
+ return PyUnicode_FromString(buf);
}
static int CFDictionaryRefObj_hash(CFDictionaryRefObject *self)
{
char buf[100];
sprintf(buf, "<CFMutableDictionaryRef object at 0x%8.8x for 0x%8.8x>", (unsigned)self, (unsigned)self->ob_itself);
- return PyString_FromString(buf);
+ return PyUnicode_FromString(buf);
}
static int CFMutableDictionaryRefObj_hash(CFMutableDictionaryRefObject *self)
{
char buf[100];
sprintf(buf, "<CFDataRef object at 0x%8.8x for 0x%8.8x>", (unsigned)self, (unsigned)self->ob_itself);
- return PyString_FromString(buf);
+ return PyUnicode_FromString(buf);
}
static int CFDataRefObj_hash(CFDataRefObject *self)
{
char buf[100];
sprintf(buf, "<CFMutableDataRef object at 0x%8.8x for 0x%8.8x>", (unsigned)self, (unsigned)self->ob_itself);
- return PyString_FromString(buf);
+ return PyUnicode_FromString(buf);
}
static int CFMutableDataRefObj_hash(CFMutableDataRefObject *self)
{
char buf[100];
sprintf(buf, "<CFStringRef object at 0x%8.8x for 0x%8.8x>", (unsigned)self, (unsigned)self->ob_itself);
- return PyString_FromString(buf);
+ return PyUnicode_FromString(buf);
}
static int CFStringRefObj_hash(CFStringRefObject *self)
{
char buf[100];
sprintf(buf, "<CFMutableStringRef object at 0x%8.8x for 0x%8.8x>", (unsigned)self, (unsigned)self->ob_itself);
- return PyString_FromString(buf);
+ return PyUnicode_FromString(buf);
}
static int CFMutableStringRefObj_hash(CFMutableStringRefObject *self)
{
char buf[100];
sprintf(buf, "<CFURL object at 0x%8.8x for 0x%8.8x>", (unsigned)self, (unsigned)self->ob_itself);
- return PyString_FromString(buf);
+ return PyUnicode_FromString(buf);
}
static int CFURLRefObj_hash(CFURLRefObject *self)
self->ob_itself.vRefNum,
self->ob_itself.parID,
self->ob_itself.name[0], self->ob_itself.name+1);
- return PyString_FromString(buf);
+ return PyUnicode_FromString(buf);
}
#define FSSpec_hash NULL
{
char buf[100];
sprintf(buf, "<Window object at 0x%8.8x for 0x%8.8x>", (unsigned)self, (unsigned)self->ob_itself);
- return PyString_FromString(buf);
+ return PyUnicode_FromString(buf);
}
static int WinObj_hash(WindowObject *self)
escape_encode(PyObject *self,
PyObject *args)
{
+ static const char *hexdigits = "0123456789abcdef";
PyObject *str;
+ Py_ssize_t size;
+ Py_ssize_t newsize;
const char *errors = NULL;
- char *buf;
- Py_ssize_t len;
+ PyObject *v;
if (!PyArg_ParseTuple(args, "O!|z:escape_encode",
&PyString_Type, &str, &errors))
return NULL;
- str = PyString_Repr(str, 0);
- if (!str)
- return NULL;
+ size = PyUnicode_GET_SIZE(str);
+ newsize = 4*size;
+ if (newsize > PY_SSIZE_T_MAX || newsize / 4 != size) {
+ PyErr_SetString(PyExc_OverflowError,
+ "string is too large to encode");
+ return NULL;
+ }
+ v = PyBytes_FromStringAndSize(NULL, newsize);
- /* The string will be quoted. Unquote, similar to unicode-escape. */
- buf = PyString_AS_STRING (str);
- len = PyString_GET_SIZE (str);
- memmove(buf, buf+1, len-2);
- if (_PyString_Resize(&str, len-2) < 0)
+ if (v == NULL) {
return NULL;
+ }
+ else {
+ register Py_ssize_t i;
+ register char c;
+ register char *p = PyBytes_AS_STRING(v);
+
+ for (i = 0; i < size; i++) {
+ /* There's at least enough room for a hex escape */
+ assert(newsize - (p - PyBytes_AS_STRING(v)) >= 4);
+ c = PyString_AS_STRING(str)[i];
+ if (c == '\'' || c == '\\')
+ *p++ = '\\', *p++ = c;
+ else if (c == '\t')
+ *p++ = '\\', *p++ = 't';
+ else if (c == '\n')
+ *p++ = '\\', *p++ = 'n';
+ else if (c == '\r')
+ *p++ = '\\', *p++ = 'r';
+ else if (c < ' ' || c >= 0x7f) {
+ *p++ = '\\';
+ *p++ = 'x';
+ *p++ = hexdigits[(c & 0xf0) >> 4];
+ *p++ = hexdigits[c & 0xf];
+ }
+ else
+ *p++ = c;
+ }
+ *p = '\0';
+ if (PyBytes_Resize(v, (p - PyBytes_AS_STRING(v)))) {
+ Py_DECREF(v);
+ return NULL;
+ }
+ }
- return codec_tuple(str, PyString_Size(str));
+ return codec_tuple(v, PyBytes_Size(v));
}
/* --- Decoder ------------------------------------------------------------ */
static PyObject *
deque_repr(PyObject *deque)
{
- PyObject *aslist, *result, *fmt;
+ PyObject *aslist, *result;
int i;
i = Py_ReprEnter(deque);
if (i != 0) {
if (i < 0)
return NULL;
- return PyString_FromString("[...]");
+ return PyUnicode_FromString("[...]");
}
aslist = PySequence_List(deque);
return NULL;
}
- fmt = PyString_FromString("deque(%r)");
- if (fmt == NULL) {
+ result = PyUnicode_FromString("deque(");
+ if (result == NULL) {
Py_DECREF(aslist);
Py_ReprLeave(deque);
return NULL;
}
- result = PyString_Format(fmt, aslist);
- Py_DECREF(fmt);
+ PyUnicode_AppendAndDel(&result, PyObject_Repr(aslist));
+ PyUnicode_AppendAndDel(&result, PyUnicode_FromString(")"));
Py_DECREF(aslist);
Py_ReprLeave(deque);
return result;
if (baserepr == NULL)
return NULL;
if (dd->default_factory == NULL)
- defrepr = PyString_FromString("None");
+ defrepr = PyUnicode_FromString("None");
else
defrepr = PyObject_Repr(dd->default_factory);
if (defrepr == NULL) {
Py_DECREF(baserepr);
return NULL;
}
- result = PyString_FromFormat("defaultdict(%s, %s)",
- PyString_AS_STRING(defrepr),
- PyString_AS_STRING(baserepr));
- Py_DECREF(defrepr);
- Py_DECREF(baserepr);
+ result = PyUnicode_FromString("defaultdict(");
+ PyUnicode_AppendAndDel(&result, defrepr);
+ PyUnicode_AppendAndDel(&result, PyUnicode_FromString(", "));
+ PyUnicode_AppendAndDel(&result, baserepr);
+ PyUnicode_AppendAndDel(&result, PyUnicode_FromString(")"));
return result;
}
{
#ifdef MS_WIN32
if (self->index)
- return PyString_FromFormat("<COM method offset %d: %s at %p>",
+ return PyUnicode_FromFormat("<COM method offset %d: %s at %p>",
self->index - 0x1000,
self->ob_type->tp_name,
self);
#endif
- return PyString_FromFormat("<%s object at %p>",
+ return PyUnicode_FromFormat("<%s object at %p>",
self->ob_type->tp_name,
self);
}
static PyObject *format;
if (self->ob_type->tp_base != &Simple_Type) {
- return PyString_FromFormat("<%s object at %p>",
+ return PyUnicode_FromFormat("<%s object at %p>",
self->ob_type->tp_name, self);
}
if (format == NULL) {
- format = PyString_FromString("%s(%r)");
+ format = PyUnicode_FromString("%s(%r)");
if (format == NULL)
return NULL;
}
if (val == NULL)
return NULL;
- name = PyString_FromString(self->ob_type->tp_name);
+ name = PyUnicode_FromString(self->ob_type->tp_name);
if (name == NULL) {
Py_DECREF(val);
return NULL;
if (args == NULL)
return NULL;
- result = PyString_Format(format, args);
+ result = PyUnicode_Format(format, args);
Py_DECREF(args);
return result;
}
self->tag, (long)self);
break;
}
- return PyString_FromString(buffer);
+ return PyUnicode_FromString(buffer);
}
static PyMemberDef PyCArgType_members[] = {
name = ((PyTypeObject *)self->proto)->tp_name;
if (bits)
- result = PyString_FromFormat(
+ result = PyUnicode_FromFormat(
#if (PY_VERSION_HEX < 0x02050000)
"<Field type=%s, ofs=%d:%d, bits=%d>",
#else
#endif
name, self->offset, size, bits);
else
- result = PyString_FromFormat(
+ result = PyUnicode_FromFormat(
#if (PY_VERSION_HEX < 0x02050000)
"<Field type=%s, ofs=%d, size=%d>",
#else
PyObject* repr;
char buffer[100];
- repr = PyString_FromString("<Element ");
+ repr = PyUnicode_FromString("<Element ");
- PyString_ConcatAndDel(&repr, PyObject_Repr(self->tag));
+ PyUnicode_AppendAndDel(&repr, PyObject_Repr(self->tag));
sprintf(buffer, " at %p>", self);
- PyString_ConcatAndDel(&repr, PyString_FromString(buffer));
+ PyUnicode_AppendAndDel(&repr, PyUnicode_FromString(buffer));
return repr;
}
fileio_repr(PyFileIOObject *self)
{
if (self->fd < 0)
- return PyString_FromFormat("_fileio._FileIO(-1)");
+ return PyUnicode_FromFormat("_fileio._FileIO(-1)");
- return PyString_FromFormat("_fileio._FileIO(%d, '%s')",
+ return PyUnicode_FromFormat("_fileio._FileIO(%d, '%s')",
self->fd, mode_string(self));
}
char buf[100];
PyOS_snprintf(buf, sizeof(buf), "<%s HASH object @ %p>",
PyString_AsString(((EVPobject *)self)->name), self);
- return PyString_FromString(buf);
+ return PyUnicode_FromString(buf);
}
#if HASH_OBJ_CONSTRUCTOR
char buf[50];
PyOS_snprintf(buf, 50, "<%s object at %p>",
self->value->typePtr->name, self->value);
- return PyString_FromString(buf);
+ return PyUnicode_FromString(buf);
}
static int
PyOS_snprintf(buf, sizeof(buf), "<tktimertoken at %p%s>", v,
v->func == NULL ? ", handler deleted" : "");
- return PyString_FromString(buf);
+ return PyUnicode_FromString(buf);
}
static PyObject *
typecode = a->ob_descr->typecode;
if (len == 0) {
PyOS_snprintf(buf, sizeof(buf), "array('%c')", typecode);
- return PyString_FromString(buf);
+ return PyUnicode_FromString(buf);
}
if (typecode == 'c')
Py_XDECREF(v);
PyOS_snprintf(buf, sizeof(buf), "array('%c', ", typecode);
- s = PyString_FromString(buf);
- PyString_ConcatAndDel(&s, t);
- PyString_ConcatAndDel(&s, PyString_FromString(")"));
+ s = PyUnicode_FromString(buf);
+ PyUnicode_AppendAndDel(&s, t);
+ PyUnicode_AppendAndDel(&s, PyUnicode_FromString(")"));
return s;
}
/* proto < 2: write the repr and newline. This is quadratic-time
* (in the number of digits), in both directions.
*/
- if (!( repr = PyObject_Repr(args)))
+ if (!( repr = PyObject_ReprStr8(args)))
goto finally;
if ((size = PyString_Size(repr)) < 0)
static char string = STRING;
- if (!( repr = PyObject_Repr(args)))
+ if (!( repr = PyObject_ReprStr8(args)))
return -1;
if ((len = PyString_Size(repr)) < 0)
{
PyObject *temp;
- assert(PyString_Check(repr));
+ assert(PyUnicode_Check(repr));
assert(tzinfo);
if (tzinfo == Py_None)
return repr;
/* Get rid of the trailing ')'. */
- assert(PyString_AsString(repr)[PyString_Size(repr)-1] == ')');
- temp = PyString_FromStringAndSize(PyString_AsString(repr),
- PyString_Size(repr) - 1);
+ assert(PyUnicode_AS_UNICODE(repr)[PyUnicode_GET_SIZE(repr)-1] == ')');
+ temp = PyUnicode_FromUnicode(PyUnicode_AS_UNICODE(repr),
+ PyUnicode_GET_SIZE(repr) - 1);
Py_DECREF(repr);
if (temp == NULL)
return NULL;
repr = temp;
/* Append ", tzinfo=". */
- PyString_ConcatAndDel(&repr, PyString_FromString(", tzinfo="));
+ PyUnicode_AppendAndDel(&repr, PyUnicode_FromString(", tzinfo="));
/* Append repr(tzinfo). */
- PyString_ConcatAndDel(&repr, PyObject_Repr(tzinfo));
+ PyUnicode_AppendAndDel(&repr, PyObject_Repr(tzinfo));
/* Add a closing paren. */
- PyString_ConcatAndDel(&repr, PyString_FromString(")"));
+ PyUnicode_AppendAndDel(&repr, PyUnicode_FromString(")"));
return repr;
}
delta_repr(PyDateTime_Delta *self)
{
if (GET_TD_MICROSECONDS(self) != 0)
- return PyString_FromFormat("%s(%d, %d, %d)",
+ return PyUnicode_FromFormat("%s(%d, %d, %d)",
self->ob_type->tp_name,
GET_TD_DAYS(self),
GET_TD_SECONDS(self),
GET_TD_MICROSECONDS(self));
if (GET_TD_SECONDS(self) != 0)
- return PyString_FromFormat("%s(%d, %d)",
+ return PyUnicode_FromFormat("%s(%d, %d)",
self->ob_type->tp_name,
GET_TD_DAYS(self),
GET_TD_SECONDS(self));
- return PyString_FromFormat("%s(%d)",
+ return PyUnicode_FromFormat("%s(%d)",
self->ob_type->tp_name,
GET_TD_DAYS(self));
}
type_name,
GET_YEAR(self), GET_MONTH(self), GET_DAY(self));
- return PyString_FromString(buffer);
+ return PyUnicode_FromString(buffer);
}
static PyObject *
else
PyOS_snprintf(buffer, sizeof(buffer),
"%s(%d, %d)", type_name, h, m);
- result = PyString_FromString(buffer);
+ result = PyUnicode_FromString(buffer);
if (result != NULL && HASTZINFO(self))
result = append_keyword_tzinfo(result, self->tzinfo);
return result;
GET_YEAR(self), GET_MONTH(self), GET_DAY(self),
DATE_GET_HOUR(self), DATE_GET_MINUTE(self));
}
- baserepr = PyString_FromString(buffer);
+ baserepr = PyUnicode_FromString(buffer);
if (baserepr == NULL || ! HASTZINFO(self))
return baserepr;
return append_keyword_tzinfo(baserepr, self->tzinfo);
static PyObject *
count_repr(countobject *lz)
{
- return PyString_FromFormat("count(%zd)", lz->cnt);
+ return PyUnicode_FromFormat("count(%zd)", lz->cnt);
}
PyDoc_STRVAR(count_doc,
return NULL;
if (ro->cnt == -1)
- result = PyString_FromFormat("repeat(%s)",
- PyString_AS_STRING(objrepr));
+ result = PyUnicode_FromFormat("repeat(%U)",
+ objrepr);
else
- result = PyString_FromFormat("repeat(%s, %zd)",
- PyString_AS_STRING(objrepr), ro->cnt);
+ result = PyUnicode_FromFormat("repeat(%U, %zd)",
+ objrepr, ro->cnt);
Py_DECREF(objrepr);
return result;
}
(long)s->sock_fd, s->sock_family,
s->sock_type,
s->sock_proto);
- return PyString_FromString(buf);
+ return PyUnicode_FromString(buf);
}
PyOS_snprintf(buf, sizeof(buf),
"<zipimporter object \"%.300s\">",
archive);
- return PyString_FromString(buf);
+ return PyUnicode_FromString(buf);
}
/* return fullname.split(".")[-1] */
if (self == Py_True)
s = true_str ? true_str :
- (true_str = PyString_InternFromString("True"));
+ (true_str = PyUnicode_FromString("True"));
else
s = false_str ? false_str :
- (false_str = PyString_InternFromString("False"));
+ (false_str = PyUnicode_FromString("False"));
Py_XINCREF(s);
return s;
}
const char *status = self->b_readonly ? "read-only" : "read-write";
if ( self->b_base == NULL )
- return PyString_FromFormat("<%s buffer ptr %p, size %zd at %p>",
+ return PyUnicode_FromFormat("<%s buffer ptr %p, size %zd at %p>",
status,
self->b_ptr,
self->b_size,
self);
else
- return PyString_FromFormat(
+ return PyUnicode_FromFormat(
"<%s buffer for %p, size %zd, offset %zd at %p>",
status,
self->b_base,
static PyObject *
bytes_repr(PyBytesObject *self)
{
+ static const char *hexdigits = "0123456789abcdef";
size_t newsize = 3 + 4 * self->ob_size;
PyObject *v;
if (newsize > PY_SSIZE_T_MAX || newsize / 4 != self->ob_size) {
"bytes object is too large to make repr");
return NULL;
}
- v = PyString_FromStringAndSize((char *)NULL, newsize);
+ v = PyUnicode_FromUnicode(NULL, newsize);
if (v == NULL) {
return NULL;
}
else {
register Py_ssize_t i;
- register char c;
- register char *p;
+ register Py_UNICODE c;
+ register Py_UNICODE *p;
int quote = '\'';
- p = PyString_AS_STRING(v);
+ p = PyUnicode_AS_UNICODE(v);
*p++ = 'b';
*p++ = quote;
for (i = 0; i < self->ob_size; i++) {
/* There's at least enough room for a hex escape
and a closing quote. */
- assert(newsize - (p - PyString_AS_STRING(v)) >= 5);
+ assert(newsize - (p - PyUnicode_AS_UNICODE(v)) >= 5);
c = self->ob_bytes[i];
if (c == quote || c == '\\')
*p++ = '\\', *p++ = c;
else if (c == 0)
*p++ = '\\', *p++ = 'x', *p++ = '0', *p++ = '0';
else if (c < ' ' || c >= 0x7f) {
- /* For performance, we don't want to call
- PyOS_snprintf here (extra layers of
- function call). */
- sprintf(p, "\\x%02x", c & 0xff);
- p += 4;
+ *p++ = '\\';
+ *p++ = 'x';
+ *p++ = hexdigits[(c & 0xf0) >> 4];
+ *p++ = hexdigits[c & 0xf];
}
else
*p++ = c;
}
- assert(newsize - (p - PyString_AS_STRING(v)) >= 1);
+ assert(newsize - (p - PyUnicode_AS_UNICODE(v)) >= 1);
*p++ = quote;
*p = '\0';
- _PyString_Resize(
- &v, (p - PyString_AS_STRING(v)));
+ if (PyUnicode_Resize(&v, (p - PyUnicode_AS_UNICODE(v)))) {
+ Py_DECREF(v);
+ return NULL;
+ }
return v;
}
}
cell_repr(PyCellObject *op)
{
if (op->ob_ref == NULL)
- return PyString_FromFormat("<cell at %p: empty>", op);
+ return PyUnicode_FromFormat("<cell at %p: empty>", op);
- return PyString_FromFormat("<cell at %p: %.80s object at %p>",
+ return PyUnicode_FromFormat("<cell at %p: %.80s object at %p>",
op, op->ob_ref->ob_type->tp_name,
op->ob_ref);
}
sklassname = PyString_AS_STRING(klassname);
}
if (self == NULL)
- result = PyString_FromFormat("<unbound method %s.%s>",
+ result = PyUnicode_FromFormat("<unbound method %s.%s>",
sklassname, sfuncname);
else {
+ result = PyUnicode_FromFormat("<bound method %s.%s of ",
+ sklassname, sfuncname);
/* XXX Shouldn't use repr() here! */
- PyObject *selfrepr = PyObject_Repr(self);
- if (selfrepr == NULL)
- goto fail;
- if (!PyString_Check(selfrepr)) {
- Py_DECREF(selfrepr);
- goto fail;
- }
- result = PyString_FromFormat("<bound method %s.%s of %s>",
- sklassname, sfuncname,
- PyString_AS_STRING(selfrepr));
- Py_DECREF(selfrepr);
+ PyUnicode_AppendAndDel(&result, PyObject_Repr(self));
+ PyUnicode_AppendAndDel(&result, PyUnicode_FromString(">"));
}
- fail:
Py_XDECREF(funcname);
Py_XDECREF(klassname);
return result;
PyOS_snprintf(buf, sizeof(buf),
"<code object %.100s at %p, file \"%.300s\", line %d>",
name, co, filename, lineno);
- return PyString_FromString(buf);
+ return PyUnicode_FromString(buf);
}
static PyObject *
{
char buf[100];
complex_to_buf(buf, sizeof(buf), v, PREC_REPR);
- return PyString_FromString(buf);
+ return PyUnicode_FromString(buf);
}
static PyObject *
static PyObject *
descr_repr(PyDescrObject *descr, char *format)
{
- return PyString_FromFormat(format, descr_name(descr),
+ return PyUnicode_FromFormat(format, descr_name(descr),
descr->d_type->tp_name);
}
static PyObject *
method_repr(PyMethodDescrObject *descr)
{
- return descr_repr((PyDescrObject *)descr,
+ return descr_repr((PyDescrObject *)descr,
"<method '%s' of '%s' objects>");
}
static PyObject *
member_repr(PyMemberDescrObject *descr)
{
- return descr_repr((PyDescrObject *)descr,
+ return descr_repr((PyDescrObject *)descr,
"<member '%s' of '%s' objects>");
}
static PyObject *
getset_repr(PyGetSetDescrObject *descr)
{
- return descr_repr((PyDescrObject *)descr,
+ return descr_repr((PyDescrObject *)descr,
"<attribute '%s' of '%s' objects>");
}
static PyObject *
wrapperdescr_repr(PyWrapperDescrObject *descr)
{
- return descr_repr((PyDescrObject *)descr,
+ return descr_repr((PyDescrObject *)descr,
"<slot wrapper '%s' of '%s' objects>");
}
static PyObject *
wrapper_repr(wrapperobject *wp)
{
- return PyString_FromFormat("<method-wrapper '%s' of %s object at %p>",
+ return PyUnicode_FromFormat("<method-wrapper '%s' of %s object at %p>",
wp->descr->d_base->name,
wp->self->ob_type->tp_name,
wp->self);
i = Py_ReprEnter((PyObject *)mp);
if (i != 0) {
- return i > 0 ? PyString_FromString("{...}") : NULL;
+ return i > 0 ? PyUnicode_FromString("{...}") : NULL;
}
if (mp->ma_used == 0) {
- result = PyString_FromString("{}");
+ result = PyUnicode_FromString("{}");
goto Done;
}
if (pieces == NULL)
goto Done;
- colon = PyString_FromString(": ");
+ colon = PyUnicode_FromString(": ");
if (colon == NULL)
goto Done;
/* Prevent repr from deleting value during key format. */
Py_INCREF(value);
s = PyObject_Repr(key);
- PyString_Concat(&s, colon);
- PyString_ConcatAndDel(&s, PyObject_Repr(value));
+ PyUnicode_Append(&s, colon);
+ PyUnicode_AppendAndDel(&s, PyObject_Repr(value));
Py_DECREF(value);
if (s == NULL)
goto Done;
/* Add "{}" decorations to the first and last items. */
assert(PyList_GET_SIZE(pieces) > 0);
- s = PyString_FromString("{");
+ s = PyUnicode_FromString("{");
if (s == NULL)
goto Done;
temp = PyList_GET_ITEM(pieces, 0);
- PyString_ConcatAndDel(&s, temp);
+ PyUnicode_AppendAndDel(&s, temp);
PyList_SET_ITEM(pieces, 0, s);
if (s == NULL)
goto Done;
- s = PyString_FromString("}");
+ s = PyUnicode_FromString("}");
if (s == NULL)
goto Done;
temp = PyList_GET_ITEM(pieces, PyList_GET_SIZE(pieces) - 1);
- PyString_ConcatAndDel(&temp, s);
+ PyUnicode_AppendAndDel(&temp, s);
PyList_SET_ITEM(pieces, PyList_GET_SIZE(pieces) - 1, temp);
if (temp == NULL)
goto Done;
/* Paste them all together with ", " between. */
- s = PyString_FromString(", ");
+ s = PyUnicode_FromString(", ");
if (s == NULL)
goto Done;
- result = _PyString_Join(s, pieces);
+ result = PyUnicode_Join(s, pieces);
Py_DECREF(s);
Done:
dot = strrchr(name, '.');
if (dot != NULL) name = dot+1;
- repr = PyString_FromString(name);
+ repr = PyUnicode_FromString(name);
if (!repr) {
Py_DECREF(repr_suffix);
return NULL;
}
- PyString_ConcatAndDel(&repr, repr_suffix);
+ PyUnicode_AppendAndDel(&repr, repr_suffix);
return repr;
}
if (!fmt)
return NULL;
- repr = PyObject_Repr(self->filename);
+ repr = PyObject_ReprStr8(self->filename);
if (!repr) {
Py_DECREF(fmt);
return NULL;
if (!fmt)
return NULL;
- repr = PyObject_Repr(self->filename);
+ repr = PyObject_ReprStr8(self->filename);
if (!repr) {
Py_DECREF(fmt);
return NULL;
If args is anything else, use the default BaseException__str__().
*/
if (PyTuple_GET_SIZE(self->args) == 1) {
- return PyObject_Repr(PyTuple_GET_ITEM(self->args, 0));
+ return PyObject_ReprStr8(PyTuple_GET_ITEM(self->args, 0));
}
return BaseException_str(self);
}
PyObject *ret = NULL;
PyObject *name = PyUnicode_AsUnicodeEscapeString(f->f_name);
const char *name_str = name ? PyString_AsString(name) : "?";
- ret = PyString_FromFormat("<%s file u'%s', mode '%s' at %p>",
+ ret = PyUnicode_FromFormat("<%s file u'%s', mode '%s' at %p>",
f->f_fp == NULL ? "closed" : "open",
name_str,
PyString_AsString(f->f_mode),
Py_XDECREF(name);
return ret;
} else {
- return PyString_FromFormat("<%s file '%s', mode '%s' at %p>",
+ return PyUnicode_FromFormat("<%s file '%s', mode '%s' at %p>",
f->f_fp == NULL ? "closed" : "open",
PyString_AsString(f->f_name),
PyString_AsString(f->f_mode),
value = PyObject_Str(v);
}
else
- value = PyObject_Repr(v);
+ value = PyObject_ReprStr8(v);
if (value == NULL) {
Py_DECREF(writer);
return -1;
{
char buf[100];
format_float(buf, sizeof(buf), v, PREC_REPR);
- return PyString_FromString(buf);
+ return PyUnicode_FromString(buf);
}
static PyObject *
static PyObject*
func_repr(PyFunctionObject *op)
{
- return PyString_FromFormat("<function %s at %p>",
+ return PyUnicode_FromFormat("<function %s at %p>",
PyString_AsString(op->func_name),
op);
}
sobj = PyString_FromStringAndSize(s, slen);
if (sobj == NULL)
return NULL;
- srepr = PyObject_Repr(sobj);
+ srepr = PyObject_ReprStr8(sobj);
Py_DECREF(sobj);
if (srepr == NULL)
return NULL;
{
char buf[64];
PyOS_snprintf(buf, sizeof(buf), "%ld", v->ob_ival);
- return PyString_FromString(buf);
+ return PyUnicode_FromString(buf);
}
static int
/* create a repr() of the input string,
* just like PyInt_FromString does */
PyObject *srepr;
- srepr = PyObject_Repr(x);
+ srepr = PyObject_ReprStr8(x);
if (srepr == NULL)
return NULL;
PyErr_Format(PyExc_ValueError,
i = Py_ReprEnter((PyObject*)v);
if (i != 0) {
- return i > 0 ? PyString_FromString("[...]") : NULL;
+ return i > 0 ? PyUnicode_FromString("[...]") : NULL;
}
if (v->ob_size == 0) {
- result = PyString_FromString("[]");
+ result = PyUnicode_FromString("[]");
goto Done;
}
/* Add "[]" decorations to the first and last items. */
assert(PyList_GET_SIZE(pieces) > 0);
- s = PyString_FromString("[");
+ s = PyUnicode_FromString("[");
if (s == NULL)
goto Done;
temp = PyList_GET_ITEM(pieces, 0);
- PyString_ConcatAndDel(&s, temp);
+ PyUnicode_AppendAndDel(&s, temp);
PyList_SET_ITEM(pieces, 0, s);
if (s == NULL)
goto Done;
- s = PyString_FromString("]");
+ s = PyUnicode_FromString("]");
if (s == NULL)
goto Done;
temp = PyList_GET_ITEM(pieces, PyList_GET_SIZE(pieces) - 1);
- PyString_ConcatAndDel(&temp, s);
+ PyUnicode_AppendAndDel(&temp, s);
PyList_SET_ITEM(pieces, PyList_GET_SIZE(pieces) - 1, temp);
if (temp == NULL)
goto Done;
/* Paste them all together with ", " between. */
- s = PyString_FromString(", ");
+ s = PyUnicode_FromString(", ");
if (s == NULL)
goto Done;
- result = _PyString_Join(s, pieces);
+ result = PyUnicode_Join(s, pieces);
Py_DECREF(s);
Done:
long_format(PyObject *aa, int base)
{
register PyLongObject *a = (PyLongObject *)aa;
- PyStringObject *str;
+ PyObject *str;
Py_ssize_t i, j, sz;
Py_ssize_t size_a;
- char *p;
+ Py_UNICODE *p;
int bits;
char sign = '\0';
"int is too large to format");
return NULL;
}
- str = (PyStringObject *) PyString_FromStringAndSize((char *)0, sz);
+ str = PyUnicode_FromUnicode(NULL, sz);
if (str == NULL)
return NULL;
- p = PyString_AS_STRING(str) + sz;
+ p = PyUnicode_AS_UNICODE(str) + sz;
*p = '\0';
if (a->ob_size < 0)
sign = '-';
do {
char cdigit = (char)(accum & (base - 1));
cdigit += (cdigit < 10) ? '0' : 'a'-10;
- assert(p > PyString_AS_STRING(str));
+ assert(p > PyUnicode_AS_UNICODE(str));
*--p = cdigit;
accumbits -= basebits;
accum >>= basebits;
do {
digit nextrem = (digit)(rem / base);
char c = (char)(rem - nextrem * base);
- assert(p > PyString_AS_STRING(str));
+ assert(p > PyUnicode_AS_UNICODE(str));
c += (c < 10) ? '0' : 'a'-10;
*--p = c;
rem = nextrem;
}
if (sign)
*--p = sign;
- if (p != PyString_AS_STRING(str)) {
- char *q = PyString_AS_STRING(str);
+ if (p != PyUnicode_AS_UNICODE(str)) {
+ Py_UNICODE *q = PyUnicode_AS_UNICODE(str);
assert(p > q);
do {
} while ((*q++ = *p++) != '\0');
q--;
- _PyString_Resize((PyObject **)&str,
- (Py_ssize_t) (q - PyString_AS_STRING(str)));
+ if (PyUnicode_Resize(&str, (Py_ssize_t) (q - PyUnicode_AS_UNICODE(str)))) {
+ Py_DECREF(str);
+ return NULL;
+ }
}
return (PyObject *)str;
}
strobj = PyString_FromStringAndSize(orig_str, slen);
if (strobj == NULL)
return NULL;
- strrepr = PyObject_Repr(strobj);
+ strrepr = PyObject_ReprStr8(strobj);
Py_DECREF(strobj);
if (strrepr == NULL)
return NULL;
/* create a repr() of the input string,
* just like PyLong_FromString does. */
PyObject *srepr;
- srepr = PyObject_Repr(x);
+ srepr = PyObject_ReprStr8(x);
if (srepr == NULL)
return NULL;
PyErr_Format(PyExc_ValueError,
meth_repr(PyCFunctionObject *m)
{
if (m->m_self == NULL)
- return PyString_FromFormat("<built-in function %s>",
+ return PyUnicode_FromFormat("<built-in function %s>",
m->m_ml->ml_name);
- return PyString_FromFormat("<built-in method %s of %s object at %p>",
+ return PyUnicode_FromFormat("<built-in method %s of %s object at %p>",
m->m_ml->ml_name,
m->m_self->ob_type->tp_name,
m->m_self);
filename = PyModule_GetFilename((PyObject *)m);
if (filename == NULL) {
PyErr_Clear();
- return PyString_FromFormat("<module '%s' (built-in)>", name);
+ return PyUnicode_FromFormat("<module '%s' (built-in)>", name);
}
- return PyString_FromFormat("<module '%s' from '%s'>", name, filename);
+ return PyUnicode_FromFormat("<module '%s' from '%s'>", name, filename);
}
/* We only need a traverse function, no clear function: If the module
if (flags & Py_PRINT_RAW)
s = PyObject_Str(op);
else
- s = PyObject_Repr(op);
+ s = PyObject_ReprStr8(op);
if (s == NULL)
ret = -1;
else {
PyObject *
PyObject_Repr(PyObject *v)
{
+ PyObject *ress, *resu;
if (PyErr_CheckSignals())
return NULL;
#ifdef USE_STACKCHECK
}
#endif
if (v == NULL)
- return PyString_FromString("<NULL>");
+ return PyUnicode_FromString("<NULL>");
else if (v->ob_type->tp_repr == NULL)
- return PyString_FromFormat("<%s object at %p>",
- v->ob_type->tp_name, v);
+ return PyUnicode_FromFormat("<%s object at %p>", v->ob_type->tp_name, v);
else {
- PyObject *res;
- res = (*v->ob_type->tp_repr)(v);
- if (res == NULL)
+ ress = (*v->ob_type->tp_repr)(v);
+ if (!ress)
return NULL;
- if (PyUnicode_Check(res))
- return res;
- if (!PyString_Check(res)) {
+ if (PyUnicode_Check(ress))
+ return ress;
+ if (!PyString_Check(ress)) {
PyErr_Format(PyExc_TypeError,
"__repr__ returned non-string (type %.200s)",
- res->ob_type->tp_name);
- Py_DECREF(res);
+ ress->ob_type->tp_name);
+ Py_DECREF(ress);
return NULL;
}
- return res;
+ resu = PyUnicode_FromObject(ress);
+ Py_DECREF(ress);
+ return resu;
}
}
+PyObject *
+PyObject_ReprStr8(PyObject *v)
+{
+ PyObject *resu = PyObject_Repr(v);
+ if (resu) {
+ PyObject *resb = PyUnicode_AsEncodedString(resu, NULL, NULL);
+ Py_DECREF(resu);
+ if (resb) {
+ PyObject *ress = PyString_FromStringAndSize(
+ PyBytes_AS_STRING(resb),
+ PyBytes_GET_SIZE(resb)
+ );
+ Py_DECREF(resb);
+ return ress;
+ }
+ }
+ return NULL;
+}
+
PyObject *
_PyObject_Str(PyObject *v)
{
static PyObject *
none_repr(PyObject *op)
{
- return PyString_FromString("None");
+ return PyUnicode_FromString("None");
}
/* ARGUSED */
static PyObject *
NotImplemented_repr(PyObject *op)
{
- return PyString_FromString("NotImplemented");
+ return PyUnicode_FromString("NotImplemented");
}
static PyTypeObject PyNotImplemented_Type = {
}
if (istart == 0 && istep == 1)
- result = PyString_FromFormat("range(%s)",
- PyString_AS_STRING(stop_str));
+ result = PyUnicode_FromFormat("range(%s)",
+ PyString_AS_STRING(stop_str));
else if (istep == 1) {
if (start_str)
- result = PyString_FromFormat("range(%s, %s)",
- PyString_AS_STRING(start_str),
- PyString_AS_STRING(stop_str));
+ result = PyUnicode_FromFormat("range(%s, %s)",
+ PyString_AS_STRING(start_str),
+ PyString_AS_STRING(stop_str));
}
else if (start_str && step_str)
- result = PyString_FromFormat("range(%s, %s, %s)",
- PyString_AS_STRING(start_str),
- PyString_AS_STRING(stop_str),
- PyString_AS_STRING(step_str));
+ result = PyUnicode_FromFormat("range(%s, %s, %s)",
+ PyString_AS_STRING(start_str),
+ PyString_AS_STRING(stop_str),
+ PyString_AS_STRING(step_str));
/* else result is NULL and an error should already be set. */
Py_XDECREF(start_str);
set_repr(PySetObject *so)
{
PyObject *keys, *result=NULL, *listrepr;
+ int newsize;
+ Py_UNICODE *u;
+ const char *s;
int status = Py_ReprEnter((PyObject*)so);
if (status != 0) {
if (status < 0)
return NULL;
- return PyString_FromFormat("%s(...)", so->ob_type->tp_name);
+ return PyUnicode_FromFormat("%s(...)", so->ob_type->tp_name);
}
/* shortcut for the empty set */
if (!so->used) {
Py_ReprLeave((PyObject*)so);
- return PyString_FromFormat("%s()", so->ob_type->tp_name);
+ return PyUnicode_FromFormat("%s()", so->ob_type->tp_name);
}
keys = PySequence_List((PyObject *)so);
if (listrepr == NULL)
goto done;
- if (so->ob_type == &PySet_Type) {
- char *s = PyString_AS_STRING(listrepr);
- s += 1;
- s[strlen(s)-1] = 0;
- result = PyString_FromFormat("{%s}", s);
- } else {
- result = PyString_FromFormat("%s(%s)", so->ob_type->tp_name,
- PyString_AS_STRING(listrepr));
+ newsize = PyUnicode_GET_SIZE(listrepr);
+ if (so->ob_type != &PySet_Type)
+ newsize += strlen(so->ob_type->tp_name)+2;
+ result = PyUnicode_FromUnicode(NULL, newsize);
+ if (result) {
+ u = PyUnicode_AS_UNICODE(result);
+ if (so->ob_type != &PySet_Type) {
+ for (s = so->ob_type->tp_name; *s;)
+ *u++ = *s++;
+ *u++ = '(';
+ Py_UNICODE_COPY(u, PyUnicode_AS_UNICODE(listrepr),
+ PyUnicode_GET_SIZE(listrepr));
+ u += PyUnicode_GET_SIZE(listrepr);
+ *u++ = ')';
+ } else {
+ *u++ = '{';
+ /* Omit the brackets from the listrepr */
+ Py_UNICODE_COPY(u, PyUnicode_AS_UNICODE(listrepr)+1,
+ PyUnicode_GET_SIZE(listrepr)-2);
+ u += PyUnicode_GET_SIZE(listrepr)-2;
+ *u++ = '}';
+ }
}
Py_DECREF(listrepr);
done:
static PyObject *
ellipsis_repr(PyObject *op)
{
- return PyString_FromString("Ellipsis");
+ return PyUnicode_FromString("Ellipsis");
}
static PyTypeObject PyEllipsis_Type = {
{
PyObject *s, *comma;
- s = PyString_FromString("slice(");
- comma = PyString_FromString(", ");
- PyString_ConcatAndDel(&s, PyObject_Repr(r->start));
- PyString_Concat(&s, comma);
- PyString_ConcatAndDel(&s, PyObject_Repr(r->stop));
- PyString_Concat(&s, comma);
- PyString_ConcatAndDel(&s, PyObject_Repr(r->step));
- PyString_ConcatAndDel(&s, PyString_FromString(")"));
+ s = PyUnicode_FromString("slice(");
+ comma = PyUnicode_FromString(", ");
+ PyUnicode_AppendAndDel(&s, PyObject_Repr(r->start));
+ PyUnicode_Append(&s, comma);
+ PyUnicode_AppendAndDel(&s, PyObject_Repr(r->stop));
+ PyUnicode_Append(&s, comma);
+ PyUnicode_AppendAndDel(&s, PyObject_Repr(r->step));
+ PyUnicode_AppendAndDel(&s, PyUnicode_FromString(")"));
Py_DECREF(comma);
return s;
}
PyObject *
PyString_Repr(PyObject *obj, int smartquotes)
{
+ static const char *hexdigits = "0123456789abcdef";
register PyStringObject* op = (PyStringObject*) obj;
+ Py_ssize_t length = PyUnicode_GET_SIZE(op);
size_t newsize = 2 + 4 * op->ob_size;
PyObject *v;
if (newsize > PY_SSIZE_T_MAX || newsize / 4 != op->ob_size) {
PyErr_SetString(PyExc_OverflowError,
"string is too large to make repr");
}
- v = PyString_FromStringAndSize((char *)NULL, newsize);
+ v = PyUnicode_FromUnicode(NULL, newsize);
if (v == NULL) {
return NULL;
}
else {
register Py_ssize_t i;
- register char c;
- register char *p;
+ register Py_UNICODE c;
+ register Py_UNICODE *p = PyUnicode_AS_UNICODE(v);
int quote;
/* figure out which quote to use; single is preferred */
quote = '\'';
- if (smartquotes &&
- memchr(op->ob_sval, '\'', op->ob_size) &&
- !memchr(op->ob_sval, '"', op->ob_size))
- quote = '"';
+ if (smartquotes) {
+ Py_UNICODE *test;
+ for (test = p; test < p+length; ++test) {
+ if (*test == '"') {
+ quote = '\''; /* switch back to single quote */
+ goto decided;
+ }
+ else if (*test == '\'')
+ quote = '"';
+ }
+ decided:
+ ;
+ }
- p = PyString_AS_STRING(v);
*p++ = quote;
for (i = 0; i < op->ob_size; i++) {
/* There's at least enough room for a hex escape
and a closing quote. */
- assert(newsize - (p - PyString_AS_STRING(v)) >= 5);
+ assert(newsize - (p - PyUnicode_AS_UNICODE(v)) >= 5);
c = op->ob_sval[i];
if (c == quote || c == '\\')
*p++ = '\\', *p++ = c;
else if (c == '\r')
*p++ = '\\', *p++ = 'r';
else if (c < ' ' || c >= 0x7f) {
- /* For performance, we don't want to call
- PyOS_snprintf here (extra layers of
- function call). */
- sprintf(p, "\\x%02x", c & 0xff);
- p += 4;
+ *p++ = '\\';
+ *p++ = 'x';
+ *p++ = hexdigits[(c & 0xf0) >> 4];
+ *p++ = hexdigits[c & 0xf];
}
else
*p++ = c;
}
- assert(newsize - (p - PyString_AS_STRING(v)) >= 1);
+ assert(newsize - (p - PyUnicode_AS_UNICODE(v)) >= 1);
*p++ = quote;
*p = '\0';
- _PyString_Resize(
- &v, (p - PyString_AS_STRING(v)));
+ if (PyUnicode_Resize(&v, (p - PyUnicode_AS_UNICODE(v)))) {
+ Py_DECREF(v);
+ return NULL;
+ }
return v;
}
}
/* Fall through */
case 'r':
if (c == 'r')
- temp = PyObject_Repr(v);
+ temp = PyObject_ReprStr8(v);
if (temp == NULL)
goto error;
if (!PyString_Check(temp)) {
n = v->ob_size;
if (n == 0)
- return PyString_FromString("()");
+ return PyUnicode_FromString("()");
pieces = PyTuple_New(n);
if (pieces == NULL)
/* Add "()" decorations to the first and last items. */
assert(n > 0);
- s = PyString_FromString("(");
+ s = PyUnicode_FromString("(");
if (s == NULL)
goto Done;
temp = PyTuple_GET_ITEM(pieces, 0);
- PyString_ConcatAndDel(&s, temp);
+ PyUnicode_AppendAndDel(&s, temp);
PyTuple_SET_ITEM(pieces, 0, s);
if (s == NULL)
goto Done;
- s = PyString_FromString(n == 1 ? ",)" : ")");
+ s = PyUnicode_FromString(n == 1 ? ",)" : ")");
if (s == NULL)
goto Done;
temp = PyTuple_GET_ITEM(pieces, n-1);
- PyString_ConcatAndDel(&temp, s);
+ PyUnicode_AppendAndDel(&temp, s);
PyTuple_SET_ITEM(pieces, n-1, temp);
if (temp == NULL)
goto Done;
/* Paste them all together with ", " between. */
- s = PyString_FromString(", ");
+ s = PyUnicode_FromString(", ");
if (s == NULL)
goto Done;
- result = _PyString_Join(s, pieces);
+ result = PyUnicode_Join(s, pieces);
Py_DECREF(s);
Done:
kind = "type";
if (mod != NULL && strcmp(PyString_AS_STRING(mod), "__builtin__")) {
- rtn = PyString_FromFormat("<%s '%s.%s'>",
+ rtn = PyUnicode_FromFormat("<%s '%s.%s'>",
kind,
PyString_AS_STRING(mod),
PyString_AS_STRING(name));
}
else
- rtn = PyString_FromFormat("<%s '%s'>", kind, type->tp_name);
+ rtn = PyUnicode_FromFormat("<%s '%s'>", kind, type->tp_name);
Py_XDECREF(mod);
Py_DECREF(name);
if (name == NULL) {
PyErr_Clear();
Py_XDECREF(name);
- name = PyObject_Repr(cls);
+ name = PyObject_ReprStr8(cls);
}
if (name == NULL)
return NULL;
if (name == NULL)
return NULL;
if (mod != NULL && strcmp(PyString_AS_STRING(mod), "__builtin__"))
- rtn = PyString_FromFormat("<%s.%s object at %p>",
+ rtn = PyUnicode_FromFormat("<%s.%s object at %p>",
PyString_AS_STRING(mod),
PyString_AS_STRING(name),
self);
else
- rtn = PyString_FromFormat("<%s object at %p>",
+ rtn = PyUnicode_FromFormat("<%s object at %p>",
type->tp_name, self);
Py_XDECREF(mod);
Py_DECREF(name);
return res;
}
PyErr_Clear();
- return PyString_FromFormat("<%s object at %p>",
+ return PyUnicode_FromFormat("<%s object at %p>",
self->ob_type->tp_name, self);
}
return res;
}
else {
+ PyObject *ress;
PyErr_Clear();
- return slot_tp_repr(self);
+ res = slot_tp_repr(self);
+ if (!res)
+ return NULL;
+ ress = _PyUnicode_AsDefaultEncodedString(res, NULL);
+ Py_DECREF(res);
+ return ress;
}
}
superobject *su = (superobject *)self;
if (su->obj_type)
- return PyString_FromFormat(
+ return PyUnicode_FromFormat(
"<super: <class '%s'>, <%s object>>",
su->type ? su->type->tp_name : "NULL",
su->obj_type->tp_name);
else
- return PyString_FromFormat(
+ return PyUnicode_FromFormat(
"<super: <class '%s'>, NULL>",
su->type ? su->type->tp_name : "NULL");
}
return NULL;
}
+void
+PyUnicode_Append(PyObject **pleft, PyObject *right)
+{
+ PyObject *new;
+ if (*pleft == NULL)
+ return;
+ if (right == NULL || !PyUnicode_Check(*pleft)) {
+ Py_DECREF(*pleft);
+ *pleft = NULL;
+ return;
+ }
+ new = PyUnicode_Concat(*pleft, right);
+ Py_DECREF(*pleft);
+ *pleft = new;
+}
+
+void
+PyUnicode_AppendAndDel(PyObject **pleft, PyObject *right)
+{
+ PyUnicode_Append(pleft, right);
+ Py_XDECREF(right);
+}
+
PyDoc_STRVAR(count__doc__,
"S.count(sub[, start[, end]]) -> int\n\
\n\
PyObject *unicode_repr(PyObject *unicode)
{
PyObject *repr;
- char *p;
+ Py_UNICODE *p;
Py_UNICODE *s = PyUnicode_AS_UNICODE(unicode);
Py_ssize_t size = PyUnicode_GET_SIZE(unicode);
escape.
*/
- repr = PyString_FromStringAndSize(NULL,
+ repr = PyUnicode_FromUnicode(NULL,
2 /* quotes */
#ifdef Py_UNICODE_WIDE
+ 10*size
if (repr == NULL)
return NULL;
- p = PyString_AS_STRING(repr);
+ p = PyUnicode_AS_UNICODE(repr);
/* Add quote */
*p++ = (findchar(s, size, '\'') &&
Py_UNICODE ch = *s++;
/* Escape quotes and backslashes */
- if ((ch == (Py_UNICODE) PyString_AS_STRING(repr)[0]) || (ch == '\\')) {
+ if ((ch == PyUnicode_AS_UNICODE(repr)[0]) || (ch == '\\')) {
*p++ = '\\';
- *p++ = (char) ch;
+ *p++ = ch;
continue;
}
*p++ = (char) ch;
}
/* Add quote */
- *p++ = PyString_AS_STRING(repr)[0];
+ *p++ = PyUnicode_AS_UNICODE(repr)[0];
*p = '\0';
- _PyString_Resize(&repr, p - PyString_AS_STRING(repr));
+ _PyUnicode_Resize(&repr, p - PyUnicode_AS_UNICODE(repr));
return repr;
}
name);
Py_XDECREF(nameobj);
}
- return PyString_FromString(buffer);
+ return PyUnicode_FromString(buffer);
}
/* Weak references only support equality, not ordering. Two weak references
"<weakproxy at %p to %.100s at %p>", proxy,
PyWeakref_GET_OBJECT(proxy)->ob_type->tp_name,
PyWeakref_GET_OBJECT(proxy));
- return PyString_FromString(buf);
+ return PyUnicode_FromString(buf);
}
{
if (exception != NULL &&
!PyExceptionClass_Check(exception)) {
- PyObject *excstr = PyObject_Repr(exception);
+ PyObject *excstr = PyObject_ReprStr8(exception);
PyErr_Format(PyExc_SystemError,
"exception %s not a BaseException subclass",
PyString_AS_STRING(excstr));
"<symtable entry %.100s(%ld), line %d>",
PyString_AS_STRING(ste->ste_name),
PyInt_AS_LONG(ste->ste_id), ste->ste_lineno);
- return PyString_FromString(buf);
+ return PyUnicode_FromString(buf);
}
static void
projects / python / commitdiff