diff -r 1638360eea41 Modules/_tracemalloc.c
--- a/Modules/_tracemalloc.c	Sat Jan 11 22:22:21 2014 -0800
+++ b/Modules/_tracemalloc.c	Sun Jan 12 09:46:10 2014 +0100
@@ -4,6 +4,11 @@
 #include "pythread.h"
 #include "osdefs.h"
 
+/*[clinic input]
+module _tracemalloc
+[clinic start generated code]*/
+/*[clinic end generated code: checksum=da39a3ee5e6b4b0d3255bfef95601890afd80709]*/
+
 /* Trace memory blocks allocated by PyMem_RawMalloc() */
 #define TRACE_RAW_MALLOC
 
@@ -917,25 +922,70 @@ lineno_as_obj(int lineno)
         Py_RETURN_NONE;
 }
 
-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)
+/*[clinic input]
+_tracemalloc.is_tracing
+
+True if the tracemalloc module is tracing Python memory allocations, False otherwise.
+[clinic start generated code]*/
+
+PyDoc_STRVAR(_tracemalloc_is_tracing__doc__,
+"is_tracing()\n"
+"True if the tracemalloc module is tracing Python memory allocations, False otherwise.");
+
+#define _TRACEMALLOC_IS_TRACING_METHODDEF    \
+    {"is_tracing", (PyCFunction)_tracemalloc_is_tracing, METH_NOARGS, _tracemalloc_is_tracing__doc__},
+
+static PyObject *
+_tracemalloc_is_tracing_impl(PyModuleDef *module);
+
+static PyObject *
+_tracemalloc_is_tracing(PyModuleDef *module, PyObject *Py_UNUSED(ignored))
+{
+    PyObject *return_value = NULL;
+
+    return_value = _tracemalloc_is_tracing_impl(module);
+
+    return return_value;
+}
+
+static PyObject *
+_tracemalloc_is_tracing_impl(PyModuleDef *module)
+/*[clinic end generated code: checksum=687fdf1c4966d85d7090c2132b6bd2e18573f57d]*/
 {
     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)
+/*[clinic input]
+_tracemalloc.clear_traces
+
+Clear traces of memory blocks allocated by Python.
+[clinic start generated code]*/
+
+PyDoc_STRVAR(_tracemalloc_clear_traces__doc__,
+"clear_traces()\n"
+"Clear traces of memory blocks allocated by Python.");
+
+#define _TRACEMALLOC_CLEAR_TRACES_METHODDEF    \
+    {"clear_traces", (PyCFunction)_tracemalloc_clear_traces, METH_NOARGS, _tracemalloc_clear_traces__doc__},
+
+static PyObject *
+_tracemalloc_clear_traces_impl(PyModuleDef *module);
+
+static PyObject *
+_tracemalloc_clear_traces(PyModuleDef *module, PyObject *Py_UNUSED(ignored))
+{
+    PyObject *return_value = NULL;
+
+    return_value = _tracemalloc_clear_traces_impl(module);
+
+    return return_value;
+}
+
+static PyObject *
+_tracemalloc_clear_traces_impl(PyModuleDef *module)
+/*[clinic end generated code: checksum=6bedc8aea0518dc47a981897fc2404e6ceecc58e]*/
 {
     if (!tracemalloc_config.tracing)
         Py_RETURN_NONE;
@@ -1073,17 +1123,46 @@ tracemalloc_pyobject_decref_cb(_Py_hasht
     return 0;
 }
 
-PyDoc_STRVAR(tracemalloc_get_traces_doc,
-    "_get_traces() -> list\n"
-    "\n"
-    "Get traces of all memory blocks allocated by Python.\n"
-    "Return a list of (size: int, traceback: tuple) tuples.\n"
-    "traceback is a tuple of (filename: str, lineno: int) tuples.\n"
-    "\n"
-    "Return an empty list if the tracemalloc module is disabled.");
 
-static PyObject*
-py_tracemalloc_get_traces(PyObject *self, PyObject *obj)
+/*[clinic input]
+_tracemalloc._get_traces
+
+Get traces of all memory blocks allocated by Python.
+
+Return a list of (size: int, traceback: tuple) tuples.
+traceback is a tuple of (filename: str, lineno: int) tuples.
+
+Return an empty list if the tracemalloc module is disabled.
+[clinic start generated code]*/
+
+PyDoc_STRVAR(_tracemalloc__get_traces__doc__,
+"_get_traces()\n"
+"Get traces of all memory blocks allocated by Python.\n"
+"\n"
+"Return a list of (size: int, traceback: tuple) tuples.\n"
+"traceback is a tuple of (filename: str, lineno: int) tuples.\n"
+"\n"
+"Return an empty list if the tracemalloc module is disabled.");
+
+#define _TRACEMALLOC__GET_TRACES_METHODDEF    \
+    {"_get_traces", (PyCFunction)_tracemalloc__get_traces, METH_NOARGS, _tracemalloc__get_traces__doc__},
+
+static PyObject *
+_tracemalloc__get_traces_impl(PyModuleDef *module);
+
+static PyObject *
+_tracemalloc__get_traces(PyModuleDef *module, PyObject *Py_UNUSED(ignored))
+{
+    PyObject *return_value = NULL;
+
+    return_value = _tracemalloc__get_traces_impl(module);
+
+    return return_value;
+}
+
+static PyObject *
+_tracemalloc__get_traces_impl(PyModuleDef *module)
+/*[clinic end generated code: checksum=4a9720264c878c513a0dd79032a696d0050012ca]*/
 {
     get_traces_t get_traces;
     int err;
@@ -1140,17 +1219,53 @@ finally:
     return get_traces.list;
 }
 
-PyDoc_STRVAR(tracemalloc_get_object_traceback_doc,
-    "_get_object_traceback(obj)\n"
-    "\n"
-    "Get the traceback where the Python object obj was allocated.\n"
-    "Return a tuple of (filename: str, lineno: int) tuples.\n"
-    "\n"
-    "Return None if the tracemalloc module is disabled or did not\n"
-    "trace the allocation of the object.");
 
-static PyObject*
-py_tracemalloc_get_object_traceback(PyObject *self, PyObject *obj)
+/*[clinic input]
+_tracemalloc._get_object_traceback
+
+    obj: 'O'
+
+Get the traceback where the Python object obj was allocated.
+
+Return a tuple of (filename: str, lineno: int) tuples.
+Return None if the tracemalloc module is disabled or did not
+trace the allocation of the object.
+[clinic start generated code]*/
+
+PyDoc_STRVAR(_tracemalloc__get_object_traceback__doc__,
+"_get_object_traceback(obj)\n"
+"Get the traceback where the Python object obj was allocated.\n"
+"\n"
+"Return a tuple of (filename: str, lineno: int) tuples.\n"
+"Return None if the tracemalloc module is disabled or did not\n"
+"trace the allocation of the object.");
+
+#define _TRACEMALLOC__GET_OBJECT_TRACEBACK_METHODDEF    \
+    {"_get_object_traceback", (PyCFunction)_tracemalloc__get_object_traceback, METH_VARARGS|METH_KEYWORDS, _tracemalloc__get_object_traceback__doc__},
+
+static PyObject *
+_tracemalloc__get_object_traceback_impl(PyModuleDef *module, PyObject *obj);
+
+static PyObject *
+_tracemalloc__get_object_traceback(PyModuleDef *module, PyObject *args, PyObject *kwargs)
+{
+    PyObject *return_value = NULL;
+    static char *_keywords[] = {"obj", NULL};
+    PyObject *obj;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+        "O:_get_object_traceback", _keywords,
+        &obj))
+        goto exit;
+    return_value = _tracemalloc__get_object_traceback_impl(module, obj);
+
+exit:
+    return return_value;
+}
+
+static PyObject *
+_tracemalloc__get_object_traceback_impl(PyModuleDef *module, PyObject *obj)
+/*[clinic end generated code: checksum=78d25667e4fadbe30e7296588dfaaf3989b830c1]*/
 {
     PyTypeObject *type;
     void *ptr;
@@ -1176,21 +1291,54 @@ py_tracemalloc_get_object_traceback(PyOb
     return traceback_to_pyobject(trace.traceback, NULL);
 }
 
-PyDoc_STRVAR(tracemalloc_start_doc,
-    "start(nframe: int=1)\n"
-    "\n"
-    "Start tracing Python memory allocations. Set also the maximum number \n"
-    "of frames stored in the traceback of a trace to nframe.");
 
-static PyObject*
-py_tracemalloc_start(PyObject *self, PyObject *args)
+/*[clinic input]
+_tracemalloc.start
+
+    nframe: 'n' = 1
+
+Start tracing Python memory allocations.
+
+Also set the maximum number of frames stored in the traceback of a
+trace to nframe.
+[clinic start generated code]*/
+
+PyDoc_STRVAR(_tracemalloc_start__doc__,
+"start(nframe=1)\n"
+"Start tracing Python memory allocations.\n"
+"\n"
+"Also set the maximum number of frames stored in the traceback of a\n"
+"trace to nframe.");
+
+#define _TRACEMALLOC_START_METHODDEF    \
+    {"start", (PyCFunction)_tracemalloc_start, METH_VARARGS|METH_KEYWORDS, _tracemalloc_start__doc__},
+
+static PyObject *
+_tracemalloc_start_impl(PyModuleDef *module, Py_ssize_t nframe);
+
+static PyObject *
+_tracemalloc_start(PyModuleDef *module, PyObject *args, PyObject *kwargs)
 {
+    PyObject *return_value = NULL;
+    static char *_keywords[] = {"nframe", NULL};
     Py_ssize_t nframe = 1;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+        "|n:start", _keywords,
+        &nframe))
+        goto exit;
+    return_value = _tracemalloc_start_impl(module, nframe);
+
+exit:
+    return return_value;
+}
+
+static PyObject *
+_tracemalloc_start_impl(PyModuleDef *module, Py_ssize_t nframe)
+/*[clinic end generated code: checksum=921012db9ba047b98dc5ea48c306a5c4f73eb7d9]*/
+{
     int nframe_int;
 
-    if (!PyArg_ParseTuple(args, "|n:start", &nframe))
-        return NULL;
-
     if (nframe < 1 || nframe > MAX_NFRAME) {
         PyErr_Format(PyExc_ValueError,
                      "the number of frames must be in range [1; %i]",
@@ -1205,42 +1353,119 @@ py_tracemalloc_start(PyObject *self, PyO
     Py_RETURN_NONE;
 }
 
-PyDoc_STRVAR(tracemalloc_stop_doc,
-    "stop()\n"
-    "\n"
-    "Stop tracing Python memory allocations and clear traces\n"
-    "of memory blocks allocated by Python.");
 
-static PyObject*
-py_tracemalloc_stop(PyObject *self)
+/*[clinic input]
+_tracemalloc.stop
+
+Stop tracing Python memory allocations.
+
+Also clear traces of memory blocks allocated by Python.
+[clinic start generated code]*/
+
+PyDoc_STRVAR(_tracemalloc_stop__doc__,
+"stop()\n"
+"Stop tracing Python memory allocations.\n"
+"\n"
+"Also clear traces of memory blocks allocated by Python.");
+
+#define _TRACEMALLOC_STOP_METHODDEF    \
+    {"stop", (PyCFunction)_tracemalloc_stop, METH_NOARGS, _tracemalloc_stop__doc__},
+
+static PyObject *
+_tracemalloc_stop_impl(PyModuleDef *module);
+
+static PyObject *
+_tracemalloc_stop(PyModuleDef *module, PyObject *Py_UNUSED(ignored))
+{
+    PyObject *return_value = NULL;
+
+    return_value = _tracemalloc_stop_impl(module);
+
+    return return_value;
+}
+
+static PyObject *
+_tracemalloc_stop_impl(PyModuleDef *module)
+/*[clinic end generated code: checksum=500d2baf420f0091d79ea66384f7889d48ce8afb]*/
 {
     tracemalloc_stop();
     Py_RETURN_NONE;
 }
 
-PyDoc_STRVAR(tracemalloc_get_traceback_limit_doc,
-    "get_traceback_limit() -> int\n"
-    "\n"
-    "Get the maximum number of frames stored in the traceback\n"
-    "of a trace.\n"
-    "\n"
-    "By default, a trace of an allocated memory block only stores\n"
-    "the most recent frame: the limit is 1.");
 
-static PyObject*
-py_tracemalloc_get_traceback_limit(PyObject *self)
+/*[clinic input]
+_tracemalloc.get_traceback_limit
+
+Get the maximum number of frames stored in the traceback of a trace.
+
+By default, a trace of an allocated memory block only stores
+the most recent frame: the limit is 1.
+[clinic start generated code]*/
+
+PyDoc_STRVAR(_tracemalloc_get_traceback_limit__doc__,
+"get_traceback_limit()\n"
+"Get the maximum number of frames stored in the traceback of a trace.\n"
+"\n"
+"By default, a trace of an allocated memory block only stores\n"
+"the most recent frame: the limit is 1.");
+
+#define _TRACEMALLOC_GET_TRACEBACK_LIMIT_METHODDEF    \
+    {"get_traceback_limit", (PyCFunction)_tracemalloc_get_traceback_limit, METH_NOARGS, _tracemalloc_get_traceback_limit__doc__},
+
+static PyObject *
+_tracemalloc_get_traceback_limit_impl(PyModuleDef *module);
+
+static PyObject *
+_tracemalloc_get_traceback_limit(PyModuleDef *module, PyObject *Py_UNUSED(ignored))
+{
+    PyObject *return_value = NULL;
+
+    return_value = _tracemalloc_get_traceback_limit_impl(module);
+
+    return return_value;
+}
+
+static PyObject *
+_tracemalloc_get_traceback_limit_impl(PyModuleDef *module)
+/*[clinic end generated code: checksum=e4f5a68d7eefc7c8f15a1ca828d25e4cb5c4faf2]*/
 {
     return PyLong_FromLong(tracemalloc_config.max_nframe);
 }
 
-PyDoc_STRVAR(tracemalloc_get_tracemalloc_memory_doc,
-    "get_tracemalloc_memory() -> int\n"
-    "\n"
-    "Get the memory usage in bytes of the tracemalloc module\n"
-    "used internally to trace memory allocations.");
 
-static PyObject*
-tracemalloc_get_tracemalloc_memory(PyObject *self)
+/*[clinic input]
+_tracemalloc.get_tracemalloc_memory
+
+Get the memory usage in bytes of the tracemalloc module.
+
+This memory is used internally to trace memory allocations.
+[clinic start generated code]*/
+
+PyDoc_STRVAR(_tracemalloc_get_tracemalloc_memory__doc__,
+"get_tracemalloc_memory()\n"
+"Get the memory usage in bytes of the tracemalloc module.\n"
+"\n"
+"This memory is used internally to trace memory allocations.");
+
+#define _TRACEMALLOC_GET_TRACEMALLOC_MEMORY_METHODDEF    \
+    {"get_tracemalloc_memory", (PyCFunction)_tracemalloc_get_tracemalloc_memory, METH_NOARGS, _tracemalloc_get_tracemalloc_memory__doc__},
+
+static PyObject *
+_tracemalloc_get_tracemalloc_memory_impl(PyModuleDef *module);
+
+static PyObject *
+_tracemalloc_get_tracemalloc_memory(PyModuleDef *module, PyObject *Py_UNUSED(ignored))
+{
+    PyObject *return_value = NULL;
+
+    return_value = _tracemalloc_get_tracemalloc_memory_impl(module);
+
+    return return_value;
+}
+
+static PyObject *
+_tracemalloc_get_tracemalloc_memory_impl(PyModuleDef *module)
+/*[clinic end generated code: checksum=edc8f026107b0abcd1cef866bdc194c5ab33fbb7]*/
 {
     size_t size;
     PyObject *size_obj;
@@ -1256,14 +1481,40 @@ tracemalloc_get_tracemalloc_memory(PyObj
     return Py_BuildValue("N", size_obj);
 }
 
-PyDoc_STRVAR(tracemalloc_get_traced_memory_doc,
-    "get_traced_memory() -> (int, int)\n"
-    "\n"
-    "Get the current size and peak size of memory blocks traced\n"
-    "by the tracemalloc module as a tuple: (current: int, peak: int).");
 
-static PyObject*
-tracemalloc_get_traced_memory(PyObject *self)
+/*[clinic input]
+_tracemalloc.get_traced_memory
+
+Get the current size and peak size of memory blocks traced by tracemalloc.
+
+Returns a tuple: (current: int, peak: int).
+[clinic start generated code]*/
+
+PyDoc_STRVAR(_tracemalloc_get_traced_memory__doc__,
+"get_traced_memory()\n"
+"Get the current size and peak size of memory blocks traced by tracemalloc.\n"
+"\n"
+"Returns a tuple: (current: int, peak: int).");
+
+#define _TRACEMALLOC_GET_TRACED_MEMORY_METHODDEF    \
+    {"get_traced_memory", (PyCFunction)_tracemalloc_get_traced_memory, METH_NOARGS, _tracemalloc_get_traced_memory__doc__},
+
+static PyObject *
+_tracemalloc_get_traced_memory_impl(PyModuleDef *module);
+
+static PyObject *
+_tracemalloc_get_traced_memory(PyModuleDef *module, PyObject *Py_UNUSED(ignored))
+{
+    PyObject *return_value = NULL;
+
+    return_value = _tracemalloc_get_traced_memory_impl(module);
+
+    return return_value;
+}
+
+static PyObject *
+_tracemalloc_get_traced_memory_impl(PyModuleDef *module)
+/*[clinic end generated code: checksum=ea928385668772b2d089000301353908c069ca0c]*/
 {
     Py_ssize_t size, peak_size;
     PyObject *size_obj, *peak_size_obj;
@@ -1282,25 +1533,15 @@ tracemalloc_get_traced_memory(PyObject *
 }
 
 static PyMethodDef module_methods[] = {
-    {"is_tracing", (PyCFunction)py_tracemalloc_is_tracing,
-     METH_NOARGS, tracemalloc_is_tracing_doc},
-    {"clear_traces", (PyCFunction)py_tracemalloc_clear_traces,
-     METH_NOARGS, tracemalloc_clear_traces_doc},
-    {"_get_traces", (PyCFunction)py_tracemalloc_get_traces,
-     METH_NOARGS, tracemalloc_get_traces_doc},
-    {"_get_object_traceback", (PyCFunction)py_tracemalloc_get_object_traceback,
-     METH_O, tracemalloc_get_object_traceback_doc},
-    {"start", (PyCFunction)py_tracemalloc_start,
-      METH_VARARGS, tracemalloc_start_doc},
-    {"stop", (PyCFunction)py_tracemalloc_stop,
-      METH_NOARGS, tracemalloc_stop_doc},
-    {"get_traceback_limit", (PyCFunction)py_tracemalloc_get_traceback_limit,
-     METH_NOARGS, tracemalloc_get_traceback_limit_doc},
-    {"get_tracemalloc_memory", (PyCFunction)tracemalloc_get_tracemalloc_memory,
-     METH_NOARGS, tracemalloc_get_tracemalloc_memory_doc},
-    {"get_traced_memory", (PyCFunction)tracemalloc_get_traced_memory,
-     METH_NOARGS, tracemalloc_get_traced_memory_doc},
-
+    _TRACEMALLOC_IS_TRACING_METHODDEF
+    _TRACEMALLOC_CLEAR_TRACES_METHODDEF
+    _TRACEMALLOC__GET_TRACES_METHODDEF
+    _TRACEMALLOC__GET_OBJECT_TRACEBACK_METHODDEF
+    _TRACEMALLOC_START_METHODDEF
+    _TRACEMALLOC_STOP_METHODDEF
+    _TRACEMALLOC_GET_TRACEBACK_LIMIT_METHODDEF
+    _TRACEMALLOC_GET_TRACEMALLOC_MEMORY_METHODDEF
+    _TRACEMALLOC_GET_TRACED_MEMORY_METHODDEF
     /* sentinel */
     {NULL, NULL}
 };