static PyObject * python_sorted_btree_repr(PyObject *self) { btsort_pyobject *tree = (btsort_pyobject *)self; PyObject *result; int rc; offsetstring *string; if ((rc = Py_ReprEnter(self))) { if (rc < 0) return NULL; return PyString_FromString("<...>"); } offsetstring_new(string, &rc); if (rc) { PyErr_SetString(PyExc_MemoryError, "failed malloc"); return NULL; } if (traverse_nodes(tree, 1, repr_visit, (void *)string)) result = NULL; else result = PyString_FromStringAndSize( offsetstring_data(string), offsetstring_offset(string) - 1); Py_ReprLeave(self); offsetstring_del(string); return result; }
static Box* setRepr(BoxedSet* self) { RELEASE_ASSERT(PyAnySet_Check(self), ""); std::vector<char> chars; int status = Py_ReprEnter((PyObject*)self); if (status != 0) { if (status < 0) throwCAPIException(); std::string ty = std::string(self->cls->tp_name); chars.insert(chars.end(), ty.begin(), ty.end()); chars.push_back('('); chars.push_back('.'); chars.push_back('.'); chars.push_back('.'); chars.push_back(')'); return boxString(llvm::StringRef(&chars[0], chars.size())); } try { std::string ty = std::string(self->cls->tp_name); chars.insert(chars.end(), ty.begin(), ty.end()); chars.push_back('('); chars.push_back('['); bool first = true; for (auto&& elt : self->s) { if (!first) { chars.push_back(','); chars.push_back(' '); } BoxedString* str = static_cast<BoxedString*>(repr(elt.value)); AUTO_DECREF(str); chars.insert(chars.end(), str->s().begin(), str->s().end()); first = false; } chars.push_back(']'); chars.push_back(')'); } catch (ExcInfo e) { Py_ReprLeave((PyObject*)self); throw e; } Py_ReprLeave((PyObject*)self); return boxString(llvm::StringRef(&chars[0], chars.size())); }
Box* tupleRepr(BoxedTuple* t) { assert(isSubclass(t->cls, tuple_cls)); int n; std::vector<char> chars; int status = Py_ReprEnter((PyObject*)t); n = t->size(); if (n == 0) { chars.push_back('('); chars.push_back(')'); return boxString(llvm::StringRef(&chars[0], chars.size())); } if (status != 0) { if (status < 0) throwCAPIException(); chars.push_back('('); chars.push_back('.'); chars.push_back('.'); chars.push_back('.'); chars.push_back(')'); return boxString(llvm::StringRef(&chars[0], chars.size())); } try { chars.push_back('('); for (int i = 0; i < n; i++) { if (i) { chars.push_back(','); chars.push_back(' '); } BoxedString* elt_repr = static_cast<BoxedString*>(repr(t->elts[i])); chars.insert(chars.end(), elt_repr->s().begin(), elt_repr->s().end()); } if (n == 1) chars.push_back(','); chars.push_back(')'); } catch (ExcInfo e) { Py_ReprLeave((PyObject*)t); throw e; } Py_ReprLeave((PyObject*)t); return boxString(llvm::StringRef(&chars[0], chars.size())); }
Py_LOCAL(PyObject *) avl_tree_repr(avl_tree_Object * self) { PyObject *result = NULL; avl_size_t len; int rc; len = avl_size(self->tree); rc = Py_ReprEnter((PyObject *) self); if (rc != 0) return rc > 0 ? PyString_FromString("[...]") : NULL; if (len == 0) { result = PyString_FromString("[]"); goto finish; } { avl_iterator iter; PyObject *list, *ob; Py_ssize_t i = 0; iter = avl_iterator_new(self->tree, AVL_ITERATOR_INI_PRE); if (iter == NULL) goto finish; list = PyList_New(len); if (list == NULL) goto finish; do { ob = objectAt(avl_iterator_next(iter)); Py_INCREF(ob); PyList_SET_ITEM(list, i, ob); ++i; } while (--len); avl_iterator_kill(iter); result = PyObject_Repr(list); list->ob_type->tp_dealloc(list); } finish: Py_ReprLeave((PyObject *) self); return result; }
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);) { /* Prevent key.__str__ from deleting the value. */ Py_INCREF(value); Py_SETREF(arglist, PyUnicode_FromFormat("%U, %S=%R", arglist, key, value)); Py_DECREF(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; }