static PyObject *
partial_repr(partialobject *pto)
{
PyObject *result = NULL;
PyObject *arglist;
Py_ssize_t i, n;
PyObject *key, *value;
int status;
status = Py_ReprEnter((PyObject *)pto);
if (status != 0) {
if (status < 0)
return NULL;
return PyUnicode_FromString("...");
}
arglist = PyUnicode_FromString("");
if (arglist == NULL)
goto done;
/* Pack positional arguments */
assert (PyTuple_Check(pto->args));
n = PyTuple_GET_SIZE(pto->args);
for (i = 0; i < n; i++) {
Py_SETREF(arglist, PyUnicode_FromFormat("%U, %R", arglist,
PyTuple_GET_ITEM(pto->args, i)));
if (arglist == NULL)
goto done;
}
/* Pack keyword arguments */
assert (PyDict_Check(pto->kw));
for (i = 0; PyDict_Next(pto->kw, &i, &key, &value);) {
Py_SETREF(arglist, PyUnicode_FromFormat("%U, %U=%R", arglist,
key, value));
if (arglist == NULL)
goto done;
}
result = PyUnicode_FromFormat("%s(%R%U)", Py_TYPE(pto)->tp_name,
pto->fn, arglist);
Py_DECREF(arglist);
done:
Py_ReprLeave((PyObject *)pto);
return result;
}
Box* tupleRepr(BoxedTuple* t) {
assert(isSubclass(t->cls, tuple_cls));
int n;
std::string O("");
llvm::raw_string_ostream os(O);
n = t->size();
if (n == 0) {
os << "()";
return boxString(os.str());
}
int status = Py_ReprEnter((PyObject*)t);
if (status != 0) {
if (status < 0)
return boxString(os.str());
os << "(...)";
return boxString(os.str());
}
os << "(";
for (int i = 0; i < n; i++) {
if (i)
os << ", ";
BoxedString* elt_repr = static_cast<BoxedString*>(repr(t->elts[i]));
os << elt_repr->s();
}
if (n == 1)
os << ",";
os << ")";
Py_ReprLeave((PyObject*)t);
return boxString(os.str());
}
static PyObject *
namespace_repr(PyObject *ns)
{
int i, loop_error = 0;
PyObject *pairs = NULL, *d = NULL, *keys = NULL, *keys_iter = NULL;
PyObject *key;
PyObject *separator, *pairsrepr, *repr = NULL;
const char * name;
name = (Py_TYPE(ns) == &_PyNamespace_Type) ? "namespace"
: ns->ob_type->tp_name;
i = Py_ReprEnter(ns);
if (i != 0) {
return i > 0 ? PyUnicode_FromFormat("%s(...)", name) : NULL;
}
pairs = PyList_New(0);
if (pairs == NULL)
goto error;
d = ((_PyNamespaceObject *)ns)->ns_dict;
assert(d != NULL);
Py_INCREF(d);
keys = PyDict_Keys(d);
if (keys == NULL)
goto error;
if (PyList_Sort(keys) != 0)
goto error;
keys_iter = PyObject_GetIter(keys);
if (keys_iter == NULL)
goto error;
while ((key = PyIter_Next(keys_iter)) != NULL) {
if (PyUnicode_Check(key) && PyUnicode_GET_LENGTH(key) > 0) {
PyObject *value, *item;
value = PyDict_GetItem(d, key);
assert(value != NULL);
item = PyUnicode_FromFormat("%S=%R", key, value);
if (item == NULL) {
loop_error = 1;
}
else {
loop_error = PyList_Append(pairs, item);
Py_DECREF(item);
}
}
Py_DECREF(key);
if (loop_error)
goto error;
}
separator = PyUnicode_FromString(", ");
if (separator == NULL)
goto error;
pairsrepr = PyUnicode_Join(separator, pairs);
Py_DECREF(separator);
if (pairsrepr == NULL)
goto error;
repr = PyUnicode_FromFormat("%s(%S)", name, pairsrepr);
Py_DECREF(pairsrepr);
error:
Py_XDECREF(pairs);
Py_XDECREF(d);
Py_XDECREF(keys);
Py_XDECREF(keys_iter);
Py_ReprLeave(ns);
return repr;
}
static PyObject *
Struct_repr(PyObject *self)
{
Py_ssize_t i;
PyObject *inner_repr = NULL;
PyObject *equals = NULL;
PyObject *pieces = NULL, *result = NULL;
PyObject *items = NULL, *s;
PyTypeObject *type = Py_TYPE(self);
i = Py_ReprEnter(self);
if (i < 0) {
return NULL;
}
if (i > 0) {
inner_repr = str_from_string("...");
if (inner_repr == NULL)
goto done;
result = format_with_type(type, inner_repr);
}
else if (((PyDictObject *)self)->ma_used == 0) {
result = format_with_type(type, NULL);
}
else {
/* basically `dict_repr` but with keyword notation */
pieces = PyList_New(0);
if (pieces == NULL)
goto done;
equals = str_from_string("=");
if (equals == NULL)
goto done;
items = PyDict_Items(self);
if (items == NULL)
goto done;
if (PyList_Sort(items) < 0)
goto done;
for (i = 0; i < PyList_GET_SIZE(items); i++) {
PyObject *temp, *key, *value;
int status;
temp = PyList_GET_ITEM(items, i);
key = PyTuple_GetItem(temp, 0);
if (key == NULL)
goto done;
value = PyTuple_GetItem(temp, 1);
if (value == NULL)
goto done;
/* Prevent repr from deleting value during key format. */
Py_INCREF(value);
s = PyObject_Str(key);
str_concat(&s, equals);
str_concat_and_del(&s, PyObject_Repr(value));
Py_DECREF(value);
if (s == NULL)
goto done;
status = PyList_Append(pieces, s);
Py_DECREF(s); /* append created a new ref */
if (status < 0)
goto done;
}
/* Paste them all together with ", " between. */
s = str_from_string(", ");
if (s == NULL)
goto done;
inner_repr = str_join(s, pieces);
Py_DECREF(s);
if (inner_repr == NULL)
goto done;
result = format_with_type(type, inner_repr);
}
done:
Py_XDECREF(inner_repr);
Py_XDECREF(items);
Py_XDECREF(pieces);
Py_XDECREF(equals);
Py_ReprLeave(self);
return result;
}
static PyObject *
tuplerepr(PyTupleObject *v)
{
Py_ssize_t i, n;
PyObject *s = NULL;
_PyAccu acc;
static PyObject *sep = NULL;
n = Py_SIZE(v);
if (n == 0)
return PyUnicode_FromString("()");
if (sep == NULL) {
sep = PyUnicode_FromString(", ");
if (sep == NULL)
return NULL;
}
/* While not mutable, it is still possible to end up with a cycle in a
tuple through an object that stores itself within a tuple (and thus
infinitely asks for the repr of itself). This should only be
possible within a type. */
i = Py_ReprEnter((PyObject *)v);
if (i != 0) {
return i > 0 ? PyUnicode_FromString("(...)") : NULL;
}
if (_PyAccu_Init(&acc))
goto error;
s = PyUnicode_FromString("(");
if (s == NULL || _PyAccu_Accumulate(&acc, s))
goto error;
Py_CLEAR(s);
/* Do repr() on each element. */
for (i = 0; i < n; ++i) {
if (Py_EnterRecursiveCall(" while getting the repr of a tuple"))
goto error;
s = PyObject_Repr(v->ob_item[i]);
Py_LeaveRecursiveCall();
if (i > 0 && _PyAccu_Accumulate(&acc, sep))
goto error;
if (s == NULL || _PyAccu_Accumulate(&acc, s))
goto error;
Py_CLEAR(s);
}
if (n > 1)
s = PyUnicode_FromString(")");
else
s = PyUnicode_FromString(",)");
if (s == NULL || _PyAccu_Accumulate(&acc, s))
goto error;
Py_CLEAR(s);
Py_ReprLeave((PyObject *)v);
return _PyAccu_Finish(&acc);
error:
_PyAccu_Destroy(&acc);
Py_XDECREF(s);
Py_ReprLeave((PyObject *)v);
return NULL;
}
static PyObject *
record_repr(ApgRecordObject *v)
{
Py_ssize_t i, n;
PyObject *keys_iter;
_PyUnicodeWriter writer;
n = Py_SIZE(v);
assert(n > 0);
keys_iter = PyObject_GetIter(v->mapping);
if (keys_iter == NULL) {
return NULL;
}
i = Py_ReprEnter((PyObject *)v);
if (i != 0) {
Py_DECREF(keys_iter);
return i > 0 ? PyUnicode_FromString("<Record ...>") : NULL;
}
_PyUnicodeWriter_Init(&writer);
writer.overallocate = 1;
writer.min_length = 12; /* <Record a=1> */
if (_PyUnicodeWriter_WriteASCIIString(&writer, "<Record ", 8) < 0) {
goto error;
}
for (i = 0; i < n; ++i) {
PyObject *key;
PyObject *key_repr;
PyObject *val_repr;
if (i > 0) {
if (_PyUnicodeWriter_WriteChar(&writer, ' ') < 0) {
goto error;
}
}
if (Py_EnterRecursiveCall(" while getting the repr of a record")) {
goto error;
}
val_repr = PyObject_Repr(v->ob_item[i]);
Py_LeaveRecursiveCall();
if (val_repr == NULL) {
goto error;
}
key = PyIter_Next(keys_iter);
if (key == NULL) {
Py_DECREF(val_repr);
PyErr_SetString(PyExc_RuntimeError, "invalid record mapping");
goto error;
}
key_repr = PyObject_Str(key);
Py_DECREF(key);
if (key_repr == NULL) {
Py_DECREF(val_repr);
goto error;
}
if (_PyUnicodeWriter_WriteStr(&writer, key_repr) < 0) {
Py_DECREF(key_repr);
Py_DECREF(val_repr);
goto error;
}
Py_DECREF(key_repr);
if (_PyUnicodeWriter_WriteChar(&writer, '=') < 0) {
Py_DECREF(val_repr);
goto error;
}
if (_PyUnicodeWriter_WriteStr(&writer, val_repr) < 0) {
Py_DECREF(val_repr);
goto error;
}
Py_DECREF(val_repr);
}
writer.overallocate = 0;
if (_PyUnicodeWriter_WriteChar(&writer, '>') < 0) {
goto error;
}
Py_DECREF(keys_iter);
Py_ReprLeave((PyObject *)v);
return _PyUnicodeWriter_Finish(&writer);
error:
Py_DECREF(keys_iter);
_PyUnicodeWriter_Dealloc(&writer);
Py_ReprLeave((PyObject *)v);
return NULL;
}
static PyObject *
tuplerepr(PyTupleObject *v)
{
Py_ssize_t i, n;
_PyUnicodeWriter writer;
n = Py_SIZE(v);
if (n == 0)
return PyUnicode_FromString("()");
/* While not mutable, it is still possible to end up with a cycle in a
tuple through an object that stores itself within a tuple (and thus
infinitely asks for the repr of itself). This should only be
possible within a type. */
i = Py_ReprEnter((PyObject *)v);
if (i != 0) {
return i > 0 ? PyUnicode_FromString("(...)") : NULL;
}
_PyUnicodeWriter_Init(&writer);
writer.overallocate = 1;
if (Py_SIZE(v) > 1) {
/* "(" + "1" + ", 2" * (len - 1) + ")" */
writer.min_length = 1 + 1 + (2 + 1) * (Py_SIZE(v) - 1) + 1;
}
else {
/* "(1,)" */
writer.min_length = 4;
}
if (_PyUnicodeWriter_WriteChar(&writer, '(') < 0)
goto error;
/* Do repr() on each element. */
for (i = 0; i < n; ++i) {
PyObject *s;
if (i > 0) {
if (_PyUnicodeWriter_WriteASCIIString(&writer, ", ", 2) < 0)
goto error;
}
if (Py_EnterRecursiveCall(" while getting the repr of a tuple"))
goto error;
s = PyObject_Repr(v->ob_item[i]);
Py_LeaveRecursiveCall();
if (s == NULL)
goto error;
if (_PyUnicodeWriter_WriteStr(&writer, s) < 0) {
Py_DECREF(s);
goto error;
}
Py_DECREF(s);
}
writer.overallocate = 0;
if (n > 1) {
if (_PyUnicodeWriter_WriteChar(&writer, ')') < 0)
goto error;
}
else {
if (_PyUnicodeWriter_WriteASCIIString(&writer, ",)", 2) < 0)
goto error;
}
Py_ReprLeave((PyObject *)v);
return _PyUnicodeWriter_Finish(&writer);
error:
_PyUnicodeWriter_Dealloc(&writer);
Py_ReprLeave((PyObject *)v);
return NULL;
}
static PyObject *
tuplerepr(PyTupleObject *v)
{
Py_ssize_t i, n;
PyObject *s, *temp;
PyObject *pieces, *result = NULL;
n = v->ob_size;
if (n == 0)
return PyString_FromString("()");
/* While not mutable, it is still possible to end up with a cycle in a
tuple through an object that stores itself within a tuple (and thus
infinitely asks for the repr of itself). This should only be
possible within a type. */
i = Py_ReprEnter((PyObject *)v);
if (i != 0) {
return i > 0 ? PyString_FromString("(...)") : NULL;
}
pieces = PyTuple_New(n);
if (pieces == NULL)
return NULL;
/* Do repr() on each element. */
for (i = 0; i < n; ++i) {
if (Py_EnterRecursiveCall(" while getting the repr of a tuple"))
goto Done;
s = PyObject_Repr(v->ob_item[i]);
Py_LeaveRecursiveCall();
if (s == NULL)
goto Done;
PyTuple_SET_ITEM(pieces, i, s);
}
/* Add "()" decorations to the first and last items. */
assert(n > 0);
s = PyString_FromString("(");
if (s == NULL)
goto Done;
temp = PyTuple_GET_ITEM(pieces, 0);
PyString_ConcatAndDel(&s, temp);
PyTuple_SET_ITEM(pieces, 0, s);
if (s == NULL)
goto Done;
s = PyString_FromString(n == 1 ? ",)" : ")");
if (s == NULL)
goto Done;
temp = PyTuple_GET_ITEM(pieces, n-1);
PyString_ConcatAndDel(&temp, s);
PyTuple_SET_ITEM(pieces, n-1, temp);
if (temp == NULL)
goto Done;
/* Paste them all together with ", " between. */
s = PyString_FromString(", ");
if (s == NULL)
goto Done;
result = _PyString_Join(s, pieces);
Py_DECREF(s);
Done:
Py_DECREF(pieces);
Py_ReprLeave((PyObject *)v);
return result;
}
