merge

Cython/Compiler/Code.py

@@ -943,6 +943,15 @@ class CCodeWriter(object):
     def put_finish_refcount_context(self):
         self.putln("__Pyx_FinishRefcountContext();")
 
+    def put_trace_call(self, name, pos):
+        self.putln('__Pyx_TraceCall("%s", %s[%s], %s);' % (name, Naming.filetable_cname, self.lookup_filename(pos[0]), pos[1]));
+    
+    def put_trace_exception(self):
+        self.putln("__Pyx_TraceException();")
+    
+    def put_trace_return(self, retvalue_cname):
+        self.putln("__Pyx_TraceReturn(%s);" % retvalue_cname)
+
 
 class PyrexCodeWriter(object):
     # f                file      output file

Cython/Compiler/ExprNodes.py

@@ -2578,6 +2578,9 @@ class GeneralCallNode(CallNode):
         if self.starstar_arg:
             self.starstar_arg.analyse_types(env)
         if not self.function.type.is_pyobject:
+            if self.function.type.is_error:
+                self.type = error_type
+                return error_type
             if hasattr(self.function, 'entry') and not self.function.entry.as_variable:
                 error(self.pos, "Keyword arguments not allowed in cdef functions.")
             else:
@@ -2592,6 +2595,7 @@ class GeneralCallNode(CallNode):
         self.is_temp = 1
         
     def generate_result_code(self, code):
+        if self.type.is_error: return
         if self.keyword_args and self.starstar_arg:
             code.put_error_if_neg(self.pos, 
                 "PyDict_Update(%s, %s)" % (

Cython/Compiler/ModuleNode.py

@@ -573,6 +573,7 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode):
         code.putln('static PyObject *%s;' % env.module_cname)
         code.putln('static PyObject *%s;' % Naming.builtins_cname)
         code.putln('static PyObject *%s;' % Naming.empty_tuple)
+        code.putln('static PyObject *%s;' % Naming.empty_bytes)
         if Options.pre_import is not None:
             code.putln('static PyObject *%s;' % Naming.preimport_cname)
         code.putln('static int %s;' % Naming.lineno_cname)
@@ -588,8 +589,6 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode):
             code.putln('static char %s[] = "%s";' % (
                     env.doc_cname, escape_byte_string(docstr)))
 
-        env.use_utility_code(streq_utility_code)
-
         # XXX this is a mess
         for utility_code in PyrexTypes.c_int_from_py_function.specialize_list:
             env.use_utility_code(utility_code)
@@ -1556,6 +1555,7 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode):
         code.putln("static void %s(void); /*proto*/" % Naming.fileinit_cname)
         
     def generate_import_star(self, env, code):
+        env.use_utility_code(streq_utility_code)
         code.putln()
         code.putln("char* %s_type_names[] = {" % Naming.import_star)
         for name, entry in env.entries.items():
@@ -1648,6 +1648,11 @@ class ModuleNode(Nodes.Node, Nodes.BlockNode):
         code.putln("#endif")
 
         code.putln("%s = PyTuple_New(0); %s" % (Naming.empty_tuple, code.error_goto_if_null(Naming.empty_tuple, self.pos)));
+        code.putln("#if PY_MAJOR_VERSION < 3");
+        code.putln("%s = PyString_FromStringAndSize(\"\", 0); %s" % (Naming.empty_bytes, code.error_goto_if_null(Naming.empty_bytes, self.pos)));
+        code.putln("#else");
+        code.putln("%s = PyBytes_FromStringAndSize(\"\", 0); %s" % (Naming.empty_bytes, code.error_goto_if_null(Naming.empty_bytes, self.pos)));
+        code.putln("#endif");
 
         code.putln("/*--- Library function declarations ---*/")
         env.generate_library_function_declarations(code)
@@ -2475,6 +2480,7 @@ static __Pyx_RefnannyAPIStruct *__Pyx_Refnanny = NULL;
 #define __Pyx_XGOTREF(r) if((r) == NULL) ; else __Pyx_GOTREF(r)
 """)
 
+
 main_method = UtilityCode(
 impl = """
 #if PY_MAJOR_VERSION < 3 || (!defined(WIN32) && !defined(MS_WINDOWS))

Cython/Compiler/Naming.py

@@ -74,6 +74,7 @@ c_api_tab_cname  = pyrex_prefix + "c_api_tab"
 gilstate_cname   = pyrex_prefix + "state"
 skip_dispatch_cname = pyrex_prefix + "skip_dispatch"
 empty_tuple      = pyrex_prefix + "empty_tuple"
+empty_bytes      = pyrex_prefix + "empty_bytes"
 print_function   = pyrex_prefix + "print"
 print_function_kwargs   = pyrex_prefix + "print_kwargs"
 cleanup_cname    = pyrex_prefix + "module_cleanup"
@@ -83,6 +84,8 @@ import_star      = pyrex_prefix + "import_star"
 import_star_set  = pyrex_prefix + "import_star_set"
 cur_scope_cname  = pyrex_prefix + "cur_scope"
 enc_scope_cname  = pyrex_prefix + "enc_scope"
+frame_cname      = pyrex_prefix + "frame"
+frame_code_cname = pyrex_prefix + "frame_code"
 
 line_c_macro = "__LINE__"
 

Cython/Compiler/Options.py

@@ -67,10 +67,11 @@ option_defaults = {
     'wraparound' : True,
     'c99_complex' : False, # Don't use macro wrappers for complex arith, not sure what to name this...
     'callspec' : "",
+    'profile': None,
 }
 
 # Override types possibilities above, if needed
-option_types = { }
+option_types = { 'profile': bool }
 
 for key, val in option_defaults.items():
     if key not in option_types:

Cython/Compiler/ParseTreeTransforms.py

@@ -625,12 +625,6 @@ property NAME:
         ATTR = value
     """, level='c_class')
 
-    readonly_property = TreeFragment(u"""
-property NAME:
-    def __get__(self):
-        return ATTR
-    """, level='c_class')
-    
     def __call__(self, root):
         self.env_stack = [root.scope]
         # needed to determine if a cdef var is declared after it's used.
@@ -707,7 +701,7 @@ property NAME:
             # mechanism for them. 
             stats = []
             for entry in node.need_properties:
-                property = self.create_Property(entry, node.visibility == 'readonly')
+                property = self.create_Property(entry)
                 property.analyse_declarations(node.dest_scope)
                 self.visit(property)
                 stats.append(property)
@@ -715,11 +709,8 @@ property NAME:
         else:
             return None
             
-    def create_Property(self, entry, readonly):
-        if readonly:
-            template = self.readonly_property
-        else:
-            template = self.basic_property
+    def create_Property(self, entry):
+        template = self.basic_property
         property = template.substitute({
                 u"ATTR": AttributeNode(pos=entry.pos,
                                        obj=NameNode(pos=entry.pos, name="self"), 

Cython/Compiler/PyrexTypes.py

@@ -170,6 +170,19 @@ class CTypedefType(BaseType):
         self.typedef_cname = cname
         self.typedef_base_type = base_type
         self.typedef_is_external = is_external
+
+        # Make typecodes in external typedefs use typesize-neutral macros
+        if is_external:
+            typecode = None
+            if base_type.is_int:
+                if base_type.signed == 0:
+                    typecode = "__Pyx_T_UNSIGNED_INT"
+                else:
+                    typecode = "__Pyx_T_SIGNED_INT"
+            elif base_type.is_float and not rank_to_type_name[base_type.rank] == "long double":
+                typecode = "__Pyx_T_FLOATING"
+            if typecode:
+                self.pymemberdef_typecode = "%s(%s)" % (typecode, cname)
     
     def resolve(self):
         return self.typedef_base_type.resolve()
@@ -814,13 +827,14 @@ static %(type)s __pyx_PyObject_As_%(type_name)s(PyObject* o); /* proto */
 """, 
 impl="""
 static %(type)s __pyx_PyObject_As_%(type_name)s(PyObject* o) {
-    if (PyComplex_Check(o)) {
+    if (PyComplex_CheckExact(o)) {
         return %(type_name)s_from_parts(
             (%(real_type)s)((PyComplexObject *)o)->cval.real,
             (%(real_type)s)((PyComplexObject *)o)->cval.imag);
     }
     else {
-        return %(type_name)s_from_parts(%(type_convert)s(o), 0);
+        Py_complex cval = PyComplex_AsCComplex(o);
+        return %(type_name)s_from_parts((%(real_type)s)cval.real, (%(real_type)s)cval.imag);
     }
 }
 """)
@@ -1726,6 +1740,40 @@ static INLINE PyObject* __Pyx_PyNumber_Int(PyObject* x);
 #endif
 #endif
 
+
+#if !defined(T_ULONGLONG)
+#define __Pyx_T_UNSIGNED_INT(x) \\
+        ((sizeof(x) == sizeof(unsigned char))  ? T_UBYTE : \\
+        ((sizeof(x) == sizeof(unsigned short)) ? T_USHORT : \\
+        ((sizeof(x) == sizeof(unsigned int))   ? T_UINT : \\
+        ((sizeof(x) == sizeof(unsigned long))  ? T_ULONG : -1))))
+#else
+#define __Pyx_T_UNSIGNED_INT(x) \\
+        ((sizeof(x) == sizeof(unsigned char))  ? T_UBYTE : \\
+        ((sizeof(x) == sizeof(unsigned short)) ? T_USHORT : \\
+        ((sizeof(x) == sizeof(unsigned int))   ? T_UINT : \\
+        ((sizeof(x) == sizeof(unsigned long))  ? T_ULONG : \\
+        ((sizeof(x) == sizeof(unsigned PY_LONG_LONG)) ? T_ULONGLONG : -1)))))
+#endif
+#if !defined(T_LONGLONG)
+#define __Pyx_T_SIGNED_INT(x) \\
+        ((sizeof(x) == sizeof(char))  ? T_BYTE : \\
+        ((sizeof(x) == sizeof(short)) ? T_SHORT : \\
+        ((sizeof(x) == sizeof(int))   ? T_INT : \\
+        ((sizeof(x) == sizeof(long))  ? T_LONG : -1))))
+#else
+#define __Pyx_T_SIGNED_INT(x) \\
+        ((sizeof(x) == sizeof(char))  ? T_BYTE : \\
+        ((sizeof(x) == sizeof(short)) ? T_SHORT : \\
+        ((sizeof(x) == sizeof(int))   ? T_INT : \\
+        ((sizeof(x) == sizeof(long))  ? T_LONG : \\
+        ((sizeof(x) == sizeof(PY_LONG_LONG))   ? T_LONGLONG : -1)))))
+#endif
+
+#define __Pyx_T_FLOATING(x) \\
+        ((sizeof(x) == sizeof(float)) ? T_FLOAT : \\
+        ((sizeof(x) == sizeof(double)) ? T_DOUBLE : -1))
+
 #if !defined(T_SIZET)
 #if !defined(T_ULONGLONG)
 #define T_SIZET \\

Cython/Compiler/Symtab.py

@@ -1583,8 +1583,14 @@ static PyObject* __Pyx_Method_ClassMethod(PyObject *method); /*proto*/
 impl = """
 static PyObject* __Pyx_Method_ClassMethod(PyObject *method) {
     /* It appears that PyMethodDescr_Type is not anywhere exposed in the Python/C API */
-    /* if (!PyObject_TypeCheck(method, &PyMethodDescr_Type)) { */ 
-    if (__Pyx_StrEq(Py_TYPE(method)->tp_name, "method_descriptor")) { /* cdef classes */
+    static PyTypeObject *methoddescr_type = NULL;
+    if (methoddescr_type == NULL) {
+       PyObject *meth = __Pyx_GetAttrString((PyObject*)&PyList_Type, "append");
+       if (!meth) return NULL;
+       methoddescr_type = Py_TYPE(meth);
+       Py_DECREF(meth);
+    }
+    if (PyObject_TypeCheck(method, methoddescr_type)) { /* cdef classes */
         PyMethodDescrObject *descr = (PyMethodDescrObject *)method;
         return PyDescr_NewClassMethod(descr->d_type, descr->d_method);
     }

Cython/Includes/__cython__.pxd

-cdef extern from "Python.h":
-    ctypedef struct PyObject
-
-
-
-    ctypedef struct Py_buffer:
-        void *buf
-        Py_ssize_t len
-        int readonly
-        char *format
-        int ndim
-        Py_ssize_t *shape
-        Py_ssize_t *strides
-        Py_ssize_t *suboffsets
-        Py_ssize_t itemsize
-        void *internal
-
-    
-    int PyObject_GetBuffer(PyObject* obj, Py_buffer* view, int flags) except -1
-    void PyObject_ReleaseBuffer(PyObject* obj, Py_buffer* view)
-
-    void PyErr_Format(int, char*, ...)
-
-    enum:
-        PyExc_TypeError
-
-#                  int PyObject_GetBuffer(PyObject *obj, Py_buffer *view,
-#                       int flags)

Cython/Includes/python_version.pxd

@@ -28,5 +28,5 @@ cdef extern from *:
     #    0xC (release candidate)
     #    0xF (final)
 
-    char[] PY_VERSION
-    char[] PY_PATCHLEVEL_REVISION
+    char PY_VERSION[]
+    char PY_PATCHLEVEL_REVISION[]

Demos/freeze/Makefile

+CC = gcc
+CYTHON = ./../bin/cython
+CYTHON_FREEZE = ../../bin/cython_freeze.py
+
+CFLAGS = -fPIC -g -O2 -Wall -Wextra
+CPPFLAGS = -I /usr/include/python2.6
+LDFLAGS = -Xlinker -export-dynamic -Wl,-O1 -Wl,-Bsymbolic-functions
+LDLIBS = /usr/lib/python2.6/config/libpython2.6.a \
+	-lm -ldl -pthread -lutil -lz
+
+
+# Name of executable
+TARGET = nCr
+
+# List of Cython source files, with main module first.
+CYTHON_SOURCE = combinatorics.pyx cmath.pyx
+
+
+all : $(TARGET)
+
+$(TARGET) : $(TARGET).o $(CYTHON_SOURCE:.pyx=.o)
+
+$(TARGET).c :
+	$(CYTHON_FREEZE) $(CYTHON_SOURCE:.pyx=) > $@
+
+%.c : %.pyx
+	$(CYTHON) $(CYTHONFLAGS) $^
+
+clean:
+	$(RM) *.o *.c $(TARGET)
+
+.PHONY: clean
+.SECONDARY: $(CYTHON_SOURCE:.pyx=.c)

Demos/freeze/README.rst

+NAME
+====
+
+cython_freeze.py - create a C file for embedding Cython modules
+
+
+SYNOPSIS
+========
+
+cython_freeze.py module [...]
+
+
+DESCRIPTION
+===========
+
+**cython_freeze.py** generates a C source file to embed a Python interpreter
+with one or more Cython modules built in.  This allows one to create a single
+executable from Cython code, without having to have separate shared objects
+for each Cython module.
+
+A major advantage of this approach is that it allows debuging with gprof(1),
+which does not work with shared objects.
+
+Note that this method differs from ``cython --embed``.  The ``--embed`` options
+modifies the resulting C source file to include a ``main()`` function, so it
+can only be used on a single Cython module.  The advantage ``--embed`` is
+simplicity.  This module, on the other hand, can be used with multiple
+modules, but it requires another C source file to be created.
+
+
+EXAMPLE
+=======
+
+In the example directory, there exist two Cython modules:
+
+cmath.pyx
+    A module that interfaces with the -lm library.
+
+combinatorics.pyx
+    A module that implements n-choose-r using cmath.
+
+Both modules have the Python idiom ``if __name__ == "__main__"``, which only
+execute if that module is the "main" module.  If run as main, cmath prints the
+factorial of the argument, while combinatorics prints n-choose-r.
+
+The provided Makefile creates an executable, *nCr*, using combinatorics as the
+"main" module.  It basically performs the following (ignoring the compiler
+flags)::
+
+    $ cython_freeze.py combintorics cmath > nCr.c
+    $ cython combinatorics.pyx
+    $ cython cmath.pyx
+    $ gcc nCr.c -o nCr.o
+    $ gcc combinatorics.c -o combinatorics.o
+    $ gcc cmath.c -o cmath.o
+    $ gcc nCr.o combinatorics.o cmath.o -o nCr
+
+Because the combinatorics module was listed first, its ``__name__`` is set
+to ``"__main__"``, while cmath's is set to ``"cmath"``.  The executable now
+contains a Python interpreter and both Cython modules. ::
+
+    $ ./nCr
+    USAGE: ./nCr n r
+    Prints n-choose-r.
+    $ ./nCr 15812351235 12
+    5.10028093999e+113
+
+
+
+
+PREREQUISITES
+=============
+
+Cython 0.11.2 (or newer, assuming the API does not change)
+
+
+SEE ALSO
+========
+
+* `Python <http://www.python.org>`_
+* `Cython <http://www.cython.org>`_
+* `freeze.py <http://wiki.python.org/moin/Freeze>`_

Demos/freeze/cmath.pyx

+cdef extern from "math.h":
+    double c_lgamma "lgamma" (double)
+    double c_exp "exp" (double)
+
+def exp(n):
+    """Return e**n."""
+    return c_exp(n)
+
+def lfactorial(n):
+    """Return an estimate of the log factorial of n."""
+    return c_lgamma(n+1)
+
+def factorial(n):
+    """Return an estimate of the factorial of n."""
+    return c_exp( c_lgamma(n+1) )
+
+
+if __name__ == "__main__":
+    import sys
+    if len(sys.argv) != 2:
+        sys.stderr.write("USAGE: %s n\nPrints n!.\n" % sys.argv[0])
+        sys.exit(1)
+    n = map(float, sys.argv[1:])
+    print factorial(n)

Demos/freeze/combinatorics.pyx

+import cmath
+
+def nCr(n, r):
+    """Return the number of ways to choose r elements of a set of n."""
+    return cmath.exp( cmath.lfactorial(n) - cmath.lfactorial(r)
+                      - cmath.lfactorial(n-r) )
+
+if __name__ == "__main__":
+    import sys
+    if len(sys.argv) != 3:
+        sys.stderr.write("USAGE: %s n r\nPrints n-choose-r.\n" % sys.argv[0])
+        sys.exit(1)
+    n, r = map(float, sys.argv[1:])
+    print nCr(n, r)

Demos/setup.py

@@ -4,6 +4,12 @@ from distutils.core import setup
 from distutils.extension import Extension
 from Cython.Distutils import build_ext
 
+try:
+    from numpy.distutils.misc_util import get_numpy_include_dirs
+    numpy_include_dirs = get_numpy_include_dirs()
+except:
+    numpy_include_dirs = []
+
 ext_modules=[ 
     Extension("primes",       ["primes.pyx"]),
     Extension("spam",         ["spam.pyx"]),
@@ -11,7 +17,7 @@ ext_modules=[
 
 for file in glob.glob("*.pyx"):
     if file != "numeric_demo.pyx":
-        ext_modules.append(Extension(file[:-4], [file]))
+        ext_modules.append(Extension(file[:-4], [file], include_dirs = numpy_include_dirs))
 
 setup(
   name = 'Demos',

bin/cython_freeze.py

+#!/usr/bin/env python
+"""
+Create a C file for embedding one or more Cython source files.
+Requires Cython 0.11.2 (or perhaps newer).
+
+See README.rst for more details.
+"""
+
+import sys
+
+if len(sys.argv) < 2:
+    print >>sys.stderr, "USAGE: %s module [module ...]" % sys.argv[0]
+    sys.exit(1)
+
+def format_modname(name):
+    if name.endswith('.pyx'):
+        name = name[:-4]
+    return name.replace('.','_')
+
+modules = [format_modname(x) for x in sys.argv[1:]]
+
+print """
+#include <Python.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#if PY_MAJOR_VERSION < 3
+# define MODINIT(name)  init ## name
+#else
+# define MODINIT(name)  PyInit_ ## name
+#endif
+"""
+
+for name in modules:
+    print "PyMODINIT_FUNC MODINIT(%s) (void);" % name
+
+print """
+static struct _inittab inittab[] = {"""
+
+for name in modules:
+    print '    {"%(name)s", MODINIT(%(name)s)},' % {'name' : name}
+
+print """    {NULL, NULL}
+};
+
+extern int __pyx_module_is_main_%(main)s;
+
+#if PY_MAJOR_VERSION < 3 || (!defined(WIN32) && !defined(MS_WINDOWS))
+int main(int argc, char** argv) {
+#else
+int wmain(int argc, wchar_t **argv) {
+#endif
+    int r = 0;
+    PyObject *m = NULL;
+    if (PyImport_ExtendInittab(inittab)) {
+        fprintf(stderr, "No memory\\n");
+        exit(1);
+    }
+    Py_SetProgramName(argv[0]);
+    Py_Initialize();
+    PySys_SetArgv(argc, argv);
+    __pyx_module_is_main_%(main)s = 1;
+    m = PyImport_ImportModule(inittab[0].name);
+    if (!m) {
+        r = 1;
+        PyErr_Print(); /* This exits with the right code if SystemExit. */
+        if (Py_FlushLine()); PyErr_Clear();
+    }
+    Py_XDECREF(m);
+    Py_Finalize();
+    return r;
+}
+""" % {'main' : modules[0]}

tests/bugs.txt

@@ -14,3 +14,6 @@ large_consts_T237
 bad_c_struct_T252
 missing_baseclass_in_predecl_T262
 ifelseexpr_T267
+
+# Not yet enabled
+profile_test

tests/compile/shipped_pxds.pyx

+cimport python_bool
+cimport python_buffer
+cimport python_complex
+cimport python_dict
+cimport python_exc
+cimport python_float
+cimport python_function
+cimport python_instance
+cimport python_int
+cimport python_iterator
+cimport python_list
+cimport python_long
+cimport python_mapping
+cimport python_mem
+cimport python_method
+cimport python_module
+cimport python_number
+cimport python_object
+cimport python_parse
+cimport python
+cimport python_ref
+cimport python_sequence
+cimport python_set
+cimport python_string
+cimport python_tuple
+cimport python_type
+cimport python_unicode
+cimport python_version
+cimport stdio
+cimport stdlib

tests/errors/callingnonexisting_T307.pyx

+nonexisting(3, with_kw_arg=4)
+
+_ERRORS = u"""
+1:11: undeclared name not builtin: nonexisting
+"""

tests/run/delete.pyx

@@ -4,6 +4,21 @@
 [2, 1]
 >>> a.g()
 (False, True)
+>>> del_item({1: 'a', 2: 'b'}, 1)
+{2: 'b'}
+>>> del_item(range(10), 2)
+[0, 1, 3, 4, 5, 6, 7, 8, 9]
+
+>>> del_dict({1: 'a', 2: 'b'}, 1)
+{2: 'b'}
+>>> del_list(range(5), 3)
+[0, 1, 2, 4]
+>>> del_int(range(5), 3)
+[0, 1, 2, 4]
+>>> del_list_int(range(5), 3)
+[0, 1, 2, 4]
+>>> del_int({-1: 'neg', 1: 'pos'}, -1)
+{1: 'pos'}
 """
 
 class A:
@@ -16,3 +31,23 @@ class A:
         self.a = 3
         del self.a
         return (hasattr(self, u"a"), hasattr(self, u"g"))
+
+def del_item(L, o):
+    del L[o]
+    return L
+
+def del_dict(dict D, o):
+    del D[o]
+    return D
+
+def del_list(list L, o):
+    del L[o]
+    return L
+
+def del_int(L, int i):
+    del L[i]
+    return L
+
+def del_list_int(L, int i):
+    del L[i]
+    return L

tests/run/external_defs.h

 
-
+typedef float FloatTypedef;
 typedef double DoubleTypedef;
+typedef long double LongDoubleTypedef;
+
+typedef char CharTypedef;
+typedef short ShortTypedef;
+typedef int IntTypedef;
+typedef long LongTypedef;
+#if defined(T_LONGLONG)
+typedef PY_LONG_LONG LongLongTypedef;
+#else
+typedef long LongLongTypedef;
+#endif
+
+typedef unsigned char UCharTypedef;
+typedef unsigned short UShortTypedef;
+typedef unsigned int UIntTypedef;
+typedef unsigned long ULongTypedef;
+#if defined(T_LONGLONG)
+typedef unsigned PY_LONG_LONG ULongLongTypedef;
+#else
+typedef unsigned long ULongLongTypedef;
+#endif

tests/run/hash_T326.pyx

+__doc__ = u"""
+
+    >>> hash(A(5))
+    5
+    >>> hash(A(-1))
+    -2
+    >>> hash(A(-2))
+    -2
+    >>> hash(A(100))
+    Traceback (most recent call last):
+    ...
+    TypeError: That's kind of a round number...
+    
+    >>> __hash__(-1)
+    -1
+"""
+
+cdef class A:
+    cdef long a
+    def __init__(self, a):
+        self.a = a
+    def __hash__(self):
+        if self.a == 100:
+            raise TypeError, "That's kind of a round number..."
+        else:
+            return self.a
+
+cpdef long __hash__(long x):
+    return x

tests/run/numpy_test.pyx

@@ -194,6 +194,11 @@ try:
     Traceback (most recent call last):
         ...
     ValueError: Item size of buffer (1 byte) does not match size of 'int' (4 bytes)
+
+    >>> test_complextypes()
+    1,1
+    1,1
+    8,16
     
 """
 except:
@@ -376,3 +381,15 @@ def test_unpacked_align(np.ndarray[UnpackedStruct] arr):
     arr[0].a = 22
     arr[0].b = 23    
     return repr(arr).replace('<', '!').replace('>', '!')
+
+def test_complextypes():
+    cdef np.complex64_t x64 = 1, y64 = 1j
+    cdef np.complex128_t x128 = 1, y128 = 1j
+    x64 = x64 + y64
+    print "%.0f,%.0f" % (x64.real, x64.imag)
+    x128 = x128 + y128
+    print "%.0f,%.0f" % (x128.real, x128.imag)
+    print "%d,%d" % (sizeof(x64), sizeof(x128))
+
+
+    

tests/run/profile_test.pyx

+__doc__ = u"""
+    >>> import os, tempfile, cProfile as profile, pstats
+    >>> statsfile = tempfile.mkstemp()[1]
+    >>> profile.runctx("test_profile(100)", locals(), globals(), statsfile)
+    >>> s = pstats.Stats(statsfile)
+    >>> short_stats = dict([(k[2], v[1]) for k,v in s.stats.items()])
+    >>> short_stats['f_def']
+    100
+    >>> short_stats['f_cdef']
+    100
+    >>> short_stats['f_inline']
+    Traceback (most recent call last):
+    ...
+    KeyError: 'f_inline'
+    >>> short_stats['f_inline_prof']
+    100
+    >>> short_stats['f_noprof']
+    Traceback (most recent call last):
+    ...
+    KeyError: 'f_noprof'
+    >>> short_stats['f_raise']
+    100
+    >>> os.unlink(statsfile)
+"""
+
+cimport cython
+
+def test_profile(long N):
+    cdef long i, n = 0
+    for i from 0 <= i < N:
+        n += f_def(i)
+        n += f_cdef(i)
+        n += f_inline(i)
+        n += f_inline_prof(i)
+        n += f_noprof(i)
+        try:
+            n += f_raise(i+2)
+        except RuntimeError:
+            pass
+    return n
+
+def f_def(long a):
+    return a
+
+cdef long f_cdef(long a):
+    return a
+
+cdef inline long f_inline(long a):
+    return a
+
+@cython.profile(True)
+cdef inline long f_inline_prof(long a):
+    return a
+
+@cython.profile(False)
+cdef int f_noprof(long a):
+    return a
+
+cdef long f_raise(long) except -2:
+    raise RuntimeError

tests/run/typedfieldbug_T303.pyx

 """
 >>> f()
-42.0 42.0 42.0
+42.0
+42.0
+>>> global_vars(12.0)
+12.0 12.0
 >>> readonly()
 Traceback (most recent call last):
     ...
-AttributeError: attribute 'var_nf' of 'typedfieldbug_T303.MyClass' objects is not writable
+TypeError: readonly attribute
+>>> longdouble_access()
+Traceback (most recent call last):
+    ...
+SystemError: bad memberdescr type
+
 """
 
 cdef extern from "external_defs.h":
     ctypedef float DoubleTypedef
+    ctypedef float LongDoubleTypedef
+
+cdef public DoubleTypedef global_tdef
+cdef public double global_double
 
 cdef class MyClass:
     cdef readonly:
-        double var_d
-        DoubleTypedef var_nf
-    cdef public:
-        DoubleTypedef var_mutable
+        double actual_double
+        DoubleTypedef float_isreally_double
+        LongDoubleTypedef float_isreally_longdouble
+        
     def __init__(self):
-        self.var_d = 42.0
-        self.var_nf = 42.0
-        self.var_mutable = 1
+        self.actual_double = 42.0
+        self.float_isreally_double = 42.0
+        self.float_isreally_longdouble = 42.0
+
+def global_vars(x):
+    global global_tdef, global_double
+    global_tdef = x
+    global_double = x
+    print global_tdef, global_double
 
 def f():
     c = MyClass()
-    c.var_mutable = 42.0
-    print c.var_d, c.var_nf, c.var_mutable
+    print c.actual_double
+    print c.float_isreally_double
+
+def longdouble_access():
+    c = MyClass()
+    print c.float_isreally_longdouble
+
 
 def readonly():
     c = MyClass()
-    c.var_nf = 3
+    c.actual_double = 3
+