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 (acquire_gil or 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 acquire_gil or 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__' and env.is_py_class_scope:
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, allow_redefine=not self.is_wrapper)
2152         self.entry = entry
2153         prefix = env.next_id(env.scope_prefix)
2154
2155         entry.func_cname = \
2156             Naming.pyfunc_prefix + prefix + name
2157         entry.pymethdef_cname = \
2158             Naming.pymethdef_prefix + prefix + name
2159         if Options.docstrings:
2160             entry.doc = embed_position(self.pos, self.doc)
2161             entry.doc_cname = \
2162                 Naming.funcdoc_prefix + prefix + name
2163             if entry.is_special:
2164                 if entry.name in TypeSlots.invisible or not entry.doc or (entry.name in '__getattr__' and env.directives['fast_getattr']):
2165                     entry.wrapperbase_cname = None
2166                 else:
2167                     entry.wrapperbase_cname = Naming.wrapperbase_prefix + prefix + name
2168         else:
2169             entry.doc = None
2170
2171     def declare_lambda_function(self, env):
2172         name = self.name
2173         prefix = env.scope_prefix
2174         func_cname = \
2175             Naming.lambda_func_prefix + u'funcdef' + prefix + self.lambda_name
2176         entry = env.declare_lambda_function(func_cname, self.pos)
2177         entry.pymethdef_cname = \
2178             Naming.lambda_func_prefix + u'methdef' + prefix + self.lambda_name
2179         entry.qualified_name = env.qualify_name(self.lambda_name)
2180         entry.doc = None
2181         self.entry = entry
2182
2183     def declare_arguments(self, env):
2184         for arg in self.args:
2185             if not arg.name:
2186                 error(arg.pos, "Missing argument name")
2187             else:
2188                 env.control_flow.set_state((), (arg.name, 'source'), 'arg')
2189                 env.control_flow.set_state((), (arg.name, 'initialized'), True)
2190             if arg.needs_conversion:
2191                 arg.entry = env.declare_var(arg.name, arg.type, arg.pos)
2192                 if arg.type.is_pyobject:
2193                     arg.entry.init = "0"
2194                 arg.entry.init_to_none = 0
2195             else:
2196                 arg.entry = self.declare_argument(env, arg)
2197             arg.entry.used = 1
2198             arg.entry.is_self_arg = arg.is_self_arg
2199             if arg.hdr_type:
2200                 if arg.is_self_arg or arg.is_type_arg or \
2201                     (arg.type.is_extension_type and not arg.hdr_type.is_extension_type):
2202                         arg.entry.is_declared_generic = 1
2203         self.declare_python_arg(env, self.star_arg)
2204         self.declare_python_arg(env, self.starstar_arg)
2205
2206     def declare_python_arg(self, env, arg):
2207         if arg:
2208             if env.directives['infer_types'] != False:
2209                 type = PyrexTypes.unspecified_type
2210             else:
2211                 type = py_object_type
2212             entry = env.declare_var(arg.name, type, arg.pos)
2213             entry.used = 1
2214             entry.init = "0"
2215             entry.init_to_none = 0
2216             entry.xdecref_cleanup = 1
2217             arg.entry = entry
2218             env.control_flow.set_state((), (arg.name, 'initialized'), True)
2219
2220     def analyse_expressions(self, env):
2221         self.local_scope.directives = env.directives
2222         self.analyse_default_values(env)
2223         if self.needs_assignment_synthesis(env):
2224             # Shouldn't we be doing this at the module level too?
2225             self.synthesize_assignment_node(env)
2226
2227     def needs_assignment_synthesis(self, env, code=None):
2228         # Should enable for module level as well, that will require more testing...
2229         if self.entry.is_anonymous:
2230             return True
2231         if env.is_module_scope:
2232             if code is None:
2233                 return env.directives['binding']
2234             else:
2235                 return code.globalstate.directives['binding']
2236         return env.is_py_class_scope or env.is_closure_scope
2237
2238     def synthesize_assignment_node(self, env):
2239         import ExprNodes
2240         genv = env
2241         while genv.is_py_class_scope or genv.is_c_class_scope:
2242             genv = genv.outer_scope
2243
2244         if genv.is_closure_scope:
2245             rhs = ExprNodes.InnerFunctionNode(
2246                 self.pos, pymethdef_cname = self.entry.pymethdef_cname)
2247         else:
2248             rhs = ExprNodes.PyCFunctionNode(
2249                 self.pos, pymethdef_cname = self.entry.pymethdef_cname, binding = env.directives['binding'])
2250
2251         if env.is_py_class_scope:
2252             if not self.is_staticmethod and not self.is_classmethod:
2253                 rhs.binding = True
2254
2255         self.assmt = SingleAssignmentNode(self.pos,
2256             lhs = ExprNodes.NameNode(self.pos, name = self.name),
2257             rhs = rhs)
2258         self.assmt.analyse_declarations(env)
2259         self.assmt.analyse_expressions(env)
2260
2261     def generate_function_header(self, code, with_pymethdef, proto_only=0):
2262         arg_code_list = []
2263         sig = self.entry.signature
2264         if sig.has_dummy_arg or self.self_in_stararg:
2265             arg_code_list.append(
2266                 "PyObject *%s" % Naming.self_cname)
2267         for arg in self.args:
2268             if not arg.is_generic:
2269                 if arg.is_self_arg or arg.is_type_arg:
2270                     arg_code_list.append("PyObject *%s" % arg.hdr_cname)
2271                 else:
2272                     arg_code_list.append(
2273                         arg.hdr_type.declaration_code(arg.hdr_cname))
2274         if not self.entry.is_special and sig.method_flags() == [TypeSlots.method_noargs]:
2275             arg_code_list.append("CYTHON_UNUSED PyObject *unused")
2276         if sig.has_generic_args:
2277             arg_code_list.append(
2278                 "PyObject *%s, PyObject *%s"
2279                     % (Naming.args_cname, Naming.kwds_cname))
2280         arg_code = ", ".join(arg_code_list)
2281         dc = self.return_type.declaration_code(self.entry.func_cname)
2282         mf = " ".join(self.modifiers).upper()
2283         if mf: mf += " "
2284         header = "static %s%s(%s)" % (mf, dc, arg_code)
2285         code.putln("%s; /*proto*/" % header)
2286         if proto_only:
2287             return
2288         if (Options.docstrings and self.entry.doc and
2289                 not self.entry.scope.is_property_scope and
2290                 (not self.entry.is_special or self.entry.wrapperbase_cname)):
2291             docstr = self.entry.doc
2292             if docstr.is_unicode:
2293                 docstr = docstr.utf8encode()
2294             code.putln(
2295                 'static char %s[] = "%s";' % (
2296                     self.entry.doc_cname,
2297                     split_string_literal(escape_byte_string(docstr))))
2298             if self.entry.is_special:
2299                 code.putln(
2300                     "struct wrapperbase %s;" % self.entry.wrapperbase_cname)
2301         if with_pymethdef:
2302             code.put(
2303                 "static PyMethodDef %s = " %
2304                     self.entry.pymethdef_cname)
2305             code.put_pymethoddef(self.entry, ";", allow_skip=False)
2306         code.putln("%s {" % header)
2307
2308     def generate_argument_declarations(self, env, code):
2309         for arg in self.args:
2310             if arg.is_generic: # or arg.needs_conversion:
2311                 if arg.needs_conversion:
2312                     code.putln("PyObject *%s = 0;" % arg.hdr_cname)
2313                 elif not arg.entry.in_closure:
2314                     code.put_var_declaration(arg.entry)
2315
2316     def generate_keyword_list(self, code):
2317         if self.signature_has_generic_args() and \
2318                 self.signature_has_nongeneric_args():
2319             code.put(
2320                 "static PyObject **%s[] = {" %
2321                     Naming.pykwdlist_cname)
2322             for arg in self.args:
2323                 if arg.is_generic:
2324                     pystring_cname = code.intern_identifier(arg.name)
2325                     code.put('&%s,' % pystring_cname)
2326             code.putln("0};")
2327
2328     def generate_argument_parsing_code(self, env, code):
2329         # Generate PyArg_ParseTuple call for generic
2330         # arguments, if any.
2331         if self.entry.signature.has_dummy_arg and not self.self_in_stararg:
2332             # get rid of unused argument warning
2333             code.putln("%s = %s;" % (Naming.self_cname, Naming.self_cname))
2334
2335         old_error_label = code.new_error_label()
2336         our_error_label = code.error_label
2337         end_label = code.new_label("argument_unpacking_done")
2338
2339         has_kwonly_args = self.num_kwonly_args > 0
2340         has_star_or_kw_args = self.star_arg is not None \
2341             or self.starstar_arg is not None or has_kwonly_args
2342
2343         for arg in self.args:
2344             if not arg.type.is_pyobject:
2345                 done = arg.type.create_from_py_utility_code(env)
2346                 if not done: pass # will fail later
2347
2348         if not self.signature_has_generic_args():
2349             if has_star_or_kw_args:
2350                 error(self.pos, "This method cannot have * or keyword arguments")
2351             self.generate_argument_conversion_code(code)
2352
2353         elif not self.signature_has_nongeneric_args():
2354             # func(*args) or func(**kw) or func(*args, **kw)
2355             self.generate_stararg_copy_code(code)
2356
2357         else:
2358             positional_args = []
2359             kw_only_args = []
2360             for arg in self.args:
2361                 arg_entry = arg.entry
2362                 if arg.is_generic:
2363                     if arg.default:
2364                         if not arg.is_self_arg and not arg.is_type_arg:
2365                             if arg.kw_only:
2366                                 kw_only_args.append(arg)
2367                             else:
2368                                 positional_args.append(arg)
2369                     elif arg.kw_only:
2370                         kw_only_args.append(arg)
2371                     elif not arg.is_self_arg and not arg.is_type_arg:
2372                         positional_args.append(arg)
2373
2374             self.generate_tuple_and_keyword_parsing_code(
2375                 positional_args, kw_only_args, end_label, code)
2376
2377         code.error_label = old_error_label
2378         if code.label_used(our_error_label):
2379             if not code.label_used(end_label):
2380                 code.put_goto(end_label)
2381             code.put_label(our_error_label)
2382             if has_star_or_kw_args:
2383                 self.generate_arg_decref(self.star_arg, code)
2384                 if self.starstar_arg:
2385                     if self.starstar_arg.entry.xdecref_cleanup:
2386                         code.put_var_xdecref(self.starstar_arg.entry)
2387                     else:
2388                         code.put_var_decref(self.starstar_arg.entry)
2389             code.putln('__Pyx_AddTraceback("%s");' % self.entry.qualified_name)
2390             # The arguments are put into the closure one after the
2391             # other, so when type errors are found, all references in
2392             # the closure instance must be properly ref-counted to
2393             # facilitate generic closure instance deallocation.  In
2394             # the case of an argument type error, it's best to just
2395             # DECREF+clear the already handled references, as this
2396             # frees their references as early as possible.
2397             for arg in self.args:
2398                 if arg.type.is_pyobject and arg.entry.in_closure:
2399                     code.put_var_xdecref_clear(arg.entry)
2400             if self.needs_closure:
2401                 code.put_decref(Naming.cur_scope_cname, self.local_scope.scope_class.type)
2402             code.put_finish_refcount_context()
2403             code.putln("return %s;" % self.error_value())
2404         if code.label_used(end_label):
2405             code.put_label(end_label)
2406
2407     def generate_arg_assignment(self, arg, item, code):
2408         if arg.type.is_pyobject:
2409             if arg.is_generic:
2410                 item = PyrexTypes.typecast(arg.type, PyrexTypes.py_object_type, item)
2411             entry = arg.entry
2412             code.putln("%s = %s;" % (entry.cname, item))
2413             if entry.in_closure:
2414                 code.put_var_incref(entry)
2415         else:
2416             func = arg.type.from_py_function
2417             if func:
2418                 code.putln("%s = %s(%s); %s" % (
2419                     arg.entry.cname,
2420                     func,
2421                     item,
2422                     code.error_goto_if(arg.type.error_condition(arg.entry.cname), arg.pos)))
2423             else:
2424                 error(arg.pos, "Cannot convert Python object argument to type '%s'" % arg.type)
2425
2426     def generate_arg_xdecref(self, arg, code):
2427         if arg:
2428             code.put_var_xdecref(arg.entry)
2429
2430     def generate_arg_decref(self, arg, code):
2431         if arg:
2432             code.put_var_decref(arg.entry)
2433
2434     def generate_stararg_copy_code(self, code):
2435         if not self.star_arg:
2436             code.globalstate.use_utility_code(raise_argtuple_invalid_utility_code)
2437             code.putln("if (unlikely(PyTuple_GET_SIZE(%s) > 0)) {" %
2438                        Naming.args_cname)
2439             code.put('__Pyx_RaiseArgtupleInvalid("%s", 1, 0, 0, PyTuple_GET_SIZE(%s)); return %s;' % (
2440                     self.name, Naming.args_cname, self.error_value()))
2441             code.putln("}")
2442
2443         code.globalstate.use_utility_code(keyword_string_check_utility_code)
2444
2445         if self.starstar_arg:
2446             if self.star_arg:
2447                 kwarg_check = "unlikely(%s)" % Naming.kwds_cname
2448             else:
2449                 kwarg_check = "%s" % Naming.kwds_cname
2450         else:
2451             kwarg_check = "unlikely(%s) && unlikely(PyDict_Size(%s) > 0)" % (
2452                 Naming.kwds_cname, Naming.kwds_cname)
2453         code.putln(
2454             "if (%s && unlikely(!__Pyx_CheckKeywordStrings(%s, \"%s\", %d))) return %s;" % (
2455                 kwarg_check, Naming.kwds_cname, self.name,
2456                 bool(self.starstar_arg), self.error_value()))
2457
2458         if self.starstar_arg:
2459             code.putln("%s = (%s) ? PyDict_Copy(%s) : PyDict_New();" % (
2460                     self.starstar_arg.entry.cname,
2461                     Naming.kwds_cname,
2462                     Naming.kwds_cname))
2463             code.putln("if (unlikely(!%s)) return %s;" % (
2464                     self.starstar_arg.entry.cname, self.error_value()))
2465             self.starstar_arg.entry.xdecref_cleanup = 0
2466             code.put_gotref(self.starstar_arg.entry.cname)
2467
2468         if self.self_in_stararg:
2469             # need to create a new tuple with 'self' inserted as first item
2470             code.put("%s = PyTuple_New(PyTuple_GET_SIZE(%s)+1); if (unlikely(!%s)) " % (
2471                     self.star_arg.entry.cname,
2472                     Naming.args_cname,
2473                     self.star_arg.entry.cname))
2474             if self.starstar_arg:
2475                 code.putln("{")
2476                 code.put_decref_clear(self.starstar_arg.entry.cname, py_object_type)
2477                 code.putln("return %s;" % self.error_value())
2478                 code.putln("}")
2479             else:
2480                 code.putln("return %s;" % self.error_value())
2481             code.put_gotref(self.star_arg.entry.cname)
2482             code.put_incref(Naming.self_cname, py_object_type)
2483             code.put_giveref(Naming.self_cname)
2484             code.putln("PyTuple_SET_ITEM(%s, 0, %s);" % (
2485                 self.star_arg.entry.cname, Naming.self_cname))
2486             temp = code.funcstate.allocate_temp(PyrexTypes.c_py_ssize_t_type, manage_ref=False)
2487             code.putln("for (%s=0; %s < PyTuple_GET_SIZE(%s); %s++) {" % (
2488                 temp, temp, Naming.args_cname, temp))
2489             code.putln("PyObject* item = PyTuple_GET_ITEM(%s, %s);" % (
2490                 Naming.args_cname, temp))
2491             code.put_incref("item", py_object_type)
2492             code.put_giveref("item")
2493             code.putln("PyTuple_SET_ITEM(%s, %s+1, item);" % (
2494                 self.star_arg.entry.cname, temp))
2495             code.putln("}")
2496             code.funcstate.release_temp(temp)
2497             self.star_arg.entry.xdecref_cleanup = 0
2498         elif self.star_arg:
2499             code.put_incref(Naming.args_cname, py_object_type)
2500             code.putln("%s = %s;" % (
2501                     self.star_arg.entry.cname,
2502                     Naming.args_cname))
2503             self.star_arg.entry.xdecref_cleanup = 0
2504
2505     def generate_tuple_and_keyword_parsing_code(self, positional_args,
2506                                                 kw_only_args, success_label, code):
2507         argtuple_error_label = code.new_label("argtuple_error")
2508
2509         min_positional_args = self.num_required_args - self.num_required_kw_args
2510         if len(self.args) > 0 and (self.args[0].is_self_arg or self.args[0].is_type_arg):
2511             min_positional_args -= 1
2512         max_positional_args = len(positional_args)
2513         has_fixed_positional_count = not self.star_arg and \
2514             min_positional_args == max_positional_args
2515
2516         code.globalstate.use_utility_code(raise_double_keywords_utility_code)
2517         code.globalstate.use_utility_code(raise_argtuple_invalid_utility_code)
2518         if self.num_required_kw_args:
2519             code.globalstate.use_utility_code(raise_keyword_required_utility_code)
2520
2521         if self.starstar_arg or self.star_arg:
2522             self.generate_stararg_init_code(max_positional_args, code)
2523
2524         # --- optimised code when we receive keyword arguments
2525         if self.num_required_kw_args:
2526             likely_hint = "likely"
2527         else:
2528             likely_hint = "unlikely"
2529         code.putln("if (%s(%s)) {" % (likely_hint, Naming.kwds_cname))
2530         self.generate_keyword_unpacking_code(
2531             min_positional_args, max_positional_args,
2532             has_fixed_positional_count,
2533             positional_args, kw_only_args, argtuple_error_label, code)
2534
2535         # --- optimised code when we do not receive any keyword arguments
2536         if (self.num_required_kw_args and min_positional_args > 0) or min_positional_args == max_positional_args:
2537             # Python raises arg tuple related errors first, so we must
2538             # check the length here
2539             if min_positional_args == max_positional_args and not self.star_arg:
2540                 compare = '!='
2541             else:
2542                 compare = '<'
2543             code.putln('} else if (PyTuple_GET_SIZE(%s) %s %d) {' % (
2544                     Naming.args_cname, compare, min_positional_args))
2545             code.put_goto(argtuple_error_label)
2546
2547         if self.num_required_kw_args:
2548             # pure error case: keywords required but not passed
2549             if max_positional_args > min_positional_args and not self.star_arg:
2550                 code.putln('} else if (PyTuple_GET_SIZE(%s) > %d) {' % (
2551                         Naming.args_cname, max_positional_args))
2552                 code.put_goto(argtuple_error_label)
2553             code.putln('} else {')
2554             for i, arg in enumerate(kw_only_args):
2555                 if not arg.default:
2556                     pystring_cname = code.intern_identifier(arg.name)
2557                     # required keyword-only argument missing
2558                     code.put('__Pyx_RaiseKeywordRequired("%s", %s); ' % (
2559                             self.name,
2560                             pystring_cname))
2561                     code.putln(code.error_goto(self.pos))
2562                     break
2563
2564         elif min_positional_args == max_positional_args:
2565             # parse the exact number of positional arguments from the
2566             # args tuple
2567             code.putln('} else {')
2568             for i, arg in enumerate(positional_args):
2569                 item = "PyTuple_GET_ITEM(%s, %d)" % (Naming.args_cname, i)
2570                 self.generate_arg_assignment(arg, item, code)
2571             self.generate_arg_default_assignments(code)
2572
2573         else:
2574             # parse the positional arguments from the variable length
2575             # args tuple
2576             code.putln('} else {')
2577             self.generate_arg_default_assignments(code)
2578             code.putln('switch (PyTuple_GET_SIZE(%s)) {' % Naming.args_cname)
2579             if self.star_arg:
2580                 code.putln('default:')
2581             reversed_args = list(enumerate(positional_args))[::-1]
2582             for i, arg in reversed_args:
2583                 if i >= min_positional_args-1:
2584                     if min_positional_args > 1:
2585                         code.putln('case %2d:' % (i+1)) # pure code beautification
2586                     else:
2587                         code.put('case %2d: ' % (i+1))
2588                 item = "PyTuple_GET_ITEM(%s, %d)" % (Naming.args_cname, i)
2589                 self.generate_arg_assignment(arg, item, code)
2590             if min_positional_args == 0:
2591                 code.put('case  0: ')
2592             code.putln('break;')
2593             if self.star_arg:
2594                 if min_positional_args:
2595                     for i in range(min_positional_args-1, -1, -1):
2596                         code.putln('case %2d:' % i)
2597                     code.put_goto(argtuple_error_label)
2598             else:
2599                 code.put('default: ')
2600                 code.put_goto(argtuple_error_label)
2601             code.putln('}')
2602
2603         code.putln('}')
2604
2605         if code.label_used(argtuple_error_label):
2606             code.put_goto(success_label)
2607             code.put_label(argtuple_error_label)
2608             code.put('__Pyx_RaiseArgtupleInvalid("%s", %d, %d, %d, PyTuple_GET_SIZE(%s)); ' % (
2609                     self.name, has_fixed_positional_count,
2610                     min_positional_args, max_positional_args,
2611                     Naming.args_cname))
2612             code.putln(code.error_goto(self.pos))
2613
2614     def generate_arg_default_assignments(self, code):
2615         for arg in self.args:
2616             if arg.is_generic and arg.default:
2617                 code.putln(
2618                     "%s = %s;" % (
2619                         arg.entry.cname,
2620                         arg.calculate_default_value_code(code)))
2621
2622     def generate_stararg_init_code(self, max_positional_args, code):
2623         if self.starstar_arg:
2624             self.starstar_arg.entry.xdecref_cleanup = 0
2625             code.putln('%s = PyDict_New(); if (unlikely(!%s)) return %s;' % (
2626                     self.starstar_arg.entry.cname,
2627                     self.starstar_arg.entry.cname,
2628                     self.error_value()))
2629             code.put_gotref(self.starstar_arg.entry.cname)
2630         if self.star_arg:
2631             self.star_arg.entry.xdecref_cleanup = 0
2632             code.putln('if (PyTuple_GET_SIZE(%s) > %d) {' % (
2633                     Naming.args_cname,
2634                     max_positional_args))
2635             code.put('%s = PyTuple_GetSlice(%s, %d, PyTuple_GET_SIZE(%s)); ' % (
2636                     self.star_arg.entry.cname, Naming.args_cname,
2637                     max_positional_args, Naming.args_cname))
2638             code.put_gotref(self.star_arg.entry.cname)
2639             if self.starstar_arg:
2640                 code.putln("")
2641                 code.putln("if (unlikely(!%s)) {" % self.star_arg.entry.cname)
2642                 code.put_decref(self.starstar_arg.entry.cname, py_object_type)
2643                 code.putln('return %s;' % self.error_value())
2644                 code.putln('}')
2645             else:
2646                 code.putln("if (unlikely(!%s)) return %s;" % (
2647                         self.star_arg.entry.cname, self.error_value()))
2648             code.putln('} else {')
2649             code.put("%s = %s; " % (self.star_arg.entry.cname, Naming.empty_tuple))
2650             code.put_incref(Naming.empty_tuple, py_object_type)
2651             code.putln('}')
2652
2653     def generate_keyword_unpacking_code(self, min_positional_args, max_positional_args,
2654                                         has_fixed_positional_count, positional_args,
2655                                         kw_only_args, argtuple_error_label, code):
2656         all_args = tuple(positional_args) + tuple(kw_only_args)
2657         max_args = len(all_args)
2658
2659         code.putln("Py_ssize_t kw_args = PyDict_Size(%s);" %
2660                    Naming.kwds_cname)
2661         # the 'values' array collects borrowed references to arguments
2662         # before doing any type coercion etc.
2663         code.putln("PyObject* values[%d] = {%s};" % (
2664             max_args, ','.join('0'*max_args)))
2665
2666         # assign borrowed Python default values to the values array,
2667         # so that they can be overwritten by received arguments below
2668         for i, arg in enumerate(all_args):
2669             if arg.default and arg.type.is_pyobject:
2670                 default_value = arg.calculate_default_value_code(code)
2671                 code.putln('values[%d] = %s;' % (i, arg.type.as_pyobject(default_value)))
2672
2673         # parse the args tuple and check that it's not too long
2674         code.putln('switch (PyTuple_GET_SIZE(%s)) {' % Naming.args_cname)
2675         if self.star_arg:
2676             code.putln('default:')
2677         for i in range(max_positional_args-1, -1, -1):
2678             code.put('case %2d: ' % (i+1))
2679             code.putln("values[%d] = PyTuple_GET_ITEM(%s, %d);" % (
2680                     i, Naming.args_cname, i))
2681         code.putln('case  0: break;')
2682         if not self.star_arg:
2683             code.put('default: ') # more arguments than allowed
2684             code.put_goto(argtuple_error_label)
2685         code.putln('}')
2686
2687         # now fill up the positional/required arguments with values
2688         # from the kw dict
2689         if self.num_required_args or max_positional_args > 0:
2690             last_required_arg = -1
2691             for i, arg in enumerate(all_args):
2692                 if not arg.default:
2693                     last_required_arg = i
2694             if last_required_arg < max_positional_args:
2695                 last_required_arg = max_positional_args-1
2696             num_required_args = self.num_required_args
2697             if max_positional_args > 0:
2698                 code.putln('switch (PyTuple_GET_SIZE(%s)) {' % Naming.args_cname)
2699             for i, arg in enumerate(all_args[:last_required_arg+1]):
2700                 if max_positional_args > 0 and i <= max_positional_args:
2701                     if self.star_arg and i == max_positional_args:
2702                         code.putln('default:')
2703                     else:
2704                         code.putln('case %2d:' % i)
2705                 pystring_cname = code.intern_identifier(arg.name)
2706                 if arg.default:
2707                     if arg.kw_only:
2708                         # handled separately below
2709                         continue
2710                     code.putln('if (kw_args > 0) {')
2711                     code.putln('PyObject* value = PyDict_GetItem(%s, %s);' % (
2712                         Naming.kwds_cname, pystring_cname))
2713                     code.putln('if (value) { values[%d] = value; kw_args--; }' % i)
2714                     code.putln('}')
2715                 else:
2716                     num_required_args -= 1
2717                     code.putln('values[%d] = PyDict_GetItem(%s, %s);' % (
2718                         i, Naming.kwds_cname, pystring_cname))
2719                     code.putln('if (likely(values[%d])) kw_args--;' % i);
2720                     if i < min_positional_args:
2721                         if i == 0:
2722                             # special case: we know arg 0 is missing
2723                             code.put('else ')
2724                             code.put_goto(argtuple_error_label)
2725                         else:
2726                             # print the correct number of values (args or
2727                             # kwargs) that were passed into positional
2728                             # arguments up to this point
2729                             code.putln('else {')
2730                             code.put('__Pyx_RaiseArgtupleInvalid("%s", %d, %d, %d, %d); ' % (
2731                                     self.name, has_fixed_positional_count,
2732                                     min_positional_args, max_positional_args, i))
2733                             code.putln(code.error_goto(self.pos))
2734                             code.putln('}')
2735                     elif arg.kw_only:
2736                         code.putln('else {')
2737                         code.put('__Pyx_RaiseKeywordRequired("%s", %s); ' %(
2738                                 self.name, pystring_cname))
2739                         code.putln(code.error_goto(self.pos))
2740                         code.putln('}')
2741             if max_positional_args > 0:
2742                 code.putln('}')
2743
2744         if kw_only_args and not self.starstar_arg:
2745             # unpack optional keyword-only arguments
2746             # checking for interned strings in a dict is faster than iterating
2747             # but it's too likely that we must iterate if we expect **kwargs
2748             optional_args = []
2749             for i, arg in enumerate(all_args[max_positional_args:]):
2750                 if not arg.kw_only or not arg.default:
2751                     continue
2752                 optional_args.append((i+max_positional_args, arg))
2753             if optional_args:
2754                 # this mimics an unrolled loop so that we can "break" out of it
2755                 code.putln('while (kw_args > 0) {')
2756                 code.putln('PyObject* value;')
2757                 for i, arg in optional_args:
2758                     pystring_cname = code.intern_identifier(arg.name)
2759                     code.putln(
2760                         'value = PyDict_GetItem(%s, %s);' % (
2761                         Naming.kwds_cname, pystring_cname))
2762                     code.putln(
2763                         'if (value) { values[%d] = value; if (!(--kw_args)) break; }' % i)
2764                 code.putln('break;')
2765                 code.putln('}')
2766
2767         code.putln('if (unlikely(kw_args > 0)) {')
2768         # non-positional/-required kw args left in dict: default args,
2769         # kw-only args, **kwargs or error
2770         #
2771         # This is sort of a catch-all: except for checking required
2772         # arguments, this will always do the right thing for unpacking
2773         # keyword arguments, so that we can concentrate on optimising
2774         # common cases above.
2775         if max_positional_args == 0:
2776             pos_arg_count = "0"
2777         elif self.star_arg:
2778             code.putln("const Py_ssize_t used_pos_args = (PyTuple_GET_SIZE(%s) < %d) ? PyTuple_GET_SIZE(%s) : %d;" % (
2779                     Naming.args_cname, max_positional_args,
2780                     Naming.args_cname, max_positional_args))
2781             pos_arg_count = "used_pos_args"
2782         else:
2783             pos_arg_count = "PyTuple_GET_SIZE(%s)" % Naming.args_cname
2784         code.globalstate.use_utility_code(parse_keywords_utility_code)
2785         code.put(
2786             'if (unlikely(__Pyx_ParseOptionalKeywords(%s, %s, %s, values, %s, "%s") < 0)) ' % (
2787                 Naming.kwds_cname,
2788                 Naming.pykwdlist_cname,
2789                 self.starstar_arg and self.starstar_arg.entry.cname or '0',
2790                 pos_arg_count,
2791                 self.name))
2792         code.putln(code.error_goto(self.pos))
2793         code.putln('}')
2794
2795         # convert arg values to their final type and assign them
2796         for i, arg in enumerate(all_args):
2797             if arg.default and not arg.type.is_pyobject:
2798                 code.putln("if (values[%d]) {" % i)
2799             self.generate_arg_assignment(arg, "values[%d]" % i, code)
2800             if arg.default and not arg.type.is_pyobject:
2801                 code.putln('} else {')
2802                 code.putln(
2803                     "%s = %s;" % (
2804                         arg.entry.cname,
2805                         arg.calculate_default_value_code(code)))
2806                 code.putln('}')
2807
2808     def generate_argument_conversion_code(self, code):
2809         # Generate code to convert arguments from signature type to
2810         # declared type, if needed.  Also copies signature arguments
2811         # into closure fields.
2812         for arg in self.args:
2813             if arg.needs_conversion:
2814                 self.generate_arg_conversion(arg, code)
2815             elif arg.entry.in_closure:
2816                 code.putln('%s = %s;' % (arg.entry.cname, arg.hdr_cname))
2817                 if arg.type.is_pyobject:
2818                     code.put_var_incref(arg.entry)
2819
2820     def generate_arg_conversion(self, arg, code):
2821         # Generate conversion code for one argument.
2822         old_type = arg.hdr_type
2823         new_type = arg.type
2824         if old_type.is_pyobject:
2825             if arg.default:
2826                 code.putln("if (%s) {" % arg.hdr_cname)
2827             else:
2828                 code.putln("assert(%s); {" % arg.hdr_cname)
2829             self.generate_arg_conversion_from_pyobject(arg, code)
2830             code.putln("}")
2831         elif new_type.is_pyobject:
2832             self.generate_arg_conversion_to_pyobject(arg, code)
2833         else:
2834             if new_type.assignable_from(old_type):
2835                 code.putln(
2836                     "%s = %s;" % (arg.entry.cname, arg.hdr_cname))
2837             else:
2838                 error(arg.pos,
2839                     "Cannot convert 1 argument from '%s' to '%s'" %
2840                         (old_type, new_type))
2841
2842     def generate_arg_conversion_from_pyobject(self, arg, code):
2843         new_type = arg.type
2844         func = new_type.from_py_function
2845         # copied from CoerceFromPyTypeNode
2846         if func:
2847             lhs = arg.entry.cname
2848             rhs = "%s(%s)" % (func, arg.hdr_cname)
2849             if new_type.is_enum:
2850                 rhs = PyrexTypes.typecast(new_type, PyrexTypes.c_long_type, rhs)
2851             code.putln("%s = %s; %s" % (
2852                 lhs,
2853                 rhs,
2854                 code.error_goto_if(new_type.error_condition(arg.entry.cname), arg.pos)))
2855         else:
2856             error(arg.pos,
2857                 "Cannot convert Python object argument to type '%s'"
2858                     % new_type)
2859
2860     def generate_arg_conversion_to_pyobject(self, arg, code):
2861         old_type = arg.hdr_type
2862         func = old_type.to_py_function
2863         if func:
2864             code.putln("%s = %s(%s); %s" % (
2865                 arg.entry.cname,
2866                 func,
2867                 arg.hdr_cname,
2868                 code.error_goto_if_null(arg.entry.cname, arg.pos)))
2869             code.put_var_gotref(arg.entry)
2870         else:
2871             error(arg.pos,
2872                 "Cannot convert argument of type '%s' to Python object"
2873                     % old_type)
2874
2875     def generate_argument_type_tests(self, code):
2876         # Generate type tests for args whose signature
2877         # type is PyObject * and whose declared type is
2878         # a subtype thereof.
2879         for arg in self.args:
2880             if arg.needs_type_test:
2881                 self.generate_arg_type_test(arg, code)
2882             elif not arg.accept_none and arg.type.is_pyobject:
2883                 self.generate_arg_none_check(arg, code)
2884
2885     def error_value(self):
2886         return self.entry.signature.error_value
2887
2888     def caller_will_check_exceptions(self):
2889         return 1
2890
2891 class OverrideCheckNode(StatNode):
2892     # A Node for dispatching to the def method if it
2893     # is overriden.
2894     #
2895     #  py_func
2896     #
2897     #  args
2898     #  func_temp
2899     #  body
2900
2901     child_attrs = ['body']
2902
2903     body = None
2904
2905     def analyse_expressions(self, env):
2906         self.args = env.arg_entries
2907         if self.py_func.is_module_scope:
2908             first_arg = 0
2909         else:
2910             first_arg = 1
2911         import ExprNodes
2912         self.func_node = ExprNodes.RawCNameExprNode(self.pos, py_object_type)
2913         call_tuple = ExprNodes.TupleNode(self.pos, args=[ExprNodes.NameNode(self.pos, name=arg.name) for arg in self.args[first_arg:]])
2914         call_node = ExprNodes.SimpleCallNode(self.pos,
2915                                              function=self.func_node,
2916                                              args=[ExprNodes.NameNode(self.pos, name=arg.name) for arg in self.args[first_arg:]])
2917         self.body = ReturnStatNode(self.pos, value=call_node)
2918         self.body.analyse_expressions(env)
2919
2920     def generate_execution_code(self, code):
2921         interned_attr_cname = code.intern_identifier(self.py_func.entry.name)
2922         # Check to see if we are an extension type
2923         if self.py_func.is_module_scope:
2924             self_arg = "((PyObject *)%s)" % Naming.module_cname
2925         else:
2926             self_arg = "((PyObject *)%s)" % self.args[0].cname
2927         code.putln("/* Check if called by wrapper */")
2928         code.putln("if (unlikely(%s)) ;" % Naming.skip_dispatch_cname)
2929         code.putln("/* Check if overriden in Python */")
2930         if self.py_func.is_module_scope:
2931             code.putln("else {")
2932         else:
2933             code.putln("else if (unlikely(Py_TYPE(%s)->tp_dictoffset != 0)) {" % self_arg)
2934         func_node_temp = code.funcstate.allocate_temp(py_object_type, manage_ref=True)
2935         self.func_node.set_cname(func_node_temp)
2936         # need to get attribute manually--scope would return cdef method
2937         err = code.error_goto_if_null(func_node_temp, self.pos)
2938         code.putln("%s = PyObject_GetAttr(%s, %s); %s" % (
2939             func_node_temp, self_arg, interned_attr_cname, err))
2940         code.put_gotref(func_node_temp)
2941         is_builtin_function_or_method = "PyCFunction_Check(%s)" % func_node_temp
2942         is_overridden = "(PyCFunction_GET_FUNCTION(%s) != (void *)&%s)" % (
2943             func_node_temp, self.py_func.entry.func_cname)
2944         code.putln("if (!%s || %s) {" % (is_builtin_function_or_method, is_overridden))
2945         self.body.generate_execution_code(code)
2946         code.putln("}")
2947         code.put_decref_clear(func_node_temp, PyrexTypes.py_object_type)
2948         code.funcstate.release_temp(func_node_temp)
2949         code.putln("}")
2950
2951 class ClassDefNode(StatNode, BlockNode):
2952     pass
2953
2954 class PyClassDefNode(ClassDefNode):
2955     #  A Python class definition.
2956     #
2957     #  name     EncodedString   Name of the class
2958     #  doc      string or None
2959     #  body     StatNode        Attribute definition code
2960     #  entry    Symtab.Entry
2961     #  scope    PyClassScope
2962     #  decorators    [DecoratorNode]        list of decorators or None
2963     #
2964     #  The following subnodes are constructed internally:
2965     #
2966     #  dict     DictNode   Class dictionary or Py3 namespace
2967     #  classobj ClassNode  Class object
2968     #  target   NameNode   Variable to assign class object to
2969
2970     child_attrs = ["body", "dict", "metaclass", "mkw", "bases", "classobj", "target"]
2971     decorators = None
2972     py3_style_class = False # Python3 style class (bases+kwargs)
2973
2974     def __init__(self, pos, name, bases, doc, body, decorators = None,
2975                  keyword_args = None, starstar_arg = None):
2976         StatNode.__init__(self, pos)
2977         self.name = name
2978         self.doc = doc
2979         self.body = body
2980         self.decorators = decorators
2981         import ExprNodes
2982         if self.doc and Options.docstrings:
2983             doc = embed_position(self.pos, self.doc)
2984             doc_node = ExprNodes.StringNode(pos, value = doc)
2985         else:
2986             doc_node = None
2987         if keyword_args or starstar_arg:
2988             self.py3_style_class = True
2989             self.bases = bases
2990             self.metaclass = None
2991             if keyword_args and not starstar_arg:
2992                 for i, item in list(enumerate(keyword_args.key_value_pairs))[::-1]:
2993                     if item.key.value == 'metaclass':
2994                         if self.metaclass is not None:
2995                             error(item.pos, "keyword argument 'metaclass' passed multiple times")
2996                         # special case: we already know the metaclass,
2997                         # so we don't need to do the "build kwargs,
2998                         # find metaclass" dance at runtime
2999                         self.metaclass = item.value
3000                         del keyword_args.key_value_pairs[i]
3001             if starstar_arg or (keyword_args and keyword_args.key_value_pairs):
3002                 self.mkw = ExprNodes.KeywordArgsNode(
3003                     pos, keyword_args = keyword_args, starstar_arg = starstar_arg)
3004             else:
3005                 self.mkw = ExprNodes.NullNode(pos)
3006             if self.metaclass is None:
3007                 self.metaclass = ExprNodes.PyClassMetaclassNode(
3008                     pos, mkw = self.mkw, bases = self.bases)
3009             self.dict = ExprNodes.PyClassNamespaceNode(pos, name = name,
3010                         doc = doc_node, metaclass = self.metaclass, bases = self.bases,
3011                         mkw = self.mkw)
3012             self.classobj = ExprNodes.Py3ClassNode(pos, name = name,
3013                     bases = self.bases, dict = self.dict, doc = doc_node,
3014                     metaclass = self.metaclass, mkw = self.mkw)
3015         else:
3016             self.dict = ExprNodes.DictNode(pos, key_value_pairs = [])
3017             self.metaclass = None
3018             self.mkw = None
3019             self.bases = None
3020             self.classobj = ExprNodes.ClassNode(pos, name = name,
3021                     bases = bases, dict = self.dict, doc = doc_node)
3022         self.target = ExprNodes.NameNode(pos, name = name)
3023
3024     def as_cclass(self):
3025         """
3026         Return this node as if it were declared as an extension class
3027         """
3028         if self.py3_style_class:
3029             error(self.classobj.pos, "Python3 style class could not be represented as C class")
3030             return
3031         bases = self.classobj.bases.args
3032         if len(bases) == 0:
3033             base_class_name = None
3034             base_class_module = None
3035         elif len(bases) == 1:
3036             base = bases[0]
3037             path = []
3038             from ExprNodes import AttributeNode, NameNode
3039             while isinstance(base, AttributeNode):
3040                 path.insert(0, base.attribute)
3041                 base = base.obj
3042             if isinstance(base, NameNode):
3043                 path.insert(0, base.name)
3044                 base_class_name = path[-1]
3045                 if len(path) > 1:
3046                     base_class_module = u'.'.join(path[:-1])
3047                 else:
3048                     base_class_module = None
3049             else:
3050                 error(self.classobj.bases.args.pos, "Invalid base class")
3051         else:
3052             error(self.classobj.bases.args.pos, "C class may only have one base class")
3053             return None
3054
3055         return CClassDefNode(self.pos,
3056                              visibility = 'private',
3057                              module_name = None,
3058                              class_name = self.name,
3059                              base_class_module = base_class_module,
3060                              base_class_name = base_class_name,
3061                              decorators = self.decorators,
3062                              body = self.body,
3063                              in_pxd = False,
3064                              doc = self.doc)
3065
3066     def create_scope(self, env):
3067         genv = env
3068         while genv.is_py_class_scope or genv.is_c_class_scope:
3069             genv = genv.outer_scope
3070         cenv = self.scope = PyClassScope(name = self.name, outer_scope = genv)
3071         return cenv
3072
3073     def analyse_declarations(self, env):
3074         self.target.analyse_target_declaration(env)
3075         cenv = self.create_scope(env)
3076         cenv.directives = env.directives
3077         cenv.class_obj_cname = self.target.entry.cname
3078         self.body.analyse_declarations(cenv)
3079
3080     def analyse_expressions(self, env):
3081         if self.py3_style_class:
3082             self.bases.analyse_expressions(env)
3083             self.metaclass.analyse_expressions(env)
3084             self.mkw.analyse_expressions(env)
3085         self.dict.analyse_expressions(env)
3086         self.classobj.analyse_expressions(env)
3087         genv = env.global_scope()
3088         cenv = self.scope
3089         self.body.analyse_expressions(cenv)
3090         self.target.analyse_target_expression(env, self.classobj)
3091
3092     def generate_function_definitions(self, env, code):
3093         self.generate_lambda_definitions(self.scope, code)
3094         self.body.generate_function_definitions(self.scope, code)
3095
3096     def generate_execution_code(self, code):
3097         code.pyclass_stack.append(self)
3098         cenv = self.scope
3099         if self.py3_style_class:
3100             self.bases.generate_evaluation_code(code)
3101             self.mkw.generate_evaluation_code(code)
3102             self.metaclass.generate_evaluation_code(code)
3103         self.dict.generate_evaluation_code(code)
3104         cenv.namespace_cname = cenv.class_obj_cname = self.dict.result()
3105         self.body.generate_execution_code(code)
3106         self.classobj.generate_evaluation_code(code)
3107         cenv.namespace_cname = cenv.class_obj_cname = self.classobj.result()
3108         self.target.generate_assignment_code(self.classobj, code)
3109         self.dict.generate_disposal_code(code)
3110         self.dict.free_temps(code)
3111         if self.py3_style_class:
3112             self.mkw.generate_disposal_code(code)
3113             self.mkw.free_temps(code)
3114             self.metaclass.generate_disposal_code(code)
3115             self.metaclass.free_temps(code)
3116             self.bases.generate_disposal_code(code)
3117             self.bases.free_temps(code)
3118         code.pyclass_stack.pop()
3119
3120 class CClassDefNode(ClassDefNode):
3121     #  An extension type definition.
3122     #
3123     #  visibility         'private' or 'public' or 'extern'
3124     #  typedef_flag       boolean
3125     #  api                boolean
3126     #  module_name        string or None    For import of extern type objects
3127     #  class_name         string            Unqualified name of class
3128     #  as_name            string or None    Name to declare as in this scope
3129     #  base_class_module  string or None    Module containing the base class
3130     #  base_class_name    string or None    Name of the base class
3131     #  objstruct_name     string or None    Specified C name of object struct
3132     #  typeobj_name       string or None    Specified C name of type object
3133     #  in_pxd             boolean           Is in a .pxd file
3134     #  decorators         [DecoratorNode]   list of decorators or None
3135     #  doc                string or None
3136     #  body               StatNode or None
3137     #  entry              Symtab.Entry
3138     #  base_type          PyExtensionType or None
3139     #  buffer_defaults_node DictNode or None Declares defaults for a buffer
3140     #  buffer_defaults_pos
3141
3142     child_attrs = ["body"]
3143     buffer_defaults_node = None
3144     buffer_defaults_pos = None
3145     typedef_flag = False
3146     api = False
3147     objstruct_name = None
3148     typeobj_name = None
3149     decorators = None
3150
3151     def analyse_declarations(self, env):
3152         #print "CClassDefNode.analyse_declarations:", self.class_name
3153         #print "...visibility =", self.visibility
3154         #print "...module_name =", self.module_name
3155
3156         import Buffer
3157         if self.buffer_defaults_node:
3158             buffer_defaults = Buffer.analyse_buffer_options(self.buffer_defaults_pos,
3159                                                             env, [], self.buffer_defaults_node,
3160                                                             need_complete=False)
3161         else:
3162             buffer_defaults = None
3163
3164         if env.in_cinclude and not self.objstruct_name:
3165             error(self.pos, "Object struct name specification required for "
3166                 "C class defined in 'extern from' block")
3167         self.base_type = None
3168         # Now that module imports are cached, we need to
3169         # import the modules for extern classes.
3170         if self.module_name:
3171             self.module = None
3172             for module in env.cimported_modules:
3173                 if module.name == self.module_name:
3174                     self.module = module
3175             if self.module is None:
3176                 self.module = ModuleScope(self.module_name, None, env.context)
3177                 self.module.has_extern_class = 1
3178                 env.add_imported_module(self.module)
3179
3180         if self.base_class_name:
3181             if self.base_class_module:
3182                 base_class_scope = env.find_module(self.base_class_module, self.pos)
3183             else:
3184                 base_class_scope = env
3185             if self.base_class_name == 'object':
3186                 # extension classes are special and don't need to inherit from object
3187                 if base_class_scope is None or base_class_scope.lookup('object') is None:
3188                     self.base_class_name = None
3189                     self.base_class_module = None
3190                     base_class_scope = None
3191             if base_class_scope:
3192                 base_class_entry = base_class_scope.find(self.base_class_name, self.pos)
3193                 if base_class_entry:
3194                     if not base_class_entry.is_type:
3195                         error(self.pos, "'%s' is not a type name" % self.base_class_name)
3196                     elif not base_class_entry.type.is_extension_type and \
3197                              not (base_class_entry.type.is_builtin_type and \
3198                                   base_class_entry.type.objstruct_cname):
3199                         error(self.pos, "'%s' is not an extension type" % self.base_class_name)
3200                     elif not base_class_entry.type.is_complete():
3201                         error(self.pos, "Base class '%s' of type '%s' is incomplete" % (
3202                             self.base_class_name, self.class_name))
3203                     elif base_class_entry.type.scope and base_class_entry.type.scope.directives and \
3204                              base_class_entry.type.scope.directives['final']:
3205                         error(self.pos, "Base class '%s' of type '%s' is final" % (
3206                             self.base_class_name, self.class_name))
3207                     elif base_class_entry.type.is_builtin_type and \
3208                              base_class_entry.type.name in ('tuple', 'str', 'bytes'):
3209                         error(self.pos, "inheritance from PyVarObject types like '%s' is not currently supported"
3210                               % base_class_entry.type.name)
3211                     else:
3212                         self.base_type = base_class_entry.type
3213         has_body = self.body is not None
3214         if self.module_name and self.visibility != 'extern':
3215             module_path = self.module_name.split(".")
3216             home_scope = env.find_imported_module(module_path, self.pos)
3217             if not home_scope:
3218                 return
3219         else:
3220             home_scope = env
3221
3222         if self.visibility == 'extern':
3223             if self.module_name == '__builtin__' and self.class_name in Builtin.builtin_types:
3224                 warning(self.pos, "%s already a builtin Cython type" % self.class_name, 1)
3225
3226         self.entry = home_scope.declare_c_class(
3227             name = self.class_name,
3228             pos = self.pos,
3229             defining = has_body and self.in_pxd,
3230             implementing = has_body and not self.in_pxd,
3231             module_name = self.module_name,
3232             base_type = self.base_type,
3233             objstruct_cname = self.objstruct_name,
3234             typeobj_cname = self.typeobj_name,
3235             visibility = self.visibility,
3236             typedef_flag = self.typedef_flag,
3237             api = self.api,
3238             buffer_defaults = buffer_defaults)
3239         if home_scope is not env and self.visibility == 'extern':
3240             env.add_imported_entry(self.class_name, self.entry, self.pos)
3241         self.scope = scope = self.entry.type.scope
3242         if scope is not None:
3243             scope.directives = env.directives
3244
3245         if self.doc and Options.docstrings:
3246             scope.doc = embed_position(self.pos, self.doc)
3247
3248         if has_body:
3249             self.body.analyse_declarations(scope)
3250             if self.in_pxd:
3251                 scope.defined = 1
3252             else:
3253                 scope.implemented = 1
3254         env.allocate_vtable_names(self.entry)
3255
3256     def analyse_expressions(self, env):
3257         if self.body:
3258             scope = self.entry.type.scope
3259             self.body.analyse_expressions(scope)
3260
3261     def generate_function_definitions(self, env, code):
3262         if self.body:
3263             self.generate_lambda_definitions(self.scope, code)
3264             self.body.generate_function_definitions(self.scope, code)
3265
3266     def generate_execution_code(self, code):
3267         # This is needed to generate evaluation code for
3268         # default values of method arguments.
3269         if self.body:
3270             self.body.generate_execution_code(code)
3271
3272     def annotate(self, code):
3273         if self.body:
3274             self.body.annotate(code)
3275
3276
3277 class PropertyNode(StatNode):
3278     #  Definition of a property in an extension type.
3279     #
3280     #  name   string
3281     #  doc    EncodedString or None    Doc string
3282     #  body   StatListNode
3283
3284     child_attrs = ["body"]
3285
3286     def analyse_declarations(self, env):
3287         entry = env.declare_property(self.name, self.doc, self.pos)
3288         if entry:
3289             entry.scope.directives = env.directives
3290             self.body.analyse_declarations(entry.scope)
3291
3292     def analyse_expressions(self, env):
3293         self.body.analyse_expressions(env)
3294
3295     def generate_function_definitions(self, env, code):
3296         self.body.generate_function_definitions(env, code)
3297
3298     def generate_execution_code(self, code):
3299         pass
3300
3301     def annotate(self, code):
3302         self.body.annotate(code)
3303
3304
3305 class GlobalNode(StatNode):
3306     # Global variable declaration.
3307     #
3308     # names    [string]
3309
3310     child_attrs = []
3311
3312     def analyse_declarations(self, env):
3313         for name in self.names:
3314             env.declare_global(name, self.pos)
3315
3316     def analyse_expressions(self, env):
3317         pass
3318
3319     def generate_execution_code(self, code):
3320         pass
3321
3322
3323 class ExprStatNode(StatNode):
3324     #  Expression used as a statement.
3325     #
3326     #  expr   ExprNode
3327
3328     child_attrs = ["expr"]
3329
3330     def analyse_declarations(self, env):
3331         import ExprNodes
3332         if isinstance(self.expr, ExprNodes.GeneralCallNode):
3333             func = self.expr.function.as_cython_attribute()
3334             if func == u'declare':
3335                 args, kwds = self.expr.explicit_args_kwds()
3336                 if len(args):
3337                     error(self.expr.pos, "Variable names must be specified.")
3338                 for var, type_node in kwds.key_value_pairs:
3339                     type = type_node.analyse_as_type(env)
3340                     if type is None:
3341                         error(type_node.pos, "Unknown type")
3342                     else:
3343                         env.declare_var(var.value, type, var.pos, is_cdef = True)
3344                 self.__class__ = PassStatNode
3345
3346     def analyse_expressions(self, env):
3347         self.expr.analyse_expressions(env)
3348
3349     def nogil_check(self, env):
3350         if self.expr.type.is_pyobject and self.expr.is_temp:
3351             self.gil_error()
3352
3353     gil_message = "Discarding owned Python object"
3354
3355     def generate_execution_code(self, code):
3356         self.expr.generate_evaluation_code(code)
3357         if not self.expr.is_temp and self.expr.result():
3358             code.putln("%s;" % self.expr.result())
3359         self.expr.generate_disposal_code(code)
3360         self.expr.free_temps(code)
3361
3362     def generate_function_definitions(self, env, code):
3363         self.expr.generate_function_definitions(env, code)
3364
3365     def annotate(self, code):
3366         self.expr.annotate(code)
3367
3368
3369 class AssignmentNode(StatNode):
3370     #  Abstract base class for assignment nodes.
3371     #
3372     #  The analyse_expressions and generate_execution_code
3373     #  phases of assignments are split into two sub-phases
3374     #  each, to enable all the right hand sides of a
3375     #  parallel assignment to be evaluated before assigning
3376     #  to any of the left hand sides.
3377
3378     def analyse_expressions(self, env):
3379         self.analyse_types(env)
3380
3381 #       def analyse_expressions(self, env):
3382 #           self.analyse_expressions_1(env)
3383 #           self.analyse_expressions_2(env)
3384
3385     def generate_execution_code(self, code):
3386         self.generate_rhs_evaluation_code(code)
3387         self.generate_assignment_code(code)
3388
3389
3390 class SingleAssignmentNode(AssignmentNode):
3391     #  The simplest case:
3392     #
3393     #    a = b
3394     #
3395     #  lhs      ExprNode      Left hand side
3396     #  rhs      ExprNode      Right hand side
3397     #  first    bool          Is this guaranteed the first assignment to lhs?
3398
3399     child_attrs = ["lhs", "rhs"]
3400     first = False
3401     declaration_only = False
3402
3403     def analyse_declarations(self, env):
3404         import ExprNodes
3405
3406         # handle declarations of the form x = cython.foo()
3407         if isinstance(self.rhs, ExprNodes.CallNode):
3408             func_name = self.rhs.function.as_cython_attribute()
3409             if func_name:
3410                 args, kwds = self.rhs.explicit_args_kwds()
3411
3412                 if func_name in ['declare', 'typedef']:
3413                     if len(args) > 2 or kwds is not None:
3414                         error(self.rhs.pos, "Can only declare one type at a time.")
3415                         return
3416                     type = args[0].analyse_as_type(env)
3417                     if type is None:
3418                         error(args[0].pos, "Unknown type")
3419                         return
3420                     lhs = self.lhs
3421                     if func_name == 'declare':
3422                         if isinstance(lhs, ExprNodes.NameNode):
3423                             vars = [(lhs.name, lhs.pos)]
3424                         elif isinstance(lhs, ExprNodes.TupleNode):
3425                             vars = [(var.name, var.pos) for var in lhs.args]
3426                         else:
3427                             error(lhs.pos, "Invalid declaration")
3428                             return
3429                         for var, pos in vars:
3430                             env.declare_var(var, type, pos, is_cdef = True)
3431                         if len(args) == 2:
3432                             # we have a value
3433                             self.rhs = args[1]
3434                         else:
3435                             self.declaration_only = True
3436                     else:
3437                         self.declaration_only = True
3438                         if not isinstance(lhs, ExprNodes.NameNode):
3439                             error(lhs.pos, "Invalid declaration.")
3440                         env.declare_typedef(lhs.name, type, self.pos, visibility='private')
3441
3442                 elif func_name in ['struct', 'union']:
3443                     self.declaration_only = True
3444                     if len(args) > 0 or kwds is None:
3445                         error(self.rhs.pos, "Struct or union members must be given by name.")
3446                         return
3447                     members = []
3448                     for member, type_node in kwds.key_value_pairs:
3449                         type = type_node.analyse_as_type(env)
3450                         if type is None:
3451                             error(type_node.pos, "Unknown type")
3452                         else:
3453                             members.append((member.value, type, member.pos))
3454                     if len(members) < len(kwds.key_value_pairs):
3455                         return
3456                     if not isinstance(self.lhs, ExprNodes.NameNode):
3457                         error(self.lhs.pos, "Invalid declaration.")
3458                     name = self.lhs.name
3459                     scope = StructOrUnionScope(name)
3460                     env.declare_struct_or_union(name, func_name, scope, False, self.rhs.pos)
3461                     for member, type, pos in members:
3462                         scope.declare_var(member, type, pos)
3463
3464         if self.declaration_only:
3465             return
3466         else:
3467             self.lhs.analyse_target_declaration(env)
3468
3469     def analyse_types(self, env, use_temp = 0):
3470         self.rhs.analyse_types(env)
3471         self.lhs.analyse_target_types(env)
3472         self.lhs.gil_assignment_check(env)
3473         self.rhs = self.rhs.coerce_to(self.lhs.type, env)
3474         if use_temp:
3475             self.rhs = self.rhs.coerce_to_temp(env)
3476
3477     def generate_rhs_evaluation_code(self, code):
3478         self.rhs.generate_evaluation_code(code)
3479
3480     def generate_assignment_code(self, code):
3481         self.lhs.generate_assignment_code(self.rhs, code)
3482
3483     def generate_function_definitions(self, env, code):
3484         self.rhs.generate_function_definitions(env, code)
3485
3486     def annotate(self, code):
3487         self.lhs.annotate(code)
3488         self.rhs.annotate(code)
3489
3490
3491 class CascadedAssignmentNode(AssignmentNode):
3492     #  An assignment with multiple left hand sides:
3493     #
3494     #    a = b = c
3495     #
3496     #  lhs_list   [ExprNode]   Left hand sides
3497     #  rhs        ExprNode     Right hand sides
3498     #
3499     #  Used internally:
3500     #
3501     #  coerced_rhs_list   [ExprNode]   RHS coerced to type of each LHS
3502
3503     child_attrs = ["lhs_list", "rhs", "coerced_rhs_list"]
3504     coerced_rhs_list = None
3505
3506     def analyse_declarations(self, env):
3507         for lhs in self.lhs_list:
3508             lhs.analyse_target_declaration(env)
3509
3510     def analyse_types(self, env, use_temp = 0):
3511         self.rhs.analyse_types(env)
3512         if not self.rhs.is_simple():
3513             if use_temp:
3514                 self.rhs = self.rhs.coerce_to_temp(env)
3515             else:
3516                 self.rhs = self.rhs.coerce_to_simple(env)
3517         from ExprNodes import CloneNode
3518         self.coerced_rhs_list = []
3519         for lhs in self.lhs_list:
3520             lhs.analyse_target_types(env)
3521             lhs.gil_assignment_check(env)
3522             rhs = CloneNode(self.rhs)
3523             rhs = rhs.coerce_to(lhs.type, env)
3524             self.coerced_rhs_list.append(rhs)
3525
3526     def generate_rhs_evaluation_code(self, code):
3527         self.rhs.generate_evaluation_code(code)
3528
3529     def generate_assignment_code(self, code):
3530         for i in range(len(self.lhs_list)):
3531             lhs = self.lhs_list[i]
3532             rhs = self.coerced_rhs_list[i]
3533             rhs.generate_evaluation_code(code)
3534             lhs.generate_assignment_code(rhs, code)
3535             # Assignment has disposed of the cloned RHS
3536         self.rhs.generate_disposal_code(code)
3537         self.rhs.free_temps(code)
3538
3539     def generate_function_definitions(self, env, code):
3540         self.rhs.generate_function_definitions(env, code)
3541
3542     def annotate(self, code):
3543         for i in range(len(self.lhs_list)):
3544             lhs = self.lhs_list[i].annotate(code)
3545             rhs = self.coerced_rhs_list[i].annotate(code)
3546         self.rhs.annotate(code)
3547
3548
3549 class ParallelAssignmentNode(AssignmentNode):
3550     #  A combined packing/unpacking assignment:
3551     #
3552     #    a, b, c =  d, e, f
3553     #
3554     #  This has been rearranged by the parser into
3555     #
3556     #    a = d ; b = e ; c = f
3557     #
3558     #  but we must evaluate all the right hand sides
3559     #  before assigning to any of the left hand sides.
3560     #
3561     #  stats     [AssignmentNode]   The constituent assignments
3562
3563     child_attrs = ["stats"]
3564
3565     def analyse_declarations(self, env):
3566         for stat in self.stats:
3567             stat.analyse_declarations(env)
3568
3569     def analyse_expressions(self, env):
3570         for stat in self.stats:
3571             stat.analyse_types(env, use_temp = 1)
3572
3573 #    def analyse_expressions(self, env):
3574 #        for stat in self.stats:
3575 #            stat.analyse_expressions_1(env, use_temp = 1)
3576 #        for stat in self.stats:
3577 #            stat.analyse_expressions_2(env)
3578
3579     def generate_execution_code(self, code):
3580         for stat in self.stats:
3581             stat.generate_rhs_evaluation_code(code)
3582         for stat in self.stats:
3583             stat.generate_assignment_code(code)
3584
3585     def generate_function_definitions(self, env, code):
3586         for stat in self.stats:
3587             stat.generate_function_definitions(env, code)
3588
3589     def annotate(self, code):
3590         for stat in self.stats:
3591             stat.annotate(code)
3592
3593
3594 class InPlaceAssignmentNode(AssignmentNode):
3595     #  An in place arithmetic operand:
3596     #
3597     #    a += b
3598     #    a -= b
3599     #    ...
3600     #
3601     #  lhs      ExprNode      Left hand side
3602     #  rhs      ExprNode      Right hand side
3603     #  op       char          one of "+-*/%^&|"
3604     #  dup     (ExprNode)     copy of lhs used for operation (auto-generated)
3605     #
3606     #  This code is a bit tricky because in order to obey Python
3607     #  semantics the sub-expressions (e.g. indices) of the lhs must
3608     #  not be evaluated twice. So we must re-use the values calculated
3609     #  in evaluation phase for the assignment phase as well.
3610     #  Fortunately, the type of the lhs node is fairly constrained
3611     #  (it must be a NameNode, AttributeNode, or IndexNode).
3612
3613     child_attrs = ["lhs", "rhs"]
3614
3615     def analyse_declarations(self, env):
3616         self.lhs.analyse_target_declaration(env)
3617
3618     def analyse_types(self, env):
3619         self.rhs.analyse_types(env)
3620         self.lhs.analyse_target_types(env)
3621
3622     def generate_execution_code(self, code):
3623         import ExprNodes
3624         self.rhs.generate_evaluation_code(code)
3625         self.lhs.generate_subexpr_evaluation_code(code)
3626         c_op = self.operator
3627         if c_op == "//":
3628             c_op = "/"
3629         elif c_op == "**":
3630             error(self.pos, "No C inplace power operator")
3631         if isinstance(self.lhs, ExprNodes.IndexNode) and self.lhs.is_buffer_access:
3632             if self.lhs.type.is_pyobject:
3633                 error(self.pos, "In-place operators not allowed on object buffers in this release.")
3634             if c_op in ('/', '%') and self.lhs.type.is_int and not code.directives['cdivision']:
3635                 error(self.pos, "In-place non-c divide operators not allowed on int buffers.")
3636             self.lhs.generate_buffer_setitem_code(self.rhs, code, c_op)
3637         else:
3638             # C++
3639             # TODO: make sure overload is declared
3640             code.putln("%s %s= %s;" % (self.lhs.result(), c_op, self.rhs.result()))
3641         self.lhs.generate_subexpr_disposal_code(code)
3642         self.lhs.free_subexpr_temps(code)
3643         self.rhs.generate_disposal_code(code)
3644         self.rhs.free_temps(code)
3645
3646     def annotate(self, code):
3647         self.lhs.annotate(code)
3648         self.rhs.annotate(code)
3649
3650     def create_binop_node(self):
3651         import ExprNodes
3652         return ExprNodes.binop_node(self.pos, self.operator, self.lhs, self.rhs)
3653
3654
3655 class PrintStatNode(StatNode):
3656     #  print statement
3657     #
3658     #  arg_tuple         TupleNode
3659     #  stream            ExprNode or None (stdout)
3660     #  append_newline    boolean
3661
3662     child_attrs = ["arg_tuple", "stream"]
3663
3664     def analyse_expressions(self, env):
3665         if self.stream:
3666             self.stream.analyse_expressions(env)
3667             self.stream = self.stream.coerce_to_pyobject(env)
3668         self.arg_tuple.analyse_expressions(env)
3669         self.arg_tuple = self.arg_tuple.coerce_to_pyobject(env)
3670         env.use_utility_code(printing_utility_code)
3671         if len(self.arg_tuple.args) == 1 and self.append_newline:
3672             env.use_utility_code(printing_one_utility_code)
3673
3674     nogil_check = Node.gil_error
3675     gil_message = "Python print statement"
3676
3677     def generate_execution_code(self, code):
3678         if self.stream:
3679             self.stream.generate_evaluation_code(code)
3680             stream_result = self.stream.py_result()
3681         else:
3682             stream_result = '0'
3683         if len(self.arg_tuple.args) == 1 and self.append_newline:
3684             arg = self.arg_tuple.args[0]
3685             arg.generate_evaluation_code(code)
3686
3687             code.putln(
3688                 "if (__Pyx_PrintOne(%s, %s) < 0) %s" % (
3689                     stream_result,
3690                     arg.py_result(),
3691                     code.error_goto(self.pos)))
3692             arg.generate_disposal_code(code)
3693             arg.free_temps(code)
3694         else:
3695             self.arg_tuple.generate_evaluation_code(code)
3696             code.putln(
3697                 "if (__Pyx_Print(%s, %s, %d) < 0) %s" % (
3698                     stream_result,
3699                     self.arg_tuple.py_result(),
3700                     self.append_newline,
3701                     code.error_goto(self.pos)))
3702             self.arg_tuple.generate_disposal_code(code)
3703             self.arg_tuple.free_temps(code)
3704
3705         if self.stream:
3706             self.stream.generate_disposal_code(code)
3707             self.stream.free_temps(code)
3708
3709     def generate_function_definitions(self, env, code):
3710         if self.stream:
3711             self.stream.generate_function_definitions(env, code)
3712         self.arg_tuple.generate_function_definitions(env, code)
3713
3714     def annotate(self, code):
3715         if self.stream:
3716             self.stream.annotate(code)
3717         self.arg_tuple.annotate(code)
3718
3719
3720 class ExecStatNode(StatNode):
3721     #  exec statement
3722     #
3723     #  args     [ExprNode]
3724
3725     child_attrs = ["args"]
3726
3727     def analyse_expressions(self, env):
3728         for i, arg in enumerate(self.args):
3729             arg.analyse_expressions(env)
3730             arg = arg.coerce_to_pyobject(env)
3731             self.args[i] = arg
3732         env.use_utility_code(Builtin.pyexec_utility_code)
3733
3734     nogil_check = Node.gil_error
3735     gil_message = "Python exec statement"
3736
3737     def generate_execution_code(self, code):
3738         args = []
3739         for arg in self.args:
3740             arg.generate_evaluation_code(code)
3741             args.append( arg.py_result() )
3742         args = tuple(args + ['0', '0'][:3-len(args)])
3743         temp_result = code.funcstate.allocate_temp(PyrexTypes.py_object_type, manage_ref=True)
3744         code.putln("%s = __Pyx_PyRun(%s, %s, %s);" % (
3745                 (temp_result,) + args))
3746         for arg in self.args:
3747             arg.generate_disposal_code(code)
3748             arg.free_temps(code)
3749         code.putln(
3750             code.error_goto_if_null(temp_result, self.pos))
3751         code.put_gotref(temp_result)
3752         code.put_decref_clear(temp_result, py_object_type)
3753         code.funcstate.release_temp(temp_result)
3754
3755     def annotate(self, code):
3756         for arg in self.args:
3757             arg.annotate(code)
3758
3759
3760 class DelStatNode(StatNode):
3761     #  del statement
3762     #
3763     #  args     [ExprNode]
3764
3765     child_attrs = ["args"]
3766
3767     def analyse_declarations(self, env):
3768         for arg in self.args:
3769             arg.analyse_target_declaration(env)
3770
3771     def analyse_expressions(self, env):
3772         for arg in self.args:
3773             arg.analyse_target_expression(env, None)
3774             if arg.type.is_pyobject:
3775                 pass
3776             elif arg.type.is_ptr and arg.type.base_type.is_cpp_class:
3777                 self.cpp_check(env)
3778             elif arg.type.is_cpp_class:
3779                 error(arg.pos, "Deletion of non-heap C++ object")
3780             else:
3781                 error(arg.pos, "Deletion of non-Python, non-C++ object")
3782             #arg.release_target_temp(env)
3783
3784     def nogil_check(self, env):
3785         for arg in self.args:
3786             if arg.type.is_pyobject:
3787                 self.gil_error()
3788
3789     gil_message = "Deleting Python object"
3790
3791     def generate_execution_code(self, code):
3792         for arg in self.args:
3793             if arg.type.is_pyobject:
3794                 arg.generate_deletion_code(code)
3795             elif arg.type.is_ptr and arg.type.base_type.is_cpp_class:
3796                 arg.generate_result_code(code)
3797                 code.putln("delete %s;" % arg.result())
3798             # else error reported earlier
3799
3800     def annotate(self, code):
3801         for arg in self.args:
3802             arg.annotate(code)
3803
3804
3805 class PassStatNode(StatNode):
3806     #  pass statement
3807
3808     child_attrs = []
3809
3810     def analyse_expressions(self, env):
3811         pass
3812
3813     def generate_execution_code(self, code):
3814         pass
3815
3816
3817 class BreakStatNode(StatNode):
3818
3819     child_attrs = []
3820
3821     def analyse_expressions(self, env):
3822         pass
3823
3824     def generate_execution_code(self, code):
3825         if not code.break_label:
3826             error(self.pos, "break statement not inside loop")
3827         else:
3828             code.put_goto(code.break_label)
3829
3830
3831 class ContinueStatNode(StatNode):
3832
3833     child_attrs = []
3834
3835     def analyse_expressions(self, env):
3836         pass
3837
3838     def generate_execution_code(self, code):
3839         if code.funcstate.in_try_finally:
3840             error(self.pos, "continue statement inside try of try...finally")
3841         elif not code.continue_label:
3842             error(self.pos, "continue statement not inside loop")
3843         else:
3844             code.put_goto(code.continue_label)
3845
3846
3847 class ReturnStatNode(StatNode):
3848     #  return statement
3849     #
3850     #  value         ExprNode or None
3851     #  return_type   PyrexType
3852
3853     child_attrs = ["value"]
3854
3855     def analyse_expressions(self, env):
3856         return_type = env.return_type
3857         self.return_type = return_type
3858         if not return_type:
3859             error(self.pos, "Return not inside a function body")
3860             return
3861         if self.value:
3862             self.value.analyse_types(env)
3863             if return_type.is_void or return_type.is_returncode:
3864                 error(self.value.pos,
3865                     "Return with value in void function")
3866             else:
3867                 self.value = self.value.coerce_to(env.return_type, env)
3868         else:
3869             if (not return_type.is_void
3870                 and not return_type.is_pyobject
3871                 and not return_type.is_returncode):
3872                     error(self.pos, "Return value required")
3873
3874     def nogil_check(self, env):
3875         if self.return_type.is_pyobject:
3876             self.gil_error()
3877
3878     gil_message = "Returning Python object"
3879
3880     def generate_execution_code(self, code):
3881         code.mark_pos(self.pos)
3882         if not self.return_type:
3883             # error reported earlier
3884             return
3885         if self.return_type.is_pyobject:
3886             code.put_xdecref(Naming.retval_cname,
3887                              self.return_type)
3888         if self.value:
3889             self.value.generate_evaluation_code(code)
3890             self.value.make_owned_reference(code)
3891             code.putln(
3892                 "%s = %s;" % (
3893                     Naming.retval_cname,
3894                     self.value.result_as(self.return_type)))
3895             self.value.generate_post_assignment_code(code)
3896             self.value.free_temps(code)
3897         else:
3898             if self.return_type.is_pyobject:
3899                 code.put_init_to_py_none(Naming.retval_cname, self.return_type)
3900             elif self.return_type.is_returncode:
3901                 code.putln(
3902                     "%s = %s;" % (
3903                         Naming.retval_cname,
3904                         self.return_type.default_value))
3905         for cname, type in code.funcstate.temps_holding_reference():
3906             code.put_decref_clear(cname, type)
3907         code.put_goto(code.return_label)
3908
3909     def generate_function_definitions(self, env, code):
3910         if self.value is not None:
3911             self.value.generate_function_definitions(env, code)
3912
3913     def annotate(self, code):
3914         if self.value:
3915             self.value.annotate(code)
3916
3917
3918 class RaiseStatNode(StatNode):
3919     #  raise statement
3920     #
3921     #  exc_type    ExprNode or None
3922     #  exc_value   ExprNode or None
3923     #  exc_tb      ExprNode or None
3924
3925     child_attrs = ["exc_type", "exc_value", "exc_tb"]
3926
3927     def analyse_expressions(self, env):
3928         if self.exc_type:
3929             self.exc_type.analyse_types(env)
3930             self.exc_type = self.exc_type.coerce_to_pyobject(env)
3931         if self.exc_value:
3932             self.exc_value.analyse_types(env)
3933             self.exc_value = self.exc_value.coerce_to_pyobject(env)
3934         if self.exc_tb:
3935             self.exc_tb.analyse_types(env)
3936             self.exc_tb = self.exc_tb.coerce_to_pyobject(env)
3937         env.use_utility_code(raise_utility_code)
3938
3939     nogil_check = Node.gil_error
3940     gil_message = "Raising exception"
3941
3942     def generate_execution_code(self, code):
3943         if self.exc_type:
3944             self.exc_type.generate_evaluation_code(code)
3945             type_code = self.exc_type.py_result()
3946         else:
3947             type_code = "0"
3948         if self.exc_value:
3949             self.exc_value.generate_evaluation_code(code)
3950             value_code = self.exc_value.py_result()
3951         else:
3952             value_code = "0"
3953         if self.exc_tb:
3954             self.exc_tb.generate_evaluation_code(code)
3955             tb_code = self.exc_tb.py_result()
3956         else:
3957             tb_code = "0"
3958         code.putln(
3959             "__Pyx_Raise(%s, %s, %s);" % (
3960                 type_code,
3961                 value_code,
3962                 tb_code))
3963         for obj in (self.exc_type, self.exc_value, self.exc_tb):
3964             if obj:
3965                 obj.generate_disposal_code(code)
3966                 obj.free_temps(code)
3967         code.putln(
3968             code.error_goto(self.pos))
3969
3970     def generate_function_definitions(self, env, code):
3971         if self.exc_type is not None:
3972             self.exc_type.generate_function_definitions(env, code)
3973         if self.exc_value is not None:
3974             self.exc_value.generate_function_definitions(env, code)
3975         if self.exc_tb is not None:
3976             self.exc_tb.generate_function_definitions(env, code)
3977
3978     def annotate(self, code):
3979         if self.exc_type:
3980             self.exc_type.annotate(code)
3981         if self.exc_value:
3982             self.exc_value.annotate(code)
3983         if self.exc_tb:
3984             self.exc_tb.annotate(code)
3985
3986
3987 class ReraiseStatNode(StatNode):
3988
3989     child_attrs = []
3990
3991     def analyse_expressions(self, env):
3992         env.use_utility_code(restore_exception_utility_code)
3993
3994     nogil_check = Node.gil_error
3995     gil_message = "Raising exception"
3996
3997     def generate_execution_code(self, code):
3998         vars = code.funcstate.exc_vars
3999         if vars:
4000             for varname in vars:
4001                 code.put_giveref(varname)
4002             code.putln("__Pyx_ErrRestore(%s, %s, %s);" % tuple(vars))
4003             for varname in vars:
4004                 code.put("%s = 0; " % varname)
4005             code.putln()
4006             code.putln(code.error_goto(self.pos))
4007         else:
4008             error(self.pos, "Reraise not inside except clause")
4009
4010
4011 class AssertStatNode(StatNode):
4012     #  assert statement
4013     #
4014     #  cond    ExprNode
4015     #  value   ExprNode or None
4016
4017     child_attrs = ["cond", "value"]
4018
4019     def analyse_expressions(self, env):
4020         self.cond = self.cond.analyse_boolean_expression(env)
4021         if self.value:
4022             self.value.analyse_types(env)
4023             self.value = self.value.coerce_to_pyobject(env)
4024
4025     nogil_check = Node.gil_error
4026     gil_message = "Raising exception"
4027
4028     def generate_execution_code(self, code):
4029         code.putln("#ifndef CYTHON_WITHOUT_ASSERTIONS")
4030         self.cond.generate_evaluation_code(code)
4031         code.putln(
4032             "if (unlikely(!%s)) {" %
4033                 self.cond.result())
4034         if self.value:
4035             self.value.generate_evaluation_code(code)
4036             code.putln(
4037                 "PyErr_SetObject(PyExc_AssertionError, %s);" %
4038                     self.value.py_result())
4039             self.value.generate_disposal_code(code)
4040             self.value.free_temps(code)
4041         else:
4042             code.putln(
4043                 "PyErr_SetNone(PyExc_AssertionError);")
4044         code.putln(
4045                 code.error_goto(self.pos))
4046         code.putln(
4047             "}")
4048         self.cond.generate_disposal_code(code)
4049         self.cond.free_temps(code)
4050         code.putln("#endif")
4051
4052     def generate_function_definitions(self, env, code):
4053         self.cond.generate_function_definitions(env, code)
4054         if self.value is not None:
4055             self.value.generate_function_definitions(env, code)
4056
4057     def annotate(self, code):
4058         self.cond.annotate(code)
4059         if self.value:
4060             self.value.annotate(code)
4061
4062
4063 class IfStatNode(StatNode):
4064     #  if statement
4065     #
4066     #  if_clauses   [IfClauseNode]
4067     #  else_clause  StatNode or None
4068
4069     child_attrs = ["if_clauses", "else_clause"]
4070
4071     def analyse_control_flow(self, env):
4072         env.start_branching(self.pos)
4073         for if_clause in self.if_clauses:
4074             if_clause.analyse_control_flow(env)
4075             env.next_branch(if_clause.end_pos())
4076         if self.else_clause:
4077             self.else_clause.analyse_control_flow(env)
4078         env.finish_branching(self.end_pos())
4079
4080     def analyse_declarations(self, env):
4081         for if_clause in self.if_clauses:
4082             if_clause.analyse_declarations(env)
4083         if self.else_clause:
4084             self.else_clause.analyse_declarations(env)
4085
4086     def analyse_expressions(self, env):
4087         for if_clause in self.if_clauses:
4088             if_clause.analyse_expressions(env)
4089         if self.else_clause:
4090             self.else_clause.analyse_expressions(env)
4091
4092     def generate_execution_code(self, code):
4093         code.mark_pos(self.pos)
4094         end_label = code.new_label()
4095         for if_clause in self.if_clauses:
4096             if_clause.generate_execution_code(code, end_label)
4097         if self.else_clause:
4098             code.putln("/*else*/ {")
4099             self.else_clause.generate_execution_code(code)
4100             code.putln("}")
4101         code.put_label(end_label)
4102
4103     def generate_function_definitions(self, env, code):
4104         for clause in self.if_clauses:
4105             clause.generate_function_definitions(env, code)
4106         if self.else_clause is not None:
4107             self.else_clause.generate_function_definitions(env, code)
4108
4109     def annotate(self, code):
4110         for if_clause in self.if_clauses:
4111             if_clause.annotate(code)
4112         if self.else_clause:
4113             self.else_clause.annotate(code)
4114
4115
4116 class IfClauseNode(Node):
4117     #  if or elif clause in an if statement
4118     #
4119     #  condition   ExprNode
4120     #  body        StatNode
4121
4122     child_attrs = ["condition", "body"]
4123
4124     def analyse_control_flow(self, env):
4125         self.body.analyse_control_flow(env)
4126
4127     def analyse_declarations(self, env):
4128         self.body.analyse_declarations(env)
4129
4130     def analyse_expressions(self, env):
4131         self.condition = \
4132             self.condition.analyse_temp_boolean_expression(env)
4133         self.body.analyse_expressions(env)
4134
4135     def get_constant_condition_result(self):
4136         if self.condition.has_constant_result():
4137             return bool(self.condition.constant_result)
4138         else:
4139             return None
4140
4141     def generate_execution_code(self, code, end_label):
4142         self.condition.generate_evaluation_code(code)
4143         code.putln(
4144             "if (%s) {" %
4145                 self.condition.result())
4146         self.condition.generate_disposal_code(code)
4147         self.condition.free_temps(code)
4148         self.body.generate_execution_code(code)
4149         code.put_goto(end_label)
4150         code.putln("}")
4151
4152     def generate_function_definitions(self, env, code):
4153         self.condition.generate_function_definitions(env, code)
4154         self.body.generate_function_definitions(env, code)
4155
4156     def annotate(self, code):
4157         self.condition.annotate(code)
4158         self.body.annotate(code)
4159
4160
4161 class SwitchCaseNode(StatNode):
4162     # Generated in the optimization of an if-elif-else node
4163     #
4164     # conditions    [ExprNode]
4165     # body          StatNode
4166
4167     child_attrs = ['conditions', 'body']
4168
4169     def generate_execution_code(self, code):
4170         for cond in self.conditions:
4171             code.mark_pos(cond.pos)
4172             cond.generate_evaluation_code(code)
4173             code.putln("case %s:" % cond.result())
4174         self.body.generate_execution_code(code)
4175         code.putln("break;")
4176
4177     def generate_function_definitions(self, env, code):
4178         for cond in self.conditions:
4179             cond.generate_function_definitions(env, code)
4180         self.body.generate_function_definitions(env, code)
4181
4182     def annotate(self, code):
4183         for cond in self.conditions:
4184             cond.annotate(code)
4185         self.body.annotate(code)
4186
4187 class SwitchStatNode(StatNode):
4188     # Generated in the optimization of an if-elif-else node
4189     #
4190     # test          ExprNode
4191     # cases         [SwitchCaseNode]
4192     # else_clause   StatNode or None
4193
4194     child_attrs = ['test', 'cases', 'else_clause']
4195
4196     def generate_execution_code(self, code):
4197         self.test.generate_evaluation_code(code)
4198         code.putln("switch (%s) {" % self.test.result())
4199         for case in self.cases:
4200             case.generate_execution_code(code)
4201         if self.else_clause is not None:
4202             code.putln("default:")
4203             self.else_clause.generate_execution_code(code)
4204             code.putln("break;")
4205         code.putln("}")
4206
4207     def generate_function_definitions(self, env, code):
4208         self.test.generate_function_definitions(env, code)
4209         for case in self.cases:
4210             case.generate_function_definitions(env, code)
4211         if self.else_clause is not None:
4212             self.else_clause.generate_function_definitions(env, code)
4213
4214     def annotate(self, code):
4215         self.test.annotate(code)
4216         for case in self.cases:
4217             case.annotate(code)
4218         if self.else_clause is not None:
4219             self.else_clause.annotate(code)
4220
4221 class LoopNode(object):
4222
4223     def analyse_control_flow(self, env):
4224         env.start_branching(self.pos)
4225         self.body.analyse_control_flow(env)
4226         env.next_branch(self.body.end_pos())
4227         if self.else_clause:
4228             self.else_clause.analyse_control_flow(env)
4229         env.finish_branching(self.end_pos())
4230
4231
4232 class WhileStatNode(LoopNode, StatNode):
4233     #  while statement
4234     #
4235     #  condition    ExprNode
4236     #  body         StatNode
4237     #  else_clause  StatNode
4238
4239     child_attrs = ["condition", "body", "else_clause"]
4240
4241     def analyse_declarations(self, env):
4242         self.body.analyse_declarations(env)
4243         if self.else_clause:
4244             self.else_clause.analyse_declarations(env)
4245
4246     def analyse_expressions(self, env):
4247         self.condition = \
4248             self.condition.analyse_temp_boolean_expression(env)
4249         self.body.analyse_expressions(env)
4250         if self.else_clause:
4251             self.else_clause.analyse_expressions(env)
4252
4253     def generate_execution_code(self, code):
4254         old_loop_labels = code.new_loop_labels()
4255         code.putln(
4256             "while (1) {")
4257         self.condition.generate_evaluation_code(code)
4258         self.condition.generate_disposal_code(code)
4259         code.putln(
4260             "if (!%s) break;" %
4261                 self.condition.result())
4262         self.condition.free_temps(code)
4263         self.body.generate_execution_code(code)
4264         code.put_label(code.continue_label)
4265         code.putln("}")
4266         break_label = code.break_label
4267         code.set_loop_labels(old_loop_labels)
4268         if self.else_clause:
4269             code.putln("/*else*/ {")
4270             self.else_clause.generate_execution_code(code)
4271             code.putln("}")
4272         code.put_label(break_label)
4273
4274     def generate_function_definitions(self, env, code):
4275         self.condition.generate_function_definitions(env, code)
4276         self.body.generate_function_definitions(env, code)
4277         if self.else_clause is not None:
4278             self.else_clause.generate_function_definitions(env, code)
4279
4280     def annotate(self, code):
4281         self.condition.annotate(code)
4282         self.body.annotate(code)
4283         if self.else_clause:
4284             self.else_clause.annotate(code)
4285
4286
4287 def ForStatNode(pos, **kw):
4288     if 'iterator' in kw:
4289         return ForInStatNode(pos, **kw)
4290     else:
4291         return ForFromStatNode(pos, **kw)
4292
4293 class ForInStatNode(LoopNode, StatNode):
4294     #  for statement
4295     #
4296     #  target        ExprNode
4297     #  iterator      IteratorNode
4298     #  body          StatNode
4299     #  else_clause   StatNode
4300     #  item          NextNode       used internally
4301
4302     child_attrs = ["target", "iterator", "body", "else_clause"]
4303     item = None
4304
4305     def analyse_declarations(self, env):
4306         self.target.analyse_target_declaration(env)
4307         self.body.analyse_declarations(env)
4308         if self.else_clause:
4309             self.else_clause.analyse_declarations(env)
4310
4311     def analyse_expressions(self, env):
4312         import ExprNodes
4313         self.target.analyse_target_types(env)
4314         self.iterator.analyse_expressions(env)
4315         self.item = ExprNodes.NextNode(self.iterator, env)
4316         self.item = self.item.coerce_to(self.target.type, env)
4317         self.body.analyse_expressions(env)
4318         if self.else_clause:
4319             self.else_clause.analyse_expressions(env)
4320
4321     def generate_execution_code(self, code):
4322         old_loop_labels = code.new_loop_labels()
4323         self.iterator.allocate_counter_temp(code)
4324         self.iterator.generate_evaluation_code(code)
4325         code.putln(
4326             "for (;;) {")
4327         self.item.generate_evaluation_code(code)
4328         self.target.generate_assignment_code(self.item, code)
4329         self.body.generate_execution_code(code)
4330         code.put_label(code.continue_label)
4331         code.putln(
4332             "}")
4333         break_label = code.break_label
4334         code.set_loop_labels(old_loop_labels)
4335
4336         if self.else_clause:
4337             # in nested loops, the 'else' block can contain a
4338             # 'continue' statement for the outer loop, but we may need
4339             # to generate cleanup code before taking that path, so we
4340             # intercept it here
4341             orig_continue_label = code.continue_label
4342             code.continue_label = code.new_label('outer_continue')
4343
4344             code.putln("/*else*/ {")
4345             self.else_clause.generate_execution_code(code)
4346             code.putln("}")
4347
4348             if code.label_used(code.continue_label):
4349                 code.put_goto(break_label)
4350                 code.put_label(code.continue_label)
4351                 self.iterator.generate_disposal_code(code)
4352                 code.put_goto(orig_continue_label)
4353             code.set_loop_labels(old_loop_labels)
4354
4355         if code.label_used(break_label):
4356             code.put_label(break_label)
4357         self.iterator.release_counter_temp(code)
4358         self.iterator.generate_disposal_code(code)
4359         self.iterator.free_temps(code)
4360
4361     def generate_function_definitions(self, env, code):
4362         self.target.generate_function_definitions(env, code)
4363         self.iterator.generate_function_definitions(env, code)
4364         self.body.generate_function_definitions(env, code)
4365         if self.else_clause is not None:
4366             self.else_clause.generate_function_definitions(env, code)
4367
4368     def annotate(self, code):
4369         self.target.annotate(code)
4370         self.iterator.annotate(code)
4371         self.body.annotate(code)
4372         if self.else_clause:
4373             self.else_clause.annotate(code)
4374         self.item.annotate(code)
4375
4376
4377 class ForFromStatNode(LoopNode, StatNode):
4378     #  for name from expr rel name rel expr
4379     #
4380     #  target        NameNode
4381     #  bound1        ExprNode
4382     #  relation1     string
4383     #  relation2     string
4384     #  bound2        ExprNode
4385     #  step          ExprNode or None
4386     #  body          StatNode
4387     #  else_clause   StatNode or None
4388     #
4389     #  Used internally:
4390     #
4391     #  from_range         bool
4392     #  is_py_target       bool
4393     #  loopvar_node       ExprNode (usually a NameNode or temp node)
4394     #  py_loopvar_node    PyTempNode or None
4395     child_attrs = ["target", "bound1", "bound2", "step", "body", "else_clause"]
4396
4397     is_py_target = False
4398     loopvar_node = None
4399     py_loopvar_node = None
4400     from_range = False
4401
4402     gil_message = "For-loop using object bounds or target"
4403
4404     def nogil_check(self, env):
4405         for x in (self.target, self.bound1, self.bound2):
4406             if x.type.is_pyobject:
4407                 self.gil_error()
4408
4409     def analyse_declarations(self, env):
4410         self.target.analyse_target_declaration(env)
4411         self.body.analyse_declarations(env)
4412         if self.else_clause:
4413             self.else_clause.analyse_declarations(env)
4414
4415     def analyse_expressions(self, env):
4416         import ExprNodes
4417         self.target.analyse_target_types(env)
4418         self.bound1.analyse_types(env)
4419         self.bound2.analyse_types(env)
4420         if self.step is not None:
4421             if isinstance(self.step, ExprNodes.UnaryMinusNode):
4422                 warning(self.step.pos, "Probable infinite loop in for-from-by statment. Consider switching the directions of the relations.", 2)
4423             self.step.analyse_types(env)
4424
4425         target_type = self.target.type
4426         if self.target.type.is_numeric:
4427             loop_type = self.target.type
4428         else:
4429             loop_type = PyrexTypes.c_int_type
4430             if not self.bound1.type.is_pyobject:
4431                 loop_type = PyrexTypes.widest_numeric_type(loop_type, self.bound1.type)
4432             if not self.bound2.type.is_pyobject:
4433                 loop_type = PyrexTypes.widest_numeric_type(loop_type, self.bound2.type)
4434             if self.step is not None and not self.step.type.is_pyobject:
4435                 loop_type = PyrexTypes.widest_numeric_type(loop_type, self.step.type)
4436         self.bound1 = self.bound1.coerce_to(loop_type, env)
4437         self.bound2 = self.bound2.coerce_to(loop_type, env)
4438         if not self.bound2.is_literal:
4439             self.bound2 = self.bound2.coerce_to_temp(env)
4440         if self.step is not None:
4441             self.step = self.step.coerce_to(loop_type, env)
4442             if not self.step.is_literal:
4443                 self.step = self.step.coerce_to_temp(env)
4444
4445         target_type = self.target.type
4446         if not (target_type.is_pyobject or target_type.is_numeric):
4447             error(self.target.pos,
4448                 "for-from loop variable must be c numeric type or Python object")
4449         if target_type.is_numeric:
4450             self.is_py_target = False
4451             if isinstance(self.target, ExprNodes.IndexNode) and self.target.is_buffer_access:
4452                 raise error(self.pos, "Buffer indexing not allowed as for loop target.")
4453             self.loopvar_node = self.target
4454             self.py_loopvar_node = None
4455         else:
4456             self.is_py_target = True
4457             c_loopvar_node = ExprNodes.TempNode(self.pos, loop_type, env)
4458             self.loopvar_node = c_loopvar_node
4459             self.py_loopvar_node = \
4460                 ExprNodes.CloneNode(c_loopvar_node).coerce_to_pyobject(env)
4461         self.body.analyse_expressions(env)
4462         if self.else_clause:
4463             self.else_clause.analyse_expressions(env)
4464
4465     def generate_execution_code(self, code):
4466         old_loop_labels = code.new_loop_labels()
4467         from_range = self.from_range
4468         self.bound1.generate_evaluation_code(code)
4469         self.bound2.generate_evaluation_code(code)
4470         offset, incop = self.relation_table[self.relation1]
4471         if self.step is not None:
4472             self.step.generate_evaluation_code(code)
4473             step = self.step.result()
4474             incop = "%s=%s" % (incop[0], step)
4475         import ExprNodes
4476         if isinstance(self.loopvar_node, ExprNodes.TempNode):
4477             self.loopvar_node.allocate(code)
4478         if isinstance(self.py_loopvar_node, ExprNodes.TempNode):
4479             self.py_loopvar_node.allocate(code)
4480         if from_range:
4481             loopvar_name = code.funcstate.allocate_temp(self.target.type, False)
4482         else:
4483             loopvar_name = self.loopvar_node.result()
4484         code.putln(
4485             "for (%s = %s%s; %s %s %s; %s%s) {" % (
4486                 loopvar_name,
4487                 self.bound1.result(), offset,
4488                 loopvar_name, self.relation2, self.bound2.result(),
4489                 loopvar_name, incop))
4490         if self.py_loopvar_node:
4491             self.py_loopvar_node.generate_evaluation_code(code)
4492             self.target.generate_assignment_code(self.py_loopvar_node, code)
4493         elif from_range:
4494             code.putln("%s = %s;" % (
4495                             self.target.result(), loopvar_name))
4496         self.body.generate_execution_code(code)
4497         code.put_label(code.continue_label)
4498         if self.py_loopvar_node:
4499             # This mess is to make for..from loops with python targets behave
4500             # exactly like those with C targets with regards to re-assignment
4501             # of the loop variable.
4502             import ExprNodes
4503             if self.target.entry.is_pyglobal:
4504                 # We know target is a NameNode, this is the only ugly case.
4505                 target_node = ExprNodes.PyTempNode(self.target.pos, None)
4506                 target_node.allocate(code)
4507                 interned_cname = code.intern_identifier(self.target.entry.name)
4508                 code.globalstate.use_utility_code(ExprNodes.get_name_interned_utility_code)
4509                 code.putln("%s = __Pyx_GetName(%s, %s); %s" % (
4510                                 target_node.result(),
4511                                 Naming.module_cname,
4512                                 interned_cname,
4513                                 code.error_goto_if_null(target_node.result(), self.target.pos)))
4514                 code.put_gotref(target_node.result())
4515             else:
4516                 target_node = self.target
4517             from_py_node = ExprNodes.CoerceFromPyTypeNode(self.loopvar_node.type, target_node, None)
4518             from_py_node.temp_code = loopvar_name
4519             from_py_node.generate_result_code(code)
4520             if self.target.entry.is_pyglobal:
4521                 code.put_decref(target_node.result(), target_node.type)
4522                 target_node.release(code)
4523         code.putln("}")
4524         if self.py_loopvar_node:
4525             # This is potentially wasteful, but we don't want the semantics to
4526             # depend on whether or not the loop is a python type.
4527             self.py_loopvar_node.generate_evaluation_code(code)
4528             self.target.generate_assignment_code(self.py_loopvar_node, code)
4529         if from_range:
4530             code.funcstate.release_temp(loopvar_name)
4531         break_label = code.break_label
4532         code.set_loop_labels(old_loop_labels)
4533         if self.else_clause:
4534             code.putln("/*else*/ {")
4535             self.else_clause.generate_execution_code(code)
4536             code.putln("}")
4537         code.put_label(break_label)
4538         self.bound1.generate_disposal_code(code)
4539         self.bound1.free_temps(code)
4540         self.bound2.generate_disposal_code(code)
4541         self.bound2.free_temps(code)
4542         if isinstance(self.loopvar_node, ExprNodes.TempNode):
4543             self.loopvar_node.release(code)
4544         if isinstance(self.py_loopvar_node, ExprNodes.TempNode):
4545             self.py_loopvar_node.release(code)
4546         if self.step is not None:
4547             self.step.generate_disposal_code(code)
4548             self.step.free_temps(code)
4549
4550     relation_table = {
4551         # {relop : (initial offset, increment op)}
4552         '<=': ("",   "++"),
4553         '<' : ("+1", "++"),
4554         '>=': ("",   "--"),
4555         '>' : ("-1", "--")
4556     }
4557
4558     def generate_function_definitions(self, env, code):
4559         self.target.generate_function_definitions(env, code)
4560         self.bound1.generate_function_definitions(env, code)
4561         self.bound2.generate_function_definitions(env, code)
4562         if self.step is not None:
4563             self.step.generate_function_definitions(env, code)
4564         self.body.generate_function_definitions(env, code)
4565         if self.else_clause is not None:
4566             self.else_clause.generate_function_definitions(env, code)
4567
4568     def annotate(self, code):
4569         self.target.annotate(code)
4570         self.bound1.annotate(code)
4571         self.bound2.annotate(code)
4572         if self.step:
4573             self.step.annotate(code)
4574         self.body.annotate(code)
4575         if self.else_clause:
4576             self.else_clause.annotate(code)
4577
4578
4579 class WithStatNode(StatNode):
4580     """
4581     Represents a Python with statement.
4582
4583     This is only used at parse tree level; and is not present in
4584     analysis or generation phases.
4585     """
4586     #  manager          The with statement manager object
4587     #  target            Node (lhs expression)
4588     #  body             StatNode
4589     child_attrs = ["manager", "target", "body"]
4590
4591 class TryExceptStatNode(StatNode):
4592     #  try .. except statement
4593     #
4594     #  body             StatNode
4595     #  except_clauses   [ExceptClauseNode]
4596     #  else_clause      StatNode or None
4597
4598     child_attrs = ["body", "except_clauses", "else_clause"]
4599
4600     def analyse_control_flow(self, env):
4601         env.start_branching(self.pos)
4602         self.body.analyse_control_flow(env)
4603         successful_try = env.control_flow # grab this for later
4604         env.next_branch(self.body.end_pos())
4605         env.finish_branching(self.body.end_pos())
4606
4607         env.start_branching(self.except_clauses[0].pos)
4608         for except_clause in self.except_clauses:
4609             except_clause.analyse_control_flow(env)
4610             env.next_branch(except_clause.end_pos())
4611
4612         # the else cause it executed only when the try clause finishes
4613         env.control_flow.incoming = successful_try
4614         if self.else_clause:
4615             self.else_clause.analyse_control_flow(env)
4616         env.finish_branching(self.end_pos())
4617
4618     def analyse_declarations(self, env):
4619         self.body.analyse_declarations(env)
4620         for except_clause in self.except_clauses:
4621             except_clause.analyse_declarations(env)
4622         if self.else_clause:
4623             self.else_clause.analyse_declarations(env)
4624         env.use_utility_code(reset_exception_utility_code)
4625
4626     def analyse_expressions(self, env):
4627         self.body.analyse_expressions(env)
4628         default_clause_seen = 0
4629         for except_clause in self.except_clauses:
4630             except_clause.analyse_expressions(env)
4631             if default_clause_seen:
4632                 error(except_clause.pos, "default 'except:' must be last")
4633             if not except_clause.pattern:
4634                 default_clause_seen = 1
4635         self.has_default_clause = default_clause_seen
4636         if self.else_clause:
4637             self.else_clause.analyse_expressions(env)
4638
4639     nogil_check = Node.gil_error
4640     gil_message = "Try-except statement"
4641
4642     def generate_execution_code(self, code):
4643         old_return_label = code.return_label
4644         old_break_label = code.break_label
4645         old_continue_label = code.continue_label
4646         old_error_label = code.new_error_label()
4647         our_error_label = code.error_label
4648         except_end_label = code.new_label('exception_handled')
4649         except_error_label = code.new_label('except_error')
4650         except_return_label = code.new_label('except_return')
4651         try_return_label = code.new_label('try_return')
4652         try_break_label = code.new_label('try_break')
4653         try_continue_label = code.new_label('try_continue')
4654         try_end_label = code.new_label('try_end')
4655
4656         code.putln("{")
4657         code.putln("PyObject %s;" %
4658                    ', '.join(['*%s' % var for var in Naming.exc_save_vars]))
4659         code.putln("__Pyx_ExceptionSave(%s);" %
4660                    ', '.join(['&%s' % var for var in Naming.exc_save_vars]))
4661         for var in Naming.exc_save_vars:
4662             code.put_xgotref(var)
4663         code.putln(
4664             "/*try:*/ {")
4665         code.return_label = try_return_label
4666         code.break_label = try_break_label
4667         code.continue_label = try_continue_label
4668         self.body.generate_execution_code(code)
4669         code.putln(
4670             "}")
4671         temps_to_clean_up = code.funcstate.all_free_managed_temps()
4672         code.error_label = except_error_label
4673         code.return_label = except_return_label
4674         if self.else_clause:
4675             code.putln(
4676                 "/*else:*/ {")
4677             self.else_clause.generate_execution_code(code)
4678             code.putln(
4679                 "}")
4680         for var in Naming.exc_save_vars:
4681             code.put_xdecref_clear(var, py_object_type)
4682         code.put_goto(try_end_label)
4683         if code.label_used(try_return_label):
4684             code.put_label(try_return_label)
4685             for var in Naming.exc_save_vars: code.put_xgiveref(var)
4686             code.putln("__Pyx_ExceptionReset(%s);" %
4687                        ', '.join(Naming.exc_save_vars))
4688             code.put_goto(old_return_label)
4689         code.put_label(our_error_label)
4690         for temp_name, type in temps_to_clean_up:
4691             code.put_xdecref_clear(temp_name, type)
4692         for except_clause in self.except_clauses:
4693             except_clause.generate_handling_code(code, except_end_label)
4694
4695         error_label_used = code.label_used(except_error_label)
4696         if error_label_used or not self.has_default_clause:
4697             if error_label_used:
4698                 code.put_label(except_error_label)
4699             for var in Naming.exc_save_vars: code.put_xgiveref(var)
4700             code.putln("__Pyx_ExceptionReset(%s);" %
4701                        ', '.join(Naming.exc_save_vars))
4702             code.put_goto(old_error_label)
4703
4704         for exit_label, old_label in zip(
4705             [try_break_label, try_continue_label, except_return_label],
4706             [old_break_label, old_continue_label, old_return_label]):
4707
4708             if code.label_used(exit_label):
4709                 code.put_label(exit_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_goto(old_label)
4714
4715         if code.label_used(except_end_label):
4716             code.put_label(except_end_label)
4717             for var in Naming.exc_save_vars: code.put_xgiveref(var)
4718             code.putln("__Pyx_ExceptionReset(%s);" %
4719                        ', '.join(Naming.exc_save_vars))
4720         code.put_label(try_end_label)
4721         code.putln("}")
4722
4723         code.return_label = old_return_label
4724         code.break_label = old_break_label
4725         code.continue_label = old_continue_label
4726         code.error_label = old_error_label
4727
4728     def generate_function_definitions(self, env, code):
4729         self.body.generate_function_definitions(env, code)
4730         for except_clause in self.except_clauses:
4731             except_clause.generate_function_definitions(env, code)
4732         if self.else_clause is not None:
4733             self.else_clause.generate_function_definitions(env, code)
4734
4735     def annotate(self, code):
4736         self.body.annotate(code)
4737         for except_node in self.except_clauses:
4738             except_node.annotate(code)
4739         if self.else_clause:
4740             self.else_clause.annotate(code)
4741
4742
4743 class ExceptClauseNode(Node):
4744     #  Part of try ... except statement.
4745     #
4746     #  pattern        [ExprNode]
4747     #  target         ExprNode or None
4748     #  body           StatNode
4749     #  excinfo_target NameNode or None   optional target for exception info
4750     #  match_flag     string             result of exception match
4751     #  exc_value      ExcValueNode       used internally
4752     #  function_name  string             qualified name of enclosing function
4753     #  exc_vars       (string * 3)       local exception variables
4754
4755     # excinfo_target is never set by the parser, but can be set by a transform
4756     # in order to extract more extensive information about the exception as a
4757     # sys.exc_info()-style tuple into a target variable
4758
4759     child_attrs = ["pattern", "target", "body", "exc_value", "excinfo_target"]
4760
4761     exc_value = None
4762     excinfo_target = None
4763
4764     def analyse_declarations(self, env):
4765         if self.target:
4766             self.target.analyse_target_declaration(env)
4767         if self.excinfo_target is not None:
4768             self.excinfo_target.analyse_target_declaration(env)
4769         self.body.analyse_declarations(env)
4770
4771     def analyse_expressions(self, env):
4772         import ExprNodes
4773         genv = env.global_scope()
4774         self.function_name = env.qualified_name
4775         if self.pattern:
4776             # normalise/unpack self.pattern into a list
4777             for i, pattern in enumerate(self.pattern):
4778                 pattern.analyse_expressions(env)
4779                 self.pattern[i] = pattern.coerce_to_pyobject(env)
4780
4781         if self.target:
4782             self.exc_value = ExprNodes.ExcValueNode(self.pos, env)
4783             self.target.analyse_target_expression(env, self.exc_value)
4784         if self.excinfo_target is not None:
4785             import ExprNodes
4786             self.excinfo_tuple = ExprNodes.TupleNode(pos=self.pos, args=[
4787                 ExprNodes.ExcValueNode(pos=self.pos, env=env) for x in range(3)])
4788             self.excinfo_tuple.analyse_expressions(env)
4789             self.excinfo_target.analyse_target_expression(env, self.excinfo_tuple)
4790
4791         self.body.analyse_expressions(env)
4792
4793     def generate_handling_code(self, code, end_label):
4794         code.mark_pos(self.pos)
4795         if self.pattern:
4796             exc_tests = []
4797             for pattern in self.pattern:
4798                 pattern.generate_evaluation_code(code)
4799                 exc_tests.append("PyErr_ExceptionMatches(%s)" % pattern.py_result())
4800
4801             match_flag = code.funcstate.allocate_temp(PyrexTypes.c_int_type, False)
4802             code.putln(
4803                 "%s = %s;" % (match_flag, ' || '.join(exc_tests)))
4804             for pattern in self.pattern:
4805                 pattern.generate_disposal_code(code)
4806                 pattern.free_temps(code)
4807             code.putln(
4808                 "if (%s) {" %
4809                     match_flag)
4810             code.funcstate.release_temp(match_flag)
4811         else:
4812             code.putln("/*except:*/ {")
4813
4814         if not getattr(self.body, 'stats', True) and \
4815                 self.excinfo_target is None and self.target is None:
4816             # most simple case: no exception variable, empty body (pass)
4817             # => reset the exception state, done
4818             code.putln("PyErr_Restore(0,0,0);")
4819             code.put_goto(end_label)
4820             code.putln("}")
4821             return
4822
4823         exc_vars = [code.funcstate.allocate_temp(py_object_type,
4824                                                  manage_ref=True)
4825                     for i in xrange(3)]
4826         code.putln('__Pyx_AddTraceback("%s");' % self.function_name)
4827         # We always have to fetch the exception value even if
4828         # there is no target, because this also normalises the
4829         # exception and stores it in the thread state.
4830         code.globalstate.use_utility_code(get_exception_utility_code)
4831         exc_args = "&%s, &%s, &%s" % tuple(exc_vars)
4832         code.putln("if (__Pyx_GetException(%s) < 0) %s" % (exc_args,
4833             code.error_goto(self.pos)))
4834         for x in exc_vars:
4835             code.put_gotref(x)
4836         if self.target:
4837             self.exc_value.set_var(exc_vars[1])
4838             self.exc_value.generate_evaluation_code(code)
4839             self.target.generate_assignment_code(self.exc_value, code)
4840         if self.excinfo_target is not None:
4841             for tempvar, node in zip(exc_vars, self.excinfo_tuple.args):
4842                 node.set_var(tempvar)
4843             self.excinfo_tuple.generate_evaluation_code(code)
4844             self.excinfo_target.generate_assignment_code(self.excinfo_tuple, code)
4845
4846         old_break_label, old_continue_label = code.break_label, code.continue_label
4847         code.break_label = code.new_label('except_break')
4848         code.continue_label = code.new_label('except_continue')
4849
4850         old_exc_vars = code.funcstate.exc_vars
4851         code.funcstate.exc_vars = exc_vars
4852         self.body.generate_execution_code(code)
4853         code.funcstate.exc_vars = old_exc_vars
4854         for var in exc_vars:
4855             code.putln("__Pyx_DECREF(%s); %s = 0;" % (var, var))
4856         code.put_goto(end_label)
4857
4858         if code.label_used(code.break_label):
4859             code.put_label(code.break_label)
4860             for var in exc_vars:
4861                 code.putln("__Pyx_DECREF(%s); %s = 0;" % (var, var))
4862             code.put_goto(old_break_label)
4863         code.break_label = old_break_label
4864
4865         if code.label_used(code.continue_label):
4866             code.put_label(code.continue_label)
4867             for var in exc_vars:
4868                 code.putln("__Pyx_DECREF(%s); %s = 0;" % (var, var))
4869             code.put_goto(old_continue_label)
4870         code.continue_label = old_continue_label
4871
4872         for temp in exc_vars:
4873             code.funcstate.release_temp(temp)
4874
4875         code.putln(
4876             "}")
4877
4878     def generate_function_definitions(self, env, code):
4879         if self.target is not None:
4880             self.target.generate_function_definitions(env, code)
4881         self.body.generate_function_definitions(env, code)
4882
4883     def annotate(self, code):
4884         if self.pattern:
4885             for pattern in self.pattern:
4886                 pattern.annotate(code)
4887         if self.target:
4888             self.target.annotate(code)
4889         self.body.annotate(code)
4890
4891
4892 class TryFinallyStatNode(StatNode):
4893     #  try ... finally statement
4894     #
4895     #  body             StatNode
4896     #  finally_clause   StatNode
4897     #
4898     #  The plan is that we funnel all continue, break
4899     #  return and error gotos into the beginning of the
4900     #  finally block, setting a variable to remember which
4901     #  one we're doing. At the end of the finally block, we
4902     #  switch on the variable to figure out where to go.
4903     #  In addition, if we're doing an error, we save the
4904     #  exception on entry to the finally block and restore
4905     #  it on exit.
4906
4907     child_attrs = ["body", "finally_clause"]
4908
4909     preserve_exception = 1
4910
4911     disallow_continue_in_try_finally = 0
4912     # There doesn't seem to be any point in disallowing
4913     # continue in the try block, since we have no problem
4914     # handling it.
4915
4916     def create_analysed(pos, env, body, finally_clause):
4917         node = TryFinallyStatNode(pos, body=body, finally_clause=finally_clause)
4918         return node
4919     create_analysed = staticmethod(create_analysed)
4920
4921     def analyse_control_flow(self, env):
4922         env.start_branching(self.pos)
4923         self.body.analyse_control_flow(env)
4924         env.next_branch(self.body.end_pos())
4925         env.finish_branching(self.body.end_pos())
4926         self.finally_clause.analyse_control_flow(env)
4927
4928     def analyse_declarations(self, env):
4929         self.body.analyse_declarations(env)
4930         self.finally_clause.analyse_declarations(env)
4931
4932     def analyse_expressions(self, env):
4933         self.body.analyse_expressions(env)
4934         self.finally_clause.analyse_expressions(env)
4935
4936     nogil_check = Node.gil_error
4937     gil_message = "Try-finally statement"
4938
4939     def generate_execution_code(self, code):
4940         old_error_label = code.error_label
4941         old_labels = code.all_new_labels()
4942         new_labels = code.get_all_labels()
4943         new_error_label = code.error_label
4944         catch_label = code.new_label()
4945         code.putln(
4946             "/*try:*/ {")
4947         if self.disallow_continue_in_try_finally:
4948             was_in_try_finally = code.funcstate.in_try_finally
4949             code.funcstate.in_try_finally = 1
4950         self.body.generate_execution_code(code)
4951         if self.disallow_continue_in_try_finally:
4952             code.funcstate.in_try_finally = was_in_try_finally
4953         code.putln(
4954             "}")
4955         temps_to_clean_up = code.funcstate.all_free_managed_temps()
4956         code.mark_pos(self.finally_clause.pos)
4957         code.putln(
4958             "/*finally:*/ {")
4959         cases_used = []
4960         error_label_used = 0
4961         for i, new_label in enumerate(new_labels):
4962             if new_label in code.labels_used:
4963                 cases_used.append(i)
4964                 if new_label == new_error_label:
4965                     error_label_used = 1
4966                     error_label_case = i
4967         if cases_used:
4968             code.putln(
4969                     "int __pyx_why;")
4970             if error_label_used and self.preserve_exception:
4971                 code.putln(
4972                     "PyObject *%s, *%s, *%s;" % Naming.exc_vars)
4973                 code.putln(
4974                     "int %s;" % Naming.exc_lineno_name)
4975                 exc_var_init_zero = ''.join(["%s = 0; " % var for var in Naming.exc_vars])
4976                 exc_var_init_zero += '%s = 0;' % Naming.exc_lineno_name
4977                 code.putln(exc_var_init_zero)
4978             else:
4979                 exc_var_init_zero = None
4980             code.use_label(catch_label)
4981             code.putln(
4982                     "__pyx_why = 0; goto %s;" % catch_label)
4983             for i in cases_used:
4984                 new_label = new_labels[i]
4985                 #if new_label and new_label != "<try>":
4986                 if new_label == new_error_label and self.preserve_exception:
4987                     self.put_error_catcher(code,
4988                         new_error_label, i+1, catch_label, temps_to_clean_up)
4989                 else:
4990                     code.put('%s: ' % new_label)
4991                     if exc_var_init_zero:
4992                         code.putln(exc_var_init_zero)
4993                     code.putln("__pyx_why = %s; goto %s;" % (
4994                             i+1,
4995                             catch_label))
4996             code.put_label(catch_label)
4997         code.set_all_labels(old_labels)
4998         if error_label_used:
4999             code.new_error_label()
5000             finally_error_label = code.error_label
5001         self.finally_clause.generate_execution_code(code)
5002         if error_label_used:
5003             if finally_error_label in code.labels_used and self.preserve_exception:
5004                 over_label = code.new_label()
5005                 code.put_goto(over_label);
5006                 code.put_label(finally_error_label)
5007                 code.putln("if (__pyx_why == %d) {" % (error_label_case + 1))
5008                 for var in Naming.exc_vars:
5009                     code.putln("Py_XDECREF(%s);" % var)
5010                 code.putln("}")
5011                 code.put_goto(old_error_label)
5012                 code.put_label(over_label)
5013             code.error_label = old_error_label
5014         if cases_used:
5015             code.putln(
5016                 "switch (__pyx_why) {")
5017             for i in cases_used:
5018                 old_label = old_labels[i]
5019                 if old_label == old_error_label and self.preserve_exception:
5020                     self.put_error_uncatcher(code, i+1, old_error_label)
5021                 else:
5022                     code.use_label(old_label)
5023                     code.putln(
5024                         "case %s: goto %s;" % (
5025                             i+1,
5026                             old_label))
5027             code.putln(
5028                 "}")
5029         code.putln(
5030             "}")
5031
5032     def generate_function_definitions(self, env, code):
5033         self.body.generate_function_definitions(env, code)
5034         self.finally_clause.generate_function_definitions(env, code)
5035
5036     def put_error_catcher(self, code, error_label, i, catch_label, temps_to_clean_up):
5037         code.globalstate.use_utility_code(restore_exception_utility_code)
5038         code.putln(
5039             "%s: {" %
5040                 error_label)
5041         code.putln(
5042                 "__pyx_why = %s;" %
5043                     i)
5044         for temp_name, type in temps_to_clean_up:
5045             code.put_xdecref_clear(temp_name, type)
5046         code.putln(
5047                 "__Pyx_ErrFetch(&%s, &%s, &%s);" %
5048                     Naming.exc_vars)
5049         code.putln(
5050                 "%s = %s;" % (
5051                     Naming.exc_lineno_name, Naming.lineno_cname))
5052         code.put_goto(catch_label)
5053         code.putln("}")
5054
5055     def put_error_uncatcher(self, code, i, error_label):
5056         code.globalstate.use_utility_code(restore_exception_utility_code)
5057         code.putln(
5058             "case %s: {" %
5059                 i)
5060         code.putln(
5061                 "__Pyx_ErrRestore(%s, %s, %s);" %
5062                     Naming.exc_vars)
5063         code.putln(
5064                 "%s = %s;" % (
5065                     Naming.lineno_cname, Naming.exc_lineno_name))
5066         for var in Naming.exc_vars:
5067             code.putln(
5068                 "%s = 0;" %
5069                     var)
5070         code.put_goto(error_label)
5071         code.putln(
5072             "}")
5073
5074     def annotate(self, code):
5075         self.body.annotate(code)
5076         self.finally_clause.annotate(code)
5077
5078
5079 class GILStatNode(TryFinallyStatNode):
5080     #  'with gil' or 'with nogil' statement
5081     #
5082     #   state   string   'gil' or 'nogil'
5083
5084 #    child_attrs = []
5085
5086     preserve_exception = 0
5087
5088     def __init__(self, pos, state, body):
5089         self.state = state
5090         TryFinallyStatNode.__init__(self, pos,
5091             body = body,
5092             finally_clause = GILExitNode(pos, state = state))
5093
5094     def analyse_expressions(self, env):
5095         env.use_utility_code(force_init_threads_utility_code)
5096         was_nogil = env.nogil
5097         env.nogil = 1
5098         TryFinallyStatNode.analyse_expressions(self, env)
5099         env.nogil = was_nogil
5100
5101     nogil_check = None
5102
5103     def generate_execution_code(self, code):
5104         code.mark_pos(self.pos)
5105         code.putln("{")
5106         if self.state == 'gil':
5107             code.putln("#ifdef WITH_THREAD")
5108             code.putln("PyGILState_STATE _save = PyGILState_Ensure();")
5109             code.putln("#endif")
5110         else:
5111             code.putln("#ifdef WITH_THREAD")
5112             code.putln("PyThreadState *_save;")
5113             code.putln("#endif")
5114             code.putln("Py_UNBLOCK_THREADS")
5115         TryFinallyStatNode.generate_execution_code(self, code)
5116         code.putln("}")
5117
5118
5119 class GILExitNode(StatNode):
5120     #  Used as the 'finally' block in a GILStatNode
5121     #
5122     #  state   string   'gil' or 'nogil'
5123
5124     child_attrs = []
5125
5126     def analyse_expressions(self, env):
5127         pass
5128
5129     def generate_execution_code(self, code):
5130         if self.state == 'gil':
5131             code.putln("#ifdef WITH_THREAD")
5132             code.putln("PyGILState_Release(_save);")
5133             code.putln("#endif")
5134         else:
5135             code.putln("Py_BLOCK_THREADS")
5136
5137
5138 class CImportStatNode(StatNode):
5139     #  cimport statement
5140     #
5141     #  module_name   string           Qualified name of module being imported
5142     #  as_name       string or None   Name specified in "as" clause, if any
5143
5144     child_attrs = []
5145
5146     def analyse_declarations(self, env):
5147         if not env.is_module_scope:
5148             error(self.pos, "cimport only allowed at module level")
5149             return
5150         module_scope = env.find_module(self.module_name, self.pos)
5151         if "." in self.module_name:
5152             names = [EncodedString(name) for name in self.module_name.split(".")]
5153             top_name = names[0]
5154             top_module_scope = env.context.find_submodule(top_name)
5155             module_scope = top_module_scope
5156             for name in names[1:]:
5157                 submodule_scope = module_scope.find_submodule(name)
5158                 module_scope.declare_module(name, submodule_scope, self.pos)
5159                 module_scope = submodule_scope
5160             if self.as_name:
5161                 env.declare_module(self.as_name, module_scope, self.pos)
5162             else:
5163                 env.declare_module(top_name, top_module_scope, self.pos)
5164         else:
5165             name = self.as_name or self.module_name
5166             env.declare_module(name, module_scope, self.pos)
5167
5168     def analyse_expressions(self, env):
5169         pass
5170
5171     def generate_execution_code(self, code):
5172         pass
5173
5174
5175 class FromCImportStatNode(StatNode):
5176     #  from ... cimport statement
5177     #
5178     #  module_name     string                        Qualified name of module
5179     #  imported_names  [(pos, name, as_name, kind)]  Names to be imported
5180
5181     child_attrs = []
5182
5183     def analyse_declarations(self, env):
5184         if not env.is_module_scope:
5185             error(self.pos, "cimport only allowed at module level")
5186             return
5187         module_scope = env.find_module(self.module_name, self.pos)
5188         env.add_imported_module(module_scope)
5189         for pos, name, as_name, kind in self.imported_names:
5190             if name == "*":
5191                 for local_name, entry in module_scope.entries.items():
5192                     env.add_imported_entry(local_name, entry, pos)
5193             else:
5194                 entry = module_scope.lookup(name)
5195                 if entry:
5196                     if kind and not self.declaration_matches(entry, kind):
5197                         entry.redeclared(pos)
5198                 else:
5199                     if kind == 'struct' or kind == 'union':
5200                         entry = module_scope.declare_struct_or_union(name,
5201                             kind = kind, scope = None, typedef_flag = 0, pos = pos)
5202                     elif kind == 'class':
5203                         entry = module_scope.declare_c_class(name, pos = pos,
5204                             module_name = self.module_name)
5205                     else:
5206                         submodule_scope = env.context.find_module(name, relative_to = module_scope, pos = self.pos)
5207                         if submodule_scope.parent_module is module_scope:
5208                             env.declare_module(as_name or name, submodule_scope, self.pos)
5209                         else:
5210                             error(pos, "Name '%s' not declared in module '%s'"
5211                                 % (name, self.module_name))
5212
5213                 if entry:
5214                     local_name = as_name or name
5215                     env.add_imported_entry(local_name, entry, pos)
5216
5217     def declaration_matches(self, entry, kind):
5218         if not entry.is_type:
5219             return 0
5220         type = entry.type
5221         if kind == 'class':
5222             if not type.is_extension_type:
5223                 return 0
5224         else:
5225             if not type.is_struct_or_union:
5226                 return 0
5227             if kind != type.kind:
5228                 return 0
5229         return 1
5230
5231     def analyse_expressions(self, env):
5232         pass
5233
5234     def generate_execution_code(self, code):
5235         pass
5236
5237
5238 class FromImportStatNode(StatNode):
5239     #  from ... import statement
5240     #
5241     #  module           ImportNode
5242     #  items            [(string, NameNode)]
5243     #  interned_items   [(string, NameNode, ExprNode)]
5244     #  item             PyTempNode            used internally
5245     #  import_star      boolean               used internally
5246
5247     child_attrs = ["module"]
5248     import_star = 0
5249
5250     def analyse_declarations(self, env):
5251         for name, target in self.items:
5252             if name == "*":
5253                 if not env.is_module_scope:
5254                     error(self.pos, "import * only allowed at module level")
5255                     return
5256                 env.has_import_star = 1
5257                 self.import_star = 1
5258             else:
5259                 target.analyse_target_declaration(env)
5260
5261     def analyse_expressions(self, env):
5262         import ExprNodes
5263         self.module.analyse_expressions(env)
5264         self.item = ExprNodes.RawCNameExprNode(self.pos, py_object_type)
5265         self.interned_items = []
5266         for name, target in self.items:
5267             if name == '*':
5268                 for _, entry in env.entries.items():
5269                     if not entry.is_type and entry.type.is_extension_type:
5270                         env.use_utility_code(ExprNodes.type_test_utility_code)
5271                         break
5272             else:
5273                 entry =  env.lookup(target.name)
5274                 # check whether or not entry is already cimported
5275                 if (entry.is_type and entry.type.name == name
5276                     and hasattr(entry.type, 'module_name')):
5277                     if entry.type.module_name == self.module.module_name.value:
5278                         # cimported with absolute name
5279                         continue
5280                     try:
5281                         # cimported with relative name
5282                         module = env.find_module(self.module.module_name.value,
5283                                                  pos=None)
5284                         if entry.type.module_name == module.qualified_name:
5285                             continue
5286                     except AttributeError:
5287                         pass
5288                 target.analyse_target_expression(env, None)
5289                 if target.type is py_object_type:
5290                     coerced_item = None
5291                 else:
5292                     coerced_item = self.item.coerce_to(target.type, env)
5293                 self.interned_items.append((name, target, coerced_item))
5294
5295     def generate_execution_code(self, code):
5296         self.module.generate_evaluation_code(code)
5297         if self.import_star:
5298             code.putln(
5299                 'if (%s(%s) < 0) %s;' % (
5300                     Naming.import_star,
5301                     self.module.py_result(),
5302                     code.error_goto(self.pos)))
5303         item_temp = code.funcstate.allocate_temp(py_object_type, manage_ref=True)
5304         self.item.set_cname(item_temp)
5305         for name, target, coerced_item in self.interned_items:
5306             cname = code.intern_identifier(name)
5307             code.putln(
5308                 '%s = PyObject_GetAttr(%s, %s); %s' % (
5309                     item_temp,
5310                     self.module.py_result(),
5311                     cname,
5312                     code.error_goto_if_null(item_temp, self.pos)))
5313             code.put_gotref(item_temp)
5314             if coerced_item is None:
5315                 target.generate_assignment_code(self.item, code)
5316             else:
5317                 coerced_item.allocate_temp_result(code)
5318                 coerced_item.generate_result_code(code)
5319                 target.generate_assignment_code(coerced_item, code)
5320             code.put_decref_clear(item_temp, py_object_type)
5321         code.funcstate.release_temp(item_temp)
5322         self.module.generate_disposal_code(code)
5323         self.module.free_temps(code)
5324
5325
5326
5327 #------------------------------------------------------------------------------------
5328 #
5329 #  Runtime support code
5330 #
5331 #------------------------------------------------------------------------------------
5332
5333 utility_function_predeclarations = \
5334 """
5335 /* inline attribute */
5336 #ifndef CYTHON_INLINE
5337   #if defined(__GNUC__)
5338     #define CYTHON_INLINE __inline__
5339   #elif defined(_MSC_VER)
5340     #define CYTHON_INLINE __inline
5341   #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
5342     #define CYTHON_INLINE inline
5343   #else
5344     #define CYTHON_INLINE
5345   #endif
5346 #endif
5347
5348 /* unused attribute */
5349 #ifndef CYTHON_UNUSED
5350 # if defined(__GNUC__)
5351 #   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
5352 #     define CYTHON_UNUSED __attribute__ ((__unused__))
5353 #   else
5354 #     define CYTHON_UNUSED
5355 #   endif
5356 # elif defined(__ICC) || defined(__INTEL_COMPILER)
5357 #   define CYTHON_UNUSED __attribute__ ((__unused__))
5358 # else
5359 #   define CYTHON_UNUSED
5360 # endif
5361 #endif
5362
5363 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*/
5364
5365 """
5366
5367 if Options.gcc_branch_hints:
5368     branch_prediction_macros = \
5369     """
5370 #ifdef __GNUC__
5371 /* Test for GCC > 2.95 */
5372 #if __GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95))
5373 #define likely(x)   __builtin_expect(!!(x), 1)
5374 #define unlikely(x) __builtin_expect(!!(x), 0)
5375 #else /* __GNUC__ > 2 ... */
5376 #define likely(x)   (x)
5377 #define unlikely(x) (x)
5378 #endif /* __GNUC__ > 2 ... */
5379 #else /* __GNUC__ */
5380 #define likely(x)   (x)
5381 #define unlikely(x) (x)
5382 #endif /* __GNUC__ */
5383     """
5384 else:
5385     branch_prediction_macros = \
5386     """
5387 #define likely(x)   (x)
5388 #define unlikely(x) (x)
5389     """
5390
5391 #get_name_predeclaration = \
5392 #"static PyObject *__Pyx_GetName(PyObject *dict, char *name); /*proto*/"
5393
5394 #get_name_interned_predeclaration = \
5395 #"static PyObject *__Pyx_GetName(PyObject *dict, PyObject *name); /*proto*/"
5396
5397 #------------------------------------------------------------------------------------
5398
5399 printing_utility_code = UtilityCode(
5400 proto = """
5401 static int __Pyx_Print(PyObject*, PyObject *, int); /*proto*/
5402 #if PY_MAJOR_VERSION >= 3
5403 static PyObject* %s = 0;
5404 static PyObject* %s = 0;
5405 #endif
5406 """ % (Naming.print_function, Naming.print_function_kwargs),
5407 cleanup = """
5408 #if PY_MAJOR_VERSION >= 3
5409 Py_CLEAR(%s);
5410 Py_CLEAR(%s);
5411 #endif
5412 """ % (Naming.print_function, Naming.print_function_kwargs),
5413 impl = r"""
5414 #if PY_MAJOR_VERSION < 3
5415 static PyObject *__Pyx_GetStdout(void) {
5416     PyObject *f = PySys_GetObject((char *)"stdout");
5417     if (!f) {
5418         PyErr_SetString(PyExc_RuntimeError, "lost sys.stdout");
5419     }
5420     return f;
5421 }
5422
5423 static int __Pyx_Print(PyObject* f, PyObject *arg_tuple, int newline) {
5424     PyObject* v;
5425     int i;
5426
5427     if (!f) {
5428         if (!(f = __Pyx_GetStdout()))
5429             return -1;
5430     }
5431     for (i=0; i < PyTuple_GET_SIZE(arg_tuple); i++) {
5432         if (PyFile_SoftSpace(f, 1)) {
5433             if (PyFile_WriteString(" ", f) < 0)
5434                 return -1;
5435         }
5436         v = PyTuple_GET_ITEM(arg_tuple, i);
5437         if (PyFile_WriteObject(v, f, Py_PRINT_RAW) < 0)
5438             return -1;
5439         if (PyString_Check(v)) {
5440             char *s = PyString_AsString(v);
5441             Py_ssize_t len = PyString_Size(v);
5442             if (len > 0 &&
5443                 isspace(Py_CHARMASK(s[len-1])) &&
5444                 s[len-1] != ' ')
5445                     PyFile_SoftSpace(f, 0);
5446         }
5447     }
5448     if (newline) {
5449         if (PyFile_WriteString("\n", f) < 0)
5450             return -1;
5451         PyFile_SoftSpace(f, 0);
5452     }
5453     return 0;
5454 }
5455
5456 #else /* Python 3 has a print function */
5457
5458 static int __Pyx_Print(PyObject* stream, PyObject *arg_tuple, int newline) {
5459     PyObject* kwargs = 0;
5460     PyObject* result = 0;
5461     PyObject* end_string;
5462     if (unlikely(!%(PRINT_FUNCTION)s)) {
5463         %(PRINT_FUNCTION)s = __Pyx_GetAttrString(%(BUILTINS)s, "print");
5464         if (!%(PRINT_FUNCTION)s)
5465             return -1;
5466     }
5467     if (stream) {
5468         kwargs = PyDict_New();
5469         if (unlikely(!kwargs))
5470             return -1;
5471         if (unlikely(PyDict_SetItemString(kwargs, "file", stream) < 0))
5472             goto bad;
5473         if (!newline) {
5474             end_string = PyUnicode_FromStringAndSize(" ", 1);
5475             if (unlikely(!end_string))
5476                 goto bad;
5477             if (PyDict_SetItemString(kwargs, "end", end_string) < 0) {
5478                 Py_DECREF(end_string);
5479                 goto bad;
5480             }
5481             Py_DECREF(end_string);
5482         }
5483     } else if (!newline) {
5484         if (unlikely(!%(PRINT_KWARGS)s)) {
5485             %(PRINT_KWARGS)s = PyDict_New();
5486             if (unlikely(!%(PRINT_KWARGS)s))
5487                 return -1;
5488             end_string = PyUnicode_FromStringAndSize(" ", 1);
5489             if (unlikely(!end_string))
5490                 return -1;
5491             if (PyDict_SetItemString(%(PRINT_KWARGS)s, "end", end_string) < 0) {
5492                 Py_DECREF(end_string);
5493                 return -1;
5494             }
5495             Py_DECREF(end_string);
5496         }
5497         kwargs = %(PRINT_KWARGS)s;
5498     }
5499     result = PyObject_Call(%(PRINT_FUNCTION)s, arg_tuple, kwargs);
5500     if (unlikely(kwargs) && (kwargs != %(PRINT_KWARGS)s))
5501         Py_DECREF(kwargs);
5502     if (!result)
5503         return -1;
5504     Py_DECREF(result);
5505     return 0;
5506 bad:
5507     if (kwargs != %(PRINT_KWARGS)s)
5508         Py_XDECREF(kwargs);
5509     return -1;
5510 }
5511
5512 #endif
5513 """ % {'BUILTINS'       : Naming.builtins_cname,
5514        'PRINT_FUNCTION' : Naming.print_function,
5515        'PRINT_KWARGS'   : Naming.print_function_kwargs}
5516 )
5517
5518
5519 printing_one_utility_code = UtilityCode(
5520 proto = """
5521 static int __Pyx_PrintOne(PyObject* stream, PyObject *o); /*proto*/
5522 """,
5523 impl = r"""
5524 #if PY_MAJOR_VERSION < 3
5525
5526 static int __Pyx_PrintOne(PyObject* f, PyObject *o) {
5527     if (!f) {
5528         if (!(f = __Pyx_GetStdout()))
5529             return -1;
5530     }
5531     if (PyFile_SoftSpace(f, 0)) {
5532         if (PyFile_WriteString(" ", f) < 0)
5533             return -1;
5534     }
5535     if (PyFile_WriteObject(o, f, Py_PRINT_RAW) < 0)
5536         return -1;
5537     if (PyFile_WriteString("\n", f) < 0)
5538         return -1;
5539     return 0;
5540     /* the line below is just to avoid compiler
5541      * compiler warnings about unused functions */
5542     return __Pyx_Print(f, NULL, 0);
5543 }
5544
5545 #else /* Python 3 has a print function */
5546
5547 static int __Pyx_PrintOne(PyObject* stream, PyObject *o) {
5548     int res;
5549     PyObject* arg_tuple = PyTuple_New(1);
5550     if (unlikely(!arg_tuple))
5551         return -1;
5552     Py_INCREF(o);
5553     PyTuple_SET_ITEM(arg_tuple, 0, o);
5554     res = __Pyx_Print(stream, arg_tuple, 1);
5555     Py_DECREF(arg_tuple);
5556     return res;
5557 }
5558
5559 #endif
5560 """,
5561 requires=[printing_utility_code])
5562
5563
5564
5565 #------------------------------------------------------------------------------------
5566
5567 # Exception raising code
5568 #
5569 # Exceptions are raised by __Pyx_Raise() and stored as plain
5570 # type/value/tb in PyThreadState->curexc_*.  When being caught by an
5571 # 'except' statement, curexc_* is moved over to exc_* by
5572 # __Pyx_GetException()
5573
5574 restore_exception_utility_code = UtilityCode(
5575 proto = """
5576 static CYTHON_INLINE void __Pyx_ErrRestore(PyObject *type, PyObject *value, PyObject *tb); /*proto*/
5577 static CYTHON_INLINE void __Pyx_ErrFetch(PyObject **type, PyObject **value, PyObject **tb); /*proto*/
5578 """,
5579 impl = """
5580 static CYTHON_INLINE void __Pyx_ErrRestore(PyObject *type, PyObject *value, PyObject *tb) {
5581     PyObject *tmp_type, *tmp_value, *tmp_tb;
5582     PyThreadState *tstate = PyThreadState_GET();
5583
5584     tmp_type = tstate->curexc_type;
5585     tmp_value = tstate->curexc_value;
5586     tmp_tb = tstate->curexc_traceback;
5587     tstate->curexc_type = type;
5588     tstate->curexc_value = value;
5589     tstate->curexc_traceback = tb;
5590     Py_XDECREF(tmp_type);
5591     Py_XDECREF(tmp_value);
5592     Py_XDECREF(tmp_tb);
5593 }
5594
5595 static CYTHON_INLINE void __Pyx_ErrFetch(PyObject **type, PyObject **value, PyObject **tb) {
5596     PyThreadState *tstate = PyThreadState_GET();
5597     *type = tstate->curexc_type;
5598     *value = tstate->curexc_value;
5599     *tb = tstate->curexc_traceback;
5600
5601     tstate->curexc_type = 0;
5602     tstate->curexc_value = 0;
5603     tstate->curexc_traceback = 0;
5604 }
5605
5606 """)
5607
5608 # The following function is based on do_raise() from ceval.c. There
5609 # are separate versions for Python2 and Python3 as exception handling
5610 # has changed quite a lot between the two versions.
5611
5612 raise_utility_code = UtilityCode(
5613 proto = """
5614 static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb); /*proto*/
5615 """,
5616 impl = """
5617 #if PY_MAJOR_VERSION < 3
5618 static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb) {
5619     Py_XINCREF(type);
5620     Py_XINCREF(value);
5621     Py_XINCREF(tb);
5622     /* First, check the traceback argument, replacing None with NULL. */
5623     if (tb == Py_None) {
5624         Py_DECREF(tb);
5625         tb = 0;
5626     }
5627     else if (tb != NULL && !PyTraceBack_Check(tb)) {
5628         PyErr_SetString(PyExc_TypeError,
5629             "raise: arg 3 must be a traceback or None");
5630         goto raise_error;
5631     }
5632     /* Next, replace a missing value with None */
5633     if (value == NULL) {
5634         value = Py_None;
5635         Py_INCREF(value);
5636     }
5637     #if PY_VERSION_HEX < 0x02050000
5638     if (!PyClass_Check(type))
5639     #else
5640     if (!PyType_Check(type))
5641     #endif
5642     {
5643         /* Raising an instance.  The value should be a dummy. */
5644         if (value != Py_None) {
5645             PyErr_SetString(PyExc_TypeError,
5646                 "instance exception may not have a separate value");
5647             goto raise_error;
5648         }
5649         /* Normalize to raise <class>, <instance> */
5650         Py_DECREF(value);
5651         value = type;
5652         #if PY_VERSION_HEX < 0x02050000
5653             if (PyInstance_Check(type)) {
5654                 type = (PyObject*) ((PyInstanceObject*)type)->in_class;
5655                 Py_INCREF(type);
5656             }
5657             else {
5658                 type = 0;
5659                 PyErr_SetString(PyExc_TypeError,
5660                     "raise: exception must be an old-style class or instance");
5661                 goto raise_error;
5662             }
5663         #else
5664             type = (PyObject*) Py_TYPE(type);
5665             Py_INCREF(type);
5666             if (!PyType_IsSubtype((PyTypeObject *)type, (PyTypeObject *)PyExc_BaseException)) {
5667                 PyErr_SetString(PyExc_TypeError,
5668                     "raise: exception class must be a subclass of BaseException");
5669                 goto raise_error;
5670             }
5671         #endif
5672     }
5673
5674     __Pyx_ErrRestore(type, value, tb);
5675     return;
5676 raise_error:
5677     Py_XDECREF(value);
5678     Py_XDECREF(type);
5679     Py_XDECREF(tb);
5680     return;
5681 }
5682
5683 #else /* Python 3+ */
5684
5685 static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb) {
5686     if (tb == Py_None) {
5687         tb = 0;
5688     } else if (tb && !PyTraceBack_Check(tb)) {
5689         PyErr_SetString(PyExc_TypeError,
5690             "raise: arg 3 must be a traceback or None");
5691         goto bad;
5692     }
5693     if (value == Py_None)
5694         value = 0;
5695
5696     if (PyExceptionInstance_Check(type)) {
5697         if (value) {
5698             PyErr_SetString(PyExc_TypeError,
5699                 "instance exception may not have a separate value");
5700             goto bad;
5701         }
5702         value = type;
5703         type = (PyObject*) Py_TYPE(value);
5704     } else if (!PyExceptionClass_Check(type)) {
5705         PyErr_SetString(PyExc_TypeError,
5706             "raise: exception class must be a subclass of BaseException");
5707         goto bad;
5708     }
5709
5710     PyErr_SetObject(type, value);
5711
5712     if (tb) {
5713         PyThreadState *tstate = PyThreadState_GET();
5714         PyObject* tmp_tb = tstate->curexc_traceback;
5715         if (tb != tmp_tb) {
5716             Py_INCREF(tb);
5717             tstate->curexc_traceback = tb;
5718             Py_XDECREF(tmp_tb);
5719         }
5720     }
5721
5722 bad:
5723     return;
5724 }
5725 #endif
5726 """,
5727 requires=[restore_exception_utility_code])
5728
5729 #------------------------------------------------------------------------------------
5730
5731 get_exception_utility_code = UtilityCode(
5732 proto = """
5733 static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb); /*proto*/
5734 """,
5735 impl = """
5736 static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb) {
5737     PyObject *local_type, *local_value, *local_tb;
5738     PyObject *tmp_type, *tmp_value, *tmp_tb;
5739     PyThreadState *tstate = PyThreadState_GET();
5740     local_type = tstate->curexc_type;
5741     local_value = tstate->curexc_value;
5742     local_tb = tstate->curexc_traceback;
5743     tstate->curexc_type = 0;
5744     tstate->curexc_value = 0;
5745     tstate->curexc_traceback = 0;
5746     PyErr_NormalizeException(&local_type, &local_value, &local_tb);
5747     if (unlikely(tstate->curexc_type))
5748         goto bad;
5749     #if PY_MAJOR_VERSION >= 3
5750     if (unlikely(PyException_SetTraceback(local_value, local_tb) < 0))
5751         goto bad;
5752     #endif
5753     *type = local_type;
5754     *value = local_value;
5755     *tb = local_tb;
5756     Py_INCREF(local_type);
5757     Py_INCREF(local_value);
5758     Py_INCREF(local_tb);
5759     tmp_type = tstate->exc_type;
5760     tmp_value = tstate->exc_value;
5761     tmp_tb = tstate->exc_traceback;
5762     tstate->exc_type = local_type;
5763     tstate->exc_value = local_value;
5764     tstate->exc_traceback = local_tb;
5765     /* Make sure tstate is in a consistent state when we XDECREF
5766        these objects (XDECREF may run arbitrary code). */
5767     Py_XDECREF(tmp_type);
5768     Py_XDECREF(tmp_value);
5769     Py_XDECREF(tmp_tb);
5770     return 0;
5771 bad:
5772     *type = 0;
5773     *value = 0;
5774     *tb = 0;
5775     Py_XDECREF(local_type);
5776     Py_XDECREF(local_value);
5777     Py_XDECREF(local_tb);
5778     return -1;
5779 }
5780
5781 """)
5782
5783 #------------------------------------------------------------------------------------
5784
5785 get_exception_tuple_utility_code = UtilityCode(proto="""
5786 static PyObject *__Pyx_GetExceptionTuple(void); /*proto*/
5787 """,
5788 # I doubt that calling __Pyx_GetException() here is correct as it moves
5789 # the exception from tstate->curexc_* to tstate->exc_*, which prevents
5790 # exception handlers later on from receiving it.
5791 impl = """
5792 static PyObject *__Pyx_GetExceptionTuple(void) {
5793     PyObject *type = NULL, *value = NULL, *tb = NULL;
5794     if (__Pyx_GetException(&type, &value, &tb) == 0) {
5795         PyObject* exc_info = PyTuple_New(3);
5796         if (exc_info) {
5797             Py_INCREF(type);
5798             Py_INCREF(value);
5799             Py_INCREF(tb);
5800             PyTuple_SET_ITEM(exc_info, 0, type);
5801             PyTuple_SET_ITEM(exc_info, 1, value);
5802             PyTuple_SET_ITEM(exc_info, 2, tb);
5803             return exc_info;
5804         }
5805     }
5806     return NULL;
5807 }
5808 """,
5809 requires=[get_exception_utility_code])
5810
5811 #------------------------------------------------------------------------------------
5812
5813 reset_exception_utility_code = UtilityCode(
5814 proto = """
5815 static CYTHON_INLINE void __Pyx_ExceptionSave(PyObject **type, PyObject **value, PyObject **tb); /*proto*/
5816 static void __Pyx_ExceptionReset(PyObject *type, PyObject *value, PyObject *tb); /*proto*/
5817 """,
5818 impl = """
5819 static CYTHON_INLINE void __Pyx_ExceptionSave(PyObject **type, PyObject **value, PyObject **tb) {
5820     PyThreadState *tstate = PyThreadState_GET();
5821     *type = tstate->exc_type;
5822     *value = tstate->exc_value;
5823     *tb = tstate->exc_traceback;
5824     Py_XINCREF(*type);
5825     Py_XINCREF(*value);
5826     Py_XINCREF(*tb);
5827 }
5828
5829 static void __Pyx_ExceptionReset(PyObject *type, PyObject *value, PyObject *tb) {
5830     PyObject *tmp_type, *tmp_value, *tmp_tb;
5831     PyThreadState *tstate = PyThreadState_GET();
5832     tmp_type = tstate->exc_type;
5833     tmp_value = tstate->exc_value;
5834     tmp_tb = tstate->exc_traceback;
5835     tstate->exc_type = type;
5836     tstate->exc_value = value;
5837     tstate->exc_traceback = tb;
5838     Py_XDECREF(tmp_type);
5839     Py_XDECREF(tmp_value);
5840     Py_XDECREF(tmp_tb);
5841 }
5842 """)
5843
5844 #------------------------------------------------------------------------------------
5845
5846 arg_type_test_utility_code = UtilityCode(
5847 proto = """
5848 static int __Pyx_ArgTypeTest(PyObject *obj, PyTypeObject *type, int none_allowed,
5849     const char *name, int exact); /*proto*/
5850 """,
5851 impl = """
5852 static int __Pyx_ArgTypeTest(PyObject *obj, PyTypeObject *type, int none_allowed,
5853     const char *name, int exact)
5854 {
5855     if (!type) {
5856         PyErr_Format(PyExc_SystemError, "Missing type object");
5857         return 0;
5858     }
5859     if (none_allowed && obj == Py_None) return 1;
5860     else if (exact) {
5861         if (Py_TYPE(obj) == type) return 1;
5862     }
5863     else {
5864         if (PyObject_TypeCheck(obj, type)) return 1;
5865     }
5866     PyErr_Format(PyExc_TypeError,
5867         "Argument '%s' has incorrect type (expected %s, got %s)",
5868         name, type->tp_name, Py_TYPE(obj)->tp_name);
5869     return 0;
5870 }
5871 """)
5872
5873 #------------------------------------------------------------------------------------
5874 #
5875 #  __Pyx_RaiseArgtupleInvalid raises the correct exception when too
5876 #  many or too few positional arguments were found.  This handles
5877 #  Py_ssize_t formatting correctly.
5878
5879 raise_argtuple_invalid_utility_code = UtilityCode(
5880 proto = """
5881 static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact,
5882     Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found); /*proto*/
5883 """,
5884 impl = """
5885 static void __Pyx_RaiseArgtupleInvalid(
5886     const char* func_name,
5887     int exact,
5888     Py_ssize_t num_min,
5889     Py_ssize_t num_max,
5890     Py_ssize_t num_found)
5891 {
5892     Py_ssize_t num_expected;
5893     const char *number, *more_or_less;
5894
5895     if (num_found < num_min) {
5896         num_expected = num_min;
5897         more_or_less = "at least";
5898     } else {
5899         num_expected = num_max;
5900         more_or_less = "at most";
5901     }
5902     if (exact) {
5903         more_or_less = "exactly";
5904     }
5905     number = (num_expected == 1) ? "" : "s";
5906     PyErr_Format(PyExc_TypeError,
5907         #if PY_VERSION_HEX < 0x02050000
5908             "%s() takes %s %d positional argument%s (%d given)",
5909         #else
5910             "%s() takes %s %zd positional argument%s (%zd given)",
5911         #endif
5912         func_name, more_or_less, num_expected, number, num_found);
5913 }
5914 """)
5915
5916 raise_keyword_required_utility_code = UtilityCode(
5917 proto = """
5918 static CYTHON_INLINE void __Pyx_RaiseKeywordRequired(const char* func_name, PyObject* kw_name); /*proto*/
5919 """,
5920 impl = """
5921 static CYTHON_INLINE void __Pyx_RaiseKeywordRequired(
5922     const char* func_name,
5923     PyObject* kw_name)
5924 {
5925     PyErr_Format(PyExc_TypeError,
5926         #if PY_MAJOR_VERSION >= 3
5927         "%s() needs keyword-only argument %U", func_name, kw_name);
5928         #else
5929         "%s() needs keyword-only argument %s", func_name,
5930         PyString_AS_STRING(kw_name));
5931         #endif
5932 }
5933 """)
5934
5935 raise_double_keywords_utility_code = UtilityCode(
5936 proto = """
5937 static void __Pyx_RaiseDoubleKeywordsError(
5938     const char* func_name, PyObject* kw_name); /*proto*/
5939 """,
5940 impl = """
5941 static void __Pyx_RaiseDoubleKeywordsError(
5942     const char* func_name,
5943     PyObject* kw_name)
5944 {
5945     PyErr_Format(PyExc_TypeError,
5946         #if PY_MAJOR_VERSION >= 3
5947         "%s() got multiple values for keyword argument '%U'", func_name, kw_name);
5948         #else
5949         "%s() got multiple values for keyword argument '%s'", func_name,
5950         PyString_AS_STRING(kw_name));
5951         #endif
5952 }
5953 """)
5954
5955 #------------------------------------------------------------------------------------
5956 #
5957 #  __Pyx_CheckKeywordStrings raises an error if non-string keywords
5958 #  were passed to a function, or if any keywords were passed to a
5959 #  function that does not accept them.
5960
5961 keyword_string_check_utility_code = UtilityCode(
5962 proto = """
5963 static CYTHON_INLINE int __Pyx_CheckKeywordStrings(PyObject *kwdict,
5964     const char* function_name, int kw_allowed); /*proto*/
5965 """,
5966 impl = """
5967 static CYTHON_INLINE int __Pyx_CheckKeywordStrings(
5968     PyObject *kwdict,
5969     const char* function_name,
5970     int kw_allowed)
5971 {
5972     PyObject* key = 0;
5973     Py_ssize_t pos = 0;
5974     while (PyDict_Next(kwdict, &pos, &key, 0)) {
5975         #if PY_MAJOR_VERSION < 3
5976         if (unlikely(!PyString_CheckExact(key)) && unlikely(!PyString_Check(key)))
5977         #else
5978         if (unlikely(!PyUnicode_CheckExact(key)) && unlikely(!PyUnicode_Check(key)))
5979         #endif
5980             goto invalid_keyword_type;
5981     }
5982     if ((!kw_allowed) && unlikely(key))
5983         goto invalid_keyword;
5984     return 1;
5985 invalid_keyword_type:
5986     PyErr_Format(PyExc_TypeError,
5987         "%s() keywords must be strings", function_name);
5988     return 0;
5989 invalid_keyword:
5990     PyErr_Format(PyExc_TypeError,
5991     #if PY_MAJOR_VERSION < 3
5992         "%s() got an unexpected keyword argument '%s'",
5993         function_name, PyString_AsString(key));
5994     #else
5995         "%s() got an unexpected keyword argument '%U'",
5996         function_name, key);
5997     #endif
5998     return 0;
5999 }
6000 """)
6001
6002 #------------------------------------------------------------------------------------
6003 #
6004 #  __Pyx_ParseOptionalKeywords copies the optional/unknown keyword
6005 #  arguments from the kwds dict into kwds2.  If kwds2 is NULL, unknown
6006 #  keywords will raise an invalid keyword error.
6007 #
6008 #  Three kinds of errors are checked: 1) non-string keywords, 2)
6009 #  unexpected keywords and 3) overlap with positional arguments.
6010 #
6011 #  If num_posargs is greater 0, it denotes the number of positional
6012 #  arguments that were passed and that must therefore not appear
6013 #  amongst the keywords as well.
6014 #
6015 #  This method does not check for required keyword arguments.
6016 #
6017
6018 parse_keywords_utility_code = UtilityCode(
6019 proto = """
6020 static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject **argnames[], \
6021     PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args, \
6022     const char* function_name); /*proto*/
6023 """,
6024 impl = """
6025 static int __Pyx_ParseOptionalKeywords(
6026     PyObject *kwds,
6027     PyObject **argnames[],
6028     PyObject *kwds2,
6029     PyObject *values[],
6030     Py_ssize_t num_pos_args,
6031     const char* function_name)
6032 {
6033     PyObject *key = 0, *value = 0;
6034     Py_ssize_t pos = 0;
6035     PyObject*** name;
6036     PyObject*** first_kw_arg = argnames + num_pos_args;
6037
6038     while (PyDict_Next(kwds, &pos, &key, &value)) {
6039         name = first_kw_arg;
6040         while (*name && (**name != key)) name++;
6041         if (*name) {
6042             values[name-argnames] = value;
6043         } else {
6044             #if PY_MAJOR_VERSION < 3
6045             if (unlikely(!PyString_CheckExact(key)) && unlikely(!PyString_Check(key))) {
6046             #else
6047             if (unlikely(!PyUnicode_CheckExact(key)) && unlikely(!PyUnicode_Check(key))) {
6048             #endif
6049                 goto invalid_keyword_type;
6050             } else {
6051                 for (name = first_kw_arg; *name; name++) {
6052                     #if PY_MAJOR_VERSION >= 3
6053                     if (PyUnicode_GET_SIZE(**name) == PyUnicode_GET_SIZE(key) &&
6054                         PyUnicode_Compare(**name, key) == 0) break;
6055                     #else
6056                     if (PyString_GET_SIZE(**name) == PyString_GET_SIZE(key) &&
6057                         _PyString_Eq(**name, key)) break;
6058                     #endif
6059                 }
6060                 if (*name) {
6061                     values[name-argnames] = value;
6062                 } else {
6063                     /* unexpected keyword found */
6064                     for (name=argnames; name != first_kw_arg; name++) {
6065                         if (**name == key) goto arg_passed_twice;
6066                         #if PY_MAJOR_VERSION >= 3
6067                         if (PyUnicode_GET_SIZE(**name) == PyUnicode_GET_SIZE(key) &&
6068                             PyUnicode_Compare(**name, key) == 0) goto arg_passed_twice;
6069                         #else
6070                         if (PyString_GET_SIZE(**name) == PyString_GET_SIZE(key) &&
6071                             _PyString_Eq(**name, key)) goto arg_passed_twice;
6072                         #endif
6073                     }
6074                     if (kwds2) {
6075                         if (unlikely(PyDict_SetItem(kwds2, key, value))) goto bad;
6076                     } else {
6077                         goto invalid_keyword;
6078                     }
6079                 }
6080             }
6081         }
6082     }
6083     return 0;
6084 arg_passed_twice:
6085     __Pyx_RaiseDoubleKeywordsError(function_name, **name);
6086     goto bad;
6087 invalid_keyword_type:
6088     PyErr_Format(PyExc_TypeError,
6089         "%s() keywords must be strings", function_name);
6090     goto bad;
6091 invalid_keyword:
6092     PyErr_Format(PyExc_TypeError,
6093     #if PY_MAJOR_VERSION < 3
6094         "%s() got an unexpected keyword argument '%s'",
6095         function_name, PyString_AsString(key));
6096     #else
6097         "%s() got an unexpected keyword argument '%U'",
6098         function_name, key);
6099     #endif
6100 bad:
6101     return -1;
6102 }
6103 """)
6104
6105 #------------------------------------------------------------------------------------
6106
6107 traceback_utility_code = UtilityCode(
6108 proto = """
6109 static void __Pyx_AddTraceback(const char *funcname); /*proto*/
6110 """,
6111 impl = """
6112 #include "compile.h"
6113 #include "frameobject.h"
6114 #include "traceback.h"
6115
6116 static void __Pyx_AddTraceback(const char *funcname) {
6117     PyObject *py_srcfile = 0;
6118     PyObject *py_funcname = 0;
6119     PyObject *py_globals = 0;
6120     PyCodeObject *py_code = 0;
6121     PyFrameObject *py_frame = 0;
6122
6123     #if PY_MAJOR_VERSION < 3
6124     py_srcfile = PyString_FromString(%(FILENAME)s);
6125     #else
6126     py_srcfile = PyUnicode_FromString(%(FILENAME)s);
6127     #endif
6128     if (!py_srcfile) goto bad;
6129     if (%(CLINENO)s) {
6130         #if PY_MAJOR_VERSION < 3
6131         py_funcname = PyString_FromFormat( "%%s (%%s:%%d)", funcname, %(CFILENAME)s, %(CLINENO)s);
6132         #else
6133         py_funcname = PyUnicode_FromFormat( "%%s (%%s:%%d)", funcname, %(CFILENAME)s, %(CLINENO)s);
6134         #endif
6135     }
6136     else {
6137         #if PY_MAJOR_VERSION < 3
6138         py_funcname = PyString_FromString(funcname);
6139         #else
6140         py_funcname = PyUnicode_FromString(funcname);
6141         #endif
6142     }
6143     if (!py_funcname) goto bad;
6144     py_globals = PyModule_GetDict(%(GLOBALS)s);
6145     if (!py_globals) goto bad;
6146     py_code = PyCode_New(
6147         0,            /*int argcount,*/
6148         #if PY_MAJOR_VERSION >= 3
6149         0,            /*int kwonlyargcount,*/
6150         #endif
6151         0,            /*int nlocals,*/
6152         0,            /*int stacksize,*/
6153         0,            /*int flags,*/
6154         %(EMPTY_BYTES)s, /*PyObject *code,*/
6155         %(EMPTY_TUPLE)s,  /*PyObject *consts,*/
6156         %(EMPTY_TUPLE)s,  /*PyObject *names,*/
6157         %(EMPTY_TUPLE)s,  /*PyObject *varnames,*/
6158         %(EMPTY_TUPLE)s,  /*PyObject *freevars,*/
6159         %(EMPTY_TUPLE)s,  /*PyObject *cellvars,*/
6160         py_srcfile,   /*PyObject *filename,*/
6161         py_funcname,  /*PyObject *name,*/
6162         %(LINENO)s,   /*int firstlineno,*/
6163         %(EMPTY_BYTES)s  /*PyObject *lnotab*/
6164     );
6165     if (!py_code) goto bad;
6166     py_frame = PyFrame_New(
6167         PyThreadState_GET(), /*PyThreadState *tstate,*/
6168         py_code,             /*PyCodeObject *code,*/
6169         py_globals,          /*PyObject *globals,*/
6170         0                    /*PyObject *locals*/
6171     );
6172     if (!py_frame) goto bad;
6173     py_frame->f_lineno = %(LINENO)s;
6174     PyTraceBack_Here(py_frame);
6175 bad:
6176     Py_XDECREF(py_srcfile);
6177     Py_XDECREF(py_funcname);
6178     Py_XDECREF(py_code);
6179     Py_XDECREF(py_frame);
6180 }
6181 """ % {
6182     'FILENAME': Naming.filename_cname,
6183     'LINENO':  Naming.lineno_cname,
6184     'CFILENAME': Naming.cfilenm_cname,
6185     'CLINENO':  Naming.clineno_cname,
6186     'GLOBALS': Naming.module_cname,
6187     'EMPTY_TUPLE' : Naming.empty_tuple,
6188     'EMPTY_BYTES' : Naming.empty_bytes,
6189 })
6190
6191 #------------------------------------------------------------------------------------
6192
6193 unraisable_exception_utility_code = UtilityCode(
6194 proto = """
6195 static void __Pyx_WriteUnraisable(const char *name); /*proto*/
6196 """,
6197 impl = """
6198 static void __Pyx_WriteUnraisable(const char *name) {
6199     PyObject *old_exc, *old_val, *old_tb;
6200     PyObject *ctx;
6201     __Pyx_ErrFetch(&old_exc, &old_val, &old_tb);
6202     #if PY_MAJOR_VERSION < 3
6203     ctx = PyString_FromString(name);
6204     #else
6205     ctx = PyUnicode_FromString(name);
6206     #endif
6207     __Pyx_ErrRestore(old_exc, old_val, old_tb);
6208     if (!ctx) {
6209         PyErr_WriteUnraisable(Py_None);
6210     } else {
6211         PyErr_WriteUnraisable(ctx);
6212         Py_DECREF(ctx);
6213     }
6214 }
6215 """,
6216 requires=[restore_exception_utility_code])
6217
6218 #------------------------------------------------------------------------------------
6219
6220 set_vtable_utility_code = UtilityCode(
6221 proto = """
6222 static int __Pyx_SetVtable(PyObject *dict, void *vtable); /*proto*/
6223 """,
6224 impl = """
6225 static int __Pyx_SetVtable(PyObject *dict, void *vtable) {
6226 #if PY_VERSION_HEX >= 0x02070000 && !(PY_MAJOR_VERSION==3&&PY_MINOR_VERSION==0)
6227     PyObject *ob = PyCapsule_New(vtable, 0, 0);
6228 #else
6229     PyObject *ob = PyCObject_FromVoidPtr(vtable, 0);
6230 #endif
6231     if (!ob)
6232         goto bad;
6233     if (PyDict_SetItemString(dict, "__pyx_vtable__", ob) < 0)
6234         goto bad;
6235     Py_DECREF(ob);
6236     return 0;
6237 bad:
6238     Py_XDECREF(ob);
6239     return -1;
6240 }
6241 """)
6242
6243 #------------------------------------------------------------------------------------
6244
6245 get_vtable_utility_code = UtilityCode(
6246 proto = """
6247 static int __Pyx_GetVtable(PyObject *dict, void *vtabptr); /*proto*/
6248 """,
6249 impl = r"""
6250 static int __Pyx_GetVtable(PyObject *dict, void *vtabptr) {
6251     PyObject *ob = PyMapping_GetItemString(dict, (char *)"__pyx_vtable__");
6252     if (!ob)
6253         goto bad;
6254 #if PY_VERSION_HEX >= 0x02070000 && !(PY_MAJOR_VERSION==3&&PY_MINOR_VERSION==0)
6255     *(void **)vtabptr = PyCapsule_GetPointer(ob, 0);
6256 #else
6257     *(void **)vtabptr = PyCObject_AsVoidPtr(ob);
6258 #endif
6259     if (!*(void **)vtabptr)
6260         goto bad;
6261     Py_DECREF(ob);
6262     return 0;
6263 bad:
6264     Py_XDECREF(ob);
6265     return -1;
6266 }
6267 """)
6268
6269 #------------------------------------------------------------------------------------
6270
6271 init_string_tab_utility_code = UtilityCode(
6272 proto = """
6273 static int __Pyx_InitStrings(__Pyx_StringTabEntry *t); /*proto*/
6274 """,
6275 impl = """
6276 static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) {
6277     while (t->p) {
6278         #if PY_MAJOR_VERSION < 3
6279         if (t->is_unicode) {
6280             *t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL);
6281         } else if (t->intern) {
6282             *t->p = PyString_InternFromString(t->s);
6283         } else {
6284             *t->p = PyString_FromStringAndSize(t->s, t->n - 1);
6285         }
6286         #else  /* Python 3+ has unicode identifiers */
6287         if (t->is_unicode | t->is_str) {
6288             if (t->intern) {
6289                 *t->p = PyUnicode_InternFromString(t->s);
6290             } else if (t->encoding) {
6291                 *t->p = PyUnicode_Decode(t->s, t->n - 1, t->encoding, NULL);
6292             } else {
6293                 *t->p = PyUnicode_FromStringAndSize(t->s, t->n - 1);
6294             }
6295         } else {
6296             *t->p = PyBytes_FromStringAndSize(t->s, t->n - 1);
6297         }
6298         #endif
6299         if (!*t->p)
6300             return -1;
6301         ++t;
6302     }
6303     return 0;
6304 }
6305 """)
6306
6307 #------------------------------------------------------------------------------------
6308
6309 force_init_threads_utility_code = UtilityCode(
6310 proto="""
6311 #ifndef __PYX_FORCE_INIT_THREADS
6312   #if PY_VERSION_HEX < 0x02040200
6313     #define __PYX_FORCE_INIT_THREADS 1
6314   #else
6315     #define __PYX_FORCE_INIT_THREADS 0
6316   #endif
6317 #endif
6318 """)
6319
6320 #------------------------------------------------------------------------------------
6321
6322 # Note that cPython ignores PyTrace_EXCEPTION,
6323 # but maybe some other profilers don't.
6324
6325 profile_utility_code = UtilityCode(proto="""
6326 #ifndef CYTHON_PROFILE
6327   #define CYTHON_PROFILE 1
6328 #endif
6329
6330 #ifndef CYTHON_PROFILE_REUSE_FRAME
6331   #define CYTHON_PROFILE_REUSE_FRAME 0
6332 #endif
6333
6334 #if CYTHON_PROFILE
6335
6336   #include "compile.h"
6337   #include "frameobject.h"
6338   #include "traceback.h"
6339
6340   #if CYTHON_PROFILE_REUSE_FRAME
6341     #define CYTHON_FRAME_MODIFIER static
6342     #define CYTHON_FRAME_DEL
6343   #else
6344     #define CYTHON_FRAME_MODIFIER
6345     #define CYTHON_FRAME_DEL Py_DECREF(%(FRAME)s)
6346   #endif
6347
6348   #define __Pyx_TraceDeclarations                                  \\
6349   static PyCodeObject *%(FRAME_CODE)s = NULL;                      \\
6350   CYTHON_FRAME_MODIFIER PyFrameObject *%(FRAME)s = NULL;           \\
6351   int __Pyx_use_tracing = 0;
6352
6353   #define __Pyx_TraceCall(funcname, srcfile, firstlineno)                            \\
6354   if (unlikely(PyThreadState_GET()->use_tracing && PyThreadState_GET()->c_profilefunc)) {      \\
6355       __Pyx_use_tracing = __Pyx_TraceSetupAndCall(&%(FRAME_CODE)s, &%(FRAME)s, funcname, srcfile, firstlineno);  \\
6356   }
6357
6358   #define __Pyx_TraceException()                                                           \\
6359   if (unlikely(__Pyx_use_tracing( && PyThreadState_GET()->use_tracing && PyThreadState_GET()->c_profilefunc) {  \\
6360       PyObject *exc_info = __Pyx_GetExceptionTuple();                                      \\
6361       if (exc_info) {                                                                      \\
6362           PyThreadState_GET()->c_profilefunc(                                              \\
6363               PyThreadState_GET()->c_profileobj, %(FRAME)s, PyTrace_EXCEPTION, exc_info);  \\
6364           Py_DECREF(exc_info);                                                             \\
6365       }                                                                                    \\
6366   }
6367
6368   #define __Pyx_TraceReturn(result)                                                  \\
6369   if (unlikely(__Pyx_use_tracing) && PyThreadState_GET()->use_tracing && PyThreadState_GET()->c_profilefunc) {  \\
6370       PyThreadState_GET()->c_profilefunc(                                            \\
6371           PyThreadState_GET()->c_profileobj, %(FRAME)s, PyTrace_RETURN, (PyObject*)result);     \\
6372       CYTHON_FRAME_DEL;                                                               \\
6373   }
6374
6375   static PyCodeObject *__Pyx_createFrameCodeObject(const char *funcname, const char *srcfile, int firstlineno); /*proto*/
6376   static int __Pyx_TraceSetupAndCall(PyCodeObject** code, PyFrameObject** frame, const char *funcname, const char *srcfile, int firstlineno); /*proto*/
6377
6378 #else
6379
6380   #define __Pyx_TraceDeclarations
6381   #define __Pyx_TraceCall(funcname, srcfile, firstlineno)
6382   #define __Pyx_TraceException()
6383   #define __Pyx_TraceReturn(result)
6384
6385 #endif /* CYTHON_PROFILE */
6386 """
6387 % {
6388     "FRAME": Naming.frame_cname,
6389     "FRAME_CODE": Naming.frame_code_cname,
6390 },
6391 impl = """
6392
6393 #if CYTHON_PROFILE
6394
6395 static int __Pyx_TraceSetupAndCall(PyCodeObject** code,
6396                                    PyFrameObject** frame,
6397                                    const char *funcname,
6398                                    const char *srcfile,
6399                                    int firstlineno) {
6400     if (*frame == NULL || !CYTHON_PROFILE_REUSE_FRAME) {
6401         if (*code == NULL) {
6402             *code = __Pyx_createFrameCodeObject(funcname, srcfile, firstlineno);
6403             if (*code == NULL) return 0;
6404         }
6405         *frame = PyFrame_New(
6406             PyThreadState_GET(),            /*PyThreadState *tstate*/
6407             *code,                          /*PyCodeObject *code*/
6408             PyModule_GetDict(%(MODULE)s),      /*PyObject *globals*/
6409             0                               /*PyObject *locals*/
6410         );
6411         if (*frame == NULL) return 0;
6412     }
6413     else {
6414         (*frame)->f_tstate = PyThreadState_GET();
6415     }
6416     return PyThreadState_GET()->c_profilefunc(PyThreadState_GET()->c_profileobj, *frame, PyTrace_CALL, NULL) == 0;
6417 }
6418
6419 static PyCodeObject *__Pyx_createFrameCodeObject(const char *funcname, const char *srcfile, int firstlineno) {
6420     PyObject *py_srcfile = 0;
6421     PyObject *py_funcname = 0;
6422     PyCodeObject *py_code = 0;
6423
6424     #if PY_MAJOR_VERSION < 3
6425     py_funcname = PyString_FromString(funcname);
6426     py_srcfile = PyString_FromString(srcfile);
6427     #else
6428     py_funcname = PyUnicode_FromString(funcname);
6429     py_srcfile = PyUnicode_FromString(srcfile);
6430     #endif
6431     if (!py_funcname | !py_srcfile) goto bad;
6432
6433     py_code = PyCode_New(
6434         0,                /*int argcount,*/
6435         #if PY_MAJOR_VERSION >= 3
6436         0,                /*int kwonlyargcount,*/
6437         #endif
6438         0,                /*int nlocals,*/
6439         0,                /*int stacksize,*/
6440         0,                /*int flags,*/
6441         %(EMPTY_BYTES)s,  /*PyObject *code,*/
6442         %(EMPTY_TUPLE)s,  /*PyObject *consts,*/
6443         %(EMPTY_TUPLE)s,  /*PyObject *names,*/
6444         %(EMPTY_TUPLE)s,  /*PyObject *varnames,*/
6445         %(EMPTY_TUPLE)s,  /*PyObject *freevars,*/
6446         %(EMPTY_TUPLE)s,  /*PyObject *cellvars,*/
6447         py_srcfile,       /*PyObject *filename,*/
6448         py_funcname,      /*PyObject *name,*/
6449         firstlineno,      /*int firstlineno,*/
6450         %(EMPTY_BYTES)s   /*PyObject *lnotab*/
6451     );
6452
6453 bad:
6454     Py_XDECREF(py_srcfile);
6455     Py_XDECREF(py_funcname);
6456
6457     return py_code;
6458 }
6459
6460 #endif /* CYTHON_PROFILE */
6461 """ % {
6462     'EMPTY_TUPLE' : Naming.empty_tuple,
6463     'EMPTY_BYTES' : Naming.empty_bytes,
6464     "MODULE": Naming.module_cname,
6465 })