Const types.

Tuple/list construction: Evaluate & store items one at a time?

Varargs argument traversal.

Optimise abs() on integer or float.

Optional semicolons after C declarations.

Multiple C declarations on one line?

Optimise return without value outside of try-finally.

exec statement.

Use iterator protocol for unpacking.

In-place operators (+=, etc).

Check for lack of return with value in non-void C functions?

Make C structs callable as constructors.

When calling user __dealloc__ func, save & restore exception.

Complex number parsetuple format?

Provide a way of declaring a C function as returning a
borrowed Python reference.

Provide a way of declaring a C function as stealing a
Python reference.

Provide a way of specifying whether a Python object obtained
by casting a pointer should be treated as a new reference
or not.

Make sizeof() take types as well as variables.

Allow "unsigned" to be used alone as a type name.

Do something about installing proper version of pyrexc
script according to platform in setup.py.

Recognise #line directives?

Catch floating point exceptions?

Generate type test when casting from one Python type
to another.

Allow ranges of exception values.

Support "complex double" and "complex float"?

Allow module-level Python variables to be declared extern.

Consider:
>cdef extern from "foo.h":
>    int dosomething() except -1 raise MyException

Properties for Python types?

Find a way to make classmethod and staticmethod work better.

Statically initialised C arrays & structs.

Make docstrings of extension type special methods work.

Treat result of getting C attribute of extension type as non-ephemeral.

Teach it about common builtin types.

Option for generating a main() function?

Do something about external C functions declared as returning
const * types?

Use PyString_FromStringAndSize for string literals? (For efficiency
and so that they can contain nulls.)

What to do about __name__ etc. attributes of a module (they are
currently assumed to be built-in names).

Use PyDict_GetItem etc. on module & builtins dicts for speed.

Intern all string literals used as Python strings?
[Koshy <jkoshy@freebsd.org>]

Disallow a filename which results in an illegal identifier when
used as a module name.

Provide an easy way of exposing a set of enum values as Python names.
[John J Lee <jjl@pobox.com>]

Prevent user from returning a value from special methods that
return an error indicator only.

Allow * in cimport? [John J Lee <jjl@pobox.com>]

Make Python class construction work more like it does in Python.

Give the right module name to Python classes.

Command line switch for full pathnames in backtraces?

Peephole optimisation? [Vladislav Bulatov <vrbulatov@list.ru>]

Avoid PyArg_ParseTuple call when a function takes no positional args.

Can a faster way of instantiating extension types be found?

Use PySequence_GetItem instead of PyObject_GetItem when index
is an integer.

If a __getitem__ method is declared with an int index, use the
sq_item slot instead of the mp_subscript slot.

Provide some way of controlling the argument list passed to
an extension type's base __new__ method?
[Alain Pointdexter <alainpoint@yahoo.fr>]

Implement a true __new__ for extension types.

Way to provide constructors for extension types that are not
available to Python and can accept C types directly?

Support generators by turning them into extension types?

List comprehensions.

Variable declarations inside inner code blocks?

Initial values when declaring variables?

Support class methods in extension types using METH_CLASS flag.

Disallow defaulting types to 'object' in C declarations?

C globals with static initialisers.

Find a way of providing C-only initialisers for extension types.

Metaclasses for extension types?

Make extension types use Py_TPFLAGS_HEAPTYPE so their __module__
will get set dynamically?

Recognise return type of calls to extension type constructors.

Track GIL state.

Private fields of extension types in a separate struct.

Private vtable entries in a separate struct.

Built-in constants (exceptions, etc.)
