merge

Cython/Compiler/Nodes.py

+
 #
 #   Pyrex - Parse tree nodes
 #
@@ -494,7 +495,7 @@ class CReferenceDeclaratorNode(CDeclaratorNode):
         if base_type.is_pyobject:
             error(self.pos,
                   "Reference base type cannot be a Python object")
-        ref_type = Pyrextypes.c_ref_type(base_type)
+        ref_type = PyrexTypes.c_ref_type(base_type)
         return self.base.analyse(ref_type, env, nonempty = nonempty)
 
 class CArrayDeclaratorNode(CDeclaratorNode):

Cython/Compiler/Parsing.py

+
 # cython: auto_cpdef=True
 #
 #   Pyrex Parser
@@ -1749,9 +1750,6 @@ def p_c_simple_base_type(s, self_flag, nonempty, templates = None):
             if s.sy == 'IDENT' and s.systring in basic_c_type_names:
                 name = s.systring
                 s.next()
-                if s.sy == '&':
-                    s.next()
-                    #TODO (Danilo)
             else:
                 name = 'int'
         if s.sy == 'IDENT' and s.systring == 'complex':
@@ -1990,6 +1988,12 @@ def p_c_simple_declarator(s, ctx, empty, is_type, cmethod_flag,
         result = Nodes.CPtrDeclaratorNode(pos,
             base = Nodes.CPtrDeclaratorNode(pos,
                 base = base))
+    elif s.sy == '&':
+        s.next()
+        base = p_c_declarator(s, ctx, empty = empty, is_type = is_type,
+                              cmethod_flag = cmethod_flag,
+                              assignable = assignable, nonempty = nonempty)
+        result = Nodes.CReferenceDeclaratorNode(pos, base = base)
     else:
         rhs = None
         if s.sy == 'IDENT':

Cython/Compiler/PyrexTypes.py

@@ -91,6 +91,7 @@ class PyrexType(BaseType):
     is_array = 0
     is_ptr = 0
     is_null_ptr = 0
+    is_reference = 0
     is_cfunction = 0
     is_struct_or_union = 0
     is_cpp_class = 0
@@ -1031,18 +1032,29 @@ class CReferenceType(CType):
         return "<CReferenceType %s>" % repr(self.base_type)
 
     def same_as_resolved_type(self, other_type):
-        return self.base_type.same_as(other_type.base_type)
+        return other_type.is_reference and self.base_type.same_as(other_type.base_type)
     
     def declaration_code(self, entity_code, 
             for_display = 0, dll_linkage = None, pyrex = 0):
-        #print "CPtrType.declaration_code: pointer to", self.base_type ###
+        #print "CReferenceType.declaration_code: pointer to", self.base_type ###
         return self.base_type.declaration_code(
             "&%s" % entity_code,
             for_display, dll_linkage, pyrex)
     
     def assignable_from_resolved_type(self, other_type):
-        return 0 #TODO (Danilo) implement this
-    
+        if other_type is error_type:
+            return 1
+        if other_type.is_ptr:
+            if other_type.base_type == self.base_type:
+                return 1
+            else:
+                pass
+                #TODO: should send a warning message: initialization from incompatible pointer type (in C/C++)
+        if other_type == self.base_type:
+            return 1
+        else: #for now
+            return 0
+        
     def specialize(self, values):
         base_type = self.base_type.specialize(values)
         if base_type == self.base_type:
@@ -1797,6 +1809,10 @@ def is_promotion(type, other_type):
         return False
 
 def best_match(args, functions, pos):
+    """
+    Finds the best function to be called
+    Error if no function fits the call or an ambiguity is find (two or more possible functions)
+    """
     actual_nargs = len(args)
     possibilities = []
     bad_types = 0
@@ -1833,7 +1849,8 @@ def best_match(args, functions, pos):
             src_type = args[i].type
             dst_type = func_type.args[i].type
             if dst_type.assignable_from(src_type):
-                if src_type == dst_type:
+                #print src_type, src_type.is_pyobject, dst_type, dst_type.is_pyobject
+                if src_type == dst_type or (dst_type.is_reference and src_type == dst_type.base_type):
                     pass # score 0
                 elif is_promotion(src_type, dst_type):
                     score[2] += 1

Cython/Compiler/Symtab.py

@@ -316,7 +316,10 @@ class Scope(object):
         entry.in_cinclude = self.in_cinclude
         if name:
             entry.qualified_name = self.qualify_name(name)
-            entries[name] = entry
+            if name in entries and self.is_cpp():
+                entries[name].overloaded_alternatives.append(entry)
+            else:
+                entries[name] = entry
         entry.scope = self
         entry.visibility = visibility
         return entry
@@ -697,7 +700,11 @@ class Scope(object):
         return 0
     
     def is_cpp(self):
-        return self.outer_scope.is_cpp()
+        outer = self.outer_scope
+        if outer is None:
+            return False
+        else:
+            return outer.is_cpp()
 
 class PreImportScope(Scope):