From 2fe3ae06243fe0ca8528c58f62c73a558c0004c4 Mon Sep 17 00:00:00 2001 From: Robert Bradshaw Date: Sat, 15 Aug 2009 18:36:50 -0700 Subject: [PATCH] Working stl vector. --- Cython/Compiler/Nodes.py | 4 ++-- Cython/Compiler/Parsing.py | 4 +--- Cython/Compiler/PyrexTypes.py | 30 ++++++++++++++++++++++++++---- Cython/Compiler/Symtab.py | 18 +++++++++--------- 4 files changed, 38 insertions(+), 18 deletions(-) diff --git a/Cython/Compiler/Nodes.py b/Cython/Compiler/Nodes.py index 4377db7e..ff316178 100644 --- a/Cython/Compiler/Nodes.py +++ b/Cython/Compiler/Nodes.py @@ -944,7 +944,7 @@ class CppClassNode(CStructOrUnionDefNode): def analyse_declarations(self, env): scope = None if len(self.attributes) != 0: - scope = CppClassScope(self.name) + scope = CppClassScope(self.name, env) else: self.attributes = None base_class_types = [] @@ -968,7 +968,7 @@ class CppClassNode(CStructOrUnionDefNode): if self.in_pxd and not env.in_cinclude: self.entry.defined_in_pxd = 1 for attr in self.attributes: - attr.analyse_declarations(env, scope) + attr.analyse_declarations(scope) class CEnumDefNode(StatNode): # name string or None diff --git a/Cython/Compiler/Parsing.py b/Cython/Compiler/Parsing.py index 173133a3..6e7044f5 100644 --- a/Cython/Compiler/Parsing.py +++ b/Cython/Compiler/Parsing.py @@ -2602,8 +2602,6 @@ def p_cpp_class_definition(s, pos, ctx): s.next() s.expect(']') base_classes = [] - objstruct_name = None - typeobj_name = None if s.sy == '(': base_class = True while (base_class): @@ -2626,7 +2624,7 @@ def p_cpp_class_definition(s, pos, ctx): s.expect('NEWLINE') s.expect_indent() attributes = [] - body_ctx = Ctx() + body_ctx = Ctx(visibility = ctx.visibility) body_ctx.templates = templates while s.sy != 'DEDENT': if s.sy != 'pass': diff --git a/Cython/Compiler/PyrexTypes.py b/Cython/Compiler/PyrexTypes.py index 017e7010..01fba6a5 100755 --- a/Cython/Compiler/PyrexTypes.py +++ b/Cython/Compiler/PyrexTypes.py @@ -1242,7 +1242,23 @@ class CFuncType(CType): def signature_cast_string(self): s = self.declaration_code("(*)", with_calling_convention=False) return '(%s)' % s - + + def specialize(self, values): + if self.templates is None: + new_templates = None + else: + new_templates = [v.specialize(values) for v in self.templates] + return CFuncType(self.return_type.specialize(values), + [arg.specialize(values) for arg in self.args], + has_varargs = 0, + exception_value = self.exception_value, + exception_check = self.exception_check, + calling_convention = self.calling_convention, + nogil = self.nogil, + with_gil = self.with_gil, + is_overridable = self.is_overridable, + optional_arg_count = self.optional_arg_count, + templates = new_templates) class CFuncTypeArg(object): # name string @@ -1266,6 +1282,9 @@ class CFuncTypeArg(object): def declaration_code(self, for_display = 0): return self.type.declaration_code(self.cname, for_display) + + def specialize(self, values): + return CFuncTypeArg(self.name, self.type.specialize(values), self.pos, self.cname) class CStructOrUnionType(CType): @@ -1736,9 +1755,12 @@ modifiers_and_name_to_type = { } def is_promotion(type, other_type): - return (type.is_int and type.is_int and type.signed == other_type.signed) \ - or (type.is_float and other_type.is_float) \ - or (type.is_enum and other_type.is_int) + if type.is_numeric and other_type.is_numeric: + return (type.is_int and type.is_int and type.signed == other_type.signed) \ + or (type.is_float and other_type.is_float) \ + or (type.is_enum and other_type.is_int) + else: + return False def best_match(args, functions, pos): actual_nargs = len(args) diff --git a/Cython/Compiler/Symtab.py b/Cython/Compiler/Symtab.py index 9fc15ef3..54387934 100644 --- a/Cython/Compiler/Symtab.py +++ b/Cython/Compiler/Symtab.py @@ -1137,7 +1137,11 @@ class ModuleScope(Scope): entry.type.scope = scope self.type_entries.append(entry) if not scope and not entry.type.scope: - entry.type.scope = CppClassScope(name) + entry.type.scope = CppClassScope(name, self) + if templates is not None: + for T in templates: + template_entry = entry.type.scope.declare(T.name, T.name, T, None, 'extern') + template_entry.is_type = 1 def declare_inherited_attributes(entry, base_classes): for base_class in base_classes: @@ -1604,8 +1608,9 @@ class CppClassScope(Scope): # Namespace of a C++ class. inherited_var_entries = [] - def __init__(self, name="?"): - Scope.__init__(self, name, None, None) + def __init__(self, name, outer_scope): + Scope.__init__(self, name, outer_scope, None) + self.directives = outer_scope.directives def declare_var(self, name, type, pos, cname = None, visibility = 'extern', is_cdef = 0, allow_pyobject = 0): @@ -1622,11 +1627,6 @@ class CppClassScope(Scope): "C++ class member cannot be a Python object") return entry - def declare_cfunction(self, name, type, pos, - cname = None, visibility = 'extern', defining = 0, - api = 0, in_pxd = 0, modifiers = ()): - entry = self.declare_var(name, type, pos, cname, visibility) - def declare_inherited_cpp_attributes(self, base_scope): # Declare entries for all the C++ attributes of an # inherited type, with cnames modified appropriately @@ -1644,7 +1644,7 @@ class CppClassScope(Scope): entry.is_inherited = 1 def specialize(self, values): - scope = CppClassScope() + scope = CppClassScope(self.name, self.outer_scope) for entry in self.entries.values(): scope.declare_var(entry.name, entry.type.specialize(values), -- 2.26.2