Cython/Compiler/Nodes.py

   1
   2 #
   3 #   Pyrex - Parse tree nodes
   4 #
   5
   6 import cython
   7 from cython import set
   8 cython.declare(sys=object, os=object, time=object, copy=object,
   9                Builtin=object, error=object, warning=object, Naming=object, PyrexTypes=object,
  10                py_object_type=object, ModuleScope=object, LocalScope=object, ClosureScope=object, \
  11                StructOrUnionScope=object, PyClassScope=object, CClassScope=object,
  12                CppClassScope=object, UtilityCode=object, EncodedString=object,
  13                absolute_path_length=cython.Py_ssize_t)
  14
  15 import sys, os, time, copy
  16
  17 import Builtin
  18 from Errors import error, warning, InternalError
  19 import Naming
  20 import PyrexTypes
  21 import TypeSlots
  22 from PyrexTypes import py_object_type, error_type, CFuncType
  23 from Symtab import ModuleScope, LocalScope, ClosureScope, \
  24     StructOrUnionScope, PyClassScope, CClassScope, CppClassScope
  25 from Cython.Utils import open_new_file, replace_suffix
  26 from Code import UtilityCode
  27 from StringEncoding import EncodedString, escape_byte_string, split_string_literal
  28 import Options
  29 import ControlFlow
  30 import DebugFlags
  31
  32 absolute_path_length = 0
  33
  34 def relative_position(pos):
  35     """
  36     We embed the relative filename in the generated C file, since we
  37     don't want to have to regnerate and compile all the source code
  38     whenever the Python install directory moves (which could happen,
  39     e.g,. when distributing binaries.)
  40
  41     INPUT:
  42         a position tuple -- (absolute filename, line number column position)
  43
  44     OUTPUT:
  45         relative filename
  46         line number
  47
  48     AUTHOR: William Stein
  49     """
  50     global absolute_path_length
  51     if absolute_path_length==0:
  52         absolute_path_length = len(os.path.abspath(os.getcwd()))
  53     return (pos[0].get_filenametable_entry()[absolute_path_length+1:], pos[1])
  54
  55 def embed_position(pos, docstring):
  56     if not Options.embed_pos_in_docstring:
  57         return docstring
  58     pos_line = u'File: %s (starting at line %s)' % relative_position(pos)
  59     if docstring is None:
  60         # unicode string
  61         return EncodedString(pos_line)
  62
  63     # make sure we can encode the filename in the docstring encoding
  64     # otherwise make the docstring a unicode string
  65     encoding = docstring.encoding
  66     if encoding is not None:
  67         try:
  68             encoded_bytes = pos_line.encode(encoding)
  69         except UnicodeEncodeError:
  70             encoding = None
  71
  72     if not docstring:
  73         # reuse the string encoding of the original docstring
  74         doc = EncodedString(pos_line)
  75     else:
  76         doc = EncodedString(pos_line + u'\n' + docstring)
  77     doc.encoding = encoding
  78     return doc
  79
  80
  81 from Code import CCodeWriter
  82 from types import FunctionType
  83
  84 def write_func_call(func):
  85     def f(*args, **kwds):
  86         if len(args) > 1 and isinstance(args[1], CCodeWriter):
  87             # here we annotate the code with this function call
  88             # but only if new code is generated
  89             node, code = args[:2]
  90             marker = '                    /* %s -> %s.%s %s */' % (
  91                     ' ' * code.call_level,
  92                     node.__class__.__name__,
  93                     func.__name__,
  94                     node.pos[1:])
  95             pristine = code.buffer.stream.tell()
  96             code.putln(marker)
  97             start = code.buffer.stream.tell()
  98             code.call_level += 4
  99             res = func(*args, **kwds)
 100             code.call_level -= 4
 101             if start == code.buffer.stream.tell():
 102                 code.buffer.stream.seek(pristine)
 103             else:
 104                 marker = marker.replace('->', '<-')
 105                 code.putln(marker)
 106             return res
 107         else:
 108             return func(*args, **kwds)
 109     return f
 110
 111 class VerboseCodeWriter(type):
 112     # Set this as a metaclass to trace function calls in code.
 113     # This slows down code generation and makes much larger files.
 114     def __new__(cls, name, bases, attrs):
 115         attrs = dict(attrs)
 116         for mname, m in attrs.items():
 117             if isinstance(m, FunctionType):
 118                 attrs[mname] = write_func_call(m)
 119         return super(VerboseCodeWriter, cls).__new__(cls, name, bases, attrs)
 120
 121
 122 class Node(object):
 123     #  pos         (string, int, int)   Source file position
 124     #  is_name     boolean              Is a NameNode
 125     #  is_literal  boolean              Is a ConstNode
 126
 127     if DebugFlags.debug_trace_code_generation:
 128         __metaclass__ = VerboseCodeWriter
 129
 130     is_name = 0
 131     is_literal = 0
 132     temps = None
 133
 134     # All descandants should set child_attrs to a list of the attributes
 135     # containing nodes considered "children" in the tree. Each such attribute
 136     # can either contain a single node or a list of nodes. See Visitor.py.
 137     child_attrs = None
 138
 139     def __init__(self, pos, **kw):
 140         self.pos = pos
 141         self.__dict__.update(kw)
 142
 143     gil_message = "Operation"
 144
 145     nogil_check = None
 146
 147     def gil_error(self, env=None):
 148         error(self.pos, "%s not allowed without gil" % self.gil_message)
 149
 150     cpp_message = "Operation"
 151
 152     def cpp_check(self, env):
 153         if not env.is_cpp():
 154             self.cpp_error()
 155
 156     def cpp_error(self):
 157         error(self.pos, "%s only allowed in c++" % self.cpp_message)
 158
 159     def clone_node(self):
 160         """Clone the node. This is defined as a shallow copy, except for member lists
 161            amongst the child attributes (from get_child_accessors) which are also
 162            copied. Lists containing child nodes are thus seen as a way for the node
 163            to hold multiple children directly; the list is not treated as a seperate
 164            level in the tree."""
 165         result = copy.copy(self)
 166         for attrname in result.child_attrs:
 167             value = getattr(result, attrname)
 168             if isinstance(value, list):
 169                 setattr(result, attrname, [x for x in value])
 170         return result
 171
 172
 173     #
 174     #  There are 4 phases of parse tree processing, applied in order to
 175     #  all the statements in a given scope-block:
 176     #
 177     #  (0) analyse_control_flow
 178     #        Create the control flow tree into which state can be asserted and
 179     #        queried.
 180     #
 181     #  (1) analyse_declarations
 182     #        Make symbol table entries for all declarations at the current
 183     #        level, both explicit (def, cdef, etc.) and implicit (assignment
 184     #        to an otherwise undeclared name).
 185     #
 186     #  (2) analyse_expressions
 187     #         Determine the result types of expressions and fill in the
 188     #         'type' attribute of each ExprNode. Insert coercion nodes into the
 189     #         tree where needed to convert to and from Python objects.
 190     #         Allocate temporary locals for intermediate results. Fill
 191     #         in the 'result_code' attribute of each ExprNode with a C code
 192     #         fragment.
 193     #
 194     #  (3) generate_code
 195     #         Emit C code for all declarations, statements and expressions.
 196     #         Recursively applies the 3 processing phases to the bodies of
 197     #         functions.
 198     #
 199
 200     def analyse_control_flow(self, env):
 201         pass
 202
 203     def analyse_declarations(self, env):
 204         pass
 205
 206     def analyse_expressions(self, env):
 207         raise InternalError("analyse_expressions not implemented for %s" % \
 208             self.__class__.__name__)
 209
 210     def generate_code(self, code):
 211         raise InternalError("generate_code not implemented for %s" % \
 212             self.__class__.__name__)
 213
 214     def annotate(self, code):
 215         # mro does the wrong thing
 216         if isinstance(self, BlockNode):
 217             self.body.annotate(code)
 218
 219     def end_pos(self):
 220         try:
 221             return self._end_pos
 222         except AttributeError:
 223             pos = self.pos
 224             if not self.child_attrs:
 225                 self._end_pos = pos
 226                 return pos
 227             for attr in self.child_attrs:
 228                 child = getattr(self, attr)
 229                 # Sometimes lists, sometimes nodes
 230                 if child is None:
 231                     pass
 232                 elif isinstance(child, list):
 233                     for c in child:
 234                         pos = max(pos, c.end_pos())
 235                 else:
 236                     pos = max(pos, child.end_pos())
 237             self._end_pos = pos
 238             return pos
 239
 240     def dump(self, level=0, filter_out=("pos",), cutoff=100, encountered=None):
 241         if cutoff == 0:
 242             return "<...nesting level cutoff...>"
 243         if encountered is None:
 244             encountered = set()
 245         if id(self) in encountered:
 246             return "<%s (0x%x) -- already output>" % (self.__class__.__name__, id(self))
 247         encountered.add(id(self))
 248
 249         def dump_child(x, level):
 250             if isinstance(x, Node):
 251                 return x.dump(level, filter_out, cutoff-1, encountered)
 252             elif isinstance(x, list):
 253                 return "[%s]" % ", ".join([dump_child(item, level) for item in x])
 254             else:
 255                 return repr(x)
 256
 257
 258         attrs = [(key, value) for key, value in self.__dict__.items() if key not in filter_out]
 259         if len(attrs) == 0:
 260             return "<%s (0x%x)>" % (self.__class__.__name__, id(self))
 261         else:
 262             indent = "  " * level
 263             res = "<%s (0x%x)\n" % (self.__class__.__name__, id(self))
 264             for key, value in attrs:
 265                 res += "%s  %s: %s\n" % (indent, key, dump_child(value, level + 1))
 266             res += "%s>" % indent
 267             return res
 268
 269 class CompilerDirectivesNode(Node):
 270     """
 271     Sets compiler directives for the children nodes
 272     """
 273     #  directives     {string:value}  A dictionary holding the right value for
 274     #                                 *all* possible directives.
 275     #  body           Node
 276     child_attrs = ["body"]
 277
 278     def analyse_control_flow(self, env):
 279         old = env.directives
 280         env.directives = self.directives
 281         self.body.analyse_control_flow(env)
 282         env.directives = old
 283
 284     def analyse_declarations(self, env):
 285         old = env.directives
 286         env.directives = self.directives
 287         self.body.analyse_declarations(env)
 288         env.directives = old
 289
 290     def analyse_expressions(self, env):
 291         old = env.directives
 292         env.directives = self.directives
 293         self.body.analyse_expressions(env)
 294         env.directives = old
 295
 296     def generate_function_definitions(self, env, code):
 297         env_old = env.directives
 298         code_old = code.globalstate.directives
 299         code.globalstate.directives = self.directives
 300         self.body.generate_function_definitions(env, code)
 301         env.directives = env_old
 302         code.globalstate.directives = code_old
 303
 304     def generate_execution_code(self, code):
 305         old = code.globalstate.directives
 306         code.globalstate.directives = self.directives
 307         self.body.generate_execution_code(code)
 308         code.globalstate.directives = old
 309
 310     def annotate(self, code):
 311         old = code.globalstate.directives
 312         code.globalstate.directives = self.directives
 313         self.body.annotate(code)
 314         code.globalstate.directives = old
 315
 316 class BlockNode(object):
 317     #  Mixin class for nodes representing a declaration block.
 318
 319     def generate_cached_builtins_decls(self, env, code):
 320         entries = env.global_scope().undeclared_cached_builtins
 321         for entry in entries:
 322             code.globalstate.add_cached_builtin_decl(entry)
 323         del entries[:]
 324
 325     def generate_lambda_definitions(self, env, code):
 326         for node in env.lambda_defs:
 327             node.generate_function_definitions(env, code)
 328
 329 class StatListNode(Node):
 330     # stats     a list of StatNode
 331
 332     child_attrs = ["stats"]
 333
 334     def create_analysed(pos, env, *args, **kw):
 335         node = StatListNode(pos, *args, **kw)
 336         return node # No node-specific analysis necesarry
 337     create_analysed = staticmethod(create_analysed)
 338
 339     def analyse_control_flow(self, env):
 340         for stat in self.stats:
 341             stat.analyse_control_flow(env)
 342
 343     def analyse_declarations(self, env):
 344         #print "StatListNode.analyse_declarations" ###
 345         for stat in self.stats:
 346             stat.analyse_declarations(env)
 347
 348     def analyse_expressions(self, env):
 349         #print "StatListNode.analyse_expressions" ###
 350         for stat in self.stats:
 351             stat.analyse_expressions(env)
 352
 353     def generate_function_definitions(self, env, code):
 354         #print "StatListNode.generate_function_definitions" ###
 355         for stat in self.stats:
 356             stat.generate_function_definitions(env, code)
 357
 358     def generate_execution_code(self, code):
 359         #print "StatListNode.generate_execution_code" ###
 360         for stat in self.stats:
 361             code.mark_pos(stat.pos)
 362             stat.generate_execution_code(code)
 363
 364     def annotate(self, code):
 365         for stat in self.stats:
 366             stat.annotate(code)
 367
 368
 369 class StatNode(Node):
 370     #
 371     #  Code generation for statements is split into the following subphases:
 372     #
 373     #  (1) generate_function_definitions
 374     #        Emit C code for the definitions of any structs,
 375     #        unions, enums and functions defined in the current
 376     #        scope-block.
 377     #
 378     #  (2) generate_execution_code
 379     #        Emit C code for executable statements.
 380     #
 381
 382     def generate_function_definitions(self, env, code):
 383         pass
 384
 385     def generate_execution_code(self, code):
 386         raise InternalError("generate_execution_code not implemented for %s" % \
 387             self.__class__.__name__)
 388
 389
 390 class CDefExternNode(StatNode):
 391     #  include_file   string or None
 392     #  body           StatNode
 393
 394     child_attrs = ["body"]
 395
 396     def analyse_declarations(self, env):
 397         if self.include_file:
 398             env.add_include_file(self.include_file)
 399         old_cinclude_flag = env.in_cinclude
 400         env.in_cinclude = 1
 401         self.body.analyse_declarations(env)
 402         env.in_cinclude = old_cinclude_flag
 403
 404     def analyse_expressions(self, env):
 405         pass
 406
 407     def generate_execution_code(self, code):
 408         pass
 409
 410     def annotate(self, code):
 411         self.body.annotate(code)
 412
 413
 414 class CDeclaratorNode(Node):
 415     # Part of a C declaration.
 416     #
 417     # Processing during analyse_declarations phase:
 418     #
 419     #   analyse
 420     #      Returns (name, type) pair where name is the
 421     #      CNameDeclaratorNode of the name being declared
 422     #      and type is the type it is being declared as.
 423     #
 424     #  calling_convention  string   Calling convention of CFuncDeclaratorNode
 425     #                               for which this is a base
 426
 427     child_attrs = []
 428
 429     calling_convention = ""
 430
 431
 432 class CNameDeclaratorNode(CDeclaratorNode):
 433     #  name    string             The Pyrex name being declared
 434     #  cname   string or None     C name, if specified
 435     #  default ExprNode or None   the value assigned on declaration
 436
 437     child_attrs = ['default']
 438
 439     default = None
 440
 441     def analyse(self, base_type, env, nonempty = 0):
 442         if nonempty and self.name == '':
 443             # May have mistaken the name for the type.
 444             if base_type.is_ptr or base_type.is_array or base_type.is_buffer:
 445                 error(self.pos, "Missing argument name")
 446             elif base_type.is_void:
 447                 error(self.pos, "Use spam() rather than spam(void) to declare a function with no arguments.")
 448             else:
 449                 self.name = base_type.declaration_code("", for_display=1, pyrex=1)
 450                 base_type = py_object_type
 451         self.type = base_type
 452         return self, base_type
 453
 454 class CPtrDeclaratorNode(CDeclaratorNode):
 455     # base     CDeclaratorNode
 456
 457     child_attrs = ["base"]
 458
 459     def analyse(self, base_type, env, nonempty = 0):
 460         if base_type.is_pyobject:
 461             error(self.pos,
 462                 "Pointer base type cannot be a Python object")
 463         ptr_type = PyrexTypes.c_ptr_type(base_type)
 464         return self.base.analyse(ptr_type, env, nonempty = nonempty)
 465
 466 class CReferenceDeclaratorNode(CDeclaratorNode):
 467     # base     CDeclaratorNode
 468
 469     child_attrs = ["base"]
 470
 471     def analyse(self, base_type, env, nonempty = 0):
 472         if base_type.is_pyobject:
 473             error(self.pos,
 474                   "Reference base type cannot be a Python object")
 475         ref_type = PyrexTypes.c_ref_type(base_type)
 476         return self.base.analyse(ref_type, env, nonempty = nonempty)
 477
 478 class CArrayDeclaratorNode(CDeclaratorNode):
 479     # base        CDeclaratorNode
 480     # dimension   ExprNode
 481
 482     child_attrs = ["base", "dimension"]
 483
 484     def analyse(self, base_type, env, nonempty = 0):
 485         if base_type.is_cpp_class:
 486             from ExprNodes import TupleNode
 487             if isinstance(self.dimension, TupleNode):
 488                 args = self.dimension.args
 489             else:
 490                 args = self.dimension,
 491             values = [v.analyse_as_type(env) for v in args]
 492             if None in values:
 493                 ix = values.index(None)
 494                 error(args[ix].pos, "Template parameter not a type.")
 495                 return error_type
 496             base_type = base_type.specialize_here(self.pos, values)
 497             return self.base.analyse(base_type, env, nonempty = nonempty)
 498         if self.dimension:
 499             self.dimension.analyse_const_expression(env)
 500             if not self.dimension.type.is_int:
 501                 error(self.dimension.pos, "Array dimension not integer")
 502             size = self.dimension.get_constant_c_result_code()
 503             if size is not None:
 504                 try:
 505                     size = int(size)
 506                 except ValueError:
 507                     # runtime constant?
 508                     pass
 509         else:
 510             size = None
 511         if not base_type.is_complete():
 512             error(self.pos,
 513                 "Array element type '%s' is incomplete" % base_type)
 514         if base_type.is_pyobject:
 515             error(self.pos,
 516                 "Array element cannot be a Python object")
 517         if base_type.is_cfunction:
 518             error(self.pos,
 519                 "Array element cannot be a function")
 520         array_type = PyrexTypes.c_array_type(base_type, size)
 521         return self.base.analyse(array_type, env, nonempty = nonempty)
 522
 523
 524 class CFuncDeclaratorNode(CDeclaratorNode):
 525     # base             CDeclaratorNode
 526     # args             [CArgDeclNode]
 527     # has_varargs      boolean
 528     # exception_value  ConstNode
 529     # exception_check  boolean    True if PyErr_Occurred check needed
 530     # nogil            boolean    Can be called without gil
 531     # with_gil         boolean    Acquire gil around function body
 532
 533     child_attrs = ["base", "args", "exception_value"]
 534
 535     overridable = 0
 536     optional_arg_count = 0
 537
 538     def analyse(self, return_type, env, nonempty = 0):
 539         if nonempty:
 540             nonempty -= 1
 541         func_type_args = []
 542         for i, arg_node in enumerate(self.args):
 543             name_declarator, type = arg_node.analyse(env, nonempty = nonempty,
 544                                                      is_self_arg = (i == 0 and env.is_c_class_scope))
 545             name = name_declarator.name
 546             if name_declarator.cname:
 547                 error(self.pos,
 548                     "Function argument cannot have C name specification")
 549             # Turn *[] argument into **
 550             if type.is_array:
 551                 type = PyrexTypes.c_ptr_type(type.base_type)
 552             # Catch attempted C-style func(void) decl
 553             if type.is_void:
 554                 error(arg_node.pos, "Use spam() rather than spam(void) to declare a function with no arguments.")
 555             func_type_args.append(
 556                 PyrexTypes.CFuncTypeArg(name, type, arg_node.pos))
 557             if arg_node.default:
 558                 self.optional_arg_count += 1
 559             elif self.optional_arg_count:
 560                 error(self.pos, "Non-default argument follows default argument")
 561
 562         if self.optional_arg_count:
 563             scope = StructOrUnionScope()
 564             arg_count_member = '%sn' % Naming.pyrex_prefix
 565             scope.declare_var(arg_count_member, PyrexTypes.c_int_type, self.pos)
 566             for arg in func_type_args[len(func_type_args)-self.optional_arg_count:]:
 567                 scope.declare_var(arg.name, arg.type, arg.pos, allow_pyobject = 1)
 568             struct_cname = env.mangle(Naming.opt_arg_prefix, self.base.name)
 569             self.op_args_struct = env.global_scope().declare_struct_or_union(name = struct_cname,
 570                                         kind = 'struct',
 571                                         scope = scope,
 572                                         typedef_flag = 0,
 573                                         pos = self.pos,
 574                                         cname = struct_cname)
 575             self.op_args_struct.defined_in_pxd = 1
 576             self.op_args_struct.used = 1
 577
 578         exc_val = None
 579         exc_check = 0
 580         if self.exception_check == '+':
 581             env.add_include_file('stdexcept')
 582         if return_type.is_pyobject \
 583             and (self.exception_value or self.exception_check) \
 584             and self.exception_check != '+':
 585                 error(self.pos,
 586                     "Exception clause not allowed for function returning Python object")
 587         else:
 588             if self.exception_value:
 589                 self.exception_value.analyse_const_expression(env)
 590                 if self.exception_check == '+':
 591                     self.exception_value.analyse_types(env)
 592                     exc_val_type = self.exception_value.type
 593                     if not exc_val_type.is_error and \
 594                           not exc_val_type.is_pyobject and \
 595                           not (exc_val_type.is_cfunction and not exc_val_type.return_type.is_pyobject and len(exc_val_type.args)==0):
 596                         error(self.exception_value.pos,
 597                             "Exception value must be a Python exception or cdef function with no arguments.")
 598                     exc_val = self.exception_value
 599                 else:
 600                     self.exception_value = self.exception_value.coerce_to(return_type, env)
 601                     if self.exception_value.analyse_const_expression(env):
 602                         exc_val = self.exception_value.get_constant_c_result_code()
 603                         if exc_val is None:
 604                             raise InternalError("get_constant_c_result_code not implemented for %s" %
 605                                 self.exception_value.__class__.__name__)
 606                         if not return_type.assignable_from(self.exception_value.type):
 607                             error(self.exception_value.pos,
 608                                   "Exception value incompatible with function return type")
 609             exc_check = self.exception_check
 610         if return_type.is_array:
 611             error(self.pos,
 612                 "Function cannot return an array")
 613         if return_type.is_cfunction:
 614             error(self.pos,
 615                 "Function cannot return a function")
 616         func_type = PyrexTypes.CFuncType(
 617             return_type, func_type_args, self.has_varargs,
 618             optional_arg_count = self.optional_arg_count,
 619             exception_value = exc_val, exception_check = exc_check,
 620             calling_convention = self.base.calling_convention,
 621             nogil = self.nogil, with_gil = self.with_gil, is_overridable = self.overridable)
 622         if self.optional_arg_count:
 623             func_type.op_arg_struct = PyrexTypes.c_ptr_type(self.op_args_struct.type)
 624         callspec = env.directives['callspec']
 625         if callspec:
 626             current = func_type.calling_convention
 627             if current and current != callspec:
 628                 error(self.pos, "cannot have both '%s' and '%s' "
 629                       "calling conventions" % (current, callspec))
 630             func_type.calling_convention = callspec
 631         return self.base.analyse(func_type, env)
 632
 633
 634 class CArgDeclNode(Node):
 635     # Item in a function declaration argument list.
 636     #
 637     # base_type      CBaseTypeNode
 638     # declarator     CDeclaratorNode
 639     # not_none       boolean            Tagged with 'not None'
 640     # or_none        boolean            Tagged with 'or None'
 641     # accept_none    boolean            Resolved boolean for not_none/or_none
 642     # default        ExprNode or None
 643     # default_value  PyObjectConst      constant for default value
 644     # annotation     ExprNode or None   Py3 function arg annotation
 645     # is_self_arg    boolean            Is the "self" arg of an extension type method
 646     # is_type_arg    boolean            Is the "class" arg of an extension type classmethod
 647     # is_kw_only     boolean            Is a keyword-only argument
 648
 649     child_attrs = ["base_type", "declarator", "default"]
 650
 651     is_self_arg = 0
 652     is_type_arg = 0
 653     is_generic = 1
 654     type = None
 655     name_declarator = None
 656     default_value = None
 657     annotation = None
 658
 659     def analyse(self, env, nonempty = 0, is_self_arg = False):
 660         if is_self_arg:
 661             self.base_type.is_self_arg = self.is_self_arg = True
 662         if self.type is None:
 663             # The parser may missinterpret names as types...
 664             # We fix that here.
 665             if isinstance(self.declarator, CNameDeclaratorNode) and self.declarator.name == '':
 666                 if nonempty:
 667                     self.declarator.name = self.base_type.name
 668                     self.base_type.name = None
 669                     self.base_type.is_basic_c_type = False
 670                 could_be_name = True
 671             else:
 672                 could_be_name = False
 673             base_type = self.base_type.analyse(env, could_be_name = could_be_name)
 674             if hasattr(self.base_type, 'arg_name') and self.base_type.arg_name:
 675                 self.declarator.name = self.base_type.arg_name
 676             # The parser is unable to resolve the ambiguity of [] as part of the
 677             # type (e.g. in buffers) or empty declarator (as with arrays).
 678             # This is only arises for empty multi-dimensional arrays.
 679             if (base_type.is_array
 680                     and isinstance(self.base_type, TemplatedTypeNode)
 681                     and isinstance(self.declarator, CArrayDeclaratorNode)):
 682                 declarator = self.declarator
 683                 while isinstance(declarator.base, CArrayDeclaratorNode):
 684                     declarator = declarator.base
 685                 declarator.base = self.base_type.array_declarator
 686                 base_type = base_type.base_type
 687             return self.declarator.analyse(base_type, env, nonempty = nonempty)
 688         else:
 689             return self.name_declarator, self.type
 690
 691     def calculate_default_value_code(self, code):
 692         if self.default_value is None:
 693             if self.default:
 694                 if self.default.is_literal:
 695                     # will not output any code, just assign the result_code
 696                     self.default.generate_evaluation_code(code)
 697                     return self.type.cast_code(self.default.result())
 698                 self.default_value = code.get_argument_default_const(self.type)
 699         return self.default_value
 700
 701     def annotate(self, code):
 702         if self.default:
 703             self.default.annotate(code)
 704
 705
 706 class CBaseTypeNode(Node):
 707     # Abstract base class for C base type nodes.
 708     #
 709     # Processing during analyse_declarations phase:
 710     #
 711     #   analyse
 712     #     Returns the type.
 713
 714     pass
 715
 716     def analyse_as_type(self, env):
 717         return self.analyse(env)
 718
 719 class CAnalysedBaseTypeNode(Node):
 720     # type            type
 721
 722     child_attrs = []
 723
 724     def analyse(self, env, could_be_name = False):
 725         return self.type
 726
 727 class CSimpleBaseTypeNode(CBaseTypeNode):
 728     # name             string
 729     # module_path      [string]     Qualifying name components
 730     # is_basic_c_type  boolean
 731     # signed           boolean
 732     # longness         integer
 733     # complex          boolean
 734     # is_self_arg      boolean      Is self argument of C method
 735     # ##is_type_arg      boolean      Is type argument of class method
 736
 737     child_attrs = []
 738     arg_name = None   # in case the argument name was interpreted as a type
 739
 740     def analyse(self, env, could_be_name = False):
 741         # Return type descriptor.
 742         #print "CSimpleBaseTypeNode.analyse: is_self_arg =", self.is_self_arg ###
 743         type = None
 744         if self.is_basic_c_type:
 745             type = PyrexTypes.simple_c_type(self.signed, self.longness, self.name)
 746             if not type:
 747                 error(self.pos, "Unrecognised type modifier combination")
 748         elif self.name == "object" and not self.module_path:
 749             type = py_object_type
 750         elif self.name is None:
 751             if self.is_self_arg and env.is_c_class_scope:
 752                 #print "CSimpleBaseTypeNode.analyse: defaulting to parent type" ###
 753                 type = env.parent_type
 754             ## elif self.is_type_arg and env.is_c_class_scope:
 755             ##     type = Builtin.type_type
 756             else:
 757                 type = py_object_type
 758         else:
 759             if self.module_path:
 760                 scope = env.find_imported_module(self.module_path, self.pos)
 761             else:
 762                 scope = env
 763             if scope:
 764                 if scope.is_c_class_scope:
 765                     scope = scope.global_scope()
 766                 entry = scope.lookup(self.name)
 767                 if entry and entry.is_type:
 768                     type = entry.type
 769                 elif could_be_name:
 770                     if self.is_self_arg and env.is_c_class_scope:
 771                         type = env.parent_type
 772                     ## elif self.is_type_arg and env.is_c_class_scope:
 773                     ##     type = Builtin.type_type
 774                     else:
 775                         type = py_object_type
 776                     self.arg_name = self.name
 777                 else:
 778                     if self.templates:
 779                         if not self.name in self.templates:
 780                             error(self.pos, "'%s' is not a type identifier" % self.name)
 781                         type = PyrexTypes.TemplatePlaceholderType(self.name)
 782                     else:
 783                         error(self.pos, "'%s' is not a type identifier" % self.name)
 784         if self.complex:
 785             if not type.is_numeric or type.is_complex:
 786                 error(self.pos, "can only complexify c numeric types")
 787             type = PyrexTypes.CComplexType(type)
 788             type.create_declaration_utility_code(env)
 789         elif type is Builtin.complex_type:
 790             # Special case: optimise builtin complex type into C's
 791             # double complex.  The parser cannot do this (as for the
 792             # normal scalar types) as the user may have redeclared the
 793             # 'complex' type.  Testing for the exact type here works.
 794             type = PyrexTypes.c_double_complex_type
 795             type.create_declaration_utility_code(env)
 796             self.complex = True
 797         if type:
 798             return type
 799         else:
 800             return PyrexTypes.error_type
 801
 802 class CNestedBaseTypeNode(CBaseTypeNode):
 803     # For C++ classes that live inside other C++ classes.
 804
 805     # name             string
 806     # base_type        CBaseTypeNode
 807
 808     child_attrs = ['base_type']
 809
 810     def analyse(self, env, could_be_name = None):
 811         base_type = self.base_type.analyse(env)
 812         if base_type is PyrexTypes.error_type:
 813             return PyrexTypes.error_type
 814         if not base_type.is_cpp_class:
 815             error(self.pos, "'%s' is not a valid type scope" % base_type)
 816             return PyrexTypes.error_type
 817         type_entry = base_type.scope.lookup_here(self.name)
 818         if not type_entry or not type_entry.is_type:
 819             error(self.pos, "'%s.%s' is not a type identifier" % (base_type, self.name))
 820             return PyrexTypes.error_type
 821         return type_entry.type
 822
 823 class TemplatedTypeNode(CBaseTypeNode):
 824     #  After parsing:
 825     #  positional_args  [ExprNode]        List of positional arguments
 826     #  keyword_args     DictNode          Keyword arguments
 827     #  base_type_node   CBaseTypeNode
 828
 829     #  After analysis:
 830     #  type             PyrexTypes.BufferType or PyrexTypes.CppClassType  ...containing the right options
 831
 832
 833     child_attrs = ["base_type_node", "positional_args",
 834                    "keyword_args", "dtype_node"]
 835
 836     dtype_node = None
 837
 838     name = None
 839
 840     def analyse(self, env, could_be_name = False, base_type = None):
 841         if base_type is None:
 842             base_type = self.base_type_node.analyse(env)
 843         if base_type.is_error: return base_type
 844
 845         if base_type.is_cpp_class:
 846             # Templated class
 847             if self.keyword_args and self.keyword_args.key_value_pairs:
 848                 error(self.pos, "c++ templates cannot take keyword arguments");
 849                 self.type = PyrexTypes.error_type
 850             else:
 851                 template_types = []
 852                 for template_node in self.positional_args:
 853                     type = template_node.analyse_as_type(env)
 854                     if type is None:
 855                         error(template_node.pos, "unknown type in template argument")
 856                         return error_type
 857                     template_types.append(type)
 858                 self.type = base_type.specialize_here(self.pos, template_types)
 859
 860         elif base_type.is_pyobject:
 861             # Buffer
 862             import Buffer
 863
 864             options = Buffer.analyse_buffer_options(
 865                 self.pos,
 866                 env,
 867                 self.positional_args,
 868                 self.keyword_args,
 869                 base_type.buffer_defaults)
 870
 871             if sys.version_info[0] < 3:
 872                 # Py 2.x enforces byte strings as keyword arguments ...
 873                 options = dict([ (name.encode('ASCII'), value)
 874                                  for name, value in options.items() ])
 875
 876             self.type = PyrexTypes.BufferType(base_type, **options)
 877
 878         else:
 879             # Array
 880             empty_declarator = CNameDeclaratorNode(self.pos, name="", cname=None)
 881             if len(self.positional_args) > 1 or self.keyword_args.key_value_pairs:
 882                 error(self.pos, "invalid array declaration")
 883                 self.type = PyrexTypes.error_type
 884             else:
 885                 # It would be nice to merge this class with CArrayDeclaratorNode,
 886                 # but arrays are part of the declaration, not the type...
 887                 if not self.positional_args:
 888                     dimension = None
 889                 else:
 890                     dimension = self.positional_args[0]
 891                 self.array_declarator = CArrayDeclaratorNode(self.pos,
 892                     base = empty_declarator,
 893                     dimension = dimension)
 894                 self.type = self.array_declarator.analyse(base_type, env)[1]
 895
 896         return self.type
 897
 898 class CComplexBaseTypeNode(CBaseTypeNode):
 899     # base_type   CBaseTypeNode
 900     # declarator  CDeclaratorNode
 901
 902     child_attrs = ["base_type", "declarator"]
 903
 904     def analyse(self, env, could_be_name = False):
 905         base = self.base_type.analyse(env, could_be_name)
 906         _, type = self.declarator.analyse(base, env)
 907         return type
 908
 909
 910 class CVarDefNode(StatNode):
 911     #  C variable definition or forward/extern function declaration.
 912     #
 913     #  visibility    'private' or 'public' or 'extern'
 914     #  base_type     CBaseTypeNode
 915     #  declarators   [CDeclaratorNode]
 916     #  in_pxd        boolean
 917     #  api           boolean
 918
 919     #  decorators    [cython.locals(...)] or None
 920     #  directive_locals { string : NameNode } locals defined by cython.locals(...)
 921
 922     child_attrs = ["base_type", "declarators"]
 923
 924     decorators = None
 925     directive_locals = {}
 926
 927     def analyse_declarations(self, env, dest_scope = None):
 928         if not dest_scope:
 929             dest_scope = env
 930         self.dest_scope = dest_scope
 931         base_type = self.base_type.analyse(env)
 932
 933         # If the field is an external typedef, we cannot be sure about the type,
 934         # so do conversion ourself rather than rely on the CPython mechanism (through
 935         # a property; made in AnalyseDeclarationsTransform).
 936         if (dest_scope.is_c_class_scope
 937             and self.visibility in ('public', 'readonly')):
 938             need_property = True
 939         else:
 940             need_property = False
 941         visibility = self.visibility
 942
 943         for declarator in self.declarators:
 944             name_declarator, type = declarator.analyse(base_type, env)
 945             if not type.is_complete():
 946                 if not (self.visibility == 'extern' and type.is_array):
 947                     error(declarator.pos,
 948                         "Variable type '%s' is incomplete" % type)
 949             if self.visibility == 'extern' and type.is_pyobject:
 950                 error(declarator.pos,
 951                     "Python object cannot be declared extern")
 952             name = name_declarator.name
 953             cname = name_declarator.cname
 954             if name == '':
 955                 error(declarator.pos, "Missing name in declaration.")
 956                 return
 957             if type.is_cfunction:
 958                 entry = dest_scope.declare_cfunction(name, type, declarator.pos,
 959                     cname = cname, visibility = self.visibility, in_pxd = self.in_pxd,
 960                     api = self.api)
 961                 if entry is not None:
 962                     entry.directive_locals = self.directive_locals
 963             else:
 964                 if self.directive_locals:
 965                     error(self.pos, "Decorators can only be followed by functions")
 966                 if self.in_pxd and self.visibility != 'extern':
 967                     error(self.pos,
 968                         "Only 'extern' C variable declaration allowed in .pxd file")
 969                 entry = dest_scope.declare_var(name, type, declarator.pos,
 970                             cname = cname, visibility = visibility, is_cdef = 1)
 971                 entry.needs_property = need_property
 972
 973
 974 class CStructOrUnionDefNode(StatNode):
 975     #  name          string
 976     #  cname         string or None
 977     #  kind          "struct" or "union"
 978     #  typedef_flag  boolean
 979     #  visibility    "public" or "private"
 980     #  in_pxd        boolean
 981     #  attributes    [CVarDefNode] or None
 982     #  entry         Entry
 983     #  packed        boolean
 984
 985     child_attrs = ["attributes"]
 986
 987     def analyse_declarations(self, env):
 988         scope = None
 989         if self.visibility == 'extern' and self.packed:
 990             error(self.pos, "Cannot declare extern struct as 'packed'")
 991         if self.attributes is not None:
 992             scope = StructOrUnionScope(self.name)
 993         self.entry = env.declare_struct_or_union(
 994             self.name, self.kind, scope, self.typedef_flag, self.pos,
 995             self.cname, visibility = self.visibility, packed = self.packed)
 996         if self.attributes is not None:
 997             if self.in_pxd and not env.in_cinclude:
 998                 self.entry.defined_in_pxd = 1
 999             for attr in self.attributes:
1000                 attr.analyse_declarations(env, scope)
1001             if self.visibility != 'extern':
1002                 need_typedef_indirection = False
1003                 for attr in scope.var_entries:
1004                     type = attr.type
1005                     while type.is_array:
1006                         type = type.base_type
1007                     if type == self.entry.type:
1008                         error(attr.pos, "Struct cannot contain itself as a member.")
1009                     if self.typedef_flag:
1010                         while type.is_ptr:
1011                             type = type.base_type
1012                         if type == self.entry.type:
1013                             need_typedef_indirection = True
1014                 if need_typedef_indirection:
1015                     # C can't handle typedef structs that refer to themselves.
1016                     struct_entry = self.entry
1017                     self.entry = env.declare_typedef(
1018                         self.name, struct_entry.type, self.pos,
1019                         cname = self.cname, visibility='ignore')
1020                     struct_entry.type.typedef_flag = False
1021                     # FIXME: this might be considered a hack ;-)
1022                     struct_entry.cname = struct_entry.type.cname = \
1023                                          '_' + self.entry.type.typedef_cname
1024
1025     def analyse_expressions(self, env):
1026         pass
1027
1028     def generate_execution_code(self, code):
1029         pass
1030
1031
1032 class CppClassNode(CStructOrUnionDefNode):
1033
1034     #  name          string
1035     #  cname         string or None
1036     #  visibility    "extern"
1037     #  in_pxd        boolean
1038     #  attributes    [CVarDefNode] or None
1039     #  entry         Entry
1040     #  base_classes  [string]
1041     #  templates     [string] or None
1042
1043     def analyse_declarations(self, env):
1044         scope = None
1045         if self.attributes is not None:
1046             scope = CppClassScope(self.name, env)
1047         base_class_types = []
1048         for base_class_name in self.base_classes:
1049             base_class_entry = env.lookup(base_class_name)
1050             if base_class_entry is None:
1051                 error(self.pos, "'%s' not found" % base_class_name)
1052             elif not base_class_entry.is_type or not base_class_entry.type.is_cpp_class:
1053                 error(self.pos, "'%s' is not a cpp class type" % base_class_name)
1054             else:
1055                 base_class_types.append(base_class_entry.type)
1056         if self.templates is None:
1057             template_types = None
1058         else:
1059             template_types = [PyrexTypes.TemplatePlaceholderType(template_name) for template_name in self.templates]
1060         self.entry = env.declare_cpp_class(
1061             self.name, scope, self.pos,
1062             self.cname, base_class_types, visibility = self.visibility, templates = template_types)
1063         self.entry.is_cpp_class = 1
1064         if self.attributes is not None:
1065             if self.in_pxd and not env.in_cinclude:
1066                 self.entry.defined_in_pxd = 1
1067             for attr in self.attributes:
1068                 attr.analyse_declarations(scope)
1069
1070 class CEnumDefNode(StatNode):
1071     #  name           string or None
1072     #  cname          string or None
1073     #  items          [CEnumDefItemNode]
1074     #  typedef_flag   boolean
1075     #  visibility     "public" or "private"
1076     #  in_pxd         boolean
1077     #  entry          Entry
1078
1079     child_attrs = ["items"]
1080
1081     def analyse_declarations(self, env):
1082         self.entry = env.declare_enum(self.name, self.pos,
1083             cname = self.cname, typedef_flag = self.typedef_flag,
1084             visibility = self.visibility)
1085         if self.items is not None:
1086             if self.in_pxd and not env.in_cinclude:
1087                 self.entry.defined_in_pxd = 1
1088             for item in self.items:
1089                 item.analyse_declarations(env, self.entry)
1090
1091     def analyse_expressions(self, env):
1092         pass
1093
1094     def generate_execution_code(self, code):
1095         if self.visibility == 'public':
1096             temp = code.funcstate.allocate_temp(PyrexTypes.py_object_type, manage_ref=True)
1097             for item in self.entry.enum_values:
1098                 code.putln("%s = PyInt_FromLong(%s); %s" % (
1099                         temp,
1100                         item.cname,
1101                         code.error_goto_if_null(temp, item.pos)))
1102                 code.put_gotref(temp)
1103                 code.putln('if (__Pyx_SetAttrString(%s, "%s", %s) < 0) %s' % (
1104                         Naming.module_cname,
1105                         item.name,
1106                         temp,
1107                         code.error_goto(item.pos)))
1108                 code.put_decref_clear(temp, PyrexTypes.py_object_type)
1109             code.funcstate.release_temp(temp)
1110
1111
1112 class CEnumDefItemNode(StatNode):
1113     #  name     string
1114     #  cname    string or None
1115     #  value    ExprNode or None
1116
1117     child_attrs = ["value"]
1118
1119     def analyse_declarations(self, env, enum_entry):
1120         if self.value:
1121             self.value.analyse_const_expression(env)
1122             if not self.value.type.is_int:
1123                 self.value = self.value.coerce_to(PyrexTypes.c_int_type, env)
1124                 self.value.analyse_const_expression(env)
1125         entry = env.declare_const(self.name, enum_entry.type,
1126             self.value, self.pos, cname = self.cname,
1127             visibility = enum_entry.visibility)
1128         enum_entry.enum_values.append(entry)
1129
1130
1131 class CTypeDefNode(StatNode):
1132     #  base_type    CBaseTypeNode
1133     #  declarator   CDeclaratorNode
1134     #  visibility   "public" or "private"
1135     #  in_pxd       boolean
1136
1137     child_attrs = ["base_type", "declarator"]
1138
1139     def analyse_declarations(self, env):
1140         base = self.base_type.analyse(env)
1141         name_declarator, type = self.declarator.analyse(base, env)
1142         name = name_declarator.name
1143         cname = name_declarator.cname
1144         entry = env.declare_typedef(name, type, self.pos,
1145             cname = cname, visibility = self.visibility)
1146         if self.in_pxd and not env.in_cinclude:
1147             entry.defined_in_pxd = 1
1148
1149     def analyse_expressions(self, env):
1150         pass
1151     def generate_execution_code(self, code):
1152         pass
1153
1154
1155 class FuncDefNode(StatNode, BlockNode):
1156     #  Base class for function definition nodes.
1157     #
1158     #  return_type     PyrexType
1159     #  #filename        string        C name of filename string const
1160     #  entry           Symtab.Entry
1161     #  needs_closure   boolean        Whether or not this function has inner functions/classes/yield
1162     #  needs_outer_scope boolean      Whether or not this function requires outer scope
1163     #  directive_locals { string : NameNode } locals defined by cython.locals(...)
1164
1165     py_func = None
1166     assmt = None
1167     needs_closure = False
1168     needs_outer_scope = False
1169     modifiers = []
1170
1171     def analyse_default_values(self, env):
1172         genv = env.global_scope()
1173         default_seen = 0
1174         for arg in self.args:
1175             if arg.default:
1176                 default_seen = 1
1177                 if arg.is_generic:
1178                     arg.default.analyse_types(env)
1179                     arg.default = arg.default.coerce_to(arg.type, genv)
1180                 else:
1181                     error(arg.pos,
1182                         "This argument cannot have a default value")
1183                     arg.default = None
1184             elif arg.kw_only:
1185                 default_seen = 1
1186             elif default_seen:
1187                 error(arg.pos, "Non-default argument following default argument")
1188
1189     def need_gil_acquisition(self, lenv):
1190         return 0
1191
1192     def create_local_scope(self, env):
1193         genv = env
1194         while genv.is_py_class_scope or genv.is_c_class_scope:
1195             genv = genv.outer_scope
1196         if self.needs_closure:
1197             lenv = ClosureScope(name=self.entry.name,
1198                                 outer_scope = genv,
1199                                 scope_name=self.entry.cname)
1200         else:
1201             lenv = LocalScope(name=self.entry.name,
1202                               outer_scope=genv,
1203                               parent_scope=env)
1204         lenv.return_type = self.return_type
1205         type = self.entry.type
1206         if type.is_cfunction:
1207             lenv.nogil = type.nogil and not type.with_gil
1208         self.local_scope = lenv
1209         lenv.directives = env.directives
1210         return lenv
1211
1212     def generate_function_definitions(self, env, code):
1213         import Buffer
1214
1215         lenv = self.local_scope
1216         if lenv.is_closure_scope and not lenv.is_passthrough:
1217             outer_scope_cname = "%s->%s" % (Naming.cur_scope_cname,
1218                                             Naming.outer_scope_cname)
1219         else:
1220             outer_scope_cname = Naming.outer_scope_cname
1221         lenv.mangle_closure_cnames(outer_scope_cname)
1222         # Generate closure function definitions
1223         self.body.generate_function_definitions(lenv, code)
1224         # generate lambda function definitions
1225         self.generate_lambda_definitions(lenv, code)
1226
1227         is_getbuffer_slot = (self.entry.name == "__getbuffer__" and
1228                              self.entry.scope.is_c_class_scope)
1229         is_releasebuffer_slot = (self.entry.name == "__releasebuffer__" and
1230                                  self.entry.scope.is_c_class_scope)
1231         is_buffer_slot = is_getbuffer_slot or is_releasebuffer_slot
1232         if is_buffer_slot:
1233             if 'cython_unused' not in self.modifiers:
1234                 self.modifiers = self.modifiers + ['cython_unused']
1235
1236         preprocessor_guard = None
1237         if self.entry.is_special and not is_buffer_slot:
1238             slot = TypeSlots.method_name_to_slot.get(self.entry.name)
1239             if slot:
1240                 preprocessor_guard = slot.preprocessor_guard_code()
1241                 if (self.entry.name == '__long__' and
1242                     not self.entry.scope.lookup_here('__int__')):
1243                     preprocessor_guard = None
1244
1245         profile = code.globalstate.directives['profile']
1246         if profile:
1247             if lenv.nogil:
1248                 error(self.pos, "Cannot profile nogil function.")
1249             code.globalstate.use_utility_code(profile_utility_code)
1250
1251         # Generate C code for header and body of function
1252         code.enter_cfunc_scope()
1253         code.return_from_error_cleanup_label = code.new_label()
1254
1255         # ----- Top-level constants used by this function
1256         code.mark_pos(self.pos)
1257         self.generate_cached_builtins_decls(lenv, code)
1258         # ----- Function header
1259         code.putln("")
1260
1261         if preprocessor_guard:
1262             code.putln(preprocessor_guard)
1263
1264         with_pymethdef = self.needs_assignment_synthesis(env, code)
1265         if self.py_func:
1266             self.py_func.generate_function_header(code,
1267                 with_pymethdef = with_pymethdef,
1268                 proto_only=True)
1269         self.generate_function_header(code,
1270             with_pymethdef = with_pymethdef)
1271         # ----- Local variable declarations
1272         # Find function scope
1273         cenv = env
1274         while cenv.is_py_class_scope or cenv.is_c_class_scope:
1275             cenv = cenv.outer_scope
1276         if self.needs_closure:
1277             code.put(lenv.scope_class.type.declaration_code(Naming.cur_scope_cname))
1278             code.putln(";")
1279         elif self.needs_outer_scope:
1280             if lenv.is_passthrough:
1281                 code.put(lenv.scope_class.type.declaration_code(Naming.cur_scope_cname))
1282                 code.putln(";")
1283             code.put(cenv.scope_class.type.declaration_code(Naming.outer_scope_cname))
1284             code.putln(";")
1285         self.generate_argument_declarations(lenv, code)
1286         for entry in lenv.var_entries:
1287             if not entry.in_closure:
1288                 code.put_var_declaration(entry)
1289         init = ""
1290         if not self.return_type.is_void:
1291             if self.return_type.is_pyobject:
1292                 init = " = NULL"
1293             code.putln(
1294                 "%s%s;" %
1295                     (self.return_type.declaration_code(Naming.retval_cname),
1296                      init))
1297         tempvardecl_code = code.insertion_point()
1298         self.generate_keyword_list(code)
1299         if profile:
1300             code.put_trace_declarations()
1301         # ----- Extern library function declarations
1302         lenv.generate_library_function_declarations(code)
1303         # ----- GIL acquisition
1304         acquire_gil = self.acquire_gil
1305         if acquire_gil:
1306             env.use_utility_code(force_init_threads_utility_code)
1307             code.putln("#ifdef WITH_THREAD")
1308             code.putln("PyGILState_STATE _save = PyGILState_Ensure();")
1309             code.putln("#endif")
1310         # ----- set up refnanny
1311         if not lenv.nogil:
1312             code.put_setup_refcount_context(self.entry.name)
1313         # ----- Automatic lead-ins for certain special functions
1314         if is_getbuffer_slot:
1315             self.getbuffer_init(code)
1316         # ----- Create closure scope object
1317         if self.needs_closure:
1318             code.putln("%s = (%s)%s->tp_new(%s, %s, NULL);" % (
1319                 Naming.cur_scope_cname,
1320                 lenv.scope_class.type.declaration_code(''),
1321                 lenv.scope_class.type.typeptr_cname,
1322                 lenv.scope_class.type.typeptr_cname,
1323                 Naming.empty_tuple))
1324             code.putln("if (unlikely(!%s)) {" % Naming.cur_scope_cname)
1325             if is_getbuffer_slot:
1326                 self.getbuffer_error_cleanup(code)
1327             if not lenv.nogil:
1328                 code.put_finish_refcount_context()
1329             # FIXME: what if the error return value is a Python value?
1330             code.putln("return %s;" % self.error_value())
1331             code.putln("}")
1332             code.put_gotref(Naming.cur_scope_cname)
1333             # Note that it is unsafe to decref the scope at this point.
1334         if self.needs_outer_scope:
1335             code.putln("%s = (%s)%s;" % (
1336                             outer_scope_cname,
1337                             cenv.scope_class.type.declaration_code(''),
1338                             Naming.self_cname))
1339             if lenv.is_passthrough:
1340                 code.putln("%s = %s;" % (Naming.cur_scope_cname, outer_scope_cname));
1341             elif self.needs_closure:
1342                 # inner closures own a reference to their outer parent
1343                 code.put_incref(outer_scope_cname, cenv.scope_class.type)
1344                 code.put_giveref(outer_scope_cname)
1345         # ----- Trace function call
1346         if profile:
1347             # this looks a bit late, but if we don't get here due to a
1348             # fatal error before hand, it's not really worth tracing
1349             code.put_trace_call(self.entry.name, self.pos)
1350         # ----- Fetch arguments
1351         self.generate_argument_parsing_code(env, code)
1352         # If an argument is assigned to in the body, we must
1353         # incref it to properly keep track of refcounts.
1354         for entry in lenv.arg_entries:
1355             if entry.type.is_pyobject:
1356                 if entry.assignments and not entry.in_closure:
1357                     code.put_var_incref(entry)
1358         # ----- Initialise local variables
1359         for entry in lenv.var_entries:
1360             if entry.type.is_pyobject and entry.init_to_none and entry.used:
1361                 code.put_init_var_to_py_none(entry)
1362         # ----- Initialise local buffer auxiliary variables
1363         for entry in lenv.var_entries + lenv.arg_entries:
1364             if entry.type.is_buffer and entry.buffer_aux.buffer_info_var.used:
1365                 code.putln("%s.buf = NULL;" %
1366                            entry.buffer_aux.buffer_info_var.cname)
1367         # ----- Check and convert arguments
1368         self.generate_argument_type_tests(code)
1369         # ----- Acquire buffer arguments
1370         for entry in lenv.arg_entries:
1371             if entry.type.is_buffer:
1372                 Buffer.put_acquire_arg_buffer(entry, code, self.pos)
1373
1374         # -------------------------
1375         # ----- Function body -----
1376         # -------------------------
1377         self.body.generate_execution_code(code)
1378
1379         # ----- Default return value
1380         code.putln("")
1381         if self.return_type.is_pyobject:
1382             #if self.return_type.is_extension_type:
1383             #    lhs = "(PyObject *)%s" % Naming.retval_cname
1384             #else:
1385             lhs = Naming.retval_cname
1386             code.put_init_to_py_none(lhs, self.return_type)
1387         else:
1388             val = self.return_type.default_value
1389             if val:
1390                 code.putln("%s = %s;" % (Naming.retval_cname, val))
1391         # ----- Error cleanup
1392         if code.error_label in code.labels_used:
1393             code.put_goto(code.return_label)
1394             code.put_label(code.error_label)
1395             for cname, type in code.funcstate.all_managed_temps():
1396                 code.put_xdecref(cname, type)
1397
1398             # Clean up buffers -- this calls a Python function
1399             # so need to save and restore error state
1400             buffers_present = len(lenv.buffer_entries) > 0
1401             if buffers_present:
1402                 code.globalstate.use_utility_code(restore_exception_utility_code)
1403                 code.putln("{ PyObject *__pyx_type, *__pyx_value, *__pyx_tb;")
1404                 code.putln("__Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb);")
1405                 for entry in lenv.buffer_entries:
1406                     Buffer.put_release_buffer_code(code, entry)
1407                     #code.putln("%s = 0;" % entry.cname)
1408                 code.putln("__Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);}")
1409
1410             err_val = self.error_value()
1411             exc_check = self.caller_will_check_exceptions()
1412             if err_val is not None or exc_check:
1413                 # TODO: Fix exception tracing (though currently unused by cProfile).
1414                 # code.globalstate.use_utility_code(get_exception_tuple_utility_code)
1415                 # code.put_trace_exception()
1416                 code.putln('__Pyx_AddTraceback("%s");' % self.entry.qualified_name)
1417             else:
1418                 warning(self.entry.pos, "Unraisable exception in function '%s'." \
1419                             % self.entry.qualified_name, 0)
1420                 code.putln(
1421                     '__Pyx_WriteUnraisable("%s");' %
1422                         self.entry.qualified_name)
1423                 env.use_utility_code(unraisable_exception_utility_code)
1424                 env.use_utility_code(restore_exception_utility_code)
1425             default_retval = self.return_type.default_value
1426             if err_val is None and default_retval:
1427                 err_val = default_retval
1428             if err_val is not None:
1429                 code.putln("%s = %s;" % (Naming.retval_cname, err_val))
1430
1431             if is_getbuffer_slot:
1432                 self.getbuffer_error_cleanup(code)
1433
1434             # If we are using the non-error cleanup section we should
1435             # jump past it if we have an error. The if-test below determine
1436             # whether this section is used.
1437             if buffers_present or is_getbuffer_slot:
1438                 code.put_goto(code.return_from_error_cleanup_label)
1439
1440
1441         # ----- Non-error return cleanup
1442         code.put_label(code.return_label)
1443         for entry in lenv.buffer_entries:
1444             if entry.used:
1445                 Buffer.put_release_buffer_code(code, entry)
1446         if is_getbuffer_slot:
1447             self.getbuffer_normal_cleanup(code)
1448         # ----- Return cleanup for both error and no-error return
1449         code.put_label(code.return_from_error_cleanup_label)
1450         if not Options.init_local_none:
1451             for entry in lenv.var_entries:
1452                 if lenv.control_flow.get_state((entry.name, 'initialized')) is not True:
1453                     entry.xdecref_cleanup = 1
1454
1455         for entry in lenv.var_entries:
1456             if entry.type.is_pyobject:
1457                 if entry.used and not entry.in_closure:
1458                     code.put_var_decref(entry)
1459                 elif entry.in_closure and self.needs_closure:
1460                     code.put_giveref(entry.cname)
1461         # Decref any increfed args
1462         for entry in lenv.arg_entries:
1463             if entry.type.is_pyobject:
1464                 if entry.in_closure:
1465                     code.put_var_giveref(entry)
1466                 elif entry.assignments:
1467                     code.put_var_decref(entry)
1468         if self.needs_closure:
1469             code.put_decref(Naming.cur_scope_cname, lenv.scope_class.type)
1470
1471         # ----- Return
1472         # This code is duplicated in ModuleNode.generate_module_init_func
1473         if not lenv.nogil:
1474             default_retval = self.return_type.default_value
1475             err_val = self.error_value()
1476             if err_val is None and default_retval:
1477                 err_val = default_retval
1478             if self.return_type.is_pyobject:
1479                 code.put_xgiveref(self.return_type.as_pyobject(Naming.retval_cname))
1480
1481         if self.entry.is_special and self.entry.name == "__hash__":
1482             # Returning -1 for __hash__ is supposed to signal an error
1483             # We do as Python instances and coerce -1 into -2.
1484             code.putln("if (unlikely(%s == -1) && !PyErr_Occurred()) %s = -2;" % (
1485                     Naming.retval_cname, Naming.retval_cname))
1486
1487         if profile:
1488             if self.return_type.is_pyobject:
1489                 code.put_trace_return(Naming.retval_cname)
1490             else:
1491                 code.put_trace_return("Py_None")
1492         if not lenv.nogil:
1493             code.put_finish_refcount_context()
1494
1495         if acquire_gil:
1496             code.putln("#ifdef WITH_THREAD")
1497             code.putln("PyGILState_Release(_save);")
1498             code.putln("#endif")
1499
1500         if not self.return_type.is_void:
1501             code.putln("return %s;" % Naming.retval_cname)
1502
1503         code.putln("}")
1504
1505         if preprocessor_guard:
1506             code.putln("#endif /*!(%s)*/" % preprocessor_guard)
1507
1508         # ----- Go back and insert temp variable declarations
1509         tempvardecl_code.put_temp_declarations(code.funcstate)
1510         # ----- Python version
1511         code.exit_cfunc_scope()
1512         if self.py_func:
1513             self.py_func.generate_function_definitions(env, code)
1514         self.generate_wrapper_functions(code)
1515
1516     def declare_argument(self, env, arg):
1517         if arg.type.is_void:
1518             error(arg.pos, "Invalid use of 'void'")
1519         elif not arg.type.is_complete() and not arg.type.is_array:
1520             error(arg.pos,
1521                 "Argument type '%s' is incomplete" % arg.type)
1522         return env.declare_arg(arg.name, arg.type, arg.pos)
1523
1524     def generate_arg_type_test(self, arg, code):
1525         # Generate type test for one argument.
1526         if arg.type.typeobj_is_available():
1527             code.globalstate.use_utility_code(arg_type_test_utility_code)
1528             typeptr_cname = arg.type.typeptr_cname
1529             arg_code = "((PyObject *)%s)" % arg.entry.cname
1530             code.putln(
1531                 'if (unlikely(!__Pyx_ArgTypeTest(%s, %s, %d, "%s", %s))) %s' % (
1532                     arg_code,
1533                     typeptr_cname,
1534                     arg.accept_none,
1535                     arg.name,
1536                     arg.type.is_builtin_type,
1537                     code.error_goto(arg.pos)))
1538         else:
1539             error(arg.pos, "Cannot test type of extern C class "
1540                 "without type object name specification")
1541
1542     def generate_arg_none_check(self, arg, code):
1543         # Generate None check for one argument.
1544         code.globalstate.use_utility_code(arg_type_test_utility_code)
1545         code.putln('if (unlikely(((PyObject *)%s) == Py_None)) {' % arg.entry.cname)
1546         code.putln('''PyErr_Format(PyExc_TypeError, "Argument '%s' must not be None"); %s''' % (
1547             arg.name,
1548             code.error_goto(arg.pos)))
1549         code.putln('}')
1550
1551     def generate_wrapper_functions(self, code):
1552         pass
1553
1554     def generate_execution_code(self, code):
1555         # Evaluate and store argument default values
1556         for arg in self.args:
1557             default = arg.default
1558             if default:
1559                 if not default.is_literal:
1560                     default.generate_evaluation_code(code)
1561                     default.make_owned_reference(code)
1562                     result = default.result_as(arg.type)
1563                     code.putln(
1564                         "%s = %s;" % (
1565                             arg.calculate_default_value_code(code),
1566                             result))
1567                     if arg.type.is_pyobject:
1568                         code.put_giveref(default.result())
1569                     default.generate_post_assignment_code(code)
1570                     default.free_temps(code)
1571         # For Python class methods, create and store function object
1572         if self.assmt:
1573             self.assmt.generate_execution_code(code)
1574
1575     #
1576     # Special code for the __getbuffer__ function
1577     #
1578     def getbuffer_init(self, code):
1579         info = self.local_scope.arg_entries[1].cname
1580         # Python 3.0 betas have a bug in memoryview which makes it call
1581         # getbuffer with a NULL parameter. For now we work around this;
1582         # the following line should be removed when this bug is fixed.
1583         code.putln("if (%s == NULL) return 0;" % info)
1584         code.putln("%s->obj = Py_None; __Pyx_INCREF(Py_None);" % info)
1585         code.put_giveref("%s->obj" % info) # Do not refnanny object within structs
1586
1587     def getbuffer_error_cleanup(self, code):
1588         info = self.local_scope.arg_entries[1].cname
1589         code.put_gotref("%s->obj" % info)
1590         code.putln("__Pyx_DECREF(%s->obj); %s->obj = NULL;" %
1591                    (info, info))
1592
1593     def getbuffer_normal_cleanup(self, code):
1594         info = self.local_scope.arg_entries[1].cname
1595         code.putln("if (%s->obj == Py_None) {" % info)
1596         code.put_gotref("Py_None")
1597         code.putln("__Pyx_DECREF(Py_None); %s->obj = NULL;" % info)
1598         code.putln("}")
1599
1600 class CFuncDefNode(FuncDefNode):
1601     #  C function definition.
1602     #
1603     #  modifiers     ['inline']
1604     #  visibility    'private' or 'public' or 'extern'
1605     #  base_type     CBaseTypeNode
1606     #  declarator    CDeclaratorNode
1607     #  body          StatListNode
1608     #  api           boolean
1609     #  decorators    [DecoratorNode]        list of decorators
1610     #
1611     #  with_gil      boolean    Acquire GIL around body
1612     #  type          CFuncType
1613     #  py_func       wrapper for calling from Python
1614     #  overridable   whether or not this is a cpdef function
1615     #  inline_in_pxd whether this is an inline function in a pxd file
1616
1617     child_attrs = ["base_type", "declarator", "body", "py_func"]
1618
1619     inline_in_pxd = False
1620     decorators = None
1621     directive_locals = {}
1622
1623     def unqualified_name(self):
1624         return self.entry.name
1625
1626     def analyse_declarations(self, env):
1627         self.directive_locals.update(env.directives['locals'])
1628         base_type = self.base_type.analyse(env)
1629         # The 2 here is because we need both function and argument names.
1630         name_declarator, type = self.declarator.analyse(base_type, env, nonempty = 2 * (self.body is not None))
1631         if not type.is_cfunction:
1632             error(self.pos,
1633                 "Suite attached to non-function declaration")
1634         # Remember the actual type according to the function header
1635         # written here, because the type in the symbol table entry
1636         # may be different if we're overriding a C method inherited
1637         # from the base type of an extension type.
1638         self.type = type
1639         type.is_overridable = self.overridable
1640         declarator = self.declarator
1641         while not hasattr(declarator, 'args'):
1642             declarator = declarator.base
1643         self.args = declarator.args
1644         for formal_arg, type_arg in zip(self.args, type.args):
1645             formal_arg.type = type_arg.type
1646             formal_arg.name = type_arg.name
1647             formal_arg.cname = type_arg.cname
1648         name = name_declarator.name
1649         cname = name_declarator.cname
1650         self.entry = env.declare_cfunction(
1651             name, type, self.pos,
1652             cname = cname, visibility = self.visibility,
1653             defining = self.body is not None,
1654             api = self.api, modifiers = self.modifiers)
1655         self.entry.inline_func_in_pxd = self.inline_in_pxd
1656         self.return_type = type.return_type
1657
1658         if self.overridable and not env.is_module_scope:
1659             if len(self.args) < 1 or not self.args[0].type.is_pyobject:
1660                 # An error will be produced in the cdef function
1661                 self.overridable = False
1662
1663         if self.overridable:
1664             import ExprNodes
1665             py_func_body = self.call_self_node(is_module_scope = env.is_module_scope)
1666             self.py_func = DefNode(pos = self.pos,
1667                                    name = self.entry.name,
1668                                    args = self.args,
1669                                    star_arg = None,
1670                                    starstar_arg = None,
1671                                    doc = self.doc,
1672                                    body = py_func_body,
1673                                    is_wrapper = 1)
1674             self.py_func.is_module_scope = env.is_module_scope
1675             self.py_func.analyse_declarations(env)
1676             self.entry.as_variable = self.py_func.entry
1677             # Reset scope entry the above cfunction
1678             env.entries[name] = self.entry
1679             if not env.is_module_scope or Options.lookup_module_cpdef:
1680                 self.override = OverrideCheckNode(self.pos, py_func = self.py_func)
1681                 self.body = StatListNode(self.pos, stats=[self.override, self.body])
1682         self.create_local_scope(env)
1683
1684     def call_self_node(self, omit_optional_args=0, is_module_scope=0):
1685         import ExprNodes
1686         args = self.type.args
1687         if omit_optional_args:
1688             args = args[:len(args) - self.type.optional_arg_count]
1689         arg_names = [arg.name for arg in args]
1690         if is_module_scope:
1691             cfunc = ExprNodes.NameNode(self.pos, name=self.entry.name)
1692         else:
1693             self_arg = ExprNodes.NameNode(self.pos, name=arg_names[0])
1694             cfunc = ExprNodes.AttributeNode(self.pos, obj=self_arg, attribute=self.entry.name)
1695         skip_dispatch = not is_module_scope or Options.lookup_module_cpdef
1696         c_call = ExprNodes.SimpleCallNode(self.pos, function=cfunc, args=[ExprNodes.NameNode(self.pos, name=n) for n in arg_names[1-is_module_scope:]], wrapper_call=skip_dispatch)
1697         return ReturnStatNode(pos=self.pos, return_type=PyrexTypes.py_object_type, value=c_call)
1698
1699     def declare_arguments(self, env):
1700         for arg in self.type.args:
1701             if not arg.name:
1702                 error(arg.pos, "Missing argument name")
1703             self.declare_argument(env, arg)
1704
1705     def need_gil_acquisition(self, lenv):
1706         return self.type.with_gil
1707
1708     def nogil_check(self, env):
1709         type = self.type
1710         with_gil = type.with_gil
1711         if type.nogil and not with_gil:
1712             if type.return_type.is_pyobject:
1713                 error(self.pos,
1714                       "Function with Python return type cannot be declared nogil")
1715             for entry in self.local_scope.var_entries:
1716                 if entry.type.is_pyobject:
1717                     error(self.pos, "Function declared nogil has Python locals or temporaries")
1718
1719     def analyse_expressions(self, env):
1720         self.local_scope.directives = env.directives
1721         if self.py_func is not None:
1722             # this will also analyse the default values
1723             self.py_func.analyse_expressions(env)
1724         else:
1725             self.analyse_default_values(env)
1726         self.acquire_gil = self.need_gil_acquisition(self.local_scope)
1727
1728     def needs_assignment_synthesis(self, env, code=None):
1729         return False
1730
1731     def generate_function_header(self, code, with_pymethdef, with_opt_args = 1, with_dispatch = 1, cname = None):
1732         arg_decls = []
1733         type = self.type
1734         visibility = self.entry.visibility
1735         for arg in type.args[:len(type.args)-type.optional_arg_count]:
1736             arg_decls.append(arg.declaration_code())
1737         if with_dispatch and self.overridable:
1738             arg_decls.append(PyrexTypes.c_int_type.declaration_code(Naming.skip_dispatch_cname))
1739         if type.optional_arg_count and with_opt_args:
1740             arg_decls.append(type.op_arg_struct.declaration_code(Naming.optional_args_cname))
1741         if type.has_varargs:
1742             arg_decls.append("...")
1743         if not arg_decls:
1744             arg_decls = ["void"]
1745         if cname is None:
1746             cname = self.entry.func_cname
1747         entity = type.function_header_code(cname, ', '.join(arg_decls))
1748         if visibility == 'public':
1749             dll_linkage = "DL_EXPORT"
1750         else:
1751             dll_linkage = None
1752         header = self.return_type.declaration_code(entity,
1753             dll_linkage = dll_linkage)
1754         if visibility == 'extern':
1755             storage_class = "%s " % Naming.extern_c_macro
1756         elif visibility == 'public':
1757             storage_class = ""
1758         else:
1759             storage_class = "static "
1760         if 'inline' in self.modifiers:
1761             self.modifiers[self.modifiers.index('inline')] = 'cython_inline'
1762         code.putln("%s%s %s {" % (
1763             storage_class,
1764             ' '.join(self.modifiers).upper(), # macro forms
1765             header))
1766
1767     def generate_argument_declarations(self, env, code):
1768         for arg in self.args:
1769             if arg.default:
1770                 result = arg.calculate_default_value_code(code)
1771                 code.putln('%s = %s;' % (
1772                     arg.type.declaration_code(arg.cname), result))
1773
1774     def generate_keyword_list(self, code):
1775         pass
1776
1777     def generate_argument_parsing_code(self, env, code):
1778         i = 0
1779         if self.type.optional_arg_count:
1780             code.putln('if (%s) {' % Naming.optional_args_cname)
1781             for arg in self.args:
1782                 if arg.default:
1783                     code.putln('if (%s->%sn > %s) {' % (Naming.optional_args_cname, Naming.pyrex_prefix, i))
1784                     declarator = arg.declarator
1785                     while not hasattr(declarator, 'name'):
1786                         declarator = declarator.base
1787                     code.putln('%s = %s->%s;' % (arg.cname, Naming.optional_args_cname, self.type.opt_arg_cname(declarator.name)))
1788                     i += 1
1789             for _ in range(self.type.optional_arg_count):
1790                 code.putln('}')
1791             code.putln('}')
1792
1793     def generate_argument_conversion_code(self, code):
1794         pass
1795
1796     def generate_argument_type_tests(self, code):
1797         # Generate type tests for args whose type in a parent
1798         # class is a supertype of the declared type.
1799         for arg in self.type.args:
1800             if arg.needs_type_test:
1801                 self.generate_arg_type_test(arg, code)
1802             elif arg.type.is_pyobject and not arg.accept_none:
1803                 self.generate_arg_none_check(arg, code)
1804
1805     def error_value(self):
1806         if self.return_type.is_pyobject:
1807             return "0"
1808         else:
1809             #return None
1810             return self.entry.type.exception_value
1811
1812     def caller_will_check_exceptions(self):
1813         return self.entry.type.exception_check
1814
1815     def generate_wrapper_functions(self, code):
1816         # If the C signature of a function has changed, we need to generate
1817         # wrappers to put in the slots here.
1818         k = 0
1819         entry = self.entry
1820         func_type = entry.type
1821         while entry.prev_entry is not None:
1822             k += 1
1823             entry = entry.prev_entry
1824             entry.func_cname = "%s%swrap_%s" % (self.entry.func_cname, Naming.pyrex_prefix, k)
1825             code.putln()
1826             self.generate_function_header(code,
1827                                           0,
1828                                           with_dispatch = entry.type.is_overridable,
1829                                           with_opt_args = entry.type.optional_arg_count,
1830                                           cname = entry.func_cname)
1831             if not self.return_type.is_void:
1832                 code.put('return ')
1833             args = self.type.args
1834             arglist = [arg.cname for arg in args[:len(args)-self.type.optional_arg_count]]
1835             if entry.type.is_overridable:
1836                 arglist.append(Naming.skip_dispatch_cname)
1837             elif func_type.is_overridable:
1838                 arglist.append('0')
1839             if entry.type.optional_arg_count:
1840                 arglist.append(Naming.optional_args_cname)
1841             elif func_type.optional_arg_count:
1842                 arglist.append('NULL')
1843             code.putln('%s(%s);' % (self.entry.func_cname, ', '.join(arglist)))
1844             code.putln('}')
1845
1846
1847 class PyArgDeclNode(Node):
1848     # Argument which must be a Python object (used
1849     # for * and ** arguments).
1850     #
1851     # name        string
1852     # entry       Symtab.Entry
1853     # annotation  ExprNode or None   Py3 argument annotation
1854     child_attrs = []
1855
1856     def generate_function_definitions(self, env, code):
1857         self.entry.generate_function_definitions(env, code)
1858
1859 class DecoratorNode(Node):
1860     # A decorator
1861     #
1862     # decorator    NameNode or CallNode or AttributeNode
1863     child_attrs = ['decorator']
1864
1865
1866 class DefNode(FuncDefNode):
1867     # A Python function definition.
1868     #
1869     # name          string                 the Python name of the function
1870     # lambda_name   string                 the internal name of a lambda 'function'
1871     # decorators    [DecoratorNode]        list of decorators
1872     # args          [CArgDeclNode]         formal arguments
1873     # star_arg      PyArgDeclNode or None  * argument
1874     # starstar_arg  PyArgDeclNode or None  ** argument
1875     # doc           EncodedString or None
1876     # body          StatListNode
1877     # return_type_annotation
1878     #               ExprNode or None       the Py3 return type annotation
1879     #
1880     #  The following subnode is constructed internally
1881     #  when the def statement is inside a Python class definition.
1882     #
1883     #  assmt   AssignmentNode   Function construction/assignment
1884
1885     child_attrs = ["args", "star_arg", "starstar_arg", "body", "decorators"]
1886
1887     lambda_name = None
1888     assmt = None
1889     num_kwonly_args = 0
1890     num_required_kw_args = 0
1891     reqd_kw_flags_cname = "0"
1892     is_wrapper = 0
1893     decorators = None
1894     return_type_annotation = None
1895     entry = None
1896     acquire_gil = 0
1897     self_in_stararg = 0
1898
1899     def __init__(self, pos, **kwds):
1900         FuncDefNode.__init__(self, pos, **kwds)
1901         k = rk = r = 0
1902         for arg in self.args:
1903             if arg.kw_only:
1904                 k += 1
1905                 if not arg.default:
1906                     rk += 1
1907             if not arg.default:
1908                 r += 1
1909         self.num_kwonly_args = k
1910         self.num_required_kw_args = rk
1911         self.num_required_args = r
1912
1913     def as_cfunction(self, cfunc=None, scope=None):
1914         if self.star_arg:
1915             error(self.star_arg.pos, "cdef function cannot have star argument")
1916         if self.starstar_arg:
1917             error(self.starstar_arg.pos, "cdef function cannot have starstar argument")
1918         if cfunc is None:
1919             cfunc_args = []
1920             for formal_arg in self.args:
1921                 name_declarator, type = formal_arg.analyse(scope, nonempty=1)
1922                 cfunc_args.append(PyrexTypes.CFuncTypeArg(name = name_declarator.name,
1923                                                           cname = None,
1924                                                           type = py_object_type,
1925                                                           pos = formal_arg.pos))
1926             cfunc_type = PyrexTypes.CFuncType(return_type = py_object_type,
1927                                               args = cfunc_args,
1928                                               has_varargs = False,
1929                                               exception_value = None,
1930                                               exception_check = False,
1931                                               nogil = False,
1932                                               with_gil = False,
1933                                               is_overridable = True)
1934             cfunc = CVarDefNode(self.pos, type=cfunc_type)
1935         else:
1936             if scope is None:
1937                 scope = cfunc.scope
1938             cfunc_type = cfunc.type
1939             if len(self.args) != len(cfunc_type.args) or cfunc_type.has_varargs:
1940                 error(self.pos, "wrong number of arguments")
1941                 error(cfunc.pos, "previous declaration here")
1942             for i, (formal_arg, type_arg) in enumerate(zip(self.args, cfunc_type.args)):
1943                 name_declarator, type = formal_arg.analyse(scope, nonempty=1,
1944                                                            is_self_arg = (i == 0 and scope.is_c_class_scope))
1945                 if type is None or type is PyrexTypes.py_object_type:
1946                     formal_arg.type = type_arg.type
1947                     formal_arg.name_declarator = name_declarator
1948         import ExprNodes
1949         if cfunc_type.exception_value is None:
1950             exception_value = None
1951         else:
1952             exception_value = ExprNodes.ConstNode(self.pos, value=cfunc_type.exception_value, type=cfunc_type.return_type)
1953         declarator = CFuncDeclaratorNode(self.pos,
1954                                          base = CNameDeclaratorNode(self.pos, name=self.name, cname=None),
1955                                          args = self.args,
1956                                          has_varargs = False,
1957                                          exception_check = cfunc_type.exception_check,
1958                                          exception_value = exception_value,
1959                                          with_gil = cfunc_type.with_gil,
1960                                          nogil = cfunc_type.nogil)
1961         return CFuncDefNode(self.pos,
1962                             modifiers = [],
1963                             base_type = CAnalysedBaseTypeNode(self.pos, type=cfunc_type.return_type),
1964                             declarator = declarator,
1965                             body = self.body,
1966                             doc = self.doc,
1967                             overridable = cfunc_type.is_overridable,
1968                             type = cfunc_type,
1969                             with_gil = cfunc_type.with_gil,
1970                             nogil = cfunc_type.nogil,
1971                             visibility = 'private',
1972                             api = False,
1973                             directive_locals = getattr(cfunc, 'directive_locals', {}))
1974
1975     def analyse_declarations(self, env):
1976         self.is_classmethod = self.is_staticmethod = False
1977         if self.decorators:
1978             for decorator in self.decorators:
1979                 func = decorator.decorator
1980                 if func.is_name:
1981                     self.is_classmethod |= func.name == 'classmethod'
1982                     self.is_staticmethod |= func.name == 'staticmethod'
1983
1984         if self.is_classmethod and env.lookup_here('classmethod'):
1985             # classmethod() was overridden - not much we can do here ...
1986             self.is_classmethod = False
1987         if self.is_staticmethod and env.lookup_here('staticmethod'):
1988             # staticmethod() was overridden - not much we can do here ...
1989             self.is_staticmethod = False
1990
1991         if self.name == '__new__':
1992             self.is_staticmethod = 1
1993
1994         self.analyse_argument_types(env)
1995         if self.name == '<lambda>':
1996             self.declare_lambda_function(env)
1997         else:
1998             self.declare_pyfunction(env)
1999         self.analyse_signature(env)
2000         self.return_type = self.entry.signature.return_type()
2001         self.create_local_scope(env)
2002
2003     def analyse_argument_types(self, env):
2004         directive_locals = self.directive_locals = env.directives['locals']
2005         allow_none_for_extension_args = env.directives['allow_none_for_extension_args']
2006         for arg in self.args:
2007             if hasattr(arg, 'name'):
2008                 type = arg.type
2009                 name_declarator = None
2010             else:
2011                 base_type = arg.base_type.analyse(env)
2012                 name_declarator, type = \
2013                     arg.declarator.analyse(base_type, env)
2014                 arg.name = name_declarator.name
2015             if arg.name in directive_locals:
2016                 type_node = directive_locals[arg.name]
2017                 other_type = type_node.analyse_as_type(env)
2018                 if other_type is None:
2019                     error(type_node.pos, "Not a type")
2020                 elif (type is not PyrexTypes.py_object_type
2021                         and not type.same_as(other_type)):
2022                     error(arg.base_type.pos, "Signature does not agree with previous declaration")
2023                     error(type_node.pos, "Previous declaration here")
2024                 else:
2025                     type = other_type
2026             if name_declarator and name_declarator.cname:
2027                 error(self.pos,
2028                     "Python function argument cannot have C name specification")
2029             arg.type = type.as_argument_type()
2030             arg.hdr_type = None
2031             arg.needs_conversion = 0
2032             arg.needs_type_test = 0
2033             arg.is_generic = 1
2034             if arg.type.is_pyobject:
2035                 if arg.or_none:
2036                     arg.accept_none = True
2037                 elif arg.not_none:
2038                     arg.accept_none = False
2039                 elif arg.type.is_extension_type or arg.type.is_builtin_type:
2040                     if arg.default and arg.default.constant_result is None:
2041                         # special case: def func(MyType obj = None)
2042                         arg.accept_none = True
2043                     else:
2044                         # default depends on compiler directive
2045                         arg.accept_none = allow_none_for_extension_args
2046                 else:
2047                     # probably just a plain 'object'
2048                     arg.accept_none = True
2049             else:
2050                 arg.accept_none = True # won't be used, but must be there
2051                 if arg.not_none:
2052                     error(arg.pos, "Only Python type arguments can have 'not None'")
2053                 if arg.or_none:
2054                     error(arg.pos, "Only Python type arguments can have 'or None'")
2055
2056     def analyse_signature(self, env):
2057         if self.entry.is_special:
2058             self.entry.trivial_signature = len(self.args) == 1 and not (self.star_arg or self.starstar_arg)
2059         elif not env.directives['always_allow_keywords'] and not (self.star_arg or self.starstar_arg):
2060             # Use the simpler calling signature for zero- and one-argument functions.
2061             if self.entry.signature is TypeSlots.pyfunction_signature:
2062                 if len(self.args) == 0:
2063                     self.entry.signature = TypeSlots.pyfunction_noargs
2064                 elif len(self.args) == 1:
2065                     if self.args[0].default is None and not self.args[0].kw_only:
2066                         self.entry.signature = TypeSlots.pyfunction_onearg
2067             elif self.entry.signature is TypeSlots.pymethod_signature:
2068                 if len(self.args) == 1:
2069                     self.entry.signature = TypeSlots.unaryfunc
2070                 elif len(self.args) == 2:
2071                     if self.args[1].default is None and not self.args[1].kw_only:
2072                         self.entry.signature = TypeSlots.ibinaryfunc
2073
2074         sig = self.entry.signature
2075         nfixed = sig.num_fixed_args()
2076         if sig is TypeSlots.pymethod_signature and nfixed == 1 \
2077                and len(self.args) == 0 and self.star_arg:
2078             # this is the only case where a diverging number of
2079             # arguments is not an error - when we have no explicit
2080             # 'self' parameter as in method(*args)
2081             sig = self.entry.signature = TypeSlots.pyfunction_signature # self is not 'really' used
2082             self.self_in_stararg = 1
2083             nfixed = 0
2084
2085         for i in range(min(nfixed, len(self.args))):
2086             arg = self.args[i]
2087             arg.is_generic = 0
2088             if sig.is_self_arg(i) and not self.is_staticmethod:
2089                 if self.is_classmethod:
2090                     arg.is_type_arg = 1
2091                     arg.hdr_type = arg.type = Builtin.type_type
2092                 else:
2093                     arg.is_self_arg = 1
2094                     arg.hdr_type = arg.type = env.parent_type
2095                 arg.needs_conversion = 0
2096             else:
2097                 arg.hdr_type = sig.fixed_arg_type(i)
2098                 if not arg.type.same_as(arg.hdr_type):
2099                     if arg.hdr_type.is_pyobject and arg.type.is_pyobject:
2100                         arg.needs_type_test = 1
2101                     else:
2102                         arg.needs_conversion = 1
2103             if arg.needs_conversion:
2104                 arg.hdr_cname = Naming.arg_prefix + arg.name
2105             else:
2106                 arg.hdr_cname = Naming.var_prefix + arg.name
2107
2108         if nfixed > len(self.args):
2109             self.bad_signature()
2110             return
2111         elif nfixed < len(self.args):
2112             if not sig.has_generic_args:
2113                 self.bad_signature()
2114             for arg in self.args:
2115                 if arg.is_generic and \
2116                         (arg.type.is_extension_type or arg.type.is_builtin_type):
2117                     arg.needs_type_test = 1
2118
2119     def bad_signature(self):
2120         sig = self.entry.signature
2121         expected_str = "%d" % sig.num_fixed_args()
2122         if sig.has_generic_args:
2123             expected_str = expected_str + " or more"
2124         name = self.name
2125         if name.startswith("__") and name.endswith("__"):
2126             desc = "Special method"
2127         else:
2128             desc = "Method"
2129         error(self.pos,
2130             "%s %s has wrong number of arguments "
2131             "(%d declared, %s expected)" % (
2132                 desc, self.name, len(self.args), expected_str))
2133
2134     def signature_has_nongeneric_args(self):
2135         argcount = len(self.args)
2136         if argcount == 0 or (
2137                 argcount == 1 and (self.args[0].is_self_arg or
2138                                    self.args[0].is_type_arg)):
2139             return 0
2140         return 1
2141
2142     def signature_has_generic_args(self):
2143         return self.entry.signature.has_generic_args
2144
2145     def declare_pyfunction(self, env):
2146         #print "DefNode.declare_pyfunction:", self.name, "in", env ###
2147         name = self.name
2148         entry = env.lookup_here(name)
2149         if entry and entry.type.is_cfunction and not self.is_wrapper:
2150             warning(self.pos, "Overriding cdef method with def method.", 5)
2151         entry = env.declare_pyfunction(name, self.pos)
2152         self.entry = entry
2153         prefix = env.scope_prefix
2154         entry.func_cname = \
2155             Naming.pyfunc_prefix + prefix + name
2156         entry.pymethdef_cname = \
2157             Naming.pymethdef_prefix + prefix + name
2158         if Options.docstrings:
2159             entry.doc = embed_position(self.pos, self.doc)
2160             entry.doc_cname = \
2161                 Naming.funcdoc_prefix + prefix + name
2162             if entry.is_special:
2163                 if entry.name in TypeSlots.invisible or not entry.doc or (entry.name in '__getattr__' and env.directives['fast_getattr']):
2164                     entry.wrapperbase_cname = None
2165                 else:
2166                     entry.wrapperbase_cname = Naming.wrapperbase_prefix + prefix + name
2167         else:
2168             entry.doc = None
2169
2170     def declare_lambda_function(self, env):
2171         name = self.name
2172         prefix = env.scope_prefix
2173         func_cname = \
2174             Naming.lambda_func_prefix + u'funcdef' + prefix + self.lambda_name
2175         entry = env.declare_lambda_function(func_cname, self.pos)
2176         entry.pymethdef_cname = \
2177             Naming.lambda_func_prefix + u'methdef' + prefix + self.lambda_name
2178         entry.qualified_name = env.qualify_name(self.lambda_name)
2179         entry.doc = None
2180         self.entry = entry
2181
2182     def declare_arguments(self, env):
2183         for arg in self.args:
2184             if not arg.name:
2185                 error(arg.pos, "Missing argument name")
2186             else:
2187                 env.control_flow.set_state((), (arg.name, 'source'), 'arg')
2188                 env.control_flow.set_state((), (arg.name, 'initialized'), True)
2189             if arg.needs_conversion:
2190                 arg.entry = env.declare_var(arg.name, arg.type, arg.pos)
2191                 if arg.type.is_pyobject:
2192                     arg.entry.init = "0"
2193                 arg.entry.init_to_none = 0
2194             else:
2195                 arg.entry = self.declare_argument(env, arg)
2196             arg.entry.used = 1
2197             arg.entry.is_self_arg = arg.is_self_arg
2198             if arg.hdr_type:
2199                 if arg.is_self_arg or arg.is_type_arg or \
2200                     (arg.type.is_extension_type and not arg.hdr_type.is_extension_type):
2201                         arg.entry.is_declared_generic = 1
2202         self.declare_python_arg(env, self.star_arg)
2203         self.declare_python_arg(env, self.starstar_arg)
2204
2205     def declare_python_arg(self, env, arg):
2206         if arg:
2207             if env.directives['infer_types'] != False:
2208                 type = PyrexTypes.unspecified_type
2209             else:
2210                 type = py_object_type
2211             entry = env.declare_var(arg.name, type, arg.pos)
2212             entry.used = 1
2213             entry.init = "0"
2214             entry.init_to_none = 0
2215             entry.xdecref_cleanup = 1
2216             arg.entry = entry
2217             env.control_flow.set_state((), (arg.name, 'initialized'), True)
2218
2219     def analyse_expressions(self, env):
2220         self.local_scope.directives = env.directives
2221         self.analyse_default_values(env)
2222         if self.needs_assignment_synthesis(env):
2223             # Shouldn't we be doing this at the module level too?
2224             self.synthesize_assignment_node(env)
2225
2226     def needs_assignment_synthesis(self, env, code=None):
2227         # Should enable for module level as well, that will require more testing...
2228         if self.entry.is_lambda:
2229             return True
2230         if env.is_module_scope:
2231             if code is None:
2232                 return env.directives['binding']
2233             else:
2234                 return code.globalstate.directives['binding']
2235         return env.is_py_class_scope or env.is_closure_scope
2236
2237     def synthesize_assignment_node(self, env):
2238         import ExprNodes
2239         genv = env
2240         while genv.is_py_class_scope or genv.is_c_class_scope:
2241             genv = genv.outer_scope
2242
2243         if genv.is_closure_scope:
2244             rhs = ExprNodes.InnerFunctionNode(
2245                 self.pos, pymethdef_cname = self.entry.pymethdef_cname)
2246         else:
2247             rhs = ExprNodes.PyCFunctionNode(
2248                 self.pos, pymethdef_cname = self.entry.pymethdef_cname, binding = env.directives['binding'])
2249
2250         if env.is_py_class_scope:
2251             if not self.is_staticmethod and not self.is_classmethod:
2252                 rhs.binding = True
2253
2254         self.assmt = SingleAssignmentNode(self.pos,
2255             lhs = ExprNodes.NameNode(self.pos, name = self.name),
2256             rhs = rhs)
2257         self.assmt.analyse_declarations(env)
2258         self.assmt.analyse_expressions(env)
2259
2260     def generate_function_header(self, code, with_pymethdef, proto_only=0):
2261         arg_code_list = []
2262         sig = self.entry.signature
2263         if sig.has_dummy_arg or self.self_in_stararg:
2264             arg_code_list.append(
2265                 "PyObject *%s" % Naming.self_cname)
2266         for arg in self.args:
2267             if not arg.is_generic:
2268                 if arg.is_self_arg or arg.is_type_arg:
2269                     arg_code_list.append("PyObject *%s" % arg.hdr_cname)
2270                 else:
2271                     arg_code_list.append(
2272                         arg.hdr_type.declaration_code(arg.hdr_cname))
2273         if not self.entry.is_special and sig.method_flags() == [TypeSlots.method_noargs]:
2274             arg_code_list.append("CYTHON_UNUSED PyObject *unused")
2275         if sig.has_generic_args:
2276             arg_code_list.append(
2277                 "PyObject *%s, PyObject *%s"
2278                     % (Naming.args_cname, Naming.kwds_cname))
2279         arg_code = ", ".join(arg_code_list)
2280         dc = self.return_type.declaration_code(self.entry.func_cname)
2281         mf = " ".join(self.modifiers).upper()
2282         if mf: mf += " "
2283         header = "static %s%s(%s)" % (mf, dc, arg_code)
2284         code.putln("%s; /*proto*/" % header)
2285         if proto_only:
2286             return
2287         if (Options.docstrings and self.entry.doc and
2288                 not self.entry.scope.is_property_scope and
2289                 (not self.entry.is_special or self.entry.wrapperbase_cname)):
2290             docstr = self.entry.doc
2291             if docstr.is_unicode:
2292                 docstr = docstr.utf8encode()
2293             code.putln(
2294                 'static char %s[] = "%s";' % (
2295                     self.entry.doc_cname,
2296                     split_string_literal(escape_byte_string(docstr))))
2297             if self.entry.is_special:
2298                 code.putln(
2299                     "struct wrapperbase %s;" % self.entry.wrapperbase_cname)
2300         if with_pymethdef:
2301             code.put(
2302                 "static PyMethodDef %s = " %
2303                     self.entry.pymethdef_cname)
2304             code.put_pymethoddef(self.entry, ";", allow_skip=False)
2305         code.putln("%s {" % header)
2306
2307     def generate_argument_declarations(self, env, code):
2308         for arg in self.args:
2309             if arg.is_generic: # or arg.needs_conversion:
2310                 if arg.needs_conversion:
2311                     code.putln("PyObject *%s = 0;" % arg.hdr_cname)
2312                 elif not arg.entry.in_closure:
2313                     code.put_var_declaration(arg.entry)
2314
2315     def generate_keyword_list(self, code):
2316         if self.signature_has_generic_args() and \
2317                 self.signature_has_nongeneric_args():
2318             code.put(
2319                 "static PyObject **%s[] = {" %
2320                     Naming.pykwdlist_cname)
2321             for arg in self.args:
2322                 if arg.is_generic:
2323                     pystring_cname = code.intern_identifier(arg.name)
2324                     code.put('&%s,' % pystring_cname)
2325             code.putln("0};")
2326
2327     def generate_argument_parsing_code(self, env, code):
2328         # Generate PyArg_ParseTuple call for generic
2329         # arguments, if any.
2330         if self.entry.signature.has_dummy_arg and not self.self_in_stararg:
2331             # get rid of unused argument warning
2332             code.putln("%s = %s;" % (Naming.self_cname, Naming.self_cname))
2333
2334         old_error_label = code.new_error_label()
2335         our_error_label = code.error_label
2336         end_label = code.new_label("argument_unpacking_done")
2337
2338         has_kwonly_args = self.num_kwonly_args > 0
2339         has_star_or_kw_args = self.star_arg is not None \
2340             or self.starstar_arg is not None or has_kwonly_args
2341
2342         for arg in self.args:
2343             if not arg.type.is_pyobject:
2344                 done = arg.type.create_from_py_utility_code(env)
2345                 if not done: pass # will fail later
2346
2347         if not self.signature_has_generic_args():
2348             if has_star_or_kw_args:
2349                 error(self.pos, "This method cannot have * or keyword arguments")
2350             self.generate_argument_conversion_code(code)
2351
2352         elif not self.signature_has_nongeneric_args():
2353             # func(*args) or func(**kw) or func(*args, **kw)
2354             self.generate_stararg_copy_code(code)
2355
2356         else:
2357             positional_args = []
2358             kw_only_args = []
2359             for arg in self.args:
2360                 arg_entry = arg.entry
2361                 if arg.is_generic:
2362                     if arg.default:
2363                         if not arg.is_self_arg and not arg.is_type_arg:
2364                             if arg.kw_only:
2365                                 kw_only_args.append(arg)
2366                             else:
2367                                 positional_args.append(arg)
2368                     elif arg.kw_only:
2369                         kw_only_args.append(arg)
2370                     elif not arg.is_self_arg and not arg.is_type_arg:
2371                         positional_args.append(arg)
2372
2373             self.generate_tuple_and_keyword_parsing_code(
2374                 positional_args, kw_only_args, end_label, code)
2375
2376         code.error_label = old_error_label
2377         if code.label_used(our_error_label):
2378             if not code.label_used(end_label):
2379                 code.put_goto(end_label)
2380             code.put_label(our_error_label)
2381             if has_star_or_kw_args:
2382                 self.generate_arg_decref(self.star_arg, code)
2383                 if self.starstar_arg:
2384                     if self.starstar_arg.entry.xdecref_cleanup:
2385                         code.put_var_xdecref(self.starstar_arg.entry)
2386                     else:
2387                         code.put_var_decref(self.starstar_arg.entry)
2388             code.putln('__Pyx_AddTraceback("%s");' % self.entry.qualified_name)
2389             # The arguments are put into the closure one after the
2390             # other, so when type errors are found, all references in
2391             # the closure instance must be properly ref-counted to
2392             # facilitate generic closure instance deallocation.  In
2393             # the case of an argument type error, it's best to just
2394             # DECREF+clear the already handled references, as this
2395             # frees their references as early as possible.
2396             for arg in self.args:
2397                 if arg.type.is_pyobject and arg.entry.in_closure:
2398                     code.put_var_xdecref_clear(arg.entry)
2399             if self.needs_closure:
2400                 code.put_decref(Naming.cur_scope_cname, self.local_scope.scope_class.type)
2401             code.put_finish_refcount_context()
2402             code.putln("return %s;" % self.error_value())
2403         if code.label_used(end_label):
2404             code.put_label(end_label)
2405
2406     def generate_arg_assignment(self, arg, item, code):
2407         if arg.type.is_pyobject:
2408             if arg.is_generic:
2409                 item = PyrexTypes.typecast(arg.type, PyrexTypes.py_object_type, item)
2410             entry = arg.entry
2411             code.putln("%s = %s;" % (entry.cname, item))
2412             if entry.in_closure:
2413                 code.put_var_incref(entry)
2414         else:
2415             func = arg.type.from_py_function
2416             if func:
2417                 code.putln("%s = %s(%s); %s" % (
2418                     arg.entry.cname,
2419                     func,
2420                     item,
2421                     code.error_goto_if(arg.type.error_condition(arg.entry.cname), arg.pos)))
2422             else:
2423                 error(arg.pos, "Cannot convert Python object argument to type '%s'" % arg.type)
2424
2425     def generate_arg_xdecref(self, arg, code):
2426         if arg:
2427             code.put_var_xdecref(arg.entry)
2428
2429     def generate_arg_decref(self, arg, code):
2430         if arg:
2431             code.put_var_decref(arg.entry)
2432
2433     def generate_stararg_copy_code(self, code):
2434         if not self.star_arg:
2435             code.globalstate.use_utility_code(raise_argtuple_invalid_utility_code)
2436             code.putln("if (unlikely(PyTuple_GET_SIZE(%s) > 0)) {" %
2437                        Naming.args_cname)
2438             code.put('__Pyx_RaiseArgtupleInvalid("%s", 1, 0, 0, PyTuple_GET_SIZE(%s)); return %s;' % (
2439                     self.name, Naming.args_cname, self.error_value()))
2440             code.putln("}")
2441
2442         code.globalstate.use_utility_code(keyword_string_check_utility_code)
2443
2444         if self.starstar_arg:
2445             if self.star_arg:
2446                 kwarg_check = "unlikely(%s)" % Naming.kwds_cname
2447             else:
2448                 kwarg_check = "%s" % Naming.kwds_cname
2449         else:
2450             kwarg_check = "unlikely(%s) && unlikely(PyDict_Size(%s) > 0)" % (
2451                 Naming.kwds_cname, Naming.kwds_cname)
2452         code.putln(
2453             "if (%s && unlikely(!__Pyx_CheckKeywordStrings(%s, \"%s\", %d))) return %s;" % (
2454                 kwarg_check, Naming.kwds_cname, self.name,
2455                 bool(self.starstar_arg), self.error_value()))
2456
2457         if self.starstar_arg:
2458             code.putln("%s = (%s) ? PyDict_Copy(%s) : PyDict_New();" % (
2459                     self.starstar_arg.entry.cname,
2460                     Naming.kwds_cname,
2461                     Naming.kwds_cname))
2462             code.putln("if (unlikely(!%s)) return %s;" % (
2463                     self.starstar_arg.entry.cname, self.error_value()))
2464             self.starstar_arg.entry.xdecref_cleanup = 0
2465             code.put_gotref(self.starstar_arg.entry.cname)
2466
2467         if self.self_in_stararg:
2468             # need to create a new tuple with 'self' inserted as first item
2469             code.put("%s = PyTuple_New(PyTuple_GET_SIZE(%s)+1); if (unlikely(!%s)) " % (
2470                     self.star_arg.entry.cname,
2471                     Naming.args_cname,
2472                     self.star_arg.entry.cname))
2473             if self.starstar_arg:
2474                 code.putln("{")
2475                 code.put_decref_clear(self.starstar_arg.entry.cname, py_object_type)
2476                 code.putln("return %s;" % self.error_value())
2477                 code.putln("}")
2478             else:
2479                 code.putln("return %s;" % self.error_value())
2480             code.put_gotref(self.star_arg.entry.cname)
2481             code.put_incref(Naming.self_cname, py_object_type)
2482             code.put_giveref(Naming.self_cname)
2483             code.putln("PyTuple_SET_ITEM(%s, 0, %s);" % (
2484                 self.star_arg.entry.cname, Naming.self_cname))
2485             temp = code.funcstate.allocate_temp(PyrexTypes.c_py_ssize_t_type, manage_ref=False)
2486             code.putln("for (%s=0; %s < PyTuple_GET_SIZE(%s); %s++) {" % (
2487                 temp, temp, Naming.args_cname, temp))
2488             code.putln("PyObject* item = PyTuple_GET_ITEM(%s, %s);" % (
2489                 Naming.args_cname, temp))
2490             code.put_incref("item", py_object_type)
2491             code.put_giveref("item")
2492             code.putln("PyTuple_SET_ITEM(%s, %s+1, item);" % (
2493                 self.star_arg.entry.cname, temp))
2494             code.putln("}")
2495             code.funcstate.release_temp(temp)
2496             self.star_arg.entry.xdecref_cleanup = 0
2497         elif self.star_arg:
2498             code.put_incref(Naming.args_cname, py_object_type)
2499             code.putln("%s = %s;" % (
2500                     self.star_arg.entry.cname,
2501                     Naming.args_cname))
2502             self.star_arg.entry.xdecref_cleanup = 0
2503
2504     def generate_tuple_and_keyword_parsing_code(self, positional_args,
2505                                                 kw_only_args, success_label, code):
2506         argtuple_error_label = code.new_label("argtuple_error")
2507
2508         min_positional_args = self.num_required_args - self.num_required_kw_args
2509         if len(self.args) > 0 and (self.args[0].is_self_arg or self.args[0].is_type_arg):
2510             min_positional_args -= 1
2511         max_positional_args = len(positional_args)
2512         has_fixed_positional_count = not self.star_arg and \
2513             min_positional_args == max_positional_args
2514
2515         code.globalstate.use_utility_code(raise_double_keywords_utility_code)
2516         code.globalstate.use_utility_code(raise_argtuple_invalid_utility_code)
2517         if self.num_required_kw_args:
2518             code.globalstate.use_utility_code(raise_keyword_required_utility_code)
2519
2520         if self.starstar_arg or self.star_arg:
2521             self.generate_stararg_init_code(max_positional_args, code)
2522
2523         # --- optimised code when we receive keyword arguments
2524         if self.num_required_kw_args:
2525             likely_hint = "likely"
2526         else:
2527             likely_hint = "unlikely"
2528         code.putln("if (%s(%s)) {" % (likely_hint, Naming.kwds_cname))
2529         self.generate_keyword_unpacking_code(
2530             min_positional_args, max_positional_args,
2531             has_fixed_positional_count,
2532             positional_args, kw_only_args, argtuple_error_label, code)
2533
2534         # --- optimised code when we do not receive any keyword arguments
2535         if (self.num_required_kw_args and min_positional_args > 0) or min_positional_args == max_positional_args:
2536             # Python raises arg tuple related errors first, so we must
2537             # check the length here
2538             if min_positional_args == max_positional_args and not self.star_arg:
2539                 compare = '!='
2540             else:
2541                 compare = '<'
2542             code.putln('} else if (PyTuple_GET_SIZE(%s) %s %d) {' % (
2543                     Naming.args_cname, compare, min_positional_args))
2544             code.put_goto(argtuple_error_label)
2545
2546         if self.num_required_kw_args:
2547             # pure error case: keywords required but not passed
2548             if max_positional_args > min_positional_args and not self.star_arg:
2549                 code.putln('} else if (PyTuple_GET_SIZE(%s) > %d) {' % (
2550                         Naming.args_cname, max_positional_args))
2551                 code.put_goto(argtuple_error_label)
2552             code.putln('} else {')
2553             for i, arg in enumerate(kw_only_args):
2554                 if not arg.default:
2555                     pystring_cname = code.intern_identifier(arg.name)
2556                     # required keyword-only argument missing
2557                     code.put('__Pyx_RaiseKeywordRequired("%s", %s); ' % (
2558                             self.name,
2559                             pystring_cname))
2560                     code.putln(code.error_goto(self.pos))
2561                     break
2562
2563         elif min_positional_args == max_positional_args:
2564             # parse the exact number of positional arguments from the
2565             # args tuple
2566             code.putln('} else {')
2567             for i, arg in enumerate(positional_args):
2568                 item = "PyTuple_GET_ITEM(%s, %d)" % (Naming.args_cname, i)
2569                 self.generate_arg_assignment(arg, item, code)
2570             self.generate_arg_default_assignments(code)
2571
2572         else:
2573             # parse the positional arguments from the variable length
2574             # args tuple
2575             code.putln('} else {')
2576             self.generate_arg_default_assignments(code)
2577             code.putln('switch (PyTuple_GET_SIZE(%s)) {' % Naming.args_cname)
2578             if self.star_arg:
2579                 code.putln('default:')
2580             reversed_args = list(enumerate(positional_args))[::-1]
2581             for i, arg in reversed_args:
2582                 if i >= min_positional_args-1:
2583                     if min_positional_args > 1:
2584                         code.putln('case %2d:' % (i+1)) # pure code beautification
2585                     else:
2586                         code.put('case %2d: ' % (i+1))
2587                 item = "PyTuple_GET_ITEM(%s, %d)" % (Naming.args_cname, i)
2588                 self.generate_arg_assignment(arg, item, code)
2589             if min_positional_args == 0:
2590                 code.put('case  0: ')
2591             code.putln('break;')
2592             if self.star_arg:
2593                 if min_positional_args:
2594                     for i in range(min_positional_args-1, -1, -1):
2595                         code.putln('case %2d:' % i)
2596                     code.put_goto(argtuple_error_label)
2597             else:
2598                 code.put('default: ')
2599                 code.put_goto(argtuple_error_label)
2600             code.putln('}')
2601
2602         code.putln('}')
2603
2604         if code.label_used(argtuple_error_label):
2605             code.put_goto(success_label)
2606             code.put_label(argtuple_error_label)
2607             code.put('__Pyx_RaiseArgtupleInvalid("%s", %d, %d, %d, PyTuple_GET_SIZE(%s)); ' % (
2608                     self.name, has_fixed_positional_count,
2609                     min_positional_args, max_positional_args,
2610                     Naming.args_cname))
2611             code.putln(code.error_goto(self.pos))
2612
2613     def generate_arg_default_assignments(self, code):
2614         for arg in self.args:
2615             if arg.is_generic and arg.default:
2616                 code.putln(
2617                     "%s = %s;" % (
2618                         arg.entry.cname,
2619                         arg.calculate_default_value_code(code)))
2620
2621     def generate_stararg_init_code(self, max_positional_args, code):
2622         if self.starstar_arg:
2623             self.starstar_arg.entry.xdecref_cleanup = 0
2624             code.putln('%s = PyDict_New(); if (unlikely(!%s)) return %s;' % (
2625                     self.starstar_arg.entry.cname,
2626                     self.starstar_arg.entry.cname,
2627                     self.error_value()))
2628             code.put_gotref(self.starstar_arg.entry.cname)
2629         if self.star_arg:
2630             self.star_arg.entry.xdecref_cleanup = 0
2631             code.putln('if (PyTuple_GET_SIZE(%s) > %d) {' % (
2632                     Naming.args_cname,
2633                     max_positional_args))
2634             code.put('%s = PyTuple_GetSlice(%s, %d, PyTuple_GET_SIZE(%s)); ' % (
2635                     self.star_arg.entry.cname, Naming.args_cname,
2636                     max_positional_args, Naming.args_cname))
2637             code.put_gotref(self.star_arg.entry.cname)
2638             if self.starstar_arg:
2639                 code.putln("")
2640                 code.putln("if (unlikely(!%s)) {" % self.star_arg.entry.cname)
2641                 code.put_decref(self.starstar_arg.entry.cname, py_object_type)
2642                 code.putln('return %s;' % self.error_value())
2643                 code.putln('}')
2644             else:
2645                 code.putln("if (unlikely(!%s)) return %s;" % (
2646                         self.star_arg.entry.cname, self.error_value()))
2647             code.putln('} else {')
2648             code.put("%s = %s; " % (self.star_arg.entry.cname, Naming.empty_tuple))
2649             code.put_incref(Naming.empty_tuple, py_object_type)
2650             code.putln('}')
2651
2652     def generate_keyword_unpacking_code(self, min_positional_args, max_positional_args,
2653                                         has_fixed_positional_count, positional_args,
2654                                         kw_only_args, argtuple_error_label, code):
2655         all_args = tuple(positional_args) + tuple(kw_only_args)
2656         max_args = len(all_args)
2657
2658         code.putln("Py_ssize_t kw_args = PyDict_Size(%s);" %
2659                    Naming.kwds_cname)
2660         # the 'values' array collects borrowed references to arguments
2661         # before doing any type coercion etc.
2662         code.putln("PyObject* values[%d] = {%s};" % (
2663             max_args, ','.join('0'*max_args)))
2664
2665         # assign borrowed Python default values to the values array,
2666         # so that they can be overwritten by received arguments below
2667         for i, arg in enumerate(all_args):
2668             if arg.default and arg.type.is_pyobject:
2669                 default_value = arg.calculate_default_value_code(code)
2670                 code.putln('values[%d] = %s;' % (i, arg.type.as_pyobject(default_value)))
2671
2672         # parse the args tuple and check that it's not too long
2673         code.putln('switch (PyTuple_GET_SIZE(%s)) {' % Naming.args_cname)
2674         if self.star_arg:
2675             code.putln('default:')
2676         for i in range(max_positional_args-1, -1, -1):
2677             code.put('case %2d: ' % (i+1))
2678             code.putln("values[%d] = PyTuple_GET_ITEM(%s, %d);" % (
2679                     i, Naming.args_cname, i))
2680         code.putln('case  0: break;')
2681         if not self.star_arg:
2682             code.put('default: ') # more arguments than allowed
2683             code.put_goto(argtuple_error_label)
2684         code.putln('}')
2685
2686         # now fill up the positional/required arguments with values
2687         # from the kw dict
2688         if self.num_required_args or max_positional_args > 0:
2689             last_required_arg = -1
2690             for i, arg in enumerate(all_args):
2691                 if not arg.default:
2692                     last_required_arg = i
2693             if last_required_arg < max_positional_args:
2694                 last_required_arg = max_positional_args-1
2695             num_required_args = self.num_required_args
2696             if max_positional_args > 0:
2697                 code.putln('switch (PyTuple_GET_SIZE(%s)) {' % Naming.args_cname)
2698             for i, arg in enumerate(all_args[:last_required_arg+1]):
2699                 if max_positional_args > 0 and i <= max_positional_args:
2700                     if self.star_arg and i == max_positional_args:
2701                         code.putln('default:')
2702                     else:
2703                         code.putln('case %2d:' % i)
2704                 pystring_cname = code.intern_identifier(arg.name)
2705                 if arg.default:
2706                     if arg.kw_only:
2707                         # handled separately below
2708                         continue
2709                     code.putln('if (kw_args > 0) {')
2710                     code.putln('PyObject* value = PyDict_GetItem(%s, %s);' % (
2711                         Naming.kwds_cname, pystring_cname))
2712                     code.putln('if (value) { values[%d] = value; kw_args--; }' % i)
2713                     code.putln('}')
2714                 else:
2715                     num_required_args -= 1
2716                     code.putln('values[%d] = PyDict_GetItem(%s, %s);' % (
2717                         i, Naming.kwds_cname, pystring_cname))
2718                     code.putln('if (likely(values[%d])) kw_args--;' % i);
2719                     if i < min_positional_args:
2720                         if i == 0:
2721                             # special case: we know arg 0 is missing
2722                             code.put('else ')
2723                             code.put_goto(argtuple_error_label)
2724                         else:
2725                             # print the correct number of values (args or
2726                             # kwargs) that were passed into positional
2727                             # arguments up to this point
2728                             code.putln('else {')
2729                             code.put('__Pyx_RaiseArgtupleInvalid("%s", %d, %d, %d, %d); ' % (
2730                                     self.name, has_fixed_positional_count,
2731                                     min_positional_args, max_positional_args, i))
2732                             code.putln(code.error_goto(self.pos))
2733                             code.putln('}')
2734                     elif arg.kw_only:
2735                         code.putln('else {')
2736                         code.put('__Pyx_RaiseKeywordRequired("%s", %s); ' %(
2737                                 self.name, pystring_cname))
2738                         code.putln(code.error_goto(self.pos))
2739                         code.putln('}')
2740             if max_positional_args > 0:
2741                 code.putln('}')
2742
2743         if kw_only_args and not self.starstar_arg:
2744             # unpack optional keyword-only arguments
2745             # checking for interned strings in a dict is faster than iterating
2746             # but it's too likely that we must iterate if we expect **kwargs
2747             optional_args = []
2748             for i, arg in enumerate(all_args[max_positional_args:]):
2749                 if not arg.kw_only or not arg.default:
2750                     continue
2751                 optional_args.append((i+max_positional_args, arg))
2752             if optional_args:
2753                 # this mimics an unrolled loop so that we can "break" out of it
2754                 code.putln('while (kw_args > 0) {')
2755                 code.putln('PyObject* value;')
2756                 for i, arg in optional_args:
2757                     pystring_cname = code.intern_identifier(arg.name)
2758                     code.putln(
2759                         'value = PyDict_GetItem(%s, %s);' % (
2760                         Naming.kwds_cname, pystring_cname))
2761                     code.putln(
2762                         'if (value) { values[%d] = value; if (!(--kw_args)) break; }' % i)
2763                 code.putln('break;')
2764                 code.putln('}')
2765
2766         code.putln('if (unlikely(kw_args > 0)) {')
2767         # non-positional/-required kw args left in dict: default args,
2768         # kw-only args, **kwargs or error
2769         #
2770         # This is sort of a catch-all: except for checking required
2771         # arguments, this will always do the right thing for unpacking
2772         # keyword arguments, so that we can concentrate on optimising
2773         # common cases above.
2774         if max_positional_args == 0:
2775             pos_arg_count = "0"
2776         elif self.star_arg:
2777             code.putln("const Py_ssize_t used_pos_args = (PyTuple_GET_SIZE(%s) < %d) ? PyTuple_GET_SIZE(%s) : %d;" % (
2778                     Naming.args_cname, max_positional_args,
2779                     Naming.args_cname, max_positional_args))
2780             pos_arg_count = "used_pos_args"
2781         else:
2782             pos_arg_count = "PyTuple_GET_SIZE(%s)" % Naming.args_cname
2783         code.globalstate.use_utility_code(parse_keywords_utility_code)
2784         code.put(
2785             'if (unlikely(__Pyx_ParseOptionalKeywords(%s, %s, %s, values, %s, "%s") < 0)) ' % (
2786                 Naming.kwds_cname,
2787                 Naming.pykwdlist_cname,
2788                 self.starstar_arg and self.starstar_arg.entry.cname or '0',
2789                 pos_arg_count,
2790                 self.name))
2791         code.putln(code.error_goto(self.pos))
2792         code.putln('}')
2793
2794         # convert arg values to their final type and assign them
2795         for i, arg in enumerate(all_args):
2796             if arg.default and not arg.type.is_pyobject:
2797                 code.putln("if (values[%d]) {" % i)
2798             self.generate_arg_assignment(arg, "values[%d]" % i, code)
2799             if arg.default and not arg.type.is_pyobject:
2800                 code.putln('} else {')
2801                 code.putln(
2802                     "%s = %s;" % (
2803                         arg.entry.cname,
2804                         arg.calculate_default_value_code(code)))
2805                 code.putln('}')
2806
2807     def generate_argument_conversion_code(self, code):
2808         # Generate code to convert arguments from signature type to
2809         # declared type, if needed.  Also copies signature arguments
2810         # into closure fields.
2811         for arg in self.args:
2812             if arg.needs_conversion:
2813                 self.generate_arg_conversion(arg, code)
2814             elif arg.entry.in_closure:
2815                 code.putln('%s = %s;' % (arg.entry.cname, arg.hdr_cname))
2816                 if arg.type.is_pyobject:
2817                     code.put_var_incref(arg.entry)
2818
2819     def generate_arg_conversion(self, arg, code):
2820         # Generate conversion code for one argument.
2821         old_type = arg.hdr_type
2822         new_type = arg.type
2823         if old_type.is_pyobject:
2824             if arg.default:
2825                 code.putln("if (%s) {" % arg.hdr_cname)
2826             else:
2827                 code.putln("assert(%s); {" % arg.hdr_cname)
2828             self.generate_arg_conversion_from_pyobject(arg, code)
2829             code.putln("}")
2830         elif new_type.is_pyobject:
2831             self.generate_arg_conversion_to_pyobject(arg, code)
2832         else:
2833             if new_type.assignable_from(old_type):
2834                 code.putln(
2835                     "%s = %s;" % (arg.entry.cname, arg.hdr_cname))
2836             else:
2837                 error(arg.pos,
2838                     "Cannot convert 1 argument from '%s' to '%s'" %
2839                         (old_type, new_type))
2840
2841     def generate_arg_conversion_from_pyobject(self, arg, code):
2842         new_type = arg.type
2843         func = new_type.from_py_function
2844         # copied from CoerceFromPyTypeNode
2845         if func:
2846             lhs = arg.entry.cname
2847             rhs = "%s(%s)" % (func, arg.hdr_cname)
2848             if new_type.is_enum:
2849                 rhs = PyrexTypes.typecast(new_type, PyrexTypes.c_long_type, rhs)
2850             code.putln("%s = %s; %s" % (
2851                 lhs,
2852                 rhs,
2853                 code.error_goto_if(new_type.error_condition(arg.entry.cname), arg.pos)))
2854         else:
2855             error(arg.pos,
2856                 "Cannot convert Python object argument to type '%s'"
2857                     % new_type)
2858
2859     def generate_arg_conversion_to_pyobject(self, arg, code):
2860         old_type = arg.hdr_type
2861         func = old_type.to_py_function
2862         if func:
2863             code.putln("%s = %s(%s); %s" % (
2864                 arg.entry.cname,
2865                 func,
2866                 arg.hdr_cname,
2867                 code.error_goto_if_null(arg.entry.cname, arg.pos)))
2868             code.put_var_gotref(arg.entry)
2869         else:
2870             error(arg.pos,
2871                 "Cannot convert argument of type '%s' to Python object"
2872                     % old_type)
2873
2874     def generate_argument_type_tests(self, code):
2875         # Generate type tests for args whose signature
2876         # type is PyObject * and whose declared type is
2877         # a subtype thereof.
2878         for arg in self.args:
2879             if arg.needs_type_test:
2880                 self.generate_arg_type_test(arg, code)
2881             elif not arg.accept_none and arg.type.is_pyobject:
2882                 self.generate_arg_none_check(arg, code)
2883
2884     def error_value(self):
2885         return self.entry.signature.error_value
2886
2887     def caller_will_check_exceptions(self):
2888         return 1
2889
2890 class OverrideCheckNode(StatNode):
2891     # A Node for dispatching to the def method if it
2892     # is overriden.
2893     #
2894     #  py_func
2895     #
2896     #  args
2897     #  func_temp
2898     #  body
2899
2900     child_attrs = ['body']
2901
2902     body = None
2903
2904     def analyse_expressions(self, env):
2905         self.args = env.arg_entries
2906         if self.py_func.is_module_scope:
2907             first_arg = 0
2908         else:
2909             first_arg = 1
2910         import ExprNodes
2911         self.func_node = ExprNodes.RawCNameExprNode(self.pos, py_object_type)
2912         call_tuple = ExprNodes.TupleNode(self.pos, args=[ExprNodes.NameNode(self.pos, name=arg.name) for arg in self.args[first_arg:]])
2913         call_node = ExprNodes.SimpleCallNode(self.pos,
2914                                              function=self.func_node,
2915                                              args=[ExprNodes.NameNode(self.pos, name=arg.name) for arg in self.args[first_arg:]])
2916         self.body = ReturnStatNode(self.pos, value=call_node)
2917         self.body.analyse_expressions(env)
2918
2919     def generate_execution_code(self, code):
2920         interned_attr_cname = code.intern_identifier(self.py_func.entry.name)
2921         # Check to see if we are an extension type
2922         if self.py_func.is_module_scope:
2923             self_arg = "((PyObject *)%s)" % Naming.module_cname
2924         else:
2925             self_arg = "((PyObject *)%s)" % self.args[0].cname
2926         code.putln("/* Check if called by wrapper */")
2927         code.putln("if (unlikely(%s)) ;" % Naming.skip_dispatch_cname)
2928         code.putln("/* Check if overriden in Python */")
2929         if self.py_func.is_module_scope:
2930             code.putln("else {")
2931         else:
2932             code.putln("else if (unlikely(Py_TYPE(%s)->tp_dictoffset != 0)) {" % self_arg)
2933         func_node_temp = code.funcstate.allocate_temp(py_object_type, manage_ref=True)
2934         self.func_node.set_cname(func_node_temp)
2935         # need to get attribute manually--scope would return cdef method
2936         err = code.error_goto_if_null(func_node_temp, self.pos)
2937         code.putln("%s = PyObject_GetAttr(%s, %s); %s" % (
2938             func_node_temp, self_arg, interned_attr_cname, err))
2939         code.put_gotref(func_node_temp)
2940         is_builtin_function_or_method = "PyCFunction_Check(%s)" % func_node_temp
2941         is_overridden = "(PyCFunction_GET_FUNCTION(%s) != (void *)&%s)" % (
2942             func_node_temp, self.py_func.entry.func_cname)
2943         code.putln("if (!%s || %s) {" % (is_builtin_function_or_method, is_overridden))
2944         self.body.generate_execution_code(code)
2945         code.putln("}")
2946         code.put_decref_clear(func_node_temp, PyrexTypes.py_object_type)
2947         code.funcstate.release_temp(func_node_temp)
2948         code.putln("}")
2949
2950 class ClassDefNode(StatNode, BlockNode):
2951     pass
2952
2953 class PyClassDefNode(ClassDefNode):
2954     #  A Python class definition.
2955     #
2956     #  name     EncodedString   Name of the class
2957     #  doc      string or None
2958     #  body     StatNode        Attribute definition code
2959     #  entry    Symtab.Entry
2960     #  scope    PyClassScope
2961     #  decorators    [DecoratorNode]        list of decorators or None
2962     #
2963     #  The following subnodes are constructed internally:
2964     #
2965     #  dict     DictNode   Class dictionary or Py3 namespace
2966     #  classobj ClassNode  Class object
2967     #  target   NameNode   Variable to assign class object to
2968
2969     child_attrs = ["body", "dict", "metaclass", "mkw", "bases", "classobj", "target"]
2970     decorators = None
2971     py3_style_class = False # Python3 style class (bases+kwargs)
2972
2973     def __init__(self, pos, name, bases, doc, body, decorators = None,
2974                  keyword_args = None, starstar_arg = None):
2975         StatNode.__init__(self, pos)
2976         self.name = name
2977         self.doc = doc
2978         self.body = body
2979         self.decorators = decorators
2980         import ExprNodes
2981         if self.doc and Options.docstrings:
2982             doc = embed_position(self.pos, self.doc)
2983             doc_node = ExprNodes.StringNode(pos, value = doc)
2984         else:
2985             doc_node = None
2986         if keyword_args or starstar_arg:
2987             self.py3_style_class = True
2988             self.bases = bases
2989             self.metaclass = None
2990             if keyword_args and not starstar_arg:
2991                 for i, item in list(enumerate(keyword_args.key_value_pairs))[::-1]:
2992                     if item.key.value == 'metaclass':
2993                         if self.metaclass is not None:
2994                             error(item.pos, "keyword argument 'metaclass' passed multiple times")
2995                         # special case: we already know the metaclass,
2996                         # so we don't need to do the "build kwargs,
2997                         # find metaclass" dance at runtime
2998                         self.metaclass = item.value
2999                         del keyword_args.key_value_pairs[i]
3000             if starstar_arg or (keyword_args and keyword_args.key_value_pairs):
3001                 self.mkw = ExprNodes.KeywordArgsNode(
3002                     pos, keyword_args = keyword_args, starstar_arg = starstar_arg)
3003             else:
3004                 self.mkw = ExprNodes.NullNode(pos)
3005             if self.metaclass is None:
3006                 self.metaclass = ExprNodes.PyClassMetaclassNode(
3007                     pos, mkw = self.mkw, bases = self.bases)
3008             self.dict = ExprNodes.PyClassNamespaceNode(pos, name = name,
3009                         doc = doc_node, metaclass = self.metaclass, bases = self.bases,
3010                         mkw = self.mkw)
3011             self.classobj = ExprNodes.Py3ClassNode(pos, name = name,
3012                     bases = self.bases, dict = self.dict, doc = doc_node,
3013                     metaclass = self.metaclass, mkw = self.mkw)
3014         else:
3015             self.dict = ExprNodes.DictNode(pos, key_value_pairs = [])
3016             self.metaclass = None
3017             self.mkw = None
3018             self.bases = None
3019             self.classobj = ExprNodes.ClassNode(pos, name = name,
3020                     bases = bases, dict = self.dict, doc = doc_node)
3021         self.target = ExprNodes.NameNode(pos, name = name)
3022
3023     def as_cclass(self):
3024         """
3025         Return this node as if it were declared as an extension class
3026         """
3027         if self.py3_style_class:
3028             error(self.classobj.pos, "Python3 style class could not be represented as C class")
3029             return
3030         bases = self.classobj.bases.args
3031         if len(bases) == 0:
3032             base_class_name = None
3033             base_class_module = None
3034         elif len(bases) == 1:
3035             base = bases[0]
3036             path = []
3037             from ExprNodes import AttributeNode, NameNode
3038             while isinstance(base, AttributeNode):
3039                 path.insert(0, base.attribute)
3040                 base = base.obj
3041             if isinstance(base, NameNode):
3042                 path.insert(0, base.name)
3043                 base_class_name = path[-1]
3044                 if len(path) > 1:
3045                     base_class_module = u'.'.join(path[:-1])
3046                 else:
3047                     base_class_module = None
3048             else:
3049                 error(self.classobj.bases.args.pos, "Invalid base class")
3050         else:
3051             error(self.classobj.bases.args.pos, "C class may only have one base class")
3052             return None
3053
3054         return CClassDefNode(self.pos,
3055                              visibility = 'private',
3056                              module_name = None,
3057                              class_name = self.name,
3058                              base_class_module = base_class_module,
3059                              base_class_name = base_class_name,
3060                              decorators = self.decorators,
3061                              body = self.body,
3062                              in_pxd = False,
3063                              doc = self.doc)
3064
3065     def create_scope(self, env):
3066         genv = env
3067         while genv.is_py_class_scope or genv.is_c_class_scope:
3068             genv = genv.outer_scope
3069         cenv = self.scope = PyClassScope(name = self.name, outer_scope = genv)
3070         return cenv
3071
3072     def analyse_declarations(self, env):
3073         self.target.analyse_target_declaration(env)
3074         cenv = self.create_scope(env)
3075         cenv.directives = env.directives
3076         cenv.class_obj_cname = self.target.entry.cname
3077         self.body.analyse_declarations(cenv)
3078
3079     def analyse_expressions(self, env):
3080         if self.py3_style_class:
3081             self.bases.analyse_expressions(env)
3082             self.metaclass.analyse_expressions(env)
3083             self.mkw.analyse_expressions(env)
3084         self.dict.analyse_expressions(env)
3085         self.classobj.analyse_expressions(env)
3086         genv = env.global_scope()
3087         cenv = self.scope
3088         self.body.analyse_expressions(cenv)
3089         self.target.analyse_target_expression(env, self.classobj)
3090
3091     def generate_function_definitions(self, env, code):
3092         self.generate_lambda_definitions(self.scope, code)
3093         self.body.generate_function_definitions(self.scope, code)
3094
3095     def generate_execution_code(self, code):
3096         code.pyclass_stack.append(self)
3097         cenv = self.scope
3098         if self.py3_style_class:
3099             self.bases.generate_evaluation_code(code)
3100             self.mkw.generate_evaluation_code(code)
3101             self.metaclass.generate_evaluation_code(code)
3102         self.dict.generate_evaluation_code(code)
3103         cenv.namespace_cname = cenv.class_obj_cname = self.dict.result()
3104         self.body.generate_execution_code(code)
3105         self.classobj.generate_evaluation_code(code)
3106         cenv.namespace_cname = cenv.class_obj_cname = self.classobj.result()
3107         self.target.generate_assignment_code(self.classobj, code)
3108         self.dict.generate_disposal_code(code)
3109         self.dict.free_temps(code)
3110         if self.py3_style_class:
3111             self.mkw.generate_disposal_code(code)
3112             self.mkw.free_temps(code)
3113             self.metaclass.generate_disposal_code(code)
3114             self.metaclass.free_temps(code)
3115             self.bases.generate_disposal_code(code)
3116             self.bases.free_temps(code)
3117         code.pyclass_stack.pop()
3118
3119 class CClassDefNode(ClassDefNode):
3120     #  An extension type definition.
3121     #
3122     #  visibility         'private' or 'public' or 'extern'
3123     #  typedef_flag       boolean
3124     #  api                boolean
3125     #  module_name        string or None    For import of extern type objects
3126     #  class_name         string            Unqualified name of class
3127     #  as_name            string or None    Name to declare as in this scope
3128     #  base_class_module  string or None    Module containing the base class
3129     #  base_class_name    string or None    Name of the base class
3130     #  objstruct_name     string or None    Specified C name of object struct
3131     #  typeobj_name       string or None    Specified C name of type object
3132     #  in_pxd             boolean           Is in a .pxd file
3133     #  decorators         [DecoratorNode]   list of decorators or None
3134     #  doc                string or None
3135     #  body               StatNode or None
3136     #  entry              Symtab.Entry
3137     #  base_type          PyExtensionType or None
3138     #  buffer_defaults_node DictNode or None Declares defaults for a buffer
3139     #  buffer_defaults_pos
3140
3141     child_attrs = ["body"]
3142     buffer_defaults_node = None
3143     buffer_defaults_pos = None
3144     typedef_flag = False
3145     api = False
3146     objstruct_name = None
3147     typeobj_name = None
3148     decorators = None
3149
3150     def analyse_declarations(self, env):
3151         #print "CClassDefNode.analyse_declarations:", self.class_name
3152         #print "...visibility =", self.visibility
3153         #print "...module_name =", self.module_name
3154
3155         import Buffer
3156         if self.buffer_defaults_node:
3157             buffer_defaults = Buffer.analyse_buffer_options(self.buffer_defaults_pos,
3158                                                             env, [], self.buffer_defaults_node,
3159                                                             need_complete=False)
3160         else:
3161             buffer_defaults = None
3162
3163         if env.in_cinclude and not self.objstruct_name:
3164             error(self.pos, "Object struct name specification required for "
3165                 "C class defined in 'extern from' block")
3166         self.base_type = None
3167         # Now that module imports are cached, we need to
3168         # import the modules for extern classes.
3169         if self.module_name:
3170             self.module = None
3171             for module in env.cimported_modules:
3172                 if module.name == self.module_name:
3173                     self.module = module
3174             if self.module is None:
3175                 self.module = ModuleScope(self.module_name, None, env.context)
3176                 self.module.has_extern_class = 1
3177                 env.add_imported_module(self.module)
3178
3179         if self.base_class_name:
3180             if self.base_class_module:
3181                 base_class_scope = env.find_module(self.base_class_module, self.pos)
3182             else:
3183                 base_class_scope = env
3184             if self.base_class_name == 'object':
3185                 # extension classes are special and don't need to inherit from object
3186                 if base_class_scope is None or base_class_scope.lookup('object') is None:
3187                     self.base_class_name = None
3188                     self.base_class_module = None
3189                     base_class_scope = None
3190             if base_class_scope:
3191                 base_class_entry = base_class_scope.find(self.base_class_name, self.pos)
3192                 if base_class_entry:
3193                     if not base_class_entry.is_type:
3194                         error(self.pos, "'%s' is not a type name" % self.base_class_name)
3195                     elif not base_class_entry.type.is_extension_type and \
3196                              not (base_class_entry.type.is_builtin_type and \
3197                                   base_class_entry.type.objstruct_cname):
3198                         error(self.pos, "'%s' is not an extension type" % self.base_class_name)
3199                     elif not base_class_entry.type.is_complete():
3200                         error(self.pos, "Base class '%s' of type '%s' is incomplete" % (
3201                             self.base_class_name, self.class_name))
3202                     elif base_class_entry.type.scope and base_class_entry.type.scope.directives and \
3203                              base_class_entry.type.scope.directives['final']:
3204                         error(self.pos, "Base class '%s' of type '%s' is final" % (
3205                             self.base_class_name, self.class_name))
3206                     elif base_class_entry.type.is_builtin_type and \
3207                              base_class_entry.type.name in ('tuple', 'str', 'bytes'):
3208                         error(self.pos, "inheritance from PyVarObject types like '%s' is not currently supported"
3209                               % base_class_entry.type.name)
3210                     else:
3211                         self.base_type = base_class_entry.type
3212         has_body = self.body is not None
3213         if self.module_name and self.visibility != 'extern':
3214             module_path = self.module_name.split(".")
3215             home_scope = env.find_imported_module(module_path, self.pos)
3216             if not home_scope:
3217                 return
3218         else:
3219             home_scope = env
3220
3221         if self.visibility == 'extern':
3222             if self.module_name == '__builtin__' and self.class_name in Builtin.builtin_types:
3223                 warning(self.pos, "%s already a builtin Cython type" % self.class_name, 1)
3224
3225         self.entry = home_scope.declare_c_class(
3226             name = self.class_name,
3227             pos = self.pos,
3228             defining = has_body and self.in_pxd,
3229             implementing = has_body and not self.in_pxd,
3230             module_name = self.module_name,
3231             base_type = self.base_type,
3232             objstruct_cname = self.objstruct_name,
3233             typeobj_cname = self.typeobj_name,
3234             visibility = self.visibility,
3235             typedef_flag = self.typedef_flag,
3236             api = self.api,
3237             buffer_defaults = buffer_defaults)
3238         if home_scope is not env and self.visibility == 'extern':
3239             env.add_imported_entry(self.class_name, self.entry, self.pos)
3240         self.scope = scope = self.entry.type.scope
3241         if scope is not None:
3242             scope.directives = env.directives
3243
3244         if self.doc and Options.docstrings:
3245             scope.doc = embed_position(self.pos, self.doc)
3246
3247         if has_body:
3248             self.body.analyse_declarations(scope)
3249             if self.in_pxd:
3250                 scope.defined = 1
3251             else:
3252                 scope.implemented = 1
3253         env.allocate_vtable_names(self.entry)
3254
3255     def analyse_expressions(self, env):
3256         if self.body:
3257             scope = self.entry.type.scope
3258             self.body.analyse_expressions(scope)
3259
3260     def generate_function_definitions(self, env, code):
3261         if self.body:
3262             self.generate_lambda_definitions(self.scope, code)
3263             self.body.generate_function_definitions(self.scope, code)
3264
3265     def generate_execution_code(self, code):
3266         # This is needed to generate evaluation code for
3267         # default values of method arguments.
3268         if self.body:
3269             self.body.generate_execution_code(code)
3270
3271     def annotate(self, code):
3272         if self.body:
3273             self.body.annotate(code)
3274
3275
3276 class PropertyNode(StatNode):
3277     #  Definition of a property in an extension type.
3278     #
3279     #  name   string
3280     #  doc    EncodedString or None    Doc string
3281     #  body   StatListNode
3282
3283     child_attrs = ["body"]
3284
3285     def analyse_declarations(self, env):
3286         entry = env.declare_property(self.name, self.doc, self.pos)
3287         if entry:
3288             entry.scope.directives = env.directives
3289             self.body.analyse_declarations(entry.scope)
3290
3291     def analyse_expressions(self, env):
3292         self.body.analyse_expressions(env)
3293
3294     def generate_function_definitions(self, env, code):
3295         self.body.generate_function_definitions(env, code)
3296
3297     def generate_execution_code(self, code):
3298         pass
3299
3300     def annotate(self, code):
3301         self.body.annotate(code)
3302
3303
3304 class GlobalNode(StatNode):
3305     # Global variable declaration.
3306     #
3307     # names    [string]
3308
3309     child_attrs = []
3310
3311     def analyse_declarations(self, env):
3312         for name in self.names:
3313             env.declare_global(name, self.pos)
3314
3315     def analyse_expressions(self, env):
3316         pass
3317
3318     def generate_execution_code(self, code):
3319         pass
3320
3321
3322 class ExprStatNode(StatNode):
3323     #  Expression used as a statement.
3324     #
3325     #  expr   ExprNode
3326
3327     child_attrs = ["expr"]
3328
3329     def analyse_declarations(self, env):
3330         import ExprNodes
3331         if isinstance(self.expr, ExprNodes.GeneralCallNode):
3332             func = self.expr.function.as_cython_attribute()
3333             if func == u'declare':
3334                 args, kwds = self.expr.explicit_args_kwds()
3335                 if len(args):
3336                     error(self.expr.pos, "Variable names must be specified.")
3337                 for var, type_node in kwds.key_value_pairs:
3338                     type = type_node.analyse_as_type(env)
3339                     if type is None:
3340                         error(type_node.pos, "Unknown type")
3341                     else:
3342                         env.declare_var(var.value, type, var.pos, is_cdef = True)
3343                 self.__class__ = PassStatNode
3344
3345     def analyse_expressions(self, env):
3346         self.expr.analyse_expressions(env)
3347
3348     def generate_execution_code(self, code):
3349         self.expr.generate_evaluation_code(code)
3350         if not self.expr.is_temp and self.expr.result():
3351             code.putln("%s;" % self.expr.result())
3352         self.expr.generate_disposal_code(code)
3353         self.expr.free_temps(code)
3354
3355     def generate_function_definitions(self, env, code):
3356         self.expr.generate_function_definitions(env, code)
3357
3358     def annotate(self, code):
3359         self.expr.annotate(code)
3360
3361
3362 class AssignmentNode(StatNode):
3363     #  Abstract base class for assignment nodes.
3364     #
3365     #  The analyse_expressions and generate_execution_code
3366     #  phases of assignments are split into two sub-phases
3367     #  each, to enable all the right hand sides of a
3368     #  parallel assignment to be evaluated before assigning
3369     #  to any of the left hand sides.
3370
3371     def analyse_expressions(self, env):
3372         self.analyse_types(env)
3373
3374 #       def analyse_expressions(self, env):
3375 #           self.analyse_expressions_1(env)
3376 #           self.analyse_expressions_2(env)
3377
3378     def generate_execution_code(self, code):
3379         self.generate_rhs_evaluation_code(code)
3380         self.generate_assignment_code(code)
3381
3382
3383 class SingleAssignmentNode(AssignmentNode):
3384     #  The simplest case:
3385     #
3386     #    a = b
3387     #
3388     #  lhs      ExprNode      Left hand side
3389     #  rhs      ExprNode      Right hand side
3390     #  first    bool          Is this guaranteed the first assignment to lhs?
3391
3392     child_attrs = ["lhs", "rhs"]
3393     first = False
3394     declaration_only = False
3395
3396     def analyse_declarations(self, env):
3397         import ExprNodes
3398
3399         # handle declarations of the form x = cython.foo()
3400         if isinstance(self.rhs, ExprNodes.CallNode):
3401             func_name = self.rhs.function.as_cython_attribute()
3402             if func_name:
3403                 args, kwds = self.rhs.explicit_args_kwds()
3404
3405                 if func_name in ['declare', 'typedef']:
3406                     if len(args) > 2 or kwds is not None:
3407                         error(self.rhs.pos, "Can only declare one type at a time.")
3408                         return
3409                     type = args[0].analyse_as_type(env)
3410                     if type is None:
3411                         error(args[0].pos, "Unknown type")
3412                         return
3413                     lhs = self.lhs
3414                     if func_name == 'declare':
3415                         if isinstance(lhs, ExprNodes.NameNode):
3416                             vars = [(lhs.name, lhs.pos)]
3417                         elif isinstance(lhs, ExprNodes.TupleNode):
3418                             vars = [(var.name, var.pos) for var in lhs.args]
3419                         else:
3420                             error(lhs.pos, "Invalid declaration")
3421                             return
3422                         for var, pos in vars:
3423                             env.declare_var(var, type, pos, is_cdef = True)
3424                         if len(args) == 2:
3425                             # we have a value
3426                             self.rhs = args[1]
3427                         else:
3428                             self.declaration_only = True
3429                     else:
3430                         self.declaration_only = True
3431                         if not isinstance(lhs, ExprNodes.NameNode):
3432                             error(lhs.pos, "Invalid declaration.")
3433                         env.declare_typedef(lhs.name, type, self.pos, visibility='private')
3434
3435                 elif func_name in ['struct', 'union']:
3436                     self.declaration_only = True
3437                     if len(args) > 0 or kwds is None:
3438                         error(self.rhs.pos, "Struct or union members must be given by name.")
3439                         return
3440                     members = []
3441                     for member, type_node in kwds.key_value_pairs:
3442                         type = type_node.analyse_as_type(env)
3443                         if type is None:
3444                             error(type_node.pos, "Unknown type")
3445                         else:
3446                             members.append((member.value, type, member.pos))
3447                     if len(members) < len(kwds.key_value_pairs):
3448                         return
3449                     if not isinstance(self.lhs, ExprNodes.NameNode):
3450                         error(self.lhs.pos, "Invalid declaration.")
3451                     name = self.lhs.name
3452                     scope = StructOrUnionScope(name)
3453                     env.declare_struct_or_union(name, func_name, scope, False, self.rhs.pos)
3454                     for member, type, pos in members:
3455                         scope.declare_var(member, type, pos)
3456
3457         if self.declaration_only:
3458             return
3459         else:
3460             self.lhs.analyse_target_declaration(env)
3461
3462     def analyse_types(self, env, use_temp = 0):
3463         self.rhs.analyse_types(env)
3464         self.lhs.analyse_target_types(env)
3465         self.lhs.gil_assignment_check(env)
3466         self.rhs = self.rhs.coerce_to(self.lhs.type, env)
3467         if use_temp:
3468             self.rhs = self.rhs.coerce_to_temp(env)
3469
3470     def generate_rhs_evaluation_code(self, code):
3471         self.rhs.generate_evaluation_code(code)
3472
3473     def generate_assignment_code(self, code):
3474         self.lhs.generate_assignment_code(self.rhs, code)
3475
3476     def generate_function_definitions(self, env, code):
3477         self.rhs.generate_function_definitions(env, code)
3478
3479     def annotate(self, code):
3480         self.lhs.annotate(code)
3481         self.rhs.annotate(code)
3482
3483
3484 class CascadedAssignmentNode(AssignmentNode):
3485     #  An assignment with multiple left hand sides:
3486     #
3487     #    a = b = c
3488     #
3489     #  lhs_list   [ExprNode]   Left hand sides
3490     #  rhs        ExprNode     Right hand sides
3491     #
3492     #  Used internally:
3493     #
3494     #  coerced_rhs_list   [ExprNode]   RHS coerced to type of each LHS
3495
3496     child_attrs = ["lhs_list", "rhs", "coerced_rhs_list"]
3497     coerced_rhs_list = None
3498
3499     def analyse_declarations(self, env):
3500         for lhs in self.lhs_list:
3501             lhs.analyse_target_declaration(env)
3502
3503     def analyse_types(self, env, use_temp = 0):
3504         self.rhs.analyse_types(env)
3505         if not self.rhs.is_simple():
3506             if use_temp:
3507                 self.rhs = self.rhs.coerce_to_temp(env)
3508             else:
3509                 self.rhs = self.rhs.coerce_to_simple(env)
3510         from ExprNodes import CloneNode
3511         self.coerced_rhs_list = []
3512         for lhs in self.lhs_list:
3513             lhs.analyse_target_types(env)
3514             lhs.gil_assignment_check(env)
3515             rhs = CloneNode(self.rhs)
3516             rhs = rhs.coerce_to(lhs.type, env)
3517             self.coerced_rhs_list.append(rhs)
3518
3519     def generate_rhs_evaluation_code(self, code):
3520         self.rhs.generate_evaluation_code(code)
3521
3522     def generate_assignment_code(self, code):
3523         for i in range(len(self.lhs_list)):
3524             lhs = self.lhs_list[i]
3525             rhs = self.coerced_rhs_list[i]
3526             rhs.generate_evaluation_code(code)
3527             lhs.generate_assignment_code(rhs, code)
3528             # Assignment has disposed of the cloned RHS
3529         self.rhs.generate_disposal_code(code)
3530         self.rhs.free_temps(code)
3531
3532     def generate_function_definitions(self, env, code):
3533         self.rhs.generate_function_definitions(env, code)
3534
3535     def annotate(self, code):
3536         for i in range(len(self.lhs_list)):
3537             lhs = self.lhs_list[i].annotate(code)
3538             rhs = self.coerced_rhs_list[i].annotate(code)
3539         self.rhs.annotate(code)
3540
3541
3542 class ParallelAssignmentNode(AssignmentNode):
3543     #  A combined packing/unpacking assignment:
3544     #
3545     #    a, b, c =  d, e, f
3546     #
3547     #  This has been rearranged by the parser into
3548     #
3549     #    a = d ; b = e ; c = f
3550     #
3551     #  but we must evaluate all the right hand sides
3552     #  before assigning to any of the left hand sides.
3553     #
3554     #  stats     [AssignmentNode]   The constituent assignments
3555
3556     child_attrs = ["stats"]
3557
3558     def analyse_declarations(self, env):
3559         for stat in self.stats:
3560             stat.analyse_declarations(env)
3561
3562     def analyse_expressions(self, env):
3563         for stat in self.stats:
3564             stat.analyse_types(env, use_temp = 1)
3565
3566 #    def analyse_expressions(self, env):
3567 #        for stat in self.stats:
3568 #            stat.analyse_expressions_1(env, use_temp = 1)
3569 #        for stat in self.stats:
3570 #            stat.analyse_expressions_2(env)
3571
3572     def generate_execution_code(self, code):
3573         for stat in self.stats:
3574             stat.generate_rhs_evaluation_code(code)
3575         for stat in self.stats:
3576             stat.generate_assignment_code(code)
3577
3578     def generate_function_definitions(self, env, code):
3579         for stat in self.stats:
3580             stat.generate_function_definitions(env, code)
3581
3582     def annotate(self, code):
3583         for stat in self.stats:
3584             stat.annotate(code)
3585
3586
3587 class InPlaceAssignmentNode(AssignmentNode):
3588     #  An in place arithmetic operand:
3589     #
3590     #    a += b
3591     #    a -= b
3592     #    ...
3593     #
3594     #  lhs      ExprNode      Left hand side
3595     #  rhs      ExprNode      Right hand side
3596     #  op       char          one of "+-*/%^&|"
3597     #  dup     (ExprNode)     copy of lhs used for operation (auto-generated)
3598     #
3599     #  This code is a bit tricky because in order to obey Python
3600     #  semantics the sub-expressions (e.g. indices) of the lhs must
3601     #  not be evaluated twice. So we must re-use the values calculated
3602     #  in evaluation phase for the assignment phase as well.
3603     #  Fortunately, the type of the lhs node is fairly constrained
3604     #  (it must be a NameNode, AttributeNode, or IndexNode).
3605
3606     child_attrs = ["lhs", "rhs"]
3607
3608     def analyse_declarations(self, env):
3609         self.lhs.analyse_target_declaration(env)
3610
3611     def analyse_types(self, env):
3612         self.rhs.analyse_types(env)
3613         self.lhs.analyse_target_types(env)
3614
3615     def generate_execution_code(self, code):
3616         import ExprNodes
3617         self.rhs.generate_evaluation_code(code)
3618         self.lhs.generate_subexpr_evaluation_code(code)
3619         c_op = self.operator
3620         if c_op == "//":
3621             c_op = "/"
3622         elif c_op == "**":
3623             error(self.pos, "No C inplace power operator")
3624         if isinstance(self.lhs, ExprNodes.IndexNode) and self.lhs.is_buffer_access:
3625             if self.lhs.type.is_pyobject:
3626                 error(self.pos, "In-place operators not allowed on object buffers in this release.")
3627             if c_op in ('/', '%') and self.lhs.type.is_int and not code.directives['cdivision']:
3628                 error(self.pos, "In-place non-c divide operators not allowed on int buffers.")
3629             self.lhs.generate_buffer_setitem_code(self.rhs, code, c_op)
3630         else:
3631             # C++
3632             # TODO: make sure overload is declared
3633             code.putln("%s %s= %s;" % (self.lhs.result(), c_op, self.rhs.result()))
3634         self.lhs.generate_subexpr_disposal_code(code)
3635         self.lhs.free_subexpr_temps(code)
3636         self.rhs.generate_disposal_code(code)
3637         self.rhs.free_temps(code)
3638
3639     def annotate(self, code):
3640         self.lhs.annotate(code)
3641         self.rhs.annotate(code)
3642
3643     def create_binop_node(self):
3644         import ExprNodes
3645         return ExprNodes.binop_node(self.pos, self.operator, self.lhs, self.rhs)
3646
3647
3648 class PrintStatNode(StatNode):
3649     #  print statement
3650     #
3651     #  arg_tuple         TupleNode
3652     #  stream            ExprNode or None (stdout)
3653     #  append_newline    boolean
3654
3655     child_attrs = ["arg_tuple", "stream"]
3656
3657     def analyse_expressions(self, env):
3658         if self.stream:
3659             self.stream.analyse_expressions(env)
3660             self.stream = self.stream.coerce_to_pyobject(env)
3661         self.arg_tuple.analyse_expressions(env)
3662         self.arg_tuple = self.arg_tuple.coerce_to_pyobject(env)
3663         env.use_utility_code(printing_utility_code)
3664         if len(self.arg_tuple.args) == 1 and self.append_newline:
3665             env.use_utility_code(printing_one_utility_code)
3666
3667     nogil_check = Node.gil_error
3668     gil_message = "Python print statement"
3669
3670     def generate_execution_code(self, code):
3671         if self.stream:
3672             self.stream.generate_evaluation_code(code)
3673             stream_result = self.stream.py_result()
3674         else:
3675             stream_result = '0'
3676         if len(self.arg_tuple.args) == 1 and self.append_newline:
3677             arg = self.arg_tuple.args[0]
3678             arg.generate_evaluation_code(code)
3679
3680             code.putln(
3681                 "if (__Pyx_PrintOne(%s, %s) < 0) %s" % (
3682                     stream_result,
3683                     arg.py_result(),
3684                     code.error_goto(self.pos)))
3685             arg.generate_disposal_code(code)
3686             arg.free_temps(code)
3687         else:
3688             self.arg_tuple.generate_evaluation_code(code)
3689             code.putln(
3690                 "if (__Pyx_Print(%s, %s, %d) < 0) %s" % (
3691                     stream_result,
3692                     self.arg_tuple.py_result(),
3693                     self.append_newline,
3694                     code.error_goto(self.pos)))
3695             self.arg_tuple.generate_disposal_code(code)
3696             self.arg_tuple.free_temps(code)
3697
3698         if self.stream:
3699             self.stream.generate_disposal_code(code)
3700             self.stream.free_temps(code)
3701
3702     def generate_function_definitions(self, env, code):
3703         if self.stream:
3704             self.stream.generate_function_definitions(env, code)
3705         self.arg_tuple.generate_function_definitions(env, code)
3706
3707     def annotate(self, code):
3708         if self.stream:
3709             self.stream.annotate(code)
3710         self.arg_tuple.annotate(code)
3711
3712
3713 class ExecStatNode(StatNode):
3714     #  exec statement
3715     #
3716     #  args     [ExprNode]
3717
3718     child_attrs = ["args"]
3719
3720     def analyse_expressions(self, env):
3721         for i, arg in enumerate(self.args):
3722             arg.analyse_expressions(env)
3723             arg = arg.coerce_to_pyobject(env)
3724             self.args[i] = arg
3725         env.use_utility_code(Builtin.pyexec_utility_code)
3726
3727     nogil_check = Node.gil_error
3728     gil_message = "Python exec statement"
3729
3730     def generate_execution_code(self, code):
3731         args = []
3732         for arg in self.args:
3733             arg.generate_evaluation_code(code)
3734             args.append( arg.py_result() )
3735         args = tuple(args + ['0', '0'][:3-len(args)])
3736         temp_result = code.funcstate.allocate_temp(PyrexTypes.py_object_type, manage_ref=True)
3737         code.putln("%s = __Pyx_PyRun(%s, %s, %s);" % (
3738                 (temp_result,) + args))
3739         for arg in self.args:
3740             arg.generate_disposal_code(code)
3741             arg.free_temps(code)
3742         code.putln(
3743             code.error_goto_if_null(temp_result, self.pos))
3744         code.put_gotref(temp_result)
3745         code.put_decref_clear(temp_result, py_object_type)
3746         code.funcstate.release_temp(temp_result)
3747
3748     def annotate(self, code):
3749         for arg in self.args:
3750             arg.annotate(code)
3751
3752
3753 class DelStatNode(StatNode):
3754     #  del statement
3755     #
3756     #  args     [ExprNode]
3757
3758     child_attrs = ["args"]
3759
3760     def analyse_declarations(self, env):
3761         for arg in self.args:
3762             arg.analyse_target_declaration(env)
3763
3764     def analyse_expressions(self, env):
3765         for arg in self.args:
3766             arg.analyse_target_expression(env, None)
3767             if arg.type.is_pyobject:
3768                 pass
3769             elif arg.type.is_ptr and arg.type.base_type.is_cpp_class:
3770                 self.cpp_check(env)
3771             elif arg.type.is_cpp_class:
3772                 error(arg.pos, "Deletion of non-heap C++ object")
3773             else:
3774                 error(arg.pos, "Deletion of non-Python, non-C++ object")
3775             #arg.release_target_temp(env)
3776
3777     def nogil_check(self, env):
3778         for arg in self.args:
3779             if arg.type.is_pyobject:
3780                 self.gil_error()
3781
3782     gil_message = "Deleting Python object"
3783
3784     def generate_execution_code(self, code):
3785         for arg in self.args:
3786             if arg.type.is_pyobject:
3787                 arg.generate_deletion_code(code)
3788             elif arg.type.is_ptr and arg.type.base_type.is_cpp_class:
3789                 arg.generate_result_code(code)
3790                 code.putln("delete %s;" % arg.result())
3791             # else error reported earlier
3792
3793     def annotate(self, code):
3794         for arg in self.args:
3795             arg.annotate(code)
3796
3797
3798 class PassStatNode(StatNode):
3799     #  pass statement
3800
3801     child_attrs = []
3802
3803     def analyse_expressions(self, env):
3804         pass
3805
3806     def generate_execution_code(self, code):
3807         pass
3808
3809
3810 class BreakStatNode(StatNode):
3811
3812     child_attrs = []
3813
3814     def analyse_expressions(self, env):
3815         pass
3816
3817     def generate_execution_code(self, code):
3818         if not code.break_label:
3819             error(self.pos, "break statement not inside loop")
3820         else:
3821             code.put_goto(code.break_label)
3822
3823
3824 class ContinueStatNode(StatNode):
3825
3826     child_attrs = []
3827
3828     def analyse_expressions(self, env):
3829         pass
3830
3831     def generate_execution_code(self, code):
3832         if code.funcstate.in_try_finally:
3833             error(self.pos, "continue statement inside try of try...finally")
3834         elif not code.continue_label:
3835             error(self.pos, "continue statement not inside loop")
3836         else:
3837             code.put_goto(code.continue_label)
3838
3839
3840 class ReturnStatNode(StatNode):
3841     #  return statement
3842     #
3843     #  value         ExprNode or None
3844     #  return_type   PyrexType
3845
3846     child_attrs = ["value"]
3847
3848     def analyse_expressions(self, env):
3849         return_type = env.return_type
3850         self.return_type = return_type
3851         if not return_type:
3852             error(self.pos, "Return not inside a function body")
3853             return
3854         if self.value:
3855             self.value.analyse_types(env)
3856             if return_type.is_void or return_type.is_returncode:
3857                 error(self.value.pos,
3858                     "Return with value in void function")
3859             else:
3860                 self.value = self.value.coerce_to(env.return_type, env)
3861         else:
3862             if (not return_type.is_void
3863                 and not return_type.is_pyobject
3864                 and not return_type.is_returncode):
3865                     error(self.pos, "Return value required")
3866
3867     def nogil_check(self, env):
3868         if self.return_type.is_pyobject:
3869             self.gil_error()
3870
3871     gil_message = "Returning Python object"
3872
3873     def generate_execution_code(self, code):
3874         code.mark_pos(self.pos)
3875         if not self.return_type:
3876             # error reported earlier
3877             return
3878         if self.return_type.is_pyobject:
3879             code.put_xdecref(Naming.retval_cname,
3880                              self.return_type)
3881         if self.value:
3882             self.value.generate_evaluation_code(code)
3883             self.value.make_owned_reference(code)
3884             code.putln(
3885                 "%s = %s;" % (
3886                     Naming.retval_cname,
3887                     self.value.result_as(self.return_type)))
3888             self.value.generate_post_assignment_code(code)
3889             self.value.free_temps(code)
3890         else:
3891             if self.return_type.is_pyobject:
3892                 code.put_init_to_py_none(Naming.retval_cname, self.return_type)
3893             elif self.return_type.is_returncode:
3894                 code.putln(
3895                     "%s = %s;" % (
3896                         Naming.retval_cname,
3897                         self.return_type.default_value))
3898         for cname, type in code.funcstate.temps_holding_reference():
3899             code.put_decref_clear(cname, type)
3900         code.put_goto(code.return_label)
3901
3902     def generate_function_definitions(self, env, code):
3903         if self.value is not None:
3904             self.value.generate_function_definitions(env, code)
3905
3906     def annotate(self, code):
3907         if self.value:
3908             self.value.annotate(code)
3909
3910
3911 class RaiseStatNode(StatNode):
3912     #  raise statement
3913     #
3914     #  exc_type    ExprNode or None
3915     #  exc_value   ExprNode or None
3916     #  exc_tb      ExprNode or None
3917
3918     child_attrs = ["exc_type", "exc_value", "exc_tb"]
3919
3920     def analyse_expressions(self, env):
3921         if self.exc_type:
3922             self.exc_type.analyse_types(env)
3923             self.exc_type = self.exc_type.coerce_to_pyobject(env)
3924         if self.exc_value:
3925             self.exc_value.analyse_types(env)
3926             self.exc_value = self.exc_value.coerce_to_pyobject(env)
3927         if self.exc_tb:
3928             self.exc_tb.analyse_types(env)
3929             self.exc_tb = self.exc_tb.coerce_to_pyobject(env)
3930         env.use_utility_code(raise_utility_code)
3931
3932     nogil_check = Node.gil_error
3933     gil_message = "Raising exception"
3934
3935     def generate_execution_code(self, code):
3936         if self.exc_type:
3937             self.exc_type.generate_evaluation_code(code)
3938             type_code = self.exc_type.py_result()
3939         else:
3940             type_code = "0"
3941         if self.exc_value:
3942             self.exc_value.generate_evaluation_code(code)
3943             value_code = self.exc_value.py_result()
3944         else:
3945             value_code = "0"
3946         if self.exc_tb:
3947             self.exc_tb.generate_evaluation_code(code)
3948             tb_code = self.exc_tb.py_result()
3949         else:
3950             tb_code = "0"
3951         code.putln(
3952             "__Pyx_Raise(%s, %s, %s);" % (
3953                 type_code,
3954                 value_code,
3955                 tb_code))
3956         for obj in (self.exc_type, self.exc_value, self.exc_tb):
3957             if obj:
3958                 obj.generate_disposal_code(code)
3959                 obj.free_temps(code)
3960         code.putln(
3961             code.error_goto(self.pos))
3962
3963     def generate_function_definitions(self, env, code):
3964         if self.exc_type is not None:
3965             self.exc_type.generate_function_definitions(env, code)
3966         if self.exc_value is not None:
3967             self.exc_value.generate_function_definitions(env, code)
3968         if self.exc_tb is not None:
3969             self.exc_tb.generate_function_definitions(env, code)
3970
3971     def annotate(self, code):
3972         if self.exc_type:
3973             self.exc_type.annotate(code)
3974         if self.exc_value:
3975             self.exc_value.annotate(code)
3976         if self.exc_tb:
3977             self.exc_tb.annotate(code)
3978
3979
3980 class ReraiseStatNode(StatNode):
3981
3982     child_attrs = []
3983
3984     def analyse_expressions(self, env):
3985         env.use_utility_code(restore_exception_utility_code)
3986
3987     nogil_check = Node.gil_error
3988     gil_message = "Raising exception"
3989
3990     def generate_execution_code(self, code):
3991         vars = code.funcstate.exc_vars
3992         if vars:
3993             for varname in vars:
3994                 code.put_giveref(varname)
3995             code.putln("__Pyx_ErrRestore(%s, %s, %s);" % tuple(vars))
3996             for varname in vars:
3997                 code.put("%s = 0; " % varname)
3998             code.putln()
3999             code.putln(code.error_goto(self.pos))
4000         else:
4001             error(self.pos, "Reraise not inside except clause")
4002
4003
4004 class AssertStatNode(StatNode):
4005     #  assert statement
4006     #
4007     #  cond    ExprNode
4008     #  value   ExprNode or None
4009
4010     child_attrs = ["cond", "value"]
4011
4012     def analyse_expressions(self, env):
4013         self.cond = self.cond.analyse_boolean_expression(env)
4014         if self.value:
4015             self.value.analyse_types(env)
4016             self.value = self.value.coerce_to_pyobject(env)
4017
4018     nogil_check = Node.gil_error
4019     gil_message = "Raising exception"
4020
4021     def generate_execution_code(self, code):
4022         code.putln("#ifndef CYTHON_WITHOUT_ASSERTIONS")
4023         self.cond.generate_evaluation_code(code)
4024         code.putln(
4025             "if (unlikely(!%s)) {" %
4026                 self.cond.result())
4027         if self.value:
4028             self.value.generate_evaluation_code(code)
4029             code.putln(
4030                 "PyErr_SetObject(PyExc_AssertionError, %s);" %
4031                     self.value.py_result())
4032             self.value.generate_disposal_code(code)
4033             self.value.free_temps(code)
4034         else:
4035             code.putln(
4036                 "PyErr_SetNone(PyExc_AssertionError);")
4037         code.putln(
4038                 code.error_goto(self.pos))
4039         code.putln(
4040             "}")
4041         self.cond.generate_disposal_code(code)
4042         self.cond.free_temps(code)
4043         code.putln("#endif")
4044
4045     def generate_function_definitions(self, env, code):
4046         self.cond.generate_function_definitions(env, code)
4047         if self.value is not None:
4048             self.value.generate_function_definitions(env, code)
4049
4050     def annotate(self, code):
4051         self.cond.annotate(code)
4052         if self.value:
4053             self.value.annotate(code)
4054
4055
4056 class IfStatNode(StatNode):
4057     #  if statement
4058     #
4059     #  if_clauses   [IfClauseNode]
4060     #  else_clause  StatNode or None
4061
4062     child_attrs = ["if_clauses", "else_clause"]
4063
4064     def analyse_control_flow(self, env):
4065         env.start_branching(self.pos)
4066         for if_clause in self.if_clauses:
4067             if_clause.analyse_control_flow(env)
4068             env.next_branch(if_clause.end_pos())
4069         if self.else_clause:
4070             self.else_clause.analyse_control_flow(env)
4071         env.finish_branching(self.end_pos())
4072
4073     def analyse_declarations(self, env):
4074         for if_clause in self.if_clauses:
4075             if_clause.analyse_declarations(env)
4076         if self.else_clause:
4077             self.else_clause.analyse_declarations(env)
4078
4079     def analyse_expressions(self, env):
4080         for if_clause in self.if_clauses:
4081             if_clause.analyse_expressions(env)
4082         if self.else_clause:
4083             self.else_clause.analyse_expressions(env)
4084
4085     def generate_execution_code(self, code):
4086         code.mark_pos(self.pos)
4087         end_label = code.new_label()
4088         for if_clause in self.if_clauses:
4089             if_clause.generate_execution_code(code, end_label)
4090         if self.else_clause:
4091             code.putln("/*else*/ {")
4092             self.else_clause.generate_execution_code(code)
4093             code.putln("}")
4094         code.put_label(end_label)
4095
4096     def generate_function_definitions(self, env, code):
4097         for clause in self.if_clauses:
4098             clause.generate_function_definitions(env, code)
4099         if self.else_clause is not None:
4100             self.else_clause.generate_function_definitions(env, code)
4101
4102     def annotate(self, code):
4103         for if_clause in self.if_clauses:
4104             if_clause.annotate(code)
4105         if self.else_clause:
4106             self.else_clause.annotate(code)
4107
4108
4109 class IfClauseNode(Node):
4110     #  if or elif clause in an if statement
4111     #
4112     #  condition   ExprNode
4113     #  body        StatNode
4114
4115     child_attrs = ["condition", "body"]
4116
4117     def analyse_control_flow(self, env):
4118         self.body.analyse_control_flow(env)
4119
4120     def analyse_declarations(self, env):
4121         self.body.analyse_declarations(env)
4122
4123     def analyse_expressions(self, env):
4124         self.condition = \
4125             self.condition.analyse_temp_boolean_expression(env)
4126         self.body.analyse_expressions(env)
4127
4128     def get_constant_condition_result(self):
4129         if self.condition.has_constant_result():
4130             return bool(self.condition.constant_result)
4131         else:
4132             return None
4133
4134     def generate_execution_code(self, code, end_label):
4135         self.condition.generate_evaluation_code(code)
4136         code.putln(
4137             "if (%s) {" %
4138                 self.condition.result())
4139         self.condition.generate_disposal_code(code)
4140         self.condition.free_temps(code)
4141         self.body.generate_execution_code(code)
4142         code.put_goto(end_label)
4143         code.putln("}")
4144
4145     def generate_function_definitions(self, env, code):
4146         self.condition.generate_function_definitions(env, code)
4147         self.body.generate_function_definitions(env, code)
4148
4149     def annotate(self, code):
4150         self.condition.annotate(code)
4151         self.body.annotate(code)
4152
4153
4154 class SwitchCaseNode(StatNode):
4155     # Generated in the optimization of an if-elif-else node
4156     #
4157     # conditions    [ExprNode]
4158     # body          StatNode
4159
4160     child_attrs = ['conditions', 'body']
4161
4162     def generate_execution_code(self, code):
4163         for cond in self.conditions:
4164             code.mark_pos(cond.pos)
4165             cond.generate_evaluation_code(code)
4166             code.putln("case %s:" % cond.result())
4167         self.body.generate_execution_code(code)
4168         code.putln("break;")
4169
4170     def generate_function_definitions(self, env, code):
4171         for cond in self.conditions:
4172             cond.generate_function_definitions(env, code)
4173         self.body.generate_function_definitions(env, code)
4174
4175     def annotate(self, code):
4176         for cond in self.conditions:
4177             cond.annotate(code)
4178         self.body.annotate(code)
4179
4180 class SwitchStatNode(StatNode):
4181     # Generated in the optimization of an if-elif-else node
4182     #
4183     # test          ExprNode
4184     # cases         [SwitchCaseNode]
4185     # else_clause   StatNode or None
4186
4187     child_attrs = ['test', 'cases', 'else_clause']
4188
4189     def generate_execution_code(self, code):
4190         self.test.generate_evaluation_code(code)
4191         code.putln("switch (%s) {" % self.test.result())
4192         for case in self.cases:
4193             case.generate_execution_code(code)
4194         if self.else_clause is not None:
4195             code.putln("default:")
4196             self.else_clause.generate_execution_code(code)
4197             code.putln("break;")
4198         code.putln("}")
4199
4200     def generate_function_definitions(self, env, code):
4201         self.test.generate_function_definitions(env, code)
4202         for case in self.cases:
4203             case.generate_function_definitions(env, code)
4204         if self.else_clause is not None:
4205             self.else_clause.generate_function_definitions(env, code)
4206
4207     def annotate(self, code):
4208         self.test.annotate(code)
4209         for case in self.cases:
4210             case.annotate(code)
4211         if self.else_clause is not None:
4212             self.else_clause.annotate(code)
4213
4214 class LoopNode(object):
4215
4216     def analyse_control_flow(self, env):
4217         env.start_branching(self.pos)
4218         self.body.analyse_control_flow(env)
4219         env.next_branch(self.body.end_pos())
4220         if self.else_clause:
4221             self.else_clause.analyse_control_flow(env)
4222         env.finish_branching(self.end_pos())
4223
4224
4225 class WhileStatNode(LoopNode, StatNode):
4226     #  while statement
4227     #
4228     #  condition    ExprNode
4229     #  body         StatNode
4230     #  else_clause  StatNode
4231
4232     child_attrs = ["condition", "body", "else_clause"]
4233
4234     def analyse_declarations(self, env):
4235         self.body.analyse_declarations(env)
4236         if self.else_clause:
4237             self.else_clause.analyse_declarations(env)
4238
4239     def analyse_expressions(self, env):
4240         self.condition = \
4241             self.condition.analyse_temp_boolean_expression(env)
4242         self.body.analyse_expressions(env)
4243         if self.else_clause:
4244             self.else_clause.analyse_expressions(env)
4245
4246     def generate_execution_code(self, code):
4247         old_loop_labels = code.new_loop_labels()
4248         code.putln(
4249             "while (1) {")
4250         self.condition.generate_evaluation_code(code)
4251         self.condition.generate_disposal_code(code)
4252         code.putln(
4253             "if (!%s) break;" %
4254                 self.condition.result())
4255         self.condition.free_temps(code)
4256         self.body.generate_execution_code(code)
4257         code.put_label(code.continue_label)
4258         code.putln("}")
4259         break_label = code.break_label
4260         code.set_loop_labels(old_loop_labels)
4261         if self.else_clause:
4262             code.putln("/*else*/ {")
4263             self.else_clause.generate_execution_code(code)
4264             code.putln("}")
4265         code.put_label(break_label)
4266
4267     def generate_function_definitions(self, env, code):
4268         self.condition.generate_function_definitions(env, code)
4269         self.body.generate_function_definitions(env, code)
4270         if self.else_clause is not None:
4271             self.else_clause.generate_function_definitions(env, code)
4272
4273     def annotate(self, code):
4274         self.condition.annotate(code)
4275         self.body.annotate(code)
4276         if self.else_clause:
4277             self.else_clause.annotate(code)
4278
4279
4280 def ForStatNode(pos, **kw):
4281     if 'iterator' in kw:
4282         return ForInStatNode(pos, **kw)
4283     else:
4284         return ForFromStatNode(pos, **kw)
4285
4286 class ForInStatNode(LoopNode, StatNode):
4287     #  for statement
4288     #
4289     #  target        ExprNode
4290     #  iterator      IteratorNode
4291     #  body          StatNode
4292     #  else_clause   StatNode
4293     #  item          NextNode       used internally
4294
4295     child_attrs = ["target", "iterator", "body", "else_clause"]
4296     item = None
4297
4298     def analyse_declarations(self, env):
4299         self.target.analyse_target_declaration(env)
4300         self.body.analyse_declarations(env)
4301         if self.else_clause:
4302             self.else_clause.analyse_declarations(env)
4303
4304     def analyse_expressions(self, env):
4305         import ExprNodes
4306         self.target.analyse_target_types(env)
4307         self.iterator.analyse_expressions(env)
4308         self.item = ExprNodes.NextNode(self.iterator, env)
4309         self.item = self.item.coerce_to(self.target.type, env)
4310         self.body.analyse_expressions(env)
4311         if self.else_clause:
4312             self.else_clause.analyse_expressions(env)
4313
4314     def generate_execution_code(self, code):
4315         old_loop_labels = code.new_loop_labels()
4316         self.iterator.allocate_counter_temp(code)
4317         self.iterator.generate_evaluation_code(code)
4318         code.putln(
4319             "for (;;) {")
4320         self.item.generate_evaluation_code(code)
4321         self.target.generate_assignment_code(self.item, code)
4322         self.body.generate_execution_code(code)
4323         code.put_label(code.continue_label)
4324         code.putln(
4325             "}")
4326         break_label = code.break_label
4327         code.set_loop_labels(old_loop_labels)
4328
4329         if self.else_clause:
4330             # in nested loops, the 'else' block can contain a
4331             # 'continue' statement for the outer loop, but we may need
4332             # to generate cleanup code before taking that path, so we
4333             # intercept it here
4334             orig_continue_label = code.continue_label
4335             code.continue_label = code.new_label('outer_continue')
4336
4337             code.putln("/*else*/ {")
4338             self.else_clause.generate_execution_code(code)
4339             code.putln("}")
4340
4341             if code.label_used(code.continue_label):
4342                 code.put_goto(break_label)
4343                 code.put_label(code.continue_label)
4344                 self.iterator.generate_disposal_code(code)
4345                 code.put_goto(orig_continue_label)
4346             code.set_loop_labels(old_loop_labels)
4347
4348         if code.label_used(break_label):
4349             code.put_label(break_label)
4350         self.iterator.release_counter_temp(code)
4351         self.iterator.generate_disposal_code(code)
4352         self.iterator.free_temps(code)
4353
4354     def generate_function_definitions(self, env, code):
4355         self.target.generate_function_definitions(env, code)
4356         self.iterator.generate_function_definitions(env, code)
4357         self.body.generate_function_definitions(env, code)
4358         if self.else_clause is not None:
4359             self.else_clause.generate_function_definitions(env, code)
4360
4361     def annotate(self, code):
4362         self.target.annotate(code)
4363         self.iterator.annotate(code)
4364         self.body.annotate(code)
4365         if self.else_clause:
4366             self.else_clause.annotate(code)
4367         self.item.annotate(code)
4368
4369
4370 class ForFromStatNode(LoopNode, StatNode):
4371     #  for name from expr rel name rel expr
4372     #
4373     #  target        NameNode
4374     #  bound1        ExprNode
4375     #  relation1     string
4376     #  relation2     string
4377     #  bound2        ExprNode
4378     #  step          ExprNode or None
4379     #  body          StatNode
4380     #  else_clause   StatNode or None
4381     #
4382     #  Used internally:
4383     #
4384     #  from_range         bool
4385     #  is_py_target       bool
4386     #  loopvar_node       ExprNode (usually a NameNode or temp node)
4387     #  py_loopvar_node    PyTempNode or None
4388     child_attrs = ["target", "bound1", "bound2", "step", "body", "else_clause"]
4389
4390     is_py_target = False
4391     loopvar_node = None
4392     py_loopvar_node = None
4393     from_range = False
4394
4395     gil_message = "For-loop using object bounds or target"
4396
4397     def nogil_check(self, env):
4398         for x in (self.target, self.bound1, self.bound2):
4399             if x.type.is_pyobject:
4400                 self.gil_error()
4401
4402     def analyse_declarations(self, env):
4403         self.target.analyse_target_declaration(env)
4404         self.body.analyse_declarations(env)
4405         if self.else_clause:
4406             self.else_clause.analyse_declarations(env)
4407
4408     def analyse_expressions(self, env):
4409         import ExprNodes
4410         self.target.analyse_target_types(env)
4411         self.bound1.analyse_types(env)
4412         self.bound2.analyse_types(env)
4413         if self.step is not None:
4414             if isinstance(self.step, ExprNodes.UnaryMinusNode):
4415                 warning(self.step.pos, "Probable infinite loop in for-from-by statment. Consider switching the directions of the relations.", 2)
4416             self.step.analyse_types(env)
4417
4418         target_type = self.target.type
4419         if self.target.type.is_numeric:
4420             loop_type = self.target.type
4421         else:
4422             loop_type = PyrexTypes.c_int_type
4423             if not self.bound1.type.is_pyobject:
4424                 loop_type = PyrexTypes.widest_numeric_type(loop_type, self.bound1.type)
4425             if not self.bound2.type.is_pyobject:
4426                 loop_type = PyrexTypes.widest_numeric_type(loop_type, self.bound2.type)
4427             if self.step is not None and not self.step.type.is_pyobject:
4428                 loop_type = PyrexTypes.widest_numeric_type(loop_type, self.step.type)
4429         self.bound1 = self.bound1.coerce_to(loop_type, env)
4430         self.bound2 = self.bound2.coerce_to(loop_type, env)
4431         if not self.bound2.is_literal:
4432             self.bound2 = self.bound2.coerce_to_temp(env)
4433         if self.step is not None:
4434             self.step = self.step.coerce_to(loop_type, env)
4435             if not self.step.is_literal:
4436                 self.step = self.step.coerce_to_temp(env)
4437
4438         target_type = self.target.type
4439         if not (target_type.is_pyobject or target_type.is_numeric):
4440             error(self.target.pos,
4441                 "for-from loop variable must be c numeric type or Python object")
4442         if target_type.is_numeric:
4443             self.is_py_target = False
4444             if isinstance(self.target, ExprNodes.IndexNode) and self.target.is_buffer_access:
4445                 raise error(self.pos, "Buffer indexing not allowed as for loop target.")
4446             self.loopvar_node = self.target
4447             self.py_loopvar_node = None
4448         else:
4449             self.is_py_target = True
4450             c_loopvar_node = ExprNodes.TempNode(self.pos, loop_type, env)
4451             self.loopvar_node = c_loopvar_node
4452             self.py_loopvar_node = \
4453                 ExprNodes.CloneNode(c_loopvar_node).coerce_to_pyobject(env)
4454         self.body.analyse_expressions(env)
4455         if self.else_clause:
4456             self.else_clause.analyse_expressions(env)
4457
4458     def generate_execution_code(self, code):
4459         old_loop_labels = code.new_loop_labels()
4460         from_range = self.from_range
4461         self.bound1.generate_evaluation_code(code)
4462         self.bound2.generate_evaluation_code(code)
4463         offset, incop = self.relation_table[self.relation1]
4464         if self.step is not None:
4465             self.step.generate_evaluation_code(code)
4466             step = self.step.result()
4467             incop = "%s=%s" % (incop[0], step)
4468         import ExprNodes
4469         if isinstance(self.loopvar_node, ExprNodes.TempNode):
4470             self.loopvar_node.allocate(code)
4471         if isinstance(self.py_loopvar_node, ExprNodes.TempNode):
4472             self.py_loopvar_node.allocate(code)
4473         if from_range:
4474             loopvar_name = code.funcstate.allocate_temp(self.target.type, False)
4475         else:
4476             loopvar_name = self.loopvar_node.result()
4477         code.putln(
4478             "for (%s = %s%s; %s %s %s; %s%s) {" % (
4479                 loopvar_name,
4480                 self.bound1.result(), offset,
4481                 loopvar_name, self.relation2, self.bound2.result(),
4482                 loopvar_name, incop))
4483         if self.py_loopvar_node:
4484             self.py_loopvar_node.generate_evaluation_code(code)
4485             self.target.generate_assignment_code(self.py_loopvar_node, code)
4486         elif from_range:
4487             code.putln("%s = %s;" % (
4488                             self.target.result(), loopvar_name))
4489         self.body.generate_execution_code(code)
4490         code.put_label(code.continue_label)
4491         if self.py_loopvar_node:
4492             # This mess is to make for..from loops with python targets behave
4493             # exactly like those with C targets with regards to re-assignment
4494             # of the loop variable.
4495             import ExprNodes
4496             if self.target.entry.is_pyglobal:
4497                 # We know target is a NameNode, this is the only ugly case.
4498                 target_node = ExprNodes.PyTempNode(self.target.pos, None)
4499                 target_node.allocate(code)
4500                 interned_cname = code.intern_identifier(self.target.entry.name)
4501                 code.globalstate.use_utility_code(ExprNodes.get_name_interned_utility_code)
4502                 code.putln("%s = __Pyx_GetName(%s, %s); %s" % (
4503                                 target_node.result(),
4504                                 Naming.module_cname,
4505                                 interned_cname,
4506                                 code.error_goto_if_null(target_node.result(), self.target.pos)))
4507                 code.put_gotref(target_node.result())
4508             else:
4509                 target_node = self.target
4510             from_py_node = ExprNodes.CoerceFromPyTypeNode(self.loopvar_node.type, target_node, None)
4511             from_py_node.temp_code = loopvar_name
4512             from_py_node.generate_result_code(code)
4513             if self.target.entry.is_pyglobal:
4514                 code.put_decref(target_node.result(), target_node.type)
4515                 target_node.release(code)
4516         code.putln("}")
4517         if self.py_loopvar_node:
4518             # This is potentially wasteful, but we don't want the semantics to
4519             # depend on whether or not the loop is a python type.
4520             self.py_loopvar_node.generate_evaluation_code(code)
4521             self.target.generate_assignment_code(self.py_loopvar_node, code)
4522         if from_range:
4523             code.funcstate.release_temp(loopvar_name)
4524         break_label = code.break_label
4525         code.set_loop_labels(old_loop_labels)
4526         if self.else_clause:
4527             code.putln("/*else*/ {")
4528             self.else_clause.generate_execution_code(code)
4529             code.putln("}")
4530         code.put_label(break_label)
4531         self.bound1.generate_disposal_code(code)
4532         self.bound1.free_temps(code)
4533         self.bound2.generate_disposal_code(code)
4534         self.bound2.free_temps(code)
4535         if isinstance(self.loopvar_node, ExprNodes.TempNode):
4536             self.loopvar_node.release(code)
4537         if isinstance(self.py_loopvar_node, ExprNodes.TempNode):
4538             self.py_loopvar_node.release(code)
4539         if self.step is not None:
4540             self.step.generate_disposal_code(code)
4541             self.step.free_temps(code)
4542
4543     relation_table = {
4544         # {relop : (initial offset, increment op)}
4545         '<=': ("",   "++"),
4546         '<' : ("+1", "++"),
4547         '>=': ("",   "--"),
4548         '>' : ("-1", "--")
4549     }
4550
4551     def generate_function_definitions(self, env, code):
4552         self.target.generate_function_definitions(env, code)
4553         self.bound1.generate_function_definitions(env, code)
4554         self.bound2.generate_function_definitions(env, code)
4555         if self.step is not None:
4556             self.step.generate_function_definitions(env, code)
4557         self.body.generate_function_definitions(env, code)
4558         if self.else_clause is not None:
4559             self.else_clause.generate_function_definitions(env, code)
4560
4561     def annotate(self, code):
4562         self.target.annotate(code)
4563         self.bound1.annotate(code)
4564         self.bound2.annotate(code)
4565         if self.step:
4566             self.step.annotate(code)
4567         self.body.annotate(code)
4568         if self.else_clause:
4569             self.else_clause.annotate(code)
4570
4571
4572 class WithStatNode(StatNode):
4573     """
4574     Represents a Python with statement.
4575
4576     This is only used at parse tree level; and is not present in
4577     analysis or generation phases.
4578     """
4579     #  manager          The with statement manager object
4580     #  target            Node (lhs expression)
4581     #  body             StatNode
4582     child_attrs = ["manager", "target", "body"]
4583
4584 class TryExceptStatNode(StatNode):
4585     #  try .. except statement
4586     #
4587     #  body             StatNode
4588     #  except_clauses   [ExceptClauseNode]
4589     #  else_clause      StatNode or None
4590
4591     child_attrs = ["body", "except_clauses", "else_clause"]
4592
4593     def analyse_control_flow(self, env):
4594         env.start_branching(self.pos)
4595         self.body.analyse_control_flow(env)
4596         successful_try = env.control_flow # grab this for later
4597         env.next_branch(self.body.end_pos())
4598         env.finish_branching(self.body.end_pos())
4599
4600         env.start_branching(self.except_clauses[0].pos)
4601         for except_clause in self.except_clauses:
4602             except_clause.analyse_control_flow(env)
4603             env.next_branch(except_clause.end_pos())
4604
4605         # the else cause it executed only when the try clause finishes
4606         env.control_flow.incoming = successful_try
4607         if self.else_clause:
4608             self.else_clause.analyse_control_flow(env)
4609         env.finish_branching(self.end_pos())
4610
4611     def analyse_declarations(self, env):
4612         self.body.analyse_declarations(env)
4613         for except_clause in self.except_clauses:
4614             except_clause.analyse_declarations(env)
4615         if self.else_clause:
4616             self.else_clause.analyse_declarations(env)
4617         env.use_utility_code(reset_exception_utility_code)
4618
4619     def analyse_expressions(self, env):
4620         self.body.analyse_expressions(env)
4621         default_clause_seen = 0
4622         for except_clause in self.except_clauses:
4623             except_clause.analyse_expressions(env)
4624             if default_clause_seen:
4625                 error(except_clause.pos, "default 'except:' must be last")
4626             if not except_clause.pattern:
4627                 default_clause_seen = 1
4628         self.has_default_clause = default_clause_seen
4629         if self.else_clause:
4630             self.else_clause.analyse_expressions(env)
4631
4632     nogil_check = Node.gil_error
4633     gil_message = "Try-except statement"
4634
4635     def generate_execution_code(self, code):
4636         old_return_label = code.return_label
4637         old_break_label = code.break_label
4638         old_continue_label = code.continue_label
4639         old_error_label = code.new_error_label()
4640         our_error_label = code.error_label
4641         except_end_label = code.new_label('exception_handled')
4642         except_error_label = code.new_label('except_error')
4643         except_return_label = code.new_label('except_return')
4644         try_return_label = code.new_label('try_return')
4645         try_break_label = code.new_label('try_break')
4646         try_continue_label = code.new_label('try_continue')
4647         try_end_label = code.new_label('try_end')
4648
4649         code.putln("{")
4650         code.putln("PyObject %s;" %
4651                    ', '.join(['*%s' % var for var in Naming.exc_save_vars]))
4652         code.putln("__Pyx_ExceptionSave(%s);" %
4653                    ', '.join(['&%s' % var for var in Naming.exc_save_vars]))
4654         for var in Naming.exc_save_vars:
4655             code.put_xgotref(var)
4656         code.putln(
4657             "/*try:*/ {")
4658         code.return_label = try_return_label
4659         code.break_label = try_break_label
4660         code.continue_label = try_continue_label
4661         self.body.generate_execution_code(code)
4662         code.putln(
4663             "}")
4664         temps_to_clean_up = code.funcstate.all_free_managed_temps()
4665         code.error_label = except_error_label
4666         code.return_label = except_return_label
4667         if self.else_clause:
4668             code.putln(
4669                 "/*else:*/ {")
4670             self.else_clause.generate_execution_code(code)
4671             code.putln(
4672                 "}")
4673         for var in Naming.exc_save_vars:
4674             code.put_xdecref_clear(var, py_object_type)
4675         code.put_goto(try_end_label)
4676         if code.label_used(try_return_label):
4677             code.put_label(try_return_label)
4678             for var in Naming.exc_save_vars: code.put_xgiveref(var)
4679             code.putln("__Pyx_ExceptionReset(%s);" %
4680                        ', '.join(Naming.exc_save_vars))
4681             code.put_goto(old_return_label)
4682         code.put_label(our_error_label)
4683         for temp_name, type in temps_to_clean_up:
4684             code.put_xdecref_clear(temp_name, type)
4685         for except_clause in self.except_clauses:
4686             except_clause.generate_handling_code(code, except_end_label)
4687
4688         error_label_used = code.label_used(except_error_label)
4689         if error_label_used or not self.has_default_clause:
4690             if error_label_used:
4691                 code.put_label(except_error_label)
4692             for var in Naming.exc_save_vars: code.put_xgiveref(var)
4693             code.putln("__Pyx_ExceptionReset(%s);" %
4694                        ', '.join(Naming.exc_save_vars))
4695             code.put_goto(old_error_label)
4696
4697         for exit_label, old_label in zip(
4698             [try_break_label, try_continue_label, except_return_label],
4699             [old_break_label, old_continue_label, old_return_label]):
4700
4701             if code.label_used(exit_label):
4702                 code.put_label(exit_label)
4703                 for var in Naming.exc_save_vars: code.put_xgiveref(var)
4704                 code.putln("__Pyx_ExceptionReset(%s);" %
4705                            ', '.join(Naming.exc_save_vars))
4706                 code.put_goto(old_label)
4707
4708         if code.label_used(except_end_label):
4709             code.put_label(except_end_label)
4710             for var in Naming.exc_save_vars: code.put_xgiveref(var)
4711             code.putln("__Pyx_ExceptionReset(%s);" %
4712                        ', '.join(Naming.exc_save_vars))
4713         code.put_label(try_end_label)
4714         code.putln("}")
4715
4716         code.return_label = old_return_label
4717         code.break_label = old_break_label
4718         code.continue_label = old_continue_label
4719         code.error_label = old_error_label
4720
4721     def generate_function_definitions(self, env, code):
4722         self.body.generate_function_definitions(env, code)
4723         for except_clause in self.except_clauses:
4724             except_clause.generate_function_definitions(env, code)
4725         if self.else_clause is not None:
4726             self.else_clause.generate_function_definitions(env, code)
4727
4728     def annotate(self, code):
4729         self.body.annotate(code)
4730         for except_node in self.except_clauses:
4731             except_node.annotate(code)
4732         if self.else_clause:
4733             self.else_clause.annotate(code)
4734
4735
4736 class ExceptClauseNode(Node):
4737     #  Part of try ... except statement.
4738     #
4739     #  pattern        [ExprNode]
4740     #  target         ExprNode or None
4741     #  body           StatNode
4742     #  excinfo_target NameNode or None   optional target for exception info
4743     #  match_flag     string             result of exception match
4744     #  exc_value      ExcValueNode       used internally
4745     #  function_name  string             qualified name of enclosing function
4746     #  exc_vars       (string * 3)       local exception variables
4747
4748     # excinfo_target is never set by the parser, but can be set by a transform
4749     # in order to extract more extensive information about the exception as a
4750     # sys.exc_info()-style tuple into a target variable
4751
4752     child_attrs = ["pattern", "target", "body", "exc_value", "excinfo_target"]
4753
4754     exc_value = None
4755     excinfo_target = None
4756
4757     def analyse_declarations(self, env):
4758         if self.target:
4759             self.target.analyse_target_declaration(env)
4760         if self.excinfo_target is not None:
4761             self.excinfo_target.analyse_target_declaration(env)
4762         self.body.analyse_declarations(env)
4763
4764     def analyse_expressions(self, env):
4765         import ExprNodes
4766         genv = env.global_scope()
4767         self.function_name = env.qualified_name
4768         if self.pattern:
4769             # normalise/unpack self.pattern into a list
4770             for i, pattern in enumerate(self.pattern):
4771                 pattern.analyse_expressions(env)
4772                 self.pattern[i] = pattern.coerce_to_pyobject(env)
4773
4774         if self.target:
4775             self.exc_value = ExprNodes.ExcValueNode(self.pos, env)
4776             self.target.analyse_target_expression(env, self.exc_value)
4777         if self.excinfo_target is not None:
4778             import ExprNodes
4779             self.excinfo_tuple = ExprNodes.TupleNode(pos=self.pos, args=[
4780                 ExprNodes.ExcValueNode(pos=self.pos, env=env) for x in range(3)])
4781             self.excinfo_tuple.analyse_expressions(env)
4782             self.excinfo_target.analyse_target_expression(env, self.excinfo_tuple)
4783
4784         self.body.analyse_expressions(env)
4785
4786     def generate_handling_code(self, code, end_label):
4787         code.mark_pos(self.pos)
4788         if self.pattern:
4789             exc_tests = []
4790             for pattern in self.pattern:
4791                 pattern.generate_evaluation_code(code)
4792                 exc_tests.append("PyErr_ExceptionMatches(%s)" % pattern.py_result())
4793
4794             match_flag = code.funcstate.allocate_temp(PyrexTypes.c_int_type, False)
4795             code.putln(
4796                 "%s = %s;" % (match_flag, ' || '.join(exc_tests)))
4797             for pattern in self.pattern:
4798                 pattern.generate_disposal_code(code)
4799                 pattern.free_temps(code)
4800             code.putln(
4801                 "if (%s) {" %
4802                     match_flag)
4803             code.funcstate.release_temp(match_flag)
4804         else:
4805             code.putln("/*except:*/ {")
4806
4807         if not getattr(self.body, 'stats', True) and \
4808                 self.excinfo_target is None and self.target is None:
4809             # most simple case: no exception variable, empty body (pass)
4810             # => reset the exception state, done
4811             code.putln("PyErr_Restore(0,0,0);")
4812             code.put_goto(end_label)
4813             code.putln("}")
4814             return
4815
4816         exc_vars = [code.funcstate.allocate_temp(py_object_type,
4817                                                  manage_ref=True)
4818                     for i in xrange(3)]
4819         code.putln('__Pyx_AddTraceback("%s");' % self.function_name)
4820         # We always have to fetch the exception value even if
4821         # there is no target, because this also normalises the
4822         # exception and stores it in the thread state.
4823         code.globalstate.use_utility_code(get_exception_utility_code)
4824         exc_args = "&%s, &%s, &%s" % tuple(exc_vars)
4825         code.putln("if (__Pyx_GetException(%s) < 0) %s" % (exc_args,
4826             code.error_goto(self.pos)))
4827         for x in exc_vars:
4828             code.put_gotref(x)
4829         if self.target:
4830             self.exc_value.set_var(exc_vars[1])
4831             self.exc_value.generate_evaluation_code(code)
4832             self.target.generate_assignment_code(self.exc_value, code)
4833         if self.excinfo_target is not None:
4834             for tempvar, node in zip(exc_vars, self.excinfo_tuple.args):
4835                 node.set_var(tempvar)
4836             self.excinfo_tuple.generate_evaluation_code(code)
4837             self.excinfo_target.generate_assignment_code(self.excinfo_tuple, code)
4838
4839         old_break_label, old_continue_label = code.break_label, code.continue_label
4840         code.break_label = code.new_label('except_break')
4841         code.continue_label = code.new_label('except_continue')
4842
4843         old_exc_vars = code.funcstate.exc_vars
4844         code.funcstate.exc_vars = exc_vars
4845         self.body.generate_execution_code(code)
4846         code.funcstate.exc_vars = old_exc_vars
4847         for var in exc_vars:
4848             code.putln("__Pyx_DECREF(%s); %s = 0;" % (var, var))
4849         code.put_goto(end_label)
4850
4851         if code.label_used(code.break_label):
4852             code.put_label(code.break_label)
4853             for var in exc_vars:
4854                 code.putln("__Pyx_DECREF(%s); %s = 0;" % (var, var))
4855             code.put_goto(old_break_label)
4856         code.break_label = old_break_label
4857
4858         if code.label_used(code.continue_label):
4859             code.put_label(code.continue_label)
4860             for var in exc_vars:
4861                 code.putln("__Pyx_DECREF(%s); %s = 0;" % (var, var))
4862             code.put_goto(old_continue_label)
4863         code.continue_label = old_continue_label
4864
4865         for temp in exc_vars:
4866             code.funcstate.release_temp(temp)
4867
4868         code.putln(
4869             "}")
4870
4871     def generate_function_definitions(self, env, code):
4872         if self.target is not None:
4873             self.target.generate_function_definitions(env, code)
4874         self.body.generate_function_definitions(env, code)
4875
4876     def annotate(self, code):
4877         if self.pattern:
4878             for pattern in self.pattern:
4879                 pattern.annotate(code)
4880         if self.target:
4881             self.target.annotate(code)
4882         self.body.annotate(code)
4883
4884
4885 class TryFinallyStatNode(StatNode):
4886     #  try ... finally statement
4887     #
4888     #  body             StatNode
4889     #  finally_clause   StatNode
4890     #
4891     #  The plan is that we funnel all continue, break
4892     #  return and error gotos into the beginning of the
4893     #  finally block, setting a variable to remember which
4894     #  one we're doing. At the end of the finally block, we
4895     #  switch on the variable to figure out where to go.
4896     #  In addition, if we're doing an error, we save the
4897     #  exception on entry to the finally block and restore
4898     #  it on exit.
4899
4900     child_attrs = ["body", "finally_clause"]
4901
4902     preserve_exception = 1
4903
4904     disallow_continue_in_try_finally = 0
4905     # There doesn't seem to be any point in disallowing
4906     # continue in the try block, since we have no problem
4907     # handling it.
4908
4909     def create_analysed(pos, env, body, finally_clause):
4910         node = TryFinallyStatNode(pos, body=body, finally_clause=finally_clause)
4911         return node
4912     create_analysed = staticmethod(create_analysed)
4913
4914     def analyse_control_flow(self, env):
4915         env.start_branching(self.pos)
4916         self.body.analyse_control_flow(env)
4917         env.next_branch(self.body.end_pos())
4918         env.finish_branching(self.body.end_pos())
4919         self.finally_clause.analyse_control_flow(env)
4920
4921     def analyse_declarations(self, env):
4922         self.body.analyse_declarations(env)
4923         self.finally_clause.analyse_declarations(env)
4924
4925     def analyse_expressions(self, env):
4926         self.body.analyse_expressions(env)
4927         self.finally_clause.analyse_expressions(env)
4928
4929     nogil_check = Node.gil_error
4930     gil_message = "Try-finally statement"
4931
4932     def generate_execution_code(self, code):
4933         old_error_label = code.error_label
4934         old_labels = code.all_new_labels()
4935         new_labels = code.get_all_labels()
4936         new_error_label = code.error_label
4937         catch_label = code.new_label()
4938         code.putln(
4939             "/*try:*/ {")
4940         if self.disallow_continue_in_try_finally:
4941             was_in_try_finally = code.funcstate.in_try_finally
4942             code.funcstate.in_try_finally = 1
4943         self.body.generate_execution_code(code)
4944         if self.disallow_continue_in_try_finally:
4945             code.funcstate.in_try_finally = was_in_try_finally
4946         code.putln(
4947             "}")
4948         temps_to_clean_up = code.funcstate.all_free_managed_temps()
4949         code.mark_pos(self.finally_clause.pos)
4950         code.putln(
4951             "/*finally:*/ {")
4952         cases_used = []
4953         error_label_used = 0
4954         for i, new_label in enumerate(new_labels):
4955             if new_label in code.labels_used:
4956                 cases_used.append(i)
4957                 if new_label == new_error_label:
4958                     error_label_used = 1
4959                     error_label_case = i
4960         if cases_used:
4961             code.putln(
4962                     "int __pyx_why;")
4963             if error_label_used and self.preserve_exception:
4964                 code.putln(
4965                     "PyObject *%s, *%s, *%s;" % Naming.exc_vars)
4966                 code.putln(
4967                     "int %s;" % Naming.exc_lineno_name)
4968                 exc_var_init_zero = ''.join(["%s = 0; " % var for var in Naming.exc_vars])
4969                 exc_var_init_zero += '%s = 0;' % Naming.exc_lineno_name
4970                 code.putln(exc_var_init_zero)
4971             else:
4972                 exc_var_init_zero = None
4973             code.use_label(catch_label)
4974             code.putln(
4975                     "__pyx_why = 0; goto %s;" % catch_label)
4976             for i in cases_used:
4977                 new_label = new_labels[i]
4978                 #if new_label and new_label != "<try>":
4979                 if new_label == new_error_label and self.preserve_exception:
4980                     self.put_error_catcher(code,
4981                         new_error_label, i+1, catch_label, temps_to_clean_up)
4982                 else:
4983                     code.put('%s: ' % new_label)
4984                     if exc_var_init_zero:
4985                         code.putln(exc_var_init_zero)
4986                     code.putln("__pyx_why = %s; goto %s;" % (
4987                             i+1,
4988                             catch_label))
4989             code.put_label(catch_label)
4990         code.set_all_labels(old_labels)
4991         if error_label_used:
4992             code.new_error_label()
4993             finally_error_label = code.error_label
4994         self.finally_clause.generate_execution_code(code)
4995         if error_label_used:
4996             if finally_error_label in code.labels_used and self.preserve_exception:
4997                 over_label = code.new_label()
4998                 code.put_goto(over_label);
4999                 code.put_label(finally_error_label)
5000                 code.putln("if (__pyx_why == %d) {" % (error_label_case + 1))
5001                 for var in Naming.exc_vars:
5002                     code.putln("Py_XDECREF(%s);" % var)
5003                 code.putln("}")
5004                 code.put_goto(old_error_label)
5005                 code.put_label(over_label)
5006             code.error_label = old_error_label
5007         if cases_used:
5008             code.putln(
5009                 "switch (__pyx_why) {")
5010             for i in cases_used:
5011                 old_label = old_labels[i]
5012                 if old_label == old_error_label and self.preserve_exception:
5013                     self.put_error_uncatcher(code, i+1, old_error_label)
5014                 else:
5015                     code.use_label(old_label)
5016                     code.putln(
5017                         "case %s: goto %s;" % (
5018                             i+1,
5019                             old_label))
5020             code.putln(
5021                 "}")
5022         code.putln(
5023             "}")
5024
5025     def generate_function_definitions(self, env, code):
5026         self.body.generate_function_definitions(env, code)
5027         self.finally_clause.generate_function_definitions(env, code)
5028
5029     def put_error_catcher(self, code, error_label, i, catch_label, temps_to_clean_up):
5030         code.globalstate.use_utility_code(restore_exception_utility_code)
5031         code.putln(
5032             "%s: {" %
5033                 error_label)
5034         code.putln(
5035                 "__pyx_why = %s;" %
5036                     i)
5037         for temp_name, type in temps_to_clean_up:
5038             code.put_xdecref_clear(temp_name, type)
5039         code.putln(
5040                 "__Pyx_ErrFetch(&%s, &%s, &%s);" %
5041                     Naming.exc_vars)
5042         code.putln(
5043                 "%s = %s;" % (
5044                     Naming.exc_lineno_name, Naming.lineno_cname))
5045         code.put_goto(catch_label)
5046         code.putln("}")
5047
5048     def put_error_uncatcher(self, code, i, error_label):
5049         code.globalstate.use_utility_code(restore_exception_utility_code)
5050         code.putln(
5051             "case %s: {" %
5052                 i)
5053         code.putln(
5054                 "__Pyx_ErrRestore(%s, %s, %s);" %
5055                     Naming.exc_vars)
5056         code.putln(
5057                 "%s = %s;" % (
5058                     Naming.lineno_cname, Naming.exc_lineno_name))
5059         for var in Naming.exc_vars:
5060             code.putln(
5061                 "%s = 0;" %
5062                     var)
5063         code.put_goto(error_label)
5064         code.putln(
5065             "}")
5066
5067     def annotate(self, code):
5068         self.body.annotate(code)
5069         self.finally_clause.annotate(code)
5070
5071
5072 class GILStatNode(TryFinallyStatNode):
5073     #  'with gil' or 'with nogil' statement
5074     #
5075     #   state   string   'gil' or 'nogil'
5076
5077 #    child_attrs = []
5078
5079     preserve_exception = 0
5080
5081     def __init__(self, pos, state, body):
5082         self.state = state
5083         TryFinallyStatNode.__init__(self, pos,
5084             body = body,
5085             finally_clause = GILExitNode(pos, state = state))
5086
5087     def analyse_expressions(self, env):
5088         env.use_utility_code(force_init_threads_utility_code)
5089         was_nogil = env.nogil
5090         env.nogil = 1
5091         TryFinallyStatNode.analyse_expressions(self, env)
5092         env.nogil = was_nogil
5093
5094     nogil_check = None
5095
5096     def generate_execution_code(self, code):
5097         code.mark_pos(self.pos)
5098         code.putln("{")
5099         if self.state == 'gil':
5100             code.putln("#ifdef WITH_THREAD")
5101             code.putln("PyGILState_STATE _save = PyGILState_Ensure();")
5102             code.putln("#endif")
5103         else:
5104             code.putln("#ifdef WITH_THREAD")
5105             code.putln("PyThreadState *_save;")
5106             code.putln("#endif")
5107             code.putln("Py_UNBLOCK_THREADS")
5108         TryFinallyStatNode.generate_execution_code(self, code)
5109         code.putln("}")
5110
5111
5112 class GILExitNode(StatNode):
5113     #  Used as the 'finally' block in a GILStatNode
5114     #
5115     #  state   string   'gil' or 'nogil'
5116
5117     child_attrs = []
5118
5119     def analyse_expressions(self, env):
5120         pass
5121
5122     def generate_execution_code(self, code):
5123         if self.state == 'gil':
5124             code.putln("#ifdef WITH_THREAD")
5125             code.putln("PyGILState_Release(_save);")
5126             code.putln("#endif")
5127         else:
5128             code.putln("Py_BLOCK_THREADS")
5129
5130
5131 class CImportStatNode(StatNode):
5132     #  cimport statement
5133     #
5134     #  module_name   string           Qualified name of module being imported
5135     #  as_name       string or None   Name specified in "as" clause, if any
5136
5137     child_attrs = []
5138
5139     def analyse_declarations(self, env):
5140         if not env.is_module_scope:
5141             error(self.pos, "cimport only allowed at module level")
5142             return
5143         module_scope = env.find_module(self.module_name, self.pos)
5144         if "." in self.module_name:
5145             names = [EncodedString(name) for name in self.module_name.split(".")]
5146             top_name = names[0]
5147             top_module_scope = env.context.find_submodule(top_name)
5148             module_scope = top_module_scope
5149             for name in names[1:]:
5150                 submodule_scope = module_scope.find_submodule(name)
5151                 module_scope.declare_module(name, submodule_scope, self.pos)
5152                 module_scope = submodule_scope
5153             if self.as_name:
5154                 env.declare_module(self.as_name, module_scope, self.pos)
5155             else:
5156                 env.declare_module(top_name, top_module_scope, self.pos)
5157         else:
5158             name = self.as_name or self.module_name
5159             env.declare_module(name, module_scope, self.pos)
5160
5161     def analyse_expressions(self, env):
5162         pass
5163
5164     def generate_execution_code(self, code):
5165         pass
5166
5167
5168 class FromCImportStatNode(StatNode):
5169     #  from ... cimport statement
5170     #
5171     #  module_name     string                        Qualified name of module
5172     #  imported_names  [(pos, name, as_name, kind)]  Names to be imported
5173
5174     child_attrs = []
5175
5176     def analyse_declarations(self, env):
5177         if not env.is_module_scope:
5178             error(self.pos, "cimport only allowed at module level")
5179             return
5180         module_scope = env.find_module(self.module_name, self.pos)
5181         env.add_imported_module(module_scope)
5182         for pos, name, as_name, kind in self.imported_names:
5183             if name == "*":
5184                 for local_name, entry in module_scope.entries.items():
5185                     env.add_imported_entry(local_name, entry, pos)
5186             else:
5187                 entry = module_scope.lookup(name)
5188                 if entry:
5189                     if kind and not self.declaration_matches(entry, kind):
5190                         entry.redeclared(pos)
5191                 else:
5192                     if kind == 'struct' or kind == 'union':
5193                         entry = module_scope.declare_struct_or_union(name,
5194                             kind = kind, scope = None, typedef_flag = 0, pos = pos)
5195                     elif kind == 'class':
5196                         entry = module_scope.declare_c_class(name, pos = pos,
5197                             module_name = self.module_name)
5198                     else:
5199                         submodule_scope = env.context.find_module(name, relative_to = module_scope, pos = self.pos)
5200                         if submodule_scope.parent_module is module_scope:
5201                             env.declare_module(as_name or name, submodule_scope, self.pos)
5202                         else:
5203                             error(pos, "Name '%s' not declared in module '%s'"
5204                                 % (name, self.module_name))
5205
5206                 if entry:
5207                     local_name = as_name or name
5208                     env.add_imported_entry(local_name, entry, pos)
5209
5210     def declaration_matches(self, entry, kind):
5211         if not entry.is_type:
5212             return 0
5213         type = entry.type
5214         if kind == 'class':
5215             if not type.is_extension_type:
5216                 return 0
5217         else:
5218             if not type.is_struct_or_union:
5219                 return 0
5220             if kind != type.kind:
5221                 return 0
5222         return 1
5223
5224     def analyse_expressions(self, env):
5225         pass
5226
5227     def generate_execution_code(self, code):
5228         pass
5229
5230
5231 class FromImportStatNode(StatNode):
5232     #  from ... import statement
5233     #
5234     #  module           ImportNode
5235     #  items            [(string, NameNode)]
5236     #  interned_items   [(string, NameNode, ExprNode)]
5237     #  item             PyTempNode            used internally
5238     #  import_star      boolean               used internally
5239
5240     child_attrs = ["module"]
5241     import_star = 0
5242
5243     def analyse_declarations(self, env):
5244         for name, target in self.items:
5245             if name == "*":
5246                 if not env.is_module_scope:
5247                     error(self.pos, "import * only allowed at module level")
5248                     return
5249                 env.has_import_star = 1
5250                 self.import_star = 1
5251             else:
5252                 target.analyse_target_declaration(env)
5253
5254     def analyse_expressions(self, env):
5255         import ExprNodes
5256         self.module.analyse_expressions(env)
5257         self.item = ExprNodes.RawCNameExprNode(self.pos, py_object_type)
5258         self.interned_items = []
5259         for name, target in self.items:
5260             if name == '*':
5261                 for _, entry in env.entries.items():
5262                     if not entry.is_type and entry.type.is_extension_type:
5263                         env.use_utility_code(ExprNodes.type_test_utility_code)
5264                         break
5265             else:
5266                 entry =  env.lookup(target.name)
5267                 # check whether or not entry is already cimported
5268                 if (entry.is_type and entry.type.name == name
5269                     and hasattr(entry.type, 'module_name')):
5270                     if entry.type.module_name == self.module.module_name.value:
5271                         # cimported with absolute name
5272                         continue
5273                     try:
5274                         # cimported with relative name
5275                         module = env.find_module(self.module.module_name.value,
5276                                                  pos=None)
5277                         if entry.type.module_name == module.qualified_name:
5278                             continue
5279                     except AttributeError:
5280                         pass
5281                 target.analyse_target_expression(env, None)
5282                 if target.type is py_object_type:
5283                     coerced_item = None
5284                 else:
5285                     coerced_item = self.item.coerce_to(target.type, env)
5286                 self.interned_items.append((name, target, coerced_item))
5287
5288     def generate_execution_code(self, code):
5289         self.module.generate_evaluation_code(code)
5290         if self.import_star:
5291             code.putln(
5292                 'if (%s(%s) < 0) %s;' % (
5293                     Naming.import_star,
5294                     self.module.py_result(),
5295                     code.error_goto(self.pos)))
5296         item_temp = code.funcstate.allocate_temp(py_object_type, manage_ref=True)
5297         self.item.set_cname(item_temp)
5298         for name, target, coerced_item in self.interned_items:
5299             cname = code.intern_identifier(name)
5300             code.putln(
5301                 '%s = PyObject_GetAttr(%s, %s); %s' % (
5302                     item_temp,
5303                     self.module.py_result(),
5304                     cname,
5305                     code.error_goto_if_null(item_temp, self.pos)))
5306             code.put_gotref(item_temp)
5307             if coerced_item is None:
5308                 target.generate_assignment_code(self.item, code)
5309             else:
5310                 coerced_item.allocate_temp_result(code)
5311                 coerced_item.generate_result_code(code)
5312                 target.generate_assignment_code(coerced_item, code)
5313             code.put_decref_clear(item_temp, py_object_type)
5314         code.funcstate.release_temp(item_temp)
5315         self.module.generate_disposal_code(code)
5316         self.module.free_temps(code)
5317
5318
5319
5320 #------------------------------------------------------------------------------------
5321 #
5322 #  Runtime support code
5323 #
5324 #------------------------------------------------------------------------------------
5325
5326 utility_function_predeclarations = \
5327 """
5328 /* inline attribute */
5329 #ifndef CYTHON_INLINE
5330   #if defined(__GNUC__)
5331     #define CYTHON_INLINE __inline__
5332   #elif defined(_MSC_VER)
5333     #define CYTHON_INLINE __inline
5334   #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
5335     #define CYTHON_INLINE inline
5336   #else
5337     #define CYTHON_INLINE
5338   #endif
5339 #endif
5340
5341 /* unused attribute */
5342 #ifndef CYTHON_UNUSED
5343 # if defined(__GNUC__)
5344 #   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
5345 #     define CYTHON_UNUSED __attribute__ ((__unused__))
5346 #   else
5347 #     define CYTHON_UNUSED
5348 #   endif
5349 # elif defined(__ICC) || defined(__INTEL_COMPILER)
5350 #   define CYTHON_UNUSED __attribute__ ((__unused__))
5351 # else
5352 #   define CYTHON_UNUSED
5353 # endif
5354 #endif
5355
5356 typedef struct {PyObject **p; char *s; const long n; const char* encoding; const char is_unicode; const char is_str; const char intern; } __Pyx_StringTabEntry; /*proto*/
5357
5358 """
5359
5360 if Options.gcc_branch_hints:
5361     branch_prediction_macros = \
5362     """
5363 #ifdef __GNUC__
5364 /* Test for GCC > 2.95 */
5365 #if __GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95))
5366 #define likely(x)   __builtin_expect(!!(x), 1)
5367 #define unlikely(x) __builtin_expect(!!(x), 0)
5368 #else /* __GNUC__ > 2 ... */
5369 #define likely(x)   (x)
5370 #define unlikely(x) (x)
5371 #endif /* __GNUC__ > 2 ... */
5372 #else /* __GNUC__ */
5373 #define likely(x)   (x)
5374 #define unlikely(x) (x)
5375 #endif /* __GNUC__ */
5376     """
5377 else:
5378     branch_prediction_macros = \
5379     """
5380 #define likely(x)   (x)
5381 #define unlikely(x) (x)
5382     """
5383
5384 #get_name_predeclaration = \
5385 #"static PyObject *__Pyx_GetName(PyObject *dict, char *name); /*proto*/"
5386
5387 #get_name_interned_predeclaration = \
5388 #"static PyObject *__Pyx_GetName(PyObject *dict, PyObject *name); /*proto*/"
5389
5390 #------------------------------------------------------------------------------------
5391
5392 printing_utility_code = UtilityCode(
5393 proto = """
5394 static int __Pyx_Print(PyObject*, PyObject *, int); /*proto*/
5395 #if PY_MAJOR_VERSION >= 3
5396 static PyObject* %s = 0;
5397 static PyObject* %s = 0;
5398 #endif
5399 """ % (Naming.print_function, Naming.print_function_kwargs),
5400 cleanup = """
5401 #if PY_MAJOR_VERSION >= 3
5402 Py_CLEAR(%s);
5403 Py_CLEAR(%s);
5404 #endif
5405 """ % (Naming.print_function, Naming.print_function_kwargs),
5406 impl = r"""
5407 #if PY_MAJOR_VERSION < 3
5408 static PyObject *__Pyx_GetStdout(void) {
5409     PyObject *f = PySys_GetObject((char *)"stdout");
5410     if (!f) {
5411         PyErr_SetString(PyExc_RuntimeError, "lost sys.stdout");
5412     }
5413     return f;
5414 }
5415
5416 static int __Pyx_Print(PyObject* f, PyObject *arg_tuple, int newline) {
5417     PyObject* v;
5418     int i;
5419
5420     if (!f) {
5421         if (!(f = __Pyx_GetStdout()))
5422             return -1;
5423     }
5424     for (i=0; i < PyTuple_GET_SIZE(arg_tuple); i++) {
5425         if (PyFile_SoftSpace(f, 1)) {
5426             if (PyFile_WriteString(" ", f) < 0)
5427                 return -1;
5428         }
5429         v = PyTuple_GET_ITEM(arg_tuple, i);
5430         if (PyFile_WriteObject(v, f, Py_PRINT_RAW) < 0)
5431             return -1;
5432         if (PyString_Check(v)) {
5433             char *s = PyString_AsString(v);
5434             Py_ssize_t len = PyString_Size(v);
5435             if (len > 0 &&
5436                 isspace(Py_CHARMASK(s[len-1])) &&
5437                 s[len-1] != ' ')
5438                     PyFile_SoftSpace(f, 0);
5439         }
5440     }
5441     if (newline) {
5442         if (PyFile_WriteString("\n", f) < 0)
5443             return -1;
5444         PyFile_SoftSpace(f, 0);
5445     }
5446     return 0;
5447 }
5448
5449 #else /* Python 3 has a print function */
5450
5451 static int __Pyx_Print(PyObject* stream, PyObject *arg_tuple, int newline) {
5452     PyObject* kwargs = 0;
5453     PyObject* result = 0;
5454     PyObject* end_string;
5455     if (unlikely(!%(PRINT_FUNCTION)s)) {
5456         %(PRINT_FUNCTION)s = __Pyx_GetAttrString(%(BUILTINS)s, "print");
5457         if (!%(PRINT_FUNCTION)s)
5458             return -1;
5459     }
5460     if (stream) {
5461         kwargs = PyDict_New();
5462         if (unlikely(!kwargs))
5463             return -1;
5464         if (unlikely(PyDict_SetItemString(kwargs, "file", stream) < 0))
5465             goto bad;
5466         if (!newline) {
5467             end_string = PyUnicode_FromStringAndSize(" ", 1);
5468             if (unlikely(!end_string))
5469                 goto bad;
5470             if (PyDict_SetItemString(kwargs, "end", end_string) < 0) {
5471                 Py_DECREF(end_string);
5472                 goto bad;
5473             }
5474             Py_DECREF(end_string);
5475         }
5476     } else if (!newline) {
5477         if (unlikely(!%(PRINT_KWARGS)s)) {
5478             %(PRINT_KWARGS)s = PyDict_New();
5479             if (unlikely(!%(PRINT_KWARGS)s))
5480                 return -1;
5481             end_string = PyUnicode_FromStringAndSize(" ", 1);
5482             if (unlikely(!end_string))
5483                 return -1;
5484             if (PyDict_SetItemString(%(PRINT_KWARGS)s, "end", end_string) < 0) {
5485                 Py_DECREF(end_string);
5486                 return -1;
5487             }
5488             Py_DECREF(end_string);
5489         }
5490         kwargs = %(PRINT_KWARGS)s;
5491     }
5492     result = PyObject_Call(%(PRINT_FUNCTION)s, arg_tuple, kwargs);
5493     if (unlikely(kwargs) && (kwargs != %(PRINT_KWARGS)s))
5494         Py_DECREF(kwargs);
5495     if (!result)
5496         return -1;
5497     Py_DECREF(result);
5498     return 0;
5499 bad:
5500     if (kwargs != %(PRINT_KWARGS)s)
5501         Py_XDECREF(kwargs);
5502     return -1;
5503 }
5504
5505 #endif
5506 """ % {'BUILTINS'       : Naming.builtins_cname,
5507        'PRINT_FUNCTION' : Naming.print_function,
5508        'PRINT_KWARGS'   : Naming.print_function_kwargs}
5509 )
5510
5511
5512 printing_one_utility_code = UtilityCode(
5513 proto = """
5514 static int __Pyx_PrintOne(PyObject* stream, PyObject *o); /*proto*/
5515 """,
5516 impl = r"""
5517 #if PY_MAJOR_VERSION < 3
5518
5519 static int __Pyx_PrintOne(PyObject* f, PyObject *o) {
5520     if (!f) {
5521         if (!(f = __Pyx_GetStdout()))
5522             return -1;
5523     }
5524     if (PyFile_SoftSpace(f, 0)) {
5525         if (PyFile_WriteString(" ", f) < 0)
5526             return -1;
5527     }
5528     if (PyFile_WriteObject(o, f, Py_PRINT_RAW) < 0)
5529         return -1;
5530     if (PyFile_WriteString("\n", f) < 0)
5531         return -1;
5532     return 0;
5533     /* the line below is just to avoid compiler
5534      * compiler warnings about unused functions */
5535     return __Pyx_Print(f, NULL, 0);
5536 }
5537
5538 #else /* Python 3 has a print function */
5539
5540 static int __Pyx_PrintOne(PyObject* stream, PyObject *o) {
5541     int res;
5542     PyObject* arg_tuple = PyTuple_New(1);
5543     if (unlikely(!arg_tuple))
5544         return -1;
5545     Py_INCREF(o);
5546     PyTuple_SET_ITEM(arg_tuple, 0, o);
5547     res = __Pyx_Print(stream, arg_tuple, 1);
5548     Py_DECREF(arg_tuple);
5549     return res;
5550 }
5551
5552 #endif
5553 """,
5554 requires=[printing_utility_code])
5555
5556
5557
5558 #------------------------------------------------------------------------------------
5559
5560 # Exception raising code
5561 #
5562 # Exceptions are raised by __Pyx_Raise() and stored as plain
5563 # type/value/tb in PyThreadState->curexc_*.  When being caught by an
5564 # 'except' statement, curexc_* is moved over to exc_* by
5565 # __Pyx_GetException()
5566
5567 restore_exception_utility_code = UtilityCode(
5568 proto = """
5569 static CYTHON_INLINE void __Pyx_ErrRestore(PyObject *type, PyObject *value, PyObject *tb); /*proto*/
5570 static CYTHON_INLINE void __Pyx_ErrFetch(PyObject **type, PyObject **value, PyObject **tb); /*proto*/
5571 """,
5572 impl = """
5573 static CYTHON_INLINE void __Pyx_ErrRestore(PyObject *type, PyObject *value, PyObject *tb) {
5574     PyObject *tmp_type, *tmp_value, *tmp_tb;
5575     PyThreadState *tstate = PyThreadState_GET();
5576
5577     tmp_type = tstate->curexc_type;
5578     tmp_value = tstate->curexc_value;
5579     tmp_tb = tstate->curexc_traceback;
5580     tstate->curexc_type = type;
5581     tstate->curexc_value = value;
5582     tstate->curexc_traceback = tb;
5583     Py_XDECREF(tmp_type);
5584     Py_XDECREF(tmp_value);
5585     Py_XDECREF(tmp_tb);
5586 }
5587
5588 static CYTHON_INLINE void __Pyx_ErrFetch(PyObject **type, PyObject **value, PyObject **tb) {
5589     PyThreadState *tstate = PyThreadState_GET();
5590     *type = tstate->curexc_type;
5591     *value = tstate->curexc_value;
5592     *tb = tstate->curexc_traceback;
5593
5594     tstate->curexc_type = 0;
5595     tstate->curexc_value = 0;
5596     tstate->curexc_traceback = 0;
5597 }
5598
5599 """)
5600
5601 # The following function is based on do_raise() from ceval.c. There
5602 # are separate versions for Python2 and Python3 as exception handling
5603 # has changed quite a lot between the two versions.
5604
5605 raise_utility_code = UtilityCode(
5606 proto = """
5607 static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb); /*proto*/
5608 """,
5609 impl = """
5610 #if PY_MAJOR_VERSION < 3
5611 static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb) {
5612     Py_XINCREF(type);
5613     Py_XINCREF(value);
5614     Py_XINCREF(tb);
5615     /* First, check the traceback argument, replacing None with NULL. */
5616     if (tb == Py_None) {
5617         Py_DECREF(tb);
5618         tb = 0;
5619     }
5620     else if (tb != NULL && !PyTraceBack_Check(tb)) {
5621         PyErr_SetString(PyExc_TypeError,
5622             "raise: arg 3 must be a traceback or None");
5623         goto raise_error;
5624     }
5625     /* Next, replace a missing value with None */
5626     if (value == NULL) {
5627         value = Py_None;
5628         Py_INCREF(value);
5629     }
5630     #if PY_VERSION_HEX < 0x02050000
5631     if (!PyClass_Check(type))
5632     #else
5633     if (!PyType_Check(type))
5634     #endif
5635     {
5636         /* Raising an instance.  The value should be a dummy. */
5637         if (value != Py_None) {
5638             PyErr_SetString(PyExc_TypeError,
5639                 "instance exception may not have a separate value");
5640             goto raise_error;
5641         }
5642         /* Normalize to raise <class>, <instance> */
5643         Py_DECREF(value);
5644         value = type;
5645         #if PY_VERSION_HEX < 0x02050000
5646             if (PyInstance_Check(type)) {
5647                 type = (PyObject*) ((PyInstanceObject*)type)->in_class;
5648                 Py_INCREF(type);
5649             }
5650             else {
5651                 type = 0;
5652                 PyErr_SetString(PyExc_TypeError,
5653                     "raise: exception must be an old-style class or instance");
5654                 goto raise_error;
5655             }
5656         #else
5657             type = (PyObject*) Py_TYPE(type);
5658             Py_INCREF(type);
5659             if (!PyType_IsSubtype((PyTypeObject *)type, (PyTypeObject *)PyExc_BaseException)) {
5660                 PyErr_SetString(PyExc_TypeError,
5661                     "raise: exception class must be a subclass of BaseException");
5662                 goto raise_error;
5663             }
5664         #endif
5665     }
5666
5667     __Pyx_ErrRestore(type, value, tb);
5668     return;
5669 raise_error:
5670     Py_XDECREF(value);
5671     Py_XDECREF(type);
5672     Py_XDECREF(tb);
5673     return;
5674 }
5675
5676 #else /* Python 3+ */
5677
5678 static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb) {
5679     if (tb == Py_None) {
5680         tb = 0;
5681     } else if (tb && !PyTraceBack_Check(tb)) {
5682         PyErr_SetString(PyExc_TypeError,
5683             "raise: arg 3 must be a traceback or None");
5684         goto bad;
5685     }
5686     if (value == Py_None)
5687         value = 0;
5688
5689     if (PyExceptionInstance_Check(type)) {
5690         if (value) {
5691             PyErr_SetString(PyExc_TypeError,
5692                 "instance exception may not have a separate value");
5693             goto bad;
5694         }
5695         value = type;
5696         type = (PyObject*) Py_TYPE(value);
5697     } else if (!PyExceptionClass_Check(type)) {
5698         PyErr_SetString(PyExc_TypeError,
5699             "raise: exception class must be a subclass of BaseException");
5700         goto bad;
5701     }
5702
5703     PyErr_SetObject(type, value);
5704
5705     if (tb) {
5706         PyThreadState *tstate = PyThreadState_GET();
5707         PyObject* tmp_tb = tstate->curexc_traceback;
5708         if (tb != tmp_tb) {
5709             Py_INCREF(tb);
5710             tstate->curexc_traceback = tb;
5711             Py_XDECREF(tmp_tb);
5712         }
5713     }
5714
5715 bad:
5716     return;
5717 }
5718 #endif
5719 """,
5720 requires=[restore_exception_utility_code])
5721
5722 #------------------------------------------------------------------------------------
5723
5724 get_exception_utility_code = UtilityCode(
5725 proto = """
5726 static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb); /*proto*/
5727 """,
5728 impl = """
5729 static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb) {
5730     PyObject *local_type, *local_value, *local_tb;
5731     PyObject *tmp_type, *tmp_value, *tmp_tb;
5732     PyThreadState *tstate = PyThreadState_GET();
5733     local_type = tstate->curexc_type;
5734     local_value = tstate->curexc_value;
5735     local_tb = tstate->curexc_traceback;
5736     tstate->curexc_type = 0;
5737     tstate->curexc_value = 0;
5738     tstate->curexc_traceback = 0;
5739     PyErr_NormalizeException(&local_type, &local_value, &local_tb);
5740     if (unlikely(tstate->curexc_type))
5741         goto bad;
5742     #if PY_MAJOR_VERSION >= 3
5743     if (unlikely(PyException_SetTraceback(local_value, local_tb) < 0))
5744         goto bad;
5745     #endif
5746     *type = local_type;
5747     *value = local_value;
5748     *tb = local_tb;
5749     Py_INCREF(local_type);
5750     Py_INCREF(local_value);
5751     Py_INCREF(local_tb);
5752     tmp_type = tstate->exc_type;
5753     tmp_value = tstate->exc_value;
5754     tmp_tb = tstate->exc_traceback;
5755     tstate->exc_type = local_type;
5756     tstate->exc_value = local_value;
5757     tstate->exc_traceback = local_tb;
5758     /* Make sure tstate is in a consistent state when we XDECREF
5759        these objects (XDECREF may run arbitrary code). */
5760     Py_XDECREF(tmp_type);
5761     Py_XDECREF(tmp_value);
5762     Py_XDECREF(tmp_tb);
5763     return 0;
5764 bad:
5765     *type = 0;
5766     *value = 0;
5767     *tb = 0;
5768     Py_XDECREF(local_type);
5769     Py_XDECREF(local_value);
5770     Py_XDECREF(local_tb);
5771     return -1;
5772 }
5773
5774 """)
5775
5776 #------------------------------------------------------------------------------------
5777
5778 get_exception_tuple_utility_code = UtilityCode(proto="""
5779 static PyObject *__Pyx_GetExceptionTuple(void); /*proto*/
5780 """,
5781 # I doubt that calling __Pyx_GetException() here is correct as it moves
5782 # the exception from tstate->curexc_* to tstate->exc_*, which prevents
5783 # exception handlers later on from receiving it.
5784 impl = """
5785 static PyObject *__Pyx_GetExceptionTuple(void) {
5786     PyObject *type = NULL, *value = NULL, *tb = NULL;
5787     if (__Pyx_GetException(&type, &value, &tb) == 0) {
5788         PyObject* exc_info = PyTuple_New(3);
5789         if (exc_info) {
5790             Py_INCREF(type);
5791             Py_INCREF(value);
5792             Py_INCREF(tb);
5793             PyTuple_SET_ITEM(exc_info, 0, type);
5794             PyTuple_SET_ITEM(exc_info, 1, value);
5795             PyTuple_SET_ITEM(exc_info, 2, tb);
5796             return exc_info;
5797         }
5798     }
5799     return NULL;
5800 }
5801 """,
5802 requires=[get_exception_utility_code])
5803
5804 #------------------------------------------------------------------------------------
5805
5806 reset_exception_utility_code = UtilityCode(
5807 proto = """
5808 static CYTHON_INLINE void __Pyx_ExceptionSave(PyObject **type, PyObject **value, PyObject **tb); /*proto*/
5809 static void __Pyx_ExceptionReset(PyObject *type, PyObject *value, PyObject *tb); /*proto*/
5810 """,
5811 impl = """
5812 static CYTHON_INLINE void __Pyx_ExceptionSave(PyObject **type, PyObject **value, PyObject **tb) {
5813     PyThreadState *tstate = PyThreadState_GET();
5814     *type = tstate->exc_type;
5815     *value = tstate->exc_value;
5816     *tb = tstate->exc_traceback;
5817     Py_XINCREF(*type);
5818     Py_XINCREF(*value);
5819     Py_XINCREF(*tb);
5820 }
5821
5822 static void __Pyx_ExceptionReset(PyObject *type, PyObject *value, PyObject *tb) {
5823     PyObject *tmp_type, *tmp_value, *tmp_tb;
5824     PyThreadState *tstate = PyThreadState_GET();
5825     tmp_type = tstate->exc_type;
5826     tmp_value = tstate->exc_value;
5827     tmp_tb = tstate->exc_traceback;
5828     tstate->exc_type = type;
5829     tstate->exc_value = value;
5830     tstate->exc_traceback = tb;
5831     Py_XDECREF(tmp_type);
5832     Py_XDECREF(tmp_value);
5833     Py_XDECREF(tmp_tb);
5834 }
5835 """)
5836
5837 #------------------------------------------------------------------------------------
5838
5839 arg_type_test_utility_code = UtilityCode(
5840 proto = """
5841 static int __Pyx_ArgTypeTest(PyObject *obj, PyTypeObject *type, int none_allowed,
5842     const char *name, int exact); /*proto*/
5843 """,
5844 impl = """
5845 static int __Pyx_ArgTypeTest(PyObject *obj, PyTypeObject *type, int none_allowed,
5846     const char *name, int exact)
5847 {
5848     if (!type) {
5849         PyErr_Format(PyExc_SystemError, "Missing type object");
5850         return 0;
5851     }
5852     if (none_allowed && obj == Py_None) return 1;
5853     else if (exact) {
5854         if (Py_TYPE(obj) == type) return 1;
5855     }
5856     else {
5857         if (PyObject_TypeCheck(obj, type)) return 1;
5858     }
5859     PyErr_Format(PyExc_TypeError,
5860         "Argument '%s' has incorrect type (expected %s, got %s)",
5861         name, type->tp_name, Py_TYPE(obj)->tp_name);
5862     return 0;
5863 }
5864 """)
5865
5866 #------------------------------------------------------------------------------------
5867 #
5868 #  __Pyx_RaiseArgtupleInvalid raises the correct exception when too
5869 #  many or too few positional arguments were found.  This handles
5870 #  Py_ssize_t formatting correctly.
5871
5872 raise_argtuple_invalid_utility_code = UtilityCode(
5873 proto = """
5874 static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact,
5875     Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found); /*proto*/
5876 """,
5877 impl = """
5878 static void __Pyx_RaiseArgtupleInvalid(
5879     const char* func_name,
5880     int exact,
5881     Py_ssize_t num_min,
5882     Py_ssize_t num_max,
5883     Py_ssize_t num_found)
5884 {
5885     Py_ssize_t num_expected;
5886     const char *number, *more_or_less;
5887
5888     if (num_found < num_min) {
5889         num_expected = num_min;
5890         more_or_less = "at least";
5891     } else {
5892         num_expected = num_max;
5893         more_or_less = "at most";
5894     }
5895     if (exact) {
5896         more_or_less = "exactly";
5897     }
5898     number = (num_expected == 1) ? "" : "s";
5899     PyErr_Format(PyExc_TypeError,
5900         #if PY_VERSION_HEX < 0x02050000
5901             "%s() takes %s %d positional argument%s (%d given)",
5902         #else
5903             "%s() takes %s %zd positional argument%s (%zd given)",
5904         #endif
5905         func_name, more_or_less, num_expected, number, num_found);
5906 }
5907 """)
5908
5909 raise_keyword_required_utility_code = UtilityCode(
5910 proto = """
5911 static CYTHON_INLINE void __Pyx_RaiseKeywordRequired(const char* func_name, PyObject* kw_name); /*proto*/
5912 """,
5913 impl = """
5914 static CYTHON_INLINE void __Pyx_RaiseKeywordRequired(
5915     const char* func_name,
5916     PyObject* kw_name)
5917 {
5918     PyErr_Format(PyExc_TypeError,
5919         #if PY_MAJOR_VERSION >= 3
5920         "%s() needs keyword-only argument %U", func_name, kw_name);
5921         #else
5922         "%s() needs keyword-only argument %s", func_name,
5923         PyString_AS_STRING(kw_name));
5924         #endif
5925 }
5926 """)
5927
5928 raise_double_keywords_utility_code = UtilityCode(
5929 proto = """
5930 static void __Pyx_RaiseDoubleKeywordsError(
5931     const char* func_name, PyObject* kw_name); /*proto*/
5932 """,
5933 impl = """
5934 static void __Pyx_RaiseDoubleKeywordsError(
5935     const char* func_name,
5936     PyObject* kw_name)
5937 {
5938     PyErr_Format(PyExc_TypeError,
5939         #if PY_MAJOR_VERSION >= 3
5940         "%s() got multiple values for keyword argument '%U'", func_name, kw_name);
5941         #else
5942         "%s() got multiple values for keyword argument '%s'", func_name,
5943         PyString_AS_STRING(kw_name));
5944         #endif
5945 }
5946 """)
5947
5948 #------------------------------------------------------------------------------------
5949 #
5950 #  __Pyx_CheckKeywordStrings raises an error if non-string keywords
5951 #  were passed to a function, or if any keywords were passed to a
5952 #  function that does not accept them.
5953
5954 keyword_string_check_utility_code = UtilityCode(
5955 proto = """
5956 static CYTHON_INLINE int __Pyx_CheckKeywordStrings(PyObject *kwdict,
5957     const char* function_name, int kw_allowed); /*proto*/
5958 """,
5959 impl = """
5960 static CYTHON_INLINE int __Pyx_CheckKeywordStrings(
5961     PyObject *kwdict,
5962     const char* function_name,
5963     int kw_allowed)
5964 {
5965     PyObject* key = 0;
5966     Py_ssize_t pos = 0;
5967     while (PyDict_Next(kwdict, &pos, &key, 0)) {
5968         #if PY_MAJOR_VERSION < 3
5969         if (unlikely(!PyString_CheckExact(key)) && unlikely(!PyString_Check(key)))
5970         #else
5971         if (unlikely(!PyUnicode_CheckExact(key)) && unlikely(!PyUnicode_Check(key)))
5972         #endif
5973             goto invalid_keyword_type;
5974     }
5975     if ((!kw_allowed) && unlikely(key))
5976         goto invalid_keyword;
5977     return 1;
5978 invalid_keyword_type:
5979     PyErr_Format(PyExc_TypeError,
5980         "%s() keywords must be strings", function_name);
5981     return 0;
5982 invalid_keyword:
5983     PyErr_Format(PyExc_TypeError,
5984     #if PY_MAJOR_VERSION < 3
5985         "%s() got an unexpected keyword argument '%s'",
5986         function_name, PyString_AsString(key));
5987     #else
5988         "%s() got an unexpected keyword argument '%U'",
5989         function_name, key);
5990     #endif
5991     return 0;
5992 }
5993 """)
5994
5995 #------------------------------------------------------------------------------------
5996 #
5997 #  __Pyx_ParseOptionalKeywords copies the optional/unknown keyword
5998 #  arguments from the kwds dict into kwds2.  If kwds2 is NULL, unknown
5999 #  keywords will raise an invalid keyword error.
6000 #
6001 #  Three kinds of errors are checked: 1) non-string keywords, 2)
6002 #  unexpected keywords and 3) overlap with positional arguments.
6003 #
6004 #  If num_posargs is greater 0, it denotes the number of positional
6005 #  arguments that were passed and that must therefore not appear
6006 #  amongst the keywords as well.
6007 #
6008 #  This method does not check for required keyword arguments.
6009 #
6010
6011 parse_keywords_utility_code = UtilityCode(
6012 proto = """
6013 static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject **argnames[], \
6014     PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args, \
6015     const char* function_name); /*proto*/
6016 """,
6017 impl = """
6018 static int __Pyx_ParseOptionalKeywords(
6019     PyObject *kwds,
6020     PyObject **argnames[],
6021     PyObject *kwds2,
6022     PyObject *values[],
6023     Py_ssize_t num_pos_args,
6024     const char* function_name)
6025 {
6026     PyObject *key = 0, *value = 0;
6027     Py_ssize_t pos = 0;
6028     PyObject*** name;
6029     PyObject*** first_kw_arg = argnames + num_pos_args;
6030
6031     while (PyDict_Next(kwds, &pos, &key, &value)) {
6032         name = first_kw_arg;
6033         while (*name && (**name != key)) name++;
6034         if (*name) {
6035             values[name-argnames] = value;
6036         } else {
6037             #if PY_MAJOR_VERSION < 3
6038             if (unlikely(!PyString_CheckExact(key)) && unlikely(!PyString_Check(key))) {
6039             #else
6040             if (unlikely(!PyUnicode_CheckExact(key)) && unlikely(!PyUnicode_Check(key))) {
6041             #endif
6042                 goto invalid_keyword_type;
6043             } else {
6044                 for (name = first_kw_arg; *name; name++) {
6045                     #if PY_MAJOR_VERSION >= 3
6046                     if (PyUnicode_GET_SIZE(**name) == PyUnicode_GET_SIZE(key) &&
6047                         PyUnicode_Compare(**name, key) == 0) break;
6048                     #else
6049                     if (PyString_GET_SIZE(**name) == PyString_GET_SIZE(key) &&
6050                         _PyString_Eq(**name, key)) break;
6051                     #endif
6052                 }
6053                 if (*name) {
6054                     values[name-argnames] = value;
6055                 } else {
6056                     /* unexpected keyword found */
6057                     for (name=argnames; name != first_kw_arg; name++) {
6058                         if (**name == key) goto arg_passed_twice;
6059                         #if PY_MAJOR_VERSION >= 3
6060                         if (PyUnicode_GET_SIZE(**name) == PyUnicode_GET_SIZE(key) &&
6061                             PyUnicode_Compare(**name, key) == 0) goto arg_passed_twice;
6062                         #else
6063                         if (PyString_GET_SIZE(**name) == PyString_GET_SIZE(key) &&
6064                             _PyString_Eq(**name, key)) goto arg_passed_twice;
6065                         #endif
6066                     }
6067                     if (kwds2) {
6068                         if (unlikely(PyDict_SetItem(kwds2, key, value))) goto bad;
6069                     } else {
6070                         goto invalid_keyword;
6071                     }
6072                 }
6073             }
6074         }
6075     }
6076     return 0;
6077 arg_passed_twice:
6078     __Pyx_RaiseDoubleKeywordsError(function_name, **name);
6079     goto bad;
6080 invalid_keyword_type:
6081     PyErr_Format(PyExc_TypeError,
6082         "%s() keywords must be strings", function_name);
6083     goto bad;
6084 invalid_keyword:
6085     PyErr_Format(PyExc_TypeError,
6086     #if PY_MAJOR_VERSION < 3
6087         "%s() got an unexpected keyword argument '%s'",
6088         function_name, PyString_AsString(key));
6089     #else
6090         "%s() got an unexpected keyword argument '%U'",
6091         function_name, key);
6092     #endif
6093 bad:
6094     return -1;
6095 }
6096 """)
6097
6098 #------------------------------------------------------------------------------------
6099
6100 traceback_utility_code = UtilityCode(
6101 proto = """
6102 static void __Pyx_AddTraceback(const char *funcname); /*proto*/
6103 """,
6104 impl = """
6105 #include "compile.h"
6106 #include "frameobject.h"
6107 #include "traceback.h"
6108
6109 static void __Pyx_AddTraceback(const char *funcname) {
6110     PyObject *py_srcfile = 0;
6111     PyObject *py_funcname = 0;
6112     PyObject *py_globals = 0;
6113     PyCodeObject *py_code = 0;
6114     PyFrameObject *py_frame = 0;
6115
6116     #if PY_MAJOR_VERSION < 3
6117     py_srcfile = PyString_FromString(%(FILENAME)s);
6118     #else
6119     py_srcfile = PyUnicode_FromString(%(FILENAME)s);
6120     #endif
6121     if (!py_srcfile) goto bad;
6122     if (%(CLINENO)s) {
6123         #if PY_MAJOR_VERSION < 3
6124         py_funcname = PyString_FromFormat( "%%s (%%s:%%d)", funcname, %(CFILENAME)s, %(CLINENO)s);
6125         #else
6126         py_funcname = PyUnicode_FromFormat( "%%s (%%s:%%d)", funcname, %(CFILENAME)s, %(CLINENO)s);
6127         #endif
6128     }
6129     else {
6130         #if PY_MAJOR_VERSION < 3
6131         py_funcname = PyString_FromString(funcname);
6132         #else
6133         py_funcname = PyUnicode_FromString(funcname);
6134         #endif
6135     }
6136     if (!py_funcname) goto bad;
6137     py_globals = PyModule_GetDict(%(GLOBALS)s);
6138     if (!py_globals) goto bad;
6139     py_code = PyCode_New(
6140         0,            /*int argcount,*/
6141         #if PY_MAJOR_VERSION >= 3
6142         0,            /*int kwonlyargcount,*/
6143         #endif
6144         0,            /*int nlocals,*/
6145         0,            /*int stacksize,*/
6146         0,            /*int flags,*/
6147         %(EMPTY_BYTES)s, /*PyObject *code,*/
6148         %(EMPTY_TUPLE)s,  /*PyObject *consts,*/
6149         %(EMPTY_TUPLE)s,  /*PyObject *names,*/
6150         %(EMPTY_TUPLE)s,  /*PyObject *varnames,*/
6151         %(EMPTY_TUPLE)s,  /*PyObject *freevars,*/
6152         %(EMPTY_TUPLE)s,  /*PyObject *cellvars,*/
6153         py_srcfile,   /*PyObject *filename,*/
6154         py_funcname,  /*PyObject *name,*/
6155         %(LINENO)s,   /*int firstlineno,*/
6156         %(EMPTY_BYTES)s  /*PyObject *lnotab*/
6157     );
6158     if (!py_code) goto bad;
6159     py_frame = PyFrame_New(
6160         PyThreadState_GET(), /*PyThreadState *tstate,*/
6161         py_code,             /*PyCodeObject *code,*/
6162         py_globals,          /*PyObject *globals,*/
6163         0                    /*PyObject *locals*/
6164     );
6165     if (!py_frame) goto bad;
6166     py_frame->f_lineno = %(LINENO)s;
6167     PyTraceBack_Here(py_frame);
6168 bad:
6169     Py_XDECREF(py_srcfile);
6170     Py_XDECREF(py_funcname);
6171     Py_XDECREF(py_code);
6172     Py_XDECREF(py_frame);
6173 }
6174 """ % {
6175     'FILENAME': Naming.filename_cname,
6176     'LINENO':  Naming.lineno_cname,
6177     'CFILENAME': Naming.cfilenm_cname,
6178     'CLINENO':  Naming.clineno_cname,
6179     'GLOBALS': Naming.module_cname,
6180     'EMPTY_TUPLE' : Naming.empty_tuple,
6181     'EMPTY_BYTES' : Naming.empty_bytes,
6182 })
6183
6184 #------------------------------------------------------------------------------------
6185
6186 unraisable_exception_utility_code = UtilityCode(
6187 proto = """
6188 static void __Pyx_WriteUnraisable(const char *name); /*proto*/
6189 """,
6190 impl = """
6191 static void __Pyx_WriteUnraisable(const char *name) {
6192     PyObject *old_exc, *old_val, *old_tb;
6193     PyObject *ctx;
6194     __Pyx_ErrFetch(&old_exc, &old_val, &old_tb);
6195     #if PY_MAJOR_VERSION < 3
6196     ctx = PyString_FromString(name);
6197     #else
6198     ctx = PyUnicode_FromString(name);
6199     #endif
6200     __Pyx_ErrRestore(old_exc, old_val, old_tb);
6201     if (!ctx) {
6202         PyErr_WriteUnraisable(Py_None);
6203     } else {
6204         PyErr_WriteUnraisable(ctx);
6205         Py_DECREF(ctx);
6206     }
6207 }
6208 """,
6209 requires=[restore_exception_utility_code])
6210
6211 #------------------------------------------------------------------------------------
6212
6213 set_vtable_utility_code = UtilityCode(
6214 proto = """
6215 static int __Pyx_SetVtable(PyObject *dict, void *vtable); /*proto*/
6216 """,
6217 impl = """
6218 static int __Pyx_SetVtable(PyObject *dict, void *vtable) {
6219 #if PY_VERSION_HEX >= 0x02070000 && !(PY_MAJOR_VERSION==3&&PY_MINOR_VERSION==0)
6220     PyObject *ob = PyCapsule_New(vtable, 0, 0);
6221 #else
6222     PyObject *ob = PyCObject_FromVoidPtr(vtable, 0);
6223 #endif
6224     if (!ob)
6225         goto bad;
6226     if (PyDict_SetItemString(dict, "__pyx_vtable__", ob) < 0)
6227         goto bad;
6228     Py_DECREF(ob);
6229     return 0;
6230 bad:
6231     Py_XDECREF(ob);
6232     return -1;
6233 }
6234 """)
6235
6236 #------------------------------------------------------------------------------------
6237
6238 get_vtable_utility_code = UtilityCode(
6239 proto = """
6240 static int __Pyx_GetVtable(PyObject *dict, void *vtabptr); /*proto*/
6241 """,
6242 impl = r"""
6243 static int __Pyx_GetVtable(PyObject *dict, void *vtabptr) {
6244     PyObject *ob = PyMapping_GetItemString(dict, (char *)"__pyx_vtable__");
6245     if (!ob)
6246         goto bad;
6247 #if PY_VERSION_HEX >= 0x02070000 && !(PY_MAJOR_VERSION==3&&PY_MINOR_VERSION==0)
6248     *(void **)vtabptr = PyCapsule_GetPointer(ob, 0);
6249 #else
6250     *(void **)vtabptr = PyCObject_AsVoidPtr(ob);
6251 #endif
6252     if (!*(void **)vtabptr)
6253         goto bad;
6254     Py_DECREF(ob);
6255     return 0;
6256 bad:
6257     Py_XDECREF(ob);
6258     return -1;
6259 }
6260 """)
6261
6262 #------------------------------------------------------------------------------------
6263
6264 init_string_tab_utility_code = UtilityCode(
6265 proto = """
6266 static int __Pyx_InitStrings(__Pyx_StringTabEntry *t); /*proto*/
6267 """,
6268 impl = """
6269 static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) {
6270     while (t->p) {
6271         #if PY_MAJOR_VERSION < 3
6272         if (t->is_unicode) {
6273             *t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL);
6274         } else if (t->intern) {
6275             *t->p = PyString_InternFromString(t->s);
6276         } else {
6277             *t->p = PyString_FromStringAndSize(t->s, t->n - 1);
6278         }
6279         #else  /* Python 3+ has unicode identifiers */
6280         if (t->is_unicode | t->is_str) {
6281             if (t->intern) {
6282                 *t->p = PyUnicode_InternFromString(t->s);
6283             } else if (t->encoding) {
6284                 *t->p = PyUnicode_Decode(t->s, t->n - 1, t->encoding, NULL);
6285             } else {
6286                 *t->p = PyUnicode_FromStringAndSize(t->s, t->n - 1);
6287             }
6288         } else {
6289             *t->p = PyBytes_FromStringAndSize(t->s, t->n - 1);
6290         }
6291         #endif
6292         if (!*t->p)
6293             return -1;
6294         ++t;
6295     }
6296     return 0;
6297 }
6298 """)
6299
6300 #------------------------------------------------------------------------------------
6301
6302 force_init_threads_utility_code = UtilityCode(
6303 proto="""
6304 #ifndef __PYX_FORCE_INIT_THREADS
6305   #if PY_VERSION_HEX < 0x02040200
6306     #define __PYX_FORCE_INIT_THREADS 1
6307   #else
6308     #define __PYX_FORCE_INIT_THREADS 0
6309   #endif
6310 #endif
6311 """)
6312
6313 #------------------------------------------------------------------------------------
6314
6315 # Note that cPython ignores PyTrace_EXCEPTION,
6316 # but maybe some other profilers don't.
6317
6318 profile_utility_code = UtilityCode(proto="""
6319 #ifndef CYTHON_PROFILE
6320   #define CYTHON_PROFILE 1
6321 #endif
6322
6323 #ifndef CYTHON_PROFILE_REUSE_FRAME
6324   #define CYTHON_PROFILE_REUSE_FRAME 0
6325 #endif
6326
6327 #if CYTHON_PROFILE
6328
6329   #include "compile.h"
6330   #include "frameobject.h"
6331   #include "traceback.h"
6332
6333   #if CYTHON_PROFILE_REUSE_FRAME
6334     #define CYTHON_FRAME_MODIFIER static
6335     #define CYTHON_FRAME_DEL
6336   #else
6337     #define CYTHON_FRAME_MODIFIER
6338     #define CYTHON_FRAME_DEL Py_DECREF(%(FRAME)s)
6339   #endif
6340
6341   #define __Pyx_TraceDeclarations                                  \\
6342   static PyCodeObject *%(FRAME_CODE)s = NULL;                      \\
6343   CYTHON_FRAME_MODIFIER PyFrameObject *%(FRAME)s = NULL;           \\
6344   int __Pyx_use_tracing = 0;
6345
6346   #define __Pyx_TraceCall(funcname, srcfile, firstlineno)                            \\
6347   if (unlikely(PyThreadState_GET()->use_tracing && PyThreadState_GET()->c_profilefunc)) {      \\
6348       __Pyx_use_tracing = __Pyx_TraceSetupAndCall(&%(FRAME_CODE)s, &%(FRAME)s, funcname, srcfile, firstlineno);  \\
6349   }
6350
6351   #define __Pyx_TraceException()                                                           \\
6352   if (unlikely(__Pyx_use_tracing( && PyThreadState_GET()->use_tracing && PyThreadState_GET()->c_profilefunc) {  \\
6353       PyObject *exc_info = __Pyx_GetExceptionTuple();                                      \\
6354       if (exc_info) {                                                                      \\
6355           PyThreadState_GET()->c_profilefunc(                                              \\
6356               PyThreadState_GET()->c_profileobj, %(FRAME)s, PyTrace_EXCEPTION, exc_info);  \\
6357           Py_DECREF(exc_info);                                                             \\
6358       }                                                                                    \\
6359   }
6360
6361   #define __Pyx_TraceReturn(result)                                                  \\
6362   if (unlikely(__Pyx_use_tracing) && PyThreadState_GET()->use_tracing && PyThreadState_GET()->c_profilefunc) {  \\
6363       PyThreadState_GET()->c_profilefunc(                                            \\
6364           PyThreadState_GET()->c_profileobj, %(FRAME)s, PyTrace_RETURN, (PyObject*)result);     \\
6365       CYTHON_FRAME_DEL;                                                               \\
6366   }
6367
6368   static PyCodeObject *__Pyx_createFrameCodeObject(const char *funcname, const char *srcfile, int firstlineno); /*proto*/
6369   static int __Pyx_TraceSetupAndCall(PyCodeObject** code, PyFrameObject** frame, const char *funcname, const char *srcfile, int firstlineno); /*proto*/
6370
6371 #else
6372
6373   #define __Pyx_TraceDeclarations
6374   #define __Pyx_TraceCall(funcname, srcfile, firstlineno)
6375   #define __Pyx_TraceException()
6376   #define __Pyx_TraceReturn(result)
6377
6378 #endif /* CYTHON_PROFILE */
6379 """
6380 % {
6381     "FRAME": Naming.frame_cname,
6382     "FRAME_CODE": Naming.frame_code_cname,
6383 },
6384 impl = """
6385
6386 #if CYTHON_PROFILE
6387
6388 static int __Pyx_TraceSetupAndCall(PyCodeObject** code,
6389                                    PyFrameObject** frame,
6390                                    const char *funcname,
6391                                    const char *srcfile,
6392                                    int firstlineno) {
6393     if (*frame == NULL || !CYTHON_PROFILE_REUSE_FRAME) {
6394         if (*code == NULL) {
6395             *code = __Pyx_createFrameCodeObject(funcname, srcfile, firstlineno);
6396             if (*code == NULL) return 0;
6397         }
6398         *frame = PyFrame_New(
6399             PyThreadState_GET(),            /*PyThreadState *tstate*/
6400             *code,                          /*PyCodeObject *code*/
6401             PyModule_GetDict(%(MODULE)s),      /*PyObject *globals*/
6402             0                               /*PyObject *locals*/
6403         );
6404         if (*frame == NULL) return 0;
6405     }
6406     else {
6407         (*frame)->f_tstate = PyThreadState_GET();
6408     }
6409     return PyThreadState_GET()->c_profilefunc(PyThreadState_GET()->c_profileobj, *frame, PyTrace_CALL, NULL) == 0;
6410 }
6411
6412 static PyCodeObject *__Pyx_createFrameCodeObject(const char *funcname, const char *srcfile, int firstlineno) {
6413     PyObject *py_srcfile = 0;
6414     PyObject *py_funcname = 0;
6415     PyCodeObject *py_code = 0;
6416
6417     #if PY_MAJOR_VERSION < 3
6418     py_funcname = PyString_FromString(funcname);
6419     py_srcfile = PyString_FromString(srcfile);
6420     #else
6421     py_funcname = PyUnicode_FromString(funcname);
6422     py_srcfile = PyUnicode_FromString(srcfile);
6423     #endif
6424     if (!py_funcname | !py_srcfile) goto bad;
6425
6426     py_code = PyCode_New(
6427         0,                /*int argcount,*/
6428         #if PY_MAJOR_VERSION >= 3
6429         0,                /*int kwonlyargcount,*/
6430         #endif
6431         0,                /*int nlocals,*/
6432         0,                /*int stacksize,*/
6433         0,                /*int flags,*/
6434         %(EMPTY_BYTES)s,  /*PyObject *code,*/
6435         %(EMPTY_TUPLE)s,  /*PyObject *consts,*/
6436         %(EMPTY_TUPLE)s,  /*PyObject *names,*/
6437         %(EMPTY_TUPLE)s,  /*PyObject *varnames,*/
6438         %(EMPTY_TUPLE)s,  /*PyObject *freevars,*/
6439         %(EMPTY_TUPLE)s,  /*PyObject *cellvars,*/
6440         py_srcfile,       /*PyObject *filename,*/
6441         py_funcname,      /*PyObject *name,*/
6442         firstlineno,      /*int firstlineno,*/
6443         %(EMPTY_BYTES)s   /*PyObject *lnotab*/
6444     );
6445
6446 bad:
6447     Py_XDECREF(py_srcfile);
6448     Py_XDECREF(py_funcname);
6449
6450     return py_code;
6451 }
6452
6453 #endif /* CYTHON_PROFILE */
6454 """ % {
6455     'EMPTY_TUPLE' : Naming.empty_tuple,
6456     'EMPTY_BYTES' : Naming.empty_bytes,
6457     "MODULE": Naming.module_cname,
6458 })