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

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

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

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

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

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

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

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

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

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

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

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

221 222
    constant_result = constant_value_not_set

223 224 225 226
    try:
        _get_child_attrs = operator.attrgetter('subexprs')
    except AttributeError:
        # Python 2.3
227
        def __get_child_attrs(self):
228
            return self.subexprs
229
        _get_child_attrs = __get_child_attrs
230
    child_attrs = property(fget=_get_child_attrs)
231

William Stein's avatar
William Stein committed
232 233 234 235
    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
236
                (self.__class__.__name__, method_name))
237

William Stein's avatar
William Stein committed
238 239
    def is_lvalue(self):
        return 0
240

241 242 243
    def is_addressable(self):
        return self.is_lvalue()

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

265
    def result(self):
266 267 268
        if self.is_temp:
            return self.temp_code
        else:
269
            return self.calculate_result_code()
270

William Stein's avatar
William Stein committed
271 272
    def result_as(self, type = None):
        #  Return the result code cast to the specified C type.
273
        return typecast(type, self.ctype(), self.result())
274

William Stein's avatar
William Stein committed
275 276 277
    def py_result(self):
        #  Return the result code cast to PyObject *.
        return self.result_as(py_object_type)
278

William Stein's avatar
William Stein committed
279 280 281 282
    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
283

284
    def get_constant_c_result_code(self):
285
        # Return the constant value of this node as a result code
286 287 288 289 290 291 292
        # 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.
293 294
        return None

295
    def calculate_constant_result(self):
296 297 298 299 300
        # 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.
301 302 303 304 305 306
        #
        # 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

307 308 309 310
    def has_constant_result(self):
        return self.constant_result is not constant_value_not_set and \
               self.constant_result is not not_a_constant

311 312 313
    def compile_time_value(self, denv):
        #  Return value of compile-time expression, or report error.
        error(self.pos, "Invalid compile-time expression")
314

315 316 317
    def compile_time_value_error(self, e):
        error(self.pos, "Error in compile-time expression: %s: %s" % (
            e.__class__.__name__, e))
318

William Stein's avatar
William Stein committed
319
    # ------------- Declaration Analysis ----------------
320

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

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

William Stein's avatar
William Stein committed
326 327 328 329 330 331
    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)
332
        return self.check_const()
333

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

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

William Stein's avatar
William Stein committed
346 347 348 349 350
    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
351

William Stein's avatar
William Stein committed
352 353 354 355 356 357 358 359 360
    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
361 362
        return self.coerce_to_boolean(env).coerce_to_simple(env)

363
    # --------------- Type Inference -----------------
364

Robert Bradshaw's avatar
Robert Bradshaw committed
365
    def type_dependencies(self, env):
366 367 368 369
        # 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
370
        return sum([node.type_dependencies(env) for node in self.subexpr_nodes()], ())
371

372
    def infer_type(self, env):
373 374
        # Attempt to deduce the type of self.
        # Differs from analyse_types as it avoids unnecessary
375 376 377 378 379 380 381 382
        # 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")
383

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

William Stein's avatar
William Stein committed
389
    # --------------- Type Analysis ------------------
390

William Stein's avatar
William Stein committed
391 392 393 394
    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
395

396 397 398 399
    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
400

William Stein's avatar
William Stein committed
401 402 403 404
    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
405

William Stein's avatar
William Stein committed
406 407
    def analyse_types(self, env):
        self.not_implemented("analyse_types")
408

William Stein's avatar
William Stein committed
409 410
    def analyse_target_types(self, env):
        self.analyse_types(env)
411

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

419 420 421 422
    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
423 424
    def check_const(self):
        self.not_const()
425
        return False
426

William Stein's avatar
William Stein committed
427 428
    def not_const(self):
        error(self.pos, "Not allowed in a constant expression")
429

William Stein's avatar
William Stein committed
430 431
    def check_const_addr(self):
        self.addr_not_const()
432
        return False
433

William Stein's avatar
William Stein committed
434 435
    def addr_not_const(self):
        error(self.pos, "Address is not constant")
436

William Stein's avatar
William Stein committed
437
    # ----------------- Result Allocation -----------------
438

William Stein's avatar
William Stein committed
439 440 441 442 443 444
    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
445

William Stein's avatar
William Stein committed
446 447 448
    def target_code(self):
        #  Return code fragment for use as LHS of a C assignment.
        return self.calculate_result_code()
449

William Stein's avatar
William Stein committed
450 451
    def calculate_result_code(self):
        self.not_implemented("calculate_result_code")
452

Robert Bradshaw's avatar
Robert Bradshaw committed
453 454 455
#    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
456

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

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

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

William Stein's avatar
William Stein committed
492
    def generate_evaluation_code(self, code):
493
        code.mark_pos(self.pos)
494

William Stein's avatar
William Stein committed
495 496 497 498
        #  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)
499 500 501 502

        if self.is_temp:
            self.allocate_temp_result(code)

William Stein's avatar
William Stein committed
503 504
        self.generate_result_code(code)
        if self.is_temp:
505 506
            # 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
507
            self.generate_subexpr_disposal_code(code)
508
            self.free_subexpr_temps(code)
509

William Stein's avatar
William Stein committed
510 511 512
    def generate_subexpr_evaluation_code(self, code):
        for node in self.subexpr_nodes():
            node.generate_evaluation_code(code)
513

William Stein's avatar
William Stein committed
514 515
    def generate_result_code(self, code):
        self.not_implemented("generate_result_code")
516

517 518
    def generate_disposal_code(self, code):
        if self.is_temp:
519 520 521 522 523 524
            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
525
        else:
526
            # Already done if self.is_temp
527
            self.generate_subexpr_disposal_code(code)
528

William Stein's avatar
William Stein committed
529 530 531 532 533
    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)
534

William Stein's avatar
William Stein committed
535 536 537
    def generate_post_assignment_code(self, code):
        if self.is_temp:
            if self.type.is_pyobject:
538
                code.putln("%s = 0;" % self.result())
539 540 541
            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
542 543
        else:
            self.generate_subexpr_disposal_code(code)
544

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

William Stein's avatar
William Stein committed
551 552 553 554 555
    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
556 557

    def free_temps(self, code):
558 559 560 561
        if self.is_temp:
            if not self.type.is_void:
                self.release_temp_result(code)
        else:
562
            self.free_subexpr_temps(code)
563

564 565 566 567
    def free_subexpr_temps(self, code):
        for sub in self.subexpr_nodes():
            sub.free_temps(code)

568 569 570
    def generate_function_definitions(self, env, code):
        pass

571
    # ---------------- Annotation ---------------------
572

573 574 575
    def annotate(self, code):
        for node in self.subexpr_nodes():
            node.annotate(code)
576

William Stein's avatar
William Stein committed
577
    # ----------------- Coercion ----------------------
578

William Stein's avatar
William Stein committed
579 580 581 582 583 584 585 586
    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.
587 588 589 590 591 592 593 594
        #
        #   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
595 596 597 598
        src = self
        src_type = self.type
        src_is_py_type = src_type.is_pyobject
        dst_is_py_type = dst_type.is_pyobject
599

600 601 602
        if self.check_for_coercion_error(dst_type):
            return self

603 604
        if dst_type.is_reference:
            dst_type = dst_type.ref_base_type
605

606
        if src_type.is_fused or dst_type.is_fused:
607 608 609 610 611 612 613 614 615
            # See if we are coercing a fused function to a pointer to a
            # specialized function
            if (src_type.is_cfunction and not dst_type.is_fused and
                    dst_type.is_ptr and dst_type.base_type.is_cfunction):

                dst_type = dst_type.base_type

                for signature in src_type.get_all_specific_function_types():
                    if signature.same_as(dst_type):
Mark Florisson's avatar
Mark Florisson committed
616 617 618 619
                        src.type = signature
                        src.entry = src.type.entry
                        src.entry.used = True
                        return self
620

621 622 623 624 625
            if src_type.is_fused:
                error(self.pos, "Type is not specific")
            else:
                error(self.pos, "Cannot coerce to a type that is not specialized")

626 627 628
            self.type = error_type
            return self

629 630 631 632 633
        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)

634
        if dst_type.is_memoryviewslice:
635
            import MemoryView
636
            if not src.type.is_memoryviewslice:
637 638 639 640 641 642
                if src.type.is_pyobject:
                    src = CoerceToMemViewSliceNode(src, dst_type, env)
                else:
                    error(self.pos,
                          "Cannot convert '%s' to memoryviewslice" %
                                                                (src_type,))
643
            elif not MemoryView.src_conforms_to_dst(src.type, dst_type):
644 645 646 647 648 649 650 651
                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)
652

653
        elif dst_type.is_pyobject:
William Stein's avatar
William Stein committed
654
            if not src.type.is_pyobject:
655 656 657 658
                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
659
            if not src.type.subtype_of(dst_type):
660 661
                if not isinstance(src, NoneNode):
                    src = PyTypeTestNode(src, dst_type, env)
William Stein's avatar
William Stein committed
662 663
        elif src.type.is_pyobject:
            src = CoerceFromPyTypeNode(dst_type, src, env)
664
        elif (dst_type.is_complex
665 666
              and src_type != dst_type
              and dst_type.assignable_from(src_type)):
667
            src = CoerceToComplexNode(src, dst_type, env)
William Stein's avatar
William Stein committed
668
        else: # neither src nor dst are py types
669
            # Added the string comparison, since for c types that
670
            # is enough, but Cython gets confused when the types are
671
            # in different pxi files.
672
            if not (str(src.type) == str(dst_type) or dst_type.assignable_from(src_type)):
673
                self.fail_assignment(dst_type)
William Stein's avatar
William Stein committed
674 675
        return src

676 677 678 679 680 681 682 683 684 685 686 687 688 689 690
    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
691 692 693 694 695 696
    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.
697 698 699 700 701 702 703

        # 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
704 705 706 707
        type = self.type
        if type.is_pyobject or type.is_ptr or type.is_float:
            return CoerceToBooleanNode(self, env)
        else:
708
            if not (type.is_int or type.is_enum or type.is_error):
709
                error(self.pos,
William Stein's avatar
William Stein committed
710 711
                    "Type '%s' not acceptable as a boolean" % type)
            return self
712

William Stein's avatar
William Stein committed
713 714 715 716 717 718
    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)
719

William Stein's avatar
William Stein committed
720 721 722 723 724 725
    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)
726

William Stein's avatar
William Stein committed
727 728 729 730 731 732
    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)
733

William Stein's avatar
William Stein committed
734 735 736 737 738 739
    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()
740 741

    def may_be_none(self):
742
        if self.type and not self.type.is_pyobject:
743 744 745 746
            return False
        if self.constant_result not in (not_a_constant, constant_value_not_set):
            return self.constant_result is not None
        return True
747

748
    def as_cython_attribute(self):
749
        return None
William Stein's avatar
William Stein committed
750

751
    def as_none_safe_node(self, message, error="PyExc_TypeError", format_args=()):
752 753 754
        # 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():
755
            return NoneCheckNode(self, error, message, format_args)
756 757 758 759
        else:
            return self


William Stein's avatar
William Stein committed
760
class AtomicExprNode(ExprNode):
761 762
    #  Abstract base class for expression nodes which have
    #  no sub-expressions.
763

764 765 766
    subexprs = []

    # Override to optimize -- we know we have no children
767 768 769 770
    def generate_subexpr_evaluation_code(self, code):
        pass
    def generate_subexpr_disposal_code(self, code):
        pass
771

772
class PyConstNode(AtomicExprNode):
William Stein's avatar
William Stein committed
773
    #  Abstract base class for constant Python values.
774

775
    is_literal = 1
776
    type = py_object_type
777

William Stein's avatar
William Stein committed
778 779
    def is_simple(self):
        return 1
780 781 782 783

    def may_be_none(self):
        return False

William Stein's avatar
William Stein committed
784
    def analyse_types(self, env):
785
        pass
786

William Stein's avatar
William Stein committed
787 788 789 790 791 792 793 794 795
    def calculate_result_code(self):
        return self.value

    def generate_result_code(self, code):
        pass


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

797
    is_none = 1
William Stein's avatar
William Stein committed
798
    value = "Py_None"
799 800

    constant_result = None
801

802
    nogil_check = None
803

804 805
    def compile_time_value(self, denv):
        return None
806 807 808 809 810

    def may_be_none(self):
        return True


William Stein's avatar
William Stein committed
811 812
class EllipsisNode(PyConstNode):
    #  '...' in a subscript list.
813

William Stein's avatar
William Stein committed
814 815
    value = "Py_Ellipsis"

816 817
    constant_result = Ellipsis

818 819 820
    def compile_time_value(self, denv):
        return Ellipsis

William Stein's avatar
William Stein committed
821

822
class ConstNode(AtomicExprNode):
William Stein's avatar
William Stein committed
823 824 825
    # Abstract base type for literal constant nodes.
    #
    # value     string      C code fragment
826

William Stein's avatar
William Stein committed
827
    is_literal = 1
828
    nogil_check = None
829

William Stein's avatar
William Stein committed
830 831
    def is_simple(self):
        return 1
832

833 834 835
    def nonlocally_immutable(self):
        return 1

836 837 838
    def may_be_none(self):
        return False

William Stein's avatar
William Stein committed
839 840
    def analyse_types(self, env):
        pass # Types are held in class variables
841

William Stein's avatar
William Stein committed
842
    def check_const(self):
843
        return True
844

845
    def get_constant_c_result_code(self):
846 847
        return self.calculate_result_code()

William Stein's avatar
William Stein committed
848 849 850 851 852 853 854
    def calculate_result_code(self):
        return str(self.value)

    def generate_result_code(self, code):
        pass


855 856 857
class BoolNode(ConstNode):
    type = PyrexTypes.c_bint_type
    #  The constant value True or False
858 859 860 861

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

862 863
    def compile_time_value(self, denv):
        return self.value
864

865
    def calculate_result_code(self):
866
        return str(int(self.value))
867

868

William Stein's avatar
William Stein committed
869 870
class NullNode(ConstNode):
    type = PyrexTypes.c_null_ptr_type
871
    value = "NULL"
872
    constant_result = 0
William Stein's avatar
William Stein committed
873

874
    def get_constant_c_result_code(self):
875 876
        return self.value

William Stein's avatar
William Stein committed
877 878 879

class CharNode(ConstNode):
    type = PyrexTypes.c_char_type
880 881 882

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

884
    def compile_time_value(self, denv):
885
        return ord(self.value)
886

William Stein's avatar
William Stein committed
887
    def calculate_result_code(self):
888
        return "'%s'" % StringEncoding.escape_char(self.value)
William Stein's avatar
William Stein committed
889 890 891


class IntNode(ConstNode):
892 893 894

    # unsigned     "" or "U"
    # longness     "" or "L" or "LL"
895
    # is_c_literal   True/False/None   creator considers this a C integer literal
896 897 898

    unsigned = ""
    longness = ""
899
    is_c_literal = None # unknown
900 901 902

    def __init__(self, pos, **kwds):
        ExprNode.__init__(self, pos, **kwds)
Robert Bradshaw's avatar
Robert Bradshaw committed
903
        if 'type' not in kwds:
904 905 906 907 908 909 910 911
            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
912 913 914 915
        # 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 \
916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931
               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
932

933
    def coerce_to(self, dst_type, env):
934
        if self.type is dst_type:
935
            return self
936
        elif dst_type.is_float:
937
            if self.constant_result is not not_a_constant:
938 939
                return FloatNode(self.pos, value='%d.0' % int(self.constant_result), type=dst_type,
                                 constant_result=float(self.constant_result))
940 941 942
            else:
                return FloatNode(self.pos, value=self.value, type=dst_type,
                                 constant_result=not_a_constant)
943
        if dst_type.is_numeric and not dst_type.is_complex:
944
            node = IntNode(self.pos, value=self.value, constant_result=self.constant_result,
945 946
                           type = dst_type, is_c_literal = True,
                           unsigned=self.unsigned, longness=self.longness)
947
            return node
948 949
        elif dst_type.is_pyobject:
            node = IntNode(self.pos, value=self.value, constant_result=self.constant_result,
950 951
                           type = PyrexTypes.py_object_type, is_c_literal = False,
                           unsigned=self.unsigned, longness=self.longness)
952
        else:
953 954
            # FIXME: not setting the type here to keep it working with
            # complex numbers. Should they be special cased?
955 956
            node = IntNode(self.pos, value=self.value, constant_result=self.constant_result,
                           unsigned=self.unsigned, longness=self.longness)
957 958 959
        # 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.
960 961
        return ConstNode.coerce_to(node, dst_type, env)

962
    def coerce_to_boolean(self, env):
963 964 965 966
        return IntNode(
            self.pos, value=self.value,
            type = PyrexTypes.c_bint_type,
            unsigned=self.unsigned, longness=self.longness)
967

968
    def generate_evaluation_code(self, code):
969
        if self.type.is_pyobject:
970
            # pre-allocate a Python version of the number
971 972
            plain_integer_string = self.value_as_c_integer_string(plain_digits=True)
            self.result_code = code.get_py_num(plain_integer_string, self.longness)
973
        else:
974
            self.result_code = self.get_constant_c_result_code()
975

976
    def get_constant_c_result_code(self):
977 978 979
        return self.value_as_c_integer_string() + self.unsigned + self.longness

    def value_as_c_integer_string(self, plain_digits=False):
980 981 982 983
        value = self.value
        if isinstance(value, basestring) and len(value) > 2:
            # must convert C-incompatible Py3 oct/bin notations
            if value[1] in 'oO':
984 985 986 987
                if plain_digits:
                    value = int(value[2:], 8)
                else:
                    value = value[0] + value[2:] # '0o123' => '0123'
988 989
            elif value[1] in 'bB':
                value = int(value[2:], 2)
990 991 992
            elif plain_digits and value[1] in 'xX':
                value = int(value[2:], 16)
        return str(value)
993 994 995

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

997
    def calculate_constant_result(self):
998
        self.constant_result = Utils.str_to_number(self.value)
999

1000
    def compile_time_value(self, denv):
1001
        return Utils.str_to_number(self.value)
1002 1003


William Stein's avatar
William Stein committed
1004 1005 1006
class FloatNode(ConstNode):
    type = PyrexTypes.c_double_type

1007
    def calculate_constant_result(self):
1008
        self.constant_result = float(self.value)
1009

1010 1011
    def compile_time_value(self, denv):
        return float(self.value)
1012

Stefan Behnel's avatar
Stefan Behnel committed
1013
    def calculate_result_code(self):
1014 1015 1016 1017
        strval = self.value
        assert isinstance(strval, (str, unicode))
        cmpval = repr(float(strval))
        if cmpval == 'nan':
1018
            return "(Py_HUGE_VAL * 0)"
1019
        elif cmpval == 'inf':
1020
            return "Py_HUGE_VAL"
1021
        elif cmpval == '-inf':
1022
            return "(-Py_HUGE_VAL)"
Stefan Behnel's avatar
Stefan Behnel committed
1023 1024
        else:
            return strval
1025

William Stein's avatar
William Stein committed
1026

1027
class BytesNode(ConstNode):
1028 1029 1030 1031
    # A char* or bytes literal
    #
    # value      BytesLiteral

1032
    is_string_literal = True
1033 1034
    # start off as Python 'bytes' to support len() in O(1)
    type = bytes_type
1035 1036

    def compile_time_value(self, denv):
1037
        return self.value
1038

1039
    def analyse_as_type(self, env):
1040
        type = PyrexTypes.parse_basic_type(self.value)
1041
        if type is not None:
1042
            return type
1043 1044 1045 1046 1047 1048 1049
        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
1050

1051 1052 1053
    def can_coerce_to_char_literal(self):
        return len(self.value) == 1

1054
    def coerce_to_boolean(self, env):
1055 1056
        # This is special because testing a C char* for truth directly
        # would yield the wrong result.
1057 1058
        bool_value = bool(self.value)
        return BoolNode(self.pos, value=bool_value, constant_result=bool_value)
1059

William Stein's avatar
William Stein committed
1060
    def coerce_to(self, dst_type, env):
1061 1062
        if self.type == dst_type:
            return self
1063
        if dst_type.is_int:
1064
            if not self.can_coerce_to_char_literal():
1065 1066
                error(self.pos, "Only single-character string literals can be coerced into ints.")
                return self
Stefan Behnel's avatar
Stefan Behnel committed
1067 1068
            if dst_type.is_unicode_char:
                error(self.pos, "Bytes literals cannot coerce to Py_UNICODE/Py_UCS4, use a unicode literal instead.")
1069
                return self
1070 1071
            return CharNode(self.pos, value=self.value)

1072
        node = BytesNode(self.pos, value=self.value)
1073 1074 1075 1076 1077 1078 1079 1080
        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
1081 1082 1083 1084
            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)
1085 1086
        elif dst_type.assignable_from(PyrexTypes.c_char_ptr_type):
            node.type = dst_type
1087
            return node
1088

William Stein's avatar
William Stein committed
1089 1090 1091 1092 1093
        # 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)

1094
    def generate_evaluation_code(self, code):
William Stein's avatar
William Stein committed
1095
        if self.type.is_pyobject:
1096
            self.result_code = code.get_py_string_const(self.value)
William Stein's avatar
William Stein committed
1097
        else:
1098
            self.result_code = code.get_string_const(self.value)
1099

1100
    def get_constant_c_result_code(self):
1101
        return None # FIXME
1102

1103 1104
    def calculate_result_code(self):
        return self.result_code
William Stein's avatar
William Stein committed
1105 1106


1107
class UnicodeNode(PyConstNode):
1108 1109
    # A Python unicode object
    #
1110 1111
    # value        EncodedString
    # bytes_value  BytesLiteral    the literal parsed as bytes string ('-3' unicode literals only)
Robert Bradshaw's avatar
Robert Bradshaw committed
1112

1113
    is_string_literal = True
1114
    bytes_value = None
1115
    type = unicode_type
1116

1117
    def coerce_to(self, dst_type, env):
1118 1119
        if dst_type is self.type:
            pass
Stefan Behnel's avatar
Stefan Behnel committed
1120
        elif dst_type.is_unicode_char:
1121
            if not self.can_coerce_to_char_literal():
Stefan Behnel's avatar
Stefan Behnel committed
1122
                error(self.pos, "Only single-character Unicode string literals or surrogate pairs can be coerced into Py_UCS4/Py_UNICODE.")
1123 1124
                return self
            int_value = ord(self.value)
Stefan Behnel's avatar
Stefan Behnel committed
1125
            return IntNode(self.pos, type=dst_type, value=str(int_value), constant_result=int_value)
1126
        elif not dst_type.is_pyobject:
1127 1128 1129
            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
1130
            error(self.pos, "Unicode literals do not support coercion to C types other than Py_UNICODE or Py_UCS4.")
1131 1132 1133 1134
        elif dst_type is not py_object_type:
            if not self.check_for_coercion_error(dst_type):
                self.fail_assignment(dst_type)
        return self
1135

1136 1137
    def can_coerce_to_char_literal(self):
        return len(self.value) == 1
Stefan Behnel's avatar
Stefan Behnel committed
1138 1139 1140
            ## or (len(self.value) == 2
            ##     and (0xD800 <= self.value[0] <= 0xDBFF)
            ##     and (0xDC00 <= self.value[1] <= 0xDFFF))
1141

1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158
    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

1159
    def generate_evaluation_code(self, code):
1160
        self.result_code = code.get_py_string_const(self.value)
1161 1162 1163

    def calculate_result_code(self):
        return self.result_code
1164

1165 1166
    def compile_time_value(self, env):
        return self.value
1167 1168


1169 1170 1171 1172
class StringNode(PyConstNode):
    # A Python str object, i.e. a byte string in Python 2.x and a
    # unicode string in Python 3.x
    #
1173 1174
    # value          BytesLiteral (or EncodedString with ASCII content)
    # unicode_value  EncodedString or None
1175
    # is_identifier  boolean
1176

1177
    type = str_type
1178
    is_string_literal = True
1179
    is_identifier = None
1180
    unicode_value = None
1181

1182
    def coerce_to(self, dst_type, env):
1183
        if dst_type is not py_object_type and not str_type.subtype_of(dst_type):
1184 1185 1186 1187 1188
#            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)
1189
            self.check_for_coercion_error(dst_type, fail=True)
1190
        return self
1191

1192 1193
    def can_coerce_to_char_literal(self):
        return not self.is_identifier and len(self.value) == 1
1194

1195
    def generate_evaluation_code(self, code):
1196
        self.result_code = code.get_py_string_const(
1197 1198
            self.value, identifier=self.is_identifier, is_str=True,
            unicode_value=self.unicode_value)
1199

1200
    def get_constant_c_result_code(self):
1201 1202
        return None

1203
    def calculate_result_code(self):
1204
        return self.result_code
1205

1206 1207
    def compile_time_value(self, env):
        return self.value
1208 1209


1210 1211 1212 1213
class IdentifierStringNode(StringNode):
    # A special str value that represents an identifier (bytes in Py2,
    # unicode in Py3).
    is_identifier = True
1214 1215


1216
class LongNode(AtomicExprNode):
William Stein's avatar
William Stein committed
1217 1218 1219
    #  Python long integer literal
    #
    #  value   string
1220

1221 1222
    type = py_object_type

1223
    def calculate_constant_result(self):
1224
        self.constant_result = Utils.str_to_number(self.value)
1225

1226
    def compile_time_value(self, denv):
1227
        return Utils.str_to_number(self.value)
1228

William Stein's avatar
William Stein committed
1229 1230
    def analyse_types(self, env):
        self.is_temp = 1
1231

1232 1233 1234
    def may_be_none(self):
        return False

1235 1236
    gil_message = "Constructing Python long int"

1237
    def generate_result_code(self, code):
William Stein's avatar
William Stein committed
1238
        code.putln(
1239
            '%s = PyLong_FromString((char *)"%s", 0, 0); %s' % (
1240
                self.result(),
William Stein's avatar
William Stein committed
1241
                self.value,
1242
                code.error_goto_if_null(self.result(), self.pos)))
1243
        code.put_gotref(self.py_result())
William Stein's avatar
William Stein committed
1244 1245


1246
class ImagNode(AtomicExprNode):
William Stein's avatar
William Stein committed
1247 1248 1249
    #  Imaginary number literal
    #
    #  value   float    imaginary part
1250

1251
    type = PyrexTypes.c_double_complex_type
1252 1253 1254

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

1256 1257
    def compile_time_value(self, denv):
        return complex(0.0, self.value)
1258

William Stein's avatar
William Stein committed
1259
    def analyse_types(self, env):
1260 1261
        self.type.create_declaration_utility_code(env)

1262 1263 1264
    def may_be_none(self):
        return False

1265
    def coerce_to(self, dst_type, env):
1266 1267 1268
        if self.type is dst_type:
            return self
        node = ImagNode(self.pos, value=self.value)
1269
        if dst_type.is_pyobject:
1270 1271
            node.is_temp = 1
            node.type = PyrexTypes.py_object_type
1272 1273 1274
        # 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.
1275
        return AtomicExprNode.coerce_to(node, dst_type, env)
1276 1277 1278

    gil_message = "Constructing complex number"

1279 1280 1281 1282 1283 1284
    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))

1285
    def generate_result_code(self, code):
1286 1287 1288 1289 1290 1291 1292
        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())
1293

William Stein's avatar
William Stein committed
1294

Danilo Freitas's avatar
Danilo Freitas committed
1295
class NewExprNode(AtomicExprNode):
1296 1297 1298

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

Robert Bradshaw's avatar
Robert Bradshaw committed
1301
    type = None
1302

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

1321
    def analyse_types(self, env):
Robert Bradshaw's avatar
Robert Bradshaw committed
1322 1323
        if self.type is None:
            self.infer_type(env)
1324 1325 1326 1327

    def may_be_none(self):
        return False

Danilo Freitas's avatar
Danilo Freitas committed
1328 1329
    def generate_result_code(self, code):
        pass
1330

Danilo Freitas's avatar
Danilo Freitas committed
1331
    def calculate_result_code(self):
1332
        return "new " + self.class_type.declaration_code("")
Danilo Freitas's avatar
Danilo Freitas committed
1333

William Stein's avatar
William Stein committed
1334

1335
class NameNode(AtomicExprNode):
William Stein's avatar
William Stein committed
1336 1337 1338 1339
    #  Reference to a local or global variable name.
    #
    #  name            string    Python name of the variable
    #  entry           Entry     Symbol table entry
1340
    #  type_entry      Entry     For extension type names, the original type entry
1341 1342
    #  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
1343
    #  allow_null      boolean   Don't raise UnboundLocalError
1344
    #  nogil           boolean   Whether it is used in a nogil context
1345

1346 1347
    is_name = True
    is_cython_module = False
Robert Bradshaw's avatar
Robert Bradshaw committed
1348
    cython_attribute = None
1349
    lhs_of_first_assignment = False # TODO: remove me
1350
    is_used_as_rvalue = 0
1351
    entry = None
1352
    type_entry = None
1353 1354
    cf_maybe_null = True
    cf_is_null = False
Vitja Makarov's avatar
Vitja Makarov committed
1355
    allow_null = False
1356
    nogil = False
1357 1358 1359 1360 1361

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

1363
    def as_cython_attribute(self):
Robert Bradshaw's avatar
Robert Bradshaw committed
1364
        return self.cython_attribute
1365

1366
    create_analysed_rvalue = staticmethod(create_analysed_rvalue)
1367

Robert Bradshaw's avatar
Robert Bradshaw committed
1368 1369 1370 1371 1372 1373 1374
    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 ()
1375

Robert Bradshaw's avatar
Robert Bradshaw committed
1376 1377 1378 1379 1380
    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
1381 1382 1383
        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
1384
            # is used for the pointer to the type they represent.
Robert Bradshaw's avatar
Robert Bradshaw committed
1385
            return type_type
1386
        elif self.entry.type.is_cfunction:
1387 1388 1389 1390 1391 1392
            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
1393 1394
        else:
            return self.entry.type
1395

1396 1397 1398 1399
    def compile_time_value(self, denv):
        try:
            return denv.lookup(self.name)
        except KeyError:
Stefan Behnel's avatar
Stefan Behnel committed
1400
            error(self.pos, "Compile-time name '%s' not defined" % self.name)
1401 1402 1403 1404 1405

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

1407 1408 1409 1410 1411 1412 1413
    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
1414
            if entry and entry.is_cfunction:
1415 1416
                var_entry = entry.as_variable
                if var_entry:
1417
                    if var_entry.is_builtin and var_entry.is_const:
1418
                        var_entry = env.declare_builtin(var_entry.name, self.pos)
1419 1420 1421 1422
                    node = NameNode(self.pos, name = self.name)
                    node.entry = var_entry
                    node.analyse_rvalue_entry(env)
                    return node
1423

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

William Stein's avatar
William Stein committed
1426 1427 1428
    def analyse_as_module(self, env):
        # Try to interpret this as a reference to a cimported module.
        # Returns the module scope, or None.
1429 1430 1431
        entry = self.entry
        if not entry:
            entry = env.lookup(self.name)
William Stein's avatar
William Stein committed
1432 1433 1434
        if entry and entry.as_module:
            return entry.as_module
        return None
1435

1436
    def analyse_as_type(self, env):
1437 1438 1439 1440
        if self.cython_attribute:
            type = PyrexTypes.parse_basic_type(self.cython_attribute)
        else:
            type = PyrexTypes.parse_basic_type(self.name)
1441 1442
        if type:
            return type
1443 1444 1445 1446 1447 1448 1449
        entry = self.entry
        if not entry:
            entry = env.lookup(self.name)
        if entry and entry.is_type:
            return entry.type
        else:
            return None
1450

William Stein's avatar
William Stein committed
1451 1452 1453
    def analyse_as_extension_type(self, env):
        # Try to interpret this as a reference to an extension type.
        # Returns the extension type, or None.
1454 1455 1456
        entry = self.entry
        if not entry:
            entry = env.lookup(self.name)
William Stein's avatar
William Stein committed
1457
        if entry and entry.is_type and entry.type.is_extension_type:
1458 1459 1460
            return entry.type
        else:
            return None
1461

William Stein's avatar
William Stein committed
1462
    def analyse_target_declaration(self, env):
1463 1464
        if not self.entry:
            self.entry = env.lookup_here(self.name)
William Stein's avatar
William Stein committed
1465
        if not self.entry:
1466 1467
            if env.directives['warn.undeclared']:
                warning(self.pos, "implicit declaration of '%s'" % self.name, 1)
1468
            if env.directives['infer_types'] != False:
1469 1470 1471 1472
                type = unspecified_type
            else:
                type = py_object_type
            self.entry = env.declare_var(self.name, type, self.pos)
1473 1474
        if self.entry.is_declared_generic:
            self.result_ctype = py_object_type
1475

1476
    def analyse_types(self, env):
1477
        self.initialized_check = env.directives['initializedcheck']
1478 1479
        if self.entry is None:
            self.entry = env.lookup(self.name)
William Stein's avatar
William Stein committed
1480 1481
        if not self.entry:
            self.entry = env.declare_builtin(self.name, self.pos)
1482 1483 1484
        if not self.entry:
            self.type = PyrexTypes.error_type
            return
Dag Sverre Seljebotn's avatar
Dag Sverre Seljebotn committed
1485 1486 1487 1488 1489 1490 1491 1492
        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)
1493
        self.analyse_rvalue_entry(env)
1494

1495
    def analyse_target_types(self, env):
William Stein's avatar
William Stein committed
1496
        self.analyse_entry(env)
1497 1498 1499

        if (not self.is_lvalue() and self.entry.is_cfunction and
                self.entry.fused_cfunction and self.entry.as_variable):
1500
            # We need this for the fused 'def' TreeFragment
1501 1502 1503
            self.entry = self.entry.as_variable
            self.type = self.entry.type

1504 1505 1506 1507
        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
1508
        self.entry.used = 1
1509
        if self.entry.type.is_buffer:
1510 1511
            import Buffer
            Buffer.used_buffer_aux_vars(self.entry)
1512

1513 1514 1515 1516
    def analyse_rvalue_entry(self, env):
        #print "NameNode.analyse_rvalue_entry:", self.name ###
        #print "Entry:", self.entry.__dict__ ###
        self.analyse_entry(env)
1517
        entry = self.entry
1518

1519
        if entry.is_declared_generic:
William Stein's avatar
William Stein committed
1520
            self.result_ctype = py_object_type
1521

1522
        if entry.is_pyglobal or entry.is_builtin:
1523
            if entry.is_builtin and entry.is_const:
1524 1525 1526
                self.is_temp = 0
            else:
                self.is_temp = 1
1527
                env.use_utility_code(get_name_interned_utility_code)
1528

1529
            self.is_used_as_rvalue = 1
1530 1531 1532
        elif entry.type.is_memoryviewslice:
            self.is_temp = False
            self.is_used_as_rvalue = True
1533
            self.use_managed_ref = True
1534

1535
    def nogil_check(self, env):
1536
        self.nogil = True
1537 1538 1539
        if self.is_used_as_rvalue:
            entry = self.entry
            if entry.is_builtin:
1540
                if not entry.is_const: # cached builtins are ok
1541
                    self.gil_error()
1542
            elif entry.is_pyglobal:
1543
                self.gil_error()
1544 1545 1546 1547
            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)
1548 1549 1550

    gil_message = "Accessing Python global or builtin"

1551 1552
    def analyse_entry(self, env):
        #print "NameNode.analyse_entry:", self.name ###
William Stein's avatar
William Stein committed
1553
        self.check_identifier_kind()
1554 1555 1556 1557
        entry = self.entry
        type = entry.type
        self.type = type

William Stein's avatar
William Stein committed
1558
    def check_identifier_kind(self):
1559 1560 1561
        # 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
1562
        entry = self.entry
1563 1564
        if entry.is_type and entry.type.is_extension_type:
            self.type_entry = entry
1565
        if not (entry.is_const or entry.is_variable
Danilo Freitas's avatar
Danilo Freitas committed
1566 1567
            or entry.is_builtin or entry.is_cfunction
            or entry.is_cpp_class):
William Stein's avatar
William Stein committed
1568 1569 1570
                if self.entry.as_variable:
                    self.entry = self.entry.as_variable
                else:
1571
                    error(self.pos,
1572 1573
                          "'%s' is not a constant, variable or function identifier" % self.name)

William Stein's avatar
William Stein committed
1574 1575 1576
    def is_simple(self):
        #  If it's not a C variable, it'll be in a temp.
        return 1
1577

1578
    def may_be_none(self):
1579
        if self.cf_state and self.type and self.type.is_pyobject:
1580 1581 1582 1583 1584 1585 1586
            # 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
1587 1588
            # evaluate control flow state to see if there were any
            # potential None values assigned to the node so far
1589
            may_be_none = False
1590 1591
            for assignment in self.cf_state:
                if assignment.rhs.may_be_none():
1592 1593 1594 1595
                    may_be_none = True
                    break
            del self._none_checking
            return may_be_none
1596 1597
        return super(NameNode, self).may_be_none()

1598
    def nonlocally_immutable(self):
1599 1600
        if ExprNode.nonlocally_immutable(self):
            return True
1601 1602 1603
        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
1604 1605
    def calculate_target_results(self, env):
        pass
1606

William Stein's avatar
William Stein committed
1607 1608
    def check_const(self):
        entry = self.entry
Robert Bradshaw's avatar
Robert Bradshaw committed
1609
        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
1610
            self.not_const()
1611 1612
            return False
        return True
1613

William Stein's avatar
William Stein committed
1614 1615
    def check_const_addr(self):
        entry = self.entry
1616
        if not (entry.is_cglobal or entry.is_cfunction or entry.is_builtin):
William Stein's avatar
William Stein committed
1617
            self.addr_not_const()
1618 1619
            return False
        return True
William Stein's avatar
William Stein committed
1620 1621 1622 1623 1624

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

1626 1627 1628
    def is_addressable(self):
        return self.entry.is_variable

William Stein's avatar
William Stein committed
1629 1630 1631 1632
    def is_ephemeral(self):
        #  Name nodes are never ephemeral, even if the
        #  result is in a temporary.
        return 0
1633

William Stein's avatar
William Stein committed
1634
    def calculate_result_code(self):
Stefan Behnel's avatar
Stefan Behnel committed
1635 1636
        entry = self.entry
        if not entry:
William Stein's avatar
William Stein committed
1637
            return "<error>" # There was an error earlier
Stefan Behnel's avatar
Stefan Behnel committed
1638
        return entry.cname
1639

William Stein's avatar
William Stein committed
1640
    def generate_result_code(self, code):
1641
        assert hasattr(self, 'entry')
William Stein's avatar
William Stein committed
1642 1643 1644
        entry = self.entry
        if entry is None:
            return # There was an error earlier
1645
        if entry.is_builtin and entry.is_const:
1646
            return # Lookup already cached
Stefan Behnel's avatar
Stefan Behnel committed
1647
        elif entry.is_pyclass_attr:
Vitja Makarov's avatar
Vitja Makarov committed
1648 1649 1650 1651 1652 1653
            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
1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671
            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
1672
            code.put_gotref(self.py_result())
1673

1674
        elif entry.is_pyglobal or entry.is_builtin:
1675 1676
            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
1677 1678 1679
            if entry.is_builtin:
                namespace = Naming.builtins_cname
            else: # entry.is_pyglobal
1680
                namespace = entry.scope.namespace_cname
1681
            code.globalstate.use_utility_code(get_name_interned_utility_code)
1682 1683
            code.putln(
                '%s = __Pyx_GetName(%s, %s); %s' % (
1684
                self.result(),
1685
                namespace,
1686
                interned_cname,
1687
                code.error_goto_if_null(self.result(), self.pos)))
1688
            code.put_gotref(self.py_result())
1689

1690
        elif entry.is_local or entry.in_closure or entry.from_closure:
1691 1692 1693 1694
            # 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)
1695

1696 1697 1698 1699
            memslice_check = entry.type.is_memoryviewslice and self.initialized_check

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

    def generate_assignment_code(self, rhs, code):
1702
        #print "NameNode.generate_assignment_code:", self.name ###
William Stein's avatar
William Stein committed
1703 1704 1705
        entry = self.entry
        if entry is None:
            return # There was an error earlier
1706 1707 1708 1709

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

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

1753
            elif self.type.is_buffer:
1754 1755 1756 1757 1758 1759 1760 1761 1762
                # 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)

1763
            if self.type.is_pyobject:
William Stein's avatar
William Stein committed
1764 1765 1766 1767
                #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() ###
1768 1769
                if self.use_managed_ref:
                    rhs.make_owned_reference(code)
1770
                    is_external_ref = entry.is_cglobal or self.entry.in_closure or self.entry.from_closure
1771 1772 1773 1774 1775 1776
                    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())
1777 1778 1779
                    if entry.is_cglobal:
                        code.put_decref(self.result(), self.ctype())
                    else:
1780 1781
                        if not self.cf_is_null:
                            if self.cf_maybe_null:
1782
                                code.put_xdecref(self.result(), self.ctype())
1783 1784
                            else:
                                code.put_decref(self.result(), self.ctype())
1785
                    if is_external_ref:
1786
                        code.put_giveref(rhs.py_result())
1787
            if not self.type.is_memoryviewslice:
1788
                code.putln('%s = %s;' % (self.result(), rhs.result_as(self.ctype())))
1789 1790 1791 1792
                if debug_disposal_code:
                    print("NameNode.generate_assignment_code:")
                    print("...generating post-assignment code for %s" % rhs)
                rhs.generate_post_assignment_code(code)
1793 1794
            elif rhs.result_in_temp():
                rhs.generate_post_assignment_code(code)
1795

1796
            rhs.free_temps(code)
1797

1798 1799
    def generate_acquire_memoryviewslice(self, rhs, code):
        """
1800 1801
        Slices, coercions from objects, return values etc are new references.
        We have a borrowed reference in case of dst = src
1802 1803 1804 1805 1806 1807 1808 1809 1810
        """
        import MemoryView

        MemoryView.put_acquire_memoryviewslice(
            lhs_cname=self.result(),
            lhs_type=self.type,
            lhs_pos=self.pos,
            rhs=rhs,
            code=code,
1811
            incref_rhs=rhs.is_name,
Mark Florisson's avatar
Mark Florisson committed
1812
            have_gil=not self.in_nogil_context)
1813

1814
    def generate_acquire_buffer(self, rhs, code):
1815 1816 1817
        # 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.
1818 1819 1820 1821 1822 1823 1824
        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())))

1825
        import Buffer
1826
        Buffer.put_assign_to_buffer(self.result(), rhstmp, self.entry,
1827
                                    is_initialized=not self.lhs_of_first_assignment,
1828
                                    pos=self.pos, code=code)
1829

1830 1831 1832
        if not pretty_rhs:
            code.putln("%s = 0;" % rhstmp)
            code.funcstate.release_temp(rhstmp)
1833

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

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

1863 1864 1865 1866 1867 1868 1869
    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)))
1870

1871
class BackquoteNode(ExprNode):
William Stein's avatar
William Stein committed
1872 1873 1874
    #  `expr`
    #
    #  arg    ExprNode
1875

1876
    type = py_object_type
1877

William Stein's avatar
William Stein committed
1878
    subexprs = ['arg']
1879

William Stein's avatar
William Stein committed
1880 1881 1882 1883
    def analyse_types(self, env):
        self.arg.analyse_types(env)
        self.arg = self.arg.coerce_to_pyobject(env)
        self.is_temp = 1
1884 1885 1886

    gil_message = "Backquote expression"

1887 1888 1889
    def calculate_constant_result(self):
        self.constant_result = repr(self.arg.constant_result)

William Stein's avatar
William Stein committed
1890 1891
    def generate_result_code(self, code):
        code.putln(
Robert Bradshaw's avatar
Robert Bradshaw committed
1892
            "%s = PyObject_Repr(%s); %s" % (
1893
                self.result(),
William Stein's avatar
William Stein committed
1894
                self.arg.py_result(),
1895
                code.error_goto_if_null(self.result(), self.pos)))
1896
        code.put_gotref(self.py_result())
1897

William Stein's avatar
William Stein committed
1898

1899
class ImportNode(ExprNode):
William Stein's avatar
William Stein committed
1900
    #  Used as part of import statement implementation.
1901
    #  Implements result =
Haoyu Bai's avatar
Haoyu Bai committed
1902
    #    __import__(module_name, globals(), None, name_list, level)
William Stein's avatar
William Stein committed
1903
    #
Haoyu Bai's avatar
Haoyu Bai committed
1904 1905 1906
    #  module_name   StringNode            dotted name of module. Empty module
    #                       name means importing the parent package accourding
    #                       to level
1907
    #  name_list     ListNode or None      list of names to be imported
Haoyu Bai's avatar
Haoyu Bai committed
1908 1909 1910 1911 1912
    #  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.
1913 1914
    #                     None: decide the level according to language level and
    #                           directives
1915

1916
    type = py_object_type
1917

William Stein's avatar
William Stein committed
1918
    subexprs = ['module_name', 'name_list']
1919

William Stein's avatar
William Stein committed
1920
    def analyse_types(self, env):
1921 1922 1923 1924 1925
        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
1926 1927 1928 1929
        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)
1930
            self.name_list.coerce_to_pyobject(env)
William Stein's avatar
William Stein committed
1931 1932
        self.is_temp = 1
        env.use_utility_code(import_utility_code)
1933 1934 1935

    gil_message = "Python import"

William Stein's avatar
William Stein committed
1936 1937 1938 1939 1940 1941
    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
1942
            "%s = __Pyx_Import(%s, %s, %d); %s" % (
1943
                self.result(),
William Stein's avatar
William Stein committed
1944 1945
                self.module_name.py_result(),
                name_list_code,
Haoyu Bai's avatar
Haoyu Bai committed
1946
                self.level,
1947
                code.error_goto_if_null(self.result(), self.pos)))
1948
        code.put_gotref(self.py_result())
William Stein's avatar
William Stein committed
1949 1950


1951
class IteratorNode(ExprNode):
William Stein's avatar
William Stein committed
1952
    #  Used as part of for statement implementation.
1953
    #
William Stein's avatar
William Stein committed
1954 1955 1956
    #  Implements result = iter(sequence)
    #
    #  sequence   ExprNode
1957

1958
    type = py_object_type
1959
    iter_func_ptr = None
1960
    counter_cname = None
1961
    reversed = False      # currently only used for list/tuple types (see Optimize.py)
1962

William Stein's avatar
William Stein committed
1963
    subexprs = ['sequence']
1964

William Stein's avatar
William Stein committed
1965 1966
    def analyse_types(self, env):
        self.sequence.analyse_types(env)
1967 1968
        if (self.sequence.type.is_array or self.sequence.type.is_ptr) and \
                not self.sequence.type.is_string:
1969
            # C array iteration will be transformed later on
1970
            self.type = self.sequence.type
1971 1972
        else:
            self.sequence = self.sequence.coerce_to_pyobject(env)
1973 1974 1975
            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
1976
        self.is_temp = 1
1977 1978 1979

    gil_message = "Iterating over Python object"

1980 1981 1982 1983
    _func_iternext_type = PyrexTypes.CPtrType(PyrexTypes.CFuncType(
        PyrexTypes.py_object_type, [
            PyrexTypes.CFuncTypeArg("it", PyrexTypes.py_object_type, None),
            ]))
1984

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

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

    def generate_iter_next_result_code(self, result_name, code):
        sequence_type = self.sequence.type
2056 2057
        if self.reversed:
            code.putln("if (%s < 0) break;" % self.counter_cname)
Stefan Behnel's avatar
Stefan Behnel committed
2058 2059 2060 2061 2062 2063 2064 2065 2066 2067 2068 2069 2070 2071 2072 2073 2074 2075 2076 2077 2078 2079 2080 2081 2082 2083 2084 2085
        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'):
                code.putln("if (Py%s_CheckExact(%s)) {" % (test_name, self.py_result()))
                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
2086

2087
    def free_temps(self, code):
2088 2089
        if self.counter_cname:
            code.funcstate.release_temp(self.counter_cname)
2090 2091 2092 2093
        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
2094 2095


2096
class NextNode(AtomicExprNode):
William Stein's avatar
William Stein committed
2097 2098 2099 2100 2101
    #  Used as part of for statement implementation.
    #  Implements result = iterator.next()
    #  Created during analyse_types phase.
    #  The iterator is not owned by this node.
    #
2102
    #  iterator   IteratorNode
2103

2104
    type = py_object_type
2105

2106
    def __init__(self, iterator):
William Stein's avatar
William Stein committed
2107 2108
        self.pos = iterator.pos
        self.iterator = iterator
2109 2110
        if iterator.type.is_ptr or iterator.type.is_array:
            self.type = iterator.type.base_type
William Stein's avatar
William Stein committed
2111
        self.is_temp = 1
2112

William Stein's avatar
William Stein committed
2113
    def generate_result_code(self, code):
Stefan Behnel's avatar
Stefan Behnel committed
2114
        self.iterator.generate_iter_next_result_code(self.result(), code)
2115

William Stein's avatar
William Stein committed
2116

2117 2118 2119 2120 2121 2122 2123 2124 2125 2126 2127 2128 2129 2130 2131 2132 2133 2134 2135 2136 2137 2138 2139 2140 2141 2142 2143 2144 2145 2146 2147 2148 2149 2150
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("}")


2151
class ExcValueNode(AtomicExprNode):
William Stein's avatar
William Stein committed
2152 2153 2154
    #  Node created during analyse_types phase
    #  of an ExceptClauseNode to fetch the current
    #  exception value.
2155

2156
    type = py_object_type
2157

2158
    def __init__(self, pos, env):
William Stein's avatar
William Stein committed
2159
        ExprNode.__init__(self, pos)
2160 2161

    def set_var(self, var):
2162
        self.var = var
2163

2164 2165 2166
    def calculate_result_code(self):
        return self.var

William Stein's avatar
William Stein committed
2167
    def generate_result_code(self, code):
2168
        pass
William Stein's avatar
William Stein committed
2169

2170 2171 2172
    def analyse_types(self, env):
        pass

William Stein's avatar
William Stein committed
2173

2174
class TempNode(ExprNode):
2175 2176 2177 2178 2179 2180 2181
    # 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.
2182 2183

    subexprs = []
2184

2185
    def __init__(self, pos, type, env=None):
William Stein's avatar
William Stein committed
2186 2187 2188 2189 2190
        ExprNode.__init__(self, pos)
        self.type = type
        if type.is_pyobject:
            self.result_ctype = py_object_type
        self.is_temp = 1
2191

2192 2193
    def analyse_types(self, env):
        return self.type
2194

2195 2196 2197
    def analyse_target_declaration(self, env):
        pass

William Stein's avatar
William Stein committed
2198 2199 2200
    def generate_result_code(self, code):
        pass

2201 2202 2203 2204 2205 2206 2207 2208 2209 2210 2211 2212 2213 2214 2215 2216 2217
    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
2218

2219 2220
    def release_temp_result(self, code):
        pass
William Stein's avatar
William Stein committed
2221 2222 2223

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

William Stein's avatar
William Stein committed
2225 2226 2227
    def __init__(self, pos, env):
        TempNode.__init__(self, pos, PyrexTypes.py_object_type, env)

2228 2229
class RawCNameExprNode(ExprNode):
    subexprs = []
2230

2231 2232 2233 2234 2235 2236 2237 2238 2239 2240 2241 2242 2243 2244 2245 2246
    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
2247

Mark Florisson's avatar
Mark Florisson committed
2248 2249 2250 2251 2252 2253 2254 2255
#-------------------------------------------------------------------
#
#  Parallel nodes (cython.parallel.thread(savailable|id))
#
#-------------------------------------------------------------------

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

Mark Florisson's avatar
Mark Florisson committed
2258 2259 2260 2261 2262 2263 2264 2265 2266
    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
2267
        # env.add_include_file("omp.h")
Mark Florisson's avatar
Mark Florisson committed
2268 2269 2270 2271 2272 2273 2274 2275 2276 2277 2278 2279 2280 2281 2282 2283 2284 2285 2286 2287 2288 2289 2290 2291
        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
2292
        # env.add_include_file("omp.h")
Mark Florisson's avatar
Mark Florisson committed
2293 2294 2295 2296 2297 2298 2299 2300 2301 2302 2303 2304 2305
        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
2306 2307 2308 2309 2310 2311
#-------------------------------------------------------------------
#
#  Trailer nodes
#
#-------------------------------------------------------------------

2312
class IndexNode(ExprNode):
William Stein's avatar
William Stein committed
2313 2314 2315 2316
    #  Sequence indexing.
    #
    #  base     ExprNode
    #  index    ExprNode
2317 2318 2319 2320 2321 2322
    #  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.
2323 2324 2325
    #
    #  is_fused_index boolean   Whether the index is used to specialize a
    #                           c(p)def function
2326

2327 2328 2329
    subexprs = ['base', 'index', 'indices']
    indices = None

2330 2331
    is_fused_index = False

2332 2333 2334 2335
    # Whether we're assigning to a buffer (in that case it needs to be
    # writable)
    writable_needed = False

2336 2337 2338 2339
    # Whether we are indexing or slicing a memoryviewslice
    memslice_index = False
    memslice_slice = False

2340 2341 2342
    def __init__(self, pos, index, *args, **kw):
        ExprNode.__init__(self, pos, index=index, *args, **kw)
        self._index = index
2343 2344 2345 2346 2347

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

2348 2349 2350 2351 2352 2353 2354
    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)
2355

William Stein's avatar
William Stein committed
2356 2357
    def is_ephemeral(self):
        return self.base.is_ephemeral()
2358

2359
    def is_simple(self):
2360
        if self.is_buffer_access or self.memslice_index:
2361
            return False
2362 2363 2364
        elif self.memslice_slice:
            return True

2365 2366 2367 2368
        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
2369 2370
    def analyse_target_declaration(self, env):
        pass
2371

2372 2373 2374
    def analyse_as_type(self, env):
        base_type = self.base.analyse_as_type(env)
        if base_type and not base_type.is_pyobject:
2375
            if base_type.is_cpp_class:
2376
                if isinstance(self.index, TupleNode):
2377 2378 2379 2380 2381
                    template_values = self.index.args
                else:
                    template_values = [self.index]
                import Nodes
                type_node = Nodes.TemplatedTypeNode(
2382 2383
                    pos = self.pos,
                    positional_args = template_values,
2384 2385 2386 2387
                    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)))
2388
        return None
2389

Robert Bradshaw's avatar
Robert Bradshaw committed
2390
    def type_dependencies(self, env):
2391
        return self.base.type_dependencies(env) + self.index.type_dependencies(env)
2392

2393
    def infer_type(self, env):
2394 2395 2396 2397
        base_type = self.base.infer_type(env)
        if isinstance(self.index, SliceNode):
            # slicing!
            if base_type.is_string:
2398
                # sliced C strings must coerce to Python
2399
                return bytes_type
2400 2401 2402
            elif base_type in (unicode_type, bytes_type, str_type, list_type, tuple_type):
                # slicing these returns the same type
                return base_type
2403
            else:
2404 2405 2406
                # TODO: Handle buffers (hopefully without too much redundancy).
                return py_object_type

2407 2408
        index_type = self.index.infer_type(env)
        if index_type and index_type.is_int or isinstance(self.index, (IntNode, LongNode)):
2409 2410
            # indexing!
            if base_type is unicode_type:
2411 2412 2413
                # 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
2414 2415 2416 2417
                # 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.
2418
                return PyrexTypes.c_py_ucs4_type
2419 2420 2421
            elif base_type is str_type:
                # always returns str - Py2: bytes, Py3: unicode
                return base_type
2422 2423 2424 2425 2426 2427
            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
2428 2429
            elif base_type.is_ptr or base_type.is_array:
                return base_type.base_type
2430

2431
        # may be slicing or indexing, we don't know
2432 2433
        if base_type in (unicode_type, str_type):
            # these types always returns their own type on Python indexing/slicing
2434
            return base_type
2435 2436 2437
        else:
            # TODO: Handle buffers (hopefully without too much redundancy).
            return py_object_type
2438

William Stein's avatar
William Stein committed
2439
    def analyse_types(self, env):
Dag Sverre Seljebotn's avatar
Merge  
Dag Sverre Seljebotn committed
2440
        self.analyse_base_and_index_types(env, getting = 1)
2441

Dag Sverre Seljebotn's avatar
Merge  
Dag Sverre Seljebotn committed
2442 2443
    def analyse_target_types(self, env):
        self.analyse_base_and_index_types(env, setting = 1)
2444 2445
        if not self.is_lvalue():
            error(self.pos, "Assignment to non-lvalue of type '%s'" % self.type)
2446

2447
    def analyse_base_and_index_types(self, env, getting = 0, setting = 0, analyse_base = True):
2448 2449 2450
        # Note: This might be cleaned up by having IndexNode
        # parsed in a saner way and only construct the tuple if
        # needed.
2451 2452 2453 2454

        # 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.
2455 2456
        self.is_buffer_access = False

2457
        # a[...] = b
2458
        self.is_memoryviewslice_access = False
2459 2460 2461 2462
        # incomplete indexing, Ellipsis indexing or slicing
        self.memslice_slice = False
        # integer indexing
        self.memslice_index = False
2463

2464 2465 2466
        if analyse_base:
            self.base.analyse_types(env)

2467 2468 2469 2470 2471
        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
2472

2473
        is_slice = isinstance(self.index, SliceNode)
2474

2475
        # Potentially overflowing index value.
2476
        if not is_slice and isinstance(self.index, IntNode) and Utils.long_literal(self.index.value):
2477
            self.index = self.index.coerce_to_pyobject(env)
2478

2479 2480
        is_memslice = self.base.type.is_memoryviewslice

2481
        # Handle the case where base is a literal char* (and we expect a string, not an int)
2482
        if not is_memslice and (isinstance(self.base, BytesNode) or is_slice):
Robert Bradshaw's avatar
Robert Bradshaw committed
2483
            if self.base.type.is_string or not (self.base.type.is_ptr or self.base.type.is_array):
2484
                self.base = self.base.coerce_to_pyobject(env)
2485 2486 2487

        skip_child_analysis = False
        buffer_access = False
Mark Florisson's avatar
Mark Florisson committed
2488 2489
        memoryviewslice_access = False

2490 2491 2492 2493 2494 2495 2496
        if self.indices:
            indices = self.indices
        elif isinstance(self.index, TupleNode):
            indices = self.index.args
        else:
            indices = [self.index]

2497
        if (is_memslice and not self.indices and
Mark Florisson's avatar
Mark Florisson committed
2498
                isinstance(self.index, EllipsisNode)):
2499
            # Memoryviewslice copying
Mark Florisson's avatar
Mark Florisson committed
2500
            memoryviewslice_access = True
2501 2502 2503 2504 2505 2506

        elif is_memslice:
            # memoryviewslice indexing or slicing
            import MemoryView

            skip_child_analysis = True
2507 2508
            have_slices, indices = MemoryView.unellipsify(indices,
                                                          self.base.type.ndim)
2509 2510 2511 2512 2513 2514 2515 2516 2517 2518 2519 2520 2521 2522 2523 2524 2525 2526 2527
            self.memslice_index = len(indices) == self.base.type.ndim
            axes = []

            index_type = PyrexTypes.c_py_ssize_t_type
            new_indices = []

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

            suboffsets_dim = -1
            for i, index in enumerate(indices[:]):
                index.analyse_types(env)
                access, packing = self.base.type.axes[i]
                if isinstance(index, SliceNode):
                    suboffsets_dim = i
                    self.memslice_slice = True
2528 2529
                    if index.step.is_none:
                        axes.append((access, packing))
2530 2531
                    else:
                        axes.append((access, 'strided'))
2532 2533 2534 2535 2536 2537

                    # 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)
2538
                            #value = value.coerce_to_temp(env)
2539 2540 2541 2542 2543
                            setattr(index, attr, value)
                            new_indices.append(value)

                elif index.type.is_int:
                    self.memslice_index = True
2544
                    index = index.coerce_to(index_type, env)
2545 2546 2547
                    indices[i] = index
                    new_indices.append(index)

2548
                    if access in ('ptr', 'generic') and i != 0 and have_slices:
2549 2550 2551 2552 2553 2554
                        self.type = error_type
                        return error(index.pos,
                                     "Indexing of non-leading indirect or generic "
                                     "dimensions not supported yet, "
                                     "try slicing with i:i+1")

2555
                else:
2556 2557
                    self.type = error_type
                    return error(index.pos, "Invalid index for memoryview specified")
2558

2559 2560
            self.memslice_index = self.memslice_index and not self.memslice_slice
            self.original_indices = indices
2561 2562
            # All indices with all start/stop/step for slices.
            # We need to keep this around
2563 2564
            self.indices = new_indices

2565 2566
            self.env = env

2567 2568
        elif self.base.type.is_buffer:
            # Buffer indexing
2569
            if len(indices) == self.base.type.ndim:
2570 2571 2572 2573 2574 2575
                buffer_access = True
                skip_child_analysis = True
                for x in indices:
                    x.analyse_types(env)
                    if not x.type.is_int:
                        buffer_access = False
2576

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

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

2583 2584
        self.nogil = env.nogil

2585
        if buffer_access or self.memslice_index:
2586 2587 2588
            if self.base.type.is_memoryviewslice and not self.base.is_name:
                self.base = self.base.coerce_to_temp(env)

2589
            self.indices = indices
2590
            self.index = None
2591 2592
            self.type = self.base.type.dtype
            self.is_buffer_access = True
2593
            self.buffer_type = self.base.type #self.base.entry.type
2594 2595

            if getting and self.type.is_pyobject:
2596
                self.is_temp = True
2597 2598

            if setting and self.base.type.is_memoryviewslice:
2599
                self.base.type.writable_needed = True
2600
            elif setting:
2601 2602 2603
                if not self.base.entry.type.writable:
                    error(self.pos, "Writing to readonly buffer")
                else:
2604
                    self.writable_needed = True
2605
                    if self.base.type.is_buffer:
2606
                        self.base.entry.buffer_aux.writable_needed = True
2607

Mark Florisson's avatar
Mark Florisson committed
2608 2609 2610 2611 2612
        elif memoryviewslice_access:
            self.type = self.base.type
            self.is_memoryviewslice_access = True
            if getting:
                error(self.pos, "memoryviews currently support setting only.")
2613

2614
        elif self.memslice_slice:
2615
            self.index = None
2616
            self.is_temp = True
2617
            self.use_managed_ref = True
2618 2619 2620
            self.type = PyrexTypes.MemoryViewSliceType(
                            self.base.type.dtype, axes)

2621
        else:
2622
            base_type = self.base.type
2623 2624 2625 2626 2627 2628 2629 2630 2631

            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
2632 2633
            if base_type.is_unicode_char:
                # we infer Py_UNICODE/Py_UCS4 for unicode strings in some
2634 2635 2636 2637 2638 2639 2640
                # 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
2641
            if base_type.is_pyobject:
2642
                if self.index.type.is_int:
2643
                    if (not setting
2644
                        and (base_type in (list_type, tuple_type, unicode_type))
2645 2646 2647
                        and (not self.index.type.signed
                             or not env.directives['wraparound']
                             or isinstance(self.index, IntNode) and int(self.index.value) >= 0)
2648 2649 2650 2651
                        and not env.directives['boundscheck']):
                        self.is_temp = 0
                    else:
                        self.is_temp = 1
2652 2653 2654
                    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)
2655
                    self.is_temp = 1
2656
                if self.index.type.is_int and base_type is unicode_type:
Stefan Behnel's avatar
Stefan Behnel committed
2657
                    # Py_UNICODE/Py_UCS4 will automatically coerce to a unicode string
2658
                    # if required, so this is fast and safe
2659
                    self.type = PyrexTypes.c_py_ucs4_type
2660 2661
                elif is_slice and base_type in (bytes_type, str_type, unicode_type, list_type, tuple_type):
                    self.type = base_type
2662 2663
                else:
                    self.type = py_object_type
William Stein's avatar
William Stein committed
2664
            else:
2665 2666
                if base_type.is_ptr or base_type.is_array:
                    self.type = base_type.base_type
2667 2668 2669
                    if is_slice:
                        self.type = base_type
                    elif self.index.type.is_pyobject:
Robert Bradshaw's avatar
Robert Bradshaw committed
2670 2671
                        self.index = self.index.coerce_to(
                            PyrexTypes.c_py_ssize_t_type, env)
2672
                    elif not self.index.type.is_int:
Robert Bradshaw's avatar
Robert Bradshaw committed
2673 2674 2675
                        error(self.pos,
                            "Invalid index type '%s'" %
                                self.index.type)
2676
                elif base_type.is_cpp_class:
2677
                    function = env.lookup_operator("[]", [self.base, self.index])
Robert Bradshaw's avatar
Robert Bradshaw committed
2678
                    if function is None:
2679
                        error(self.pos, "Indexing '%s' not supported for index type '%s'" % (base_type, self.index.type))
Robert Bradshaw's avatar
Robert Bradshaw committed
2680 2681 2682 2683 2684 2685 2686 2687 2688
                        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
2689
                        error(self.pos, "Can't set non-reference result '%s'" % self.type)
2690 2691
                elif fused_index_operation:
                    self.parse_indexed_fused_cdef(env)
2692 2693 2694
                else:
                    error(self.pos,
                        "Attempting to index non-array type '%s'" %
2695
                            base_type)
2696
                    self.type = PyrexTypes.error_type
Stefan Behnel's avatar
Stefan Behnel committed
2697

2698 2699 2700 2701 2702 2703 2704 2705 2706
    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.
        """
2707
        self.type = PyrexTypes.error_type
2708

2709 2710
        self.is_fused_index = True

Mark Florisson's avatar
Mark Florisson committed
2711
        base_type = self.base.type
2712 2713 2714 2715 2716 2717 2718 2719 2720
        specific_types = []
        positions = []

        if self.index.is_name:
            positions.append(self.index.pos)
            specific_types.append(self.index.analyse_as_type(env))
        elif isinstance(self.index, TupleNode):
            for arg in self.index.args:
                positions.append(arg.pos)
2721 2722
                specific_type = arg.analyse_as_type(env)
                specific_types.append(specific_type)
2723
        else:
2724
            specific_types = [False]
2725

2726 2727 2728 2729
        if not Utils.all(specific_types):
            self.index.analyse_types(env)

            if not self.base.entry.as_variable:
2730
                error(self.pos, "Can only index fused functions with types")
2731 2732
            else:
                # A cpdef function indexed with Python objects
2733 2734
                self.base.entry = self.entry = self.base.entry.as_variable
                self.base.type = self.type = self.entry.type
2735

2736 2737 2738 2739 2740 2741
                self.base.is_temp = True
                self.is_temp = True

                self.entry.used = True

            self.is_fused_index = False
2742 2743
            return

2744 2745
        fused_types = base_type.get_fused_types()
        if len(specific_types) > len(fused_types):
2746 2747 2748 2749 2750
            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)
2751 2752 2753 2754 2755 2756 2757

        # 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]):
2758
                return error(pos, "Type not in fused type")
2759 2760 2761 2762 2763 2764 2765

            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)

2766 2767 2768 2769 2770
        if type.is_fused:
            # Only partially specific, this is invalid
            error(self.pos,
                  "Index operation makes function only partially specific")
        else:
2771 2772 2773 2774
            # Fully specific, find the signature with the specialized entry
            for signature in self.base.type.get_all_specific_function_types():
                if type.same_as(signature):
                    self.type = signature
Mark Florisson's avatar
Mark Florisson committed
2775 2776 2777 2778 2779

                    if self.base.is_attribute:
                        # Pretend to be a normal attribute, for cdef extension
                        # methods
                        self.entry = signature.entry
2780
                        self.is_attribute = True
Mark Florisson's avatar
Mark Florisson committed
2781
                        self.obj = self.base.obj
2782 2783 2784 2785

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

2787 2788
                    break
            else:
Mark Florisson's avatar
Mark Florisson committed
2789 2790
                # This is a bug
                raise InternalError("Couldn't find the right signature")
2791

2792 2793
    gil_message = "Indexing Python object"

2794
    def nogil_check(self, env):
2795 2796
        if self.is_buffer_access or self.memslice_index or self.memslice_slice:
            if not self.memslice_slice and env.directives['boundscheck']:
2797 2798 2799 2800 2801
                error(self.pos, "Cannot check buffer index bounds without gil; use boundscheck(False) directive")
                return
            elif self.type.is_pyobject:
                error(self.pos, "Cannot access buffer with object dtype without gil")
                return
2802
        super(IndexNode, self).nogil_check(env)
2803 2804


William Stein's avatar
William Stein committed
2805
    def check_const_addr(self):
2806
        return self.base.check_const_addr() and self.index.check_const()
2807

William Stein's avatar
William Stein committed
2808
    def is_lvalue(self):
2809 2810 2811 2812 2813
        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
2814

William Stein's avatar
William Stein committed
2815
    def calculate_result_code(self):
2816
        if self.is_buffer_access:
2817
            return "(*%s)" % self.buffer_ptr_code
2818 2819 2820 2821
        elif self.base.type is list_type:
            return "PyList_GET_ITEM(%s, %s)" % (self.base.result(), self.index.result())
        elif self.base.type is tuple_type:
            return "PyTuple_GET_ITEM(%s, %s)" % (self.base.result(), self.index.result())
Stefan Behnel's avatar
Stefan Behnel committed
2822
        elif self.base.type is unicode_type and self.type.is_unicode_char:
2823
            return "__Pyx_PyUnicode_READ_CHAR(%s, %s)" % (self.base.result(), self.index.result())
2824 2825
        elif (self.type.is_ptr or self.type.is_array) and self.type == self.base.type:
            error(self.pos, "Invalid use of pointer slice")
2826 2827
        else:
            return "(%s[%s])" % (
2828
                self.base.result(), self.index.result())
2829

2830
    def extra_index_params(self):
Dag Sverre Seljebotn's avatar
Merge  
Dag Sverre Seljebotn committed
2831 2832
        if self.index.type.is_int:
            if self.original_index_type.signed:
2833
                size_adjustment = ""
Dag Sverre Seljebotn's avatar
Merge  
Dag Sverre Seljebotn committed
2834
            else:
2835 2836
                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
2837 2838
        else:
            return ""
2839 2840 2841

    def generate_subexpr_evaluation_code(self, code):
        self.base.generate_evaluation_code(code)
2842
        if not self.indices:
2843 2844
            self.index.generate_evaluation_code(code)
        else:
2845 2846
            for i in self.indices:
                i.generate_evaluation_code(code)
2847

2848 2849
    def generate_subexpr_disposal_code(self, code):
        self.base.generate_disposal_code(code)
2850
        if not self.indices:
2851 2852
            self.index.generate_disposal_code(code)
        else:
2853 2854
            for i in self.indices:
                i.generate_disposal_code(code)
2855

2856 2857 2858 2859 2860 2861 2862 2863
    def free_subexpr_temps(self, code):
        self.base.free_temps(code)
        if not self.indices:
            self.index.free_temps(code)
        else:
            for i in self.indices:
                i.free_temps(code)

William Stein's avatar
William Stein committed
2864
    def generate_result_code(self, code):
2865
        if self.is_buffer_access or self.memslice_index:
2866 2867
            if code.globalstate.directives['nonecheck']:
                self.put_nonecheck(code)
2868
            buffer_entry, self.buffer_ptr_code = self.buffer_lookup_code(code)
2869 2870 2871
            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
2872
                code.putln("__Pyx_INCREF((PyObject*)%s);" % self.result())
2873 2874 2875 2876

        elif self.memslice_slice:
            self.put_memoryviewslice_slice_code(code)

2877 2878 2879 2880 2881 2882 2883 2884 2885 2886 2887
        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)
2888
                else:
2889 2890 2891 2892 2893 2894 2895 2896 2897 2898 2899 2900 2901 2902 2903 2904
                    index_code = self.index.py_result()
                    if self.base.type is dict_type:
                        function = "__Pyx_PyDict_GetItem"
                        code.globalstate.use_utility_code(getitem_dict_utility_code)
                    else:
                        function = "PyObject_GetItem"
                code.putln(
                    "%s = %s(%s, %s%s); if (!%s) %s" % (
                        self.result(),
                        function,
                        self.base.py_result(),
                        index_code,
                        self.extra_index_params(),
                        self.result(),
                        code.error_goto(self.pos)))
                code.put_gotref(self.py_result())
Stefan Behnel's avatar
Stefan Behnel committed
2905
            elif self.type.is_unicode_char and self.base.type is unicode_type:
2906 2907 2908
                assert self.index.type.is_int
                index_code = self.index.result()
                function = "__Pyx_GetItemInt_Unicode"
2909 2910
                code.globalstate.use_utility_code(getitem_int_pyunicode_utility_code)
                code.putln(
2911
                    "%s = %s(%s, %s%s); if (unlikely(%s == (Py_UCS4)-1)) %s;" % (
2912 2913 2914 2915 2916 2917 2918
                        self.result(),
                        function,
                        self.base.py_result(),
                        index_code,
                        self.extra_index_params(),
                        self.result(),
                        code.error_goto(self.pos)))
2919

Dag Sverre Seljebotn's avatar
Merge  
Dag Sverre Seljebotn committed
2920 2921 2922
    def generate_setitem_code(self, value_code, code):
        if self.index.type.is_int:
            function = "__Pyx_SetItemInt"
2923
            index_code = self.index.result()
2924
            code.globalstate.use_utility_code(setitem_int_utility_code)
Dag Sverre Seljebotn's avatar
Merge  
Dag Sverre Seljebotn committed
2925 2926
        else:
            index_code = self.index.py_result()
2927 2928
            if self.base.type is dict_type:
                function = "PyDict_SetItem"
Craig Citro's avatar
Craig Citro committed
2929
            # It would seem that we could specialized lists/tuples, but that
2930 2931 2932 2933 2934 2935
            # 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).
2936 2937
            else:
                function = "PyObject_SetItem"
2938
        code.putln(
Dag Sverre Seljebotn's avatar
Merge  
Dag Sverre Seljebotn committed
2939 2940
            "if (%s(%s, %s, %s%s) < 0) %s" % (
                function,
2941
                self.base.py_result(),
Dag Sverre Seljebotn's avatar
Merge  
Dag Sverre Seljebotn committed
2942 2943
                index_code,
                value_code,
2944
                self.extra_index_params(),
Dag Sverre Seljebotn's avatar
Merge  
Dag Sverre Seljebotn committed
2945
                code.error_goto(self.pos)))
2946

2947
    def generate_memoryviewslice_copy_code(self, rhs, code, op=""):
2948 2949 2950 2951 2952 2953 2954
        assert isinstance(self.index, EllipsisNode)
        import MemoryView
        util_code = MemoryView.CopyContentsFuncUtilCode(rhs.type, self.type)
        func_name = util_code.copy_contents_name
        code.putln(code.error_goto_if_neg("%s(&%s, &%s)" % (func_name, rhs.result(), self.base.result()), self.pos))
        code.globalstate.use_utility_code(util_code)

2955 2956
    def generate_buffer_setitem_code(self, rhs, code, op=""):
        # Used from generate_assignment_code and InPlaceAssignmentNode
2957
        if code.globalstate.directives['nonecheck'] and not self.memslice_index:
2958
            self.put_nonecheck(code)
2959 2960 2961

        buffer_entry, ptrexpr = self.buffer_lookup_code(code)

2962 2963 2964
        if self.buffer_type.dtype.is_pyobject:
            # Must manage refcounts. Decref what is already there
            # and incref what we put in.
2965 2966
            ptr = code.funcstate.allocate_temp(buffer_entry.buf_ptr_type,
                                               manage_ref=False)
2967
            rhs_code = rhs.result()
2968
            code.putln("%s = %s;" % (ptr, ptrexpr))
2969
            code.put_gotref("*%s" % ptr)
Dag Sverre Seljebotn's avatar
Dag Sverre Seljebotn committed
2970
            code.putln("__Pyx_DECREF(*%s); __Pyx_INCREF(%s);" % (
2971 2972 2973
                ptr, rhs_code
                ))
            code.putln("*%s %s= %s;" % (ptr, op, rhs_code))
2974
            code.put_giveref("*%s" % ptr)
2975
            code.funcstate.release_temp(ptr)
2976
        else:
2977
            # Simple case
2978
            code.putln("*%s %s= %s;" % (ptrexpr, op, rhs.result()))
2979

William Stein's avatar
William Stein committed
2980 2981
    def generate_assignment_code(self, rhs, code):
        self.generate_subexpr_evaluation_code(code)
2982
        if self.is_buffer_access or self.memslice_index:
2983
            self.generate_buffer_setitem_code(rhs, code)
2984 2985 2986
        elif self.memslice_slice:
            error(rhs.pos, "Slice assignment not supported yet")
            #self.generate_memoryviewslice_setslice_code(rhs, code)
2987
        elif self.is_memoryviewslice_access:
2988
            self.generate_memoryviewslice_copy_code(rhs, code)
2989
        elif self.type.is_pyobject:
Dag Sverre Seljebotn's avatar
Merge  
Dag Sverre Seljebotn committed
2990
            self.generate_setitem_code(rhs.py_result(), code)
William Stein's avatar
William Stein committed
2991 2992 2993
        else:
            code.putln(
                "%s = %s;" % (
2994
                    self.result(), rhs.result()))
2995
        self.generate_subexpr_disposal_code(code)
2996
        self.free_subexpr_temps(code)
William Stein's avatar
William Stein committed
2997
        rhs.generate_disposal_code(code)
2998
        rhs.free_temps(code)
2999

William Stein's avatar
William Stein committed
3000 3001
    def generate_deletion_code(self, code):
        self.generate_subexpr_evaluation_code(code)
Dag Sverre Seljebotn's avatar
Merge  
Dag Sverre Seljebotn committed
3002 3003
        #if self.type.is_pyobject:
        if self.index.type.is_int:
3004
            function = "__Pyx_DelItemInt"
3005
            index_code = self.index.result()
3006
            code.globalstate.use_utility_code(delitem_int_utility_code)
Dag Sverre Seljebotn's avatar
Merge  
Dag Sverre Seljebotn committed
3007 3008
        else:
            index_code = self.index.py_result()
3009 3010 3011 3012
            if self.base.type is dict_type:
                function = "PyDict_DelItem"
            else:
                function = "PyObject_DelItem"
Dag Sverre Seljebotn's avatar
Merge  
Dag Sverre Seljebotn committed
3013
        code.putln(
3014
            "if (%s(%s, %s%s) < 0) %s" % (
Dag Sverre Seljebotn's avatar
Merge  
Dag Sverre Seljebotn committed
3015
                function,
William Stein's avatar
William Stein committed
3016
                self.base.py_result(),
Dag Sverre Seljebotn's avatar
Merge  
Dag Sverre Seljebotn committed
3017
                index_code,
3018
                self.extra_index_params(),
Dag Sverre Seljebotn's avatar
Merge  
Dag Sverre Seljebotn committed
3019
                code.error_goto(self.pos)))
William Stein's avatar
William Stein committed
3020
        self.generate_subexpr_disposal_code(code)
3021
        self.free_subexpr_temps(code)
3022

3023 3024 3025 3026 3027 3028 3029 3030 3031 3032 3033 3034 3035 3036 3037 3038 3039
    def buffer_entry(self):
        import Buffer, MemoryView

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

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

        return buffer_entry

3040
    def buffer_lookup_code(self, code):
3041
        # Assign indices to temps
3042 3043 3044
        index_temps = [code.funcstate.allocate_temp(i.type, manage_ref=False)
                           for i in self.indices]

3045
        for temp, index in zip(index_temps, self.indices):
3046
            code.putln("%s = %s;" % (temp, index.result()))
3047

3048
        # Generate buffer access code using these temps
3049
        import Buffer, MemoryView
3050

3051
        buffer_entry = self.buffer_entry()
3052

3053
        if buffer_entry.type.is_buffer:
3054
            negative_indices = buffer_entry.type.negative_indices
3055 3056 3057
        else:
            negative_indices = Buffer.buffer_defaults['negative_indices']

3058 3059 3060 3061 3062 3063 3064
        return buffer_entry, Buffer.put_buffer_lookup_code(
               entry=buffer_entry,
               index_signeds=[i.type.signed for i in self.indices],
               index_cnames=index_temps,
               directives=code.globalstate.directives,
               pos=self.pos, code=code,
               negative_indices=negative_indices)
William Stein's avatar
William Stein committed
3065

3066 3067
    def put_memoryviewslice_slice_code(self, code):
        buffer_entry = self.buffer_entry()
3068
        have_gil = not self.in_nogil_context
3069 3070
        buffer_entry.generate_buffer_slice_code(code,
                                                self.original_indices,
3071
                                                self.result(),
3072
                                                have_gil=have_gil)
William Stein's avatar
William Stein committed
3073

3074 3075 3076 3077 3078 3079 3080
    def put_nonecheck(self, code):
        code.globalstate.use_utility_code(raise_noneindex_error_utility_code)
        code.putln("if (%s) {" % code.unlikely("%s == Py_None") % self.base.result_as(PyrexTypes.py_object_type))
        code.putln("__Pyx_RaiseNoneIndexingError();")
        code.putln(code.error_goto(self.pos))
        code.putln("}")

3081

3082
class SliceIndexNode(ExprNode):
William Stein's avatar
William Stein committed
3083 3084 3085 3086 3087
    #  2-element slice indexing
    #
    #  base      ExprNode
    #  start     ExprNode or None
    #  stop      ExprNode or None
3088

William Stein's avatar
William Stein committed
3089
    subexprs = ['base', 'start', 'stop']
3090

3091 3092 3093 3094 3095 3096 3097
    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
3098 3099
        elif base_type.is_ptr or base_type.is_array:
            return PyrexTypes.c_array_type(base_type.base_type, None)
3100 3101
        return py_object_type

3102 3103 3104 3105
    def calculate_constant_result(self):
        self.constant_result = self.base.constant_result[
            self.start.constant_result : self.stop.constant_result]

3106 3107
    def compile_time_value(self, denv):
        base = self.base.compile_time_value(denv)
3108 3109 3110 3111 3112 3113 3114 3115
        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)
3116 3117 3118 3119
        try:
            return base[start:stop]
        except Exception, e:
            self.compile_time_value_error(e)
3120

William Stein's avatar
William Stein committed
3121 3122
    def analyse_target_declaration(self, env):
        pass
3123

3124
    def analyse_target_types(self, env):
3125
        self.analyse_types(env, getting=False)
3126
        # when assigning, we must accept any Python type
3127 3128
        if self.type.is_pyobject:
            self.type = py_object_type
William Stein's avatar
William Stein committed
3129

3130
    def analyse_types(self, env, getting=True):
William Stein's avatar
William Stein committed
3131
        self.base.analyse_types(env)
3132 3133 3134 3135 3136 3137 3138 3139 3140 3141 3142 3143 3144 3145 3146 3147 3148 3149 3150 3151

        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
3152 3153 3154 3155
        if self.start:
            self.start.analyse_types(env)
        if self.stop:
            self.stop.analyse_types(env)
3156 3157 3158
        base_type = self.base.type
        if base_type.is_string:
            self.type = bytes_type
3159 3160 3161
        elif base_type.is_ptr:
            self.type = base_type
        elif base_type.is_array:
3162 3163 3164
            # we need a ptr type here instead of an array type, as
            # array types can result in invalid type casts in the C
            # code
3165
            self.type = PyrexTypes.CPtrType(base_type.base_type)
3166 3167 3168
        else:
            self.base = self.base.coerce_to_pyobject(env)
            self.type = py_object_type
3169 3170 3171
        if base_type.is_builtin_type:
            # slicing builtin types returns something of the same type
            self.type = base_type
3172
        c_int = PyrexTypes.c_py_ssize_t_type
William Stein's avatar
William Stein committed
3173 3174 3175 3176 3177
        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
3178

3179
    nogil_check = Node.gil_error
3180 3181
    gil_message = "Slicing Python object"

William Stein's avatar
William Stein committed
3182
    def generate_result_code(self, code):
3183 3184 3185 3186
        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
3187 3188 3189
        if self.base.type.is_string:
            if self.stop is None:
                code.putln(
3190
                    "%s = PyBytes_FromString(%s + %s); %s" % (
Robert Bradshaw's avatar
Robert Bradshaw committed
3191 3192 3193 3194 3195 3196
                        self.result(),
                        self.base.result(),
                        self.start_code(),
                        code.error_goto_if_null(self.result(), self.pos)))
            else:
                code.putln(
3197
                    "%s = PyBytes_FromStringAndSize(%s + %s, %s - %s); %s" % (
Robert Bradshaw's avatar
Robert Bradshaw committed
3198 3199 3200 3201 3202 3203 3204 3205
                        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(
3206
                "%s = __Pyx_PySequence_GetSlice(%s, %s, %s); %s" % (
Robert Bradshaw's avatar
Robert Bradshaw committed
3207 3208 3209 3210 3211
                    self.result(),
                    self.base.py_result(),
                    self.start_code(),
                    self.stop_code(),
                    code.error_goto_if_null(self.result(), self.pos)))
3212
        code.put_gotref(self.py_result())
3213

William Stein's avatar
William Stein committed
3214 3215
    def generate_assignment_code(self, rhs, code):
        self.generate_subexpr_evaluation_code(code)
3216
        if self.type.is_pyobject:
3217
            code.put_error_if_neg(self.pos,
3218
                "__Pyx_PySequence_SetSlice(%s, %s, %s, %s)" % (
3219 3220 3221
                    self.base.py_result(),
                    self.start_code(),
                    self.stop_code(),
Lisandro Dalcin's avatar
Lisandro Dalcin committed
3222
                    rhs.py_result()))
3223 3224 3225 3226 3227 3228 3229 3230
        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
3231 3232
            if rhs.type.is_array:
                array_length = rhs.type.size
3233
                self.generate_slice_guard_code(code, array_length)
Stefan Behnel's avatar
Stefan Behnel committed
3234
            else:
Stefan Behnel's avatar
Stefan Behnel committed
3235 3236
                error(self.pos,
                      "Slice assignments from pointers are not yet supported.")
Stefan Behnel's avatar
Stefan Behnel committed
3237 3238
                # FIXME: fix the array size according to start/stop
                array_length = self.base.type.size
3239 3240 3241 3242
            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
3243
        self.generate_subexpr_disposal_code(code)
3244
        self.free_subexpr_temps(code)
William Stein's avatar
William Stein committed
3245
        rhs.generate_disposal_code(code)
3246
        rhs.free_temps(code)
William Stein's avatar
William Stein committed
3247 3248

    def generate_deletion_code(self, code):
Robert Bradshaw's avatar
Robert Bradshaw committed
3249
        if not self.base.type.is_pyobject:
3250 3251 3252
            error(self.pos,
                  "Deleting slices is only supported for Python types, not '%s'." % self.type)
            return
William Stein's avatar
William Stein committed
3253
        self.generate_subexpr_evaluation_code(code)
Robert Bradshaw's avatar
Robert Bradshaw committed
3254
        code.put_error_if_neg(self.pos,
3255
            "__Pyx_PySequence_DelSlice(%s, %s, %s)" % (
William Stein's avatar
William Stein committed
3256 3257
                self.base.py_result(),
                self.start_code(),
Robert Bradshaw's avatar
Robert Bradshaw committed
3258
                self.stop_code()))
William Stein's avatar
William Stein committed
3259
        self.generate_subexpr_disposal_code(code)
3260
        self.free_subexpr_temps(code)
3261 3262 3263 3264 3265 3266 3267 3268 3269 3270

    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
3271
                if stop < 0:
3272
                    slice_size = self.base.type.size + stop
Stefan Behnel's avatar
Stefan Behnel committed
3273 3274
                else:
                    slice_size = stop
3275 3276 3277 3278 3279 3280 3281 3282 3283 3284 3285 3286 3287 3288 3289 3290 3291 3292 3293 3294 3295 3296 3297 3298 3299 3300 3301 3302 3303 3304
                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))
3305
            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));' % (
3306 3307 3308
                        target_size, check))
            code.putln(code.error_goto(self.pos))
            code.putln("}")
3309

William Stein's avatar
William Stein committed
3310 3311
    def start_code(self):
        if self.start:
3312
            return self.start.result()
William Stein's avatar
William Stein committed
3313 3314
        else:
            return "0"
3315

William Stein's avatar
William Stein committed
3316 3317
    def stop_code(self):
        if self.stop:
3318
            return self.stop.result()
3319 3320
        elif self.base.type.is_array:
            return self.base.type.size
William Stein's avatar
William Stein committed
3321
        else:
3322
            return "PY_SSIZE_T_MAX"
3323

William Stein's avatar
William Stein committed
3324
    def calculate_result_code(self):
3325
        # self.result() is not used, but this method must exist
William Stein's avatar
William Stein committed
3326
        return "<unused>"
3327

William Stein's avatar
William Stein committed
3328

3329
class SliceNode(ExprNode):
William Stein's avatar
William Stein committed
3330 3331 3332 3333 3334
    #  start:stop:step in subscript list
    #
    #  start     ExprNode
    #  stop      ExprNode
    #  step      ExprNode
3335

3336 3337
    subexprs = ['start', 'stop', 'step']

3338 3339
    type = py_object_type
    is_temp = 1
3340 3341

    def calculate_constant_result(self):
3342 3343 3344 3345
        self.constant_result = slice(
            self.start.constant_result,
            self.stop.constant_result,
            self.step.constant_result)
3346

3347 3348
    def compile_time_value(self, denv):
        start = self.start.compile_time_value(denv)
Stefan Behnel's avatar
Stefan Behnel committed
3349 3350
        stop = self.stop.compile_time_value(denv)
        step = self.step.compile_time_value(denv)
3351 3352 3353 3354 3355
        try:
            return slice(start, stop, step)
        except Exception, e:
            self.compile_time_value_error(e)

William Stein's avatar
William Stein committed
3356 3357 3358 3359 3360 3361 3362
    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)
3363 3364 3365
        if self.start.is_literal and self.stop.is_literal and self.step.is_literal:
            self.is_literal = True
            self.is_temp = False
3366 3367 3368

    gil_message = "Constructing Python slice object"

3369 3370 3371
    def calculate_result_code(self):
        return self.result_code

William Stein's avatar
William Stein committed
3372
    def generate_result_code(self, code):
3373 3374 3375 3376 3377
        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
3378
        code.putln(
Robert Bradshaw's avatar
Robert Bradshaw committed
3379
            "%s = PySlice_New(%s, %s, %s); %s" % (
3380
                self.result(),
3381 3382
                self.start.py_result(),
                self.stop.py_result(),
William Stein's avatar
William Stein committed
3383
                self.step.py_result(),
3384
                code.error_goto_if_null(self.result(), self.pos)))
3385
        code.put_gotref(self.py_result())
3386 3387
        if self.is_literal:
            code.put_giveref(self.py_result())
William Stein's avatar
William Stein committed
3388

3389

3390
class CallNode(ExprNode):
3391

Stefan Behnel's avatar
Stefan Behnel committed
3392 3393 3394
    # allow overriding the default 'may_be_none' behaviour
    may_return_none = None

3395 3396 3397 3398 3399 3400 3401 3402 3403 3404 3405 3406 3407 3408 3409 3410 3411 3412 3413 3414 3415
    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
3416 3417 3418 3419 3420
    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
3421 3422 3423 3424 3425
    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
3426 3427 3428 3429 3430 3431
    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):
3432
                items.append(DictItemNode(pos=arg.pos, key=StringNode(pos=arg.pos, value=member.name), value=arg))
Robert Bradshaw's avatar
Robert Bradshaw committed
3433 3434 3435 3436 3437 3438 3439
            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
3440 3441 3442 3443 3444 3445 3446 3447 3448
        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
3449

3450 3451
    def is_lvalue(self):
        return self.type.is_reference
3452

3453
    def nogil_check(self, env):
3454 3455
        func_type = self.function_type()
        if func_type.is_pyobject:
3456
            self.gil_error()
3457
        elif not getattr(func_type, 'nogil', False):
3458
            self.gil_error()
3459 3460 3461

    gil_message = "Calling gil-requiring function"

3462 3463

class SimpleCallNode(CallNode):
William Stein's avatar
William Stein committed
3464 3465 3466 3467 3468 3469 3470
    #  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
3471
    #  wrapper_call   bool                 used internally
3472
    #  has_optional_args   bool            used internally
3473
    #  nogil          bool                 used internally
3474

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

William Stein's avatar
William Stein committed
3477 3478 3479
    self = None
    coerced_self = None
    arg_tuple = None
3480
    wrapper_call = False
3481
    has_optional_args = False
3482
    nogil = False
3483
    analysed = False
3484

3485 3486 3487 3488 3489 3490 3491
    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)
3492

3493
    def analyse_as_type(self, env):
3494
        attr = self.function.as_cython_attribute()
3495 3496 3497 3498 3499 3500 3501 3502 3503 3504 3505 3506
        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
3507

William Stein's avatar
William Stein committed
3508
    def analyse_types(self, env):
Robert Bradshaw's avatar
Robert Bradshaw committed
3509 3510
        if self.analyse_as_type_constructor(env):
            return
3511 3512 3513
        if self.analysed:
            return
        self.analysed = True
William Stein's avatar
William Stein committed
3514 3515 3516
        function = self.function
        function.is_called = 1
        self.function.analyse_types(env)
Mark Florisson's avatar
Mark Florisson committed
3517

William Stein's avatar
William Stein committed
3518 3519 3520 3521 3522
        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
3523

William Stein's avatar
William Stein committed
3524 3525
        func_type = self.function_type()
        if func_type.is_pyobject:
3526 3527
            self.arg_tuple = TupleNode(self.pos, args = self.args)
            self.arg_tuple.analyse_types(env)
William Stein's avatar
William Stein committed
3528
            self.args = None
3529 3530 3531
            if func_type is Builtin.type_type and function.is_name and \
                   function.entry and \
                   function.entry.is_builtin and \
3532 3533 3534 3535 3536 3537 3538 3539 3540
                   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
3541
                self.may_return_none = False
3542
            elif function.is_name and function.type_entry:
3543 3544 3545 3546 3547
                # 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
3548
                self.may_return_none = False
3549 3550
            else:
                self.type = py_object_type
William Stein's avatar
William Stein committed
3551 3552 3553 3554
            self.is_temp = 1
        else:
            for arg in self.args:
                arg.analyse_types(env)
3555

William Stein's avatar
William Stein committed
3556 3557
            if self.self and func_type.args:
                # Coerce 'self' to the type expected by the method.
3558 3559 3560
                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(
3561 3562 3563
                        "'NoneType' object has no attribute '%s'",
                        error = 'PyExc_AttributeError',
                        format_args = [self.function.entry.name])
3564
                expected_type = self_arg.type
Stefan Behnel's avatar
Stefan Behnel committed
3565 3566 3567 3568 3569
                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
3570 3571 3572
                # Insert coerced 'self' argument into argument list.
                self.args.insert(0, self.coerced_self)
            self.analyse_c_function_call(env)
3573

William Stein's avatar
William Stein committed
3574 3575
    def function_type(self):
        # Return the type of the function being called, coercing a function
3576 3577
        # pointer to a function if necessary. If the function has fused
        # arguments, return the specific type.
William Stein's avatar
William Stein committed
3578
        func_type = self.function.type
3579

William Stein's avatar
William Stein committed
3580 3581
        if func_type.is_ptr:
            func_type = func_type.base_type
3582

William Stein's avatar
William Stein committed
3583
        return func_type
3584

3585 3586 3587 3588 3589 3590 3591
    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
3592
    def analyse_c_function_call(self, env):
Robert Bradshaw's avatar
Robert Bradshaw committed
3593
        if self.function.type is error_type:
3594
            self.type = error_type
Robert Bradshaw's avatar
Robert Bradshaw committed
3595
            return
3596

Robert Bradshaw's avatar
Robert Bradshaw committed
3597
        if self.function.type.is_cpp_class:
3598 3599
            overloaded_entry = self.function.type.scope.lookup("operator()")
            if overloaded_entry is None:
Robert Bradshaw's avatar
Robert Bradshaw committed
3600 3601 3602
                self.type = PyrexTypes.error_type
                self.result_code = "<error>"
                return
3603 3604
        elif hasattr(self.function, 'entry'):
            overloaded_entry = self.function.entry
3605
        elif (isinstance(self.function, IndexNode) and
3606
              self.function.is_fused_index):
3607
            overloaded_entry = self.function.type.entry
Robert Bradshaw's avatar
Robert Bradshaw committed
3608
        else:
3609
            overloaded_entry = None
3610

3611
        if overloaded_entry:
3612
            if self.function.type.is_fused:
Mark Florisson's avatar
Mark Florisson committed
3613 3614
                functypes = self.function.type.get_all_specific_function_types()
                alternatives = [f.entry for f in functypes]
3615 3616 3617 3618 3619
            else:
                alternatives = overloaded_entry.all_alternatives()

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

3620 3621 3622 3623
            if not entry:
                self.type = PyrexTypes.error_type
                self.result_code = "<error>"
                return
Mark Florisson's avatar
Mark Florisson committed
3624 3625

            entry.used = True
3626 3627
            self.function.entry = entry
            self.function.type = entry.type
3628 3629 3630 3631 3632 3633 3634 3635
            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
3636
        # Check no. of args
3637 3638
        max_nargs = len(func_type.args)
        expected_nargs = max_nargs - func_type.optional_arg_count
William Stein's avatar
William Stein committed
3639
        actual_nargs = len(self.args)
3640 3641 3642
        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
3643
        # Coerce arguments
3644
        some_args_in_temps = False
3645
        for i in xrange(min(max_nargs, actual_nargs)):
William Stein's avatar
William Stein committed
3646
            formal_type = func_type.args[i].type
3647
            arg = self.args[i].coerce_to(formal_type, env)
3648
            if arg.is_temp:
3649 3650
                if i > 0:
                    # first argument in temp doesn't impact subsequent arguments
3651
                    some_args_in_temps = True
3652
            elif arg.type.is_pyobject and not env.nogil:
3653 3654
                if i == 0 and self.self is not None:
                    # a method's cloned "self" argument is ok
3655
                    pass
3656
                elif arg.nonlocally_immutable():
3657 3658 3659
                    # plain local variables are ok
                    pass
                else:
3660 3661 3662 3663
                    # 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
3664 3665
                    if i > 0: # first argument doesn't matter
                        some_args_in_temps = True
3666
                    arg = arg.coerce_to_temp(env)
3667
            self.args[i] = arg
3668
        # handle additional varargs parameters
3669
        for i in xrange(max_nargs, actual_nargs):
3670 3671 3672 3673 3674 3675 3676
            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:
3677
                    self.args[i] = arg = arg.coerce_to(arg_ctype, env)
3678 3679
            if arg.is_temp and i > 0:
                some_args_in_temps = True
3680 3681 3682
        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
3683 3684 3685 3686
            # 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):
3687 3688
                if i == 0 and self.self is not None:
                    continue # self is ok
3689
                arg = self.args[i]
3690 3691
                if arg.nonlocally_immutable():
                    # locals, C functions, unassignable types are safe.
3692
                    pass
3693 3694
                elif arg.type.is_cpp_class:
                    # Assignment has side effects, avoid.
3695 3696
                    pass
                elif env.nogil and arg.type.is_pyobject:
3697 3698 3699
                    # can't copy a Python reference into a temp in nogil
                    # env (this is safe: a construction would fail in
                    # nogil anyway)
3700 3701
                    pass
                else:
3702 3703 3704 3705 3706
                    #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
3707

William Stein's avatar
William Stein committed
3708
        # Calc result type and code fragment
Robert Bradshaw's avatar
Robert Bradshaw committed
3709
        if isinstance(self.function, NewExprNode):
3710
            self.type = PyrexTypes.CPtrType(self.function.class_type)
Robert Bradshaw's avatar
Robert Bradshaw committed
3711 3712
        else:
            self.type = func_type.return_type
3713

3714 3715 3716
        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()
3717

Stefan Behnel's avatar
Stefan Behnel committed
3718 3719 3720 3721 3722 3723
        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
3724 3725 3726 3727
        elif self.type.is_memoryviewslice:
            self.is_temp = 1
            # func_type.exception_check = True

3728
        # Called in 'nogil' context?
3729
        self.nogil = env.nogil
3730 3731 3732 3733 3734
        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
3735 3736 3737 3738
        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
3739 3740
    def calculate_result_code(self):
        return self.c_call_code()
3741

William Stein's avatar
William Stein committed
3742 3743
    def c_call_code(self):
        func_type = self.function_type()
3744
        if self.type is PyrexTypes.error_type or not func_type.is_cfunction:
William Stein's avatar
William Stein committed
3745 3746 3747
            return "<error>"
        formal_args = func_type.args
        arg_list_code = []
3748
        args = list(zip(formal_args, self.args))
3749 3750 3751 3752
        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
3753 3754
                arg_code = actual_arg.result_as(formal_arg.type)
                arg_list_code.append(arg_code)
3755

3756 3757
        if func_type.is_overridable:
            arg_list_code.append(str(int(self.wrapper_call or self.function.entry.is_unbound_cmethod)))
3758

3759
        if func_type.optional_arg_count:
3760
            if expected_nargs == actual_nargs:
3761
                optional_args = 'NULL'
3762
            else:
3763
                optional_args = "&%s" % self.opt_arg_struct
3764
            arg_list_code.append(optional_args)
3765

William Stein's avatar
William Stein committed
3766
        for actual_arg in self.args[len(formal_args):]:
3767
            arg_list_code.append(actual_arg.result())
3768 3769

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

William Stein's avatar
William Stein committed
3772 3773
    def generate_result_code(self, code):
        func_type = self.function_type()
3774 3775 3776
        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
3777
        if func_type.is_pyobject:
3778
            arg_code = self.arg_tuple.py_result()
William Stein's avatar
William Stein committed
3779
            code.putln(
3780
                "%s = PyObject_Call(%s, %s, NULL); %s" % (
3781
                    self.result(),
William Stein's avatar
William Stein committed
3782
                    self.function.py_result(),
3783
                    arg_code,
3784
                    code.error_goto_if_null(self.result(), self.pos)))
3785
            code.put_gotref(self.py_result())
William Stein's avatar
William Stein committed
3786
        elif func_type.is_cfunction:
3787 3788 3789
            if self.has_optional_args:
                actual_nargs = len(self.args)
                expected_nargs = len(func_type.args) - func_type.optional_arg_count
3790 3791
                self.opt_arg_struct = code.funcstate.allocate_temp(
                    func_type.op_arg_struct.base_type, manage_ref=True)
3792 3793 3794 3795
                code.putln("%s.%s = %s;" % (
                        self.opt_arg_struct,
                        Naming.pyrex_prefix + "n",
                        len(self.args) - expected_nargs))
3796
                args = list(zip(func_type.args, self.args))
3797 3798 3799
                for formal_arg, actual_arg in args[expected_nargs:actual_nargs]:
                    code.putln("%s.%s = %s;" % (
                            self.opt_arg_struct,
3800
                            func_type.opt_arg_cname(formal_arg.name),
3801
                            actual_arg.result_as(formal_arg.type)))
William Stein's avatar
William Stein committed
3802
            exc_checks = []
3803
            if self.type.is_pyobject and self.is_temp:
3804
                exc_checks.append("!%s" % self.result())
3805 3806 3807
            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
3808
            else:
3809 3810
                exc_val = func_type.exception_value
                exc_check = func_type.exception_check
William Stein's avatar
William Stein committed
3811
                if exc_val is not None:
3812
                    exc_checks.append("%s == %s" % (self.result(), exc_val))
William Stein's avatar
William Stein committed
3813
                if exc_check:
3814 3815
                    if self.nogil:
                        exc_checks.append("__Pyx_ErrOccurredWithGIL()")
3816
                    else:
3817
                        exc_checks.append("PyErr_Occurred()")
William Stein's avatar
William Stein committed
3818 3819
            if self.is_temp or exc_checks:
                rhs = self.c_call_code()
3820 3821
                if self.result():
                    lhs = "%s = " % self.result()
William Stein's avatar
William Stein committed
3822 3823 3824
                    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
3825
                        #    "from", return_type, "to pyobject" ###
William Stein's avatar
William Stein committed
3826 3827 3828
                        rhs = typecast(py_object_type, self.type, rhs)
                else:
                    lhs = ""
Felix Wu's avatar
Felix Wu committed
3829
                if func_type.exception_check == '+':
Robert Bradshaw's avatar
Robert Bradshaw committed
3830 3831 3832
                    if func_type.exception_value is None:
                        raise_py_exception = "__Pyx_CppExn2PyErr()"
                    elif func_type.exception_value.type.is_pyobject:
3833 3834 3835
                        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
3836 3837
                    else:
                        raise_py_exception = '%s(); if (!PyErr_Occurred()) PyErr_SetString(PyExc_RuntimeError , "Error converting c++ exception.")' % func_type.exception_value.entry.cname
3838 3839
                    if self.nogil:
                        raise_py_exception = 'Py_BLOCK_THREADS; %s; Py_UNBLOCK_THREADS' % raise_py_exception
Felix Wu's avatar
Felix Wu committed
3840
                    code.putln(
Robert Bradshaw's avatar
Robert Bradshaw committed
3841
                    "try {%s%s;} catch(...) {%s; %s}" % (
Felix Wu's avatar
Felix Wu committed
3842 3843
                        lhs,
                        rhs,
Robert Bradshaw's avatar
Robert Bradshaw committed
3844
                        raise_py_exception,
Felix Wu's avatar
Felix Wu committed
3845
                        code.error_goto(self.pos)))
3846 3847 3848 3849 3850 3851
                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))
3852
                if self.type.is_pyobject and self.result():
3853
                    code.put_gotref(self.py_result())
3854 3855
            if self.has_optional_args:
                code.funcstate.release_temp(self.opt_arg_struct)
3856 3857 3858 3859


class PythonCapiFunctionNode(ExprNode):
    subexprs = []
3860
    def __init__(self, pos, py_name, cname, func_type, utility_code = None):
3861
        self.pos = pos
3862 3863
        self.name = py_name
        self.cname = cname
3864 3865 3866
        self.type = func_type
        self.utility_code = utility_code

3867 3868 3869
    def analyse_types(self, env):
        pass

3870 3871 3872 3873 3874
    def generate_result_code(self, code):
        if self.utility_code:
            code.globalstate.use_utility_code(self.utility_code)

    def calculate_result_code(self):
3875
        return self.cname
3876 3877 3878 3879

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

Stefan Behnel's avatar
Stefan Behnel committed
3880 3881 3882 3883 3884 3885
    # 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

3886
    def __init__(self, pos, function_name, func_type,
3887
                 utility_code = None, py_name=None, **kwargs):
3888 3889 3890
        self.type = func_type.return_type
        self.result_ctype = self.type
        self.function = PythonCapiFunctionNode(
3891
            pos, py_name, function_name, func_type,
3892 3893 3894 3895 3896
            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
3897

3898
class GeneralCallNode(CallNode):
William Stein's avatar
William Stein committed
3899 3900 3901 3902 3903 3904
    #  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
3905

3906
    type = py_object_type
3907

3908
    subexprs = ['function', 'positional_args', 'keyword_args']
William Stein's avatar
William Stein committed
3909

3910
    nogil_check = Node.gil_error
3911

3912 3913 3914 3915 3916 3917 3918 3919
    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)
3920

3921
    def explicit_args_kwds(self):
3922 3923
        if (self.keyword_args and not isinstance(self.keyword_args, DictNode) or
            not isinstance(self.positional_args, TupleNode)):
3924
            raise CompileError(self.pos,
3925 3926
                'Compile-time keyword arguments must be explicit.')
        return self.positional_args.args, self.keyword_args
3927

William Stein's avatar
William Stein committed
3928
    def analyse_types(self, env):
Robert Bradshaw's avatar
Robert Bradshaw committed
3929 3930
        if self.analyse_as_type_constructor(env):
            return
William Stein's avatar
William Stein committed
3931 3932 3933 3934
        self.function.analyse_types(env)
        self.positional_args.analyse_types(env)
        if self.keyword_args:
            self.keyword_args.analyse_types(env)
3935
        if not self.function.type.is_pyobject:
3936 3937
            if self.function.type.is_error:
                self.type = error_type
Stefan Behnel's avatar
Stefan Behnel committed
3938
                return
3939
            if hasattr(self.function, 'entry') and not self.function.entry.as_variable:
3940
                error(self.pos, "Keyword and starred arguments not allowed in cdef functions.")
3941 3942
            else:
                self.function = self.function.coerce_to_pyobject(env)
William Stein's avatar
William Stein committed
3943 3944
        self.positional_args = \
            self.positional_args.coerce_to_pyobject(env)
Stefan Behnel's avatar
Stefan Behnel committed
3945
        function = self.function
3946 3947 3948 3949 3950
        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
3951
            self.may_return_none = False
3952 3953
        else:
            self.type = py_object_type
William Stein's avatar
William Stein committed
3954
        self.is_temp = 1
3955

William Stein's avatar
William Stein committed
3956
    def generate_result_code(self, code):
3957
        if self.type.is_error: return
3958 3959
        if self.keyword_args:
            kwargs = self.keyword_args.py_result()
William Stein's avatar
William Stein committed
3960
        else:
3961
            kwargs = 'NULL'
William Stein's avatar
William Stein committed
3962
        code.putln(
3963
            "%s = PyObject_Call(%s, %s, %s); %s" % (
3964
                self.result(),
3965 3966 3967
                self.function.py_result(),
                self.positional_args.py_result(),
                kwargs,
3968
                code.error_goto_if_null(self.result(), self.pos)))
3969
        code.put_gotref(self.py_result())
William Stein's avatar
William Stein committed
3970 3971


3972
class AsTupleNode(ExprNode):
William Stein's avatar
William Stein committed
3973 3974 3975 3976
    #  Convert argument to tuple. Used for normalising
    #  the * argument of a function call.
    #
    #  arg    ExprNode
3977

William Stein's avatar
William Stein committed
3978
    subexprs = ['arg']
3979 3980 3981

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

3983 3984 3985 3986 3987 3988 3989
    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
3990 3991 3992
    def analyse_types(self, env):
        self.arg.analyse_types(env)
        self.arg = self.arg.coerce_to_pyobject(env)
3993
        self.type = tuple_type
William Stein's avatar
William Stein committed
3994
        self.is_temp = 1
3995

3996 3997 3998
    def may_be_none(self):
        return False

3999
    nogil_check = Node.gil_error
4000 4001
    gil_message = "Constructing Python tuple"

William Stein's avatar
William Stein committed
4002 4003
    def generate_result_code(self, code):
        code.putln(
Robert Bradshaw's avatar
Robert Bradshaw committed
4004
            "%s = PySequence_Tuple(%s); %s" % (
4005
                self.result(),
William Stein's avatar
William Stein committed
4006
                self.arg.py_result(),
4007
                code.error_goto_if_null(self.result(), self.pos)))
4008
        code.put_gotref(self.py_result())
4009

William Stein's avatar
William Stein committed
4010

4011
class AttributeNode(ExprNode):
William Stein's avatar
William Stein committed
4012 4013 4014 4015
    #  obj.attribute
    #
    #  obj          ExprNode
    #  attribute    string
4016
    #  needs_none_check boolean        Used if obj is an extension type.
4017
    #                                  If set to True, it is known that the type is not None.
William Stein's avatar
William Stein committed
4018 4019 4020 4021 4022 4023 4024
    #
    #  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
4025

William Stein's avatar
William Stein committed
4026 4027
    is_attribute = 1
    subexprs = ['obj']
4028

William Stein's avatar
William Stein committed
4029 4030 4031
    type = PyrexTypes.error_type
    entry = None
    is_called = 0
4032
    needs_none_check = True
4033
    is_memslice_transpose = False
William Stein's avatar
William Stein committed
4034

4035
    def as_cython_attribute(self):
Mark Florisson's avatar
Mark Florisson committed
4036 4037 4038
        if (isinstance(self.obj, NameNode) and
                self.obj.is_cython_module and not
                self.attribute == u"parallel"):
4039
            return self.attribute
Mark Florisson's avatar
Mark Florisson committed
4040

4041 4042 4043
        cy = self.obj.as_cython_attribute()
        if cy:
            return "%s.%s" % (cy, self.attribute)
4044
        return None
4045

4046 4047 4048 4049 4050 4051 4052 4053 4054
    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
4055
                self.analyse_as_python_attribute(env)
4056
                return self
4057
        return ExprNode.coerce_to(self, dst_type, env)
4058 4059 4060

    def calculate_constant_result(self):
        attr = self.attribute
4061
        if attr.startswith("__") and attr.endswith("__"):
4062 4063 4064
            return
        self.constant_result = getattr(self.obj.constant_result, attr)

4065 4066
    def compile_time_value(self, denv):
        attr = self.attribute
4067
        if attr.startswith("__") and attr.endswith("__"):
Stefan Behnel's avatar
Stefan Behnel committed
4068 4069
            error(self.pos,
                  "Invalid attribute name '%s' in compile-time expression" % attr)
4070
            return None
4071
        obj = self.obj.compile_time_value(denv)
4072 4073 4074 4075
        try:
            return getattr(obj, attr)
        except Exception, e:
            self.compile_time_value_error(e)
4076

Robert Bradshaw's avatar
Robert Bradshaw committed
4077 4078
    def type_dependencies(self, env):
        return self.obj.type_dependencies(env)
4079

4080 4081 4082 4083 4084 4085
    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:
4086 4087 4088 4089 4090 4091 4092 4093
            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
4094
            return self.type
4095

William Stein's avatar
William Stein committed
4096 4097
    def analyse_target_declaration(self, env):
        pass
4098

William Stein's avatar
William Stein committed
4099 4100
    def analyse_target_types(self, env):
        self.analyse_types(env, target = 1)
4101 4102
        if not self.is_lvalue():
            error(self.pos, "Assignment to non-lvalue of type '%s'" % self.type)
4103

William Stein's avatar
William Stein committed
4104
    def analyse_types(self, env, target = 0):
4105
        self.initialized_check = env.directives['initializedcheck']
William Stein's avatar
William Stein committed
4106
        if self.analyse_as_cimported_attribute(env, target):
4107 4108 4109 4110 4111 4112 4113
            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
4114

William Stein's avatar
William Stein committed
4115 4116 4117 4118 4119 4120 4121 4122 4123 4124 4125 4126
    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)
4127
                    entry.used = 1
William Stein's avatar
William Stein committed
4128 4129
                    return 1
        return 0
4130

William Stein's avatar
William Stein committed
4131 4132 4133 4134 4135 4136 4137 4138 4139 4140 4141 4142 4143 4144 4145 4146
    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
4147
                ubcm_entry.is_unbound_cmethod = 1
William Stein's avatar
William Stein committed
4148 4149 4150
                self.mutate_into_name_node(env, ubcm_entry, None)
                return 1
        return 0
4151

4152 4153 4154
    def analyse_as_type(self, env):
        module_scope = self.obj.analyse_as_module(env)
        if module_scope:
4155
            return module_scope.lookup_type(self.attribute)
4156
        if not self.obj.is_string_literal:
Robert Bradshaw's avatar
Robert Bradshaw committed
4157
            base_type = self.obj.analyse_as_type(env)
Robert Bradshaw's avatar
Robert Bradshaw committed
4158
            if base_type and hasattr(base_type, 'scope') and base_type.scope is not None:
Robert Bradshaw's avatar
Robert Bradshaw committed
4159
                return base_type.scope.lookup_type(self.attribute)
4160
        return None
4161

William Stein's avatar
William Stein committed
4162 4163 4164 4165 4166 4167 4168 4169 4170
    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
4171

William Stein's avatar
William Stein committed
4172 4173 4174 4175 4176 4177 4178 4179 4180
    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
4181

William Stein's avatar
William Stein committed
4182 4183 4184 4185 4186 4187 4188 4189 4190 4191 4192
    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:
4193
            NameNode.analyse_rvalue_entry(self, env)
4194

William Stein's avatar
William Stein committed
4195 4196 4197 4198
    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:
4199 4200
#            error(self.pos, "C method can only be called")
            pass
4201 4202
        ## Reference to C array turns into pointer to first element.
        #while self.type.is_array:
Robert Bradshaw's avatar
Robert Bradshaw committed
4203
        #    self.type = self.type.element_ptr_type()
William Stein's avatar
William Stein committed
4204 4205 4206 4207
        if self.is_py_attr:
            if not target:
                self.is_temp = 1
                self.result_ctype = py_object_type
4208 4209
        elif target and self.obj.type.is_builtin_type:
            error(self.pos, "Assignment to an immutable object field")
4210 4211
        #elif self.type.is_memoryviewslice and not target:
        #    self.is_temp = True
4212

Robert Bradshaw's avatar
Robert Bradshaw committed
4213
    def analyse_attribute(self, env, obj_type = None):
William Stein's avatar
William Stein committed
4214 4215 4216
        # 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
4217 4218 4219 4220 4221 4222 4223
        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
4224
        if obj_type.is_ptr or obj_type.is_array:
William Stein's avatar
William Stein committed
4225 4226
            obj_type = obj_type.base_type
            self.op = "->"
4227
        elif obj_type.is_extension_type or obj_type.is_builtin_type:
William Stein's avatar
William Stein committed
4228 4229 4230 4231 4232 4233
            self.op = "->"
        else:
            self.op = "."
        if obj_type.has_attributes:
            entry = None
            if obj_type.attributes_known():
4234 4235
                if (obj_type.is_memoryviewslice and not
                        obj_type.scope.lookup_here(self.attribute)):
4236 4237 4238 4239 4240 4241 4242
                    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:
4243
                        obj_type.declare_attribute(self.attribute, env)
William Stein's avatar
William Stein committed
4244
                entry = obj_type.scope.lookup_here(self.attribute)
Robert Bradshaw's avatar
Robert Bradshaw committed
4245 4246
                if entry and entry.is_member:
                    entry = None
William Stein's avatar
William Stein committed
4247
            else:
4248 4249
                error(self.pos,
                    "Cannot select attribute of incomplete type '%s'"
William Stein's avatar
William Stein committed
4250
                    % obj_type)
Robert Bradshaw's avatar
Robert Bradshaw committed
4251 4252
                self.type = PyrexTypes.error_type
                return
William Stein's avatar
William Stein committed
4253 4254
            self.entry = entry
            if entry:
4255 4256
                if obj_type.is_extension_type and entry.name == "__weakref__":
                    error(self.pos, "Illegal use of special attribute __weakref__")
4257 4258
                # methods need the normal attribute lookup
                # because they do not have struct entries
4259 4260 4261 4262
                if entry.is_variable or entry.is_cmethod:
                    self.type = entry.type
                    self.member = entry.cname
                    return
William Stein's avatar
William Stein committed
4263 4264 4265 4266 4267
                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
4268
        # If we get here, the base object is not a struct/union/extension
William Stein's avatar
William Stein committed
4269 4270 4271
        # 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
4272
        self.analyse_as_python_attribute(env, obj_type)
Stefan Behnel's avatar
Stefan Behnel committed
4273

Robert Bradshaw's avatar
Robert Bradshaw committed
4274 4275 4276
    def analyse_as_python_attribute(self, env, obj_type = None):
        if obj_type is None:
            obj_type = self.obj.type
4277 4278
        # mangle private '__*' Python attributes used inside of a class
        self.attribute = env.mangle_class_private_name(self.attribute)
4279
        self.member = self.attribute
4280 4281
        self.type = py_object_type
        self.is_py_attr = 1
4282
        if not obj_type.is_pyobject and not obj_type.is_error:
4283
            if obj_type.can_coerce_to_pyobject(env):
4284 4285 4286 4287 4288
                self.obj = self.obj.coerce_to_pyobject(env)
            else:
                error(self.pos,
                      "Object of type '%s' has no attribute '%s'" %
                      (obj_type, self.attribute))
4289

4290
    def nogil_check(self, env):
4291
        if self.is_py_attr:
4292
            self.gil_error()
4293 4294 4295
        elif self.type.is_memoryviewslice:
            import MemoryView
            MemoryView.err_if_nogil_initialized_check(self.pos, env, 'attribute')
4296

4297 4298
    gil_message = "Accessing Python attribute"

William Stein's avatar
William Stein committed
4299 4300 4301 4302 4303 4304 4305 4306
    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:
4307
            return not self.type.is_array
William Stein's avatar
William Stein committed
4308 4309
        else:
            return NameNode.is_lvalue(self)
4310

William Stein's avatar
William Stein committed
4311 4312 4313 4314 4315
    def is_ephemeral(self):
        if self.obj:
            return self.obj.is_ephemeral()
        else:
            return NameNode.is_ephemeral(self)
4316

William Stein's avatar
William Stein committed
4317 4318
    def calculate_result_code(self):
        #print "AttributeNode.calculate_result_code:", self.member ###
4319
        #print "...obj node =", self.obj, "code", self.obj.result() ###
William Stein's avatar
William Stein committed
4320 4321 4322 4323 4324
        #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
4325
            if obj.type.is_extension_type and not self.entry.is_builtin_cmethod:
4326 4327
                if self.entry.final_func_cname:
                    return self.entry.final_func_cname
4328

Mark Florisson's avatar
Mark Florisson committed
4329
                if self.type.from_fused:
4330 4331 4332 4333
                    # 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
4334 4335
                    self.member = self.entry.cname

Robert Bradshaw's avatar
Robert Bradshaw committed
4336
                return "((struct %s *)%s%s%s)->%s" % (
4337
                    obj.type.vtabstruct_cname, obj_code, self.op,
Robert Bradshaw's avatar
Robert Bradshaw committed
4338 4339 4340
                    obj.type.vtabslot_cname, self.member)
            else:
                return self.member
4341
        elif obj.type.is_complex:
4342
            return "__Pyx_C%s(%s)" % (self.member.upper(), obj_code)
William Stein's avatar
William Stein committed
4343
        else:
4344 4345 4346
            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
4347
            return "%s%s%s" % (obj_code, self.op, self.member)
4348

William Stein's avatar
William Stein committed
4349 4350
    def generate_result_code(self, code):
        if self.is_py_attr:
4351 4352
            code.putln(
                '%s = PyObject_GetAttr(%s, %s); %s' % (
4353
                    self.result(),
4354
                    self.obj.py_result(),
4355
                    code.intern_identifier(self.attribute),
4356
                    code.error_goto_if_null(self.result(), self.pos)))
4357
            code.put_gotref(self.py_result())
4358
        elif self.type.is_memoryviewslice:
4359 4360 4361 4362 4363 4364 4365 4366 4367
            if self.is_memslice_transpose:
                # transpose the slice
                for access, packing in self.type.axes:
                    if access == 'ptr':
                        error(self.pos, "Transposing not supported for slices "
                                        "with indirect dimensions")
                        return

                code.putln("%s = %s;" % (self.result(), self.obj.result()))
Mark Florisson's avatar
Mark Florisson committed
4368
                if self.obj.is_name or self.obj.is_attribute and self.obj.is_memslice_transpose:
4369 4370 4371 4372 4373
                    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:
4374 4375 4376 4377 4378 4379
                code.putln(
                    'if (unlikely(!%s.memview)) {'
                        'PyErr_SetString(PyExc_AttributeError,'
                                        '"Memoryview is not initialized");'
                        '%s'
                    '}' % (self.result(), code.error_goto(self.pos)))
4380 4381 4382
        else:
            # result_code contains what is needed, but we may need to insert
            # a check and raise an exception
4383 4384 4385 4386 4387 4388
            if self.obj.type.is_extension_type:
                if self.needs_none_check and code.globalstate.directives['nonecheck']:
                    self.put_nonecheck(code)
            elif self.entry and self.entry.is_cmethod and self.entry.utility_code:
                # C method implemented as function call with utility code
                code.globalstate.use_utility_code(self.entry.utility_code)
4389

William Stein's avatar
William Stein committed
4390 4391 4392
    def generate_assignment_code(self, rhs, code):
        self.obj.generate_evaluation_code(code)
        if self.is_py_attr:
4393
            code.put_error_if_neg(self.pos,
4394 4395
                'PyObject_SetAttr(%s, %s, %s)' % (
                    self.obj.py_result(),
4396
                    code.intern_identifier(self.attribute),
4397
                    rhs.py_result()))
William Stein's avatar
William Stein committed
4398
            rhs.generate_disposal_code(code)
4399
            rhs.free_temps(code)
4400 4401 4402 4403 4404
        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
4405
        else:
4406
            if (self.obj.type.needs_nonecheck()
4407 4408 4409 4410
                  and self.needs_none_check
                  and code.globalstate.directives['nonecheck']):
                self.put_nonecheck(code)

4411
            select_code = self.result()
4412
            if self.type.is_pyobject and self.use_managed_ref:
William Stein's avatar
William Stein committed
4413
                rhs.make_owned_reference(code)
Dag Sverre Seljebotn's avatar
Dag Sverre Seljebotn committed
4414
                code.put_giveref(rhs.py_result())
4415
                code.put_gotref(select_code)
William Stein's avatar
William Stein committed
4416
                code.put_decref(select_code, self.ctype())
4417
            elif self.type.is_memoryviewslice:
4418
                import MemoryView
4419
                MemoryView.put_assign_to_memviewslice(
Mark Florisson's avatar
Mark Florisson committed
4420 4421
                        select_code, rhs.result(), self.type, code,
                        incref_rhs=rhs.is_name)
4422

4423
            if not self.type.is_memoryviewslice:
4424 4425 4426 4427 4428
                code.putln(
                    "%s = %s;" % (
                        select_code,
                        rhs.result_as(self.ctype())))
                        #rhs.result()))
William Stein's avatar
William Stein committed
4429
            rhs.generate_post_assignment_code(code)
4430
            rhs.free_temps(code)
William Stein's avatar
William Stein committed
4431
        self.obj.generate_disposal_code(code)
4432
        self.obj.free_temps(code)
4433

William Stein's avatar
William Stein committed
4434 4435
    def generate_deletion_code(self, code):
        self.obj.generate_evaluation_code(code)
4436
        if self.is_py_attr or (isinstance(self.entry.scope, Symtab.PropertyScope)
4437
                               and u'__del__' in self.entry.scope.entries):
4438 4439 4440
            code.put_error_if_neg(self.pos,
                'PyObject_DelAttr(%s, %s)' % (
                    self.obj.py_result(),
4441
                    code.intern_identifier(self.attribute)))
William Stein's avatar
William Stein committed
4442 4443 4444
        else:
            error(self.pos, "Cannot delete C attribute of extension type")
        self.obj.generate_disposal_code(code)
4445
        self.obj.free_temps(code)
4446

4447 4448 4449 4450 4451
    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
4452

4453 4454
    def put_nonecheck(self, code):
        code.globalstate.use_utility_code(raise_noneattr_error_utility_code)
4455 4456 4457 4458 4459 4460 4461
        if self.obj.type.is_extension_type:
            test = "%s == Py_None" % self.obj.result_as(PyrexTypes.py_object_type)
        elif self.obj.type.is_memoryviewslice:
            test = "!%s.memview" % self.obj.result()
        else:
            assert False
        code.putln("if (%s) {" % code.unlikely(test))
Stefan Behnel's avatar
Stefan Behnel committed
4462
        code.putln("__Pyx_RaiseNoneAttributeError(\"%s\");" % self.attribute)
4463 4464 4465 4466
        code.putln(code.error_goto(self.pos))
        code.putln("}")


William Stein's avatar
William Stein committed
4467 4468 4469 4470 4471 4472
#-------------------------------------------------------------------
#
#  Constructor nodes
#
#-------------------------------------------------------------------

4473 4474 4475 4476 4477 4478 4479 4480 4481 4482 4483 4484 4485 4486 4487
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
4488
    is_temp = 1
4489 4490 4491 4492 4493 4494 4495 4496 4497 4498 4499 4500 4501 4502 4503 4504 4505 4506 4507 4508 4509 4510 4511 4512 4513 4514 4515 4516

    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


4517
class SequenceNode(ExprNode):
William Stein's avatar
William Stein committed
4518 4519 4520 4521 4522 4523
    #  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
4524
    # mult_factor              ExprNode     the integer number of content repetitions ([1,2]*3)
4525

4526
    subexprs = ['args', 'mult_factor']
4527

William Stein's avatar
William Stein committed
4528 4529
    is_sequence_constructor = 1
    unpacked_items = None
4530
    mult_factor = None
4531

4532 4533 4534
    def compile_time_value_list(self, denv):
        return [arg.compile_time_value(denv) for arg in self.args]

4535 4536 4537 4538 4539 4540 4541 4542 4543 4544 4545 4546 4547 4548
    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
4549
    def analyse_target_declaration(self, env):
4550
        self.replace_starred_target_node()
William Stein's avatar
William Stein committed
4551 4552 4553
        for arg in self.args:
            arg.analyse_target_declaration(env)

4554
    def analyse_types(self, env, skip_children=False):
William Stein's avatar
William Stein committed
4555 4556
        for i in range(len(self.args)):
            arg = self.args[i]
4557
            if not skip_children: arg.analyse_types(env)
William Stein's avatar
William Stein committed
4558
            self.args[i] = arg.coerce_to_pyobject(env)
4559 4560 4561
        if self.mult_factor:
            self.mult_factor.analyse_types(env)
            if not self.mult_factor.type.is_int:
4562
                self.mult_factor = self.mult_factor.coerce_to_pyobject(env)
William Stein's avatar
William Stein committed
4563
        self.is_temp = 1
Stefan Behnel's avatar
Stefan Behnel committed
4564
        # not setting self.type here, subtypes do this
4565

4566 4567 4568
    def may_be_none(self):
        return False

William Stein's avatar
William Stein committed
4569
    def analyse_target_types(self, env):
4570 4571
        if self.mult_factor:
            error(arg.pos, "can't assign to multiplied sequence")
4572
        self.unpacked_items = []
William Stein's avatar
William Stein committed
4573
        self.coerced_unpacked_items = []
4574
        self.any_coerced_items = False
William Stein's avatar
William Stein committed
4575 4576
        for arg in self.args:
            arg.analyse_target_types(env)
4577 4578 4579 4580 4581 4582
            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
4583 4584
            unpacked_item = PyTempNode(self.pos, env)
            coerced_unpacked_item = unpacked_item.coerce_to(arg.type, env)
4585 4586
            if unpacked_item is not coerced_unpacked_item:
                self.any_coerced_items = True
William Stein's avatar
William Stein committed
4587 4588 4589
            self.unpacked_items.append(unpacked_item)
            self.coerced_unpacked_items.append(coerced_unpacked_item)
        self.type = py_object_type
4590

William Stein's avatar
William Stein committed
4591 4592
    def generate_result_code(self, code):
        self.generate_operation_code(code)
4593

4594 4595 4596 4597 4598 4599
    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
4600
        else:
4601 4602 4603 4604 4605 4606
            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
4607 4608 4609 4610 4611
            else:
                size_factor = ' * ((%s<0) ? 0:%s)' % (mult, mult)
        else:
            size_factor = ''
            mult = ''
4612 4613 4614 4615 4616 4617 4618

        if self.type is Builtin.list_type:
            create_func, set_item_func = 'PyList_New', 'PyList_SET_ITEM'
        elif self.type is Builtin.tuple_type:
            create_func, set_item_func = 'PyTuple_New', 'PyTuple_SET_ITEM'
        else:
            raise InternalError("sequence unpacking for unexpected type %s" % self.type)
4619 4620
        arg_count = len(self.args)
        code.putln("%s = %s(%s%s); %s" % (
4621 4622 4623 4624
            target, create_func, arg_count, size_factor,
            code.error_goto_if_null(target, self.pos)))
        code.put_gotref(target)

4625
        if mult:
4626 4627 4628 4629
            # 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.

4630 4631
            #counter = code.funcstate.allocate_temp(mult_factor.type, manage_ref=False)
            counter = Naming.quick_temp_cname
4632 4633
            code.putln('{ Py_ssize_t %s;' % counter)
            if arg_count == 1:
Stefan Behnel's avatar
Stefan Behnel committed
4634
                offset = counter
4635
            else:
Stefan Behnel's avatar
Stefan Behnel committed
4636
                offset = '%s * %s' % (counter, arg_count)
4637 4638 4639 4640 4641 4642 4643 4644 4645
            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
4646
            code.putln("%s(%s, %s, %s);" % (
4647
                set_item_func,
4648
                target,
Stefan Behnel's avatar
Stefan Behnel committed
4649
                (offset and i) and ('%s + %s' % (offset, i)) or (offset or i),
4650 4651 4652 4653
                arg.py_result()))
            code.put_giveref(arg.py_result())
        if mult:
            code.putln('}')
4654 4655
            #code.funcstate.release_temp(counter)
            code.putln('}')
4656
        elif py_multiply and not plain:
4657
            code.putln('{ PyObject* %s = PyNumber_InPlaceMultiply(%s, %s); %s' % (
4658 4659 4660 4661 4662 4663 4664
                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('}')
4665 4666

    def generate_subexpr_disposal_code(self, code):
4667
        if self.mult_factor and self.mult_factor.type.is_int:
4668 4669 4670 4671 4672 4673 4674 4675 4676
            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.
4677 4678
            if self.mult_factor:
                self.mult_factor.generate_disposal_code(code)
4679

William Stein's avatar
William Stein committed
4680
    def generate_assignment_code(self, rhs, code):
4681 4682 4683
        if self.starred_assignment:
            self.generate_starred_assignment_code(rhs, code)
        else:
4684
            self.generate_parallel_assignment_code(rhs, code)
4685 4686 4687 4688 4689

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

4690 4691 4692 4693 4694
    _func_iternext_type = PyrexTypes.CPtrType(PyrexTypes.CFuncType(
        PyrexTypes.py_object_type, [
            PyrexTypes.CFuncTypeArg("it", PyrexTypes.py_object_type, None),
            ]))

4695
    def generate_parallel_assignment_code(self, rhs, code):
4696 4697 4698
        # 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.
4699 4700
        for item in self.unpacked_items:
            item.allocate(code)
4701 4702 4703 4704 4705 4706 4707 4708 4709 4710 4711 4712 4713 4714 4715 4716 4717 4718 4719 4720 4721 4722 4723 4724 4725 4726 4727 4728
        special_unpack = (rhs.type is py_object_type
                          or rhs.type in (tuple_type, list_type)
                          or not rhs.type.is_builtin_type)
        if special_unpack:
            tuple_check = 'likely(PyTuple_CheckExact(%s))' % rhs.py_result()
            list_check  = 'PyList_CheckExact(%s)' % rhs.py_result()
            if rhs.type is list_type:
                sequence_types = ['List']
                sequence_type_test = list_check
            elif rhs.type is tuple_type:
                sequence_types = ['Tuple']
                sequence_type_test = tuple_check
            else:
                sequence_types = ['Tuple', 'List']
                sequence_type_test = "(%s) || (%s)" % (tuple_check, list_check)
            code.putln("if (%s) {" % sequence_type_test)
            code.putln("PyObject* sequence = %s;" % rhs.py_result())
            if len(sequence_types) == 2:
                code.putln("if (likely(Py%s_CheckExact(sequence))) {" % sequence_types[0])
            self.generate_special_parallel_unpacking_code(code, sequence_types[0])
            if len(sequence_types) == 2:
                code.putln("} else {")
                self.generate_special_parallel_unpacking_code(code, sequence_types[1])
                code.putln("}")
            for item in self.unpacked_items:
                code.put_incref(item.result(), item.ctype())
            rhs.generate_disposal_code(code)
            code.putln("} else {")
4729 4730
        else:
            code.putln("{")
4731

4732
        if special_unpack and rhs.type is tuple_type:
4733 4734 4735 4736
            code.globalstate.use_utility_code(tuple_unpacking_error_code)
            code.putln("__Pyx_UnpackTupleError(%s, %s);" % (
                        rhs.py_result(), len(self.args)))
            code.putln(code.error_goto(self.pos))
4737
        else:
4738
            self.generate_generic_parallel_unpacking_code(code, rhs)
4739
        code.putln("}")
4740

4741 4742
        for value_node in self.coerced_unpacked_items:
            value_node.generate_evaluation_code(code)
4743 4744 4745
        for i in range(len(self.args)):
            self.args[i].generate_assignment_code(
                self.coerced_unpacked_items[i], code)
4746

4747 4748 4749 4750 4751 4752 4753 4754 4755 4756 4757 4758
    def generate_special_parallel_unpacking_code(self, code, sequence_type):
        code.globalstate.use_utility_code(raise_need_more_values_to_unpack)
        code.globalstate.use_utility_code(raise_too_many_values_to_unpack)
        code.putln("if (unlikely(Py%s_GET_SIZE(sequence) != %d)) {" % (
            sequence_type, len(self.args)))
        code.putln("if (Py%s_GET_SIZE(sequence) > %d) __Pyx_RaiseTooManyValuesError(%d);" % (
            sequence_type, len(self.args), len(self.args)))
        code.putln("else __Pyx_RaiseNeedMoreValuesError(Py%s_GET_SIZE(sequence));" % sequence_type)
        code.putln(code.error_goto(self.pos))
        code.putln("}")
        for i, item in enumerate(self.unpacked_items):
            code.putln("%s = Py%s_GET_ITEM(sequence, %d); " % (item.result(), sequence_type, i))
Robert Bradshaw's avatar
Robert Bradshaw committed
4759

4760 4761 4762
    def generate_generic_parallel_unpacking_code(self, code, rhs):
        code.globalstate.use_utility_code(iternext_unpacking_end_utility_code)
        code.globalstate.use_utility_code(raise_need_more_values_to_unpack)
4763
        code.putln("Py_ssize_t index = -1;") # must be at the start of a C block!
4764

4765 4766 4767 4768 4769 4770 4771 4772
        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)
4773

4774 4775 4776
        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
4777

4778 4779 4780 4781 4782 4783 4784 4785 4786 4787 4788 4789 4790 4791 4792 4793 4794 4795 4796 4797 4798 4799 4800 4801 4802 4803 4804 4805 4806
        unpacking_error_label = code.new_label('unpacking_failed')
        code.use_label(unpacking_error_label)
        unpack_code = "%s(%s)" % (iternext_func, iterator_temp)
        for i in range(len(self.args)):
            item = self.unpacked_items[i]
            code.putln(
                "index = %d; %s = %s; if (unlikely(!%s)) goto %s;" % (
                    i,
                    item.result(),
                    typecast(item.ctype(), py_object_type, unpack_code),
                    item.result(),
                    unpacking_error_label))
            code.put_gotref(item.py_result())
        code.put_error_if_neg(self.pos, "__Pyx_IternextUnpackEndCheck(%s(%s), %d)" % (
            iternext_func,
            iterator_temp,
            len(self.args)))
        code.put_decref_clear(iterator_temp, py_object_type)
        code.funcstate.release_temp(iterator_temp)
        code.funcstate.release_temp(iternext_func)
        unpacking_done_label = code.new_label('unpacking_done')
        code.put_goto(unpacking_done_label)

        code.put_label(unpacking_error_label)
        code.put_decref_clear(iterator_temp, py_object_type)
        code.putln("if (PyErr_Occurred() && PyErr_ExceptionMatches(PyExc_StopIteration)) PyErr_Clear();")
        code.putln("if (!PyErr_Occurred()) __Pyx_RaiseNeedMoreValuesError(index);")
        code.putln(code.error_goto(self.pos))
        code.put_label(unpacking_done_label)
4807 4808 4809 4810 4811 4812 4813 4814 4815

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

4816
        iterator_temp = code.funcstate.allocate_temp(py_object_type, manage_ref=True)
4817 4818
        code.putln(
            "%s = PyObject_GetIter(%s); %s" % (
4819
                iterator_temp,
4820
                rhs.py_result(),
4821 4822
                code.error_goto_if_null(iterator_temp, self.pos)))
        code.put_gotref(iterator_temp)
4823 4824
        rhs.generate_disposal_code(code)

4825
        for item in self.unpacked_items:
4826
            item.allocate(code)
4827
        code.globalstate.use_utility_code(unpacking_utility_code)
4828 4829 4830
        for i in range(len(fixed_args_left)):
            item = self.unpacked_items[i]
            unpack_code = "__Pyx_UnpackItem(%s, %d)" % (
4831
                iterator_temp, i)
4832 4833 4834 4835 4836 4837 4838 4839 4840 4841 4842
            code.putln(
                "%s = %s; %s" % (
                    item.result(),
                    typecast(item.ctype(), py_object_type, unpack_code),
                    code.error_goto_if_null(item.result(), self.pos)))
            code.put_gotref(item.py_result())
            value_node = self.coerced_unpacked_items[i]
            value_node.generate_evaluation_code(code)

        target_list = starred_target.result()
        code.putln("%s = PySequence_List(%s); %s" % (
4843
            target_list, iterator_temp,
4844 4845 4846 4847 4848 4849 4850 4851 4852 4853 4854 4855 4856 4857 4858 4859 4860 4861
            code.error_goto_if_null(target_list, self.pos)))
        code.put_gotref(target_list)
        if fixed_args_right:
            code.globalstate.use_utility_code(raise_need_more_values_to_unpack)
            unpacked_right_args = self.unpacked_items[-len(fixed_args_right):]
            code.putln("if (unlikely(PyList_GET_SIZE(%s) < %d)) {" % (
                (target_list, len(unpacked_right_args))))
            code.put("__Pyx_RaiseNeedMoreValuesError(%d+PyList_GET_SIZE(%s)); %s" % (
                     len(fixed_args_left), target_list,
                     code.error_goto(self.pos)))
            code.putln('}')
            for i, (arg, coerced_arg) in enumerate(zip(unpacked_right_args[::-1],
                                                       self.coerced_unpacked_items[::-1])):
                code.putln(
                    "%s = PyList_GET_ITEM(%s, PyList_GET_SIZE(%s)-1); " % (
                        arg.py_result(),
                        target_list, target_list))
                # resize the list the hard way
4862
                code.putln("((PyVarObject*)%s)->ob_size--;" % target_list)
4863 4864 4865
                code.put_gotref(arg.py_result())
                coerced_arg.generate_evaluation_code(code)

4866 4867
        code.put_decref_clear(iterator_temp, py_object_type)
        code.funcstate.release_temp(iterator_temp)
4868 4869 4870 4871 4872

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

4873 4874 4875 4876 4877 4878 4879 4880
    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
4881 4882 4883 4884


class TupleNode(SequenceNode):
    #  Tuple constructor.
4885

4886
    type = tuple_type
4887
    is_partly_literal = False
4888 4889 4890

    gil_message = "Constructing Python tuple"

4891
    def analyse_types(self, env, skip_children=False):
Robert Bradshaw's avatar
Robert Bradshaw committed
4892
        if len(self.args) == 0:
4893 4894
            self.is_temp = False
            self.is_literal = True
Robert Bradshaw's avatar
Robert Bradshaw committed
4895
        else:
4896
            SequenceNode.analyse_types(self, env, skip_children)
4897 4898 4899 4900
            for child in self.args:
                if not child.is_literal:
                    break
            else:
4901 4902 4903 4904 4905 4906 4907
                if not self.mult_factor or self.mult_factor.is_literal and \
                       isinstance(self.mult_factor.constant_result, (int, long)):
                    self.is_temp = False
                    self.is_literal = True
                else:
                    self.is_temp = True
                    self.is_partly_literal = True
4908

Stefan Behnel's avatar
Stefan Behnel committed
4909 4910 4911 4912
    def is_simple(self):
        # either temp or constant => always simple
        return True

4913 4914 4915 4916
    def nonlocally_immutable(self):
        # either temp or constant => always safe
        return True

Robert Bradshaw's avatar
Robert Bradshaw committed
4917 4918
    def calculate_result_code(self):
        if len(self.args) > 0:
4919
            return self.result_code
Robert Bradshaw's avatar
Robert Bradshaw committed
4920 4921
        else:
            return Naming.empty_tuple
William Stein's avatar
William Stein committed
4922

4923 4924 4925 4926
    def calculate_constant_result(self):
        self.constant_result = tuple([
                arg.constant_result for arg in self.args])

4927 4928 4929 4930 4931 4932
    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)
4933

William Stein's avatar
William Stein committed
4934
    def generate_operation_code(self, code):
Robert Bradshaw's avatar
Robert Bradshaw committed
4935 4936 4937
        if len(self.args) == 0:
            # result_code is Naming.empty_tuple
            return
4938 4939 4940 4941 4942 4943 4944 4945 4946 4947 4948 4949 4950
        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:
4951 4952
            # non-empty cached tuple => result is global constant,
            # creation code goes into separate code writer
4953
            self.result_code = code.get_py_const(py_object_type, 'tuple_', cleanup_level=2)
4954 4955
            code = code.get_cached_constants_writer()
            code.mark_pos(self.pos)
4956
            self.generate_sequence_packing_code(code)
4957
            code.put_giveref(self.py_result())
4958 4959
        else:
            self.generate_sequence_packing_code(code)
William Stein's avatar
William Stein committed
4960 4961 4962 4963


class ListNode(SequenceNode):
    #  List constructor.
4964

4965 4966
    # obj_conversion_errors    [PyrexError]   used internally
    # orignial_args            [ExprNode]     used internally
4967

4968
    obj_conversion_errors = []
Stefan Behnel's avatar
Stefan Behnel committed
4969
    type = list_type
4970

4971
    gil_message = "Constructing Python list"
4972

Robert Bradshaw's avatar
Robert Bradshaw committed
4973
    def type_dependencies(self, env):
4974
        return ()
4975

4976 4977 4978
    def infer_type(self, env):
        # TOOD: Infer non-object list arrays.
        return list_type
4979

4980
    def analyse_expressions(self, env):
4981
        SequenceNode.analyse_expressions(self, env)
4982 4983
        self.coerce_to_pyobject(env)

Robert Bradshaw's avatar
Robert Bradshaw committed
4984
    def analyse_types(self, env):
4985 4986 4987 4988 4989
        hold_errors()
        self.original_args = list(self.args)
        SequenceNode.analyse_types(self, env)
        self.obj_conversion_errors = held_errors()
        release_errors(ignore=True)
4990

Robert Bradshaw's avatar
Robert Bradshaw committed
4991 4992
    def coerce_to(self, dst_type, env):
        if dst_type.is_pyobject:
4993 4994 4995
            for err in self.obj_conversion_errors:
                report_error(err)
            self.obj_conversion_errors = []
Robert Bradshaw's avatar
Robert Bradshaw committed
4996 4997
            if not self.type.subtype_of(dst_type):
                error(self.pos, "Cannot coerce list to type '%s'" % dst_type)
4998 4999
        elif self.mult_factor:
            error(self.pos, "Cannot coerce multiplied list to '%s'" % dst_type)
5000
        elif dst_type.is_ptr and dst_type.base_type is not PyrexTypes.c_void_type:
Robert Bradshaw's avatar
Robert Bradshaw committed
5001
            base_type = dst_type.base_type
Robert Bradshaw's avatar
Robert Bradshaw committed
5002
            self.type = PyrexTypes.CArrayType(base_type, len(self.args))
5003
            for i in range(len(self.original_args)):
Robert Bradshaw's avatar
Robert Bradshaw committed
5004
                arg = self.args[i]
5005 5006
                if isinstance(arg, CoerceToPyTypeNode):
                    arg = arg.arg
Robert Bradshaw's avatar
Robert Bradshaw committed
5007
                self.args[i] = arg.coerce_to(base_type, env)
Robert Bradshaw's avatar
Robert Bradshaw committed
5008 5009 5010 5011 5012 5013
        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)
5014 5015 5016
                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
5017 5018
                    self.args[i] = arg.coerce_to(member.type, env)
            self.type = dst_type
Robert Bradshaw's avatar
Robert Bradshaw committed
5019 5020 5021 5022
        else:
            self.type = error_type
            error(self.pos, "Cannot coerce list to type '%s'" % dst_type)
        return self
5023

Robert Bradshaw's avatar
Robert Bradshaw committed
5024 5025
    def release_temp(self, env):
        if self.type.is_array:
5026 5027
            # 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
5028 5029 5030
            pass
        else:
            SequenceNode.release_temp(self, env)
Robert Bradshaw's avatar
Robert Bradshaw committed
5031

5032
    def calculate_constant_result(self):
5033 5034
        if self.mult_factor:
            raise ValueError() # may exceed the compile time memory
5035 5036 5037
        self.constant_result = [
            arg.constant_result for arg in self.args]

5038
    def compile_time_value(self, denv):
5039 5040 5041 5042
        l = self.compile_time_value_list(denv)
        if self.mult_factor:
            l *= self.mult_factor.compile_time_value(denv)
        return l
5043

William Stein's avatar
William Stein committed
5044
    def generate_operation_code(self, code):
Robert Bradshaw's avatar
Robert Bradshaw committed
5045
        if self.type.is_pyobject:
5046 5047
            for err in self.obj_conversion_errors:
                report_error(err)
5048
            self.generate_sequence_packing_code(code)
Robert Bradshaw's avatar
Robert Bradshaw committed
5049 5050 5051 5052 5053 5054
        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
5055
        elif self.type.is_struct:
Robert Bradshaw's avatar
Robert Bradshaw committed
5056 5057 5058 5059 5060
            for arg, member in zip(self.args, self.type.scope.var_entries):
                code.putln("%s.%s = %s;" % (
                        self.result(),
                        member.cname,
                        arg.result()))
5061 5062
        else:
            raise InternalError("List type never specified")
5063

Robert Bradshaw's avatar
Robert Bradshaw committed
5064

5065 5066 5067 5068 5069 5070 5071 5072 5073
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

5074 5075 5076 5077 5078 5079 5080 5081 5082 5083 5084 5085 5086 5087 5088 5089 5090 5091 5092
    # 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
5093 5094
        pass

5095 5096
    def analyse_types(self, env):
        # no recursion here, the children will be analysed separately below
5097 5098 5099 5100 5101 5102
        pass

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

5103 5104 5105 5106 5107 5108 5109 5110 5111 5112 5113 5114 5115 5116 5117 5118 5119 5120 5121 5122 5123 5124 5125 5126 5127 5128 5129 5130 5131 5132 5133 5134 5135 5136 5137 5138 5139 5140 5141 5142 5143 5144 5145 5146 5147 5148 5149
    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

5150 5151

class ComprehensionNode(ScopedExprNode):
5152
    subexprs = ["target"]
5153
    child_attrs = ["loop"]
5154

5155 5156
    def infer_type(self, env):
        return self.target.infer_type(env)
5157 5158 5159

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

5162 5163
    def analyse_scoped_declarations(self, env):
        self.loop.analyse_declarations(env)
5164

5165 5166 5167
    def analyse_types(self, env):
        self.target.analyse_expressions(env)
        self.type = self.target.type
5168 5169
        if not self.has_local_scope:
            self.loop.analyse_expressions(env)
5170

5171 5172 5173
    def analyse_scoped_expressions(self, env):
        if self.has_local_scope:
            self.loop.analyse_expressions(env)
5174

5175 5176 5177
    def may_be_none(self):
        return False

5178 5179
    def calculate_result_code(self):
        return self.target.result()
5180

5181 5182
    def generate_result_code(self, code):
        self.generate_operation_code(code)
Robert Bradshaw's avatar
Robert Bradshaw committed
5183

5184 5185 5186
    def generate_operation_code(self, code):
        self.loop.generate_execution_code(code)

5187 5188
    def annotate(self, code):
        self.loop.annotate(code)
5189 5190


5191
class ComprehensionAppendNode(Node):
5192 5193
    # Need to be careful to avoid infinite recursion:
    # target must not be in child_attrs/subexprs
5194 5195

    child_attrs = ['expr']
5196 5197

    type = PyrexTypes.c_int_type
5198

5199 5200
    def analyse_expressions(self, env):
        self.expr.analyse_expressions(env)
5201
        if not self.expr.type.is_pyobject:
Robert Bradshaw's avatar
Robert Bradshaw committed
5202
            self.expr = self.expr.coerce_to_pyobject(env)
5203

5204
    def generate_execution_code(self, code):
5205 5206 5207 5208 5209 5210 5211
        if self.target.type is list_type:
            function = "PyList_Append"
        elif self.target.type is set_type:
            function = "PySet_Add"
        else:
            raise InternalError(
                "Invalid type for comprehension node: %s" % self.target.type)
5212 5213 5214 5215 5216 5217 5218 5219 5220 5221 5222 5223 5224 5225 5226

        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)
5227 5228

class DictComprehensionAppendNode(ComprehensionAppendNode):
5229
    child_attrs = ['key_expr', 'value_expr']
5230

5231 5232
    def analyse_expressions(self, env):
        self.key_expr.analyse_expressions(env)
5233 5234
        if not self.key_expr.type.is_pyobject:
            self.key_expr = self.key_expr.coerce_to_pyobject(env)
5235
        self.value_expr.analyse_expressions(env)
5236 5237 5238
        if not self.value_expr.type.is_pyobject:
            self.value_expr = self.value_expr.coerce_to_pyobject(env)

5239 5240 5241 5242 5243 5244 5245 5246 5247 5248 5249 5250 5251 5252 5253 5254 5255 5256 5257 5258
    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)
5259 5260


5261 5262 5263 5264 5265
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.
5266
    #
5267 5268 5269
    # 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
5270

5271
    child_attrs = ["loop"]
5272
    loop_analysed = False
5273 5274
    type = py_object_type

5275 5276
    def analyse_scoped_declarations(self, env):
        self.loop.analyse_declarations(env)
5277

5278 5279 5280 5281 5282 5283
    def may_be_none(self):
        return False

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

5284 5285
    def infer_type(self, env):
        return self.result_node.infer_type(env)
5286 5287

    def analyse_types(self, env):
5288 5289 5290
        if not self.has_local_scope:
            self.loop_analysed = True
            self.loop.analyse_expressions(env)
5291 5292 5293
        self.type = self.result_node.type
        self.is_temp = True

5294 5295
    def analyse_scoped_expressions(self, env):
        self.loop_analysed = True
5296 5297
        if self.has_local_scope:
            self.loop.analyse_expressions(env)
5298

5299
    def coerce_to(self, dst_type, env):
5300 5301 5302 5303 5304 5305
        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.
5306 5307
            self.result_node.type = self.type = dst_type
            return self
5308
        return super(InlinedGeneratorExpressionNode, self).coerce_to(dst_type, env)
5309

5310 5311 5312 5313 5314
    def generate_result_code(self, code):
        self.result_node.result_code = self.result()
        self.loop.generate_execution_code(code)


5315
class SetNode(ExprNode):
5316 5317
    #  Set constructor.

5318 5319
    type = set_type

5320 5321 5322
    subexprs = ['args']

    gil_message = "Constructing Python set"
5323

5324 5325 5326 5327 5328 5329 5330 5331
    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

5332 5333 5334
    def may_be_none(self):
        return False

5335 5336 5337 5338
    def calculate_constant_result(self):
        self.constant_result = set([
                arg.constant_result for arg in self.args])

5339 5340 5341 5342 5343 5344 5345 5346
    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
5347
        code.globalstate.use_utility_code(Builtin.py_set_utility_code)
5348 5349 5350 5351 5352
        self.allocate_temp_result(code)
        code.putln(
            "%s = PySet_New(0); %s" % (
                self.result(),
                code.error_goto_if_null(self.result(), self.pos)))
5353
        code.put_gotref(self.py_result())
5354 5355 5356 5357 5358 5359 5360 5361
        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
5362

William Stein's avatar
William Stein committed
5363

5364
class DictNode(ExprNode):
William Stein's avatar
William Stein committed
5365 5366
    #  Dictionary constructor.
    #
Vitja Makarov's avatar
Vitja Makarov committed
5367 5368
    #  key_value_pairs     [DictItemNode]
    #  exclude_null_values [boolean]          Do not add NULL values to dict
5369 5370
    #
    # obj_conversion_errors    [PyrexError]   used internally
5371

5372
    subexprs = ['key_value_pairs']
5373
    is_temp = 1
Vitja Makarov's avatar
Vitja Makarov committed
5374
    exclude_null_values = False
5375
    type = dict_type
5376

5377
    obj_conversion_errors = []
5378 5379 5380 5381

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

5383
    def compile_time_value(self, denv):
Robert Bradshaw's avatar
Robert Bradshaw committed
5384 5385
        pairs = [(item.key.compile_time_value(denv), item.value.compile_time_value(denv))
            for item in self.key_value_pairs]
5386 5387 5388 5389
        try:
            return dict(pairs)
        except Exception, e:
            self.compile_time_value_error(e)
5390

Robert Bradshaw's avatar
Robert Bradshaw committed
5391
    def type_dependencies(self, env):
5392
        return ()
5393

5394 5395 5396 5397
    def infer_type(self, env):
        # TOOD: Infer struct constructors.
        return dict_type

William Stein's avatar
William Stein committed
5398
    def analyse_types(self, env):
5399
        hold_errors()
Robert Bradshaw's avatar
Robert Bradshaw committed
5400 5401
        for item in self.key_value_pairs:
            item.analyse_types(env)
5402 5403
        self.obj_conversion_errors = held_errors()
        release_errors(ignore=True)
5404 5405 5406

    def may_be_none(self):
        return False
5407

5408 5409 5410 5411 5412 5413 5414 5415 5416 5417 5418 5419 5420 5421
    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
5422
                if not item.key.is_string_literal:
5423
                    error(item.key.pos, "Invalid struct field identifier")
5424
                    item.key = StringNode(item.key.pos, value="<error>")
5425
                else:
Stefan Behnel's avatar
Stefan Behnel committed
5426 5427
                    key = str(item.key.value) # converts string literals to unicode in Py3
                    member = dst_type.scope.lookup_here(key)
5428
                    if not member:
Stefan Behnel's avatar
Stefan Behnel committed
5429
                        error(item.key.pos, "struct '%s' has no field '%s'" % (dst_type, key))
5430 5431 5432 5433 5434 5435 5436 5437 5438
                    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
5439

5440 5441 5442 5443
    def release_errors(self):
        for err in self.obj_conversion_errors:
            report_error(err)
        self.obj_conversion_errors = []
5444 5445 5446

    gil_message = "Constructing Python dict"

William Stein's avatar
William Stein committed
5447 5448 5449
    def generate_evaluation_code(self, code):
        #  Custom method used here because key-value
        #  pairs are evaluated and used one at a time.
5450 5451
        code.mark_pos(self.pos)
        self.allocate_temp_result(code)
5452 5453 5454 5455 5456 5457
        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)))
5458
            code.put_gotref(self.py_result())
Robert Bradshaw's avatar
Robert Bradshaw committed
5459 5460
        for item in self.key_value_pairs:
            item.generate_evaluation_code(code)
5461
            if self.type.is_pyobject:
Vitja Makarov's avatar
Vitja Makarov committed
5462 5463
                if self.exclude_null_values:
                    code.putln('if (%s) {' % item.value.py_result())
5464
                code.put_error_if_neg(self.pos,
5465 5466 5467 5468
                    "PyDict_SetItem(%s, %s, %s)" % (
                        self.result(),
                        item.key.py_result(),
                        item.value.py_result()))
Vitja Makarov's avatar
Vitja Makarov committed
5469 5470
                if self.exclude_null_values:
                    code.putln('}')
5471 5472 5473
            else:
                code.putln("%s.%s = %s;" % (
                        self.result(),
5474
                        item.key.value,
5475
                        item.value.result()))
Robert Bradshaw's avatar
Robert Bradshaw committed
5476
            item.generate_disposal_code(code)
5477
            item.free_temps(code)
5478

5479
    def annotate(self, code):
Robert Bradshaw's avatar
Robert Bradshaw committed
5480 5481
        for item in self.key_value_pairs:
            item.annotate(code)
5482

5483
class DictItemNode(ExprNode):
Robert Bradshaw's avatar
Robert Bradshaw committed
5484 5485 5486 5487 5488
    # Represents a single item in a DictNode
    #
    # key          ExprNode
    # value        ExprNode
    subexprs = ['key', 'value']
5489

5490
    nogil_check = None # Parent DictNode takes care of it
5491

5492 5493 5494
    def calculate_constant_result(self):
        self.constant_result = (
            self.key.constant_result, self.value.constant_result)
5495

Robert Bradshaw's avatar
Robert Bradshaw committed
5496 5497 5498 5499 5500
    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)
5501

Robert Bradshaw's avatar
Robert Bradshaw committed
5502 5503 5504
    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
5505

5506 5507 5508
    def generate_disposal_code(self, code):
        self.key.generate_disposal_code(code)
        self.value.generate_disposal_code(code)
5509 5510 5511 5512

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

5514 5515
    def __iter__(self):
        return iter([self.key, self.value])
William Stein's avatar
William Stein committed
5516

5517

5518 5519 5520 5521 5522 5523 5524
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
5525

5526
class ClassNode(ExprNode, ModuleNameMixin):
William Stein's avatar
William Stein committed
5527 5528 5529 5530
    #  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
5531
    #  name         EncodedString      Name of the class
William Stein's avatar
William Stein committed
5532 5533 5534
    #  bases        ExprNode           Base class tuple
    #  dict         ExprNode           Class dict (not owned by this node)
    #  doc          ExprNode or None   Doc string
5535
    #  module_name  EncodedString      Name of defining module
5536

5537
    subexprs = ['bases', 'doc']
5538

William Stein's avatar
William Stein committed
5539 5540 5541 5542 5543 5544 5545 5546
    def analyse_types(self, env):
        self.bases.analyse_types(env)
        if self.doc:
            self.doc.analyse_types(env)
            self.doc = self.doc.coerce_to_pyobject(env)
        self.type = py_object_type
        self.is_temp = 1
        env.use_utility_code(create_class_utility_code);
5547 5548
        #TODO(craig,haoyu) This should be moved to a better place
        self.set_mod_name(env)
5549

5550
    def may_be_none(self):
Stefan Behnel's avatar
Stefan Behnel committed
5551
        return True
5552

5553 5554
    gil_message = "Constructing Python class"

William Stein's avatar
William Stein committed
5555
    def generate_result_code(self, code):
5556
        cname = code.intern_identifier(self.name)
5557

William Stein's avatar
William Stein committed
5558
        if self.doc:
5559
            code.put_error_if_neg(self.pos,
Robert Bradshaw's avatar
Robert Bradshaw committed
5560
                'PyDict_SetItemString(%s, "__doc__", %s)' % (
William Stein's avatar
William Stein committed
5561
                    self.dict.py_result(),
Robert Bradshaw's avatar
Robert Bradshaw committed
5562
                    self.doc.py_result()))
5563
        py_mod_name = self.get_py_mod_name(code)
William Stein's avatar
William Stein committed
5564
        code.putln(
5565
            '%s = __Pyx_CreateClass(%s, %s, %s, %s); %s' % (
5566
                self.result(),
William Stein's avatar
William Stein committed
5567 5568
                self.bases.py_result(),
                self.dict.py_result(),
5569
                cname,
5570
                py_mod_name,
5571
                code.error_goto_if_null(self.result(), self.pos)))
5572
        code.put_gotref(self.py_result())
William Stein's avatar
William Stein committed
5573

Stefan Behnel's avatar
Stefan Behnel committed
5574

5575 5576 5577 5578 5579 5580 5581 5582 5583 5584 5585 5586 5587 5588 5589 5590 5591 5592
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

5593
    gil_message = "Constructing Python class"
5594 5595

    def generate_result_code(self, code):
5596
        code.globalstate.use_utility_code(create_py3class_utility_code)
5597 5598 5599 5600 5601 5602 5603 5604 5605 5606 5607 5608 5609
        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):
5610
    #  Helper class for keyword arguments.
5611
    #
5612 5613
    #  starstar_arg      DictNode
    #  keyword_args      [DictItemNode]
5614

5615 5616 5617 5618 5619 5620 5621 5622 5623 5624 5625 5626 5627 5628 5629 5630 5631 5632 5633 5634 5635 5636 5637 5638 5639 5640
    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
5641

5642 5643 5644 5645 5646
    def type_dependencies(self, env):
        return ()

    def infer_type(self, env):
        return dict_type
5647 5648

    def analyse_types(self, env):
5649 5650 5651 5652 5653 5654
        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)
5655

5656 5657
    def may_be_none(self):
        return False
5658

5659 5660 5661 5662 5663 5664 5665 5666 5667 5668
    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())
5669 5670 5671 5672 5673 5674
        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)))
5675
            code.put_gotref(self.py_result())
5676
        else:
5677 5678 5679 5680 5681 5682
            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 {')
5683
            code.putln(
5684 5685
                "%s = PyObject_CallFunctionObjArgs("
                "(PyObject*)&PyDict_Type, %s, NULL); %s" % (
5686
                    self.result(),
5687
                    self.starstar_arg.py_result(),
5688
                    code.error_goto_if_null(self.result(), self.pos)))
5689
            code.put_gotref(self.py_result())
5690 5691 5692 5693 5694 5695 5696 5697 5698 5699 5700 5701 5702 5703 5704 5705 5706 5707 5708 5709 5710 5711 5712 5713 5714 5715 5716 5717 5718 5719
            code.putln('}')
        self.starstar_arg.generate_disposal_code(code)
        self.starstar_arg.free_temps(code)

        if not self.keyword_args:
            return

        code.globalstate.use_utility_code(Nodes.raise_double_keywords_utility_code)
        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)
5720 5721 5722 5723 5724 5725 5726 5727 5728 5729 5730 5731 5732 5733 5734 5735 5736 5737 5738 5739 5740 5741 5742 5743 5744 5745 5746 5747 5748 5749 5750 5751 5752 5753 5754 5755 5756 5757 5758 5759 5760 5761 5762 5763 5764 5765 5766 5767 5768 5769 5770 5771 5772 5773 5774 5775 5776 5777 5778 5779 5780 5781 5782 5783 5784 5785 5786 5787

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

    subexprs = []

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

    def may_be_none(self):
        return True

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

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

    subexprs = ['doc']

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

    def may_be_none(self):
        return True

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

5788 5789 5790 5791 5792 5793 5794 5795 5796 5797 5798 5799 5800 5801 5802 5803 5804 5805 5806 5807 5808 5809 5810 5811 5812 5813 5814 5815 5816 5817 5818 5819 5820 5821 5822 5823 5824 5825 5826 5827 5828 5829 5830 5831 5832 5833 5834 5835 5836 5837 5838 5839 5840

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;' % (
                self.result(), Naming.cur_scope_cname))
        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
5841 5842 5843 5844 5845 5846 5847
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
5848

Robert Bradshaw's avatar
Robert Bradshaw committed
5849
    subexprs = ['function']
5850

Robert Bradshaw's avatar
Robert Bradshaw committed
5851 5852 5853 5854 5855 5856 5857 5858 5859 5860 5861 5862 5863 5864 5865 5866
    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
5867

5868
class UnboundMethodNode(ExprNode):
William Stein's avatar
William Stein committed
5869 5870 5871 5872 5873
    #  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
5874

5875 5876
    type = py_object_type
    is_temp = 1
5877

William Stein's avatar
William Stein committed
5878
    subexprs = ['function']
5879

William Stein's avatar
William Stein committed
5880 5881
    def analyse_types(self, env):
        self.function.analyse_types(env)
5882

5883 5884 5885
    def may_be_none(self):
        return False

5886 5887
    gil_message = "Constructing an unbound method"

William Stein's avatar
William Stein committed
5888
    def generate_result_code(self, code):
5889
        class_cname = code.pyclass_stack[-1].classobj.result()
William Stein's avatar
William Stein committed
5890
        code.putln(
Robert Bradshaw's avatar
Robert Bradshaw committed
5891
            "%s = PyMethod_New(%s, 0, %s); %s" % (
5892
                self.result(),
William Stein's avatar
William Stein committed
5893
                self.function.py_result(),
5894
                class_cname,
5895
                code.error_goto_if_null(self.result(), self.pos)))
5896
        code.put_gotref(self.py_result())
William Stein's avatar
William Stein committed
5897

Robert Bradshaw's avatar
Robert Bradshaw committed
5898

5899
class PyCFunctionNode(ExprNode, ModuleNameMixin):
William Stein's avatar
William Stein committed
5900 5901 5902 5903
    #  Helper class used in the implementation of Python
    #  class definitions. Constructs a PyCFunction object
    #  from a PyMethodDef struct.
    #
5904
    #  pymethdef_cname   string             PyMethodDef structure
Robert Bradshaw's avatar
Robert Bradshaw committed
5905
    #  self_object       ExprNode or None
Robert Bradshaw's avatar
Robert Bradshaw committed
5906
    #  binding           bool
5907
    #  def_node          DefNode            the Python function node
5908
    #  module_name       EncodedString      Name of defining module
5909 5910 5911
    #  code_object       CodeObjectNode     the PyCodeObject creator node

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

Robert Bradshaw's avatar
Robert Bradshaw committed
5913
    self_object = None
5914
    code_object = None
Robert Bradshaw's avatar
Robert Bradshaw committed
5915
    binding = False
5916
    def_node = None
5917

5918 5919
    type = py_object_type
    is_temp = 1
5920

5921 5922
    specialized_cpdefs = None

William Stein's avatar
William Stein committed
5923
    def analyse_types(self, env):
5924 5925 5926
        if self.specialized_cpdefs:
            self.binding = True

Robert Bradshaw's avatar
Robert Bradshaw committed
5927
        if self.binding:
5928 5929 5930 5931
            if self.specialized_cpdefs:
                env.use_utility_code(fused_function_utility_code)
            else:
                env.use_utility_code(binding_cfunc_utility_code)
5932

5933 5934 5935
        #TODO(craig,haoyu) This should be moved to a better place
        self.set_mod_name(env)

5936 5937
    def may_be_none(self):
        return False
5938

5939 5940
    gil_message = "Constructing Python function"

Stefan Behnel's avatar
Stefan Behnel committed
5941
    def self_result_code(self):
Robert Bradshaw's avatar
Robert Bradshaw committed
5942 5943 5944 5945
        if self.self_object is None:
            self_result = "NULL"
        else:
            self_result = self.self_object.py_result()
Stefan Behnel's avatar
Stefan Behnel committed
5946 5947 5948
        return self_result

    def generate_result_code(self, code):
Robert Bradshaw's avatar
Robert Bradshaw committed
5949
        if self.binding:
5950 5951 5952
            self.generate_cyfunction_code(code)
        else:
            self.generate_pycfunction_code(code)
5953

5954 5955 5956 5957 5958 5959 5960 5961 5962 5963 5964 5965 5966 5967 5968
    def generate_pycfunction_code(self, code):
        py_mod_name = self.get_py_mod_name(code)
        code.putln(
            '%s = PyCFunction_NewEx(&%s, %s, %s); %s' % (
                self.result(),
                self.pymethdef_cname,
                self.self_result_code(),
                py_mod_name,
                code.error_goto_if_null(self.result(), self.pos)))

        code.put_gotref(self.py_result())

    def generate_cyfunction_code(self, code):
        if self.specialized_cpdefs:
            constructor = "__pyx_FusedFunction_NewEx"
5969
            def_node = self.specialized_cpdefs[0]
Robert Bradshaw's avatar
Robert Bradshaw committed
5970
        else:
5971
            constructor = "__Pyx_CyFunction_NewEx"
5972
            def_node = self.def_node
5973 5974 5975 5976 5977 5978 5979

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

        flags = []
5980
        if def_node.is_staticmethod:
5981
            flags.append('__Pyx_CYFUNCTION_STATICMETHOD')
5982
        elif def_node.is_classmethod:
5983
            flags.append('__Pyx_CYFUNCTION_CLASSMETHOD')
5984 5985 5986 5987

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

5988 5989 5990 5991
        if flags:
            flags = ' | '.join(flags)
        else:
            flags = '0'
5992

5993
        py_mod_name = self.get_py_mod_name(code)
William Stein's avatar
William Stein committed
5994
        code.putln(
5995
            '%s = %s(&%s, %s, %s, %s, %s); %s' % (
5996
                self.result(),
Robert Bradshaw's avatar
Robert Bradshaw committed
5997
                constructor,
William Stein's avatar
William Stein committed
5998
                self.pymethdef_cname,
5999
                flags,
Stefan Behnel's avatar
Stefan Behnel committed
6000
                self.self_result_code(),
6001
                py_mod_name,
6002
                code_object_result,
6003
                code.error_goto_if_null(self.result(), self.pos)))
6004

6005
        code.put_gotref(self.py_result())
William Stein's avatar
William Stein committed
6006

6007
        if def_node.requires_classobj:
6008 6009 6010 6011 6012 6013 6014 6015 6016
            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())

6017
        if self.specialized_cpdefs:
6018
            self.generate_fused_cpdef(code, code_object_result, flags)
6019

6020
    def generate_fused_cpdef(self, code, code_object_result, flags):
6021 6022 6023 6024 6025 6026 6027 6028 6029 6030 6031 6032 6033 6034 6035 6036 6037 6038 6039 6040
        """
        Generate binding function objects for all specialized cpdefs, and the
        original fused one. The fused function gets a dict __signatures__
        mapping the specialized signature to the specialized binding function.
        In Python space, the specialized versions can be obtained by indexing
        the fused function.

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

        # Set up an interpolation dict
        fmt_dict = dict(
            vars(Naming),
            result=self.result(),
            py_mod_name=self.get_py_mod_name(code),
            self=self.self_result_code(),
6041
            code=code_object_result,
6042
            flags=flags,
6043 6044 6045 6046 6047 6048 6049
            func=code.funcstate.allocate_temp(py_object_type,
                                              manage_ref=True),
            signature=code.funcstate.allocate_temp(py_object_type,
                                                   manage_ref=True),
        )

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

6052
        # Initialize __signatures__
6053 6054 6055 6056 6057 6058 6059 6060 6061 6062
        goto_err("%(sigdict)s = PyDict_New()")

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

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

6063
            goto_err("%(func)s = __pyx_FusedFunction_NewEx("
6064
                            "&%(pymethdef_cname)s, %(flags)s, %(self)s, %(py_mod_name)s, %(code)s)")
6065 6066 6067 6068 6069 6070 6071 6072 6073 6074 6075

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

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

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


Stefan Behnel's avatar
Stefan Behnel committed
6076 6077 6078
class InnerFunctionNode(PyCFunctionNode):
    # Special PyCFunctionNode that depends on a closure class
    #
Vitja Makarov's avatar
Vitja Makarov committed
6079

Robert Bradshaw's avatar
Robert Bradshaw committed
6080
    binding = True
Vitja Makarov's avatar
Vitja Makarov committed
6081 6082
    needs_self_code = True

Stefan Behnel's avatar
Stefan Behnel committed
6083
    def self_result_code(self):
Vitja Makarov's avatar
Vitja Makarov committed
6084 6085 6086
        if self.needs_self_code:
            return "((PyObject*)%s)" % (Naming.cur_scope_cname)
        return "NULL"
Stefan Behnel's avatar
Stefan Behnel committed
6087

6088 6089 6090 6091
class CodeObjectNode(ExprNode):
    # Create a PyCodeObject for a CyFunction instance.
    #
    # def_node   DefNode    the Python function node
6092
    # varnames   TupleNode  a tuple with all local variable names
6093 6094 6095 6096 6097 6098 6099 6100 6101 6102 6103

    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)
6104
        local_vars = [ arg for arg in def_node.local_scope.var_entries
6105
                       if arg.name ]
6106 6107
        self.varnames = TupleNode(
            def_node.pos,
6108
            args = [ IdentifierStringNode(arg.pos, value=arg.name)
6109
                     for arg in args + local_vars ],
6110 6111 6112 6113 6114 6115 6116 6117 6118 6119 6120 6121 6122 6123 6124 6125 6126 6127 6128 6129 6130 6131 6132 6133 6134
            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
6135 6136
            Naming.empty_tuple,        # names (FIXME)
            self.varnames.result(),    # varnames
6137 6138 6139 6140 6141 6142 6143 6144 6145 6146
            Naming.empty_tuple,        # freevars (FIXME)
            Naming.empty_tuple,        # cellvars (FIXME)
            file_path_const,           # filename
            func_name,                 # name
            self.pos[1],               # firstlineno
            Naming.empty_bytes,        # lnotab
            code.error_goto_if_null(self.result_code, self.pos),
            ))


Stefan Behnel's avatar
Stefan Behnel committed
6147 6148 6149 6150 6151 6152 6153 6154 6155 6156 6157 6158 6159 6160 6161
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):
6162 6163
        self.def_node.no_assignment_synthesis = True
        self.def_node.pymethdef_required = True
Stefan Behnel's avatar
Stefan Behnel committed
6164
        self.def_node.analyse_declarations(env)
6165
        self.def_node.is_cyfunction = True
Stefan Behnel's avatar
Stefan Behnel committed
6166 6167 6168
        self.pymethdef_cname = self.def_node.entry.pymethdef_cname
        env.add_lambda_def(self.def_node)

6169 6170 6171 6172 6173 6174 6175 6176
    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)

6177

6178 6179 6180 6181 6182 6183 6184 6185
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

6186
    name = StringEncoding.EncodedString('genexpr')
6187 6188 6189
    binding = False

    def analyse_declarations(self, env):
6190 6191 6192
        super(GeneratorExpressionNode, self).analyse_declarations(env)
        # No pymethdef required
        self.def_node.pymethdef_required = False
6193
        self.def_node.is_cyfunction = False
6194 6195
        # Force genexpr signature
        self.def_node.entry.signature = TypeSlots.pyfunction_noargs
6196 6197 6198 6199 6200 6201 6202 6203 6204 6205 6206

    def generate_result_code(self, code):
        code.putln(
            '%s = %s(%s, NULL); %s' % (
                self.result(),
                self.def_node.entry.func_cname,
                self.self_result_code(),
                code.error_goto_if_null(self.result(), self.pos)))
        code.put_gotref(self.py_result())


6207 6208 6209 6210 6211
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
6212
    # label_num   integer    yield label number
6213 6214 6215

    subexprs = ['arg']
    type = py_object_type
6216
    label_num = 0
6217 6218

    def analyse_types(self, env):
6219 6220
        if not self.label_num:
            error(self.pos, "'yield' not supported here")
6221 6222 6223 6224 6225 6226 6227 6228 6229 6230 6231 6232 6233 6234 6235 6236 6237 6238 6239 6240 6241
        self.is_temp = 1
        if self.arg is not None:
            self.arg.analyse_types(env)
            if not self.arg.type.is_pyobject:
                self.arg = self.arg.coerce_to_pyobject(env)

    def generate_evaluation_code(self, code):
        self.label_name = code.new_label('resume_from_yield')
        code.use_label(self.label_name)
        if self.arg:
            self.arg.generate_evaluation_code(code)
            self.arg.make_owned_reference(code)
            code.putln(
                "%s = %s;" % (
                    Naming.retval_cname,
                    self.arg.result_as(py_object_type)))
            self.arg.generate_post_assignment_code(code)
            #self.arg.generate_disposal_code(code)
            self.arg.free_temps(code)
        else:
            code.put_init_to_py_none(Naming.retval_cname, py_object_type)
6242
        saved = []
6243
        code.funcstate.closure_temps.reset()
6244
        for cname, type, manage_ref in code.funcstate.temps_in_use():
6245
            save_cname = code.funcstate.closure_temps.allocate_temp(type)
6246 6247 6248 6249
            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))
6250

6251
        code.put_xgiveref(Naming.retval_cname)
6252
        code.put_finish_refcount_context()
Stefan Behnel's avatar
Stefan Behnel committed
6253
        code.putln("/* return from generator, yielding value */")
6254 6255 6256
        code.putln("%s->%s.resume_label = %d;" % (Naming.cur_scope_cname, Naming.obj_base_cname, self.label_num))
        code.putln("return %s;" % Naming.retval_cname);
        code.put_label(self.label_name)
6257 6258 6259 6260 6261 6262
        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)
6263 6264 6265 6266 6267 6268 6269 6270
        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))
6271

Vitja Makarov's avatar
Vitja Makarov committed
6272 6273 6274 6275 6276 6277 6278 6279 6280 6281 6282 6283 6284 6285 6286 6287

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
6288

6289
class FuncLocalsExprNode(DictNode):
Vitja Makarov's avatar
Vitja Makarov committed
6290 6291 6292 6293 6294 6295 6296 6297
    def __init__(self, pos, env):
        local_vars = [var.name for var in env.entries.values() if var.name]
        items = [DictItemNode(pos, key=IdentifierStringNode(pos, value=var),
                              value=NameNode(pos, name=var, allow_null=True))
                 for var in local_vars]
        DictNode.__init__(self, pos, key_value_pairs=items,
                          exclude_null_values=True)

6298 6299 6300 6301 6302 6303 6304 6305 6306 6307 6308 6309 6310 6311 6312 6313 6314 6315 6316 6317 6318 6319 6320 6321 6322

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
6323 6324 6325 6326 6327 6328
#-------------------------------------------------------------------
#
#  Unary operator nodes
#
#-------------------------------------------------------------------

6329 6330 6331 6332 6333 6334 6335
compile_time_unary_operators = {
    'not': operator.not_,
    '~': operator.inv,
    '-': operator.neg,
    '+': operator.pos,
}

6336
class UnopNode(ExprNode):
William Stein's avatar
William Stein committed
6337 6338 6339 6340 6341 6342 6343 6344 6345 6346
    #  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.
6347

William Stein's avatar
William Stein committed
6348
    subexprs = ['operand']
Robert Bradshaw's avatar
Robert Bradshaw committed
6349
    infix = True
6350 6351 6352 6353

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

6355 6356 6357 6358 6359 6360 6361 6362 6363 6364 6365
    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)
6366

6367
    def infer_type(self, env):
6368 6369 6370 6371 6372
        operand_type = self.operand.infer_type(env)
        if operand_type.is_pyobject:
            return py_object_type
        else:
            return operand_type
6373

William Stein's avatar
William Stein committed
6374 6375 6376 6377 6378 6379
    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
6380 6381
        elif self.is_cpp_operation():
            self.analyse_cpp_operation(env)
William Stein's avatar
William Stein committed
6382 6383
        else:
            self.analyse_c_operation(env)
6384

William Stein's avatar
William Stein committed
6385
    def check_const(self):
6386
        return self.operand.check_const()
6387

William Stein's avatar
William Stein committed
6388 6389
    def is_py_operation(self):
        return self.operand.type.is_pyobject
6390

6391
    def nogil_check(self, env):
6392
        if self.is_py_operation():
6393
            self.gil_error()
6394

Danilo Freitas's avatar
Danilo Freitas committed
6395
    def is_cpp_operation(self):
Robert Bradshaw's avatar
Robert Bradshaw committed
6396
        type = self.operand.type
Robert Bradshaw's avatar
Robert Bradshaw committed
6397
        return type.is_cpp_class
6398

William Stein's avatar
William Stein committed
6399 6400
    def coerce_operand_to_pyobject(self, env):
        self.operand = self.operand.coerce_to_pyobject(env)
6401

William Stein's avatar
William Stein committed
6402 6403 6404
    def generate_result_code(self, code):
        if self.operand.type.is_pyobject:
            self.generate_py_operation_code(code)
6405

William Stein's avatar
William Stein committed
6406 6407 6408
    def generate_py_operation_code(self, code):
        function = self.py_operation_function()
        code.putln(
Robert Bradshaw's avatar
Robert Bradshaw committed
6409
            "%s = %s(%s); %s" % (
6410 6411
                self.result(),
                function,
William Stein's avatar
William Stein committed
6412
                self.operand.py_result(),
6413
                code.error_goto_if_null(self.result(), self.pos)))
6414
        code.put_gotref(self.py_result())
6415

William Stein's avatar
William Stein committed
6416 6417 6418 6419 6420 6421
    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
6422
    def analyse_cpp_operation(self, env):
6423
        type = self.operand.type
Robert Bradshaw's avatar
Robert Bradshaw committed
6424
        if type.is_ptr:
Danilo Freitas's avatar
Danilo Freitas committed
6425
            type = type.base_type
Robert Bradshaw's avatar
Robert Bradshaw committed
6426
        function = type.scope.lookup("operator%s" % self.operator)
Danilo Freitas's avatar
Danilo Freitas committed
6427 6428
        if not function:
            error(self.pos, "'%s' operator not defined for %s"
6429
                % (self.operator, type))
Danilo Freitas's avatar
Danilo Freitas committed
6430 6431
            self.type_error()
            return
6432 6433 6434 6435
        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
6436

William Stein's avatar
William Stein committed
6437

6438
class NotNode(ExprNode):
William Stein's avatar
William Stein committed
6439 6440 6441
    #  'not' operator
    #
    #  operand   ExprNode
6442

6443
    type = PyrexTypes.c_bint_type
6444

6445
    subexprs = ['operand']
6446

6447 6448 6449
    def calculate_constant_result(self):
        self.constant_result = not self.operand.constant_result

6450 6451 6452 6453 6454 6455 6456
    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)

6457 6458
    def infer_type(self, env):
        return PyrexTypes.c_bint_type
6459

William Stein's avatar
William Stein committed
6460 6461 6462
    def analyse_types(self, env):
        self.operand.analyse_types(env)
        self.operand = self.operand.coerce_to_boolean(env)
6463

William Stein's avatar
William Stein committed
6464
    def calculate_result_code(self):
6465
        return "(!%s)" % self.operand.result()
6466

William Stein's avatar
William Stein committed
6467 6468 6469 6470 6471 6472
    def generate_result_code(self, code):
        pass


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

William Stein's avatar
William Stein committed
6474
    operator = '+'
6475

William Stein's avatar
William Stein committed
6476
    def analyse_c_operation(self, env):
Lisandro Dalcin's avatar
Lisandro Dalcin committed
6477
        self.type = PyrexTypes.widest_numeric_type(
Robert Bradshaw's avatar
Robert Bradshaw committed
6478
            self.operand.type, PyrexTypes.c_int_type)
6479

William Stein's avatar
William Stein committed
6480 6481
    def py_operation_function(self):
        return "PyNumber_Positive"
6482

William Stein's avatar
William Stein committed
6483
    def calculate_result_code(self):
6484 6485 6486 6487
        if self.is_cpp_operation():
            return "(+%s)" % self.operand.result()
        else:
            return self.operand.result()
William Stein's avatar
William Stein committed
6488 6489 6490 6491


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

William Stein's avatar
William Stein committed
6493
    operator = '-'
6494

William Stein's avatar
William Stein committed
6495 6496
    def analyse_c_operation(self, env):
        if self.operand.type.is_numeric:
6497 6498
            self.type = PyrexTypes.widest_numeric_type(
                self.operand.type, PyrexTypes.c_int_type)
6499 6500
        elif self.operand.type.is_enum:
            self.type = PyrexTypes.c_int_type
William Stein's avatar
William Stein committed
6501 6502
        else:
            self.type_error()
Robert Bradshaw's avatar
Robert Bradshaw committed
6503
        if self.type.is_complex:
6504
            self.infix = False
6505

William Stein's avatar
William Stein committed
6506 6507
    def py_operation_function(self):
        return "PyNumber_Negative"
6508

William Stein's avatar
William Stein committed
6509
    def calculate_result_code(self):
Robert Bradshaw's avatar
Robert Bradshaw committed
6510 6511 6512 6513
        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
6514

6515 6516 6517 6518 6519
    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
6520 6521 6522 6523 6524
class TildeNode(UnopNode):
    #  unary '~' operator

    def analyse_c_operation(self, env):
        if self.operand.type.is_int:
6525 6526
            self.type = PyrexTypes.widest_numeric_type(
                self.operand.type, PyrexTypes.c_int_type)
6527 6528
        elif self.operand.type.is_enum:
            self.type = PyrexTypes.c_int_type
William Stein's avatar
William Stein committed
6529 6530 6531 6532 6533
        else:
            self.type_error()

    def py_operation_function(self):
        return "PyNumber_Invert"
6534

William Stein's avatar
William Stein committed
6535
    def calculate_result_code(self):
6536
        return "(~%s)" % self.operand.result()
William Stein's avatar
William Stein committed
6537 6538


6539 6540
class CUnopNode(UnopNode):

Robert Bradshaw's avatar
Robert Bradshaw committed
6541 6542 6543
    def is_py_operation(self):
        return False

6544 6545
class DereferenceNode(CUnopNode):
    #  unary * operator
6546 6547

    operator = '*'
6548

Robert Bradshaw's avatar
Robert Bradshaw committed
6549 6550 6551 6552 6553 6554 6555 6556
    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
6557 6558


6559 6560
class DecrementIncrementNode(CUnopNode):
    #  unary ++/-- operator
6561

6562
    def analyse_c_operation(self, env):
6563 6564 6565 6566
        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:
6567 6568 6569 6570 6571 6572 6573 6574 6575 6576 6577 6578 6579 6580
            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)


6581
class AmpersandNode(ExprNode):
William Stein's avatar
William Stein committed
6582 6583 6584
    #  The C address-of operator.
    #
    #  operand  ExprNode
6585

William Stein's avatar
William Stein committed
6586
    subexprs = ['operand']
6587

6588 6589
    def infer_type(self, env):
        return PyrexTypes.c_ptr_type(self.operand.infer_type(env))
William Stein's avatar
William Stein committed
6590 6591 6592 6593

    def analyse_types(self, env):
        self.operand.analyse_types(env)
        argtype = self.operand.type
6594
        if not (argtype.is_cfunction or self.operand.is_addressable()):
William Stein's avatar
William Stein committed
6595 6596 6597 6598 6599 6600
            self.error("Taking address of non-lvalue")
            return
        if argtype.is_pyobject:
            self.error("Cannot take address of Python variable")
            return
        self.type = PyrexTypes.c_ptr_type(argtype)
6601

William Stein's avatar
William Stein committed
6602
    def check_const(self):
6603
        return self.operand.check_const_addr()
6604

William Stein's avatar
William Stein committed
6605 6606 6607 6608
    def error(self, mess):
        error(self.pos, mess)
        self.type = PyrexTypes.error_type
        self.result_code = "<error>"
6609

William Stein's avatar
William Stein committed
6610
    def calculate_result_code(self):
6611
        return "(&%s)" % self.operand.result()
William Stein's avatar
William Stein committed
6612 6613 6614

    def generate_result_code(self, code):
        pass
6615

William Stein's avatar
William Stein committed
6616 6617 6618 6619 6620 6621 6622 6623

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

def unop_node(pos, operator, operand):
6624
    # Construct unnop node of appropriate class for
William Stein's avatar
William Stein committed
6625
    # given operator.
6626
    if isinstance(operand, IntNode) and operator == '-':
6627
        return IntNode(pos = operand.pos, value = str(-Utils.str_to_number(operand.value)))
Robert Bradshaw's avatar
Robert Bradshaw committed
6628 6629
    elif isinstance(operand, UnopNode) and operand.operator == operator:
        warning(pos, "Python has no increment/decrement operator: %s%sx = %s(%sx) = x" % ((operator,)*4), 5)
6630 6631
    return unop_node_classes[operator](pos,
        operator = operator,
William Stein's avatar
William Stein committed
6632 6633 6634
        operand = operand)


6635
class TypecastNode(ExprNode):
William Stein's avatar
William Stein committed
6636 6637
    #  C type cast
    #
6638
    #  operand      ExprNode
William Stein's avatar
William Stein committed
6639 6640
    #  base_type    CBaseTypeNode
    #  declarator   CDeclaratorNode
6641 6642 6643
    #
    #  If used from a transform, one can if wanted specify the attribute
    #  "type" directly and leave base_type and declarator to None
6644

William Stein's avatar
William Stein committed
6645
    subexprs = ['operand']
6646
    base_type = declarator = type = None
6647

Robert Bradshaw's avatar
Robert Bradshaw committed
6648
    def type_dependencies(self, env):
6649
        return ()
6650

Robert Bradshaw's avatar
Robert Bradshaw committed
6651
    def infer_type(self, env):
6652 6653 6654 6655
        if self.type is None:
            base_type = self.base_type.analyse(env)
            _, self.type = self.declarator.analyse(base_type, env)
        return self.type
6656

William Stein's avatar
William Stein committed
6657
    def analyse_types(self, env):
6658 6659 6660
        if self.type is None:
            base_type = self.base_type.analyse(env)
            _, self.type = self.declarator.analyse(base_type, env)
6661 6662 6663 6664
        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
6665 6666 6667
        self.operand.analyse_types(env)
        to_py = self.type.is_pyobject
        from_py = self.operand.type.is_pyobject
6668 6669
        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
6670
        if to_py and not from_py:
6671 6672 6673 6674 6675 6676
            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
6677
                self.result_ctype = py_object_type
6678
                self.operand = self.operand.coerce_to_pyobject(env)
6679
            else:
6680 6681 6682 6683
                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:
6684
                    # Should this be an error?
6685
                    warning(self.pos, "No conversion from %s to %s, python object pointer used." % (self.operand.type, self.type))
6686
                self.operand = self.operand.coerce_to_simple(env)
6687
        elif from_py and not to_py:
6688
            if self.type.create_from_py_utility_code(env):
6689
                self.operand = self.operand.coerce_to(self.type, env)
6690 6691 6692
            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")
6693 6694
            else:
                warning(self.pos, "No conversion from %s to %s, python object pointer used." % (self.type, self.operand.type))
6695 6696
        elif from_py and to_py:
            if self.typecheck and self.type.is_extension_type:
6697
                self.operand = PyTypeTestNode(self.operand, self.type, env, notnone=True)
6698 6699
        elif self.type.is_complex and self.operand.type.is_complex:
            self.operand = self.operand.coerce_to_simple(env)
6700 6701
        elif self.operand.type.is_fused:
            self.operand = self.operand.coerce_to(self.type, env)
6702
            #self.type = self.operand.type
6703

Stefan Behnel's avatar
Stefan Behnel committed
6704
    def is_simple(self):
6705 6706
        # 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
6707

6708 6709 6710
    def nonlocally_immutable(self):
        return self.operand.nonlocally_immutable()

6711 6712 6713
    def nogil_check(self, env):
        if self.type and self.type.is_pyobject and self.is_temp:
            self.gil_error()
6714

William Stein's avatar
William Stein committed
6715
    def check_const(self):
6716
        return self.operand.check_const()
Stefan Behnel's avatar
Stefan Behnel committed
6717 6718

    def calculate_constant_result(self):
6719 6720 6721
        # we usually do not know the result of a type cast at code
        # generation time
        pass
6722

William Stein's avatar
William Stein committed
6723
    def calculate_result_code(self):
6724 6725 6726 6727 6728 6729 6730 6731 6732 6733 6734
        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,
6735
                    imag_part)
6736 6737
        else:
            return self.type.cast_code(self.operand.result())
6738

6739 6740 6741 6742
    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)
6743

William Stein's avatar
William Stein committed
6744 6745 6746 6747 6748 6749 6750 6751 6752 6753 6754
    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;" % (
6755 6756 6757
                    self.result(),
                    self.operand.result()))
            code.put_incref(self.result(), self.ctype())
William Stein's avatar
William Stein committed
6758 6759


6760 6761 6762 6763 6764 6765 6766 6767 6768 6769 6770 6771
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")
ERR_NOT_POINTER = "Can only create cython.array from pointer"
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.

6772
        <int[:M:1, :N]> p
6773 6774 6775 6776 6777 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 6803 6804 6805 6806 6807 6808 6809 6810 6811 6812 6813 6814 6815 6816 6817 6818 6819 6820 6821 6822 6823 6824 6825 6826 6827 6828 6829 6830 6831

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

    subexprs = ['operand', 'shapes']

    shapes = None
    is_temp = True
    mode = "c"

    shape_type = PyrexTypes.c_py_ssize_t_type

    def analyse_types(self, env):
        import MemoryView

        self.type = error_type
        self.shapes = []

        for axis_no, axis in enumerate(self.base_type_node.axes):
            if not axis.start.is_none:
                return error(axis.start.pos, ERR_START)

            if axis.stop.is_none:
                return error(axis.pos, ERR_NOT_STOP)

            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)

            if not axis.stop.type.is_int:
                return error(axis.stop.pos, "Expected an integer type")

            first_or_last = axis_no in (0, len(self.base_type_node.axes) - 1)
            if not axis.step.is_none and first_or_last:
                axis.step.analyse_types(env)
                if (not axis.step.type.is_int and axis.step.is_literal and not
                        axis.step.type.is_error):
                    return error(axis.step.pos, "Expected an integer literal")

                if axis.step.compile_time_value(env) != 1:
                    return error(axis.step.pos, ERR_STEPS)

                if axis_no == 0:
                    self.mode = "fortran"

            elif axis.step and not first_or_last:
                return error(axis.step.pos, ERR_STEPS)

        self.operand.analyse_types(env)
        array_dtype = self.base_type_node.base_type_node.analyse(env)

6832 6833
        MemoryView.validate_memslice_dtype(self.pos, array_dtype)

6834 6835 6836 6837 6838 6839 6840 6841 6842 6843 6844 6845 6846 6847 6848 6849 6850
        if not self.operand.type.is_ptr:
            return error(self.operand.pos, ERR_NOT_POINTER)

        elif not self.operand.type.base_type.same_as(array_dtype):
            return error(self.operand.pos, ERR_BASE_TYPE)

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

        axes = [('direct', 'follow')] * len(self.base_type_node.axes)
        if self.mode == "fortran":
            axes[0] = ('direct', 'contig')
        else:
            axes[-1] = ('direct', 'contig')

        self.coercion_type = PyrexTypes.MemoryViewSliceType(array_dtype, axes)
        #self.type = py_object_type
6851
        self.type = self.get_cython_array_type(env)
6852 6853
        assert self.type

6854
        MemoryView.use_cython_array_utility_code(env)
6855 6856 6857 6858 6859 6860 6861 6862
        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)

6863 6864 6865 6866 6867 6868
    def infer_type(self, env):
        return self.get_cython_array_type(env)

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

6869 6870 6871 6872 6873 6874 6875 6876 6877 6878 6879 6880 6881 6882 6883 6884 6885 6886 6887 6888 6889 6890 6891 6892 6893 6894 6895 6896 6897 6898 6899 6900 6901 6902 6903
    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)

        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("}")

        code.putln("%s = __pyx_format_from_typeinfo(&%s);" %
                                                (format_temp, type_info))
        code.putln('%s = Py_BuildValue("(%s)", %s);' % (shapes_temp,
                                                        "n" * len(shapes),
                                                        ", ".join(shapes)))

        err = "!%s || !%s || !PyBytes_Check(%s)" % (format_temp, shapes_temp,
                                                    format_temp)
        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), '
6904
                            '(char *) "%s", (char *) %s);' % tup)
6905 6906 6907 6908 6909 6910 6911 6912 6913 6914 6915
        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)


6916
class SizeofNode(ExprNode):
William Stein's avatar
William Stein committed
6917
    #  Abstract base class for sizeof(x) expression nodes.
6918

6919
    type = PyrexTypes.c_size_t_type
William Stein's avatar
William Stein committed
6920 6921

    def check_const(self):
6922
        return True
William Stein's avatar
William Stein committed
6923 6924 6925 6926 6927 6928 6929 6930 6931 6932

    def generate_result_code(self, code):
        pass


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

William Stein's avatar
William Stein committed
6934
    subexprs = []
6935
    arg_type = None
6936

William Stein's avatar
William Stein committed
6937
    def analyse_types(self, env):
6938 6939
        # 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
6940
        if 0 and self.base_type.module_path:
6941 6942 6943 6944 6945 6946 6947 6948 6949 6950 6951
            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
6952 6953 6954 6955
        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
6956
        self.check_type()
6957

6958 6959
    def check_type(self):
        arg_type = self.arg_type
6960
        if arg_type.is_pyobject and not arg_type.is_extension_type:
William Stein's avatar
William Stein committed
6961 6962 6963 6964 6965
            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)
6966

William Stein's avatar
William Stein committed
6967
    def calculate_result_code(self):
6968 6969 6970 6971 6972 6973
        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
6974
        return "(sizeof(%s))" % arg_code
6975

William Stein's avatar
William Stein committed
6976 6977 6978 6979 6980

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

William Stein's avatar
William Stein committed
6982
    subexprs = ['operand']
6983

William Stein's avatar
William Stein committed
6984
    def analyse_types(self, env):
6985 6986 6987 6988 6989 6990 6991 6992 6993
        # 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
            self.__class__ = SizeofTypeNode
            self.check_type()
        else:
            self.operand.analyse_types(env)
6994

William Stein's avatar
William Stein committed
6995
    def calculate_result_code(self):
6996
        return "(sizeof(%s))" % self.operand.result()
6997

William Stein's avatar
William Stein committed
6998 6999 7000
    def generate_result_code(self, code):
        pass

Robert Bradshaw's avatar
Robert Bradshaw committed
7001
class TypeofNode(ExprNode):
7002 7003 7004
    #  Compile-time type of an expression, as a string.
    #
    #  operand   ExprNode
Robert Bradshaw's avatar
Robert Bradshaw committed
7005
    #  literal   StringNode # internal
7006

Robert Bradshaw's avatar
Robert Bradshaw committed
7007 7008
    literal = None
    type = py_object_type
7009

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

7012 7013
    def analyse_types(self, env):
        self.operand.analyse_types(env)
7014
        value = StringEncoding.EncodedString(str(self.operand.type)) #self.operand.type.typeof_name())
7015
        self.literal = StringNode(self.pos, value=value)
Robert Bradshaw's avatar
Robert Bradshaw committed
7016 7017
        self.literal.analyse_types(env)
        self.literal = self.literal.coerce_to_pyobject(env)
7018 7019 7020 7021

    def may_be_none(self):
        return False

7022
    def generate_evaluation_code(self, code):
Robert Bradshaw's avatar
Robert Bradshaw committed
7023
        self.literal.generate_evaluation_code(code)
7024

Robert Bradshaw's avatar
Robert Bradshaw committed
7025 7026
    def calculate_result_code(self):
        return self.literal.calculate_result_code()
William Stein's avatar
William Stein committed
7027 7028 7029 7030 7031 7032 7033

#-------------------------------------------------------------------
#
#  Binary operator nodes
#
#-------------------------------------------------------------------

Stefan Behnel's avatar
Stefan Behnel committed
7034 7035 7036
def _not_in(x, seq):
    return x not in seq

7037 7038 7039
compile_time_binary_operators = {
    '<': operator.lt,
    '<=': operator.le,
7040
    '==': operator.eq,
7041 7042 7043 7044 7045 7046 7047
    '!=': operator.ne,
    '>=': operator.ge,
    '>': operator.gt,
    'is': operator.is_,
    'is_not': operator.is_not,
    '+': operator.add,
    '&': operator.and_,
7048
    '/': operator.truediv,
7049 7050 7051 7052 7053 7054 7055 7056 7057
    '//': 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
7058 7059
    'in': operator.contains,
    'not_in': _not_in,
7060 7061 7062 7063 7064 7065 7066
}

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"
7067
                % node.operator)
7068 7069
    return func

7070
class BinopNode(ExprNode):
William Stein's avatar
William Stein committed
7071 7072 7073 7074 7075 7076 7077 7078 7079 7080 7081
    #  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.
7082

William Stein's avatar
William Stein committed
7083
    subexprs = ['operand1', 'operand2']
7084
    inplace = False
7085 7086 7087 7088 7089 7090 7091

    def calculate_constant_result(self):
        func = compile_time_binary_operators[self.operator]
        self.constant_result = func(
            self.operand1.constant_result,
            self.operand2.constant_result)

7092 7093 7094 7095 7096 7097 7098 7099
    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)
7100

7101 7102
    def infer_type(self, env):
        return self.result_type(self.operand1.infer_type(env),
Robert Bradshaw's avatar
Robert Bradshaw committed
7103
                                self.operand2.infer_type(env))
7104

William Stein's avatar
William Stein committed
7105 7106 7107
    def analyse_types(self, env):
        self.operand1.analyse_types(env)
        self.operand2.analyse_types(env)
Robert Bradshaw's avatar
Robert Bradshaw committed
7108
        self.analyse_operation(env)
7109

Robert Bradshaw's avatar
Robert Bradshaw committed
7110
    def analyse_operation(self, env):
William Stein's avatar
William Stein committed
7111 7112
        if self.is_py_operation():
            self.coerce_operands_to_pyobjects(env)
7113 7114 7115
            self.type = self.result_type(self.operand1.type,
                                         self.operand2.type)
            assert self.type.is_pyobject
William Stein's avatar
William Stein committed
7116
            self.is_temp = 1
DaniloFreitas's avatar
DaniloFreitas committed
7117 7118
        elif self.is_cpp_operation():
            self.analyse_cpp_operation(env)
William Stein's avatar
William Stein committed
7119 7120
        else:
            self.analyse_c_operation(env)
7121

William Stein's avatar
William Stein committed
7122
    def is_py_operation(self):
7123
        return self.is_py_operation_types(self.operand1.type, self.operand2.type)
7124

7125 7126 7127
    def is_py_operation_types(self, type1, type2):
        return type1.is_pyobject or type2.is_pyobject

DaniloFreitas's avatar
DaniloFreitas committed
7128
    def is_cpp_operation(self):
Robert Bradshaw's avatar
Robert Bradshaw committed
7129 7130
        return (self.operand1.type.is_cpp_class
            or self.operand2.type.is_cpp_class)
7131

7132 7133 7134 7135 7136 7137 7138 7139 7140 7141 7142 7143 7144 7145 7146 7147
    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
7148

7149 7150
    def result_type(self, type1, type2):
        if self.is_py_operation_types(type1, type2):
7151 7152 7153 7154 7155 7156 7157 7158 7159 7160 7161 7162 7163 7164 7165 7166 7167 7168
            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
7169
                    if type2.is_int:
7170
                        return type1
7171 7172 7173 7174
            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
7175 7176 7177
            return py_object_type
        else:
            return self.compute_c_result_type(type1, type2)
7178

7179
    def nogil_check(self, env):
7180
        if self.is_py_operation():
7181
            self.gil_error()
7182

William Stein's avatar
William Stein committed
7183 7184 7185
    def coerce_operands_to_pyobjects(self, env):
        self.operand1 = self.operand1.coerce_to_pyobject(env)
        self.operand2 = self.operand2.coerce_to_pyobject(env)
7186

William Stein's avatar
William Stein committed
7187
    def check_const(self):
7188
        return self.operand1.check_const() and self.operand2.check_const()
7189

William Stein's avatar
William Stein committed
7190 7191 7192 7193
    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()
7194
            if self.operator == '**':
William Stein's avatar
William Stein committed
7195 7196 7197 7198
                extra_args = ", Py_None"
            else:
                extra_args = ""
            code.putln(
Robert Bradshaw's avatar
Robert Bradshaw committed
7199
                "%s = %s(%s, %s%s); %s" % (
7200 7201
                    self.result(),
                    function,
William Stein's avatar
William Stein committed
7202 7203 7204
                    self.operand1.py_result(),
                    self.operand2.py_result(),
                    extra_args,
7205
                    code.error_goto_if_null(self.result(), self.pos)))
7206
            code.put_gotref(self.py_result())
7207

William Stein's avatar
William Stein committed
7208 7209 7210 7211
    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)" %
7212
                (self.operator, self.operand1.type,
William Stein's avatar
William Stein committed
7213 7214 7215 7216
                    self.operand2.type))
        self.type = PyrexTypes.error_type


Robert Bradshaw's avatar
Robert Bradshaw committed
7217
class CBinopNode(BinopNode):
7218

Robert Bradshaw's avatar
Robert Bradshaw committed
7219 7220 7221 7222
    def analyse_types(self, env):
        BinopNode.analyse_types(self, env)
        if self.is_py_operation():
            self.type = PyrexTypes.error_type
7223

Robert Bradshaw's avatar
Robert Bradshaw committed
7224 7225
    def py_operation_function():
        return ""
7226

Robert Bradshaw's avatar
Robert Bradshaw committed
7227 7228
    def calculate_result_code(self):
        return "(%s %s %s)" % (
7229 7230
            self.operand1.result(),
            self.operator,
Robert Bradshaw's avatar
Robert Bradshaw committed
7231 7232 7233 7234 7235 7236 7237 7238
            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
7239 7240
class NumBinopNode(BinopNode):
    #  Binary operation taking numeric arguments.
7241

Robert Bradshaw's avatar
Robert Bradshaw committed
7242
    infix = True
7243

William Stein's avatar
William Stein committed
7244 7245 7246 7247 7248 7249
    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()
7250
            return
7251
        if self.type.is_complex:
Robert Bradshaw's avatar
Robert Bradshaw committed
7252
            self.infix = False
7253
        if not self.infix or (type1.is_numeric and type2.is_numeric):
7254 7255
            self.operand1 = self.operand1.coerce_to(self.type, env)
            self.operand2 = self.operand2.coerce_to(self.type, env)
7256

William Stein's avatar
William Stein committed
7257 7258
    def compute_c_result_type(self, type1, type2):
        if self.c_types_okay(type1, type2):
7259 7260 7261 7262 7263
            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
7264 7265 7266
            else:
                widest_type = PyrexTypes.widest_numeric_type(
                    widest_type, PyrexTypes.c_int_type)
7267
            return widest_type
William Stein's avatar
William Stein committed
7268 7269
        else:
            return None
7270

7271 7272 7273 7274 7275 7276 7277 7278 7279 7280
    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()

7281 7282 7283 7284 7285 7286 7287
    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
7288

William Stein's avatar
William Stein committed
7289
    def c_types_okay(self, type1, type2):
7290 7291 7292
        #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
7293 7294

    def calculate_result_code(self):
7295 7296
        if self.infix:
            return "(%s %s %s)" % (
7297 7298
                self.operand1.result(),
                self.operator,
7299 7300
                self.operand2.result())
        else:
7301 7302 7303
            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))
7304
            return "%s(%s, %s)" % (
7305
                func,
7306 7307
                self.operand1.result(),
                self.operand2.result())
7308

7309
    def is_py_operation_types(self, type1, type2):
Stefan Behnel's avatar
Stefan Behnel committed
7310 7311
        return (type1.is_unicode_char or
                type2.is_unicode_char or
7312
                BinopNode.is_py_operation_types(self, type1, type2))
7313

William Stein's avatar
William Stein committed
7314
    def py_operation_function(self):
7315 7316 7317 7318
        fuction = self.py_functions[self.operator]
        if self.inplace:
            fuction = fuction.replace('PyNumber_', 'PyNumber_InPlace')
        return fuction
William Stein's avatar
William Stein committed
7319 7320

    py_functions = {
Robert Bradshaw's avatar
Robert Bradshaw committed
7321 7322 7323
        "|":        "PyNumber_Or",
        "^":        "PyNumber_Xor",
        "&":        "PyNumber_And",
7324 7325
        "<<":       "PyNumber_Lshift",
        ">>":       "PyNumber_Rshift",
Robert Bradshaw's avatar
Robert Bradshaw committed
7326 7327 7328 7329
        "+":        "PyNumber_Add",
        "-":        "PyNumber_Subtract",
        "*":        "PyNumber_Multiply",
        "/":        "__Pyx_PyNumber_Divide",
7330
        "//":       "PyNumber_FloorDivide",
Robert Bradshaw's avatar
Robert Bradshaw committed
7331
        "%":        "PyNumber_Remainder",
7332
        "**":       "PyNumber_Power"
William Stein's avatar
William Stein committed
7333 7334 7335 7336
    }

class IntBinopNode(NumBinopNode):
    #  Binary operation taking integer arguments.
7337

William Stein's avatar
William Stein committed
7338
    def c_types_okay(self, type1, type2):
7339 7340 7341
        #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
7342

7343

William Stein's avatar
William Stein committed
7344 7345
class AddNode(NumBinopNode):
    #  '+' operator.
7346

7347 7348 7349
    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
7350
        else:
7351
            return NumBinopNode.is_py_operation_types(self, type1, type2)
William Stein's avatar
William Stein committed
7352 7353

    def compute_c_result_type(self, type1, type2):
7354 7355
        #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
7356
            return type1
7357
        elif (type2.is_ptr or type2.is_array) and (type1.is_int or type1.is_enum):
William Stein's avatar
William Stein committed
7358 7359 7360 7361 7362 7363 7364 7365
            return type2
        else:
            return NumBinopNode.compute_c_result_type(
                self, type1, type2)


class SubNode(NumBinopNode):
    #  '-' operator.
7366

William Stein's avatar
William Stein committed
7367
    def compute_c_result_type(self, type1, type2):
7368
        if (type1.is_ptr or type1.is_array) and (type2.is_int or type2.is_enum):
William Stein's avatar
William Stein committed
7369
            return type1
7370
        elif (type1.is_ptr or type1.is_array) and (type2.is_ptr or type2.is_array):
William Stein's avatar
William Stein committed
7371 7372 7373 7374 7375 7376 7377 7378
            return PyrexTypes.c_int_type
        else:
            return NumBinopNode.compute_c_result_type(
                self, type1, type2)


class MulNode(NumBinopNode):
    #  '*' operator.
7379

7380
    def is_py_operation_types(self, type1, type2):
William Stein's avatar
William Stein committed
7381 7382 7383 7384
        if (type1.is_string and type2.is_int) \
            or (type2.is_string and type1.is_int):
                return 1
        else:
7385
            return NumBinopNode.is_py_operation_types(self, type1, type2)
William Stein's avatar
William Stein committed
7386 7387


7388 7389
class DivNode(NumBinopNode):
    #  '/' or '//' operator.
7390

7391
    cdivision = None
7392 7393
    truedivision = None   # == "unknown" if operator == '/'
    ctruedivision = False
Robert Bradshaw's avatar
Robert Bradshaw committed
7394
    cdivision_warnings = False
7395
    zerodivision_check = None
7396 7397 7398 7399 7400 7401 7402 7403 7404 7405 7406 7407 7408 7409 7410 7411 7412 7413 7414 7415 7416 7417

    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
7418
                operand1, operand2)
7419 7420 7421 7422
            return func(operand1, operand2)
        except Exception, e:
            self.compile_time_value_error(e)

Robert Bradshaw's avatar
Robert Bradshaw committed
7423
    def analyse_operation(self, env):
7424 7425 7426 7427
        if self.cdivision or env.directives['cdivision']:
            self.ctruedivision = False
        else:
            self.ctruedivision = self.truedivision
Robert Bradshaw's avatar
Robert Bradshaw committed
7428
        NumBinopNode.analyse_operation(self, env)
7429 7430
        if self.is_cpp_operation():
            self.cdivision = True
7431
        if not self.type.is_pyobject:
7432 7433
            self.zerodivision_check = (
                self.cdivision is None and not env.directives['cdivision']
7434
                and (not self.operand2.has_constant_result() or
7435
                     self.operand2.constant_result == 0))
7436 7437 7438 7439
            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)
7440 7441
                if env.nogil:
                    error(self.pos, "Pythonic division not allowed without gil, consider using cython.cdivision(True)")
7442 7443 7444 7445 7446 7447 7448 7449 7450

    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)

7451 7452 7453 7454 7455
    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
7456

7457
    def generate_evaluation_code(self, code):
7458
        if not self.type.is_pyobject and not self.type.is_complex:
7459
            if self.cdivision is None:
7460
                self.cdivision = (code.globalstate.directives['cdivision']
7461 7462 7463
                                    or not self.type.signed
                                    or self.type.is_float)
            if not self.cdivision:
7464
                code.globalstate.use_utility_code(div_int_utility_code.specialize(self.type))
7465
        NumBinopNode.generate_evaluation_code(self, code)
7466
        self.generate_div_warning_code(code)
7467

7468
    def generate_div_warning_code(self, code):
7469 7470
        if not self.type.is_pyobject:
            if self.zerodivision_check:
7471 7472 7473 7474 7475
                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)
7476 7477 7478
                code.putln('PyErr_Format(PyExc_ZeroDivisionError, "%s");' % self.zero_division_message())
                code.putln(code.error_goto(self.pos))
                code.putln("}")
7479 7480 7481
                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))) {" % (
7482
                                    self.type.declaration_code(''),
7483 7484 7485 7486 7487
                                    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
7488
            if code.globalstate.directives['cdivision_warnings'] and self.operator != '/':
7489 7490 7491 7492 7493
                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));
7494 7495 7496 7497 7498 7499
                code.put("if (__Pyx_cdivision_warning(%(FILENAME)s, "
                                                     "%(LINENO)s)) " % {
                    'FILENAME': Naming.filename_cname,
                    'LINENO':  Naming.lineno_cname,
                    })

7500 7501
                code.put_goto(code.error_label)
                code.putln("}")
7502

Robert Bradshaw's avatar
Robert Bradshaw committed
7503
    def calculate_result_code(self):
7504 7505 7506
        if self.type.is_complex:
            return NumBinopNode.calculate_result_code(self)
        elif self.type.is_float and self.operator == '//':
7507
            return "floor(%s / %s)" % (
7508
                self.operand1.result(),
7509
                self.operand2.result())
7510 7511 7512 7513 7514 7515 7516 7517 7518
        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)
7519 7520
        else:
            return "__Pyx_div_%s(%s, %s)" % (
Craig Citro's avatar
Craig Citro committed
7521
                    self.type.specialization_name(),
7522
                    self.operand1.result(),
7523
                    self.operand2.result())
Robert Bradshaw's avatar
Robert Bradshaw committed
7524 7525


Robert Bradshaw's avatar
Robert Bradshaw committed
7526
class ModNode(DivNode):
William Stein's avatar
William Stein committed
7527
    #  '%' operator.
7528

7529 7530 7531 7532
    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
7533

7534 7535 7536 7537 7538
    def zero_division_message(self):
        if self.type.is_int:
            return "integer division or modulo by zero"
        else:
            return "float divmod()"
7539

7540
    def generate_evaluation_code(self, code):
7541 7542 7543 7544 7545
        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:
7546
                    code.globalstate.use_utility_code(mod_int_utility_code.specialize(self.type))
7547
                else:
7548 7549
                    code.globalstate.use_utility_code(
                        mod_float_utility_code.specialize(self.type, math_h_modifier=self.type.math_h_modifier))
7550
        NumBinopNode.generate_evaluation_code(self, code)
7551
        self.generate_div_warning_code(code)
7552

Robert Bradshaw's avatar
Robert Bradshaw committed
7553
    def calculate_result_code(self):
7554 7555 7556 7557
        if self.cdivision:
            if self.type.is_float:
                return "fmod%s(%s, %s)" % (
                    self.type.math_h_modifier,
7558
                    self.operand1.result(),
7559 7560 7561
                    self.operand2.result())
            else:
                return "(%s %% %s)" % (
7562
                    self.operand1.result(),
7563
                    self.operand2.result())
Robert Bradshaw's avatar
Robert Bradshaw committed
7564
        else:
7565
            return "__Pyx_mod_%s(%s, %s)" % (
Craig Citro's avatar
Craig Citro committed
7566
                    self.type.specialization_name(),
7567
                    self.operand1.result(),
7568
                    self.operand2.result())
William Stein's avatar
William Stein committed
7569 7570 7571

class PowNode(NumBinopNode):
    #  '**' operator.
7572

Robert Bradshaw's avatar
Robert Bradshaw committed
7573 7574
    def analyse_c_operation(self, env):
        NumBinopNode.analyse_c_operation(self, env)
7575
        if self.type.is_complex:
Robert Bradshaw's avatar
Robert Bradshaw committed
7576 7577 7578 7579 7580 7581 7582
            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>"
7583
        elif self.type.is_float:
7584
            self.pow_func = "pow" + self.type.math_h_modifier
William Stein's avatar
William Stein committed
7585
        else:
Robert Bradshaw's avatar
Robert Bradshaw committed
7586 7587
            self.pow_func = "__Pyx_pow_%s" % self.type.declaration_code('').replace(' ', '_')
            env.use_utility_code(
7588
                    int_pow_utility_code.specialize(func_name=self.pow_func,
Robert Bradshaw's avatar
Robert Bradshaw committed
7589
                                                type=self.type.declaration_code('')))
7590

William Stein's avatar
William Stein committed
7591
    def calculate_result_code(self):
7592 7593 7594 7595 7596 7597
        # 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
7598
        return "%s(%s, %s)" % (
7599 7600
            self.pow_func,
            typecast(self.operand1),
7601
            typecast(self.operand2))
7602

William Stein's avatar
William Stein committed
7603

Craig Citro's avatar
Craig Citro committed
7604
# Note: This class is temporarily "shut down" into an ineffective temp
7605 7606
# allocation mode.
#
Craig Citro's avatar
Craig Citro committed
7607 7608 7609
# 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).
7610
class BoolBinopNode(ExprNode):
William Stein's avatar
William Stein committed
7611 7612 7613 7614 7615
    #  Short-circuiting boolean operation.
    #
    #  operator     string
    #  operand1     ExprNode
    #  operand2     ExprNode
7616

7617
    subexprs = ['operand1', 'operand2']
7618

7619
    def infer_type(self, env):
7620 7621
        type1 = self.operand1.infer_type(env)
        type2 = self.operand2.infer_type(env)
7622
        return PyrexTypes.independent_spanning_type(type1, type2)
7623

Stefan Behnel's avatar
Stefan Behnel committed
7624 7625 7626 7627 7628 7629
    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()

7630 7631 7632 7633 7634 7635 7636 7637 7638
    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
7639

7640 7641 7642 7643 7644 7645 7646
    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)
7647

7648
    def coerce_to_boolean(self, env):
7649 7650 7651 7652 7653 7654 7655
        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)
7656

William Stein's avatar
William Stein committed
7657 7658 7659
    def analyse_types(self, env):
        self.operand1.analyse_types(env)
        self.operand2.analyse_types(env)
7660
        self.type = PyrexTypes.independent_spanning_type(self.operand1.type, self.operand2.type)
7661 7662
        self.operand1 = self.operand1.coerce_to(self.type, env)
        self.operand2 = self.operand2.coerce_to(self.type, env)
7663

William Stein's avatar
William Stein committed
7664 7665
        # For what we're about to do, it's vital that
        # both operands be temp nodes.
7666 7667
        self.operand1 = self.operand1.coerce_to_simple(env)
        self.operand2 = self.operand2.coerce_to_simple(env)
William Stein's avatar
William Stein committed
7668
        self.is_temp = 1
7669 7670 7671

    gil_message = "Truth-testing Python object"

William Stein's avatar
William Stein committed
7672
    def check_const(self):
7673
        return self.operand1.check_const() and self.operand2.check_const()
7674

William Stein's avatar
William Stein committed
7675
    def generate_evaluation_code(self, code):
7676
        code.mark_pos(self.pos)
William Stein's avatar
William Stein committed
7677
        self.operand1.generate_evaluation_code(code)
7678
        test_result, uses_temp = self.generate_operand1_test(code)
William Stein's avatar
William Stein committed
7679 7680 7681 7682 7683 7684 7685 7686
        if self.operator == 'and':
            sense = ""
        else:
            sense = "!"
        code.putln(
            "if (%s%s) {" % (
                sense,
                test_result))
7687 7688
        if uses_temp:
            code.funcstate.release_temp(test_result)
7689
        self.operand1.generate_disposal_code(code)
William Stein's avatar
William Stein committed
7690
        self.operand2.generate_evaluation_code(code)
7691
        self.allocate_temp_result(code)
7692
        self.operand2.make_owned_reference(code)
7693
        code.putln("%s = %s;" % (self.result(), self.operand2.result()))
7694 7695
        self.operand2.generate_post_assignment_code(code)
        self.operand2.free_temps(code)
7696
        code.putln("} else {")
7697
        self.operand1.make_owned_reference(code)
7698
        code.putln("%s = %s;" % (self.result(), self.operand1.result()))
7699 7700
        self.operand1.generate_post_assignment_code(code)
        self.operand1.free_temps(code)
7701
        code.putln("}")
7702

William Stein's avatar
William Stein committed
7703 7704 7705
    def generate_operand1_test(self, code):
        #  Generate code to test the truth of the first operand.
        if self.type.is_pyobject:
7706 7707
            test_result = code.funcstate.allocate_temp(PyrexTypes.c_bint_type,
                                                       manage_ref=False)
William Stein's avatar
William Stein committed
7708
            code.putln(
7709
                "%s = __Pyx_PyObject_IsTrue(%s); %s" % (
William Stein's avatar
William Stein committed
7710 7711
                    test_result,
                    self.operand1.py_result(),
Robert Bradshaw's avatar
Robert Bradshaw committed
7712
                    code.error_goto_if_neg(test_result, self.pos)))
William Stein's avatar
William Stein committed
7713
        else:
7714
            test_result = self.operand1.result()
7715
        return (test_result, self.type.is_pyobject)
William Stein's avatar
William Stein committed
7716 7717


7718
class CondExprNode(ExprNode):
Robert Bradshaw's avatar
Robert Bradshaw committed
7719 7720 7721 7722 7723
    #  Short-circuiting conditional expression.
    #
    #  test        ExprNode
    #  true_val    ExprNode
    #  false_val   ExprNode
7724

7725 7726
    true_val = None
    false_val = None
7727

Robert Bradshaw's avatar
Robert Bradshaw committed
7728
    subexprs = ['test', 'true_val', 'false_val']
7729

Robert Bradshaw's avatar
Robert Bradshaw committed
7730 7731
    def type_dependencies(self, env):
        return self.true_val.type_dependencies(env) + self.false_val.type_dependencies(env)
7732

Robert Bradshaw's avatar
Robert Bradshaw committed
7733
    def infer_type(self, env):
7734 7735
        return PyrexTypes.independent_spanning_type(self.true_val.infer_type(env),
                                                    self.false_val.infer_type(env))
7736 7737 7738 7739 7740 7741 7742

    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
7743 7744 7745 7746 7747
    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)
7748
        self.type = PyrexTypes.independent_spanning_type(self.true_val.type, self.false_val.type)
7749 7750 7751 7752 7753
        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
7754
            self.type_error()
7755

Robert Bradshaw's avatar
Robert Bradshaw committed
7756 7757 7758 7759 7760
    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
7761

Robert Bradshaw's avatar
Robert Bradshaw committed
7762
    def check_const(self):
7763
        return (self.test.check_const()
7764 7765
            and self.true_val.check_const()
            and self.false_val.check_const())
7766

Robert Bradshaw's avatar
Robert Bradshaw committed
7767
    def generate_evaluation_code(self, code):
Dag Sverre Seljebotn's avatar
Dag Sverre Seljebotn committed
7768 7769
        # Because subexprs may not be evaluated we can use a more optimal
        # subexpr allocation strategy than the default, so override evaluation_code.
7770

Dag Sverre Seljebotn's avatar
Dag Sverre Seljebotn committed
7771
        code.mark_pos(self.pos)
7772
        self.allocate_temp_result(code)
Robert Bradshaw's avatar
Robert Bradshaw committed
7773
        self.test.generate_evaluation_code(code)
7774
        code.putln("if (%s) {" % self.test.result() )
Dag Sverre Seljebotn's avatar
Dag Sverre Seljebotn committed
7775
        self.eval_and_get(code, self.true_val)
Robert Bradshaw's avatar
Robert Bradshaw committed
7776
        code.putln("} else {")
Dag Sverre Seljebotn's avatar
Dag Sverre Seljebotn committed
7777
        self.eval_and_get(code, self.false_val)
Robert Bradshaw's avatar
Robert Bradshaw committed
7778 7779
        code.putln("}")
        self.test.generate_disposal_code(code)
7780
        self.test.free_temps(code)
Robert Bradshaw's avatar
Robert Bradshaw committed
7781

Dag Sverre Seljebotn's avatar
Dag Sverre Seljebotn committed
7782 7783 7784 7785 7786 7787 7788
    def eval_and_get(self, code, expr):
        expr.generate_evaluation_code(code)
        expr.make_owned_reference(code)
        code.putln("%s = %s;" % (self.result(), expr.result()))
        expr.generate_post_assignment_code(code)
        expr.free_temps(code)

7789 7790 7791 7792 7793 7794 7795 7796 7797 7798
richcmp_constants = {
    "<" : "Py_LT",
    "<=": "Py_LE",
    "==": "Py_EQ",
    "!=": "Py_NE",
    "<>": "Py_NE",
    ">" : "Py_GT",
    ">=": "Py_GE",
}

7799
class CmpNode(object):
William Stein's avatar
William Stein committed
7800 7801
    #  Mixin class containing code common to PrimaryCmpNodes
    #  and CascadedCmpNodes.
7802 7803 7804

    special_bool_cmp_function = None

Stefan Behnel's avatar
typo  
Stefan Behnel committed
7805
    def infer_type(self, env):
7806 7807
        # TODO: Actually implement this (after merging with -unstable).
        return py_object_type
7808 7809 7810 7811 7812

    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)
7813 7814 7815 7816 7817 7818 7819
        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

7820 7821
    def cascaded_compile_time_value(self, operand1, denv):
        func = get_compile_time_binop(self)
7822
        operand2 = self.operand2.compile_time_value(denv)
7823 7824 7825 7826
        try:
            result = func(operand1, operand2)
        except Exception, e:
            self.compile_time_value_error(e)
7827
            result = None
7828 7829 7830
        if result:
            cascade = self.cascade
            if cascade:
7831
                # FIXME: I bet this must call cascaded_compile_time_value()
7832
                result = result and cascade.cascaded_compile_time_value(operand2, denv)
7833 7834
        return result

7835
    def is_cpp_comparison(self):
Robert Bradshaw's avatar
Robert Bradshaw committed
7836
        return self.operand1.type.is_cpp_class or self.operand2.type.is_cpp_class
7837

7838
    def find_common_int_type(self, env, op, operand1, operand2):
7839 7840 7841 7842 7843 7844
        # 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

7845
        if operand1.is_string_literal and operand1.can_coerce_to_char_literal():
7846
            type1_can_be_int = True
7847
        if operand2.is_string_literal and operand2.can_coerce_to_char_literal():
7848 7849 7850 7851
            type2_can_be_int = True

        if type1.is_int:
            if type2_can_be_int:
7852
                return type1
7853 7854
        elif type2.is_int:
            if type1_can_be_int:
7855
                return type2
7856 7857
        elif type1_can_be_int:
            if type2_can_be_int:
7858
                return PyrexTypes.c_uchar_type
William Stein's avatar
William Stein committed
7859

7860
        return None
7861

7862
    def find_common_type(self, env, op, operand1, common_type=None):
7863
        operand2 = self.operand2
William Stein's avatar
William Stein committed
7864 7865
        type1 = operand1.type
        type2 = operand2.type
7866

7867 7868
        new_common_type = None

Stefan Behnel's avatar
Stefan Behnel committed
7869
        # catch general errors
7870 7871 7872
        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")
7873
            new_common_type = error_type
Stefan Behnel's avatar
Stefan Behnel committed
7874 7875

        # try to use numeric comparisons where possible
7876
        elif type1.is_complex or type2.is_complex:
7877 7878 7879
            if op not in ('==', '!=') \
               and (type1.is_complex or type1.is_numeric) \
               and (type2.is_complex or type2.is_numeric):
7880 7881
                error(self.pos, "complex types are unordered")
                new_common_type = error_type
7882
            elif type1.is_pyobject:
7883 7884 7885
                new_common_type = type1
            elif type2.is_pyobject:
                new_common_type = type2
7886
            else:
7887
                new_common_type = PyrexTypes.widest_numeric_type(type1, type2)
7888 7889
        elif type1.is_numeric and type2.is_numeric:
            new_common_type = PyrexTypes.widest_numeric_type(type1, type2)
7890
        elif common_type is None or not common_type.is_pyobject:
7891
            new_common_type = self.find_common_int_type(env, op, operand1, operand2)
7892 7893

        if new_common_type is None:
Stefan Behnel's avatar
Stefan Behnel committed
7894
            # fall back to generic type compatibility tests
7895
            if type1 == type2:
7896 7897 7898 7899 7900 7901
                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
7902
                        new_common_type = py_object_type
7903 7904 7905 7906
                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
7907 7908 7909
                        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
7910 7911 7912 7913
                else:
                    # one Python type and one non-Python type, not assignable
                    self.invalid_types_error(operand1, op, operand2)
                    new_common_type = error_type
7914 7915 7916 7917
            elif type1.assignable_from(type2):
                new_common_type = type1
            elif type2.assignable_from(type1):
                new_common_type = type2
7918 7919 7920 7921
            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
7922

7923 7924 7925 7926 7927 7928
        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
7929
        # recursively merge types
7930
        if common_type is None or new_common_type.is_error:
7931
            common_type = new_common_type
William Stein's avatar
William Stein committed
7932
        else:
7933 7934 7935
            # 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
7936
            common_type = PyrexTypes.spanning_type(common_type, new_common_type)
7937 7938

        if self.cascade:
7939
            common_type = self.cascade.find_common_type(env, self.operator, operand2, common_type)
7940

7941 7942
        return common_type

7943 7944 7945 7946
    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
7947
    def is_python_comparison(self):
7948 7949 7950 7951 7952
        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
7953

7954 7955 7956 7957 7958 7959
    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)
7960

7961
    def is_python_result(self):
7962
        return ((self.has_python_operands() and
7963
                 self.special_bool_cmp_function is None and
7964
                 self.operator not in ('is', 'is_not', 'in', 'not_in') and
7965 7966
                 not self.is_c_string_contains() and
                 not self.is_ptr_contains())
7967
            or (self.cascade and self.cascade.is_python_result()))
William Stein's avatar
William Stein committed
7968

7969 7970
    def is_c_string_contains(self):
        return self.operator in ('in', 'not_in') and \
7971 7972
               ((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
7973
                (self.operand1.type.is_unicode_char
7974
                 and self.operand2.type is unicode_type))
7975

7976 7977
    def is_ptr_contains(self):
        if self.operator in ('in', 'not_in'):
7978 7979 7980
            container_type = self.operand2.type
            return (container_type.is_ptr or container_type.is_array) \
                and not container_type.is_string
7981

7982 7983 7984 7985 7986 7987 7988 7989
    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:
                    env.use_utility_code(pyunicode_equals_utility_code)
                    self.special_bool_cmp_function = "__Pyx_PyUnicode_Equals"
                    return True
7990 7991 7992 7993 7994 7995 7996 7997
                elif type1 is Builtin.bytes_type or type2 is Builtin.bytes_type:
                    env.use_utility_code(pybytes_equals_utility_code)
                    self.special_bool_cmp_function = "__Pyx_PyBytes_Equals"
                    return True
                elif type1 is Builtin.str_type or type2 is Builtin.str_type:
                    env.use_utility_code(pystr_equals_utility_code)
                    self.special_bool_cmp_function = "__Pyx_PyString_Equals"
                    return True
7998 7999
        return False

8000
    def generate_operation_code(self, code, result_code,
William Stein's avatar
William Stein committed
8001
            operand1, op , operand2):
8002
        if self.type.is_pyobject:
8003 8004 8005
            coerce_result = "__Pyx_PyBool_FromLong"
        else:
            coerce_result = ""
8006
        if 'not' in op:
8007
            negation = "!"
8008
        else:
8009
            negation = ""
8010 8011 8012 8013 8014 8015 8016 8017 8018 8019 8020 8021 8022 8023 8024 8025 8026
        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
8027
            code.globalstate.use_utility_code(contains_utility_code)
8028
            if self.type.is_pyobject:
8029
                coerce_result = "__Pyx_PyBoolOrNull_FromLong"
8030
            if op == 'not_in':
8031
                negation = "__Pyx_NegateNonNeg"
8032
            if operand2.type is dict_type:
8033
                method = "PyDict_Contains"
8034
            else:
8035
                method = "PySequence_Contains"
8036
            if self.type.is_pyobject:
8037 8038 8039 8040 8041 8042 8043 8044 8045 8046 8047
                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,
8048 8049
                    operand2.py_result(),
                    operand1.py_result(),
8050 8051
                    got_ref,
                    error_clause(result_code, self.pos)))
William Stein's avatar
William Stein committed
8052 8053
        elif (operand1.type.is_pyobject
            and op not in ('is', 'is_not')):
8054
                code.putln("%s = PyObject_RichCompare(%s, %s, %s); %s" % (
8055 8056 8057
                        result_code,
                        operand1.py_result(),
                        operand2.py_result(),
8058 8059
                        richcmp_constants[op],
                        code.error_goto_if_null(result_code, self.pos)))
8060
                code.put_gotref(result_code)
8061
        elif operand1.type.is_complex:
8062
            if op == "!=":
8063
                negation = "!"
8064
            else:
8065
                negation = ""
8066
            code.putln("%s = %s(%s%s(%s, %s));" % (
8067
                result_code,
8068 8069
                coerce_result,
                negation,
8070 8071
                operand1.type.unary_op('eq'),
                operand1.result(),
8072
                operand2.result()))
William Stein's avatar
William Stein committed
8073
        else:
8074 8075 8076 8077 8078
            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
8079 8080
            elif type1.is_numeric:
                common_type = PyrexTypes.widest_numeric_type(type1, type2)
8081
            else:
8082 8083 8084
                common_type = type1
            code1 = operand1.result_as(common_type)
            code2 = operand2.result_as(common_type)
8085
            code.putln("%s = %s(%s %s %s);" % (
8086 8087 8088 8089
                result_code,
                coerce_result,
                code1,
                self.c_operator(op),
8090 8091
                code2))

William Stein's avatar
William Stein committed
8092 8093 8094 8095 8096 8097 8098
    def c_operator(self, op):
        if op == 'is':
            return "=="
        elif op == 'is_not':
            return "!="
        else:
            return op
8099

Stefan Behnel's avatar
typo  
Stefan Behnel committed
8100
contains_utility_code = UtilityCode(
8101
proto="""
8102 8103
static CYTHON_INLINE int __Pyx_NegateNonNeg(int b) {
    return unlikely(b < 0) ? b : !b;
Lisandro Dalcin's avatar
Lisandro Dalcin committed
8104
}
8105
static CYTHON_INLINE PyObject* __Pyx_PyBoolOrNull_FromLong(long b) {
8106 8107 8108 8109
    return unlikely(b < 0) ? NULL : __Pyx_PyBool_FromLong(b);
}
""")

8110 8111 8112 8113 8114 8115 8116 8117 8118 8119 8120 8121 8122 8123 8124 8125
char_in_bytes_utility_code = UtilityCode(
proto="""
static CYTHON_INLINE int __Pyx_BytesContains(PyObject* bytes, char character); /*proto*/
""",
impl="""
static CYTHON_INLINE int __Pyx_BytesContains(PyObject* bytes, char character) {
    const Py_ssize_t length = PyBytes_GET_SIZE(bytes);
    char* char_start = PyBytes_AS_STRING(bytes);
    char* pos;
    for (pos=char_start; pos < char_start+length; pos++) {
        if (character == pos[0]) return 1;
    }
    return 0;
}
""")

8126 8127 8128
py_ucs4_in_unicode_utility_code = UtilityCode(
proto="""
static CYTHON_INLINE int __Pyx_UnicodeContainsUCS4(PyObject* unicode, Py_UCS4 character); /*proto*/
8129
static CYTHON_INLINE int __Pyx_PyUnicodeBufferContainsUCS4(Py_UNICODE* buffer, Py_ssize_t length, Py_UCS4 character); /*proto*/
8130
""",
8131
# additionally handles surrogate pairs for Py_UNICODE buffers in 16bit Unicode builds
8132 8133
impl="""
static CYTHON_INLINE int __Pyx_UnicodeContainsUCS4(PyObject* unicode, Py_UCS4 character) {
8134 8135
#ifdef CYTHON_PEP393_ENABLED
    Py_ssize_t i;
8136 8137 8138 8139 8140 8141 8142 8143 8144 8145 8146
    int kind;
    void* udata;
    Py_ssize_t length;
    kind = PyUnicode_KIND(unicode);
    if (likely(kind != PyUnicode_WCHAR_KIND)) {
        udata = PyUnicode_DATA(unicode);
        length = PyUnicode_GET_LENGTH(unicode);
        for (i=0; i < length; i++) {
            if (unlikely(character == PyUnicode_READ(kind, udata, i))) return 1;
        }
        return 0;
8147
    }
8148 8149 8150 8151 8152 8153
#endif
    return __Pyx_PyUnicodeBufferContainsUCS4(
        PyUnicode_AS_UNICODE(unicode),
        PyUnicode_GET_SIZE(unicode),
        character);
}
8154

8155 8156 8157
static CYTHON_INLINE int __Pyx_PyUnicodeBufferContainsUCS4(Py_UNICODE* buffer, Py_ssize_t length, Py_UCS4 character) {
    Py_UNICODE uchar;
    Py_UNICODE* pos;
8158
    #if Py_UNICODE_SIZE == 2
8159
    if (character > 65535) {
8160 8161 8162
        Py_UNICODE high_val, low_val;
        high_val = (Py_UNICODE) (0xD800 | (((character - 0x10000) >> 10) & ((1<<10)-1)));
        low_val  = (Py_UNICODE) (0xDC00 | ( (character - 0x10000)        & ((1<<10)-1)));
8163
        for (pos=buffer; pos < buffer+length-1; pos++) {
8164 8165 8166 8167 8168 8169
            if (unlikely(high_val == pos[0]) & unlikely(low_val == pos[1])) return 1;
        }
        return 0;
    }
    #endif
    uchar = (Py_UNICODE) character;
8170
    for (pos=buffer; pos < buffer+length; pos++) {
8171
        if (unlikely(uchar == pos[0])) return 1;
8172 8173 8174 8175 8176
    }
    return 0;
}
""")

8177 8178 8179 8180 8181 8182
pyunicode_equals_utility_code = UtilityCode(
proto="""
static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals); /*proto*/
""",
impl="""
static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals) {
Stefan Behnel's avatar
Stefan Behnel committed
8183
    if (s1 == s2) {   /* as done by PyObject_RichCompareBool(); also catches the (interned) empty string */
8184 8185
        return (equals == Py_EQ);
    } else if (PyUnicode_CheckExact(s1) & PyUnicode_CheckExact(s2)) {
8186
        #ifdef CYTHON_PEP393_ENABLED
8187
        if ((PyUnicode_READY(s1) < 0) || (PyUnicode_READY(s2) < 0))
8188
            return -1;
8189 8190 8191
        if (PyUnicode_GET_LENGTH(s1) != PyUnicode_GET_LENGTH(s2)) {
            return (equals == Py_NE);
        } else if (PyUnicode_GET_LENGTH(s1) == 1) {
8192 8193 8194
            Py_UCS4 ch1 = PyUnicode_READ_CHAR(s1, 0);
            Py_UCS4 ch2 = PyUnicode_READ_CHAR(s2, 0);
            return (equals == Py_EQ) ? (ch1 == ch2) : (ch1 != ch2);
8195 8196 8197 8198 8199
"""
## currently disabled: may not be safe depending on who created the string
#        } else if (PyUnicode_MAX_CHAR_VALUE(s1) != PyUnicode_MAX_CHAR_VALUE(s2)) {
#            return (equals == Py_NE);
"""\
8200
        #else
8201 8202 8203
        if (PyUnicode_GET_SIZE(s1) != PyUnicode_GET_SIZE(s2)) {
            return (equals == Py_NE);
        } else if (PyUnicode_GET_SIZE(s1) == 1) {
8204 8205 8206
            Py_UNICODE ch1 = PyUnicode_AS_UNICODE(s1)[0];
            Py_UNICODE ch2 = PyUnicode_AS_UNICODE(s2)[0];
            return (equals == Py_EQ) ? (ch1 == ch2) : (ch1 != ch2);
8207
        #endif
8208 8209 8210 8211 8212 8213 8214 8215 8216 8217 8218 8219 8220 8221 8222 8223 8224 8225 8226 8227 8228 8229
        } else {
            int result = PyUnicode_Compare(s1, s2);
            if ((result == -1) && unlikely(PyErr_Occurred()))
                return -1;
            return (equals == Py_EQ) ? (result == 0) : (result != 0);
        }
    } else if ((s1 == Py_None) & PyUnicode_CheckExact(s2)) {
        return (equals == Py_NE);
    } else if ((s2 == Py_None) & PyUnicode_CheckExact(s1)) {
        return (equals == Py_NE);
    } else {
        int result;
        PyObject* py_result = PyObject_RichCompare(s1, s2, equals);
        if (!py_result)
            return -1;
        result = __Pyx_PyObject_IsTrue(py_result);
        Py_DECREF(py_result);
        return result;
    }
}
""")

8230 8231 8232 8233 8234 8235 8236 8237 8238 8239 8240 8241 8242 8243 8244 8245
pybytes_equals_utility_code = UtilityCode(
proto="""
static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals); /*proto*/
""",
impl="""
static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals) {
    if (s1 == s2) {   /* as done by PyObject_RichCompareBool(); also catches the (interned) empty string */
        return (equals == Py_EQ);
    } else if (PyBytes_CheckExact(s1) & PyBytes_CheckExact(s2)) {
        if (PyBytes_GET_SIZE(s1) != PyBytes_GET_SIZE(s2)) {
            return (equals == Py_NE);
        } else if (PyBytes_GET_SIZE(s1) == 1) {
            if (equals == Py_EQ)
                return (PyBytes_AS_STRING(s1)[0] == PyBytes_AS_STRING(s2)[0]);
            else
                return (PyBytes_AS_STRING(s1)[0] != PyBytes_AS_STRING(s2)[0]);
8246
        } else {
Lisandro Dalcin's avatar
Lisandro Dalcin committed
8247
            int result = memcmp(PyBytes_AS_STRING(s1), PyBytes_AS_STRING(s2), (size_t)PyBytes_GET_SIZE(s1));
8248 8249
            return (equals == Py_EQ) ? (result == 0) : (result != 0);
        }
8250 8251 8252 8253
    } else if ((s1 == Py_None) & PyBytes_CheckExact(s2)) {
        return (equals == Py_NE);
    } else if ((s2 == Py_None) & PyBytes_CheckExact(s1)) {
        return (equals == Py_NE);
8254
    } else {
8255 8256 8257 8258 8259 8260 8261 8262 8263
        int result;
        PyObject* py_result = PyObject_RichCompare(s1, s2, equals);
        if (!py_result)
            return -1;
        result = __Pyx_PyObject_IsTrue(py_result);
        Py_DECREF(py_result);
        return result;
    }
}
8264 8265
""",
requires=[Builtin.include_string_h_utility_code])
8266 8267 8268 8269 8270 8271 8272 8273 8274 8275 8276

pystr_equals_utility_code = UtilityCode(
proto="""
#if PY_MAJOR_VERSION >= 3
#define __Pyx_PyString_Equals __Pyx_PyUnicode_Equals
#else
#define __Pyx_PyString_Equals __Pyx_PyBytes_Equals
#endif
""",
requires=[pybytes_equals_utility_code, pyunicode_equals_utility_code])

William Stein's avatar
William Stein committed
8277

8278
class PrimaryCmpNode(ExprNode, CmpNode):
William Stein's avatar
William Stein committed
8279 8280 8281 8282 8283 8284 8285
    #  Non-cascaded comparison or first comparison of
    #  a cascaded sequence.
    #
    #  operator      string
    #  operand1      ExprNode
    #  operand2      ExprNode
    #  cascade       CascadedCmpNode
8286

William Stein's avatar
William Stein committed
8287 8288 8289 8290
    #  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.
8291

Robert Bradshaw's avatar
Robert Bradshaw committed
8292
    child_attrs = ['operand1', 'operand2', 'cascade']
8293

William Stein's avatar
William Stein committed
8294
    cascade = None
8295

Robert Bradshaw's avatar
Robert Bradshaw committed
8296 8297 8298 8299 8300 8301 8302
    def infer_type(self, env):
        # TODO: Actually implement this (after merging with -unstable).
        return py_object_type

    def type_dependencies(self, env):
        return ()

8303
    def calculate_constant_result(self):
8304
        self.calculate_cascaded_constant_result(self.operand1.constant_result)
8305

8306
    def compile_time_value(self, denv):
8307
        operand1 = self.operand1.compile_time_value(denv)
8308 8309
        return self.cascaded_compile_time_value(operand1, denv)

William Stein's avatar
William Stein committed
8310 8311 8312
    def analyse_types(self, env):
        self.operand1.analyse_types(env)
        self.operand2.analyse_types(env)
8313 8314
        if self.is_cpp_comparison():
            self.analyse_cpp_comparison(env)
Robert Bradshaw's avatar
Robert Bradshaw committed
8315 8316 8317
            if self.cascade:
                error(self.pos, "Cascading comparison not yet supported for cpp types.")
            return
William Stein's avatar
William Stein committed
8318
        if self.cascade:
8319 8320
            self.cascade.analyse_types(env)

8321
        if self.operator in ('in', 'not_in'):
8322 8323 8324 8325 8326 8327 8328
            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:
8329
                    env.use_utility_code(py_ucs4_in_unicode_utility_code)
8330 8331 8332 8333 8334 8335
                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)
                    env.use_utility_code(char_in_bytes_utility_code)
Stefan Behnel's avatar
Stefan Behnel committed
8336 8337
                self.operand2 = self.operand2.as_none_safe_node(
                    "argument of type 'NoneType' is not iterable")
8338 8339 8340 8341 8342 8343
            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
8344
            else:
8345 8346
                if self.operand2.type is dict_type:
                    self.operand2 = self.operand2.as_none_safe_node("'NoneType' object is not iterable")
8347 8348
                common_type = py_object_type
                self.is_pycmp = True
8349 8350 8351 8352
        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
8353 8354 8355 8356
        else:
            common_type = self.find_common_type(env, self.operator, self.operand1)
            self.is_pycmp = common_type.is_pyobject

8357
        if common_type is not None and not common_type.is_error:
8358 8359 8360
            if self.operand1.type != common_type:
                self.operand1 = self.operand1.coerce_to(common_type, env)
            self.coerce_operands_to(common_type, env)
8361

William Stein's avatar
William Stein committed
8362 8363 8364
        if self.cascade:
            self.operand2 = self.operand2.coerce_to_simple(env)
            self.cascade.coerce_cascaded_operands_to_temp(env)
8365 8366 8367 8368 8369 8370 8371 8372
        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
8373 8374
        if self.is_pycmp or self.cascade:
            self.is_temp = 1
8375

8376 8377 8378
    def analyse_cpp_comparison(self, env):
        type1 = self.operand1.type
        type2 = self.operand2.type
8379 8380
        entry = env.lookup_operator(self.operator, [self.operand1, self.operand2])
        if entry is None:
8381 8382
            error(self.pos, "Invalid types for '%s' (%s, %s)" %
                (self.operator, type1, type2))
8383 8384 8385
            self.type = PyrexTypes.error_type
            self.result_code = "<error>"
            return
8386 8387 8388 8389 8390
        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)
8391
        else:
8392 8393 8394
            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
8395

William Stein's avatar
William Stein committed
8396 8397 8398
    def has_python_operands(self):
        return (self.operand1.type.is_pyobject
            or self.operand2.type.is_pyobject)
8399

William Stein's avatar
William Stein committed
8400 8401 8402
    def check_const(self):
        if self.cascade:
            self.not_const()
8403 8404 8405
            return False
        else:
            return self.operand1.check_const() and self.operand2.check_const()
William Stein's avatar
William Stein committed
8406 8407

    def calculate_result_code(self):
8408 8409 8410 8411 8412 8413 8414
        if self.operand1.type.is_complex:
            if self.operator == "!=":
                negation = "!"
            else:
                negation = ""
            return "(%s%s(%s, %s))" % (
                negation,
8415 8416
                self.operand1.type.binary_op('=='),
                self.operand1.result(),
8417
                self.operand2.result())
8418
        elif self.is_c_string_contains():
8419
            if self.operand2.type is unicode_type:
8420
                method = "__Pyx_UnicodeContainsUCS4"
8421
            else:
8422
                method = "__Pyx_BytesContains"
8423 8424 8425 8426 8427 8428 8429
            if self.operator == "not_in":
                negation = "!"
            else:
                negation = ""
            return "(%s%s(%s, %s))" % (
                negation,
                method,
8430
                self.operand2.result(),
8431
                self.operand1.result())
8432 8433 8434 8435 8436
        else:
            return "(%s %s %s)" % (
                self.operand1.result(),
                self.c_operator(self.operator),
                self.operand2.result())
8437

William Stein's avatar
William Stein committed
8438 8439 8440 8441
    def generate_evaluation_code(self, code):
        self.operand1.generate_evaluation_code(code)
        self.operand2.generate_evaluation_code(code)
        if self.is_temp:
8442
            self.allocate_temp_result(code)
8443
            self.generate_operation_code(code, self.result(),
William Stein's avatar
William Stein committed
8444 8445 8446
                self.operand1, self.operator, self.operand2)
            if self.cascade:
                self.cascade.generate_evaluation_code(code,
8447
                    self.result(), self.operand2)
William Stein's avatar
William Stein committed
8448
            self.operand1.generate_disposal_code(code)
8449
            self.operand1.free_temps(code)
William Stein's avatar
William Stein committed
8450
            self.operand2.generate_disposal_code(code)
8451
            self.operand2.free_temps(code)
8452

William Stein's avatar
William Stein committed
8453 8454 8455 8456 8457
    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)
8458

8459 8460 8461 8462 8463
    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)
8464

8465 8466 8467 8468 8469
    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
8470 8471 8472


class CascadedCmpNode(Node, CmpNode):
8473 8474 8475
    #  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
8476 8477 8478 8479 8480 8481
    #  with the PrimaryCmpNode at the head of the chain.
    #
    #  operator      string
    #  operand2      ExprNode
    #  cascade       CascadedCmpNode

Robert Bradshaw's avatar
Robert Bradshaw committed
8482 8483
    child_attrs = ['operand2', 'cascade']

William Stein's avatar
William Stein committed
8484
    cascade = None
8485 8486
    constant_result = constant_value_not_set # FIXME: where to calculate this?

Robert Bradshaw's avatar
Robert Bradshaw committed
8487 8488 8489 8490 8491 8492 8493
    def infer_type(self, env):
        # TODO: Actually implement this (after merging with -unstable).
        return py_object_type

    def type_dependencies(self, env):
        return ()

8494 8495 8496 8497
    def has_constant_result(self):
        return self.constant_result is not constant_value_not_set and \
               self.constant_result is not not_a_constant

8498
    def analyse_types(self, env):
William Stein's avatar
William Stein committed
8499 8500
        self.operand2.analyse_types(env)
        if self.cascade:
8501
            self.cascade.analyse_types(env)
8502

William Stein's avatar
William Stein committed
8503 8504
    def has_python_operands(self):
        return self.operand2.type.is_pyobject
8505

William Stein's avatar
William Stein committed
8506 8507
    def coerce_operands_to_pyobjects(self, env):
        self.operand2 = self.operand2.coerce_to_pyobject(env)
8508 8509
        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
8510 8511 8512 8513 8514 8515 8516 8517
        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)
8518

William Stein's avatar
William Stein committed
8519
    def generate_evaluation_code(self, code, result, operand1):
8520 8521
        if self.type.is_pyobject:
            code.putln("if (__Pyx_PyObject_IsTrue(%s)) {" % result)
8522
            code.put_decref(result, self.type)
8523 8524
        else:
            code.putln("if (%s) {" % result)
William Stein's avatar
William Stein committed
8525
        self.operand2.generate_evaluation_code(code)
8526
        self.generate_operation_code(code, result,
William Stein's avatar
William Stein committed
8527 8528 8529 8530 8531 8532
            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)
8533
        self.operand2.free_temps(code)
William Stein's avatar
William Stein committed
8534 8535
        code.putln("}")

8536 8537 8538 8539 8540
    def annotate(self, code):
        self.operand2.annotate(code)
        if self.cascade:
            self.cascade.annotate(code)

William Stein's avatar
William Stein committed
8541 8542

binop_node_classes = {
8543 8544
    "or":       BoolBinopNode,
    "and":      BoolBinopNode,
Robert Bradshaw's avatar
Robert Bradshaw committed
8545 8546 8547
    "|":        IntBinopNode,
    "^":        IntBinopNode,
    "&":        IntBinopNode,
8548 8549
    "<<":       IntBinopNode,
    ">>":       IntBinopNode,
Robert Bradshaw's avatar
Robert Bradshaw committed
8550 8551 8552
    "+":        AddNode,
    "-":        SubNode,
    "*":        MulNode,
8553 8554
    "/":        DivNode,
    "//":       DivNode,
Robert Bradshaw's avatar
Robert Bradshaw committed
8555
    "%":        ModNode,
8556
    "**":       PowNode
William Stein's avatar
William Stein committed
8557 8558
}

8559
def binop_node(pos, operator, operand1, operand2, inplace=False):
8560
    # Construct binop node of appropriate class for
William Stein's avatar
William Stein committed
8561
    # given operator.
8562 8563 8564
    return binop_node_classes[operator](pos,
        operator = operator,
        operand1 = operand1,
8565 8566
        operand2 = operand2,
        inplace = inplace)
William Stein's avatar
William Stein committed
8567 8568 8569 8570 8571 8572 8573 8574 8575 8576 8577 8578

#-------------------------------------------------------------------
#
#  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.
#
#-------------------------------------------------------------------

8579
class CoercionNode(ExprNode):
William Stein's avatar
William Stein committed
8580 8581 8582
    #  Abstract base class for coercion nodes.
    #
    #  arg       ExprNode       node being coerced
8583

William Stein's avatar
William Stein committed
8584
    subexprs = ['arg']
8585
    constant_result = not_a_constant
8586

William Stein's avatar
William Stein committed
8587 8588 8589 8590
    def __init__(self, arg):
        self.pos = arg.pos
        self.arg = arg
        if debug_coercion:
Stefan Behnel's avatar
Stefan Behnel committed
8591
            print("%s Coercing %s" % (self, self.arg))
8592 8593

    def calculate_constant_result(self):
8594 8595
        # constant folding can break type coercion, so this is disabled
        pass
8596

8597 8598 8599 8600 8601
    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
8602

8603
class CoerceToMemViewSliceNode(CoercionNode):
8604 8605

    def __init__(self, arg, dst_type, env):
8606 8607
        assert dst_type.is_memoryviewslice
        assert not arg.type.is_memoryviewslice
8608 8609
        CoercionNode.__init__(self, arg)
        self.type = dst_type
8610
        self.is_temp = 1
8611 8612
        self.env = env
        self.use_managed_ref = True
8613
        self.arg = arg
8614 8615

    def generate_result_code(self, code):
8616 8617 8618 8619 8620
        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()))

8621 8622 8623
        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
8624 8625 8626

class CastNode(CoercionNode):
    #  Wrap a node in a C type cast.
8627

William Stein's avatar
William Stein committed
8628 8629 8630
    def __init__(self, arg, new_type):
        CoercionNode.__init__(self, arg)
        self.type = new_type
Stefan Behnel's avatar
Stefan Behnel committed
8631 8632 8633

    def may_be_none(self):
        return self.arg.may_be_none()
8634

William Stein's avatar
William Stein committed
8635 8636 8637 8638 8639 8640 8641 8642 8643 8644 8645 8646
    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.

8647
    def __init__(self, arg, dst_type, env, notnone=False):
William Stein's avatar
William Stein committed
8648 8649
        #  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
8650
        assert dst_type.is_extension_type or dst_type.is_builtin_type, "PyTypeTest on non extension type"
William Stein's avatar
William Stein committed
8651 8652 8653
        CoercionNode.__init__(self, arg)
        self.type = dst_type
        self.result_ctype = arg.ctype()
8654
        self.notnone = notnone
8655

8656
    nogil_check = Node.gil_error
8657
    gil_message = "Python type test"
8658

8659 8660
    def analyse_types(self, env):
        pass
Stefan Behnel's avatar
Stefan Behnel committed
8661 8662 8663 8664 8665

    def may_be_none(self):
        if self.notnone:
            return False
        return self.arg.may_be_none()
8666

8667 8668 8669
    def is_simple(self):
        return self.arg.is_simple()

William Stein's avatar
William Stein committed
8670 8671
    def result_in_temp(self):
        return self.arg.result_in_temp()
8672

William Stein's avatar
William Stein committed
8673 8674
    def is_ephemeral(self):
        return self.arg.is_ephemeral()
8675 8676 8677 8678 8679

    def calculate_constant_result(self):
        # FIXME
        pass

William Stein's avatar
William Stein committed
8680
    def calculate_result_code(self):
8681
        return self.arg.result()
8682

William Stein's avatar
William Stein committed
8683 8684
    def generate_result_code(self, code):
        if self.type.typeobj_is_available():
8685
            if not self.type.is_builtin_type:
8686
                code.globalstate.use_utility_code(type_test_utility_code)
William Stein's avatar
William Stein committed
8687
            code.putln(
Robert Bradshaw's avatar
Robert Bradshaw committed
8688
                "if (!(%s)) %s" % (
8689
                    self.type.type_test_code(self.arg.py_result(), self.notnone),
William Stein's avatar
William Stein committed
8690 8691 8692 8693
                    code.error_goto(self.pos)))
        else:
            error(self.pos, "Cannot test type of extern C class "
                "without type object name specification")
8694

William Stein's avatar
William Stein committed
8695 8696
    def generate_post_assignment_code(self, code):
        self.arg.generate_post_assignment_code(code)
8697 8698 8699

    def free_temps(self, code):
        self.arg.free_temps(code)
8700 8701 8702 8703 8704 8705 8706


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).

8707 8708
    def __init__(self, arg, exception_type_cname, exception_message,
                 exception_format_args):
8709 8710 8711 8712 8713
        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
8714
        self.exception_format_args = tuple(exception_format_args or ())
8715 8716 8717 8718

    def analyse_types(self, env):
        pass

8719 8720 8721
    def may_be_none(self):
        return False

8722 8723 8724
    def is_simple(self):
        return self.arg.is_simple()

8725 8726 8727 8728 8729
    def result_in_temp(self):
        return self.arg.result_in_temp()

    def calculate_result_code(self):
        return self.arg.result()
8730

8731 8732
    def generate_result_code(self, code):
        code.putln(
8733
            "if (unlikely(%s == Py_None)) {" % self.arg.py_result())
8734 8735 8736 8737 8738 8739 8740 8741 8742 8743 8744 8745 8746 8747
        escape = StringEncoding.escape_byte_string
        if self.exception_format_args:
            code.putln('PyErr_Format(%s, "%s", %s); %s ' % (
                self.exception_type_cname,
                StringEncoding.escape_byte_string(
                    self.exception_message.encode('UTF-8')),
                ', '.join([ '"%s"' % escape(str(arg).encode('UTF-8'))
                            for arg in self.exception_format_args ]),
                code.error_goto(self.pos)))
        else:
            code.putln('PyErr_SetString(%s, "%s"); %s ' % (
                self.exception_type_cname,
                escape(self.exception_message.encode('UTF-8')),
                code.error_goto(self.pos)))
8748 8749 8750 8751 8752 8753 8754 8755
        code.putln("}")

    def generate_post_assignment_code(self, code):
        self.arg.generate_post_assignment_code(code)

    def free_temps(self, code):
        self.arg.free_temps(code)

8756

William Stein's avatar
William Stein committed
8757 8758 8759
class CoerceToPyTypeNode(CoercionNode):
    #  This node is used to convert a C data type
    #  to a Python object.
8760

8761
    type = py_object_type
Robert Bradshaw's avatar
Robert Bradshaw committed
8762
    is_temp = 1
William Stein's avatar
William Stein committed
8763

8764
    def __init__(self, arg, env, type=py_object_type):
8765
        if not arg.type.create_to_py_utility_code(env):
8766 8767 8768 8769 8770 8771 8772
            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)
8773 8774 8775 8776
        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
8777
            elif arg.type.is_unicode_char:
8778 8779 8780 8781 8782 8783
                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
8784

8785 8786 8787 8788
        if arg.type.is_memoryviewslice:
            # Register utility codes at this point
            arg.type.get_to_py_function(env, arg)

8789 8790
        self.env = env

8791
    gil_message = "Converting to Python object"
8792

8793 8794 8795 8796
    def may_be_none(self):
        # FIXME: is this always safe?
        return False

8797
    def coerce_to_boolean(self, env):
8798 8799 8800 8801 8802 8803
        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)
8804

8805 8806 8807 8808 8809 8810
    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)
8811

8812 8813 8814 8815
    def analyse_types(self, env):
        # The arg is always already analysed
        pass

William Stein's avatar
William Stein committed
8816
    def generate_result_code(self, code):
8817
        if self.arg.type.is_memoryviewslice:
8818
            funccall = self.arg.type.get_to_py_function(self.env, self.arg)
8819 8820 8821 8822 8823
        else:
            funccall = "%s(%s)" % (self.arg.type.to_py_function,
                                   self.arg.result())

        code.putln('%s = %s; %s' % (
8824
            self.result(),
8825
            funccall,
8826
            code.error_goto_if_null(self.result(), self.pos)))
8827

8828
        code.put_gotref(self.py_result())
William Stein's avatar
William Stein committed
8829 8830


8831 8832 8833 8834 8835 8836 8837 8838 8839 8840 8841 8842 8843 8844 8845 8846 8847 8848 8849 8850 8851 8852 8853 8854 8855 8856 8857 8858 8859 8860 8861 8862 8863 8864 8865 8866 8867 8868 8869 8870
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
8871 8872 8873 8874 8875 8876 8877 8878
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
8879
        if not result_type.create_from_py_utility_code(env):
William Stein's avatar
William Stein committed
8880
            error(arg.pos,
Craig Citro's avatar
Craig Citro committed
8881
                  "Cannot convert Python object to '%s'" % result_type)
William Stein's avatar
William Stein committed
8882 8883
        if self.type.is_string and self.arg.is_ephemeral():
            error(arg.pos,
Craig Citro's avatar
Craig Citro committed
8884
                  "Obtaining char * from temporary Python value")
8885

8886 8887 8888 8889
    def analyse_types(self, env):
        # The arg is always already analysed
        pass

William Stein's avatar
William Stein committed
8890 8891
    def generate_result_code(self, code):
        function = self.type.from_py_function
8892 8893 8894 8895
        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
8896
        code.putln('%s = %s; %s' % (
8897
            self.result(),
8898
            rhs,
8899
            code.error_goto_if(self.type.error_condition(self.result()), self.pos)))
8900
        if self.type.is_pyobject:
8901
            code.put_gotref(self.py_result())
William Stein's avatar
William Stein committed
8902

8903 8904 8905
    def nogil_check(self, env):
        error(self.pos, "Coercion from Python not allowed without the GIL")

William Stein's avatar
William Stein committed
8906 8907 8908 8909

class CoerceToBooleanNode(CoercionNode):
    #  This node is used when a result needs to be used
    #  in a boolean context.
8910

8911
    type = PyrexTypes.c_bint_type
8912 8913 8914 8915

    _special_builtins = {
        Builtin.list_type    : 'PyList_GET_SIZE',
        Builtin.tuple_type   : 'PyTuple_GET_SIZE',
8916
        Builtin.bytes_type   : 'PyBytes_GET_SIZE',
8917 8918 8919
        Builtin.unicode_type : 'PyUnicode_GET_SIZE',
        }

William Stein's avatar
William Stein committed
8920 8921 8922 8923
    def __init__(self, arg, env):
        CoercionNode.__init__(self, arg)
        if arg.type.is_pyobject:
            self.is_temp = 1
8924

8925
    def nogil_check(self, env):
8926
        if self.arg.type.is_pyobject and self._special_builtins.get(self.arg.type) is None:
8927
            self.gil_error()
8928

8929
    gil_message = "Truth-testing Python object"
8930

William Stein's avatar
William Stein committed
8931 8932 8933
    def check_const(self):
        if self.is_temp:
            self.not_const()
8934 8935
            return False
        return self.arg.check_const()
8936

William Stein's avatar
William Stein committed
8937
    def calculate_result_code(self):
8938
        return "(%s != 0)" % self.arg.result()
William Stein's avatar
William Stein committed
8939 8940

    def generate_result_code(self, code):
8941 8942 8943 8944
        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
8945
            code.putln("%s = (%s != Py_None) && (%s(%s) != 0);" % (
8946 8947 8948 8949 8950
                       self.result(),
                       self.arg.py_result(),
                       test_func,
                       self.arg.py_result()))
        else:
William Stein's avatar
William Stein committed
8951
            code.putln(
8952
                "%s = __Pyx_PyObject_IsTrue(%s); %s" % (
8953 8954
                    self.result(),
                    self.arg.py_result(),
8955
                    code.error_goto_if_neg(self.result(), self.pos)))
William Stein's avatar
William Stein committed
8956

8957 8958 8959 8960 8961 8962 8963 8964 8965 8966 8967
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:
8968 8969
            real_part = "__Pyx_CREAL(%s)" % self.arg.result()
            imag_part = "__Pyx_CIMAG(%s)" % self.arg.result()
8970 8971 8972 8973 8974 8975 8976
        else:
            real_part = self.arg.result()
            imag_part = "0"
        return "%s(%s, %s)" % (
                self.type.from_parts,
                real_part,
                imag_part)
8977

8978 8979
    def generate_result_code(self, code):
        pass
William Stein's avatar
William Stein committed
8980 8981 8982 8983 8984 8985 8986 8987 8988

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
8989
        self.constant_result = self.arg.constant_result
William Stein's avatar
William Stein committed
8990 8991 8992
        self.is_temp = 1
        if self.type.is_pyobject:
            self.result_ctype = py_object_type
8993 8994 8995

    gil_message = "Creating temporary Python reference"

8996 8997 8998
    def analyse_types(self, env):
        # The arg is always already analysed
        pass
8999

9000 9001
    def coerce_to_boolean(self, env):
        self.arg = self.arg.coerce_to_boolean(env)
9002 9003
        if self.arg.is_simple():
            return self.arg
9004 9005 9006
        self.type = self.arg.type
        self.result_ctype = self.type
        return self
9007

William Stein's avatar
William Stein committed
9008 9009 9010 9011
    def generate_result_code(self, code):
        #self.arg.generate_evaluation_code(code) # Already done
        # by generic generate_subexpr_evaluation_code!
        code.putln("%s = %s;" % (
9012
            self.result(), self.arg.result_as(self.ctype())))
9013
        if self.type.is_pyobject and self.use_managed_ref:
9014
            code.put_incref(self.result(), self.ctype())
William Stein's avatar
William Stein committed
9015 9016 9017 9018 9019 9020 9021


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
9022
    #  disposal code for it. The original owner of the argument
William Stein's avatar
William Stein committed
9023
    #  node is responsible for doing those things.
9024

William Stein's avatar
William Stein committed
9025
    subexprs = [] # Arg is not considered a subexpr
9026
    nogil_check = None
9027

William Stein's avatar
William Stein committed
9028 9029
    def __init__(self, arg):
        CoercionNode.__init__(self, arg)
9030 9031 9032 9033 9034
        if hasattr(arg, 'type'):
            self.type = arg.type
            self.result_ctype = arg.result_ctype
        if hasattr(arg, 'entry'):
            self.entry = arg.entry
9035

9036
    def result(self):
9037
        return self.arg.result()
9038

9039 9040 9041
    def may_be_none(self):
        return self.arg.may_be_none()

Robert Bradshaw's avatar
Robert Bradshaw committed
9042 9043
    def type_dependencies(self, env):
        return self.arg.type_dependencies(env)
9044

9045 9046
    def infer_type(self, env):
        return self.arg.infer_type(env)
Robert Bradshaw's avatar
Robert Bradshaw committed
9047

Robert Bradshaw's avatar
Robert Bradshaw committed
9048 9049 9050 9051
    def analyse_types(self, env):
        self.type = self.arg.type
        self.result_ctype = self.arg.result_ctype
        self.is_temp = 1
9052 9053
        if hasattr(self.arg, 'entry'):
            self.entry = self.arg.entry
9054

9055 9056 9057
    def is_simple(self):
        return True # result is always in a temp (or a name)

William Stein's avatar
William Stein committed
9058 9059 9060 9061 9062
    def generate_evaluation_code(self, code):
        pass

    def generate_result_code(self, code):
        pass
9063

9064
    def generate_disposal_code(self, code):
9065
        pass
9066

9067 9068
    def free_temps(self, code):
        pass
9069

9070

Stefan Behnel's avatar
Stefan Behnel committed
9071 9072 9073 9074 9075 9076 9077 9078 9079 9080 9081 9082
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)


9083 9084
class ModuleRefNode(ExprNode):
    # Simple returns the module object
9085

9086 9087 9088
    type = py_object_type
    is_temp = False
    subexprs = []
9089

9090 9091 9092
    def analyse_types(self, env):
        pass

9093 9094 9095
    def may_be_none(self):
        return False

9096 9097 9098 9099 9100 9101 9102 9103
    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
9104

9105 9106 9107
    subexprs = ['body']
    type = py_object_type
    is_temp = True
9108

9109 9110 9111 9112 9113 9114 9115 9116 9117
    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):
9118 9119 9120
        code.putln('%s = __Pyx_GetAttrString(%s, "__doc__"); %s' % (
            self.result(), self.body.result(),
            code.error_goto_if_null(self.result(), self.pos)))
9121 9122 9123 9124
        code.put_gotref(self.result())



William Stein's avatar
William Stein committed
9125 9126 9127 9128 9129 9130
#------------------------------------------------------------------------------------
#
#  Runtime support code
#
#------------------------------------------------------------------------------------

9131 9132
get_name_interned_utility_code = UtilityCode(
proto = """
9133
static PyObject *__Pyx_GetName(PyObject *dict, PyObject *name); /*proto*/
9134 9135
""",
impl = """
William Stein's avatar
William Stein committed
9136 9137 9138
static PyObject *__Pyx_GetName(PyObject *dict, PyObject *name) {
    PyObject *result;
    result = PyObject_GetAttr(dict, name);
9139 9140 9141 9142 9143 9144 9145 9146 9147
    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
9148 9149
    return result;
}
9150
""" % {'BUILTINS' : Naming.builtins_cname})
William Stein's avatar
William Stein committed
9151 9152 9153

#------------------------------------------------------------------------------------

9154 9155
import_utility_code = UtilityCode(
proto = """
Haoyu Bai's avatar
Haoyu Bai committed
9156
static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, long level); /*proto*/
9157 9158
""",
impl = """
Haoyu Bai's avatar
Haoyu Bai committed
9159
static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, long level) {
9160
    PyObject *py_import = 0;
William Stein's avatar
William Stein committed
9161 9162 9163 9164 9165
    PyObject *empty_list = 0;
    PyObject *module = 0;
    PyObject *global_dict = 0;
    PyObject *empty_dict = 0;
    PyObject *list;
9166 9167
    py_import = __Pyx_GetAttrString(%(BUILTINS)s, "__import__");
    if (!py_import)
William Stein's avatar
William Stein committed
9168 9169 9170 9171 9172 9173 9174 9175 9176 9177 9178 9179 9180 9181 9182
        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
9183 9184 9185 9186 9187 9188 9189 9190 9191 9192 9193 9194 9195 9196
    #if PY_VERSION_HEX >= 0x02050000
    {
        PyObject *py_level = PyInt_FromLong(level);
        if (!py_level)
            goto bad;
        module = PyObject_CallFunctionObjArgs(py_import,
            name, global_dict, empty_dict, list, py_level, NULL);
        Py_DECREF(py_level);
    }
    #else
    if (level>0) {
        PyErr_SetString(PyExc_RuntimeError, "Relative import is not supported for Python <=2.4.");
        goto bad;
    }
9197
    module = PyObject_CallFunctionObjArgs(py_import,
9198
        name, global_dict, empty_dict, list, NULL);
Haoyu Bai's avatar
Haoyu Bai committed
9199
    #endif
William Stein's avatar
William Stein committed
9200 9201
bad:
    Py_XDECREF(empty_list);
9202
    Py_XDECREF(py_import);
William Stein's avatar
William Stein committed
9203 9204 9205 9206 9207 9208
    Py_XDECREF(empty_dict);
    return module;
}
""" % {
    "BUILTINS": Naming.builtins_cname,
    "GLOBALS":  Naming.module_cname,
9209
})
William Stein's avatar
William Stein committed
9210 9211 9212

#------------------------------------------------------------------------------------

9213 9214
get_exception_utility_code = UtilityCode(
proto = """
9215
static PyObject *__Pyx_GetExcValue(void); /*proto*/
9216 9217
""",
impl = """
William Stein's avatar
William Stein committed
9218 9219
static PyObject *__Pyx_GetExcValue(void) {
    PyObject *type = 0, *value = 0, *tb = 0;
9220
    PyObject *tmp_type, *tmp_value, *tmp_tb;
William Stein's avatar
William Stein committed
9221 9222 9223 9224 9225 9226 9227 9228 9229 9230
    PyObject *result = 0;
    PyThreadState *tstate = PyThreadState_Get();
    PyErr_Fetch(&type, &value, &tb);
    PyErr_NormalizeException(&type, &value, &tb);
    if (PyErr_Occurred())
        goto bad;
    if (!value) {
        value = Py_None;
        Py_INCREF(value);
    }
9231 9232 9233
    tmp_type = tstate->exc_type;
    tmp_value = tstate->exc_value;
    tmp_tb = tstate->exc_traceback;
William Stein's avatar
William Stein committed
9234 9235 9236
    tstate->exc_type = type;
    tstate->exc_value = value;
    tstate->exc_traceback = tb;
9237 9238 9239 9240 9241
    /* Make sure tstate is in a consistent state when we XDECREF
    these objects (XDECREF may run arbitrary code). */
    Py_XDECREF(tmp_type);
    Py_XDECREF(tmp_value);
    Py_XDECREF(tmp_tb);
William Stein's avatar
William Stein committed
9242 9243 9244 9245 9246 9247 9248 9249 9250 9251 9252
    result = value;
    Py_XINCREF(result);
    type = 0;
    value = 0;
    tb = 0;
bad:
    Py_XDECREF(type);
    Py_XDECREF(value);
    Py_XDECREF(tb);
    return result;
}
9253
""")
William Stein's avatar
William Stein committed
9254 9255 9256

#------------------------------------------------------------------------------------

9257 9258
type_test_utility_code = UtilityCode(
proto = """
9259
static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type); /*proto*/
9260 9261
""",
impl = """
9262
static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type) {
9263
    if (unlikely(!type)) {
William Stein's avatar
William Stein committed
9264 9265 9266
        PyErr_Format(PyExc_SystemError, "Missing type object");
        return 0;
    }
9267
    if (likely(PyObject_TypeCheck(obj, type)))
William Stein's avatar
William Stein committed
9268
        return 1;
9269 9270
    PyErr_Format(PyExc_TypeError, "Cannot convert %.200s to %.200s",
                 Py_TYPE(obj)->tp_name, type->tp_name);
William Stein's avatar
William Stein committed
9271 9272
    return 0;
}
9273
""")
William Stein's avatar
William Stein committed
9274 9275 9276

#------------------------------------------------------------------------------------

9277 9278 9279 9280 9281 9282 9283 9284 9285 9286 9287
find_py2_metaclass_utility_code = UtilityCode(
proto = '''
static PyObject *__Pyx_FindPy2Metaclass(PyObject *bases); /*proto*/
''',
impl = '''
static PyObject *__Pyx_FindPy2Metaclass(PyObject *bases) {
    PyObject *metaclass;
    /* Default metaclass */
#if PY_MAJOR_VERSION < 3
    if (PyTuple_Check(bases) && PyTuple_GET_SIZE(bases) > 0) {
        PyObject *base = PyTuple_GET_ITEM(bases, 0);
9288
        metaclass = PyObject_GetAttrString(base, (char *)"__class__");
9289 9290 9291 9292 9293 9294 9295 9296 9297 9298 9299 9300 9301 9302 9303 9304 9305 9306 9307 9308
        if (!metaclass) {
            PyErr_Clear();
            metaclass = (PyObject*) Py_TYPE(base);
        }
    } else {
        metaclass = (PyObject *) &PyClass_Type;
    }
#else
    if (PyTuple_Check(bases) && PyTuple_GET_SIZE(bases) > 0) {
        PyObject *base = PyTuple_GET_ITEM(bases, 0);
        metaclass = (PyObject*) Py_TYPE(base);
    } else {
        metaclass = (PyObject *) &PyType_Type;
    }
#endif
    Py_INCREF(metaclass);
    return metaclass;
}
''')

9309 9310
create_class_utility_code = UtilityCode(
proto = """
9311
static PyObject *__Pyx_CreateClass(PyObject *bases, PyObject *dict, PyObject *name,
9312 9313 9314 9315 9316
                                   PyObject *modname); /*proto*/
""",
impl = """
static PyObject *__Pyx_CreateClass(PyObject *bases, PyObject *dict, PyObject *name,
                                   PyObject *modname) {
9317 9318
    PyObject *result;
    PyObject *metaclass;
9319 9320 9321 9322 9323 9324

    if (PyDict_SetItemString(dict, "__module__", modname) < 0)
        return NULL;

    /* Python2 __metaclass__ */
    metaclass = PyDict_GetItemString(dict, "__metaclass__");
9325 9326 9327 9328
    if (metaclass) {
        Py_INCREF(metaclass);
    } else {
        metaclass = __Pyx_FindPy2Metaclass(bases);
9329 9330 9331 9332 9333
    }
    result = PyObject_CallFunctionObjArgs(metaclass, name, bases, dict, NULL);
    Py_DECREF(metaclass);
    return result;
}
9334 9335
""",
requires = [find_py2_metaclass_utility_code])
9336 9337 9338 9339 9340

#------------------------------------------------------------------------------------

create_py3class_utility_code = UtilityCode(
proto = """
Stefan Behnel's avatar
Stefan Behnel committed
9341 9342 9343
static PyObject *__Pyx_Py3MetaclassGet(PyObject *bases, PyObject *mkw); /*proto*/
static PyObject *__Pyx_Py3MetaclassPrepare(PyObject *metaclass, PyObject *bases, PyObject *name, PyObject *mkw, PyObject *modname, PyObject *doc); /*proto*/
static PyObject *__Pyx_Py3ClassCreate(PyObject *metaclass, PyObject *name, PyObject *bases, PyObject *dict, PyObject *mkw); /*proto*/
9344 9345
""",
impl = """
Stefan Behnel's avatar
Stefan Behnel committed
9346
PyObject *__Pyx_Py3MetaclassGet(PyObject *bases, PyObject *mkw) {
9347
    PyObject *metaclass = PyDict_GetItemString(mkw, "metaclass");
9348 9349 9350 9351 9352 9353 9354 9355
    if (metaclass) {
        Py_INCREF(metaclass);
        if (PyDict_DelItemString(mkw, "metaclass") < 0) {
            Py_DECREF(metaclass);
            return NULL;
        }
        return metaclass;
    }
9356
    return __Pyx_FindPy2Metaclass(bases);
9357 9358
}

Stefan Behnel's avatar
Stefan Behnel committed
9359 9360
PyObject *__Pyx_Py3MetaclassPrepare(PyObject *metaclass, PyObject *bases, PyObject *name, PyObject *mkw,
                                    PyObject *modname, PyObject *doc) {
9361 9362 9363
    PyObject *prep;
    PyObject *pargs;
    PyObject *ns;
9364
    PyObject *str;
9365

9366
    prep = PyObject_GetAttrString(metaclass, (char *)"__prepare__");
Stefan Behnel's avatar
Stefan Behnel committed
9367
    if (!prep) {
9368
        if (!PyErr_ExceptionMatches(PyExc_AttributeError))
9369
            return NULL;
9370
        PyErr_Clear();
9371
        return PyDict_New();
9372
    }
Stefan Behnel's avatar
Stefan Behnel committed
9373 9374
    pargs = PyTuple_New(2);
    if (!pargs) {
9375
        Py_DECREF(prep);
9376
        return NULL;
9377
    }
9378

Stefan Behnel's avatar
Stefan Behnel committed
9379 9380 9381 9382
    Py_INCREF(name);
    Py_INCREF(bases);
    PyTuple_SET_ITEM(pargs, 0, name);
    PyTuple_SET_ITEM(pargs, 1, bases);
9383

Stefan Behnel's avatar
Stefan Behnel committed
9384
    ns = PyObject_Call(prep, pargs, mkw);
9385

9386
    Py_DECREF(prep);
9387 9388
    Py_DECREF(pargs);

9389
    if (ns == NULL)
9390 9391 9392 9393
        return NULL;

    /* Required here to emulate assignment order */
    /* XXX: use consts here */
Stefan Behnel's avatar
Stefan Behnel committed
9394 9395 9396
    #if PY_MAJOR_VERSION >= 3
    str = PyUnicode_FromString("__module__");
    #else
9397
    str = PyString_FromString("__module__");
Stefan Behnel's avatar
Stefan Behnel committed
9398
    #endif
9399
    if (!str) {
9400
        Py_DECREF(ns);
9401
        return NULL;
9402
    }
Vitja Makarov's avatar
Vitja Makarov committed
9403

9404 9405 9406
    if (PyObject_SetItem(ns, str, modname) < 0) {
        Py_DECREF(ns);
        Py_DECREF(str);
9407
        return NULL;
9408 9409 9410
    }
    Py_DECREF(str);
    if (doc) {
Stefan Behnel's avatar
Stefan Behnel committed
9411 9412 9413
        #if PY_MAJOR_VERSION >= 3
        str = PyUnicode_FromString("__doc__");
        #else
9414
        str = PyString_FromString("__doc__");
Stefan Behnel's avatar
Stefan Behnel committed
9415
        #endif
9416 9417
        if (!str) {
            Py_DECREF(ns);
9418
            return NULL;
Vitja Makarov's avatar
Vitja Makarov committed
9419
        }
9420 9421 9422 9423
        if (PyObject_SetItem(ns, str, doc) < 0) {
            Py_DECREF(ns);
            Py_DECREF(str);
            return NULL;
Stefan Behnel's avatar
Stefan Behnel committed
9424
        }
9425
        Py_DECREF(str);
Vitja Makarov's avatar
Vitja Makarov committed
9426
    }
9427 9428 9429
    return ns;
}

Stefan Behnel's avatar
Stefan Behnel committed
9430
PyObject *__Pyx_Py3ClassCreate(PyObject *metaclass, PyObject *name, PyObject *bases, PyObject *dict, PyObject *mkw) {
9431
    PyObject *result;
9432
    PyObject *margs = PyTuple_New(3);
9433 9434
    if (!margs)
        return NULL;
9435 9436 9437 9438 9439 9440
    Py_INCREF(name);
    Py_INCREF(bases);
    Py_INCREF(dict);
    PyTuple_SET_ITEM(margs, 0, name);
    PyTuple_SET_ITEM(margs, 1, bases);
    PyTuple_SET_ITEM(margs, 2, dict);
Stefan Behnel's avatar
Stefan Behnel committed
9441
    result = PyObject_Call(metaclass, margs, mkw);
9442
    Py_DECREF(margs);
William Stein's avatar
William Stein committed
9443 9444
    return result;
}
9445 9446
""",
requires = [find_py2_metaclass_utility_code])
William Stein's avatar
William Stein committed
9447 9448

#------------------------------------------------------------------------------------
Robert Bradshaw's avatar
Robert Bradshaw committed
9449

9450 9451
cpp_exception_utility_code = UtilityCode(
proto = """
9452 9453
#ifndef __Pyx_CppExn2PyErr
static void __Pyx_CppExn2PyErr() {
9454 9455
  // Catch a handful of different errors here and turn them into the
  // equivalent Python errors.
Robert Bradshaw's avatar
Robert Bradshaw committed
9456 9457 9458 9459 9460
  try {
    if (PyErr_Occurred())
      ; // let the latest Python exn pass through and ignore the current one
    else
      throw;
9461 9462
  } catch (const std::bad_alloc& exn) {
    PyErr_SetString(PyExc_MemoryError, exn.what());
9463 9464
  } catch (const std::bad_cast& exn) {
    PyErr_SetString(PyExc_TypeError, exn.what());
9465 9466
  } catch (const std::domain_error& exn) {
    PyErr_SetString(PyExc_ValueError, exn.what());
9467 9468
  } catch (const std::invalid_argument& exn) {
    PyErr_SetString(PyExc_ValueError, exn.what());
9469 9470 9471 9472
  } 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
9473
  } catch (const std::out_of_range& exn) {
9474
    // Change out_of_range to IndexError
Robert Bradshaw's avatar
Robert Bradshaw committed
9475
    PyErr_SetString(PyExc_IndexError, exn.what());
9476 9477 9478 9479 9480 9481
  } 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
9482 9483 9484 9485 9486 9487 9488 9489
  } catch (const std::exception& exn) {
    PyErr_SetString(PyExc_RuntimeError, exn.what());
  }
  catch (...)
  {
    PyErr_SetString(PyExc_RuntimeError, "Unknown exception");
  }
}
9490
#endif
9491 9492 9493
""",
impl = ""
)
Robert Bradshaw's avatar
Robert Bradshaw committed
9494

9495 9496 9497 9498 9499 9500 9501 9502 9503 9504 9505 9506 9507 9508 9509 9510 9511 9512 9513
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
9514
#------------------------------------------------------------------------------------
Robert Bradshaw's avatar
Robert Bradshaw committed
9515

9516 9517 9518 9519 9520 9521 9522 9523 9524 9525 9526 9527 9528 9529 9530 9531 9532 9533 9534 9535 9536 9537 9538 9539 9540 9541 9542 9543 9544 9545
raise_noneattr_error_utility_code = UtilityCode(
proto = """
static CYTHON_INLINE void __Pyx_RaiseNoneAttributeError(const char* attrname);
""",
impl = '''
static CYTHON_INLINE void __Pyx_RaiseNoneAttributeError(const char* attrname) {
    PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", attrname);
}
''')

raise_noneindex_error_utility_code = UtilityCode(
proto = """
static CYTHON_INLINE void __Pyx_RaiseNoneIndexingError(void);
""",
impl = '''
static CYTHON_INLINE void __Pyx_RaiseNoneIndexingError(void) {
    PyErr_SetString(PyExc_TypeError, "'NoneType' object is unsubscriptable");
}
''')

raise_none_iter_error_utility_code = UtilityCode(
proto = """
static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void);
""",
impl = '''
static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void) {
    PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable");
}
''')

9546 9547 9548 9549 9550 9551 9552 9553 9554 9555 9556 9557 9558 9559 9560 9561 9562 9563 9564 9565
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);
}
""")

9566 9567 9568 9569
#------------------------------------------------------------------------------------

getitem_dict_utility_code = UtilityCode(
proto = """
9570
#if PY_MAJOR_VERSION >= 3
9571
static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key) {
9572
    PyObject *value;
9573
    if (unlikely(d == Py_None)) {
9574 9575 9576
        __Pyx_RaiseNoneIndexingError();
        return NULL;
    }
9577 9578 9579
    value = PyDict_GetItemWithError(d, key);
    if (unlikely(!value)) {
        if (!PyErr_Occurred())
9580
            PyErr_SetObject(PyExc_KeyError, key);
9581
        return NULL;
9582
    }
9583 9584
    Py_INCREF(value);
    return value;
9585
}
9586 9587 9588
#else
    #define __Pyx_PyDict_GetItem(d, key) PyObject_GetItem(d, key)
#endif
9589
""",
9590 9591 9592
requires = [raise_noneindex_error_utility_code])

#------------------------------------------------------------------------------------
Dag Sverre Seljebotn's avatar
Merge  
Dag Sverre Seljebotn committed
9593

9594 9595 9596 9597
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
9598
                                               __Pyx_GetItemInt_Unicode_Generic(o, to_py_func(i)))
9599

9600
static CYTHON_INLINE Py_UCS4 __Pyx_GetItemInt_Unicode_Fast(PyObject* ustring, Py_ssize_t i) {
9601 9602 9603 9604 9605
    const Py_ssize_t length = __Pyx_PyUnicode_GET_LENGTH(ustring);
    if (likely((0 <= i) & (i < length))) {
        return __Pyx_PyUnicode_READ_CHAR(ustring, i);
    } else if ((-length <= i) & (i < 0)) {
        return __Pyx_PyUnicode_READ_CHAR(ustring, i + length);
9606 9607
    } else {
        PyErr_SetString(PyExc_IndexError, "string index out of range");
9608
        return (Py_UCS4)-1;
9609 9610 9611
    }
}

9612 9613
static CYTHON_INLINE Py_UCS4 __Pyx_GetItemInt_Unicode_Generic(PyObject* ustring, PyObject* j) {
    Py_UCS4 uchar;
9614
    PyObject *uchar_string;
9615
    if (!j) return (Py_UCS4)-1;
9616
    uchar_string = PyObject_GetItem(ustring, j);
9617
    Py_DECREF(j);
9618
    if (!uchar_string) return (Py_UCS4)-1;
9619
    uchar = __Pyx_PyUnicode_READ_CHAR(uchar_string, 0);
9620
    Py_DECREF(uchar_string);
9621 9622
    return uchar;
}
9623
''')
9624

9625 9626
getitem_int_utility_code = UtilityCode(
proto = """
9627

9628
static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j) {
9629
    PyObject *r;
9630
    if (!j) return NULL;
9631 9632 9633 9634
    r = PyObject_GetItem(o, j);
    Py_DECREF(j);
    return r;
}
9635

9636 9637
""" + ''.join([
"""
9638 9639
#define __Pyx_GetItemInt_%(type)s(o, i, size, to_py_func) (((size) <= sizeof(Py_ssize_t)) ? \\
                                                    __Pyx_GetItemInt_%(type)s_Fast(o, i) : \\
9640 9641
                                                    __Pyx_GetItemInt_Generic(o, to_py_func(i)))

9642
static CYTHON_INLINE PyObject *__Pyx_GetItemInt_%(type)s_Fast(PyObject *o, Py_ssize_t i) {
9643 9644 9645 9646 9647 9648
    if (likely(o != Py_None)) {
        if (likely((0 <= i) & (i < Py%(type)s_GET_SIZE(o)))) {
            PyObject *r = Py%(type)s_GET_ITEM(o, i);
            Py_INCREF(r);
            return r;
        }
9649 9650
        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);
9651 9652 9653
            Py_INCREF(r);
            return r;
        }
9654
    }
9655
    return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i));
9656
}
9657 9658
""" % {'type' : type_name} for type_name in ('List', 'Tuple')
]) + """
9659

9660 9661
#define __Pyx_GetItemInt(o, i, size, to_py_func) (((size) <= sizeof(Py_ssize_t)) ? \\
                                                    __Pyx_GetItemInt_Fast(o, i) : \\
9662 9663
                                                    __Pyx_GetItemInt_Generic(o, to_py_func(i)))

9664
static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i) {
9665 9666 9667 9668 9669 9670 9671
    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
9672
    }
9673 9674 9675 9676 9677 9678 9679
    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;
        }
9680
    }
9681 9682 9683 9684 9685
    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
9686
    }
9687
    return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i));
Dag Sverre Seljebotn's avatar
Merge  
Dag Sverre Seljebotn committed
9688 9689
}
""",
9690 9691
impl = """
""")
Dag Sverre Seljebotn's avatar
Merge  
Dag Sverre Seljebotn committed
9692

9693 9694


Dag Sverre Seljebotn's avatar
Merge  
Dag Sverre Seljebotn committed
9695 9696
#------------------------------------------------------------------------------------

9697 9698
setitem_int_utility_code = UtilityCode(
proto = """
9699 9700
#define __Pyx_SetItemInt(o, i, v, size, to_py_func) (((size) <= sizeof(Py_ssize_t)) ? \\
                                                    __Pyx_SetItemInt_Fast(o, i, v) : \\
9701 9702
                                                    __Pyx_SetItemInt_Generic(o, to_py_func(i), v))

9703
static CYTHON_INLINE int __Pyx_SetItemInt_Generic(PyObject *o, PyObject *j, PyObject *v) {
Dag Sverre Seljebotn's avatar
Merge  
Dag Sverre Seljebotn committed
9704
    int r;
9705 9706 9707 9708 9709 9710
    if (!j) return -1;
    r = PyObject_SetItem(o, j, v);
    Py_DECREF(j);
    return r;
}

9711
static CYTHON_INLINE int __Pyx_SetItemInt_Fast(PyObject *o, Py_ssize_t i, PyObject *v) {
9712 9713 9714
    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)))) {
9715
            PyObject* old = PyList_GET_ITEM(o, n);
9716
            Py_INCREF(v);
9717
            PyList_SET_ITEM(o, n, v);
9718 9719 9720
            Py_DECREF(old);
            return 1;
        }
Dag Sverre Seljebotn's avatar
Merge  
Dag Sverre Seljebotn committed
9721
    }
9722 9723 9724 9725 9726
    else if (likely(i >= 0)) {
        PySequenceMethods *m = Py_TYPE(o)->tp_as_sequence;
        if (likely(m && m->sq_ass_item)) {
            return m->sq_ass_item(o, i, v);
        }
Dag Sverre Seljebotn's avatar
Merge  
Dag Sverre Seljebotn committed
9727
    }
9728
    return __Pyx_SetItemInt_Generic(o, PyInt_FromSsize_t(i), v);
Dag Sverre Seljebotn's avatar
Merge  
Dag Sverre Seljebotn committed
9729 9730
}
""",
9731 9732 9733
impl = """
""")

9734 9735
#------------------------------------------------------------------------------------

9736 9737
delitem_int_utility_code = UtilityCode(
proto = """
9738 9739
#define __Pyx_DelItemInt(o, i, size, to_py_func) (((size) <= sizeof(Py_ssize_t)) ? \\
                                                    __Pyx_DelItemInt_Fast(o, i) : \\
9740 9741
                                                    __Pyx_DelItem_Generic(o, to_py_func(i)))

9742
static CYTHON_INLINE int __Pyx_DelItem_Generic(PyObject *o, PyObject *j) {
9743
    int r;
9744 9745 9746 9747 9748 9749
    if (!j) return -1;
    r = PyObject_DelItem(o, j);
    Py_DECREF(j);
    return r;
}

9750
static CYTHON_INLINE int __Pyx_DelItemInt_Fast(PyObject *o, Py_ssize_t i) {
9751 9752 9753 9754 9755
    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);
        }
9756
    }
9757
    return __Pyx_DelItem_Generic(o, PyInt_FromSsize_t(i));
9758 9759 9760 9761 9762 9763 9764
}
""",
impl = """
""")

#------------------------------------------------------------------------------------

9765 9766
raise_too_many_values_to_unpack = UtilityCode(
proto = """
9767
static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected);
9768 9769
""",
impl = '''
9770 9771
static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected) {
    PyErr_Format(PyExc_ValueError,
9772
                 "too many values to unpack (expected %"PY_FORMAT_SIZE_T"d)", expected);
9773 9774 9775 9776 9777
}
''')

raise_need_more_values_to_unpack = UtilityCode(
proto = """
9778
static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index);
9779 9780
""",
impl = '''
9781
static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index) {
9782
    PyErr_Format(PyExc_ValueError,
9783 9784
                 "need more than %"PY_FORMAT_SIZE_T"d value%s to unpack",
                 index, (index == 1) ? "" : "s");
9785 9786 9787 9788 9789
}
''')

#------------------------------------------------------------------------------------

9790 9791 9792
tuple_unpacking_error_code = UtilityCode(
proto = """
static void __Pyx_UnpackTupleError(PyObject *, Py_ssize_t index); /*proto*/
9793
""",
9794 9795 9796 9797 9798 9799 9800
impl = """
static void __Pyx_UnpackTupleError(PyObject *t, Py_ssize_t index) {
    if (t == Py_None) {
      __Pyx_RaiseNoneNotIterableError();
    } else if (PyTuple_GET_SIZE(t) < index) {
      __Pyx_RaiseNeedMoreValuesError(PyTuple_GET_SIZE(t));
    } else {
9801
      __Pyx_RaiseTooManyValuesError(index);
9802 9803
    }
}
9804
""",
9805 9806 9807 9808 9809
requires = [raise_none_iter_error_utility_code,
            raise_need_more_values_to_unpack,
            raise_too_many_values_to_unpack]
)

9810 9811 9812 9813 9814 9815 9816 9817 9818 9819 9820 9821 9822 9823
unpacking_utility_code = UtilityCode(
proto = """
static PyObject *__Pyx_UnpackItem(PyObject *, Py_ssize_t index); /*proto*/
""",
impl = """
static PyObject *__Pyx_UnpackItem(PyObject *iter, Py_ssize_t index) {
    PyObject *item;
    if (!(item = PyIter_Next(iter))) {
        if (!PyErr_Occurred()) {
            __Pyx_RaiseNeedMoreValuesError(index);
        }
    }
    return item;
}
9824 9825 9826
""",
requires = [raise_need_more_values_to_unpack]
)
9827

9828 9829 9830 9831 9832 9833 9834 9835
iternext_unpacking_end_utility_code = UtilityCode(
proto = """
static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected); /*proto*/
""",
impl = """
static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected) {
    if (unlikely(retval)) {
        Py_DECREF(retval);
9836
        __Pyx_RaiseTooManyValuesError(expected);
9837
        return -1;
9838 9839 9840 9841 9842 9843 9844
    } else if (PyErr_Occurred()) {
        if (likely(PyErr_ExceptionMatches(PyExc_StopIteration))) {
            PyErr_Clear();
            return 0;
        } else {
            return -1;
        }
9845
    }
9846
    return 0;
9847 9848
}
""",
9849
requires = [raise_too_many_values_to_unpack]
9850
)
Robert Bradshaw's avatar
Robert Bradshaw committed
9851

9852 9853 9854 9855 9856 9857 9858 9859 9860 9861 9862 9863
#------------------------------------------------------------------------------------

# CPython supports calling functions with non-dict kwargs by
# converting them to a dict first

kwargs_call_utility_code = UtilityCode(
proto = """
static PyObject* __Pyx_PyEval_CallObjectWithKeywords(PyObject*, PyObject*, PyObject*); /*proto*/
""",
impl = """
static PyObject* __Pyx_PyEval_CallObjectWithKeywords(PyObject *callable, PyObject *args, PyObject *kwargs) {
    PyObject* result;
9864
    if (likely(PyDict_Check(kwargs))) {
9865 9866 9867 9868 9869 9870 9871 9872 9873 9874 9875
        return PyEval_CallObjectWithKeywords(callable, args, kwargs);
    } else {
        PyObject* real_dict;
        real_dict = PyObject_CallFunctionObjArgs((PyObject*)&PyDict_Type, kwargs, NULL);
        if (unlikely(!real_dict))
            return NULL;
        result = PyEval_CallObjectWithKeywords(callable, args, real_dict);
        Py_DECREF(real_dict);
        return result; /* may be NULL */
    }
}
9876
""",
9877 9878
)

Robert Bradshaw's avatar
Robert Bradshaw committed
9879 9880 9881 9882 9883

#------------------------------------------------------------------------------------

int_pow_utility_code = UtilityCode(
proto="""
9884
static CYTHON_INLINE %(type)s %(func_name)s(%(type)s, %(type)s); /* proto */
Robert Bradshaw's avatar
Robert Bradshaw committed
9885 9886
""",
impl="""
9887
static CYTHON_INLINE %(type)s %(func_name)s(%(type)s b, %(type)s e) {
Robert Bradshaw's avatar
Robert Bradshaw committed
9888 9889 9890 9891 9892 9893 9894 9895 9896 9897 9898 9899 9900 9901 9902 9903 9904 9905 9906 9907 9908
    %(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;
}
""")
9909 9910 9911

# ------------------------------ Division ------------------------------------

9912 9913
div_int_utility_code = UtilityCode(
proto="""
9914
static CYTHON_INLINE %(type)s __Pyx_div_%(type_name)s(%(type)s, %(type)s); /* proto */
9915 9916
""",
impl="""
9917
static CYTHON_INLINE %(type)s __Pyx_div_%(type_name)s(%(type)s a, %(type)s b) {
9918 9919 9920 9921 9922
    %(type)s q = a / b;
    %(type)s r = a - q*b;
    q -= ((r != 0) & ((r ^ b) < 0));
    return q;
}
9923 9924
""")

9925
mod_int_utility_code = UtilityCode(
9926
proto="""
9927
static CYTHON_INLINE %(type)s __Pyx_mod_%(type_name)s(%(type)s, %(type)s); /* proto */
9928 9929
""",
impl="""
9930
static CYTHON_INLINE %(type)s __Pyx_mod_%(type_name)s(%(type)s a, %(type)s b) {
9931 9932 9933
    %(type)s r = a %% b;
    r += ((r != 0) & ((r ^ b) < 0)) * b;
    return r;
9934 9935 9936
}
""")

9937
mod_float_utility_code = UtilityCode(
9938
proto="""
9939
static CYTHON_INLINE %(type)s __Pyx_mod_%(type_name)s(%(type)s, %(type)s); /* proto */
9940 9941
""",
impl="""
9942
static CYTHON_INLINE %(type)s __Pyx_mod_%(type_name)s(%(type)s a, %(type)s b) {
9943 9944 9945
    %(type)s r = fmod%(math_h_modifier)s(a, b);
    r += ((r != 0) & ((r < 0) ^ (b < 0))) * b;
    return r;
9946 9947
}
""")
Robert Bradshaw's avatar
Robert Bradshaw committed
9948

9949
cdivision_warning_utility_code = UtilityCode(
Robert Bradshaw's avatar
Robert Bradshaw committed
9950
proto="""
9951
static int __Pyx_cdivision_warning(const char *, int); /* proto */
Robert Bradshaw's avatar
Robert Bradshaw committed
9952 9953
""",
impl="""
9954
static int __Pyx_cdivision_warning(const char *filename, int lineno) {
9955
    return PyErr_WarnExplicit(PyExc_RuntimeWarning,
9956
                              "division with oppositely signed operands, C and Python semantics differ",
9957 9958
                              filename,
                              lineno,
9959
                              __Pyx_MODULE_NAME,
9960
                              NULL);
Robert Bradshaw's avatar
Robert Bradshaw committed
9961
}
9962
""")
9963 9964 9965 9966

# from intobject.c
division_overflow_test_code = UtilityCode(
proto="""
Vitja Makarov's avatar
Vitja Makarov committed
9967 9968
#define UNARY_NEG_WOULD_OVERFLOW(x)    \
        (((x) < 0) & ((unsigned long)(x) == 0-(unsigned long)(x)))
9969
""")
Robert Bradshaw's avatar
Robert Bradshaw committed
9970

9971 9972 9973
binding_cfunc_utility_code = TempitaUtilityCode.load(
    "CythonFunction", context=vars(Naming))
fused_function_utility_code = TempitaUtilityCode.load(
9974 9975 9976 9977
        "FusedFunction",
        "CythonFunction.c",
        context=vars(Naming),
        requires=[binding_cfunc_utility_code])
9978 9979 9980 9981
cyfunction_class_cell_utility_code = UtilityCode.load(
    "CyFunctionClassCell",
    "CythonFunction.c",
    requires=[binding_cfunc_utility_code])
9982

9983 9984
generator_utility_code = UtilityCode(
proto="""
9985 9986 9987 9988
static PyObject *__Pyx_Generator_Next(PyObject *self);
static PyObject *__Pyx_Generator_Send(PyObject *self, PyObject *value);
static PyObject *__Pyx_Generator_Close(PyObject *self);
static PyObject *__Pyx_Generator_Throw(PyObject *gen, PyObject *args, CYTHON_UNUSED PyObject *kwds);
9989

9990
typedef PyObject *(*__pyx_generator_body_t)(PyObject *, PyObject *);
9991 9992
""",
impl="""
9993 9994 9995 9996 9997 9998 9999 10000 10001 10002 10003
static CYTHON_INLINE void __Pyx_Generator_ExceptionClear(struct __pyx_Generator_object *self)
{
    Py_XDECREF(self->exc_type);
    Py_XDECREF(self->exc_value);
    Py_XDECREF(self->exc_traceback);

    self->exc_type = NULL;
    self->exc_value = NULL;
    self->exc_traceback = NULL;
}

10004
static CYTHON_INLINE PyObject *__Pyx_Generator_SendEx(struct __pyx_Generator_object *self, PyObject *value)
10005 10006 10007 10008 10009 10010 10011 10012 10013 10014 10015 10016 10017 10018 10019 10020 10021 10022
{
    PyObject *retval;

    if (self->is_running) {
        PyErr_SetString(PyExc_ValueError,
                        "generator already executing");
        return NULL;
    }

    if (self->resume_label == 0) {
        if (value && value != Py_None) {
            PyErr_SetString(PyExc_TypeError,
                            "can't send non-None value to a "
                            "just-started generator");
            return NULL;
        }
    }

10023 10024 10025 10026 10027
    if (self->resume_label == -1) {
        PyErr_SetNone(PyExc_StopIteration);
        return NULL;
    }

10028 10029 10030 10031 10032 10033

    if (value)
        __Pyx_ExceptionSwap(&self->exc_type, &self->exc_value, &self->exc_traceback);
    else
        __Pyx_Generator_ExceptionClear(self);

10034
    self->is_running = 1;
10035
    retval = self->body((PyObject *) self, value);
10036 10037
    self->is_running = 0;

10038 10039 10040 10041 10042
    if (retval)
        __Pyx_ExceptionSwap(&self->exc_type, &self->exc_value, &self->exc_traceback);
    else
        __Pyx_Generator_ExceptionClear(self);

10043 10044 10045
    return retval;
}

10046
static PyObject *__Pyx_Generator_Next(PyObject *self)
10047
{
10048
    return __Pyx_Generator_SendEx((struct __pyx_Generator_object *) self, Py_None);
10049 10050
}

10051
static PyObject *__Pyx_Generator_Send(PyObject *self, PyObject *value)
10052
{
10053
    return __Pyx_Generator_SendEx((struct __pyx_Generator_object *) self, value);
10054
}
Vitja Makarov's avatar
Vitja Makarov committed
10055

10056
static PyObject *__Pyx_Generator_Close(PyObject *self)
Vitja Makarov's avatar
Vitja Makarov committed
10057
{
10058
    struct __pyx_Generator_object *generator = (struct __pyx_Generator_object *) self;
Vitja Makarov's avatar
Vitja Makarov committed
10059
    PyObject *retval;
10060 10061 10062
#if PY_VERSION_HEX < 0x02050000
    PyErr_SetNone(PyExc_StopIteration);
#else
Vitja Makarov's avatar
Vitja Makarov committed
10063
    PyErr_SetNone(PyExc_GeneratorExit);
10064
#endif
10065
    retval = __Pyx_Generator_SendEx(generator, NULL);
Vitja Makarov's avatar
Vitja Makarov committed
10066 10067 10068 10069 10070 10071
    if (retval) {
        Py_DECREF(retval);
        PyErr_SetString(PyExc_RuntimeError,
                        "generator ignored GeneratorExit");
        return NULL;
    }
10072 10073 10074
#if PY_VERSION_HEX < 0x02050000
    if (PyErr_ExceptionMatches(PyExc_StopIteration))
#else
Vitja Makarov's avatar
Vitja Makarov committed
10075 10076
    if (PyErr_ExceptionMatches(PyExc_StopIteration)
        || PyErr_ExceptionMatches(PyExc_GeneratorExit))
10077
#endif
Vitja Makarov's avatar
Vitja Makarov committed
10078 10079 10080 10081 10082 10083 10084
    {
        PyErr_Clear();          /* ignore these errors */
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
}
10085

10086
static PyObject *__Pyx_Generator_Throw(PyObject *self, PyObject *args, CYTHON_UNUSED PyObject *kwds)
10087
{
10088
    struct __pyx_Generator_object *generator = (struct __pyx_Generator_object *) self;
10089 10090 10091 10092
    PyObject *typ;
    PyObject *tb = NULL;
    PyObject *val = NULL;

10093
    if (!PyArg_UnpackTuple(args, (char *)"throw", 1, 3, &typ, &val, &tb))
10094
        return NULL;
10095
    __Pyx_Raise(typ, val, tb, NULL);
10096
    return __Pyx_Generator_SendEx(generator, NULL);
10097
}
Stefan Behnel's avatar
Stefan Behnel committed
10098 10099
""",
proto_block='utility_code_proto_before_types',
10100
requires=[Nodes.raise_utility_code, Nodes.swap_exception_utility_code],
Stefan Behnel's avatar
Stefan Behnel committed
10101
)