PyMemAllocatorDomain domain,
PyMemAllocatorEx *old_alloc);
+/* Special bytes broadcast into debug memory blocks at appropriate times.
+ Strings of these are unlikely to be valid addresses, floats, ints or
+ 7-bit ASCII.
+
+ - PYMEM_CLEANBYTE: clean (newly allocated) memory
+ - PYMEM_DEADBYTE dead (newly freed) memory
+ - PYMEM_FORBIDDENBYTE: untouchable bytes at each end of a block
+
+ Byte patterns 0xCB, 0xDB and 0xFB have been replaced with 0xCD, 0xDD and
+ 0xFD to use the same values than Windows CRT debug malloc() and free().
+ If modified, _PyMem_IsPtrFreed() should be updated as well. */
+#define PYMEM_CLEANBYTE 0xCD
+#define PYMEM_DEADBYTE 0xDD
+#define PYMEM_FORBIDDENBYTE 0xFD
+
/* Heuristic checking if a pointer value is newly allocated
- (uninitialized) or newly freed. The pointer is not dereferenced, only the
- pointer value is checked.
+ (uninitialized), newly freed or NULL (is equal to zero).
+
+ The pointer is not dereferenced, only the pointer value is checked.
The heuristic relies on the debug hooks on Python memory allocators which
fills newly allocated memory with CLEANBYTE (0xCD) and newly freed memory
{
uintptr_t value = (uintptr_t)ptr;
#if SIZEOF_VOID_P == 8
- return (value == (uintptr_t)0xCDCDCDCDCDCDCDCD
+ return (value == 0
+ || value == (uintptr_t)0xCDCDCDCDCDCDCDCD
|| value == (uintptr_t)0xDDDDDDDDDDDDDDDD
|| value == (uintptr_t)0xFDFDFDFDFDFDFDFD);
#elif SIZEOF_VOID_P == 4
- return (value == (uintptr_t)0xCDCDCDCD
+ return (value == 0
+ || value == (uintptr_t)0xCDCDCDCD
|| value == (uintptr_t)0xDDDDDDDD
|| value == (uintptr_t)0xFDFDFDFD);
#else
''')
assert_python_ok('-c', code, PYTHONMALLOC=self.PYTHONMALLOC)
+ def test_pyobject_null_is_freed(self):
+ self.check_pyobject_is_freed('check_pyobject_null_is_freed')
+
def test_pyobject_uninitialized_is_freed(self):
self.check_pyobject_is_freed('check_pyobject_uninitialized_is_freed')
br'gcmodule\.c:[0-9]+: gc_decref: Assertion "gc_get_refs\(g\) > 0" failed.')
self.assertRegex(stderr,
br'refcount is too small')
+ # "address : 0x7fb5062efc18"
+ # "address : 7FB5062EFC18"
+ address_regex = br'[0-9a-fA-Fx]+'
self.assertRegex(stderr,
- br'object : \[1, 2, 3\]')
+ br'object address : ' + address_regex)
self.assertRegex(stderr,
- br'type : list')
+ br'object refcount : 1')
self.assertRegex(stderr,
- br'refcount: 1')
- # "address : 0x7fb5062efc18"
- # "address : 7FB5062EFC18"
+ br'object type : ' + address_regex)
+ self.assertRegex(stderr,
+ br'object type name: list')
self.assertRegex(stderr,
- br'address : [0-9a-fA-Fx]+')
+ br'object repr : \[1, 2, 3\]')
class GCTogglingTests(unittest.TestCase):
--- /dev/null
+The ``_PyObject_CheckConsistency()`` function is now also available in release
+mode. For example, it can be used to debug a crash in the ``visit_decref()``
+function of the GC.
}
+static PyObject*
+check_pyobject_null_is_freed(PyObject *self, PyObject *Py_UNUSED(args))
+{
+ PyObject *op = NULL;
+ return test_pyobject_is_freed("check_pyobject_null_is_freed", op);
+}
+
+
static PyObject*
check_pyobject_uninitialized_is_freed(PyObject *self, PyObject *Py_UNUSED(args))
{
{"pymem_api_misuse", pymem_api_misuse, METH_NOARGS},
{"pymem_malloc_without_gil", pymem_malloc_without_gil, METH_NOARGS},
{"pymem_getallocatorsname", test_pymem_getallocatorsname, METH_NOARGS},
+ {"check_pyobject_null_is_freed", check_pyobject_null_is_freed, METH_NOARGS},
{"check_pyobject_uninitialized_is_freed", check_pyobject_uninitialized_is_freed, METH_NOARGS},
{"check_pyobject_forbidden_bytes_is_freed", check_pyobject_forbidden_bytes_is_freed, METH_NOARGS},
{"check_pyobject_freed_is_freed", check_pyobject_freed_is_freed, METH_NOARGS},
/* A traversal callback for subtract_refs. */
static int
-visit_decref(PyObject *op, void *data)
+visit_decref(PyObject *op, void *parent)
{
- assert(op != NULL);
- _PyObject_ASSERT(op, !_PyObject_IsFreed(op));
+ _PyObject_ASSERT(_PyObject_CAST(parent), !_PyObject_IsFreed(op));
if (PyObject_IS_GC(op)) {
PyGC_Head *gc = AS_GC(op);
traverseproc traverse;
PyGC_Head *gc = GC_NEXT(containers);
for (; gc != containers; gc = GC_NEXT(gc)) {
- traverse = Py_TYPE(FROM_GC(gc))->tp_traverse;
+ PyObject *op = FROM_GC(gc);
+ traverse = Py_TYPE(op)->tp_traverse;
(void) traverse(FROM_GC(gc),
(visitproc)visit_decref,
- NULL);
+ op);
}
}
Py_ssize_t len = 0;
char onechar; /* For byte_converter() */
Py_ssize_t alloc;
-#ifdef Py_DEBUG
- char *before;
-#endif
fmt++;
if (*fmt == '%') {
if (res == NULL)
goto error;
}
-#ifdef Py_DEBUG
- before = res;
+#ifndef NDEBUG
+ char *before = res;
#endif
/* Write the sign if needed */
}
Py_XDECREF(temp);
-#ifdef Py_DEBUG
+#ifndef NDEBUG
/* check that we computed the exact size for this write */
assert((res - before) == alloc);
#endif
{
/* Set all attributes before small_buffer to 0 */
memset(writer, 0, offsetof(_PyBytesWriter, small_buffer));
-#ifdef Py_DEBUG
- memset(writer->small_buffer, 0xCB, sizeof(writer->small_buffer));
+#ifndef NDEBUG
+ memset(writer->small_buffer, PYMEM_CLEANBYTE,
+ sizeof(writer->small_buffer));
#endif
}
return str - start;
}
-Py_LOCAL_INLINE(void)
+#ifndef NDEBUG
+Py_LOCAL_INLINE(int)
_PyBytesWriter_CheckConsistency(_PyBytesWriter *writer, char *str)
{
-#ifdef Py_DEBUG
char *start, *end;
if (writer->use_small_buffer) {
end = start + writer->allocated;
assert(str != NULL);
assert(start <= str && str <= end);
-#endif
+ return 1;
}
+#endif
void*
_PyBytesWriter_Resize(_PyBytesWriter *writer, void *str, Py_ssize_t size)
{
Py_ssize_t allocated, pos;
- _PyBytesWriter_CheckConsistency(writer, str);
+ assert(_PyBytesWriter_CheckConsistency(writer, str));
assert(writer->allocated < size);
allocated = size;
}
writer->use_small_buffer = 0;
-#ifdef Py_DEBUG
- memset(writer->small_buffer, 0xDB, sizeof(writer->small_buffer));
+#ifndef NDEBUG
+ memset(writer->small_buffer, PYMEM_CLEANBYTE,
+ sizeof(writer->small_buffer));
#endif
}
writer->allocated = allocated;
str = _PyBytesWriter_AsString(writer) + pos;
- _PyBytesWriter_CheckConsistency(writer, str);
+ assert(_PyBytesWriter_CheckConsistency(writer, str));
return str;
error:
{
Py_ssize_t new_min_size;
- _PyBytesWriter_CheckConsistency(writer, str);
+ assert(_PyBytesWriter_CheckConsistency(writer, str));
assert(size >= 0);
if (size == 0) {
assert(size >= 0);
writer->use_small_buffer = 1;
-#ifdef Py_DEBUG
+#ifndef NDEBUG
writer->allocated = sizeof(writer->small_buffer) - 1;
/* In debug mode, don't use the full small buffer because it is less
efficient than bytes and bytearray objects to detect buffer underflow
Py_ssize_t size;
PyObject *result;
- _PyBytesWriter_CheckConsistency(writer, str);
+ assert(_PyBytesWriter_CheckConsistency(writer, str));
size = _PyBytesWriter_GetSize(writer, str);
if (size == 0 && !writer->use_bytearray) {
int
_PyDict_CheckConsistency(PyObject *op, int check_content)
{
-#ifndef NDEBUG
- _PyObject_ASSERT(op, PyDict_Check(op));
+#define CHECK(expr) \
+ do { if (!(expr)) { _PyObject_ASSERT_FAILED_MSG(op, Py_STRINGIFY(expr)); } } while (0)
+
+ assert(op != NULL);
+ CHECK(PyDict_Check(op));
PyDictObject *mp = (PyDictObject *)op;
PyDictKeysObject *keys = mp->ma_keys;
int splitted = _PyDict_HasSplitTable(mp);
Py_ssize_t usable = USABLE_FRACTION(keys->dk_size);
- _PyObject_ASSERT(op, 0 <= mp->ma_used && mp->ma_used <= usable);
- _PyObject_ASSERT(op, IS_POWER_OF_2(keys->dk_size));
- _PyObject_ASSERT(op, 0 <= keys->dk_usable && keys->dk_usable <= usable);
- _PyObject_ASSERT(op, 0 <= keys->dk_nentries && keys->dk_nentries <= usable);
- _PyObject_ASSERT(op, keys->dk_usable + keys->dk_nentries <= usable);
+ CHECK(0 <= mp->ma_used && mp->ma_used <= usable);
+ CHECK(IS_POWER_OF_2(keys->dk_size));
+ CHECK(0 <= keys->dk_usable && keys->dk_usable <= usable);
+ CHECK(0 <= keys->dk_nentries && keys->dk_nentries <= usable);
+ CHECK(keys->dk_usable + keys->dk_nentries <= usable);
if (!splitted) {
/* combined table */
- _PyObject_ASSERT(op, keys->dk_refcnt == 1);
+ CHECK(keys->dk_refcnt == 1);
}
if (check_content) {
for (i=0; i < keys->dk_size; i++) {
Py_ssize_t ix = dictkeys_get_index(keys, i);
- _PyObject_ASSERT(op, DKIX_DUMMY <= ix && ix <= usable);
+ CHECK(DKIX_DUMMY <= ix && ix <= usable);
}
for (i=0; i < usable; i++) {
if (key != NULL) {
if (PyUnicode_CheckExact(key)) {
Py_hash_t hash = ((PyASCIIObject *)key)->hash;
- _PyObject_ASSERT(op, hash != -1);
- _PyObject_ASSERT(op, entry->me_hash == hash);
+ CHECK(hash != -1);
+ CHECK(entry->me_hash == hash);
}
else {
/* test_dict fails if PyObject_Hash() is called again */
- _PyObject_ASSERT(op, entry->me_hash != -1);
+ CHECK(entry->me_hash != -1);
}
if (!splitted) {
- _PyObject_ASSERT(op, entry->me_value != NULL);
+ CHECK(entry->me_value != NULL);
}
}
if (splitted) {
- _PyObject_ASSERT(op, entry->me_value == NULL);
+ CHECK(entry->me_value == NULL);
}
}
if (splitted) {
/* splitted table */
for (i=0; i < mp->ma_used; i++) {
- _PyObject_ASSERT(op, mp->ma_values[i] != NULL);
+ CHECK(mp->ma_values[i] != NULL);
}
}
}
-#endif
return 1;
+
+#undef CHECK
}
int
_PyObject_CheckConsistency(PyObject *op, int check_content)
{
- _PyObject_ASSERT(op, op != NULL);
- _PyObject_ASSERT(op, !_PyObject_IsFreed(op));
- _PyObject_ASSERT(op, Py_REFCNT(op) >= 1);
+#define CHECK(expr) \
+ do { if (!(expr)) { _PyObject_ASSERT_FAILED_MSG(op, Py_STRINGIFY(expr)); } } while (0)
- PyTypeObject *type = op->ob_type;
- _PyObject_ASSERT(op, type != NULL);
- _PyType_CheckConsistency(type);
+ CHECK(!_PyObject_IsFreed(op));
+ CHECK(Py_REFCNT(op) >= 1);
+
+ CHECK(op->ob_type != NULL);
+ _PyType_CheckConsistency(op->ob_type);
if (PyUnicode_Check(op)) {
_PyUnicode_CheckConsistency(op, check_content);
_PyDict_CheckConsistency(op, check_content);
}
return 1;
+
+#undef CHECK
}
void
_PyObject_Dump(PyObject* op)
{
- if (op == NULL) {
- fprintf(stderr, "<object at NULL>\n");
- fflush(stderr);
- return;
- }
-
if (_PyObject_IsFreed(op)) {
/* It seems like the object memory has been freed:
don't access it to prevent a segmentation fault. */
fprintf(stderr, "<object at %p is freed>\n", op);
+ fflush(stderr);
return;
}
- PyGILState_STATE gil;
- PyObject *error_type, *error_value, *error_traceback;
+ /* first, write fields which are the least likely to crash */
+ fprintf(stderr, "object address : %p\n", (void *)op);
+ /* XXX(twouters) cast refcount to long until %zd is
+ universally available */
+ fprintf(stderr, "object refcount : %ld\n", (long)op->ob_refcnt);
+ fflush(stderr);
- fprintf(stderr, "object : ");
+ PyTypeObject *type = Py_TYPE(op);
+ fprintf(stderr, "object type : %p\n", type);
+ fprintf(stderr, "object type name: %s\n",
+ type==NULL ? "NULL" : type->tp_name);
+
+ /* the most dangerous part */
+ fprintf(stderr, "object repr : ");
fflush(stderr);
- gil = PyGILState_Ensure();
+ PyGILState_STATE gil = PyGILState_Ensure();
+ PyObject *error_type, *error_value, *error_traceback;
PyErr_Fetch(&error_type, &error_value, &error_traceback);
+
(void)PyObject_Print(op, stderr, 0);
fflush(stderr);
- PyErr_Restore(error_type, error_value, error_traceback);
+ PyErr_Restore(error_type, error_value, error_traceback);
PyGILState_Release(gil);
- /* XXX(twouters) cast refcount to long until %zd is
- universally available */
- fprintf(stderr, "\n"
- "type : %s\n"
- "refcount: %ld\n"
- "address : %p\n",
- Py_TYPE(op)==NULL ? "NULL" : Py_TYPE(op)->tp_name,
- (long)op->ob_refcnt,
- (void *)op);
+
+ fprintf(stderr, "\n");
fflush(stderr);
}
fprintf(stderr, "%s: ", function);
}
fflush(stderr);
+
if (expr) {
fprintf(stderr, "Assertion \"%s\" failed", expr);
}
fprintf(stderr, "Assertion failed");
}
fflush(stderr);
+
if (msg) {
fprintf(stderr, ": %s", msg);
}
fprintf(stderr, "\n");
fflush(stderr);
- if (obj == NULL) {
- fprintf(stderr, "<object at NULL>\n");
- }
- else if (_PyObject_IsFreed(obj)) {
+ if (_PyObject_IsFreed(obj)) {
/* It seems like the object memory has been freed:
don't access it to prevent a segmentation fault. */
fprintf(stderr, "<object at %p is freed>\n", obj);
- }
- else if (Py_TYPE(obj) == NULL) {
- fprintf(stderr, "<object at %p: ob_type=NULL>\n", obj);
- }
- else if (_PyObject_IsFreed((PyObject *)Py_TYPE(obj))) {
- fprintf(stderr, "<object at %p: type at %p is freed>\n",
- obj, (void *)Py_TYPE(obj));
+ fflush(stderr);
}
else {
/* Display the traceback where the object has been allocated.
/* This might succeed or fail, but we're about to abort, so at least
try to provide any extra info we can: */
_PyObject_Dump(obj);
+
+ fprintf(stderr, "\n");
+ fflush(stderr);
}
- fflush(stderr);
Py_FatalError("_PyObject_AssertFailed");
}
* it wraps a real allocator, adding extra debugging info to the memory blocks.
*/
-/* Special bytes broadcast into debug memory blocks at appropriate times.
- * Strings of these are unlikely to be valid addresses, floats, ints or
- * 7-bit ASCII. If modified, _PyMem_IsPtrFreed() should be updated as well.
- *
- * Byte patterns 0xCB, 0xBB and 0xFB have been replaced with 0xCD, 0xDD and
- * 0xFD to use the same values than Windows CRT debug malloc() and free().
- */
-#undef CLEANBYTE
-#undef DEADBYTE
-#undef FORBIDDENBYTE
-#define CLEANBYTE 0xCD /* clean (newly allocated) memory */
-#define DEADBYTE 0xDD /* dead (newly freed) memory */
-#define FORBIDDENBYTE 0xFD /* untouchable bytes at each end of a block */
-
/* Uncomment this define to add the "serialno" field */
/* #define PYMEM_DEBUG_SERIALNO */
p[S]
API ID. See PEP 445. This is a character, but seems undocumented.
p[S+1: 2*S]
- Copies of FORBIDDENBYTE. Used to catch under- writes and reads.
+ Copies of PYMEM_FORBIDDENBYTE. Used to catch under- writes and reads.
p[2*S: 2*S+n]
- The requested memory, filled with copies of CLEANBYTE.
+ The requested memory, filled with copies of PYMEM_CLEANBYTE.
Used to catch reference to uninitialized memory.
&p[2*S] is returned. Note that this is 8-byte aligned if pymalloc
handled the request itself.
p[2*S+n: 2*S+n+S]
- Copies of FORBIDDENBYTE. Used to catch over- writes and reads.
+ Copies of PYMEM_FORBIDDENBYTE. Used to catch over- writes and reads.
p[2*S+n+S: 2*S+n+2*S]
A serial number, incremented by 1 on each call to _PyMem_DebugMalloc
and _PyMem_DebugRealloc.
/* at p, write size (SST bytes), id (1 byte), pad (SST-1 bytes) */
write_size_t(p, nbytes);
p[SST] = (uint8_t)api->api_id;
- memset(p + SST + 1, FORBIDDENBYTE, SST-1);
+ memset(p + SST + 1, PYMEM_FORBIDDENBYTE, SST-1);
if (nbytes > 0 && !use_calloc) {
- memset(data, CLEANBYTE, nbytes);
+ memset(data, PYMEM_CLEANBYTE, nbytes);
}
/* at tail, write pad (SST bytes) and serialno (SST bytes) */
tail = data + nbytes;
- memset(tail, FORBIDDENBYTE, SST);
+ memset(tail, PYMEM_FORBIDDENBYTE, SST);
#ifdef PYMEM_DEBUG_SERIALNO
write_size_t(tail + SST, serialno);
#endif
/* The debug free first checks the 2*SST bytes on each end for sanity (in
particular, that the FORBIDDENBYTEs with the api ID are still intact).
- Then fills the original bytes with DEADBYTE.
+ Then fills the original bytes with PYMEM_DEADBYTE.
Then calls the underlying free.
*/
static void
_PyMem_DebugCheckAddress(api->api_id, p);
nbytes = read_size_t(q);
nbytes += PYMEM_DEBUG_EXTRA_BYTES;
- memset(q, DEADBYTE, nbytes);
+ memset(q, PYMEM_DEADBYTE, nbytes);
api->alloc.free(api->alloc.ctx, q);
}
*/
if (original_nbytes <= sizeof(save)) {
memcpy(save, data, original_nbytes);
- memset(data - 2 * SST, DEADBYTE,
+ memset(data - 2 * SST, PYMEM_DEADBYTE,
original_nbytes + PYMEM_DEBUG_EXTRA_BYTES);
}
else {
memcpy(save, data, ERASED_SIZE);
- memset(head, DEADBYTE, ERASED_SIZE + 2 * SST);
+ memset(head, PYMEM_DEADBYTE, ERASED_SIZE + 2 * SST);
memcpy(&save[ERASED_SIZE], tail - ERASED_SIZE, ERASED_SIZE);
- memset(tail - ERASED_SIZE, DEADBYTE,
+ memset(tail - ERASED_SIZE, PYMEM_DEADBYTE,
ERASED_SIZE + PYMEM_DEBUG_EXTRA_BYTES - 2 * SST);
}
write_size_t(head, nbytes);
head[SST] = (uint8_t)api->api_id;
- memset(head + SST + 1, FORBIDDENBYTE, SST-1);
+ memset(head + SST + 1, PYMEM_FORBIDDENBYTE, SST-1);
tail = data + nbytes;
- memset(tail, FORBIDDENBYTE, SST);
+ memset(tail, PYMEM_FORBIDDENBYTE, SST);
#ifdef PYMEM_DEBUG_SERIALNO
write_size_t(tail + SST, block_serialno);
#endif
if (nbytes > original_nbytes) {
/* growing: mark new extra memory clean */
- memset(data + original_nbytes, CLEANBYTE, nbytes - original_nbytes);
+ memset(data + original_nbytes, PYMEM_CLEANBYTE,
+ nbytes - original_nbytes);
}
return data;
* the tail could lead to a segfault then.
*/
for (i = SST-1; i >= 1; --i) {
- if (*(q-i) != FORBIDDENBYTE) {
+ if (*(q-i) != PYMEM_FORBIDDENBYTE) {
msg = "bad leading pad byte";
goto error;
}
nbytes = read_size_t(q - 2*SST);
tail = q + nbytes;
for (i = 0; i < SST; ++i) {
- if (tail[i] != FORBIDDENBYTE) {
+ if (tail[i] != PYMEM_FORBIDDENBYTE) {
msg = "bad trailing pad byte";
goto error;
}
fprintf(stderr, " The %d pad bytes at p-%d are ", SST-1, SST-1);
ok = 1;
for (i = 1; i <= SST-1; ++i) {
- if (*(q-i) != FORBIDDENBYTE) {
+ if (*(q-i) != PYMEM_FORBIDDENBYTE) {
ok = 0;
break;
}
fputs("FORBIDDENBYTE, as expected.\n", stderr);
else {
fprintf(stderr, "not all FORBIDDENBYTE (0x%02x):\n",
- FORBIDDENBYTE);
+ PYMEM_FORBIDDENBYTE);
for (i = SST-1; i >= 1; --i) {
const uint8_t byte = *(q-i);
fprintf(stderr, " at p-%d: 0x%02x", i, byte);
- if (byte != FORBIDDENBYTE)
+ if (byte != PYMEM_FORBIDDENBYTE)
fputs(" *** OUCH", stderr);
fputc('\n', stderr);
}
fprintf(stderr, " The %d pad bytes at tail=%p are ", SST, (void *)tail);
ok = 1;
for (i = 0; i < SST; ++i) {
- if (tail[i] != FORBIDDENBYTE) {
+ if (tail[i] != PYMEM_FORBIDDENBYTE) {
ok = 0;
break;
}
fputs("FORBIDDENBYTE, as expected.\n", stderr);
else {
fprintf(stderr, "not all FORBIDDENBYTE (0x%02x):\n",
- FORBIDDENBYTE);
+ PYMEM_FORBIDDENBYTE);
for (i = 0; i < SST; ++i) {
const uint8_t byte = tail[i];
fprintf(stderr, " at tail+%d: 0x%02x",
i, byte);
- if (byte != FORBIDDENBYTE)
+ if (byte != PYMEM_FORBIDDENBYTE)
fputs(" *** OUCH", stderr);
fputc('\n', stderr);
}
int
_PyType_CheckConsistency(PyTypeObject *type)
{
-#define ASSERT(expr) _PyObject_ASSERT((PyObject *)type, (expr))
+#define CHECK(expr) \
+ do { if (!(expr)) { _PyObject_ASSERT_FAILED_MSG((PyObject *)type, Py_STRINGIFY(expr)); } } while (0)
+
+ CHECK(!_PyObject_IsFreed((PyObject *)type));
if (!(type->tp_flags & Py_TPFLAGS_READY)) {
- /* don't check types before PyType_Ready() */
+ /* don't check static types before PyType_Ready() */
return 1;
}
- ASSERT(!_PyObject_IsFreed((PyObject *)type));
- ASSERT(Py_REFCNT(type) >= 1);
- ASSERT(PyType_Check(type));
+ CHECK(Py_REFCNT(type) >= 1);
+ CHECK(PyType_Check(type));
- ASSERT(!(type->tp_flags & Py_TPFLAGS_READYING));
- ASSERT(type->tp_dict != NULL);
+ CHECK(!(type->tp_flags & Py_TPFLAGS_READYING));
+ CHECK(type->tp_dict != NULL);
return 1;
-#undef ASSERT
+#undef CHECK
}
static const char *
int
_PyUnicode_CheckConsistency(PyObject *op, int check_content)
{
+#define CHECK(expr) \
+ do { if (!(expr)) { _PyObject_ASSERT_FAILED_MSG(op, Py_STRINGIFY(expr)); } } while (0)
+
PyASCIIObject *ascii;
unsigned int kind;
- _PyObject_ASSERT(op, PyUnicode_Check(op));
+ assert(op != NULL);
+ CHECK(PyUnicode_Check(op));
ascii = (PyASCIIObject *)op;
kind = ascii->state.kind;
if (ascii->state.ascii == 1 && ascii->state.compact == 1) {
- _PyObject_ASSERT(op, kind == PyUnicode_1BYTE_KIND);
- _PyObject_ASSERT(op, ascii->state.ready == 1);
+ CHECK(kind == PyUnicode_1BYTE_KIND);
+ CHECK(ascii->state.ready == 1);
}
else {
PyCompactUnicodeObject *compact = (PyCompactUnicodeObject *)op;
-#ifndef NDEBUG
void *data;
-#endif
if (ascii->state.compact == 1) {
-#ifndef NDEBUG
data = compact + 1;
-#endif
- _PyObject_ASSERT(op, kind == PyUnicode_1BYTE_KIND
+ CHECK(kind == PyUnicode_1BYTE_KIND
|| kind == PyUnicode_2BYTE_KIND
|| kind == PyUnicode_4BYTE_KIND);
- _PyObject_ASSERT(op, ascii->state.ascii == 0);
- _PyObject_ASSERT(op, ascii->state.ready == 1);
- _PyObject_ASSERT(op, compact->utf8 != data);
+ CHECK(ascii->state.ascii == 0);
+ CHECK(ascii->state.ready == 1);
+ CHECK(compact->utf8 != data);
}
else {
-#ifndef NDEBUG
PyUnicodeObject *unicode = (PyUnicodeObject *)op;
data = unicode->data.any;
-#endif
if (kind == PyUnicode_WCHAR_KIND) {
- _PyObject_ASSERT(op, ascii->length == 0);
- _PyObject_ASSERT(op, ascii->hash == -1);
- _PyObject_ASSERT(op, ascii->state.compact == 0);
- _PyObject_ASSERT(op, ascii->state.ascii == 0);
- _PyObject_ASSERT(op, ascii->state.ready == 0);
- _PyObject_ASSERT(op, ascii->state.interned == SSTATE_NOT_INTERNED);
- _PyObject_ASSERT(op, ascii->wstr != NULL);
- _PyObject_ASSERT(op, data == NULL);
- _PyObject_ASSERT(op, compact->utf8 == NULL);
+ CHECK(ascii->length == 0);
+ CHECK(ascii->hash == -1);
+ CHECK(ascii->state.compact == 0);
+ CHECK(ascii->state.ascii == 0);
+ CHECK(ascii->state.ready == 0);
+ CHECK(ascii->state.interned == SSTATE_NOT_INTERNED);
+ CHECK(ascii->wstr != NULL);
+ CHECK(data == NULL);
+ CHECK(compact->utf8 == NULL);
}
else {
- _PyObject_ASSERT(op, kind == PyUnicode_1BYTE_KIND
+ CHECK(kind == PyUnicode_1BYTE_KIND
|| kind == PyUnicode_2BYTE_KIND
|| kind == PyUnicode_4BYTE_KIND);
- _PyObject_ASSERT(op, ascii->state.compact == 0);
- _PyObject_ASSERT(op, ascii->state.ready == 1);
- _PyObject_ASSERT(op, data != NULL);
+ CHECK(ascii->state.compact == 0);
+ CHECK(ascii->state.ready == 1);
+ CHECK(data != NULL);
if (ascii->state.ascii) {
- _PyObject_ASSERT(op, compact->utf8 == data);
- _PyObject_ASSERT(op, compact->utf8_length == ascii->length);
+ CHECK(compact->utf8 == data);
+ CHECK(compact->utf8_length == ascii->length);
}
else
- _PyObject_ASSERT(op, compact->utf8 != data);
+ CHECK(compact->utf8 != data);
}
}
if (kind != PyUnicode_WCHAR_KIND) {
#endif
)
{
- _PyObject_ASSERT(op, ascii->wstr == data);
- _PyObject_ASSERT(op, compact->wstr_length == ascii->length);
+ CHECK(ascii->wstr == data);
+ CHECK(compact->wstr_length == ascii->length);
} else
- _PyObject_ASSERT(op, ascii->wstr != data);
+ CHECK(ascii->wstr != data);
}
if (compact->utf8 == NULL)
- _PyObject_ASSERT(op, compact->utf8_length == 0);
+ CHECK(compact->utf8_length == 0);
if (ascii->wstr == NULL)
- _PyObject_ASSERT(op, compact->wstr_length == 0);
+ CHECK(compact->wstr_length == 0);
}
/* check that the best kind is used: O(n) operation */
}
if (kind == PyUnicode_1BYTE_KIND) {
if (ascii->state.ascii == 0) {
- _PyObject_ASSERT(op, maxchar >= 128);
- _PyObject_ASSERT(op, maxchar <= 255);
+ CHECK(maxchar >= 128);
+ CHECK(maxchar <= 255);
}
else
- _PyObject_ASSERT(op, maxchar < 128);
+ CHECK(maxchar < 128);
}
else if (kind == PyUnicode_2BYTE_KIND) {
- _PyObject_ASSERT(op, maxchar >= 0x100);
- _PyObject_ASSERT(op, maxchar <= 0xFFFF);
+ CHECK(maxchar >= 0x100);
+ CHECK(maxchar <= 0xFFFF);
}
else {
- _PyObject_ASSERT(op, maxchar >= 0x10000);
- _PyObject_ASSERT(op, maxchar <= MAX_UNICODE);
+ CHECK(maxchar >= 0x10000);
+ CHECK(maxchar <= MAX_UNICODE);
}
- _PyObject_ASSERT(op, PyUnicode_READ(kind, data, ascii->length) == 0);
+ CHECK(PyUnicode_READ(kind, data, ascii->length) == 0);
}
return 1;
+
+#undef CHECK
}
projects / thirdparty / Python / cpython.git / commitdiff
