Merge in latest release.

.hgtags

@@ -14,3 +14,4 @@ a4abf0156540db4d3ebaa95712b65811c43c5acb 0.11-beta
 7bc36a0f81723117a19f92ffde1676a0884fef65 0.11.1.beta
 6454db601984145f38e28d34176fca8a3a22329c 0.11.1
 af6f1bed8cd40a2edefb57d3eacbc9274a8788b4 0.11.2.rc1
+15ad532e2127840ae09dfbe46ccc80ac8c562f99 0.11.2

Cython/Compiler/Nodes.py

@@ -801,25 +801,18 @@ class CVarDefNode(StatNode):
         self.dest_scope = dest_scope
         base_type = self.base_type.analyse(env)
 
-        need_property = False
+        # If the field is an external typedef, we cannot be sure about the type,
+        # so do conversion ourself rather than rely on the CPython mechanism (through
+        # a property; made in AnalyseDeclarationsTransform).
         if (dest_scope.is_c_class_scope
-              and self.visibility == 'public'
-              and base_type.is_pyobject
-              and (base_type.is_builtin_type or base_type.is_extension_type)):
-            # If the field is settable and extension type, then the CPython mechanism does
-            # not do enough type-checking for us.
-            need_property = True
-        elif (base_type.is_typedef and base_type.typedef_is_external
-              and (self.visibility in ('public', 'readonly'))):
-            # If the field is an external typedef, we cannot be sure about the type,
-            # so do conversion ourself rather than rely on the CPython mechanism (through
-            # a property; made in AnalyseDeclarationsTransform).
+                and self.visibility == 'public' 
+                and base_type.is_pyobject 
+                and (base_type.is_builtin_type or base_type.is_extension_type)):
+            self.need_properties = []
             need_property = True
-
-        if need_property:
             visibility = 'private'
-            self.need_properties = []
         else:
+            need_property = False
             visibility = self.visibility
             
         for declarator in self.declarators:

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

@@ -171,6 +171,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()
@@ -831,8 +844,10 @@ proto="""
 #if __PYX_USE_C99_COMPLEX
 
     typedef %(real_type)s _Complex %(type_name)s;
-    #define %(type_name)s_from_parts(x, y) ((x) + (y)*(%(type)s)_Complex_I)
-
+    static INLINE %(type)s %(type_name)s_from_parts(%(real_type)s x, %(real_type)s y) {
+      return x + y*(%(type)s)_Complex_I;
+    }
+    
     #define %(type_name)s_is_zero(a) ((a) == 0)
     #define %(type_name)s_eq(a, b) ((a) == (b))
     #define %(type_name)s_add(a, b) ((a)+(b))
@@ -844,8 +859,10 @@ proto="""
 #else
 
     typedef struct { %(real_type)s real, imag; } %(type_name)s;
-    #define %(type_name)s_from_parts(x, y) ((%(type_name)s){(%(real_type)s)x, (%(real_type)s)y})
-
+    static INLINE %(type)s %(type_name)s_from_parts(%(real_type)s x, %(real_type)s y) {
+      %(type)s c; c.real = x; c.imag = y; return c;
+    }
+    
     static INLINE int %(type_name)s_is_zero(%(type)s a) {
        return (a.real == 0) & (a.imag == 0);
     }
@@ -1774,6 +1791,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/Version.py

-version = '0.11.2.rc1'
+version = '0.11.2'

Cython/TestUtils.py

@@ -38,6 +38,15 @@ def treetypes(root):
 
 class CythonTest(unittest.TestCase):
 
+    def setUp(self):
+        self.listing_file = Errors.listing_file
+        self.echo_file = Errors.echo_file
+        Errors.listing_file = Errors.echo_file = None
+ 
+    def tearDown(self):
+        Errors.listing_file = self.listing_file
+        Errors.echo_file = self.echo_file
+ 
     def assertLines(self, expected, result):
         "Checks that the given strings or lists of strings are equal line by line"
         if not isinstance(expected, list): expected = expected.split(u"\n")

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/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
+