ExprNodes.py 374 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
               Naming=object, Nodes=object, PyrexTypes=object, py_object_type=object,
Stefan Behnel's avatar
Stefan Behnel committed
10
               list_type=object, tuple_type=object, set_type=object, dict_type=object,
11 12 13 14
               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 copy
17
import operator
William Stein's avatar
William Stein committed
18

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

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

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

Stefan Behnel's avatar
Stefan Behnel committed
47
class NotConstant(object):
48 49 50 51 52 53 54 55
    _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
56 57 58
    def __repr__(self):
        return "<NOT CONSTANT>"

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

62 63 64 65 66 67 68 69 70 71
# 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.",
72
    (Builtin.str_type, PyrexTypes.c_char_ptr_type) : "'str' objects do not support coercion to C types (use 'bytes'?).",
73 74 75 76 77
    (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
78 79 80 81 82 83
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
84
    #  is_sequence_constructor
William Stein's avatar
William Stein committed
85
    #               boolean      Is a list or tuple constructor expression
86
    #  is_starred   boolean      Is a starred expression (e.g. '*a')
William Stein's avatar
William Stein committed
87 88 89
    #  saved_subexpr_nodes
    #               [ExprNode or [ExprNode or None] or None]
    #                            Cached result of subexpr_nodes()
90
    #  use_managed_ref boolean   use ref-counted temps/assignments/etc.
91 92 93
    #  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
94
    result_ctype = None
95
    type = None
96 97
    temp_code = None
    old_temp = None # error checker for multiple frees etc.
98
    use_managed_ref = True # can be set by optimisation transforms
99
    result_is_used = True
William Stein's avatar
William Stein committed
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 126

    #  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.
127 128
    #
    #  The framework makes use of a number of abstract methods.
William Stein's avatar
William Stein committed
129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150
    #  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
151
    #        the LHS of an assignment or argument of a del
William Stein's avatar
William Stein committed
152 153
    #        statement. Similar responsibilities to analyse_types.
    #
154 155 156 157
    #      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
158 159 160 161
    #
    #      check_const
    #        - Check that this node and its subnodes form a
    #          legal constant expression. If so, do nothing,
162
    #          otherwise call not_const.
William Stein's avatar
William Stein committed
163
    #
164
    #        The default implementation of check_const
William Stein's avatar
William Stein committed
165 166 167 168 169 170 171 172
    #        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
173
    #        assumes that the expression is not a constant
William Stein's avatar
William Stein committed
174 175 176 177 178 179 180 181 182 183 184 185
    #        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
186
    #        is provided which uses the following abstract methods:
William Stein's avatar
William Stein committed
187 188 189 190 191 192
    #
    #          generate_result_code
    #            - Generate any C statements necessary to calculate
    #              the result of this node from the results of its
    #              sub-expressions.
    #
193
    #          calculate_result_code
194 195
    #            - Should return a C code fragment evaluating to the
    #              result. This is only called when the result is not
196 197
    #              a temporary.
    #
William Stein's avatar
William Stein committed
198 199 200 201 202 203 204 205 206 207 208 209 210 211 212
    #      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.
    #
    #
213

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

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

223 224
    constant_result = constant_value_not_set

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

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

William Stein's avatar
William Stein committed
237 238 239 240
    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
241
                (self.__class__.__name__, method_name))
242

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

246
    def is_addressable(self):
247
        return self.is_lvalue() and not self.type.is_memoryviewslice
248

William Stein's avatar
William Stein committed
249 250 251 252 253 254 255 256 257 258 259
    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.
260 261 262
        nodes = []
        for name in self.subexprs:
            item = getattr(self, name)
Stefan Behnel's avatar
Stefan Behnel committed
263 264
            if item is not None:
                if type(item) is list:
265
                    nodes.extend(item)
Stefan Behnel's avatar
Stefan Behnel committed
266 267
                else:
                    nodes.append(item)
268
        return nodes
269

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

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

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

William Stein's avatar
William Stein committed
284 285 286 287
    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
288

289
    def get_constant_c_result_code(self):
290
        # Return the constant value of this node as a result code
291 292 293 294 295 296 297
        # 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.
298 299
        return None

300
    def calculate_constant_result(self):
301 302 303 304 305
        # 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.
306 307 308 309 310 311
        #
        # 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

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

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

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

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

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

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

William Stein's avatar
William Stein committed
331 332 333 334 335 336
    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)
337
        return self.check_const()
338

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

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

William Stein's avatar
William Stein committed
351 352 353 354 355
    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
356

William Stein's avatar
William Stein committed
357 358 359 360 361 362 363 364 365
    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
366 367
        return self.coerce_to_boolean(env).coerce_to_simple(env)

368
    # --------------- Type Inference -----------------
369

Robert Bradshaw's avatar
Robert Bradshaw committed
370
    def type_dependencies(self, env):
371 372 373 374
        # 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
375
        return sum([node.type_dependencies(env) for node in self.subexpr_nodes()], ())
376

377
    def infer_type(self, env):
378 379
        # Attempt to deduce the type of self.
        # Differs from analyse_types as it avoids unnecessary
380 381 382 383 384 385 386 387
        # 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")
388

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

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

William Stein's avatar
William Stein committed
396 397 398 399
    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
400

401 402 403 404
    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
405

William Stein's avatar
William Stein committed
406 407 408 409
    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
410

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

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

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

424 425 426 427
    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
428 429
    def check_const(self):
        self.not_const()
430
        return False
431

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

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

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

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

William Stein's avatar
William Stein committed
444 445 446 447 448 449
    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
450

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

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

Robert Bradshaw's avatar
Robert Bradshaw committed
458 459 460
#    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
461

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

    def release_temp_result(self, code):
        if not self.temp_code:
476 477 478
            if not self.result_is_used:
                # not used anyway, so ignore if not set up
                return
479 480 481 482 483 484 485 486 487 488
            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
489
    # ---------------- Code Generation -----------------
490

William Stein's avatar
William Stein committed
491
    def make_owned_reference(self, code):
492 493 494 495
        """
        If result is a pyobject, make sure we own a reference to it.
        If the result is in a temp, it is already a new reference.
        """
William Stein's avatar
William Stein committed
496
        if self.type.is_pyobject and not self.result_in_temp():
497
            code.put_incref(self.result(), self.ctype())
498

499 500 501 502 503 504 505 506
    def make_owned_memoryviewslice(self, code):
        """
        Make sure we own the reference to this memoryview slice.
        """
        if not self.result_in_temp():
            code.put_incref_memoryviewslice(self.result(),
                                            have_gil=self.in_nogil_context)

William Stein's avatar
William Stein committed
507
    def generate_evaluation_code(self, code):
508
        code.mark_pos(self.pos)
509

William Stein's avatar
William Stein committed
510 511 512 513
        #  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)
514 515 516 517

        if self.is_temp:
            self.allocate_temp_result(code)

William Stein's avatar
William Stein committed
518 519
        self.generate_result_code(code)
        if self.is_temp:
520 521
            # 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
522
            self.generate_subexpr_disposal_code(code)
523
            self.free_subexpr_temps(code)
524

William Stein's avatar
William Stein committed
525 526 527
    def generate_subexpr_evaluation_code(self, code):
        for node in self.subexpr_nodes():
            node.generate_evaluation_code(code)
528

William Stein's avatar
William Stein committed
529 530
    def generate_result_code(self, code):
        self.not_implemented("generate_result_code")
531

532 533
    def generate_disposal_code(self, code):
        if self.is_temp:
534 535 536 537 538 539
            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
540
        else:
541
            # Already done if self.is_temp
542
            self.generate_subexpr_disposal_code(code)
543

William Stein's avatar
William Stein committed
544 545 546 547 548
    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)
549

William Stein's avatar
William Stein committed
550 551 552
    def generate_post_assignment_code(self, code):
        if self.is_temp:
            if self.type.is_pyobject:
553
                code.putln("%s = 0;" % self.result())
554 555 556
            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
557 558
        else:
            self.generate_subexpr_disposal_code(code)
559

William Stein's avatar
William Stein committed
560 561
    def generate_assignment_code(self, rhs, code):
        #  Stub method for nodes which are not legal as
562
        #  the LHS of an assignment. An error will have
William Stein's avatar
William Stein committed
563 564
        #  been reported earlier.
        pass
565

William Stein's avatar
William Stein committed
566 567 568 569 570
    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
571 572

    def free_temps(self, code):
573 574 575 576
        if self.is_temp:
            if not self.type.is_void:
                self.release_temp_result(code)
        else:
577
            self.free_subexpr_temps(code)
578

579 580 581 582
    def free_subexpr_temps(self, code):
        for sub in self.subexpr_nodes():
            sub.free_temps(code)

583 584 585
    def generate_function_definitions(self, env, code):
        pass

586
    # ---------------- Annotation ---------------------
587

588 589 590
    def annotate(self, code):
        for node in self.subexpr_nodes():
            node.annotate(code)
591

William Stein's avatar
William Stein committed
592
    # ----------------- Coercion ----------------------
593

William Stein's avatar
William Stein committed
594 595 596 597 598 599 600 601
    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.
602 603 604 605 606 607 608 609
        #
        #   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
610 611 612 613
        src = self
        src_type = self.type
        src_is_py_type = src_type.is_pyobject
        dst_is_py_type = dst_type.is_pyobject
614

615 616 617
        if self.check_for_coercion_error(dst_type):
            return self

618
        if dst_type.is_reference and not src_type.is_reference:
619
            dst_type = dst_type.ref_base_type
620

621
        if src_type.is_fused or dst_type.is_fused:
622 623 624 625 626 627 628
            # 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

629
                for signature in src_type.get_all_specialized_function_types():
630
                    if signature.same_as(dst_type):
Mark Florisson's avatar
Mark Florisson committed
631 632 633 634
                        src.type = signature
                        src.entry = src.type.entry
                        src.entry.used = True
                        return self
635

636
            if src_type.is_fused:
Mark Florisson's avatar
Mark Florisson committed
637
                error(self.pos, "Type is not specialized")
638 639 640
            else:
                error(self.pos, "Cannot coerce to a type that is not specialized")

641 642 643
            self.type = error_type
            return self

644 645 646 647 648
        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)

649
        if dst_type.is_memoryviewslice:
650
            import MemoryView
651
            if not src.type.is_memoryviewslice:
652 653
                if src.type.is_pyobject:
                    src = CoerceToMemViewSliceNode(src, dst_type, env)
654 655 656
                elif src.type.is_array:
                    src = CythonArrayNode.from_carray(src, env).coerce_to(
                                                            dst_type, env)
657
                elif not src_type.is_error:
658 659 660
                    error(self.pos,
                          "Cannot convert '%s' to memoryviewslice" %
                                                                (src_type,))
661 662
            elif not MemoryView.src_conforms_to_dst(
                        src.type, dst_type, broadcast=self.memslice_broadcast):
663 664 665 666 667 668 669 670
                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)
671

672
        elif dst_type.is_pyobject:
William Stein's avatar
William Stein committed
673
            if not src.type.is_pyobject:
674 675 676 677
                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
678
            if not src.type.subtype_of(dst_type):
679 680
                if not isinstance(src, NoneNode):
                    src = PyTypeTestNode(src, dst_type, env)
William Stein's avatar
William Stein committed
681 682
        elif src.type.is_pyobject:
            src = CoerceFromPyTypeNode(dst_type, src, env)
683
        elif (dst_type.is_complex
684 685
              and src_type != dst_type
              and dst_type.assignable_from(src_type)):
686
            src = CoerceToComplexNode(src, dst_type, env)
William Stein's avatar
William Stein committed
687
        else: # neither src nor dst are py types
688
            # Added the string comparison, since for c types that
689
            # is enough, but Cython gets confused when the types are
690
            # in different pxi files.
691
            if not (str(src.type) == str(dst_type) or dst_type.assignable_from(src_type)):
692
                self.fail_assignment(dst_type)
William Stein's avatar
William Stein committed
693 694
        return src

695 696 697 698 699 700 701 702 703 704 705 706 707 708 709
    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
710 711 712 713 714 715
    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.
716 717 718 719 720 721 722

        # 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
723 724 725 726
        type = self.type
        if type.is_pyobject or type.is_ptr or type.is_float:
            return CoerceToBooleanNode(self, env)
        else:
727
            if not (type.is_int or type.is_enum or type.is_error):
728
                error(self.pos,
William Stein's avatar
William Stein committed
729 730
                    "Type '%s' not acceptable as a boolean" % type)
            return self
731

William Stein's avatar
William Stein committed
732 733 734 735 736 737
    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)
738

William Stein's avatar
William Stein committed
739 740 741 742 743 744
    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)
745

William Stein's avatar
William Stein committed
746 747 748 749 750 751
    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)
752

William Stein's avatar
William Stein committed
753 754 755 756 757 758
    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()
759 760

    def may_be_none(self):
761 762
        if self.type and not (self.type.is_pyobject or
                              self.type.is_memoryviewslice):
763 764 765 766
            return False
        if self.constant_result not in (not_a_constant, constant_value_not_set):
            return self.constant_result is not None
        return True
767

768
    def as_cython_attribute(self):
769
        return None
William Stein's avatar
William Stein committed
770

771
    def as_none_safe_node(self, message, error="PyExc_TypeError", format_args=()):
772 773 774
        # 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():
775
            return NoneCheckNode(self, error, message, format_args)
776 777 778 779
        else:
            return self


William Stein's avatar
William Stein committed
780
class AtomicExprNode(ExprNode):
781 782
    #  Abstract base class for expression nodes which have
    #  no sub-expressions.
783

784 785 786
    subexprs = []

    # Override to optimize -- we know we have no children
787 788 789 790
    def generate_subexpr_evaluation_code(self, code):
        pass
    def generate_subexpr_disposal_code(self, code):
        pass
791

792
class PyConstNode(AtomicExprNode):
William Stein's avatar
William Stein committed
793
    #  Abstract base class for constant Python values.
794

795
    is_literal = 1
796
    type = py_object_type
797

William Stein's avatar
William Stein committed
798 799
    def is_simple(self):
        return 1
800 801 802 803

    def may_be_none(self):
        return False

William Stein's avatar
William Stein committed
804
    def analyse_types(self, env):
805
        pass
806

William Stein's avatar
William Stein committed
807 808 809 810 811 812 813 814 815
    def calculate_result_code(self):
        return self.value

    def generate_result_code(self, code):
        pass


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

817
    is_none = 1
William Stein's avatar
William Stein committed
818
    value = "Py_None"
819 820

    constant_result = None
821

822
    nogil_check = None
823

824 825
    def compile_time_value(self, denv):
        return None
826 827 828 829 830

    def may_be_none(self):
        return True


William Stein's avatar
William Stein committed
831 832
class EllipsisNode(PyConstNode):
    #  '...' in a subscript list.
833

William Stein's avatar
William Stein committed
834 835
    value = "Py_Ellipsis"

836 837
    constant_result = Ellipsis

838 839 840
    def compile_time_value(self, denv):
        return Ellipsis

William Stein's avatar
William Stein committed
841

842
class ConstNode(AtomicExprNode):
William Stein's avatar
William Stein committed
843 844 845
    # Abstract base type for literal constant nodes.
    #
    # value     string      C code fragment
846

William Stein's avatar
William Stein committed
847
    is_literal = 1
848
    nogil_check = None
849

William Stein's avatar
William Stein committed
850 851
    def is_simple(self):
        return 1
852

853 854 855
    def nonlocally_immutable(self):
        return 1

856 857 858
    def may_be_none(self):
        return False

William Stein's avatar
William Stein committed
859 860
    def analyse_types(self, env):
        pass # Types are held in class variables
861

William Stein's avatar
William Stein committed
862
    def check_const(self):
863
        return True
864

865
    def get_constant_c_result_code(self):
866 867
        return self.calculate_result_code()

William Stein's avatar
William Stein committed
868 869 870 871 872 873 874
    def calculate_result_code(self):
        return str(self.value)

    def generate_result_code(self, code):
        pass


875 876 877
class BoolNode(ConstNode):
    type = PyrexTypes.c_bint_type
    #  The constant value True or False
878 879 880 881

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

882 883
    def compile_time_value(self, denv):
        return self.value
884

885
    def calculate_result_code(self):
886
        return str(int(self.value))
887

888

William Stein's avatar
William Stein committed
889 890
class NullNode(ConstNode):
    type = PyrexTypes.c_null_ptr_type
891
    value = "NULL"
892
    constant_result = 0
William Stein's avatar
William Stein committed
893

894
    def get_constant_c_result_code(self):
895 896
        return self.value

William Stein's avatar
William Stein committed
897 898 899

class CharNode(ConstNode):
    type = PyrexTypes.c_char_type
900 901 902

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

904
    def compile_time_value(self, denv):
905
        return ord(self.value)
906

William Stein's avatar
William Stein committed
907
    def calculate_result_code(self):
908
        return "'%s'" % StringEncoding.escape_char(self.value)
William Stein's avatar
William Stein committed
909 910 911


class IntNode(ConstNode):
912 913 914

    # unsigned     "" or "U"
    # longness     "" or "L" or "LL"
915
    # is_c_literal   True/False/None   creator considers this a C integer literal
916 917 918

    unsigned = ""
    longness = ""
919
    is_c_literal = None # unknown
920 921 922

    def __init__(self, pos, **kwds):
        ExprNode.__init__(self, pos, **kwds)
Robert Bradshaw's avatar
Robert Bradshaw committed
923
        if 'type' not in kwds:
924 925 926 927 928 929 930 931
            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
932 933 934 935
        # 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 \
936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951
               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
952

953
    def coerce_to(self, dst_type, env):
954
        if self.type is dst_type:
955
            return self
956
        elif dst_type.is_float:
957
            if self.constant_result is not not_a_constant:
958 959
                return FloatNode(self.pos, value='%d.0' % int(self.constant_result), type=dst_type,
                                 constant_result=float(self.constant_result))
960 961 962
            else:
                return FloatNode(self.pos, value=self.value, type=dst_type,
                                 constant_result=not_a_constant)
963
        if dst_type.is_numeric and not dst_type.is_complex:
964
            node = IntNode(self.pos, value=self.value, constant_result=self.constant_result,
965 966
                           type = dst_type, is_c_literal = True,
                           unsigned=self.unsigned, longness=self.longness)
967
            return node
968 969
        elif dst_type.is_pyobject:
            node = IntNode(self.pos, value=self.value, constant_result=self.constant_result,
970 971
                           type = PyrexTypes.py_object_type, is_c_literal = False,
                           unsigned=self.unsigned, longness=self.longness)
972
        else:
973 974
            # FIXME: not setting the type here to keep it working with
            # complex numbers. Should they be special cased?
975 976
            node = IntNode(self.pos, value=self.value, constant_result=self.constant_result,
                           unsigned=self.unsigned, longness=self.longness)
977 978 979
        # 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.
980 981
        return ConstNode.coerce_to(node, dst_type, env)

982
    def coerce_to_boolean(self, env):
983 984 985 986
        return IntNode(
            self.pos, value=self.value,
            type = PyrexTypes.c_bint_type,
            unsigned=self.unsigned, longness=self.longness)
987

988
    def generate_evaluation_code(self, code):
989
        if self.type.is_pyobject:
990
            # pre-allocate a Python version of the number
991 992
            plain_integer_string = self.value_as_c_integer_string(plain_digits=True)
            self.result_code = code.get_py_num(plain_integer_string, self.longness)
993
        else:
994
            self.result_code = self.get_constant_c_result_code()
995

996
    def get_constant_c_result_code(self):
997 998 999
        return self.value_as_c_integer_string() + self.unsigned + self.longness

    def value_as_c_integer_string(self, plain_digits=False):
1000 1001 1002 1003
        value = self.value
        if isinstance(value, basestring) and len(value) > 2:
            # must convert C-incompatible Py3 oct/bin notations
            if value[1] in 'oO':
1004 1005 1006 1007
                if plain_digits:
                    value = int(value[2:], 8)
                else:
                    value = value[0] + value[2:] # '0o123' => '0123'
1008 1009
            elif value[1] in 'bB':
                value = int(value[2:], 2)
1010 1011 1012
            elif plain_digits and value[1] in 'xX':
                value = int(value[2:], 16)
        return str(value)
1013 1014 1015

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

1017
    def calculate_constant_result(self):
1018
        self.constant_result = Utils.str_to_number(self.value)
1019

1020
    def compile_time_value(self, denv):
1021
        return Utils.str_to_number(self.value)
1022 1023


William Stein's avatar
William Stein committed
1024 1025 1026
class FloatNode(ConstNode):
    type = PyrexTypes.c_double_type

1027
    def calculate_constant_result(self):
1028
        self.constant_result = float(self.value)
1029

1030 1031
    def compile_time_value(self, denv):
        return float(self.value)
1032

Stefan Behnel's avatar
Stefan Behnel committed
1033
    def calculate_result_code(self):
1034 1035 1036 1037
        strval = self.value
        assert isinstance(strval, (str, unicode))
        cmpval = repr(float(strval))
        if cmpval == 'nan':
1038
            return "(Py_HUGE_VAL * 0)"
1039
        elif cmpval == 'inf':
1040
            return "Py_HUGE_VAL"
1041
        elif cmpval == '-inf':
1042
            return "(-Py_HUGE_VAL)"
Stefan Behnel's avatar
Stefan Behnel committed
1043 1044
        else:
            return strval
1045

William Stein's avatar
William Stein committed
1046

1047
class BytesNode(ConstNode):
1048 1049 1050 1051
    # A char* or bytes literal
    #
    # value      BytesLiteral

1052
    is_string_literal = True
1053 1054
    # start off as Python 'bytes' to support len() in O(1)
    type = bytes_type
1055 1056

    def compile_time_value(self, denv):
1057
        return self.value
1058

1059
    def analyse_as_type(self, env):
1060
        type = PyrexTypes.parse_basic_type(self.value)
1061
        if type is not None:
1062
            return type
1063 1064 1065 1066 1067 1068 1069
        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
1070

1071 1072 1073
    def can_coerce_to_char_literal(self):
        return len(self.value) == 1

1074
    def coerce_to_boolean(self, env):
1075 1076
        # This is special because testing a C char* for truth directly
        # would yield the wrong result.
1077 1078
        bool_value = bool(self.value)
        return BoolNode(self.pos, value=bool_value, constant_result=bool_value)
1079

William Stein's avatar
William Stein committed
1080
    def coerce_to(self, dst_type, env):
1081 1082
        if self.type == dst_type:
            return self
1083
        if dst_type.is_int:
1084
            if not self.can_coerce_to_char_literal():
1085 1086
                error(self.pos, "Only single-character string literals can be coerced into ints.")
                return self
Stefan Behnel's avatar
Stefan Behnel committed
1087 1088
            if dst_type.is_unicode_char:
                error(self.pos, "Bytes literals cannot coerce to Py_UNICODE/Py_UCS4, use a unicode literal instead.")
1089
                return self
1090 1091
            return CharNode(self.pos, value=self.value)

1092
        node = BytesNode(self.pos, value=self.value)
1093 1094 1095 1096 1097 1098 1099 1100
        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
1101 1102 1103 1104
            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)
1105 1106
        elif dst_type.assignable_from(PyrexTypes.c_char_ptr_type):
            node.type = dst_type
1107
            return node
1108

William Stein's avatar
William Stein committed
1109 1110 1111 1112 1113
        # 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)

1114
    def generate_evaluation_code(self, code):
William Stein's avatar
William Stein committed
1115
        if self.type.is_pyobject:
1116
            self.result_code = code.get_py_string_const(self.value)
William Stein's avatar
William Stein committed
1117
        else:
1118
            self.result_code = code.get_string_const(self.value)
1119

1120
    def get_constant_c_result_code(self):
1121
        return None # FIXME
1122

1123 1124
    def calculate_result_code(self):
        return self.result_code
William Stein's avatar
William Stein committed
1125 1126


1127
class UnicodeNode(PyConstNode):
1128 1129
    # A Python unicode object
    #
1130 1131
    # value        EncodedString
    # bytes_value  BytesLiteral    the literal parsed as bytes string ('-3' unicode literals only)
Robert Bradshaw's avatar
Robert Bradshaw committed
1132

1133
    is_string_literal = True
1134
    bytes_value = None
1135
    type = unicode_type
1136

1137
    def coerce_to(self, dst_type, env):
1138 1139
        if dst_type is self.type:
            pass
Stefan Behnel's avatar
Stefan Behnel committed
1140
        elif dst_type.is_unicode_char:
1141
            if not self.can_coerce_to_char_literal():
Stefan Behnel's avatar
Stefan Behnel committed
1142
                error(self.pos, "Only single-character Unicode string literals or surrogate pairs can be coerced into Py_UCS4/Py_UNICODE.")
1143 1144
                return self
            int_value = ord(self.value)
Stefan Behnel's avatar
Stefan Behnel committed
1145
            return IntNode(self.pos, type=dst_type, value=str(int_value), constant_result=int_value)
1146
        elif not dst_type.is_pyobject:
1147 1148 1149
            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
1150
            error(self.pos, "Unicode literals do not support coercion to C types other than Py_UNICODE or Py_UCS4.")
1151 1152 1153 1154
        elif dst_type is not py_object_type:
            if not self.check_for_coercion_error(dst_type):
                self.fail_assignment(dst_type)
        return self
1155

1156 1157
    def can_coerce_to_char_literal(self):
        return len(self.value) == 1
Stefan Behnel's avatar
Stefan Behnel committed
1158 1159 1160
            ## or (len(self.value) == 2
            ##     and (0xD800 <= self.value[0] <= 0xDBFF)
            ##     and (0xDC00 <= self.value[1] <= 0xDFFF))
1161

1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178
    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

1179
    def generate_evaluation_code(self, code):
1180
        self.result_code = code.get_py_string_const(self.value)
1181 1182 1183

    def calculate_result_code(self):
        return self.result_code
1184

1185 1186
    def compile_time_value(self, env):
        return self.value
1187 1188


1189 1190 1191 1192
class StringNode(PyConstNode):
    # A Python str object, i.e. a byte string in Python 2.x and a
    # unicode string in Python 3.x
    #
1193 1194
    # value          BytesLiteral (or EncodedString with ASCII content)
    # unicode_value  EncodedString or None
1195
    # is_identifier  boolean
1196

1197
    type = str_type
1198
    is_string_literal = True
1199
    is_identifier = None
1200
    unicode_value = None
1201

1202
    def coerce_to(self, dst_type, env):
1203
        if dst_type is not py_object_type and not str_type.subtype_of(dst_type):
1204 1205 1206 1207 1208
#            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)
1209
            self.check_for_coercion_error(dst_type, fail=True)
1210
        return self
1211

1212 1213
    def can_coerce_to_char_literal(self):
        return not self.is_identifier and len(self.value) == 1
1214

1215
    def generate_evaluation_code(self, code):
1216
        self.result_code = code.get_py_string_const(
1217 1218
            self.value, identifier=self.is_identifier, is_str=True,
            unicode_value=self.unicode_value)
1219

1220
    def get_constant_c_result_code(self):
1221 1222
        return None

1223
    def calculate_result_code(self):
1224
        return self.result_code
1225

1226 1227
    def compile_time_value(self, env):
        return self.value
1228 1229


1230 1231 1232 1233
class IdentifierStringNode(StringNode):
    # A special str value that represents an identifier (bytes in Py2,
    # unicode in Py3).
    is_identifier = True
1234 1235


1236
class LongNode(AtomicExprNode):
William Stein's avatar
William Stein committed
1237 1238 1239
    #  Python long integer literal
    #
    #  value   string
1240

1241 1242
    type = py_object_type

1243
    def calculate_constant_result(self):
1244
        self.constant_result = Utils.str_to_number(self.value)
1245

1246
    def compile_time_value(self, denv):
1247
        return Utils.str_to_number(self.value)
1248

William Stein's avatar
William Stein committed
1249 1250
    def analyse_types(self, env):
        self.is_temp = 1
1251

1252 1253 1254
    def may_be_none(self):
        return False

1255 1256
    gil_message = "Constructing Python long int"

1257
    def generate_result_code(self, code):
William Stein's avatar
William Stein committed
1258
        code.putln(
1259
            '%s = PyLong_FromString((char *)"%s", 0, 0); %s' % (
1260
                self.result(),
William Stein's avatar
William Stein committed
1261
                self.value,
1262
                code.error_goto_if_null(self.result(), self.pos)))
1263
        code.put_gotref(self.py_result())
William Stein's avatar
William Stein committed
1264 1265


1266
class ImagNode(AtomicExprNode):
William Stein's avatar
William Stein committed
1267 1268 1269
    #  Imaginary number literal
    #
    #  value   float    imaginary part
1270

1271
    type = PyrexTypes.c_double_complex_type
1272 1273 1274

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

1276 1277
    def compile_time_value(self, denv):
        return complex(0.0, self.value)
1278

William Stein's avatar
William Stein committed
1279
    def analyse_types(self, env):
1280 1281
        self.type.create_declaration_utility_code(env)

1282 1283 1284
    def may_be_none(self):
        return False

1285
    def coerce_to(self, dst_type, env):
1286 1287 1288
        if self.type is dst_type:
            return self
        node = ImagNode(self.pos, value=self.value)
1289
        if dst_type.is_pyobject:
1290 1291
            node.is_temp = 1
            node.type = PyrexTypes.py_object_type
1292 1293 1294
        # 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.
1295
        return AtomicExprNode.coerce_to(node, dst_type, env)
1296 1297 1298

    gil_message = "Constructing complex number"

1299 1300 1301 1302 1303 1304
    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))

1305
    def generate_result_code(self, code):
1306 1307 1308 1309 1310 1311 1312
        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())
1313

William Stein's avatar
William Stein committed
1314

Danilo Freitas's avatar
Danilo Freitas committed
1315
class NewExprNode(AtomicExprNode):
1316 1317 1318

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

Robert Bradshaw's avatar
Robert Bradshaw committed
1321
    type = None
1322

1323
    def infer_type(self, env):
Robert Bradshaw's avatar
Robert Bradshaw committed
1324 1325
        type = self.cppclass.analyse_as_type(env)
        if type is None or not type.is_cpp_class:
Danilo Freitas's avatar
Danilo Freitas committed
1326
            error(self.pos, "new operator can only be applied to a C++ class")
Robert Bradshaw's avatar
Robert Bradshaw committed
1327
            self.type = error_type
Danilo Freitas's avatar
Danilo Freitas committed
1328
            return
Robert Bradshaw's avatar
Robert Bradshaw committed
1329
        self.cpp_check(env)
1330
        constructor = type.scope.lookup(u'<init>')
Danilo Freitas's avatar
Danilo Freitas committed
1331
        if constructor is None:
1332 1333
            return_type = PyrexTypes.CFuncType(type, [])
            return_type = PyrexTypes.CPtrType(return_type)
1334 1335
            type.scope.declare_cfunction(u'<init>', return_type, self.pos)
            constructor = type.scope.lookup(u'<init>')
1336
        self.class_type = type
DaniloFreitas's avatar
DaniloFreitas committed
1337
        self.entry = constructor
Robert Bradshaw's avatar
Robert Bradshaw committed
1338
        self.type = constructor.type
1339
        return self.type
1340

1341
    def analyse_types(self, env):
Robert Bradshaw's avatar
Robert Bradshaw committed
1342 1343
        if self.type is None:
            self.infer_type(env)
1344 1345 1346 1347

    def may_be_none(self):
        return False

Danilo Freitas's avatar
Danilo Freitas committed
1348 1349
    def generate_result_code(self, code):
        pass
1350

Danilo Freitas's avatar
Danilo Freitas committed
1351
    def calculate_result_code(self):
1352
        return "new " + self.class_type.declaration_code("")
Danilo Freitas's avatar
Danilo Freitas committed
1353

William Stein's avatar
William Stein committed
1354

1355
class NameNode(AtomicExprNode):
William Stein's avatar
William Stein committed
1356 1357 1358 1359
    #  Reference to a local or global variable name.
    #
    #  name            string    Python name of the variable
    #  entry           Entry     Symbol table entry
1360
    #  type_entry      Entry     For extension type names, the original type entry
1361 1362
    #  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
1363
    #  allow_null      boolean   Don't raise UnboundLocalError
1364
    #  nogil           boolean   Whether it is used in a nogil context
1365

1366 1367
    is_name = True
    is_cython_module = False
Robert Bradshaw's avatar
Robert Bradshaw committed
1368
    cython_attribute = None
1369
    lhs_of_first_assignment = False # TODO: remove me
1370
    is_used_as_rvalue = 0
1371
    entry = None
1372
    type_entry = None
1373 1374
    cf_maybe_null = True
    cf_is_null = False
Vitja Makarov's avatar
Vitja Makarov committed
1375
    allow_null = False
1376
    nogil = False
1377

1378
    def as_cython_attribute(self):
Robert Bradshaw's avatar
Robert Bradshaw committed
1379
        return self.cython_attribute
1380

Robert Bradshaw's avatar
Robert Bradshaw committed
1381 1382 1383 1384 1385 1386 1387
    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 ()
1388

Robert Bradshaw's avatar
Robert Bradshaw committed
1389 1390 1391 1392 1393
    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
1394 1395 1396
        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
1397
            # is used for the pointer to the type they represent.
Robert Bradshaw's avatar
Robert Bradshaw committed
1398
            return type_type
1399
        elif self.entry.type.is_cfunction:
1400 1401 1402 1403 1404 1405
            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
1406 1407
        else:
            return self.entry.type
1408

1409 1410 1411 1412
    def compile_time_value(self, denv):
        try:
            return denv.lookup(self.name)
        except KeyError:
Stefan Behnel's avatar
Stefan Behnel committed
1413
            error(self.pos, "Compile-time name '%s' not defined" % self.name)
1414 1415 1416 1417 1418

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

1420 1421 1422 1423 1424 1425 1426
    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
1427
            if entry and entry.is_cfunction:
1428 1429
                var_entry = entry.as_variable
                if var_entry:
1430
                    if var_entry.is_builtin and var_entry.is_const:
1431
                        var_entry = env.declare_builtin(var_entry.name, self.pos)
1432 1433 1434 1435
                    node = NameNode(self.pos, name = self.name)
                    node.entry = var_entry
                    node.analyse_rvalue_entry(env)
                    return node
1436

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

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

1449
    def analyse_as_type(self, env):
1450 1451 1452 1453
        if self.cython_attribute:
            type = PyrexTypes.parse_basic_type(self.cython_attribute)
        else:
            type = PyrexTypes.parse_basic_type(self.name)
1454 1455
        if type:
            return type
1456 1457 1458 1459 1460 1461 1462
        entry = self.entry
        if not entry:
            entry = env.lookup(self.name)
        if entry and entry.is_type:
            return entry.type
        else:
            return None
1463

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

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

1489
    def analyse_types(self, env):
1490
        self.initialized_check = env.directives['initializedcheck']
1491 1492
        if self.entry is None:
            self.entry = env.lookup(self.name)
William Stein's avatar
William Stein committed
1493 1494
        if not self.entry:
            self.entry = env.declare_builtin(self.name, self.pos)
1495 1496 1497
        if not self.entry:
            self.type = PyrexTypes.error_type
            return
Dag Sverre Seljebotn's avatar
Dag Sverre Seljebotn committed
1498 1499 1500 1501 1502 1503 1504 1505
        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)
1506
        self.analyse_rvalue_entry(env)
1507

1508
    def analyse_target_types(self, env):
William Stein's avatar
William Stein committed
1509
        self.analyse_entry(env)
1510 1511 1512

        if (not self.is_lvalue() and self.entry.is_cfunction and
                self.entry.fused_cfunction and self.entry.as_variable):
1513
            # We need this for the fused 'def' TreeFragment
1514 1515 1516
            self.entry = self.entry.as_variable
            self.type = self.entry.type

1517 1518 1519 1520
        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
1521
        self.entry.used = 1
1522
        if self.entry.type.is_buffer:
1523 1524
            import Buffer
            Buffer.used_buffer_aux_vars(self.entry)
1525

1526 1527 1528 1529
    def analyse_rvalue_entry(self, env):
        #print "NameNode.analyse_rvalue_entry:", self.name ###
        #print "Entry:", self.entry.__dict__ ###
        self.analyse_entry(env)
1530
        entry = self.entry
1531

1532
        if entry.is_declared_generic:
William Stein's avatar
William Stein committed
1533
            self.result_ctype = py_object_type
1534

1535
        if entry.is_pyglobal or entry.is_builtin:
1536
            if entry.is_builtin and entry.is_const:
1537 1538 1539
                self.is_temp = 0
            else:
                self.is_temp = 1
1540
                env.use_utility_code(get_name_interned_utility_code)
1541

1542
            self.is_used_as_rvalue = 1
1543 1544 1545
        elif entry.type.is_memoryviewslice:
            self.is_temp = False
            self.is_used_as_rvalue = True
1546
            self.use_managed_ref = True
1547

1548
    def nogil_check(self, env):
1549
        self.nogil = True
1550 1551 1552
        if self.is_used_as_rvalue:
            entry = self.entry
            if entry.is_builtin:
1553
                if not entry.is_const: # cached builtins are ok
1554
                    self.gil_error()
1555
            elif entry.is_pyglobal:
1556
                self.gil_error()
1557 1558 1559 1560
            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)
1561 1562 1563

    gil_message = "Accessing Python global or builtin"

1564 1565
    def analyse_entry(self, env):
        #print "NameNode.analyse_entry:", self.name ###
William Stein's avatar
William Stein committed
1566
        self.check_identifier_kind()
1567 1568 1569 1570
        entry = self.entry
        type = entry.type
        self.type = type

William Stein's avatar
William Stein committed
1571
    def check_identifier_kind(self):
1572 1573 1574
        # 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
1575
        entry = self.entry
1576 1577
        if entry.is_type and entry.type.is_extension_type:
            self.type_entry = entry
1578
        if not (entry.is_const or entry.is_variable
Danilo Freitas's avatar
Danilo Freitas committed
1579 1580
            or entry.is_builtin or entry.is_cfunction
            or entry.is_cpp_class):
William Stein's avatar
William Stein committed
1581 1582 1583
                if self.entry.as_variable:
                    self.entry = self.entry.as_variable
                else:
1584
                    error(self.pos,
1585 1586
                          "'%s' is not a constant, variable or function identifier" % self.name)

William Stein's avatar
William Stein committed
1587 1588 1589
    def is_simple(self):
        #  If it's not a C variable, it'll be in a temp.
        return 1
1590

1591
    def may_be_none(self):
1592 1593
        if self.cf_state and self.type and (self.type.is_pyobject or
                                            self.type.is_memoryviewslice):
1594 1595 1596 1597 1598 1599 1600
            # 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
1601 1602
            # evaluate control flow state to see if there were any
            # potential None values assigned to the node so far
1603
            may_be_none = False
1604 1605
            for assignment in self.cf_state:
                if assignment.rhs.may_be_none():
1606 1607 1608 1609
                    may_be_none = True
                    break
            del self._none_checking
            return may_be_none
1610 1611
        return super(NameNode, self).may_be_none()

1612
    def nonlocally_immutable(self):
1613 1614
        if ExprNode.nonlocally_immutable(self):
            return True
1615 1616 1617
        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
1618 1619
    def calculate_target_results(self, env):
        pass
1620

William Stein's avatar
William Stein committed
1621 1622
    def check_const(self):
        entry = self.entry
Robert Bradshaw's avatar
Robert Bradshaw committed
1623
        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
1624
            self.not_const()
1625 1626
            return False
        return True
1627

William Stein's avatar
William Stein committed
1628 1629
    def check_const_addr(self):
        entry = self.entry
1630
        if not (entry.is_cglobal or entry.is_cfunction or entry.is_builtin):
William Stein's avatar
William Stein committed
1631
            self.addr_not_const()
1632 1633
            return False
        return True
William Stein's avatar
William Stein committed
1634 1635 1636 1637 1638

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

1640
    def is_addressable(self):
1641
        return self.entry.is_variable and not self.type.is_memoryviewslice
1642

William Stein's avatar
William Stein committed
1643 1644 1645 1646
    def is_ephemeral(self):
        #  Name nodes are never ephemeral, even if the
        #  result is in a temporary.
        return 0
1647

William Stein's avatar
William Stein committed
1648
    def calculate_result_code(self):
Stefan Behnel's avatar
Stefan Behnel committed
1649 1650
        entry = self.entry
        if not entry:
William Stein's avatar
William Stein committed
1651
            return "<error>" # There was an error earlier
Stefan Behnel's avatar
Stefan Behnel committed
1652
        return entry.cname
1653

William Stein's avatar
William Stein committed
1654
    def generate_result_code(self, code):
1655
        assert hasattr(self, 'entry')
William Stein's avatar
William Stein committed
1656 1657 1658
        entry = self.entry
        if entry is None:
            return # There was an error earlier
1659
        if entry.is_builtin and entry.is_const:
1660
            return # Lookup already cached
Stefan Behnel's avatar
Stefan Behnel committed
1661
        elif entry.is_pyclass_attr:
Vitja Makarov's avatar
Vitja Makarov committed
1662 1663 1664 1665 1666 1667
            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
1668 1669 1670 1671 1672 1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685
            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
1686
            code.put_gotref(self.py_result())
1687

1688
        elif entry.is_pyglobal or entry.is_builtin:
1689 1690
            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
1691 1692 1693
            if entry.is_builtin:
                namespace = Naming.builtins_cname
            else: # entry.is_pyglobal
1694
                namespace = entry.scope.namespace_cname
1695
            code.globalstate.use_utility_code(get_name_interned_utility_code)
1696 1697
            code.putln(
                '%s = __Pyx_GetName(%s, %s); %s' % (
1698
                self.result(),
1699
                namespace,
1700
                interned_cname,
1701
                code.error_goto_if_null(self.result(), self.pos)))
1702
            code.put_gotref(self.py_result())
1703

1704
        elif entry.is_local or entry.in_closure or entry.from_closure or entry.type.is_memoryviewslice:
1705 1706 1707 1708
            # 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)
1709

1710 1711 1712
            memslice_check = entry.type.is_memoryviewslice and self.initialized_check

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

    def generate_assignment_code(self, rhs, code):
1716
        #print "NameNode.generate_assignment_code:", self.name ###
William Stein's avatar
William Stein committed
1717 1718 1719
        entry = self.entry
        if entry is None:
            return # There was an error earlier
1720 1721 1722 1723

        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")
1724

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

1767
            elif self.type.is_buffer:
1768 1769 1770 1771 1772 1773 1774 1775 1776
                # 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)

1777
            if self.type.is_pyobject:
William Stein's avatar
William Stein committed
1778 1779 1780 1781
                #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() ###
1782 1783
                if self.use_managed_ref:
                    rhs.make_owned_reference(code)
1784
                    is_external_ref = entry.is_cglobal or self.entry.in_closure or self.entry.from_closure
1785 1786 1787 1788 1789 1790
                    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())
1791 1792 1793
                    if entry.is_cglobal:
                        code.put_decref(self.result(), self.ctype())
                    else:
1794 1795
                        if not self.cf_is_null:
                            if self.cf_maybe_null:
1796
                                code.put_xdecref(self.result(), self.ctype())
1797 1798
                            else:
                                code.put_decref(self.result(), self.ctype())
1799
                    if is_external_ref:
1800
                        code.put_giveref(rhs.py_result())
1801
            if not self.type.is_memoryviewslice:
1802
                code.putln('%s = %s;' % (self.result(), rhs.result_as(self.ctype())))
1803 1804 1805 1806
                if debug_disposal_code:
                    print("NameNode.generate_assignment_code:")
                    print("...generating post-assignment code for %s" % rhs)
                rhs.generate_post_assignment_code(code)
1807 1808
            elif rhs.result_in_temp():
                rhs.generate_post_assignment_code(code)
1809

1810
            rhs.free_temps(code)
1811

1812 1813
    def generate_acquire_memoryviewslice(self, rhs, code):
        """
1814 1815
        Slices, coercions from objects, return values etc are new references.
        We have a borrowed reference in case of dst = src
1816 1817 1818 1819 1820 1821 1822 1823 1824
        """
        import MemoryView

        MemoryView.put_acquire_memoryviewslice(
            lhs_cname=self.result(),
            lhs_type=self.type,
            lhs_pos=self.pos,
            rhs=rhs,
            code=code,
1825 1826
            have_gil=not self.in_nogil_context,
            first_assignment=self.cf_is_null)
1827

1828
    def generate_acquire_buffer(self, rhs, code):
1829 1830 1831
        # 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.
1832 1833 1834 1835 1836 1837 1838
        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())))

1839
        import Buffer
1840
        Buffer.put_assign_to_buffer(self.result(), rhstmp, self.entry,
1841
                                    is_initialized=not self.lhs_of_first_assignment,
1842
                                    pos=self.pos, code=code)
1843

1844 1845 1846
        if not pretty_rhs:
            code.putln("%s = 0;" % rhstmp)
            code.funcstate.release_temp(rhstmp)
1847

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

                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
1874
        else:
1875
            error(self.pos, "Deletion of C names not supported")
1876

1877 1878 1879 1880 1881 1882 1883
    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)))
1884

1885
class BackquoteNode(ExprNode):
William Stein's avatar
William Stein committed
1886 1887 1888
    #  `expr`
    #
    #  arg    ExprNode
1889

1890
    type = py_object_type
1891

William Stein's avatar
William Stein committed
1892
    subexprs = ['arg']
1893

William Stein's avatar
William Stein committed
1894 1895 1896 1897
    def analyse_types(self, env):
        self.arg.analyse_types(env)
        self.arg = self.arg.coerce_to_pyobject(env)
        self.is_temp = 1
1898 1899 1900

    gil_message = "Backquote expression"

1901 1902 1903
    def calculate_constant_result(self):
        self.constant_result = repr(self.arg.constant_result)

William Stein's avatar
William Stein committed
1904 1905
    def generate_result_code(self, code):
        code.putln(
Robert Bradshaw's avatar
Robert Bradshaw committed
1906
            "%s = PyObject_Repr(%s); %s" % (
1907
                self.result(),
William Stein's avatar
William Stein committed
1908
                self.arg.py_result(),
1909
                code.error_goto_if_null(self.result(), self.pos)))
1910
        code.put_gotref(self.py_result())
1911

William Stein's avatar
William Stein committed
1912

1913
class ImportNode(ExprNode):
William Stein's avatar
William Stein committed
1914
    #  Used as part of import statement implementation.
1915
    #  Implements result =
Haoyu Bai's avatar
Haoyu Bai committed
1916
    #    __import__(module_name, globals(), None, name_list, level)
William Stein's avatar
William Stein committed
1917
    #
Haoyu Bai's avatar
Haoyu Bai committed
1918 1919 1920
    #  module_name   StringNode            dotted name of module. Empty module
    #                       name means importing the parent package accourding
    #                       to level
1921
    #  name_list     ListNode or None      list of names to be imported
Haoyu Bai's avatar
Haoyu Bai committed
1922 1923 1924 1925 1926
    #  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.
1927 1928
    #                     None: decide the level according to language level and
    #                           directives
1929

1930
    type = py_object_type
1931

William Stein's avatar
William Stein committed
1932
    subexprs = ['module_name', 'name_list']
1933

William Stein's avatar
William Stein committed
1934
    def analyse_types(self, env):
1935 1936 1937 1938 1939
        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
1940 1941 1942 1943
        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)
1944
            self.name_list.coerce_to_pyobject(env)
William Stein's avatar
William Stein committed
1945 1946
        self.is_temp = 1
        env.use_utility_code(import_utility_code)
1947 1948 1949

    gil_message = "Python import"

William Stein's avatar
William Stein committed
1950 1951 1952 1953 1954 1955
    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
1956
            "%s = __Pyx_Import(%s, %s, %d); %s" % (
1957
                self.result(),
William Stein's avatar
William Stein committed
1958 1959
                self.module_name.py_result(),
                name_list_code,
Haoyu Bai's avatar
Haoyu Bai committed
1960
                self.level,
1961
                code.error_goto_if_null(self.result(), self.pos)))
1962
        code.put_gotref(self.py_result())
William Stein's avatar
William Stein committed
1963 1964


1965
class IteratorNode(ExprNode):
William Stein's avatar
William Stein committed
1966
    #  Used as part of for statement implementation.
1967
    #
William Stein's avatar
William Stein committed
1968 1969 1970
    #  Implements result = iter(sequence)
    #
    #  sequence   ExprNode
1971

1972
    type = py_object_type
1973
    iter_func_ptr = None
1974
    counter_cname = None
1975
    reversed = False      # currently only used for list/tuple types (see Optimize.py)
1976

William Stein's avatar
William Stein committed
1977
    subexprs = ['sequence']
1978

William Stein's avatar
William Stein committed
1979 1980
    def analyse_types(self, env):
        self.sequence.analyse_types(env)
1981 1982
        if (self.sequence.type.is_array or self.sequence.type.is_ptr) and \
                not self.sequence.type.is_string:
1983
            # C array iteration will be transformed later on
1984
            self.type = self.sequence.type
1985 1986
        else:
            self.sequence = self.sequence.coerce_to_pyobject(env)
1987 1988 1989
            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
1990
        self.is_temp = 1
1991 1992 1993

    gil_message = "Iterating over Python object"

1994 1995 1996 1997
    _func_iternext_type = PyrexTypes.CPtrType(PyrexTypes.CFuncType(
        PyrexTypes.py_object_type, [
            PyrexTypes.CFuncTypeArg("it", PyrexTypes.py_object_type, None),
            ]))
1998

William Stein's avatar
William Stein committed
1999
    def generate_result_code(self, code):
Stefan Behnel's avatar
Stefan Behnel committed
2000 2001
        sequence_type = self.sequence.type
        if sequence_type.is_array or sequence_type.is_ptr:
2002
            raise InternalError("for in carray slice not transformed")
Stefan Behnel's avatar
Stefan Behnel committed
2003 2004
        is_builtin_sequence = sequence_type is list_type or \
                              sequence_type is tuple_type
2005 2006 2007
        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
2008 2009
        self.may_be_a_sequence = not sequence_type.is_builtin_type
        if self.may_be_a_sequence:
2010 2011 2012 2013
            code.putln(
                "if (PyList_CheckExact(%s) || PyTuple_CheckExact(%s)) {" % (
                    self.sequence.py_result(),
                    self.sequence.py_result()))
Stefan Behnel's avatar
Stefan Behnel committed
2014
        if is_builtin_sequence or self.may_be_a_sequence:
2015 2016
            self.counter_cname = code.funcstate.allocate_temp(
                PyrexTypes.c_py_ssize_t_type, manage_ref=False)
2017 2018 2019 2020 2021 2022 2023
            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'
2024
            code.putln(
2025
                "%s = %s; __Pyx_INCREF(%s); %s = %s;" % (
2026 2027
                    self.result(),
                    self.sequence.py_result(),
2028 2029 2030 2031
                    self.result(),
                    self.counter_cname,
                    init_value
                    ))
2032
        if not is_builtin_sequence:
Stefan Behnel's avatar
Stefan Behnel committed
2033
            self.iter_func_ptr = code.funcstate.allocate_temp(self._func_iternext_type, manage_ref=False)
Stefan Behnel's avatar
Stefan Behnel committed
2034
            if self.may_be_a_sequence:
Stefan Behnel's avatar
Stefan Behnel committed
2035
                code.putln("%s = NULL;" % self.iter_func_ptr)
2036
                code.putln("} else {")
2037 2038
                code.put("%s = -1; " % self.counter_cname)
            code.putln("%s = PyObject_GetIter(%s); %s" % (
2039 2040 2041
                    self.result(),
                    self.sequence.py_result(),
                    code.error_goto_if_null(self.result(), self.pos)))
2042
            code.put_gotref(self.py_result())
2043
            code.putln("%s = Py_TYPE(%s)->tp_iternext;" % (self.iter_func_ptr, self.py_result()))
Stefan Behnel's avatar
Stefan Behnel committed
2044 2045 2046 2047
        if self.may_be_a_sequence:
            code.putln("}")

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

    def generate_iter_next_result_code(self, result_name, code):
        sequence_type = self.sequence.type
2070 2071
        if self.reversed:
            code.putln("if (%s < 0) break;" % self.counter_cname)
Stefan Behnel's avatar
Stefan Behnel committed
2072 2073 2074 2075 2076 2077 2078 2079 2080
        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'):
2081 2082
                code.putln("if (!%s && Py%s_CheckExact(%s)) {" % (
                    self.iter_func_ptr, test_name, self.py_result()))
Stefan Behnel's avatar
Stefan Behnel committed
2083 2084 2085 2086 2087 2088 2089 2090 2091 2092 2093 2094 2095 2096 2097 2098 2099 2100
                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
2101

2102
    def free_temps(self, code):
2103 2104
        if self.counter_cname:
            code.funcstate.release_temp(self.counter_cname)
2105 2106 2107 2108
        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
2109 2110


2111
class NextNode(AtomicExprNode):
William Stein's avatar
William Stein committed
2112 2113 2114 2115 2116
    #  Used as part of for statement implementation.
    #  Implements result = iterator.next()
    #  Created during analyse_types phase.
    #  The iterator is not owned by this node.
    #
2117
    #  iterator   IteratorNode
2118

2119
    type = py_object_type
2120

2121
    def __init__(self, iterator):
William Stein's avatar
William Stein committed
2122 2123
        self.pos = iterator.pos
        self.iterator = iterator
2124 2125
        if iterator.type.is_ptr or iterator.type.is_array:
            self.type = iterator.type.base_type
William Stein's avatar
William Stein committed
2126
        self.is_temp = 1
2127

William Stein's avatar
William Stein committed
2128
    def generate_result_code(self, code):
Stefan Behnel's avatar
Stefan Behnel committed
2129
        self.iterator.generate_iter_next_result_code(self.result(), code)
2130

William Stein's avatar
William Stein committed
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 2159 2160 2161 2162 2163 2164 2165
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("}")


2166
class ExcValueNode(AtomicExprNode):
William Stein's avatar
William Stein committed
2167 2168 2169
    #  Node created during analyse_types phase
    #  of an ExceptClauseNode to fetch the current
    #  exception value.
2170

2171
    type = py_object_type
2172

2173
    def __init__(self, pos, env):
William Stein's avatar
William Stein committed
2174
        ExprNode.__init__(self, pos)
2175 2176

    def set_var(self, var):
2177
        self.var = var
2178

2179 2180 2181
    def calculate_result_code(self):
        return self.var

William Stein's avatar
William Stein committed
2182
    def generate_result_code(self, code):
2183
        pass
William Stein's avatar
William Stein committed
2184

2185 2186 2187
    def analyse_types(self, env):
        pass

William Stein's avatar
William Stein committed
2188

2189
class TempNode(ExprNode):
2190 2191 2192 2193 2194 2195 2196
    # 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.
2197 2198

    subexprs = []
2199

2200
    def __init__(self, pos, type, env=None):
William Stein's avatar
William Stein committed
2201 2202 2203 2204 2205
        ExprNode.__init__(self, pos)
        self.type = type
        if type.is_pyobject:
            self.result_ctype = py_object_type
        self.is_temp = 1
2206

2207 2208
    def analyse_types(self, env):
        return self.type
2209

2210 2211 2212
    def analyse_target_declaration(self, env):
        pass

William Stein's avatar
William Stein committed
2213 2214 2215
    def generate_result_code(self, code):
        pass

2216 2217 2218 2219 2220 2221 2222 2223 2224 2225 2226 2227 2228 2229 2230 2231 2232
    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
2233

2234 2235
    def release_temp_result(self, code):
        pass
William Stein's avatar
William Stein committed
2236 2237 2238

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

William Stein's avatar
William Stein committed
2240 2241 2242
    def __init__(self, pos, env):
        TempNode.__init__(self, pos, PyrexTypes.py_object_type, env)

2243 2244
class RawCNameExprNode(ExprNode):
    subexprs = []
2245

2246 2247 2248 2249 2250 2251 2252 2253 2254 2255 2256 2257 2258 2259 2260 2261
    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
2262

Mark Florisson's avatar
Mark Florisson committed
2263 2264 2265 2266 2267 2268 2269 2270
#-------------------------------------------------------------------
#
#  Parallel nodes (cython.parallel.thread(savailable|id))
#
#-------------------------------------------------------------------

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

Mark Florisson's avatar
Mark Florisson committed
2273 2274 2275 2276 2277 2278 2279 2280 2281
    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
2282
        # env.add_include_file("omp.h")
Mark Florisson's avatar
Mark Florisson committed
2283 2284 2285 2286 2287 2288 2289 2290 2291 2292 2293 2294 2295 2296 2297 2298 2299 2300 2301 2302 2303 2304 2305 2306
        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
2307
        # env.add_include_file("omp.h")
Mark Florisson's avatar
Mark Florisson committed
2308 2309 2310 2311 2312 2313 2314 2315 2316 2317 2318 2319 2320
        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
2321 2322 2323 2324 2325 2326
#-------------------------------------------------------------------
#
#  Trailer nodes
#
#-------------------------------------------------------------------

2327
class IndexNode(ExprNode):
William Stein's avatar
William Stein committed
2328 2329 2330 2331
    #  Sequence indexing.
    #
    #  base     ExprNode
    #  index    ExprNode
2332 2333 2334 2335 2336 2337
    #  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.
2338 2339 2340
    #
    #  is_fused_index boolean   Whether the index is used to specialize a
    #                           c(p)def function
2341

2342 2343 2344
    subexprs = ['base', 'index', 'indices']
    indices = None

2345 2346
    is_fused_index = False

2347 2348 2349 2350
    # Whether we're assigning to a buffer (in that case it needs to be
    # writable)
    writable_needed = False

2351 2352 2353
    # Whether we are indexing or slicing a memoryviewslice
    memslice_index = False
    memslice_slice = False
2354 2355
    is_memslice_copy = False
    memslice_ellipsis_noop = False
2356
    warned_untyped_idx = False
2357 2358
    # set by SingleAssignmentNode after analyse_types()
    is_memslice_scalar_assignment = False
2359

2360 2361 2362
    def __init__(self, pos, index, *args, **kw):
        ExprNode.__init__(self, pos, index=index, *args, **kw)
        self._index = index
2363 2364 2365 2366 2367

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

2368 2369 2370 2371 2372 2373 2374
    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)
2375

William Stein's avatar
William Stein committed
2376 2377
    def is_ephemeral(self):
        return self.base.is_ephemeral()
2378

2379
    def is_simple(self):
2380
        if self.is_buffer_access or self.memslice_index:
2381
            return False
2382 2383 2384
        elif self.memslice_slice:
            return True

2385 2386 2387 2388
        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
2389 2390
    def analyse_target_declaration(self, env):
        pass
2391

2392 2393 2394
    def analyse_as_type(self, env):
        base_type = self.base.analyse_as_type(env)
        if base_type and not base_type.is_pyobject:
2395
            if base_type.is_cpp_class:
2396
                if isinstance(self.index, TupleNode):
2397 2398 2399 2400 2401
                    template_values = self.index.args
                else:
                    template_values = [self.index]
                import Nodes
                type_node = Nodes.TemplatedTypeNode(
2402 2403
                    pos = self.pos,
                    positional_args = template_values,
2404 2405 2406 2407
                    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)))
2408
        return None
2409

Robert Bradshaw's avatar
Robert Bradshaw committed
2410
    def type_dependencies(self, env):
2411
        return self.base.type_dependencies(env) + self.index.type_dependencies(env)
2412

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

2427 2428
        index_type = self.index.infer_type(env)
        if index_type and index_type.is_int or isinstance(self.index, (IntNode, LongNode)):
2429 2430
            # indexing!
            if base_type is unicode_type:
2431 2432 2433
                # 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
2434 2435 2436 2437
                # 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.
2438
                return PyrexTypes.c_py_ucs4_type
2439 2440 2441
            elif base_type is str_type:
                # always returns str - Py2: bytes, Py3: unicode
                return base_type
2442 2443 2444 2445 2446 2447
            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
2448 2449
            elif base_type.is_ptr or base_type.is_array:
                return base_type.base_type
2450

2451
        # may be slicing or indexing, we don't know
2452 2453
        if base_type in (unicode_type, str_type):
            # these types always returns their own type on Python indexing/slicing
2454
            return base_type
2455 2456 2457
        else:
            # TODO: Handle buffers (hopefully without too much redundancy).
            return py_object_type
2458

William Stein's avatar
William Stein committed
2459
    def analyse_types(self, env):
Dag Sverre Seljebotn's avatar
Merge  
Dag Sverre Seljebotn committed
2460
        self.analyse_base_and_index_types(env, getting = 1)
2461

Dag Sverre Seljebotn's avatar
Merge  
Dag Sverre Seljebotn committed
2462 2463
    def analyse_target_types(self, env):
        self.analyse_base_and_index_types(env, setting = 1)
2464 2465
        if not self.is_lvalue():
            error(self.pos, "Assignment to non-lvalue of type '%s'" % self.type)
2466

2467
    def analyse_base_and_index_types(self, env, getting = 0, setting = 0, analyse_base = True):
2468 2469 2470
        # Note: This might be cleaned up by having IndexNode
        # parsed in a saner way and only construct the tuple if
        # needed.
2471 2472 2473 2474

        # 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.
2475 2476
        self.is_buffer_access = False

2477
        # a[...] = b
2478
        self.is_memslice_copy = False
2479 2480 2481 2482
        # incomplete indexing, Ellipsis indexing or slicing
        self.memslice_slice = False
        # integer indexing
        self.memslice_index = False
2483

2484 2485 2486
        if analyse_base:
            self.base.analyse_types(env)

2487 2488 2489 2490 2491
        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
2492

2493
        is_slice = isinstance(self.index, SliceNode)
2494

2495
        # Potentially overflowing index value.
2496
        if not is_slice and isinstance(self.index, IntNode) and Utils.long_literal(self.index.value):
2497
            self.index = self.index.coerce_to_pyobject(env)
2498

2499 2500
        is_memslice = self.base.type.is_memoryviewslice

2501
        # Handle the case where base is a literal char* (and we expect a string, not an int)
2502
        if not is_memslice and (isinstance(self.base, BytesNode) or is_slice):
Robert Bradshaw's avatar
Robert Bradshaw committed
2503
            if self.base.type.is_string or not (self.base.type.is_ptr or self.base.type.is_array):
2504
                self.base = self.base.coerce_to_pyobject(env)
2505 2506 2507

        skip_child_analysis = False
        buffer_access = False
Mark Florisson's avatar
Mark Florisson committed
2508

2509 2510 2511 2512 2513 2514 2515
        if self.indices:
            indices = self.indices
        elif isinstance(self.index, TupleNode):
            indices = self.index.args
        else:
            indices = [self.index]

2516
        if (is_memslice and not self.indices and
Mark Florisson's avatar
Mark Florisson committed
2517
                isinstance(self.index, EllipsisNode)):
2518
            # Memoryviewslice copying
2519
            self.is_memslice_copy = True
2520 2521 2522 2523 2524 2525

        elif is_memslice:
            # memoryviewslice indexing or slicing
            import MemoryView

            skip_child_analysis = True
2526
            newaxes = [newaxis for newaxis in indices if newaxis.is_none]
2527
            have_slices, indices = MemoryView.unellipsify(indices,
2528
                                                          newaxes,
2529
                                                          self.base.type.ndim)
2530 2531 2532

            self.memslice_index = (not newaxes and
                                   len(indices) == self.base.type.ndim)
2533 2534 2535 2536 2537
            axes = []

            index_type = PyrexTypes.c_py_ssize_t_type
            new_indices = []

2538
            if len(indices) - len(newaxes) > self.base.type.ndim:
2539 2540 2541 2542 2543
                self.type = error_type
                return error(indices[self.base.type.ndim].pos,
                             "Too many indices specified for type %s" %
                                                        self.base.type)

2544
            axis_idx = 0
2545 2546
            for i, index in enumerate(indices[:]):
                index.analyse_types(env)
2547 2548 2549 2550
                if not index.is_none:
                    access, packing = self.base.type.axes[axis_idx]
                    axis_idx += 1

2551 2552
                if isinstance(index, SliceNode):
                    self.memslice_slice = True
2553 2554
                    if index.step.is_none:
                        axes.append((access, packing))
2555 2556
                    else:
                        axes.append((access, 'strided'))
2557 2558 2559 2560 2561 2562

                    # 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)
2563
                            #value = value.coerce_to_temp(env)
2564 2565 2566
                            setattr(index, attr, value)
                            new_indices.append(value)

2567 2568 2569 2570 2571
                elif index.is_none:
                    self.memslice_slice = True
                    new_indices.append(index)
                    axes.append(('direct', 'strided'))

2572 2573 2574 2575 2576
                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
2577

2578
                    self.memslice_index = True
2579
                    index = index.coerce_to(index_type, env)
2580 2581 2582
                    indices[i] = index
                    new_indices.append(index)

2583
                else:
2584 2585
                    self.type = error_type
                    return error(index.pos, "Invalid index for memoryview specified")
2586

2587 2588
            self.memslice_index = self.memslice_index and not self.memslice_slice
            self.original_indices = indices
2589 2590
            # All indices with all start/stop/step for slices.
            # We need to keep this around
2591
            self.indices = new_indices
2592 2593
            self.env = env

2594 2595
        elif self.base.type.is_buffer:
            # Buffer indexing
2596
            if len(indices) == self.base.type.ndim:
2597 2598 2599 2600 2601 2602
                buffer_access = True
                skip_child_analysis = True
                for x in indices:
                    x.analyse_types(env)
                    if not x.type.is_int:
                        buffer_access = False
2603

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

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

2610 2611
        self.nogil = env.nogil

2612
        if buffer_access or self.memslice_index:
2613 2614 2615
            #if self.base.type.is_memoryviewslice and not self.base.is_name:
            #    self.base = self.base.coerce_to_temp(env)
            self.base = self.base.coerce_to_simple(env)
2616

2617
            self.indices = indices
2618
            self.index = None
2619 2620
            self.type = self.base.type.dtype
            self.is_buffer_access = True
2621
            self.buffer_type = self.base.type #self.base.entry.type
2622 2623

            if getting and self.type.is_pyobject:
2624
                self.is_temp = True
2625 2626

            if setting and self.base.type.is_memoryviewslice:
2627
                self.base.type.writable_needed = True
2628
            elif setting:
2629 2630 2631
                if not self.base.entry.type.writable:
                    error(self.pos, "Writing to readonly buffer")
                else:
2632
                    self.writable_needed = True
2633
                    if self.base.type.is_buffer:
2634
                        self.base.entry.buffer_aux.writable_needed = True
2635

2636
        elif self.is_memslice_copy:
Mark Florisson's avatar
Mark Florisson committed
2637 2638
            self.type = self.base.type
            if getting:
2639 2640 2641
                self.memslice_ellipsis_noop = True
            else:
                self.memslice_broadcast = True
2642

2643
        elif self.memslice_slice:
2644
            self.index = None
2645
            self.is_temp = True
2646
            self.use_managed_ref = True
2647 2648 2649 2650 2651

            if not MemoryView.validate_axes(self.pos, axes):
                self.type = error_type
                return

2652 2653
            self.type = PyrexTypes.MemoryViewSliceType(
                            self.base.type.dtype, axes)
2654 2655 2656 2657 2658 2659

            if (self.base.type.is_memoryviewslice and not
                    self.base.is_name and not
                    self.base.result_in_temp()):
                self.base = self.base.coerce_to_temp(env)

2660 2661
            if setting:
                self.memslice_broadcast = True
2662

2663
        else:
2664
            base_type = self.base.type
2665 2666 2667 2668 2669 2670 2671 2672 2673

            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
2674 2675
            if base_type.is_unicode_char:
                # we infer Py_UNICODE/Py_UCS4 for unicode strings in some
2676 2677 2678 2679 2680 2681 2682
                # 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
2683
            if base_type.is_pyobject:
2684
                if self.index.type.is_int:
2685
                    if (not setting
2686
                        and (base_type in (list_type, tuple_type))
2687 2688
                        and (not self.index.type.signed
                             or not env.directives['wraparound']
2689 2690
                             or (isinstance(self.index, IntNode) and
                                 self.index.has_constant_result() and self.index.constant_result >= 0))
2691 2692 2693 2694
                        and not env.directives['boundscheck']):
                        self.is_temp = 0
                    else:
                        self.is_temp = 1
2695 2696 2697
                    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)
2698
                    self.is_temp = 1
2699
                if self.index.type.is_int and base_type is unicode_type:
Stefan Behnel's avatar
Stefan Behnel committed
2700
                    # Py_UNICODE/Py_UCS4 will automatically coerce to a unicode string
2701
                    # if required, so this is fast and safe
2702
                    self.type = PyrexTypes.c_py_ucs4_type
2703 2704
                elif is_slice and base_type in (bytes_type, str_type, unicode_type, list_type, tuple_type):
                    self.type = base_type
2705
                else:
2706 2707 2708
                    if base_type in (list_type, tuple_type, dict_type):
                        # do the None check explicitly (not in a helper) to allow optimising it away
                        self.base = self.base.as_none_safe_node("'NoneType' object is not subscriptable")
2709
                    self.type = py_object_type
William Stein's avatar
William Stein committed
2710
            else:
2711 2712
                if base_type.is_ptr or base_type.is_array:
                    self.type = base_type.base_type
2713 2714 2715
                    if is_slice:
                        self.type = base_type
                    elif self.index.type.is_pyobject:
Robert Bradshaw's avatar
Robert Bradshaw committed
2716 2717
                        self.index = self.index.coerce_to(
                            PyrexTypes.c_py_ssize_t_type, env)
2718
                    elif not self.index.type.is_int:
Robert Bradshaw's avatar
Robert Bradshaw committed
2719 2720 2721
                        error(self.pos,
                            "Invalid index type '%s'" %
                                self.index.type)
2722
                elif base_type.is_cpp_class:
2723
                    function = env.lookup_operator("[]", [self.base, self.index])
Robert Bradshaw's avatar
Robert Bradshaw committed
2724
                    if function is None:
2725
                        error(self.pos, "Indexing '%s' not supported for index type '%s'" % (base_type, self.index.type))
Robert Bradshaw's avatar
Robert Bradshaw committed
2726 2727 2728 2729 2730 2731 2732 2733 2734
                        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
2735
                        error(self.pos, "Can't set non-reference result '%s'" % self.type)
2736 2737
                elif fused_index_operation:
                    self.parse_indexed_fused_cdef(env)
2738 2739 2740
                else:
                    error(self.pos,
                        "Attempting to index non-array type '%s'" %
2741
                            base_type)
2742
                    self.type = PyrexTypes.error_type
Stefan Behnel's avatar
Stefan Behnel committed
2743

2744 2745 2746 2747 2748 2749 2750 2751 2752 2753 2754 2755 2756 2757 2758 2759 2760 2761
        self.wrap_in_nonecheck_node(env, getting)

    def wrap_in_nonecheck_node(self, env, getting):
        if not env.directives['nonecheck'] or not self.base.may_be_none():
            return

        if self.base.type.is_memoryviewslice:
            if self.is_memslice_copy and not getting:
                msg = "Cannot assign to None memoryview slice"
            elif self.memslice_slice:
                msg = "Cannot slice None memoryview slice"
            else:
                msg = "Cannot index None memoryview slice"
        else:
            msg = "'NoneType' object is not subscriptable"

        self.base = self.base.as_none_safe_node(msg)

2762 2763 2764 2765 2766 2767 2768 2769 2770
    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.
        """
2771
        self.type = PyrexTypes.error_type
2772

2773 2774
        self.is_fused_index = True

Mark Florisson's avatar
Mark Florisson committed
2775
        base_type = self.base.type
2776 2777 2778
        specific_types = []
        positions = []

2779
        if self.index.is_name or self.index.is_attribute:
2780 2781 2782 2783 2784
            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)
2785 2786
                specific_type = arg.analyse_as_type(env)
                specific_types.append(specific_type)
2787
        else:
2788
            specific_types = [False]
2789

2790 2791 2792 2793
        if not Utils.all(specific_types):
            self.index.analyse_types(env)

            if not self.base.entry.as_variable:
2794
                error(self.pos, "Can only index fused functions with types")
2795 2796
            else:
                # A cpdef function indexed with Python objects
2797 2798
                self.base.entry = self.entry = self.base.entry.as_variable
                self.base.type = self.type = self.entry.type
2799

2800 2801 2802 2803 2804 2805
                self.base.is_temp = True
                self.is_temp = True

                self.entry.used = True

            self.is_fused_index = False
2806 2807
            return

Mark Florisson's avatar
Mark Florisson committed
2808 2809 2810
        for i, type in enumerate(specific_types):
            specific_types[i] = type.specialize_fused(env)

2811 2812
        fused_types = base_type.get_fused_types()
        if len(specific_types) > len(fused_types):
2813 2814 2815 2816 2817
            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)
2818 2819 2820 2821 2822 2823 2824

        # 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]):
2825
                return error(pos, "Type not in fused type")
2826 2827 2828 2829 2830 2831 2832

            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)

2833 2834 2835 2836 2837
        if type.is_fused:
            # Only partially specific, this is invalid
            error(self.pos,
                  "Index operation makes function only partially specific")
        else:
2838
            # Fully specific, find the signature with the specialized entry
2839
            for signature in self.base.type.get_all_specialized_function_types():
2840 2841
                if type.same_as(signature):
                    self.type = signature
Mark Florisson's avatar
Mark Florisson committed
2842 2843 2844 2845 2846

                    if self.base.is_attribute:
                        # Pretend to be a normal attribute, for cdef extension
                        # methods
                        self.entry = signature.entry
2847
                        self.is_attribute = True
Mark Florisson's avatar
Mark Florisson committed
2848
                        self.obj = self.base.obj
2849 2850 2851 2852

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

2854 2855
                    break
            else:
Mark Florisson's avatar
Mark Florisson committed
2856 2857
                # This is a bug
                raise InternalError("Couldn't find the right signature")
2858

2859 2860
    gil_message = "Indexing Python object"

2861
    def nogil_check(self, env):
2862 2863
        if self.is_buffer_access or self.memslice_index or self.memslice_slice:
            if not self.memslice_slice and env.directives['boundscheck']:
2864 2865 2866 2867 2868
                # error(self.pos, "Cannot check buffer index bounds without gil; "
                #                 "use boundscheck(False) directive")
                warning(self.pos, "Use boundscheck(False) for faster access",
                        level=1)
            if self.type.is_pyobject:
2869 2870
                error(self.pos, "Cannot access buffer with object dtype without gil")
                return
2871
        super(IndexNode, self).nogil_check(env)
2872 2873


William Stein's avatar
William Stein committed
2874
    def check_const_addr(self):
2875
        return self.base.check_const_addr() and self.index.check_const()
2876

William Stein's avatar
William Stein committed
2877
    def is_lvalue(self):
2878 2879 2880 2881 2882
        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
2883

William Stein's avatar
William Stein committed
2884
    def calculate_result_code(self):
2885
        if self.is_buffer_access:
2886
            return "(*%s)" % self.buffer_ptr_code
2887 2888
        elif self.is_memslice_copy:
            return self.base.result()
2889 2890 2891 2892
        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())
2893 2894
        elif (self.type.is_ptr or self.type.is_array) and self.type == self.base.type:
            error(self.pos, "Invalid use of pointer slice")
2895 2896
        else:
            return "(%s[%s])" % (
2897
                self.base.result(), self.index.result())
2898

2899
    def extra_index_params(self):
Dag Sverre Seljebotn's avatar
Merge  
Dag Sverre Seljebotn committed
2900 2901
        if self.index.type.is_int:
            if self.original_index_type.signed:
2902
                size_adjustment = ""
Dag Sverre Seljebotn's avatar
Merge  
Dag Sverre Seljebotn committed
2903
            else:
2904 2905
                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
2906 2907
        else:
            return ""
2908 2909 2910

    def generate_subexpr_evaluation_code(self, code):
        self.base.generate_evaluation_code(code)
2911
        if self.indices is None:
2912 2913
            self.index.generate_evaluation_code(code)
        else:
2914 2915
            for i in self.indices:
                i.generate_evaluation_code(code)
2916

2917 2918
    def generate_subexpr_disposal_code(self, code):
        self.base.generate_disposal_code(code)
2919
        if self.indices is None:
2920 2921
            self.index.generate_disposal_code(code)
        else:
2922 2923
            for i in self.indices:
                i.generate_disposal_code(code)
2924

2925 2926
    def free_subexpr_temps(self, code):
        self.base.free_temps(code)
2927
        if self.indices is None:
2928 2929 2930 2931 2932
            self.index.free_temps(code)
        else:
            for i in self.indices:
                i.free_temps(code)

William Stein's avatar
William Stein committed
2933
    def generate_result_code(self, code):
2934
        if self.is_buffer_access or self.memslice_index:
2935
            buffer_entry, self.buffer_ptr_code = self.buffer_lookup_code(code)
2936 2937 2938
            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
2939
                code.putln("__Pyx_INCREF((PyObject*)%s);" % self.result())
2940 2941 2942 2943

        elif self.memslice_slice:
            self.put_memoryviewslice_slice_code(code)

2944 2945 2946 2947 2948 2949 2950 2951 2952 2953 2954
        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)
2955
                else:
2956 2957 2958
                    index_code = self.index.py_result()
                    if self.base.type is dict_type:
                        function = "__Pyx_PyDict_GetItem"
2959 2960
                        code.globalstate.use_utility_code(
                            UtilityCode.load_cached("DictGetItem", "ObjectHandling.c"))
2961 2962 2963 2964 2965 2966 2967 2968 2969 2970 2971 2972
                    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
2973
            elif self.type.is_unicode_char and self.base.type is unicode_type:
2974 2975 2976
                assert self.index.type.is_int
                index_code = self.index.result()
                function = "__Pyx_GetItemInt_Unicode"
2977 2978
                code.globalstate.use_utility_code(getitem_int_pyunicode_utility_code)
                code.putln(
2979
                    "%s = %s(%s, %s%s); if (unlikely(%s == (Py_UCS4)-1)) %s;" % (
2980 2981 2982 2983 2984 2985 2986
                        self.result(),
                        function,
                        self.base.py_result(),
                        index_code,
                        self.extra_index_params(),
                        self.result(),
                        code.error_goto(self.pos)))
2987

Dag Sverre Seljebotn's avatar
Merge  
Dag Sverre Seljebotn committed
2988 2989 2990
    def generate_setitem_code(self, value_code, code):
        if self.index.type.is_int:
            function = "__Pyx_SetItemInt"
2991
            index_code = self.index.result()
2992
            code.globalstate.use_utility_code(setitem_int_utility_code)
Dag Sverre Seljebotn's avatar
Merge  
Dag Sverre Seljebotn committed
2993 2994
        else:
            index_code = self.index.py_result()
2995 2996
            if self.base.type is dict_type:
                function = "PyDict_SetItem"
Craig Citro's avatar
Craig Citro committed
2997
            # It would seem that we could specialized lists/tuples, but that
2998 2999 3000 3001 3002 3003
            # 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).
3004 3005
            else:
                function = "PyObject_SetItem"
3006
        code.putln(
Dag Sverre Seljebotn's avatar
Merge  
Dag Sverre Seljebotn committed
3007 3008
            "if (%s(%s, %s, %s%s) < 0) %s" % (
                function,
3009
                self.base.py_result(),
Dag Sverre Seljebotn's avatar
Merge  
Dag Sverre Seljebotn committed
3010 3011
                index_code,
                value_code,
3012
                self.extra_index_params(),
Dag Sverre Seljebotn's avatar
Merge  
Dag Sverre Seljebotn committed
3013
                code.error_goto(self.pos)))
3014 3015 3016

    def generate_buffer_setitem_code(self, rhs, code, op=""):
        # Used from generate_assignment_code and InPlaceAssignmentNode
3017 3018
        buffer_entry, ptrexpr = self.buffer_lookup_code(code)

3019 3020 3021
        if self.buffer_type.dtype.is_pyobject:
            # Must manage refcounts. Decref what is already there
            # and incref what we put in.
3022 3023
            ptr = code.funcstate.allocate_temp(buffer_entry.buf_ptr_type,
                                               manage_ref=False)
3024
            rhs_code = rhs.result()
3025
            code.putln("%s = %s;" % (ptr, ptrexpr))
3026
            code.put_gotref("*%s" % ptr)
Dag Sverre Seljebotn's avatar
Dag Sverre Seljebotn committed
3027
            code.putln("__Pyx_DECREF(*%s); __Pyx_INCREF(%s);" % (
3028 3029 3030
                ptr, rhs_code
                ))
            code.putln("*%s %s= %s;" % (ptr, op, rhs_code))
3031
            code.put_giveref("*%s" % ptr)
3032
            code.funcstate.release_temp(ptr)
3033
        else:
3034
            # Simple case
3035
            code.putln("*%s %s= %s;" % (ptrexpr, op, rhs.result()))
3036

William Stein's avatar
William Stein committed
3037
    def generate_assignment_code(self, rhs, code):
3038 3039 3040 3041 3042 3043 3044
        generate_evaluation_code = (self.is_memslice_scalar_assignment or
                                    self.memslice_slice)
        if generate_evaluation_code:
            self.generate_evaluation_code(code)
        else:
            self.generate_subexpr_evaluation_code(code)

3045
        if self.is_buffer_access or self.memslice_index:
3046
            self.generate_buffer_setitem_code(rhs, code)
3047 3048
        elif self.is_memslice_scalar_assignment:
            self.generate_memoryviewslice_assign_scalar_code(rhs, code)
3049
        elif self.memslice_slice or self.is_memslice_copy:
3050
            self.generate_memoryviewslice_setslice_code(rhs, code)
3051
        elif self.type.is_pyobject:
Dag Sverre Seljebotn's avatar
Merge  
Dag Sverre Seljebotn committed
3052
            self.generate_setitem_code(rhs.py_result(), code)
William Stein's avatar
William Stein committed
3053 3054 3055
        else:
            code.putln(
                "%s = %s;" % (
3056
                    self.result(), rhs.result()))
3057 3058 3059 3060 3061 3062 3063

        if generate_evaluation_code:
            self.generate_disposal_code(code)
        else:
            self.generate_subexpr_disposal_code(code)
            self.free_subexpr_temps(code)

William Stein's avatar
William Stein committed
3064
        rhs.generate_disposal_code(code)
3065
        rhs.free_temps(code)
3066

William Stein's avatar
William Stein committed
3067 3068
    def generate_deletion_code(self, code):
        self.generate_subexpr_evaluation_code(code)
Dag Sverre Seljebotn's avatar
Merge  
Dag Sverre Seljebotn committed
3069 3070
        #if self.type.is_pyobject:
        if self.index.type.is_int:
3071
            function = "__Pyx_DelItemInt"
3072
            index_code = self.index.result()
3073
            code.globalstate.use_utility_code(delitem_int_utility_code)
Dag Sverre Seljebotn's avatar
Merge  
Dag Sverre Seljebotn committed
3074 3075
        else:
            index_code = self.index.py_result()
3076 3077 3078 3079
            if self.base.type is dict_type:
                function = "PyDict_DelItem"
            else:
                function = "PyObject_DelItem"
Dag Sverre Seljebotn's avatar
Merge  
Dag Sverre Seljebotn committed
3080
        code.putln(
3081
            "if (%s(%s, %s%s) < 0) %s" % (
Dag Sverre Seljebotn's avatar
Merge  
Dag Sverre Seljebotn committed
3082
                function,
William Stein's avatar
William Stein committed
3083
                self.base.py_result(),
Dag Sverre Seljebotn's avatar
Merge  
Dag Sverre Seljebotn committed
3084
                index_code,
3085
                self.extra_index_params(),
Dag Sverre Seljebotn's avatar
Merge  
Dag Sverre Seljebotn committed
3086
                code.error_goto(self.pos)))
William Stein's avatar
William Stein committed
3087
        self.generate_subexpr_disposal_code(code)
3088
        self.free_subexpr_temps(code)
3089

3090 3091 3092
    def buffer_entry(self):
        import Buffer, MemoryView

3093 3094 3095 3096 3097 3098
        base = self.base
        if self.base.is_nonecheck:
            base = base.arg

        if base.is_name:
            entry = base.entry
3099
        else:
3100
            # SimpleCallNode is_simple is not consistent with coerce_to_simple
3101 3102
            assert base.is_simple() or base.is_temp
            cname = base.result()
3103 3104 3105 3106 3107 3108 3109 3110 3111
            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

3112
    def buffer_lookup_code(self, code):
3113
        "ndarray[1, 2, 3] and memslice[1, 2, 3]"
3114
        # Assign indices to temps
3115 3116 3117
        index_temps = [code.funcstate.allocate_temp(i.type, manage_ref=False)
                           for i in self.indices]

3118
        for temp, index in zip(index_temps, self.indices):
3119
            code.putln("%s = %s;" % (temp, index.result()))
3120

3121
        # Generate buffer access code using these temps
3122
        import Buffer, MemoryView
3123

3124
        buffer_entry = self.buffer_entry()
3125

3126
        if buffer_entry.type.is_buffer:
3127
            negative_indices = buffer_entry.type.negative_indices
3128 3129 3130
        else:
            negative_indices = Buffer.buffer_defaults['negative_indices']

3131 3132 3133 3134 3135 3136
        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,
3137 3138
               negative_indices=negative_indices,
               in_nogil_context=self.in_nogil_context)
William Stein's avatar
William Stein committed
3139

3140
    def put_memoryviewslice_slice_code(self, code):
3141
        "memslice[:]"
3142
        buffer_entry = self.buffer_entry()
3143
        have_gil = not self.in_nogil_context
3144

3145 3146 3147 3148 3149 3150
        if sys.version_info < (3,):
            def next_(it):
                return it.next()
        else:
            next_ = next

3151 3152 3153 3154 3155 3156 3157
        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:
3158
                    index.start = next_(it)
3159
                if not index.stop.is_none:
3160
                    index.stop = next_(it)
3161
                if not index.step.is_none:
3162
                    index.step = next_(it)
3163
            else:
3164
                next_(it)
3165 3166 3167 3168

        assert not list(it)

        buffer_entry.generate_buffer_slice_code(code, self.original_indices,
3169
                                                self.result(),
3170 3171
                                                have_gil=have_gil,
                                                have_slices=have_slices)
William Stein's avatar
William Stein committed
3172

3173
    def generate_memoryviewslice_setslice_code(self, rhs, code):
3174
        "memslice1[...] = memslice2 or memslice1[:] = memslice2"
3175 3176 3177
        import MemoryView
        MemoryView.copy_broadcast_memview_src_to_dst(rhs, self, code)

3178 3179 3180 3181 3182
    def generate_memoryviewslice_assign_scalar_code(self, rhs, code):
        "memslice1[...] = 0.0 or memslice1[:] = 0.0"
        import MemoryView
        MemoryView.assign_scalar(self, rhs, code)

3183

3184
class SliceIndexNode(ExprNode):
William Stein's avatar
William Stein committed
3185 3186 3187 3188 3189
    #  2-element slice indexing
    #
    #  base      ExprNode
    #  start     ExprNode or None
    #  stop      ExprNode or None
3190

William Stein's avatar
William Stein committed
3191
    subexprs = ['base', 'start', 'stop']
3192

3193 3194 3195 3196 3197 3198 3199
    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
3200 3201
        elif base_type.is_ptr or base_type.is_array:
            return PyrexTypes.c_array_type(base_type.base_type, None)
3202 3203
        return py_object_type

3204 3205 3206 3207
    def calculate_constant_result(self):
        self.constant_result = self.base.constant_result[
            self.start.constant_result : self.stop.constant_result]

3208 3209
    def compile_time_value(self, denv):
        base = self.base.compile_time_value(denv)
3210 3211 3212 3213 3214 3215 3216 3217
        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)
3218 3219 3220 3221
        try:
            return base[start:stop]
        except Exception, e:
            self.compile_time_value_error(e)
3222

William Stein's avatar
William Stein committed
3223 3224
    def analyse_target_declaration(self, env):
        pass
3225

3226
    def analyse_target_types(self, env):
3227
        self.analyse_types(env, getting=False)
3228
        # when assigning, we must accept any Python type
3229 3230
        if self.type.is_pyobject:
            self.type = py_object_type
William Stein's avatar
William Stein committed
3231

3232
    def analyse_types(self, env, getting=True):
William Stein's avatar
William Stein committed
3233
        self.base.analyse_types(env)
3234 3235 3236 3237 3238 3239 3240 3241 3242 3243 3244 3245 3246 3247 3248 3249 3250 3251 3252 3253

        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
3254 3255 3256 3257
        if self.start:
            self.start.analyse_types(env)
        if self.stop:
            self.stop.analyse_types(env)
3258 3259 3260
        base_type = self.base.type
        if base_type.is_string:
            self.type = bytes_type
3261 3262 3263
        elif base_type.is_ptr:
            self.type = base_type
        elif base_type.is_array:
3264 3265 3266
            # we need a ptr type here instead of an array type, as
            # array types can result in invalid type casts in the C
            # code
3267
            self.type = PyrexTypes.CPtrType(base_type.base_type)
3268 3269 3270
        else:
            self.base = self.base.coerce_to_pyobject(env)
            self.type = py_object_type
3271 3272 3273
        if base_type.is_builtin_type:
            # slicing builtin types returns something of the same type
            self.type = base_type
3274
        c_int = PyrexTypes.c_py_ssize_t_type
William Stein's avatar
William Stein committed
3275 3276 3277 3278 3279
        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
3280

3281
    nogil_check = Node.gil_error
3282 3283
    gil_message = "Slicing Python object"

William Stein's avatar
William Stein committed
3284
    def generate_result_code(self, code):
3285 3286 3287 3288
        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
3289 3290 3291
        if self.base.type.is_string:
            if self.stop is None:
                code.putln(
3292
                    "%s = PyBytes_FromString(%s + %s); %s" % (
Robert Bradshaw's avatar
Robert Bradshaw committed
3293 3294 3295 3296 3297 3298
                        self.result(),
                        self.base.result(),
                        self.start_code(),
                        code.error_goto_if_null(self.result(), self.pos)))
            else:
                code.putln(
3299
                    "%s = PyBytes_FromStringAndSize(%s + %s, %s - %s); %s" % (
Robert Bradshaw's avatar
Robert Bradshaw committed
3300 3301 3302 3303 3304 3305 3306 3307
                        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(
3308
                "%s = __Pyx_PySequence_GetSlice(%s, %s, %s); %s" % (
Robert Bradshaw's avatar
Robert Bradshaw committed
3309 3310 3311 3312 3313
                    self.result(),
                    self.base.py_result(),
                    self.start_code(),
                    self.stop_code(),
                    code.error_goto_if_null(self.result(), self.pos)))
3314
        code.put_gotref(self.py_result())
3315

William Stein's avatar
William Stein committed
3316 3317
    def generate_assignment_code(self, rhs, code):
        self.generate_subexpr_evaluation_code(code)
3318
        if self.type.is_pyobject:
3319
            code.put_error_if_neg(self.pos,
3320
                "__Pyx_PySequence_SetSlice(%s, %s, %s, %s)" % (
3321 3322 3323
                    self.base.py_result(),
                    self.start_code(),
                    self.stop_code(),
Lisandro Dalcin's avatar
Lisandro Dalcin committed
3324
                    rhs.py_result()))
3325 3326 3327 3328 3329 3330 3331 3332
        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
3333 3334
            if rhs.type.is_array:
                array_length = rhs.type.size
3335
                self.generate_slice_guard_code(code, array_length)
Stefan Behnel's avatar
Stefan Behnel committed
3336
            else:
Stefan Behnel's avatar
Stefan Behnel committed
3337 3338
                error(self.pos,
                      "Slice assignments from pointers are not yet supported.")
Stefan Behnel's avatar
Stefan Behnel committed
3339 3340
                # FIXME: fix the array size according to start/stop
                array_length = self.base.type.size
3341 3342 3343 3344
            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
3345
        self.generate_subexpr_disposal_code(code)
3346
        self.free_subexpr_temps(code)
William Stein's avatar
William Stein committed
3347
        rhs.generate_disposal_code(code)
3348
        rhs.free_temps(code)
William Stein's avatar
William Stein committed
3349 3350

    def generate_deletion_code(self, code):
Robert Bradshaw's avatar
Robert Bradshaw committed
3351
        if not self.base.type.is_pyobject:
3352 3353 3354
            error(self.pos,
                  "Deleting slices is only supported for Python types, not '%s'." % self.type)
            return
William Stein's avatar
William Stein committed
3355
        self.generate_subexpr_evaluation_code(code)
Robert Bradshaw's avatar
Robert Bradshaw committed
3356
        code.put_error_if_neg(self.pos,
3357
            "__Pyx_PySequence_DelSlice(%s, %s, %s)" % (
William Stein's avatar
William Stein committed
3358 3359
                self.base.py_result(),
                self.start_code(),
Robert Bradshaw's avatar
Robert Bradshaw committed
3360
                self.stop_code()))
William Stein's avatar
William Stein committed
3361
        self.generate_subexpr_disposal_code(code)
3362
        self.free_subexpr_temps(code)
3363 3364 3365 3366 3367 3368 3369 3370 3371 3372

    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
3373
                if stop < 0:
3374
                    slice_size = self.base.type.size + stop
Stefan Behnel's avatar
Stefan Behnel committed
3375 3376
                else:
                    slice_size = stop
3377 3378 3379 3380 3381 3382 3383 3384 3385 3386 3387 3388 3389 3390 3391 3392 3393 3394 3395 3396 3397 3398 3399 3400 3401 3402 3403 3404 3405 3406
                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))
3407
            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));' % (
3408 3409 3410
                        target_size, check))
            code.putln(code.error_goto(self.pos))
            code.putln("}")
3411

William Stein's avatar
William Stein committed
3412 3413
    def start_code(self):
        if self.start:
3414
            return self.start.result()
William Stein's avatar
William Stein committed
3415 3416
        else:
            return "0"
3417

William Stein's avatar
William Stein committed
3418 3419
    def stop_code(self):
        if self.stop:
3420
            return self.stop.result()
3421 3422
        elif self.base.type.is_array:
            return self.base.type.size
William Stein's avatar
William Stein committed
3423
        else:
3424
            return "PY_SSIZE_T_MAX"
3425

William Stein's avatar
William Stein committed
3426
    def calculate_result_code(self):
3427
        # self.result() is not used, but this method must exist
William Stein's avatar
William Stein committed
3428
        return "<unused>"
3429

William Stein's avatar
William Stein committed
3430

3431
class SliceNode(ExprNode):
William Stein's avatar
William Stein committed
3432 3433 3434 3435 3436
    #  start:stop:step in subscript list
    #
    #  start     ExprNode
    #  stop      ExprNode
    #  step      ExprNode
3437

3438 3439
    subexprs = ['start', 'stop', 'step']

3440 3441
    type = py_object_type
    is_temp = 1
3442 3443

    def calculate_constant_result(self):
3444 3445 3446 3447
        self.constant_result = slice(
            self.start.constant_result,
            self.stop.constant_result,
            self.step.constant_result)
3448

3449 3450
    def compile_time_value(self, denv):
        start = self.start.compile_time_value(denv)
Stefan Behnel's avatar
Stefan Behnel committed
3451 3452
        stop = self.stop.compile_time_value(denv)
        step = self.step.compile_time_value(denv)
3453 3454 3455 3456 3457
        try:
            return slice(start, stop, step)
        except Exception, e:
            self.compile_time_value_error(e)

William Stein's avatar
William Stein committed
3458 3459 3460 3461 3462 3463 3464
    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)
3465 3466 3467
        if self.start.is_literal and self.stop.is_literal and self.step.is_literal:
            self.is_literal = True
            self.is_temp = False
3468 3469 3470

    gil_message = "Constructing Python slice object"

3471 3472 3473
    def calculate_result_code(self):
        return self.result_code

William Stein's avatar
William Stein committed
3474
    def generate_result_code(self, code):
3475 3476 3477 3478 3479
        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
3480
        code.putln(
Robert Bradshaw's avatar
Robert Bradshaw committed
3481
            "%s = PySlice_New(%s, %s, %s); %s" % (
3482
                self.result(),
3483 3484
                self.start.py_result(),
                self.stop.py_result(),
William Stein's avatar
William Stein committed
3485
                self.step.py_result(),
3486
                code.error_goto_if_null(self.result(), self.pos)))
3487
        code.put_gotref(self.py_result())
3488 3489
        if self.is_literal:
            code.put_giveref(self.py_result())
William Stein's avatar
William Stein committed
3490

3491 3492 3493 3494 3495 3496 3497 3498 3499 3500 3501 3502 3503
    def __deepcopy__(self, memo):
        """
        There is a copy bug in python 2.4 for slice objects.
        """
        return SliceNode(
            self.pos,
            start=copy.deepcopy(self.start, memo),
            stop=copy.deepcopy(self.stop, memo),
            step=copy.deepcopy(self.step, memo),
            is_temp=self.is_temp,
            is_literal=self.is_literal,
            constant_result=self.constant_result)

3504

3505
class CallNode(ExprNode):
3506

Stefan Behnel's avatar
Stefan Behnel committed
3507 3508 3509
    # allow overriding the default 'may_be_none' behaviour
    may_return_none = None

3510 3511 3512 3513 3514 3515 3516 3517 3518 3519 3520 3521 3522 3523 3524 3525 3526 3527 3528 3529 3530
    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
3531 3532 3533 3534 3535
    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
3536 3537 3538 3539 3540
    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
3541 3542 3543 3544 3545 3546
    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):
3547
                items.append(DictItemNode(pos=arg.pos, key=StringNode(pos=arg.pos, value=member.name), value=arg))
Robert Bradshaw's avatar
Robert Bradshaw committed
3548 3549 3550 3551 3552 3553 3554
            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
3555 3556 3557 3558 3559 3560 3561 3562 3563
        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
3564

3565 3566
    def is_lvalue(self):
        return self.type.is_reference
3567

3568
    def nogil_check(self, env):
3569 3570
        func_type = self.function_type()
        if func_type.is_pyobject:
3571
            self.gil_error()
3572
        elif not getattr(func_type, 'nogil', False):
3573
            self.gil_error()
3574 3575 3576

    gil_message = "Calling gil-requiring function"

3577 3578

class SimpleCallNode(CallNode):
William Stein's avatar
William Stein committed
3579 3580 3581 3582 3583 3584 3585
    #  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
3586
    #  wrapper_call   bool                 used internally
3587
    #  has_optional_args   bool            used internally
3588
    #  nogil          bool                 used internally
3589

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

William Stein's avatar
William Stein committed
3592 3593 3594
    self = None
    coerced_self = None
    arg_tuple = None
3595
    wrapper_call = False
3596
    has_optional_args = False
3597
    nogil = False
3598
    analysed = False
3599

3600 3601 3602 3603 3604 3605 3606
    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)
3607

3608
    def analyse_as_type(self, env):
3609
        attr = self.function.as_cython_attribute()
3610 3611 3612 3613 3614 3615 3616 3617 3618 3619 3620 3621
        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
3622

William Stein's avatar
William Stein committed
3623
    def analyse_types(self, env):
Robert Bradshaw's avatar
Robert Bradshaw committed
3624 3625
        if self.analyse_as_type_constructor(env):
            return
3626 3627 3628
        if self.analysed:
            return
        self.analysed = True
William Stein's avatar
William Stein committed
3629 3630 3631
        function = self.function
        function.is_called = 1
        self.function.analyse_types(env)
Mark Florisson's avatar
Mark Florisson committed
3632

William Stein's avatar
William Stein committed
3633 3634 3635 3636 3637
        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
3638

William Stein's avatar
William Stein committed
3639 3640
        func_type = self.function_type()
        if func_type.is_pyobject:
3641 3642
            self.arg_tuple = TupleNode(self.pos, args = self.args)
            self.arg_tuple.analyse_types(env)
William Stein's avatar
William Stein committed
3643
            self.args = None
3644 3645 3646
            if func_type is Builtin.type_type and function.is_name and \
                   function.entry and \
                   function.entry.is_builtin and \
3647 3648 3649 3650 3651 3652 3653 3654 3655
                   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
3656
                self.may_return_none = False
3657
            elif function.is_name and function.type_entry:
3658 3659 3660 3661 3662
                # 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
3663
                self.may_return_none = False
3664 3665
            else:
                self.type = py_object_type
William Stein's avatar
William Stein committed
3666 3667 3668 3669
            self.is_temp = 1
        else:
            for arg in self.args:
                arg.analyse_types(env)
3670

William Stein's avatar
William Stein committed
3671 3672
            if self.self and func_type.args:
                # Coerce 'self' to the type expected by the method.
3673 3674 3675
                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(
3676 3677 3678
                        "'NoneType' object has no attribute '%s'",
                        error = 'PyExc_AttributeError',
                        format_args = [self.function.entry.name])
3679
                expected_type = self_arg.type
Stefan Behnel's avatar
Stefan Behnel committed
3680 3681 3682 3683 3684
                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
3685 3686 3687
                # Insert coerced 'self' argument into argument list.
                self.args.insert(0, self.coerced_self)
            self.analyse_c_function_call(env)
3688

William Stein's avatar
William Stein committed
3689 3690
    def function_type(self):
        # Return the type of the function being called, coercing a function
3691 3692
        # pointer to a function if necessary. If the function has fused
        # arguments, return the specific type.
William Stein's avatar
William Stein committed
3693
        func_type = self.function.type
3694

William Stein's avatar
William Stein committed
3695 3696
        if func_type.is_ptr:
            func_type = func_type.base_type
3697

William Stein's avatar
William Stein committed
3698
        return func_type
3699

3700 3701 3702 3703 3704 3705 3706
    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
3707
    def analyse_c_function_call(self, env):
Robert Bradshaw's avatar
Robert Bradshaw committed
3708
        if self.function.type is error_type:
3709
            self.type = error_type
Robert Bradshaw's avatar
Robert Bradshaw committed
3710
            return
3711

Robert Bradshaw's avatar
Robert Bradshaw committed
3712
        if self.function.type.is_cpp_class:
3713 3714
            overloaded_entry = self.function.type.scope.lookup("operator()")
            if overloaded_entry is None:
Robert Bradshaw's avatar
Robert Bradshaw committed
3715 3716 3717
                self.type = PyrexTypes.error_type
                self.result_code = "<error>"
                return
3718 3719
        elif hasattr(self.function, 'entry'):
            overloaded_entry = self.function.entry
3720
        elif (isinstance(self.function, IndexNode) and
3721
              self.function.is_fused_index):
3722
            overloaded_entry = self.function.type.entry
Robert Bradshaw's avatar
Robert Bradshaw committed
3723
        else:
3724
            overloaded_entry = None
3725

3726
        if overloaded_entry:
3727
            if self.function.type.is_fused:
3728
                functypes = self.function.type.get_all_specialized_function_types()
Mark Florisson's avatar
Mark Florisson committed
3729
                alternatives = [f.entry for f in functypes]
3730 3731 3732 3733 3734
            else:
                alternatives = overloaded_entry.all_alternatives()

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

3735 3736 3737 3738
            if not entry:
                self.type = PyrexTypes.error_type
                self.result_code = "<error>"
                return
Mark Florisson's avatar
Mark Florisson committed
3739 3740

            entry.used = True
3741 3742
            self.function.entry = entry
            self.function.type = entry.type
3743 3744 3745 3746 3747 3748 3749 3750
            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
3751
        # Check no. of args
3752 3753
        max_nargs = len(func_type.args)
        expected_nargs = max_nargs - func_type.optional_arg_count
William Stein's avatar
William Stein committed
3754
        actual_nargs = len(self.args)
3755 3756 3757
        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
3758
        # Coerce arguments
3759
        some_args_in_temps = False
3760
        for i in xrange(min(max_nargs, actual_nargs)):
William Stein's avatar
William Stein committed
3761
            formal_type = func_type.args[i].type
3762
            arg = self.args[i].coerce_to(formal_type, env)
3763
            if arg.is_temp:
3764 3765
                if i > 0:
                    # first argument in temp doesn't impact subsequent arguments
3766
                    some_args_in_temps = True
3767
            elif arg.type.is_pyobject and not env.nogil:
3768 3769
                if i == 0 and self.self is not None:
                    # a method's cloned "self" argument is ok
3770
                    pass
3771
                elif arg.nonlocally_immutable():
3772 3773 3774
                    # plain local variables are ok
                    pass
                else:
3775 3776 3777 3778
                    # 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
3779 3780
                    if i > 0: # first argument doesn't matter
                        some_args_in_temps = True
3781
                    arg = arg.coerce_to_temp(env)
3782
            self.args[i] = arg
3783
        # handle additional varargs parameters
3784
        for i in xrange(max_nargs, actual_nargs):
3785 3786 3787 3788 3789 3790 3791
            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:
3792
                    self.args[i] = arg = arg.coerce_to(arg_ctype, env)
3793 3794
            if arg.is_temp and i > 0:
                some_args_in_temps = True
3795 3796 3797
        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
3798 3799 3800 3801
            # 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):
3802 3803
                if i == 0 and self.self is not None:
                    continue # self is ok
3804
                arg = self.args[i]
3805 3806
                if arg.nonlocally_immutable():
                    # locals, C functions, unassignable types are safe.
3807
                    pass
3808 3809
                elif arg.type.is_cpp_class:
                    # Assignment has side effects, avoid.
3810 3811
                    pass
                elif env.nogil and arg.type.is_pyobject:
3812 3813 3814
                    # can't copy a Python reference into a temp in nogil
                    # env (this is safe: a construction would fail in
                    # nogil anyway)
3815 3816
                    pass
                else:
3817 3818 3819 3820 3821
                    #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
3822

William Stein's avatar
William Stein committed
3823
        # Calc result type and code fragment
Robert Bradshaw's avatar
Robert Bradshaw committed
3824
        if isinstance(self.function, NewExprNode):
3825
            self.type = PyrexTypes.CPtrType(self.function.class_type)
Robert Bradshaw's avatar
Robert Bradshaw committed
3826 3827
        else:
            self.type = func_type.return_type
3828

3829 3830 3831
        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()
3832

Stefan Behnel's avatar
Stefan Behnel committed
3833 3834 3835 3836 3837 3838
        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
3839 3840 3841 3842
        elif self.type.is_memoryviewslice:
            self.is_temp = 1
            # func_type.exception_check = True

3843
        # Called in 'nogil' context?
3844
        self.nogil = env.nogil
3845 3846 3847 3848 3849
        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
3850 3851 3852 3853
        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
3854 3855
    def calculate_result_code(self):
        return self.c_call_code()
3856

William Stein's avatar
William Stein committed
3857 3858
    def c_call_code(self):
        func_type = self.function_type()
3859
        if self.type is PyrexTypes.error_type or not func_type.is_cfunction:
William Stein's avatar
William Stein committed
3860 3861 3862
            return "<error>"
        formal_args = func_type.args
        arg_list_code = []
3863
        args = list(zip(formal_args, self.args))
3864 3865 3866 3867
        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
3868 3869
                arg_code = actual_arg.result_as(formal_arg.type)
                arg_list_code.append(arg_code)
3870

3871 3872
        if func_type.is_overridable:
            arg_list_code.append(str(int(self.wrapper_call or self.function.entry.is_unbound_cmethod)))
3873

3874
        if func_type.optional_arg_count:
3875
            if expected_nargs == actual_nargs:
3876
                optional_args = 'NULL'
3877
            else:
3878
                optional_args = "&%s" % self.opt_arg_struct
3879
            arg_list_code.append(optional_args)
3880

William Stein's avatar
William Stein committed
3881
        for actual_arg in self.args[len(formal_args):]:
3882
            arg_list_code.append(actual_arg.result())
3883 3884

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

William Stein's avatar
William Stein committed
3887 3888
    def generate_result_code(self, code):
        func_type = self.function_type()
3889 3890 3891
        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
3892
        if func_type.is_pyobject:
3893
            arg_code = self.arg_tuple.py_result()
William Stein's avatar
William Stein committed
3894
            code.putln(
3895
                "%s = PyObject_Call(%s, %s, NULL); %s" % (
3896
                    self.result(),
William Stein's avatar
William Stein committed
3897
                    self.function.py_result(),
3898
                    arg_code,
3899
                    code.error_goto_if_null(self.result(), self.pos)))
3900
            code.put_gotref(self.py_result())
William Stein's avatar
William Stein committed
3901
        elif func_type.is_cfunction:
3902 3903 3904
            if self.has_optional_args:
                actual_nargs = len(self.args)
                expected_nargs = len(func_type.args) - func_type.optional_arg_count
3905 3906
                self.opt_arg_struct = code.funcstate.allocate_temp(
                    func_type.op_arg_struct.base_type, manage_ref=True)
3907 3908 3909 3910
                code.putln("%s.%s = %s;" % (
                        self.opt_arg_struct,
                        Naming.pyrex_prefix + "n",
                        len(self.args) - expected_nargs))
3911
                args = list(zip(func_type.args, self.args))
3912 3913 3914
                for formal_arg, actual_arg in args[expected_nargs:actual_nargs]:
                    code.putln("%s.%s = %s;" % (
                            self.opt_arg_struct,
3915
                            func_type.opt_arg_cname(formal_arg.name),
3916
                            actual_arg.result_as(formal_arg.type)))
William Stein's avatar
William Stein committed
3917
            exc_checks = []
3918
            if self.type.is_pyobject and self.is_temp:
3919
                exc_checks.append("!%s" % self.result())
3920 3921 3922
            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
3923
            else:
3924 3925
                exc_val = func_type.exception_value
                exc_check = func_type.exception_check
William Stein's avatar
William Stein committed
3926
                if exc_val is not None:
3927
                    exc_checks.append("%s == %s" % (self.result(), exc_val))
William Stein's avatar
William Stein committed
3928
                if exc_check:
3929 3930
                    if self.nogil:
                        exc_checks.append("__Pyx_ErrOccurredWithGIL()")
3931
                    else:
3932
                        exc_checks.append("PyErr_Occurred()")
William Stein's avatar
William Stein committed
3933 3934
            if self.is_temp or exc_checks:
                rhs = self.c_call_code()
3935 3936
                if self.result():
                    lhs = "%s = " % self.result()
William Stein's avatar
William Stein committed
3937 3938 3939
                    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
3940
                        #    "from", return_type, "to pyobject" ###
William Stein's avatar
William Stein committed
3941 3942 3943
                        rhs = typecast(py_object_type, self.type, rhs)
                else:
                    lhs = ""
Felix Wu's avatar
Felix Wu committed
3944
                if func_type.exception_check == '+':
Robert Bradshaw's avatar
Robert Bradshaw committed
3945 3946 3947
                    if func_type.exception_value is None:
                        raise_py_exception = "__Pyx_CppExn2PyErr()"
                    elif func_type.exception_value.type.is_pyobject:
3948 3949 3950
                        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
3951 3952
                    else:
                        raise_py_exception = '%s(); if (!PyErr_Occurred()) PyErr_SetString(PyExc_RuntimeError , "Error converting c++ exception.")' % func_type.exception_value.entry.cname
3953 3954
                    if self.nogil:
                        raise_py_exception = 'Py_BLOCK_THREADS; %s; Py_UNBLOCK_THREADS' % raise_py_exception
Felix Wu's avatar
Felix Wu committed
3955
                    code.putln(
Robert Bradshaw's avatar
Robert Bradshaw committed
3956
                    "try {%s%s;} catch(...) {%s; %s}" % (
Felix Wu's avatar
Felix Wu committed
3957 3958
                        lhs,
                        rhs,
Robert Bradshaw's avatar
Robert Bradshaw committed
3959
                        raise_py_exception,
Felix Wu's avatar
Felix Wu committed
3960
                        code.error_goto(self.pos)))
3961 3962 3963 3964 3965 3966
                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))
3967
                if self.type.is_pyobject and self.result():
3968
                    code.put_gotref(self.py_result())
3969 3970
            if self.has_optional_args:
                code.funcstate.release_temp(self.opt_arg_struct)
3971 3972


3973 3974 3975 3976 3977 3978 3979 3980 3981 3982 3983 3984 3985 3986 3987 3988 3989 3990 3991 3992 3993 3994 3995 3996 3997 3998 3999 4000 4001 4002 4003 4004 4005 4006 4007 4008 4009 4010 4011 4012 4013 4014 4015 4016 4017 4018 4019 4020 4021 4022 4023 4024 4025 4026 4027 4028 4029 4030 4031 4032 4033 4034 4035 4036 4037 4038 4039 4040 4041 4042 4043 4044 4045 4046 4047 4048 4049 4050 4051 4052 4053 4054 4055 4056
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:
4057
                arg_code.append(arg.result_as(proto_arg.type))
4058 4059 4060 4061 4062 4063 4064 4065 4066 4067 4068 4069
            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())


4070 4071
class PythonCapiFunctionNode(ExprNode):
    subexprs = []
4072
    def __init__(self, pos, py_name, cname, func_type, utility_code = None):
4073
        self.pos = pos
4074 4075
        self.name = py_name
        self.cname = cname
4076 4077 4078
        self.type = func_type
        self.utility_code = utility_code

4079 4080 4081
    def analyse_types(self, env):
        pass

4082 4083 4084 4085 4086
    def generate_result_code(self, code):
        if self.utility_code:
            code.globalstate.use_utility_code(self.utility_code)

    def calculate_result_code(self):
4087
        return self.cname
4088 4089 4090 4091

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

Stefan Behnel's avatar
Stefan Behnel committed
4092 4093 4094 4095 4096 4097
    # 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

4098
    def __init__(self, pos, function_name, func_type,
4099
                 utility_code = None, py_name=None, **kwargs):
4100 4101 4102
        self.type = func_type.return_type
        self.result_ctype = self.type
        self.function = PythonCapiFunctionNode(
4103
            pos, py_name, function_name, func_type,
4104 4105 4106 4107 4108
            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
4109

4110
class GeneralCallNode(CallNode):
William Stein's avatar
William Stein committed
4111 4112 4113 4114 4115 4116
    #  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
4117

4118
    type = py_object_type
4119

4120
    subexprs = ['function', 'positional_args', 'keyword_args']
William Stein's avatar
William Stein committed
4121

4122
    nogil_check = Node.gil_error
4123

4124 4125 4126 4127 4128 4129 4130 4131
    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)
4132

4133
    def explicit_args_kwds(self):
4134 4135
        if (self.keyword_args and not isinstance(self.keyword_args, DictNode) or
            not isinstance(self.positional_args, TupleNode)):
4136
            raise CompileError(self.pos,
4137 4138
                'Compile-time keyword arguments must be explicit.')
        return self.positional_args.args, self.keyword_args
4139

William Stein's avatar
William Stein committed
4140
    def analyse_types(self, env):
Robert Bradshaw's avatar
Robert Bradshaw committed
4141 4142
        if self.analyse_as_type_constructor(env):
            return
William Stein's avatar
William Stein committed
4143 4144 4145 4146
        self.function.analyse_types(env)
        self.positional_args.analyse_types(env)
        if self.keyword_args:
            self.keyword_args.analyse_types(env)
4147
        if not self.function.type.is_pyobject:
4148 4149
            if self.function.type.is_error:
                self.type = error_type
Stefan Behnel's avatar
Stefan Behnel committed
4150
                return
4151
            if hasattr(self.function, 'entry') and not self.function.entry.as_variable:
4152
                error(self.pos, "Keyword and starred arguments not allowed in cdef functions.")
4153 4154
            else:
                self.function = self.function.coerce_to_pyobject(env)
William Stein's avatar
William Stein committed
4155 4156
        self.positional_args = \
            self.positional_args.coerce_to_pyobject(env)
Stefan Behnel's avatar
Stefan Behnel committed
4157
        function = self.function
4158 4159 4160 4161 4162
        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
4163
            self.may_return_none = False
4164 4165
        else:
            self.type = py_object_type
William Stein's avatar
William Stein committed
4166
        self.is_temp = 1
4167

William Stein's avatar
William Stein committed
4168
    def generate_result_code(self, code):
4169
        if self.type.is_error: return
4170 4171
        if self.keyword_args:
            kwargs = self.keyword_args.py_result()
William Stein's avatar
William Stein committed
4172
        else:
4173
            kwargs = 'NULL'
William Stein's avatar
William Stein committed
4174
        code.putln(
4175
            "%s = PyObject_Call(%s, %s, %s); %s" % (
4176
                self.result(),
4177 4178 4179
                self.function.py_result(),
                self.positional_args.py_result(),
                kwargs,
4180
                code.error_goto_if_null(self.result(), self.pos)))
4181
        code.put_gotref(self.py_result())
William Stein's avatar
William Stein committed
4182 4183


4184
class AsTupleNode(ExprNode):
William Stein's avatar
William Stein committed
4185 4186 4187 4188
    #  Convert argument to tuple. Used for normalising
    #  the * argument of a function call.
    #
    #  arg    ExprNode
4189

William Stein's avatar
William Stein committed
4190
    subexprs = ['arg']
4191 4192 4193

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

4195 4196 4197 4198 4199 4200 4201
    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
4202 4203 4204
    def analyse_types(self, env):
        self.arg.analyse_types(env)
        self.arg = self.arg.coerce_to_pyobject(env)
4205
        self.type = tuple_type
William Stein's avatar
William Stein committed
4206
        self.is_temp = 1
4207

4208 4209 4210
    def may_be_none(self):
        return False

4211
    nogil_check = Node.gil_error
4212 4213
    gil_message = "Constructing Python tuple"

William Stein's avatar
William Stein committed
4214 4215
    def generate_result_code(self, code):
        code.putln(
Robert Bradshaw's avatar
Robert Bradshaw committed
4216
            "%s = PySequence_Tuple(%s); %s" % (
4217
                self.result(),
William Stein's avatar
William Stein committed
4218
                self.arg.py_result(),
4219
                code.error_goto_if_null(self.result(), self.pos)))
4220
        code.put_gotref(self.py_result())
4221

William Stein's avatar
William Stein committed
4222

4223
class AttributeNode(ExprNode):
William Stein's avatar
William Stein committed
4224 4225 4226 4227
    #  obj.attribute
    #
    #  obj          ExprNode
    #  attribute    string
4228
    #  needs_none_check boolean        Used if obj is an extension type.
4229
    #                                  If set to True, it is known that the type is not None.
William Stein's avatar
William Stein committed
4230 4231 4232 4233 4234 4235 4236
    #
    #  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
4237

William Stein's avatar
William Stein committed
4238 4239
    is_attribute = 1
    subexprs = ['obj']
4240

William Stein's avatar
William Stein committed
4241 4242 4243
    type = PyrexTypes.error_type
    entry = None
    is_called = 0
4244
    needs_none_check = True
4245
    is_memslice_transpose = False
William Stein's avatar
William Stein committed
4246

4247
    def as_cython_attribute(self):
Mark Florisson's avatar
Mark Florisson committed
4248 4249 4250
        if (isinstance(self.obj, NameNode) and
                self.obj.is_cython_module and not
                self.attribute == u"parallel"):
4251
            return self.attribute
Mark Florisson's avatar
Mark Florisson committed
4252

4253 4254 4255
        cy = self.obj.as_cython_attribute()
        if cy:
            return "%s.%s" % (cy, self.attribute)
4256
        return None
4257

4258 4259 4260 4261 4262 4263 4264 4265 4266
    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
4267
                self.analyse_as_python_attribute(env)
4268
                return self
4269
        return ExprNode.coerce_to(self, dst_type, env)
4270 4271 4272

    def calculate_constant_result(self):
        attr = self.attribute
4273
        if attr.startswith("__") and attr.endswith("__"):
4274 4275 4276
            return
        self.constant_result = getattr(self.obj.constant_result, attr)

4277 4278
    def compile_time_value(self, denv):
        attr = self.attribute
4279
        if attr.startswith("__") and attr.endswith("__"):
Stefan Behnel's avatar
Stefan Behnel committed
4280 4281
            error(self.pos,
                  "Invalid attribute name '%s' in compile-time expression" % attr)
4282
            return None
4283
        obj = self.obj.compile_time_value(denv)
4284 4285 4286 4287
        try:
            return getattr(obj, attr)
        except Exception, e:
            self.compile_time_value_error(e)
4288

Robert Bradshaw's avatar
Robert Bradshaw committed
4289 4290
    def type_dependencies(self, env):
        return self.obj.type_dependencies(env)
4291

4292 4293 4294 4295 4296 4297
    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:
4298 4299 4300 4301 4302 4303 4304 4305
            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
4306
            return self.type
4307

William Stein's avatar
William Stein committed
4308 4309
    def analyse_target_declaration(self, env):
        pass
4310

William Stein's avatar
William Stein committed
4311 4312
    def analyse_target_types(self, env):
        self.analyse_types(env, target = 1)
4313 4314
        if not self.is_lvalue():
            error(self.pos, "Assignment to non-lvalue of type '%s'" % self.type)
4315

William Stein's avatar
William Stein committed
4316
    def analyse_types(self, env, target = 0):
4317
        self.initialized_check = env.directives['initializedcheck']
William Stein's avatar
William Stein committed
4318
        if self.analyse_as_cimported_attribute(env, target):
4319 4320 4321 4322 4323 4324 4325
            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
4326

4327 4328 4329 4330
        # may be mutated in a namenode now :)
        if self.is_attribute:
            self.wrap_obj_in_nonecheck(env)

William Stein's avatar
William Stein committed
4331 4332 4333 4334 4335 4336 4337 4338 4339 4340 4341 4342
    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)
4343
                    entry.used = 1
William Stein's avatar
William Stein committed
4344 4345
                    return 1
        return 0
4346

William Stein's avatar
William Stein committed
4347 4348 4349 4350 4351 4352 4353 4354 4355 4356 4357 4358 4359 4360 4361 4362
    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
4363
                ubcm_entry.is_unbound_cmethod = 1
William Stein's avatar
William Stein committed
4364 4365 4366
                self.mutate_into_name_node(env, ubcm_entry, None)
                return 1
        return 0
4367

4368 4369 4370
    def analyse_as_type(self, env):
        module_scope = self.obj.analyse_as_module(env)
        if module_scope:
4371
            return module_scope.lookup_type(self.attribute)
4372
        if not self.obj.is_string_literal:
Robert Bradshaw's avatar
Robert Bradshaw committed
4373
            base_type = self.obj.analyse_as_type(env)
Robert Bradshaw's avatar
Robert Bradshaw committed
4374
            if base_type and hasattr(base_type, 'scope') and base_type.scope is not None:
Robert Bradshaw's avatar
Robert Bradshaw committed
4375
                return base_type.scope.lookup_type(self.attribute)
4376
        return None
4377

William Stein's avatar
William Stein committed
4378 4379 4380 4381 4382 4383 4384 4385 4386
    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
4387

William Stein's avatar
William Stein committed
4388 4389 4390 4391 4392 4393 4394 4395 4396
    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
4397

William Stein's avatar
William Stein committed
4398 4399 4400 4401 4402 4403 4404 4405 4406 4407 4408
    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:
4409
            NameNode.analyse_rvalue_entry(self, env)
4410

William Stein's avatar
William Stein committed
4411 4412 4413 4414
    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:
4415 4416
#            error(self.pos, "C method can only be called")
            pass
4417 4418
        ## Reference to C array turns into pointer to first element.
        #while self.type.is_array:
Robert Bradshaw's avatar
Robert Bradshaw committed
4419
        #    self.type = self.type.element_ptr_type()
William Stein's avatar
William Stein committed
4420 4421 4422 4423
        if self.is_py_attr:
            if not target:
                self.is_temp = 1
                self.result_ctype = py_object_type
4424 4425
        elif target and self.obj.type.is_builtin_type:
            error(self.pos, "Assignment to an immutable object field")
4426 4427
        #elif self.type.is_memoryviewslice and not target:
        #    self.is_temp = True
4428

Robert Bradshaw's avatar
Robert Bradshaw committed
4429
    def analyse_attribute(self, env, obj_type = None):
William Stein's avatar
William Stein committed
4430 4431 4432
        # 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
4433 4434 4435 4436 4437 4438 4439
        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
4440
        if obj_type.is_ptr or obj_type.is_array:
William Stein's avatar
William Stein committed
4441 4442
            obj_type = obj_type.base_type
            self.op = "->"
4443
        elif obj_type.is_extension_type or obj_type.is_builtin_type:
William Stein's avatar
William Stein committed
4444 4445 4446 4447 4448 4449
            self.op = "->"
        else:
            self.op = "."
        if obj_type.has_attributes:
            entry = None
            if obj_type.attributes_known():
4450 4451
                if (obj_type.is_memoryviewslice and not
                        obj_type.scope.lookup_here(self.attribute)):
4452 4453 4454 4455 4456 4457 4458
                    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:
4459
                        obj_type.declare_attribute(self.attribute, env, self.pos)
William Stein's avatar
William Stein committed
4460
                entry = obj_type.scope.lookup_here(self.attribute)
Robert Bradshaw's avatar
Robert Bradshaw committed
4461 4462
                if entry and entry.is_member:
                    entry = None
William Stein's avatar
William Stein committed
4463
            else:
4464 4465
                error(self.pos,
                    "Cannot select attribute of incomplete type '%s'"
William Stein's avatar
William Stein committed
4466
                    % obj_type)
Robert Bradshaw's avatar
Robert Bradshaw committed
4467 4468
                self.type = PyrexTypes.error_type
                return
William Stein's avatar
William Stein committed
4469 4470
            self.entry = entry
            if entry:
4471 4472
                if obj_type.is_extension_type and entry.name == "__weakref__":
                    error(self.pos, "Illegal use of special attribute __weakref__")
4473 4474

                # def methods need the normal attribute lookup
4475
                # because they do not have struct entries
4476 4477 4478 4479
                # fused function go through assignment synthesis
                # (foo = pycfunction(foo_func_obj)) and need to go through
                # regular Python lookup as well
                if (entry.is_variable and not entry.fused_cfunction) or entry.is_cmethod:
4480 4481 4482
                    self.type = entry.type
                    self.member = entry.cname
                    return
William Stein's avatar
William Stein committed
4483 4484 4485 4486 4487
                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
4488
        # If we get here, the base object is not a struct/union/extension
William Stein's avatar
William Stein committed
4489 4490 4491
        # 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
4492
        self.analyse_as_python_attribute(env, obj_type)
Stefan Behnel's avatar
Stefan Behnel committed
4493

Robert Bradshaw's avatar
Robert Bradshaw committed
4494 4495 4496
    def analyse_as_python_attribute(self, env, obj_type = None):
        if obj_type is None:
            obj_type = self.obj.type
4497 4498
        # mangle private '__*' Python attributes used inside of a class
        self.attribute = env.mangle_class_private_name(self.attribute)
4499
        self.member = self.attribute
4500 4501
        self.type = py_object_type
        self.is_py_attr = 1
4502
        if not obj_type.is_pyobject and not obj_type.is_error:
4503
            if obj_type.can_coerce_to_pyobject(env):
4504 4505 4506 4507 4508
                self.obj = self.obj.coerce_to_pyobject(env)
            else:
                error(self.pos,
                      "Object of type '%s' has no attribute '%s'" %
                      (obj_type, self.attribute))
4509

4510 4511 4512 4513 4514
    def wrap_obj_in_nonecheck(self, env):
        if not env.directives['nonecheck']:
            return

        msg = None
4515
        format_args = ()
4516 4517
        if (self.obj.type.is_extension_type and self.needs_none_check and not
                self.is_py_attr):
4518 4519
            msg = "'NoneType' object has no attribute '%s'"
            format_args = (self.attribute,)
4520 4521 4522 4523 4524 4525 4526
        elif self.obj.type.is_memoryviewslice:
            if self.is_memslice_transpose:
                msg = "Cannot transpose None memoryview slice"
            else:
                entry = self.obj.type.scope.lookup_here(self.attribute)
                if entry:
                    # copy/is_c_contig/shape/strides etc
4527 4528
                    msg = "Cannot access '%s' attribute of None memoryview slice"
                    format_args = (entry.name,)
4529 4530

        if msg:
4531 4532
            self.obj = self.obj.as_none_safe_node(msg, 'PyExc_AttributeError',
                                                  format_args=format_args)
4533 4534


4535
    def nogil_check(self, env):
4536
        if self.is_py_attr:
4537
            self.gil_error()
4538 4539 4540
        elif self.type.is_memoryviewslice:
            import MemoryView
            MemoryView.err_if_nogil_initialized_check(self.pos, env, 'attribute')
4541

4542 4543
    gil_message = "Accessing Python attribute"

William Stein's avatar
William Stein committed
4544 4545 4546 4547 4548 4549 4550 4551
    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:
4552
            return not self.type.is_array
William Stein's avatar
William Stein committed
4553 4554
        else:
            return NameNode.is_lvalue(self)
4555

William Stein's avatar
William Stein committed
4556 4557 4558 4559 4560
    def is_ephemeral(self):
        if self.obj:
            return self.obj.is_ephemeral()
        else:
            return NameNode.is_ephemeral(self)
4561

William Stein's avatar
William Stein committed
4562 4563
    def calculate_result_code(self):
        #print "AttributeNode.calculate_result_code:", self.member ###
4564
        #print "...obj node =", self.obj, "code", self.obj.result() ###
William Stein's avatar
William Stein committed
4565 4566 4567 4568 4569
        #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
4570
            if obj.type.is_extension_type and not self.entry.is_builtin_cmethod:
4571 4572
                if self.entry.final_func_cname:
                    return self.entry.final_func_cname
4573

Mark Florisson's avatar
Mark Florisson committed
4574
                if self.type.from_fused:
4575 4576 4577 4578
                    # 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
4579 4580
                    self.member = self.entry.cname

Robert Bradshaw's avatar
Robert Bradshaw committed
4581
                return "((struct %s *)%s%s%s)->%s" % (
4582
                    obj.type.vtabstruct_cname, obj_code, self.op,
Robert Bradshaw's avatar
Robert Bradshaw committed
4583 4584 4585
                    obj.type.vtabslot_cname, self.member)
            else:
                return self.member
4586
        elif obj.type.is_complex:
4587
            return "__Pyx_C%s(%s)" % (self.member.upper(), obj_code)
William Stein's avatar
William Stein committed
4588
        else:
4589 4590 4591
            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
4592
            return "%s%s%s" % (obj_code, self.op, self.member)
4593

William Stein's avatar
William Stein committed
4594 4595
    def generate_result_code(self, code):
        if self.is_py_attr:
4596 4597
            code.putln(
                '%s = PyObject_GetAttr(%s, %s); %s' % (
4598
                    self.result(),
4599
                    self.obj.py_result(),
4600
                    code.intern_identifier(self.attribute),
4601
                    code.error_goto_if_null(self.result(), self.pos)))
4602
            code.put_gotref(self.py_result())
4603
        elif self.type.is_memoryviewslice:
4604 4605 4606 4607 4608 4609 4610 4611 4612
            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()))
4613 4614
                if self.obj.is_name or (self.obj.is_attribute and
                                        self.obj.is_memslice_transpose):
4615 4616 4617 4618 4619
                    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:
4620 4621 4622 4623 4624 4625
                code.putln(
                    'if (unlikely(!%s.memview)) {'
                        'PyErr_SetString(PyExc_AttributeError,'
                                        '"Memoryview is not initialized");'
                        '%s'
                    '}' % (self.result(), code.error_goto(self.pos)))
4626 4627 4628
        else:
            # result_code contains what is needed, but we may need to insert
            # a check and raise an exception
4629
            if self.obj.type.is_extension_type:
4630
                pass
4631 4632 4633
            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)
4634

William Stein's avatar
William Stein committed
4635 4636 4637
    def generate_assignment_code(self, rhs, code):
        self.obj.generate_evaluation_code(code)
        if self.is_py_attr:
4638
            code.put_error_if_neg(self.pos,
4639 4640
                'PyObject_SetAttr(%s, %s, %s)' % (
                    self.obj.py_result(),
4641
                    code.intern_identifier(self.attribute),
4642
                    rhs.py_result()))
William Stein's avatar
William Stein committed
4643
            rhs.generate_disposal_code(code)
4644
            rhs.free_temps(code)
4645 4646 4647 4648 4649
        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
4650
        else:
4651
            select_code = self.result()
4652
            if self.type.is_pyobject and self.use_managed_ref:
William Stein's avatar
William Stein committed
4653
                rhs.make_owned_reference(code)
Dag Sverre Seljebotn's avatar
Dag Sverre Seljebotn committed
4654
                code.put_giveref(rhs.py_result())
4655
                code.put_gotref(select_code)
William Stein's avatar
William Stein committed
4656
                code.put_decref(select_code, self.ctype())
4657
            elif self.type.is_memoryviewslice:
4658
                import MemoryView
4659
                MemoryView.put_assign_to_memviewslice(
4660
                        select_code, rhs, rhs.result(), self.type, code)
4661

4662
            if not self.type.is_memoryviewslice:
4663 4664 4665 4666 4667
                code.putln(
                    "%s = %s;" % (
                        select_code,
                        rhs.result_as(self.ctype())))
                        #rhs.result()))
William Stein's avatar
William Stein committed
4668
            rhs.generate_post_assignment_code(code)
4669
            rhs.free_temps(code)
William Stein's avatar
William Stein committed
4670
        self.obj.generate_disposal_code(code)
4671
        self.obj.free_temps(code)
4672

William Stein's avatar
William Stein committed
4673 4674
    def generate_deletion_code(self, code):
        self.obj.generate_evaluation_code(code)
4675
        if self.is_py_attr or (isinstance(self.entry.scope, Symtab.PropertyScope)
4676
                               and u'__del__' in self.entry.scope.entries):
4677 4678 4679
            code.put_error_if_neg(self.pos,
                'PyObject_DelAttr(%s, %s)' % (
                    self.obj.py_result(),
4680
                    code.intern_identifier(self.attribute)))
William Stein's avatar
William Stein committed
4681 4682 4683
        else:
            error(self.pos, "Cannot delete C attribute of extension type")
        self.obj.generate_disposal_code(code)
4684
        self.obj.free_temps(code)
4685

4686 4687 4688 4689 4690
    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
4691

4692

William Stein's avatar
William Stein committed
4693 4694 4695 4696 4697 4698
#-------------------------------------------------------------------
#
#  Constructor nodes
#
#-------------------------------------------------------------------

4699 4700 4701 4702 4703 4704 4705 4706 4707 4708 4709 4710 4711 4712 4713
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
4714
    is_temp = 1
4715 4716 4717 4718 4719 4720 4721 4722 4723 4724 4725 4726 4727 4728 4729 4730 4731 4732 4733 4734 4735 4736 4737 4738 4739 4740 4741 4742

    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


4743
class SequenceNode(ExprNode):
William Stein's avatar
William Stein committed
4744 4745 4746 4747 4748 4749
    #  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
4750
    # mult_factor              ExprNode     the integer number of content repetitions ([1,2]*3)
4751

4752
    subexprs = ['args', 'mult_factor']
4753

William Stein's avatar
William Stein committed
4754 4755
    is_sequence_constructor = 1
    unpacked_items = None
4756
    mult_factor = None
4757

4758 4759 4760
    def compile_time_value_list(self, denv):
        return [arg.compile_time_value(denv) for arg in self.args]

4761 4762 4763 4764 4765 4766 4767 4768 4769 4770 4771 4772 4773 4774
    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
4775
    def analyse_target_declaration(self, env):
4776
        self.replace_starred_target_node()
William Stein's avatar
William Stein committed
4777 4778 4779
        for arg in self.args:
            arg.analyse_target_declaration(env)

4780
    def analyse_types(self, env, skip_children=False):
William Stein's avatar
William Stein committed
4781 4782
        for i in range(len(self.args)):
            arg = self.args[i]
4783
            if not skip_children: arg.analyse_types(env)
William Stein's avatar
William Stein committed
4784
            self.args[i] = arg.coerce_to_pyobject(env)
4785 4786 4787
        if self.mult_factor:
            self.mult_factor.analyse_types(env)
            if not self.mult_factor.type.is_int:
4788
                self.mult_factor = self.mult_factor.coerce_to_pyobject(env)
William Stein's avatar
William Stein committed
4789
        self.is_temp = 1
Stefan Behnel's avatar
Stefan Behnel committed
4790
        # not setting self.type here, subtypes do this
4791

4792 4793 4794
    def may_be_none(self):
        return False

William Stein's avatar
William Stein committed
4795
    def analyse_target_types(self, env):
4796
        if self.mult_factor:
Stefan Behnel's avatar
Stefan Behnel committed
4797
            error(self.pos, "can't assign to multiplied sequence")
4798
        self.unpacked_items = []
William Stein's avatar
William Stein committed
4799
        self.coerced_unpacked_items = []
4800
        self.any_coerced_items = False
William Stein's avatar
William Stein committed
4801 4802
        for arg in self.args:
            arg.analyse_target_types(env)
4803 4804 4805 4806 4807 4808
            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
4809 4810
            unpacked_item = PyTempNode(self.pos, env)
            coerced_unpacked_item = unpacked_item.coerce_to(arg.type, env)
4811 4812
            if unpacked_item is not coerced_unpacked_item:
                self.any_coerced_items = True
William Stein's avatar
William Stein committed
4813 4814 4815
            self.unpacked_items.append(unpacked_item)
            self.coerced_unpacked_items.append(coerced_unpacked_item)
        self.type = py_object_type
4816

William Stein's avatar
William Stein committed
4817 4818
    def generate_result_code(self, code):
        self.generate_operation_code(code)
4819

4820 4821 4822 4823 4824 4825
    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
4826
        else:
4827 4828 4829 4830 4831 4832
            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
4833 4834 4835 4836 4837
            else:
                size_factor = ' * ((%s<0) ? 0:%s)' % (mult, mult)
        else:
            size_factor = ''
            mult = ''
4838 4839 4840 4841 4842 4843

        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:
Stefan Behnel's avatar
Stefan Behnel committed
4844
            raise InternalError("sequence packing for unexpected type %s" % self.type)
4845 4846
        arg_count = len(self.args)
        code.putln("%s = %s(%s%s); %s" % (
4847 4848 4849 4850
            target, create_func, arg_count, size_factor,
            code.error_goto_if_null(target, self.pos)))
        code.put_gotref(target)

4851
        if mult:
4852 4853 4854 4855
            # 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.

4856 4857
            #counter = code.funcstate.allocate_temp(mult_factor.type, manage_ref=False)
            counter = Naming.quick_temp_cname
4858 4859
            code.putln('{ Py_ssize_t %s;' % counter)
            if arg_count == 1:
Stefan Behnel's avatar
Stefan Behnel committed
4860
                offset = counter
4861
            else:
Stefan Behnel's avatar
Stefan Behnel committed
4862
                offset = '%s * %s' % (counter, arg_count)
4863 4864 4865 4866 4867 4868 4869 4870 4871
            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
4872
            code.putln("%s(%s, %s, %s);" % (
4873
                set_item_func,
4874
                target,
Stefan Behnel's avatar
Stefan Behnel committed
4875
                (offset and i) and ('%s + %s' % (offset, i)) or (offset or i),
4876 4877 4878 4879
                arg.py_result()))
            code.put_giveref(arg.py_result())
        if mult:
            code.putln('}')
4880 4881
            #code.funcstate.release_temp(counter)
            code.putln('}')
4882
        elif py_multiply and not plain:
4883
            code.putln('{ PyObject* %s = PyNumber_InPlaceMultiply(%s, %s); %s' % (
4884 4885 4886 4887 4888 4889 4890
                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('}')
4891 4892

    def generate_subexpr_disposal_code(self, code):
4893
        if self.mult_factor and self.mult_factor.type.is_int:
4894 4895 4896 4897 4898 4899 4900 4901 4902
            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.
4903 4904
            if self.mult_factor:
                self.mult_factor.generate_disposal_code(code)
4905

William Stein's avatar
William Stein committed
4906
    def generate_assignment_code(self, rhs, code):
4907 4908 4909
        if self.starred_assignment:
            self.generate_starred_assignment_code(rhs, code)
        else:
4910
            self.generate_parallel_assignment_code(rhs, code)
4911 4912 4913 4914 4915

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

4916 4917 4918 4919 4920
    _func_iternext_type = PyrexTypes.CPtrType(PyrexTypes.CFuncType(
        PyrexTypes.py_object_type, [
            PyrexTypes.CFuncTypeArg("it", PyrexTypes.py_object_type, None),
            ]))

4921
    def generate_parallel_assignment_code(self, rhs, code):
4922 4923 4924
        # 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.
4925 4926
        for item in self.unpacked_items:
            item.allocate(code)
4927 4928 4929
        special_unpack = (rhs.type is py_object_type
                          or rhs.type in (tuple_type, list_type)
                          or not rhs.type.is_builtin_type)
4930
        long_enough_for_a_loop = len(self.unpacked_items) > 3
4931 4932 4933
        if special_unpack:
            tuple_check = 'likely(PyTuple_CheckExact(%s))' % rhs.py_result()
            list_check  = 'PyList_CheckExact(%s)' % rhs.py_result()
4934
            sequence_type_test = '1'
4935 4936
            if rhs.type is list_type:
                sequence_types = ['List']
4937 4938
                if rhs.may_be_none():
                    sequence_type_test = list_check
4939 4940
            elif rhs.type is tuple_type:
                sequence_types = ['Tuple']
4941 4942
                if rhs.may_be_none():
                    sequence_type_test = tuple_check
4943 4944 4945
            else:
                sequence_types = ['Tuple', 'List']
                sequence_type_test = "(%s) || (%s)" % (tuple_check, list_check)
4946
            code.putln("#if CYTHON_COMPILING_IN_CPYTHON")
4947 4948 4949 4950
            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])
4951 4952 4953
            self.generate_special_parallel_unpacking_code(
                code, sequence_types[0],
                use_loop=long_enough_for_a_loop and sequence_types[0] != 'Tuple')
4954 4955
            if len(sequence_types) == 2:
                code.putln("} else {")
4956 4957
                self.generate_special_parallel_unpacking_code(
                    code, sequence_types[1], use_loop=long_enough_for_a_loop)
4958 4959
                code.putln("}")
            rhs.generate_disposal_code(code)
4960
            code.putln("} else")
Stefan Behnel's avatar
Stefan Behnel committed
4961 4962 4963 4964 4965 4966
            if rhs.type is tuple_type:
                code.putln("if (1) {")
                code.globalstate.use_utility_code(tuple_unpacking_error_code)
                code.putln("__Pyx_UnpackTupleError(%s, %s); %s" % (
                    rhs.py_result(), len(self.args), code.error_goto(self.pos)))
                code.putln("} else")
4967
            code.putln("#endif")
4968

4969
        code.putln("{")
Stefan Behnel's avatar
Stefan Behnel committed
4970 4971
        self.generate_generic_parallel_unpacking_code(
            code, rhs, self.unpacked_items, use_loop=long_enough_for_a_loop)
4972
        code.putln("}")
4973

4974 4975
        for value_node in self.coerced_unpacked_items:
            value_node.generate_evaluation_code(code)
4976 4977 4978
        for i in range(len(self.args)):
            self.args[i].generate_assignment_code(
                self.coerced_unpacked_items[i], code)
4979

4980
    def generate_special_parallel_unpacking_code(self, code, sequence_type, use_loop):
4981 4982
        code.globalstate.use_utility_code(raise_need_more_values_to_unpack)
        code.globalstate.use_utility_code(raise_too_many_values_to_unpack)
4983 4984 4985 4986 4987 4988 4989

        if use_loop:
            # must be at the start of a C block!
            code.putln("PyObject** temps[%s] = {%s};" % (
                len(self.unpacked_items),
                ','.join(['&%s' % item.result() for item in self.unpacked_items])))

4990 4991 4992 4993 4994 4995 4996
        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("}")
Robert Bradshaw's avatar
Robert Bradshaw committed
4997

4998 4999 5000 5001 5002
        if use_loop:
            # shorter code in a loop works better for lists in CPython
            counter = code.funcstate.allocate_temp(PyrexTypes.c_py_ssize_t_type, manage_ref=False)
            code.putln("for (%s=0; %s < %s; %s++) {" % (
                counter, counter, len(self.unpacked_items), counter))
Stefan Behnel's avatar
Stefan Behnel committed
5003 5004 5005
            code.putln("PyObject* item = Py%s_GET_ITEM(sequence, %s);" % (
                sequence_type, counter))
            code.putln("*(temps[%s]) = item;" % counter)
5006 5007 5008 5009 5010 5011 5012 5013 5014
            code.put_incref("item", PyrexTypes.py_object_type)
            code.putln("}")
            code.funcstate.release_temp(counter)
        else:
            # unrolling the loop is very fast for tuples in CPython
            for i, item in enumerate(self.unpacked_items):
                code.putln("%s = Py%s_GET_ITEM(sequence, %d); " % (item.result(), sequence_type, i))
                code.put_incref(item.result(), item.ctype())

5015
    def generate_generic_parallel_unpacking_code(self, code, rhs, unpacked_items, use_loop, terminate=True):
5016
        code.globalstate.use_utility_code(raise_need_more_values_to_unpack)
5017
        code.globalstate.use_utility_code(UtilityCode.load_cached("IterFinish", "ObjectHandling.c"))
5018
        code.putln("Py_ssize_t index = -1;") # must be at the start of a C block!
5019

5020 5021 5022
        if use_loop:
            code.putln("PyObject** temps[%s] = {%s};" % (
                len(self.unpacked_items),
5023
                ','.join(['&%s' % item.result() for item in unpacked_items])))
5024

5025 5026 5027 5028 5029 5030 5031 5032
        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)
5033

5034 5035 5036
        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
5037

5038 5039
        unpacking_error_label = code.new_label('unpacking_failed')
        unpack_code = "%s(%s)" % (iternext_func, iterator_temp)
5040
        if use_loop:
5041
            code.putln("for (index=0; index < %s; index++) {" % len(unpacked_items))
5042 5043 5044 5045 5046 5047
            code.put("PyObject* item = %s; if (unlikely(!item)) " % unpack_code)
            code.put_goto(unpacking_error_label)
            code.put_gotref("item")
            code.putln("*(temps[index]) = item;")
            code.putln("}")
        else:
5048
            for i, item in enumerate(unpacked_items):
5049 5050 5051 5052 5053 5054 5055 5056
                code.put(
                    "index = %d; %s = %s; if (unlikely(!%s)) " % (
                        i,
                        item.result(),
                        unpack_code,
                        item.result()))
                code.put_goto(unpacking_error_label)
                code.put_gotref(item.py_result())
5057 5058

        if terminate:
5059 5060
            code.globalstate.use_utility_code(
                UtilityCode.load_cached("UnpackItemEndCheck", "ObjectHandling.c"))
5061 5062 5063 5064 5065 5066
            code.put_error_if_neg(self.pos, "__Pyx_IternextUnpackEndCheck(%s, %d)" % (
                unpack_code,
                len(unpacked_items)))
            code.putln("%s = NULL;" % iternext_func)
            code.put_decref_clear(iterator_temp, py_object_type)

5067 5068 5069 5070 5071
        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)
5072
        code.putln("%s = NULL;" % iternext_func)
5073
        code.putln("if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);")
5074 5075
        code.putln(code.error_goto(self.pos))
        code.put_label(unpacking_done_label)
5076

5077 5078 5079 5080 5081 5082 5083
        code.funcstate.release_temp(iternext_func)
        if terminate:
            code.funcstate.release_temp(iterator_temp)
            iterator_temp = None

        return iterator_temp

5084 5085 5086 5087
    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]
5088 5089
                unpacked_fixed_items_left  = self.unpacked_items[:i]
                unpacked_fixed_items_right = self.unpacked_items[i+1:]
5090
                break
5091 5092
        else:
            assert False
5093

5094 5095
        iterator_temp = None
        if unpacked_fixed_items_left:
5096
            for item in unpacked_fixed_items_left:
5097
                item.allocate(code)
5098 5099 5100 5101 5102
            code.putln('{')
            iterator_temp = self.generate_generic_parallel_unpacking_code(
                code, rhs, unpacked_fixed_items_left,
                use_loop=True, terminate=False)
            for i, item in enumerate(unpacked_fixed_items_left):
5103 5104
                value_node = self.coerced_unpacked_items[i]
                value_node.generate_evaluation_code(code)
5105
            code.putln('}')
5106

5107
        starred_target.allocate(code)
5108 5109
        target_list = starred_target.result()
        code.putln("%s = PySequence_List(%s); %s" % (
5110 5111
            target_list,
            iterator_temp or rhs.py_result(),
5112 5113
            code.error_goto_if_null(target_list, self.pos)))
        code.put_gotref(target_list)
5114 5115 5116 5117 5118 5119 5120 5121

        if iterator_temp:
            code.put_decref_clear(iterator_temp, py_object_type)
            code.funcstate.release_temp(iterator_temp)
        else:
            rhs.generate_disposal_code(code)

        if unpacked_fixed_items_right:
5122
            code.globalstate.use_utility_code(raise_need_more_values_to_unpack)
5123 5124 5125 5126 5127 5128
            length_temp = code.funcstate.allocate_temp(PyrexTypes.c_py_ssize_t_type, manage_ref=False)
            code.putln('%s = PyList_GET_SIZE(%s);' % (length_temp, target_list))
            code.putln("if (unlikely(%s < %d)) {" % (length_temp, len(unpacked_fixed_items_right)))
            code.putln("__Pyx_RaiseNeedMoreValuesError(%d+%s); %s" % (
                 len(unpacked_fixed_items_left), length_temp,
                 code.error_goto(self.pos)))
5129
            code.putln('}')
5130 5131 5132 5133 5134

            for item in unpacked_fixed_items_right[::-1]:
                item.allocate(code)
            for i, (item, coerced_arg) in enumerate(zip(unpacked_fixed_items_right[::-1],
                                                        self.coerced_unpacked_items[::-1])):
5135 5136 5137
                code.putln('#if CYTHON_COMPILING_IN_CPYTHON')
                code.putln("%s = PyList_GET_ITEM(%s, %s-%d); " % (
                    item.py_result(), target_list, length_temp, i+1))
5138
                # resize the list the hard way
5139
                code.putln("((PyVarObject*)%s)->ob_size--;" % target_list)
5140 5141 5142 5143
                code.putln('#else')
                code.putln("%s = PySequence_GetItem(%s, %s-%d); " % (
                    item.py_result(), target_list, length_temp, i+1))
                code.putln('#endif')
5144
                code.put_gotref(item.py_result())
5145 5146
                coerced_arg.generate_evaluation_code(code)

5147
            code.putln('#if !CYTHON_COMPILING_IN_CPYTHON')
5148
            sublist_temp = code.funcstate.allocate_temp(py_object_type, manage_ref=True)
Stefan Behnel's avatar
Stefan Behnel committed
5149
            code.putln('%s = PySequence_GetSlice(%s, 0, %s-%d); %s' % (
5150 5151 5152 5153 5154 5155
                sublist_temp, target_list, length_temp, len(unpacked_fixed_items_right),
                code.error_goto_if_null(sublist_temp, self.pos)))
            code.put_gotref(sublist_temp)
            code.funcstate.release_temp(length_temp)
            code.put_decref(target_list, py_object_type)
            code.putln('%s = %s; %s = NULL;' % (target_list, sublist_temp, sublist_temp))
5156 5157
            code.putln('#else')
            code.putln('%s = %s;' % (sublist_temp, sublist_temp)) # avoid warning about unused variable
5158 5159 5160 5161 5162
            code.funcstate.release_temp(sublist_temp)
            code.putln('#endif')

        for i, arg in enumerate(self.args):
            arg.generate_assignment_code(self.coerced_unpacked_items[i], code)
5163

5164 5165 5166 5167 5168 5169 5170 5171
    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
5172 5173 5174 5175


class TupleNode(SequenceNode):
    #  Tuple constructor.
5176

5177
    type = tuple_type
5178
    is_partly_literal = False
5179 5180 5181

    gil_message = "Constructing Python tuple"

5182
    def analyse_types(self, env, skip_children=False):
Robert Bradshaw's avatar
Robert Bradshaw committed
5183
        if len(self.args) == 0:
5184 5185
            self.is_temp = False
            self.is_literal = True
Robert Bradshaw's avatar
Robert Bradshaw committed
5186
        else:
5187
            SequenceNode.analyse_types(self, env, skip_children)
5188 5189 5190 5191
            for child in self.args:
                if not child.is_literal:
                    break
            else:
5192 5193 5194 5195 5196
                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:
5197 5198
                    if not self.mult_factor.type.is_pyobject:
                        self.mult_factor = self.mult_factor.coerce_to_pyobject(env)
5199 5200
                    self.is_temp = True
                    self.is_partly_literal = True
5201

Stefan Behnel's avatar
Stefan Behnel committed
5202 5203 5204 5205
    def is_simple(self):
        # either temp or constant => always simple
        return True

5206 5207 5208 5209
    def nonlocally_immutable(self):
        # either temp or constant => always safe
        return True

Robert Bradshaw's avatar
Robert Bradshaw committed
5210 5211
    def calculate_result_code(self):
        if len(self.args) > 0:
5212
            return self.result_code
Robert Bradshaw's avatar
Robert Bradshaw committed
5213 5214
        else:
            return Naming.empty_tuple
William Stein's avatar
William Stein committed
5215

5216 5217 5218 5219
    def calculate_constant_result(self):
        self.constant_result = tuple([
                arg.constant_result for arg in self.args])

5220 5221 5222 5223 5224 5225
    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)
5226

William Stein's avatar
William Stein committed
5227
    def generate_operation_code(self, code):
Robert Bradshaw's avatar
Robert Bradshaw committed
5228 5229 5230
        if len(self.args) == 0:
            # result_code is Naming.empty_tuple
            return
5231 5232 5233 5234 5235 5236 5237 5238 5239 5240 5241 5242 5243
        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:
5244 5245
            # non-empty cached tuple => result is global constant,
            # creation code goes into separate code writer
5246
            self.result_code = code.get_py_const(py_object_type, 'tuple_', cleanup_level=2)
5247 5248
            code = code.get_cached_constants_writer()
            code.mark_pos(self.pos)
5249
            self.generate_sequence_packing_code(code)
5250
            code.put_giveref(self.py_result())
5251 5252
        else:
            self.generate_sequence_packing_code(code)
William Stein's avatar
William Stein committed
5253 5254 5255 5256


class ListNode(SequenceNode):
    #  List constructor.
5257

5258 5259
    # obj_conversion_errors    [PyrexError]   used internally
    # orignial_args            [ExprNode]     used internally
5260

5261
    obj_conversion_errors = []
Stefan Behnel's avatar
Stefan Behnel committed
5262
    type = list_type
5263

5264
    gil_message = "Constructing Python list"
5265

Robert Bradshaw's avatar
Robert Bradshaw committed
5266
    def type_dependencies(self, env):
5267
        return ()
5268

5269 5270 5271
    def infer_type(self, env):
        # TOOD: Infer non-object list arrays.
        return list_type
5272

5273
    def analyse_expressions(self, env):
5274
        SequenceNode.analyse_expressions(self, env)
5275 5276
        self.coerce_to_pyobject(env)

Robert Bradshaw's avatar
Robert Bradshaw committed
5277
    def analyse_types(self, env):
5278 5279 5280 5281 5282
        hold_errors()
        self.original_args = list(self.args)
        SequenceNode.analyse_types(self, env)
        self.obj_conversion_errors = held_errors()
        release_errors(ignore=True)
5283

Robert Bradshaw's avatar
Robert Bradshaw committed
5284 5285
    def coerce_to(self, dst_type, env):
        if dst_type.is_pyobject:
5286 5287 5288
            for err in self.obj_conversion_errors:
                report_error(err)
            self.obj_conversion_errors = []
Robert Bradshaw's avatar
Robert Bradshaw committed
5289 5290
            if not self.type.subtype_of(dst_type):
                error(self.pos, "Cannot coerce list to type '%s'" % dst_type)
5291 5292
        elif self.mult_factor:
            error(self.pos, "Cannot coerce multiplied list to '%s'" % dst_type)
5293
        elif dst_type.is_ptr and dst_type.base_type is not PyrexTypes.c_void_type:
Robert Bradshaw's avatar
Robert Bradshaw committed
5294
            base_type = dst_type.base_type
Robert Bradshaw's avatar
Robert Bradshaw committed
5295
            self.type = PyrexTypes.CArrayType(base_type, len(self.args))
5296
            for i in range(len(self.original_args)):
Robert Bradshaw's avatar
Robert Bradshaw committed
5297
                arg = self.args[i]
5298 5299
                if isinstance(arg, CoerceToPyTypeNode):
                    arg = arg.arg
Robert Bradshaw's avatar
Robert Bradshaw committed
5300
                self.args[i] = arg.coerce_to(base_type, env)
Robert Bradshaw's avatar
Robert Bradshaw committed
5301 5302 5303 5304 5305 5306
        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)
5307 5308 5309
                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
5310 5311
                    self.args[i] = arg.coerce_to(member.type, env)
            self.type = dst_type
Robert Bradshaw's avatar
Robert Bradshaw committed
5312 5313 5314 5315
        else:
            self.type = error_type
            error(self.pos, "Cannot coerce list to type '%s'" % dst_type)
        return self
5316

Robert Bradshaw's avatar
Robert Bradshaw committed
5317 5318
    def release_temp(self, env):
        if self.type.is_array:
5319 5320
            # 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
5321 5322 5323
            pass
        else:
            SequenceNode.release_temp(self, env)
Robert Bradshaw's avatar
Robert Bradshaw committed
5324

5325
    def calculate_constant_result(self):
5326 5327
        if self.mult_factor:
            raise ValueError() # may exceed the compile time memory
5328 5329 5330
        self.constant_result = [
            arg.constant_result for arg in self.args]

5331
    def compile_time_value(self, denv):
5332 5333 5334 5335
        l = self.compile_time_value_list(denv)
        if self.mult_factor:
            l *= self.mult_factor.compile_time_value(denv)
        return l
5336

William Stein's avatar
William Stein committed
5337
    def generate_operation_code(self, code):
Robert Bradshaw's avatar
Robert Bradshaw committed
5338
        if self.type.is_pyobject:
5339 5340
            for err in self.obj_conversion_errors:
                report_error(err)
5341
            self.generate_sequence_packing_code(code)
Robert Bradshaw's avatar
Robert Bradshaw committed
5342 5343 5344 5345 5346 5347
        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
5348
        elif self.type.is_struct:
Robert Bradshaw's avatar
Robert Bradshaw committed
5349 5350 5351 5352 5353
            for arg, member in zip(self.args, self.type.scope.var_entries):
                code.putln("%s.%s = %s;" % (
                        self.result(),
                        member.cname,
                        arg.result()))
5354 5355
        else:
            raise InternalError("List type never specified")
5356

Robert Bradshaw's avatar
Robert Bradshaw committed
5357

5358 5359 5360 5361 5362 5363 5364 5365 5366
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

5367 5368 5369 5370 5371 5372 5373 5374 5375 5376 5377 5378 5379 5380 5381 5382 5383 5384 5385
    # 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
5386 5387
        pass

5388 5389
    def analyse_types(self, env):
        # no recursion here, the children will be analysed separately below
5390 5391 5392 5393 5394 5395
        pass

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

5396 5397 5398 5399 5400 5401 5402 5403 5404 5405 5406 5407 5408 5409 5410 5411 5412 5413 5414 5415 5416 5417 5418 5419 5420 5421 5422 5423 5424 5425 5426 5427 5428 5429 5430 5431 5432 5433 5434 5435 5436 5437 5438 5439 5440 5441 5442
    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

5443 5444

class ComprehensionNode(ScopedExprNode):
5445
    subexprs = ["target"]
5446
    child_attrs = ["loop"]
5447

5448 5449
    def infer_type(self, env):
        return self.target.infer_type(env)
5450 5451 5452

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

5455 5456
    def analyse_scoped_declarations(self, env):
        self.loop.analyse_declarations(env)
5457

5458 5459 5460
    def analyse_types(self, env):
        self.target.analyse_expressions(env)
        self.type = self.target.type
5461 5462
        if not self.has_local_scope:
            self.loop.analyse_expressions(env)
5463

5464 5465 5466
    def analyse_scoped_expressions(self, env):
        if self.has_local_scope:
            self.loop.analyse_expressions(env)
5467

5468 5469 5470
    def may_be_none(self):
        return False

5471 5472
    def calculate_result_code(self):
        return self.target.result()
5473

5474 5475
    def generate_result_code(self, code):
        self.generate_operation_code(code)
Robert Bradshaw's avatar
Robert Bradshaw committed
5476

5477 5478 5479
    def generate_operation_code(self, code):
        self.loop.generate_execution_code(code)

5480 5481
    def annotate(self, code):
        self.loop.annotate(code)
5482 5483


5484
class ComprehensionAppendNode(Node):
5485 5486
    # Need to be careful to avoid infinite recursion:
    # target must not be in child_attrs/subexprs
5487 5488

    child_attrs = ['expr']
5489 5490

    type = PyrexTypes.c_int_type
5491

5492 5493
    def analyse_expressions(self, env):
        self.expr.analyse_expressions(env)
5494
        if not self.expr.type.is_pyobject:
Robert Bradshaw's avatar
Robert Bradshaw committed
5495
            self.expr = self.expr.coerce_to_pyobject(env)
5496

5497
    def generate_execution_code(self, code):
5498
        if self.target.type is list_type:
5499 5500
            code.globalstate.use_utility_code(UtilityCode.load_cached("InternalListAppend", "Optimize.c"))
            function = "__Pyx_PyList_Append"
5501 5502 5503 5504 5505
        elif self.target.type is set_type:
            function = "PySet_Add"
        else:
            raise InternalError(
                "Invalid type for comprehension node: %s" % self.target.type)
5506 5507 5508 5509 5510 5511 5512 5513 5514 5515 5516 5517 5518 5519 5520

        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)
5521 5522

class DictComprehensionAppendNode(ComprehensionAppendNode):
5523
    child_attrs = ['key_expr', 'value_expr']
5524

5525 5526
    def analyse_expressions(self, env):
        self.key_expr.analyse_expressions(env)
5527 5528
        if not self.key_expr.type.is_pyobject:
            self.key_expr = self.key_expr.coerce_to_pyobject(env)
5529
        self.value_expr.analyse_expressions(env)
5530 5531 5532
        if not self.value_expr.type.is_pyobject:
            self.value_expr = self.value_expr.coerce_to_pyobject(env)

5533 5534 5535 5536 5537 5538 5539 5540 5541 5542 5543 5544 5545 5546 5547 5548 5549 5550 5551 5552
    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)
5553 5554


5555 5556 5557 5558 5559
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.
5560
    #
5561 5562 5563
    # 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
5564

5565
    child_attrs = ["loop"]
5566
    loop_analysed = False
5567 5568
    type = py_object_type

5569 5570
    def analyse_scoped_declarations(self, env):
        self.loop.analyse_declarations(env)
5571

5572 5573 5574 5575 5576 5577
    def may_be_none(self):
        return False

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

5578 5579
    def infer_type(self, env):
        return self.result_node.infer_type(env)
5580 5581

    def analyse_types(self, env):
5582 5583 5584
        if not self.has_local_scope:
            self.loop_analysed = True
            self.loop.analyse_expressions(env)
5585 5586 5587
        self.type = self.result_node.type
        self.is_temp = True

5588 5589
    def analyse_scoped_expressions(self, env):
        self.loop_analysed = True
5590 5591
        if self.has_local_scope:
            self.loop.analyse_expressions(env)
5592

5593
    def coerce_to(self, dst_type, env):
5594 5595 5596 5597 5598 5599
        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.
5600 5601
            self.result_node.type = self.type = dst_type
            return self
5602
        return super(InlinedGeneratorExpressionNode, self).coerce_to(dst_type, env)
5603

5604 5605 5606 5607 5608
    def generate_result_code(self, code):
        self.result_node.result_code = self.result()
        self.loop.generate_execution_code(code)


5609
class SetNode(ExprNode):
5610 5611
    #  Set constructor.

5612 5613
    type = set_type

5614 5615 5616
    subexprs = ['args']

    gil_message = "Constructing Python set"
5617

5618 5619 5620 5621 5622 5623 5624 5625
    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

5626 5627 5628
    def may_be_none(self):
        return False

5629 5630 5631 5632
    def calculate_constant_result(self):
        self.constant_result = set([
                arg.constant_result for arg in self.args])

5633 5634 5635 5636 5637 5638 5639 5640
    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
5641
        code.globalstate.use_utility_code(Builtin.py_set_utility_code)
5642 5643 5644 5645 5646
        self.allocate_temp_result(code)
        code.putln(
            "%s = PySet_New(0); %s" % (
                self.result(),
                code.error_goto_if_null(self.result(), self.pos)))
5647
        code.put_gotref(self.py_result())
5648 5649 5650 5651 5652 5653 5654 5655
        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
5656

William Stein's avatar
William Stein committed
5657

5658
class DictNode(ExprNode):
William Stein's avatar
William Stein committed
5659 5660
    #  Dictionary constructor.
    #
Vitja Makarov's avatar
Vitja Makarov committed
5661 5662
    #  key_value_pairs     [DictItemNode]
    #  exclude_null_values [boolean]          Do not add NULL values to dict
5663 5664
    #
    # obj_conversion_errors    [PyrexError]   used internally
5665

5666
    subexprs = ['key_value_pairs']
5667
    is_temp = 1
Vitja Makarov's avatar
Vitja Makarov committed
5668
    exclude_null_values = False
5669
    type = dict_type
5670

5671
    obj_conversion_errors = []
5672

5673 5674 5675 5676 5677
    @classmethod
    def from_pairs(cls, pos, pairs):
        return cls(pos, key_value_pairs=[
                DictItemNode(pos, key=k, value=v) for k, v in pairs])

5678 5679 5680
    def calculate_constant_result(self):
        self.constant_result = dict([
                item.constant_result for item in self.key_value_pairs])
5681

5682
    def compile_time_value(self, denv):
Robert Bradshaw's avatar
Robert Bradshaw committed
5683 5684
        pairs = [(item.key.compile_time_value(denv), item.value.compile_time_value(denv))
            for item in self.key_value_pairs]
5685 5686 5687 5688
        try:
            return dict(pairs)
        except Exception, e:
            self.compile_time_value_error(e)
5689

Robert Bradshaw's avatar
Robert Bradshaw committed
5690
    def type_dependencies(self, env):
5691
        return ()
5692

5693 5694 5695 5696
    def infer_type(self, env):
        # TOOD: Infer struct constructors.
        return dict_type

William Stein's avatar
William Stein committed
5697
    def analyse_types(self, env):
5698
        hold_errors()
Robert Bradshaw's avatar
Robert Bradshaw committed
5699 5700
        for item in self.key_value_pairs:
            item.analyse_types(env)
5701 5702
        self.obj_conversion_errors = held_errors()
        release_errors(ignore=True)
5703 5704 5705

    def may_be_none(self):
        return False
5706

5707 5708 5709 5710 5711 5712 5713 5714 5715 5716 5717 5718 5719 5720
    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
5721
                if not item.key.is_string_literal:
5722
                    error(item.key.pos, "Invalid struct field identifier")
5723
                    item.key = StringNode(item.key.pos, value="<error>")
5724
                else:
Stefan Behnel's avatar
Stefan Behnel committed
5725 5726
                    key = str(item.key.value) # converts string literals to unicode in Py3
                    member = dst_type.scope.lookup_here(key)
5727
                    if not member:
Stefan Behnel's avatar
Stefan Behnel committed
5728
                        error(item.key.pos, "struct '%s' has no field '%s'" % (dst_type, key))
5729 5730 5731 5732 5733 5734 5735 5736 5737
                    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
5738

5739 5740 5741 5742
    def release_errors(self):
        for err in self.obj_conversion_errors:
            report_error(err)
        self.obj_conversion_errors = []
5743 5744 5745

    gil_message = "Constructing Python dict"

William Stein's avatar
William Stein committed
5746 5747 5748
    def generate_evaluation_code(self, code):
        #  Custom method used here because key-value
        #  pairs are evaluated and used one at a time.
5749 5750
        code.mark_pos(self.pos)
        self.allocate_temp_result(code)
5751 5752 5753 5754 5755 5756
        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)))
5757
            code.put_gotref(self.py_result())
Robert Bradshaw's avatar
Robert Bradshaw committed
5758 5759
        for item in self.key_value_pairs:
            item.generate_evaluation_code(code)
5760
            if self.type.is_pyobject:
Vitja Makarov's avatar
Vitja Makarov committed
5761 5762
                if self.exclude_null_values:
                    code.putln('if (%s) {' % item.value.py_result())
5763
                code.put_error_if_neg(self.pos,
5764 5765 5766 5767
                    "PyDict_SetItem(%s, %s, %s)" % (
                        self.result(),
                        item.key.py_result(),
                        item.value.py_result()))
Vitja Makarov's avatar
Vitja Makarov committed
5768 5769
                if self.exclude_null_values:
                    code.putln('}')
5770 5771 5772
            else:
                code.putln("%s.%s = %s;" % (
                        self.result(),
5773
                        item.key.value,
5774
                        item.value.result()))
Robert Bradshaw's avatar
Robert Bradshaw committed
5775
            item.generate_disposal_code(code)
5776
            item.free_temps(code)
5777

5778
    def annotate(self, code):
Robert Bradshaw's avatar
Robert Bradshaw committed
5779 5780
        for item in self.key_value_pairs:
            item.annotate(code)
5781

5782
class DictItemNode(ExprNode):
Robert Bradshaw's avatar
Robert Bradshaw committed
5783 5784 5785 5786 5787
    # Represents a single item in a DictNode
    #
    # key          ExprNode
    # value        ExprNode
    subexprs = ['key', 'value']
5788

5789
    nogil_check = None # Parent DictNode takes care of it
5790

5791 5792 5793
    def calculate_constant_result(self):
        self.constant_result = (
            self.key.constant_result, self.value.constant_result)
5794

Robert Bradshaw's avatar
Robert Bradshaw committed
5795 5796 5797 5798 5799
    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)
5800

Robert Bradshaw's avatar
Robert Bradshaw committed
5801 5802 5803
    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
5804

5805 5806 5807
    def generate_disposal_code(self, code):
        self.key.generate_disposal_code(code)
        self.value.generate_disposal_code(code)
5808 5809 5810 5811

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

5813 5814
    def __iter__(self):
        return iter([self.key, self.value])
William Stein's avatar
William Stein committed
5815

5816

5817 5818 5819 5820 5821 5822 5823
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
5824

5825
class ClassNode(ExprNode, ModuleNameMixin):
William Stein's avatar
William Stein committed
5826 5827 5828 5829
    #  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
5830
    #  name         EncodedString      Name of the class
William Stein's avatar
William Stein committed
5831 5832 5833
    #  bases        ExprNode           Base class tuple
    #  dict         ExprNode           Class dict (not owned by this node)
    #  doc          ExprNode or None   Doc string
5834
    #  module_name  EncodedString      Name of defining module
5835

5836
    subexprs = ['bases', 'doc']
5837

William Stein's avatar
William Stein committed
5838 5839 5840 5841 5842 5843 5844
    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
5845
        env.use_utility_code(UtilityCode.load_cached("CreateClass", "ObjectHandling.c"))
5846 5847
        #TODO(craig,haoyu) This should be moved to a better place
        self.set_mod_name(env)
5848

5849
    def may_be_none(self):
Stefan Behnel's avatar
Stefan Behnel committed
5850
        return True
5851

5852 5853
    gil_message = "Constructing Python class"

William Stein's avatar
William Stein committed
5854
    def generate_result_code(self, code):
5855
        cname = code.intern_identifier(self.name)
5856

William Stein's avatar
William Stein committed
5857
        if self.doc:
5858
            code.put_error_if_neg(self.pos,
Robert Bradshaw's avatar
Robert Bradshaw committed
5859
                'PyDict_SetItemString(%s, "__doc__", %s)' % (
William Stein's avatar
William Stein committed
5860
                    self.dict.py_result(),
Robert Bradshaw's avatar
Robert Bradshaw committed
5861
                    self.doc.py_result()))
5862
        py_mod_name = self.get_py_mod_name(code)
William Stein's avatar
William Stein committed
5863
        code.putln(
5864
            '%s = __Pyx_CreateClass(%s, %s, %s, %s); %s' % (
5865
                self.result(),
William Stein's avatar
William Stein committed
5866 5867
                self.bases.py_result(),
                self.dict.py_result(),
5868
                cname,
5869
                py_mod_name,
5870
                code.error_goto_if_null(self.result(), self.pos)))
5871
        code.put_gotref(self.py_result())
William Stein's avatar
William Stein committed
5872

Stefan Behnel's avatar
Stefan Behnel committed
5873

5874 5875 5876 5877 5878 5879 5880 5881 5882 5883 5884 5885 5886 5887 5888 5889 5890 5891
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

5892
    gil_message = "Constructing Python class"
5893 5894

    def generate_result_code(self, code):
5895
        code.globalstate.use_utility_code(UtilityCode.load_cached("Py3ClassCreate", "ObjectHandling.c"))
5896 5897 5898 5899 5900 5901 5902 5903 5904 5905 5906 5907 5908
        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):
5909
    #  Helper class for keyword arguments.
5910
    #
5911 5912
    #  starstar_arg      DictNode
    #  keyword_args      [DictItemNode]
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 5938 5939
    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
5940

5941 5942 5943 5944 5945
    def type_dependencies(self, env):
        return ()

    def infer_type(self, env):
        return dict_type
5946 5947

    def analyse_types(self, env):
5948 5949 5950 5951 5952 5953
        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)
5954

5955 5956
    def may_be_none(self):
        return False
5957

5958 5959 5960 5961 5962 5963 5964 5965 5966 5967
    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())
5968 5969 5970 5971 5972 5973
        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)))
5974
            code.put_gotref(self.py_result())
5975
        else:
5976 5977 5978 5979 5980 5981
            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 {')
5982
            code.putln(
5983 5984
                "%s = PyObject_CallFunctionObjArgs("
                "(PyObject*)&PyDict_Type, %s, NULL); %s" % (
5985
                    self.result(),
5986
                    self.starstar_arg.py_result(),
5987
                    code.error_goto_if_null(self.result(), self.pos)))
5988
            code.put_gotref(self.py_result())
5989 5990 5991 5992 5993 5994 5995
            code.putln('}')
        self.starstar_arg.generate_disposal_code(code)
        self.starstar_arg.free_temps(code)

        if not self.keyword_args:
            return

5996 5997
        code.globalstate.use_utility_code(
            UtilityCode.load_cached("RaiseDoubleKeywords", "FunctionArguments.c"))
5998 5999 6000 6001 6002 6003 6004 6005 6006 6007 6008 6009 6010 6011 6012 6013 6014 6015 6016 6017 6018 6019
        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)
6020 6021 6022 6023 6024 6025 6026 6027 6028 6029 6030 6031 6032 6033 6034 6035 6036

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):
6037
        code.globalstate.use_utility_code(UtilityCode.load_cached("Py3MetaclassGet", "ObjectHandling.c"))
6038 6039 6040 6041 6042 6043 6044 6045 6046 6047 6048 6049 6050 6051 6052 6053 6054 6055 6056 6057 6058 6059 6060 6061 6062 6063 6064 6065 6066 6067 6068 6069 6070 6071 6072 6073 6074 6075 6076 6077 6078 6079 6080 6081 6082 6083 6084 6085 6086 6087 6088
        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())

6089 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 6127 6128 6129 6130 6131 6132

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;' % (
6133
                self.result(), Naming.generator_cname))
6134 6135 6136 6137 6138 6139 6140 6141
        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
6142 6143 6144 6145 6146 6147 6148
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
6149

Robert Bradshaw's avatar
Robert Bradshaw committed
6150
    subexprs = ['function']
6151

Robert Bradshaw's avatar
Robert Bradshaw committed
6152 6153 6154 6155 6156 6157 6158 6159 6160 6161 6162 6163 6164 6165 6166 6167
    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
6168

6169
class UnboundMethodNode(ExprNode):
William Stein's avatar
William Stein committed
6170 6171 6172 6173 6174
    #  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
6175

6176 6177
    type = py_object_type
    is_temp = 1
6178

William Stein's avatar
William Stein committed
6179
    subexprs = ['function']
6180

William Stein's avatar
William Stein committed
6181 6182
    def analyse_types(self, env):
        self.function.analyse_types(env)
6183

6184 6185 6186
    def may_be_none(self):
        return False

6187 6188
    gil_message = "Constructing an unbound method"

William Stein's avatar
William Stein committed
6189
    def generate_result_code(self, code):
6190
        class_cname = code.pyclass_stack[-1].classobj.result()
William Stein's avatar
William Stein committed
6191
        code.putln(
Robert Bradshaw's avatar
Robert Bradshaw committed
6192
            "%s = PyMethod_New(%s, 0, %s); %s" % (
6193
                self.result(),
William Stein's avatar
William Stein committed
6194
                self.function.py_result(),
6195
                class_cname,
6196
                code.error_goto_if_null(self.result(), self.pos)))
6197
        code.put_gotref(self.py_result())
William Stein's avatar
William Stein committed
6198

Robert Bradshaw's avatar
Robert Bradshaw committed
6199

6200
class PyCFunctionNode(ExprNode, ModuleNameMixin):
William Stein's avatar
William Stein committed
6201 6202 6203 6204
    #  Helper class used in the implementation of Python
    #  class definitions. Constructs a PyCFunction object
    #  from a PyMethodDef struct.
    #
6205
    #  pymethdef_cname   string             PyMethodDef structure
Robert Bradshaw's avatar
Robert Bradshaw committed
6206
    #  self_object       ExprNode or None
Robert Bradshaw's avatar
Robert Bradshaw committed
6207
    #  binding           bool
6208
    #  def_node          DefNode            the Python function node
6209
    #  module_name       EncodedString      Name of defining module
6210 6211
    #  code_object       CodeObjectNode     the PyCodeObject creator node

6212
    subexprs = ['code_object', 'defaults_tuple']
Stefan Behnel's avatar
Stefan Behnel committed
6213

Robert Bradshaw's avatar
Robert Bradshaw committed
6214
    self_object = None
6215
    code_object = None
Robert Bradshaw's avatar
Robert Bradshaw committed
6216
    binding = False
6217
    def_node = None
6218 6219 6220
    defaults = None
    defaults_struct = None
    defaults_pyobjects = 0
6221
    defaults_tuple = None
6222

6223 6224
    type = py_object_type
    is_temp = 1
6225

6226
    specialized_cpdefs = None
6227
    is_specialization = False
6228

6229 6230 6231 6232 6233 6234 6235 6236
    @classmethod
    def from_defnode(cls, node, binding):
        return cls(node.pos,
                   def_node=node,
                   pymethdef_cname=node.entry.pymethdef_cname,
                   binding=binding or node.specialized_cpdefs,
                   specialized_cpdefs=node.specialized_cpdefs,
                   code_object=CodeObjectNode(node))
6237

6238
    def analyse_types(self, env):
Robert Bradshaw's avatar
Robert Bradshaw committed
6239
        if self.binding:
6240
            if self.specialized_cpdefs or self.is_specialization:
6241 6242 6243
                env.use_utility_code(fused_function_utility_code)
            else:
                env.use_utility_code(binding_cfunc_utility_code)
Mark Florisson's avatar
Mark Florisson committed
6244
            self.analyse_default_args(env)
6245

6246 6247 6248
        #TODO(craig,haoyu) This should be moved to a better place
        self.set_mod_name(env)

6249 6250 6251 6252 6253 6254
    def analyse_default_args(self, env):
        """
        Handle non-literal function's default arguments.
        """
        nonliteral_objects = []
        nonliteral_other = []
6255
        default_args = []
6256
        for arg in self.def_node.args:
6257 6258 6259 6260 6261 6262 6263
            if arg.default:
                if not arg.default.is_literal:
                    arg.is_dynamic = True
                    if arg.type.is_pyobject:
                        nonliteral_objects.append(arg)
                    else:
                        nonliteral_other.append(arg)
6264 6265
                else:
                    arg.default = DefaultLiteralArgNode(arg.pos, arg.default)
6266
                default_args.append(arg)
Mark Florisson's avatar
Mark Florisson committed
6267
        if nonliteral_objects or nonliteral_other:
6268 6269 6270 6271 6272 6273 6274 6275 6276 6277 6278 6279 6280 6281 6282 6283 6284 6285 6286 6287 6288 6289 6290
            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

6291 6292 6293 6294 6295
        if default_args:
            if self.defaults_struct is None:
                self.defaults_tuple = TupleNode(self.pos, args=[
                    arg.default for arg in default_args])
                self.defaults_tuple.analyse_types(env)
6296 6297 6298 6299 6300 6301 6302 6303
            else:
                defaults_getter = Nodes.DefNode(
                    self.pos, args=[], star_arg=None, starstar_arg=None,
                    body=Nodes.ReturnStatNode(
                        self.pos, return_type=py_object_type,
                        value=DefaultsTupleNode(
                            self.pos, default_args,
                            self.defaults_struct)),
6304
                    decorators=None, name=StringEncoding.EncodedString("__defaults__"))
6305 6306 6307 6308 6309 6310 6311
                defaults_getter.analyse_declarations(env)
                defaults_getter.analyse_expressions(env)
                defaults_getter.body.analyse_expressions(
                    defaults_getter.local_scope)
                defaults_getter.py_wrapper_required = False
                defaults_getter.pymethdef_required = False
                self.def_node.defaults_getter = defaults_getter
6312

6313 6314
    def may_be_none(self):
        return False
6315

6316 6317
    gil_message = "Constructing Python function"

Stefan Behnel's avatar
Stefan Behnel committed
6318
    def self_result_code(self):
Robert Bradshaw's avatar
Robert Bradshaw committed
6319 6320 6321 6322
        if self.self_object is None:
            self_result = "NULL"
        else:
            self_result = self.self_object.py_result()
Stefan Behnel's avatar
Stefan Behnel committed
6323 6324 6325
        return self_result

    def generate_result_code(self, code):
Robert Bradshaw's avatar
Robert Bradshaw committed
6326
        if self.binding:
6327 6328 6329
            self.generate_cyfunction_code(code)
        else:
            self.generate_pycfunction_code(code)
6330

6331 6332 6333 6334 6335 6336 6337 6338 6339 6340 6341 6342 6343
    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):
6344 6345
        def_node = self.def_node

6346 6347
        if self.specialized_cpdefs:
            constructor = "__pyx_FusedFunction_NewEx"
6348
            def_node = self.specialized_cpdefs[0]
6349 6350
        elif self.is_specialization:
            constructor = "__pyx_FusedFunction_NewEx"
Robert Bradshaw's avatar
Robert Bradshaw committed
6351
        else:
6352 6353 6354 6355 6356 6357 6358 6359
            constructor = "__Pyx_CyFunction_NewEx"

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

        flags = []
6360
        if def_node.is_staticmethod:
6361
            flags.append('__Pyx_CYFUNCTION_STATICMETHOD')
6362
        elif def_node.is_classmethod:
6363
            flags.append('__Pyx_CYFUNCTION_CLASSMETHOD')
6364 6365 6366 6367

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

6368 6369 6370 6371
        if flags:
            flags = ' | '.join(flags)
        else:
            flags = '0'
6372

6373
        py_mod_name = self.get_py_mod_name(code)
William Stein's avatar
William Stein committed
6374
        code.putln(
6375
            '%s = %s(&%s, %s, %s, %s, %s); %s' % (
6376
                self.result(),
Robert Bradshaw's avatar
Robert Bradshaw committed
6377
                constructor,
William Stein's avatar
William Stein committed
6378
                self.pymethdef_cname,
6379
                flags,
Stefan Behnel's avatar
Stefan Behnel committed
6380
                self.self_result_code(),
6381
                py_mod_name,
6382
                code_object_result,
6383
                code.error_goto_if_null(self.result(), self.pos)))
6384

6385
        code.put_gotref(self.py_result())
William Stein's avatar
William Stein committed
6386

6387
        if def_node.requires_classobj:
6388 6389 6390 6391 6392 6393 6394 6395 6396
            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())

6397 6398 6399 6400 6401 6402 6403 6404 6405 6406 6407
        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))

6408 6409 6410
        if self.defaults_tuple:
            code.putln('__Pyx_CyFunction_SetDefaultsTuple(%s, %s);' % (
                self.result(), self.defaults_tuple.py_result()))
6411 6412 6413
        if def_node.defaults_getter:
            code.putln('__Pyx_CyFunction_SetDefaultsGetter(%s, %s);' % (
                self.result(), def_node.defaults_getter.entry.pyfunc_cname))
6414

6415

Stefan Behnel's avatar
Stefan Behnel committed
6416 6417 6418
class InnerFunctionNode(PyCFunctionNode):
    # Special PyCFunctionNode that depends on a closure class
    #
Vitja Makarov's avatar
Vitja Makarov committed
6419

Robert Bradshaw's avatar
Robert Bradshaw committed
6420
    binding = True
Vitja Makarov's avatar
Vitja Makarov committed
6421 6422
    needs_self_code = True

Stefan Behnel's avatar
Stefan Behnel committed
6423
    def self_result_code(self):
Vitja Makarov's avatar
Vitja Makarov committed
6424 6425 6426
        if self.needs_self_code:
            return "((PyObject*)%s)" % (Naming.cur_scope_cname)
        return "NULL"
Stefan Behnel's avatar
Stefan Behnel committed
6427

6428 6429 6430 6431
class CodeObjectNode(ExprNode):
    # Create a PyCodeObject for a CyFunction instance.
    #
    # def_node   DefNode    the Python function node
6432
    # varnames   TupleNode  a tuple with all local variable names
6433 6434 6435 6436 6437 6438 6439 6440 6441 6442 6443

    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)
6444
        local_vars = [ arg for arg in def_node.local_scope.var_entries
6445
                       if arg.name ]
6446 6447
        self.varnames = TupleNode(
            def_node.pos,
6448
            args = [ IdentifierStringNode(arg.pos, value=arg.name)
6449
                     for arg in args + local_vars ],
6450 6451 6452 6453 6454 6455 6456 6457 6458 6459 6460 6461 6462 6463 6464 6465 6466 6467 6468 6469 6470 6471 6472 6473 6474
            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
6475 6476
            Naming.empty_tuple,        # names (FIXME)
            self.varnames.result(),    # varnames
6477 6478 6479 6480 6481 6482 6483 6484 6485 6486
            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),
            ))


6487 6488 6489 6490 6491 6492 6493 6494 6495 6496 6497 6498 6499 6500 6501 6502 6503 6504 6505 6506 6507 6508 6509 6510 6511 6512 6513 6514 6515 6516 6517
class DefaultLiteralArgNode(ExprNode):
    # CyFunction's literal argument default value
    #
    # Evaluate literal only once.

    subexprs = []
    is_literal = True
    is_temp = False

    def __init__(self, pos, arg):
        super(DefaultLiteralArgNode, self).__init__(pos)
        self.arg = arg
        self.type = self.arg.type
        self.evaluated = False

    def analyse_types(self, env):
        pass

    def generate_result_code(self, code):
        pass

    def generate_evaluation_code(self, code):
        if not self.evaluated:
            self.arg.generate_evaluation_code(code)
            self.evaluated = True

    def result(self):
        return self.type.cast_code(self.arg.result())


class DefaultNonLiteralArgNode(ExprNode):
6518 6519 6520 6521 6522
    # CyFunction's non-literal argument default value

    subexprs = []

    def __init__(self, pos, arg, defaults_struct):
6523
        super(DefaultNonLiteralArgNode, self).__init__(pos)
6524 6525 6526 6527 6528 6529 6530 6531 6532 6533 6534 6535 6536 6537 6538 6539 6540 6541 6542 6543 6544 6545 6546
        self.arg = arg
        self.defaults_struct = defaults_struct

    def analyse_types(self, env):
        self.type = self.arg.type
        self.is_temp = False

    def generate_result_code(self, code):
        pass

    def result(self):
        return '__Pyx_CyFunction_Defaults(%s, %s)->%s' % (
            self.defaults_struct.name, Naming.self_cname,
            self.defaults_struct.lookup(self.arg.name).cname)


class DefaultsTupleNode(TupleNode):
    # CyFunction's __defaults__ tuple

    def __init__(self, pos, defaults, defaults_struct):
        args = []
        for arg in defaults:
            if not arg.default.is_literal:
6547
                arg = DefaultNonLiteralArgNode(pos, arg, defaults_struct)
6548 6549 6550 6551 6552 6553
            else:
                arg = arg.default
            args.append(arg)
        super(DefaultsTupleNode, self).__init__(pos, args=args)


Stefan Behnel's avatar
Stefan Behnel committed
6554 6555 6556 6557 6558 6559 6560 6561 6562 6563 6564 6565 6566 6567 6568
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):
6569 6570
        self.def_node.no_assignment_synthesis = True
        self.def_node.pymethdef_required = True
Stefan Behnel's avatar
Stefan Behnel committed
6571
        self.def_node.analyse_declarations(env)
6572
        self.def_node.is_cyfunction = True
Stefan Behnel's avatar
Stefan Behnel committed
6573 6574 6575
        self.pymethdef_cname = self.def_node.entry.pymethdef_cname
        env.add_lambda_def(self.def_node)

6576 6577 6578 6579 6580 6581 6582 6583
    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)

6584

6585 6586 6587 6588 6589 6590 6591 6592
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

6593
    name = StringEncoding.EncodedString('genexpr')
6594 6595 6596
    binding = False

    def analyse_declarations(self, env):
6597 6598 6599
        super(GeneratorExpressionNode, self).analyse_declarations(env)
        # No pymethdef required
        self.def_node.pymethdef_required = False
6600
        self.def_node.py_wrapper_required = False
6601
        self.def_node.is_cyfunction = False
6602 6603
        # Force genexpr signature
        self.def_node.entry.signature = TypeSlots.pyfunction_noargs
6604 6605 6606

    def generate_result_code(self, code):
        code.putln(
6607
            '%s = %s(%s); %s' % (
6608
                self.result(),
6609
                self.def_node.entry.pyfunc_cname,
6610 6611 6612 6613 6614
                self.self_result_code(),
                code.error_goto_if_null(self.result(), self.pos)))
        code.put_gotref(self.py_result())


6615 6616 6617 6618 6619
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
6620
    # label_num   integer    yield label number
6621
    # is_yield_from  boolean is a YieldFromExprNode to delegate to another generator
6622 6623 6624

    subexprs = ['arg']
    type = py_object_type
6625
    label_num = 0
6626
    is_yield_from = False
6627 6628

    def analyse_types(self, env):
6629 6630
        if not self.label_num:
            error(self.pos, "'yield' not supported here")
6631 6632 6633 6634
        self.is_temp = 1
        if self.arg is not None:
            self.arg.analyse_types(env)
            if not self.arg.type.is_pyobject:
6635 6636 6637 6638
                self.coerce_yield_argument(env)

    def coerce_yield_argument(self, env):
        self.arg = self.arg.coerce_to_pyobject(env)
6639 6640 6641 6642 6643 6644 6645 6646 6647 6648 6649 6650 6651

    def generate_evaluation_code(self, code):
        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.free_temps(code)
        else:
            code.put_init_to_py_none(Naming.retval_cname, py_object_type)
6652 6653 6654 6655 6656 6657 6658 6659 6660 6661
        self.generate_yield_code(code)

    def generate_yield_code(self, code):
        """
        Generate the code to return the argument in 'Naming.retval_cname'
        and to continue at the yield label.
        """
        self.label_name = code.new_label('resume_from_yield')
        code.use_label(self.label_name)

6662
        saved = []
6663
        code.funcstate.closure_temps.reset()
6664
        for cname, type, manage_ref in code.funcstate.temps_in_use():
6665
            save_cname = code.funcstate.closure_temps.allocate_temp(type)
6666 6667 6668 6669
            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))
6670

6671
        code.put_xgiveref(Naming.retval_cname)
6672
        code.put_finish_refcount_context()
Stefan Behnel's avatar
Stefan Behnel committed
6673
        code.putln("/* return from generator, yielding value */")
6674 6675
        code.putln("%s->resume_label = %d;" % (
            Naming.generator_cname, self.label_num))
6676
        code.putln("return %s;" % Naming.retval_cname);
6677

6678
        code.put_label(self.label_name)
6679 6680 6681 6682 6683 6684
        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)
6685 6686 6687 6688 6689 6690 6691 6692
        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))
6693

Vitja Makarov's avatar
Vitja Makarov committed
6694

6695 6696 6697 6698 6699 6700 6701 6702 6703 6704 6705 6706 6707 6708 6709 6710 6711 6712
class YieldFromExprNode(YieldExprNode):
    # "yield from GEN" expression
    is_yield_from = True

    def coerce_yield_argument(self, env):
        if not self.arg.type.is_string:
            # FIXME: support C arrays and C++ iterators?
            error(self.pos, "yielding from non-Python object not supported")
        self.arg = self.arg.coerce_to_pyobject(env)

    def generate_evaluation_code(self, code):
        code.globalstate.use_utility_code(UtilityCode.load_cached("YieldFrom", "Generator.c"))

        self.arg.generate_evaluation_code(code)
        code.putln("%s = __Pyx_Generator_Yield_From(%s, %s);" % (
            Naming.retval_cname,
            Naming.generator_cname,
            self.arg.result_as(py_object_type)))
6713
        self.arg.generate_disposal_code(code)
6714 6715 6716 6717 6718 6719 6720 6721 6722 6723 6724 6725 6726 6727 6728 6729 6730 6731 6732 6733 6734
        self.arg.free_temps(code)
        code.put_xgotref(Naming.retval_cname)

        code.putln("if (likely(%s)) {" % Naming.retval_cname)
        self.generate_yield_code(code)
        code.putln("} else {")
        # either error or sub-generator has normally terminated: return value => node result
        if self.result_is_used:
            # YieldExprNode has allocated the result temp for us
            code.putln("if (__Pyx_PyGen_FetchStopIterationValue(&%s) < 0) %s" % (
                self.result(),
                code.error_goto(self.pos)))
        else:
            code.putln("PyObject* exc_type = PyErr_Occurred();")
            code.putln("if (exc_type) {")
            code.putln("if (!PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration)) %s" %
                code.error_goto(self.pos))
            code.putln("PyErr_Clear();")
            code.putln("}")
        code.putln("}")

Vitja Makarov's avatar
Vitja Makarov committed
6735 6736 6737 6738 6739 6740 6741 6742 6743 6744 6745 6746 6747 6748 6749
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
6750

6751 6752 6753 6754 6755 6756 6757 6758 6759 6760 6761
class LocalsDictItemNode(DictItemNode):
    def analyse_types(self, env):
        self.key.analyse_types(env)
        self.value.analyse_types(env)
        self.key = self.key.coerce_to_pyobject(env)
        if self.value.type.can_coerce_to_pyobject(env):
            self.value = self.value.coerce_to_pyobject(env)
        else:
            self.value = None


6762
class FuncLocalsExprNode(DictNode):
Vitja Makarov's avatar
Vitja Makarov committed
6763
    def __init__(self, pos, env):
6764
        local_vars = [entry.name for entry in env.entries.values()
6765 6766 6767 6768
                      if entry.name]
        items = [LocalsDictItemNode(
            pos, key=IdentifierStringNode(pos, value=var),
            value=NameNode(pos, name=var, allow_null=True))
Vitja Makarov's avatar
Vitja Makarov committed
6769 6770 6771 6772
                 for var in local_vars]
        DictNode.__init__(self, pos, key_value_pairs=items,
                          exclude_null_values=True)

6773 6774 6775 6776 6777
    def analyse_types(self, env):
        super(FuncLocalsExprNode, self).analyse_types(env)
        self.key_value_pairs = [i for i in self.key_value_pairs
                                if i.value is not None]

6778 6779 6780 6781 6782 6783 6784 6785 6786 6787 6788 6789 6790 6791 6792 6793 6794 6795 6796 6797 6798 6799 6800 6801 6802

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
6803 6804 6805 6806 6807 6808
#-------------------------------------------------------------------
#
#  Unary operator nodes
#
#-------------------------------------------------------------------

6809 6810 6811 6812 6813 6814 6815
compile_time_unary_operators = {
    'not': operator.not_,
    '~': operator.inv,
    '-': operator.neg,
    '+': operator.pos,
}

6816
class UnopNode(ExprNode):
William Stein's avatar
William Stein committed
6817 6818 6819 6820 6821 6822 6823 6824 6825 6826
    #  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.
6827

William Stein's avatar
William Stein committed
6828
    subexprs = ['operand']
Robert Bradshaw's avatar
Robert Bradshaw committed
6829
    infix = True
6830 6831 6832 6833

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

6835 6836 6837 6838 6839 6840 6841 6842 6843 6844 6845
    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)
6846

6847
    def infer_type(self, env):
6848 6849 6850 6851 6852
        operand_type = self.operand.infer_type(env)
        if operand_type.is_pyobject:
            return py_object_type
        else:
            return operand_type
6853

William Stein's avatar
William Stein committed
6854 6855 6856 6857 6858 6859
    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
6860 6861
        elif self.is_cpp_operation():
            self.analyse_cpp_operation(env)
William Stein's avatar
William Stein committed
6862 6863
        else:
            self.analyse_c_operation(env)
6864

William Stein's avatar
William Stein committed
6865
    def check_const(self):
6866
        return self.operand.check_const()
6867

William Stein's avatar
William Stein committed
6868 6869
    def is_py_operation(self):
        return self.operand.type.is_pyobject
6870

6871
    def nogil_check(self, env):
6872
        if self.is_py_operation():
6873
            self.gil_error()
6874

Danilo Freitas's avatar
Danilo Freitas committed
6875
    def is_cpp_operation(self):
Robert Bradshaw's avatar
Robert Bradshaw committed
6876
        type = self.operand.type
Robert Bradshaw's avatar
Robert Bradshaw committed
6877
        return type.is_cpp_class
6878

William Stein's avatar
William Stein committed
6879 6880
    def coerce_operand_to_pyobject(self, env):
        self.operand = self.operand.coerce_to_pyobject(env)
6881

William Stein's avatar
William Stein committed
6882 6883 6884
    def generate_result_code(self, code):
        if self.operand.type.is_pyobject:
            self.generate_py_operation_code(code)
6885

William Stein's avatar
William Stein committed
6886 6887 6888
    def generate_py_operation_code(self, code):
        function = self.py_operation_function()
        code.putln(
Robert Bradshaw's avatar
Robert Bradshaw committed
6889
            "%s = %s(%s); %s" % (
6890 6891
                self.result(),
                function,
William Stein's avatar
William Stein committed
6892
                self.operand.py_result(),
6893
                code.error_goto_if_null(self.result(), self.pos)))
6894
        code.put_gotref(self.py_result())
6895

William Stein's avatar
William Stein committed
6896 6897 6898 6899 6900 6901
    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
6902
    def analyse_cpp_operation(self, env):
6903
        type = self.operand.type
Robert Bradshaw's avatar
Robert Bradshaw committed
6904
        if type.is_ptr:
Danilo Freitas's avatar
Danilo Freitas committed
6905
            type = type.base_type
Robert Bradshaw's avatar
Robert Bradshaw committed
6906
        function = type.scope.lookup("operator%s" % self.operator)
Danilo Freitas's avatar
Danilo Freitas committed
6907 6908
        if not function:
            error(self.pos, "'%s' operator not defined for %s"
6909
                % (self.operator, type))
Danilo Freitas's avatar
Danilo Freitas committed
6910 6911
            self.type_error()
            return
6912 6913 6914 6915
        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
6916

William Stein's avatar
William Stein committed
6917

6918
class NotNode(ExprNode):
William Stein's avatar
William Stein committed
6919 6920 6921
    #  'not' operator
    #
    #  operand   ExprNode
6922

6923
    type = PyrexTypes.c_bint_type
6924

6925
    subexprs = ['operand']
6926

6927 6928 6929
    def calculate_constant_result(self):
        self.constant_result = not self.operand.constant_result

6930 6931 6932 6933 6934 6935 6936
    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)

6937 6938
    def infer_type(self, env):
        return PyrexTypes.c_bint_type
6939

William Stein's avatar
William Stein committed
6940 6941 6942
    def analyse_types(self, env):
        self.operand.analyse_types(env)
        self.operand = self.operand.coerce_to_boolean(env)
6943

William Stein's avatar
William Stein committed
6944
    def calculate_result_code(self):
6945
        return "(!%s)" % self.operand.result()
6946

William Stein's avatar
William Stein committed
6947 6948 6949 6950 6951 6952
    def generate_result_code(self, code):
        pass


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

William Stein's avatar
William Stein committed
6954
    operator = '+'
6955

William Stein's avatar
William Stein committed
6956
    def analyse_c_operation(self, env):
Lisandro Dalcin's avatar
Lisandro Dalcin committed
6957
        self.type = PyrexTypes.widest_numeric_type(
Robert Bradshaw's avatar
Robert Bradshaw committed
6958
            self.operand.type, PyrexTypes.c_int_type)
6959

William Stein's avatar
William Stein committed
6960 6961
    def py_operation_function(self):
        return "PyNumber_Positive"
6962

William Stein's avatar
William Stein committed
6963
    def calculate_result_code(self):
6964 6965 6966 6967
        if self.is_cpp_operation():
            return "(+%s)" % self.operand.result()
        else:
            return self.operand.result()
William Stein's avatar
William Stein committed
6968 6969 6970 6971


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

William Stein's avatar
William Stein committed
6973
    operator = '-'
6974

William Stein's avatar
William Stein committed
6975 6976
    def analyse_c_operation(self, env):
        if self.operand.type.is_numeric:
6977 6978
            self.type = PyrexTypes.widest_numeric_type(
                self.operand.type, PyrexTypes.c_int_type)
6979 6980
        elif self.operand.type.is_enum:
            self.type = PyrexTypes.c_int_type
William Stein's avatar
William Stein committed
6981 6982
        else:
            self.type_error()
Robert Bradshaw's avatar
Robert Bradshaw committed
6983
        if self.type.is_complex:
6984
            self.infix = False
6985

William Stein's avatar
William Stein committed
6986 6987
    def py_operation_function(self):
        return "PyNumber_Negative"
6988

William Stein's avatar
William Stein committed
6989
    def calculate_result_code(self):
Robert Bradshaw's avatar
Robert Bradshaw committed
6990 6991 6992 6993
        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
6994

6995 6996 6997 6998 6999
    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
7000 7001 7002 7003 7004
class TildeNode(UnopNode):
    #  unary '~' operator

    def analyse_c_operation(self, env):
        if self.operand.type.is_int:
7005 7006
            self.type = PyrexTypes.widest_numeric_type(
                self.operand.type, PyrexTypes.c_int_type)
7007 7008
        elif self.operand.type.is_enum:
            self.type = PyrexTypes.c_int_type
William Stein's avatar
William Stein committed
7009 7010 7011 7012 7013
        else:
            self.type_error()

    def py_operation_function(self):
        return "PyNumber_Invert"
7014

William Stein's avatar
William Stein committed
7015
    def calculate_result_code(self):
7016
        return "(~%s)" % self.operand.result()
William Stein's avatar
William Stein committed
7017 7018


7019 7020
class CUnopNode(UnopNode):

Robert Bradshaw's avatar
Robert Bradshaw committed
7021 7022 7023
    def is_py_operation(self):
        return False

7024 7025 7026 7027 7028 7029 7030 7031 7032 7033 7034 7035 7036 7037
class BangNode(CUnopNode):
    #  unary ! operator

    operator = '!'

    def analyse_c_operation(self, env):
        if self.operand.type.is_ptr or self.operand.type.is_numeric:
            self.type = PyrexTypes.c_bint_type
        else:
            self.type_error()

    def calculate_result_code(self):
        return "(!%s)" % self.operand.result()

7038 7039
class DereferenceNode(CUnopNode):
    #  unary * operator
7040 7041

    operator = '*'
7042

Robert Bradshaw's avatar
Robert Bradshaw committed
7043 7044 7045 7046 7047 7048 7049 7050
    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
7051 7052


7053 7054
class DecrementIncrementNode(CUnopNode):
    #  unary ++/-- operator
7055

7056
    def analyse_c_operation(self, env):
7057 7058 7059 7060
        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:
7061 7062 7063 7064 7065 7066 7067 7068 7069 7070 7071 7072 7073 7074
            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)


7075
class AmpersandNode(ExprNode):
William Stein's avatar
William Stein committed
7076 7077 7078
    #  The C address-of operator.
    #
    #  operand  ExprNode
7079

William Stein's avatar
William Stein committed
7080
    subexprs = ['operand']
7081

7082 7083
    def infer_type(self, env):
        return PyrexTypes.c_ptr_type(self.operand.infer_type(env))
William Stein's avatar
William Stein committed
7084 7085 7086 7087

    def analyse_types(self, env):
        self.operand.analyse_types(env)
        argtype = self.operand.type
7088
        if not (argtype.is_cfunction or self.operand.is_addressable()):
7089 7090 7091 7092
            if argtype.is_memoryviewslice:
                self.error("Cannot take address of memoryview slice")
            else:
                self.error("Taking address of non-lvalue")
William Stein's avatar
William Stein committed
7093 7094 7095 7096 7097
            return
        if argtype.is_pyobject:
            self.error("Cannot take address of Python variable")
            return
        self.type = PyrexTypes.c_ptr_type(argtype)
7098

William Stein's avatar
William Stein committed
7099
    def check_const(self):
7100
        return self.operand.check_const_addr()
7101

William Stein's avatar
William Stein committed
7102 7103 7104 7105
    def error(self, mess):
        error(self.pos, mess)
        self.type = PyrexTypes.error_type
        self.result_code = "<error>"
7106

William Stein's avatar
William Stein committed
7107
    def calculate_result_code(self):
7108
        return "(&%s)" % self.operand.result()
William Stein's avatar
William Stein committed
7109 7110 7111

    def generate_result_code(self, code):
        pass
7112

William Stein's avatar
William Stein committed
7113 7114 7115 7116 7117 7118 7119 7120

unop_node_classes = {
    "+":  UnaryPlusNode,
    "-":  UnaryMinusNode,
    "~":  TildeNode,
}

def unop_node(pos, operator, operand):
7121
    # Construct unnop node of appropriate class for
William Stein's avatar
William Stein committed
7122
    # given operator.
7123
    if isinstance(operand, IntNode) and operator == '-':
7124
        return IntNode(pos = operand.pos, value = str(-Utils.str_to_number(operand.value)))
Robert Bradshaw's avatar
Robert Bradshaw committed
7125 7126
    elif isinstance(operand, UnopNode) and operand.operator == operator:
        warning(pos, "Python has no increment/decrement operator: %s%sx = %s(%sx) = x" % ((operator,)*4), 5)
7127 7128
    return unop_node_classes[operator](pos,
        operator = operator,
William Stein's avatar
William Stein committed
7129 7130 7131
        operand = operand)


7132
class TypecastNode(ExprNode):
William Stein's avatar
William Stein committed
7133 7134
    #  C type cast
    #
7135
    #  operand      ExprNode
William Stein's avatar
William Stein committed
7136 7137
    #  base_type    CBaseTypeNode
    #  declarator   CDeclaratorNode
7138 7139 7140
    #
    #  If used from a transform, one can if wanted specify the attribute
    #  "type" directly and leave base_type and declarator to None
7141

William Stein's avatar
William Stein committed
7142
    subexprs = ['operand']
7143
    base_type = declarator = type = None
7144

Robert Bradshaw's avatar
Robert Bradshaw committed
7145
    def type_dependencies(self, env):
7146
        return ()
7147

Robert Bradshaw's avatar
Robert Bradshaw committed
7148
    def infer_type(self, env):
7149 7150 7151 7152
        if self.type is None:
            base_type = self.base_type.analyse(env)
            _, self.type = self.declarator.analyse(base_type, env)
        return self.type
7153

William Stein's avatar
William Stein committed
7154
    def analyse_types(self, env):
7155 7156 7157
        if self.type is None:
            base_type = self.base_type.analyse(env)
            _, self.type = self.declarator.analyse(base_type, env)
7158 7159 7160 7161
        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
7162 7163 7164
        self.operand.analyse_types(env)
        to_py = self.type.is_pyobject
        from_py = self.operand.type.is_pyobject
7165 7166
        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
7167
        if to_py and not from_py:
7168 7169 7170 7171 7172 7173
            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
7174
                self.result_ctype = py_object_type
7175
                self.operand = self.operand.coerce_to_pyobject(env)
7176
            else:
7177 7178 7179 7180
                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:
7181
                    # Should this be an error?
7182
                    warning(self.pos, "No conversion from %s to %s, python object pointer used." % (self.operand.type, self.type))
7183
                self.operand = self.operand.coerce_to_simple(env)
7184
        elif from_py and not to_py:
7185
            if self.type.create_from_py_utility_code(env):
7186
                self.operand = self.operand.coerce_to(self.type, env)
7187 7188 7189
            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")
7190 7191
            else:
                warning(self.pos, "No conversion from %s to %s, python object pointer used." % (self.type, self.operand.type))
7192 7193
        elif from_py and to_py:
            if self.typecheck and self.type.is_extension_type:
7194
                self.operand = PyTypeTestNode(self.operand, self.type, env, notnone=True)
7195 7196
        elif self.type.is_complex and self.operand.type.is_complex:
            self.operand = self.operand.coerce_to_simple(env)
7197 7198
        elif self.operand.type.is_fused:
            self.operand = self.operand.coerce_to(self.type, env)
7199
            #self.type = self.operand.type
7200

Stefan Behnel's avatar
Stefan Behnel committed
7201
    def is_simple(self):
7202 7203
        # 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
7204

7205 7206 7207
    def nonlocally_immutable(self):
        return self.operand.nonlocally_immutable()

7208 7209 7210
    def nogil_check(self, env):
        if self.type and self.type.is_pyobject and self.is_temp:
            self.gil_error()
7211

William Stein's avatar
William Stein committed
7212
    def check_const(self):
7213
        return self.operand.check_const()
Stefan Behnel's avatar
Stefan Behnel committed
7214 7215

    def calculate_constant_result(self):
7216 7217 7218
        # we usually do not know the result of a type cast at code
        # generation time
        pass
7219

William Stein's avatar
William Stein committed
7220
    def calculate_result_code(self):
7221 7222 7223 7224 7225 7226 7227 7228 7229 7230 7231
        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,
7232
                    imag_part)
7233 7234
        else:
            return self.type.cast_code(self.operand.result())
7235

7236 7237 7238 7239
    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)
7240

William Stein's avatar
William Stein committed
7241 7242 7243 7244 7245 7246 7247 7248 7249 7250 7251
    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;" % (
7252 7253 7254
                    self.result(),
                    self.operand.result()))
            code.put_incref(self.result(), self.ctype())
William Stein's avatar
William Stein committed
7255 7256


7257 7258 7259 7260
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")
7261
ERR_NOT_POINTER = "Can only create cython.array from pointer or array"
7262 7263 7264 7265 7266 7267 7268
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.

7269
        <int[:M:1, :N]> p
7270 7271 7272 7273 7274 7275 7276

    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
7277 7278 7279 7280 7281 7282

    This also handles <int[:, :]> my_c_array


    operand             ExprNode                 the thing we're casting
    base_type_node      MemoryViewSliceTypeNode  the cast expression node
7283 7284 7285 7286 7287 7288 7289
    """

    subexprs = ['operand', 'shapes']

    shapes = None
    is_temp = True
    mode = "c"
7290
    array_dtype = None
7291 7292 7293 7294 7295 7296

    shape_type = PyrexTypes.c_py_ssize_t_type

    def analyse_types(self, env):
        import MemoryView

7297 7298 7299 7300 7301 7302 7303 7304 7305
        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)

7306 7307
        self.type = error_type
        self.shapes = []
7308
        ndim = len(axes)
7309

7310 7311 7312
        # Base type of the pointer or C array we are converting
        base_type = self.operand.type

7313 7314 7315
        if not self.operand.type.is_ptr and not self.operand.type.is_array:
            return error(self.operand.pos, ERR_NOT_POINTER)

7316 7317 7318 7319 7320 7321
        # 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
7322
        elif base_type.is_ptr:
7323
            base_type = base_type.base_type
7324 7325
        else:
            return error()
7326

7327
        if not (base_type.same_as(array_dtype) or base_type.is_void):
7328 7329 7330 7331 7332 7333 7334 7335 7336 7337
            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):
7338 7339 7340 7341
            if not axis.start.is_none:
                return error(axis.start.pos, ERR_START)

            if axis.stop.is_none:
7342 7343 7344 7345 7346 7347 7348
                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)
7349 7350 7351 7352 7353 7354 7355 7356

            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)

7357
            first_or_last = axis_no in (0, ndim - 1)
7358
            if not axis.step.is_none and first_or_last:
7359
                # '1' in the first or last dimension denotes F or C contiguity
7360 7361 7362 7363 7364 7365 7366 7367 7368 7369 7370
                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"

7371 7372
            elif not axis.step.is_none and not first_or_last:
                # step provided in some other dimension
7373 7374 7375 7376 7377
                return error(axis.step.pos, ERR_STEPS)

        if not self.operand.is_name:
            self.operand = self.operand.coerce_to_temp(env)

7378
        axes = [('direct', 'follow')] * len(axes)
7379 7380 7381 7382 7383 7384
        if self.mode == "fortran":
            axes[0] = ('direct', 'contig')
        else:
            axes[-1] = ('direct', 'contig')

        self.coercion_type = PyrexTypes.MemoryViewSliceType(array_dtype, axes)
7385
        self.type = self.get_cython_array_type(env)
7386
        MemoryView.use_cython_array_utility_code(env)
7387 7388 7389 7390 7391 7392 7393 7394
        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)

7395 7396 7397 7398
    def infer_type(self, env):
        return self.get_cython_array_type(env)

    def get_cython_array_type(self, env):
7399
        return env.global_scope().context.cython_scope.viewscope.lookup("array").type
7400

7401 7402 7403 7404 7405 7406 7407 7408 7409 7410 7411 7412 7413
    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)

7414 7415 7416 7417 7418 7419
        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("}")
7420 7421 7422

        code.putln("%s = __pyx_format_from_typeinfo(&%s);" %
                                                (format_temp, type_info))
7423 7424 7425 7426
        buildvalue_fmt = " __PYX_BUILD_PY_SSIZE_T " * len(shapes)
        code.putln('%s = Py_BuildValue("(" %s ")", %s);' % (shapes_temp,
                                                            buildvalue_fmt,
                                                            ", ".join(shapes)))
7427

7428 7429 7430
        err = "!%s || !%s || !PyBytes_AsString(%s)" % (format_temp,
                                                       shapes_temp,
                                                       format_temp)
7431 7432 7433 7434 7435 7436 7437 7438
        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), '
7439
                            '(char *) "%s", (char *) %s);' % tup)
7440 7441 7442 7443 7444 7445 7446 7447 7448 7449
        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)

7450 7451 7452 7453 7454 7455 7456 7457 7458 7459 7460 7461 7462 7463 7464 7465 7466 7467 7468 7469 7470 7471 7472
    @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
7473

7474
class SizeofNode(ExprNode):
William Stein's avatar
William Stein committed
7475
    #  Abstract base class for sizeof(x) expression nodes.
7476

7477
    type = PyrexTypes.c_size_t_type
William Stein's avatar
William Stein committed
7478 7479

    def check_const(self):
7480
        return True
William Stein's avatar
William Stein committed
7481 7482 7483 7484 7485 7486 7487 7488 7489 7490

    def generate_result_code(self, code):
        pass


class SizeofTypeNode(SizeofNode):
    #  C sizeof function applied to a type
    #
    #  base_type   CBaseTypeNode
    #  declarator  CDeclaratorNode
7491

William Stein's avatar
William Stein committed
7492
    subexprs = []
7493
    arg_type = None
7494

William Stein's avatar
William Stein committed
7495
    def analyse_types(self, env):
7496 7497
        # 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
7498
        if 0 and self.base_type.module_path:
7499 7500 7501 7502 7503 7504 7505 7506 7507 7508 7509
            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
7510 7511 7512 7513
        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
7514
        self.check_type()
7515

7516 7517
    def check_type(self):
        arg_type = self.arg_type
7518
        if arg_type.is_pyobject and not arg_type.is_extension_type:
William Stein's avatar
William Stein committed
7519 7520 7521 7522 7523
            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)
7524

William Stein's avatar
William Stein committed
7525
    def calculate_result_code(self):
7526 7527 7528 7529 7530 7531
        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
7532
        return "(sizeof(%s))" % arg_code
7533

William Stein's avatar
William Stein committed
7534 7535 7536 7537 7538

class SizeofVarNode(SizeofNode):
    #  C sizeof function applied to a variable
    #
    #  operand   ExprNode
7539

William Stein's avatar
William Stein committed
7540
    subexprs = ['operand']
7541

William Stein's avatar
William Stein committed
7542
    def analyse_types(self, env):
7543 7544 7545 7546 7547
        # 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
7548 7549
            if self.arg_type.is_fused:
                self.arg_type = self.arg_type.specialize(env.fused_to_specific)
7550 7551 7552 7553
            self.__class__ = SizeofTypeNode
            self.check_type()
        else:
            self.operand.analyse_types(env)
7554

William Stein's avatar
William Stein committed
7555
    def calculate_result_code(self):
7556
        return "(sizeof(%s))" % self.operand.result()
7557

William Stein's avatar
William Stein committed
7558 7559 7560
    def generate_result_code(self, code):
        pass

Robert Bradshaw's avatar
Robert Bradshaw committed
7561
class TypeofNode(ExprNode):
7562 7563 7564
    #  Compile-time type of an expression, as a string.
    #
    #  operand   ExprNode
Robert Bradshaw's avatar
Robert Bradshaw committed
7565
    #  literal   StringNode # internal
7566

Robert Bradshaw's avatar
Robert Bradshaw committed
7567 7568
    literal = None
    type = py_object_type
7569

Stefan Behnel's avatar
Stefan Behnel committed
7570
    subexprs = ['literal'] # 'operand' will be ignored after type analysis!
7571

7572 7573
    def analyse_types(self, env):
        self.operand.analyse_types(env)
7574
        value = StringEncoding.EncodedString(str(self.operand.type)) #self.operand.type.typeof_name())
7575
        self.literal = StringNode(self.pos, value=value)
Robert Bradshaw's avatar
Robert Bradshaw committed
7576 7577
        self.literal.analyse_types(env)
        self.literal = self.literal.coerce_to_pyobject(env)
7578 7579 7580 7581

    def may_be_none(self):
        return False

7582
    def generate_evaluation_code(self, code):
Robert Bradshaw's avatar
Robert Bradshaw committed
7583
        self.literal.generate_evaluation_code(code)
7584

Robert Bradshaw's avatar
Robert Bradshaw committed
7585 7586
    def calculate_result_code(self):
        return self.literal.calculate_result_code()
William Stein's avatar
William Stein committed
7587 7588 7589 7590 7591 7592 7593

#-------------------------------------------------------------------
#
#  Binary operator nodes
#
#-------------------------------------------------------------------

Stefan Behnel's avatar
Stefan Behnel committed
7594 7595 7596
def _not_in(x, seq):
    return x not in seq

7597 7598 7599
compile_time_binary_operators = {
    '<': operator.lt,
    '<=': operator.le,
7600
    '==': operator.eq,
7601 7602 7603 7604 7605 7606 7607
    '!=': operator.ne,
    '>=': operator.ge,
    '>': operator.gt,
    'is': operator.is_,
    'is_not': operator.is_not,
    '+': operator.add,
    '&': operator.and_,
7608
    '/': operator.truediv,
7609 7610 7611 7612 7613 7614 7615 7616 7617
    '//': 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
7618 7619
    'in': operator.contains,
    'not_in': _not_in,
7620 7621 7622 7623 7624 7625 7626
}

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"
7627
                % node.operator)
7628 7629
    return func

7630
class BinopNode(ExprNode):
William Stein's avatar
William Stein committed
7631 7632 7633 7634 7635 7636 7637 7638 7639 7640 7641
    #  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.
7642

William Stein's avatar
William Stein committed
7643
    subexprs = ['operand1', 'operand2']
7644
    inplace = False
7645 7646 7647 7648 7649 7650 7651

    def calculate_constant_result(self):
        func = compile_time_binary_operators[self.operator]
        self.constant_result = func(
            self.operand1.constant_result,
            self.operand2.constant_result)

7652 7653 7654 7655 7656 7657 7658 7659
    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)
7660

7661 7662
    def infer_type(self, env):
        return self.result_type(self.operand1.infer_type(env),
Robert Bradshaw's avatar
Robert Bradshaw committed
7663
                                self.operand2.infer_type(env))
7664

William Stein's avatar
William Stein committed
7665 7666 7667
    def analyse_types(self, env):
        self.operand1.analyse_types(env)
        self.operand2.analyse_types(env)
Robert Bradshaw's avatar
Robert Bradshaw committed
7668
        self.analyse_operation(env)
7669

Robert Bradshaw's avatar
Robert Bradshaw committed
7670
    def analyse_operation(self, env):
William Stein's avatar
William Stein committed
7671 7672
        if self.is_py_operation():
            self.coerce_operands_to_pyobjects(env)
7673 7674 7675
            self.type = self.result_type(self.operand1.type,
                                         self.operand2.type)
            assert self.type.is_pyobject
William Stein's avatar
William Stein committed
7676
            self.is_temp = 1
DaniloFreitas's avatar
DaniloFreitas committed
7677 7678
        elif self.is_cpp_operation():
            self.analyse_cpp_operation(env)
William Stein's avatar
William Stein committed
7679 7680
        else:
            self.analyse_c_operation(env)
7681

William Stein's avatar
William Stein committed
7682
    def is_py_operation(self):
7683
        return self.is_py_operation_types(self.operand1.type, self.operand2.type)
7684

7685 7686 7687
    def is_py_operation_types(self, type1, type2):
        return type1.is_pyobject or type2.is_pyobject

DaniloFreitas's avatar
DaniloFreitas committed
7688
    def is_cpp_operation(self):
Robert Bradshaw's avatar
Robert Bradshaw committed
7689 7690
        return (self.operand1.type.is_cpp_class
            or self.operand2.type.is_cpp_class)
7691

7692 7693 7694 7695 7696 7697 7698 7699 7700 7701 7702 7703 7704 7705 7706 7707
    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
7708

7709 7710
    def result_type(self, type1, type2):
        if self.is_py_operation_types(type1, type2):
7711 7712 7713 7714 7715 7716 7717 7718 7719 7720 7721 7722 7723 7724 7725 7726 7727 7728
            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
7729
                    if type2.is_int:
7730
                        return type1
7731 7732 7733 7734
            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
7735 7736 7737
            return py_object_type
        else:
            return self.compute_c_result_type(type1, type2)
7738

7739
    def nogil_check(self, env):
7740
        if self.is_py_operation():
7741
            self.gil_error()
7742

William Stein's avatar
William Stein committed
7743 7744 7745
    def coerce_operands_to_pyobjects(self, env):
        self.operand1 = self.operand1.coerce_to_pyobject(env)
        self.operand2 = self.operand2.coerce_to_pyobject(env)
7746

William Stein's avatar
William Stein committed
7747
    def check_const(self):
7748
        return self.operand1.check_const() and self.operand2.check_const()
7749

William Stein's avatar
William Stein committed
7750 7751 7752 7753
    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()
7754
            if self.operator == '**':
William Stein's avatar
William Stein committed
7755 7756 7757 7758
                extra_args = ", Py_None"
            else:
                extra_args = ""
            code.putln(
Robert Bradshaw's avatar
Robert Bradshaw committed
7759
                "%s = %s(%s, %s%s); %s" % (
7760 7761
                    self.result(),
                    function,
William Stein's avatar
William Stein committed
7762 7763 7764
                    self.operand1.py_result(),
                    self.operand2.py_result(),
                    extra_args,
7765
                    code.error_goto_if_null(self.result(), self.pos)))
7766
            code.put_gotref(self.py_result())
7767

William Stein's avatar
William Stein committed
7768 7769 7770 7771
    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)" %
7772
                (self.operator, self.operand1.type,
William Stein's avatar
William Stein committed
7773 7774 7775 7776
                    self.operand2.type))
        self.type = PyrexTypes.error_type


Robert Bradshaw's avatar
Robert Bradshaw committed
7777
class CBinopNode(BinopNode):
7778

Robert Bradshaw's avatar
Robert Bradshaw committed
7779 7780 7781 7782
    def analyse_types(self, env):
        BinopNode.analyse_types(self, env)
        if self.is_py_operation():
            self.type = PyrexTypes.error_type
7783

Stefan Behnel's avatar
Stefan Behnel committed
7784
    def py_operation_function(self):
Robert Bradshaw's avatar
Robert Bradshaw committed
7785
        return ""
7786

Robert Bradshaw's avatar
Robert Bradshaw committed
7787 7788
    def calculate_result_code(self):
        return "(%s %s %s)" % (
7789 7790
            self.operand1.result(),
            self.operator,
Robert Bradshaw's avatar
Robert Bradshaw committed
7791 7792 7793 7794 7795 7796 7797 7798
            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
7799 7800
class NumBinopNode(BinopNode):
    #  Binary operation taking numeric arguments.
7801

Robert Bradshaw's avatar
Robert Bradshaw committed
7802
    infix = True
7803

William Stein's avatar
William Stein committed
7804 7805 7806 7807 7808 7809
    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()
7810
            return
7811
        if self.type.is_complex:
Robert Bradshaw's avatar
Robert Bradshaw committed
7812
            self.infix = False
7813
        if not self.infix or (type1.is_numeric and type2.is_numeric):
7814 7815
            self.operand1 = self.operand1.coerce_to(self.type, env)
            self.operand2 = self.operand2.coerce_to(self.type, env)
7816

William Stein's avatar
William Stein committed
7817 7818
    def compute_c_result_type(self, type1, type2):
        if self.c_types_okay(type1, type2):
7819 7820 7821 7822 7823
            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
7824 7825 7826
            else:
                widest_type = PyrexTypes.widest_numeric_type(
                    widest_type, PyrexTypes.c_int_type)
7827
            return widest_type
William Stein's avatar
William Stein committed
7828 7829
        else:
            return None
7830

7831 7832 7833 7834 7835 7836 7837 7838 7839 7840
    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()

7841 7842 7843 7844 7845 7846 7847
    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
7848

William Stein's avatar
William Stein committed
7849
    def c_types_okay(self, type1, type2):
7850 7851 7852
        #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
7853 7854

    def calculate_result_code(self):
7855 7856
        if self.infix:
            return "(%s %s %s)" % (
7857 7858
                self.operand1.result(),
                self.operator,
7859 7860
                self.operand2.result())
        else:
7861 7862 7863
            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))
7864
            return "%s(%s, %s)" % (
7865
                func,
7866 7867
                self.operand1.result(),
                self.operand2.result())
7868

7869
    def is_py_operation_types(self, type1, type2):
Stefan Behnel's avatar
Stefan Behnel committed
7870 7871
        return (type1.is_unicode_char or
                type2.is_unicode_char or
7872
                BinopNode.is_py_operation_types(self, type1, type2))
7873

William Stein's avatar
William Stein committed
7874
    def py_operation_function(self):
7875 7876 7877 7878
        fuction = self.py_functions[self.operator]
        if self.inplace:
            fuction = fuction.replace('PyNumber_', 'PyNumber_InPlace')
        return fuction
William Stein's avatar
William Stein committed
7879 7880

    py_functions = {
Robert Bradshaw's avatar
Robert Bradshaw committed
7881 7882 7883
        "|":        "PyNumber_Or",
        "^":        "PyNumber_Xor",
        "&":        "PyNumber_And",
7884 7885
        "<<":       "PyNumber_Lshift",
        ">>":       "PyNumber_Rshift",
Robert Bradshaw's avatar
Robert Bradshaw committed
7886 7887 7888 7889
        "+":        "PyNumber_Add",
        "-":        "PyNumber_Subtract",
        "*":        "PyNumber_Multiply",
        "/":        "__Pyx_PyNumber_Divide",
7890
        "//":       "PyNumber_FloorDivide",
Robert Bradshaw's avatar
Robert Bradshaw committed
7891
        "%":        "PyNumber_Remainder",
7892
        "**":       "PyNumber_Power"
William Stein's avatar
William Stein committed
7893 7894 7895 7896
    }

class IntBinopNode(NumBinopNode):
    #  Binary operation taking integer arguments.
7897

William Stein's avatar
William Stein committed
7898
    def c_types_okay(self, type1, type2):
7899 7900 7901
        #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
7902

7903

William Stein's avatar
William Stein committed
7904 7905
class AddNode(NumBinopNode):
    #  '+' operator.
7906

7907 7908 7909
    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
7910
        else:
7911
            return NumBinopNode.is_py_operation_types(self, type1, type2)
William Stein's avatar
William Stein committed
7912 7913

    def compute_c_result_type(self, type1, type2):
7914 7915
        #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
7916
            return type1
7917
        elif (type2.is_ptr or type2.is_array) and (type1.is_int or type1.is_enum):
William Stein's avatar
William Stein committed
7918 7919 7920 7921 7922 7923 7924 7925
            return type2
        else:
            return NumBinopNode.compute_c_result_type(
                self, type1, type2)


class SubNode(NumBinopNode):
    #  '-' operator.
7926

William Stein's avatar
William Stein committed
7927
    def compute_c_result_type(self, type1, type2):
7928
        if (type1.is_ptr or type1.is_array) and (type2.is_int or type2.is_enum):
William Stein's avatar
William Stein committed
7929
            return type1
7930
        elif (type1.is_ptr or type1.is_array) and (type2.is_ptr or type2.is_array):
William Stein's avatar
William Stein committed
7931 7932 7933 7934 7935 7936 7937 7938
            return PyrexTypes.c_int_type
        else:
            return NumBinopNode.compute_c_result_type(
                self, type1, type2)


class MulNode(NumBinopNode):
    #  '*' operator.
7939

7940
    def is_py_operation_types(self, type1, type2):
William Stein's avatar
William Stein committed
7941 7942 7943 7944
        if (type1.is_string and type2.is_int) \
            or (type2.is_string and type1.is_int):
                return 1
        else:
7945
            return NumBinopNode.is_py_operation_types(self, type1, type2)
William Stein's avatar
William Stein committed
7946 7947


7948 7949
class DivNode(NumBinopNode):
    #  '/' or '//' operator.
7950

7951
    cdivision = None
7952 7953
    truedivision = None   # == "unknown" if operator == '/'
    ctruedivision = False
Robert Bradshaw's avatar
Robert Bradshaw committed
7954
    cdivision_warnings = False
7955
    zerodivision_check = None
7956 7957 7958 7959 7960 7961 7962 7963 7964 7965 7966 7967 7968 7969 7970 7971 7972 7973 7974 7975 7976 7977

    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
7978
                operand1, operand2)
7979 7980 7981 7982
            return func(operand1, operand2)
        except Exception, e:
            self.compile_time_value_error(e)

Robert Bradshaw's avatar
Robert Bradshaw committed
7983
    def analyse_operation(self, env):
7984 7985 7986 7987
        if self.cdivision or env.directives['cdivision']:
            self.ctruedivision = False
        else:
            self.ctruedivision = self.truedivision
Robert Bradshaw's avatar
Robert Bradshaw committed
7988
        NumBinopNode.analyse_operation(self, env)
7989 7990
        if self.is_cpp_operation():
            self.cdivision = True
7991
        if not self.type.is_pyobject:
7992 7993
            self.zerodivision_check = (
                self.cdivision is None and not env.directives['cdivision']
7994
                and (not self.operand2.has_constant_result() or
7995
                     self.operand2.constant_result == 0))
7996 7997 7998 7999
            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)
8000 8001
                if env.nogil:
                    error(self.pos, "Pythonic division not allowed without gil, consider using cython.cdivision(True)")
8002 8003 8004 8005 8006 8007 8008 8009 8010

    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)

8011 8012 8013 8014 8015
    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
8016

8017
    def generate_evaluation_code(self, code):
8018
        if not self.type.is_pyobject and not self.type.is_complex:
8019
            if self.cdivision is None:
8020
                self.cdivision = (code.globalstate.directives['cdivision']
8021 8022 8023
                                    or not self.type.signed
                                    or self.type.is_float)
            if not self.cdivision:
8024
                code.globalstate.use_utility_code(div_int_utility_code.specialize(self.type))
8025
        NumBinopNode.generate_evaluation_code(self, code)
8026
        self.generate_div_warning_code(code)
8027

8028
    def generate_div_warning_code(self, code):
8029 8030
        if not self.type.is_pyobject:
            if self.zerodivision_check:
8031 8032 8033 8034 8035
                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)
8036 8037 8038
                code.putln('PyErr_Format(PyExc_ZeroDivisionError, "%s");' % self.zero_division_message())
                code.putln(code.error_goto(self.pos))
                code.putln("}")
8039 8040 8041
                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))) {" % (
8042
                                    self.type.declaration_code(''),
8043 8044 8045 8046 8047
                                    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
8048
            if code.globalstate.directives['cdivision_warnings'] and self.operator != '/':
8049 8050 8051 8052 8053
                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));
8054 8055 8056 8057 8058 8059
                code.put("if (__Pyx_cdivision_warning(%(FILENAME)s, "
                                                     "%(LINENO)s)) " % {
                    'FILENAME': Naming.filename_cname,
                    'LINENO':  Naming.lineno_cname,
                    })

8060 8061
                code.put_goto(code.error_label)
                code.putln("}")
8062

Robert Bradshaw's avatar
Robert Bradshaw committed
8063
    def calculate_result_code(self):
8064 8065 8066
        if self.type.is_complex:
            return NumBinopNode.calculate_result_code(self)
        elif self.type.is_float and self.operator == '//':
8067
            return "floor(%s / %s)" % (
8068
                self.operand1.result(),
8069
                self.operand2.result())
8070 8071 8072 8073 8074 8075 8076 8077 8078
        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)
8079 8080
        else:
            return "__Pyx_div_%s(%s, %s)" % (
Craig Citro's avatar
Craig Citro committed
8081
                    self.type.specialization_name(),
8082
                    self.operand1.result(),
8083
                    self.operand2.result())
Robert Bradshaw's avatar
Robert Bradshaw committed
8084 8085


Robert Bradshaw's avatar
Robert Bradshaw committed
8086
class ModNode(DivNode):
William Stein's avatar
William Stein committed
8087
    #  '%' operator.
8088

8089 8090 8091 8092
    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
8093

8094 8095 8096 8097 8098
    def zero_division_message(self):
        if self.type.is_int:
            return "integer division or modulo by zero"
        else:
            return "float divmod()"
8099

8100
    def generate_evaluation_code(self, code):
8101 8102 8103 8104 8105
        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:
8106
                    code.globalstate.use_utility_code(mod_int_utility_code.specialize(self.type))
8107
                else:
8108 8109
                    code.globalstate.use_utility_code(
                        mod_float_utility_code.specialize(self.type, math_h_modifier=self.type.math_h_modifier))
8110
        NumBinopNode.generate_evaluation_code(self, code)
8111
        self.generate_div_warning_code(code)
8112

Robert Bradshaw's avatar
Robert Bradshaw committed
8113
    def calculate_result_code(self):
8114 8115 8116 8117
        if self.cdivision:
            if self.type.is_float:
                return "fmod%s(%s, %s)" % (
                    self.type.math_h_modifier,
8118
                    self.operand1.result(),
8119 8120 8121
                    self.operand2.result())
            else:
                return "(%s %% %s)" % (
8122
                    self.operand1.result(),
8123
                    self.operand2.result())
Robert Bradshaw's avatar
Robert Bradshaw committed
8124
        else:
8125
            return "__Pyx_mod_%s(%s, %s)" % (
Craig Citro's avatar
Craig Citro committed
8126
                    self.type.specialization_name(),
8127
                    self.operand1.result(),
8128
                    self.operand2.result())
William Stein's avatar
William Stein committed
8129 8130 8131

class PowNode(NumBinopNode):
    #  '**' operator.
8132

Robert Bradshaw's avatar
Robert Bradshaw committed
8133 8134
    def analyse_c_operation(self, env):
        NumBinopNode.analyse_c_operation(self, env)
8135
        if self.type.is_complex:
Robert Bradshaw's avatar
Robert Bradshaw committed
8136 8137 8138 8139 8140 8141 8142
            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>"
8143
        elif self.type.is_float:
8144
            self.pow_func = "pow" + self.type.math_h_modifier
William Stein's avatar
William Stein committed
8145
        else:
Robert Bradshaw's avatar
Robert Bradshaw committed
8146 8147
            self.pow_func = "__Pyx_pow_%s" % self.type.declaration_code('').replace(' ', '_')
            env.use_utility_code(
8148
                    int_pow_utility_code.specialize(func_name=self.pow_func,
Robert Bradshaw's avatar
Robert Bradshaw committed
8149
                                                type=self.type.declaration_code('')))
8150

William Stein's avatar
William Stein committed
8151
    def calculate_result_code(self):
8152 8153 8154 8155 8156 8157
        # 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
8158
        return "%s(%s, %s)" % (
8159 8160
            self.pow_func,
            typecast(self.operand1),
8161
            typecast(self.operand2))
8162

William Stein's avatar
William Stein committed
8163

Craig Citro's avatar
Craig Citro committed
8164
# Note: This class is temporarily "shut down" into an ineffective temp
8165 8166
# allocation mode.
#
Craig Citro's avatar
Craig Citro committed
8167 8168 8169
# 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).
8170
class BoolBinopNode(ExprNode):
William Stein's avatar
William Stein committed
8171 8172 8173 8174 8175
    #  Short-circuiting boolean operation.
    #
    #  operator     string
    #  operand1     ExprNode
    #  operand2     ExprNode
8176

8177
    subexprs = ['operand1', 'operand2']
8178

8179
    def infer_type(self, env):
8180 8181
        type1 = self.operand1.infer_type(env)
        type2 = self.operand2.infer_type(env)
8182
        return PyrexTypes.independent_spanning_type(type1, type2)
8183

Stefan Behnel's avatar
Stefan Behnel committed
8184 8185 8186 8187 8188 8189
    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()

8190 8191 8192 8193 8194 8195 8196 8197 8198
    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
8199

8200 8201 8202 8203 8204 8205 8206
    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)
8207

8208
    def coerce_to_boolean(self, env):
8209 8210 8211 8212 8213 8214 8215
        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)
8216

William Stein's avatar
William Stein committed
8217 8218 8219
    def analyse_types(self, env):
        self.operand1.analyse_types(env)
        self.operand2.analyse_types(env)
8220
        self.type = PyrexTypes.independent_spanning_type(self.operand1.type, self.operand2.type)
8221 8222
        self.operand1 = self.operand1.coerce_to(self.type, env)
        self.operand2 = self.operand2.coerce_to(self.type, env)
8223

William Stein's avatar
William Stein committed
8224 8225
        # For what we're about to do, it's vital that
        # both operands be temp nodes.
8226 8227
        self.operand1 = self.operand1.coerce_to_simple(env)
        self.operand2 = self.operand2.coerce_to_simple(env)
William Stein's avatar
William Stein committed
8228
        self.is_temp = 1
8229 8230 8231

    gil_message = "Truth-testing Python object"

William Stein's avatar
William Stein committed
8232
    def check_const(self):
8233
        return self.operand1.check_const() and self.operand2.check_const()
8234

William Stein's avatar
William Stein committed
8235
    def generate_evaluation_code(self, code):
8236
        code.mark_pos(self.pos)
William Stein's avatar
William Stein committed
8237
        self.operand1.generate_evaluation_code(code)
8238
        test_result, uses_temp = self.generate_operand1_test(code)
William Stein's avatar
William Stein committed
8239 8240 8241 8242 8243 8244 8245 8246
        if self.operator == 'and':
            sense = ""
        else:
            sense = "!"
        code.putln(
            "if (%s%s) {" % (
                sense,
                test_result))
8247 8248
        if uses_temp:
            code.funcstate.release_temp(test_result)
8249
        self.operand1.generate_disposal_code(code)
William Stein's avatar
William Stein committed
8250
        self.operand2.generate_evaluation_code(code)
8251
        self.allocate_temp_result(code)
8252
        self.operand2.make_owned_reference(code)
8253
        code.putln("%s = %s;" % (self.result(), self.operand2.result()))
8254 8255
        self.operand2.generate_post_assignment_code(code)
        self.operand2.free_temps(code)
8256
        code.putln("} else {")
8257
        self.operand1.make_owned_reference(code)
8258
        code.putln("%s = %s;" % (self.result(), self.operand1.result()))
8259 8260
        self.operand1.generate_post_assignment_code(code)
        self.operand1.free_temps(code)
8261
        code.putln("}")
8262

William Stein's avatar
William Stein committed
8263 8264 8265
    def generate_operand1_test(self, code):
        #  Generate code to test the truth of the first operand.
        if self.type.is_pyobject:
8266 8267
            test_result = code.funcstate.allocate_temp(PyrexTypes.c_bint_type,
                                                       manage_ref=False)
William Stein's avatar
William Stein committed
8268
            code.putln(
8269
                "%s = __Pyx_PyObject_IsTrue(%s); %s" % (
William Stein's avatar
William Stein committed
8270 8271
                    test_result,
                    self.operand1.py_result(),
Robert Bradshaw's avatar
Robert Bradshaw committed
8272
                    code.error_goto_if_neg(test_result, self.pos)))
William Stein's avatar
William Stein committed
8273
        else:
8274
            test_result = self.operand1.result()
8275
        return (test_result, self.type.is_pyobject)
William Stein's avatar
William Stein committed
8276 8277


8278
class CondExprNode(ExprNode):
Robert Bradshaw's avatar
Robert Bradshaw committed
8279 8280 8281 8282 8283
    #  Short-circuiting conditional expression.
    #
    #  test        ExprNode
    #  true_val    ExprNode
    #  false_val   ExprNode
8284

8285 8286
    true_val = None
    false_val = None
8287

Robert Bradshaw's avatar
Robert Bradshaw committed
8288
    subexprs = ['test', 'true_val', 'false_val']
8289

Robert Bradshaw's avatar
Robert Bradshaw committed
8290 8291
    def type_dependencies(self, env):
        return self.true_val.type_dependencies(env) + self.false_val.type_dependencies(env)
8292

Robert Bradshaw's avatar
Robert Bradshaw committed
8293
    def infer_type(self, env):
8294 8295
        return PyrexTypes.independent_spanning_type(self.true_val.infer_type(env),
                                                    self.false_val.infer_type(env))
8296 8297 8298 8299 8300 8301 8302

    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
8303 8304 8305 8306 8307
    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)
8308
        self.type = PyrexTypes.independent_spanning_type(self.true_val.type, self.false_val.type)
8309 8310 8311 8312 8313
        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
8314
            self.type_error()
8315

Robert Bradshaw's avatar
Robert Bradshaw committed
8316 8317 8318 8319 8320
    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
8321

Robert Bradshaw's avatar
Robert Bradshaw committed
8322
    def check_const(self):
8323
        return (self.test.check_const()
8324 8325
            and self.true_val.check_const()
            and self.false_val.check_const())
8326

Robert Bradshaw's avatar
Robert Bradshaw committed
8327
    def generate_evaluation_code(self, code):
Dag Sverre Seljebotn's avatar
Dag Sverre Seljebotn committed
8328 8329
        # Because subexprs may not be evaluated we can use a more optimal
        # subexpr allocation strategy than the default, so override evaluation_code.
8330

Dag Sverre Seljebotn's avatar
Dag Sverre Seljebotn committed
8331
        code.mark_pos(self.pos)
8332
        self.allocate_temp_result(code)
Robert Bradshaw's avatar
Robert Bradshaw committed
8333
        self.test.generate_evaluation_code(code)
8334
        code.putln("if (%s) {" % self.test.result() )
Dag Sverre Seljebotn's avatar
Dag Sverre Seljebotn committed
8335
        self.eval_and_get(code, self.true_val)
Robert Bradshaw's avatar
Robert Bradshaw committed
8336
        code.putln("} else {")
Dag Sverre Seljebotn's avatar
Dag Sverre Seljebotn committed
8337
        self.eval_and_get(code, self.false_val)
Robert Bradshaw's avatar
Robert Bradshaw committed
8338 8339
        code.putln("}")
        self.test.generate_disposal_code(code)
8340
        self.test.free_temps(code)
Robert Bradshaw's avatar
Robert Bradshaw committed
8341

Dag Sverre Seljebotn's avatar
Dag Sverre Seljebotn committed
8342 8343 8344
    def eval_and_get(self, code, expr):
        expr.generate_evaluation_code(code)
        expr.make_owned_reference(code)
8345
        code.putln('%s = %s;' % (self.result(), expr.result_as(self.ctype())))
Dag Sverre Seljebotn's avatar
Dag Sverre Seljebotn committed
8346 8347 8348
        expr.generate_post_assignment_code(code)
        expr.free_temps(code)

8349 8350 8351 8352 8353 8354 8355 8356 8357 8358
richcmp_constants = {
    "<" : "Py_LT",
    "<=": "Py_LE",
    "==": "Py_EQ",
    "!=": "Py_NE",
    "<>": "Py_NE",
    ">" : "Py_GT",
    ">=": "Py_GE",
}

8359
class CmpNode(object):
William Stein's avatar
William Stein committed
8360 8361
    #  Mixin class containing code common to PrimaryCmpNodes
    #  and CascadedCmpNodes.
8362 8363 8364

    special_bool_cmp_function = None

Stefan Behnel's avatar
typo  
Stefan Behnel committed
8365
    def infer_type(self, env):
8366 8367
        # TODO: Actually implement this (after merging with -unstable).
        return py_object_type
8368 8369 8370 8371 8372

    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)
8373 8374 8375 8376 8377 8378 8379
        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

8380 8381
    def cascaded_compile_time_value(self, operand1, denv):
        func = get_compile_time_binop(self)
8382
        operand2 = self.operand2.compile_time_value(denv)
8383 8384 8385 8386
        try:
            result = func(operand1, operand2)
        except Exception, e:
            self.compile_time_value_error(e)
8387
            result = None
8388 8389 8390
        if result:
            cascade = self.cascade
            if cascade:
8391
                # FIXME: I bet this must call cascaded_compile_time_value()
8392
                result = result and cascade.cascaded_compile_time_value(operand2, denv)
8393 8394
        return result

8395
    def is_cpp_comparison(self):
Robert Bradshaw's avatar
Robert Bradshaw committed
8396
        return self.operand1.type.is_cpp_class or self.operand2.type.is_cpp_class
8397

8398
    def find_common_int_type(self, env, op, operand1, operand2):
8399 8400 8401 8402 8403 8404
        # 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

8405
        if operand1.is_string_literal and operand1.can_coerce_to_char_literal():
8406
            type1_can_be_int = True
8407
        if operand2.is_string_literal and operand2.can_coerce_to_char_literal():
8408 8409 8410 8411
            type2_can_be_int = True

        if type1.is_int:
            if type2_can_be_int:
8412
                return type1
8413 8414
        elif type2.is_int:
            if type1_can_be_int:
8415
                return type2
8416 8417
        elif type1_can_be_int:
            if type2_can_be_int:
8418
                return PyrexTypes.c_uchar_type
William Stein's avatar
William Stein committed
8419

8420
        return None
8421

8422
    def find_common_type(self, env, op, operand1, common_type=None):
8423
        operand2 = self.operand2
William Stein's avatar
William Stein committed
8424 8425
        type1 = operand1.type
        type2 = operand2.type
8426

8427 8428
        new_common_type = None

Stefan Behnel's avatar
Stefan Behnel committed
8429
        # catch general errors
8430 8431 8432
        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")
8433
            new_common_type = error_type
Stefan Behnel's avatar
Stefan Behnel committed
8434 8435

        # try to use numeric comparisons where possible
8436
        elif type1.is_complex or type2.is_complex:
8437 8438 8439
            if op not in ('==', '!=') \
               and (type1.is_complex or type1.is_numeric) \
               and (type2.is_complex or type2.is_numeric):
8440 8441
                error(self.pos, "complex types are unordered")
                new_common_type = error_type
8442
            elif type1.is_pyobject:
8443 8444 8445
                new_common_type = type1
            elif type2.is_pyobject:
                new_common_type = type2
8446
            else:
8447
                new_common_type = PyrexTypes.widest_numeric_type(type1, type2)
8448 8449
        elif type1.is_numeric and type2.is_numeric:
            new_common_type = PyrexTypes.widest_numeric_type(type1, type2)
8450
        elif common_type is None or not common_type.is_pyobject:
8451
            new_common_type = self.find_common_int_type(env, op, operand1, operand2)
8452 8453

        if new_common_type is None:
Stefan Behnel's avatar
Stefan Behnel committed
8454
            # fall back to generic type compatibility tests
8455
            if type1 == type2:
8456 8457 8458 8459 8460 8461
                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
8462
                        new_common_type = py_object_type
8463 8464 8465 8466
                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
8467 8468 8469
                        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
8470 8471 8472 8473
                else:
                    # one Python type and one non-Python type, not assignable
                    self.invalid_types_error(operand1, op, operand2)
                    new_common_type = error_type
8474 8475 8476 8477
            elif type1.assignable_from(type2):
                new_common_type = type1
            elif type2.assignable_from(type1):
                new_common_type = type2
8478 8479 8480 8481
            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
8482

8483 8484 8485 8486 8487 8488
        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
8489
        # recursively merge types
8490
        if common_type is None or new_common_type.is_error:
8491
            common_type = new_common_type
William Stein's avatar
William Stein committed
8492
        else:
8493 8494 8495
            # 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
8496
            common_type = PyrexTypes.spanning_type(common_type, new_common_type)
8497 8498

        if self.cascade:
8499
            common_type = self.cascade.find_common_type(env, self.operator, operand2, common_type)
8500

8501 8502
        return common_type

8503 8504 8505 8506
    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
8507
    def is_python_comparison(self):
8508 8509 8510 8511 8512
        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
8513

8514 8515 8516 8517 8518 8519
    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)
8520

8521
    def is_python_result(self):
8522
        return ((self.has_python_operands() and
8523
                 self.special_bool_cmp_function is None and
8524
                 self.operator not in ('is', 'is_not', 'in', 'not_in') and
8525 8526
                 not self.is_c_string_contains() and
                 not self.is_ptr_contains())
8527
            or (self.cascade and self.cascade.is_python_result()))
William Stein's avatar
William Stein committed
8528

8529 8530
    def is_c_string_contains(self):
        return self.operator in ('in', 'not_in') and \
8531 8532
               ((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
8533
                (self.operand1.type.is_unicode_char
8534
                 and self.operand2.type is unicode_type))
8535

8536 8537
    def is_ptr_contains(self):
        if self.operator in ('in', 'not_in'):
8538 8539 8540
            container_type = self.operand2.type
            return (container_type.is_ptr or container_type.is_array) \
                and not container_type.is_string
8541

8542 8543 8544 8545 8546
    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:
8547
                    env.use_utility_code(UtilityCode.load_cached("UnicodeEquals", "StringTools.c"))
8548 8549
                    self.special_bool_cmp_function = "__Pyx_PyUnicode_Equals"
                    return True
8550
                elif type1 is Builtin.bytes_type or type2 is Builtin.bytes_type:
8551
                    env.use_utility_code(UtilityCode.load_cached("BytesEquals", "StringTools.c"))
8552 8553 8554
                    self.special_bool_cmp_function = "__Pyx_PyBytes_Equals"
                    return True
                elif type1 is Builtin.str_type or type2 is Builtin.str_type:
8555
                    env.use_utility_code(UtilityCode.load_cached("StrEquals", "StringTools.c"))
8556 8557
                    self.special_bool_cmp_function = "__Pyx_PyString_Equals"
                    return True
8558 8559
        return False

8560
    def generate_operation_code(self, code, result_code,
William Stein's avatar
William Stein committed
8561
            operand1, op , operand2):
8562
        if self.type.is_pyobject:
8563 8564 8565
            coerce_result = "__Pyx_PyBool_FromLong"
        else:
            coerce_result = ""
8566
        if 'not' in op:
8567
            negation = "!"
8568
        else:
8569
            negation = ""
8570 8571 8572 8573 8574 8575 8576 8577 8578 8579 8580 8581 8582 8583 8584 8585 8586
        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
8587
            code.globalstate.use_utility_code(contains_utility_code)
8588
            if self.type.is_pyobject:
8589
                coerce_result = "__Pyx_PyBoolOrNull_FromLong"
8590
            if op == 'not_in':
8591
                negation = "__Pyx_NegateNonNeg"
8592
            if operand2.type is dict_type:
8593
                method = "PyDict_Contains"
8594
            else:
8595
                method = "PySequence_Contains"
8596
            if self.type.is_pyobject:
8597 8598 8599 8600 8601 8602 8603 8604 8605 8606 8607
                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,
8608 8609
                    operand2.py_result(),
                    operand1.py_result(),
8610 8611
                    got_ref,
                    error_clause(result_code, self.pos)))
William Stein's avatar
William Stein committed
8612 8613
        elif (operand1.type.is_pyobject
            and op not in ('is', 'is_not')):
8614
                code.putln("%s = PyObject_RichCompare(%s, %s, %s); %s" % (
8615 8616 8617
                        result_code,
                        operand1.py_result(),
                        operand2.py_result(),
8618 8619
                        richcmp_constants[op],
                        code.error_goto_if_null(result_code, self.pos)))
8620
                code.put_gotref(result_code)
8621
        elif operand1.type.is_complex:
8622
            if op == "!=":
8623
                negation = "!"
8624
            else:
8625
                negation = ""
8626
            code.putln("%s = %s(%s%s(%s, %s));" % (
8627
                result_code,
8628 8629
                coerce_result,
                negation,
8630 8631
                operand1.type.unary_op('eq'),
                operand1.result(),
8632
                operand2.result()))
William Stein's avatar
William Stein committed
8633
        else:
8634 8635 8636 8637 8638
            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
8639 8640
            elif type1.is_numeric:
                common_type = PyrexTypes.widest_numeric_type(type1, type2)
8641
            else:
8642 8643 8644
                common_type = type1
            code1 = operand1.result_as(common_type)
            code2 = operand2.result_as(common_type)
8645
            code.putln("%s = %s(%s %s %s);" % (
8646 8647 8648 8649
                result_code,
                coerce_result,
                code1,
                self.c_operator(op),
8650 8651
                code2))

William Stein's avatar
William Stein committed
8652 8653 8654 8655 8656 8657 8658
    def c_operator(self, op):
        if op == 'is':
            return "=="
        elif op == 'is_not':
            return "!="
        else:
            return op
8659

Stefan Behnel's avatar
typo  
Stefan Behnel committed
8660
contains_utility_code = UtilityCode(
8661
proto="""
8662 8663
static CYTHON_INLINE int __Pyx_NegateNonNeg(int b) {
    return unlikely(b < 0) ? b : !b;
Lisandro Dalcin's avatar
Lisandro Dalcin committed
8664
}
8665
static CYTHON_INLINE PyObject* __Pyx_PyBoolOrNull_FromLong(long b) {
8666 8667 8668 8669
    return unlikely(b < 0) ? NULL : __Pyx_PyBool_FromLong(b);
}
""")

William Stein's avatar
William Stein committed
8670

8671
class PrimaryCmpNode(ExprNode, CmpNode):
William Stein's avatar
William Stein committed
8672 8673 8674 8675 8676 8677 8678
    #  Non-cascaded comparison or first comparison of
    #  a cascaded sequence.
    #
    #  operator      string
    #  operand1      ExprNode
    #  operand2      ExprNode
    #  cascade       CascadedCmpNode
8679

William Stein's avatar
William Stein committed
8680 8681 8682 8683
    #  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.
8684

Robert Bradshaw's avatar
Robert Bradshaw committed
8685
    child_attrs = ['operand1', 'operand2', 'cascade']
8686

William Stein's avatar
William Stein committed
8687
    cascade = None
8688
    is_memslice_nonecheck = False
8689

Robert Bradshaw's avatar
Robert Bradshaw committed
8690 8691 8692 8693 8694 8695 8696
    def infer_type(self, env):
        # TODO: Actually implement this (after merging with -unstable).
        return py_object_type

    def type_dependencies(self, env):
        return ()

8697
    def calculate_constant_result(self):
8698
        self.calculate_cascaded_constant_result(self.operand1.constant_result)
8699

8700
    def compile_time_value(self, denv):
8701
        operand1 = self.operand1.compile_time_value(denv)
8702 8703
        return self.cascaded_compile_time_value(operand1, denv)

William Stein's avatar
William Stein committed
8704 8705 8706
    def analyse_types(self, env):
        self.operand1.analyse_types(env)
        self.operand2.analyse_types(env)
8707 8708
        if self.is_cpp_comparison():
            self.analyse_cpp_comparison(env)
Robert Bradshaw's avatar
Robert Bradshaw committed
8709 8710 8711
            if self.cascade:
                error(self.pos, "Cascading comparison not yet supported for cpp types.")
            return
8712 8713 8714 8715

        if self.analyse_memoryviewslice_comparison(env):
            return

William Stein's avatar
William Stein committed
8716
        if self.cascade:
8717 8718
            self.cascade.analyse_types(env)

8719
        if self.operator in ('in', 'not_in'):
8720 8721 8722 8723 8724 8725 8726
            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:
8727
                    env.use_utility_code(UtilityCode.load_cached("PyUCS4InUnicode", "StringTools.c"))
8728 8729 8730 8731 8732
                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)
8733
                    env.use_utility_code(UtilityCode.load_cached("BytesContains", "StringTools.c"))
Stefan Behnel's avatar
Stefan Behnel committed
8734 8735
                self.operand2 = self.operand2.as_none_safe_node(
                    "argument of type 'NoneType' is not iterable")
8736 8737 8738 8739 8740 8741
            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
8742
            else:
8743 8744
                if self.operand2.type is dict_type:
                    self.operand2 = self.operand2.as_none_safe_node("'NoneType' object is not iterable")
8745 8746
                common_type = py_object_type
                self.is_pycmp = True
8747 8748 8749 8750
        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
8751 8752 8753 8754
        else:
            common_type = self.find_common_type(env, self.operator, self.operand1)
            self.is_pycmp = common_type.is_pyobject

8755
        if common_type is not None and not common_type.is_error:
8756 8757 8758
            if self.operand1.type != common_type:
                self.operand1 = self.operand1.coerce_to(common_type, env)
            self.coerce_operands_to(common_type, env)
8759

William Stein's avatar
William Stein committed
8760 8761 8762
        if self.cascade:
            self.operand2 = self.operand2.coerce_to_simple(env)
            self.cascade.coerce_cascaded_operands_to_temp(env)
8763 8764 8765 8766 8767 8768 8769 8770
        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
8771 8772
        if self.is_pycmp or self.cascade:
            self.is_temp = 1
8773

8774 8775 8776
    def analyse_cpp_comparison(self, env):
        type1 = self.operand1.type
        type2 = self.operand2.type
8777 8778
        entry = env.lookup_operator(self.operator, [self.operand1, self.operand2])
        if entry is None:
8779 8780
            error(self.pos, "Invalid types for '%s' (%s, %s)" %
                (self.operator, type1, type2))
8781 8782 8783
            self.type = PyrexTypes.error_type
            self.result_code = "<error>"
            return
8784 8785 8786 8787 8788
        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)
8789
        else:
8790 8791 8792
            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
8793

8794 8795 8796 8797 8798 8799 8800 8801 8802 8803 8804 8805 8806
    def analyse_memoryviewslice_comparison(self, env):
        have_none = self.operand1.is_none or self.operand2.is_none
        have_slice = (self.operand1.type.is_memoryviewslice or
                      self.operand2.type.is_memoryviewslice)
        ops = ('==', '!=', 'is', 'is_not')
        if have_slice and have_none and self.operator in ops:
            self.is_pycmp = False
            self.type = PyrexTypes.c_bint_type
            self.is_memslice_nonecheck = True
            return True

        return False

William Stein's avatar
William Stein committed
8807 8808 8809
    def has_python_operands(self):
        return (self.operand1.type.is_pyobject
            or self.operand2.type.is_pyobject)
8810

William Stein's avatar
William Stein committed
8811 8812 8813
    def check_const(self):
        if self.cascade:
            self.not_const()
8814 8815 8816
            return False
        else:
            return self.operand1.check_const() and self.operand2.check_const()
William Stein's avatar
William Stein committed
8817 8818

    def calculate_result_code(self):
8819 8820 8821 8822 8823 8824 8825
        if self.operand1.type.is_complex:
            if self.operator == "!=":
                negation = "!"
            else:
                negation = ""
            return "(%s%s(%s, %s))" % (
                negation,
8826 8827
                self.operand1.type.binary_op('=='),
                self.operand1.result(),
8828
                self.operand2.result())
8829
        elif self.is_c_string_contains():
8830
            if self.operand2.type is unicode_type:
8831
                method = "__Pyx_UnicodeContainsUCS4"
8832
            else:
8833
                method = "__Pyx_BytesContains"
8834 8835 8836 8837 8838 8839 8840
            if self.operator == "not_in":
                negation = "!"
            else:
                negation = ""
            return "(%s%s(%s, %s))" % (
                negation,
                method,
8841
                self.operand2.result(),
8842
                self.operand1.result())
8843
        else:
8844 8845 8846 8847 8848 8849 8850 8851
            result1 = self.operand1.result()
            result2 = self.operand2.result()
            if self.is_memslice_nonecheck:
                if self.operand1.type.is_memoryviewslice:
                    result1 = "((PyObject *) %s.memview)" % result1
                else:
                    result2 = "((PyObject *) %s.memview)" % result2

8852
            return "(%s %s %s)" % (
8853
                result1,
8854
                self.c_operator(self.operator),
8855
                result2)
8856

William Stein's avatar
William Stein committed
8857 8858 8859 8860
    def generate_evaluation_code(self, code):
        self.operand1.generate_evaluation_code(code)
        self.operand2.generate_evaluation_code(code)
        if self.is_temp:
8861
            self.allocate_temp_result(code)
8862
            self.generate_operation_code(code, self.result(),
William Stein's avatar
William Stein committed
8863 8864 8865
                self.operand1, self.operator, self.operand2)
            if self.cascade:
                self.cascade.generate_evaluation_code(code,
8866
                    self.result(), self.operand2)
William Stein's avatar
William Stein committed
8867
            self.operand1.generate_disposal_code(code)
8868
            self.operand1.free_temps(code)
William Stein's avatar
William Stein committed
8869
            self.operand2.generate_disposal_code(code)
8870
            self.operand2.free_temps(code)
8871

William Stein's avatar
William Stein committed
8872 8873 8874 8875 8876
    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)
8877

8878 8879 8880 8881 8882
    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)
8883

8884 8885 8886 8887 8888
    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
8889 8890 8891


class CascadedCmpNode(Node, CmpNode):
8892 8893 8894
    #  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
8895 8896 8897 8898 8899 8900
    #  with the PrimaryCmpNode at the head of the chain.
    #
    #  operator      string
    #  operand2      ExprNode
    #  cascade       CascadedCmpNode

Robert Bradshaw's avatar
Robert Bradshaw committed
8901 8902
    child_attrs = ['operand2', 'cascade']

William Stein's avatar
William Stein committed
8903
    cascade = None
8904 8905
    constant_result = constant_value_not_set # FIXME: where to calculate this?

Robert Bradshaw's avatar
Robert Bradshaw committed
8906 8907 8908 8909 8910 8911 8912
    def infer_type(self, env):
        # TODO: Actually implement this (after merging with -unstable).
        return py_object_type

    def type_dependencies(self, env):
        return ()

8913 8914 8915 8916
    def has_constant_result(self):
        return self.constant_result is not constant_value_not_set and \
               self.constant_result is not not_a_constant

8917
    def analyse_types(self, env):
William Stein's avatar
William Stein committed
8918 8919
        self.operand2.analyse_types(env)
        if self.cascade:
8920
            self.cascade.analyse_types(env)
8921

William Stein's avatar
William Stein committed
8922 8923
    def has_python_operands(self):
        return self.operand2.type.is_pyobject
8924

William Stein's avatar
William Stein committed
8925 8926
    def coerce_operands_to_pyobjects(self, env):
        self.operand2 = self.operand2.coerce_to_pyobject(env)
8927 8928
        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
8929 8930 8931 8932 8933 8934 8935 8936
        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)
8937

William Stein's avatar
William Stein committed
8938
    def generate_evaluation_code(self, code, result, operand1):
8939 8940
        if self.type.is_pyobject:
            code.putln("if (__Pyx_PyObject_IsTrue(%s)) {" % result)
8941
            code.put_decref(result, self.type)
8942 8943
        else:
            code.putln("if (%s) {" % result)
William Stein's avatar
William Stein committed
8944
        self.operand2.generate_evaluation_code(code)
8945
        self.generate_operation_code(code, result,
William Stein's avatar
William Stein committed
8946 8947 8948 8949 8950 8951
            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)
8952
        self.operand2.free_temps(code)
William Stein's avatar
William Stein committed
8953 8954
        code.putln("}")

8955 8956 8957 8958 8959
    def annotate(self, code):
        self.operand2.annotate(code)
        if self.cascade:
            self.cascade.annotate(code)

William Stein's avatar
William Stein committed
8960 8961

binop_node_classes = {
8962 8963
    "or":       BoolBinopNode,
    "and":      BoolBinopNode,
Robert Bradshaw's avatar
Robert Bradshaw committed
8964 8965 8966
    "|":        IntBinopNode,
    "^":        IntBinopNode,
    "&":        IntBinopNode,
8967 8968
    "<<":       IntBinopNode,
    ">>":       IntBinopNode,
Robert Bradshaw's avatar
Robert Bradshaw committed
8969 8970 8971
    "+":        AddNode,
    "-":        SubNode,
    "*":        MulNode,
8972 8973
    "/":        DivNode,
    "//":       DivNode,
Robert Bradshaw's avatar
Robert Bradshaw committed
8974
    "%":        ModNode,
8975
    "**":       PowNode
William Stein's avatar
William Stein committed
8976 8977
}

8978
def binop_node(pos, operator, operand1, operand2, inplace=False):
8979
    # Construct binop node of appropriate class for
William Stein's avatar
William Stein committed
8980
    # given operator.
8981 8982 8983
    return binop_node_classes[operator](pos,
        operator = operator,
        operand1 = operand1,
8984 8985
        operand2 = operand2,
        inplace = inplace)
William Stein's avatar
William Stein committed
8986 8987 8988 8989 8990 8991 8992 8993 8994 8995 8996 8997

#-------------------------------------------------------------------
#
#  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.
#
#-------------------------------------------------------------------

8998
class CoercionNode(ExprNode):
William Stein's avatar
William Stein committed
8999 9000 9001
    #  Abstract base class for coercion nodes.
    #
    #  arg       ExprNode       node being coerced
9002

William Stein's avatar
William Stein committed
9003
    subexprs = ['arg']
9004
    constant_result = not_a_constant
9005

William Stein's avatar
William Stein committed
9006 9007 9008 9009
    def __init__(self, arg):
        self.pos = arg.pos
        self.arg = arg
        if debug_coercion:
Stefan Behnel's avatar
Stefan Behnel committed
9010
            print("%s Coercing %s" % (self, self.arg))
9011 9012

    def calculate_constant_result(self):
9013 9014
        # constant folding can break type coercion, so this is disabled
        pass
9015

9016 9017 9018 9019 9020
    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
9021

9022
class CoerceToMemViewSliceNode(CoercionNode):
9023 9024 9025 9026
    """
    Coerce an object to a memoryview slice. This holds a new reference in
    a managed temp.
    """
9027 9028

    def __init__(self, arg, dst_type, env):
9029 9030
        assert dst_type.is_memoryviewslice
        assert not arg.type.is_memoryviewslice
9031 9032
        CoercionNode.__init__(self, arg)
        self.type = dst_type
9033
        self.is_temp = 1
9034 9035
        self.env = env
        self.use_managed_ref = True
9036
        self.arg = arg
9037 9038

    def generate_result_code(self, code):
9039 9040 9041 9042 9043
        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()))

9044 9045 9046
        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
9047 9048 9049

class CastNode(CoercionNode):
    #  Wrap a node in a C type cast.
9050

William Stein's avatar
William Stein committed
9051 9052 9053
    def __init__(self, arg, new_type):
        CoercionNode.__init__(self, arg)
        self.type = new_type
Stefan Behnel's avatar
Stefan Behnel committed
9054 9055 9056

    def may_be_none(self):
        return self.arg.may_be_none()
9057

William Stein's avatar
William Stein committed
9058 9059 9060 9061 9062 9063 9064 9065 9066 9067 9068 9069
    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.

9070
    def __init__(self, arg, dst_type, env, notnone=False):
William Stein's avatar
William Stein committed
9071 9072
        #  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
9073
        assert dst_type.is_extension_type or dst_type.is_builtin_type, "PyTypeTest on non extension type"
William Stein's avatar
William Stein committed
9074 9075 9076
        CoercionNode.__init__(self, arg)
        self.type = dst_type
        self.result_ctype = arg.ctype()
9077
        self.notnone = notnone
9078

9079
    nogil_check = Node.gil_error
9080
    gil_message = "Python type test"
9081

9082 9083
    def analyse_types(self, env):
        pass
Stefan Behnel's avatar
Stefan Behnel committed
9084 9085 9086 9087 9088

    def may_be_none(self):
        if self.notnone:
            return False
        return self.arg.may_be_none()
9089

9090 9091 9092
    def is_simple(self):
        return self.arg.is_simple()

William Stein's avatar
William Stein committed
9093 9094
    def result_in_temp(self):
        return self.arg.result_in_temp()
9095

William Stein's avatar
William Stein committed
9096 9097
    def is_ephemeral(self):
        return self.arg.is_ephemeral()
9098 9099 9100 9101 9102

    def calculate_constant_result(self):
        # FIXME
        pass

William Stein's avatar
William Stein committed
9103
    def calculate_result_code(self):
9104
        return self.arg.result()
9105

William Stein's avatar
William Stein committed
9106 9107
    def generate_result_code(self, code):
        if self.type.typeobj_is_available():
9108
            if not self.type.is_builtin_type:
9109
                code.globalstate.use_utility_code(UtilityCode.load_cached("ExtTypeTest", "ObjectHandling.c"))
William Stein's avatar
William Stein committed
9110
            code.putln(
Robert Bradshaw's avatar
Robert Bradshaw committed
9111
                "if (!(%s)) %s" % (
9112
                    self.type.type_test_code(self.arg.py_result(), self.notnone),
William Stein's avatar
William Stein committed
9113 9114 9115 9116
                    code.error_goto(self.pos)))
        else:
            error(self.pos, "Cannot test type of extern C class "
                "without type object name specification")
9117

William Stein's avatar
William Stein committed
9118 9119
    def generate_post_assignment_code(self, code):
        self.arg.generate_post_assignment_code(code)
9120 9121 9122

    def free_temps(self, code):
        self.arg.free_temps(code)
9123 9124 9125 9126 9127 9128 9129


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).

9130 9131
    is_nonecheck = True

9132 9133
    def __init__(self, arg, exception_type_cname, exception_message,
                 exception_format_args):
9134 9135 9136 9137 9138
        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
9139
        self.exception_format_args = tuple(exception_format_args or ())
9140

9141 9142
    nogil_check = None # this node only guards an operation that would fail already

9143 9144 9145
    def analyse_types(self, env):
        pass

9146 9147 9148
    def may_be_none(self):
        return False

9149 9150 9151
    def is_simple(self):
        return self.arg.is_simple()

9152 9153 9154 9155 9156
    def result_in_temp(self):
        return self.arg.result_in_temp()

    def calculate_result_code(self):
        return self.arg.result()
9157

9158 9159 9160 9161
    def condition(self):
        if self.type.is_pyobject:
            return self.arg.py_result()
        elif self.type.is_memoryviewslice:
9162
            return "((PyObject *) %s.memview)" % self.arg.result()
9163 9164 9165 9166
        else:
            raise Exception("unsupported type")

    def put_nonecheck(self, code):
9167
        code.putln(
9168 9169 9170 9171 9172
            "if (unlikely(%s == Py_None)) {" % self.condition())

        if self.in_nogil_context:
            code.put_ensure_gil()

9173 9174
        escape = StringEncoding.escape_byte_string
        if self.exception_format_args:
9175
            code.putln('PyErr_Format(%s, "%s", %s);' % (
9176 9177 9178 9179
                self.exception_type_cname,
                StringEncoding.escape_byte_string(
                    self.exception_message.encode('UTF-8')),
                ', '.join([ '"%s"' % escape(str(arg).encode('UTF-8'))
9180
                            for arg in self.exception_format_args ])))
9181
        else:
9182
            code.putln('PyErr_SetString(%s, "%s");' % (
9183
                self.exception_type_cname,
9184 9185 9186 9187 9188 9189
                escape(self.exception_message.encode('UTF-8'))))

        if self.in_nogil_context:
            code.put_release_ensured_gil()

        code.putln(code.error_goto(self.pos))
9190 9191
        code.putln("}")

9192 9193 9194
    def generate_result_code(self, code):
        self.put_nonecheck(code)

9195 9196 9197 9198 9199 9200
    def generate_post_assignment_code(self, code):
        self.arg.generate_post_assignment_code(code)

    def free_temps(self, code):
        self.arg.free_temps(code)

9201

William Stein's avatar
William Stein committed
9202 9203 9204
class CoerceToPyTypeNode(CoercionNode):
    #  This node is used to convert a C data type
    #  to a Python object.
9205

9206
    type = py_object_type
Robert Bradshaw's avatar
Robert Bradshaw committed
9207
    is_temp = 1
William Stein's avatar
William Stein committed
9208

9209
    def __init__(self, arg, env, type=py_object_type):
9210
        if not arg.type.create_to_py_utility_code(env):
9211 9212 9213 9214 9215 9216 9217
            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)
9218 9219 9220 9221
        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
9222
            elif arg.type.is_unicode_char:
9223 9224 9225 9226 9227 9228
                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
9229

9230 9231 9232 9233
        if arg.type.is_memoryviewslice:
            # Register utility codes at this point
            arg.type.get_to_py_function(env, arg)

9234 9235
        self.env = env

9236
    gil_message = "Converting to Python object"
9237

9238 9239 9240 9241
    def may_be_none(self):
        # FIXME: is this always safe?
        return False

9242
    def coerce_to_boolean(self, env):
9243 9244 9245 9246 9247 9248
        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)
9249

9250 9251 9252 9253 9254 9255
    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)
9256

9257 9258 9259 9260
    def analyse_types(self, env):
        # The arg is always already analysed
        pass

William Stein's avatar
William Stein committed
9261
    def generate_result_code(self, code):
9262
        if self.arg.type.is_memoryviewslice:
9263
            funccall = self.arg.type.get_to_py_function(self.env, self.arg)
9264 9265 9266 9267 9268
        else:
            funccall = "%s(%s)" % (self.arg.type.to_py_function,
                                   self.arg.result())

        code.putln('%s = %s; %s' % (
9269
            self.result(),
9270
            funccall,
9271
            code.error_goto_if_null(self.result(), self.pos)))
9272

9273
        code.put_gotref(self.py_result())
William Stein's avatar
William Stein committed
9274 9275


9276 9277 9278 9279 9280 9281 9282 9283 9284 9285 9286 9287 9288 9289 9290 9291 9292 9293 9294 9295 9296 9297 9298 9299 9300 9301 9302 9303 9304 9305 9306 9307 9308 9309 9310 9311 9312 9313 9314 9315
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
9316 9317 9318 9319 9320 9321 9322 9323
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
9324
        if not result_type.create_from_py_utility_code(env):
William Stein's avatar
William Stein committed
9325
            error(arg.pos,
Craig Citro's avatar
Craig Citro committed
9326
                  "Cannot convert Python object to '%s'" % result_type)
9327 9328 9329 9330 9331 9332 9333 9334
        if self.type.is_string:
            if self.arg.is_ephemeral():
                error(arg.pos,
                      "Obtaining char* from temporary Python value")
            elif self.arg.is_name and self.arg.entry and self.arg.entry.is_pyglobal:
                warning(arg.pos,
                        "Obtaining char* from externally modifiable global Python value",
                        level=1)
9335

9336 9337 9338 9339
    def analyse_types(self, env):
        # The arg is always already analysed
        pass

William Stein's avatar
William Stein committed
9340 9341
    def generate_result_code(self, code):
        function = self.type.from_py_function
9342 9343 9344 9345
        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
9346
        code.putln('%s = %s; %s' % (
9347
            self.result(),
9348
            rhs,
9349
            code.error_goto_if(self.type.error_condition(self.result()), self.pos)))
9350
        if self.type.is_pyobject:
9351
            code.put_gotref(self.py_result())
William Stein's avatar
William Stein committed
9352

9353 9354 9355
    def nogil_check(self, env):
        error(self.pos, "Coercion from Python not allowed without the GIL")

William Stein's avatar
William Stein committed
9356 9357 9358 9359

class CoerceToBooleanNode(CoercionNode):
    #  This node is used when a result needs to be used
    #  in a boolean context.
9360

9361
    type = PyrexTypes.c_bint_type
9362 9363 9364 9365

    _special_builtins = {
        Builtin.list_type    : 'PyList_GET_SIZE',
        Builtin.tuple_type   : 'PyTuple_GET_SIZE',
9366
        Builtin.bytes_type   : 'PyBytes_GET_SIZE',
9367 9368 9369
        Builtin.unicode_type : 'PyUnicode_GET_SIZE',
        }

William Stein's avatar
William Stein committed
9370 9371 9372 9373
    def __init__(self, arg, env):
        CoercionNode.__init__(self, arg)
        if arg.type.is_pyobject:
            self.is_temp = 1
9374

9375
    def nogil_check(self, env):
9376
        if self.arg.type.is_pyobject and self._special_builtins.get(self.arg.type) is None:
9377
            self.gil_error()
9378

9379
    gil_message = "Truth-testing Python object"
9380

William Stein's avatar
William Stein committed
9381 9382 9383
    def check_const(self):
        if self.is_temp:
            self.not_const()
9384 9385
            return False
        return self.arg.check_const()
9386

William Stein's avatar
William Stein committed
9387
    def calculate_result_code(self):
9388
        return "(%s != 0)" % self.arg.result()
William Stein's avatar
William Stein committed
9389 9390

    def generate_result_code(self, code):
9391 9392 9393 9394
        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
9395
            code.putln("%s = (%s != Py_None) && (%s(%s) != 0);" % (
9396 9397 9398 9399 9400
                       self.result(),
                       self.arg.py_result(),
                       test_func,
                       self.arg.py_result()))
        else:
William Stein's avatar
William Stein committed
9401
            code.putln(
9402
                "%s = __Pyx_PyObject_IsTrue(%s); %s" % (
9403 9404
                    self.result(),
                    self.arg.py_result(),
9405
                    code.error_goto_if_neg(self.result(), self.pos)))
William Stein's avatar
William Stein committed
9406

9407 9408 9409 9410 9411 9412 9413 9414 9415 9416 9417
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:
9418 9419
            real_part = "__Pyx_CREAL(%s)" % self.arg.result()
            imag_part = "__Pyx_CIMAG(%s)" % self.arg.result()
9420 9421 9422 9423 9424 9425 9426
        else:
            real_part = self.arg.result()
            imag_part = "0"
        return "%s(%s, %s)" % (
                self.type.from_parts,
                real_part,
                imag_part)
9427

9428 9429
    def generate_result_code(self, code):
        pass
William Stein's avatar
William Stein committed
9430 9431 9432 9433 9434 9435 9436 9437 9438

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
9439
        self.constant_result = self.arg.constant_result
William Stein's avatar
William Stein committed
9440 9441 9442
        self.is_temp = 1
        if self.type.is_pyobject:
            self.result_ctype = py_object_type
9443 9444 9445

    gil_message = "Creating temporary Python reference"

9446 9447 9448
    def analyse_types(self, env):
        # The arg is always already analysed
        pass
9449

9450 9451
    def coerce_to_boolean(self, env):
        self.arg = self.arg.coerce_to_boolean(env)
9452 9453
        if self.arg.is_simple():
            return self.arg
9454 9455 9456
        self.type = self.arg.type
        self.result_ctype = self.type
        return self
9457

William Stein's avatar
William Stein committed
9458 9459 9460 9461
    def generate_result_code(self, code):
        #self.arg.generate_evaluation_code(code) # Already done
        # by generic generate_subexpr_evaluation_code!
        code.putln("%s = %s;" % (
9462
            self.result(), self.arg.result_as(self.ctype())))
9463 9464 9465 9466 9467 9468
        if self.use_managed_ref:
            if self.type.is_pyobject:
                code.put_incref(self.result(), self.ctype())
            elif self.type.is_memoryviewslice:
                code.put_incref_memoryviewslice(self.result(),
                                                not self.in_nogil_context)
William Stein's avatar
William Stein committed
9469

9470 9471 9472 9473 9474 9475 9476 9477 9478
class ProxyNode(CoercionNode):
    """
    A node that should not be replaced by transforms or other means,
    and hence can be useful to wrap the argument to a clone node

    MyNode    -> ProxyNode -> ArgNode
    CloneNode -^
    """

9479 9480
    nogil_check = None

9481 9482
    def __init__(self, arg):
        super(ProxyNode, self).__init__(arg)
9483 9484 9485 9486 9487 9488 9489 9490 9491 9492 9493 9494
        self._proxy_type()

    def analyse_expressions(self, env):
        self.arg.analyse_expressions(env)
        self._proxy_type()

    def _proxy_type(self):
        if hasattr(self.arg, 'type'):
            self.type = self.arg.type
            self.result_ctype = self.arg.result_ctype
        if hasattr(self.arg, 'entry'):
            self.entry = self.arg.entry
9495 9496 9497 9498 9499 9500 9501 9502 9503 9504 9505 9506 9507 9508 9509 9510 9511 9512 9513 9514 9515 9516 9517 9518

    def generate_result_code(self, code):
        self.arg.generate_result_code(code)

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

    def is_simple(self):
        return self.arg.is_simple()

    def may_be_none(self):
        return self.arg.may_be_none()

    def generate_evaluation_code(self, code):
        self.arg.generate_evaluation_code(code)

    def generate_result_code(self, code):
        self.arg.generate_result_code(code)

    def generate_disposal_code(self, code):
        self.arg.generate_disposal_code(code)

    def free_temps(self, code):
        self.arg.free_temps(code)
William Stein's avatar
William Stein committed
9519 9520 9521 9522 9523 9524

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
9525
    #  disposal code for it. The original owner of the argument
William Stein's avatar
William Stein committed
9526
    #  node is responsible for doing those things.
9527

William Stein's avatar
William Stein committed
9528
    subexprs = [] # Arg is not considered a subexpr
9529
    nogil_check = None
9530

William Stein's avatar
William Stein committed
9531 9532
    def __init__(self, arg):
        CoercionNode.__init__(self, arg)
9533 9534 9535 9536 9537
        if hasattr(arg, 'type'):
            self.type = arg.type
            self.result_ctype = arg.result_ctype
        if hasattr(arg, 'entry'):
            self.entry = arg.entry
9538

9539
    def result(self):
9540
        return self.arg.result()
9541

9542 9543 9544
    def may_be_none(self):
        return self.arg.may_be_none()

Robert Bradshaw's avatar
Robert Bradshaw committed
9545 9546
    def type_dependencies(self, env):
        return self.arg.type_dependencies(env)
9547

9548 9549
    def infer_type(self, env):
        return self.arg.infer_type(env)
Robert Bradshaw's avatar
Robert Bradshaw committed
9550

Robert Bradshaw's avatar
Robert Bradshaw committed
9551 9552 9553 9554
    def analyse_types(self, env):
        self.type = self.arg.type
        self.result_ctype = self.arg.result_ctype
        self.is_temp = 1
9555 9556
        if hasattr(self.arg, 'entry'):
            self.entry = self.arg.entry
9557

9558 9559 9560
    def is_simple(self):
        return True # result is always in a temp (or a name)

William Stein's avatar
William Stein committed
9561 9562 9563 9564 9565
    def generate_evaluation_code(self, code):
        pass

    def generate_result_code(self, code):
        pass
9566

9567
    def generate_disposal_code(self, code):
9568
        pass
9569

9570 9571
    def free_temps(self, code):
        pass
9572

9573

Stefan Behnel's avatar
Stefan Behnel committed
9574 9575 9576 9577 9578 9579 9580 9581 9582 9583 9584 9585
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)


9586 9587
class ModuleRefNode(ExprNode):
    # Simple returns the module object
9588

9589 9590 9591
    type = py_object_type
    is_temp = False
    subexprs = []
9592

9593 9594 9595
    def analyse_types(self, env):
        pass

9596 9597 9598
    def may_be_none(self):
        return False

9599 9600 9601 9602 9603 9604 9605 9606
    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
9607

9608 9609 9610
    subexprs = ['body']
    type = py_object_type
    is_temp = True
9611

9612 9613 9614 9615 9616 9617 9618 9619 9620
    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):
9621 9622 9623
        code.putln('%s = __Pyx_GetAttrString(%s, "__doc__"); %s' % (
            self.result(), self.body.result(),
            code.error_goto_if_null(self.result(), self.pos)))
9624 9625 9626 9627
        code.put_gotref(self.result())



William Stein's avatar
William Stein committed
9628 9629 9630 9631 9632 9633
#------------------------------------------------------------------------------------
#
#  Runtime support code
#
#------------------------------------------------------------------------------------

9634 9635
get_name_interned_utility_code = UtilityCode(
proto = """
9636
static PyObject *__Pyx_GetName(PyObject *dict, PyObject *name); /*proto*/
9637 9638
""",
impl = """
William Stein's avatar
William Stein committed
9639 9640 9641
static PyObject *__Pyx_GetName(PyObject *dict, PyObject *name) {
    PyObject *result;
    result = PyObject_GetAttr(dict, name);
9642 9643 9644 9645 9646 9647 9648 9649 9650
    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
9651 9652
    return result;
}
9653
""" % {'BUILTINS' : Naming.builtins_cname})
William Stein's avatar
William Stein committed
9654 9655 9656

#------------------------------------------------------------------------------------

9657 9658
import_utility_code = UtilityCode(
proto = """
Haoyu Bai's avatar
Haoyu Bai committed
9659
static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, long level); /*proto*/
9660 9661
""",
impl = """
Haoyu Bai's avatar
Haoyu Bai committed
9662
static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, long level) {
9663
    PyObject *py_import = 0;
William Stein's avatar
William Stein committed
9664 9665 9666 9667 9668
    PyObject *empty_list = 0;
    PyObject *module = 0;
    PyObject *global_dict = 0;
    PyObject *empty_dict = 0;
    PyObject *list;
9669 9670
    py_import = __Pyx_GetAttrString(%(BUILTINS)s, "__import__");
    if (!py_import)
William Stein's avatar
William Stein committed
9671 9672 9673 9674 9675 9676 9677 9678 9679 9680 9681 9682 9683 9684 9685
        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
9686 9687
    #if PY_VERSION_HEX >= 0x02050000
    {
9688
        #if PY_MAJOR_VERSION >= 3
9689
        if (level == -1) {
9690 9691 9692 9693
            if (strchr(__Pyx_MODULE_NAME, '.')) {
                /* try package relative import first */
                PyObject *py_level = PyInt_FromLong(1);
                if (!py_level)
9694
                    goto bad;
9695 9696 9697 9698 9699 9700 9701 9702
                module = PyObject_CallFunctionObjArgs(py_import,
                    name, global_dict, empty_dict, list, py_level, NULL);
                Py_DECREF(py_level);
                if (!module) {
                    if (!PyErr_ExceptionMatches(PyExc_ImportError))
                        goto bad;
                    PyErr_Clear();
                }
9703
            }
9704
            level = 0; /* try absolute import on failure */
9705 9706 9707 9708 9709 9710 9711 9712 9713 9714
        }
        #endif
        if (!module) {
            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);
        }
Haoyu Bai's avatar
Haoyu Bai committed
9715 9716 9717 9718 9719 9720
    }
    #else
    if (level>0) {
        PyErr_SetString(PyExc_RuntimeError, "Relative import is not supported for Python <=2.4.");
        goto bad;
    }
9721
    module = PyObject_CallFunctionObjArgs(py_import,
9722
        name, global_dict, empty_dict, list, NULL);
Haoyu Bai's avatar
Haoyu Bai committed
9723
    #endif
William Stein's avatar
William Stein committed
9724 9725
bad:
    Py_XDECREF(empty_list);
9726
    Py_XDECREF(py_import);
William Stein's avatar
William Stein committed
9727 9728 9729 9730 9731 9732
    Py_XDECREF(empty_dict);
    return module;
}
""" % {
    "BUILTINS": Naming.builtins_cname,
    "GLOBALS":  Naming.module_cname,
9733
})
William Stein's avatar
William Stein committed
9734 9735 9736

#------------------------------------------------------------------------------------

9737 9738
cpp_exception_utility_code = UtilityCode(
proto = """
9739 9740
#ifndef __Pyx_CppExn2PyErr
static void __Pyx_CppExn2PyErr() {
9741 9742
  // Catch a handful of different errors here and turn them into the
  // equivalent Python errors.
Robert Bradshaw's avatar
Robert Bradshaw committed
9743 9744 9745 9746 9747
  try {
    if (PyErr_Occurred())
      ; // let the latest Python exn pass through and ignore the current one
    else
      throw;
9748 9749
  } catch (const std::bad_alloc& exn) {
    PyErr_SetString(PyExc_MemoryError, exn.what());
9750 9751
  } catch (const std::bad_cast& exn) {
    PyErr_SetString(PyExc_TypeError, exn.what());
9752 9753
  } catch (const std::domain_error& exn) {
    PyErr_SetString(PyExc_ValueError, exn.what());
9754 9755
  } catch (const std::invalid_argument& exn) {
    PyErr_SetString(PyExc_ValueError, exn.what());
9756 9757 9758 9759
  } 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
9760
  } catch (const std::out_of_range& exn) {
9761
    // Change out_of_range to IndexError
Robert Bradshaw's avatar
Robert Bradshaw committed
9762
    PyErr_SetString(PyExc_IndexError, exn.what());
9763 9764 9765 9766 9767 9768
  } 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
9769 9770 9771 9772 9773 9774 9775 9776
  } catch (const std::exception& exn) {
    PyErr_SetString(PyExc_RuntimeError, exn.what());
  }
  catch (...)
  {
    PyErr_SetString(PyExc_RuntimeError, "Unknown exception");
  }
}
9777
#endif
9778 9779 9780
""",
impl = ""
)
Robert Bradshaw's avatar
Robert Bradshaw committed
9781

9782 9783 9784 9785 9786 9787 9788 9789 9790 9791 9792 9793 9794 9795 9796 9797 9798 9799 9800
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
9801
#------------------------------------------------------------------------------------
Robert Bradshaw's avatar
Robert Bradshaw committed
9802

9803 9804 9805 9806 9807 9808 9809 9810 9811 9812 9813 9814 9815 9816 9817 9818 9819 9820 9821 9822
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);
}
""")

9823 9824 9825 9826 9827 9828 9829 9830 9831 9832 9833
# Don't inline the function, it should really never be called in production
raise_unbound_memoryview_utility_code_nogil = UtilityCode(
proto = """
static void __Pyx_RaiseUnboundMemoryviewSliceNogil(const char *varname);
""",
impl = """
static void __Pyx_RaiseUnboundMemoryviewSliceNogil(const char *varname) {
    #ifdef WITH_THREAD
    PyGILState_STATE gilstate = PyGILState_Ensure();
    #endif
    __Pyx_RaiseUnboundLocalError(varname);
9834
    #ifdef WITH_THREAD
9835 9836 9837 9838 9839 9840
    PyGILState_Release(gilstate);
    #endif
}
""",
requires = [raise_unbound_local_error_utility_code])

9841 9842
#------------------------------------------------------------------------------------

9843 9844 9845 9846
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
9847
                                               __Pyx_GetItemInt_Unicode_Generic(o, to_py_func(i)))
9848

9849
static CYTHON_INLINE Py_UCS4 __Pyx_GetItemInt_Unicode_Fast(PyObject* ustring, Py_ssize_t i) {
9850
    Py_ssize_t length;
9851 9852 9853
#if CYTHON_PEP393_ENABLED
    if (unlikely(__Pyx_PyUnicode_READY(ustring) < 0)) return (Py_UCS4)-1;
#endif
9854
    length = __Pyx_PyUnicode_GET_LENGTH(ustring);
9855 9856 9857 9858
    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);
9859 9860
    } else {
        PyErr_SetString(PyExc_IndexError, "string index out of range");
9861
        return (Py_UCS4)-1;
9862 9863 9864
    }
}

9865 9866
static CYTHON_INLINE Py_UCS4 __Pyx_GetItemInt_Unicode_Generic(PyObject* ustring, PyObject* j) {
    Py_UCS4 uchar;
9867
    PyObject *uchar_string;
9868
    if (!j) return (Py_UCS4)-1;
9869
    uchar_string = PyObject_GetItem(ustring, j);
9870
    Py_DECREF(j);
9871
    if (!uchar_string) return (Py_UCS4)-1;
9872 9873 9874 9875 9876 9877
#if CYTHON_PEP393_ENABLED
    if (unlikely(__Pyx_PyUnicode_READY(uchar_string) < 0)) {
        Py_DECREF(uchar_string);
        return (Py_UCS4)-1;
    }
#endif
9878
    uchar = __Pyx_PyUnicode_READ_CHAR(uchar_string, 0);
9879
    Py_DECREF(uchar_string);
9880 9881
    return uchar;
}
9882
''')
9883

9884 9885
getitem_int_utility_code = UtilityCode(
proto = """
9886

9887
static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j) {
9888
    PyObject *r;
9889
    if (!j) return NULL;
9890 9891 9892 9893
    r = PyObject_GetItem(o, j);
    Py_DECREF(j);
    return r;
}
9894

9895 9896
""" + ''.join([
"""
9897 9898
#define __Pyx_GetItemInt_%(type)s(o, i, size, to_py_func) (((size) <= sizeof(Py_ssize_t)) ? \\
                                                    __Pyx_GetItemInt_%(type)s_Fast(o, i) : \\
9899 9900
                                                    __Pyx_GetItemInt_Generic(o, to_py_func(i)))

9901
static CYTHON_INLINE PyObject *__Pyx_GetItemInt_%(type)s_Fast(PyObject *o, Py_ssize_t i) {
9902
#if CYTHON_COMPILING_IN_CPYTHON
9903 9904 9905 9906 9907 9908 9909 9910 9911
    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;
    }
    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);
        Py_INCREF(r);
        return r;
9912
    }
9913
    return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i));
9914 9915 9916
#else
    return PySequence_GetItem(o, i);
#endif
9917
}
9918 9919
""" % {'type' : type_name} for type_name in ('List', 'Tuple')
]) + """
9920

9921 9922
#define __Pyx_GetItemInt(o, i, size, to_py_func) (((size) <= sizeof(Py_ssize_t)) ? \\
                                                    __Pyx_GetItemInt_Fast(o, i) : \\
9923 9924
                                                    __Pyx_GetItemInt_Generic(o, to_py_func(i)))

9925
static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i) {
9926
#if CYTHON_COMPILING_IN_CPYTHON
9927 9928 9929 9930 9931 9932 9933
    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
9934
    }
9935 9936 9937 9938 9939 9940 9941
    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;
        }
9942
    }
9943 9944 9945 9946 9947
    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
9948
    }
9949 9950 9951 9952 9953
#else
    if (PySequence_Check(o)) {
        return PySequence_GetItem(o, i);
    }
#endif
9954
    return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i));
Dag Sverre Seljebotn's avatar
Merge  
Dag Sverre Seljebotn committed
9955
}
9956
""")
Dag Sverre Seljebotn's avatar
Merge  
Dag Sverre Seljebotn committed
9957

9958 9959


Dag Sverre Seljebotn's avatar
Merge  
Dag Sverre Seljebotn committed
9960 9961
#------------------------------------------------------------------------------------

9962 9963
setitem_int_utility_code = UtilityCode(
proto = """
9964 9965
#define __Pyx_SetItemInt(o, i, v, size, to_py_func) (((size) <= sizeof(Py_ssize_t)) ? \\
                                                    __Pyx_SetItemInt_Fast(o, i, v) : \\
9966 9967
                                                    __Pyx_SetItemInt_Generic(o, to_py_func(i), v))

9968
static CYTHON_INLINE int __Pyx_SetItemInt_Generic(PyObject *o, PyObject *j, PyObject *v) {
Dag Sverre Seljebotn's avatar
Merge  
Dag Sverre Seljebotn committed
9969
    int r;
9970 9971 9972 9973 9974 9975
    if (!j) return -1;
    r = PyObject_SetItem(o, j, v);
    Py_DECREF(j);
    return r;
}

9976
static CYTHON_INLINE int __Pyx_SetItemInt_Fast(PyObject *o, Py_ssize_t i, PyObject *v) {
9977
#if CYTHON_COMPILING_IN_CPYTHON
9978 9979 9980
    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)))) {
9981
            PyObject* old = PyList_GET_ITEM(o, n);
9982
            Py_INCREF(v);
9983
            PyList_SET_ITEM(o, n, v);
9984 9985 9986
            Py_DECREF(old);
            return 1;
        }
9987 9988 9989
    } else
#endif
    if (likely(i >= 0)) {
9990 9991 9992 9993
        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
9994
    }
9995
    return __Pyx_SetItemInt_Generic(o, PyInt_FromSsize_t(i), v);
Dag Sverre Seljebotn's avatar
Merge  
Dag Sverre Seljebotn committed
9996 9997
}
""",
9998 9999 10000
impl = """
""")

10001 10002
#------------------------------------------------------------------------------------

10003 10004
delitem_int_utility_code = UtilityCode(
proto = """
10005 10006
#define __Pyx_DelItemInt(o, i, size, to_py_func) (((size) <= sizeof(Py_ssize_t)) ? \\
                                                    __Pyx_DelItemInt_Fast(o, i) : \\
10007 10008
                                                    __Pyx_DelItem_Generic(o, to_py_func(i)))

10009
static CYTHON_INLINE int __Pyx_DelItem_Generic(PyObject *o, PyObject *j) {
10010
    int r;
10011 10012 10013 10014 10015 10016
    if (!j) return -1;
    r = PyObject_DelItem(o, j);
    Py_DECREF(j);
    return r;
}

10017
static CYTHON_INLINE int __Pyx_DelItemInt_Fast(PyObject *o, Py_ssize_t i) {
10018 10019 10020 10021 10022
    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);
        }
10023
    }
10024
    return __Pyx_DelItem_Generic(o, PyInt_FromSsize_t(i));
10025 10026 10027 10028 10029 10030 10031
}
""",
impl = """
""")

#------------------------------------------------------------------------------------

10032 10033 10034
raise_too_many_values_to_unpack = UtilityCode.load_cached("RaiseTooManyValuesToUnpack", "ObjectHandling.c")
raise_need_more_values_to_unpack = UtilityCode.load_cached("RaiseNeedMoreValuesToUnpack", "ObjectHandling.c")
tuple_unpacking_error_code = UtilityCode.load_cached("UnpackTupleError", "ObjectHandling.c")
Robert Bradshaw's avatar
Robert Bradshaw committed
10035 10036 10037 10038 10039

#------------------------------------------------------------------------------------

int_pow_utility_code = UtilityCode(
proto="""
10040
static CYTHON_INLINE %(type)s %(func_name)s(%(type)s, %(type)s); /* proto */
Robert Bradshaw's avatar
Robert Bradshaw committed
10041 10042
""",
impl="""
10043
static CYTHON_INLINE %(type)s %(func_name)s(%(type)s b, %(type)s e) {
Robert Bradshaw's avatar
Robert Bradshaw committed
10044 10045 10046 10047 10048 10049 10050 10051 10052 10053 10054 10055 10056 10057 10058 10059 10060 10061 10062 10063 10064
    %(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;
}
""")
10065 10066 10067

# ------------------------------ Division ------------------------------------

10068 10069
div_int_utility_code = UtilityCode(
proto="""
10070
static CYTHON_INLINE %(type)s __Pyx_div_%(type_name)s(%(type)s, %(type)s); /* proto */
10071 10072
""",
impl="""
10073
static CYTHON_INLINE %(type)s __Pyx_div_%(type_name)s(%(type)s a, %(type)s b) {
10074 10075 10076 10077 10078
    %(type)s q = a / b;
    %(type)s r = a - q*b;
    q -= ((r != 0) & ((r ^ b) < 0));
    return q;
}
10079 10080
""")

10081
mod_int_utility_code = UtilityCode(
10082
proto="""
10083
static CYTHON_INLINE %(type)s __Pyx_mod_%(type_name)s(%(type)s, %(type)s); /* proto */
10084 10085
""",
impl="""
10086
static CYTHON_INLINE %(type)s __Pyx_mod_%(type_name)s(%(type)s a, %(type)s b) {
10087 10088 10089
    %(type)s r = a %% b;
    r += ((r != 0) & ((r ^ b) < 0)) * b;
    return r;
10090 10091 10092
}
""")

10093
mod_float_utility_code = UtilityCode(
10094
proto="""
10095
static CYTHON_INLINE %(type)s __Pyx_mod_%(type_name)s(%(type)s, %(type)s); /* proto */
10096 10097
""",
impl="""
10098
static CYTHON_INLINE %(type)s __Pyx_mod_%(type_name)s(%(type)s a, %(type)s b) {
10099 10100 10101
    %(type)s r = fmod%(math_h_modifier)s(a, b);
    r += ((r != 0) & ((r < 0) ^ (b < 0))) * b;
    return r;
10102 10103
}
""")
Robert Bradshaw's avatar
Robert Bradshaw committed
10104

10105
cdivision_warning_utility_code = UtilityCode(
Robert Bradshaw's avatar
Robert Bradshaw committed
10106
proto="""
10107
static int __Pyx_cdivision_warning(const char *, int); /* proto */
Robert Bradshaw's avatar
Robert Bradshaw committed
10108 10109
""",
impl="""
10110
static int __Pyx_cdivision_warning(const char *filename, int lineno) {
10111
    return PyErr_WarnExplicit(PyExc_RuntimeWarning,
10112
                              "division with oppositely signed operands, C and Python semantics differ",
10113 10114
                              filename,
                              lineno,
10115
                              __Pyx_MODULE_NAME,
10116
                              NULL);
Robert Bradshaw's avatar
Robert Bradshaw committed
10117
}
10118
""")
10119 10120 10121 10122

# from intobject.c
division_overflow_test_code = UtilityCode(
proto="""
Vitja Makarov's avatar
Vitja Makarov committed
10123 10124
#define UNARY_NEG_WOULD_OVERFLOW(x)    \
        (((x) < 0) & ((unsigned long)(x) == 0-(unsigned long)(x)))
10125
""")
Robert Bradshaw's avatar
Robert Bradshaw committed
10126

10127 10128 10129
binding_cfunc_utility_code = TempitaUtilityCode.load(
    "CythonFunction", context=vars(Naming))
fused_function_utility_code = TempitaUtilityCode.load(
10130 10131 10132 10133
        "FusedFunction",
        "CythonFunction.c",
        context=vars(Naming),
        requires=[binding_cfunc_utility_code])
10134 10135 10136 10137
cyfunction_class_cell_utility_code = UtilityCode.load(
    "CyFunctionClassCell",
    "CythonFunction.c",
    requires=[binding_cfunc_utility_code])
10138

10139 10140 10141 10142
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
10143
)