ExprNodes.py 369 KB
Newer Older
William Stein's avatar
William Stein committed
1
#
2
#   Parse tree nodes for expressions
William Stein's avatar
William Stein committed
3 4
#

5 6
import cython
cython.declare(error=object, warning=object, warn_once=object, InternalError=object,
7 8
               CompileError=object, UtilityCode=object, TempitaUtilityCode=object,
               StringEncoding=object, operator=object,
9 10 11 12 13 14
               Naming=object, Nodes=object, PyrexTypes=object, py_object_type=object,
               list_type=object, tuple_type=object, set_type=object, dict_type=object, \
               unicode_type=object, str_type=object, bytes_type=object, type_type=object,
               Builtin=object, Symtab=object, Utils=object, find_coercion_error=object,
               debug_disposal_code=object, debug_temp_alloc=object, debug_coercion=object)

15
import sys
16
import operator
William Stein's avatar
William Stein committed
17

18
from Errors import error, warning, warn_once, InternalError, CompileError
19
from Errors import hold_errors, release_errors, held_errors, report_error
20
from Code import UtilityCode, TempitaUtilityCode
21
import StringEncoding
William Stein's avatar
William Stein committed
22
import Naming
Robert Bradshaw's avatar
Robert Bradshaw committed
23
import Nodes
William Stein's avatar
William Stein committed
24 25
from Nodes import Node
import PyrexTypes
26
from PyrexTypes import py_object_type, c_long_type, typecast, error_type, \
27
     unspecified_type, cython_memoryview_ptr_type
28
import TypeSlots
29 30
from Builtin import list_type, tuple_type, set_type, dict_type, \
     unicode_type, str_type, bytes_type, type_type
31
import Builtin
William Stein's avatar
William Stein committed
32 33
import Symtab
import Options
34
from Cython import Utils
35
from Annotate import AnnotationItem
William Stein's avatar
William Stein committed
36

William Stein's avatar
William Stein committed
37
from Cython.Debugging import print_call_chain
William Stein's avatar
William Stein committed
38 39 40
from DebugFlags import debug_disposal_code, debug_temp_alloc, \
    debug_coercion

41 42 43 44 45
try:
    from __builtin__ import basestring
except ImportError:
    basestring = str # Python 3

Stefan Behnel's avatar
Stefan Behnel committed
46
class NotConstant(object):
47 48 49 50 51 52 53 54
    _obj = None

    def __new__(cls):
        if NotConstant._obj is None:
            NotConstant._obj = super(NotConstant, cls).__new__(cls)

        return NotConstant._obj

Stefan Behnel's avatar
Stefan Behnel committed
55 56 57
    def __repr__(self):
        return "<NOT CONSTANT>"

58
not_a_constant = NotConstant()
59
constant_value_not_set = object()
60

61 62 63 64 65 66 67 68 69 70
# error messages when coercing from key[0] to key[1]
find_coercion_error = {
    # string related errors
    (Builtin.unicode_type, Builtin.bytes_type) : "Cannot convert Unicode string to 'bytes' implicitly, encoding required.",
    (Builtin.unicode_type, Builtin.str_type)   : "Cannot convert Unicode string to 'str' implicitly. This is not portable and requires explicit encoding.",
    (Builtin.unicode_type, PyrexTypes.c_char_ptr_type) : "Unicode objects do not support coercion to C types.",
    (Builtin.bytes_type, Builtin.unicode_type) : "Cannot convert 'bytes' object to unicode implicitly, decoding required",
    (Builtin.bytes_type, Builtin.str_type) : "Cannot convert 'bytes' object to str implicitly. This is not portable to Py3.",
    (Builtin.str_type, Builtin.unicode_type) : "str objects do not support coercion to unicode, use a unicode string literal instead (u'')",
    (Builtin.str_type, Builtin.bytes_type) : "Cannot convert 'str' to 'bytes' implicitly. This is not portable.",
71
    (Builtin.str_type, PyrexTypes.c_char_ptr_type) : "'str' objects do not support coercion to C types (use 'bytes'?).",
72 73 74 75 76
    (PyrexTypes.c_char_ptr_type, Builtin.unicode_type) : "Cannot convert 'char*' to unicode implicitly, decoding required",
    (PyrexTypes.c_uchar_ptr_type, Builtin.unicode_type) : "Cannot convert 'char*' to unicode implicitly, decoding required",
    }.get


William Stein's avatar
William Stein committed
77 78 79 80 81 82
class ExprNode(Node):
    #  subexprs     [string]     Class var holding names of subexpr node attrs
    #  type         PyrexType    Type of the result
    #  result_code  string       Code fragment
    #  result_ctype string       C type of result_code if different from type
    #  is_temp      boolean      Result is in a temporary variable
83
    #  is_sequence_constructor
William Stein's avatar
William Stein committed
84
    #               boolean      Is a list or tuple constructor expression
85
    #  is_starred   boolean      Is a starred expression (e.g. '*a')
William Stein's avatar
William Stein committed
86 87 88
    #  saved_subexpr_nodes
    #               [ExprNode or [ExprNode or None] or None]
    #                            Cached result of subexpr_nodes()
89
    #  use_managed_ref boolean   use ref-counted temps/assignments/etc.
90 91 92
    #  result_is_used  boolean   indicates that the result will be dropped and the
    #                            result_code/temp_result can safely be set to None

William Stein's avatar
William Stein committed
93
    result_ctype = None
94
    type = None
95 96
    temp_code = None
    old_temp = None # error checker for multiple frees etc.
97
    use_managed_ref = True # can be set by optimisation transforms
98
    result_is_used = True
William Stein's avatar
William Stein committed
99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125

    #  The Analyse Expressions phase for expressions is split
    #  into two sub-phases:
    #
    #    Analyse Types
    #      Determines the result type of the expression based
    #      on the types of its sub-expressions, and inserts
    #      coercion nodes into the expression tree where needed.
    #      Marks nodes which will need to have temporary variables
    #      allocated.
    #
    #    Allocate Temps
    #      Allocates temporary variables where needed, and fills
    #      in the result_code field of each node.
    #
    #  ExprNode provides some convenience routines which
    #  perform both of the above phases. These should only
    #  be called from statement nodes, and only when no
    #  coercion nodes need to be added around the expression
    #  being analysed. In that case, the above two phases
    #  should be invoked separately.
    #
    #  Framework code in ExprNode provides much of the common
    #  processing for the various phases. It makes use of the
    #  'subexprs' class attribute of ExprNodes, which should
    #  contain a list of the names of attributes which can
    #  hold sub-nodes or sequences of sub-nodes.
126 127
    #
    #  The framework makes use of a number of abstract methods.
William Stein's avatar
William Stein committed
128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149
    #  Their responsibilities are as follows.
    #
    #    Declaration Analysis phase
    #
    #      analyse_target_declaration
    #        Called during the Analyse Declarations phase to analyse
    #        the LHS of an assignment or argument of a del statement.
    #        Nodes which cannot be the LHS of an assignment need not
    #        implement it.
    #
    #    Expression Analysis phase
    #
    #      analyse_types
    #        - Call analyse_types on all sub-expressions.
    #        - Check operand types, and wrap coercion nodes around
    #          sub-expressions where needed.
    #        - Set the type of this node.
    #        - If a temporary variable will be required for the
    #          result, set the is_temp flag of this node.
    #
    #      analyse_target_types
    #        Called during the Analyse Types phase to analyse
150
    #        the LHS of an assignment or argument of a del
William Stein's avatar
William Stein committed
151 152
    #        statement. Similar responsibilities to analyse_types.
    #
153 154 155 156
    #      target_code
    #        Called by the default implementation of allocate_target_temps.
    #        Should return a C lvalue for assigning to the node. The default
    #        implementation calls calculate_result_code.
William Stein's avatar
William Stein committed
157 158 159 160
    #
    #      check_const
    #        - Check that this node and its subnodes form a
    #          legal constant expression. If so, do nothing,
161
    #          otherwise call not_const.
William Stein's avatar
William Stein committed
162
    #
163
    #        The default implementation of check_const
William Stein's avatar
William Stein committed
164 165 166 167 168 169 170 171
    #        assumes that the expression is not constant.
    #
    #      check_const_addr
    #        - Same as check_const, except check that the
    #          expression is a C lvalue whose address is
    #          constant. Otherwise, call addr_not_const.
    #
    #        The default implementation of calc_const_addr
172
    #        assumes that the expression is not a constant
William Stein's avatar
William Stein committed
173 174 175 176 177 178 179 180 181 182 183 184
    #        lvalue.
    #
    #   Code Generation phase
    #
    #      generate_evaluation_code
    #        - Call generate_evaluation_code for sub-expressions.
    #        - Perform the functions of generate_result_code
    #          (see below).
    #        - If result is temporary, call generate_disposal_code
    #          on all sub-expressions.
    #
    #        A default implementation of generate_evaluation_code
185
    #        is provided which uses the following abstract methods:
William Stein's avatar
William Stein committed
186 187 188 189 190 191
    #
    #          generate_result_code
    #            - Generate any C statements necessary to calculate
    #              the result of this node from the results of its
    #              sub-expressions.
    #
192
    #          calculate_result_code
193 194
    #            - Should return a C code fragment evaluating to the
    #              result. This is only called when the result is not
195 196
    #              a temporary.
    #
William Stein's avatar
William Stein committed
197 198 199 200 201 202 203 204 205 206 207 208 209 210 211
    #      generate_assignment_code
    #        Called on the LHS of an assignment.
    #        - Call generate_evaluation_code for sub-expressions.
    #        - Generate code to perform the assignment.
    #        - If the assignment absorbed a reference, call
    #          generate_post_assignment_code on the RHS,
    #          otherwise call generate_disposal_code on it.
    #
    #      generate_deletion_code
    #        Called on an argument of a del statement.
    #        - Call generate_evaluation_code for sub-expressions.
    #        - Generate code to perform the deletion.
    #        - Call generate_disposal_code on all sub-expressions.
    #
    #
212

William Stein's avatar
William Stein committed
213
    is_sequence_constructor = 0
214
    is_string_literal = 0
William Stein's avatar
William Stein committed
215
    is_attribute = 0
216

William Stein's avatar
William Stein committed
217 218
    saved_subexpr_nodes = None
    is_temp = 0
219
    is_target = 0
220
    is_starred = 0
William Stein's avatar
William Stein committed
221

222 223
    constant_result = constant_value_not_set

224 225 226
    # whether this node with a memoryview type should be broadcast
    memslice_broadcast = False

227 228 229 230
    try:
        _get_child_attrs = operator.attrgetter('subexprs')
    except AttributeError:
        # Python 2.3
231
        def __get_child_attrs(self):
232
            return self.subexprs
233
        _get_child_attrs = __get_child_attrs
234
    child_attrs = property(fget=_get_child_attrs)
235

William Stein's avatar
William Stein committed
236 237 238 239
    def not_implemented(self, method_name):
        print_call_chain(method_name, "not implemented") ###
        raise InternalError(
            "%s.%s not implemented" %
Dag Sverre Seljebotn's avatar
Merge  
Dag Sverre Seljebotn committed
240
                (self.__class__.__name__, method_name))
241

William Stein's avatar
William Stein committed
242 243
    def is_lvalue(self):
        return 0
244

245 246 247
    def is_addressable(self):
        return self.is_lvalue()

William Stein's avatar
William Stein committed
248 249 250 251 252 253 254 255 256 257 258
    def is_ephemeral(self):
        #  An ephemeral node is one whose result is in
        #  a Python temporary and we suspect there are no
        #  other references to it. Certain operations are
        #  disallowed on such values, since they are
        #  likely to result in a dangling pointer.
        return self.type.is_pyobject and self.is_temp

    def subexpr_nodes(self):
        #  Extract a list of subexpression nodes based
        #  on the contents of the subexprs class attribute.
259 260 261
        nodes = []
        for name in self.subexprs:
            item = getattr(self, name)
Stefan Behnel's avatar
Stefan Behnel committed
262 263
            if item is not None:
                if type(item) is list:
264
                    nodes.extend(item)
Stefan Behnel's avatar
Stefan Behnel committed
265 266
                else:
                    nodes.append(item)
267
        return nodes
268

269
    def result(self):
270 271 272
        if self.is_temp:
            return self.temp_code
        else:
273
            return self.calculate_result_code()
274

William Stein's avatar
William Stein committed
275 276
    def result_as(self, type = None):
        #  Return the result code cast to the specified C type.
277
        return typecast(type, self.ctype(), self.result())
278

William Stein's avatar
William Stein committed
279 280 281
    def py_result(self):
        #  Return the result code cast to PyObject *.
        return self.result_as(py_object_type)
282

William Stein's avatar
William Stein committed
283 284 285 286
    def ctype(self):
        #  Return the native C type of the result (i.e. the
        #  C type of the result_code expression).
        return self.result_ctype or self.type
287

288
    def get_constant_c_result_code(self):
289
        # Return the constant value of this node as a result code
290 291 292 293 294 295 296
        # string, or None if the node is not constant.  This method
        # can be called when the constant result code is required
        # before the code generation phase.
        #
        # The return value is a string that can represent a simple C
        # value, a constant C name or a constant C expression.  If the
        # node type depends on Python code, this must return None.
297 298
        return None

299
    def calculate_constant_result(self):
300 301 302 303 304
        # Calculate the constant compile time result value of this
        # expression and store it in ``self.constant_result``.  Does
        # nothing by default, thus leaving ``self.constant_result``
        # unknown.  If valid, the result can be an arbitrary Python
        # value.
305 306 307 308 309 310
        #
        # This must only be called when it is assured that all
        # sub-expressions have a valid constant_result value.  The
        # ConstantFolding transform will do this.
        pass

311 312 313 314
    def has_constant_result(self):
        return self.constant_result is not constant_value_not_set and \
               self.constant_result is not not_a_constant

315 316 317
    def compile_time_value(self, denv):
        #  Return value of compile-time expression, or report error.
        error(self.pos, "Invalid compile-time expression")
318

319 320 321
    def compile_time_value_error(self, e):
        error(self.pos, "Error in compile-time expression: %s: %s" % (
            e.__class__.__name__, e))
322

William Stein's avatar
William Stein committed
323
    # ------------- Declaration Analysis ----------------
324

William Stein's avatar
William Stein committed
325 326
    def analyse_target_declaration(self, env):
        error(self.pos, "Cannot assign to or delete this")
327

William Stein's avatar
William Stein committed
328
    # ------------- Expression Analysis ----------------
329

William Stein's avatar
William Stein committed
330 331 332 333 334 335
    def analyse_const_expression(self, env):
        #  Called during the analyse_declarations phase of a
        #  constant expression. Analyses the expression's type,
        #  checks whether it is a legal const expression,
        #  and determines its value.
        self.analyse_types(env)
336
        return self.check_const()
337

William Stein's avatar
William Stein committed
338 339
    def analyse_expressions(self, env):
        #  Convenience routine performing both the Type
340
        #  Analysis and Temp Allocation phases for a whole
William Stein's avatar
William Stein committed
341 342
        #  expression.
        self.analyse_types(env)
343

344
    def analyse_target_expression(self, env, rhs):
William Stein's avatar
William Stein committed
345 346 347 348
        #  Convenience routine performing both the Type
        #  Analysis and Temp Allocation phases for the LHS of
        #  an assignment.
        self.analyse_target_types(env)
349

William Stein's avatar
William Stein committed
350 351 352 353 354
    def analyse_boolean_expression(self, env):
        #  Analyse expression and coerce to a boolean.
        self.analyse_types(env)
        bool = self.coerce_to_boolean(env)
        return bool
355

William Stein's avatar
William Stein committed
356 357 358 359 360 361 362 363 364
    def analyse_temp_boolean_expression(self, env):
        #  Analyse boolean expression and coerce result into
        #  a temporary. This is used when a branch is to be
        #  performed on the result and we won't have an
        #  opportunity to ensure disposal code is executed
        #  afterwards. By forcing the result into a temporary,
        #  we ensure that all disposal has been done by the
        #  time we get the result.
        self.analyse_types(env)
Stefan Behnel's avatar
Stefan Behnel committed
365 366
        return self.coerce_to_boolean(env).coerce_to_simple(env)

367
    # --------------- Type Inference -----------------
368

Robert Bradshaw's avatar
Robert Bradshaw committed
369
    def type_dependencies(self, env):
370 371 372 373
        # Returns the list of entries whose types must be determined
        # before the type of self can be infered.
        if hasattr(self, 'type') and self.type is not None:
            return ()
Robert Bradshaw's avatar
Robert Bradshaw committed
374
        return sum([node.type_dependencies(env) for node in self.subexpr_nodes()], ())
375

376
    def infer_type(self, env):
377 378
        # Attempt to deduce the type of self.
        # Differs from analyse_types as it avoids unnecessary
379 380 381 382 383 384 385 386
        # analysis of subexpressions, but can assume everything
        # in self.type_dependencies() has been resolved.
        if hasattr(self, 'type') and self.type is not None:
            return self.type
        elif hasattr(self, 'entry') and self.entry is not None:
            return self.entry.type
        else:
            self.not_implemented("infer_type")
387

388 389 390
    def nonlocally_immutable(self):
        # Returns whether this variable is a safe reference, i.e.
        # can't be modified as part of globals or closures.
391
        return self.is_temp or self.type.is_array or self.type.is_cfunction
392

William Stein's avatar
William Stein committed
393
    # --------------- Type Analysis ------------------
394

William Stein's avatar
William Stein committed
395 396 397 398
    def analyse_as_module(self, env):
        # If this node can be interpreted as a reference to a
        # cimported module, return its scope, else None.
        return None
399

400 401 402 403
    def analyse_as_type(self, env):
        # If this node can be interpreted as a reference to a
        # type, return that type, else None.
        return None
404

William Stein's avatar
William Stein committed
405 406 407 408
    def analyse_as_extension_type(self, env):
        # If this node can be interpreted as a reference to an
        # extension type, return its type, else None.
        return None
409

William Stein's avatar
William Stein committed
410 411
    def analyse_types(self, env):
        self.not_implemented("analyse_types")
412

William Stein's avatar
William Stein committed
413 414
    def analyse_target_types(self, env):
        self.analyse_types(env)
415

416
    def nogil_check(self, env):
417 418 419
        # By default, any expression based on Python objects is
        # prevented in nogil environments.  Subtypes must override
        # this if they can work without the GIL.
420
        if self.type and self.type.is_pyobject:
421
            self.gil_error()
422

423 424 425 426
    def gil_assignment_check(self, env):
        if env.nogil and self.type.is_pyobject:
            error(self.pos, "Assignment of Python object not allowed without gil")

William Stein's avatar
William Stein committed
427 428
    def check_const(self):
        self.not_const()
429
        return False
430

William Stein's avatar
William Stein committed
431 432
    def not_const(self):
        error(self.pos, "Not allowed in a constant expression")
433

William Stein's avatar
William Stein committed
434 435
    def check_const_addr(self):
        self.addr_not_const()
436
        return False
437

William Stein's avatar
William Stein committed
438 439
    def addr_not_const(self):
        error(self.pos, "Address is not constant")
440

William Stein's avatar
William Stein committed
441
    # ----------------- Result Allocation -----------------
442

William Stein's avatar
William Stein committed
443 444 445 446 447 448
    def result_in_temp(self):
        #  Return true if result is in a temporary owned by
        #  this node or one of its subexpressions. Overridden
        #  by certain nodes which can share the result of
        #  a subnode.
        return self.is_temp
449

William Stein's avatar
William Stein committed
450 451 452
    def target_code(self):
        #  Return code fragment for use as LHS of a C assignment.
        return self.calculate_result_code()
453

William Stein's avatar
William Stein committed
454 455
    def calculate_result_code(self):
        self.not_implemented("calculate_result_code")
456

Robert Bradshaw's avatar
Robert Bradshaw committed
457 458 459
#    def release_target_temp(self, env):
#        #  Release temporaries used by LHS of an assignment.
#        self.release_subexpr_temps(env)
William Stein's avatar
William Stein committed
460

461 462
    def allocate_temp_result(self, code):
        if self.temp_code:
463
            raise RuntimeError("Temp allocated multiple times in %r: %r" % (self.__class__.__name__, self.pos))
464 465 466 467 468
        type = self.type
        if not type.is_void:
            if type.is_pyobject:
                type = PyrexTypes.py_object_type
            self.temp_code = code.funcstate.allocate_temp(
469
                type, manage_ref=self.use_managed_ref)
470 471 472 473 474
        else:
            self.temp_code = None

    def release_temp_result(self, code):
        if not self.temp_code:
475 476 477
            if not self.result_is_used:
                # not used anyway, so ignore if not set up
                return
478 479 480 481 482 483 484 485 486 487
            if self.old_temp:
                raise RuntimeError("temp %s released multiple times in %s" % (
                        self.old_temp, self.__class__.__name__))
            else:
                raise RuntimeError("no temp, but release requested in %s" % (
                        self.__class__.__name__))
        code.funcstate.release_temp(self.temp_code)
        self.old_temp = self.temp_code
        self.temp_code = None

William Stein's avatar
William Stein committed
488
    # ---------------- Code Generation -----------------
489

William Stein's avatar
William Stein committed
490 491 492 493
    def make_owned_reference(self, code):
        #  If result is a pyobject, make sure we own
        #  a reference to it.
        if self.type.is_pyobject and not self.result_in_temp():
494
            code.put_incref(self.result(), self.ctype())
495

William Stein's avatar
William Stein committed
496
    def generate_evaluation_code(self, code):
497
        code.mark_pos(self.pos)
498

William Stein's avatar
William Stein committed
499 500 501 502
        #  Generate code to evaluate this node and
        #  its sub-expressions, and dispose of any
        #  temporary results of its sub-expressions.
        self.generate_subexpr_evaluation_code(code)
503 504 505 506

        if self.is_temp:
            self.allocate_temp_result(code)

William Stein's avatar
William Stein committed
507 508
        self.generate_result_code(code)
        if self.is_temp:
509 510
            # If we are temp we do not need to wait until this node is disposed
            # before disposing children.
William Stein's avatar
William Stein committed
511
            self.generate_subexpr_disposal_code(code)
512
            self.free_subexpr_temps(code)
513

William Stein's avatar
William Stein committed
514 515 516
    def generate_subexpr_evaluation_code(self, code):
        for node in self.subexpr_nodes():
            node.generate_evaluation_code(code)
517

William Stein's avatar
William Stein committed
518 519
    def generate_result_code(self, code):
        self.not_implemented("generate_result_code")
520

521 522
    def generate_disposal_code(self, code):
        if self.is_temp:
523 524 525 526 527 528
            if self.result():
                if self.type.is_pyobject:
                    code.put_decref_clear(self.result(), self.ctype())
                elif self.type.is_memoryviewslice:
                    code.put_xdecref_memoryviewslice(
                            self.result(), have_gil=not self.in_nogil_context)
William Stein's avatar
William Stein committed
529
        else:
530
            # Already done if self.is_temp
531
            self.generate_subexpr_disposal_code(code)
532

William Stein's avatar
William Stein committed
533 534 535 536 537
    def generate_subexpr_disposal_code(self, code):
        #  Generate code to dispose of temporary results
        #  of all sub-expressions.
        for node in self.subexpr_nodes():
            node.generate_disposal_code(code)
538

William Stein's avatar
William Stein committed
539 540 541
    def generate_post_assignment_code(self, code):
        if self.is_temp:
            if self.type.is_pyobject:
542
                code.putln("%s = 0;" % self.result())
543 544 545
            elif self.type.is_memoryviewslice:
                code.putln("%s.memview = NULL;" % self.result())
                code.putln("%s.data = NULL;" % self.result())
William Stein's avatar
William Stein committed
546 547
        else:
            self.generate_subexpr_disposal_code(code)
548

William Stein's avatar
William Stein committed
549 550
    def generate_assignment_code(self, rhs, code):
        #  Stub method for nodes which are not legal as
551
        #  the LHS of an assignment. An error will have
William Stein's avatar
William Stein committed
552 553
        #  been reported earlier.
        pass
554

William Stein's avatar
William Stein committed
555 556 557 558 559
    def generate_deletion_code(self, code):
        #  Stub method for nodes that are not legal as
        #  the argument of a del statement. An error
        #  will have been reported earlier.
        pass
560 561

    def free_temps(self, code):
562 563 564 565
        if self.is_temp:
            if not self.type.is_void:
                self.release_temp_result(code)
        else:
566
            self.free_subexpr_temps(code)
567

568 569 570 571
    def free_subexpr_temps(self, code):
        for sub in self.subexpr_nodes():
            sub.free_temps(code)

572 573 574
    def generate_function_definitions(self, env, code):
        pass

575
    # ---------------- Annotation ---------------------
576

577 578 579
    def annotate(self, code):
        for node in self.subexpr_nodes():
            node.annotate(code)
580

William Stein's avatar
William Stein committed
581
    # ----------------- Coercion ----------------------
582

William Stein's avatar
William Stein committed
583 584 585 586 587 588 589 590
    def coerce_to(self, dst_type, env):
        #   Coerce the result so that it can be assigned to
        #   something of type dst_type. If processing is necessary,
        #   wraps this node in a coercion node and returns that.
        #   Otherwise, returns this node unchanged.
        #
        #   This method is called during the analyse_expressions
        #   phase of the src_node's processing.
591 592 593 594 595 596 597 598
        #
        #   Note that subclasses that override this (especially
        #   ConstNodes) must not (re-)set their own .type attribute
        #   here.  Since expression nodes may turn up in different
        #   places in the tree (e.g. inside of CloneNodes in cascaded
        #   assignments), this method must return a new node instance
        #   if it changes the type.
        #
William Stein's avatar
William Stein committed
599 600 601 602
        src = self
        src_type = self.type
        src_is_py_type = src_type.is_pyobject
        dst_is_py_type = dst_type.is_pyobject
603

604 605 606
        if self.check_for_coercion_error(dst_type):
            return self

607
        if dst_type.is_reference and not src_type.is_reference:
608
            dst_type = dst_type.ref_base_type
609

610
        if src_type.is_fused or dst_type.is_fused:
611 612 613 614 615 616 617 618 619
            # See if we are coercing a fused function to a pointer to a
            # specialized function
            if (src_type.is_cfunction and not dst_type.is_fused and
                    dst_type.is_ptr and dst_type.base_type.is_cfunction):

                dst_type = dst_type.base_type

                for signature in src_type.get_all_specific_function_types():
                    if signature.same_as(dst_type):
Mark Florisson's avatar
Mark Florisson committed
620 621 622 623
                        src.type = signature
                        src.entry = src.type.entry
                        src.entry.used = True
                        return self
624

625 626 627 628 629
            if src_type.is_fused:
                error(self.pos, "Type is not specific")
            else:
                error(self.pos, "Cannot coerce to a type that is not specialized")

630 631 632
            self.type = error_type
            return self

633 634 635 636 637
        if self.coercion_type is not None:
            # This is purely for error checking purposes!
            node = NameNode(self.pos, name='', type=self.coercion_type)
            node.coerce_to(dst_type, env)

638
        if dst_type.is_memoryviewslice:
639
            import MemoryView
640
            if not src.type.is_memoryviewslice:
641 642
                if src.type.is_pyobject:
                    src = CoerceToMemViewSliceNode(src, dst_type, env)
643 644 645
                elif src.type.is_array:
                    src = CythonArrayNode.from_carray(src, env).coerce_to(
                                                            dst_type, env)
646
                elif not src_type.is_error:
647 648 649
                    error(self.pos,
                          "Cannot convert '%s' to memoryviewslice" %
                                                                (src_type,))
650 651
            elif not MemoryView.src_conforms_to_dst(
                        src.type, dst_type, broadcast=self.memslice_broadcast):
652 653 654 655 656 657 658 659
                if src.type.dtype.same_as(dst_type.dtype):
                    msg = "Memoryview '%s' not conformable to memoryview '%s'."
                    tup = src.type, dst_type
                else:
                    msg = "Different base types for memoryviews (%s, %s)"
                    tup = src.type.dtype, dst_type.dtype

                error(self.pos, msg % tup)
660

661
        elif dst_type.is_pyobject:
William Stein's avatar
William Stein committed
662
            if not src.type.is_pyobject:
663 664 665 666
                if dst_type is bytes_type and src.type.is_int:
                    src = CoerceIntToBytesNode(src, env)
                else:
                    src = CoerceToPyTypeNode(src, env)
William Stein's avatar
William Stein committed
667
            if not src.type.subtype_of(dst_type):
668 669
                if not isinstance(src, NoneNode):
                    src = PyTypeTestNode(src, dst_type, env)
William Stein's avatar
William Stein committed
670 671
        elif src.type.is_pyobject:
            src = CoerceFromPyTypeNode(dst_type, src, env)
672
        elif (dst_type.is_complex
673 674
              and src_type != dst_type
              and dst_type.assignable_from(src_type)):
675
            src = CoerceToComplexNode(src, dst_type, env)
William Stein's avatar
William Stein committed
676
        else: # neither src nor dst are py types
677
            # Added the string comparison, since for c types that
678
            # is enough, but Cython gets confused when the types are
679
            # in different pxi files.
680
            if not (str(src.type) == str(dst_type) or dst_type.assignable_from(src_type)):
681
                self.fail_assignment(dst_type)
William Stein's avatar
William Stein committed
682 683
        return src

684 685 686 687 688 689 690 691 692 693 694 695 696 697 698
    def fail_assignment(self, dst_type):
        error(self.pos, "Cannot assign type '%s' to '%s'" % (self.type, dst_type))

    def check_for_coercion_error(self, dst_type, fail=False, default=None):
        if fail and not default:
            default = "Cannot assign type '%(FROM)s' to '%(TO)s'"
        message = find_coercion_error((self.type, dst_type), default)
        if message is not None:
            error(self.pos, message % {'FROM': self.type, 'TO': dst_type})
            return True
        if fail:
            self.fail_assignment(dst_type)
            return True
        return False

William Stein's avatar
William Stein committed
699 700 701 702 703 704
    def coerce_to_pyobject(self, env):
        return self.coerce_to(PyrexTypes.py_object_type, env)

    def coerce_to_boolean(self, env):
        #  Coerce result to something acceptable as
        #  a boolean value.
705 706 707 708 709 710 711

        # if it's constant, calculate the result now
        if self.has_constant_result():
            bool_value = bool(self.constant_result)
            return BoolNode(self.pos, value=bool_value,
                            constant_result=bool_value)

William Stein's avatar
William Stein committed
712 713 714 715
        type = self.type
        if type.is_pyobject or type.is_ptr or type.is_float:
            return CoerceToBooleanNode(self, env)
        else:
716
            if not (type.is_int or type.is_enum or type.is_error):
717
                error(self.pos,
William Stein's avatar
William Stein committed
718 719
                    "Type '%s' not acceptable as a boolean" % type)
            return self
720

William Stein's avatar
William Stein committed
721 722 723 724 725 726
    def coerce_to_integer(self, env):
        # If not already some C integer type, coerce to longint.
        if self.type.is_int:
            return self
        else:
            return self.coerce_to(PyrexTypes.c_long_type, env)
727

William Stein's avatar
William Stein committed
728 729 730 731 732 733
    def coerce_to_temp(self, env):
        #  Ensure that the result is in a temporary.
        if self.result_in_temp():
            return self
        else:
            return CoerceToTempNode(self, env)
734

William Stein's avatar
William Stein committed
735 736 737 738 739 740
    def coerce_to_simple(self, env):
        #  Ensure that the result is simple (see is_simple).
        if self.is_simple():
            return self
        else:
            return self.coerce_to_temp(env)
741

William Stein's avatar
William Stein committed
742 743 744 745 746 747
    def is_simple(self):
        #  A node is simple if its result is something that can
        #  be referred to without performing any operations, e.g.
        #  a constant, local var, C global var, struct member
        #  reference, or temporary.
        return self.result_in_temp()
748 749

    def may_be_none(self):
750
        if self.type and not self.type.is_pyobject:
751 752 753 754
            return False
        if self.constant_result not in (not_a_constant, constant_value_not_set):
            return self.constant_result is not None
        return True
755

756
    def as_cython_attribute(self):
757
        return None
William Stein's avatar
William Stein committed
758

759
    def as_none_safe_node(self, message, error="PyExc_TypeError", format_args=()):
760 761 762
        # Wraps the node in a NoneCheckNode if it is not known to be
        # not-None (e.g. because it is a Python literal).
        if self.may_be_none():
763
            return NoneCheckNode(self, error, message, format_args)
764 765 766 767
        else:
            return self


William Stein's avatar
William Stein committed
768
class AtomicExprNode(ExprNode):
769 770
    #  Abstract base class for expression nodes which have
    #  no sub-expressions.
771

772 773 774
    subexprs = []

    # Override to optimize -- we know we have no children
775 776 777 778
    def generate_subexpr_evaluation_code(self, code):
        pass
    def generate_subexpr_disposal_code(self, code):
        pass
779

780
class PyConstNode(AtomicExprNode):
William Stein's avatar
William Stein committed
781
    #  Abstract base class for constant Python values.
782

783
    is_literal = 1
784
    type = py_object_type
785

William Stein's avatar
William Stein committed
786 787
    def is_simple(self):
        return 1
788 789 790 791

    def may_be_none(self):
        return False

William Stein's avatar
William Stein committed
792
    def analyse_types(self, env):
793
        pass
794

William Stein's avatar
William Stein committed
795 796 797 798 799 800 801 802 803
    def calculate_result_code(self):
        return self.value

    def generate_result_code(self, code):
        pass


class NoneNode(PyConstNode):
    #  The constant value None
804

805
    is_none = 1
William Stein's avatar
William Stein committed
806
    value = "Py_None"
807 808

    constant_result = None
809

810
    nogil_check = None
811

812 813
    def compile_time_value(self, denv):
        return None
814 815 816 817 818

    def may_be_none(self):
        return True


William Stein's avatar
William Stein committed
819 820
class EllipsisNode(PyConstNode):
    #  '...' in a subscript list.
821

William Stein's avatar
William Stein committed
822 823
    value = "Py_Ellipsis"

824 825
    constant_result = Ellipsis

826 827 828
    def compile_time_value(self, denv):
        return Ellipsis

William Stein's avatar
William Stein committed
829

830
class ConstNode(AtomicExprNode):
William Stein's avatar
William Stein committed
831 832 833
    # Abstract base type for literal constant nodes.
    #
    # value     string      C code fragment
834

William Stein's avatar
William Stein committed
835
    is_literal = 1
836
    nogil_check = None
837

William Stein's avatar
William Stein committed
838 839
    def is_simple(self):
        return 1
840

841 842 843
    def nonlocally_immutable(self):
        return 1

844 845 846
    def may_be_none(self):
        return False

William Stein's avatar
William Stein committed
847 848
    def analyse_types(self, env):
        pass # Types are held in class variables
849

William Stein's avatar
William Stein committed
850
    def check_const(self):
851
        return True
852

853
    def get_constant_c_result_code(self):
854 855
        return self.calculate_result_code()

William Stein's avatar
William Stein committed
856 857 858 859 860 861 862
    def calculate_result_code(self):
        return str(self.value)

    def generate_result_code(self, code):
        pass


863 864 865
class BoolNode(ConstNode):
    type = PyrexTypes.c_bint_type
    #  The constant value True or False
866 867 868 869

    def calculate_constant_result(self):
        self.constant_result = self.value

870 871
    def compile_time_value(self, denv):
        return self.value
872

873
    def calculate_result_code(self):
874
        return str(int(self.value))
875

876

William Stein's avatar
William Stein committed
877 878
class NullNode(ConstNode):
    type = PyrexTypes.c_null_ptr_type
879
    value = "NULL"
880
    constant_result = 0
William Stein's avatar
William Stein committed
881

882
    def get_constant_c_result_code(self):
883 884
        return self.value

William Stein's avatar
William Stein committed
885 886 887

class CharNode(ConstNode):
    type = PyrexTypes.c_char_type
888 889 890

    def calculate_constant_result(self):
        self.constant_result = ord(self.value)
891

892
    def compile_time_value(self, denv):
893
        return ord(self.value)
894

William Stein's avatar
William Stein committed
895
    def calculate_result_code(self):
896
        return "'%s'" % StringEncoding.escape_char(self.value)
William Stein's avatar
William Stein committed
897 898 899


class IntNode(ConstNode):
900 901 902

    # unsigned     "" or "U"
    # longness     "" or "L" or "LL"
903
    # is_c_literal   True/False/None   creator considers this a C integer literal
904 905 906

    unsigned = ""
    longness = ""
907
    is_c_literal = None # unknown
908 909 910

    def __init__(self, pos, **kwds):
        ExprNode.__init__(self, pos, **kwds)
Robert Bradshaw's avatar
Robert Bradshaw committed
911
        if 'type' not in kwds:
912 913 914 915 916 917 918 919
            self.type = self.find_suitable_type_for_value()

    def find_suitable_type_for_value(self):
        if self.constant_result is constant_value_not_set:
            try:
                self.calculate_constant_result()
            except ValueError:
                pass
920 921 922 923
        # we ignore 'is_c_literal = True' and instead map signed 32bit
        # integers as C long values
        if self.is_c_literal or \
               self.constant_result in (constant_value_not_set, not_a_constant) or \
924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939
               self.unsigned or self.longness == 'LL':
            # clearly a C literal
            rank = (self.longness == 'LL') and 2 or 1
            suitable_type = PyrexTypes.modifiers_and_name_to_type[not self.unsigned, rank, "int"]
            if self.type:
                suitable_type = PyrexTypes.widest_numeric_type(suitable_type, self.type)
        else:
            # C literal or Python literal - split at 32bit boundary
            if self.constant_result >= -2**31 and self.constant_result < 2**31:
                if self.type and self.type.is_int:
                    suitable_type = self.type
                else:
                    suitable_type = PyrexTypes.c_long_type
            else:
                suitable_type = PyrexTypes.py_object_type
        return suitable_type
William Stein's avatar
William Stein committed
940

941
    def coerce_to(self, dst_type, env):
942
        if self.type is dst_type:
943
            return self
944
        elif dst_type.is_float:
945
            if self.constant_result is not not_a_constant:
946 947
                return FloatNode(self.pos, value='%d.0' % int(self.constant_result), type=dst_type,
                                 constant_result=float(self.constant_result))
948 949 950
            else:
                return FloatNode(self.pos, value=self.value, type=dst_type,
                                 constant_result=not_a_constant)
951
        if dst_type.is_numeric and not dst_type.is_complex:
952
            node = IntNode(self.pos, value=self.value, constant_result=self.constant_result,
953 954
                           type = dst_type, is_c_literal = True,
                           unsigned=self.unsigned, longness=self.longness)
955
            return node
956 957
        elif dst_type.is_pyobject:
            node = IntNode(self.pos, value=self.value, constant_result=self.constant_result,
958 959
                           type = PyrexTypes.py_object_type, is_c_literal = False,
                           unsigned=self.unsigned, longness=self.longness)
960
        else:
961 962
            # FIXME: not setting the type here to keep it working with
            # complex numbers. Should they be special cased?
963 964
            node = IntNode(self.pos, value=self.value, constant_result=self.constant_result,
                           unsigned=self.unsigned, longness=self.longness)
965 966 967
        # We still need to perform normal coerce_to processing on the
        # result, because we might be coercing to an extension type,
        # in which case a type test node will be needed.
968 969
        return ConstNode.coerce_to(node, dst_type, env)

970
    def coerce_to_boolean(self, env):
971 972 973 974
        return IntNode(
            self.pos, value=self.value,
            type = PyrexTypes.c_bint_type,
            unsigned=self.unsigned, longness=self.longness)
975

976
    def generate_evaluation_code(self, code):
977
        if self.type.is_pyobject:
978
            # pre-allocate a Python version of the number
979 980
            plain_integer_string = self.value_as_c_integer_string(plain_digits=True)
            self.result_code = code.get_py_num(plain_integer_string, self.longness)
981
        else:
982
            self.result_code = self.get_constant_c_result_code()
983

984
    def get_constant_c_result_code(self):
985 986 987
        return self.value_as_c_integer_string() + self.unsigned + self.longness

    def value_as_c_integer_string(self, plain_digits=False):
988 989 990 991
        value = self.value
        if isinstance(value, basestring) and len(value) > 2:
            # must convert C-incompatible Py3 oct/bin notations
            if value[1] in 'oO':
992 993 994 995
                if plain_digits:
                    value = int(value[2:], 8)
                else:
                    value = value[0] + value[2:] # '0o123' => '0123'
996 997
            elif value[1] in 'bB':
                value = int(value[2:], 2)
998 999 1000
            elif plain_digits and value[1] in 'xX':
                value = int(value[2:], 16)
        return str(value)
1001 1002 1003

    def calculate_result_code(self):
        return self.result_code
William Stein's avatar
William Stein committed
1004

1005
    def calculate_constant_result(self):
1006
        self.constant_result = Utils.str_to_number(self.value)
1007

1008
    def compile_time_value(self, denv):
1009
        return Utils.str_to_number(self.value)
1010 1011


William Stein's avatar
William Stein committed
1012 1013 1014
class FloatNode(ConstNode):
    type = PyrexTypes.c_double_type

1015
    def calculate_constant_result(self):
1016
        self.constant_result = float(self.value)
1017

1018 1019
    def compile_time_value(self, denv):
        return float(self.value)
1020

Stefan Behnel's avatar
Stefan Behnel committed
1021
    def calculate_result_code(self):
1022 1023 1024 1025
        strval = self.value
        assert isinstance(strval, (str, unicode))
        cmpval = repr(float(strval))
        if cmpval == 'nan':
1026
            return "(Py_HUGE_VAL * 0)"
1027
        elif cmpval == 'inf':
1028
            return "Py_HUGE_VAL"
1029
        elif cmpval == '-inf':
1030
            return "(-Py_HUGE_VAL)"
Stefan Behnel's avatar
Stefan Behnel committed
1031 1032
        else:
            return strval
1033

William Stein's avatar
William Stein committed
1034

1035
class BytesNode(ConstNode):
1036 1037 1038 1039
    # A char* or bytes literal
    #
    # value      BytesLiteral

1040
    is_string_literal = True
1041 1042
    # start off as Python 'bytes' to support len() in O(1)
    type = bytes_type
1043 1044

    def compile_time_value(self, denv):
1045
        return self.value
1046

1047
    def analyse_as_type(self, env):
1048
        type = PyrexTypes.parse_basic_type(self.value)
1049
        if type is not None:
1050
            return type
1051 1052 1053 1054 1055 1056 1057
        from TreeFragment import TreeFragment
        pos = (self.pos[0], self.pos[1], self.pos[2]-7)
        declaration = TreeFragment(u"sizeof(%s)" % self.value, name=pos[0].filename, initial_pos=pos)
        sizeof_node = declaration.root.stats[0].expr
        sizeof_node.analyse_types(env)
        if isinstance(sizeof_node, SizeofTypeNode):
            return sizeof_node.arg_type
1058

1059 1060 1061
    def can_coerce_to_char_literal(self):
        return len(self.value) == 1

1062
    def coerce_to_boolean(self, env):
1063 1064
        # This is special because testing a C char* for truth directly
        # would yield the wrong result.
1065 1066
        bool_value = bool(self.value)
        return BoolNode(self.pos, value=bool_value, constant_result=bool_value)
1067

William Stein's avatar
William Stein committed
1068
    def coerce_to(self, dst_type, env):
1069 1070
        if self.type == dst_type:
            return self
1071
        if dst_type.is_int:
1072
            if not self.can_coerce_to_char_literal():
1073 1074
                error(self.pos, "Only single-character string literals can be coerced into ints.")
                return self
Stefan Behnel's avatar
Stefan Behnel committed
1075 1076
            if dst_type.is_unicode_char:
                error(self.pos, "Bytes literals cannot coerce to Py_UNICODE/Py_UCS4, use a unicode literal instead.")
1077
                return self
1078 1079
            return CharNode(self.pos, value=self.value)

1080
        node = BytesNode(self.pos, value=self.value)
1081 1082 1083 1084 1085 1086 1087 1088
        if dst_type.is_pyobject:
            if dst_type in (py_object_type, Builtin.bytes_type):
                node.type = Builtin.bytes_type
            else:
                self.check_for_coercion_error(dst_type, fail=True)
                return node
        elif dst_type == PyrexTypes.c_char_ptr_type:
            node.type = dst_type
1089 1090 1091 1092
            return node
        elif dst_type == PyrexTypes.c_uchar_ptr_type:
            node.type = PyrexTypes.c_char_ptr_type
            return CastNode(node, PyrexTypes.c_uchar_ptr_type)
1093 1094
        elif dst_type.assignable_from(PyrexTypes.c_char_ptr_type):
            node.type = dst_type
1095
            return node
1096

William Stein's avatar
William Stein committed
1097 1098 1099 1100 1101
        # We still need to perform normal coerce_to processing on the
        # result, because we might be coercing to an extension type,
        # in which case a type test node will be needed.
        return ConstNode.coerce_to(node, dst_type, env)

1102
    def generate_evaluation_code(self, code):
William Stein's avatar
William Stein committed
1103
        if self.type.is_pyobject:
1104
            self.result_code = code.get_py_string_const(self.value)
William Stein's avatar
William Stein committed
1105
        else:
1106
            self.result_code = code.get_string_const(self.value)
1107

1108
    def get_constant_c_result_code(self):
1109
        return None # FIXME
1110

1111 1112
    def calculate_result_code(self):
        return self.result_code
William Stein's avatar
William Stein committed
1113 1114


1115
class UnicodeNode(PyConstNode):
1116 1117
    # A Python unicode object
    #
1118 1119
    # value        EncodedString
    # bytes_value  BytesLiteral    the literal parsed as bytes string ('-3' unicode literals only)
Robert Bradshaw's avatar
Robert Bradshaw committed
1120

1121
    is_string_literal = True
1122
    bytes_value = None
1123
    type = unicode_type
1124

1125
    def coerce_to(self, dst_type, env):
1126 1127
        if dst_type is self.type:
            pass
Stefan Behnel's avatar
Stefan Behnel committed
1128
        elif dst_type.is_unicode_char:
1129
            if not self.can_coerce_to_char_literal():
Stefan Behnel's avatar
Stefan Behnel committed
1130
                error(self.pos, "Only single-character Unicode string literals or surrogate pairs can be coerced into Py_UCS4/Py_UNICODE.")
1131 1132
                return self
            int_value = ord(self.value)
Stefan Behnel's avatar
Stefan Behnel committed
1133
            return IntNode(self.pos, type=dst_type, value=str(int_value), constant_result=int_value)
1134
        elif not dst_type.is_pyobject:
1135 1136 1137
            if dst_type.is_string and self.bytes_value is not None:
                # special case: '-3' enforced unicode literal used in a C char* context
                return BytesNode(self.pos, value=self.bytes_value).coerce_to(dst_type, env)
Stefan Behnel's avatar
Stefan Behnel committed
1138
            error(self.pos, "Unicode literals do not support coercion to C types other than Py_UNICODE or Py_UCS4.")
1139 1140 1141 1142
        elif dst_type is not py_object_type:
            if not self.check_for_coercion_error(dst_type):
                self.fail_assignment(dst_type)
        return self
1143

1144 1145
    def can_coerce_to_char_literal(self):
        return len(self.value) == 1
Stefan Behnel's avatar
Stefan Behnel committed
1146 1147 1148
            ## or (len(self.value) == 2
            ##     and (0xD800 <= self.value[0] <= 0xDBFF)
            ##     and (0xDC00 <= self.value[1] <= 0xDFFF))
1149

1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166
    def contains_surrogates(self):
        # Check if the unicode string contains surrogate code points
        # on a CPython platform with wide (UCS-4) or narrow (UTF-16)
        # Unicode, i.e. characters that would be spelled as two
        # separate code units on a narrow platform.
        for c in map(ord, self.value):
            if c > 65535: # can only happen on wide platforms
                return True
            # We only look for the first code unit (D800-DBFF) of a
            # surrogate pair - if we find one, the other one
            # (DC00-DFFF) is likely there, too.  If we don't find it,
            # any second code unit cannot make for a surrogate pair by
            # itself.
            if c >= 0xD800 and c <= 0xDBFF:
                return True
        return False

1167
    def generate_evaluation_code(self, code):
1168
        self.result_code = code.get_py_string_const(self.value)
1169 1170 1171

    def calculate_result_code(self):
        return self.result_code
1172

1173 1174
    def compile_time_value(self, env):
        return self.value
1175 1176


1177 1178 1179 1180
class StringNode(PyConstNode):
    # A Python str object, i.e. a byte string in Python 2.x and a
    # unicode string in Python 3.x
    #
1181 1182
    # value          BytesLiteral (or EncodedString with ASCII content)
    # unicode_value  EncodedString or None
1183
    # is_identifier  boolean
1184

1185
    type = str_type
1186
    is_string_literal = True
1187
    is_identifier = None
1188
    unicode_value = None
1189

1190
    def coerce_to(self, dst_type, env):
1191
        if dst_type is not py_object_type and not str_type.subtype_of(dst_type):
1192 1193 1194 1195 1196
#            if dst_type is Builtin.bytes_type:
#                # special case: bytes = 'str literal'
#                return BytesNode(self.pos, value=self.value)
            if not dst_type.is_pyobject:
                return BytesNode(self.pos, value=self.value).coerce_to(dst_type, env)
1197
            self.check_for_coercion_error(dst_type, fail=True)
1198
        return self
1199

1200 1201
    def can_coerce_to_char_literal(self):
        return not self.is_identifier and len(self.value) == 1
1202

1203
    def generate_evaluation_code(self, code):
1204
        self.result_code = code.get_py_string_const(
1205 1206
            self.value, identifier=self.is_identifier, is_str=True,
            unicode_value=self.unicode_value)
1207

1208
    def get_constant_c_result_code(self):
1209 1210
        return None

1211
    def calculate_result_code(self):
1212
        return self.result_code
1213

1214 1215
    def compile_time_value(self, env):
        return self.value
1216 1217


1218 1219 1220 1221
class IdentifierStringNode(StringNode):
    # A special str value that represents an identifier (bytes in Py2,
    # unicode in Py3).
    is_identifier = True
1222 1223


1224
class LongNode(AtomicExprNode):
William Stein's avatar
William Stein committed
1225 1226 1227
    #  Python long integer literal
    #
    #  value   string
1228

1229 1230
    type = py_object_type

1231
    def calculate_constant_result(self):
1232
        self.constant_result = Utils.str_to_number(self.value)
1233

1234
    def compile_time_value(self, denv):
1235
        return Utils.str_to_number(self.value)
1236

William Stein's avatar
William Stein committed
1237 1238
    def analyse_types(self, env):
        self.is_temp = 1
1239

1240 1241 1242
    def may_be_none(self):
        return False

1243 1244
    gil_message = "Constructing Python long int"

1245
    def generate_result_code(self, code):
William Stein's avatar
William Stein committed
1246
        code.putln(
1247
            '%s = PyLong_FromString((char *)"%s", 0, 0); %s' % (
1248
                self.result(),
William Stein's avatar
William Stein committed
1249
                self.value,
1250
                code.error_goto_if_null(self.result(), self.pos)))
1251
        code.put_gotref(self.py_result())
William Stein's avatar
William Stein committed
1252 1253


1254
class ImagNode(AtomicExprNode):
William Stein's avatar
William Stein committed
1255 1256 1257
    #  Imaginary number literal
    #
    #  value   float    imaginary part
1258

1259
    type = PyrexTypes.c_double_complex_type
1260 1261 1262

    def calculate_constant_result(self):
        self.constant_result = complex(0.0, self.value)
1263

1264 1265
    def compile_time_value(self, denv):
        return complex(0.0, self.value)
1266

William Stein's avatar
William Stein committed
1267
    def analyse_types(self, env):
1268 1269
        self.type.create_declaration_utility_code(env)

1270 1271 1272
    def may_be_none(self):
        return False

1273
    def coerce_to(self, dst_type, env):
1274 1275 1276
        if self.type is dst_type:
            return self
        node = ImagNode(self.pos, value=self.value)
1277
        if dst_type.is_pyobject:
1278 1279
            node.is_temp = 1
            node.type = PyrexTypes.py_object_type
1280 1281 1282
        # We still need to perform normal coerce_to processing on the
        # result, because we might be coercing to an extension type,
        # in which case a type test node will be needed.
1283
        return AtomicExprNode.coerce_to(node, dst_type, env)
1284 1285 1286

    gil_message = "Constructing complex number"

1287 1288 1289 1290 1291 1292
    def calculate_result_code(self):
        if self.type.is_pyobject:
            return self.result()
        else:
            return "%s(0, %r)" % (self.type.from_parts, float(self.value))

1293
    def generate_result_code(self, code):
1294 1295 1296 1297 1298 1299 1300
        if self.type.is_pyobject:
            code.putln(
                "%s = PyComplex_FromDoubles(0.0, %r); %s" % (
                    self.result(),
                    float(self.value),
                    code.error_goto_if_null(self.result(), self.pos)))
            code.put_gotref(self.py_result())
1301

William Stein's avatar
William Stein committed
1302

Danilo Freitas's avatar
Danilo Freitas committed
1303
class NewExprNode(AtomicExprNode):
1304 1305 1306

    # C++ new statement
    #
Robert Bradshaw's avatar
Robert Bradshaw committed
1307
    # cppclass              node                 c++ class to create
1308

Robert Bradshaw's avatar
Robert Bradshaw committed
1309
    type = None
1310

1311
    def infer_type(self, env):
Robert Bradshaw's avatar
Robert Bradshaw committed
1312 1313
        type = self.cppclass.analyse_as_type(env)
        if type is None or not type.is_cpp_class:
Danilo Freitas's avatar
Danilo Freitas committed
1314
            error(self.pos, "new operator can only be applied to a C++ class")
Robert Bradshaw's avatar
Robert Bradshaw committed
1315
            self.type = error_type
Danilo Freitas's avatar
Danilo Freitas committed
1316
            return
Robert Bradshaw's avatar
Robert Bradshaw committed
1317
        self.cpp_check(env)
1318
        constructor = type.scope.lookup(u'<init>')
Danilo Freitas's avatar
Danilo Freitas committed
1319
        if constructor is None:
1320 1321
            return_type = PyrexTypes.CFuncType(type, [])
            return_type = PyrexTypes.CPtrType(return_type)
1322 1323
            type.scope.declare_cfunction(u'<init>', return_type, self.pos)
            constructor = type.scope.lookup(u'<init>')
1324
        self.class_type = type
DaniloFreitas's avatar
DaniloFreitas committed
1325
        self.entry = constructor
Robert Bradshaw's avatar
Robert Bradshaw committed
1326
        self.type = constructor.type
1327
        return self.type
1328

1329
    def analyse_types(self, env):
Robert Bradshaw's avatar
Robert Bradshaw committed
1330 1331
        if self.type is None:
            self.infer_type(env)
1332 1333 1334 1335

    def may_be_none(self):
        return False

Danilo Freitas's avatar
Danilo Freitas committed
1336 1337
    def generate_result_code(self, code):
        pass
1338

Danilo Freitas's avatar
Danilo Freitas committed
1339
    def calculate_result_code(self):
1340
        return "new " + self.class_type.declaration_code("")
Danilo Freitas's avatar
Danilo Freitas committed
1341

William Stein's avatar
William Stein committed
1342

1343
class NameNode(AtomicExprNode):
William Stein's avatar
William Stein committed
1344 1345 1346 1347
    #  Reference to a local or global variable name.
    #
    #  name            string    Python name of the variable
    #  entry           Entry     Symbol table entry
1348
    #  type_entry      Entry     For extension type names, the original type entry
1349 1350
    #  cf_is_null      boolean   Is uninitialized before this node
    #  cf_maybe_null   boolean   Maybe uninitialized before this node
Vitja Makarov's avatar
Vitja Makarov committed
1351
    #  allow_null      boolean   Don't raise UnboundLocalError
1352
    #  nogil           boolean   Whether it is used in a nogil context
1353

1354 1355
    is_name = True
    is_cython_module = False
Robert Bradshaw's avatar
Robert Bradshaw committed
1356
    cython_attribute = None
1357
    lhs_of_first_assignment = False # TODO: remove me
1358
    is_used_as_rvalue = 0
1359
    entry = None
1360
    type_entry = None
1361 1362
    cf_maybe_null = True
    cf_is_null = False
Vitja Makarov's avatar
Vitja Makarov committed
1363
    allow_null = False
1364
    nogil = False
1365 1366 1367 1368 1369

    def create_analysed_rvalue(pos, env, entry):
        node = NameNode(pos)
        node.analyse_types(env, entry=entry)
        return node
1370

1371
    def as_cython_attribute(self):
Robert Bradshaw's avatar
Robert Bradshaw committed
1372
        return self.cython_attribute
1373

1374
    create_analysed_rvalue = staticmethod(create_analysed_rvalue)
1375

Robert Bradshaw's avatar
Robert Bradshaw committed
1376 1377 1378 1379 1380 1381 1382
    def type_dependencies(self, env):
        if self.entry is None:
            self.entry = env.lookup(self.name)
        if self.entry is not None and self.entry.type.is_unspecified:
            return (self.entry,)
        else:
            return ()
1383

Robert Bradshaw's avatar
Robert Bradshaw committed
1384 1385 1386 1387 1388
    def infer_type(self, env):
        if self.entry is None:
            self.entry = env.lookup(self.name)
        if self.entry is None:
            return py_object_type
Robert Bradshaw's avatar
Robert Bradshaw committed
1389 1390 1391
        elif (self.entry.type.is_extension_type or self.entry.type.is_builtin_type) and \
                self.name == self.entry.type.name:
            # Unfortunately the type attribute of type objects
1392
            # is used for the pointer to the type they represent.
Robert Bradshaw's avatar
Robert Bradshaw committed
1393
            return type_type
1394
        elif self.entry.type.is_cfunction:
1395 1396 1397 1398 1399 1400
            if self.entry.scope.is_builtin_scope:
                # special case: optimised builtin functions must be treated as Python objects
                return py_object_type
            else:
                # special case: referring to a C function must return its pointer
                return PyrexTypes.CPtrType(self.entry.type)
Robert Bradshaw's avatar
Robert Bradshaw committed
1401 1402
        else:
            return self.entry.type
1403

1404 1405 1406 1407
    def compile_time_value(self, denv):
        try:
            return denv.lookup(self.name)
        except KeyError:
Stefan Behnel's avatar
Stefan Behnel committed
1408
            error(self.pos, "Compile-time name '%s' not defined" % self.name)
1409 1410 1411 1412 1413

    def get_constant_c_result_code(self):
        if not self.entry or self.entry.type.is_pyobject:
            return None
        return self.entry.cname
1414

1415 1416 1417 1418 1419 1420 1421
    def coerce_to(self, dst_type, env):
        #  If coercing to a generic pyobject and this is a builtin
        #  C function with a Python equivalent, manufacture a NameNode
        #  referring to the Python builtin.
        #print "NameNode.coerce_to:", self.name, dst_type ###
        if dst_type is py_object_type:
            entry = self.entry
1422
            if entry and entry.is_cfunction:
1423 1424
                var_entry = entry.as_variable
                if var_entry:
1425
                    if var_entry.is_builtin and var_entry.is_const:
1426
                        var_entry = env.declare_builtin(var_entry.name, self.pos)
1427 1428 1429 1430
                    node = NameNode(self.pos, name = self.name)
                    node.entry = var_entry
                    node.analyse_rvalue_entry(env)
                    return node
1431

Dag Sverre Seljebotn's avatar
Dag Sverre Seljebotn committed
1432
        return super(NameNode, self).coerce_to(dst_type, env)
1433

William Stein's avatar
William Stein committed
1434 1435 1436
    def analyse_as_module(self, env):
        # Try to interpret this as a reference to a cimported module.
        # Returns the module scope, or None.
1437 1438 1439
        entry = self.entry
        if not entry:
            entry = env.lookup(self.name)
William Stein's avatar
William Stein committed
1440 1441 1442
        if entry and entry.as_module:
            return entry.as_module
        return None
1443

1444
    def analyse_as_type(self, env):
1445 1446 1447 1448
        if self.cython_attribute:
            type = PyrexTypes.parse_basic_type(self.cython_attribute)
        else:
            type = PyrexTypes.parse_basic_type(self.name)
1449 1450
        if type:
            return type
1451 1452 1453 1454 1455 1456 1457
        entry = self.entry
        if not entry:
            entry = env.lookup(self.name)
        if entry and entry.is_type:
            return entry.type
        else:
            return None
1458

William Stein's avatar
William Stein committed
1459 1460 1461
    def analyse_as_extension_type(self, env):
        # Try to interpret this as a reference to an extension type.
        # Returns the extension type, or None.
1462 1463 1464
        entry = self.entry
        if not entry:
            entry = env.lookup(self.name)
William Stein's avatar
William Stein committed
1465
        if entry and entry.is_type and entry.type.is_extension_type:
1466 1467 1468
            return entry.type
        else:
            return None
1469

William Stein's avatar
William Stein committed
1470
    def analyse_target_declaration(self, env):
1471 1472
        if not self.entry:
            self.entry = env.lookup_here(self.name)
William Stein's avatar
William Stein committed
1473
        if not self.entry:
1474 1475
            if env.directives['warn.undeclared']:
                warning(self.pos, "implicit declaration of '%s'" % self.name, 1)
1476
            if env.directives['infer_types'] != False:
1477 1478 1479 1480
                type = unspecified_type
            else:
                type = py_object_type
            self.entry = env.declare_var(self.name, type, self.pos)
1481 1482
        if self.entry.is_declared_generic:
            self.result_ctype = py_object_type
1483

1484
    def analyse_types(self, env):
1485
        self.initialized_check = env.directives['initializedcheck']
1486 1487
        if self.entry is None:
            self.entry = env.lookup(self.name)
William Stein's avatar
William Stein committed
1488 1489
        if not self.entry:
            self.entry = env.declare_builtin(self.name, self.pos)
1490 1491 1492
        if not self.entry:
            self.type = PyrexTypes.error_type
            return
Dag Sverre Seljebotn's avatar
Dag Sverre Seljebotn committed
1493 1494 1495 1496 1497 1498 1499 1500
        entry = self.entry
        if entry:
            entry.used = 1
            if entry.type.is_buffer:
                import Buffer
                Buffer.used_buffer_aux_vars(entry)
            if entry.utility_code:
                env.use_utility_code(entry.utility_code)
1501
        self.analyse_rvalue_entry(env)
1502

1503
    def analyse_target_types(self, env):
William Stein's avatar
William Stein committed
1504
        self.analyse_entry(env)
1505 1506 1507

        if (not self.is_lvalue() and self.entry.is_cfunction and
                self.entry.fused_cfunction and self.entry.as_variable):
1508
            # We need this for the fused 'def' TreeFragment
1509 1510 1511
            self.entry = self.entry.as_variable
            self.type = self.entry.type

1512 1513 1514 1515
        if not self.is_lvalue():
            error(self.pos, "Assignment to non-lvalue '%s'"
                % self.name)
            self.type = PyrexTypes.error_type
Stefan Behnel's avatar
Stefan Behnel committed
1516
        self.entry.used = 1
1517
        if self.entry.type.is_buffer:
1518 1519
            import Buffer
            Buffer.used_buffer_aux_vars(self.entry)
1520

1521 1522 1523 1524
    def analyse_rvalue_entry(self, env):
        #print "NameNode.analyse_rvalue_entry:", self.name ###
        #print "Entry:", self.entry.__dict__ ###
        self.analyse_entry(env)
1525
        entry = self.entry
1526

1527
        if entry.is_declared_generic:
William Stein's avatar
William Stein committed
1528
            self.result_ctype = py_object_type
1529

1530
        if entry.is_pyglobal or entry.is_builtin:
1531
            if entry.is_builtin and entry.is_const:
1532 1533 1534
                self.is_temp = 0
            else:
                self.is_temp = 1
1535
                env.use_utility_code(get_name_interned_utility_code)
1536

1537
            self.is_used_as_rvalue = 1
1538 1539 1540
        elif entry.type.is_memoryviewslice:
            self.is_temp = False
            self.is_used_as_rvalue = True
1541
            self.use_managed_ref = True
1542

1543
    def nogil_check(self, env):
1544
        self.nogil = True
1545 1546 1547
        if self.is_used_as_rvalue:
            entry = self.entry
            if entry.is_builtin:
1548
                if not entry.is_const: # cached builtins are ok
1549
                    self.gil_error()
1550
            elif entry.is_pyglobal:
1551
                self.gil_error()
1552 1553 1554 1555
            elif self.entry.type.is_memoryviewslice:
                if self.cf_is_null or self.cf_maybe_null:
                    import MemoryView
                    MemoryView.err_if_nogil_initialized_check(self.pos, env)
1556 1557 1558

    gil_message = "Accessing Python global or builtin"

1559 1560
    def analyse_entry(self, env):
        #print "NameNode.analyse_entry:", self.name ###
William Stein's avatar
William Stein committed
1561
        self.check_identifier_kind()
1562 1563 1564 1565
        entry = self.entry
        type = entry.type
        self.type = type

William Stein's avatar
William Stein committed
1566
    def check_identifier_kind(self):
1567 1568 1569
        # Check that this is an appropriate kind of name for use in an
        # expression.  Also finds the variable entry associated with
        # an extension type.
William Stein's avatar
William Stein committed
1570
        entry = self.entry
1571 1572
        if entry.is_type and entry.type.is_extension_type:
            self.type_entry = entry
1573
        if not (entry.is_const or entry.is_variable
Danilo Freitas's avatar
Danilo Freitas committed
1574 1575
            or entry.is_builtin or entry.is_cfunction
            or entry.is_cpp_class):
William Stein's avatar
William Stein committed
1576 1577 1578
                if self.entry.as_variable:
                    self.entry = self.entry.as_variable
                else:
1579
                    error(self.pos,
1580 1581
                          "'%s' is not a constant, variable or function identifier" % self.name)

William Stein's avatar
William Stein committed
1582 1583 1584
    def is_simple(self):
        #  If it's not a C variable, it'll be in a temp.
        return 1
1585

1586
    def may_be_none(self):
1587
        if self.cf_state and self.type and self.type.is_pyobject:
1588 1589 1590 1591 1592 1593 1594
            # gard against infinite recursion on self-dependencies
            if getattr(self, '_none_checking', False):
                # self-dependency - either this node receives a None
                # value from *another* node, or it can not reference
                # None at this point => safe to assume "not None"
                return False
            self._none_checking = True
1595 1596
            # evaluate control flow state to see if there were any
            # potential None values assigned to the node so far
1597
            may_be_none = False
1598 1599
            for assignment in self.cf_state:
                if assignment.rhs.may_be_none():
1600 1601 1602 1603
                    may_be_none = True
                    break
            del self._none_checking
            return may_be_none
1604 1605
        return super(NameNode, self).may_be_none()

1606
    def nonlocally_immutable(self):
1607 1608
        if ExprNode.nonlocally_immutable(self):
            return True
1609 1610 1611
        entry = self.entry
        return entry and (entry.is_local or entry.is_arg) and not entry.in_closure

William Stein's avatar
William Stein committed
1612 1613
    def calculate_target_results(self, env):
        pass
1614

William Stein's avatar
William Stein committed
1615 1616
    def check_const(self):
        entry = self.entry
Robert Bradshaw's avatar
Robert Bradshaw committed
1617
        if entry is not None and not (entry.is_const or entry.is_cfunction or entry.is_builtin):
William Stein's avatar
William Stein committed
1618
            self.not_const()
1619 1620
            return False
        return True
1621

William Stein's avatar
William Stein committed
1622 1623
    def check_const_addr(self):
        entry = self.entry
1624
        if not (entry.is_cglobal or entry.is_cfunction or entry.is_builtin):
William Stein's avatar
William Stein committed
1625
            self.addr_not_const()
1626 1627
            return False
        return True
William Stein's avatar
William Stein committed
1628 1629 1630 1631 1632

    def is_lvalue(self):
        return self.entry.is_variable and \
            not self.entry.type.is_array and \
            not self.entry.is_readonly
1633

1634 1635 1636
    def is_addressable(self):
        return self.entry.is_variable

William Stein's avatar
William Stein committed
1637 1638 1639 1640
    def is_ephemeral(self):
        #  Name nodes are never ephemeral, even if the
        #  result is in a temporary.
        return 0
1641

William Stein's avatar
William Stein committed
1642
    def calculate_result_code(self):
Stefan Behnel's avatar
Stefan Behnel committed
1643 1644
        entry = self.entry
        if not entry:
William Stein's avatar
William Stein committed
1645
            return "<error>" # There was an error earlier
Stefan Behnel's avatar
Stefan Behnel committed
1646
        return entry.cname
1647

William Stein's avatar
William Stein committed
1648
    def generate_result_code(self, code):
1649
        assert hasattr(self, 'entry')
William Stein's avatar
William Stein committed
1650 1651 1652
        entry = self.entry
        if entry is None:
            return # There was an error earlier
1653
        if entry.is_builtin and entry.is_const:
1654
            return # Lookup already cached
Stefan Behnel's avatar
Stefan Behnel committed
1655
        elif entry.is_pyclass_attr:
Vitja Makarov's avatar
Vitja Makarov committed
1656 1657 1658 1659 1660 1661
            assert entry.type.is_pyobject, "Python global or builtin not a Python object"
            interned_cname = code.intern_identifier(self.entry.name)
            if entry.is_builtin:
                namespace = Naming.builtins_cname
            else: # entry.is_pyglobal
                namespace = entry.scope.namespace_cname
1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674 1675 1676 1677 1678 1679
            if not self.cf_is_null:
                code.putln(
                    '%s = PyObject_GetItem(%s, %s);' % (
                        self.result(),
                        namespace,
                        interned_cname))
            if self.cf_maybe_null:
                if not self.cf_is_null:
                    code.putln('if (unlikely(!%s)) {' % self.result())
                    code.putln('PyErr_Clear();')
                code.putln(
                    '%s = __Pyx_GetName(%s, %s);' % (
                    self.result(),
                    Naming.module_cname,
                    interned_cname))
                if not self.cf_is_null:
                    code.putln("}");
            code.putln(code.error_goto_if_null(self.result(), self.pos))
Vitja Makarov's avatar
Vitja Makarov committed
1680
            code.put_gotref(self.py_result())
1681

1682
        elif entry.is_pyglobal or entry.is_builtin:
1683 1684
            assert entry.type.is_pyobject, "Python global or builtin not a Python object"
            interned_cname = code.intern_identifier(self.entry.name)
William Stein's avatar
William Stein committed
1685 1686 1687
            if entry.is_builtin:
                namespace = Naming.builtins_cname
            else: # entry.is_pyglobal
1688
                namespace = entry.scope.namespace_cname
1689
            code.globalstate.use_utility_code(get_name_interned_utility_code)
1690 1691
            code.putln(
                '%s = __Pyx_GetName(%s, %s); %s' % (
1692
                self.result(),
1693
                namespace,
1694
                interned_cname,
1695
                code.error_goto_if_null(self.result(), self.pos)))
1696
            code.put_gotref(self.py_result())
1697

1698
        elif entry.is_local or entry.in_closure or entry.from_closure or entry.type.is_memoryviewslice:
1699 1700 1701 1702
            # Raise UnboundLocalError for objects and memoryviewslices
            raise_unbound = (
                (self.cf_maybe_null or self.cf_is_null) and not self.allow_null)
            null_code = entry.type.check_for_null_code(entry.cname)
1703

1704 1705 1706 1707
            memslice_check = entry.type.is_memoryviewslice and self.initialized_check

            if null_code and raise_unbound and (entry.type.is_pyobject or memslice_check):
                code.put_error_if_unbound(self.pos, entry)
William Stein's avatar
William Stein committed
1708 1709

    def generate_assignment_code(self, rhs, code):
1710
        #print "NameNode.generate_assignment_code:", self.name ###
William Stein's avatar
William Stein committed
1711 1712 1713
        entry = self.entry
        if entry is None:
            return # There was an error earlier
1714 1715 1716 1717

        if (self.entry.type.is_ptr and isinstance(rhs, ListNode)
            and not self.lhs_of_first_assignment):
            error(self.pos, "Literal list must be assigned to pointer at time of declaration")
1718

1719 1720
        # is_pyglobal seems to be True for module level-globals only.
        # We use this to access class->tp_dict if necessary.
William Stein's avatar
William Stein committed
1721
        if entry.is_pyglobal:
1722 1723
            assert entry.type.is_pyobject, "Python global or builtin not a Python object"
            interned_cname = code.intern_identifier(self.entry.name)
1724
            namespace = self.entry.scope.namespace_cname
1725
            if entry.is_member:
Stefan Behnel's avatar
Stefan Behnel committed
1726
                # if the entry is a member we have to cheat: SetAttr does not work
1727
                # on types, so we create a descriptor which is then added to tp_dict
1728 1729 1730
                code.put_error_if_neg(self.pos,
                    'PyDict_SetItem(%s->tp_dict, %s, %s)' % (
                        namespace,
1731
                        interned_cname,
1732
                        rhs.py_result()))
1733 1734
                rhs.generate_disposal_code(code)
                rhs.free_temps(code)
1735
                # in Py2.6+, we need to invalidate the method cache
1736
                code.putln("PyType_Modified(%s);" %
Vitja Makarov's avatar
Vitja Makarov committed
1737
                            entry.scope.parent_type.typeptr_cname)
Stefan Behnel's avatar
Stefan Behnel committed
1738
            elif entry.is_pyclass_attr:
Vitja Makarov's avatar
Vitja Makarov committed
1739
                code.put_error_if_neg(self.pos,
Stefan Behnel's avatar
Stefan Behnel committed
1740
                    'PyObject_SetItem(%s, %s, %s)' % (
Vitja Makarov's avatar
Vitja Makarov committed
1741 1742 1743 1744 1745 1746
                        namespace,
                        interned_cname,
                        rhs.py_result()))
                rhs.generate_disposal_code(code)
                rhs.free_temps(code)
            else:
1747 1748 1749
                code.put_error_if_neg(self.pos,
                    'PyObject_SetAttr(%s, %s, %s)' % (
                        namespace,
1750
                        interned_cname,
1751
                        rhs.py_result()))
1752
                if debug_disposal_code:
Stefan Behnel's avatar
Stefan Behnel committed
1753 1754
                    print("NameNode.generate_assignment_code:")
                    print("...generating disposal code for %s" % rhs)
1755
                rhs.generate_disposal_code(code)
1756
                rhs.free_temps(code)
William Stein's avatar
William Stein committed
1757
        else:
1758
            if self.type.is_memoryviewslice:
1759
                self.generate_acquire_memoryviewslice(rhs, code)
1760

1761
            elif self.type.is_buffer:
1762 1763 1764 1765 1766 1767 1768 1769 1770
                # Generate code for doing the buffer release/acquisition.
                # This might raise an exception in which case the assignment (done
                # below) will not happen.
                #
                # The reason this is not in a typetest-like node is because the
                # variables that the acquired buffer info is stored to is allocated
                # per entry and coupled with it.
                self.generate_acquire_buffer(rhs, code)

1771
            if self.type.is_pyobject:
William Stein's avatar
William Stein committed
1772 1773 1774 1775
                #print "NameNode.generate_assignment_code: to", self.name ###
                #print "...from", rhs ###
                #print "...LHS type", self.type, "ctype", self.ctype() ###
                #print "...RHS type", rhs.type, "ctype", rhs.ctype() ###
1776 1777
                if self.use_managed_ref:
                    rhs.make_owned_reference(code)
1778
                    is_external_ref = entry.is_cglobal or self.entry.in_closure or self.entry.from_closure
1779 1780 1781 1782 1783 1784
                    if is_external_ref:
                        if not self.cf_is_null:
                            if self.cf_maybe_null:
                                code.put_xgotref(self.py_result())
                            else:
                                code.put_gotref(self.py_result())
1785 1786 1787
                    if entry.is_cglobal:
                        code.put_decref(self.result(), self.ctype())
                    else:
1788 1789
                        if not self.cf_is_null:
                            if self.cf_maybe_null:
1790
                                code.put_xdecref(self.result(), self.ctype())
1791 1792
                            else:
                                code.put_decref(self.result(), self.ctype())
1793
                    if is_external_ref:
1794
                        code.put_giveref(rhs.py_result())
1795
            if not self.type.is_memoryviewslice:
1796
                code.putln('%s = %s;' % (self.result(), rhs.result_as(self.ctype())))
1797 1798 1799 1800
                if debug_disposal_code:
                    print("NameNode.generate_assignment_code:")
                    print("...generating post-assignment code for %s" % rhs)
                rhs.generate_post_assignment_code(code)
1801 1802
            elif rhs.result_in_temp():
                rhs.generate_post_assignment_code(code)
1803

1804
            rhs.free_temps(code)
1805

1806 1807
    def generate_acquire_memoryviewslice(self, rhs, code):
        """
1808 1809
        Slices, coercions from objects, return values etc are new references.
        We have a borrowed reference in case of dst = src
1810 1811 1812 1813 1814 1815 1816 1817 1818
        """
        import MemoryView

        MemoryView.put_acquire_memoryviewslice(
            lhs_cname=self.result(),
            lhs_type=self.type,
            lhs_pos=self.pos,
            rhs=rhs,
            code=code,
Mark Florisson's avatar
Mark Florisson committed
1819
            have_gil=not self.in_nogil_context)
1820

1821
    def generate_acquire_buffer(self, rhs, code):
1822 1823 1824
        # rhstmp is only used in case the rhs is a complicated expression leading to
        # the object, to avoid repeating the same C expression for every reference
        # to the rhs. It does NOT hold a reference.
1825 1826 1827 1828 1829 1830 1831
        pretty_rhs = isinstance(rhs, NameNode) or rhs.is_temp
        if pretty_rhs:
            rhstmp = rhs.result_as(self.ctype())
        else:
            rhstmp = code.funcstate.allocate_temp(self.entry.type, manage_ref=False)
            code.putln('%s = %s;' % (rhstmp, rhs.result_as(self.ctype())))

1832
        import Buffer
1833
        Buffer.put_assign_to_buffer(self.result(), rhstmp, self.entry,
1834
                                    is_initialized=not self.lhs_of_first_assignment,
1835
                                    pos=self.pos, code=code)
1836

1837 1838 1839
        if not pretty_rhs:
            code.putln("%s = 0;" % rhstmp)
            code.funcstate.release_temp(rhstmp)
1840

William Stein's avatar
William Stein committed
1841 1842 1843
    def generate_deletion_code(self, code):
        if self.entry is None:
            return # There was an error earlier
1844
        elif self.entry.is_pyclass_attr:
Vitja Makarov's avatar
Vitja Makarov committed
1845
            namespace = self.entry.scope.namespace_cname
1846
            interned_cname = code.intern_identifier(self.entry.name)
Vitja Makarov's avatar
Vitja Makarov committed
1847
            code.put_error_if_neg(self.pos,
1848
                'PyMapping_DelItem(%s, %s)' % (
Vitja Makarov's avatar
Vitja Makarov committed
1849
                    namespace,
1850
                    interned_cname))
1851 1852 1853 1854 1855
        elif self.entry.is_pyglobal:
            code.put_error_if_neg(self.pos,
                '__Pyx_DelAttrString(%s, "%s")' % (
                    Naming.module_cname,
                    self.entry.name))
1856
        elif self.entry.type.is_pyobject or self.entry.type.is_memoryviewslice:
1857 1858
            if not self.cf_is_null:
                if self.cf_maybe_null:
1859
                    code.put_error_if_unbound(self.pos, self.entry)
1860 1861 1862 1863 1864 1865 1866

                if self.entry.type.is_pyobject:
                    code.put_decref(self.result(), self.ctype())
                    code.putln('%s = NULL;' % self.result())
                else:
                    code.put_xdecref_memoryviewslice(self.entry.cname,
                                                     have_gil=not self.nogil)
Vitja Makarov's avatar
Vitja Makarov committed
1867
        else:
1868
            error(self.pos, "Deletion of C names not supported")
1869

1870 1871 1872 1873 1874 1875 1876
    def annotate(self, code):
        if hasattr(self, 'is_called') and self.is_called:
            pos = (self.pos[0], self.pos[1], self.pos[2] - len(self.name) - 1)
            if self.type.is_pyobject:
                code.annotate(pos, AnnotationItem('py_call', 'python function', size=len(self.name)))
            else:
                code.annotate(pos, AnnotationItem('c_call', 'c function', size=len(self.name)))
1877

1878
class BackquoteNode(ExprNode):
William Stein's avatar
William Stein committed
1879 1880 1881
    #  `expr`
    #
    #  arg    ExprNode
1882

1883
    type = py_object_type
1884

William Stein's avatar
William Stein committed
1885
    subexprs = ['arg']
1886

William Stein's avatar
William Stein committed
1887 1888 1889 1890
    def analyse_types(self, env):
        self.arg.analyse_types(env)
        self.arg = self.arg.coerce_to_pyobject(env)
        self.is_temp = 1
1891 1892 1893

    gil_message = "Backquote expression"

1894 1895 1896
    def calculate_constant_result(self):
        self.constant_result = repr(self.arg.constant_result)

William Stein's avatar
William Stein committed
1897 1898
    def generate_result_code(self, code):
        code.putln(
Robert Bradshaw's avatar
Robert Bradshaw committed
1899
            "%s = PyObject_Repr(%s); %s" % (
1900
                self.result(),
William Stein's avatar
William Stein committed
1901
                self.arg.py_result(),
1902
                code.error_goto_if_null(self.result(), self.pos)))
1903
        code.put_gotref(self.py_result())
1904

William Stein's avatar
William Stein committed
1905

1906
class ImportNode(ExprNode):
William Stein's avatar
William Stein committed
1907
    #  Used as part of import statement implementation.
1908
    #  Implements result =
Haoyu Bai's avatar
Haoyu Bai committed
1909
    #    __import__(module_name, globals(), None, name_list, level)
William Stein's avatar
William Stein committed
1910
    #
Haoyu Bai's avatar
Haoyu Bai committed
1911 1912 1913
    #  module_name   StringNode            dotted name of module. Empty module
    #                       name means importing the parent package accourding
    #                       to level
1914
    #  name_list     ListNode or None      list of names to be imported
Haoyu Bai's avatar
Haoyu Bai committed
1915 1916 1917 1918 1919
    #  level         int                   relative import level:
    #                       -1: attempt both relative import and absolute import;
    #                        0: absolute import;
    #                       >0: the number of parent directories to search
    #                           relative to the current module.
1920 1921
    #                     None: decide the level according to language level and
    #                           directives
1922

1923
    type = py_object_type
1924

William Stein's avatar
William Stein committed
1925
    subexprs = ['module_name', 'name_list']
1926

William Stein's avatar
William Stein committed
1927
    def analyse_types(self, env):
1928 1929 1930 1931 1932
        if self.level is None:
            if env.directives['language_level'] < 3 or env.directives['py2_import']:
                self.level = -1
            else:
                self.level = 0
William Stein's avatar
William Stein committed
1933 1934 1935 1936
        self.module_name.analyse_types(env)
        self.module_name = self.module_name.coerce_to_pyobject(env)
        if self.name_list:
            self.name_list.analyse_types(env)
1937
            self.name_list.coerce_to_pyobject(env)
William Stein's avatar
William Stein committed
1938 1939
        self.is_temp = 1
        env.use_utility_code(import_utility_code)
1940 1941 1942

    gil_message = "Python import"

William Stein's avatar
William Stein committed
1943 1944 1945 1946 1947 1948
    def generate_result_code(self, code):
        if self.name_list:
            name_list_code = self.name_list.py_result()
        else:
            name_list_code = "0"
        code.putln(
Haoyu Bai's avatar
Haoyu Bai committed
1949
            "%s = __Pyx_Import(%s, %s, %d); %s" % (
1950
                self.result(),
William Stein's avatar
William Stein committed
1951 1952
                self.module_name.py_result(),
                name_list_code,
Haoyu Bai's avatar
Haoyu Bai committed
1953
                self.level,
1954
                code.error_goto_if_null(self.result(), self.pos)))
1955
        code.put_gotref(self.py_result())
William Stein's avatar
William Stein committed
1956 1957


1958
class IteratorNode(ExprNode):
William Stein's avatar
William Stein committed
1959
    #  Used as part of for statement implementation.
1960
    #
William Stein's avatar
William Stein committed
1961 1962 1963
    #  Implements result = iter(sequence)
    #
    #  sequence   ExprNode
1964

1965
    type = py_object_type
1966
    iter_func_ptr = None
1967
    counter_cname = None
1968
    reversed = False      # currently only used for list/tuple types (see Optimize.py)
1969

William Stein's avatar
William Stein committed
1970
    subexprs = ['sequence']
1971

William Stein's avatar
William Stein committed
1972 1973
    def analyse_types(self, env):
        self.sequence.analyse_types(env)
1974 1975
        if (self.sequence.type.is_array or self.sequence.type.is_ptr) and \
                not self.sequence.type.is_string:
1976
            # C array iteration will be transformed later on
1977
            self.type = self.sequence.type
1978 1979
        else:
            self.sequence = self.sequence.coerce_to_pyobject(env)
1980 1981 1982
            if self.sequence.type is list_type or \
                   self.sequence.type is tuple_type:
                self.sequence = self.sequence.as_none_safe_node("'NoneType' object is not iterable")
William Stein's avatar
William Stein committed
1983
        self.is_temp = 1
1984 1985 1986

    gil_message = "Iterating over Python object"

1987 1988 1989 1990
    _func_iternext_type = PyrexTypes.CPtrType(PyrexTypes.CFuncType(
        PyrexTypes.py_object_type, [
            PyrexTypes.CFuncTypeArg("it", PyrexTypes.py_object_type, None),
            ]))
1991

William Stein's avatar
William Stein committed
1992
    def generate_result_code(self, code):
Stefan Behnel's avatar
Stefan Behnel committed
1993 1994
        sequence_type = self.sequence.type
        if sequence_type.is_array or sequence_type.is_ptr:
1995
            raise InternalError("for in carray slice not transformed")
Stefan Behnel's avatar
Stefan Behnel committed
1996 1997
        is_builtin_sequence = sequence_type is list_type or \
                              sequence_type is tuple_type
1998 1999 2000
        if not is_builtin_sequence:
            # reversed() not currently optimised (see Optimize.py)
            assert not self.reversed, "internal error: reversed() only implemented for list/tuple objects"
Stefan Behnel's avatar
Stefan Behnel committed
2001 2002
        self.may_be_a_sequence = not sequence_type.is_builtin_type
        if self.may_be_a_sequence:
2003 2004 2005 2006
            code.putln(
                "if (PyList_CheckExact(%s) || PyTuple_CheckExact(%s)) {" % (
                    self.sequence.py_result(),
                    self.sequence.py_result()))
Stefan Behnel's avatar
Stefan Behnel committed
2007
        if is_builtin_sequence or self.may_be_a_sequence:
2008 2009
            self.counter_cname = code.funcstate.allocate_temp(
                PyrexTypes.c_py_ssize_t_type, manage_ref=False)
2010 2011 2012 2013 2014 2015 2016
            if self.reversed:
                if sequence_type is list_type:
                    init_value = 'PyList_GET_SIZE(%s) - 1' % self.result()
                else:
                    init_value = 'PyTuple_GET_SIZE(%s) - 1' % self.result()
            else:
                init_value = '0'
2017
            code.putln(
2018
                "%s = %s; __Pyx_INCREF(%s); %s = %s;" % (
2019 2020
                    self.result(),
                    self.sequence.py_result(),
2021 2022 2023 2024
                    self.result(),
                    self.counter_cname,
                    init_value
                    ))
2025
        if not is_builtin_sequence:
Stefan Behnel's avatar
Stefan Behnel committed
2026
            self.iter_func_ptr = code.funcstate.allocate_temp(self._func_iternext_type, manage_ref=False)
Stefan Behnel's avatar
Stefan Behnel committed
2027
            if self.may_be_a_sequence:
Stefan Behnel's avatar
Stefan Behnel committed
2028
                code.putln("%s = NULL;" % self.iter_func_ptr)
2029
                code.putln("} else {")
2030 2031
                code.put("%s = -1; " % self.counter_cname)
            code.putln("%s = PyObject_GetIter(%s); %s" % (
2032 2033 2034
                    self.result(),
                    self.sequence.py_result(),
                    code.error_goto_if_null(self.result(), self.pos)))
2035
            code.put_gotref(self.py_result())
2036
            code.putln("%s = Py_TYPE(%s)->tp_iternext;" % (self.iter_func_ptr, self.py_result()))
Stefan Behnel's avatar
Stefan Behnel committed
2037 2038 2039 2040
        if self.may_be_a_sequence:
            code.putln("}")

    def generate_next_sequence_item(self, test_name, result_name, code):
2041
        assert self.counter_cname, "internal error: counter_cname temp not prepared"
Stefan Behnel's avatar
Stefan Behnel committed
2042 2043 2044 2045 2046
        code.putln(
            "if (%s >= Py%s_GET_SIZE(%s)) break;" % (
                self.counter_cname,
                test_name,
                self.py_result()))
2047 2048 2049 2050
        if self.reversed:
            inc_dec = '--'
        else:
            inc_dec = '++'
Stefan Behnel's avatar
Stefan Behnel committed
2051
        code.putln(
2052
            "%s = Py%s_GET_ITEM(%s, %s); __Pyx_INCREF(%s); %s%s;" % (
Stefan Behnel's avatar
Stefan Behnel committed
2053 2054 2055 2056 2057
                result_name,
                test_name,
                self.py_result(),
                self.counter_cname,
                result_name,
2058 2059
                self.counter_cname,
                inc_dec))
Stefan Behnel's avatar
Stefan Behnel committed
2060 2061 2062

    def generate_iter_next_result_code(self, result_name, code):
        sequence_type = self.sequence.type
2063 2064
        if self.reversed:
            code.putln("if (%s < 0) break;" % self.counter_cname)
Stefan Behnel's avatar
Stefan Behnel committed
2065 2066 2067 2068 2069 2070 2071 2072 2073
        if sequence_type is list_type:
            self.generate_next_sequence_item('List', result_name, code)
            return
        elif sequence_type is tuple_type:
            self.generate_next_sequence_item('Tuple', result_name, code)
            return

        if self.may_be_a_sequence:
            for test_name in ('List', 'Tuple'):
2074 2075
                code.putln("if (!%s && Py%s_CheckExact(%s)) {" % (
                    self.iter_func_ptr, test_name, self.py_result()))
Stefan Behnel's avatar
Stefan Behnel committed
2076 2077 2078 2079 2080 2081 2082 2083 2084 2085 2086 2087 2088 2089 2090 2091 2092 2093
                self.generate_next_sequence_item(test_name, result_name, code)
                code.put("} else ")

        code.putln("{")
        code.putln(
            "%s = %s(%s);" % (
                result_name,
                self.iter_func_ptr,
                self.py_result()))
        code.putln("if (unlikely(!%s)) {" % result_name)
        code.putln("if (PyErr_Occurred()) {")
        code.putln("if (likely(PyErr_ExceptionMatches(PyExc_StopIteration))) PyErr_Clear();")
        code.putln("else %s" % code.error_goto(self.pos))
        code.putln("}")
        code.putln("break;")
        code.putln("}")
        code.put_gotref(result_name)
        code.putln("}")
William Stein's avatar
William Stein committed
2094

2095
    def free_temps(self, code):
2096 2097
        if self.counter_cname:
            code.funcstate.release_temp(self.counter_cname)
2098 2099 2100 2101
        if self.iter_func_ptr:
            code.funcstate.release_temp(self.iter_func_ptr)
            self.iter_func_ptr = None
        ExprNode.free_temps(self, code)
William Stein's avatar
William Stein committed
2102 2103


2104
class NextNode(AtomicExprNode):
William Stein's avatar
William Stein committed
2105 2106 2107 2108 2109
    #  Used as part of for statement implementation.
    #  Implements result = iterator.next()
    #  Created during analyse_types phase.
    #  The iterator is not owned by this node.
    #
2110
    #  iterator   IteratorNode
2111

2112
    type = py_object_type
2113

2114
    def __init__(self, iterator):
William Stein's avatar
William Stein committed
2115 2116
        self.pos = iterator.pos
        self.iterator = iterator
2117 2118
        if iterator.type.is_ptr or iterator.type.is_array:
            self.type = iterator.type.base_type
William Stein's avatar
William Stein committed
2119
        self.is_temp = 1
2120

William Stein's avatar
William Stein committed
2121
    def generate_result_code(self, code):
Stefan Behnel's avatar
Stefan Behnel committed
2122
        self.iterator.generate_iter_next_result_code(self.result(), code)
2123

William Stein's avatar
William Stein committed
2124

2125 2126 2127 2128 2129 2130 2131 2132 2133 2134 2135 2136 2137 2138 2139 2140 2141 2142 2143 2144 2145 2146 2147 2148 2149 2150 2151 2152 2153 2154 2155 2156 2157 2158
class WithExitCallNode(ExprNode):
    # The __exit__() call of a 'with' statement.  Used in both the
    # except and finally clauses.

    # with_stat  WithStatNode                the surrounding 'with' statement
    # args       TupleNode or ResultStatNode the exception info tuple

    subexprs = ['args']

    def analyse_types(self, env):
        self.args.analyse_types(env)
        self.type = PyrexTypes.c_bint_type
        self.is_temp = True

    def generate_result_code(self, code):
        if isinstance(self.args, TupleNode):
            # call only if it was not already called (and decref-cleared)
            code.putln("if (%s) {" % self.with_stat.exit_var)
        result_var = code.funcstate.allocate_temp(py_object_type, manage_ref=False)
        code.putln("%s = PyObject_Call(%s, %s, NULL);" % (
            result_var,
            self.with_stat.exit_var,
            self.args.result()))
        code.put_decref_clear(self.with_stat.exit_var, type=py_object_type)
        code.putln(code.error_goto_if_null(result_var, self.pos))
        code.put_gotref(result_var)
        code.putln("%s = __Pyx_PyObject_IsTrue(%s);" % (self.result(), result_var))
        code.put_decref_clear(result_var, type=py_object_type)
        code.putln(code.error_goto_if_neg(self.result(), self.pos))
        code.funcstate.release_temp(result_var)
        if isinstance(self.args, TupleNode):
            code.putln("}")


2159
class ExcValueNode(AtomicExprNode):
William Stein's avatar
William Stein committed
2160 2161 2162
    #  Node created during analyse_types phase
    #  of an ExceptClauseNode to fetch the current
    #  exception value.
2163

2164
    type = py_object_type
2165

2166
    def __init__(self, pos, env):
William Stein's avatar
William Stein committed
2167
        ExprNode.__init__(self, pos)
2168 2169

    def set_var(self, var):
2170
        self.var = var
2171

2172 2173 2174
    def calculate_result_code(self):
        return self.var

William Stein's avatar
William Stein committed
2175
    def generate_result_code(self, code):
2176
        pass
William Stein's avatar
William Stein committed
2177

2178 2179 2180
    def analyse_types(self, env):
        pass

William Stein's avatar
William Stein committed
2181

2182
class TempNode(ExprNode):
2183 2184 2185 2186 2187 2188 2189
    # Node created during analyse_types phase
    # of some nodes to hold a temporary value.
    #
    # Note: One must call "allocate" and "release" on
    # the node during code generation to get/release the temp.
    # This is because the temp result is often used outside of
    # the regular cycle.
2190 2191

    subexprs = []
2192

2193
    def __init__(self, pos, type, env=None):
William Stein's avatar
William Stein committed
2194 2195 2196 2197 2198
        ExprNode.__init__(self, pos)
        self.type = type
        if type.is_pyobject:
            self.result_ctype = py_object_type
        self.is_temp = 1
2199

2200 2201
    def analyse_types(self, env):
        return self.type
2202

2203 2204 2205
    def analyse_target_declaration(self, env):
        pass

William Stein's avatar
William Stein committed
2206 2207 2208
    def generate_result_code(self, code):
        pass

2209 2210 2211 2212 2213 2214 2215 2216 2217 2218 2219 2220 2221 2222 2223 2224 2225
    def allocate(self, code):
        self.temp_cname = code.funcstate.allocate_temp(self.type, manage_ref=True)

    def release(self, code):
        code.funcstate.release_temp(self.temp_cname)
        self.temp_cname = None

    def result(self):
        try:
            return self.temp_cname
        except:
            assert False, "Remember to call allocate/release on TempNode"
            raise

    # Do not participate in normal temp alloc/dealloc:
    def allocate_temp_result(self, code):
        pass
2226

2227 2228
    def release_temp_result(self, code):
        pass
William Stein's avatar
William Stein committed
2229 2230 2231

class PyTempNode(TempNode):
    #  TempNode holding a Python value.
2232

William Stein's avatar
William Stein committed
2233 2234 2235
    def __init__(self, pos, env):
        TempNode.__init__(self, pos, PyrexTypes.py_object_type, env)

2236 2237
class RawCNameExprNode(ExprNode):
    subexprs = []
2238

2239 2240 2241 2242 2243 2244 2245 2246 2247 2248 2249 2250 2251 2252 2253 2254
    def __init__(self, pos, type=None):
        self.pos = pos
        self.type = type

    def analyse_types(self, env):
        return self.type

    def set_cname(self, cname):
        self.cname = cname

    def result(self):
        return self.cname

    def generate_result_code(self, code):
        pass

William Stein's avatar
William Stein committed
2255

Mark Florisson's avatar
Mark Florisson committed
2256 2257 2258 2259 2260 2261 2262 2263
#-------------------------------------------------------------------
#
#  Parallel nodes (cython.parallel.thread(savailable|id))
#
#-------------------------------------------------------------------

class ParallelThreadsAvailableNode(AtomicExprNode):
    """
Mark Florisson's avatar
Mark Florisson committed
2264 2265
    Note: this is disabled and not a valid directive at this moment

Mark Florisson's avatar
Mark Florisson committed
2266 2267 2268 2269 2270 2271 2272 2273 2274
    Implements cython.parallel.threadsavailable(). If we are called from the
    sequential part of the application, we need to call omp_get_max_threads(),
    and in the parallel part we can just call omp_get_num_threads()
    """

    type = PyrexTypes.c_int_type

    def analyse_types(self, env):
        self.is_temp = True
2275
        # env.add_include_file("omp.h")
Mark Florisson's avatar
Mark Florisson committed
2276 2277 2278 2279 2280 2281 2282 2283 2284 2285 2286 2287 2288 2289 2290 2291 2292 2293 2294 2295 2296 2297 2298 2299
        return self.type

    def generate_result_code(self, code):
        code.putln("#ifdef _OPENMP")
        code.putln("if (omp_in_parallel()) %s = omp_get_max_threads();" %
                                                            self.temp_code)
        code.putln("else %s = omp_get_num_threads();" % self.temp_code)
        code.putln("#else")
        code.putln("%s = 1;" % self.temp_code)
        code.putln("#endif")

    def result(self):
        return self.temp_code


class ParallelThreadIdNode(AtomicExprNode): #, Nodes.ParallelNode):
    """
    Implements cython.parallel.threadid()
    """

    type = PyrexTypes.c_int_type

    def analyse_types(self, env):
        self.is_temp = True
2300
        # env.add_include_file("omp.h")
Mark Florisson's avatar
Mark Florisson committed
2301 2302 2303 2304 2305 2306 2307 2308 2309 2310 2311 2312 2313
        return self.type

    def generate_result_code(self, code):
        code.putln("#ifdef _OPENMP")
        code.putln("%s = omp_get_thread_num();" % self.temp_code)
        code.putln("#else")
        code.putln("%s = 0;" % self.temp_code)
        code.putln("#endif")

    def result(self):
        return self.temp_code


William Stein's avatar
William Stein committed
2314 2315 2316 2317 2318 2319
#-------------------------------------------------------------------
#
#  Trailer nodes
#
#-------------------------------------------------------------------

2320
class IndexNode(ExprNode):
William Stein's avatar
William Stein committed
2321 2322 2323 2324
    #  Sequence indexing.
    #
    #  base     ExprNode
    #  index    ExprNode
2325 2326 2327 2328 2329 2330
    #  indices  [ExprNode]
    #  is_buffer_access boolean Whether this is a buffer access.
    #
    #  indices is used on buffer access, index on non-buffer access.
    #  The former contains a clean list of index parameters, the
    #  latter whatever Python object is needed for index access.
2331 2332 2333
    #
    #  is_fused_index boolean   Whether the index is used to specialize a
    #                           c(p)def function
2334

2335 2336 2337
    subexprs = ['base', 'index', 'indices']
    indices = None

2338 2339
    is_fused_index = False

2340 2341 2342 2343
    # Whether we're assigning to a buffer (in that case it needs to be
    # writable)
    writable_needed = False

2344 2345 2346
    # Whether we are indexing or slicing a memoryviewslice
    memslice_index = False
    memslice_slice = False
2347 2348
    is_memslice_copy = False
    memslice_ellipsis_noop = False
2349
    warned_untyped_idx = False
2350 2351
    # set by SingleAssignmentNode after analyse_types()
    is_memslice_scalar_assignment = False
2352

2353 2354 2355
    def __init__(self, pos, index, *args, **kw):
        ExprNode.__init__(self, pos, index=index, *args, **kw)
        self._index = index
2356 2357 2358 2359 2360

    def calculate_constant_result(self):
        self.constant_result = \
            self.base.constant_result[self.index.constant_result]

2361 2362 2363 2364 2365 2366 2367
    def compile_time_value(self, denv):
        base = self.base.compile_time_value(denv)
        index = self.index.compile_time_value(denv)
        try:
            return base[index]
        except Exception, e:
            self.compile_time_value_error(e)
2368

William Stein's avatar
William Stein committed
2369 2370
    def is_ephemeral(self):
        return self.base.is_ephemeral()
2371

2372
    def is_simple(self):
2373
        if self.is_buffer_access or self.memslice_index:
2374
            return False
2375 2376 2377
        elif self.memslice_slice:
            return True

2378 2379 2380 2381
        base = self.base
        return (base.is_simple() and self.index.is_simple()
                and base.type and (base.type.is_ptr or base.type.is_array))

William Stein's avatar
William Stein committed
2382 2383
    def analyse_target_declaration(self, env):
        pass
2384

2385 2386 2387
    def analyse_as_type(self, env):
        base_type = self.base.analyse_as_type(env)
        if base_type and not base_type.is_pyobject:
2388
            if base_type.is_cpp_class:
2389
                if isinstance(self.index, TupleNode):
2390 2391 2392 2393 2394
                    template_values = self.index.args
                else:
                    template_values = [self.index]
                import Nodes
                type_node = Nodes.TemplatedTypeNode(
2395 2396
                    pos = self.pos,
                    positional_args = template_values,
2397 2398 2399 2400
                    keyword_args = None)
                return type_node.analyse(env, base_type = base_type)
            else:
                return PyrexTypes.CArrayType(base_type, int(self.index.compile_time_value(env)))
2401
        return None
2402

Robert Bradshaw's avatar
Robert Bradshaw committed
2403
    def type_dependencies(self, env):
2404
        return self.base.type_dependencies(env) + self.index.type_dependencies(env)
2405

2406
    def infer_type(self, env):
2407 2408 2409 2410
        base_type = self.base.infer_type(env)
        if isinstance(self.index, SliceNode):
            # slicing!
            if base_type.is_string:
2411
                # sliced C strings must coerce to Python
2412
                return bytes_type
2413 2414 2415
            elif base_type in (unicode_type, bytes_type, str_type, list_type, tuple_type):
                # slicing these returns the same type
                return base_type
2416
            else:
2417 2418 2419
                # TODO: Handle buffers (hopefully without too much redundancy).
                return py_object_type

2420 2421
        index_type = self.index.infer_type(env)
        if index_type and index_type.is_int or isinstance(self.index, (IntNode, LongNode)):
2422 2423
            # indexing!
            if base_type is unicode_type:
2424 2425 2426
                # Py_UCS4 will automatically coerce to a unicode string
                # if required, so this is safe.  We only infer Py_UCS4
                # when the index is a C integer type.  Otherwise, we may
2427 2428 2429 2430
                # need to use normal Python item access, in which case
                # it's faster to return the one-char unicode string than
                # to receive it, throw it away, and potentially rebuild it
                # on a subsequent PyObject coercion.
2431
                return PyrexTypes.c_py_ucs4_type
2432 2433 2434
            elif base_type is str_type:
                # always returns str - Py2: bytes, Py3: unicode
                return base_type
2435 2436 2437 2438 2439 2440
            elif isinstance(self.base, BytesNode):
                #if env.global_scope().context.language_level >= 3:
                #    # infering 'char' can be made to work in Python 3 mode
                #    return PyrexTypes.c_char_type
                # Py2/3 return different types on indexing bytes objects
                return py_object_type
2441 2442
            elif base_type.is_ptr or base_type.is_array:
                return base_type.base_type
2443

2444
        # may be slicing or indexing, we don't know
2445 2446
        if base_type in (unicode_type, str_type):
            # these types always returns their own type on Python indexing/slicing
2447
            return base_type
2448 2449 2450
        else:
            # TODO: Handle buffers (hopefully without too much redundancy).
            return py_object_type
2451

William Stein's avatar
William Stein committed
2452
    def analyse_types(self, env):
Dag Sverre Seljebotn's avatar
Merge  
Dag Sverre Seljebotn committed
2453
        self.analyse_base_and_index_types(env, getting = 1)
2454

Dag Sverre Seljebotn's avatar
Merge  
Dag Sverre Seljebotn committed
2455 2456
    def analyse_target_types(self, env):
        self.analyse_base_and_index_types(env, setting = 1)
2457 2458
        if not self.is_lvalue():
            error(self.pos, "Assignment to non-lvalue of type '%s'" % self.type)
2459

2460
    def analyse_base_and_index_types(self, env, getting = 0, setting = 0, analyse_base = True):
2461 2462 2463
        # Note: This might be cleaned up by having IndexNode
        # parsed in a saner way and only construct the tuple if
        # needed.
2464 2465 2466 2467

        # Note that this function must leave IndexNode in a cloneable state.
        # For buffers, self.index is packed out on the initial analysis, and
        # when cloning self.indices is copied.
2468 2469
        self.is_buffer_access = False

2470
        # a[...] = b
2471
        self.is_memoryviewslice_access = False
2472 2473 2474 2475
        # incomplete indexing, Ellipsis indexing or slicing
        self.memslice_slice = False
        # integer indexing
        self.memslice_index = False
2476

2477 2478 2479
        if analyse_base:
            self.base.analyse_types(env)

2480 2481 2482 2483 2484
        if self.base.type.is_error:
            # Do not visit child tree if base is undeclared to avoid confusing
            # error messages
            self.type = PyrexTypes.error_type
            return
2485

2486
        is_slice = isinstance(self.index, SliceNode)
2487

2488
        # Potentially overflowing index value.
2489
        if not is_slice and isinstance(self.index, IntNode) and Utils.long_literal(self.index.value):
2490
            self.index = self.index.coerce_to_pyobject(env)
2491

2492 2493
        is_memslice = self.base.type.is_memoryviewslice

2494
        # Handle the case where base is a literal char* (and we expect a string, not an int)
2495
        if not is_memslice and (isinstance(self.base, BytesNode) or is_slice):
Robert Bradshaw's avatar
Robert Bradshaw committed
2496
            if self.base.type.is_string or not (self.base.type.is_ptr or self.base.type.is_array):
2497
                self.base = self.base.coerce_to_pyobject(env)
2498 2499 2500

        skip_child_analysis = False
        buffer_access = False
Mark Florisson's avatar
Mark Florisson committed
2501 2502
        memoryviewslice_access = False

2503 2504 2505 2506 2507 2508 2509
        if self.indices:
            indices = self.indices
        elif isinstance(self.index, TupleNode):
            indices = self.index.args
        else:
            indices = [self.index]

2510
        if (is_memslice and not self.indices and
Mark Florisson's avatar
Mark Florisson committed
2511
                isinstance(self.index, EllipsisNode)):
2512
            # Memoryviewslice copying
Mark Florisson's avatar
Mark Florisson committed
2513
            memoryviewslice_access = True
2514 2515 2516 2517 2518 2519

        elif is_memslice:
            # memoryviewslice indexing or slicing
            import MemoryView

            skip_child_analysis = True
2520 2521
            have_slices, indices = MemoryView.unellipsify(indices,
                                                          self.base.type.ndim)
2522 2523 2524 2525 2526 2527 2528 2529 2530 2531 2532 2533 2534 2535 2536 2537 2538 2539 2540
            self.memslice_index = len(indices) == self.base.type.ndim
            axes = []

            index_type = PyrexTypes.c_py_ssize_t_type
            new_indices = []

            if len(indices) > self.base.type.ndim:
                self.type = error_type
                return error(indices[self.base.type.ndim].pos,
                             "Too many indices specified for type %s" %
                                                        self.base.type)

            suboffsets_dim = -1
            for i, index in enumerate(indices[:]):
                index.analyse_types(env)
                access, packing = self.base.type.axes[i]
                if isinstance(index, SliceNode):
                    suboffsets_dim = i
                    self.memslice_slice = True
2541 2542
                    if index.step.is_none:
                        axes.append((access, packing))
2543 2544
                    else:
                        axes.append((access, 'strided'))
2545 2546 2547 2548 2549 2550

                    # Coerce start, stop and step to temps of the right type
                    for attr in ('start', 'stop', 'step'):
                        value = getattr(index, attr)
                        if not value.is_none:
                            value = value.coerce_to(index_type, env)
2551
                            #value = value.coerce_to_temp(env)
2552 2553 2554
                            setattr(index, attr, value)
                            new_indices.append(value)

2555 2556 2557 2558 2559
                elif index.type.is_int or index.type.is_pyobject:
                    if index.type.is_pyobject and not self.warned_untyped_idx:
                        warning(index.pos, "Index should be typed for more "
                                           "efficient access", level=2)
                        IndexNode.warned_untyped_idx = True
2560

2561
                    self.memslice_index = True
2562
                    index = index.coerce_to(index_type, env)
2563 2564 2565
                    indices[i] = index
                    new_indices.append(index)

2566
                else:
2567 2568
                    self.type = error_type
                    return error(index.pos, "Invalid index for memoryview specified")
2569

2570 2571
            self.memslice_index = self.memslice_index and not self.memslice_slice
            self.original_indices = indices
2572 2573
            # All indices with all start/stop/step for slices.
            # We need to keep this around
2574
            self.indices = new_indices
2575 2576
            self.env = env

2577 2578
        elif self.base.type.is_buffer:
            # Buffer indexing
2579
            if len(indices) == self.base.type.ndim:
2580 2581 2582 2583 2584 2585
                buffer_access = True
                skip_child_analysis = True
                for x in indices:
                    x.analyse_types(env)
                    if not x.type.is_int:
                        buffer_access = False
2586

2587
            if buffer_access and not self.base.type.is_memoryviewslice:
Robert Bradshaw's avatar
Robert Bradshaw committed
2588
                assert hasattr(self.base, "entry") # Must be a NameNode-like node
2589

Dag Sverre Seljebotn's avatar
Dag Sverre Seljebotn committed
2590 2591 2592
        # On cloning, indices is cloned. Otherwise, unpack index into indices
        assert not (buffer_access and isinstance(self.index, CloneNode))

2593 2594
        self.nogil = env.nogil

2595
        if buffer_access or self.memslice_index:
2596 2597 2598
            if self.base.type.is_memoryviewslice and not self.base.is_name:
                self.base = self.base.coerce_to_temp(env)

2599
            self.indices = indices
2600
            self.index = None
2601 2602
            self.type = self.base.type.dtype
            self.is_buffer_access = True
2603
            self.buffer_type = self.base.type #self.base.entry.type
2604 2605

            if getting and self.type.is_pyobject:
2606
                self.is_temp = True
2607 2608

            if setting and self.base.type.is_memoryviewslice:
2609
                self.base.type.writable_needed = True
2610
            elif setting:
2611 2612 2613
                if not self.base.entry.type.writable:
                    error(self.pos, "Writing to readonly buffer")
                else:
2614
                    self.writable_needed = True
2615
                    if self.base.type.is_buffer:
2616
                        self.base.entry.buffer_aux.writable_needed = True
2617

Mark Florisson's avatar
Mark Florisson committed
2618 2619 2620 2621
        elif memoryviewslice_access:
            self.type = self.base.type
            self.is_memoryviewslice_access = True
            if getting:
2622 2623 2624 2625
                self.memslice_ellipsis_noop = True
            else:
                self.is_memslice_copy = True
                self.memslice_broadcast = True
2626

2627
        elif self.memslice_slice:
2628
            self.index = None
2629
            self.is_temp = True
2630
            self.use_managed_ref = True
2631 2632
            self.type = PyrexTypes.MemoryViewSliceType(
                            self.base.type.dtype, axes)
2633 2634
            if setting:
                self.memslice_broadcast = True
2635

2636
        else:
2637
            base_type = self.base.type
2638 2639 2640 2641 2642 2643 2644 2645 2646

            fused_index_operation = base_type.is_cfunction and base_type.is_fused
            if not fused_index_operation:
                if isinstance(self.index, TupleNode):
                    self.index.analyse_types(env, skip_children=skip_child_analysis)
                elif not skip_child_analysis:
                    self.index.analyse_types(env)
                self.original_index_type = self.index.type

Stefan Behnel's avatar
Stefan Behnel committed
2647 2648
            if base_type.is_unicode_char:
                # we infer Py_UNICODE/Py_UCS4 for unicode strings in some
2649 2650 2651 2652 2653 2654 2655
                # cases, but indexing must still work for them
                if self.index.constant_result in (0, -1):
                    # FIXME: we know that this node is redundant -
                    # currently, this needs to get handled in Optimize.py
                    pass
                self.base = self.base.coerce_to_pyobject(env)
                base_type = self.base.type
2656
            if base_type.is_pyobject:
2657
                if self.index.type.is_int:
2658
                    if (not setting
2659
                        and (base_type in (list_type, tuple_type, unicode_type))
2660 2661 2662
                        and (not self.index.type.signed
                             or not env.directives['wraparound']
                             or isinstance(self.index, IntNode) and int(self.index.value) >= 0)
2663 2664 2665 2666
                        and not env.directives['boundscheck']):
                        self.is_temp = 0
                    else:
                        self.is_temp = 1
2667 2668 2669
                    self.index = self.index.coerce_to(PyrexTypes.c_py_ssize_t_type, env).coerce_to_simple(env)
                else:
                    self.index = self.index.coerce_to_pyobject(env)
2670
                    self.is_temp = 1
2671
                if self.index.type.is_int and base_type is unicode_type:
Stefan Behnel's avatar
Stefan Behnel committed
2672
                    # Py_UNICODE/Py_UCS4 will automatically coerce to a unicode string
2673
                    # if required, so this is fast and safe
2674
                    self.type = PyrexTypes.c_py_ucs4_type
2675 2676
                elif is_slice and base_type in (bytes_type, str_type, unicode_type, list_type, tuple_type):
                    self.type = base_type
2677 2678
                else:
                    self.type = py_object_type
William Stein's avatar
William Stein committed
2679
            else:
2680 2681
                if base_type.is_ptr or base_type.is_array:
                    self.type = base_type.base_type
2682 2683 2684
                    if is_slice:
                        self.type = base_type
                    elif self.index.type.is_pyobject:
Robert Bradshaw's avatar
Robert Bradshaw committed
2685 2686
                        self.index = self.index.coerce_to(
                            PyrexTypes.c_py_ssize_t_type, env)
2687
                    elif not self.index.type.is_int:
Robert Bradshaw's avatar
Robert Bradshaw committed
2688 2689 2690
                        error(self.pos,
                            "Invalid index type '%s'" %
                                self.index.type)
2691
                elif base_type.is_cpp_class:
2692
                    function = env.lookup_operator("[]", [self.base, self.index])
Robert Bradshaw's avatar
Robert Bradshaw committed
2693
                    if function is None:
2694
                        error(self.pos, "Indexing '%s' not supported for index type '%s'" % (base_type, self.index.type))
Robert Bradshaw's avatar
Robert Bradshaw committed
2695 2696 2697 2698 2699 2700 2701 2702 2703
                        self.type = PyrexTypes.error_type
                        self.result_code = "<error>"
                        return
                    func_type = function.type
                    if func_type.is_ptr:
                        func_type = func_type.base_type
                    self.index = self.index.coerce_to(func_type.args[0].type, env)
                    self.type = func_type.return_type
                    if setting and not func_type.return_type.is_reference:
Robert Bradshaw's avatar
Robert Bradshaw committed
2704
                        error(self.pos, "Can't set non-reference result '%s'" % self.type)
2705 2706
                elif fused_index_operation:
                    self.parse_indexed_fused_cdef(env)
2707 2708 2709
                else:
                    error(self.pos,
                        "Attempting to index non-array type '%s'" %
2710
                            base_type)
2711
                    self.type = PyrexTypes.error_type
Stefan Behnel's avatar
Stefan Behnel committed
2712

2713 2714 2715 2716 2717 2718 2719 2720 2721
    def parse_indexed_fused_cdef(self, env):
        """
        Interpret fused_cdef_func[specific_type1, ...]

        Note that if this method is called, we are an indexed cdef function
        with fused argument types, and this IndexNode will be replaced by the
        NameNode with specific entry just after analysis of expressions by
        AnalyseExpressionsTransform.
        """
2722
        self.type = PyrexTypes.error_type
2723

2724 2725
        self.is_fused_index = True

Mark Florisson's avatar
Mark Florisson committed
2726
        base_type = self.base.type
2727 2728 2729 2730 2731 2732 2733 2734 2735
        specific_types = []
        positions = []

        if self.index.is_name:
            positions.append(self.index.pos)
            specific_types.append(self.index.analyse_as_type(env))
        elif isinstance(self.index, TupleNode):
            for arg in self.index.args:
                positions.append(arg.pos)
2736 2737
                specific_type = arg.analyse_as_type(env)
                specific_types.append(specific_type)
2738
        else:
2739
            specific_types = [False]
2740

2741 2742 2743 2744
        if not Utils.all(specific_types):
            self.index.analyse_types(env)

            if not self.base.entry.as_variable:
2745
                error(self.pos, "Can only index fused functions with types")
2746 2747
            else:
                # A cpdef function indexed with Python objects
2748 2749
                self.base.entry = self.entry = self.base.entry.as_variable
                self.base.type = self.type = self.entry.type
2750

2751 2752 2753 2754 2755 2756
                self.base.is_temp = True
                self.is_temp = True

                self.entry.used = True

            self.is_fused_index = False
2757 2758
            return

2759 2760
        fused_types = base_type.get_fused_types()
        if len(specific_types) > len(fused_types):
2761 2762 2763 2764 2765
            return error(self.pos, "Too many types specified")
        elif len(specific_types) < len(fused_types):
            t = fused_types[len(specific_types)]
            return error(self.pos, "Not enough types specified to specialize "
                                   "the function, %s is still fused" % t)
2766 2767 2768 2769 2770 2771 2772

        # See if our index types form valid specializations
        for pos, specific_type, fused_type in zip(positions,
                                                  specific_types,
                                                  fused_types):
            if not Utils.any([specific_type.same_as(t)
                                  for t in fused_type.types]):
2773
                return error(pos, "Type not in fused type")
2774 2775 2776 2777 2778 2779 2780

            if specific_type is None or specific_type.is_error:
                return

        fused_to_specific = dict(zip(fused_types, specific_types))
        type = base_type.specialize(fused_to_specific)

2781 2782 2783 2784 2785
        if type.is_fused:
            # Only partially specific, this is invalid
            error(self.pos,
                  "Index operation makes function only partially specific")
        else:
2786 2787 2788 2789
            # Fully specific, find the signature with the specialized entry
            for signature in self.base.type.get_all_specific_function_types():
                if type.same_as(signature):
                    self.type = signature
Mark Florisson's avatar
Mark Florisson committed
2790 2791 2792 2793 2794

                    if self.base.is_attribute:
                        # Pretend to be a normal attribute, for cdef extension
                        # methods
                        self.entry = signature.entry
2795
                        self.is_attribute = True
Mark Florisson's avatar
Mark Florisson committed
2796
                        self.obj = self.base.obj
2797 2798 2799 2800

                    self.type.entry.used = True
                    self.base.type = signature
                    self.base.entry = signature.entry
Mark Florisson's avatar
Mark Florisson committed
2801

2802 2803
                    break
            else:
Mark Florisson's avatar
Mark Florisson committed
2804 2805
                # This is a bug
                raise InternalError("Couldn't find the right signature")
2806

2807 2808
    gil_message = "Indexing Python object"

2809
    def nogil_check(self, env):
2810 2811
        if self.is_buffer_access or self.memslice_index or self.memslice_slice:
            if not self.memslice_slice and env.directives['boundscheck']:
2812 2813 2814 2815 2816
                error(self.pos, "Cannot check buffer index bounds without gil; use boundscheck(False) directive")
                return
            elif self.type.is_pyobject:
                error(self.pos, "Cannot access buffer with object dtype without gil")
                return
2817
        super(IndexNode, self).nogil_check(env)
2818 2819


William Stein's avatar
William Stein committed
2820
    def check_const_addr(self):
2821
        return self.base.check_const_addr() and self.index.check_const()
2822

William Stein's avatar
William Stein committed
2823
    def is_lvalue(self):
2824 2825 2826 2827 2828
        base_type = self.base.type
        if self.type.is_ptr or self.type.is_array:
            return not base_type.base_type.is_array
        else:
            return True
Dag Sverre Seljebotn's avatar
merge  
Dag Sverre Seljebotn committed
2829

William Stein's avatar
William Stein committed
2830
    def calculate_result_code(self):
2831
        if self.is_buffer_access:
2832
            return "(*%s)" % self.buffer_ptr_code
2833 2834
        elif self.is_memslice_copy:
            return self.base.result()
2835 2836 2837 2838
        elif self.base.type is list_type:
            return "PyList_GET_ITEM(%s, %s)" % (self.base.result(), self.index.result())
        elif self.base.type is tuple_type:
            return "PyTuple_GET_ITEM(%s, %s)" % (self.base.result(), self.index.result())
Stefan Behnel's avatar
Stefan Behnel committed
2839
        elif self.base.type is unicode_type and self.type.is_unicode_char:
2840
            return "__Pyx_PyUnicode_READ_CHAR(%s, %s)" % (self.base.result(), self.index.result())
2841 2842
        elif (self.type.is_ptr or self.type.is_array) and self.type == self.base.type:
            error(self.pos, "Invalid use of pointer slice")
2843 2844
        else:
            return "(%s[%s])" % (
2845
                self.base.result(), self.index.result())
2846

2847
    def extra_index_params(self):
Dag Sverre Seljebotn's avatar
Merge  
Dag Sverre Seljebotn committed
2848 2849
        if self.index.type.is_int:
            if self.original_index_type.signed:
2850
                size_adjustment = ""
Dag Sverre Seljebotn's avatar
Merge  
Dag Sverre Seljebotn committed
2851
            else:
2852 2853
                size_adjustment = "+1"
            return ", sizeof(%s)%s, %s" % (self.original_index_type.declaration_code(""), size_adjustment, self.original_index_type.to_py_function)
Dag Sverre Seljebotn's avatar
Merge  
Dag Sverre Seljebotn committed
2854 2855
        else:
            return ""
2856 2857 2858

    def generate_subexpr_evaluation_code(self, code):
        self.base.generate_evaluation_code(code)
2859
        if self.indices is None:
2860 2861
            self.index.generate_evaluation_code(code)
        else:
2862 2863
            for i in self.indices:
                i.generate_evaluation_code(code)
2864

2865 2866
    def generate_subexpr_disposal_code(self, code):
        self.base.generate_disposal_code(code)
2867
        if self.indices is None:
2868 2869
            self.index.generate_disposal_code(code)
        else:
2870 2871
            for i in self.indices:
                i.generate_disposal_code(code)
2872

2873 2874
    def free_subexpr_temps(self, code):
        self.base.free_temps(code)
2875
        if self.indices is None:
2876 2877 2878 2879 2880
            self.index.free_temps(code)
        else:
            for i in self.indices:
                i.free_temps(code)

William Stein's avatar
William Stein committed
2881
    def generate_result_code(self, code):
2882
        if self.is_buffer_access or self.memslice_index:
2883 2884
            if code.globalstate.directives['nonecheck']:
                self.put_nonecheck(code)
2885
            buffer_entry, self.buffer_ptr_code = self.buffer_lookup_code(code)
2886 2887 2888
            if self.type.is_pyobject:
                # is_temp is True, so must pull out value and incref it.
                code.putln("%s = *%s;" % (self.result(), self.buffer_ptr_code))
Dag Sverre Seljebotn's avatar
Dag Sverre Seljebotn committed
2889
                code.putln("__Pyx_INCREF((PyObject*)%s);" % self.result())
2890 2891 2892 2893

        elif self.memslice_slice:
            self.put_memoryviewslice_slice_code(code)

2894 2895 2896 2897 2898 2899 2900 2901 2902 2903 2904
        elif self.is_temp:
            if self.type.is_pyobject:
                if self.index.type.is_int:
                    index_code = self.index.result()
                    if self.base.type is list_type:
                        function = "__Pyx_GetItemInt_List"
                    elif self.base.type is tuple_type:
                        function = "__Pyx_GetItemInt_Tuple"
                    else:
                        function = "__Pyx_GetItemInt"
                    code.globalstate.use_utility_code(getitem_int_utility_code)
2905
                else:
2906 2907 2908 2909 2910 2911 2912 2913 2914 2915 2916 2917 2918 2919 2920 2921
                    index_code = self.index.py_result()
                    if self.base.type is dict_type:
                        function = "__Pyx_PyDict_GetItem"
                        code.globalstate.use_utility_code(getitem_dict_utility_code)
                    else:
                        function = "PyObject_GetItem"
                code.putln(
                    "%s = %s(%s, %s%s); if (!%s) %s" % (
                        self.result(),
                        function,
                        self.base.py_result(),
                        index_code,
                        self.extra_index_params(),
                        self.result(),
                        code.error_goto(self.pos)))
                code.put_gotref(self.py_result())
Stefan Behnel's avatar
Stefan Behnel committed
2922
            elif self.type.is_unicode_char and self.base.type is unicode_type:
2923 2924 2925
                assert self.index.type.is_int
                index_code = self.index.result()
                function = "__Pyx_GetItemInt_Unicode"
2926 2927
                code.globalstate.use_utility_code(getitem_int_pyunicode_utility_code)
                code.putln(
2928
                    "%s = %s(%s, %s%s); if (unlikely(%s == (Py_UCS4)-1)) %s;" % (
2929 2930 2931 2932 2933 2934 2935
                        self.result(),
                        function,
                        self.base.py_result(),
                        index_code,
                        self.extra_index_params(),
                        self.result(),
                        code.error_goto(self.pos)))
2936

Dag Sverre Seljebotn's avatar
Merge  
Dag Sverre Seljebotn committed
2937 2938 2939
    def generate_setitem_code(self, value_code, code):
        if self.index.type.is_int:
            function = "__Pyx_SetItemInt"
2940
            index_code = self.index.result()
2941
            code.globalstate.use_utility_code(setitem_int_utility_code)
Dag Sverre Seljebotn's avatar
Merge  
Dag Sverre Seljebotn committed
2942 2943
        else:
            index_code = self.index.py_result()
2944 2945
            if self.base.type is dict_type:
                function = "PyDict_SetItem"
Craig Citro's avatar
Craig Citro committed
2946
            # It would seem that we could specialized lists/tuples, but that
2947 2948 2949 2950 2951 2952
            # shouldn't happen here.
            # Both PyList_SetItem PyTuple_SetItem and a Py_ssize_t as input,
            # not a PyObject*, and bad conversion here would give the wrong
            # exception. Also, tuples are supposed to be immutable, and raise
            # TypeErrors when trying to set their entries (PyTuple_SetItem
            # is for creating new tuples from).
2953 2954
            else:
                function = "PyObject_SetItem"
2955
        code.putln(
Dag Sverre Seljebotn's avatar
Merge  
Dag Sverre Seljebotn committed
2956 2957
            "if (%s(%s, %s, %s%s) < 0) %s" % (
                function,
2958
                self.base.py_result(),
Dag Sverre Seljebotn's avatar
Merge  
Dag Sverre Seljebotn committed
2959 2960
                index_code,
                value_code,
2961
                self.extra_index_params(),
Dag Sverre Seljebotn's avatar
Merge  
Dag Sverre Seljebotn committed
2962
                code.error_goto(self.pos)))
2963 2964 2965

    def generate_buffer_setitem_code(self, rhs, code, op=""):
        # Used from generate_assignment_code and InPlaceAssignmentNode
2966
        if code.globalstate.directives['nonecheck'] and not self.memslice_index:
2967
            self.put_nonecheck(code)
2968 2969 2970

        buffer_entry, ptrexpr = self.buffer_lookup_code(code)

2971 2972 2973
        if self.buffer_type.dtype.is_pyobject:
            # Must manage refcounts. Decref what is already there
            # and incref what we put in.
2974 2975
            ptr = code.funcstate.allocate_temp(buffer_entry.buf_ptr_type,
                                               manage_ref=False)
2976
            rhs_code = rhs.result()
2977
            code.putln("%s = %s;" % (ptr, ptrexpr))
2978
            code.put_gotref("*%s" % ptr)
Dag Sverre Seljebotn's avatar
Dag Sverre Seljebotn committed
2979
            code.putln("__Pyx_DECREF(*%s); __Pyx_INCREF(%s);" % (
2980 2981 2982
                ptr, rhs_code
                ))
            code.putln("*%s %s= %s;" % (ptr, op, rhs_code))
2983
            code.put_giveref("*%s" % ptr)
2984
            code.funcstate.release_temp(ptr)
2985
        else:
2986
            # Simple case
2987
            code.putln("*%s %s= %s;" % (ptrexpr, op, rhs.result()))
2988

William Stein's avatar
William Stein committed
2989 2990
    def generate_assignment_code(self, rhs, code):
        self.generate_subexpr_evaluation_code(code)
2991
        if self.is_buffer_access or self.memslice_index:
2992
            self.generate_buffer_setitem_code(rhs, code)
2993 2994
        elif self.is_memslice_scalar_assignment:
            self.generate_memoryviewslice_assign_scalar_code(rhs, code)
2995
        elif self.memslice_slice:
2996
            self.generate_memoryviewslice_setslice_code(rhs, code)
2997
        elif self.is_memoryviewslice_access:
2998
            self.generate_memoryviewslice_copy_code(rhs, code)
2999
        elif self.type.is_pyobject:
Dag Sverre Seljebotn's avatar
Merge  
Dag Sverre Seljebotn committed
3000
            self.generate_setitem_code(rhs.py_result(), code)
William Stein's avatar
William Stein committed
3001 3002 3003
        else:
            code.putln(
                "%s = %s;" % (
3004
                    self.result(), rhs.result()))
3005
        self.generate_subexpr_disposal_code(code)
3006
        self.free_subexpr_temps(code)
William Stein's avatar
William Stein committed
3007
        rhs.generate_disposal_code(code)
3008
        rhs.free_temps(code)
3009

William Stein's avatar
William Stein committed
3010 3011
    def generate_deletion_code(self, code):
        self.generate_subexpr_evaluation_code(code)
Dag Sverre Seljebotn's avatar
Merge  
Dag Sverre Seljebotn committed
3012 3013
        #if self.type.is_pyobject:
        if self.index.type.is_int:
3014
            function = "__Pyx_DelItemInt"
3015
            index_code = self.index.result()
3016
            code.globalstate.use_utility_code(delitem_int_utility_code)
Dag Sverre Seljebotn's avatar
Merge  
Dag Sverre Seljebotn committed
3017 3018
        else:
            index_code = self.index.py_result()
3019 3020 3021 3022
            if self.base.type is dict_type:
                function = "PyDict_DelItem"
            else:
                function = "PyObject_DelItem"
Dag Sverre Seljebotn's avatar
Merge  
Dag Sverre Seljebotn committed
3023
        code.putln(
3024
            "if (%s(%s, %s%s) < 0) %s" % (
Dag Sverre Seljebotn's avatar
Merge  
Dag Sverre Seljebotn committed
3025
                function,
William Stein's avatar
William Stein committed
3026
                self.base.py_result(),
Dag Sverre Seljebotn's avatar
Merge  
Dag Sverre Seljebotn committed
3027
                index_code,
3028
                self.extra_index_params(),
Dag Sverre Seljebotn's avatar
Merge  
Dag Sverre Seljebotn committed
3029
                code.error_goto(self.pos)))
William Stein's avatar
William Stein committed
3030
        self.generate_subexpr_disposal_code(code)
3031
        self.free_subexpr_temps(code)
3032

3033 3034 3035 3036 3037 3038 3039 3040 3041 3042 3043 3044 3045 3046 3047 3048 3049
    def buffer_entry(self):
        import Buffer, MemoryView

        if self.base.is_name:
            entry = self.base.entry
        else:
            assert self.base.is_temp
            cname = self.base.result()
            entry = Symtab.Entry(cname, cname, self.base.type, self.base.pos)

        if entry.type.is_buffer:
            buffer_entry = Buffer.BufferEntry(entry)
        else:
            buffer_entry = MemoryView.MemoryViewSliceBufferEntry(entry)

        return buffer_entry

3050
    def buffer_lookup_code(self, code):
3051
        "ndarray[1, 2, 3] and memslice[1, 2, 3]"
3052
        # Assign indices to temps
3053 3054 3055
        index_temps = [code.funcstate.allocate_temp(i.type, manage_ref=False)
                           for i in self.indices]

3056
        for temp, index in zip(index_temps, self.indices):
3057
            code.putln("%s = %s;" % (temp, index.result()))
3058

3059
        # Generate buffer access code using these temps
3060
        import Buffer, MemoryView
3061

3062
        buffer_entry = self.buffer_entry()
3063

3064
        if buffer_entry.type.is_buffer:
3065
            negative_indices = buffer_entry.type.negative_indices
3066 3067 3068
        else:
            negative_indices = Buffer.buffer_defaults['negative_indices']

3069 3070 3071 3072 3073 3074 3075
        return buffer_entry, Buffer.put_buffer_lookup_code(
               entry=buffer_entry,
               index_signeds=[i.type.signed for i in self.indices],
               index_cnames=index_temps,
               directives=code.globalstate.directives,
               pos=self.pos, code=code,
               negative_indices=negative_indices)
William Stein's avatar
William Stein committed
3076

3077
    def put_memoryviewslice_slice_code(self, code):
3078
        "memslice[:]"
3079
        buffer_entry = self.buffer_entry()
3080
        have_gil = not self.in_nogil_context
3081

3082 3083 3084 3085 3086 3087
        if sys.version_info < (3,):
            def next_(it):
                return it.next()
        else:
            next_ = next

3088 3089 3090 3091 3092 3093 3094
        have_slices = False
        it = iter(self.indices)
        for index in self.original_indices:
            is_slice = isinstance(index, SliceNode)
            have_slices = have_slices or is_slice
            if is_slice:
                if not index.start.is_none:
3095
                    index.start = next_(it)
3096
                if not index.stop.is_none:
3097
                    index.stop = next_(it)
3098
                if not index.step.is_none:
3099
                    index.step = next_(it)
3100
            else:
3101
                next_(it)
3102 3103 3104 3105

        assert not list(it)

        buffer_entry.generate_buffer_slice_code(code, self.original_indices,
3106
                                                self.result(),
3107 3108
                                                have_gil=have_gil,
                                                have_slices=have_slices)
William Stein's avatar
William Stein committed
3109

3110 3111 3112 3113 3114 3115 3116 3117 3118 3119 3120
    def generate_memoryviewslice_setslice_code(self, rhs, code):
        "memslice1[:] = memslice2"
        import MemoryView
        self.generate_evaluation_code(code)
        MemoryView.copy_broadcast_memview_src_to_dst(rhs, self, code)

    def generate_memoryviewslice_copy_code(self, rhs, code):
        "memslice1[...] = memslice2"
        import MemoryView
        MemoryView.copy_broadcast_memview_src_to_dst(rhs, self, code)

3121 3122 3123 3124 3125 3126
    def generate_memoryviewslice_assign_scalar_code(self, rhs, code):
        "memslice1[...] = 0.0 or memslice1[:] = 0.0"
        import MemoryView
        self.generate_evaluation_code(code)
        MemoryView.assign_scalar(self, rhs, code)

3127 3128 3129 3130 3131 3132 3133
    def put_nonecheck(self, code):
        code.globalstate.use_utility_code(raise_noneindex_error_utility_code)
        code.putln("if (%s) {" % code.unlikely("%s == Py_None") % self.base.result_as(PyrexTypes.py_object_type))
        code.putln("__Pyx_RaiseNoneIndexingError();")
        code.putln(code.error_goto(self.pos))
        code.putln("}")

3134

3135
class SliceIndexNode(ExprNode):
William Stein's avatar
William Stein committed
3136 3137 3138 3139 3140
    #  2-element slice indexing
    #
    #  base      ExprNode
    #  start     ExprNode or None
    #  stop      ExprNode or None
3141

William Stein's avatar
William Stein committed
3142
    subexprs = ['base', 'start', 'stop']
3143

3144 3145 3146 3147 3148 3149 3150
    def infer_type(self, env):
        base_type = self.base.infer_type(env)
        if base_type.is_string:
            return bytes_type
        elif base_type in (bytes_type, str_type, unicode_type,
                           list_type, tuple_type):
            return base_type
3151 3152
        elif base_type.is_ptr or base_type.is_array:
            return PyrexTypes.c_array_type(base_type.base_type, None)
3153 3154
        return py_object_type

3155 3156 3157 3158
    def calculate_constant_result(self):
        self.constant_result = self.base.constant_result[
            self.start.constant_result : self.stop.constant_result]

3159 3160
    def compile_time_value(self, denv):
        base = self.base.compile_time_value(denv)
3161 3162 3163 3164 3165 3166 3167 3168
        if self.start is None:
            start = 0
        else:
            start = self.start.compile_time_value(denv)
        if self.stop is None:
            stop = None
        else:
            stop = self.stop.compile_time_value(denv)
3169 3170 3171 3172
        try:
            return base[start:stop]
        except Exception, e:
            self.compile_time_value_error(e)
3173

William Stein's avatar
William Stein committed
3174 3175
    def analyse_target_declaration(self, env):
        pass
3176

3177
    def analyse_target_types(self, env):
3178
        self.analyse_types(env, getting=False)
3179
        # when assigning, we must accept any Python type
3180 3181
        if self.type.is_pyobject:
            self.type = py_object_type
William Stein's avatar
William Stein committed
3182

3183
    def analyse_types(self, env, getting=True):
William Stein's avatar
William Stein committed
3184
        self.base.analyse_types(env)
3185 3186 3187 3188 3189 3190 3191 3192 3193 3194 3195 3196 3197 3198 3199 3200 3201 3202 3203 3204

        if self.base.type.is_memoryviewslice:
            # Gross hack here! But we do not know the type until this point,
            # and we cannot create and return a new node. So we change the
            # type...
            none_node = NoneNode(self.pos)
            index = SliceNode(self.pos,
                              start=self.start or none_node,
                              stop=self.stop or none_node,
                              step=none_node)
            del self.start
            del self.stop
            self.index = index
            self.__class__ = IndexNode
            self.analyse_base_and_index_types(env,
                                              getting=getting,
                                              setting=not getting,
                                              analyse_base=False)
            return

William Stein's avatar
William Stein committed
3205 3206 3207 3208
        if self.start:
            self.start.analyse_types(env)
        if self.stop:
            self.stop.analyse_types(env)
3209 3210 3211
        base_type = self.base.type
        if base_type.is_string:
            self.type = bytes_type
3212 3213 3214
        elif base_type.is_ptr:
            self.type = base_type
        elif base_type.is_array:
3215 3216 3217
            # we need a ptr type here instead of an array type, as
            # array types can result in invalid type casts in the C
            # code
3218
            self.type = PyrexTypes.CPtrType(base_type.base_type)
3219 3220 3221
        else:
            self.base = self.base.coerce_to_pyobject(env)
            self.type = py_object_type
3222 3223 3224
        if base_type.is_builtin_type:
            # slicing builtin types returns something of the same type
            self.type = base_type
3225
        c_int = PyrexTypes.c_py_ssize_t_type
William Stein's avatar
William Stein committed
3226 3227 3228 3229 3230
        if self.start:
            self.start = self.start.coerce_to(c_int, env)
        if self.stop:
            self.stop = self.stop.coerce_to(c_int, env)
        self.is_temp = 1
3231

3232
    nogil_check = Node.gil_error
3233 3234
    gil_message = "Slicing Python object"

William Stein's avatar
William Stein committed
3235
    def generate_result_code(self, code):
3236 3237 3238 3239
        if not self.type.is_pyobject:
            error(self.pos,
                  "Slicing is not currently supported for '%s'." % self.type)
            return
Robert Bradshaw's avatar
Robert Bradshaw committed
3240 3241 3242
        if self.base.type.is_string:
            if self.stop is None:
                code.putln(
3243
                    "%s = PyBytes_FromString(%s + %s); %s" % (
Robert Bradshaw's avatar
Robert Bradshaw committed
3244 3245 3246 3247 3248 3249
                        self.result(),
                        self.base.result(),
                        self.start_code(),
                        code.error_goto_if_null(self.result(), self.pos)))
            else:
                code.putln(
3250
                    "%s = PyBytes_FromStringAndSize(%s + %s, %s - %s); %s" % (
Robert Bradshaw's avatar
Robert Bradshaw committed
3251 3252 3253 3254 3255 3256 3257 3258
                        self.result(),
                        self.base.result(),
                        self.start_code(),
                        self.stop_code(),
                        self.start_code(),
                        code.error_goto_if_null(self.result(), self.pos)))
        else:
            code.putln(
3259
                "%s = __Pyx_PySequence_GetSlice(%s, %s, %s); %s" % (
Robert Bradshaw's avatar
Robert Bradshaw committed
3260 3261 3262 3263 3264
                    self.result(),
                    self.base.py_result(),
                    self.start_code(),
                    self.stop_code(),
                    code.error_goto_if_null(self.result(), self.pos)))
3265
        code.put_gotref(self.py_result())
3266

William Stein's avatar
William Stein committed
3267 3268
    def generate_assignment_code(self, rhs, code):
        self.generate_subexpr_evaluation_code(code)
3269
        if self.type.is_pyobject:
3270
            code.put_error_if_neg(self.pos,
3271
                "__Pyx_PySequence_SetSlice(%s, %s, %s, %s)" % (
3272 3273 3274
                    self.base.py_result(),
                    self.start_code(),
                    self.stop_code(),
Lisandro Dalcin's avatar
Lisandro Dalcin committed
3275
                    rhs.py_result()))
3276 3277 3278 3279 3280 3281 3282 3283
        else:
            start_offset = ''
            if self.start:
                start_offset = self.start_code()
                if start_offset == '0':
                    start_offset = ''
                else:
                    start_offset += '+'
Stefan Behnel's avatar
Stefan Behnel committed
3284 3285
            if rhs.type.is_array:
                array_length = rhs.type.size
3286
                self.generate_slice_guard_code(code, array_length)
Stefan Behnel's avatar
Stefan Behnel committed
3287
            else:
Stefan Behnel's avatar
Stefan Behnel committed
3288 3289
                error(self.pos,
                      "Slice assignments from pointers are not yet supported.")
Stefan Behnel's avatar
Stefan Behnel committed
3290 3291
                # FIXME: fix the array size according to start/stop
                array_length = self.base.type.size
3292 3293 3294 3295
            for i in range(array_length):
                code.putln("%s[%s%s] = %s[%d];" % (
                        self.base.result(), start_offset, i,
                        rhs.result(), i))
William Stein's avatar
William Stein committed
3296
        self.generate_subexpr_disposal_code(code)
3297
        self.free_subexpr_temps(code)
William Stein's avatar
William Stein committed
3298
        rhs.generate_disposal_code(code)
3299
        rhs.free_temps(code)
William Stein's avatar
William Stein committed
3300 3301

    def generate_deletion_code(self, code):
Robert Bradshaw's avatar
Robert Bradshaw committed
3302
        if not self.base.type.is_pyobject:
3303 3304 3305
            error(self.pos,
                  "Deleting slices is only supported for Python types, not '%s'." % self.type)
            return
William Stein's avatar
William Stein committed
3306
        self.generate_subexpr_evaluation_code(code)
Robert Bradshaw's avatar
Robert Bradshaw committed
3307
        code.put_error_if_neg(self.pos,
3308
            "__Pyx_PySequence_DelSlice(%s, %s, %s)" % (
William Stein's avatar
William Stein committed
3309 3310
                self.base.py_result(),
                self.start_code(),
Robert Bradshaw's avatar
Robert Bradshaw committed
3311
                self.stop_code()))
William Stein's avatar
William Stein committed
3312
        self.generate_subexpr_disposal_code(code)
3313
        self.free_subexpr_temps(code)
3314 3315 3316 3317 3318 3319 3320 3321 3322 3323

    def generate_slice_guard_code(self, code, target_size):
        if not self.base.type.is_array:
            return
        slice_size = self.base.type.size
        start = stop = None
        if self.stop:
            stop = self.stop.result()
            try:
                stop = int(stop)
Stefan Behnel's avatar
Stefan Behnel committed
3324
                if stop < 0:
3325
                    slice_size = self.base.type.size + stop
Stefan Behnel's avatar
Stefan Behnel committed
3326 3327
                else:
                    slice_size = stop
3328 3329 3330 3331 3332 3333 3334 3335 3336 3337 3338 3339 3340 3341 3342 3343 3344 3345 3346 3347 3348 3349 3350 3351 3352 3353 3354 3355 3356 3357
                stop = None
            except ValueError:
                pass
        if self.start:
            start = self.start.result()
            try:
                start = int(start)
                if start < 0:
                    start = self.base.type.size + start
                slice_size -= start
                start = None
            except ValueError:
                pass
        check = None
        if slice_size < 0:
            if target_size > 0:
                error(self.pos, "Assignment to empty slice.")
        elif start is None and stop is None:
            # we know the exact slice length
            if target_size != slice_size:
                error(self.pos, "Assignment to slice of wrong length, expected %d, got %d" % (
                        slice_size, target_size))
        elif start is not None:
            if stop is None:
                stop = slice_size
            check = "(%s)-(%s)" % (stop, start)
        else: # stop is not None:
            check = stop
        if check:
            code.putln("if (unlikely((%s) != %d)) {" % (check, target_size))
3358
            code.putln('PyErr_Format(PyExc_ValueError, "Assignment to slice of wrong length, expected %%"PY_FORMAT_SIZE_T"d, got %%"PY_FORMAT_SIZE_T"d", (Py_ssize_t)%d, (Py_ssize_t)(%s));' % (
3359 3360 3361
                        target_size, check))
            code.putln(code.error_goto(self.pos))
            code.putln("}")
3362

William Stein's avatar
William Stein committed
3363 3364
    def start_code(self):
        if self.start:
3365
            return self.start.result()
William Stein's avatar
William Stein committed
3366 3367
        else:
            return "0"
3368

William Stein's avatar
William Stein committed
3369 3370
    def stop_code(self):
        if self.stop:
3371
            return self.stop.result()
3372 3373
        elif self.base.type.is_array:
            return self.base.type.size
William Stein's avatar
William Stein committed
3374
        else:
3375
            return "PY_SSIZE_T_MAX"
3376

William Stein's avatar
William Stein committed
3377
    def calculate_result_code(self):
3378
        # self.result() is not used, but this method must exist
William Stein's avatar
William Stein committed
3379
        return "<unused>"
3380

William Stein's avatar
William Stein committed
3381

3382
class SliceNode(ExprNode):
William Stein's avatar
William Stein committed
3383 3384 3385 3386 3387
    #  start:stop:step in subscript list
    #
    #  start     ExprNode
    #  stop      ExprNode
    #  step      ExprNode
3388

3389 3390
    subexprs = ['start', 'stop', 'step']

3391 3392
    type = py_object_type
    is_temp = 1
3393 3394

    def calculate_constant_result(self):
3395 3396 3397 3398
        self.constant_result = slice(
            self.start.constant_result,
            self.stop.constant_result,
            self.step.constant_result)
3399

3400 3401
    def compile_time_value(self, denv):
        start = self.start.compile_time_value(denv)
Stefan Behnel's avatar
Stefan Behnel committed
3402 3403
        stop = self.stop.compile_time_value(denv)
        step = self.step.compile_time_value(denv)
3404 3405 3406 3407 3408
        try:
            return slice(start, stop, step)
        except Exception, e:
            self.compile_time_value_error(e)

William Stein's avatar
William Stein committed
3409 3410 3411 3412 3413 3414 3415
    def analyse_types(self, env):
        self.start.analyse_types(env)
        self.stop.analyse_types(env)
        self.step.analyse_types(env)
        self.start = self.start.coerce_to_pyobject(env)
        self.stop = self.stop.coerce_to_pyobject(env)
        self.step = self.step.coerce_to_pyobject(env)
3416 3417 3418
        if self.start.is_literal and self.stop.is_literal and self.step.is_literal:
            self.is_literal = True
            self.is_temp = False
3419 3420 3421

    gil_message = "Constructing Python slice object"

3422 3423 3424
    def calculate_result_code(self):
        return self.result_code

William Stein's avatar
William Stein committed
3425
    def generate_result_code(self, code):
3426 3427 3428 3429 3430
        if self.is_literal:
            self.result_code = code.get_py_const(py_object_type, 'slice_', cleanup_level=2)
            code = code.get_cached_constants_writer()
            code.mark_pos(self.pos)

William Stein's avatar
William Stein committed
3431
        code.putln(
Robert Bradshaw's avatar
Robert Bradshaw committed
3432
            "%s = PySlice_New(%s, %s, %s); %s" % (
3433
                self.result(),
3434 3435
                self.start.py_result(),
                self.stop.py_result(),
William Stein's avatar
William Stein committed
3436
                self.step.py_result(),
3437
                code.error_goto_if_null(self.result(), self.pos)))
3438
        code.put_gotref(self.py_result())
3439 3440
        if self.is_literal:
            code.put_giveref(self.py_result())
William Stein's avatar
William Stein committed
3441

3442

3443
class CallNode(ExprNode):
3444

Stefan Behnel's avatar
Stefan Behnel committed
3445 3446 3447
    # allow overriding the default 'may_be_none' behaviour
    may_return_none = None

3448 3449 3450 3451 3452 3453 3454 3455 3456 3457 3458 3459 3460 3461 3462 3463 3464 3465 3466 3467 3468
    def infer_type(self, env):
        function = self.function
        func_type = function.infer_type(env)
        if isinstance(self.function, NewExprNode):
            return PyrexTypes.CPtrType(self.function.class_type)
        if func_type.is_ptr:
            func_type = func_type.base_type
        if func_type.is_cfunction:
            return func_type.return_type
        elif func_type is type_type:
            if function.is_name and function.entry and function.entry.type:
                result_type = function.entry.type
                if result_type.is_extension_type:
                    return result_type
                elif result_type.is_builtin_type:
                    if function.entry.name == 'float':
                        return PyrexTypes.c_double_type
                    elif function.entry.name in Builtin.types_that_construct_their_instance:
                        return result_type
        return py_object_type

Robert Bradshaw's avatar
Robert Bradshaw committed
3469 3470 3471 3472 3473
    def type_dependencies(self, env):
        # TODO: Update when Danilo's C++ code merged in to handle the
        # the case of function overloading.
        return self.function.type_dependencies(env)

Stefan Behnel's avatar
Stefan Behnel committed
3474 3475 3476 3477 3478
    def may_be_none(self):
        if self.may_return_none is not None:
            return self.may_return_none
        return ExprNode.may_be_none(self)

Robert Bradshaw's avatar
Robert Bradshaw committed
3479 3480 3481 3482 3483 3484
    def analyse_as_type_constructor(self, env):
        type = self.function.analyse_as_type(env)
        if type and type.is_struct_or_union:
            args, kwds = self.explicit_args_kwds()
            items = []
            for arg, member in zip(args, type.scope.var_entries):
3485
                items.append(DictItemNode(pos=arg.pos, key=StringNode(pos=arg.pos, value=member.name), value=arg))
Robert Bradshaw's avatar
Robert Bradshaw committed
3486 3487 3488 3489 3490 3491 3492
            if kwds:
                items += kwds.key_value_pairs
            self.key_value_pairs = items
            self.__class__ = DictNode
            self.analyse_types(env)
            self.coerce_to(type, env)
            return True
3493 3494 3495 3496 3497 3498 3499 3500 3501
        elif type and type.is_cpp_class:
            for arg in self.args:
                arg.analyse_types(env)
            constructor = type.scope.lookup("<init>")
            self.function = RawCNameExprNode(self.function.pos, constructor.type)
            self.function.entry = constructor
            self.function.set_cname(type.declaration_code(""))
            self.analyse_c_function_call(env)
            return True
3502

3503 3504
    def is_lvalue(self):
        return self.type.is_reference
3505

3506
    def nogil_check(self, env):
3507 3508
        func_type = self.function_type()
        if func_type.is_pyobject:
3509
            self.gil_error()
3510
        elif not getattr(func_type, 'nogil', False):
3511
            self.gil_error()
3512 3513 3514

    gil_message = "Calling gil-requiring function"

3515 3516

class SimpleCallNode(CallNode):
William Stein's avatar
William Stein committed
3517 3518 3519 3520 3521 3522 3523
    #  Function call without keyword, * or ** args.
    #
    #  function       ExprNode
    #  args           [ExprNode]
    #  arg_tuple      ExprNode or None     used internally
    #  self           ExprNode or None     used internally
    #  coerced_self   ExprNode or None     used internally
3524
    #  wrapper_call   bool                 used internally
3525
    #  has_optional_args   bool            used internally
3526
    #  nogil          bool                 used internally
3527

William Stein's avatar
William Stein committed
3528
    subexprs = ['self', 'coerced_self', 'function', 'args', 'arg_tuple']
3529

William Stein's avatar
William Stein committed
3530 3531 3532
    self = None
    coerced_self = None
    arg_tuple = None
3533
    wrapper_call = False
3534
    has_optional_args = False
3535
    nogil = False
3536
    analysed = False
3537

3538 3539 3540 3541 3542 3543 3544
    def compile_time_value(self, denv):
        function = self.function.compile_time_value(denv)
        args = [arg.compile_time_value(denv) for arg in self.args]
        try:
            return function(*args)
        except Exception, e:
            self.compile_time_value_error(e)
3545

3546
    def analyse_as_type(self, env):
3547
        attr = self.function.as_cython_attribute()
3548 3549 3550 3551 3552 3553 3554 3555 3556 3557 3558 3559
        if attr == 'pointer':
            if len(self.args) != 1:
                error(self.args.pos, "only one type allowed.")
            else:
                type = self.args[0].analyse_as_type(env)
                if not type:
                    error(self.args[0].pos, "Unknown type")
                else:
                    return PyrexTypes.CPtrType(type)

    def explicit_args_kwds(self):
        return self.args, None
3560

William Stein's avatar
William Stein committed
3561
    def analyse_types(self, env):
Robert Bradshaw's avatar
Robert Bradshaw committed
3562 3563
        if self.analyse_as_type_constructor(env):
            return
3564 3565 3566
        if self.analysed:
            return
        self.analysed = True
William Stein's avatar
William Stein committed
3567 3568 3569
        function = self.function
        function.is_called = 1
        self.function.analyse_types(env)
Mark Florisson's avatar
Mark Florisson committed
3570

William Stein's avatar
William Stein committed
3571 3572 3573 3574 3575
        if function.is_attribute and function.entry and function.entry.is_cmethod:
            # Take ownership of the object from which the attribute
            # was obtained, because we need to pass it as 'self'.
            self.self = function.obj
            function.obj = CloneNode(self.self)
Mark Florisson's avatar
Mark Florisson committed
3576

William Stein's avatar
William Stein committed
3577 3578
        func_type = self.function_type()
        if func_type.is_pyobject:
3579 3580
            self.arg_tuple = TupleNode(self.pos, args = self.args)
            self.arg_tuple.analyse_types(env)
William Stein's avatar
William Stein committed
3581
            self.args = None
3582 3583 3584
            if func_type is Builtin.type_type and function.is_name and \
                   function.entry and \
                   function.entry.is_builtin and \
3585 3586 3587 3588 3589 3590 3591 3592 3593
                   function.entry.name in Builtin.types_that_construct_their_instance:
                # calling a builtin type that returns a specific object type
                if function.entry.name == 'float':
                    # the following will come true later on in a transform
                    self.type = PyrexTypes.c_double_type
                    self.result_ctype = PyrexTypes.c_double_type
                else:
                    self.type = Builtin.builtin_types[function.entry.name]
                    self.result_ctype = py_object_type
Stefan Behnel's avatar
Stefan Behnel committed
3594
                self.may_return_none = False
3595
            elif function.is_name and function.type_entry:
3596 3597 3598 3599 3600
                # We are calling an extension type constructor.  As
                # long as we do not support __new__(), the result type
                # is clear
                self.type = function.type_entry.type
                self.result_ctype = py_object_type
Stefan Behnel's avatar
Stefan Behnel committed
3601
                self.may_return_none = False
3602 3603
            else:
                self.type = py_object_type
William Stein's avatar
William Stein committed
3604 3605 3606 3607
            self.is_temp = 1
        else:
            for arg in self.args:
                arg.analyse_types(env)
3608

William Stein's avatar
William Stein committed
3609 3610
            if self.self and func_type.args:
                # Coerce 'self' to the type expected by the method.
3611 3612 3613
                self_arg = func_type.args[0]
                if self_arg.not_none: # C methods must do the None test for self at *call* time
                    self.self = self.self.as_none_safe_node(
3614 3615 3616
                        "'NoneType' object has no attribute '%s'",
                        error = 'PyExc_AttributeError',
                        format_args = [self.function.entry.name])
3617
                expected_type = self_arg.type
Stefan Behnel's avatar
Stefan Behnel committed
3618 3619 3620 3621 3622
                if self_arg.accept_builtin_subtypes:
                    self.coerced_self = CMethodSelfCloneNode(self.self)
                else:
                    self.coerced_self = CloneNode(self.self)
                self.coerced_self = self.coerced_self.coerce_to(expected_type, env)
William Stein's avatar
William Stein committed
3623 3624 3625
                # Insert coerced 'self' argument into argument list.
                self.args.insert(0, self.coerced_self)
            self.analyse_c_function_call(env)
3626

William Stein's avatar
William Stein committed
3627 3628
    def function_type(self):
        # Return the type of the function being called, coercing a function
3629 3630
        # pointer to a function if necessary. If the function has fused
        # arguments, return the specific type.
William Stein's avatar
William Stein committed
3631
        func_type = self.function.type
3632

William Stein's avatar
William Stein committed
3633 3634
        if func_type.is_ptr:
            func_type = func_type.base_type
3635

William Stein's avatar
William Stein committed
3636
        return func_type
3637

3638 3639 3640 3641 3642 3643 3644
    def is_simple(self):
        # C function calls could be considered simple, but they may
        # have side-effects that may hit when multiple operations must
        # be effected in order, e.g. when constructing the argument
        # sequence for a function call or comparing values.
        return False

William Stein's avatar
William Stein committed
3645
    def analyse_c_function_call(self, env):
Robert Bradshaw's avatar
Robert Bradshaw committed
3646
        if self.function.type is error_type:
3647
            self.type = error_type
Robert Bradshaw's avatar
Robert Bradshaw committed
3648
            return
3649

Robert Bradshaw's avatar
Robert Bradshaw committed
3650
        if self.function.type.is_cpp_class:
3651 3652
            overloaded_entry = self.function.type.scope.lookup("operator()")
            if overloaded_entry is None:
Robert Bradshaw's avatar
Robert Bradshaw committed
3653 3654 3655
                self.type = PyrexTypes.error_type
                self.result_code = "<error>"
                return
3656 3657
        elif hasattr(self.function, 'entry'):
            overloaded_entry = self.function.entry
3658
        elif (isinstance(self.function, IndexNode) and
3659
              self.function.is_fused_index):
3660
            overloaded_entry = self.function.type.entry
Robert Bradshaw's avatar
Robert Bradshaw committed
3661
        else:
3662
            overloaded_entry = None
3663

3664
        if overloaded_entry:
3665
            if self.function.type.is_fused:
Mark Florisson's avatar
Mark Florisson committed
3666 3667
                functypes = self.function.type.get_all_specific_function_types()
                alternatives = [f.entry for f in functypes]
3668 3669 3670 3671 3672
            else:
                alternatives = overloaded_entry.all_alternatives()

            entry = PyrexTypes.best_match(self.args, alternatives, self.pos, env)

3673 3674 3675 3676
            if not entry:
                self.type = PyrexTypes.error_type
                self.result_code = "<error>"
                return
Mark Florisson's avatar
Mark Florisson committed
3677 3678

            entry.used = True
3679 3680
            self.function.entry = entry
            self.function.type = entry.type
3681 3682 3683 3684 3685 3686 3687 3688
            func_type = self.function_type()
        else:
            func_type = self.function_type()
            if not func_type.is_cfunction:
                error(self.pos, "Calling non-function type '%s'" % func_type)
                self.type = PyrexTypes.error_type
                self.result_code = "<error>"
                return
William Stein's avatar
William Stein committed
3689
        # Check no. of args
3690 3691
        max_nargs = len(func_type.args)
        expected_nargs = max_nargs - func_type.optional_arg_count
William Stein's avatar
William Stein committed
3692
        actual_nargs = len(self.args)
3693 3694 3695
        if func_type.optional_arg_count and expected_nargs != actual_nargs:
            self.has_optional_args = 1
            self.is_temp = 1
William Stein's avatar
William Stein committed
3696
        # Coerce arguments
3697
        some_args_in_temps = False
3698
        for i in xrange(min(max_nargs, actual_nargs)):
William Stein's avatar
William Stein committed
3699
            formal_type = func_type.args[i].type
3700
            arg = self.args[i].coerce_to(formal_type, env)
3701
            if arg.is_temp:
3702 3703
                if i > 0:
                    # first argument in temp doesn't impact subsequent arguments
3704
                    some_args_in_temps = True
3705
            elif arg.type.is_pyobject and not env.nogil:
3706 3707
                if i == 0 and self.self is not None:
                    # a method's cloned "self" argument is ok
3708
                    pass
3709
                elif arg.nonlocally_immutable():
3710 3711 3712
                    # plain local variables are ok
                    pass
                else:
3713 3714 3715 3716
                    # we do not safely own the argument's reference,
                    # but we must make sure it cannot be collected
                    # before we return from the function, so we create
                    # an owned temp reference to it
3717 3718
                    if i > 0: # first argument doesn't matter
                        some_args_in_temps = True
3719
                    arg = arg.coerce_to_temp(env)
3720
            self.args[i] = arg
3721
        # handle additional varargs parameters
3722
        for i in xrange(max_nargs, actual_nargs):
3723 3724 3725 3726 3727 3728 3729
            arg = self.args[i]
            if arg.type.is_pyobject:
                arg_ctype = arg.type.default_coerced_ctype()
                if arg_ctype is None:
                    error(self.args[i].pos,
                          "Python object cannot be passed as a varargs parameter")
                else:
3730
                    self.args[i] = arg = arg.coerce_to(arg_ctype, env)
3731 3732
            if arg.is_temp and i > 0:
                some_args_in_temps = True
3733 3734 3735
        if some_args_in_temps:
            # if some args are temps and others are not, they may get
            # constructed in the wrong order (temps first) => make
3736 3737 3738 3739
            # sure they are either all temps or all not temps (except
            # for the last argument, which is evaluated last in any
            # case)
            for i in xrange(actual_nargs-1):
3740 3741
                if i == 0 and self.self is not None:
                    continue # self is ok
3742
                arg = self.args[i]
3743 3744
                if arg.nonlocally_immutable():
                    # locals, C functions, unassignable types are safe.
3745
                    pass
3746 3747
                elif arg.type.is_cpp_class:
                    # Assignment has side effects, avoid.
3748 3749
                    pass
                elif env.nogil and arg.type.is_pyobject:
3750 3751 3752
                    # can't copy a Python reference into a temp in nogil
                    # env (this is safe: a construction would fail in
                    # nogil anyway)
3753 3754
                    pass
                else:
3755 3756 3757 3758 3759
                    #self.args[i] = arg.coerce_to_temp(env)
                    # instead: issue a warning
                    if i > 0 or i == 1 and self.self is not None: # skip first arg
                        warning(arg.pos, "Argument evaluation order in C function call is undefined and may not be as expected", 0)
                        break
3760

William Stein's avatar
William Stein committed
3761
        # Calc result type and code fragment
Robert Bradshaw's avatar
Robert Bradshaw committed
3762
        if isinstance(self.function, NewExprNode):
3763
            self.type = PyrexTypes.CPtrType(self.function.class_type)
Robert Bradshaw's avatar
Robert Bradshaw committed
3764 3765
        else:
            self.type = func_type.return_type
3766

3767 3768 3769
        if self.function.is_name or self.function.is_attribute:
            if self.function.entry and self.function.entry.utility_code:
                self.is_temp = 1 # currently doesn't work for self.calculate_result_code()
3770

Stefan Behnel's avatar
Stefan Behnel committed
3771 3772 3773 3774 3775 3776
        if self.type.is_pyobject:
            self.result_ctype = py_object_type
            self.is_temp = 1
        elif func_type.exception_value is not None \
                 or func_type.exception_check:
            self.is_temp = 1
3777 3778 3779 3780
        elif self.type.is_memoryviewslice:
            self.is_temp = 1
            # func_type.exception_check = True

3781
        # Called in 'nogil' context?
3782
        self.nogil = env.nogil
3783 3784 3785 3786 3787
        if (self.nogil and
            func_type.exception_check and
            func_type.exception_check != '+'):
            env.use_utility_code(pyerr_occurred_withgil_utility_code)
        # C++ exception handler
Robert Bradshaw's avatar
Robert Bradshaw committed
3788 3789 3790 3791
        if func_type.exception_check == '+':
            if func_type.exception_value is None:
                env.use_utility_code(cpp_exception_utility_code)

William Stein's avatar
William Stein committed
3792 3793
    def calculate_result_code(self):
        return self.c_call_code()
3794

William Stein's avatar
William Stein committed
3795 3796
    def c_call_code(self):
        func_type = self.function_type()
3797
        if self.type is PyrexTypes.error_type or not func_type.is_cfunction:
William Stein's avatar
William Stein committed
3798 3799 3800
            return "<error>"
        formal_args = func_type.args
        arg_list_code = []
3801
        args = list(zip(formal_args, self.args))
3802 3803 3804 3805
        max_nargs = len(func_type.args)
        expected_nargs = max_nargs - func_type.optional_arg_count
        actual_nargs = len(self.args)
        for formal_arg, actual_arg in args[:expected_nargs]:
William Stein's avatar
William Stein committed
3806 3807
                arg_code = actual_arg.result_as(formal_arg.type)
                arg_list_code.append(arg_code)
3808

3809 3810
        if func_type.is_overridable:
            arg_list_code.append(str(int(self.wrapper_call or self.function.entry.is_unbound_cmethod)))
3811

3812
        if func_type.optional_arg_count:
3813
            if expected_nargs == actual_nargs:
3814
                optional_args = 'NULL'
3815
            else:
3816
                optional_args = "&%s" % self.opt_arg_struct
3817
            arg_list_code.append(optional_args)
3818

William Stein's avatar
William Stein committed
3819
        for actual_arg in self.args[len(formal_args):]:
3820
            arg_list_code.append(actual_arg.result())
3821 3822

        result = "%s(%s)" % (self.function.result(), ', '.join(arg_list_code))
William Stein's avatar
William Stein committed
3823
        return result
3824

William Stein's avatar
William Stein committed
3825 3826
    def generate_result_code(self, code):
        func_type = self.function_type()
3827 3828 3829
        if self.function.is_name or self.function.is_attribute:
            if self.function.entry and self.function.entry.utility_code:
                code.globalstate.use_utility_code(self.function.entry.utility_code)
William Stein's avatar
William Stein committed
3830
        if func_type.is_pyobject:
3831
            arg_code = self.arg_tuple.py_result()
William Stein's avatar
William Stein committed
3832
            code.putln(
3833
                "%s = PyObject_Call(%s, %s, NULL); %s" % (
3834
                    self.result(),
William Stein's avatar
William Stein committed
3835
                    self.function.py_result(),
3836
                    arg_code,
3837
                    code.error_goto_if_null(self.result(), self.pos)))
3838
            code.put_gotref(self.py_result())
William Stein's avatar
William Stein committed
3839
        elif func_type.is_cfunction:
3840 3841 3842
            if self.has_optional_args:
                actual_nargs = len(self.args)
                expected_nargs = len(func_type.args) - func_type.optional_arg_count
3843 3844
                self.opt_arg_struct = code.funcstate.allocate_temp(
                    func_type.op_arg_struct.base_type, manage_ref=True)
3845 3846 3847 3848
                code.putln("%s.%s = %s;" % (
                        self.opt_arg_struct,
                        Naming.pyrex_prefix + "n",
                        len(self.args) - expected_nargs))
3849
                args = list(zip(func_type.args, self.args))
3850 3851 3852
                for formal_arg, actual_arg in args[expected_nargs:actual_nargs]:
                    code.putln("%s.%s = %s;" % (
                            self.opt_arg_struct,
3853
                            func_type.opt_arg_cname(formal_arg.name),
3854
                            actual_arg.result_as(formal_arg.type)))
William Stein's avatar
William Stein committed
3855
            exc_checks = []
3856
            if self.type.is_pyobject and self.is_temp:
3857
                exc_checks.append("!%s" % self.result())
3858 3859 3860
            elif self.type.is_memoryviewslice:
                assert self.is_temp
                exc_checks.append(self.type.error_condition(self.result()))
William Stein's avatar
William Stein committed
3861
            else:
3862 3863
                exc_val = func_type.exception_value
                exc_check = func_type.exception_check
William Stein's avatar
William Stein committed
3864
                if exc_val is not None:
3865
                    exc_checks.append("%s == %s" % (self.result(), exc_val))
William Stein's avatar
William Stein committed
3866
                if exc_check:
3867 3868
                    if self.nogil:
                        exc_checks.append("__Pyx_ErrOccurredWithGIL()")
3869
                    else:
3870
                        exc_checks.append("PyErr_Occurred()")
William Stein's avatar
William Stein committed
3871 3872
            if self.is_temp or exc_checks:
                rhs = self.c_call_code()
3873 3874
                if self.result():
                    lhs = "%s = " % self.result()
William Stein's avatar
William Stein committed
3875 3876 3877
                    if self.is_temp and self.type.is_pyobject:
                        #return_type = self.type # func_type.return_type
                        #print "SimpleCallNode.generate_result_code: casting", rhs, \
Robert Bradshaw's avatar
Robert Bradshaw committed
3878
                        #    "from", return_type, "to pyobject" ###
William Stein's avatar
William Stein committed
3879 3880 3881
                        rhs = typecast(py_object_type, self.type, rhs)
                else:
                    lhs = ""
Felix Wu's avatar
Felix Wu committed
3882
                if func_type.exception_check == '+':
Robert Bradshaw's avatar
Robert Bradshaw committed
3883 3884 3885
                    if func_type.exception_value is None:
                        raise_py_exception = "__Pyx_CppExn2PyErr()"
                    elif func_type.exception_value.type.is_pyobject:
3886 3887 3888
                        raise_py_exception = ' try { throw; } catch(const std::exception& exn) { PyErr_SetString(%s, exn.what()); } catch(...) { PyErr_SetNone(%s); }' % (
                            func_type.exception_value.entry.cname,
                            func_type.exception_value.entry.cname)
Robert Bradshaw's avatar
Robert Bradshaw committed
3889 3890
                    else:
                        raise_py_exception = '%s(); if (!PyErr_Occurred()) PyErr_SetString(PyExc_RuntimeError , "Error converting c++ exception.")' % func_type.exception_value.entry.cname
3891 3892
                    if self.nogil:
                        raise_py_exception = 'Py_BLOCK_THREADS; %s; Py_UNBLOCK_THREADS' % raise_py_exception
Felix Wu's avatar
Felix Wu committed
3893
                    code.putln(
Robert Bradshaw's avatar
Robert Bradshaw committed
3894
                    "try {%s%s;} catch(...) {%s; %s}" % (
Felix Wu's avatar
Felix Wu committed
3895 3896
                        lhs,
                        rhs,
Robert Bradshaw's avatar
Robert Bradshaw committed
3897
                        raise_py_exception,
Felix Wu's avatar
Felix Wu committed
3898
                        code.error_goto(self.pos)))
3899 3900 3901 3902 3903 3904
                else:
                    if exc_checks:
                        goto_error = code.error_goto_if(" && ".join(exc_checks), self.pos)
                    else:
                        goto_error = ""
                    code.putln("%s%s; %s" % (lhs, rhs, goto_error))
3905
                if self.type.is_pyobject and self.result():
3906
                    code.put_gotref(self.py_result())
3907 3908
            if self.has_optional_args:
                code.funcstate.release_temp(self.opt_arg_struct)
3909 3910


3911 3912 3913 3914 3915 3916 3917 3918 3919 3920 3921 3922 3923 3924 3925 3926 3927 3928 3929 3930 3931 3932 3933 3934 3935 3936 3937 3938 3939 3940 3941 3942 3943 3944 3945 3946 3947 3948 3949 3950 3951 3952 3953 3954 3955 3956 3957 3958 3959 3960 3961 3962 3963 3964 3965 3966 3967 3968 3969 3970 3971 3972 3973 3974 3975 3976 3977 3978 3979 3980 3981 3982 3983 3984 3985 3986 3987 3988 3989 3990 3991 3992 3993 3994
class InlinedDefNodeCallNode(CallNode):
    #  Inline call to defnode
    #
    #  function       PyCFunctionNode
    #  function_name  NameNode
    #  args           [ExprNode]

    subexprs = ['args', 'function_name']
    is_temp = 1
    type = py_object_type
    function = None
    function_name = None

    def can_be_inlined(self):
        func_type= self.function.def_node
        if func_type.star_arg or func_type.starstar_arg:
            return False
        if len(func_type.args) != len(self.args):
            return False
        return True

    def analyse_types(self, env):
        self.function_name.analyse_types(env)

        for arg in self.args:
            arg.analyse_types(env)

        func_type = self.function.def_node
        actual_nargs = len(self.args)

        # Coerce arguments
        some_args_in_temps = False
        for i in xrange(actual_nargs):
            formal_type = func_type.args[i].type
            arg = self.args[i].coerce_to(formal_type, env)
            if arg.is_temp:
                if i > 0:
                    # first argument in temp doesn't impact subsequent arguments
                    some_args_in_temps = True
            elif arg.type.is_pyobject and not env.nogil:
                if arg.nonlocally_immutable():
                    # plain local variables are ok
                    pass
                else:
                    # we do not safely own the argument's reference,
                    # but we must make sure it cannot be collected
                    # before we return from the function, so we create
                    # an owned temp reference to it
                    if i > 0: # first argument doesn't matter
                        some_args_in_temps = True
                    arg = arg.coerce_to_temp(env)
            self.args[i] = arg

        if some_args_in_temps:
            # if some args are temps and others are not, they may get
            # constructed in the wrong order (temps first) => make
            # sure they are either all temps or all not temps (except
            # for the last argument, which is evaluated last in any
            # case)
            for i in xrange(actual_nargs-1):
                arg = self.args[i]
                if arg.nonlocally_immutable():
                    # locals, C functions, unassignable types are safe.
                    pass
                elif arg.type.is_cpp_class:
                    # Assignment has side effects, avoid.
                    pass
                elif env.nogil and arg.type.is_pyobject:
                    # can't copy a Python reference into a temp in nogil
                    # env (this is safe: a construction would fail in
                    # nogil anyway)
                    pass
                else:
                    #self.args[i] = arg.coerce_to_temp(env)
                    # instead: issue a warning
                    if i > 0:
                        warning(arg.pos, "Argument evaluation order in C function call is undefined and may not be as expected", 0)
                        break

    def generate_result_code(self, code):
        arg_code = [self.function_name.py_result()]
        func_type = self.function.def_node
        for arg, proto_arg in zip(self.args, func_type.args):
            if arg.type.is_pyobject:
3995
                arg_code.append(arg.result_as(proto_arg.type))
3996 3997 3998 3999 4000 4001 4002 4003 4004 4005 4006 4007
            else:
                arg_code.append(arg.result())
        arg_code = ', '.join(arg_code)
        code.putln(
            "%s = %s(%s); %s" % (
                self.result(),
                self.function.def_node.entry.pyfunc_cname,
                arg_code,
                code.error_goto_if_null(self.result(), self.pos)))
        code.put_gotref(self.py_result())


4008 4009
class PythonCapiFunctionNode(ExprNode):
    subexprs = []
4010
    def __init__(self, pos, py_name, cname, func_type, utility_code = None):
4011
        self.pos = pos
4012 4013
        self.name = py_name
        self.cname = cname
4014 4015 4016
        self.type = func_type
        self.utility_code = utility_code

4017 4018 4019
    def analyse_types(self, env):
        pass

4020 4021 4022 4023 4024
    def generate_result_code(self, code):
        if self.utility_code:
            code.globalstate.use_utility_code(self.utility_code)

    def calculate_result_code(self):
4025
        return self.cname
4026 4027 4028 4029

class PythonCapiCallNode(SimpleCallNode):
    # Python C-API Function call (only created in transforms)

Stefan Behnel's avatar
Stefan Behnel committed
4030 4031 4032 4033 4034 4035
    # By default, we assume that the call never returns None, as this
    # is true for most C-API functions in CPython.  If this does not
    # apply to a call, set the following to True (or None to inherit
    # the default behaviour).
    may_return_none = False

4036
    def __init__(self, pos, function_name, func_type,
4037
                 utility_code = None, py_name=None, **kwargs):
4038 4039 4040
        self.type = func_type.return_type
        self.result_ctype = self.type
        self.function = PythonCapiFunctionNode(
4041
            pos, py_name, function_name, func_type,
4042 4043 4044 4045 4046
            utility_code = utility_code)
        # call this last so that we can override the constructed
        # attributes above with explicit keyword arguments if required
        SimpleCallNode.__init__(self, pos, **kwargs)

William Stein's avatar
William Stein committed
4047

4048
class GeneralCallNode(CallNode):
William Stein's avatar
William Stein committed
4049 4050 4051 4052 4053 4054
    #  General Python function call, including keyword,
    #  * and ** arguments.
    #
    #  function         ExprNode
    #  positional_args  ExprNode          Tuple of positional arguments
    #  keyword_args     ExprNode or None  Dict of keyword arguments
4055

4056
    type = py_object_type
4057

4058
    subexprs = ['function', 'positional_args', 'keyword_args']
William Stein's avatar
William Stein committed
4059

4060
    nogil_check = Node.gil_error
4061

4062 4063 4064 4065 4066 4067 4068 4069
    def compile_time_value(self, denv):
        function = self.function.compile_time_value(denv)
        positional_args = self.positional_args.compile_time_value(denv)
        keyword_args = self.keyword_args.compile_time_value(denv)
        try:
            return function(*positional_args, **keyword_args)
        except Exception, e:
            self.compile_time_value_error(e)
4070

4071
    def explicit_args_kwds(self):
4072 4073
        if (self.keyword_args and not isinstance(self.keyword_args, DictNode) or
            not isinstance(self.positional_args, TupleNode)):
4074
            raise CompileError(self.pos,
4075 4076
                'Compile-time keyword arguments must be explicit.')
        return self.positional_args.args, self.keyword_args
4077

William Stein's avatar
William Stein committed
4078
    def analyse_types(self, env):
Robert Bradshaw's avatar
Robert Bradshaw committed
4079 4080
        if self.analyse_as_type_constructor(env):
            return
William Stein's avatar
William Stein committed
4081 4082 4083 4084
        self.function.analyse_types(env)
        self.positional_args.analyse_types(env)
        if self.keyword_args:
            self.keyword_args.analyse_types(env)
4085
        if not self.function.type.is_pyobject:
4086 4087
            if self.function.type.is_error:
                self.type = error_type
Stefan Behnel's avatar
Stefan Behnel committed
4088
                return
4089
            if hasattr(self.function, 'entry') and not self.function.entry.as_variable:
4090
                error(self.pos, "Keyword and starred arguments not allowed in cdef functions.")
4091 4092
            else:
                self.function = self.function.coerce_to_pyobject(env)
William Stein's avatar
William Stein committed
4093 4094
        self.positional_args = \
            self.positional_args.coerce_to_pyobject(env)
Stefan Behnel's avatar
Stefan Behnel committed
4095
        function = self.function
4096 4097 4098 4099 4100
        if function.is_name and function.type_entry:
            # We are calling an extension type constructor.  As long
            # as we do not support __new__(), the result type is clear
            self.type = function.type_entry.type
            self.result_ctype = py_object_type
Stefan Behnel's avatar
Stefan Behnel committed
4101
            self.may_return_none = False
4102 4103
        else:
            self.type = py_object_type
William Stein's avatar
William Stein committed
4104
        self.is_temp = 1
4105

William Stein's avatar
William Stein committed
4106
    def generate_result_code(self, code):
4107
        if self.type.is_error: return
4108 4109
        if self.keyword_args:
            kwargs = self.keyword_args.py_result()
William Stein's avatar
William Stein committed
4110
        else:
4111
            kwargs = 'NULL'
William Stein's avatar
William Stein committed
4112
        code.putln(
4113
            "%s = PyObject_Call(%s, %s, %s); %s" % (
4114
                self.result(),
4115 4116 4117
                self.function.py_result(),
                self.positional_args.py_result(),
                kwargs,
4118
                code.error_goto_if_null(self.result(), self.pos)))
4119
        code.put_gotref(self.py_result())
William Stein's avatar
William Stein committed
4120 4121


4122
class AsTupleNode(ExprNode):
William Stein's avatar
William Stein committed
4123 4124 4125 4126
    #  Convert argument to tuple. Used for normalising
    #  the * argument of a function call.
    #
    #  arg    ExprNode
4127

William Stein's avatar
William Stein committed
4128
    subexprs = ['arg']
4129 4130 4131

    def calculate_constant_result(self):
        self.constant_result = tuple(self.base.constant_result)
4132

4133 4134 4135 4136 4137 4138 4139
    def compile_time_value(self, denv):
        arg = self.arg.compile_time_value(denv)
        try:
            return tuple(arg)
        except Exception, e:
            self.compile_time_value_error(e)

William Stein's avatar
William Stein committed
4140 4141 4142
    def analyse_types(self, env):
        self.arg.analyse_types(env)
        self.arg = self.arg.coerce_to_pyobject(env)
4143
        self.type = tuple_type
William Stein's avatar
William Stein committed
4144
        self.is_temp = 1
4145

4146 4147 4148
    def may_be_none(self):
        return False

4149
    nogil_check = Node.gil_error
4150 4151
    gil_message = "Constructing Python tuple"

William Stein's avatar
William Stein committed
4152 4153
    def generate_result_code(self, code):
        code.putln(
Robert Bradshaw's avatar
Robert Bradshaw committed
4154
            "%s = PySequence_Tuple(%s); %s" % (
4155
                self.result(),
William Stein's avatar
William Stein committed
4156
                self.arg.py_result(),
4157
                code.error_goto_if_null(self.result(), self.pos)))
4158
        code.put_gotref(self.py_result())
4159

William Stein's avatar
William Stein committed
4160

4161
class AttributeNode(ExprNode):
William Stein's avatar
William Stein committed
4162 4163 4164 4165
    #  obj.attribute
    #
    #  obj          ExprNode
    #  attribute    string
4166
    #  needs_none_check boolean        Used if obj is an extension type.
4167
    #                                  If set to True, it is known that the type is not None.
William Stein's avatar
William Stein committed
4168 4169 4170 4171 4172 4173 4174
    #
    #  Used internally:
    #
    #  is_py_attr           boolean   Is a Python getattr operation
    #  member               string    C name of struct member
    #  is_called            boolean   Function call is being done on result
    #  entry                Entry     Symbol table entry of attribute
4175

William Stein's avatar
William Stein committed
4176 4177
    is_attribute = 1
    subexprs = ['obj']
4178

William Stein's avatar
William Stein committed
4179 4180 4181
    type = PyrexTypes.error_type
    entry = None
    is_called = 0
4182
    needs_none_check = True
4183
    is_memslice_transpose = False
William Stein's avatar
William Stein committed
4184

4185
    def as_cython_attribute(self):
Mark Florisson's avatar
Mark Florisson committed
4186 4187 4188
        if (isinstance(self.obj, NameNode) and
                self.obj.is_cython_module and not
                self.attribute == u"parallel"):
4189
            return self.attribute
Mark Florisson's avatar
Mark Florisson committed
4190

4191 4192 4193
        cy = self.obj.as_cython_attribute()
        if cy:
            return "%s.%s" % (cy, self.attribute)
4194
        return None
4195

4196 4197 4198 4199 4200 4201 4202 4203 4204
    def coerce_to(self, dst_type, env):
        #  If coercing to a generic pyobject and this is a cpdef function
        #  we can create the corresponding attribute
        if dst_type is py_object_type:
            entry = self.entry
            if entry and entry.is_cfunction and entry.as_variable:
                # must be a cpdef function
                self.is_temp = 1
                self.entry = entry.as_variable
4205
                self.analyse_as_python_attribute(env)
4206
                return self
4207
        return ExprNode.coerce_to(self, dst_type, env)
4208 4209 4210

    def calculate_constant_result(self):
        attr = self.attribute
4211
        if attr.startswith("__") and attr.endswith("__"):
4212 4213 4214
            return
        self.constant_result = getattr(self.obj.constant_result, attr)

4215 4216
    def compile_time_value(self, denv):
        attr = self.attribute
4217
        if attr.startswith("__") and attr.endswith("__"):
Stefan Behnel's avatar
Stefan Behnel committed
4218 4219
            error(self.pos,
                  "Invalid attribute name '%s' in compile-time expression" % attr)
4220
            return None
4221
        obj = self.obj.compile_time_value(denv)
4222 4223 4224 4225
        try:
            return getattr(obj, attr)
        except Exception, e:
            self.compile_time_value_error(e)
4226

Robert Bradshaw's avatar
Robert Bradshaw committed
4227 4228
    def type_dependencies(self, env):
        return self.obj.type_dependencies(env)
4229

4230 4231 4232 4233 4234 4235
    def infer_type(self, env):
        if self.analyse_as_cimported_attribute(env, 0):
            return self.entry.type
        elif self.analyse_as_unbound_cmethod(env):
            return self.entry.type
        else:
4236 4237 4238 4239 4240 4241 4242 4243
            obj_type = self.obj.infer_type(env)
            self.analyse_attribute(env, obj_type = obj_type)
            if obj_type.is_builtin_type and self.type.is_cfunction:
                # special case: C-API replacements for C methods of
                # builtin types cannot be inferred as C functions as
                # that would prevent their use as bound methods
                self.type = py_object_type
                return py_object_type
4244
            return self.type
4245

William Stein's avatar
William Stein committed
4246 4247
    def analyse_target_declaration(self, env):
        pass
4248

William Stein's avatar
William Stein committed
4249 4250
    def analyse_target_types(self, env):
        self.analyse_types(env, target = 1)
4251 4252
        if not self.is_lvalue():
            error(self.pos, "Assignment to non-lvalue of type '%s'" % self.type)
4253

William Stein's avatar
William Stein committed
4254
    def analyse_types(self, env, target = 0):
4255
        self.initialized_check = env.directives['initializedcheck']
William Stein's avatar
William Stein committed
4256
        if self.analyse_as_cimported_attribute(env, target):
4257 4258 4259 4260 4261 4262 4263
            self.entry.used = True
        elif not target and self.analyse_as_unbound_cmethod(env):
            self.entry.used = True
        else:
            self.analyse_as_ordinary_attribute(env, target)
            if self.entry:
                self.entry.used = True
4264

William Stein's avatar
William Stein committed
4265 4266 4267 4268 4269 4270 4271 4272 4273 4274 4275 4276
    def analyse_as_cimported_attribute(self, env, target):
        # Try to interpret this as a reference to an imported
        # C const, type, var or function. If successful, mutates
        # this node into a NameNode and returns 1, otherwise
        # returns 0.
        module_scope = self.obj.analyse_as_module(env)
        if module_scope:
            entry = module_scope.lookup_here(self.attribute)
            if entry and (
                entry.is_cglobal or entry.is_cfunction
                or entry.is_type or entry.is_const):
                    self.mutate_into_name_node(env, entry, target)
4277
                    entry.used = 1
William Stein's avatar
William Stein committed
4278 4279
                    return 1
        return 0
4280

William Stein's avatar
William Stein committed
4281 4282 4283 4284 4285 4286 4287 4288 4289 4290 4291 4292 4293 4294 4295 4296
    def analyse_as_unbound_cmethod(self, env):
        # Try to interpret this as a reference to an unbound
        # C method of an extension type. If successful, mutates
        # this node into a NameNode and returns 1, otherwise
        # returns 0.
        type = self.obj.analyse_as_extension_type(env)
        if type:
            entry = type.scope.lookup_here(self.attribute)
            if entry and entry.is_cmethod:
                # Create a temporary entry describing the C method
                # as an ordinary function.
                ubcm_entry = Symtab.Entry(entry.name,
                    "%s->%s" % (type.vtabptr_cname, entry.cname),
                    entry.type)
                ubcm_entry.is_cfunction = 1
                ubcm_entry.func_cname = entry.func_cname
4297
                ubcm_entry.is_unbound_cmethod = 1
William Stein's avatar
William Stein committed
4298 4299 4300
                self.mutate_into_name_node(env, ubcm_entry, None)
                return 1
        return 0
4301

4302 4303 4304
    def analyse_as_type(self, env):
        module_scope = self.obj.analyse_as_module(env)
        if module_scope:
4305
            return module_scope.lookup_type(self.attribute)
4306
        if not self.obj.is_string_literal:
Robert Bradshaw's avatar
Robert Bradshaw committed
4307
            base_type = self.obj.analyse_as_type(env)
Robert Bradshaw's avatar
Robert Bradshaw committed
4308
            if base_type and hasattr(base_type, 'scope') and base_type.scope is not None:
Robert Bradshaw's avatar
Robert Bradshaw committed
4309
                return base_type.scope.lookup_type(self.attribute)
4310
        return None
4311

William Stein's avatar
William Stein committed
4312 4313 4314 4315 4316 4317 4318 4319 4320
    def analyse_as_extension_type(self, env):
        # Try to interpret this as a reference to an extension type
        # in a cimported module. Returns the extension type, or None.
        module_scope = self.obj.analyse_as_module(env)
        if module_scope:
            entry = module_scope.lookup_here(self.attribute)
            if entry and entry.is_type and entry.type.is_extension_type:
                return entry.type
        return None
4321

William Stein's avatar
William Stein committed
4322 4323 4324 4325 4326 4327 4328 4329 4330
    def analyse_as_module(self, env):
        # Try to interpret this as a reference to a cimported module
        # in another cimported module. Returns the module scope, or None.
        module_scope = self.obj.analyse_as_module(env)
        if module_scope:
            entry = module_scope.lookup_here(self.attribute)
            if entry and entry.as_module:
                return entry.as_module
        return None
4331

William Stein's avatar
William Stein committed
4332 4333 4334 4335 4336 4337 4338 4339 4340 4341 4342
    def mutate_into_name_node(self, env, entry, target):
        # Mutate this node into a NameNode and complete the
        # analyse_types phase.
        self.__class__ = NameNode
        self.name = self.attribute
        self.entry = entry
        del self.obj
        del self.attribute
        if target:
            NameNode.analyse_target_types(self, env)
        else:
4343
            NameNode.analyse_rvalue_entry(self, env)
4344

William Stein's avatar
William Stein committed
4345 4346 4347 4348
    def analyse_as_ordinary_attribute(self, env, target):
        self.obj.analyse_types(env)
        self.analyse_attribute(env)
        if self.entry and self.entry.is_cmethod and not self.is_called:
4349 4350
#            error(self.pos, "C method can only be called")
            pass
4351 4352
        ## Reference to C array turns into pointer to first element.
        #while self.type.is_array:
Robert Bradshaw's avatar
Robert Bradshaw committed
4353
        #    self.type = self.type.element_ptr_type()
William Stein's avatar
William Stein committed
4354 4355 4356 4357
        if self.is_py_attr:
            if not target:
                self.is_temp = 1
                self.result_ctype = py_object_type
4358 4359
        elif target and self.obj.type.is_builtin_type:
            error(self.pos, "Assignment to an immutable object field")
4360 4361
        #elif self.type.is_memoryviewslice and not target:
        #    self.is_temp = True
4362

Robert Bradshaw's avatar
Robert Bradshaw committed
4363
    def analyse_attribute(self, env, obj_type = None):
William Stein's avatar
William Stein committed
4364 4365 4366
        # Look up attribute and set self.type and self.member.
        self.is_py_attr = 0
        self.member = self.attribute
Robert Bradshaw's avatar
Robert Bradshaw committed
4367 4368 4369 4370 4371 4372 4373
        if obj_type is None:
            if self.obj.type.is_string:
                self.obj = self.obj.coerce_to_pyobject(env)
            obj_type = self.obj.type
        else:
            if obj_type.is_string:
                obj_type = py_object_type
4374
        if obj_type.is_ptr or obj_type.is_array:
William Stein's avatar
William Stein committed
4375 4376
            obj_type = obj_type.base_type
            self.op = "->"
4377
        elif obj_type.is_extension_type or obj_type.is_builtin_type:
William Stein's avatar
William Stein committed
4378 4379 4380 4381 4382 4383
            self.op = "->"
        else:
            self.op = "."
        if obj_type.has_attributes:
            entry = None
            if obj_type.attributes_known():
4384 4385
                if (obj_type.is_memoryviewslice and not
                        obj_type.scope.lookup_here(self.attribute)):
4386 4387 4388 4389 4390 4391 4392
                    if self.attribute == 'T':
                        self.is_memslice_transpose = True
                        self.is_temp = True
                        self.use_managed_ref = True
                        self.type = self.obj.type
                        return
                    else:
4393
                        obj_type.declare_attribute(self.attribute, env, self.pos)
William Stein's avatar
William Stein committed
4394
                entry = obj_type.scope.lookup_here(self.attribute)
Robert Bradshaw's avatar
Robert Bradshaw committed
4395 4396
                if entry and entry.is_member:
                    entry = None
William Stein's avatar
William Stein committed
4397
            else:
4398 4399
                error(self.pos,
                    "Cannot select attribute of incomplete type '%s'"
William Stein's avatar
William Stein committed
4400
                    % obj_type)
Robert Bradshaw's avatar
Robert Bradshaw committed
4401 4402
                self.type = PyrexTypes.error_type
                return
William Stein's avatar
William Stein committed
4403 4404
            self.entry = entry
            if entry:
4405 4406
                if obj_type.is_extension_type and entry.name == "__weakref__":
                    error(self.pos, "Illegal use of special attribute __weakref__")
4407 4408
                # methods need the normal attribute lookup
                # because they do not have struct entries
4409 4410 4411 4412
                if entry.is_variable or entry.is_cmethod:
                    self.type = entry.type
                    self.member = entry.cname
                    return
William Stein's avatar
William Stein committed
4413 4414 4415 4416 4417
                else:
                    # If it's not a variable or C method, it must be a Python
                    # method of an extension type, so we treat it like a Python
                    # attribute.
                    pass
4418
        # If we get here, the base object is not a struct/union/extension
William Stein's avatar
William Stein committed
4419 4420 4421
        # type, or it is an extension type and the attribute is either not
        # declared or is declared as a Python method. Treat it as a Python
        # attribute reference.
Robert Bradshaw's avatar
Robert Bradshaw committed
4422
        self.analyse_as_python_attribute(env, obj_type)
Stefan Behnel's avatar
Stefan Behnel committed
4423

Robert Bradshaw's avatar
Robert Bradshaw committed
4424 4425 4426
    def analyse_as_python_attribute(self, env, obj_type = None):
        if obj_type is None:
            obj_type = self.obj.type
4427 4428
        # mangle private '__*' Python attributes used inside of a class
        self.attribute = env.mangle_class_private_name(self.attribute)
4429
        self.member = self.attribute
4430 4431
        self.type = py_object_type
        self.is_py_attr = 1
4432
        if not obj_type.is_pyobject and not obj_type.is_error:
4433
            if obj_type.can_coerce_to_pyobject(env):
4434 4435 4436 4437 4438
                self.obj = self.obj.coerce_to_pyobject(env)
            else:
                error(self.pos,
                      "Object of type '%s' has no attribute '%s'" %
                      (obj_type, self.attribute))
4439

4440
    def nogil_check(self, env):
4441
        if self.is_py_attr:
4442
            self.gil_error()
4443 4444 4445
        elif self.type.is_memoryviewslice:
            import MemoryView
            MemoryView.err_if_nogil_initialized_check(self.pos, env, 'attribute')
4446

4447 4448
    gil_message = "Accessing Python attribute"

William Stein's avatar
William Stein committed
4449 4450 4451 4452 4453 4454 4455 4456
    def is_simple(self):
        if self.obj:
            return self.result_in_temp() or self.obj.is_simple()
        else:
            return NameNode.is_simple(self)

    def is_lvalue(self):
        if self.obj:
4457
            return not self.type.is_array
William Stein's avatar
William Stein committed
4458 4459
        else:
            return NameNode.is_lvalue(self)
4460

William Stein's avatar
William Stein committed
4461 4462 4463 4464 4465
    def is_ephemeral(self):
        if self.obj:
            return self.obj.is_ephemeral()
        else:
            return NameNode.is_ephemeral(self)
4466

William Stein's avatar
William Stein committed
4467 4468
    def calculate_result_code(self):
        #print "AttributeNode.calculate_result_code:", self.member ###
4469
        #print "...obj node =", self.obj, "code", self.obj.result() ###
William Stein's avatar
William Stein committed
4470 4471 4472 4473 4474
        #print "...obj type", self.obj.type, "ctype", self.obj.ctype() ###
        obj = self.obj
        obj_code = obj.result_as(obj.type)
        #print "...obj_code =", obj_code ###
        if self.entry and self.entry.is_cmethod:
Stefan Behnel's avatar
Stefan Behnel committed
4475
            if obj.type.is_extension_type and not self.entry.is_builtin_cmethod:
4476 4477
                if self.entry.final_func_cname:
                    return self.entry.final_func_cname
4478

Mark Florisson's avatar
Mark Florisson committed
4479
                if self.type.from_fused:
4480 4481 4482 4483
                    # If the attribute was specialized through indexing, make
                    # sure to get the right fused name, as our entry was
                    # replaced by our parent index node
                    # (AnalyseExpressionsTransform)
Mark Florisson's avatar
Mark Florisson committed
4484 4485
                    self.member = self.entry.cname

Robert Bradshaw's avatar
Robert Bradshaw committed
4486
                return "((struct %s *)%s%s%s)->%s" % (
4487
                    obj.type.vtabstruct_cname, obj_code, self.op,
Robert Bradshaw's avatar
Robert Bradshaw committed
4488 4489 4490
                    obj.type.vtabslot_cname, self.member)
            else:
                return self.member
4491
        elif obj.type.is_complex:
4492
            return "__Pyx_C%s(%s)" % (self.member.upper(), obj_code)
William Stein's avatar
William Stein committed
4493
        else:
4494 4495 4496
            if obj.type.is_builtin_type and self.entry and self.entry.is_variable:
                # accessing a field of a builtin type, need to cast better than result_as() does
                obj_code = obj.type.cast_code(obj.result(), to_object_struct = True)
William Stein's avatar
William Stein committed
4497
            return "%s%s%s" % (obj_code, self.op, self.member)
4498

William Stein's avatar
William Stein committed
4499 4500
    def generate_result_code(self, code):
        if self.is_py_attr:
4501 4502
            code.putln(
                '%s = PyObject_GetAttr(%s, %s); %s' % (
4503
                    self.result(),
4504
                    self.obj.py_result(),
4505
                    code.intern_identifier(self.attribute),
4506
                    code.error_goto_if_null(self.result(), self.pos)))
4507
            code.put_gotref(self.py_result())
4508
        elif self.type.is_memoryviewslice:
4509 4510 4511 4512 4513 4514 4515 4516 4517
            if self.is_memslice_transpose:
                # transpose the slice
                for access, packing in self.type.axes:
                    if access == 'ptr':
                        error(self.pos, "Transposing not supported for slices "
                                        "with indirect dimensions")
                        return

                code.putln("%s = %s;" % (self.result(), self.obj.result()))
Mark Florisson's avatar
Mark Florisson committed
4518
                if self.obj.is_name or self.obj.is_attribute and self.obj.is_memslice_transpose:
4519 4520 4521 4522 4523
                    code.put_incref_memoryviewslice(self.result(), have_gil=True)

                T = "__pyx_memslice_transpose(&%s) == 0"
                code.putln(code.error_goto_if(T % self.result(), self.pos))
            elif self.initialized_check:
4524 4525 4526 4527 4528 4529
                code.putln(
                    'if (unlikely(!%s.memview)) {'
                        'PyErr_SetString(PyExc_AttributeError,'
                                        '"Memoryview is not initialized");'
                        '%s'
                    '}' % (self.result(), code.error_goto(self.pos)))
4530 4531 4532
        else:
            # result_code contains what is needed, but we may need to insert
            # a check and raise an exception
4533 4534 4535 4536 4537 4538
            if self.obj.type.is_extension_type:
                if self.needs_none_check and code.globalstate.directives['nonecheck']:
                    self.put_nonecheck(code)
            elif self.entry and self.entry.is_cmethod and self.entry.utility_code:
                # C method implemented as function call with utility code
                code.globalstate.use_utility_code(self.entry.utility_code)
4539

William Stein's avatar
William Stein committed
4540 4541 4542
    def generate_assignment_code(self, rhs, code):
        self.obj.generate_evaluation_code(code)
        if self.is_py_attr:
4543
            code.put_error_if_neg(self.pos,
4544 4545
                'PyObject_SetAttr(%s, %s, %s)' % (
                    self.obj.py_result(),
4546
                    code.intern_identifier(self.attribute),
4547
                    rhs.py_result()))
William Stein's avatar
William Stein committed
4548
            rhs.generate_disposal_code(code)
4549
            rhs.free_temps(code)
4550 4551 4552 4553 4554
        elif self.obj.type.is_complex:
            code.putln("__Pyx_SET_C%s(%s, %s);" % (
                self.member.upper(),
                self.obj.result_as(self.obj.type),
                rhs.result_as(self.ctype())))
William Stein's avatar
William Stein committed
4555
        else:
4556
            if (self.obj.type.needs_nonecheck()
4557 4558 4559 4560
                  and self.needs_none_check
                  and code.globalstate.directives['nonecheck']):
                self.put_nonecheck(code)

4561
            select_code = self.result()
4562
            if self.type.is_pyobject and self.use_managed_ref:
William Stein's avatar
William Stein committed
4563
                rhs.make_owned_reference(code)
Dag Sverre Seljebotn's avatar
Dag Sverre Seljebotn committed
4564
                code.put_giveref(rhs.py_result())
4565
                code.put_gotref(select_code)
William Stein's avatar
William Stein committed
4566
                code.put_decref(select_code, self.ctype())
4567
            elif self.type.is_memoryviewslice:
4568
                import MemoryView
4569
                MemoryView.put_assign_to_memviewslice(
4570
                        select_code, rhs, rhs.result(), self.type, code)
4571

4572
            if not self.type.is_memoryviewslice:
4573 4574 4575 4576 4577
                code.putln(
                    "%s = %s;" % (
                        select_code,
                        rhs.result_as(self.ctype())))
                        #rhs.result()))
William Stein's avatar
William Stein committed
4578
            rhs.generate_post_assignment_code(code)
4579
            rhs.free_temps(code)
William Stein's avatar
William Stein committed
4580
        self.obj.generate_disposal_code(code)
4581
        self.obj.free_temps(code)
4582

William Stein's avatar
William Stein committed
4583 4584
    def generate_deletion_code(self, code):
        self.obj.generate_evaluation_code(code)
4585
        if self.is_py_attr or (isinstance(self.entry.scope, Symtab.PropertyScope)
4586
                               and u'__del__' in self.entry.scope.entries):
4587 4588 4589
            code.put_error_if_neg(self.pos,
                'PyObject_DelAttr(%s, %s)' % (
                    self.obj.py_result(),
4590
                    code.intern_identifier(self.attribute)))
William Stein's avatar
William Stein committed
4591 4592 4593
        else:
            error(self.pos, "Cannot delete C attribute of extension type")
        self.obj.generate_disposal_code(code)
4594
        self.obj.free_temps(code)
4595

4596 4597 4598 4599 4600
    def annotate(self, code):
        if self.is_py_attr:
            code.annotate(self.pos, AnnotationItem('py_attr', 'python attribute', size=len(self.attribute)))
        else:
            code.annotate(self.pos, AnnotationItem('c_attr', 'c attribute', size=len(self.attribute)))
William Stein's avatar
William Stein committed
4601

4602 4603
    def put_nonecheck(self, code):
        code.globalstate.use_utility_code(raise_noneattr_error_utility_code)
4604 4605 4606 4607 4608 4609 4610
        if self.obj.type.is_extension_type:
            test = "%s == Py_None" % self.obj.result_as(PyrexTypes.py_object_type)
        elif self.obj.type.is_memoryviewslice:
            test = "!%s.memview" % self.obj.result()
        else:
            assert False
        code.putln("if (%s) {" % code.unlikely(test))
Stefan Behnel's avatar
Stefan Behnel committed
4611
        code.putln("__Pyx_RaiseNoneAttributeError(\"%s\");" % self.attribute)
4612 4613 4614 4615
        code.putln(code.error_goto(self.pos))
        code.putln("}")


William Stein's avatar
William Stein committed
4616 4617 4618 4619 4620 4621
#-------------------------------------------------------------------
#
#  Constructor nodes
#
#-------------------------------------------------------------------

4622 4623 4624 4625 4626 4627 4628 4629 4630 4631 4632 4633 4634 4635 4636
class StarredTargetNode(ExprNode):
    #  A starred expression like "*a"
    #
    #  This is only allowed in sequence assignment targets such as
    #
    #      a, *b = (1,2,3,4)    =>     a = 1 ; b = [2,3,4]
    #
    #  and will be removed during type analysis (or generate an error
    #  if it's found at unexpected places).
    #
    #  target          ExprNode

    subexprs = ['target']
    is_starred = 1
    type = py_object_type
Robert Bradshaw's avatar
Robert Bradshaw committed
4637
    is_temp = 1
4638 4639 4640 4641 4642 4643 4644 4645 4646 4647 4648 4649 4650 4651 4652 4653 4654 4655 4656 4657 4658 4659 4660 4661 4662 4663 4664 4665

    def __init__(self, pos, target):
        self.pos = pos
        self.target = target

    def analyse_declarations(self, env):
        error(self.pos, "can use starred expression only as assignment target")
        self.target.analyse_declarations(env)

    def analyse_types(self, env):
        error(self.pos, "can use starred expression only as assignment target")
        self.target.analyse_types(env)
        self.type = self.target.type

    def analyse_target_declaration(self, env):
        self.target.analyse_target_declaration(env)

    def analyse_target_types(self, env):
        self.target.analyse_target_types(env)
        self.type = self.target.type

    def calculate_result_code(self):
        return ""

    def generate_result_code(self, code):
        pass


4666
class SequenceNode(ExprNode):
William Stein's avatar
William Stein committed
4667 4668 4669 4670 4671 4672
    #  Base class for list and tuple constructor nodes.
    #  Contains common code for performing sequence unpacking.
    #
    #  args                    [ExprNode]
    #  unpacked_items          [ExprNode] or None
    #  coerced_unpacked_items  [ExprNode] or None
4673
    # mult_factor              ExprNode     the integer number of content repetitions ([1,2]*3)
4674

4675
    subexprs = ['args', 'mult_factor']
4676

William Stein's avatar
William Stein committed
4677 4678
    is_sequence_constructor = 1
    unpacked_items = None
4679
    mult_factor = None
4680

4681 4682 4683
    def compile_time_value_list(self, denv):
        return [arg.compile_time_value(denv) for arg in self.args]

4684 4685 4686 4687 4688 4689 4690 4691 4692 4693 4694 4695 4696 4697
    def replace_starred_target_node(self):
        # replace a starred node in the targets by the contained expression
        self.starred_assignment = False
        args = []
        for arg in self.args:
            if arg.is_starred:
                if self.starred_assignment:
                    error(arg.pos, "more than 1 starred expression in assignment")
                self.starred_assignment = True
                arg = arg.target
                arg.is_starred = True
            args.append(arg)
        self.args = args

William Stein's avatar
William Stein committed
4698
    def analyse_target_declaration(self, env):
4699
        self.replace_starred_target_node()
William Stein's avatar
William Stein committed
4700 4701 4702
        for arg in self.args:
            arg.analyse_target_declaration(env)

4703
    def analyse_types(self, env, skip_children=False):
William Stein's avatar
William Stein committed
4704 4705
        for i in range(len(self.args)):
            arg = self.args[i]
4706
            if not skip_children: arg.analyse_types(env)
William Stein's avatar
William Stein committed
4707
            self.args[i] = arg.coerce_to_pyobject(env)
4708 4709 4710
        if self.mult_factor:
            self.mult_factor.analyse_types(env)
            if not self.mult_factor.type.is_int:
4711
                self.mult_factor = self.mult_factor.coerce_to_pyobject(env)
William Stein's avatar
William Stein committed
4712
        self.is_temp = 1
Stefan Behnel's avatar
Stefan Behnel committed
4713
        # not setting self.type here, subtypes do this
4714

4715 4716 4717
    def may_be_none(self):
        return False

William Stein's avatar
William Stein committed
4718
    def analyse_target_types(self, env):
4719
        if self.mult_factor:
Stefan Behnel's avatar
Stefan Behnel committed
4720
            error(self.pos, "can't assign to multiplied sequence")
4721
        self.unpacked_items = []
William Stein's avatar
William Stein committed
4722
        self.coerced_unpacked_items = []
4723
        self.any_coerced_items = False
William Stein's avatar
William Stein committed
4724 4725
        for arg in self.args:
            arg.analyse_target_types(env)
4726 4727 4728 4729 4730 4731
            if arg.is_starred:
                if not arg.type.assignable_from(Builtin.list_type):
                    error(arg.pos,
                          "starred target must have Python object (list) type")
                if arg.type is py_object_type:
                    arg.type = Builtin.list_type
William Stein's avatar
William Stein committed
4732 4733
            unpacked_item = PyTempNode(self.pos, env)
            coerced_unpacked_item = unpacked_item.coerce_to(arg.type, env)
4734 4735
            if unpacked_item is not coerced_unpacked_item:
                self.any_coerced_items = True
William Stein's avatar
William Stein committed
4736 4737 4738
            self.unpacked_items.append(unpacked_item)
            self.coerced_unpacked_items.append(coerced_unpacked_item)
        self.type = py_object_type
4739

William Stein's avatar
William Stein committed
4740 4741
    def generate_result_code(self, code):
        self.generate_operation_code(code)
4742

4743 4744 4745 4746 4747 4748
    def generate_sequence_packing_code(self, code, target=None, plain=False):
        if target is None:
            target = self.result()
        py_multiply = self.mult_factor and not self.mult_factor.type.is_int
        if plain or py_multiply:
            mult_factor = None
4749
        else:
4750 4751 4752 4753 4754 4755
            mult_factor = self.mult_factor
        if mult_factor:
            mult = mult_factor.result()
            if isinstance(mult_factor.constant_result, (int,long)) \
                   and mult_factor.constant_result > 0:
                size_factor = ' * %s' % mult_factor.constant_result
4756 4757 4758 4759 4760
            else:
                size_factor = ' * ((%s<0) ? 0:%s)' % (mult, mult)
        else:
            size_factor = ''
            mult = ''
4761 4762 4763 4764 4765 4766 4767

        if self.type is Builtin.list_type:
            create_func, set_item_func = 'PyList_New', 'PyList_SET_ITEM'
        elif self.type is Builtin.tuple_type:
            create_func, set_item_func = 'PyTuple_New', 'PyTuple_SET_ITEM'
        else:
            raise InternalError("sequence unpacking for unexpected type %s" % self.type)
4768 4769
        arg_count = len(self.args)
        code.putln("%s = %s(%s%s); %s" % (
4770 4771 4772 4773
            target, create_func, arg_count, size_factor,
            code.error_goto_if_null(target, self.pos)))
        code.put_gotref(target)

4774
        if mult:
4775 4776 4777 4778
            # FIXME: can't use a temp variable here as the code may
            # end up in the constant building function.  Temps
            # currently don't work there.

4779 4780
            #counter = code.funcstate.allocate_temp(mult_factor.type, manage_ref=False)
            counter = Naming.quick_temp_cname
4781 4782
            code.putln('{ Py_ssize_t %s;' % counter)
            if arg_count == 1:
Stefan Behnel's avatar
Stefan Behnel committed
4783
                offset = counter
4784
            else:
Stefan Behnel's avatar
Stefan Behnel committed
4785
                offset = '%s * %s' % (counter, arg_count)
4786 4787 4788 4789 4790 4791 4792 4793 4794
            code.putln('for (%s=0; %s < %s; %s++) {' % (
                counter, counter, mult, counter
                ))
        else:
            offset = ''
        for i in xrange(arg_count):
            arg = self.args[i]
            if mult or not arg.result_in_temp():
                code.put_incref(arg.result(), arg.ctype())
Stefan Behnel's avatar
Stefan Behnel committed
4795
            code.putln("%s(%s, %s, %s);" % (
4796
                set_item_func,
4797
                target,
Stefan Behnel's avatar
Stefan Behnel committed
4798
                (offset and i) and ('%s + %s' % (offset, i)) or (offset or i),
4799 4800 4801 4802
                arg.py_result()))
            code.put_giveref(arg.py_result())
        if mult:
            code.putln('}')
4803 4804
            #code.funcstate.release_temp(counter)
            code.putln('}')
4805
        elif py_multiply and not plain:
4806
            code.putln('{ PyObject* %s = PyNumber_InPlaceMultiply(%s, %s); %s' % (
4807 4808 4809 4810 4811 4812 4813
                Naming.quick_temp_cname, target, self.mult_factor.py_result(),
                code.error_goto_if_null(Naming.quick_temp_cname, self.pos)
                ))
            code.put_gotref(Naming.quick_temp_cname)
            code.put_decref(target, py_object_type)
            code.putln('%s = %s;' % (target, Naming.quick_temp_cname))
            code.putln('}')
4814 4815

    def generate_subexpr_disposal_code(self, code):
4816
        if self.mult_factor and self.mult_factor.type.is_int:
4817 4818 4819 4820 4821 4822 4823 4824 4825
            super(SequenceNode, self).generate_subexpr_disposal_code(code)
        else:
            # We call generate_post_assignment_code here instead
            # of generate_disposal_code, because values were stored
            # in the tuple using a reference-stealing operation.
            for arg in self.args:
                arg.generate_post_assignment_code(code)
                # Should NOT call free_temps -- this is invoked by the default
                # generate_evaluation_code which will do that.
4826 4827
            if self.mult_factor:
                self.mult_factor.generate_disposal_code(code)
4828

William Stein's avatar
William Stein committed
4829
    def generate_assignment_code(self, rhs, code):
4830 4831 4832
        if self.starred_assignment:
            self.generate_starred_assignment_code(rhs, code)
        else:
4833
            self.generate_parallel_assignment_code(rhs, code)
4834 4835 4836 4837 4838

        for item in self.unpacked_items:
            item.release(code)
        rhs.free_temps(code)

4839 4840 4841 4842 4843
    _func_iternext_type = PyrexTypes.CPtrType(PyrexTypes.CFuncType(
        PyrexTypes.py_object_type, [
            PyrexTypes.CFuncTypeArg("it", PyrexTypes.py_object_type, None),
            ]))

4844
    def generate_parallel_assignment_code(self, rhs, code):
4845 4846 4847
        # Need to work around the fact that generate_evaluation_code
        # allocates the temps in a rather hacky way -- the assignment
        # is evaluated twice, within each if-block.
4848 4849
        for item in self.unpacked_items:
            item.allocate(code)
4850 4851 4852 4853 4854 4855 4856 4857 4858 4859 4860 4861 4862 4863 4864 4865 4866 4867 4868 4869 4870 4871 4872 4873 4874 4875 4876 4877
        special_unpack = (rhs.type is py_object_type
                          or rhs.type in (tuple_type, list_type)
                          or not rhs.type.is_builtin_type)
        if special_unpack:
            tuple_check = 'likely(PyTuple_CheckExact(%s))' % rhs.py_result()
            list_check  = 'PyList_CheckExact(%s)' % rhs.py_result()
            if rhs.type is list_type:
                sequence_types = ['List']
                sequence_type_test = list_check
            elif rhs.type is tuple_type:
                sequence_types = ['Tuple']
                sequence_type_test = tuple_check
            else:
                sequence_types = ['Tuple', 'List']
                sequence_type_test = "(%s) || (%s)" % (tuple_check, list_check)
            code.putln("if (%s) {" % sequence_type_test)
            code.putln("PyObject* sequence = %s;" % rhs.py_result())
            if len(sequence_types) == 2:
                code.putln("if (likely(Py%s_CheckExact(sequence))) {" % sequence_types[0])
            self.generate_special_parallel_unpacking_code(code, sequence_types[0])
            if len(sequence_types) == 2:
                code.putln("} else {")
                self.generate_special_parallel_unpacking_code(code, sequence_types[1])
                code.putln("}")
            for item in self.unpacked_items:
                code.put_incref(item.result(), item.ctype())
            rhs.generate_disposal_code(code)
            code.putln("} else {")
4878 4879
        else:
            code.putln("{")
4880

4881
        if special_unpack and rhs.type is tuple_type:
4882 4883 4884 4885
            code.globalstate.use_utility_code(tuple_unpacking_error_code)
            code.putln("__Pyx_UnpackTupleError(%s, %s);" % (
                        rhs.py_result(), len(self.args)))
            code.putln(code.error_goto(self.pos))
4886
        else:
4887
            self.generate_generic_parallel_unpacking_code(code, rhs)
4888
        code.putln("}")
4889

4890 4891
        for value_node in self.coerced_unpacked_items:
            value_node.generate_evaluation_code(code)
4892 4893 4894
        for i in range(len(self.args)):
            self.args[i].generate_assignment_code(
                self.coerced_unpacked_items[i], code)
4895

4896 4897 4898 4899 4900 4901 4902 4903 4904 4905 4906 4907
    def generate_special_parallel_unpacking_code(self, code, sequence_type):
        code.globalstate.use_utility_code(raise_need_more_values_to_unpack)
        code.globalstate.use_utility_code(raise_too_many_values_to_unpack)
        code.putln("if (unlikely(Py%s_GET_SIZE(sequence) != %d)) {" % (
            sequence_type, len(self.args)))
        code.putln("if (Py%s_GET_SIZE(sequence) > %d) __Pyx_RaiseTooManyValuesError(%d);" % (
            sequence_type, len(self.args), len(self.args)))
        code.putln("else __Pyx_RaiseNeedMoreValuesError(Py%s_GET_SIZE(sequence));" % sequence_type)
        code.putln(code.error_goto(self.pos))
        code.putln("}")
        for i, item in enumerate(self.unpacked_items):
            code.putln("%s = Py%s_GET_ITEM(sequence, %d); " % (item.result(), sequence_type, i))
Robert Bradshaw's avatar
Robert Bradshaw committed
4908

4909 4910 4911
    def generate_generic_parallel_unpacking_code(self, code, rhs):
        code.globalstate.use_utility_code(iternext_unpacking_end_utility_code)
        code.globalstate.use_utility_code(raise_need_more_values_to_unpack)
4912
        code.putln("Py_ssize_t index = -1;") # must be at the start of a C block!
4913

4914 4915 4916 4917 4918 4919 4920 4921
        iterator_temp = code.funcstate.allocate_temp(py_object_type, manage_ref=True)
        code.putln(
            "%s = PyObject_GetIter(%s); %s" % (
                iterator_temp,
                rhs.py_result(),
                code.error_goto_if_null(iterator_temp, self.pos)))
        code.put_gotref(iterator_temp)
        rhs.generate_disposal_code(code)
4922

4923 4924 4925
        iternext_func = code.funcstate.allocate_temp(self._func_iternext_type, manage_ref=False)
        code.putln("%s = Py_TYPE(%s)->tp_iternext;" % (
            iternext_func, iterator_temp))
William Stein's avatar
William Stein committed
4926

4927 4928 4929 4930 4931 4932 4933 4934 4935 4936 4937 4938 4939 4940 4941 4942 4943 4944 4945 4946 4947 4948 4949 4950 4951 4952 4953 4954 4955
        unpacking_error_label = code.new_label('unpacking_failed')
        code.use_label(unpacking_error_label)
        unpack_code = "%s(%s)" % (iternext_func, iterator_temp)
        for i in range(len(self.args)):
            item = self.unpacked_items[i]
            code.putln(
                "index = %d; %s = %s; if (unlikely(!%s)) goto %s;" % (
                    i,
                    item.result(),
                    typecast(item.ctype(), py_object_type, unpack_code),
                    item.result(),
                    unpacking_error_label))
            code.put_gotref(item.py_result())
        code.put_error_if_neg(self.pos, "__Pyx_IternextUnpackEndCheck(%s(%s), %d)" % (
            iternext_func,
            iterator_temp,
            len(self.args)))
        code.put_decref_clear(iterator_temp, py_object_type)
        code.funcstate.release_temp(iterator_temp)
        code.funcstate.release_temp(iternext_func)
        unpacking_done_label = code.new_label('unpacking_done')
        code.put_goto(unpacking_done_label)

        code.put_label(unpacking_error_label)
        code.put_decref_clear(iterator_temp, py_object_type)
        code.putln("if (PyErr_Occurred() && PyErr_ExceptionMatches(PyExc_StopIteration)) PyErr_Clear();")
        code.putln("if (!PyErr_Occurred()) __Pyx_RaiseNeedMoreValuesError(index);")
        code.putln(code.error_goto(self.pos))
        code.put_label(unpacking_done_label)
4956 4957 4958 4959 4960 4961 4962 4963 4964

    def generate_starred_assignment_code(self, rhs, code):
        for i, arg in enumerate(self.args):
            if arg.is_starred:
                starred_target = self.unpacked_items[i]
                fixed_args_left  = self.args[:i]
                fixed_args_right = self.args[i+1:]
                break

4965
        iterator_temp = code.funcstate.allocate_temp(py_object_type, manage_ref=True)
4966 4967
        code.putln(
            "%s = PyObject_GetIter(%s); %s" % (
4968
                iterator_temp,
4969
                rhs.py_result(),
4970 4971
                code.error_goto_if_null(iterator_temp, self.pos)))
        code.put_gotref(iterator_temp)
4972 4973
        rhs.generate_disposal_code(code)

4974
        for item in self.unpacked_items:
4975
            item.allocate(code)
4976
        code.globalstate.use_utility_code(unpacking_utility_code)
4977 4978 4979
        for i in range(len(fixed_args_left)):
            item = self.unpacked_items[i]
            unpack_code = "__Pyx_UnpackItem(%s, %d)" % (
4980
                iterator_temp, i)
4981 4982 4983 4984 4985 4986 4987 4988 4989 4990 4991
            code.putln(
                "%s = %s; %s" % (
                    item.result(),
                    typecast(item.ctype(), py_object_type, unpack_code),
                    code.error_goto_if_null(item.result(), self.pos)))
            code.put_gotref(item.py_result())
            value_node = self.coerced_unpacked_items[i]
            value_node.generate_evaluation_code(code)

        target_list = starred_target.result()
        code.putln("%s = PySequence_List(%s); %s" % (
4992
            target_list, iterator_temp,
4993 4994 4995 4996 4997 4998 4999 5000 5001 5002 5003 5004 5005 5006 5007 5008 5009 5010
            code.error_goto_if_null(target_list, self.pos)))
        code.put_gotref(target_list)
        if fixed_args_right:
            code.globalstate.use_utility_code(raise_need_more_values_to_unpack)
            unpacked_right_args = self.unpacked_items[-len(fixed_args_right):]
            code.putln("if (unlikely(PyList_GET_SIZE(%s) < %d)) {" % (
                (target_list, len(unpacked_right_args))))
            code.put("__Pyx_RaiseNeedMoreValuesError(%d+PyList_GET_SIZE(%s)); %s" % (
                     len(fixed_args_left), target_list,
                     code.error_goto(self.pos)))
            code.putln('}')
            for i, (arg, coerced_arg) in enumerate(zip(unpacked_right_args[::-1],
                                                       self.coerced_unpacked_items[::-1])):
                code.putln(
                    "%s = PyList_GET_ITEM(%s, PyList_GET_SIZE(%s)-1); " % (
                        arg.py_result(),
                        target_list, target_list))
                # resize the list the hard way
5011
                code.putln("((PyVarObject*)%s)->ob_size--;" % target_list)
5012 5013 5014
                code.put_gotref(arg.py_result())
                coerced_arg.generate_evaluation_code(code)

5015 5016
        code.put_decref_clear(iterator_temp, py_object_type)
        code.funcstate.release_temp(iterator_temp)
5017 5018 5019 5020 5021

        for i in range(len(self.args)):
            self.args[i].generate_assignment_code(
                self.coerced_unpacked_items[i], code)

5022 5023 5024 5025 5026 5027 5028 5029
    def annotate(self, code):
        for arg in self.args:
            arg.annotate(code)
        if self.unpacked_items:
            for arg in self.unpacked_items:
                arg.annotate(code)
            for arg in self.coerced_unpacked_items:
                arg.annotate(code)
William Stein's avatar
William Stein committed
5030 5031 5032 5033


class TupleNode(SequenceNode):
    #  Tuple constructor.
5034

5035
    type = tuple_type
5036
    is_partly_literal = False
5037 5038 5039

    gil_message = "Constructing Python tuple"

5040
    def analyse_types(self, env, skip_children=False):
Robert Bradshaw's avatar
Robert Bradshaw committed
5041
        if len(self.args) == 0:
5042 5043
            self.is_temp = False
            self.is_literal = True
Robert Bradshaw's avatar
Robert Bradshaw committed
5044
        else:
5045
            SequenceNode.analyse_types(self, env, skip_children)
5046 5047 5048 5049
            for child in self.args:
                if not child.is_literal:
                    break
            else:
5050 5051 5052 5053 5054 5055 5056
                if not self.mult_factor or self.mult_factor.is_literal and \
                       isinstance(self.mult_factor.constant_result, (int, long)):
                    self.is_temp = False
                    self.is_literal = True
                else:
                    self.is_temp = True
                    self.is_partly_literal = True
5057

Stefan Behnel's avatar
Stefan Behnel committed
5058 5059 5060 5061
    def is_simple(self):
        # either temp or constant => always simple
        return True

5062 5063 5064 5065
    def nonlocally_immutable(self):
        # either temp or constant => always safe
        return True

Robert Bradshaw's avatar
Robert Bradshaw committed
5066 5067
    def calculate_result_code(self):
        if len(self.args) > 0:
5068
            return self.result_code
Robert Bradshaw's avatar
Robert Bradshaw committed
5069 5070
        else:
            return Naming.empty_tuple
William Stein's avatar
William Stein committed
5071

5072 5073 5074 5075
    def calculate_constant_result(self):
        self.constant_result = tuple([
                arg.constant_result for arg in self.args])

5076 5077 5078 5079 5080 5081
    def compile_time_value(self, denv):
        values = self.compile_time_value_list(denv)
        try:
            return tuple(values)
        except Exception, e:
            self.compile_time_value_error(e)
5082

William Stein's avatar
William Stein committed
5083
    def generate_operation_code(self, code):
Robert Bradshaw's avatar
Robert Bradshaw committed
5084 5085 5086
        if len(self.args) == 0:
            # result_code is Naming.empty_tuple
            return
5087 5088 5089 5090 5091 5092 5093 5094 5095 5096 5097 5098 5099
        if self.is_partly_literal:
            # underlying tuple is const, but factor is not
            tuple_target = code.get_py_const(py_object_type, 'tuple_', cleanup_level=2)
            const_code = code.get_cached_constants_writer()
            const_code.mark_pos(self.pos)
            self.generate_sequence_packing_code(const_code, tuple_target, plain=True)
            const_code.put_giveref(tuple_target)
            code.putln('%s = PyNumber_Multiply(%s, %s); %s' % (
                self.result(), tuple_target, self.mult_factor.py_result(),
                code.error_goto_if_null(self.result(), self.pos)
                ))
            code.put_gotref(self.py_result())
        elif self.is_literal:
5100 5101
            # non-empty cached tuple => result is global constant,
            # creation code goes into separate code writer
5102
            self.result_code = code.get_py_const(py_object_type, 'tuple_', cleanup_level=2)
5103 5104
            code = code.get_cached_constants_writer()
            code.mark_pos(self.pos)
5105
            self.generate_sequence_packing_code(code)
5106
            code.put_giveref(self.py_result())
5107 5108
        else:
            self.generate_sequence_packing_code(code)
William Stein's avatar
William Stein committed
5109 5110 5111 5112


class ListNode(SequenceNode):
    #  List constructor.
5113

5114 5115
    # obj_conversion_errors    [PyrexError]   used internally
    # orignial_args            [ExprNode]     used internally
5116

5117
    obj_conversion_errors = []
Stefan Behnel's avatar
Stefan Behnel committed
5118
    type = list_type
5119

5120
    gil_message = "Constructing Python list"
5121

Robert Bradshaw's avatar
Robert Bradshaw committed
5122
    def type_dependencies(self, env):
5123
        return ()
5124

5125 5126 5127
    def infer_type(self, env):
        # TOOD: Infer non-object list arrays.
        return list_type
5128

5129
    def analyse_expressions(self, env):
5130
        SequenceNode.analyse_expressions(self, env)
5131 5132
        self.coerce_to_pyobject(env)

Robert Bradshaw's avatar
Robert Bradshaw committed
5133
    def analyse_types(self, env):
5134 5135 5136 5137 5138
        hold_errors()
        self.original_args = list(self.args)
        SequenceNode.analyse_types(self, env)
        self.obj_conversion_errors = held_errors()
        release_errors(ignore=True)
5139

Robert Bradshaw's avatar
Robert Bradshaw committed
5140 5141
    def coerce_to(self, dst_type, env):
        if dst_type.is_pyobject:
5142 5143 5144
            for err in self.obj_conversion_errors:
                report_error(err)
            self.obj_conversion_errors = []
Robert Bradshaw's avatar
Robert Bradshaw committed
5145 5146
            if not self.type.subtype_of(dst_type):
                error(self.pos, "Cannot coerce list to type '%s'" % dst_type)
5147 5148
        elif self.mult_factor:
            error(self.pos, "Cannot coerce multiplied list to '%s'" % dst_type)
5149
        elif dst_type.is_ptr and dst_type.base_type is not PyrexTypes.c_void_type:
Robert Bradshaw's avatar
Robert Bradshaw committed
5150
            base_type = dst_type.base_type
Robert Bradshaw's avatar
Robert Bradshaw committed
5151
            self.type = PyrexTypes.CArrayType(base_type, len(self.args))
5152
            for i in range(len(self.original_args)):
Robert Bradshaw's avatar
Robert Bradshaw committed
5153
                arg = self.args[i]
5154 5155
                if isinstance(arg, CoerceToPyTypeNode):
                    arg = arg.arg
Robert Bradshaw's avatar
Robert Bradshaw committed
5156
                self.args[i] = arg.coerce_to(base_type, env)
Robert Bradshaw's avatar
Robert Bradshaw committed
5157 5158 5159 5160 5161 5162
        elif dst_type.is_struct:
            if len(self.args) > len(dst_type.scope.var_entries):
                error(self.pos, "Too may members for '%s'" % dst_type)
            else:
                if len(self.args) < len(dst_type.scope.var_entries):
                    warning(self.pos, "Too few members for '%s'" % dst_type, 1)
5163 5164 5165
                for i, (arg, member) in enumerate(zip(self.original_args, dst_type.scope.var_entries)):
                    if isinstance(arg, CoerceToPyTypeNode):
                        arg = arg.arg
Robert Bradshaw's avatar
Robert Bradshaw committed
5166 5167
                    self.args[i] = arg.coerce_to(member.type, env)
            self.type = dst_type
Robert Bradshaw's avatar
Robert Bradshaw committed
5168 5169 5170 5171
        else:
            self.type = error_type
            error(self.pos, "Cannot coerce list to type '%s'" % dst_type)
        return self
5172

Robert Bradshaw's avatar
Robert Bradshaw committed
5173 5174
    def release_temp(self, env):
        if self.type.is_array:
5175 5176
            # To be valid C++, we must allocate the memory on the stack
            # manually and be sure not to reuse it for something else.
Robert Bradshaw's avatar
Robert Bradshaw committed
5177 5178 5179
            pass
        else:
            SequenceNode.release_temp(self, env)
Robert Bradshaw's avatar
Robert Bradshaw committed
5180

5181
    def calculate_constant_result(self):
5182 5183
        if self.mult_factor:
            raise ValueError() # may exceed the compile time memory
5184 5185 5186
        self.constant_result = [
            arg.constant_result for arg in self.args]

5187
    def compile_time_value(self, denv):
5188 5189 5190 5191
        l = self.compile_time_value_list(denv)
        if self.mult_factor:
            l *= self.mult_factor.compile_time_value(denv)
        return l
5192

William Stein's avatar
William Stein committed
5193
    def generate_operation_code(self, code):
Robert Bradshaw's avatar
Robert Bradshaw committed
5194
        if self.type.is_pyobject:
5195 5196
            for err in self.obj_conversion_errors:
                report_error(err)
5197
            self.generate_sequence_packing_code(code)
Robert Bradshaw's avatar
Robert Bradshaw committed
5198 5199 5200 5201 5202 5203
        elif self.type.is_array:
            for i, arg in enumerate(self.args):
                code.putln("%s[%s] = %s;" % (
                                self.result(),
                                i,
                                arg.result()))
Robert Bradshaw's avatar
Robert Bradshaw committed
5204
        elif self.type.is_struct:
Robert Bradshaw's avatar
Robert Bradshaw committed
5205 5206 5207 5208 5209
            for arg, member in zip(self.args, self.type.scope.var_entries):
                code.putln("%s.%s = %s;" % (
                        self.result(),
                        member.cname,
                        arg.result()))
5210 5211
        else:
            raise InternalError("List type never specified")
5212

Robert Bradshaw's avatar
Robert Bradshaw committed
5213

5214 5215 5216 5217 5218 5219 5220 5221 5222
class ScopedExprNode(ExprNode):
    # Abstract base class for ExprNodes that have their own local
    # scope, such as generator expressions.
    #
    # expr_scope    Scope  the inner scope of the expression

    subexprs = []
    expr_scope = None

5223 5224 5225 5226 5227 5228 5229 5230 5231 5232 5233 5234 5235 5236 5237 5238 5239 5240 5241
    # does this node really have a local scope, e.g. does it leak loop
    # variables or not?  non-leaking Py3 behaviour is default, except
    # for list comprehensions where the behaviour differs in Py2 and
    # Py3 (set in Parsing.py based on parser context)
    has_local_scope = True

    def init_scope(self, outer_scope, expr_scope=None):
        if expr_scope is not None:
            self.expr_scope = expr_scope
        elif self.has_local_scope:
            self.expr_scope = Symtab.GeneratorExpressionScope(outer_scope)
        else:
            self.expr_scope = None

    def analyse_declarations(self, env):
        self.init_scope(env)

    def analyse_scoped_declarations(self, env):
        # this is called with the expr_scope as env
5242 5243
        pass

5244 5245
    def analyse_types(self, env):
        # no recursion here, the children will be analysed separately below
5246 5247 5248 5249 5250 5251
        pass

    def analyse_scoped_expressions(self, env):
        # this is called with the expr_scope as env
        pass

5252 5253 5254 5255 5256 5257 5258 5259 5260 5261 5262 5263 5264 5265 5266 5267 5268 5269 5270 5271 5272 5273 5274 5275 5276 5277 5278 5279 5280 5281 5282 5283 5284 5285 5286 5287 5288 5289 5290 5291 5292 5293 5294 5295 5296 5297 5298
    def generate_evaluation_code(self, code):
        # set up local variables and free their references on exit
        generate_inner_evaluation_code = super(ScopedExprNode, self).generate_evaluation_code
        if not self.has_local_scope or not self.expr_scope.var_entries:
            # no local variables => delegate, done
            generate_inner_evaluation_code(code)
            return

        code.putln('{ /* enter inner scope */')
        py_entries = []
        for entry in self.expr_scope.var_entries:
            if not entry.in_closure:
                code.put_var_declaration(entry)
                if entry.type.is_pyobject and entry.used:
                    py_entries.append(entry)
        if not py_entries:
            # no local Python references => no cleanup required
            generate_inner_evaluation_code(code)
            code.putln('} /* exit inner scope */')
            return

        # must free all local Python references at each exit point
        old_loop_labels = tuple(code.new_loop_labels())
        old_error_label = code.new_error_label()

        generate_inner_evaluation_code(code)

        # normal (non-error) exit
        for entry in py_entries:
            code.put_var_decref(entry)

        # error/loop body exit points
        exit_scope = code.new_label('exit_scope')
        code.put_goto(exit_scope)
        for label, old_label in ([(code.error_label, old_error_label)] +
                                 list(zip(code.get_loop_labels(), old_loop_labels))):
            if code.label_used(label):
                code.put_label(label)
                for entry in py_entries:
                    code.put_var_decref(entry)
                code.put_goto(old_label)
        code.put_label(exit_scope)
        code.putln('} /* exit inner scope */')

        code.set_loop_labels(old_loop_labels)
        code.error_label = old_error_label

5299 5300

class ComprehensionNode(ScopedExprNode):
5301
    subexprs = ["target"]
5302
    child_attrs = ["loop"]
5303

5304 5305
    def infer_type(self, env):
        return self.target.infer_type(env)
5306 5307 5308

    def analyse_declarations(self, env):
        self.append.target = self # this is used in the PyList_Append of the inner loop
5309 5310
        self.init_scope(env)

5311 5312
    def analyse_scoped_declarations(self, env):
        self.loop.analyse_declarations(env)
5313

5314 5315 5316
    def analyse_types(self, env):
        self.target.analyse_expressions(env)
        self.type = self.target.type
5317 5318
        if not self.has_local_scope:
            self.loop.analyse_expressions(env)
5319

5320 5321 5322
    def analyse_scoped_expressions(self, env):
        if self.has_local_scope:
            self.loop.analyse_expressions(env)
5323

5324 5325 5326
    def may_be_none(self):
        return False

5327 5328
    def calculate_result_code(self):
        return self.target.result()
5329

5330 5331
    def generate_result_code(self, code):
        self.generate_operation_code(code)
Robert Bradshaw's avatar
Robert Bradshaw committed
5332

5333 5334 5335
    def generate_operation_code(self, code):
        self.loop.generate_execution_code(code)

5336 5337
    def annotate(self, code):
        self.loop.annotate(code)
5338 5339


5340
class ComprehensionAppendNode(Node):
5341 5342
    # Need to be careful to avoid infinite recursion:
    # target must not be in child_attrs/subexprs
5343 5344

    child_attrs = ['expr']
5345 5346

    type = PyrexTypes.c_int_type
5347

5348 5349
    def analyse_expressions(self, env):
        self.expr.analyse_expressions(env)
5350
        if not self.expr.type.is_pyobject:
Robert Bradshaw's avatar
Robert Bradshaw committed
5351
            self.expr = self.expr.coerce_to_pyobject(env)
5352

5353
    def generate_execution_code(self, code):
5354 5355 5356 5357 5358 5359 5360
        if self.target.type is list_type:
            function = "PyList_Append"
        elif self.target.type is set_type:
            function = "PySet_Add"
        else:
            raise InternalError(
                "Invalid type for comprehension node: %s" % self.target.type)
5361 5362 5363 5364 5365 5366 5367 5368 5369 5370 5371 5372 5373 5374 5375

        self.expr.generate_evaluation_code(code)
        code.putln(code.error_goto_if("%s(%s, (PyObject*)%s)" % (
            function,
            self.target.result(),
            self.expr.result()
            ), self.pos))
        self.expr.generate_disposal_code(code)
        self.expr.free_temps(code)

    def generate_function_definitions(self, env, code):
        self.expr.generate_function_definitions(env, code)

    def annotate(self, code):
        self.expr.annotate(code)
5376 5377

class DictComprehensionAppendNode(ComprehensionAppendNode):
5378
    child_attrs = ['key_expr', 'value_expr']
5379

5380 5381
    def analyse_expressions(self, env):
        self.key_expr.analyse_expressions(env)
5382 5383
        if not self.key_expr.type.is_pyobject:
            self.key_expr = self.key_expr.coerce_to_pyobject(env)
5384
        self.value_expr.analyse_expressions(env)
5385 5386 5387
        if not self.value_expr.type.is_pyobject:
            self.value_expr = self.value_expr.coerce_to_pyobject(env)

5388 5389 5390 5391 5392 5393 5394 5395 5396 5397 5398 5399 5400 5401 5402 5403 5404 5405 5406 5407
    def generate_execution_code(self, code):
        self.key_expr.generate_evaluation_code(code)
        self.value_expr.generate_evaluation_code(code)
        code.putln(code.error_goto_if("PyDict_SetItem(%s, (PyObject*)%s, (PyObject*)%s)" % (
            self.target.result(),
            self.key_expr.result(),
            self.value_expr.result()
            ), self.pos))
        self.key_expr.generate_disposal_code(code)
        self.key_expr.free_temps(code)
        self.value_expr.generate_disposal_code(code)
        self.value_expr.free_temps(code)

    def generate_function_definitions(self, env, code):
        self.key_expr.generate_function_definitions(env, code)
        self.value_expr.generate_function_definitions(env, code)

    def annotate(self, code):
        self.key_expr.annotate(code)
        self.value_expr.annotate(code)
5408 5409


5410 5411 5412 5413 5414
class InlinedGeneratorExpressionNode(ScopedExprNode):
    # An inlined generator expression for which the result is
    # calculated inside of the loop.  This will only be created by
    # transforms when replacing builtin calls on generator
    # expressions.
5415
    #
5416 5417 5418
    # loop           ForStatNode      the for-loop, not containing any YieldExprNodes
    # result_node    ResultRefNode    the reference to the result value temp
    # orig_func      String           the name of the builtin function this node replaces
5419

5420
    child_attrs = ["loop"]
5421
    loop_analysed = False
5422 5423
    type = py_object_type

5424 5425
    def analyse_scoped_declarations(self, env):
        self.loop.analyse_declarations(env)
5426

5427 5428 5429 5430 5431 5432
    def may_be_none(self):
        return False

    def annotate(self, code):
        self.loop.annotate(code)

5433 5434
    def infer_type(self, env):
        return self.result_node.infer_type(env)
5435 5436

    def analyse_types(self, env):
5437 5438 5439
        if not self.has_local_scope:
            self.loop_analysed = True
            self.loop.analyse_expressions(env)
5440 5441 5442
        self.type = self.result_node.type
        self.is_temp = True

5443 5444
    def analyse_scoped_expressions(self, env):
        self.loop_analysed = True
5445 5446
        if self.has_local_scope:
            self.loop.analyse_expressions(env)
5447

5448
    def coerce_to(self, dst_type, env):
5449 5450 5451 5452 5453 5454
        if self.orig_func == 'sum' and dst_type.is_numeric and not self.loop_analysed:
            # We can optimise by dropping the aggregation variable and
            # the add operations into C.  This can only be done safely
            # before analysing the loop body, after that, the result
            # reference type will have infected expressions and
            # assignments.
5455 5456
            self.result_node.type = self.type = dst_type
            return self
5457
        return super(InlinedGeneratorExpressionNode, self).coerce_to(dst_type, env)
5458

5459 5460 5461 5462 5463
    def generate_result_code(self, code):
        self.result_node.result_code = self.result()
        self.loop.generate_execution_code(code)


5464
class SetNode(ExprNode):
5465 5466
    #  Set constructor.

5467 5468
    type = set_type

5469 5470 5471
    subexprs = ['args']

    gil_message = "Constructing Python set"
5472

5473 5474 5475 5476 5477 5478 5479 5480
    def analyse_types(self, env):
        for i in range(len(self.args)):
            arg = self.args[i]
            arg.analyse_types(env)
            self.args[i] = arg.coerce_to_pyobject(env)
        self.type = set_type
        self.is_temp = 1

5481 5482 5483
    def may_be_none(self):
        return False

5484 5485 5486 5487
    def calculate_constant_result(self):
        self.constant_result = set([
                arg.constant_result for arg in self.args])

5488 5489 5490 5491 5492 5493 5494 5495
    def compile_time_value(self, denv):
        values = [arg.compile_time_value(denv) for arg in self.args]
        try:
            return set(values)
        except Exception, e:
            self.compile_time_value_error(e)

    def generate_evaluation_code(self, code):
Robert Bradshaw's avatar
Robert Bradshaw committed
5496
        code.globalstate.use_utility_code(Builtin.py_set_utility_code)
5497 5498 5499 5500 5501
        self.allocate_temp_result(code)
        code.putln(
            "%s = PySet_New(0); %s" % (
                self.result(),
                code.error_goto_if_null(self.result(), self.pos)))
5502
        code.put_gotref(self.py_result())
5503 5504 5505 5506 5507 5508 5509 5510
        for arg in self.args:
            arg.generate_evaluation_code(code)
            code.putln(
                code.error_goto_if_neg(
                    "PySet_Add(%s, %s)" % (self.result(), arg.py_result()),
                    self.pos))
            arg.generate_disposal_code(code)
            arg.free_temps(code)
Robert Bradshaw's avatar
Robert Bradshaw committed
5511

William Stein's avatar
William Stein committed
5512

5513
class DictNode(ExprNode):
William Stein's avatar
William Stein committed
5514 5515
    #  Dictionary constructor.
    #
Vitja Makarov's avatar
Vitja Makarov committed
5516 5517
    #  key_value_pairs     [DictItemNode]
    #  exclude_null_values [boolean]          Do not add NULL values to dict
5518 5519
    #
    # obj_conversion_errors    [PyrexError]   used internally
5520

5521
    subexprs = ['key_value_pairs']
5522
    is_temp = 1
Vitja Makarov's avatar
Vitja Makarov committed
5523
    exclude_null_values = False
5524
    type = dict_type
5525

5526
    obj_conversion_errors = []
5527 5528 5529 5530

    def calculate_constant_result(self):
        self.constant_result = dict([
                item.constant_result for item in self.key_value_pairs])
5531

5532
    def compile_time_value(self, denv):
Robert Bradshaw's avatar
Robert Bradshaw committed
5533 5534
        pairs = [(item.key.compile_time_value(denv), item.value.compile_time_value(denv))
            for item in self.key_value_pairs]
5535 5536 5537 5538
        try:
            return dict(pairs)
        except Exception, e:
            self.compile_time_value_error(e)
5539

Robert Bradshaw's avatar
Robert Bradshaw committed
5540
    def type_dependencies(self, env):
5541
        return ()
5542

5543 5544 5545 5546
    def infer_type(self, env):
        # TOOD: Infer struct constructors.
        return dict_type

William Stein's avatar
William Stein committed
5547
    def analyse_types(self, env):
5548
        hold_errors()
Robert Bradshaw's avatar
Robert Bradshaw committed
5549 5550
        for item in self.key_value_pairs:
            item.analyse_types(env)
5551 5552
        self.obj_conversion_errors = held_errors()
        release_errors(ignore=True)
5553 5554 5555

    def may_be_none(self):
        return False
5556

5557 5558 5559 5560 5561 5562 5563 5564 5565 5566 5567 5568 5569 5570
    def coerce_to(self, dst_type, env):
        if dst_type.is_pyobject:
            self.release_errors()
            if not self.type.subtype_of(dst_type):
                error(self.pos, "Cannot interpret dict as type '%s'" % dst_type)
        elif dst_type.is_struct_or_union:
            self.type = dst_type
            if not dst_type.is_struct and len(self.key_value_pairs) != 1:
                error(self.pos, "Exactly one field must be specified to convert to union '%s'" % dst_type)
            elif dst_type.is_struct and len(self.key_value_pairs) < len(dst_type.scope.var_entries):
                warning(self.pos, "Not all members given for struct '%s'" % dst_type, 1)
            for item in self.key_value_pairs:
                if isinstance(item.key, CoerceToPyTypeNode):
                    item.key = item.key.arg
5571
                if not item.key.is_string_literal:
5572
                    error(item.key.pos, "Invalid struct field identifier")
5573
                    item.key = StringNode(item.key.pos, value="<error>")
5574
                else:
Stefan Behnel's avatar
Stefan Behnel committed
5575 5576
                    key = str(item.key.value) # converts string literals to unicode in Py3
                    member = dst_type.scope.lookup_here(key)
5577
                    if not member:
Stefan Behnel's avatar
Stefan Behnel committed
5578
                        error(item.key.pos, "struct '%s' has no field '%s'" % (dst_type, key))
5579 5580 5581 5582 5583 5584 5585 5586 5587
                    else:
                        value = item.value
                        if isinstance(value, CoerceToPyTypeNode):
                            value = value.arg
                        item.value = value.coerce_to(member.type, env)
        else:
            self.type = error_type
            error(self.pos, "Cannot interpret dict as type '%s'" % dst_type)
        return self
5588

5589 5590 5591 5592
    def release_errors(self):
        for err in self.obj_conversion_errors:
            report_error(err)
        self.obj_conversion_errors = []
5593 5594 5595

    gil_message = "Constructing Python dict"

William Stein's avatar
William Stein committed
5596 5597 5598
    def generate_evaluation_code(self, code):
        #  Custom method used here because key-value
        #  pairs are evaluated and used one at a time.
5599 5600
        code.mark_pos(self.pos)
        self.allocate_temp_result(code)
5601 5602 5603 5604 5605 5606
        if self.type.is_pyobject:
            self.release_errors()
            code.putln(
                "%s = PyDict_New(); %s" % (
                    self.result(),
                    code.error_goto_if_null(self.result(), self.pos)))
5607
            code.put_gotref(self.py_result())
Robert Bradshaw's avatar
Robert Bradshaw committed
5608 5609
        for item in self.key_value_pairs:
            item.generate_evaluation_code(code)
5610
            if self.type.is_pyobject:
Vitja Makarov's avatar
Vitja Makarov committed
5611 5612
                if self.exclude_null_values:
                    code.putln('if (%s) {' % item.value.py_result())
5613
                code.put_error_if_neg(self.pos,
5614 5615 5616 5617
                    "PyDict_SetItem(%s, %s, %s)" % (
                        self.result(),
                        item.key.py_result(),
                        item.value.py_result()))
Vitja Makarov's avatar
Vitja Makarov committed
5618 5619
                if self.exclude_null_values:
                    code.putln('}')
5620 5621 5622
            else:
                code.putln("%s.%s = %s;" % (
                        self.result(),
5623
                        item.key.value,
5624
                        item.value.result()))
Robert Bradshaw's avatar
Robert Bradshaw committed
5625
            item.generate_disposal_code(code)
5626
            item.free_temps(code)
5627

5628
    def annotate(self, code):
Robert Bradshaw's avatar
Robert Bradshaw committed
5629 5630
        for item in self.key_value_pairs:
            item.annotate(code)
5631

5632
class DictItemNode(ExprNode):
Robert Bradshaw's avatar
Robert Bradshaw committed
5633 5634 5635 5636 5637
    # Represents a single item in a DictNode
    #
    # key          ExprNode
    # value        ExprNode
    subexprs = ['key', 'value']
5638

5639
    nogil_check = None # Parent DictNode takes care of it
5640

5641 5642 5643
    def calculate_constant_result(self):
        self.constant_result = (
            self.key.constant_result, self.value.constant_result)
5644

Robert Bradshaw's avatar
Robert Bradshaw committed
5645 5646 5647 5648 5649
    def analyse_types(self, env):
        self.key.analyse_types(env)
        self.value.analyse_types(env)
        self.key = self.key.coerce_to_pyobject(env)
        self.value = self.value.coerce_to_pyobject(env)
5650

Robert Bradshaw's avatar
Robert Bradshaw committed
5651 5652 5653
    def generate_evaluation_code(self, code):
        self.key.generate_evaluation_code(code)
        self.value.generate_evaluation_code(code)
Stefan Behnel's avatar
Stefan Behnel committed
5654

5655 5656 5657
    def generate_disposal_code(self, code):
        self.key.generate_disposal_code(code)
        self.value.generate_disposal_code(code)
5658 5659 5660 5661

    def free_temps(self, code):
        self.key.free_temps(code)
        self.value.free_temps(code)
5662

5663 5664
    def __iter__(self):
        return iter([self.key, self.value])
William Stein's avatar
William Stein committed
5665

5666

5667 5668 5669 5670 5671 5672 5673
class ModuleNameMixin(object):
    def set_mod_name(self, env):
        self.module_name = env.global_scope().qualified_name

    def get_py_mod_name(self, code):
        return code.get_py_string_const(
                 self.module_name, identifier=True)
Stefan Behnel's avatar
Stefan Behnel committed
5674

5675
class ClassNode(ExprNode, ModuleNameMixin):
William Stein's avatar
William Stein committed
5676 5677 5678 5679
    #  Helper class used in the implementation of Python
    #  class definitions. Constructs a class object given
    #  a name, tuple of bases and class dictionary.
    #
Stefan Behnel's avatar
Stefan Behnel committed
5680
    #  name         EncodedString      Name of the class
William Stein's avatar
William Stein committed
5681 5682 5683
    #  bases        ExprNode           Base class tuple
    #  dict         ExprNode           Class dict (not owned by this node)
    #  doc          ExprNode or None   Doc string
5684
    #  module_name  EncodedString      Name of defining module
5685

5686
    subexprs = ['bases', 'doc']
5687

William Stein's avatar
William Stein committed
5688 5689 5690 5691 5692 5693 5694 5695
    def analyse_types(self, env):
        self.bases.analyse_types(env)
        if self.doc:
            self.doc.analyse_types(env)
            self.doc = self.doc.coerce_to_pyobject(env)
        self.type = py_object_type
        self.is_temp = 1
        env.use_utility_code(create_class_utility_code);
5696 5697
        #TODO(craig,haoyu) This should be moved to a better place
        self.set_mod_name(env)
5698

5699
    def may_be_none(self):
Stefan Behnel's avatar
Stefan Behnel committed
5700
        return True
5701

5702 5703
    gil_message = "Constructing Python class"

William Stein's avatar
William Stein committed
5704
    def generate_result_code(self, code):
5705
        cname = code.intern_identifier(self.name)
5706

William Stein's avatar
William Stein committed
5707
        if self.doc:
5708
            code.put_error_if_neg(self.pos,
Robert Bradshaw's avatar
Robert Bradshaw committed
5709
                'PyDict_SetItemString(%s, "__doc__", %s)' % (
William Stein's avatar
William Stein committed
5710
                    self.dict.py_result(),
Robert Bradshaw's avatar
Robert Bradshaw committed
5711
                    self.doc.py_result()))
5712
        py_mod_name = self.get_py_mod_name(code)
William Stein's avatar
William Stein committed
5713
        code.putln(
5714
            '%s = __Pyx_CreateClass(%s, %s, %s, %s); %s' % (
5715
                self.result(),
William Stein's avatar
William Stein committed
5716 5717
                self.bases.py_result(),
                self.dict.py_result(),
5718
                cname,
5719
                py_mod_name,
5720
                code.error_goto_if_null(self.result(), self.pos)))
5721
        code.put_gotref(self.py_result())
William Stein's avatar
William Stein committed
5722

Stefan Behnel's avatar
Stefan Behnel committed
5723

5724 5725 5726 5727 5728 5729 5730 5731 5732 5733 5734 5735 5736 5737 5738 5739 5740 5741
class Py3ClassNode(ExprNode):
    #  Helper class used in the implementation of Python3+
    #  class definitions. Constructs a class object given
    #  a name, tuple of bases and class dictionary.
    #
    #  name         EncodedString      Name of the class
    #  dict         ExprNode           Class dict (not owned by this node)
    #  module_name  EncodedString      Name of defining module

    subexprs = []

    def analyse_types(self, env):
        self.type = py_object_type
        self.is_temp = 1

    def may_be_none(self):
        return True

5742
    gil_message = "Constructing Python class"
5743 5744

    def generate_result_code(self, code):
5745
        code.globalstate.use_utility_code(create_py3class_utility_code)
5746 5747 5748 5749 5750 5751 5752 5753 5754 5755 5756 5757 5758
        cname = code.intern_identifier(self.name)
        code.putln(
            '%s = __Pyx_Py3ClassCreate(%s, %s, %s, %s, %s); %s' % (
                self.result(),
                self.metaclass.result(),
                cname,
                self.bases.py_result(),
                self.dict.py_result(),
                self.mkw.py_result(),
                code.error_goto_if_null(self.result(), self.pos)))
        code.put_gotref(self.py_result())

class KeywordArgsNode(ExprNode):
5759
    #  Helper class for keyword arguments.
5760
    #
5761 5762
    #  starstar_arg      DictNode
    #  keyword_args      [DictItemNode]
5763

5764 5765 5766 5767 5768 5769 5770 5771 5772 5773 5774 5775 5776 5777 5778 5779 5780 5781 5782 5783 5784 5785 5786 5787 5788 5789
    subexprs = ['starstar_arg', 'keyword_args']
    is_temp = 1
    type = dict_type

    def calculate_constant_result(self):
        result = dict(self.starstar_arg.constant_result)
        for item in self.keyword_args:
            key, value = item.constant_result
            if key in result:
                raise ValueError("duplicate keyword argument found: %s" % key)
            result[key] = value
        self.constant_result = result

    def compile_time_value(self, denv):
        result = self.starstar_arg.compile_time_value(denv)
        pairs = [ (item.key.compile_time_value(denv), item.value.compile_time_value(denv))
                  for item in self.keyword_args ]
        try:
            result = dict(result)
            for key, value in pairs:
                if key in result:
                    raise ValueError("duplicate keyword argument found: %s" % key)
                result[key] = value
        except Exception, e:
            self.compile_time_value_error(e)
        return result
5790

5791 5792 5793 5794 5795
    def type_dependencies(self, env):
        return ()

    def infer_type(self, env):
        return dict_type
5796 5797

    def analyse_types(self, env):
5798 5799 5800 5801 5802 5803
        self.starstar_arg.analyse_types(env)
        self.starstar_arg = self.starstar_arg.coerce_to_pyobject(env).as_none_safe_node(
            # FIXME: CPython's error message starts with the runtime function name
            'argument after ** must be a mapping, not NoneType')
        for item in self.keyword_args:
            item.analyse_types(env)
5804

5805 5806
    def may_be_none(self):
        return False
5807

5808 5809 5810 5811 5812 5813 5814 5815 5816 5817
    gil_message = "Constructing Python dict"

    def generate_evaluation_code(self, code):
        code.mark_pos(self.pos)
        self.allocate_temp_result(code)
        self.starstar_arg.generate_evaluation_code(code)
        if self.starstar_arg.type is not Builtin.dict_type:
            # CPython supports calling functions with non-dicts, so do we
            code.putln('if (likely(PyDict_Check(%s))) {' %
                       self.starstar_arg.py_result())
5818 5819 5820 5821 5822 5823
        if self.keyword_args:
            code.putln(
                "%s = PyDict_Copy(%s); %s" % (
                    self.result(),
                    self.starstar_arg.py_result(),
                    code.error_goto_if_null(self.result(), self.pos)))
5824
            code.put_gotref(self.py_result())
5825
        else:
5826 5827 5828 5829 5830 5831
            code.putln("%s = %s;" % (
                self.result(),
                self.starstar_arg.py_result()))
            code.put_incref(self.result(), py_object_type)
        if self.starstar_arg.type is not Builtin.dict_type:
            code.putln('} else {')
5832
            code.putln(
5833 5834
                "%s = PyObject_CallFunctionObjArgs("
                "(PyObject*)&PyDict_Type, %s, NULL); %s" % (
5835
                    self.result(),
5836
                    self.starstar_arg.py_result(),
5837
                    code.error_goto_if_null(self.result(), self.pos)))
5838
            code.put_gotref(self.py_result())
5839 5840 5841 5842 5843 5844 5845
            code.putln('}')
        self.starstar_arg.generate_disposal_code(code)
        self.starstar_arg.free_temps(code)

        if not self.keyword_args:
            return

5846 5847
        code.globalstate.use_utility_code(
            UtilityCode.load_cached("RaiseDoubleKeywords", "FunctionArguments.c"))
5848 5849 5850 5851 5852 5853 5854 5855 5856 5857 5858 5859 5860 5861 5862 5863 5864 5865 5866 5867 5868 5869
        for item in self.keyword_args:
            item.generate_evaluation_code(code)
            code.putln("if (unlikely(PyDict_GetItem(%s, %s))) {" % (
                    self.result(),
                    item.key.py_result()))
            # FIXME: find out function name at runtime!
            code.putln('__Pyx_RaiseDoubleKeywordsError("function", %s); %s' % (
                item.key.py_result(),
                code.error_goto(self.pos)))
            code.putln("}")
            code.put_error_if_neg(self.pos,
                "PyDict_SetItem(%s, %s, %s)" % (
                    self.result(),
                    item.key.py_result(),
                    item.value.py_result()))
            item.generate_disposal_code(code)
            item.free_temps(code)

    def annotate(self, code):
        self.starstar_arg.annotate(code)
        for item in self.keyword_args:
            item.annotate(code)
5870 5871 5872 5873 5874 5875 5876 5877 5878 5879 5880 5881 5882 5883 5884 5885 5886 5887 5888 5889 5890 5891 5892 5893 5894 5895 5896 5897 5898 5899 5900 5901 5902 5903 5904 5905 5906 5907 5908 5909 5910 5911 5912 5913 5914 5915 5916 5917 5918 5919 5920 5921 5922 5923 5924 5925 5926 5927 5928 5929 5930 5931 5932 5933 5934 5935 5936 5937

class PyClassMetaclassNode(ExprNode):
    # Helper class holds Python3 metaclass object
    #
    #  bases        ExprNode           Base class tuple (not owned by this node)
    #  mkw          ExprNode           Class keyword arguments (not owned by this node)

    subexprs = []

    def analyse_types(self, env):
        self.type = py_object_type
        self.is_temp = True

    def may_be_none(self):
        return True

    def generate_result_code(self, code):
        code.putln(
            "%s = __Pyx_Py3MetaclassGet(%s, %s); %s" % (
                self.result(),
                self.bases.result(),
                self.mkw.result(),
                code.error_goto_if_null(self.result(), self.pos)))
        code.put_gotref(self.py_result())

class PyClassNamespaceNode(ExprNode, ModuleNameMixin):
    # Helper class holds Python3 namespace object
    #
    # All this are not owned by this node
    #  metaclass    ExprNode           Metaclass object
    #  bases        ExprNode           Base class tuple
    #  mkw          ExprNode           Class keyword arguments
    #  doc          ExprNode or None   Doc string (owned)

    subexprs = ['doc']

    def analyse_types(self, env):
        self.bases.analyse_types(env)
        if self.doc:
            self.doc.analyse_types(env)
            self.doc = self.doc.coerce_to_pyobject(env)
        self.type = py_object_type
        self.is_temp = 1
        #TODO(craig,haoyu) This should be moved to a better place
        self.set_mod_name(env)

    def may_be_none(self):
        return True

    def generate_result_code(self, code):
        cname = code.intern_identifier(self.name)
        py_mod_name = self.get_py_mod_name(code)
        if self.doc:
            doc_code = self.doc.result()
        else:
            doc_code = '(PyObject *) NULL'
        code.putln(
            "%s = __Pyx_Py3MetaclassPrepare(%s, %s, %s, %s, %s, %s); %s" % (
                self.result(),
                self.metaclass.result(),
                self.bases.result(),
                cname,
                self.mkw.result(),
                py_mod_name,
                doc_code,
                code.error_goto_if_null(self.result(), self.pos)))
        code.put_gotref(self.py_result())

5938 5939 5940 5941 5942 5943 5944 5945 5946 5947 5948 5949 5950 5951 5952 5953 5954 5955 5956 5957 5958 5959 5960 5961 5962 5963 5964 5965 5966 5967 5968 5969 5970 5971 5972 5973 5974 5975 5976 5977 5978 5979 5980 5981

class ClassCellInjectorNode(ExprNode):
    # Initialize CyFunction.func_classobj
    is_temp = True
    type = py_object_type
    subexprs = []
    is_active = False

    def analyse_expressions(self, env):
        if self.is_active:
            env.use_utility_code(cyfunction_class_cell_utility_code)

    def generate_evaluation_code(self, code):
        if self.is_active:
            self.allocate_temp_result(code)
            code.putln(
                '%s = PyList_New(0); %s' % (
                    self.result(),
                    code.error_goto_if_null(self.result(), self.pos)))
            code.put_gotref(self.result())

    def generate_injection_code(self, code, classobj_cname):
        if self.is_active:
            code.putln('__Pyx_CyFunction_InitClassCell(%s, %s);' % (
                self.result(), classobj_cname))


class ClassCellNode(ExprNode):
    # Class Cell for noargs super()
    subexprs = []
    is_temp = True
    is_generator = False
    type = py_object_type

    def analyse_types(self, env):
        pass

    def generate_result_code(self, code):
        if not self.is_generator:
            code.putln('%s = __Pyx_CyFunction_GetClassObj(%s);' % (
                self.result(),
                Naming.self_cname))
        else:
            code.putln('%s =  %s->classobj;' % (
5982
                self.result(), Naming.generator_cname))
5983 5984 5985 5986 5987 5988 5989 5990
        code.putln(
            'if (!%s) { PyErr_SetString(PyExc_SystemError, '
            '"super(): empty __class__ cell"); %s }' % (
                self.result(),
                code.error_goto(self.pos)));
        code.put_incref(self.result(), py_object_type)


Robert Bradshaw's avatar
Robert Bradshaw committed
5991 5992 5993 5994 5995 5996 5997
class BoundMethodNode(ExprNode):
    #  Helper class used in the implementation of Python
    #  class definitions. Constructs an bound method
    #  object from a class and a function.
    #
    #  function      ExprNode   Function object
    #  self_object   ExprNode   self object
5998

Robert Bradshaw's avatar
Robert Bradshaw committed
5999
    subexprs = ['function']
6000

Robert Bradshaw's avatar
Robert Bradshaw committed
6001 6002 6003 6004 6005 6006 6007 6008 6009 6010 6011 6012 6013 6014 6015 6016
    def analyse_types(self, env):
        self.function.analyse_types(env)
        self.type = py_object_type
        self.is_temp = 1

    gil_message = "Constructing an bound method"

    def generate_result_code(self, code):
        code.putln(
            "%s = PyMethod_New(%s, %s, (PyObject*)%s->ob_type); %s" % (
                self.result(),
                self.function.py_result(),
                self.self_object.py_result(),
                self.self_object.py_result(),
                code.error_goto_if_null(self.result(), self.pos)))
        code.put_gotref(self.py_result())
William Stein's avatar
William Stein committed
6017

6018
class UnboundMethodNode(ExprNode):
William Stein's avatar
William Stein committed
6019 6020 6021 6022 6023
    #  Helper class used in the implementation of Python
    #  class definitions. Constructs an unbound method
    #  object from a class and a function.
    #
    #  function      ExprNode   Function object
6024

6025 6026
    type = py_object_type
    is_temp = 1
6027

William Stein's avatar
William Stein committed
6028
    subexprs = ['function']
6029

William Stein's avatar
William Stein committed
6030 6031
    def analyse_types(self, env):
        self.function.analyse_types(env)
6032

6033 6034 6035
    def may_be_none(self):
        return False

6036 6037
    gil_message = "Constructing an unbound method"

William Stein's avatar
William Stein committed
6038
    def generate_result_code(self, code):
6039
        class_cname = code.pyclass_stack[-1].classobj.result()
William Stein's avatar
William Stein committed
6040
        code.putln(
Robert Bradshaw's avatar
Robert Bradshaw committed
6041
            "%s = PyMethod_New(%s, 0, %s); %s" % (
6042
                self.result(),
William Stein's avatar
William Stein committed
6043
                self.function.py_result(),
6044
                class_cname,
6045
                code.error_goto_if_null(self.result(), self.pos)))
6046
        code.put_gotref(self.py_result())
William Stein's avatar
William Stein committed
6047

Robert Bradshaw's avatar
Robert Bradshaw committed
6048

6049
class PyCFunctionNode(ExprNode, ModuleNameMixin):
William Stein's avatar
William Stein committed
6050 6051 6052 6053
    #  Helper class used in the implementation of Python
    #  class definitions. Constructs a PyCFunction object
    #  from a PyMethodDef struct.
    #
6054
    #  pymethdef_cname   string             PyMethodDef structure
Robert Bradshaw's avatar
Robert Bradshaw committed
6055
    #  self_object       ExprNode or None
Robert Bradshaw's avatar
Robert Bradshaw committed
6056
    #  binding           bool
6057
    #  def_node          DefNode            the Python function node
6058
    #  module_name       EncodedString      Name of defining module
6059 6060 6061
    #  code_object       CodeObjectNode     the PyCodeObject creator node

    subexprs = ['code_object']
Stefan Behnel's avatar
Stefan Behnel committed
6062

Robert Bradshaw's avatar
Robert Bradshaw committed
6063
    self_object = None
6064
    code_object = None
Robert Bradshaw's avatar
Robert Bradshaw committed
6065
    binding = False
6066
    def_node = None
6067 6068 6069
    defaults = None
    defaults_struct = None
    defaults_pyobjects = 0
6070

6071 6072
    type = py_object_type
    is_temp = 1
6073

6074 6075
    specialized_cpdefs = None

William Stein's avatar
William Stein committed
6076
    def analyse_types(self, env):
6077 6078 6079
        if self.specialized_cpdefs:
            self.binding = True

Robert Bradshaw's avatar
Robert Bradshaw committed
6080
        if self.binding:
6081 6082 6083 6084
            if self.specialized_cpdefs:
                env.use_utility_code(fused_function_utility_code)
            else:
                env.use_utility_code(binding_cfunc_utility_code)
6085
                self.analyse_default_args(env)
6086

6087 6088 6089
        #TODO(craig,haoyu) This should be moved to a better place
        self.set_mod_name(env)

6090 6091 6092 6093 6094 6095 6096 6097 6098 6099 6100 6101 6102 6103 6104 6105 6106 6107 6108 6109 6110 6111 6112 6113 6114 6115 6116 6117 6118 6119 6120 6121 6122 6123 6124 6125 6126
    def analyse_default_args(self, env):
        """
        Handle non-literal function's default arguments.
        """
        nonliteral_objects = []
        nonliteral_other = []
        for arg in self.def_node.args:
            if arg.default and not arg.default.is_literal:
                arg.is_dynamic = True
                if arg.type.is_pyobject:
                    nonliteral_objects.append(arg)
                else:
                    nonliteral_other.append(arg)
        if nonliteral_objects or nonliteral_objects:
            module_scope = env.global_scope()
            cname = module_scope.next_id(Naming.defaults_struct_prefix)
            scope = Symtab.StructOrUnionScope(cname)
            self.defaults = []
            for arg in nonliteral_objects:
                entry = scope.declare_var(arg.name, arg.type, None,
                                          Naming.arg_prefix + arg.name,
                                          allow_pyobject=True)
                self.defaults.append((arg, entry))
            for arg in nonliteral_other:
                entry = scope.declare_var(arg.name, arg.type, None,
                                          Naming.arg_prefix + arg.name,
                                          allow_pyobject=False)
                self.defaults.append((arg, entry))
            entry = module_scope.declare_struct_or_union(
                None, 'struct', scope, 1, None, cname=cname)
            self.defaults_struct = scope
            self.defaults_pyobjects = len(nonliteral_objects)
            for arg, entry in self.defaults:
                arg.default_value = '%s->%s' % (
                    Naming.dynamic_args_cname, entry.cname)
            self.def_node.defaults_struct = self.defaults_struct.name

6127 6128
    def may_be_none(self):
        return False
6129

6130 6131
    gil_message = "Constructing Python function"

Stefan Behnel's avatar
Stefan Behnel committed
6132
    def self_result_code(self):
Robert Bradshaw's avatar
Robert Bradshaw committed
6133 6134 6135 6136
        if self.self_object is None:
            self_result = "NULL"
        else:
            self_result = self.self_object.py_result()
Stefan Behnel's avatar
Stefan Behnel committed
6137 6138 6139
        return self_result

    def generate_result_code(self, code):
Robert Bradshaw's avatar
Robert Bradshaw committed
6140
        if self.binding:
6141 6142 6143
            self.generate_cyfunction_code(code)
        else:
            self.generate_pycfunction_code(code)
6144

6145 6146 6147 6148 6149 6150 6151 6152 6153 6154 6155 6156 6157 6158 6159
    def generate_pycfunction_code(self, code):
        py_mod_name = self.get_py_mod_name(code)
        code.putln(
            '%s = PyCFunction_NewEx(&%s, %s, %s); %s' % (
                self.result(),
                self.pymethdef_cname,
                self.self_result_code(),
                py_mod_name,
                code.error_goto_if_null(self.result(), self.pos)))

        code.put_gotref(self.py_result())

    def generate_cyfunction_code(self, code):
        if self.specialized_cpdefs:
            constructor = "__pyx_FusedFunction_NewEx"
6160
            def_node = self.specialized_cpdefs[0]
Robert Bradshaw's avatar
Robert Bradshaw committed
6161
        else:
6162
            constructor = "__Pyx_CyFunction_NewEx"
6163
            def_node = self.def_node
6164 6165 6166 6167 6168 6169 6170

        if self.code_object:
            code_object_result = self.code_object.py_result()
        else:
            code_object_result = 'NULL'

        flags = []
6171
        if def_node.is_staticmethod:
6172
            flags.append('__Pyx_CYFUNCTION_STATICMETHOD')
6173
        elif def_node.is_classmethod:
6174
            flags.append('__Pyx_CYFUNCTION_CLASSMETHOD')
6175 6176 6177 6178

        if def_node.local_scope.parent_scope.is_c_class_scope:
            flags.append('__Pyx_CYFUNCTION_CCLASS')

6179 6180 6181 6182
        if flags:
            flags = ' | '.join(flags)
        else:
            flags = '0'
6183

6184
        py_mod_name = self.get_py_mod_name(code)
William Stein's avatar
William Stein committed
6185
        code.putln(
6186
            '%s = %s(&%s, %s, %s, %s, %s); %s' % (
6187
                self.result(),
Robert Bradshaw's avatar
Robert Bradshaw committed
6188
                constructor,
William Stein's avatar
William Stein committed
6189
                self.pymethdef_cname,
6190
                flags,
Stefan Behnel's avatar
Stefan Behnel committed
6191
                self.self_result_code(),
6192
                py_mod_name,
6193
                code_object_result,
6194
                code.error_goto_if_null(self.result(), self.pos)))
6195

6196
        code.put_gotref(self.py_result())
William Stein's avatar
William Stein committed
6197

6198
        if def_node.requires_classobj:
6199 6200 6201 6202 6203 6204 6205 6206 6207
            assert code.pyclass_stack, "pyclass_stack is empty"
            class_node = code.pyclass_stack[-1]
            code.put_incref(self.py_result(), py_object_type)
            code.putln(
                'PyList_Append(%s, %s);' % (
                    class_node.class_cell.result(),
                    self.result()))
            code.put_giveref(self.py_result())

6208 6209 6210 6211 6212 6213 6214 6215 6216 6217 6218
        if self.defaults:
            code.putln(
                'if (!__Pyx_CyFunction_InitDefaults(%s, sizeof(%s), %d)) %s' % (
                    self.result(), self.defaults_struct.name,
                    self.defaults_pyobjects, code.error_goto(self.pos)))
            defaults = '__Pyx_CyFunction_Defaults(%s, %s)' % (
                self.defaults_struct.name, self.result())
            for arg, entry in self.defaults:
                arg.generate_assignment_code(code, target='%s->%s' % (
                    defaults, entry.cname))

6219
        if self.specialized_cpdefs:
6220
            self.generate_fused_cpdef(code, code_object_result, flags)
6221

6222
    def generate_fused_cpdef(self, code, code_object_result, flags):
6223 6224 6225 6226 6227 6228 6229 6230 6231 6232 6233 6234 6235 6236 6237 6238 6239 6240 6241 6242
        """
        Generate binding function objects for all specialized cpdefs, and the
        original fused one. The fused function gets a dict __signatures__
        mapping the specialized signature to the specialized binding function.
        In Python space, the specialized versions can be obtained by indexing
        the fused function.

        For unsubscripted dispatch, we also need to remember the positions of
        the arguments with fused types.
        """
        def goto_err(string):
            string = "(%s)" % string
            code.putln(code.error_goto_if_null(string % fmt_dict, self.pos))

        # Set up an interpolation dict
        fmt_dict = dict(
            vars(Naming),
            result=self.result(),
            py_mod_name=self.get_py_mod_name(code),
            self=self.self_result_code(),
6243
            code=code_object_result,
6244
            flags=flags,
6245 6246 6247 6248 6249 6250 6251
            func=code.funcstate.allocate_temp(py_object_type,
                                              manage_ref=True),
            signature=code.funcstate.allocate_temp(py_object_type,
                                                   manage_ref=True),
        )

        fmt_dict['sigdict'] = \
6252
            "((__pyx_FusedFunctionObject *) %(result)s)->__signatures__" % fmt_dict
6253

6254
        # Initialize __signatures__
6255 6256 6257 6258 6259 6260 6261 6262 6263 6264
        goto_err("%(sigdict)s = PyDict_New()")

        # Now put all specialized cpdefs in __signatures__
        for cpdef in self.specialized_cpdefs:
            fmt_dict['signature_string'] = cpdef.specialized_signature_string
            fmt_dict['pymethdef_cname'] = cpdef.entry.pymethdef_cname

            goto_err('%(signature)s = PyUnicode_FromString('
                                    '"%(signature_string)s")')

6265
            goto_err("%(func)s = __pyx_FusedFunction_NewEx("
6266
                            "&%(pymethdef_cname)s, %(flags)s, %(self)s, %(py_mod_name)s, %(code)s)")
6267 6268 6269 6270 6271 6272 6273 6274 6275 6276 6277

            s = "PyDict_SetItem(%(sigdict)s, %(signature)s, %(func)s)"
            code.put_error_if_neg(self.pos, s % fmt_dict)

            code.putln("Py_DECREF(%(signature)s); %(signature)s = NULL;" % fmt_dict)
            code.putln("Py_DECREF(%(func)s); %(func)s = NULL;" % fmt_dict)

        code.funcstate.release_temp(fmt_dict['func'])
        code.funcstate.release_temp(fmt_dict['signature'])


Stefan Behnel's avatar
Stefan Behnel committed
6278 6279 6280
class InnerFunctionNode(PyCFunctionNode):
    # Special PyCFunctionNode that depends on a closure class
    #
Vitja Makarov's avatar
Vitja Makarov committed
6281

Robert Bradshaw's avatar
Robert Bradshaw committed
6282
    binding = True
Vitja Makarov's avatar
Vitja Makarov committed
6283 6284
    needs_self_code = True

Stefan Behnel's avatar
Stefan Behnel committed
6285
    def self_result_code(self):
Vitja Makarov's avatar
Vitja Makarov committed
6286 6287 6288
        if self.needs_self_code:
            return "((PyObject*)%s)" % (Naming.cur_scope_cname)
        return "NULL"
Stefan Behnel's avatar
Stefan Behnel committed
6289

6290 6291 6292 6293
class CodeObjectNode(ExprNode):
    # Create a PyCodeObject for a CyFunction instance.
    #
    # def_node   DefNode    the Python function node
6294
    # varnames   TupleNode  a tuple with all local variable names
6295 6296 6297 6298 6299 6300 6301 6302 6303 6304 6305

    subexprs = ['varnames']
    is_temp = False

    def __init__(self, def_node):
        ExprNode.__init__(self, def_node.pos, def_node=def_node)
        args = list(def_node.args)
        if def_node.star_arg:
            args.append(def_node.star_arg)
        if def_node.starstar_arg:
            args.append(def_node.starstar_arg)
6306
        local_vars = [ arg for arg in def_node.local_scope.var_entries
6307
                       if arg.name ]
6308 6309
        self.varnames = TupleNode(
            def_node.pos,
6310
            args = [ IdentifierStringNode(arg.pos, value=arg.name)
6311
                     for arg in args + local_vars ],
6312 6313 6314 6315 6316 6317 6318 6319 6320 6321 6322 6323 6324 6325 6326 6327 6328 6329 6330 6331 6332 6333 6334 6335 6336
            is_temp = 0,
            is_literal = 1)

    def calculate_result_code(self):
        return self.result_code

    def generate_result_code(self, code):
        self.result_code = code.get_py_const(py_object_type, 'codeobj_', cleanup_level=2)

        code = code.get_cached_constants_writer()
        code.mark_pos(self.pos)
        func = self.def_node
        func_name = code.get_py_string_const(
            func.name, identifier=True, is_str=False, unicode_value=func.name)
        # FIXME: better way to get the module file path at module init time? Encoding to use?
        file_path = StringEncoding.BytesLiteral(func.pos[0].get_filenametable_entry().encode('utf8'))
        file_path_const = code.get_py_string_const(file_path, identifier=False, is_str=True)

        code.putln("%s = (PyObject*)__Pyx_PyCode_New(%d, %d, %d, 0, 0, %s, %s, %s, %s, %s, %s, %s, %s, %d, %s); %s" % (
            self.result_code,
            len(func.args),            # argcount
            func.num_kwonly_args,      # kwonlyargcount (Py3 only)
            len(self.varnames.args),   # nlocals
            Naming.empty_bytes,        # code
            Naming.empty_tuple,        # consts
6337 6338
            Naming.empty_tuple,        # names (FIXME)
            self.varnames.result(),    # varnames
6339 6340 6341 6342 6343 6344 6345 6346 6347 6348
            Naming.empty_tuple,        # freevars (FIXME)
            Naming.empty_tuple,        # cellvars (FIXME)
            file_path_const,           # filename
            func_name,                 # name
            self.pos[1],               # firstlineno
            Naming.empty_bytes,        # lnotab
            code.error_goto_if_null(self.result_code, self.pos),
            ))


Stefan Behnel's avatar
Stefan Behnel committed
6349 6350 6351 6352 6353 6354 6355 6356 6357 6358 6359 6360 6361 6362 6363
class LambdaNode(InnerFunctionNode):
    # Lambda expression node (only used as a function reference)
    #
    # args          [CArgDeclNode]         formal arguments
    # star_arg      PyArgDeclNode or None  * argument
    # starstar_arg  PyArgDeclNode or None  ** argument
    # lambda_name   string                 a module-globally unique lambda name
    # result_expr   ExprNode
    # def_node      DefNode                the underlying function 'def' node

    child_attrs = ['def_node']

    name = StringEncoding.EncodedString('<lambda>')

    def analyse_declarations(self, env):
6364 6365
        self.def_node.no_assignment_synthesis = True
        self.def_node.pymethdef_required = True
Stefan Behnel's avatar
Stefan Behnel committed
6366
        self.def_node.analyse_declarations(env)
6367
        self.def_node.is_cyfunction = True
Stefan Behnel's avatar
Stefan Behnel committed
6368 6369 6370
        self.pymethdef_cname = self.def_node.entry.pymethdef_cname
        env.add_lambda_def(self.def_node)

6371 6372 6373 6374 6375 6376 6377 6378
    def analyse_types(self, env):
        self.def_node.analyse_expressions(env)
        super(LambdaNode, self).analyse_types(env)

    def generate_result_code(self, code):
        self.def_node.generate_execution_code(code)
        super(LambdaNode, self).generate_result_code(code)

6379

6380 6381 6382 6383 6384 6385 6386 6387
class GeneratorExpressionNode(LambdaNode):
    # A generator expression, e.g.  (i for i in range(10))
    #
    # Result is a generator.
    #
    # loop      ForStatNode   the for-loop, containing a YieldExprNode
    # def_node  DefNode       the underlying generator 'def' node

6388
    name = StringEncoding.EncodedString('genexpr')
6389 6390 6391
    binding = False

    def analyse_declarations(self, env):
6392 6393 6394
        super(GeneratorExpressionNode, self).analyse_declarations(env)
        # No pymethdef required
        self.def_node.pymethdef_required = False
6395
        self.def_node.py_wrapper_required = False
6396
        self.def_node.is_cyfunction = False
6397 6398
        # Force genexpr signature
        self.def_node.entry.signature = TypeSlots.pyfunction_noargs
6399 6400 6401

    def generate_result_code(self, code):
        code.putln(
6402
            '%s = %s(%s); %s' % (
6403
                self.result(),
6404
                self.def_node.entry.pyfunc_cname,
6405 6406 6407 6408 6409
                self.self_result_code(),
                code.error_goto_if_null(self.result(), self.pos)))
        code.put_gotref(self.py_result())


6410 6411 6412 6413 6414
class YieldExprNode(ExprNode):
    # Yield expression node
    #
    # arg         ExprNode   the value to return from the generator
    # label_name  string     name of the C label used for this yield
6415
    # label_num   integer    yield label number
6416 6417 6418

    subexprs = ['arg']
    type = py_object_type
6419
    label_num = 0
6420 6421

    def analyse_types(self, env):
6422 6423
        if not self.label_num:
            error(self.pos, "'yield' not supported here")
6424 6425 6426 6427 6428 6429 6430 6431 6432 6433 6434 6435 6436 6437 6438 6439 6440 6441 6442 6443 6444
        self.is_temp = 1
        if self.arg is not None:
            self.arg.analyse_types(env)
            if not self.arg.type.is_pyobject:
                self.arg = self.arg.coerce_to_pyobject(env)

    def generate_evaluation_code(self, code):
        self.label_name = code.new_label('resume_from_yield')
        code.use_label(self.label_name)
        if self.arg:
            self.arg.generate_evaluation_code(code)
            self.arg.make_owned_reference(code)
            code.putln(
                "%s = %s;" % (
                    Naming.retval_cname,
                    self.arg.result_as(py_object_type)))
            self.arg.generate_post_assignment_code(code)
            #self.arg.generate_disposal_code(code)
            self.arg.free_temps(code)
        else:
            code.put_init_to_py_none(Naming.retval_cname, py_object_type)
6445
        saved = []
6446
        code.funcstate.closure_temps.reset()
6447
        for cname, type, manage_ref in code.funcstate.temps_in_use():
6448
            save_cname = code.funcstate.closure_temps.allocate_temp(type)
6449 6450 6451 6452
            saved.append((cname, save_cname, type))
            if type.is_pyobject:
                code.put_xgiveref(cname)
            code.putln('%s->%s = %s;' % (Naming.cur_scope_cname, save_cname, cname))
6453

6454
        code.put_xgiveref(Naming.retval_cname)
6455
        code.put_finish_refcount_context()
Stefan Behnel's avatar
Stefan Behnel committed
6456
        code.putln("/* return from generator, yielding value */")
6457 6458
        code.putln("%s->resume_label = %d;" % (
            Naming.generator_cname, self.label_num))
6459 6460
        code.putln("return %s;" % Naming.retval_cname);
        code.put_label(self.label_name)
6461 6462 6463 6464 6465 6466
        for cname, save_cname, type in saved:
            code.putln('%s = %s->%s;' % (cname, Naming.cur_scope_cname, save_cname))
            if type.is_pyobject:
                code.putln('%s->%s = 0;' % (Naming.cur_scope_cname, save_cname))
            if type.is_pyobject:
                code.put_xgotref(cname)
6467 6468 6469 6470 6471 6472 6473 6474
        if self.result_is_used:
            self.allocate_temp_result(code)
            code.putln('%s = %s; %s' %
                       (self.result(), Naming.sent_value_cname,
                        code.error_goto_if_null(self.result(), self.pos)))
            code.put_incref(self.result(), py_object_type)
        else:
            code.putln(code.error_goto_if_null(Naming.sent_value_cname, self.pos))
6475

Vitja Makarov's avatar
Vitja Makarov committed
6476 6477 6478 6479 6480 6481 6482 6483 6484 6485 6486 6487 6488 6489 6490 6491

class GlobalsExprNode(AtomicExprNode):
    type = dict_type
    is_temp = 1

    def analyse_types(self, env):
        env.use_utility_code(Builtin.globals_utility_code)

    gil_message = "Constructing globals dict"

    def generate_result_code(self, code):
        code.putln('%s = __Pyx_Globals(); %s' % (
            self.result(),
            code.error_goto_if_null(self.result(), self.pos)))
        code.put_gotref(self.result())

Vitja Makarov's avatar
Vitja Makarov committed
6492

6493
class FuncLocalsExprNode(DictNode):
Vitja Makarov's avatar
Vitja Makarov committed
6494 6495 6496 6497 6498 6499 6500 6501
    def __init__(self, pos, env):
        local_vars = [var.name for var in env.entries.values() if var.name]
        items = [DictItemNode(pos, key=IdentifierStringNode(pos, value=var),
                              value=NameNode(pos, name=var, allow_null=True))
                 for var in local_vars]
        DictNode.__init__(self, pos, key_value_pairs=items,
                          exclude_null_values=True)

6502 6503 6504 6505 6506 6507 6508 6509 6510 6511 6512 6513 6514 6515 6516 6517 6518 6519 6520 6521 6522 6523 6524 6525 6526

class PyClassLocalsExprNode(AtomicExprNode):
    def __init__(self, pos, pyclass_dict):
        AtomicExprNode.__init__(self, pos)
        self.pyclass_dict = pyclass_dict

    def analyse_types(self, env):
        self.type = self.pyclass_dict.type
        self.is_tmep = 0

    def result(self):
        return self.pyclass_dict.result()

    def generate_result_code(self, code):
        pass


def LocalsExprNode(pos, scope_node, env):
    if env.is_module_scope:
        return GlobalsExprNode(pos)
    if env.is_py_class_scope:
        return PyClassLocalsExprNode(pos, scope_node.dict)
    return FuncLocalsExprNode(pos, env)


William Stein's avatar
William Stein committed
6527 6528 6529 6530 6531 6532
#-------------------------------------------------------------------
#
#  Unary operator nodes
#
#-------------------------------------------------------------------

6533 6534 6535 6536 6537 6538 6539
compile_time_unary_operators = {
    'not': operator.not_,
    '~': operator.inv,
    '-': operator.neg,
    '+': operator.pos,
}

6540
class UnopNode(ExprNode):
William Stein's avatar
William Stein committed
6541 6542 6543 6544 6545 6546 6547 6548 6549 6550
    #  operator     string
    #  operand      ExprNode
    #
    #  Processing during analyse_expressions phase:
    #
    #    analyse_c_operation
    #      Called when the operand is not a pyobject.
    #      - Check operand type and coerce if needed.
    #      - Determine result type and result code fragment.
    #      - Allocate temporary for result if needed.
6551

William Stein's avatar
William Stein committed
6552
    subexprs = ['operand']
Robert Bradshaw's avatar
Robert Bradshaw committed
6553
    infix = True
6554 6555 6556 6557

    def calculate_constant_result(self):
        func = compile_time_unary_operators[self.operator]
        self.constant_result = func(self.operand.constant_result)
6558

6559 6560 6561 6562 6563 6564 6565 6566 6567 6568 6569
    def compile_time_value(self, denv):
        func = compile_time_unary_operators.get(self.operator)
        if not func:
            error(self.pos,
                "Unary '%s' not supported in compile-time expression"
                    % self.operator)
        operand = self.operand.compile_time_value(denv)
        try:
            return func(operand)
        except Exception, e:
            self.compile_time_value_error(e)
6570

6571
    def infer_type(self, env):
6572 6573 6574 6575 6576
        operand_type = self.operand.infer_type(env)
        if operand_type.is_pyobject:
            return py_object_type
        else:
            return operand_type
6577

William Stein's avatar
William Stein committed
6578 6579 6580 6581 6582 6583
    def analyse_types(self, env):
        self.operand.analyse_types(env)
        if self.is_py_operation():
            self.coerce_operand_to_pyobject(env)
            self.type = py_object_type
            self.is_temp = 1
6584 6585
        elif self.is_cpp_operation():
            self.analyse_cpp_operation(env)
William Stein's avatar
William Stein committed
6586 6587
        else:
            self.analyse_c_operation(env)
6588

William Stein's avatar
William Stein committed
6589
    def check_const(self):
6590
        return self.operand.check_const()
6591

William Stein's avatar
William Stein committed
6592 6593
    def is_py_operation(self):
        return self.operand.type.is_pyobject
6594

6595
    def nogil_check(self, env):
6596
        if self.is_py_operation():
6597
            self.gil_error()
6598

Danilo Freitas's avatar
Danilo Freitas committed
6599
    def is_cpp_operation(self):
Robert Bradshaw's avatar
Robert Bradshaw committed
6600
        type = self.operand.type
Robert Bradshaw's avatar
Robert Bradshaw committed
6601
        return type.is_cpp_class
6602

William Stein's avatar
William Stein committed
6603 6604
    def coerce_operand_to_pyobject(self, env):
        self.operand = self.operand.coerce_to_pyobject(env)
6605

William Stein's avatar
William Stein committed
6606 6607 6608
    def generate_result_code(self, code):
        if self.operand.type.is_pyobject:
            self.generate_py_operation_code(code)
6609

William Stein's avatar
William Stein committed
6610 6611 6612
    def generate_py_operation_code(self, code):
        function = self.py_operation_function()
        code.putln(
Robert Bradshaw's avatar
Robert Bradshaw committed
6613
            "%s = %s(%s); %s" % (
6614 6615
                self.result(),
                function,
William Stein's avatar
William Stein committed
6616
                self.operand.py_result(),
6617
                code.error_goto_if_null(self.result(), self.pos)))
6618
        code.put_gotref(self.py_result())
6619

William Stein's avatar
William Stein committed
6620 6621 6622 6623 6624 6625
    def type_error(self):
        if not self.operand.type.is_error:
            error(self.pos, "Invalid operand type for '%s' (%s)" %
                (self.operator, self.operand.type))
        self.type = PyrexTypes.error_type

Danilo Freitas's avatar
Danilo Freitas committed
6626
    def analyse_cpp_operation(self, env):
6627
        type = self.operand.type
Robert Bradshaw's avatar
Robert Bradshaw committed
6628
        if type.is_ptr:
Danilo Freitas's avatar
Danilo Freitas committed
6629
            type = type.base_type
Robert Bradshaw's avatar
Robert Bradshaw committed
6630
        function = type.scope.lookup("operator%s" % self.operator)
Danilo Freitas's avatar
Danilo Freitas committed
6631 6632
        if not function:
            error(self.pos, "'%s' operator not defined for %s"
6633
                % (self.operator, type))
Danilo Freitas's avatar
Danilo Freitas committed
6634 6635
            self.type_error()
            return
6636 6637 6638 6639
        func_type = function.type
        if func_type.is_ptr:
            func_type = func_type.base_type
        self.type = func_type.return_type
Danilo Freitas's avatar
Danilo Freitas committed
6640

William Stein's avatar
William Stein committed
6641

6642
class NotNode(ExprNode):
William Stein's avatar
William Stein committed
6643 6644 6645
    #  'not' operator
    #
    #  operand   ExprNode
6646

6647
    type = PyrexTypes.c_bint_type
6648

6649
    subexprs = ['operand']
6650

6651 6652 6653
    def calculate_constant_result(self):
        self.constant_result = not self.operand.constant_result

6654 6655 6656 6657 6658 6659 6660
    def compile_time_value(self, denv):
        operand = self.operand.compile_time_value(denv)
        try:
            return not operand
        except Exception, e:
            self.compile_time_value_error(e)

6661 6662
    def infer_type(self, env):
        return PyrexTypes.c_bint_type
6663

William Stein's avatar
William Stein committed
6664 6665 6666
    def analyse_types(self, env):
        self.operand.analyse_types(env)
        self.operand = self.operand.coerce_to_boolean(env)
6667

William Stein's avatar
William Stein committed
6668
    def calculate_result_code(self):
6669
        return "(!%s)" % self.operand.result()
6670

William Stein's avatar
William Stein committed
6671 6672 6673 6674 6675 6676
    def generate_result_code(self, code):
        pass


class UnaryPlusNode(UnopNode):
    #  unary '+' operator
6677

William Stein's avatar
William Stein committed
6678
    operator = '+'
6679

William Stein's avatar
William Stein committed
6680
    def analyse_c_operation(self, env):
Lisandro Dalcin's avatar
Lisandro Dalcin committed
6681
        self.type = PyrexTypes.widest_numeric_type(
Robert Bradshaw's avatar
Robert Bradshaw committed
6682
            self.operand.type, PyrexTypes.c_int_type)
6683

William Stein's avatar
William Stein committed
6684 6685
    def py_operation_function(self):
        return "PyNumber_Positive"
6686

William Stein's avatar
William Stein committed
6687
    def calculate_result_code(self):
6688 6689 6690 6691
        if self.is_cpp_operation():
            return "(+%s)" % self.operand.result()
        else:
            return self.operand.result()
William Stein's avatar
William Stein committed
6692 6693 6694 6695


class UnaryMinusNode(UnopNode):
    #  unary '-' operator
6696

William Stein's avatar
William Stein committed
6697
    operator = '-'
6698

William Stein's avatar
William Stein committed
6699 6700
    def analyse_c_operation(self, env):
        if self.operand.type.is_numeric:
6701 6702
            self.type = PyrexTypes.widest_numeric_type(
                self.operand.type, PyrexTypes.c_int_type)
6703 6704
        elif self.operand.type.is_enum:
            self.type = PyrexTypes.c_int_type
William Stein's avatar
William Stein committed
6705 6706
        else:
            self.type_error()
Robert Bradshaw's avatar
Robert Bradshaw committed
6707
        if self.type.is_complex:
6708
            self.infix = False
6709

William Stein's avatar
William Stein committed
6710 6711
    def py_operation_function(self):
        return "PyNumber_Negative"
6712

William Stein's avatar
William Stein committed
6713
    def calculate_result_code(self):
Robert Bradshaw's avatar
Robert Bradshaw committed
6714 6715 6716 6717
        if self.infix:
            return "(-%s)" % self.operand.result()
        else:
            return "%s(%s)" % (self.operand.type.unary_op('-'), self.operand.result())
William Stein's avatar
William Stein committed
6718

6719 6720 6721 6722 6723
    def get_constant_c_result_code(self):
        value = self.operand.get_constant_c_result_code()
        if value:
            return "(-%s)" % (value)

William Stein's avatar
William Stein committed
6724 6725 6726 6727 6728
class TildeNode(UnopNode):
    #  unary '~' operator

    def analyse_c_operation(self, env):
        if self.operand.type.is_int:
6729 6730
            self.type = PyrexTypes.widest_numeric_type(
                self.operand.type, PyrexTypes.c_int_type)
6731 6732
        elif self.operand.type.is_enum:
            self.type = PyrexTypes.c_int_type
William Stein's avatar
William Stein committed
6733 6734 6735 6736 6737
        else:
            self.type_error()

    def py_operation_function(self):
        return "PyNumber_Invert"
6738

William Stein's avatar
William Stein committed
6739
    def calculate_result_code(self):
6740
        return "(~%s)" % self.operand.result()
William Stein's avatar
William Stein committed
6741 6742


6743 6744
class CUnopNode(UnopNode):

Robert Bradshaw's avatar
Robert Bradshaw committed
6745 6746 6747
    def is_py_operation(self):
        return False

6748 6749
class DereferenceNode(CUnopNode):
    #  unary * operator
6750 6751

    operator = '*'
6752

Robert Bradshaw's avatar
Robert Bradshaw committed
6753 6754 6755 6756 6757 6758 6759 6760
    def analyse_c_operation(self, env):
        if self.operand.type.is_ptr:
            self.type = self.operand.type.base_type
        else:
            self.type_error()

    def calculate_result_code(self):
        return "(*%s)" % self.operand.result()
William Stein's avatar
William Stein committed
6761 6762


6763 6764
class DecrementIncrementNode(CUnopNode):
    #  unary ++/-- operator
6765

6766
    def analyse_c_operation(self, env):
6767 6768 6769 6770
        if self.operand.type.is_numeric:
            self.type = PyrexTypes.widest_numeric_type(
                self.operand.type, PyrexTypes.c_int_type)
        elif self.operand.type.is_ptr:
6771 6772 6773 6774 6775 6776 6777 6778 6779 6780 6781 6782 6783 6784
            self.type = self.operand.type
        else:
            self.type_error()

    def calculate_result_code(self):
        if self.is_prefix:
            return "(%s%s)" % (self.operator, self.operand.result())
        else:
            return "(%s%s)" % (self.operand.result(), self.operator)

def inc_dec_constructor(is_prefix, operator):
    return lambda pos, **kwds: DecrementIncrementNode(pos, is_prefix=is_prefix, operator=operator, **kwds)


6785
class AmpersandNode(ExprNode):
William Stein's avatar
William Stein committed
6786 6787 6788
    #  The C address-of operator.
    #
    #  operand  ExprNode
6789

William Stein's avatar
William Stein committed
6790
    subexprs = ['operand']
6791

6792 6793
    def infer_type(self, env):
        return PyrexTypes.c_ptr_type(self.operand.infer_type(env))
William Stein's avatar
William Stein committed
6794 6795 6796 6797

    def analyse_types(self, env):
        self.operand.analyse_types(env)
        argtype = self.operand.type
6798
        if not (argtype.is_cfunction or self.operand.is_addressable()):
William Stein's avatar
William Stein committed
6799 6800 6801 6802 6803 6804
            self.error("Taking address of non-lvalue")
            return
        if argtype.is_pyobject:
            self.error("Cannot take address of Python variable")
            return
        self.type = PyrexTypes.c_ptr_type(argtype)
6805

William Stein's avatar
William Stein committed
6806
    def check_const(self):
6807
        return self.operand.check_const_addr()
6808

William Stein's avatar
William Stein committed
6809 6810 6811 6812
    def error(self, mess):
        error(self.pos, mess)
        self.type = PyrexTypes.error_type
        self.result_code = "<error>"
6813

William Stein's avatar
William Stein committed
6814
    def calculate_result_code(self):
6815
        return "(&%s)" % self.operand.result()
William Stein's avatar
William Stein committed
6816 6817 6818

    def generate_result_code(self, code):
        pass
6819

William Stein's avatar
William Stein committed
6820 6821 6822 6823 6824 6825 6826 6827

unop_node_classes = {
    "+":  UnaryPlusNode,
    "-":  UnaryMinusNode,
    "~":  TildeNode,
}

def unop_node(pos, operator, operand):
6828
    # Construct unnop node of appropriate class for
William Stein's avatar
William Stein committed
6829
    # given operator.
6830
    if isinstance(operand, IntNode) and operator == '-':
6831
        return IntNode(pos = operand.pos, value = str(-Utils.str_to_number(operand.value)))
Robert Bradshaw's avatar
Robert Bradshaw committed
6832 6833
    elif isinstance(operand, UnopNode) and operand.operator == operator:
        warning(pos, "Python has no increment/decrement operator: %s%sx = %s(%sx) = x" % ((operator,)*4), 5)
6834 6835
    return unop_node_classes[operator](pos,
        operator = operator,
William Stein's avatar
William Stein committed
6836 6837 6838
        operand = operand)


6839
class TypecastNode(ExprNode):
William Stein's avatar
William Stein committed
6840 6841
    #  C type cast
    #
6842
    #  operand      ExprNode
William Stein's avatar
William Stein committed
6843 6844
    #  base_type    CBaseTypeNode
    #  declarator   CDeclaratorNode
6845 6846 6847
    #
    #  If used from a transform, one can if wanted specify the attribute
    #  "type" directly and leave base_type and declarator to None
6848

William Stein's avatar
William Stein committed
6849
    subexprs = ['operand']
6850
    base_type = declarator = type = None
6851

Robert Bradshaw's avatar
Robert Bradshaw committed
6852
    def type_dependencies(self, env):
6853
        return ()
6854

Robert Bradshaw's avatar
Robert Bradshaw committed
6855
    def infer_type(self, env):
6856 6857 6858 6859
        if self.type is None:
            base_type = self.base_type.analyse(env)
            _, self.type = self.declarator.analyse(base_type, env)
        return self.type
6860

William Stein's avatar
William Stein committed
6861
    def analyse_types(self, env):
6862 6863 6864
        if self.type is None:
            base_type = self.base_type.analyse(env)
            _, self.type = self.declarator.analyse(base_type, env)
6865 6866 6867 6868
        if self.type.is_cfunction:
            error(self.pos,
                "Cannot cast to a function type")
            self.type = PyrexTypes.error_type
William Stein's avatar
William Stein committed
6869 6870 6871
        self.operand.analyse_types(env)
        to_py = self.type.is_pyobject
        from_py = self.operand.type.is_pyobject
6872 6873
        if from_py and not to_py and self.operand.is_ephemeral() and not self.type.is_numeric:
            error(self.pos, "Casting temporary Python object to non-numeric non-Python type")
William Stein's avatar
William Stein committed
6874
        if to_py and not from_py:
6875 6876 6877 6878 6879 6880
            if self.type is bytes_type and self.operand.type.is_int:
                # FIXME: the type cast node isn't needed in this case
                # and can be dropped once analyse_types() can return a
                # different node
                self.operand = CoerceIntToBytesNode(self.operand, env)
            elif self.operand.type.can_coerce_to_pyobject(env):
Dag Sverre Seljebotn's avatar
Merge  
Dag Sverre Seljebotn committed
6881
                self.result_ctype = py_object_type
6882
                self.operand = self.operand.coerce_to_pyobject(env)
6883
            else:
6884 6885 6886 6887
                if self.operand.type.is_ptr:
                    if not (self.operand.type.base_type.is_void or self.operand.type.base_type.is_struct):
                        error(self.pos, "Python objects cannot be cast from pointers of primitive types")
                else:
6888
                    # Should this be an error?
6889
                    warning(self.pos, "No conversion from %s to %s, python object pointer used." % (self.operand.type, self.type))
6890
                self.operand = self.operand.coerce_to_simple(env)
6891
        elif from_py and not to_py:
6892
            if self.type.create_from_py_utility_code(env):
6893
                self.operand = self.operand.coerce_to(self.type, env)
6894 6895 6896
            elif self.type.is_ptr:
                if not (self.type.base_type.is_void or self.type.base_type.is_struct):
                    error(self.pos, "Python objects cannot be cast to pointers of primitive types")
6897 6898
            else:
                warning(self.pos, "No conversion from %s to %s, python object pointer used." % (self.type, self.operand.type))
6899 6900
        elif from_py and to_py:
            if self.typecheck and self.type.is_extension_type:
6901
                self.operand = PyTypeTestNode(self.operand, self.type, env, notnone=True)
6902 6903
        elif self.type.is_complex and self.operand.type.is_complex:
            self.operand = self.operand.coerce_to_simple(env)
6904 6905
        elif self.operand.type.is_fused:
            self.operand = self.operand.coerce_to(self.type, env)
6906
            #self.type = self.operand.type
6907

Stefan Behnel's avatar
Stefan Behnel committed
6908
    def is_simple(self):
6909 6910
        # either temp or a C cast => no side effects other than the operand's
        return self.operand.is_simple()
Stefan Behnel's avatar
Stefan Behnel committed
6911

6912 6913 6914
    def nonlocally_immutable(self):
        return self.operand.nonlocally_immutable()

6915 6916 6917
    def nogil_check(self, env):
        if self.type and self.type.is_pyobject and self.is_temp:
            self.gil_error()
6918

William Stein's avatar
William Stein committed
6919
    def check_const(self):
6920
        return self.operand.check_const()
Stefan Behnel's avatar
Stefan Behnel committed
6921 6922

    def calculate_constant_result(self):
6923 6924 6925
        # we usually do not know the result of a type cast at code
        # generation time
        pass
6926

William Stein's avatar
William Stein committed
6927
    def calculate_result_code(self):
6928 6929 6930 6931 6932 6933 6934 6935 6936 6937 6938
        if self.type.is_complex:
            operand_result = self.operand.result()
            if self.operand.type.is_complex:
                real_part = self.type.real_type.cast_code("__Pyx_CREAL(%s)" % operand_result)
                imag_part = self.type.real_type.cast_code("__Pyx_CIMAG(%s)" % operand_result)
            else:
                real_part = self.type.real_type.cast_code(operand_result)
                imag_part = "0"
            return "%s(%s, %s)" % (
                    self.type.from_parts,
                    real_part,
6939
                    imag_part)
6940 6941
        else:
            return self.type.cast_code(self.operand.result())
6942

6943 6944 6945 6946
    def get_constant_c_result_code(self):
        operand_result = self.operand.get_constant_c_result_code()
        if operand_result:
            return self.type.cast_code(operand_result)
6947

William Stein's avatar
William Stein committed
6948 6949 6950 6951 6952 6953 6954 6955 6956 6957 6958
    def result_as(self, type):
        if self.type.is_pyobject and not self.is_temp:
            #  Optimise away some unnecessary casting
            return self.operand.result_as(type)
        else:
            return ExprNode.result_as(self, type)

    def generate_result_code(self, code):
        if self.is_temp:
            code.putln(
                "%s = (PyObject *)%s;" % (
6959 6960 6961
                    self.result(),
                    self.operand.result()))
            code.put_incref(self.result(), self.ctype())
William Stein's avatar
William Stein committed
6962 6963


6964 6965 6966 6967
ERR_START = "Start may not be given"
ERR_NOT_STOP = "Stop must be provided to indicate shape"
ERR_STEPS = ("Strides may only be given to indicate contiguity. "
             "Consider slicing it after conversion")
6968
ERR_NOT_POINTER = "Can only create cython.array from pointer or array"
6969 6970 6971 6972 6973 6974 6975
ERR_BASE_TYPE = "Pointer base type does not match cython.array base type"

class CythonArrayNode(ExprNode):
    """
    Used when a pointer of base_type is cast to a memoryviewslice with that
    base type. i.e.

6976
        <int[:M:1, :N]> p
6977 6978 6979 6980 6981 6982 6983

    creates a fortran-contiguous cython.array.

    We leave the type set to object so coercions to object are more efficient
    and less work. Acquiring a memoryviewslice from this will be just as
    efficient. ExprNode.coerce_to() will do the additional typecheck on
    self.compile_time_type
6984 6985 6986 6987 6988 6989

    This also handles <int[:, :]> my_c_array


    operand             ExprNode                 the thing we're casting
    base_type_node      MemoryViewSliceTypeNode  the cast expression node
6990 6991 6992 6993 6994 6995 6996
    """

    subexprs = ['operand', 'shapes']

    shapes = None
    is_temp = True
    mode = "c"
6997
    array_dtype = None
6998 6999 7000 7001 7002 7003

    shape_type = PyrexTypes.c_py_ssize_t_type

    def analyse_types(self, env):
        import MemoryView

7004 7005 7006 7007 7008 7009 7010 7011 7012
        self.operand.analyse_types(env)
        if self.array_dtype:
            array_dtype = self.array_dtype
        else:
            array_dtype = self.base_type_node.base_type_node.analyse(env)
        axes = self.base_type_node.axes

        MemoryView.validate_memslice_dtype(self.pos, array_dtype)

7013 7014
        self.type = error_type
        self.shapes = []
7015
        ndim = len(axes)
7016

7017 7018 7019
        # Base type of the pointer or C array we are converting
        base_type = self.operand.type

7020 7021 7022
        if not self.operand.type.is_ptr and not self.operand.type.is_array:
            return error(self.operand.pos, ERR_NOT_POINTER)

7023 7024 7025 7026 7027 7028
        # Dimension sizes of C array
        array_dimension_sizes = []
        if base_type.is_array:
            while base_type.is_array:
                array_dimension_sizes.append(base_type.size)
                base_type = base_type.base_type
7029
        elif base_type.is_ptr:
7030
            base_type = base_type.base_type
7031 7032
        else:
            return error()
7033

7034
        if not base_type.same_as(array_dtype):
7035 7036 7037 7038 7039 7040 7041 7042 7043 7044
            return error(self.operand.pos, ERR_BASE_TYPE)
        elif self.operand.type.is_array and len(array_dimension_sizes) != ndim:
            return error(self.operand.pos,
                         "Expected %d dimensions, array has %d dimensions" %
                                            (ndim, len(array_dimension_sizes)))

        # Verify the start, stop and step values
        # In case of a C array, use the size of C array in each dimension to
        # get an automatic cast
        for axis_no, axis in enumerate(axes):
7045 7046 7047 7048
            if not axis.start.is_none:
                return error(axis.start.pos, ERR_START)

            if axis.stop.is_none:
7049 7050 7051 7052 7053 7054 7055
                if array_dimension_sizes:
                    dimsize = array_dimension_sizes[axis_no]
                    axis.stop = IntNode(self.pos, value=dimsize,
                                        constant_result=dimsize,
                                        type=PyrexTypes.c_int_type)
                else:
                    return error(axis.pos, ERR_NOT_STOP)
7056 7057 7058 7059 7060 7061 7062 7063

            axis.stop.analyse_types(env)
            shape = axis.stop.coerce_to(self.shape_type, env)
            if not shape.is_literal:
                shape.coerce_to_temp(env)

            self.shapes.append(shape)

7064
            first_or_last = axis_no in (0, ndim - 1)
7065 7066 7067 7068 7069 7070 7071 7072 7073 7074 7075 7076 7077 7078 7079 7080 7081 7082
            if not axis.step.is_none and first_or_last:
                axis.step.analyse_types(env)
                if (not axis.step.type.is_int and axis.step.is_literal and not
                        axis.step.type.is_error):
                    return error(axis.step.pos, "Expected an integer literal")

                if axis.step.compile_time_value(env) != 1:
                    return error(axis.step.pos, ERR_STEPS)

                if axis_no == 0:
                    self.mode = "fortran"

            elif axis.step and not first_or_last:
                return error(axis.step.pos, ERR_STEPS)

        if not self.operand.is_name:
            self.operand = self.operand.coerce_to_temp(env)

7083
        axes = [('direct', 'follow')] * len(axes)
7084 7085 7086 7087 7088 7089
        if self.mode == "fortran":
            axes[0] = ('direct', 'contig')
        else:
            axes[-1] = ('direct', 'contig')

        self.coercion_type = PyrexTypes.MemoryViewSliceType(array_dtype, axes)
7090
        self.type = self.get_cython_array_type(env)
7091
        MemoryView.use_cython_array_utility_code(env)
7092 7093 7094 7095 7096 7097 7098 7099
        env.use_utility_code(MemoryView.typeinfo_to_format_code)

    def allocate_temp_result(self, code):
        if self.temp_code:
            raise RuntimeError("temp allocated mulitple times")

        self.temp_code = code.funcstate.allocate_temp(self.type, True)

7100 7101 7102 7103 7104 7105
    def infer_type(self, env):
        return self.get_cython_array_type(env)

    def get_cython_array_type(self, env):
        return env.global_scope().context.cython_scope.lookup("array").type

7106 7107 7108 7109 7110 7111 7112 7113 7114 7115 7116 7117 7118
    def generate_result_code(self, code):
        import Buffer

        shapes = [self.shape_type.cast_code(shape.result())
                      for shape in self.shapes]
        dtype = self.coercion_type.dtype

        shapes_temp = code.funcstate.allocate_temp(py_object_type, True)
        format_temp = code.funcstate.allocate_temp(py_object_type, True)

        itemsize = "sizeof(%s)" % dtype.declaration_code("")
        type_info = Buffer.get_type_information_cname(code, dtype)

7119 7120 7121 7122 7123 7124
        if self.operand.type.is_ptr:
            code.putln("if (!%s) {" % self.operand.result())
            code.putln(    'PyErr_SetString(PyExc_ValueError,'
                                '"Cannot create cython.array from NULL pointer");')
            code.putln(code.error_goto(self.operand.pos))
            code.putln("}")
7125 7126 7127 7128 7129 7130 7131

        code.putln("%s = __pyx_format_from_typeinfo(&%s);" %
                                                (format_temp, type_info))
        code.putln('%s = Py_BuildValue("(%s)", %s);' % (shapes_temp,
                                                        "n" * len(shapes),
                                                        ", ".join(shapes)))

7132 7133 7134
        err = "!%s || !%s || !PyBytes_AsString(%s)" % (format_temp,
                                                       shapes_temp,
                                                       format_temp)
7135 7136 7137 7138 7139 7140 7141 7142
        code.putln(code.error_goto_if(err, self.pos))
        code.put_gotref(format_temp)
        code.put_gotref(shapes_temp)

        tup = (self.result(), shapes_temp, itemsize, format_temp,
               self.mode, self.operand.result())
        code.putln('%s = __pyx_array_new('
                            '%s, %s, PyBytes_AS_STRING(%s), '
7143
                            '(char *) "%s", (char *) %s);' % tup)
7144 7145 7146 7147 7148 7149 7150 7151 7152 7153
        code.putln(code.error_goto_if_null(self.result(), self.pos))
        code.put_gotref(self.result())

        def dispose(temp):
            code.put_decref_clear(temp, py_object_type)
            code.funcstate.release_temp(temp)

        dispose(shapes_temp)
        dispose(format_temp)

7154 7155 7156 7157 7158 7159 7160 7161 7162 7163 7164 7165 7166 7167 7168 7169 7170 7171 7172 7173 7174 7175 7176
    @classmethod
    def from_carray(cls, src_node, env):
        """
        Given a C array type, return a CythonArrayNode
        """
        pos = src_node.pos
        base_type = src_node.type

        none_node = NoneNode(pos)
        axes = []

        while base_type.is_array:
            axes.append(SliceNode(pos, start=none_node, stop=none_node,
                                       step=none_node))
            base_type = base_type.base_type
        axes[-1].step = IntNode(pos, value="1", is_c_literal=True)

        memslicenode = Nodes.MemoryViewSliceTypeNode(pos, axes=axes,
                                                     base_type_node=base_type)
        result = CythonArrayNode(pos, base_type_node=memslicenode,
                                 operand=src_node, array_dtype=base_type)
        result.analyse_types(env)
        return result
7177

7178
class SizeofNode(ExprNode):
William Stein's avatar
William Stein committed
7179
    #  Abstract base class for sizeof(x) expression nodes.
7180

7181
    type = PyrexTypes.c_size_t_type
William Stein's avatar
William Stein committed
7182 7183

    def check_const(self):
7184
        return True
William Stein's avatar
William Stein committed
7185 7186 7187 7188 7189 7190 7191 7192 7193 7194

    def generate_result_code(self, code):
        pass


class SizeofTypeNode(SizeofNode):
    #  C sizeof function applied to a type
    #
    #  base_type   CBaseTypeNode
    #  declarator  CDeclaratorNode
7195

William Stein's avatar
William Stein committed
7196
    subexprs = []
7197
    arg_type = None
7198

William Stein's avatar
William Stein committed
7199
    def analyse_types(self, env):
7200 7201
        # we may have incorrectly interpreted a dotted name as a type rather than an attribute
        # this could be better handled by more uniformly treating types as runtime-available objects
7202
        if 0 and self.base_type.module_path:
7203 7204 7205 7206 7207 7208 7209 7210 7211 7212 7213
            path = self.base_type.module_path
            obj = env.lookup(path[0])
            if obj.as_module is None:
                operand = NameNode(pos=self.pos, name=path[0])
                for attr in path[1:]:
                    operand = AttributeNode(pos=self.pos, obj=operand, attribute=attr)
                operand = AttributeNode(pos=self.pos, obj=operand, attribute=self.base_type.name)
                self.operand = operand
                self.__class__ = SizeofVarNode
                self.analyse_types(env)
                return
7214 7215 7216 7217
        if self.arg_type is None:
            base_type = self.base_type.analyse(env)
            _, arg_type = self.declarator.analyse(base_type, env)
            self.arg_type = arg_type
7218
        self.check_type()
7219

7220 7221
    def check_type(self):
        arg_type = self.arg_type
7222
        if arg_type.is_pyobject and not arg_type.is_extension_type:
William Stein's avatar
William Stein committed
7223 7224 7225 7226 7227
            error(self.pos, "Cannot take sizeof Python object")
        elif arg_type.is_void:
            error(self.pos, "Cannot take sizeof void")
        elif not arg_type.is_complete():
            error(self.pos, "Cannot take sizeof incomplete type '%s'" % arg_type)
7228

William Stein's avatar
William Stein committed
7229
    def calculate_result_code(self):
7230 7231 7232 7233 7234 7235
        if self.arg_type.is_extension_type:
            # the size of the pointer is boring
            # we want the size of the actual struct
            arg_code = self.arg_type.declaration_code("", deref=1)
        else:
            arg_code = self.arg_type.declaration_code("")
William Stein's avatar
William Stein committed
7236
        return "(sizeof(%s))" % arg_code
7237

William Stein's avatar
William Stein committed
7238 7239 7240 7241 7242

class SizeofVarNode(SizeofNode):
    #  C sizeof function applied to a variable
    #
    #  operand   ExprNode
7243

William Stein's avatar
William Stein committed
7244
    subexprs = ['operand']
7245

William Stein's avatar
William Stein committed
7246
    def analyse_types(self, env):
7247 7248 7249 7250 7251
        # We may actually be looking at a type rather than a variable...
        # If we are, traditional analysis would fail...
        operand_as_type = self.operand.analyse_as_type(env)
        if operand_as_type:
            self.arg_type = operand_as_type
Mark Florisson's avatar
Mark Florisson committed
7252 7253
            if self.arg_type.is_fused:
                self.arg_type = self.arg_type.specialize(env.fused_to_specific)
7254 7255 7256 7257
            self.__class__ = SizeofTypeNode
            self.check_type()
        else:
            self.operand.analyse_types(env)
7258

William Stein's avatar
William Stein committed
7259
    def calculate_result_code(self):
7260
        return "(sizeof(%s))" % self.operand.result()
7261

William Stein's avatar
William Stein committed
7262 7263 7264
    def generate_result_code(self, code):
        pass

Robert Bradshaw's avatar
Robert Bradshaw committed
7265
class TypeofNode(ExprNode):
7266 7267 7268
    #  Compile-time type of an expression, as a string.
    #
    #  operand   ExprNode
Robert Bradshaw's avatar
Robert Bradshaw committed
7269
    #  literal   StringNode # internal
7270

Robert Bradshaw's avatar
Robert Bradshaw committed
7271 7272
    literal = None
    type = py_object_type
7273

Stefan Behnel's avatar
Stefan Behnel committed
7274
    subexprs = ['literal'] # 'operand' will be ignored after type analysis!
7275

7276 7277
    def analyse_types(self, env):
        self.operand.analyse_types(env)
7278
        value = StringEncoding.EncodedString(str(self.operand.type)) #self.operand.type.typeof_name())
7279
        self.literal = StringNode(self.pos, value=value)
Robert Bradshaw's avatar
Robert Bradshaw committed
7280 7281
        self.literal.analyse_types(env)
        self.literal = self.literal.coerce_to_pyobject(env)
7282 7283 7284 7285

    def may_be_none(self):
        return False

7286
    def generate_evaluation_code(self, code):
Robert Bradshaw's avatar
Robert Bradshaw committed
7287
        self.literal.generate_evaluation_code(code)
7288

Robert Bradshaw's avatar
Robert Bradshaw committed
7289 7290
    def calculate_result_code(self):
        return self.literal.calculate_result_code()
William Stein's avatar
William Stein committed
7291 7292 7293 7294 7295 7296 7297

#-------------------------------------------------------------------
#
#  Binary operator nodes
#
#-------------------------------------------------------------------

Stefan Behnel's avatar
Stefan Behnel committed
7298 7299 7300
def _not_in(x, seq):
    return x not in seq

7301 7302 7303
compile_time_binary_operators = {
    '<': operator.lt,
    '<=': operator.le,
7304
    '==': operator.eq,
7305 7306 7307 7308 7309 7310 7311
    '!=': operator.ne,
    '>=': operator.ge,
    '>': operator.gt,
    'is': operator.is_,
    'is_not': operator.is_not,
    '+': operator.add,
    '&': operator.and_,
7312
    '/': operator.truediv,
7313 7314 7315 7316 7317 7318 7319 7320 7321
    '//': operator.floordiv,
    '<<': operator.lshift,
    '%': operator.mod,
    '*': operator.mul,
    '|': operator.or_,
    '**': operator.pow,
    '>>': operator.rshift,
    '-': operator.sub,
    '^': operator.xor,
Stefan Behnel's avatar
Stefan Behnel committed
7322 7323
    'in': operator.contains,
    'not_in': _not_in,
7324 7325 7326 7327 7328 7329 7330
}

def get_compile_time_binop(node):
    func = compile_time_binary_operators.get(node.operator)
    if not func:
        error(node.pos,
            "Binary '%s' not supported in compile-time expression"
7331
                % node.operator)
7332 7333
    return func

7334
class BinopNode(ExprNode):
William Stein's avatar
William Stein committed
7335 7336 7337 7338 7339 7340 7341 7342 7343 7344 7345
    #  operator     string
    #  operand1     ExprNode
    #  operand2     ExprNode
    #
    #  Processing during analyse_expressions phase:
    #
    #    analyse_c_operation
    #      Called when neither operand is a pyobject.
    #      - Check operand types and coerce if needed.
    #      - Determine result type and result code fragment.
    #      - Allocate temporary for result if needed.
7346

William Stein's avatar
William Stein committed
7347
    subexprs = ['operand1', 'operand2']
7348
    inplace = False
7349 7350 7351 7352 7353 7354 7355

    def calculate_constant_result(self):
        func = compile_time_binary_operators[self.operator]
        self.constant_result = func(
            self.operand1.constant_result,
            self.operand2.constant_result)

7356 7357 7358 7359 7360 7361 7362 7363
    def compile_time_value(self, denv):
        func = get_compile_time_binop(self)
        operand1 = self.operand1.compile_time_value(denv)
        operand2 = self.operand2.compile_time_value(denv)
        try:
            return func(operand1, operand2)
        except Exception, e:
            self.compile_time_value_error(e)
7364

7365 7366
    def infer_type(self, env):
        return self.result_type(self.operand1.infer_type(env),
Robert Bradshaw's avatar
Robert Bradshaw committed
7367
                                self.operand2.infer_type(env))
7368

William Stein's avatar
William Stein committed
7369 7370 7371
    def analyse_types(self, env):
        self.operand1.analyse_types(env)
        self.operand2.analyse_types(env)
Robert Bradshaw's avatar
Robert Bradshaw committed
7372
        self.analyse_operation(env)
7373

Robert Bradshaw's avatar
Robert Bradshaw committed
7374
    def analyse_operation(self, env):
William Stein's avatar
William Stein committed
7375 7376
        if self.is_py_operation():
            self.coerce_operands_to_pyobjects(env)
7377 7378 7379
            self.type = self.result_type(self.operand1.type,
                                         self.operand2.type)
            assert self.type.is_pyobject
William Stein's avatar
William Stein committed
7380
            self.is_temp = 1
DaniloFreitas's avatar
DaniloFreitas committed
7381 7382
        elif self.is_cpp_operation():
            self.analyse_cpp_operation(env)
William Stein's avatar
William Stein committed
7383 7384
        else:
            self.analyse_c_operation(env)
7385

William Stein's avatar
William Stein committed
7386
    def is_py_operation(self):
7387
        return self.is_py_operation_types(self.operand1.type, self.operand2.type)
7388

7389 7390 7391
    def is_py_operation_types(self, type1, type2):
        return type1.is_pyobject or type2.is_pyobject

DaniloFreitas's avatar
DaniloFreitas committed
7392
    def is_cpp_operation(self):
Robert Bradshaw's avatar
Robert Bradshaw committed
7393 7394
        return (self.operand1.type.is_cpp_class
            or self.operand2.type.is_cpp_class)
7395

7396 7397 7398 7399 7400 7401 7402 7403 7404 7405 7406 7407 7408 7409 7410 7411
    def analyse_cpp_operation(self, env):
        type1 = self.operand1.type
        type2 = self.operand2.type
        entry = env.lookup_operator(self.operator, [self.operand1, self.operand2])
        if not entry:
            self.type_error()
            return
        func_type = entry.type
        if func_type.is_ptr:
            func_type = func_type.base_type
        if len(func_type.args) == 1:
            self.operand2 = self.operand2.coerce_to(func_type.args[0].type, env)
        else:
            self.operand1 = self.operand1.coerce_to(func_type.args[0].type, env)
            self.operand2 = self.operand2.coerce_to(func_type.args[1].type, env)
        self.type = func_type.return_type
7412

7413 7414
    def result_type(self, type1, type2):
        if self.is_py_operation_types(type1, type2):
7415 7416 7417 7418 7419 7420 7421 7422 7423 7424 7425 7426 7427 7428 7429 7430 7431 7432
            if type2.is_string:
                type2 = Builtin.bytes_type
            if type1.is_string:
                type1 = Builtin.bytes_type
            elif self.operator == '%' \
                     and type1 in (Builtin.str_type, Builtin.unicode_type):
                # note that  b'%s' % b'abc'  doesn't work in Py3
                return type1
            if type1.is_builtin_type:
                if type1 is type2:
                    if self.operator in '**%+|&^':
                        # FIXME: at least these operators should be safe - others?
                        return type1
                elif self.operator == '*':
                    if type1 in (Builtin.bytes_type, Builtin.str_type, Builtin.unicode_type):
                        return type1
                    # multiplication of containers/numbers with an
                    # integer value always (?) returns the same type
7433
                    if type2.is_int:
7434
                        return type1
7435 7436 7437 7438
            elif type2.is_builtin_type and type1.is_int and self.operator == '*':
                # multiplication of containers/numbers with an
                # integer value always (?) returns the same type
                return type2
7439 7440 7441
            return py_object_type
        else:
            return self.compute_c_result_type(type1, type2)
7442

7443
    def nogil_check(self, env):
7444
        if self.is_py_operation():
7445
            self.gil_error()
7446

William Stein's avatar
William Stein committed
7447 7448 7449
    def coerce_operands_to_pyobjects(self, env):
        self.operand1 = self.operand1.coerce_to_pyobject(env)
        self.operand2 = self.operand2.coerce_to_pyobject(env)
7450

William Stein's avatar
William Stein committed
7451
    def check_const(self):
7452
        return self.operand1.check_const() and self.operand2.check_const()
7453

William Stein's avatar
William Stein committed
7454 7455 7456 7457
    def generate_result_code(self, code):
        #print "BinopNode.generate_result_code:", self.operand1, self.operand2 ###
        if self.operand1.type.is_pyobject:
            function = self.py_operation_function()
7458
            if self.operator == '**':
William Stein's avatar
William Stein committed
7459 7460 7461 7462
                extra_args = ", Py_None"
            else:
                extra_args = ""
            code.putln(
Robert Bradshaw's avatar
Robert Bradshaw committed
7463
                "%s = %s(%s, %s%s); %s" % (
7464 7465
                    self.result(),
                    function,
William Stein's avatar
William Stein committed
7466 7467 7468
                    self.operand1.py_result(),
                    self.operand2.py_result(),
                    extra_args,
7469
                    code.error_goto_if_null(self.result(), self.pos)))
7470
            code.put_gotref(self.py_result())
7471

William Stein's avatar
William Stein committed
7472 7473 7474 7475
    def type_error(self):
        if not (self.operand1.type.is_error
                or self.operand2.type.is_error):
            error(self.pos, "Invalid operand types for '%s' (%s; %s)" %
7476
                (self.operator, self.operand1.type,
William Stein's avatar
William Stein committed
7477 7478 7479 7480
                    self.operand2.type))
        self.type = PyrexTypes.error_type


Robert Bradshaw's avatar
Robert Bradshaw committed
7481
class CBinopNode(BinopNode):
7482

Robert Bradshaw's avatar
Robert Bradshaw committed
7483 7484 7485 7486
    def analyse_types(self, env):
        BinopNode.analyse_types(self, env)
        if self.is_py_operation():
            self.type = PyrexTypes.error_type
7487

Robert Bradshaw's avatar
Robert Bradshaw committed
7488 7489
    def py_operation_function():
        return ""
7490

Robert Bradshaw's avatar
Robert Bradshaw committed
7491 7492
    def calculate_result_code(self):
        return "(%s %s %s)" % (
7493 7494
            self.operand1.result(),
            self.operator,
Robert Bradshaw's avatar
Robert Bradshaw committed
7495 7496 7497 7498 7499 7500 7501 7502
            self.operand2.result())


def c_binop_constructor(operator):
    def make_binop_node(pos, **operands):
        return CBinopNode(pos, operator=operator, **operands)
    return make_binop_node

William Stein's avatar
William Stein committed
7503 7504
class NumBinopNode(BinopNode):
    #  Binary operation taking numeric arguments.
7505

Robert Bradshaw's avatar
Robert Bradshaw committed
7506
    infix = True
7507

William Stein's avatar
William Stein committed
7508 7509 7510 7511 7512 7513
    def analyse_c_operation(self, env):
        type1 = self.operand1.type
        type2 = self.operand2.type
        self.type = self.compute_c_result_type(type1, type2)
        if not self.type:
            self.type_error()
7514
            return
7515
        if self.type.is_complex:
Robert Bradshaw's avatar
Robert Bradshaw committed
7516
            self.infix = False
7517
        if not self.infix or (type1.is_numeric and type2.is_numeric):
7518 7519
            self.operand1 = self.operand1.coerce_to(self.type, env)
            self.operand2 = self.operand2.coerce_to(self.type, env)
7520

William Stein's avatar
William Stein committed
7521 7522
    def compute_c_result_type(self, type1, type2):
        if self.c_types_okay(type1, type2):
7523 7524 7525 7526 7527
            widest_type = PyrexTypes.widest_numeric_type(type1, type2)
            if widest_type is PyrexTypes.c_bint_type:
                if self.operator not in '|^&':
                    # False + False == 0 # not False!
                    widest_type = PyrexTypes.c_int_type
7528 7529 7530
            else:
                widest_type = PyrexTypes.widest_numeric_type(
                    widest_type, PyrexTypes.c_int_type)
7531
            return widest_type
William Stein's avatar
William Stein committed
7532 7533
        else:
            return None
7534

7535 7536 7537 7538 7539 7540 7541 7542 7543 7544
    def may_be_none(self):
        type1 = self.operand1.type
        type2 = self.operand2.type
        if type1 and type1.is_builtin_type and type2 and type2.is_builtin_type:
            # XXX: I can't think of any case where a binary operation
            # on builtin types evaluates to None - add a special case
            # here if there is one.
            return False
        return super(NumBinopNode, self).may_be_none()

7545 7546 7547 7548 7549 7550 7551
    def get_constant_c_result_code(self):
        value1 = self.operand1.get_constant_c_result_code()
        value2 = self.operand2.get_constant_c_result_code()
        if value1 and value2:
            return "(%s %s %s)" % (value1, self.operator, value2)
        else:
            return None
7552

William Stein's avatar
William Stein committed
7553
    def c_types_okay(self, type1, type2):
7554 7555 7556
        #print "NumBinopNode.c_types_okay:", type1, type2 ###
        return (type1.is_numeric  or type1.is_enum) \
            and (type2.is_numeric  or type2.is_enum)
William Stein's avatar
William Stein committed
7557 7558

    def calculate_result_code(self):
7559 7560
        if self.infix:
            return "(%s %s %s)" % (
7561 7562
                self.operand1.result(),
                self.operator,
7563 7564
                self.operand2.result())
        else:
7565 7566 7567
            func = self.type.binary_op(self.operator)
            if func is None:
                error(self.pos, "binary operator %s not supported for %s" % (self.operator, self.type))
7568
            return "%s(%s, %s)" % (
7569
                func,
7570 7571
                self.operand1.result(),
                self.operand2.result())
7572

7573
    def is_py_operation_types(self, type1, type2):
Stefan Behnel's avatar
Stefan Behnel committed
7574 7575
        return (type1.is_unicode_char or
                type2.is_unicode_char or
7576
                BinopNode.is_py_operation_types(self, type1, type2))
7577

William Stein's avatar
William Stein committed
7578
    def py_operation_function(self):
7579 7580 7581 7582
        fuction = self.py_functions[self.operator]
        if self.inplace:
            fuction = fuction.replace('PyNumber_', 'PyNumber_InPlace')
        return fuction
William Stein's avatar
William Stein committed
7583 7584

    py_functions = {
Robert Bradshaw's avatar
Robert Bradshaw committed
7585 7586 7587
        "|":        "PyNumber_Or",
        "^":        "PyNumber_Xor",
        "&":        "PyNumber_And",
7588 7589
        "<<":       "PyNumber_Lshift",
        ">>":       "PyNumber_Rshift",
Robert Bradshaw's avatar
Robert Bradshaw committed
7590 7591 7592 7593
        "+":        "PyNumber_Add",
        "-":        "PyNumber_Subtract",
        "*":        "PyNumber_Multiply",
        "/":        "__Pyx_PyNumber_Divide",
7594
        "//":       "PyNumber_FloorDivide",
Robert Bradshaw's avatar
Robert Bradshaw committed
7595
        "%":        "PyNumber_Remainder",
7596
        "**":       "PyNumber_Power"
William Stein's avatar
William Stein committed
7597 7598 7599 7600
    }

class IntBinopNode(NumBinopNode):
    #  Binary operation taking integer arguments.
7601

William Stein's avatar
William Stein committed
7602
    def c_types_okay(self, type1, type2):
7603 7604 7605
        #print "IntBinopNode.c_types_okay:", type1, type2 ###
        return (type1.is_int or type1.is_enum) \
            and (type2.is_int or type2.is_enum)
William Stein's avatar
William Stein committed
7606

7607

William Stein's avatar
William Stein committed
7608 7609
class AddNode(NumBinopNode):
    #  '+' operator.
7610

7611 7612 7613
    def is_py_operation_types(self, type1, type2):
        if type1.is_string and type2.is_string:
            return 1
William Stein's avatar
William Stein committed
7614
        else:
7615
            return NumBinopNode.is_py_operation_types(self, type1, type2)
William Stein's avatar
William Stein committed
7616 7617

    def compute_c_result_type(self, type1, type2):
7618 7619
        #print "AddNode.compute_c_result_type:", type1, self.operator, type2 ###
        if (type1.is_ptr or type1.is_array) and (type2.is_int or type2.is_enum):
William Stein's avatar
William Stein committed
7620
            return type1
7621
        elif (type2.is_ptr or type2.is_array) and (type1.is_int or type1.is_enum):
William Stein's avatar
William Stein committed
7622 7623 7624 7625 7626 7627 7628 7629
            return type2
        else:
            return NumBinopNode.compute_c_result_type(
                self, type1, type2)


class SubNode(NumBinopNode):
    #  '-' operator.
7630

William Stein's avatar
William Stein committed
7631
    def compute_c_result_type(self, type1, type2):
7632
        if (type1.is_ptr or type1.is_array) and (type2.is_int or type2.is_enum):
William Stein's avatar
William Stein committed
7633
            return type1
7634
        elif (type1.is_ptr or type1.is_array) and (type2.is_ptr or type2.is_array):
William Stein's avatar
William Stein committed
7635 7636 7637 7638 7639 7640 7641 7642
            return PyrexTypes.c_int_type
        else:
            return NumBinopNode.compute_c_result_type(
                self, type1, type2)


class MulNode(NumBinopNode):
    #  '*' operator.
7643

7644
    def is_py_operation_types(self, type1, type2):
William Stein's avatar
William Stein committed
7645 7646 7647 7648
        if (type1.is_string and type2.is_int) \
            or (type2.is_string and type1.is_int):
                return 1
        else:
7649
            return NumBinopNode.is_py_operation_types(self, type1, type2)
William Stein's avatar
William Stein committed
7650 7651


7652 7653
class DivNode(NumBinopNode):
    #  '/' or '//' operator.
7654

7655
    cdivision = None
7656 7657
    truedivision = None   # == "unknown" if operator == '/'
    ctruedivision = False
Robert Bradshaw's avatar
Robert Bradshaw committed
7658
    cdivision_warnings = False
7659
    zerodivision_check = None
7660 7661 7662 7663 7664 7665 7666 7667 7668 7669 7670 7671 7672 7673 7674 7675 7676 7677 7678 7679 7680 7681

    def find_compile_time_binary_operator(self, op1, op2):
        func = compile_time_binary_operators[self.operator]
        if self.operator == '/' and self.truedivision is None:
            # => true div for floats, floor div for integers
            if isinstance(op1, (int,long)) and isinstance(op2, (int,long)):
                func = compile_time_binary_operators['//']
        return func

    def calculate_constant_result(self):
        op1 = self.operand1.constant_result
        op2 = self.operand2.constant_result
        func = self.find_compile_time_binary_operator(op1, op2)
        self.constant_result = func(
            self.operand1.constant_result,
            self.operand2.constant_result)

    def compile_time_value(self, denv):
        operand1 = self.operand1.compile_time_value(denv)
        operand2 = self.operand2.compile_time_value(denv)
        try:
            func = self.find_compile_time_binary_operator(
Robert Bradshaw's avatar
Robert Bradshaw committed
7682
                operand1, operand2)
7683 7684 7685 7686
            return func(operand1, operand2)
        except Exception, e:
            self.compile_time_value_error(e)

Robert Bradshaw's avatar
Robert Bradshaw committed
7687
    def analyse_operation(self, env):
7688 7689 7690 7691
        if self.cdivision or env.directives['cdivision']:
            self.ctruedivision = False
        else:
            self.ctruedivision = self.truedivision
Robert Bradshaw's avatar
Robert Bradshaw committed
7692
        NumBinopNode.analyse_operation(self, env)
7693 7694
        if self.is_cpp_operation():
            self.cdivision = True
7695
        if not self.type.is_pyobject:
7696 7697
            self.zerodivision_check = (
                self.cdivision is None and not env.directives['cdivision']
7698
                and (not self.operand2.has_constant_result() or
7699
                     self.operand2.constant_result == 0))
7700 7701 7702 7703
            if self.zerodivision_check or env.directives['cdivision_warnings']:
                # Need to check ahead of time to warn or raise zero division error
                self.operand1 = self.operand1.coerce_to_simple(env)
                self.operand2 = self.operand2.coerce_to_simple(env)
7704 7705
                if env.nogil:
                    error(self.pos, "Pythonic division not allowed without gil, consider using cython.cdivision(True)")
7706 7707 7708 7709 7710 7711 7712 7713 7714

    def compute_c_result_type(self, type1, type2):
        if self.operator == '/' and self.ctruedivision:
            if not type1.is_float and not type2.is_float:
                widest_type = PyrexTypes.widest_numeric_type(type1, PyrexTypes.c_double_type)
                widest_type = PyrexTypes.widest_numeric_type(type2, widest_type)
                return widest_type
        return NumBinopNode.compute_c_result_type(self, type1, type2)

7715 7716 7717 7718 7719
    def zero_division_message(self):
        if self.type.is_int:
            return "integer division or modulo by zero"
        else:
            return "float division"
Robert Bradshaw's avatar
Robert Bradshaw committed
7720

7721
    def generate_evaluation_code(self, code):
7722
        if not self.type.is_pyobject and not self.type.is_complex:
7723
            if self.cdivision is None:
7724
                self.cdivision = (code.globalstate.directives['cdivision']
7725 7726 7727
                                    or not self.type.signed
                                    or self.type.is_float)
            if not self.cdivision:
7728
                code.globalstate.use_utility_code(div_int_utility_code.specialize(self.type))
7729
        NumBinopNode.generate_evaluation_code(self, code)
7730
        self.generate_div_warning_code(code)
7731

7732
    def generate_div_warning_code(self, code):
7733 7734
        if not self.type.is_pyobject:
            if self.zerodivision_check:
7735 7736 7737 7738 7739
                if not self.infix:
                    zero_test = "%s(%s)" % (self.type.unary_op('zero'), self.operand2.result())
                else:
                    zero_test = "%s == 0" % self.operand2.result()
                code.putln("if (unlikely(%s)) {" % zero_test)
7740 7741 7742
                code.putln('PyErr_Format(PyExc_ZeroDivisionError, "%s");' % self.zero_division_message())
                code.putln(code.error_goto(self.pos))
                code.putln("}")
7743 7744 7745
                if self.type.is_int and self.type.signed and self.operator != '%':
                    code.globalstate.use_utility_code(division_overflow_test_code)
                    code.putln("else if (sizeof(%s) == sizeof(long) && unlikely(%s == -1) && unlikely(UNARY_NEG_WOULD_OVERFLOW(%s))) {" % (
7746
                                    self.type.declaration_code(''),
7747 7748 7749 7750 7751
                                    self.operand2.result(),
                                    self.operand1.result()))
                    code.putln('PyErr_Format(PyExc_OverflowError, "value too large to perform division");')
                    code.putln(code.error_goto(self.pos))
                    code.putln("}")
Robert Bradshaw's avatar
Robert Bradshaw committed
7752
            if code.globalstate.directives['cdivision_warnings'] and self.operator != '/':
7753 7754 7755 7756 7757
                code.globalstate.use_utility_code(cdivision_warning_utility_code)
                code.putln("if ((%s < 0) ^ (%s < 0)) {" % (
                                self.operand1.result(),
                                self.operand2.result()))
                code.putln(code.set_error_info(self.pos));
7758 7759 7760 7761 7762 7763
                code.put("if (__Pyx_cdivision_warning(%(FILENAME)s, "
                                                     "%(LINENO)s)) " % {
                    'FILENAME': Naming.filename_cname,
                    'LINENO':  Naming.lineno_cname,
                    })

7764 7765
                code.put_goto(code.error_label)
                code.putln("}")
7766

Robert Bradshaw's avatar
Robert Bradshaw committed
7767
    def calculate_result_code(self):
7768 7769 7770
        if self.type.is_complex:
            return NumBinopNode.calculate_result_code(self)
        elif self.type.is_float and self.operator == '//':
7771
            return "floor(%s / %s)" % (
7772
                self.operand1.result(),
7773
                self.operand2.result())
7774 7775 7776 7777 7778 7779 7780 7781 7782
        elif self.truedivision or self.cdivision:
            op1 = self.operand1.result()
            op2 = self.operand2.result()
            if self.truedivision:
                if self.type != self.operand1.type:
                    op1 = self.type.cast_code(op1)
                if self.type != self.operand2.type:
                    op2 = self.type.cast_code(op2)
            return "(%s / %s)" % (op1, op2)
7783 7784
        else:
            return "__Pyx_div_%s(%s, %s)" % (
Craig Citro's avatar
Craig Citro committed
7785
                    self.type.specialization_name(),
7786
                    self.operand1.result(),
7787
                    self.operand2.result())
Robert Bradshaw's avatar
Robert Bradshaw committed
7788 7789


Robert Bradshaw's avatar
Robert Bradshaw committed
7790
class ModNode(DivNode):
William Stein's avatar
William Stein committed
7791
    #  '%' operator.
7792

7793 7794 7795 7796
    def is_py_operation_types(self, type1, type2):
        return (type1.is_string
            or type2.is_string
            or NumBinopNode.is_py_operation_types(self, type1, type2))
William Stein's avatar
William Stein committed
7797

7798 7799 7800 7801 7802
    def zero_division_message(self):
        if self.type.is_int:
            return "integer division or modulo by zero"
        else:
            return "float divmod()"
7803

7804
    def generate_evaluation_code(self, code):
7805 7806 7807 7808 7809
        if not self.type.is_pyobject:
            if self.cdivision is None:
                self.cdivision = code.globalstate.directives['cdivision'] or not self.type.signed
            if not self.cdivision:
                if self.type.is_int:
7810
                    code.globalstate.use_utility_code(mod_int_utility_code.specialize(self.type))
7811
                else:
7812 7813
                    code.globalstate.use_utility_code(
                        mod_float_utility_code.specialize(self.type, math_h_modifier=self.type.math_h_modifier))
7814
        NumBinopNode.generate_evaluation_code(self, code)
7815
        self.generate_div_warning_code(code)
7816

Robert Bradshaw's avatar
Robert Bradshaw committed
7817
    def calculate_result_code(self):
7818 7819 7820 7821
        if self.cdivision:
            if self.type.is_float:
                return "fmod%s(%s, %s)" % (
                    self.type.math_h_modifier,
7822
                    self.operand1.result(),
7823 7824 7825
                    self.operand2.result())
            else:
                return "(%s %% %s)" % (
7826
                    self.operand1.result(),
7827
                    self.operand2.result())
Robert Bradshaw's avatar
Robert Bradshaw committed
7828
        else:
7829
            return "__Pyx_mod_%s(%s, %s)" % (
Craig Citro's avatar
Craig Citro committed
7830
                    self.type.specialization_name(),
7831
                    self.operand1.result(),
7832
                    self.operand2.result())
William Stein's avatar
William Stein committed
7833 7834 7835

class PowNode(NumBinopNode):
    #  '**' operator.
7836

Robert Bradshaw's avatar
Robert Bradshaw committed
7837 7838
    def analyse_c_operation(self, env):
        NumBinopNode.analyse_c_operation(self, env)
7839
        if self.type.is_complex:
Robert Bradshaw's avatar
Robert Bradshaw committed
7840 7841 7842 7843 7844 7845 7846
            if self.type.real_type.is_float:
                self.operand1 = self.operand1.coerce_to(self.type, env)
                self.operand2 = self.operand2.coerce_to(self.type, env)
                self.pow_func = "__Pyx_c_pow" + self.type.real_type.math_h_modifier
            else:
                error(self.pos, "complex int powers not supported")
                self.pow_func = "<error>"
7847
        elif self.type.is_float:
7848
            self.pow_func = "pow" + self.type.math_h_modifier
William Stein's avatar
William Stein committed
7849
        else:
Robert Bradshaw's avatar
Robert Bradshaw committed
7850 7851
            self.pow_func = "__Pyx_pow_%s" % self.type.declaration_code('').replace(' ', '_')
            env.use_utility_code(
7852
                    int_pow_utility_code.specialize(func_name=self.pow_func,
Robert Bradshaw's avatar
Robert Bradshaw committed
7853
                                                type=self.type.declaration_code('')))
7854

William Stein's avatar
William Stein committed
7855
    def calculate_result_code(self):
7856 7857 7858 7859 7860 7861
        # Work around MSVC overloading ambiguity.
        def typecast(operand):
            if self.type == operand.type:
                return operand.result()
            else:
                return self.type.cast_code(operand.result())
Robert Bradshaw's avatar
Robert Bradshaw committed
7862
        return "%s(%s, %s)" % (
7863 7864
            self.pow_func,
            typecast(self.operand1),
7865
            typecast(self.operand2))
7866

William Stein's avatar
William Stein committed
7867

Craig Citro's avatar
Craig Citro committed
7868
# Note: This class is temporarily "shut down" into an ineffective temp
7869 7870
# allocation mode.
#
Craig Citro's avatar
Craig Citro committed
7871 7872 7873
# More sophisticated temp reuse was going on before, one could have a
# look at adding this again after /all/ classes are converted to the
# new temp scheme. (The temp juggling cannot work otherwise).
7874
class BoolBinopNode(ExprNode):
William Stein's avatar
William Stein committed
7875 7876 7877 7878 7879
    #  Short-circuiting boolean operation.
    #
    #  operator     string
    #  operand1     ExprNode
    #  operand2     ExprNode
7880

7881
    subexprs = ['operand1', 'operand2']
7882

7883
    def infer_type(self, env):
7884 7885
        type1 = self.operand1.infer_type(env)
        type2 = self.operand2.infer_type(env)
7886
        return PyrexTypes.independent_spanning_type(type1, type2)
7887

Stefan Behnel's avatar
Stefan Behnel committed
7888 7889 7890 7891 7892 7893
    def may_be_none(self):
        if self.operator == 'or':
            return self.operand2.may_be_none()
        else:
            return self.operand1.may_be_none() or self.operand2.may_be_none()

7894 7895 7896 7897 7898 7899 7900 7901 7902
    def calculate_constant_result(self):
        if self.operator == 'and':
            self.constant_result = \
                self.operand1.constant_result and \
                self.operand2.constant_result
        else:
            self.constant_result = \
                self.operand1.constant_result or \
                self.operand2.constant_result
7903

7904 7905 7906 7907 7908 7909 7910
    def compile_time_value(self, denv):
        if self.operator == 'and':
            return self.operand1.compile_time_value(denv) \
                and self.operand2.compile_time_value(denv)
        else:
            return self.operand1.compile_time_value(denv) \
                or self.operand2.compile_time_value(denv)
7911

7912
    def coerce_to_boolean(self, env):
7913 7914 7915 7916 7917 7918 7919
        return BoolBinopNode(
            self.pos,
            operator = self.operator,
            operand1 = self.operand1.coerce_to_boolean(env),
            operand2 = self.operand2.coerce_to_boolean(env),
            type = PyrexTypes.c_bint_type,
            is_temp = self.is_temp)
7920

William Stein's avatar
William Stein committed
7921 7922 7923
    def analyse_types(self, env):
        self.operand1.analyse_types(env)
        self.operand2.analyse_types(env)
7924
        self.type = PyrexTypes.independent_spanning_type(self.operand1.type, self.operand2.type)
7925 7926
        self.operand1 = self.operand1.coerce_to(self.type, env)
        self.operand2 = self.operand2.coerce_to(self.type, env)
7927

William Stein's avatar
William Stein committed
7928 7929
        # For what we're about to do, it's vital that
        # both operands be temp nodes.
7930 7931
        self.operand1 = self.operand1.coerce_to_simple(env)
        self.operand2 = self.operand2.coerce_to_simple(env)
William Stein's avatar
William Stein committed
7932
        self.is_temp = 1
7933 7934 7935

    gil_message = "Truth-testing Python object"

William Stein's avatar
William Stein committed
7936
    def check_const(self):
7937
        return self.operand1.check_const() and self.operand2.check_const()
7938

William Stein's avatar
William Stein committed
7939
    def generate_evaluation_code(self, code):
7940
        code.mark_pos(self.pos)
William Stein's avatar
William Stein committed
7941
        self.operand1.generate_evaluation_code(code)
7942
        test_result, uses_temp = self.generate_operand1_test(code)
William Stein's avatar
William Stein committed
7943 7944 7945 7946 7947 7948 7949 7950
        if self.operator == 'and':
            sense = ""
        else:
            sense = "!"
        code.putln(
            "if (%s%s) {" % (
                sense,
                test_result))
7951 7952
        if uses_temp:
            code.funcstate.release_temp(test_result)
7953
        self.operand1.generate_disposal_code(code)
William Stein's avatar
William Stein committed
7954
        self.operand2.generate_evaluation_code(code)
7955
        self.allocate_temp_result(code)
7956
        self.operand2.make_owned_reference(code)
7957
        code.putln("%s = %s;" % (self.result(), self.operand2.result()))
7958 7959
        self.operand2.generate_post_assignment_code(code)
        self.operand2.free_temps(code)
7960
        code.putln("} else {")
7961
        self.operand1.make_owned_reference(code)
7962
        code.putln("%s = %s;" % (self.result(), self.operand1.result()))
7963 7964
        self.operand1.generate_post_assignment_code(code)
        self.operand1.free_temps(code)
7965
        code.putln("}")
7966

William Stein's avatar
William Stein committed
7967 7968 7969
    def generate_operand1_test(self, code):
        #  Generate code to test the truth of the first operand.
        if self.type.is_pyobject:
7970 7971
            test_result = code.funcstate.allocate_temp(PyrexTypes.c_bint_type,
                                                       manage_ref=False)
William Stein's avatar
William Stein committed
7972
            code.putln(
7973
                "%s = __Pyx_PyObject_IsTrue(%s); %s" % (
William Stein's avatar
William Stein committed
7974 7975
                    test_result,
                    self.operand1.py_result(),
Robert Bradshaw's avatar
Robert Bradshaw committed
7976
                    code.error_goto_if_neg(test_result, self.pos)))
William Stein's avatar
William Stein committed
7977
        else:
7978
            test_result = self.operand1.result()
7979
        return (test_result, self.type.is_pyobject)
William Stein's avatar
William Stein committed
7980 7981


7982
class CondExprNode(ExprNode):
Robert Bradshaw's avatar
Robert Bradshaw committed
7983 7984 7985 7986 7987
    #  Short-circuiting conditional expression.
    #
    #  test        ExprNode
    #  true_val    ExprNode
    #  false_val   ExprNode
7988

7989 7990
    true_val = None
    false_val = None
7991

Robert Bradshaw's avatar
Robert Bradshaw committed
7992
    subexprs = ['test', 'true_val', 'false_val']
7993

Robert Bradshaw's avatar
Robert Bradshaw committed
7994 7995
    def type_dependencies(self, env):
        return self.true_val.type_dependencies(env) + self.false_val.type_dependencies(env)
7996

Robert Bradshaw's avatar
Robert Bradshaw committed
7997
    def infer_type(self, env):
7998 7999
        return PyrexTypes.independent_spanning_type(self.true_val.infer_type(env),
                                                    self.false_val.infer_type(env))
8000 8001 8002 8003 8004 8005 8006

    def calculate_constant_result(self):
        if self.test.constant_result:
            self.constant_result = self.true_val.constant_result
        else:
            self.constant_result = self.false_val.constant_result

Robert Bradshaw's avatar
Robert Bradshaw committed
8007 8008 8009 8010 8011
    def analyse_types(self, env):
        self.test.analyse_types(env)
        self.test = self.test.coerce_to_boolean(env)
        self.true_val.analyse_types(env)
        self.false_val.analyse_types(env)
8012
        self.type = PyrexTypes.independent_spanning_type(self.true_val.type, self.false_val.type)
8013 8014 8015 8016 8017
        if self.true_val.type.is_pyobject or self.false_val.type.is_pyobject:
            self.true_val = self.true_val.coerce_to(self.type, env)
            self.false_val = self.false_val.coerce_to(self.type, env)
        self.is_temp = 1
        if self.type == PyrexTypes.error_type:
Robert Bradshaw's avatar
Robert Bradshaw committed
8018
            self.type_error()
8019

Robert Bradshaw's avatar
Robert Bradshaw committed
8020 8021 8022 8023 8024
    def type_error(self):
        if not (self.true_val.type.is_error or self.false_val.type.is_error):
            error(self.pos, "Incompatable types in conditional expression (%s; %s)" %
                (self.true_val.type, self.false_val.type))
        self.type = PyrexTypes.error_type
8025

Robert Bradshaw's avatar
Robert Bradshaw committed
8026
    def check_const(self):
8027
        return (self.test.check_const()
8028 8029
            and self.true_val.check_const()
            and self.false_val.check_const())
8030

Robert Bradshaw's avatar
Robert Bradshaw committed
8031
    def generate_evaluation_code(self, code):
Dag Sverre Seljebotn's avatar
Dag Sverre Seljebotn committed
8032 8033
        # Because subexprs may not be evaluated we can use a more optimal
        # subexpr allocation strategy than the default, so override evaluation_code.
8034

Dag Sverre Seljebotn's avatar
Dag Sverre Seljebotn committed
8035
        code.mark_pos(self.pos)
8036
        self.allocate_temp_result(code)
Robert Bradshaw's avatar
Robert Bradshaw committed
8037
        self.test.generate_evaluation_code(code)
8038
        code.putln("if (%s) {" % self.test.result() )
Dag Sverre Seljebotn's avatar
Dag Sverre Seljebotn committed
8039
        self.eval_and_get(code, self.true_val)
Robert Bradshaw's avatar
Robert Bradshaw committed
8040
        code.putln("} else {")
Dag Sverre Seljebotn's avatar
Dag Sverre Seljebotn committed
8041
        self.eval_and_get(code, self.false_val)
Robert Bradshaw's avatar
Robert Bradshaw committed
8042 8043
        code.putln("}")
        self.test.generate_disposal_code(code)
8044
        self.test.free_temps(code)
Robert Bradshaw's avatar
Robert Bradshaw committed
8045

Dag Sverre Seljebotn's avatar
Dag Sverre Seljebotn committed
8046 8047 8048
    def eval_and_get(self, code, expr):
        expr.generate_evaluation_code(code)
        expr.make_owned_reference(code)
8049
        code.putln('%s = %s;' % (self.result(), expr.result_as(self.ctype())))
Dag Sverre Seljebotn's avatar
Dag Sverre Seljebotn committed
8050 8051 8052
        expr.generate_post_assignment_code(code)
        expr.free_temps(code)

8053 8054 8055 8056 8057 8058 8059 8060 8061 8062
richcmp_constants = {
    "<" : "Py_LT",
    "<=": "Py_LE",
    "==": "Py_EQ",
    "!=": "Py_NE",
    "<>": "Py_NE",
    ">" : "Py_GT",
    ">=": "Py_GE",
}

8063
class CmpNode(object):
William Stein's avatar
William Stein committed
8064 8065
    #  Mixin class containing code common to PrimaryCmpNodes
    #  and CascadedCmpNodes.
8066 8067 8068

    special_bool_cmp_function = None

Stefan Behnel's avatar
typo  
Stefan Behnel committed
8069
    def infer_type(self, env):
8070 8071
        # TODO: Actually implement this (after merging with -unstable).
        return py_object_type
8072 8073 8074 8075 8076

    def calculate_cascaded_constant_result(self, operand1_result):
        func = compile_time_binary_operators[self.operator]
        operand2_result = self.operand2.constant_result
        result = func(operand1_result, operand2_result)
8077 8078 8079 8080 8081 8082 8083
        if self.cascade:
            self.cascade.calculate_cascaded_constant_result(operand2_result)
            if self.cascade.constant_result:
                self.constant_result = result and self.cascade.constant_result
        else:
            self.constant_result = result

8084 8085
    def cascaded_compile_time_value(self, operand1, denv):
        func = get_compile_time_binop(self)
8086
        operand2 = self.operand2.compile_time_value(denv)
8087 8088 8089 8090
        try:
            result = func(operand1, operand2)
        except Exception, e:
            self.compile_time_value_error(e)
8091
            result = None
8092 8093 8094
        if result:
            cascade = self.cascade
            if cascade:
8095
                # FIXME: I bet this must call cascaded_compile_time_value()
8096
                result = result and cascade.cascaded_compile_time_value(operand2, denv)
8097 8098
        return result

8099
    def is_cpp_comparison(self):
Robert Bradshaw's avatar
Robert Bradshaw committed
8100
        return self.operand1.type.is_cpp_class or self.operand2.type.is_cpp_class
8101

8102
    def find_common_int_type(self, env, op, operand1, operand2):
8103 8104 8105 8106 8107 8108
        # type1 != type2 and at least one of the types is not a C int
        type1 = operand1.type
        type2 = operand2.type
        type1_can_be_int = False
        type2_can_be_int = False

8109
        if operand1.is_string_literal and operand1.can_coerce_to_char_literal():
8110
            type1_can_be_int = True
8111
        if operand2.is_string_literal and operand2.can_coerce_to_char_literal():
8112 8113 8114 8115
            type2_can_be_int = True

        if type1.is_int:
            if type2_can_be_int:
8116
                return type1
8117 8118
        elif type2.is_int:
            if type1_can_be_int:
8119
                return type2
8120 8121
        elif type1_can_be_int:
            if type2_can_be_int:
8122
                return PyrexTypes.c_uchar_type
William Stein's avatar
William Stein committed
8123

8124
        return None
8125

8126
    def find_common_type(self, env, op, operand1, common_type=None):
8127
        operand2 = self.operand2
William Stein's avatar
William Stein committed
8128 8129
        type1 = operand1.type
        type2 = operand2.type
8130

8131 8132
        new_common_type = None

Stefan Behnel's avatar
Stefan Behnel committed
8133
        # catch general errors
8134 8135 8136
        if type1 == str_type and (type2.is_string or type2 in (bytes_type, unicode_type)) or \
               type2 == str_type and (type1.is_string or type1 in (bytes_type, unicode_type)):
            error(self.pos, "Comparisons between bytes/unicode and str are not portable to Python 3")
8137
            new_common_type = error_type
Stefan Behnel's avatar
Stefan Behnel committed
8138 8139

        # try to use numeric comparisons where possible
8140
        elif type1.is_complex or type2.is_complex:
8141 8142 8143
            if op not in ('==', '!=') \
               and (type1.is_complex or type1.is_numeric) \
               and (type2.is_complex or type2.is_numeric):
8144 8145
                error(self.pos, "complex types are unordered")
                new_common_type = error_type
8146
            elif type1.is_pyobject:
8147 8148 8149
                new_common_type = type1
            elif type2.is_pyobject:
                new_common_type = type2
8150
            else:
8151
                new_common_type = PyrexTypes.widest_numeric_type(type1, type2)
8152 8153
        elif type1.is_numeric and type2.is_numeric:
            new_common_type = PyrexTypes.widest_numeric_type(type1, type2)
8154
        elif common_type is None or not common_type.is_pyobject:
8155
            new_common_type = self.find_common_int_type(env, op, operand1, operand2)
8156 8157

        if new_common_type is None:
Stefan Behnel's avatar
Stefan Behnel committed
8158
            # fall back to generic type compatibility tests
8159
            if type1 == type2:
8160 8161 8162 8163 8164 8165
                new_common_type = type1
            elif type1.is_pyobject or type2.is_pyobject:
                if type2.is_numeric or type2.is_string:
                    if operand2.check_for_coercion_error(type1):
                        new_common_type = error_type
                    else:
Robert Bradshaw's avatar
Robert Bradshaw committed
8166
                        new_common_type = py_object_type
8167 8168 8169 8170
                elif type1.is_numeric or type1.is_string:
                    if operand1.check_for_coercion_error(type2):
                        new_common_type = error_type
                    else:
Robert Bradshaw's avatar
Robert Bradshaw committed
8171 8172 8173
                        new_common_type = py_object_type
                elif py_object_type.assignable_from(type1) and py_object_type.assignable_from(type2):
                    new_common_type = py_object_type
8174 8175 8176 8177
                else:
                    # one Python type and one non-Python type, not assignable
                    self.invalid_types_error(operand1, op, operand2)
                    new_common_type = error_type
8178 8179 8180 8181
            elif type1.assignable_from(type2):
                new_common_type = type1
            elif type2.assignable_from(type1):
                new_common_type = type2
8182 8183 8184 8185
            else:
                # C types that we couldn't handle up to here are an error
                self.invalid_types_error(operand1, op, operand2)
                new_common_type = error_type
8186

8187 8188 8189 8190 8191 8192
        if new_common_type.is_string and (isinstance(operand1, BytesNode) or
                                          isinstance(operand2, BytesNode)):
            # special case when comparing char* to bytes literal: must
            # compare string values!
            new_common_type = bytes_type

Stefan Behnel's avatar
Stefan Behnel committed
8193
        # recursively merge types
8194
        if common_type is None or new_common_type.is_error:
8195
            common_type = new_common_type
William Stein's avatar
William Stein committed
8196
        else:
8197 8198 8199
            # we could do a lot better by splitting the comparison
            # into a non-Python part and a Python part, but this is
            # safer for now
8200
            common_type = PyrexTypes.spanning_type(common_type, new_common_type)
8201 8202

        if self.cascade:
8203
            common_type = self.cascade.find_common_type(env, self.operator, operand2, common_type)
8204

8205 8206
        return common_type

8207 8208 8209 8210
    def invalid_types_error(self, operand1, op, operand2):
        error(self.pos, "Invalid types for '%s' (%s, %s)" %
              (op, operand1.type, operand2.type))

Stefan Behnel's avatar
Stefan Behnel committed
8211
    def is_python_comparison(self):
8212 8213 8214 8215 8216
        return (not self.is_ptr_contains()
            and not self.is_c_string_contains()
            and (self.has_python_operands()
                 or (self.cascade and self.cascade.is_python_comparison())
                 or self.operator in ('in', 'not_in')))
Stefan Behnel's avatar
Stefan Behnel committed
8217

8218 8219 8220 8221 8222 8223
    def coerce_operands_to(self, dst_type, env):
        operand2 = self.operand2
        if operand2.type != dst_type:
            self.operand2 = operand2.coerce_to(dst_type, env)
        if self.cascade:
            self.cascade.coerce_operands_to(dst_type, env)
8224

8225
    def is_python_result(self):
8226
        return ((self.has_python_operands() and
8227
                 self.special_bool_cmp_function is None and
8228
                 self.operator not in ('is', 'is_not', 'in', 'not_in') and
8229 8230
                 not self.is_c_string_contains() and
                 not self.is_ptr_contains())
8231
            or (self.cascade and self.cascade.is_python_result()))
William Stein's avatar
William Stein committed
8232

8233 8234
    def is_c_string_contains(self):
        return self.operator in ('in', 'not_in') and \
8235 8236
               ((self.operand1.type.is_int
                 and (self.operand2.type.is_string or self.operand2.type is bytes_type)) or
Stefan Behnel's avatar
Stefan Behnel committed
8237
                (self.operand1.type.is_unicode_char
8238
                 and self.operand2.type is unicode_type))
8239

8240 8241
    def is_ptr_contains(self):
        if self.operator in ('in', 'not_in'):
8242 8243 8244
            container_type = self.operand2.type
            return (container_type.is_ptr or container_type.is_array) \
                and not container_type.is_string
8245

8246 8247 8248 8249 8250
    def find_special_bool_compare_function(self, env):
        if self.operator in ('==', '!='):
            type1, type2 = self.operand1.type, self.operand2.type
            if type1.is_pyobject and type2.is_pyobject:
                if type1 is Builtin.unicode_type or type2 is Builtin.unicode_type:
8251
                    env.use_utility_code(UtilityCode.load_cached("UnicodeEquals", "StringTools.c"))
8252 8253
                    self.special_bool_cmp_function = "__Pyx_PyUnicode_Equals"
                    return True
8254
                elif type1 is Builtin.bytes_type or type2 is Builtin.bytes_type:
8255
                    env.use_utility_code(UtilityCode.load_cached("BytesEquals", "StringTools.c"))
8256 8257 8258
                    self.special_bool_cmp_function = "__Pyx_PyBytes_Equals"
                    return True
                elif type1 is Builtin.str_type or type2 is Builtin.str_type:
8259
                    env.use_utility_code(UtilityCode.load_cached("StrEquals", "StringTools.c"))
8260 8261
                    self.special_bool_cmp_function = "__Pyx_PyString_Equals"
                    return True
8262 8263
        return False

8264
    def generate_operation_code(self, code, result_code,
William Stein's avatar
William Stein committed
8265
            operand1, op , operand2):
8266
        if self.type.is_pyobject:
8267 8268 8269
            coerce_result = "__Pyx_PyBool_FromLong"
        else:
            coerce_result = ""
8270
        if 'not' in op:
8271
            negation = "!"
8272
        else:
8273
            negation = ""
8274 8275 8276 8277 8278 8279 8280 8281 8282 8283 8284 8285 8286 8287 8288 8289 8290
        if self.special_bool_cmp_function:
            if operand1.type.is_pyobject:
                result1 = operand1.py_result()
            else:
                result1 = operand1.result()
            if operand2.type.is_pyobject:
                result2 = operand2.py_result()
            else:
                result2 = operand2.result()
            code.putln("%s = %s(%s, %s, %s); %s" % (
                result_code,
                self.special_bool_cmp_function,
                result1,
                result2,
                richcmp_constants[op],
                code.error_goto_if_neg(result_code, self.pos)))
        elif op == 'in' or op == 'not_in':
Stefan Behnel's avatar
typo  
Stefan Behnel committed
8291
            code.globalstate.use_utility_code(contains_utility_code)
8292
            if self.type.is_pyobject:
8293
                coerce_result = "__Pyx_PyBoolOrNull_FromLong"
8294
            if op == 'not_in':
8295
                negation = "__Pyx_NegateNonNeg"
8296
            if operand2.type is dict_type:
8297
                method = "PyDict_Contains"
8298
            else:
8299
                method = "PySequence_Contains"
8300
            if self.type.is_pyobject:
8301 8302 8303 8304 8305 8306 8307 8308 8309 8310 8311
                error_clause = code.error_goto_if_null
                got_ref = "__Pyx_XGOTREF(%s); " % result_code
            else:
                error_clause = code.error_goto_if_neg
                got_ref = ""
            code.putln(
                "%s = %s(%s(%s(%s, %s))); %s%s" % (
                    result_code,
                    coerce_result,
                    negation,
                    method,
8312 8313
                    operand2.py_result(),
                    operand1.py_result(),
8314 8315
                    got_ref,
                    error_clause(result_code, self.pos)))
William Stein's avatar
William Stein committed
8316 8317
        elif (operand1.type.is_pyobject
            and op not in ('is', 'is_not')):
8318
                code.putln("%s = PyObject_RichCompare(%s, %s, %s); %s" % (
8319 8320 8321
                        result_code,
                        operand1.py_result(),
                        operand2.py_result(),
8322 8323
                        richcmp_constants[op],
                        code.error_goto_if_null(result_code, self.pos)))
8324
                code.put_gotref(result_code)
8325
        elif operand1.type.is_complex:
8326
            if op == "!=":
8327
                negation = "!"
8328
            else:
8329
                negation = ""
8330
            code.putln("%s = %s(%s%s(%s, %s));" % (
8331
                result_code,
8332 8333
                coerce_result,
                negation,
8334 8335
                operand1.type.unary_op('eq'),
                operand1.result(),
8336
                operand2.result()))
William Stein's avatar
William Stein committed
8337
        else:
8338 8339 8340 8341 8342
            type1 = operand1.type
            type2 = operand2.type
            if (type1.is_extension_type or type2.is_extension_type) \
                    and not type1.same_as(type2):
                common_type = py_object_type
8343 8344
            elif type1.is_numeric:
                common_type = PyrexTypes.widest_numeric_type(type1, type2)
8345
            else:
8346 8347 8348
                common_type = type1
            code1 = operand1.result_as(common_type)
            code2 = operand2.result_as(common_type)
8349
            code.putln("%s = %s(%s %s %s);" % (
8350 8351 8352 8353
                result_code,
                coerce_result,
                code1,
                self.c_operator(op),
8354 8355
                code2))

William Stein's avatar
William Stein committed
8356 8357 8358 8359 8360 8361 8362
    def c_operator(self, op):
        if op == 'is':
            return "=="
        elif op == 'is_not':
            return "!="
        else:
            return op
8363

Stefan Behnel's avatar
typo  
Stefan Behnel committed
8364
contains_utility_code = UtilityCode(
8365
proto="""
8366 8367
static CYTHON_INLINE int __Pyx_NegateNonNeg(int b) {
    return unlikely(b < 0) ? b : !b;
Lisandro Dalcin's avatar
Lisandro Dalcin committed
8368
}
8369
static CYTHON_INLINE PyObject* __Pyx_PyBoolOrNull_FromLong(long b) {
8370 8371 8372 8373
    return unlikely(b < 0) ? NULL : __Pyx_PyBool_FromLong(b);
}
""")

William Stein's avatar
William Stein committed
8374

8375
class PrimaryCmpNode(ExprNode, CmpNode):
William Stein's avatar
William Stein committed
8376 8377 8378 8379 8380 8381 8382
    #  Non-cascaded comparison or first comparison of
    #  a cascaded sequence.
    #
    #  operator      string
    #  operand1      ExprNode
    #  operand2      ExprNode
    #  cascade       CascadedCmpNode
8383

William Stein's avatar
William Stein committed
8384 8385 8386 8387
    #  We don't use the subexprs mechanism, because
    #  things here are too complicated for it to handle.
    #  Instead, we override all the framework methods
    #  which use it.
8388

Robert Bradshaw's avatar
Robert Bradshaw committed
8389
    child_attrs = ['operand1', 'operand2', 'cascade']
8390

William Stein's avatar
William Stein committed
8391
    cascade = None
8392

Robert Bradshaw's avatar
Robert Bradshaw committed
8393 8394 8395 8396 8397 8398 8399
    def infer_type(self, env):
        # TODO: Actually implement this (after merging with -unstable).
        return py_object_type

    def type_dependencies(self, env):
        return ()

8400
    def calculate_constant_result(self):
8401
        self.calculate_cascaded_constant_result(self.operand1.constant_result)
8402

8403
    def compile_time_value(self, denv):
8404
        operand1 = self.operand1.compile_time_value(denv)
8405 8406
        return self.cascaded_compile_time_value(operand1, denv)

William Stein's avatar
William Stein committed
8407 8408 8409
    def analyse_types(self, env):
        self.operand1.analyse_types(env)
        self.operand2.analyse_types(env)
8410 8411
        if self.is_cpp_comparison():
            self.analyse_cpp_comparison(env)
Robert Bradshaw's avatar
Robert Bradshaw committed
8412 8413 8414
            if self.cascade:
                error(self.pos, "Cascading comparison not yet supported for cpp types.")
            return
William Stein's avatar
William Stein committed
8415
        if self.cascade:
8416 8417
            self.cascade.analyse_types(env)

8418
        if self.operator in ('in', 'not_in'):
8419 8420 8421 8422 8423 8424 8425
            if self.is_c_string_contains():
                self.is_pycmp = False
                common_type = None
                if self.cascade:
                    error(self.pos, "Cascading comparison not yet supported for 'int_val in string'.")
                    return
                if self.operand2.type is unicode_type:
8426
                    env.use_utility_code(UtilityCode.load_cached("PyUCS4InUnicode", "StringTools.c"))
8427 8428 8429 8430 8431
                else:
                    if self.operand1.type is PyrexTypes.c_uchar_type:
                        self.operand1 = self.operand1.coerce_to(PyrexTypes.c_char_type, env)
                    if self.operand2.type is not bytes_type:
                        self.operand2 = self.operand2.coerce_to(bytes_type, env)
8432
                    env.use_utility_code(UtilityCode.load_cached("BytesContains", "StringTools.c"))
Stefan Behnel's avatar
Stefan Behnel committed
8433 8434
                self.operand2 = self.operand2.as_none_safe_node(
                    "argument of type 'NoneType' is not iterable")
8435 8436 8437 8438 8439 8440
            elif self.is_ptr_contains():
                if self.cascade:
                    error(self.pos, "Cascading comparison not yet supported for 'val in sliced pointer'.")
                self.type = PyrexTypes.c_bint_type
                # Will be transformed by IterationTransform
                return
8441
            else:
8442 8443
                if self.operand2.type is dict_type:
                    self.operand2 = self.operand2.as_none_safe_node("'NoneType' object is not iterable")
8444 8445
                common_type = py_object_type
                self.is_pycmp = True
8446 8447 8448 8449
        elif self.find_special_bool_compare_function(env):
            common_type = None # if coercion needed, the method call above has already done it
            self.is_pycmp = False # result is bint
            self.is_temp = True # must check for error return
8450 8451 8452 8453
        else:
            common_type = self.find_common_type(env, self.operator, self.operand1)
            self.is_pycmp = common_type.is_pyobject

8454
        if common_type is not None and not common_type.is_error:
8455 8456 8457
            if self.operand1.type != common_type:
                self.operand1 = self.operand1.coerce_to(common_type, env)
            self.coerce_operands_to(common_type, env)
8458

William Stein's avatar
William Stein committed
8459 8460 8461
        if self.cascade:
            self.operand2 = self.operand2.coerce_to_simple(env)
            self.cascade.coerce_cascaded_operands_to_temp(env)
8462 8463 8464 8465 8466 8467 8468 8469
        if self.is_python_result():
            self.type = PyrexTypes.py_object_type
        else:
            self.type = PyrexTypes.c_bint_type
        cdr = self.cascade
        while cdr:
            cdr.type = self.type
            cdr = cdr.cascade
William Stein's avatar
William Stein committed
8470 8471
        if self.is_pycmp or self.cascade:
            self.is_temp = 1
8472

8473 8474 8475
    def analyse_cpp_comparison(self, env):
        type1 = self.operand1.type
        type2 = self.operand2.type
8476 8477
        entry = env.lookup_operator(self.operator, [self.operand1, self.operand2])
        if entry is None:
8478 8479
            error(self.pos, "Invalid types for '%s' (%s, %s)" %
                (self.operator, type1, type2))
8480 8481 8482
            self.type = PyrexTypes.error_type
            self.result_code = "<error>"
            return
8483 8484 8485 8486 8487
        func_type = entry.type
        if func_type.is_ptr:
            func_type = func_type.base_type
        if len(func_type.args) == 1:
            self.operand2 = self.operand2.coerce_to(func_type.args[0].type, env)
8488
        else:
8489 8490 8491
            self.operand1 = self.operand1.coerce_to(func_type.args[0].type, env)
            self.operand2 = self.operand2.coerce_to(func_type.args[1].type, env)
        self.type = func_type.return_type
8492

William Stein's avatar
William Stein committed
8493 8494 8495
    def has_python_operands(self):
        return (self.operand1.type.is_pyobject
            or self.operand2.type.is_pyobject)
8496

William Stein's avatar
William Stein committed
8497 8498 8499
    def check_const(self):
        if self.cascade:
            self.not_const()
8500 8501 8502
            return False
        else:
            return self.operand1.check_const() and self.operand2.check_const()
William Stein's avatar
William Stein committed
8503 8504

    def calculate_result_code(self):
8505 8506 8507 8508 8509 8510 8511
        if self.operand1.type.is_complex:
            if self.operator == "!=":
                negation = "!"
            else:
                negation = ""
            return "(%s%s(%s, %s))" % (
                negation,
8512 8513
                self.operand1.type.binary_op('=='),
                self.operand1.result(),
8514
                self.operand2.result())
8515
        elif self.is_c_string_contains():
8516
            if self.operand2.type is unicode_type:
8517
                method = "__Pyx_UnicodeContainsUCS4"
8518
            else:
8519
                method = "__Pyx_BytesContains"
8520 8521 8522 8523 8524 8525 8526
            if self.operator == "not_in":
                negation = "!"
            else:
                negation = ""
            return "(%s%s(%s, %s))" % (
                negation,
                method,
8527
                self.operand2.result(),
8528
                self.operand1.result())
8529 8530 8531 8532 8533
        else:
            return "(%s %s %s)" % (
                self.operand1.result(),
                self.c_operator(self.operator),
                self.operand2.result())
8534

William Stein's avatar
William Stein committed
8535 8536 8537 8538
    def generate_evaluation_code(self, code):
        self.operand1.generate_evaluation_code(code)
        self.operand2.generate_evaluation_code(code)
        if self.is_temp:
8539
            self.allocate_temp_result(code)
8540
            self.generate_operation_code(code, self.result(),
William Stein's avatar
William Stein committed
8541 8542 8543
                self.operand1, self.operator, self.operand2)
            if self.cascade:
                self.cascade.generate_evaluation_code(code,
8544
                    self.result(), self.operand2)
William Stein's avatar
William Stein committed
8545
            self.operand1.generate_disposal_code(code)
8546
            self.operand1.free_temps(code)
William Stein's avatar
William Stein committed
8547
            self.operand2.generate_disposal_code(code)
8548
            self.operand2.free_temps(code)
8549

William Stein's avatar
William Stein committed
8550 8551 8552 8553 8554
    def generate_subexpr_disposal_code(self, code):
        #  If this is called, it is a non-cascaded cmp,
        #  so only need to dispose of the two main operands.
        self.operand1.generate_disposal_code(code)
        self.operand2.generate_disposal_code(code)
8555

8556 8557 8558 8559 8560
    def free_subexpr_temps(self, code):
        #  If this is called, it is a non-cascaded cmp,
        #  so only need to dispose of the two main operands.
        self.operand1.free_temps(code)
        self.operand2.free_temps(code)
8561

8562 8563 8564 8565 8566
    def annotate(self, code):
        self.operand1.annotate(code)
        self.operand2.annotate(code)
        if self.cascade:
            self.cascade.annotate(code)
William Stein's avatar
William Stein committed
8567 8568 8569


class CascadedCmpNode(Node, CmpNode):
8570 8571 8572
    #  A CascadedCmpNode is not a complete expression node. It
    #  hangs off the side of another comparison node, shares
    #  its left operand with that node, and shares its result
William Stein's avatar
William Stein committed
8573 8574 8575 8576 8577 8578
    #  with the PrimaryCmpNode at the head of the chain.
    #
    #  operator      string
    #  operand2      ExprNode
    #  cascade       CascadedCmpNode

Robert Bradshaw's avatar
Robert Bradshaw committed
8579 8580
    child_attrs = ['operand2', 'cascade']

William Stein's avatar
William Stein committed
8581
    cascade = None
8582 8583
    constant_result = constant_value_not_set # FIXME: where to calculate this?

Robert Bradshaw's avatar
Robert Bradshaw committed
8584 8585 8586 8587 8588 8589 8590
    def infer_type(self, env):
        # TODO: Actually implement this (after merging with -unstable).
        return py_object_type

    def type_dependencies(self, env):
        return ()

8591 8592 8593 8594
    def has_constant_result(self):
        return self.constant_result is not constant_value_not_set and \
               self.constant_result is not not_a_constant

8595
    def analyse_types(self, env):
William Stein's avatar
William Stein committed
8596 8597
        self.operand2.analyse_types(env)
        if self.cascade:
8598
            self.cascade.analyse_types(env)
8599

William Stein's avatar
William Stein committed
8600 8601
    def has_python_operands(self):
        return self.operand2.type.is_pyobject
8602

William Stein's avatar
William Stein committed
8603 8604
    def coerce_operands_to_pyobjects(self, env):
        self.operand2 = self.operand2.coerce_to_pyobject(env)
8605 8606
        if self.operand2.type is dict_type and self.operator in ('in', 'not_in'):
            self.operand2 = self.operand2.as_none_safe_node("'NoneType' object is not iterable")
William Stein's avatar
William Stein committed
8607 8608 8609 8610 8611 8612 8613 8614
        if self.cascade:
            self.cascade.coerce_operands_to_pyobjects(env)

    def coerce_cascaded_operands_to_temp(self, env):
        if self.cascade:
            #self.operand2 = self.operand2.coerce_to_temp(env) #CTT
            self.operand2 = self.operand2.coerce_to_simple(env)
            self.cascade.coerce_cascaded_operands_to_temp(env)
8615

William Stein's avatar
William Stein committed
8616
    def generate_evaluation_code(self, code, result, operand1):
8617 8618
        if self.type.is_pyobject:
            code.putln("if (__Pyx_PyObject_IsTrue(%s)) {" % result)
8619
            code.put_decref(result, self.type)
8620 8621
        else:
            code.putln("if (%s) {" % result)
William Stein's avatar
William Stein committed
8622
        self.operand2.generate_evaluation_code(code)
8623
        self.generate_operation_code(code, result,
William Stein's avatar
William Stein committed
8624 8625 8626 8627 8628 8629
            operand1, self.operator, self.operand2)
        if self.cascade:
            self.cascade.generate_evaluation_code(
                code, result, self.operand2)
        # Cascaded cmp result is always temp
        self.operand2.generate_disposal_code(code)
8630
        self.operand2.free_temps(code)
William Stein's avatar
William Stein committed
8631 8632
        code.putln("}")

8633 8634 8635 8636 8637
    def annotate(self, code):
        self.operand2.annotate(code)
        if self.cascade:
            self.cascade.annotate(code)

William Stein's avatar
William Stein committed
8638 8639

binop_node_classes = {
8640 8641
    "or":       BoolBinopNode,
    "and":      BoolBinopNode,
Robert Bradshaw's avatar
Robert Bradshaw committed
8642 8643 8644
    "|":        IntBinopNode,
    "^":        IntBinopNode,
    "&":        IntBinopNode,
8645 8646
    "<<":       IntBinopNode,
    ">>":       IntBinopNode,
Robert Bradshaw's avatar
Robert Bradshaw committed
8647 8648 8649
    "+":        AddNode,
    "-":        SubNode,
    "*":        MulNode,
8650 8651
    "/":        DivNode,
    "//":       DivNode,
Robert Bradshaw's avatar
Robert Bradshaw committed
8652
    "%":        ModNode,
8653
    "**":       PowNode
William Stein's avatar
William Stein committed
8654 8655
}

8656
def binop_node(pos, operator, operand1, operand2, inplace=False):
8657
    # Construct binop node of appropriate class for
William Stein's avatar
William Stein committed
8658
    # given operator.
8659 8660 8661
    return binop_node_classes[operator](pos,
        operator = operator,
        operand1 = operand1,
8662 8663
        operand2 = operand2,
        inplace = inplace)
William Stein's avatar
William Stein committed
8664 8665 8666 8667 8668 8669 8670 8671 8672 8673 8674 8675

#-------------------------------------------------------------------
#
#  Coercion nodes
#
#  Coercion nodes are special in that they are created during
#  the analyse_types phase of parse tree processing.
#  Their __init__ methods consequently incorporate some aspects
#  of that phase.
#
#-------------------------------------------------------------------

8676
class CoercionNode(ExprNode):
William Stein's avatar
William Stein committed
8677 8678 8679
    #  Abstract base class for coercion nodes.
    #
    #  arg       ExprNode       node being coerced
8680

William Stein's avatar
William Stein committed
8681
    subexprs = ['arg']
8682
    constant_result = not_a_constant
8683

William Stein's avatar
William Stein committed
8684 8685 8686 8687
    def __init__(self, arg):
        self.pos = arg.pos
        self.arg = arg
        if debug_coercion:
Stefan Behnel's avatar
Stefan Behnel committed
8688
            print("%s Coercing %s" % (self, self.arg))
8689 8690

    def calculate_constant_result(self):
8691 8692
        # constant folding can break type coercion, so this is disabled
        pass
8693

8694 8695 8696 8697 8698
    def annotate(self, code):
        self.arg.annotate(code)
        if self.arg.type != self.type:
            file, line, col = self.pos
            code.annotate((file, line, col-1), AnnotationItem(style='coerce', tag='coerce', text='[%s] to [%s]' % (self.arg.type, self.type)))
William Stein's avatar
William Stein committed
8699

8700
class CoerceToMemViewSliceNode(CoercionNode):
8701 8702

    def __init__(self, arg, dst_type, env):
8703 8704
        assert dst_type.is_memoryviewslice
        assert not arg.type.is_memoryviewslice
8705 8706
        CoercionNode.__init__(self, arg)
        self.type = dst_type
8707
        self.is_temp = 1
8708 8709
        self.env = env
        self.use_managed_ref = True
8710
        self.arg = arg
8711 8712

    def generate_result_code(self, code):
8713 8714 8715 8716 8717
        self.type.create_from_py_utility_code(self.env)
        code.putln("%s = %s(%s);" % (self.result(),
                                     self.type.from_py_function,
                                     self.arg.py_result()))

8718 8719 8720
        error_cond = self.type.error_condition(self.result())
        code.putln(code.error_goto_if(error_cond, self.pos))

William Stein's avatar
William Stein committed
8721 8722 8723

class CastNode(CoercionNode):
    #  Wrap a node in a C type cast.
8724

William Stein's avatar
William Stein committed
8725 8726 8727
    def __init__(self, arg, new_type):
        CoercionNode.__init__(self, arg)
        self.type = new_type
Stefan Behnel's avatar
Stefan Behnel committed
8728 8729 8730

    def may_be_none(self):
        return self.arg.may_be_none()
8731

William Stein's avatar
William Stein committed
8732 8733 8734 8735 8736 8737 8738 8739 8740 8741 8742 8743
    def calculate_result_code(self):
        return self.arg.result_as(self.type)

    def generate_result_code(self, code):
        self.arg.generate_result_code(code)


class PyTypeTestNode(CoercionNode):
    #  This node is used to check that a generic Python
    #  object is an instance of a particular extension type.
    #  This node borrows the result of its argument node.

8744
    def __init__(self, arg, dst_type, env, notnone=False):
William Stein's avatar
William Stein committed
8745 8746
        #  The arg is know to be a Python object, and
        #  the dst_type is known to be an extension type.
Robert Bradshaw's avatar
Robert Bradshaw committed
8747
        assert dst_type.is_extension_type or dst_type.is_builtin_type, "PyTypeTest on non extension type"
William Stein's avatar
William Stein committed
8748 8749 8750
        CoercionNode.__init__(self, arg)
        self.type = dst_type
        self.result_ctype = arg.ctype()
8751
        self.notnone = notnone
8752

8753
    nogil_check = Node.gil_error
8754
    gil_message = "Python type test"
8755

8756 8757
    def analyse_types(self, env):
        pass
Stefan Behnel's avatar
Stefan Behnel committed
8758 8759 8760 8761 8762

    def may_be_none(self):
        if self.notnone:
            return False
        return self.arg.may_be_none()
8763

8764 8765 8766
    def is_simple(self):
        return self.arg.is_simple()

William Stein's avatar
William Stein committed
8767 8768
    def result_in_temp(self):
        return self.arg.result_in_temp()
8769

William Stein's avatar
William Stein committed
8770 8771
    def is_ephemeral(self):
        return self.arg.is_ephemeral()
8772 8773 8774 8775 8776

    def calculate_constant_result(self):
        # FIXME
        pass

William Stein's avatar
William Stein committed
8777
    def calculate_result_code(self):
8778
        return self.arg.result()
8779

William Stein's avatar
William Stein committed
8780 8781
    def generate_result_code(self, code):
        if self.type.typeobj_is_available():
8782
            if not self.type.is_builtin_type:
8783
                code.globalstate.use_utility_code(type_test_utility_code)
William Stein's avatar
William Stein committed
8784
            code.putln(
Robert Bradshaw's avatar
Robert Bradshaw committed
8785
                "if (!(%s)) %s" % (
8786
                    self.type.type_test_code(self.arg.py_result(), self.notnone),
William Stein's avatar
William Stein committed
8787 8788 8789 8790
                    code.error_goto(self.pos)))
        else:
            error(self.pos, "Cannot test type of extern C class "
                "without type object name specification")
8791

William Stein's avatar
William Stein committed
8792 8793
    def generate_post_assignment_code(self, code):
        self.arg.generate_post_assignment_code(code)
8794 8795 8796

    def free_temps(self, code):
        self.arg.free_temps(code)
8797 8798 8799 8800 8801 8802 8803


class NoneCheckNode(CoercionNode):
    # This node is used to check that a Python object is not None and
    # raises an appropriate exception (as specified by the creating
    # transform).

8804 8805
    def __init__(self, arg, exception_type_cname, exception_message,
                 exception_format_args):
8806 8807 8808 8809 8810
        CoercionNode.__init__(self, arg)
        self.type = arg.type
        self.result_ctype = arg.ctype()
        self.exception_type_cname = exception_type_cname
        self.exception_message = exception_message
8811
        self.exception_format_args = tuple(exception_format_args or ())
8812 8813 8814 8815

    def analyse_types(self, env):
        pass

8816 8817 8818
    def may_be_none(self):
        return False

8819 8820 8821
    def is_simple(self):
        return self.arg.is_simple()

8822 8823 8824 8825 8826
    def result_in_temp(self):
        return self.arg.result_in_temp()

    def calculate_result_code(self):
        return self.arg.result()
8827

8828 8829
    def generate_result_code(self, code):
        code.putln(
8830
            "if (unlikely(%s == Py_None)) {" % self.arg.py_result())
8831 8832 8833 8834 8835 8836 8837 8838 8839 8840 8841 8842 8843 8844
        escape = StringEncoding.escape_byte_string
        if self.exception_format_args:
            code.putln('PyErr_Format(%s, "%s", %s); %s ' % (
                self.exception_type_cname,
                StringEncoding.escape_byte_string(
                    self.exception_message.encode('UTF-8')),
                ', '.join([ '"%s"' % escape(str(arg).encode('UTF-8'))
                            for arg in self.exception_format_args ]),
                code.error_goto(self.pos)))
        else:
            code.putln('PyErr_SetString(%s, "%s"); %s ' % (
                self.exception_type_cname,
                escape(self.exception_message.encode('UTF-8')),
                code.error_goto(self.pos)))
8845 8846 8847 8848 8849 8850 8851 8852
        code.putln("}")

    def generate_post_assignment_code(self, code):
        self.arg.generate_post_assignment_code(code)

    def free_temps(self, code):
        self.arg.free_temps(code)

8853

William Stein's avatar
William Stein committed
8854 8855 8856
class CoerceToPyTypeNode(CoercionNode):
    #  This node is used to convert a C data type
    #  to a Python object.
8857

8858
    type = py_object_type
Robert Bradshaw's avatar
Robert Bradshaw committed
8859
    is_temp = 1
William Stein's avatar
William Stein committed
8860

8861
    def __init__(self, arg, env, type=py_object_type):
8862
        if not arg.type.create_to_py_utility_code(env):
8863 8864 8865 8866 8867 8868 8869
            error(arg.pos, "Cannot convert '%s' to Python object" % arg.type)
        elif arg.type.is_complex:
            # special case: complex coercion is so complex that it
            # uses a macro ("__pyx_PyComplex_FromComplex()"), for
            # which the argument must be simple
            arg = arg.coerce_to_simple(env)
        CoercionNode.__init__(self, arg)
8870 8871 8872 8873
        if type is py_object_type:
            # be specific about some known types
            if arg.type.is_string:
                self.type = bytes_type
Stefan Behnel's avatar
Stefan Behnel committed
8874
            elif arg.type.is_unicode_char:
8875 8876 8877 8878 8879 8880
                self.type = unicode_type
            elif arg.type.is_complex:
                self.type = Builtin.complex_type
        else:
            # FIXME: check that the target type and the resulting type are compatible
            pass
8881

8882 8883 8884 8885
        if arg.type.is_memoryviewslice:
            # Register utility codes at this point
            arg.type.get_to_py_function(env, arg)

8886 8887
        self.env = env

8888
    gil_message = "Converting to Python object"
8889

8890 8891 8892 8893
    def may_be_none(self):
        # FIXME: is this always safe?
        return False

8894
    def coerce_to_boolean(self, env):
8895 8896 8897 8898 8899 8900
        arg_type = self.arg.type
        if (arg_type == PyrexTypes.c_bint_type or
            (arg_type.is_pyobject and arg_type.name == 'bool')):
            return self.arg.coerce_to_temp(env)
        else:
            return CoerceToBooleanNode(self, env)
8901

8902 8903 8904 8905 8906 8907
    def coerce_to_integer(self, env):
        # If not already some C integer type, coerce to longint.
        if self.arg.type.is_int:
            return self.arg
        else:
            return self.arg.coerce_to(PyrexTypes.c_long_type, env)
8908

8909 8910 8911 8912
    def analyse_types(self, env):
        # The arg is always already analysed
        pass

William Stein's avatar
William Stein committed
8913
    def generate_result_code(self, code):
8914
        if self.arg.type.is_memoryviewslice:
8915
            funccall = self.arg.type.get_to_py_function(self.env, self.arg)
8916 8917 8918 8919 8920
        else:
            funccall = "%s(%s)" % (self.arg.type.to_py_function,
                                   self.arg.result())

        code.putln('%s = %s; %s' % (
8921
            self.result(),
8922
            funccall,
8923
            code.error_goto_if_null(self.result(), self.pos)))
8924

8925
        code.put_gotref(self.py_result())
William Stein's avatar
William Stein committed
8926 8927


8928 8929 8930 8931 8932 8933 8934 8935 8936 8937 8938 8939 8940 8941 8942 8943 8944 8945 8946 8947 8948 8949 8950 8951 8952 8953 8954 8955 8956 8957 8958 8959 8960 8961 8962 8963 8964 8965 8966 8967
class CoerceIntToBytesNode(CoerceToPyTypeNode):
    #  This node is used to convert a C int type to a Python bytes
    #  object.

    is_temp = 1

    def __init__(self, arg, env):
        arg = arg.coerce_to_simple(env)
        CoercionNode.__init__(self, arg)
        self.type = Builtin.bytes_type

    def generate_result_code(self, code):
        arg = self.arg
        arg_result = arg.result()
        if arg.type not in (PyrexTypes.c_char_type,
                            PyrexTypes.c_uchar_type,
                            PyrexTypes.c_schar_type):
            if arg.type.signed:
                code.putln("if ((%s < 0) || (%s > 255)) {" % (
                    arg_result, arg_result))
            else:
                code.putln("if (%s > 255) {" % arg_result)
            code.putln('PyErr_Format(PyExc_OverflowError, '
                       '"value too large to pack into a byte"); %s' % (
                           code.error_goto(self.pos)))
            code.putln('}')
        temp = None
        if arg.type is not PyrexTypes.c_char_type:
            temp = code.funcstate.allocate_temp(PyrexTypes.c_char_type, manage_ref=False)
            code.putln("%s = (char)%s;" % (temp, arg_result))
            arg_result = temp
        code.putln('%s = PyBytes_FromStringAndSize(&%s, 1); %s' % (
            self.result(),
            arg_result,
            code.error_goto_if_null(self.result(), self.pos)))
        if temp is not None:
            code.funcstate.release_temp(temp)
        code.put_gotref(self.py_result())


William Stein's avatar
William Stein committed
8968 8969 8970 8971 8972 8973 8974 8975
class CoerceFromPyTypeNode(CoercionNode):
    #  This node is used to convert a Python object
    #  to a C data type.

    def __init__(self, result_type, arg, env):
        CoercionNode.__init__(self, arg)
        self.type = result_type
        self.is_temp = 1
8976
        if not result_type.create_from_py_utility_code(env):
William Stein's avatar
William Stein committed
8977
            error(arg.pos,
Craig Citro's avatar
Craig Citro committed
8978
                  "Cannot convert Python object to '%s'" % result_type)
William Stein's avatar
William Stein committed
8979 8980
        if self.type.is_string and self.arg.is_ephemeral():
            error(arg.pos,
Craig Citro's avatar
Craig Citro committed
8981
                  "Obtaining char * from temporary Python value")
8982

8983 8984 8985 8986
    def analyse_types(self, env):
        # The arg is always already analysed
        pass

William Stein's avatar
William Stein committed
8987 8988
    def generate_result_code(self, code):
        function = self.type.from_py_function
8989 8990 8991 8992
        operand = self.arg.py_result()
        rhs = "%s(%s)" % (function, operand)
        if self.type.is_enum:
            rhs = typecast(self.type, c_long_type, rhs)
Robert Bradshaw's avatar
Robert Bradshaw committed
8993
        code.putln('%s = %s; %s' % (
8994
            self.result(),
8995
            rhs,
8996
            code.error_goto_if(self.type.error_condition(self.result()), self.pos)))
8997
        if self.type.is_pyobject:
8998
            code.put_gotref(self.py_result())
William Stein's avatar
William Stein committed
8999

9000 9001 9002
    def nogil_check(self, env):
        error(self.pos, "Coercion from Python not allowed without the GIL")

William Stein's avatar
William Stein committed
9003 9004 9005 9006

class CoerceToBooleanNode(CoercionNode):
    #  This node is used when a result needs to be used
    #  in a boolean context.
9007

9008
    type = PyrexTypes.c_bint_type
9009 9010 9011 9012

    _special_builtins = {
        Builtin.list_type    : 'PyList_GET_SIZE',
        Builtin.tuple_type   : 'PyTuple_GET_SIZE',
9013
        Builtin.bytes_type   : 'PyBytes_GET_SIZE',
9014 9015 9016
        Builtin.unicode_type : 'PyUnicode_GET_SIZE',
        }

William Stein's avatar
William Stein committed
9017 9018 9019 9020
    def __init__(self, arg, env):
        CoercionNode.__init__(self, arg)
        if arg.type.is_pyobject:
            self.is_temp = 1
9021

9022
    def nogil_check(self, env):
9023
        if self.arg.type.is_pyobject and self._special_builtins.get(self.arg.type) is None:
9024
            self.gil_error()
9025

9026
    gil_message = "Truth-testing Python object"
9027

William Stein's avatar
William Stein committed
9028 9029 9030
    def check_const(self):
        if self.is_temp:
            self.not_const()
9031 9032
            return False
        return self.arg.check_const()
9033

William Stein's avatar
William Stein committed
9034
    def calculate_result_code(self):
9035
        return "(%s != 0)" % self.arg.result()
William Stein's avatar
William Stein committed
9036 9037

    def generate_result_code(self, code):
9038 9039 9040 9041
        if not self.is_temp:
            return
        test_func = self._special_builtins.get(self.arg.type)
        if test_func is not None:
Stefan Behnel's avatar
Stefan Behnel committed
9042
            code.putln("%s = (%s != Py_None) && (%s(%s) != 0);" % (
9043 9044 9045 9046 9047
                       self.result(),
                       self.arg.py_result(),
                       test_func,
                       self.arg.py_result()))
        else:
William Stein's avatar
William Stein committed
9048
            code.putln(
9049
                "%s = __Pyx_PyObject_IsTrue(%s); %s" % (
9050 9051
                    self.result(),
                    self.arg.py_result(),
9052
                    code.error_goto_if_neg(self.result(), self.pos)))
William Stein's avatar
William Stein committed
9053

9054 9055 9056 9057 9058 9059 9060 9061 9062 9063 9064
class CoerceToComplexNode(CoercionNode):

    def __init__(self, arg, dst_type, env):
        if arg.type.is_complex:
            arg = arg.coerce_to_simple(env)
        self.type = dst_type
        CoercionNode.__init__(self, arg)
        dst_type.create_declaration_utility_code(env)

    def calculate_result_code(self):
        if self.arg.type.is_complex:
9065 9066
            real_part = "__Pyx_CREAL(%s)" % self.arg.result()
            imag_part = "__Pyx_CIMAG(%s)" % self.arg.result()
9067 9068 9069 9070 9071 9072 9073
        else:
            real_part = self.arg.result()
            imag_part = "0"
        return "%s(%s, %s)" % (
                self.type.from_parts,
                real_part,
                imag_part)
9074

9075 9076
    def generate_result_code(self, code):
        pass
William Stein's avatar
William Stein committed
9077 9078 9079 9080 9081 9082 9083 9084 9085

class CoerceToTempNode(CoercionNode):
    #  This node is used to force the result of another node
    #  to be stored in a temporary. It is only used if the
    #  argument node's result is not already in a temporary.

    def __init__(self, arg, env):
        CoercionNode.__init__(self, arg)
        self.type = self.arg.type
9086
        self.constant_result = self.arg.constant_result
William Stein's avatar
William Stein committed
9087 9088 9089
        self.is_temp = 1
        if self.type.is_pyobject:
            self.result_ctype = py_object_type
9090 9091 9092

    gil_message = "Creating temporary Python reference"

9093 9094 9095
    def analyse_types(self, env):
        # The arg is always already analysed
        pass
9096

9097 9098
    def coerce_to_boolean(self, env):
        self.arg = self.arg.coerce_to_boolean(env)
9099 9100
        if self.arg.is_simple():
            return self.arg
9101 9102 9103
        self.type = self.arg.type
        self.result_ctype = self.type
        return self
9104

William Stein's avatar
William Stein committed
9105 9106 9107 9108
    def generate_result_code(self, code):
        #self.arg.generate_evaluation_code(code) # Already done
        # by generic generate_subexpr_evaluation_code!
        code.putln("%s = %s;" % (
9109
            self.result(), self.arg.result_as(self.ctype())))
9110
        if self.type.is_pyobject and self.use_managed_ref:
9111
            code.put_incref(self.result(), self.ctype())
William Stein's avatar
William Stein committed
9112 9113 9114 9115 9116 9117 9118


class CloneNode(CoercionNode):
    #  This node is employed when the result of another node needs
    #  to be used multiple times. The argument node's result must
    #  be in a temporary. This node "borrows" the result from the
    #  argument node, and does not generate any evaluation or
9119
    #  disposal code for it. The original owner of the argument
William Stein's avatar
William Stein committed
9120
    #  node is responsible for doing those things.
9121

William Stein's avatar
William Stein committed
9122
    subexprs = [] # Arg is not considered a subexpr
9123
    nogil_check = None
9124

William Stein's avatar
William Stein committed
9125 9126
    def __init__(self, arg):
        CoercionNode.__init__(self, arg)
9127 9128 9129 9130 9131
        if hasattr(arg, 'type'):
            self.type = arg.type
            self.result_ctype = arg.result_ctype
        if hasattr(arg, 'entry'):
            self.entry = arg.entry
9132

9133
    def result(self):
9134
        return self.arg.result()
9135

9136 9137 9138
    def may_be_none(self):
        return self.arg.may_be_none()

Robert Bradshaw's avatar
Robert Bradshaw committed
9139 9140
    def type_dependencies(self, env):
        return self.arg.type_dependencies(env)
9141

9142 9143
    def infer_type(self, env):
        return self.arg.infer_type(env)
Robert Bradshaw's avatar
Robert Bradshaw committed
9144

Robert Bradshaw's avatar
Robert Bradshaw committed
9145 9146 9147 9148
    def analyse_types(self, env):
        self.type = self.arg.type
        self.result_ctype = self.arg.result_ctype
        self.is_temp = 1
9149 9150
        if hasattr(self.arg, 'entry'):
            self.entry = self.arg.entry
9151

9152 9153 9154
    def is_simple(self):
        return True # result is always in a temp (or a name)

William Stein's avatar
William Stein committed
9155 9156 9157 9158 9159
    def generate_evaluation_code(self, code):
        pass

    def generate_result_code(self, code):
        pass
9160

9161
    def generate_disposal_code(self, code):
9162
        pass
9163

9164 9165
    def free_temps(self, code):
        pass
9166

9167

Stefan Behnel's avatar
Stefan Behnel committed
9168 9169 9170 9171 9172 9173 9174 9175 9176 9177 9178 9179
class CMethodSelfCloneNode(CloneNode):
    # Special CloneNode for the self argument of builtin C methods
    # that accepts subtypes of the builtin type.  This is safe only
    # for 'final' subtypes, as subtypes of the declared type may
    # override the C method.

    def coerce_to(self, dst_type, env):
        if dst_type.is_builtin_type and self.type.subtype_of(dst_type):
            return self
        return CloneNode.coerce_to(self, dst_type, env)


9180 9181
class ModuleRefNode(ExprNode):
    # Simple returns the module object
9182

9183 9184 9185
    type = py_object_type
    is_temp = False
    subexprs = []
9186

9187 9188 9189
    def analyse_types(self, env):
        pass

9190 9191 9192
    def may_be_none(self):
        return False

9193 9194 9195 9196 9197 9198 9199 9200
    def calculate_result_code(self):
        return Naming.module_cname

    def generate_result_code(self, code):
        pass

class DocstringRefNode(ExprNode):
    # Extracts the docstring of the body element
9201

9202 9203 9204
    subexprs = ['body']
    type = py_object_type
    is_temp = True
9205

9206 9207 9208 9209 9210 9211 9212 9213 9214
    def __init__(self, pos, body):
        ExprNode.__init__(self, pos)
        assert body.type.is_pyobject
        self.body = body

    def analyse_types(self, env):
        pass

    def generate_result_code(self, code):
9215 9216 9217
        code.putln('%s = __Pyx_GetAttrString(%s, "__doc__"); %s' % (
            self.result(), self.body.result(),
            code.error_goto_if_null(self.result(), self.pos)))
9218 9219 9220 9221
        code.put_gotref(self.result())



William Stein's avatar
William Stein committed
9222 9223 9224 9225 9226 9227
#------------------------------------------------------------------------------------
#
#  Runtime support code
#
#------------------------------------------------------------------------------------

9228 9229
get_name_interned_utility_code = UtilityCode(
proto = """
9230
static PyObject *__Pyx_GetName(PyObject *dict, PyObject *name); /*proto*/
9231 9232
""",
impl = """
William Stein's avatar
William Stein committed
9233 9234 9235
static PyObject *__Pyx_GetName(PyObject *dict, PyObject *name) {
    PyObject *result;
    result = PyObject_GetAttr(dict, name);
9236 9237 9238 9239 9240 9241 9242 9243 9244
    if (!result) {
        if (dict != %(BUILTINS)s) {
            PyErr_Clear();
            result = PyObject_GetAttr(%(BUILTINS)s, name);
        }
        if (!result) {
            PyErr_SetObject(PyExc_NameError, name);
        }
    }
William Stein's avatar
William Stein committed
9245 9246
    return result;
}
9247
""" % {'BUILTINS' : Naming.builtins_cname})
William Stein's avatar
William Stein committed
9248 9249 9250

#------------------------------------------------------------------------------------

9251 9252
import_utility_code = UtilityCode(
proto = """
Haoyu Bai's avatar
Haoyu Bai committed
9253
static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, long level); /*proto*/
9254 9255
""",
impl = """
Haoyu Bai's avatar
Haoyu Bai committed
9256
static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, long level) {
9257
    PyObject *py_import = 0;
William Stein's avatar
William Stein committed
9258 9259 9260 9261 9262
    PyObject *empty_list = 0;
    PyObject *module = 0;
    PyObject *global_dict = 0;
    PyObject *empty_dict = 0;
    PyObject *list;
9263 9264
    py_import = __Pyx_GetAttrString(%(BUILTINS)s, "__import__");
    if (!py_import)
William Stein's avatar
William Stein committed
9265 9266 9267 9268 9269 9270 9271 9272 9273 9274 9275 9276 9277 9278 9279
        goto bad;
    if (from_list)
        list = from_list;
    else {
        empty_list = PyList_New(0);
        if (!empty_list)
            goto bad;
        list = empty_list;
    }
    global_dict = PyModule_GetDict(%(GLOBALS)s);
    if (!global_dict)
        goto bad;
    empty_dict = PyDict_New();
    if (!empty_dict)
        goto bad;
Haoyu Bai's avatar
Haoyu Bai committed
9280 9281 9282 9283 9284 9285 9286 9287 9288 9289 9290 9291 9292 9293
    #if PY_VERSION_HEX >= 0x02050000
    {
        PyObject *py_level = PyInt_FromLong(level);
        if (!py_level)
            goto bad;
        module = PyObject_CallFunctionObjArgs(py_import,
            name, global_dict, empty_dict, list, py_level, NULL);
        Py_DECREF(py_level);
    }
    #else
    if (level>0) {
        PyErr_SetString(PyExc_RuntimeError, "Relative import is not supported for Python <=2.4.");
        goto bad;
    }
9294
    module = PyObject_CallFunctionObjArgs(py_import,
9295
        name, global_dict, empty_dict, list, NULL);
Haoyu Bai's avatar
Haoyu Bai committed
9296
    #endif
William Stein's avatar
William Stein committed
9297 9298
bad:
    Py_XDECREF(empty_list);
9299
    Py_XDECREF(py_import);
William Stein's avatar
William Stein committed
9300 9301 9302 9303 9304 9305
    Py_XDECREF(empty_dict);
    return module;
}
""" % {
    "BUILTINS": Naming.builtins_cname,
    "GLOBALS":  Naming.module_cname,
9306
})
William Stein's avatar
William Stein committed
9307 9308 9309

#------------------------------------------------------------------------------------

9310 9311
get_exception_utility_code = UtilityCode(
proto = """
9312
static PyObject *__Pyx_GetExcValue(void); /*proto*/
9313 9314
""",
impl = """
William Stein's avatar
William Stein committed
9315 9316
static PyObject *__Pyx_GetExcValue(void) {
    PyObject *type = 0, *value = 0, *tb = 0;
9317
    PyObject *tmp_type, *tmp_value, *tmp_tb;
William Stein's avatar
William Stein committed
9318 9319 9320 9321 9322 9323 9324 9325 9326 9327
    PyObject *result = 0;
    PyThreadState *tstate = PyThreadState_Get();
    PyErr_Fetch(&type, &value, &tb);
    PyErr_NormalizeException(&type, &value, &tb);
    if (PyErr_Occurred())
        goto bad;
    if (!value) {
        value = Py_None;
        Py_INCREF(value);
    }
9328 9329 9330
    tmp_type = tstate->exc_type;
    tmp_value = tstate->exc_value;
    tmp_tb = tstate->exc_traceback;
William Stein's avatar
William Stein committed
9331 9332 9333
    tstate->exc_type = type;
    tstate->exc_value = value;
    tstate->exc_traceback = tb;
9334 9335 9336 9337 9338
    /* Make sure tstate is in a consistent state when we XDECREF
    these objects (XDECREF may run arbitrary code). */
    Py_XDECREF(tmp_type);
    Py_XDECREF(tmp_value);
    Py_XDECREF(tmp_tb);
William Stein's avatar
William Stein committed
9339 9340 9341 9342 9343 9344 9345 9346 9347 9348 9349
    result = value;
    Py_XINCREF(result);
    type = 0;
    value = 0;
    tb = 0;
bad:
    Py_XDECREF(type);
    Py_XDECREF(value);
    Py_XDECREF(tb);
    return result;
}
9350
""")
William Stein's avatar
William Stein committed
9351 9352 9353

#------------------------------------------------------------------------------------

9354 9355
type_test_utility_code = UtilityCode(
proto = """
9356
static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type); /*proto*/
9357 9358
""",
impl = """
9359
static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type) {
9360
    if (unlikely(!type)) {
William Stein's avatar
William Stein committed
9361 9362 9363
        PyErr_Format(PyExc_SystemError, "Missing type object");
        return 0;
    }
9364
    if (likely(PyObject_TypeCheck(obj, type)))
William Stein's avatar
William Stein committed
9365
        return 1;
9366 9367
    PyErr_Format(PyExc_TypeError, "Cannot convert %.200s to %.200s",
                 Py_TYPE(obj)->tp_name, type->tp_name);
William Stein's avatar
William Stein committed
9368 9369
    return 0;
}
9370
""")
William Stein's avatar
William Stein committed
9371 9372 9373

#------------------------------------------------------------------------------------

9374 9375 9376 9377 9378 9379 9380 9381 9382 9383 9384
find_py2_metaclass_utility_code = UtilityCode(
proto = '''
static PyObject *__Pyx_FindPy2Metaclass(PyObject *bases); /*proto*/
''',
impl = '''
static PyObject *__Pyx_FindPy2Metaclass(PyObject *bases) {
    PyObject *metaclass;
    /* Default metaclass */
#if PY_MAJOR_VERSION < 3
    if (PyTuple_Check(bases) && PyTuple_GET_SIZE(bases) > 0) {
        PyObject *base = PyTuple_GET_ITEM(bases, 0);
9385
        metaclass = PyObject_GetAttrString(base, (char *)"__class__");
9386 9387 9388 9389 9390 9391 9392 9393 9394 9395 9396 9397 9398 9399 9400 9401 9402 9403 9404 9405
        if (!metaclass) {
            PyErr_Clear();
            metaclass = (PyObject*) Py_TYPE(base);
        }
    } else {
        metaclass = (PyObject *) &PyClass_Type;
    }
#else
    if (PyTuple_Check(bases) && PyTuple_GET_SIZE(bases) > 0) {
        PyObject *base = PyTuple_GET_ITEM(bases, 0);
        metaclass = (PyObject*) Py_TYPE(base);
    } else {
        metaclass = (PyObject *) &PyType_Type;
    }
#endif
    Py_INCREF(metaclass);
    return metaclass;
}
''')

9406 9407
create_class_utility_code = UtilityCode(
proto = """
9408
static PyObject *__Pyx_CreateClass(PyObject *bases, PyObject *dict, PyObject *name,
9409 9410 9411 9412 9413
                                   PyObject *modname); /*proto*/
""",
impl = """
static PyObject *__Pyx_CreateClass(PyObject *bases, PyObject *dict, PyObject *name,
                                   PyObject *modname) {
9414 9415
    PyObject *result;
    PyObject *metaclass;
9416 9417 9418 9419 9420 9421

    if (PyDict_SetItemString(dict, "__module__", modname) < 0)
        return NULL;

    /* Python2 __metaclass__ */
    metaclass = PyDict_GetItemString(dict, "__metaclass__");
9422 9423 9424 9425
    if (metaclass) {
        Py_INCREF(metaclass);
    } else {
        metaclass = __Pyx_FindPy2Metaclass(bases);
9426 9427 9428 9429 9430
    }
    result = PyObject_CallFunctionObjArgs(metaclass, name, bases, dict, NULL);
    Py_DECREF(metaclass);
    return result;
}
9431 9432
""",
requires = [find_py2_metaclass_utility_code])
9433 9434 9435 9436 9437

#------------------------------------------------------------------------------------

create_py3class_utility_code = UtilityCode(
proto = """
Stefan Behnel's avatar
Stefan Behnel committed
9438 9439 9440
static PyObject *__Pyx_Py3MetaclassGet(PyObject *bases, PyObject *mkw); /*proto*/
static PyObject *__Pyx_Py3MetaclassPrepare(PyObject *metaclass, PyObject *bases, PyObject *name, PyObject *mkw, PyObject *modname, PyObject *doc); /*proto*/
static PyObject *__Pyx_Py3ClassCreate(PyObject *metaclass, PyObject *name, PyObject *bases, PyObject *dict, PyObject *mkw); /*proto*/
9441 9442
""",
impl = """
Stefan Behnel's avatar
Stefan Behnel committed
9443
PyObject *__Pyx_Py3MetaclassGet(PyObject *bases, PyObject *mkw) {
9444
    PyObject *metaclass = PyDict_GetItemString(mkw, "metaclass");
9445 9446 9447 9448 9449 9450 9451 9452
    if (metaclass) {
        Py_INCREF(metaclass);
        if (PyDict_DelItemString(mkw, "metaclass") < 0) {
            Py_DECREF(metaclass);
            return NULL;
        }
        return metaclass;
    }
9453
    return __Pyx_FindPy2Metaclass(bases);
9454 9455
}

Stefan Behnel's avatar
Stefan Behnel committed
9456 9457
PyObject *__Pyx_Py3MetaclassPrepare(PyObject *metaclass, PyObject *bases, PyObject *name, PyObject *mkw,
                                    PyObject *modname, PyObject *doc) {
9458 9459 9460
    PyObject *prep;
    PyObject *pargs;
    PyObject *ns;
9461
    PyObject *str;
9462

9463
    prep = PyObject_GetAttrString(metaclass, (char *)"__prepare__");
Stefan Behnel's avatar
Stefan Behnel committed
9464
    if (!prep) {
9465
        if (!PyErr_ExceptionMatches(PyExc_AttributeError))
9466
            return NULL;
9467
        PyErr_Clear();
9468
        return PyDict_New();
9469
    }
Stefan Behnel's avatar
Stefan Behnel committed
9470 9471
    pargs = PyTuple_New(2);
    if (!pargs) {
9472
        Py_DECREF(prep);
9473
        return NULL;
9474
    }
9475

Stefan Behnel's avatar
Stefan Behnel committed
9476 9477 9478 9479
    Py_INCREF(name);
    Py_INCREF(bases);
    PyTuple_SET_ITEM(pargs, 0, name);
    PyTuple_SET_ITEM(pargs, 1, bases);
9480

Stefan Behnel's avatar
Stefan Behnel committed
9481
    ns = PyObject_Call(prep, pargs, mkw);
9482

9483
    Py_DECREF(prep);
9484 9485
    Py_DECREF(pargs);

9486
    if (ns == NULL)
9487 9488 9489 9490
        return NULL;

    /* Required here to emulate assignment order */
    /* XXX: use consts here */
Stefan Behnel's avatar
Stefan Behnel committed
9491 9492 9493
    #if PY_MAJOR_VERSION >= 3
    str = PyUnicode_FromString("__module__");
    #else
9494
    str = PyString_FromString("__module__");
Stefan Behnel's avatar
Stefan Behnel committed
9495
    #endif
9496
    if (!str) {
9497
        Py_DECREF(ns);
9498
        return NULL;
9499
    }
Vitja Makarov's avatar
Vitja Makarov committed
9500

9501 9502 9503
    if (PyObject_SetItem(ns, str, modname) < 0) {
        Py_DECREF(ns);
        Py_DECREF(str);
9504
        return NULL;
9505 9506 9507
    }
    Py_DECREF(str);
    if (doc) {
Stefan Behnel's avatar
Stefan Behnel committed
9508 9509 9510
        #if PY_MAJOR_VERSION >= 3
        str = PyUnicode_FromString("__doc__");
        #else
9511
        str = PyString_FromString("__doc__");
Stefan Behnel's avatar
Stefan Behnel committed
9512
        #endif
9513 9514
        if (!str) {
            Py_DECREF(ns);
9515
            return NULL;
Vitja Makarov's avatar
Vitja Makarov committed
9516
        }
9517 9518 9519 9520
        if (PyObject_SetItem(ns, str, doc) < 0) {
            Py_DECREF(ns);
            Py_DECREF(str);
            return NULL;
Stefan Behnel's avatar
Stefan Behnel committed
9521
        }
9522
        Py_DECREF(str);
Vitja Makarov's avatar
Vitja Makarov committed
9523
    }
9524 9525 9526
    return ns;
}

Stefan Behnel's avatar
Stefan Behnel committed
9527
PyObject *__Pyx_Py3ClassCreate(PyObject *metaclass, PyObject *name, PyObject *bases, PyObject *dict, PyObject *mkw) {
9528
    PyObject *result;
9529
    PyObject *margs = PyTuple_New(3);
9530 9531
    if (!margs)
        return NULL;
9532 9533 9534 9535 9536 9537
    Py_INCREF(name);
    Py_INCREF(bases);
    Py_INCREF(dict);
    PyTuple_SET_ITEM(margs, 0, name);
    PyTuple_SET_ITEM(margs, 1, bases);
    PyTuple_SET_ITEM(margs, 2, dict);
Stefan Behnel's avatar
Stefan Behnel committed
9538
    result = PyObject_Call(metaclass, margs, mkw);
9539
    Py_DECREF(margs);
William Stein's avatar
William Stein committed
9540 9541
    return result;
}
9542 9543
""",
requires = [find_py2_metaclass_utility_code])
William Stein's avatar
William Stein committed
9544 9545

#------------------------------------------------------------------------------------
Robert Bradshaw's avatar
Robert Bradshaw committed
9546

9547 9548
cpp_exception_utility_code = UtilityCode(
proto = """
9549 9550
#ifndef __Pyx_CppExn2PyErr
static void __Pyx_CppExn2PyErr() {
9551 9552
  // Catch a handful of different errors here and turn them into the
  // equivalent Python errors.
Robert Bradshaw's avatar
Robert Bradshaw committed
9553 9554 9555 9556 9557
  try {
    if (PyErr_Occurred())
      ; // let the latest Python exn pass through and ignore the current one
    else
      throw;
9558 9559
  } catch (const std::bad_alloc& exn) {
    PyErr_SetString(PyExc_MemoryError, exn.what());
9560 9561
  } catch (const std::bad_cast& exn) {
    PyErr_SetString(PyExc_TypeError, exn.what());
9562 9563
  } catch (const std::domain_error& exn) {
    PyErr_SetString(PyExc_ValueError, exn.what());
9564 9565
  } catch (const std::invalid_argument& exn) {
    PyErr_SetString(PyExc_ValueError, exn.what());
9566 9567 9568 9569
  } catch (const std::ios_base::failure& exn) {
    // Unfortunately, in standard C++ we have no way of distinguishing EOF
    // from other errors here; be careful with the exception mask
    PyErr_SetString(PyExc_IOError, exn.what());
Robert Bradshaw's avatar
Robert Bradshaw committed
9570
  } catch (const std::out_of_range& exn) {
9571
    // Change out_of_range to IndexError
Robert Bradshaw's avatar
Robert Bradshaw committed
9572
    PyErr_SetString(PyExc_IndexError, exn.what());
9573 9574 9575 9576 9577 9578
  } catch (const std::overflow_error& exn) {
    PyErr_SetString(PyExc_OverflowError, exn.what());
  } catch (const std::range_error& exn) {
    PyErr_SetString(PyExc_ArithmeticError, exn.what());
  } catch (const std::underflow_error& exn) {
    PyErr_SetString(PyExc_ArithmeticError, exn.what());
Robert Bradshaw's avatar
Robert Bradshaw committed
9579 9580 9581 9582 9583 9584 9585 9586
  } catch (const std::exception& exn) {
    PyErr_SetString(PyExc_RuntimeError, exn.what());
  }
  catch (...)
  {
    PyErr_SetString(PyExc_RuntimeError, "Unknown exception");
  }
}
9587
#endif
9588 9589 9590
""",
impl = ""
)
Robert Bradshaw's avatar
Robert Bradshaw committed
9591

9592 9593 9594 9595 9596 9597 9598 9599 9600 9601 9602 9603 9604 9605 9606 9607 9608 9609 9610
pyerr_occurred_withgil_utility_code= UtilityCode(
proto = """
static CYTHON_INLINE int __Pyx_ErrOccurredWithGIL(void); /* proto */
""",
impl = """
static CYTHON_INLINE int __Pyx_ErrOccurredWithGIL(void) {
  int err;
  #ifdef WITH_THREAD
  PyGILState_STATE _save = PyGILState_Ensure();
  #endif
  err = !!PyErr_Occurred();
  #ifdef WITH_THREAD
  PyGILState_Release(_save);
  #endif
  return err;
}
"""
)

Robert Bradshaw's avatar
Robert Bradshaw committed
9611
#------------------------------------------------------------------------------------
Robert Bradshaw's avatar
Robert Bradshaw committed
9612

9613 9614 9615 9616 9617 9618 9619 9620 9621 9622 9623 9624 9625 9626 9627 9628 9629 9630 9631 9632 9633 9634 9635 9636 9637 9638 9639 9640 9641 9642
raise_noneattr_error_utility_code = UtilityCode(
proto = """
static CYTHON_INLINE void __Pyx_RaiseNoneAttributeError(const char* attrname);
""",
impl = '''
static CYTHON_INLINE void __Pyx_RaiseNoneAttributeError(const char* attrname) {
    PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", attrname);
}
''')

raise_noneindex_error_utility_code = UtilityCode(
proto = """
static CYTHON_INLINE void __Pyx_RaiseNoneIndexingError(void);
""",
impl = '''
static CYTHON_INLINE void __Pyx_RaiseNoneIndexingError(void) {
    PyErr_SetString(PyExc_TypeError, "'NoneType' object is unsubscriptable");
}
''')

raise_none_iter_error_utility_code = UtilityCode(
proto = """
static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void);
""",
impl = '''
static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void) {
    PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable");
}
''')

9643 9644 9645 9646 9647 9648 9649 9650 9651 9652 9653 9654 9655 9656 9657 9658 9659 9660 9661 9662
raise_unbound_local_error_utility_code = UtilityCode(
proto = """
static CYTHON_INLINE void __Pyx_RaiseUnboundLocalError(const char *varname);
""",
impl = """
static CYTHON_INLINE void __Pyx_RaiseUnboundLocalError(const char *varname) {
    PyErr_Format(PyExc_UnboundLocalError, "local variable '%s' referenced before assignment", varname);
}
""")

raise_closure_name_error_utility_code = UtilityCode(
proto = """
static CYTHON_INLINE void __Pyx_RaiseClosureNameError(const char *varname);
""",
impl = """
static CYTHON_INLINE void __Pyx_RaiseClosureNameError(const char *varname) {
    PyErr_Format(PyExc_NameError, "free variable '%s' referenced before assignment in enclosing scope", varname);
}
""")

9663 9664 9665 9666
#------------------------------------------------------------------------------------

getitem_dict_utility_code = UtilityCode(
proto = """
9667
#if PY_MAJOR_VERSION >= 3
9668
static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key) {
9669
    PyObject *value;
9670
    if (unlikely(d == Py_None)) {
9671 9672 9673
        __Pyx_RaiseNoneIndexingError();
        return NULL;
    }
9674 9675 9676
    value = PyDict_GetItemWithError(d, key);
    if (unlikely(!value)) {
        if (!PyErr_Occurred())
9677
            PyErr_SetObject(PyExc_KeyError, key);
9678
        return NULL;
9679
    }
9680 9681
    Py_INCREF(value);
    return value;
9682
}
9683 9684 9685
#else
    #define __Pyx_PyDict_GetItem(d, key) PyObject_GetItem(d, key)
#endif
9686
""",
9687 9688 9689
requires = [raise_noneindex_error_utility_code])

#------------------------------------------------------------------------------------
Dag Sverre Seljebotn's avatar
Merge  
Dag Sverre Seljebotn committed
9690

9691 9692 9693 9694
getitem_int_pyunicode_utility_code = UtilityCode(
proto = '''
#define __Pyx_GetItemInt_Unicode(o, i, size, to_py_func) (((size) <= sizeof(Py_ssize_t)) ? \\
                                               __Pyx_GetItemInt_Unicode_Fast(o, i) : \\
Stefan Behnel's avatar
Stefan Behnel committed
9695
                                               __Pyx_GetItemInt_Unicode_Generic(o, to_py_func(i)))
9696

9697
static CYTHON_INLINE Py_UCS4 __Pyx_GetItemInt_Unicode_Fast(PyObject* ustring, Py_ssize_t i) {
9698 9699 9700 9701 9702
    const Py_ssize_t length = __Pyx_PyUnicode_GET_LENGTH(ustring);
    if (likely((0 <= i) & (i < length))) {
        return __Pyx_PyUnicode_READ_CHAR(ustring, i);
    } else if ((-length <= i) & (i < 0)) {
        return __Pyx_PyUnicode_READ_CHAR(ustring, i + length);
9703 9704
    } else {
        PyErr_SetString(PyExc_IndexError, "string index out of range");
9705
        return (Py_UCS4)-1;
9706 9707 9708
    }
}

9709 9710
static CYTHON_INLINE Py_UCS4 __Pyx_GetItemInt_Unicode_Generic(PyObject* ustring, PyObject* j) {
    Py_UCS4 uchar;
9711
    PyObject *uchar_string;
9712
    if (!j) return (Py_UCS4)-1;
9713
    uchar_string = PyObject_GetItem(ustring, j);
9714
    Py_DECREF(j);
9715
    if (!uchar_string) return (Py_UCS4)-1;
9716
    uchar = __Pyx_PyUnicode_READ_CHAR(uchar_string, 0);
9717
    Py_DECREF(uchar_string);
9718 9719
    return uchar;
}
9720
''')
9721

9722 9723
getitem_int_utility_code = UtilityCode(
proto = """
9724

9725
static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j) {
9726
    PyObject *r;
9727
    if (!j) return NULL;
9728 9729 9730 9731
    r = PyObject_GetItem(o, j);
    Py_DECREF(j);
    return r;
}
9732

9733 9734
""" + ''.join([
"""
9735 9736
#define __Pyx_GetItemInt_%(type)s(o, i, size, to_py_func) (((size) <= sizeof(Py_ssize_t)) ? \\
                                                    __Pyx_GetItemInt_%(type)s_Fast(o, i) : \\
9737 9738
                                                    __Pyx_GetItemInt_Generic(o, to_py_func(i)))

9739
static CYTHON_INLINE PyObject *__Pyx_GetItemInt_%(type)s_Fast(PyObject *o, Py_ssize_t i) {
9740 9741 9742 9743 9744 9745
    if (likely(o != Py_None)) {
        if (likely((0 <= i) & (i < Py%(type)s_GET_SIZE(o)))) {
            PyObject *r = Py%(type)s_GET_ITEM(o, i);
            Py_INCREF(r);
            return r;
        }
9746 9747
        else if ((-Py%(type)s_GET_SIZE(o) <= i) & (i < 0)) {
            PyObject *r = Py%(type)s_GET_ITEM(o, Py%(type)s_GET_SIZE(o) + i);
9748 9749 9750
            Py_INCREF(r);
            return r;
        }
9751
    }
9752
    return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i));
9753
}
9754 9755
""" % {'type' : type_name} for type_name in ('List', 'Tuple')
]) + """
9756

9757 9758
#define __Pyx_GetItemInt(o, i, size, to_py_func) (((size) <= sizeof(Py_ssize_t)) ? \\
                                                    __Pyx_GetItemInt_Fast(o, i) : \\
9759 9760
                                                    __Pyx_GetItemInt_Generic(o, to_py_func(i)))

9761
static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i) {
9762 9763 9764 9765 9766 9767 9768
    if (PyList_CheckExact(o)) {
        Py_ssize_t n = (likely(i >= 0)) ? i : i + PyList_GET_SIZE(o);
        if (likely((n >= 0) & (n < PyList_GET_SIZE(o)))) {
            PyObject *r = PyList_GET_ITEM(o, n);
            Py_INCREF(r);
            return r;
        }
Dag Sverre Seljebotn's avatar
Merge  
Dag Sverre Seljebotn committed
9769
    }
9770 9771 9772 9773 9774 9775 9776
    else if (PyTuple_CheckExact(o)) {
        Py_ssize_t n = (likely(i >= 0)) ? i : i + PyTuple_GET_SIZE(o);
        if (likely((n >= 0) & (n < PyTuple_GET_SIZE(o)))) {
            PyObject *r = PyTuple_GET_ITEM(o, n);
            Py_INCREF(r);
            return r;
        }
9777
    }
9778 9779 9780 9781 9782
    else if (likely(i >= 0)) {
        PySequenceMethods *m = Py_TYPE(o)->tp_as_sequence;
        if (likely(m && m->sq_item)) {
            return m->sq_item(o, i);
        }
Dag Sverre Seljebotn's avatar
Merge  
Dag Sverre Seljebotn committed
9783
    }
9784
    return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i));
Dag Sverre Seljebotn's avatar
Merge  
Dag Sverre Seljebotn committed
9785 9786
}
""",
9787 9788
impl = """
""")
Dag Sverre Seljebotn's avatar
Merge  
Dag Sverre Seljebotn committed
9789

9790 9791


Dag Sverre Seljebotn's avatar
Merge  
Dag Sverre Seljebotn committed
9792 9793
#------------------------------------------------------------------------------------

9794 9795
setitem_int_utility_code = UtilityCode(
proto = """
9796 9797
#define __Pyx_SetItemInt(o, i, v, size, to_py_func) (((size) <= sizeof(Py_ssize_t)) ? \\
                                                    __Pyx_SetItemInt_Fast(o, i, v) : \\
9798 9799
                                                    __Pyx_SetItemInt_Generic(o, to_py_func(i), v))

9800
static CYTHON_INLINE int __Pyx_SetItemInt_Generic(PyObject *o, PyObject *j, PyObject *v) {
Dag Sverre Seljebotn's avatar
Merge  
Dag Sverre Seljebotn committed
9801
    int r;
9802 9803 9804 9805 9806 9807
    if (!j) return -1;
    r = PyObject_SetItem(o, j, v);
    Py_DECREF(j);
    return r;
}

9808
static CYTHON_INLINE int __Pyx_SetItemInt_Fast(PyObject *o, Py_ssize_t i, PyObject *v) {
9809 9810 9811
    if (PyList_CheckExact(o)) {
        Py_ssize_t n = (likely(i >= 0)) ? i : i + PyList_GET_SIZE(o);
        if (likely((n >= 0) & (n < PyList_GET_SIZE(o)))) {
9812
            PyObject* old = PyList_GET_ITEM(o, n);
9813
            Py_INCREF(v);
9814
            PyList_SET_ITEM(o, n, v);
9815 9816 9817
            Py_DECREF(old);
            return 1;
        }
Dag Sverre Seljebotn's avatar
Merge  
Dag Sverre Seljebotn committed
9818
    }
9819 9820 9821 9822 9823
    else if (likely(i >= 0)) {
        PySequenceMethods *m = Py_TYPE(o)->tp_as_sequence;
        if (likely(m && m->sq_ass_item)) {
            return m->sq_ass_item(o, i, v);
        }
Dag Sverre Seljebotn's avatar
Merge  
Dag Sverre Seljebotn committed
9824
    }
9825
    return __Pyx_SetItemInt_Generic(o, PyInt_FromSsize_t(i), v);
Dag Sverre Seljebotn's avatar
Merge  
Dag Sverre Seljebotn committed
9826 9827
}
""",
9828 9829 9830
impl = """
""")

9831 9832
#------------------------------------------------------------------------------------

9833 9834
delitem_int_utility_code = UtilityCode(
proto = """
9835 9836
#define __Pyx_DelItemInt(o, i, size, to_py_func) (((size) <= sizeof(Py_ssize_t)) ? \\
                                                    __Pyx_DelItemInt_Fast(o, i) : \\
9837 9838
                                                    __Pyx_DelItem_Generic(o, to_py_func(i)))

9839
static CYTHON_INLINE int __Pyx_DelItem_Generic(PyObject *o, PyObject *j) {
9840
    int r;
9841 9842 9843 9844 9845 9846
    if (!j) return -1;
    r = PyObject_DelItem(o, j);
    Py_DECREF(j);
    return r;
}

9847
static CYTHON_INLINE int __Pyx_DelItemInt_Fast(PyObject *o, Py_ssize_t i) {
9848 9849 9850 9851 9852
    if (likely(i >= 0)) {
        PySequenceMethods *m = Py_TYPE(o)->tp_as_sequence;
        if (likely(m && m->sq_ass_item)) {
            return m->sq_ass_item(o, i, (PyObject *)NULL);
        }
9853
    }
9854
    return __Pyx_DelItem_Generic(o, PyInt_FromSsize_t(i));
9855 9856 9857 9858 9859 9860 9861
}
""",
impl = """
""")

#------------------------------------------------------------------------------------

9862 9863
raise_too_many_values_to_unpack = UtilityCode(
proto = """
9864
static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected);
9865 9866
""",
impl = '''
9867 9868
static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected) {
    PyErr_Format(PyExc_ValueError,
9869
                 "too many values to unpack (expected %"PY_FORMAT_SIZE_T"d)", expected);
9870 9871 9872 9873 9874
}
''')

raise_need_more_values_to_unpack = UtilityCode(
proto = """
9875
static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index);
9876 9877
""",
impl = '''
9878
static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index) {
9879
    PyErr_Format(PyExc_ValueError,
9880 9881
                 "need more than %"PY_FORMAT_SIZE_T"d value%s to unpack",
                 index, (index == 1) ? "" : "s");
9882 9883 9884 9885 9886
}
''')

#------------------------------------------------------------------------------------

9887 9888 9889
tuple_unpacking_error_code = UtilityCode(
proto = """
static void __Pyx_UnpackTupleError(PyObject *, Py_ssize_t index); /*proto*/
9890
""",
9891 9892 9893 9894 9895 9896 9897
impl = """
static void __Pyx_UnpackTupleError(PyObject *t, Py_ssize_t index) {
    if (t == Py_None) {
      __Pyx_RaiseNoneNotIterableError();
    } else if (PyTuple_GET_SIZE(t) < index) {
      __Pyx_RaiseNeedMoreValuesError(PyTuple_GET_SIZE(t));
    } else {
9898
      __Pyx_RaiseTooManyValuesError(index);
9899 9900
    }
}
9901
""",
9902 9903 9904 9905 9906
requires = [raise_none_iter_error_utility_code,
            raise_need_more_values_to_unpack,
            raise_too_many_values_to_unpack]
)

9907 9908 9909 9910 9911 9912 9913 9914 9915 9916 9917 9918 9919 9920
unpacking_utility_code = UtilityCode(
proto = """
static PyObject *__Pyx_UnpackItem(PyObject *, Py_ssize_t index); /*proto*/
""",
impl = """
static PyObject *__Pyx_UnpackItem(PyObject *iter, Py_ssize_t index) {
    PyObject *item;
    if (!(item = PyIter_Next(iter))) {
        if (!PyErr_Occurred()) {
            __Pyx_RaiseNeedMoreValuesError(index);
        }
    }
    return item;
}
9921 9922 9923
""",
requires = [raise_need_more_values_to_unpack]
)
9924

9925 9926 9927 9928 9929 9930 9931 9932
iternext_unpacking_end_utility_code = UtilityCode(
proto = """
static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected); /*proto*/
""",
impl = """
static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected) {
    if (unlikely(retval)) {
        Py_DECREF(retval);
9933
        __Pyx_RaiseTooManyValuesError(expected);
9934
        return -1;
9935 9936 9937 9938 9939 9940 9941
    } else if (PyErr_Occurred()) {
        if (likely(PyErr_ExceptionMatches(PyExc_StopIteration))) {
            PyErr_Clear();
            return 0;
        } else {
            return -1;
        }
9942
    }
9943
    return 0;
9944 9945
}
""",
9946
requires = [raise_too_many_values_to_unpack]
9947
)
Robert Bradshaw's avatar
Robert Bradshaw committed
9948

9949 9950 9951 9952 9953 9954 9955 9956 9957 9958 9959 9960
#------------------------------------------------------------------------------------

# CPython supports calling functions with non-dict kwargs by
# converting them to a dict first

kwargs_call_utility_code = UtilityCode(
proto = """
static PyObject* __Pyx_PyEval_CallObjectWithKeywords(PyObject*, PyObject*, PyObject*); /*proto*/
""",
impl = """
static PyObject* __Pyx_PyEval_CallObjectWithKeywords(PyObject *callable, PyObject *args, PyObject *kwargs) {
    PyObject* result;
9961
    if (likely(PyDict_Check(kwargs))) {
9962 9963 9964 9965 9966 9967 9968 9969 9970 9971 9972
        return PyEval_CallObjectWithKeywords(callable, args, kwargs);
    } else {
        PyObject* real_dict;
        real_dict = PyObject_CallFunctionObjArgs((PyObject*)&PyDict_Type, kwargs, NULL);
        if (unlikely(!real_dict))
            return NULL;
        result = PyEval_CallObjectWithKeywords(callable, args, real_dict);
        Py_DECREF(real_dict);
        return result; /* may be NULL */
    }
}
9973
""",
9974 9975
)

Robert Bradshaw's avatar
Robert Bradshaw committed
9976 9977 9978 9979 9980

#------------------------------------------------------------------------------------

int_pow_utility_code = UtilityCode(
proto="""
9981
static CYTHON_INLINE %(type)s %(func_name)s(%(type)s, %(type)s); /* proto */
Robert Bradshaw's avatar
Robert Bradshaw committed
9982 9983
""",
impl="""
9984
static CYTHON_INLINE %(type)s %(func_name)s(%(type)s b, %(type)s e) {
Robert Bradshaw's avatar
Robert Bradshaw committed
9985 9986 9987 9988 9989 9990 9991 9992 9993 9994 9995 9996 9997 9998 9999 10000 10001 10002 10003 10004 10005
    %(type)s t = b;
    switch (e) {
        case 3:
            t *= b;
        case 2:
            t *= b;
        case 1:
            return t;
        case 0:
            return 1;
    }
    if (unlikely(e<0)) return 0;
    t = 1;
    while (likely(e)) {
        t *= (b * (e&1)) | ((~e)&1);    /* 1 or b */
        b *= b;
        e >>= 1;
    }
    return t;
}
""")
10006 10007 10008

# ------------------------------ Division ------------------------------------

10009 10010
div_int_utility_code = UtilityCode(
proto="""
10011
static CYTHON_INLINE %(type)s __Pyx_div_%(type_name)s(%(type)s, %(type)s); /* proto */
10012 10013
""",
impl="""
10014
static CYTHON_INLINE %(type)s __Pyx_div_%(type_name)s(%(type)s a, %(type)s b) {
10015 10016 10017 10018 10019
    %(type)s q = a / b;
    %(type)s r = a - q*b;
    q -= ((r != 0) & ((r ^ b) < 0));
    return q;
}
10020 10021
""")

10022
mod_int_utility_code = UtilityCode(
10023
proto="""
10024
static CYTHON_INLINE %(type)s __Pyx_mod_%(type_name)s(%(type)s, %(type)s); /* proto */
10025 10026
""",
impl="""
10027
static CYTHON_INLINE %(type)s __Pyx_mod_%(type_name)s(%(type)s a, %(type)s b) {
10028 10029 10030
    %(type)s r = a %% b;
    r += ((r != 0) & ((r ^ b) < 0)) * b;
    return r;
10031 10032 10033
}
""")

10034
mod_float_utility_code = UtilityCode(
10035
proto="""
10036
static CYTHON_INLINE %(type)s __Pyx_mod_%(type_name)s(%(type)s, %(type)s); /* proto */
10037 10038
""",
impl="""
10039
static CYTHON_INLINE %(type)s __Pyx_mod_%(type_name)s(%(type)s a, %(type)s b) {
10040 10041 10042
    %(type)s r = fmod%(math_h_modifier)s(a, b);
    r += ((r != 0) & ((r < 0) ^ (b < 0))) * b;
    return r;
10043 10044
}
""")
Robert Bradshaw's avatar
Robert Bradshaw committed
10045

10046
cdivision_warning_utility_code = UtilityCode(
Robert Bradshaw's avatar
Robert Bradshaw committed
10047
proto="""
10048
static int __Pyx_cdivision_warning(const char *, int); /* proto */
Robert Bradshaw's avatar
Robert Bradshaw committed
10049 10050
""",
impl="""
10051
static int __Pyx_cdivision_warning(const char *filename, int lineno) {
10052
    return PyErr_WarnExplicit(PyExc_RuntimeWarning,
10053
                              "division with oppositely signed operands, C and Python semantics differ",
10054 10055
                              filename,
                              lineno,
10056
                              __Pyx_MODULE_NAME,
10057
                              NULL);
Robert Bradshaw's avatar
Robert Bradshaw committed
10058
}
10059
""")
10060 10061 10062 10063

# from intobject.c
division_overflow_test_code = UtilityCode(
proto="""
Vitja Makarov's avatar
Vitja Makarov committed
10064 10065
#define UNARY_NEG_WOULD_OVERFLOW(x)    \
        (((x) < 0) & ((unsigned long)(x) == 0-(unsigned long)(x)))
10066
""")
Robert Bradshaw's avatar
Robert Bradshaw committed
10067

10068 10069 10070
binding_cfunc_utility_code = TempitaUtilityCode.load(
    "CythonFunction", context=vars(Naming))
fused_function_utility_code = TempitaUtilityCode.load(
10071 10072 10073 10074
        "FusedFunction",
        "CythonFunction.c",
        context=vars(Naming),
        requires=[binding_cfunc_utility_code])
10075 10076 10077 10078
cyfunction_class_cell_utility_code = UtilityCode.load(
    "CyFunctionClassCell",
    "CythonFunction.c",
    requires=[binding_cfunc_utility_code])
10079

10080 10081 10082 10083
generator_utility_code = UtilityCode.load(
    "Generator",
    "Generator.c",
    requires=[Nodes.raise_utility_code, Nodes.swap_exception_utility_code],
Stefan Behnel's avatar
Stefan Behnel committed
10084
)