#include "Python.h"

#include "hashtable.h"

#include "frameobject.h"

#include "pythread.h"

#include "osdefs.h"

#define TRACE_RAW_MALLOC

static void tracemalloc_stop(void);

static void* raw_malloc(size_t size);

static void raw_free(void *ptr);

#ifdef Py_DEBUG

# define TRACE_DEBUG

static struct {

PyMemAllocatorEx mem;

PyMemAllocatorEx raw;

PyMemAllocatorEx obj;

} allocators;

static struct {

/* Module initialized?

enum {

TRACEMALLOC_NOT_INITIALIZED,

TRACEMALLOC_INITIALIZED,

TRACEMALLOC_FINALIZED

} initialized;

/* Is tracemalloc tracing memory allocations?

int tracing;

/* limit of the number of frames in a traceback, 1 by default.

int max_nframe;

} tracemalloc_config = {TRACEMALLOC_NOT_INITIALIZED, 0, 1};

#if defined(TRACE_RAW_MALLOC) && defined(WITH_THREAD)

static PyThread_type_lock tables_lock;

# define TABLES_LOCK() PyThread_acquire_lock(tables_lock, 1)

# define TABLES_UNLOCK() PyThread_release_lock(tables_lock)

/* variables are protected by the GIL */

# define TABLES_LOCK()

# define TABLES_UNLOCK()

typedef struct

#ifdef __GNUC__

__attribute__((packed))

#elif defined(_MSC_VER)

_declspec(align(4))

} frame_t;

typedef struct {

Py_uhash_t hash;

int nframe;

frame_t frames[1];

} traceback_t;

#define TRACEBACK_SIZE(NFRAME) \

(sizeof(traceback_t) + sizeof(frame_t) * (NFRAME - 1))

#define MAX_NFRAME \

((INT_MAX - (int)sizeof(traceback_t)) / (int)sizeof(frame_t) + 1)

static PyObject *unknown_filename = NULL;

static traceback_t tracemalloc_empty_traceback;

typedef struct {

/* Size of the memory block in bytes */

size_t size;

/* Traceback where the memory block was allocated */

traceback_t *traceback;

} trace_t;

static size_t tracemalloc_traced_memory = 0;

static size_t tracemalloc_peak_traced_memory = 0;

static _Py_hashtable_t *tracemalloc_filenames = NULL;

static traceback_t *tracemalloc_traceback = NULL;

static _Py_hashtable_t *tracemalloc_tracebacks = NULL;

static _Py_hashtable_t *tracemalloc_traces = NULL;

#ifdef TRACE_DEBUG

static void

tracemalloc_error(const char *format, ...)

{

va_list ap;

fprintf(stderr, "tracemalloc: ");

va_start(ap, format);

vfprintf(stderr, format, ap);

va_end(ap);

fprintf(stderr, "\n");

fflush(stderr);

}

#if defined(WITH_THREAD) && defined(TRACE_RAW_MALLOC)

#define REENTRANT_THREADLOCAL

#if !(defined(_POSIX_THREADS) || defined(NT_THREADS))

# error "need native thread local storage (TLS)"

static int tracemalloc_reentrant_key;

#define REENTRANT Py_True

static int

get_reentrant(void)

{

void *ptr = PyThread_get_key_value(tracemalloc_reentrant_key);

if (ptr != NULL) {

assert(ptr == REENTRANT);

return 1;

}

else

return 0;

}

static void

set_reentrant(int reentrant)

{

assert(reentrant == 0 || reentrant == 1);

if (reentrant) {

assert(PyThread_get_key_value(tracemalloc_reentrant_key) == NULL);

PyThread_set_key_value(tracemalloc_reentrant_key, REENTRANT);

}

else {

assert(PyThread_get_key_value(tracemalloc_reentrant_key) == REENTRANT);

PyThread_set_key_value(tracemalloc_reentrant_key, NULL);

}

}

static int tracemalloc_reentrant = 0;

static int

get_reentrant(void)

{

return tracemalloc_reentrant;

}

static void

set_reentrant(int reentrant)

{

assert(reentrant != tracemalloc_reentrant);

tracemalloc_reentrant = reentrant;

}

static int

hashtable_compare_unicode(const void *key, const _Py_hashtable_entry_t *entry)

{

if (key != NULL && entry->key != NULL)

return (PyUnicode_Compare((PyObject *)key, (PyObject *)entry->key) == 0);

else

return key == entry->key;

}

static _Py_hashtable_allocator_t hashtable_alloc = {malloc, free};

static _Py_hashtable_t *

hashtable_new(size_t data_size,

_Py_hashtable_hash_func hash_func,

_Py_hashtable_compare_func compare_func)

{

return _Py_hashtable_new_full(data_size, 0,

hash_func, compare_func,

NULL, NULL, NULL, &hashtable_alloc);

}

static void*

raw_malloc(size_t size)

{

return allocators.raw.malloc(allocators.raw.ctx, size);

}

static void

raw_free(void *ptr)

{

allocators.raw.free(allocators.raw.ctx, ptr);

}

static Py_uhash_t

hashtable_hash_traceback(const void *key)

{

const traceback_t *traceback = key;

return traceback->hash;

}

static int

hashtable_compare_traceback(const traceback_t *traceback1,

const _Py_hashtable_entry_t *he)

{

const traceback_t *traceback2 = he->key;

const frame_t *frame1, *frame2;

int i;

if (traceback1->nframe != traceback2->nframe)

return 0;

for (i=0; i < traceback1->nframe; i++) {

frame1 = &traceback1->frames[i];

frame2 = &traceback2->frames[i];

if (frame1->lineno != frame2->lineno)

return 0;

if (frame1->filename != frame2->filename) {

assert(PyUnicode_Compare(frame1->filename, frame2->filename) != 0);

return 0;

}

}

return 1;

}

static void

tracemalloc_get_frame(PyFrameObject *pyframe, frame_t *frame)

{

PyCodeObject *code;

PyObject *filename;

_Py_hashtable_entry_t *entry;

int lineno;

frame->filename = unknown_filename;

lineno = PyFrame_GetLineNumber(pyframe);

if (lineno < 0)

lineno = 0;

frame->lineno = (unsigned int)lineno;

code = pyframe->f_code;

if (code == NULL) {

#ifdef TRACE_DEBUG

tracemalloc_error("failed to get the code object of the frame");

return;

}

if (code->co_filename == NULL) {

#ifdef TRACE_DEBUG

tracemalloc_error("failed to get the filename of the code object");

return;

}

filename = code->co_filename;

assert(filename != NULL);

if (filename == NULL)

return;

if (!PyUnicode_Check(filename)) {

#ifdef TRACE_DEBUG

tracemalloc_error("filename is not a unicode string");

return;

}

if (!PyUnicode_IS_READY(filename)) {

/* Don't make a Unicode string ready to avoid reentrant calls

#ifdef TRACE_DEBUG

tracemalloc_error("filename is not a ready unicode string");

return;

}

/* intern the filename */

entry = _Py_hashtable_get_entry(tracemalloc_filenames, filename);

if (entry != NULL) {

filename = (PyObject *)entry->key;

}

else {

/* tracemalloc_filenames is responsible to keep a reference

Py_INCREF(filename);

if (_Py_hashtable_set(tracemalloc_filenames, filename, NULL, 0) < 0) {

Py_DECREF(filename);

#ifdef TRACE_DEBUG

tracemalloc_error("failed to intern the filename");

return;

}

}

/* the tracemalloc_filenames table keeps a reference to the filename */

frame->filename = filename;

}

static Py_uhash_t

traceback_hash(traceback_t *traceback)

{

/* code based on tuplehash() of Objects/tupleobject.c */

Py_uhash_t x, y; /* Unsigned for defined overflow behavior. */

int len = traceback->nframe;

Py_uhash_t mult = _PyHASH_MULTIPLIER;

frame_t *frame;

x = 0x345678UL;

frame = traceback->frames;

while (--len >= 0) {

y = (Py_uhash_t)PyObject_Hash(frame->filename);

y ^= (Py_uhash_t)frame->lineno;

frame++;

x = (x ^ y) * mult;

/* the cast might truncate len; that doesn't change hash stability */

mult += (Py_uhash_t)(82520UL + len + len);

}

x += 97531UL;

return x;

}

static void

traceback_get_frames(traceback_t *traceback)

{

PyThreadState *tstate;

PyFrameObject *pyframe;

#ifdef WITH_THREAD

tstate = PyGILState_GetThisThreadState();

tstate = PyThreadState_Get();

if (tstate == NULL) {

#ifdef TRACE_DEBUG

tracemalloc_error("failed to get the current thread state");

return;

}

for (pyframe = tstate->frame; pyframe != NULL; pyframe = pyframe->f_back) {

tracemalloc_get_frame(pyframe, &traceback->frames[traceback->nframe]);

assert(traceback->frames[traceback->nframe].filename != NULL);

traceback->nframe++;

if (traceback->nframe == tracemalloc_config.max_nframe)

break;

}

}

static traceback_t *

traceback_new(void)

{

traceback_t *traceback;

_Py_hashtable_entry_t *entry;

#ifdef WITH_THREAD

assert(PyGILState_Check());

/* get frames */

traceback = tracemalloc_traceback;

traceback->nframe = 0;

traceback_get_frames(traceback);

if (traceback->nframe == 0)

return &tracemalloc_empty_traceback;

traceback->hash = traceback_hash(traceback);

/* intern the traceback */

entry = _Py_hashtable_get_entry(tracemalloc_tracebacks, traceback);

if (entry != NULL) {

traceback = (traceback_t *)entry->key;

}

else {

traceback_t *copy;

size_t traceback_size;

traceback_size = TRACEBACK_SIZE(traceback->nframe);

copy = raw_malloc(traceback_size);

if (copy == NULL) {

#ifdef TRACE_DEBUG

tracemalloc_error("failed to intern the traceback: malloc failed");

return NULL;

}

memcpy(copy, traceback, traceback_size);

if (_Py_hashtable_set(tracemalloc_tracebacks, copy, NULL, 0) < 0) {

raw_free(copy);

#ifdef TRACE_DEBUG

tracemalloc_error("failed to intern the traceback: putdata failed");

return NULL;

}

traceback = copy;

}

return traceback;

}

static int

tracemalloc_add_trace(void *ptr, size_t size)

{

traceback_t *traceback;

trace_t trace;

int res;

#ifdef WITH_THREAD

assert(PyGILState_Check());

traceback = traceback_new();

if (traceback == NULL)

return -1;

trace.size = size;

trace.traceback = traceback;

res = _Py_HASHTABLE_SET(tracemalloc_traces, ptr, trace);

if (res == 0) {

assert(tracemalloc_traced_memory <= PY_SIZE_MAX - size);

tracemalloc_traced_memory += size;

if (tracemalloc_traced_memory > tracemalloc_peak_traced_memory)

tracemalloc_peak_traced_memory = tracemalloc_traced_memory;

}

return res;

}

static void

tracemalloc_remove_trace(void *ptr)

{

trace_t trace;

if (_Py_hashtable_pop(tracemalloc_traces, ptr, &trace, sizeof(trace))) {

assert(tracemalloc_traced_memory >= trace.size);

tracemalloc_traced_memory -= trace.size;

}

}

static void*

tracemalloc_alloc(int use_calloc, void *ctx, size_t nelem, size_t elsize)

{

PyMemAllocatorEx *alloc = (PyMemAllocatorEx *)ctx;

void *ptr;

assert(elsize == 0 || nelem <= PY_SIZE_MAX / elsize);

if (use_calloc)

ptr = alloc->calloc(alloc->ctx, nelem, elsize);

else

ptr = alloc->malloc(alloc->ctx, nelem * elsize);

if (ptr == NULL)

return NULL;

TABLES_LOCK();

if (tracemalloc_add_trace(ptr, nelem * elsize) < 0) {

/* Failed to allocate a trace for the new memory block */

TABLES_UNLOCK();

alloc->free(alloc->ctx, ptr);

return NULL;

}

TABLES_UNLOCK();

return ptr;

}

static void*

tracemalloc_realloc(void *ctx, void *ptr, size_t new_size)

{

PyMemAllocatorEx *alloc = (PyMemAllocatorEx *)ctx;

void *ptr2;

ptr2 = alloc->realloc(alloc->ctx, ptr, new_size);

if (ptr2 == NULL)

return NULL;

if (ptr != NULL) {

/* an existing memory block has been resized */

TABLES_LOCK();

tracemalloc_remove_trace(ptr);

if (tracemalloc_add_trace(ptr2, new_size) < 0) {

/* Memory allocation failed. The error cannot be reported to

assert(0 && "should never happen");

}

TABLES_UNLOCK();

}

else {

/* new allocation */

TABLES_LOCK();

if (tracemalloc_add_trace(ptr2, new_size) < 0) {

/* Failed to allocate a trace for the new memory block */

TABLES_UNLOCK();

alloc->free(alloc->ctx, ptr2);

return NULL;

}

TABLES_UNLOCK();

}

return ptr2;

}

static void

tracemalloc_free(void *ctx, void *ptr)

{

PyMemAllocatorEx *alloc = (PyMemAllocatorEx *)ctx;

if (ptr == NULL)

return;

/* GIL cannot be locked in PyMem_RawFree() because it would introduce

alloc->free(alloc->ctx, ptr);

TABLES_LOCK();

tracemalloc_remove_trace(ptr);

TABLES_UNLOCK();

}

static void*

tracemalloc_alloc_gil(int use_calloc, void *ctx, size_t nelem, size_t elsize)

{

void *ptr;

if (get_reentrant()) {

PyMemAllocatorEx *alloc = (PyMemAllocatorEx *)ctx;

if (use_calloc)

return alloc->calloc(alloc->ctx, nelem, elsize);

else

return alloc->malloc(alloc->ctx, nelem * elsize);

}

/* Ignore reentrant call. PyObjet_Malloc() calls PyMem_Malloc() for

set_reentrant(1);

ptr = tracemalloc_alloc(use_calloc, ctx, nelem, elsize);

set_reentrant(0);

return ptr;

}

static void*

tracemalloc_malloc_gil(void *ctx, size_t size)

{

return tracemalloc_alloc_gil(0, ctx, 1, size);

}

static void*

tracemalloc_calloc_gil(void *ctx, size_t nelem, size_t elsize)

{

return tracemalloc_alloc_gil(1, ctx, nelem, elsize);

}

static void*

tracemalloc_realloc_gil(void *ctx, void *ptr, size_t new_size)

{

void *ptr2;

if (get_reentrant()) {

/* Reentrant call to PyMem_Realloc() and PyMem_RawRealloc().

PyMemAllocatorEx *alloc = (PyMemAllocatorEx *)ctx;

ptr2 = alloc->realloc(alloc->ctx, ptr, new_size);

if (ptr2 != NULL && ptr != NULL) {

TABLES_LOCK();

tracemalloc_remove_trace(ptr);

TABLES_UNLOCK();

}

return ptr2;

}

/* Ignore reentrant call. PyObjet_Realloc() calls PyMem_Realloc() for

set_reentrant(1);

ptr2 = tracemalloc_realloc(ctx, ptr, new_size);

set_reentrant(0);

return ptr2;

}

#ifdef TRACE_RAW_MALLOC

static void*

tracemalloc_raw_alloc(int use_calloc, void *ctx, size_t nelem, size_t elsize)

{

#ifdef WITH_THREAD

PyGILState_STATE gil_state;

void *ptr;

if (get_reentrant()) {

PyMemAllocatorEx *alloc = (PyMemAllocatorEx *)ctx;

if (use_calloc)

return alloc->calloc(alloc->ctx, nelem, elsize);

else

return alloc->malloc(alloc->ctx, nelem * elsize);

}

/* Ignore reentrant call. PyGILState_Ensure() may call PyMem_RawMalloc()

set_reentrant(1);

#ifdef WITH_THREAD

gil_state = PyGILState_Ensure();

ptr = tracemalloc_alloc(use_calloc, ctx, nelem, elsize);

PyGILState_Release(gil_state);

ptr = tracemalloc_alloc(use_calloc, ctx, nelem, elsize);

set_reentrant(0);

return ptr;

}

static void*

tracemalloc_raw_malloc(void *ctx, size_t size)

{

return tracemalloc_raw_alloc(0, ctx, 1, size);

}

static void*

tracemalloc_raw_calloc(void *ctx, size_t nelem, size_t elsize)

{

return tracemalloc_raw_alloc(1, ctx, nelem, elsize);

}

static void*

tracemalloc_raw_realloc(void *ctx, void *ptr, size_t new_size)

{

#ifdef WITH_THREAD

PyGILState_STATE gil_state;

void *ptr2;

if (get_reentrant()) {

/* Reentrant call to PyMem_RawRealloc(). */

PyMemAllocatorEx *alloc = (PyMemAllocatorEx *)ctx;

ptr2 = alloc->realloc(alloc->ctx, ptr, new_size);

if (ptr2 != NULL && ptr != NULL) {

TABLES_LOCK();

tracemalloc_remove_trace(ptr);

TABLES_UNLOCK();

}

return ptr2;

}

/* Ignore reentrant call. PyGILState_Ensure() may call PyMem_RawMalloc()

set_reentrant(1);

#ifdef WITH_THREAD

gil_state = PyGILState_Ensure();

ptr2 = tracemalloc_realloc(ctx, ptr, new_size);

PyGILState_Release(gil_state);

ptr2 = tracemalloc_realloc(ctx, ptr, new_size);

set_reentrant(0);

return ptr2;

}

#endif /* TRACE_RAW_MALLOC */

static int

tracemalloc_clear_filename(_Py_hashtable_entry_t *entry, void *user_data)

{

PyObject *filename = (PyObject *)entry->key;

Py_DECREF(filename);

return 0;

}

static int

traceback_free_traceback(_Py_hashtable_entry_t *entry, void *user_data)

{

traceback_t *traceback = (traceback_t *)entry->key;

raw_free(traceback);

return 0;

}

static void

tracemalloc_clear_traces(void)

{

#ifdef WITH_THREAD

/* The GIL protects variables againt concurrent access */

assert(PyGILState_Check());

TABLES_LOCK();

_Py_hashtable_clear(tracemalloc_traces);

tracemalloc_traced_memory = 0;

tracemalloc_peak_traced_memory = 0;

TABLES_UNLOCK();

_Py_hashtable_foreach(tracemalloc_tracebacks, traceback_free_traceback, NULL);

_Py_hashtable_clear(tracemalloc_tracebacks);

_Py_hashtable_foreach(tracemalloc_filenames, tracemalloc_clear_filename, NULL);

_Py_hashtable_clear(tracemalloc_filenames);

}

static int

tracemalloc_init(void)

{

if (tracemalloc_config.initialized == TRACEMALLOC_FINALIZED) {

PyErr_SetString(PyExc_RuntimeError,

"the tracemalloc module has been unloaded");

return -1;

}

if (tracemalloc_config.initialized == TRACEMALLOC_INITIALIZED)

return 0;

PyMem_GetAllocator(PYMEM_DOMAIN_RAW, &allocators.raw);

#ifdef REENTRANT_THREADLOCAL

tracemalloc_reentrant_key = PyThread_create_key();

if (tracemalloc_reentrant_key == -1) {

#ifdef MS_WINDOWS

PyErr_SetFromWindowsErr(0);

PyErr_SetFromErrno(PyExc_OSError);

return -1;

}

#if defined(WITH_THREAD) && defined(TRACE_RAW_MALLOC)

if (tables_lock == NULL) {

tables_lock = PyThread_allocate_lock();

if (tables_lock == NULL) {

PyErr_SetString(PyExc_RuntimeError, "cannot allocate lock");

return -1;

}

}

tracemalloc_filenames = hashtable_new(0,

(_Py_hashtable_hash_func)PyObject_Hash,

hashtable_compare_unicode);

tracemalloc_tracebacks = hashtable_new(0,

(_Py_hashtable_hash_func)hashtable_hash_traceback,

(_Py_hashtable_compare_func)hashtable_compare_traceback);

tracemalloc_traces = hashtable_new(sizeof(trace_t),

_Py_hashtable_hash_ptr,

_Py_hashtable_compare_direct);

if (tracemalloc_filenames == NULL || tracemalloc_tracebacks == NULL

|| tracemalloc_traces == NULL)

{

PyErr_NoMemory();

return -1;

}

unknown_filename = PyUnicode_FromString("<unknown>");

if (unknown_filename == NULL)

return -1;

PyUnicode_InternInPlace(&unknown_filename);

tracemalloc_empty_traceback.nframe = 1;

/* borrowed reference */

tracemalloc_empty_traceback.frames[0].filename = unknown_filename;

tracemalloc_empty_traceback.frames[0].lineno = 0;

tracemalloc_empty_traceback.hash = traceback_hash(&tracemalloc_empty_traceback);

tracemalloc_config.initialized = TRACEMALLOC_INITIALIZED;

return 0;

}

static void

tracemalloc_deinit(void)

{

if (tracemalloc_config.initialized != TRACEMALLOC_INITIALIZED)

return;

tracemalloc_config.initialized = TRACEMALLOC_FINALIZED;

tracemalloc_stop();

/* destroy hash tables */

_Py_hashtable_destroy(tracemalloc_traces);

_Py_hashtable_destroy(tracemalloc_tracebacks);

_Py_hashtable_destroy(tracemalloc_filenames);

#if defined(WITH_THREAD) && defined(TRACE_RAW_MALLOC)

if (tables_lock != NULL) {

PyThread_free_lock(tables_lock);

tables_lock = NULL;

}

#ifdef REENTRANT_THREADLOCAL

PyThread_delete_key(tracemalloc_reentrant_key);

Py_XDECREF(unknown_filename);

}

static int

tracemalloc_start(int max_nframe)

{

PyMemAllocatorEx alloc;

size_t size;

if (tracemalloc_init() < 0)

return -1;

if (tracemalloc_config.tracing) {

/* hook already installed: do nothing */

return 0;

}

assert(1 <= max_nframe && max_nframe <= MAX_NFRAME);

tracemalloc_config.max_nframe = max_nframe;

/* allocate a buffer to store a new traceback */

size = TRACEBACK_SIZE(max_nframe);

assert(tracemalloc_traceback == NULL);

tracemalloc_traceback = raw_malloc(size);

if (tracemalloc_traceback == NULL) {

PyErr_NoMemory();

return -1;

}

#ifdef TRACE_RAW_MALLOC

alloc.malloc = tracemalloc_raw_malloc;

alloc.calloc = tracemalloc_raw_calloc;

alloc.realloc = tracemalloc_raw_realloc;

alloc.free = tracemalloc_free;

alloc.ctx = &allocators.raw;

PyMem_GetAllocator(PYMEM_DOMAIN_RAW, &allocators.raw);

PyMem_SetAllocator(PYMEM_DOMAIN_RAW, &alloc);

alloc.malloc = tracemalloc_malloc_gil;

alloc.calloc = tracemalloc_calloc_gil;

alloc.realloc = tracemalloc_realloc_gil;

alloc.free = tracemalloc_free;

alloc.ctx = &allocators.mem;

PyMem_GetAllocator(PYMEM_DOMAIN_MEM, &allocators.mem);

PyMem_SetAllocator(PYMEM_DOMAIN_MEM, &alloc);

alloc.ctx = &allocators.obj;

PyMem_GetAllocator(PYMEM_DOMAIN_OBJ, &allocators.obj);

PyMem_SetAllocator(PYMEM_DOMAIN_OBJ, &alloc);

/* everything is ready: start tracing Python memory allocations */

tracemalloc_config.tracing = 1;

return 0;

}

static void

tracemalloc_stop(void)

{

if (!tracemalloc_config.tracing)

return;

/* stop tracing Python memory allocations */

tracemalloc_config.tracing = 0;

/* unregister the hook on memory allocators */

#ifdef TRACE_RAW_MALLOC

PyMem_SetAllocator(PYMEM_DOMAIN_RAW, &allocators.raw);

PyMem_SetAllocator(PYMEM_DOMAIN_MEM, &allocators.mem);

PyMem_SetAllocator(PYMEM_DOMAIN_OBJ, &allocators.obj);

/* release memory */

tracemalloc_clear_traces();

raw_free(tracemalloc_traceback);

tracemalloc_traceback = NULL;

}

PyDoc_STRVAR(tracemalloc_is_tracing_doc,

"is_tracing()->bool\n"

"\n"

"True if the tracemalloc module is tracing Python memory allocations,\n"

"False otherwise.");

static PyObject*

py_tracemalloc_is_tracing(PyObject *self)

{

return PyBool_FromLong(tracemalloc_config.tracing);

}

PyDoc_STRVAR(tracemalloc_clear_traces_doc,

"clear_traces()\n"

"\n"

"Clear traces of memory blocks allocated by Python.");

static PyObject*

py_tracemalloc_clear_traces(PyObject *self)

{

if (!tracemalloc_config.tracing)

Py_RETURN_NONE;

set_reentrant(1);

tracemalloc_clear_traces();

set_reentrant(0);

Py_RETURN_NONE;

}

static PyObject*

frame_to_pyobject(frame_t *frame)

{

PyObject *frame_obj, *lineno_obj;

frame_obj = PyTuple_New(2);

if (frame_obj == NULL)

return NULL;

if (frame->filename == NULL)

frame->filename = Py_None;

Py_INCREF(frame->filename);

PyTuple_SET_ITEM(frame_obj, 0, frame->filename);

lineno_obj = PyLong_FromUnsignedLong(frame->lineno);

if (lineno_obj == NULL) {

Py_DECREF(frame_obj);

return NULL;

}

PyTuple_SET_ITEM(frame_obj, 1, lineno_obj);

return frame_obj;

}

static PyObject*

traceback_to_pyobject(traceback_t *traceback, _Py_hashtable_t *intern_table)

{

int i;

PyObject *frames, *frame;

if (intern_table != NULL) {

if (_Py_HASHTABLE_GET(intern_table, traceback, frames)) {

Py_INCREF(frames);

return frames;

}

}

frames = PyTuple_New(traceback->nframe);

if (frames == NULL)