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

5
import operator
William Stein's avatar
William Stein committed
6 7
from string import join

8
from Errors import error, warning, InternalError
9
import StringEncoding
William Stein's avatar
William Stein committed
10 11 12
import Naming
from Nodes import Node
import PyrexTypes
13
from PyrexTypes import py_object_type, c_long_type, typecast, error_type
14
from Builtin import list_type, tuple_type, dict_type, unicode_type
William Stein's avatar
William Stein committed
15 16
import Symtab
import Options
17
from Annotate import AnnotationItem
William Stein's avatar
William Stein committed
18

William Stein's avatar
William Stein committed
19
from Cython.Debugging import print_call_chain
William Stein's avatar
William Stein committed
20 21 22
from DebugFlags import debug_disposal_code, debug_temp_alloc, \
    debug_coercion

23

William Stein's avatar
William Stein committed
24 25 26 27 28 29 30 31 32 33 34 35 36
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
    #  is_sequence_constructor  
    #               boolean      Is a list or tuple constructor expression
    #  saved_subexpr_nodes
    #               [ExprNode or [ExprNode or None] or None]
    #                            Cached result of subexpr_nodes()
    
    result_ctype = None
37
    type = None
William Stein's avatar
William Stein committed
38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97

    #  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.
    #  
    #  The framework makes use of a number of abstract methods. 
    #  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
    #        the LHS of an assignment or argument of a del 
    #        statement. Similar responsibilities to analyse_types.
    #
    #      allocate_temps
    #        - Call allocate_temps for all sub-nodes.
    #        - Call allocate_temp for this node.
    #        - If a temporary was allocated, call release_temp on 
    #          all sub-expressions.
    #
98 99 100 101 102 103 104
    #      allocate_target_temps
    #        - Call allocate_temps on sub-nodes and allocate any other
    #          temps used during assignment.
    #        - Fill in result_code with a C lvalue if needed.
    #        - If a rhs node is supplied, call release_temp on it.
    #        - Call release_temp on sub-nodes and release any other
    #          temps used during assignment.
William Stein's avatar
William Stein committed
105
    #
106 107 108 109
    #      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
110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137
    #
    #      check_const
    #        - Check that this node and its subnodes form a
    #          legal constant expression. If so, do nothing,
    #          otherwise call not_const. 
    #
    #        The default implementation of check_const 
    #        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
    #        assumes that the expression is not a constant 
    #        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
138
    #        is provided which uses the following abstract methods:
William Stein's avatar
William Stein committed
139 140 141 142 143 144
    #
    #          generate_result_code
    #            - Generate any C statements necessary to calculate
    #              the result of this node from the results of its
    #              sub-expressions.
    #
145 146 147 148 149
    #          calculate_result_code
    #            - Should return a C code fragment evaluating to the 
    #              result. This is only called when the result is not 
    #              a temporary.
    #
William Stein's avatar
William Stein committed
150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171
    #      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.
    #
    #
    
    is_sequence_constructor = 0
    is_attribute = 0
    
    saved_subexpr_nodes = None
    is_temp = 0

172
    def get_child_attrs(self):
173 174
        return self.subexprs
    child_attrs = property(fget=get_child_attrs)
175
        
William Stein's avatar
William Stein committed
176 177 178 179
    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
180
                (self.__class__.__name__, method_name))
William Stein's avatar
William Stein committed
181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206
                
    def is_lvalue(self):
        return 0
    
    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.
        if self.saved_subexpr_nodes is None:
            nodes = []
            for name in self.subexprs:
                item = getattr(self, name)
                if item:
                    if isinstance(item, ExprNode):
                        nodes.append(item)
                    else:
                        nodes.extend(item)
            self.saved_subexpr_nodes = nodes
        return self.saved_subexpr_nodes
207 208 209 210 211 212
        
    def result(self):
		if self.is_temp:
			return self.result_code
		else:
			return self.calculate_result_code()
William Stein's avatar
William Stein committed
213 214 215
    
    def result_as(self, type = None):
        #  Return the result code cast to the specified C type.
216
        return typecast(type, self.ctype(), self.result())
William Stein's avatar
William Stein committed
217 218 219 220 221 222 223 224 225 226
    
    def py_result(self):
        #  Return the result code cast to PyObject *.
        return self.result_as(py_object_type)
    
    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
    
227 228 229 230 231 232 233 234
    def compile_time_value(self, denv):
        #  Return value of compile-time expression, or report error.
        error(self.pos, "Invalid compile-time expression")
    
    def compile_time_value_error(self, e):
        error(self.pos, "Error in compile-time expression: %s: %s" % (
            e.__class__.__name__, e))
    
William Stein's avatar
William Stein committed
235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257
    # ------------- Declaration Analysis ----------------
    
    def analyse_target_declaration(self, env):
        error(self.pos, "Cannot assign to or delete this")
    
    # ------------- Expression Analysis ----------------
    
    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)
        self.allocate_temps(env)
        self.check_const()
    
    def analyse_expressions(self, env):
        #  Convenience routine performing both the Type
        #  Analysis and Temp Allocation phases for a whole 
        #  expression.
        self.analyse_types(env)
        self.allocate_temps(env)
    
258
    def analyse_target_expression(self, env, rhs):
William Stein's avatar
William Stein committed
259 260 261 262
        #  Convenience routine performing both the Type
        #  Analysis and Temp Allocation phases for the LHS of
        #  an assignment.
        self.analyse_target_types(env)
263
        self.allocate_target_temps(env, rhs)
William Stein's avatar
William Stein committed
264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302
    
    def analyse_boolean_expression(self, env):
        #  Analyse expression and coerce to a boolean.
        self.analyse_types(env)
        bool = self.coerce_to_boolean(env)
        bool.allocate_temps(env)
        return bool
    
    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)
        bool = self.coerce_to_boolean(env)
        temp_bool = bool.coerce_to_temp(env)
        temp_bool.allocate_temps(env)
        return temp_bool
    
    # --------------- Type Analysis ------------------
    
    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
    
    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
    
    def analyse_types(self, env):
        self.not_implemented("analyse_types")
    
    def analyse_target_types(self, env):
        self.analyse_types(env)
303 304 305 306 307

    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
308 309 310 311 312 313 314 315 316 317 318
    def check_const(self):
        self.not_const()
    
    def not_const(self):
        error(self.pos, "Not allowed in a constant expression")
    
    def check_const_addr(self):
        self.addr_not_const()
    
    def addr_not_const(self):
        error(self.pos, "Address is not constant")
319 320 321 322 323

    def gil_check(self, env):
        if env.nogil and self.type.is_pyobject:
            self.gil_error()

William Stein's avatar
William Stein committed
324 325 326 327 328 329 330 331 332
    # ----------------- Result Allocation -----------------
    
    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
            
333 334
    def allocate_target_temps(self, env, rhs):
        #  Perform temp allocation for the LHS of an assignment.
William Stein's avatar
William Stein committed
335
        if debug_temp_alloc:
Stefan Behnel's avatar
Stefan Behnel committed
336
            print("%s Allocating target temps" % self)
William Stein's avatar
William Stein committed
337 338
        self.allocate_subexpr_temps(env)
        self.result_code = self.target_code()
339 340 341
        if rhs:
            rhs.release_temp(env)
        self.release_subexpr_temps(env)
William Stein's avatar
William Stein committed
342 343 344 345 346 347 348 349
    
    def allocate_temps(self, env, result = None):
        #  Allocate temporary variables for this node and
        #  all its sub-expressions. If a result is specified,
        #  this must be a temp node and the specified variable
        #  is used as the result instead of allocating a new
        #  one.
        if debug_temp_alloc:
Stefan Behnel's avatar
Stefan Behnel committed
350
            print("%s Allocating temps" % self)
William Stein's avatar
William Stein committed
351 352 353 354 355 356 357 358 359
        self.allocate_subexpr_temps(env)
        self.allocate_temp(env, result)
        if self.is_temp:
            self.release_subexpr_temps(env)
    
    def allocate_subexpr_temps(self, env):
        #  Allocate temporary variables for all sub-expressions
        #  of this node.
        if debug_temp_alloc:
Stefan Behnel's avatar
Stefan Behnel committed
360
            print("%s Allocating temps for: %s" % (self, self.subexprs))
William Stein's avatar
William Stein committed
361 362 363
        for node in self.subexpr_nodes():
            if node:
                if debug_temp_alloc:
Stefan Behnel's avatar
Stefan Behnel committed
364
                    print("%s Allocating temps for %s" % (self, node))
William Stein's avatar
William Stein committed
365 366 367 368 369 370 371 372 373 374
                node.allocate_temps(env)
    
    def allocate_temp(self, env, result = None):
        #  If this node requires a temporary variable for its
        #  result, allocate one, otherwise set the result to
        #  a C code fragment. If a result is specified,
        #  this must be a temp node and the specified variable
        #  is used as the result instead of allocating a new
        #  one.
        if debug_temp_alloc:
Stefan Behnel's avatar
Stefan Behnel committed
375
            print("%s Allocating temp" % self)
William Stein's avatar
William Stein committed
376 377 378 379 380 381 382 383 384 385 386 387 388
        if result:
            if not self.is_temp:
                raise InternalError("Result forced on non-temp node")
            self.result_code = result
        elif self.is_temp:
            type = self.type
            if not type.is_void:
                if type.is_pyobject:
                    type = PyrexTypes.py_object_type
                self.result_code = env.allocate_temp(type)
            else:
                self.result_code = None
            if debug_temp_alloc:
Stefan Behnel's avatar
Stefan Behnel committed
389
                print("%s Allocated result %s" % (self, self.result_code))
William Stein's avatar
William Stein committed
390 391 392 393 394 395 396 397
    
    def target_code(self):
        #  Return code fragment for use as LHS of a C assignment.
        return self.calculate_result_code()
    
    def calculate_result_code(self):
        self.not_implemented("calculate_result_code")
    
398 399 400
#	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
401 402 403 404 405 406

    def release_temp(self, env):
        #  If this node owns a temporary result, release it,
        #  otherwise release results of its sub-expressions.
        if self.is_temp:
            if debug_temp_alloc:
Stefan Behnel's avatar
Stefan Behnel committed
407
                print("%s Releasing result %s" % (self, self.result_code))
William Stein's avatar
William Stein committed
408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424
            env.release_temp(self.result_code)
        else:
            self.release_subexpr_temps(env)
    
    def release_subexpr_temps(self, env):
        #  Release the results of all sub-expressions of
        #  this node.
        for node in self.subexpr_nodes():
            if node:
                node.release_temp(env)
    
    # ---------------- Code Generation -----------------
    
    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():
425
            code.put_incref(self.result(), self.ctype())
William Stein's avatar
William Stein committed
426 427
    
    def generate_evaluation_code(self, code):
428
        code.mark_pos(self.pos)
William Stein's avatar
William Stein committed
429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448
        #  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)
        self.generate_result_code(code)
        if self.is_temp:
            self.generate_subexpr_disposal_code(code)
    
    def generate_subexpr_evaluation_code(self, code):
        for node in self.subexpr_nodes():
            node.generate_evaluation_code(code)
    
    def generate_result_code(self, code):
        self.not_implemented("generate_result_code")
    
    def generate_disposal_code(self, code):
        # If necessary, generate code to dispose of 
        # temporary Python reference.
        if self.is_temp:
            if self.type.is_pyobject:
449
                code.put_decref_clear(self.result(), self.ctype())
William Stein's avatar
William Stein committed
450 451 452 453 454 455 456 457 458 459 460 461 462 463 464
        else:
            self.generate_subexpr_disposal_code(code)
    
    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)
    
    def generate_post_assignment_code(self, code):
        # Same as generate_disposal_code except that
        # assignment will have absorbed a reference to
        # the result if it is a Python object.
        if self.is_temp:
            if self.type.is_pyobject:
465
                code.putln("%s = 0;" % self.result())
William Stein's avatar
William Stein committed
466 467 468 469 470 471 472 473 474 475 476 477 478 479 480
        else:
            self.generate_subexpr_disposal_code(code)
    
    def generate_assignment_code(self, rhs, code):
        #  Stub method for nodes which are not legal as
        #  the LHS of an assignment. An error will have 
        #  been reported earlier.
        pass
    
    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
    
481 482 483 484 485 486
    # ---------------- Annotation ---------------------
    
    def annotate(self, code):
        for node in self.subexpr_nodes():
            node.annotate(code)
    
William Stein's avatar
William Stein committed
487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505
    # ----------------- Coercion ----------------------
    
    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.
        src = self
        src_type = self.type
        src_is_py_type = src_type.is_pyobject
        dst_is_py_type = dst_type.is_pyobject
        
        if dst_type.is_pyobject:
            if not src.type.is_pyobject:
                src = CoerceToPyTypeNode(src, env)
            if not src.type.subtype_of(dst_type):
506 507
                if not isinstance(src, NoneNode):
                    src = PyTypeTestNode(src, dst_type, env)
William Stein's avatar
William Stein committed
508 509 510
        elif src.type.is_pyobject:
            src = CoerceFromPyTypeNode(dst_type, src, env)
        else: # neither src nor dst are py types
511
            # Added the string comparison, since for c types that
512
            # is enough, but Cython gets confused when the types are
513
            # in different files.
514
            if not (str(src.type) == str(dst_type) or dst_type.assignable_from(src_type)):
William Stein's avatar
William Stein committed
515 516 517 518 519 520 521 522 523 524 525 526 527 528
                error(self.pos, "Cannot assign type '%s' to '%s'" %
                    (src.type, dst_type))
        return src

    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.
        type = self.type
        if type.is_pyobject or type.is_ptr or type.is_float:
            return CoerceToBooleanNode(self, env)
        else:
529
            if not type.is_int and not type.is_error:
William Stein's avatar
William Stein committed
530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572
                error(self.pos, 
                    "Type '%s' not acceptable as a boolean" % type)
            return self
    
    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)
    
    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)
    
    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)
    
    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()


class AtomicExprNode(ExprNode):
    #  Abstract base class for expression nodes which have
    #  no sub-expressions.
    
    subexprs = []


class PyConstNode(AtomicExprNode):
    #  Abstract base class for constant Python values.
    
573 574
    is_literal = 1
    
William Stein's avatar
William Stein committed
575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592
    def is_simple(self):
        return 1
    
    def analyse_types(self, env):
        self.type = py_object_type
    
    def calculate_result_code(self):
        return self.value

    def generate_result_code(self, code):
        pass


class NoneNode(PyConstNode):
    #  The constant value None
    
    value = "Py_None"
    
593 594 595
    def compile_time_value(self, denv):
        return None
    
William Stein's avatar
William Stein committed
596 597 598 599 600
class EllipsisNode(PyConstNode):
    #  '...' in a subscript list.
    
    value = "Py_Ellipsis"

601 602 603
    def compile_time_value(self, denv):
        return Ellipsis

William Stein's avatar
William Stein committed
604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627

class ConstNode(AtomicExprNode):
    # Abstract base type for literal constant nodes.
    #
    # value     string      C code fragment
    
    is_literal = 1
    
    def is_simple(self):
        return 1
    
    def analyse_types(self, env):
        pass # Types are held in class variables
    
    def check_const(self):
        pass
    
    def calculate_result_code(self):
        return str(self.value)

    def generate_result_code(self, code):
        pass


628 629 630 631 632 633 634 635
class BoolNode(ConstNode):
    type = PyrexTypes.c_bint_type
    #  The constant value True or False
    
    def compile_time_value(self, denv):
        return self.value
    
    def calculate_result_code(self):
636
        return str(int(self.value))
637

William Stein's avatar
William Stein committed
638 639
class NullNode(ConstNode):
    type = PyrexTypes.c_null_ptr_type
640
    value = "NULL"
William Stein's avatar
William Stein committed
641 642 643 644 645


class CharNode(ConstNode):
    type = PyrexTypes.c_char_type
    
646
    def compile_time_value(self, denv):
647
        return ord(self.value)
648
    
William Stein's avatar
William Stein committed
649
    def calculate_result_code(self):
650
        return "'%s'" % StringEncoding.escape_character(self.value)
William Stein's avatar
William Stein committed
651 652 653


class IntNode(ConstNode):
654 655 656 657 658 659

    # unsigned     "" or "U"
    # longness     "" or "L" or "LL"

    unsigned = ""
    longness = ""
William Stein's avatar
William Stein committed
660 661
    type = PyrexTypes.c_long_type

662 663 664 665
    def coerce_to(self, dst_type, env):
        # Arrange for a Python version of the string to be pre-allocated
        # when coercing to a Python type.
        if dst_type.is_pyobject:
666
            self.entry = env.get_py_num(self.value, self.longness)
667 668 669 670 671 672 673 674 675 676
            self.type = PyrexTypes.py_object_type
        # 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(self, dst_type, env)

    def calculate_result_code(self):
        if self.type.is_pyobject:
            return self.entry.cname
        else:
677
            return str(self.value) + self.unsigned + self.longness
William Stein's avatar
William Stein committed
678

679
    def compile_time_value(self, denv):
680
        return int(self.value, 0)
681 682


William Stein's avatar
William Stein committed
683 684 685
class FloatNode(ConstNode):
    type = PyrexTypes.c_double_type

686 687
    def compile_time_value(self, denv):
        return float(self.value)
Stefan Behnel's avatar
Stefan Behnel committed
688 689 690 691
    
    def calculate_result_code(self):
        strval = str(self.value)
        if strval == 'nan':
692
            return "(Py_HUGE_VAL * 0)"
Stefan Behnel's avatar
Stefan Behnel committed
693
        elif strval == 'inf':
694
            return "Py_HUGE_VAL"
Stefan Behnel's avatar
Stefan Behnel committed
695
        elif strval == '-inf':
696
            return "(-Py_HUGE_VAL)"
Stefan Behnel's avatar
Stefan Behnel committed
697 698
        else:
            return strval
699

William Stein's avatar
William Stein committed
700 701 702 703 704

class StringNode(ConstNode):
    #  entry   Symtab.Entry
    
    type = PyrexTypes.c_char_ptr_type
705 706

    def compile_time_value(self, denv):
707
        return self.value
William Stein's avatar
William Stein committed
708 709 710 711 712
    
    def analyse_types(self, env):
        self.entry = env.add_string_const(self.value)
    
    def coerce_to(self, dst_type, env):
713
        if dst_type.is_int:
714
            if not self.type.is_pyobject and len(self.entry.init) == 1:
Robert Bradshaw's avatar
Robert Bradshaw committed
715
                return CharNode(self.pos, value=self.value)
716 717 718
            else:
                error(self.pos, "Only coerce single-character ascii strings can be used as ints.")
                return self
William Stein's avatar
William Stein committed
719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743
        # Arrange for a Python version of the string to be pre-allocated
        # when coercing to a Python type.
        if dst_type.is_pyobject and not self.type.is_pyobject:
            node = self.as_py_string_node(env)
        else:
            node = self
        # 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)

    def as_py_string_node(self, env):
        # Return a new StringNode with the same entry as this node
        # but whose type is a Python type instead of a C type.
        entry = self.entry
        env.add_py_string(entry)
        return StringNode(self.pos, entry = entry, type = py_object_type)
            
    def calculate_result_code(self):
        if self.type.is_pyobject:
            return self.entry.pystring_cname
        else:
            return self.entry.cname


744 745 746
class UnicodeNode(PyConstNode):
    #  entry   Symtab.Entry

747
    type = unicode_type
748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764

    def analyse_types(self, env):
        self.entry = env.add_string_const(self.value)
        env.add_py_string(self.entry)

    def calculate_result_code(self):
        return self.entry.pystring_cname
    
    def _coerce_to(self, dst_type, env):
        if not dst_type.is_pyobject:
            node = StringNode(self.pos, entry = entry, type = py_object_type)
            return ConstNode.coerce_to(node, dst_type, env)
        else:
            return self
        # 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.
765 766 767
        
    def compile_time_value(self, env):
        return self.value
768 769


770 771 772
class IdentifierStringNode(ConstNode):
    # A Python string that behaves like an identifier, e.g. for
    # keyword arguments in a call, or for imported names
773 774 775 776 777 778 779 780 781
    type = PyrexTypes.py_object_type

    def analyse_types(self, env):
        self.cname = env.intern_identifier(self.value)

    def calculate_result_code(self):
        return self.cname


William Stein's avatar
William Stein committed
782 783 784 785 786
class LongNode(AtomicExprNode):
    #  Python long integer literal
    #
    #  value   string
    
787 788
    def compile_time_value(self, denv):
        return long(self.value)
789 790

    gil_message = "Constructing Python long int"
791
    
William Stein's avatar
William Stein committed
792 793
    def analyse_types(self, env):
        self.type = py_object_type
794
        self.gil_check(env)
William Stein's avatar
William Stein committed
795
        self.is_temp = 1
796 797 798

    gil_message = "Constructing Python long int"

William Stein's avatar
William Stein committed
799 800
    def generate_evaluation_code(self, code):
        code.putln(
Robert Bradshaw's avatar
Robert Bradshaw committed
801
            '%s = PyLong_FromString("%s", 0, 0); %s' % (
802
                self.result(),
William Stein's avatar
William Stein committed
803
                self.value,
804
                code.error_goto_if_null(self.result(), self.pos)))
William Stein's avatar
William Stein committed
805 806 807 808 809 810 811


class ImagNode(AtomicExprNode):
    #  Imaginary number literal
    #
    #  value   float    imaginary part
    
812 813 814
    def compile_time_value(self, denv):
        return complex(0.0, self.value)
    
William Stein's avatar
William Stein committed
815 816
    def analyse_types(self, env):
        self.type = py_object_type
817
        self.gil_check(env)
William Stein's avatar
William Stein committed
818
        self.is_temp = 1
819 820 821

    gil_message = "Constructing complex number"

William Stein's avatar
William Stein committed
822 823
    def generate_evaluation_code(self, code):
        code.putln(
Robert Bradshaw's avatar
Robert Bradshaw committed
824
            "%s = PyComplex_FromDoubles(0.0, %s); %s" % (
825
                self.result(),
William Stein's avatar
William Stein committed
826
                self.value,
827
                code.error_goto_if_null(self.result(), self.pos)))
William Stein's avatar
William Stein committed
828 829 830 831 832 833


class NameNode(AtomicExprNode):
    #  Reference to a local or global variable name.
    #
    #  name            string    Python name of the variable
834
    #
William Stein's avatar
William Stein committed
835
    #  entry           Entry     Symbol table entry
836
    #  interned_cname  string
William Stein's avatar
William Stein committed
837 838
    
    is_name = 1
839
    skip_assignment_decref = False
840
    entry = None
841 842 843 844 845 846 847

    def create_analysed_rvalue(pos, env, entry):
        node = NameNode(pos)
        node.analyse_types(env, entry=entry)
        return node
    
    create_analysed_rvalue = staticmethod(create_analysed_rvalue)
William Stein's avatar
William Stein committed
848
    
849 850 851 852
    def compile_time_value(self, denv):
        try:
            return denv.lookup(self.name)
        except KeyError:
Stefan Behnel's avatar
Stefan Behnel committed
853
            error(self.pos, "Compile-time name '%s' not defined" % self.name)
854 855 856 857 858 859 860 861
    
    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
862
            if entry and entry.is_cfunction:
863 864
                var_entry = entry.as_variable
                if var_entry:
865 866
                    if var_entry.is_builtin and Options.cache_builtins:
                        var_entry = env.declare_builtin(var_entry.name, self.pos)
867 868 869 870 871 872
                    node = NameNode(self.pos, name = self.name)
                    node.entry = var_entry
                    node.analyse_rvalue_entry(env)
                    return node
        return AtomicExprNode.coerce_to(self, dst_type, env)
    
William Stein's avatar
William Stein committed
873 874 875
    def analyse_as_module(self, env):
        # Try to interpret this as a reference to a cimported module.
        # Returns the module scope, or None.
876 877 878
        entry = self.entry
        if not entry:
            entry = env.lookup(self.name)
William Stein's avatar
William Stein committed
879 880 881 882 883 884 885
        if entry and entry.as_module:
            return entry.as_module
        return None
    
    def analyse_as_extension_type(self, env):
        # Try to interpret this as a reference to an extension type.
        # Returns the extension type, or None.
886 887 888
        entry = self.entry
        if not entry:
            entry = env.lookup(self.name)
William Stein's avatar
William Stein committed
889
        if entry and entry.is_type and entry.type.is_extension_type:
890 891 892
            return entry.type
        else:
            return None
William Stein's avatar
William Stein committed
893 894
    
    def analyse_target_declaration(self, env):
895 896
        if not self.entry:
            self.entry = env.lookup_here(self.name)
William Stein's avatar
William Stein committed
897 898
        if not self.entry:
            self.entry = env.declare_var(self.name, py_object_type, self.pos)
899
        env.control_flow.set_state(self.pos, (self.name, 'initalized'), True)
Robert Bradshaw's avatar
Robert Bradshaw committed
900
        env.control_flow.set_state(self.pos, (self.name, 'source'), 'assignment')
901 902
        if self.entry.is_declared_generic:
            self.result_ctype = py_object_type
William Stein's avatar
William Stein committed
903
    
904 905 906
    def analyse_types(self, env):
        if self.entry is None:
            self.entry = env.lookup(self.name)
William Stein's avatar
William Stein committed
907 908
        if not self.entry:
            self.entry = env.declare_builtin(self.name, self.pos)
909 910 911
        if not self.entry:
            self.type = PyrexTypes.error_type
            return
912 913 914
        self.analyse_rvalue_entry(env)
        
    def analyse_target_types(self, env):
William Stein's avatar
William Stein committed
915
        self.analyse_entry(env)
916 917 918 919
        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
920
        self.entry.used = 1
921
        if self.entry.type.is_buffer:
922 923 924
            import Buffer
            Buffer.used_buffer_aux_vars(self.entry)
                
925 926 927 928
    def analyse_rvalue_entry(self, env):
        #print "NameNode.analyse_rvalue_entry:", self.name ###
        #print "Entry:", self.entry.__dict__ ###
        self.analyse_entry(env)
929 930
        entry = self.entry
        if entry.is_declared_generic:
William Stein's avatar
William Stein committed
931
            self.result_ctype = py_object_type
932
        if entry.is_pyglobal or entry.is_builtin:
933 934 935 936
            if Options.cache_builtins and entry.is_builtin:
                self.is_temp = 0
            else:
                self.is_temp = 1
937
            env.use_utility_code(get_name_interned_utility_code)
938 939 940 941
            self.gil_check(env)

    gil_message = "Accessing Python global or builtin"

942 943
    def analyse_entry(self, env):
        #print "NameNode.analyse_entry:", self.name ###
William Stein's avatar
William Stein committed
944
        self.check_identifier_kind()
945 946 947 948 949
        entry = self.entry
        type = entry.type
        self.type = type
        if entry.is_pyglobal or entry.is_builtin:
            assert type.is_pyobject, "Python global or builtin not a Python object"
950 951
            self.interned_cname = self.entry.interned_cname = \
                env.intern_identifier(self.entry.name)
952

William Stein's avatar
William Stein committed
953
    def check_identifier_kind(self):
954
        #print "NameNode.check_identifier_kind:", self.entry.name ###
955
        #print self.entry.__dict__ ###
William Stein's avatar
William Stein committed
956
        entry = self.entry
Stefan Behnel's avatar
Stefan Behnel committed
957
        #entry.used = 1
William Stein's avatar
William Stein committed
958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974
        if not (entry.is_const or entry.is_variable 
            or entry.is_builtin or entry.is_cfunction):
                if self.entry.as_variable:
                    self.entry = self.entry.as_variable
                else:
                    error(self.pos, 
                        "'%s' is not a constant, variable or function identifier" % self.name)
    
    def is_simple(self):
        #  If it's not a C variable, it'll be in a temp.
        return 1
    
    def calculate_target_results(self, env):
        pass
    
    def check_const(self):
        entry = self.entry
Robert Bradshaw's avatar
Robert Bradshaw committed
975
        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
976 977 978 979
            self.not_const()
    
    def check_const_addr(self):
        entry = self.entry
980
        if not (entry.is_cglobal or entry.is_cfunction or entry.is_builtin):
William Stein's avatar
William Stein committed
981 982 983 984 985 986 987 988 989 990 991
            self.addr_not_const()

    def is_lvalue(self):
        return self.entry.is_variable and \
            not self.entry.type.is_array and \
            not self.entry.is_readonly
    
    def is_ephemeral(self):
        #  Name nodes are never ephemeral, even if the
        #  result is in a temporary.
        return 0
Stefan Behnel's avatar
Stefan Behnel committed
992 993 994
    
    def allocate_temp(self, env, result = None):
        AtomicExprNode.allocate_temp(self, env, result)
Stefan Behnel's avatar
Stefan Behnel committed
995 996 997
        entry = self.entry
        if entry:
            entry.used = 1
998 999 1000
            if entry.type.is_buffer:
                import Buffer
                Buffer.used_buffer_aux_vars(entry)
Stefan Behnel's avatar
Stefan Behnel committed
1001 1002
            if entry.utility_code:
                env.use_utility_code(entry.utility_code)
Stefan Behnel's avatar
Stefan Behnel committed
1003
        
William Stein's avatar
William Stein committed
1004
    def calculate_result_code(self):
Stefan Behnel's avatar
Stefan Behnel committed
1005 1006
        entry = self.entry
        if not entry:
William Stein's avatar
William Stein committed
1007
            return "<error>" # There was an error earlier
Stefan Behnel's avatar
Stefan Behnel committed
1008
        return entry.cname
William Stein's avatar
William Stein committed
1009 1010
    
    def generate_result_code(self, code):
1011
        assert hasattr(self, 'entry')
William Stein's avatar
William Stein committed
1012 1013 1014
        entry = self.entry
        if entry is None:
            return # There was an error earlier
1015 1016 1017
        if entry.is_builtin and Options.cache_builtins:
            return # Lookup already cached
        elif entry.is_pyglobal or entry.is_builtin:
William Stein's avatar
William Stein committed
1018 1019 1020
            if entry.is_builtin:
                namespace = Naming.builtins_cname
            else: # entry.is_pyglobal
1021
                namespace = entry.scope.namespace_cname
1022 1023
            code.putln(
                '%s = __Pyx_GetName(%s, %s); %s' % (
1024
                self.result(),
1025 1026
                namespace, 
                self.interned_cname,
1027
                code.error_goto_if_null(self.result(), self.pos)))
1028 1029
        elif entry.is_local and False:
            # control flow not good enough yet
Robert Bradshaw's avatar
Robert Bradshaw committed
1030
            assigned = entry.scope.control_flow.get_state((entry.name, 'initalized'), self.pos)
1031 1032
            if assigned is False:
                error(self.pos, "local variable '%s' referenced before assignment" % entry.name)
Robert Bradshaw's avatar
Robert Bradshaw committed
1033 1034 1035
            elif not Options.init_local_none and assigned is None:
                code.putln('if (%s == 0) { PyErr_SetString(PyExc_UnboundLocalError, "%s"); %s }' % (entry.cname, entry.name, code.error_goto(self.pos)))
                entry.scope.control_flow.set_state(self.pos, (entry.name, 'initalized'), True)
William Stein's avatar
William Stein committed
1036 1037

    def generate_assignment_code(self, rhs, code):
1038
        #print "NameNode.generate_assignment_code:", self.name ###
William Stein's avatar
William Stein committed
1039 1040 1041
        entry = self.entry
        if entry is None:
            return # There was an error earlier
1042
        
1043 1044
        # 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
1045
        if entry.is_pyglobal:
1046
            namespace = self.entry.scope.namespace_cname
1047
            if entry.is_member:
Stefan Behnel's avatar
Stefan Behnel committed
1048
                # if the entry is a member we have to cheat: SetAttr does not work
1049
                # on types, so we create a descriptor which is then added to tp_dict
1050 1051 1052 1053 1054
                code.put_error_if_neg(self.pos,
                    'PyDict_SetItem(%s->tp_dict, %s, %s)' % (
                        namespace,
                        self.interned_cname,
                        rhs.py_result()))
1055
                # in Py2.6+, we need to invalidate the method cache
1056
                code.putln("PyType_Modified(%s);" %
1057
                           entry.scope.parent_type.typeptr_cname)
1058
            else: 
1059 1060 1061 1062 1063
                code.put_error_if_neg(self.pos,
                    'PyObject_SetAttr(%s, %s, %s)' % (
                        namespace,
                        self.interned_cname,
                        rhs.py_result()))
1064
                if debug_disposal_code:
Stefan Behnel's avatar
Stefan Behnel committed
1065 1066
                    print("NameNode.generate_assignment_code:")
                    print("...generating disposal code for %s" % rhs)
1067 1068
                rhs.generate_disposal_code(code)
                
William Stein's avatar
William Stein committed
1069
        else:
1070 1071 1072 1073 1074 1075 1076 1077 1078 1079
            if self.type.is_buffer:
                # 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)

1080 1081
            if self.type.is_pyobject:
                rhs.make_owned_reference(code)
William Stein's avatar
William Stein committed
1082 1083 1084 1085
                #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() ###
1086 1087 1088 1089
                if not self.skip_assignment_decref:
                    if entry.is_local and not Options.init_local_none:
                        initalized = entry.scope.control_flow.get_state((entry.name, 'initalized'), self.pos)
                        if initalized is True:
1090
                            code.put_decref(self.result(), self.ctype())
1091
                        elif initalized is None:
1092
                            code.put_xdecref(self.result(), self.ctype())
1093
                    else:
1094 1095
                        code.put_decref(self.result(), self.ctype())
            code.putln('%s = %s;' % (self.result(), rhs.result_as(self.ctype())))
William Stein's avatar
William Stein committed
1096
            if debug_disposal_code:
Stefan Behnel's avatar
Stefan Behnel committed
1097 1098
                print("NameNode.generate_assignment_code:")
                print("...generating post-assignment code for %s" % rhs)
William Stein's avatar
William Stein committed
1099
            rhs.generate_post_assignment_code(code)
1100 1101

    def generate_acquire_buffer(self, rhs, code):
1102
        rhstmp = code.funcstate.allocate_temp(self.entry.type)
1103 1104 1105 1106 1107
        buffer_aux = self.entry.buffer_aux
        bufstruct = buffer_aux.buffer_info_var.cname
        code.putln('%s = %s;' % (rhstmp, rhs.result_as(self.ctype())))

        import Buffer
1108
        Buffer.put_assign_to_buffer(self.result(), rhstmp, buffer_aux, self.entry.type,
1109 1110 1111
                                    is_initialized=not self.skip_assignment_decref,
                                    pos=self.pos, code=code)
        code.putln("%s = 0;" % rhstmp)
1112
        code.funcstate.release_temp(rhstmp)
William Stein's avatar
William Stein committed
1113 1114 1115 1116 1117 1118 1119
    
    def generate_deletion_code(self, code):
        if self.entry is None:
            return # There was an error earlier
        if not self.entry.is_pyglobal:
            error(self.pos, "Deletion of local or C global name not supported")
            return
Robert Bradshaw's avatar
Robert Bradshaw committed
1120 1121
        code.put_error_if_neg(self.pos, 
            'PyObject_DelAttrString(%s, "%s")' % (
William Stein's avatar
William Stein committed
1122
                Naming.module_cname,
Robert Bradshaw's avatar
Robert Bradshaw committed
1123
                self.entry.name))
1124 1125 1126 1127 1128 1129 1130 1131
                
    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)))
William Stein's avatar
William Stein committed
1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143
            
class BackquoteNode(ExprNode):
    #  `expr`
    #
    #  arg    ExprNode
    
    subexprs = ['arg']
    
    def analyse_types(self, env):
        self.arg.analyse_types(env)
        self.arg = self.arg.coerce_to_pyobject(env)
        self.type = py_object_type
1144
        self.gil_check(env)
William Stein's avatar
William Stein committed
1145
        self.is_temp = 1
1146 1147 1148

    gil_message = "Backquote expression"

William Stein's avatar
William Stein committed
1149 1150
    def generate_result_code(self, code):
        code.putln(
Robert Bradshaw's avatar
Robert Bradshaw committed
1151
            "%s = PyObject_Repr(%s); %s" % (
1152
                self.result(),
William Stein's avatar
William Stein committed
1153
                self.arg.py_result(),
1154
                code.error_goto_if_null(self.result(), self.pos)))
William Stein's avatar
William Stein committed
1155 1156 1157 1158 1159 1160 1161


class ImportNode(ExprNode):
    #  Used as part of import statement implementation.
    #  Implements result = 
    #    __import__(module_name, globals(), None, name_list)
    #
1162 1163
    #  module_name   IdentifierStringNode     dotted name of module
    #  name_list     ListNode or None         list of names to be imported
William Stein's avatar
William Stein committed
1164 1165 1166 1167 1168 1169 1170 1171 1172
    
    subexprs = ['module_name', 'name_list']

    def analyse_types(self, env):
        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)
        self.type = py_object_type
1173
        self.gil_check(env)
William Stein's avatar
William Stein committed
1174 1175
        self.is_temp = 1
        env.use_utility_code(import_utility_code)
1176 1177 1178

    gil_message = "Python import"

William Stein's avatar
William Stein committed
1179 1180 1181 1182 1183 1184
    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(
Robert Bradshaw's avatar
Robert Bradshaw committed
1185
            "%s = __Pyx_Import(%s, %s); %s" % (
1186
                self.result(),
William Stein's avatar
William Stein committed
1187 1188
                self.module_name.py_result(),
                name_list_code,
1189
                code.error_goto_if_null(self.result(), self.pos)))
William Stein's avatar
William Stein committed
1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203


class IteratorNode(ExprNode):
    #  Used as part of for statement implementation.
    #  Implements result = iter(sequence)
    #
    #  sequence   ExprNode
    
    subexprs = ['sequence']
    
    def analyse_types(self, env):
        self.sequence.analyse_types(env)
        self.sequence = self.sequence.coerce_to_pyobject(env)
        self.type = py_object_type
1204
        self.gil_check(env)
William Stein's avatar
William Stein committed
1205
        self.is_temp = 1
Robert Bradshaw's avatar
Robert Bradshaw committed
1206 1207 1208
        
        self.counter = TempNode(self.pos, PyrexTypes.c_py_ssize_t_type, env)
        self.counter.allocate_temp(env)
1209 1210 1211

    gil_message = "Iterating over Python object"

Robert Bradshaw's avatar
Robert Bradshaw committed
1212
    def release_temp(self, env):
1213
        env.release_temp(self.result())
Robert Bradshaw's avatar
Robert Bradshaw committed
1214
        self.counter.release_temp(env)
William Stein's avatar
William Stein committed
1215 1216 1217
    
    def generate_result_code(self, code):
        code.putln(
1218
            "if (PyList_CheckExact(%s) || PyTuple_CheckExact(%s)) {" % (
Robert Bradshaw's avatar
Robert Bradshaw committed
1219
                self.sequence.py_result(),
1220 1221 1222
                self.sequence.py_result()))
        code.putln(
            "%s = 0; %s = %s; Py_INCREF(%s);" % (
1223 1224
                self.counter.result(),
                self.result(),
Robert Bradshaw's avatar
Robert Bradshaw committed
1225
                self.sequence.py_result(),
1226
                self.result()))
1227 1228
        code.putln("} else {")
        code.putln("%s = -1; %s = PyObject_GetIter(%s); %s" % (
1229 1230
                self.counter.result(),
                self.result(),
William Stein's avatar
William Stein committed
1231
                self.sequence.py_result(),
1232
                code.error_goto_if_null(self.result(), self.pos)))
1233
        code.putln("}")
William Stein's avatar
William Stein committed
1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250


class NextNode(AtomicExprNode):
    #  Used as part of for statement implementation.
    #  Implements result = iterator.next()
    #  Created during analyse_types phase.
    #  The iterator is not owned by this node.
    #
    #  iterator   ExprNode
    
    def __init__(self, iterator, env):
        self.pos = iterator.pos
        self.iterator = iterator
        self.type = py_object_type
        self.is_temp = 1
    
    def generate_result_code(self, code):
1251 1252 1253 1254 1255
        for py_type in ["List", "Tuple"]:
            code.putln(
                "if (likely(Py%s_CheckExact(%s))) {" % (py_type, self.iterator.py_result()))
            code.putln(
                "if (%s >= Py%s_GET_SIZE(%s)) break;" % (
1256
                    self.iterator.counter.result(),
1257 1258 1259 1260
                    py_type,
                    self.iterator.py_result()))
            code.putln(
                "%s = Py%s_GET_ITEM(%s, %s); Py_INCREF(%s); %s++;" % (
1261
                    self.result(),
1262 1263
                    py_type,
                    self.iterator.py_result(),
1264 1265 1266
                    self.iterator.counter.result(),
                    self.result(),
                    self.iterator.counter.result()))
1267 1268
            code.put("} else ")
        code.putln("{")
William Stein's avatar
William Stein committed
1269 1270
        code.putln(
            "%s = PyIter_Next(%s);" % (
1271
                self.result(),
William Stein's avatar
William Stein committed
1272 1273 1274
                self.iterator.py_result()))
        code.putln(
            "if (!%s) {" %
1275
                self.result())
1276
        code.putln(code.error_goto_if_PyErr(self.pos))
Robert Bradshaw's avatar
Robert Bradshaw committed
1277 1278 1279
        code.putln("break;")
        code.putln("}")
        code.putln("}")
1280

William Stein's avatar
William Stein committed
1281 1282 1283 1284 1285 1286

class ExcValueNode(AtomicExprNode):
    #  Node created during analyse_types phase
    #  of an ExceptClauseNode to fetch the current
    #  exception value.
    
1287
    def __init__(self, pos, env, var):
William Stein's avatar
William Stein committed
1288 1289
        ExprNode.__init__(self, pos)
        self.type = py_object_type
1290
        self.var = var
William Stein's avatar
William Stein committed
1291
    
1292 1293 1294
    def calculate_result_code(self):
        return self.var

William Stein's avatar
William Stein committed
1295
    def generate_result_code(self, code):
1296
        pass
William Stein's avatar
William Stein committed
1297

1298 1299 1300
    def analyse_types(self, env):
        pass

William Stein's avatar
William Stein committed
1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311

class TempNode(AtomicExprNode):
    #  Node created during analyse_types phase
    #  of some nodes to hold a temporary value.
    
    def __init__(self, pos, type, env):
        ExprNode.__init__(self, pos)
        self.type = type
        if type.is_pyobject:
            self.result_ctype = py_object_type
        self.is_temp = 1
1312 1313 1314
        
    def analyse_types(self, env):
        return self.type
William Stein's avatar
William Stein committed
1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337
    
    def generate_result_code(self, code):
        pass


class PyTempNode(TempNode):
    #  TempNode holding a Python value.
    
    def __init__(self, pos, env):
        TempNode.__init__(self, pos, PyrexTypes.py_object_type, env)


#-------------------------------------------------------------------
#
#  Trailer nodes
#
#-------------------------------------------------------------------

class IndexNode(ExprNode):
    #  Sequence indexing.
    #
    #  base     ExprNode
    #  index    ExprNode
1338 1339 1340 1341 1342 1343
    #  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.
William Stein's avatar
William Stein committed
1344
    
1345 1346 1347 1348 1349 1350
    subexprs = ['base', 'index', 'indices']
    indices = None

    def __init__(self, pos, index, *args, **kw):
        ExprNode.__init__(self, pos, index=index, *args, **kw)
        self._index = index
William Stein's avatar
William Stein committed
1351
    
1352 1353 1354 1355 1356 1357 1358 1359
    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)
    
William Stein's avatar
William Stein committed
1360 1361 1362 1363 1364 1365 1366
    def is_ephemeral(self):
        return self.base.is_ephemeral()
    
    def analyse_target_declaration(self, env):
        pass
    
    def analyse_types(self, env):
Dag Sverre Seljebotn's avatar
Merge  
Dag Sverre Seljebotn committed
1367 1368 1369 1370
        self.analyse_base_and_index_types(env, getting = 1)
    
    def analyse_target_types(self, env):
        self.analyse_base_and_index_types(env, setting = 1)
1371

Dag Sverre Seljebotn's avatar
Merge  
Dag Sverre Seljebotn committed
1372
    def analyse_base_and_index_types(self, env, getting = 0, setting = 0):
1373 1374 1375
        # Note: This might be cleaned up by having IndexNode
        # parsed in a saner way and only construct the tuple if
        # needed.
1376 1377 1378 1379

        # 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.
1380 1381
        self.is_buffer_access = False

William Stein's avatar
William Stein committed
1382
        self.base.analyse_types(env)
1383 1384 1385
        # Handle the case where base is a literal char* (and we expect a string, not an int)
        if isinstance(self.base, StringNode):
            self.base = self.base.coerce_to_pyobject(env)
1386 1387 1388

        skip_child_analysis = False
        buffer_access = False
1389
        if self.base.type.is_buffer:
1390 1391 1392
            assert hasattr(self.base, "entry") # Must be a NameNode-like node
            if self.indices:
                indices = self.indices
1393
            else:
1394 1395 1396 1397 1398 1399
                # On cloning, indices is cloned. Otherwise, unpack index into indices
                assert not isinstance(self.index, CloneNode)
                if isinstance(self.index, TupleNode):
                    indices = self.index.args
                else:
                    indices = [self.index]
1400
            if len(indices) == self.base.type.ndim:
1401 1402 1403 1404 1405 1406
                buffer_access = True
                skip_child_analysis = True
                for x in indices:
                    x.analyse_types(env)
                    if not x.type.is_int:
                        buffer_access = False
1407

1408 1409
        if buffer_access:
            self.indices = indices
1410
            self.index = None
1411 1412
            self.type = self.base.type.dtype
            self.is_buffer_access = True
1413
            self.buffer_type = self.base.entry.type
1414
           
1415 1416 1417 1418
            if getting:
                # we only need a temp because result_code isn't refactored to
                # generation time, but this seems an ok shortcut to take
                self.is_temp = True
1419 1420 1421 1422 1423
            if setting:
                if not self.base.entry.type.writable:
                    error(self.pos, "Writing to readonly buffer")
                else:
                    self.base.entry.buffer_aux.writable_needed = True
1424
        else:
1425 1426 1427 1428
            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)
1429
            if self.base.type.is_pyobject:
1430
                if self.index.type.is_int and not self.index.type.is_longlong:
1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441
                    self.original_index_type = self.index.type
                    self.index = self.index.coerce_to(PyrexTypes.c_py_ssize_t_type, env).coerce_to_simple(env)
                    if getting:
                        env.use_utility_code(getitem_int_utility_code)
                    if setting:
                        env.use_utility_code(setitem_int_utility_code)
                else:
                    self.index = self.index.coerce_to_pyobject(env)
                self.type = py_object_type
                self.gil_check(env)
                self.is_temp = 1
William Stein's avatar
William Stein committed
1442
            else:
1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456
                if self.base.type.is_ptr or self.base.type.is_array:
                    self.type = self.base.type.base_type
                else:
                    error(self.pos,
                        "Attempting to index non-array type '%s'" %
                            self.base.type)
                    self.type = PyrexTypes.error_type
                if self.index.type.is_pyobject:
                    self.index = self.index.coerce_to(
                        PyrexTypes.c_py_ssize_t_type, env)
                if not self.index.type.is_int:
                    error(self.pos,
                        "Invalid index type '%s'" %
                            self.index.type)
1457 1458 1459

    gil_message = "Indexing Python object"

William Stein's avatar
William Stein committed
1460 1461 1462 1463 1464 1465 1466 1467
    def check_const_addr(self):
        self.base.check_const_addr()
        self.index.check_const()
    
    def is_lvalue(self):
        return 1
    
    def calculate_result_code(self):
1468
        if self.is_buffer_access:
1469
            return "<not used>"
1470 1471
        else:
            return "(%s[%s])" % (
1472
                self.base.result(), self.index.result())
Dag Sverre Seljebotn's avatar
Merge  
Dag Sverre Seljebotn committed
1473 1474 1475 1476 1477 1478 1479 1480 1481
            
    def index_unsigned_parameter(self):
        if self.index.type.is_int:
            if self.original_index_type.signed:
                return ", 0"
            else:
                return ", sizeof(Py_ssize_t) <= sizeof(%s)" % self.original_index_type.declaration_code("")
        else:
            return ""
1482 1483 1484

    def generate_subexpr_evaluation_code(self, code):
        self.base.generate_evaluation_code(code)
1485
        if not self.indices:
1486 1487
            self.index.generate_evaluation_code(code)
        else:
1488 1489
            for i in self.indices:
                i.generate_evaluation_code(code)
1490
        
1491 1492
    def generate_subexpr_disposal_code(self, code):
        self.base.generate_disposal_code(code)
1493
        if not self.indices:
1494 1495
            self.index.generate_disposal_code(code)
        else:
1496 1497
            for i in self.indices:
                i.generate_disposal_code(code)
1498

William Stein's avatar
William Stein committed
1499
    def generate_result_code(self, code):
1500
        if self.is_buffer_access:
1501 1502
            ptrcode = self.buffer_lookup_code(code)
            code.putln("%s = *%s;" % (
1503
                self.result(),
1504 1505 1506
                self.buffer_type.buffer_ptr_type.cast_code(ptrcode)))
            # Must incref the value we pulled out.
            if self.buffer_type.dtype.is_pyobject:
1507
                code.putln("Py_INCREF((PyObject*)%s);" % self.result())
1508
        elif self.type.is_pyobject:
1509
            if self.index.type.is_int:
Dag Sverre Seljebotn's avatar
Merge  
Dag Sverre Seljebotn committed
1510
                function = "__Pyx_GetItemInt"
1511
                index_code = self.index.result()
1512
            else:
Dag Sverre Seljebotn's avatar
Merge  
Dag Sverre Seljebotn committed
1513 1514 1515 1516 1517
                function = "PyObject_GetItem"
                index_code = self.index.py_result()
                sign_code = ""
            code.putln(
                "%s = %s(%s, %s%s); if (!%s) %s" % (
1518
                    self.result(),
Dag Sverre Seljebotn's avatar
Merge  
Dag Sverre Seljebotn committed
1519 1520 1521 1522
                    function,
                    self.base.py_result(),
                    index_code,
                    self.index_unsigned_parameter(),
1523
                    self.result(),
Dag Sverre Seljebotn's avatar
Merge  
Dag Sverre Seljebotn committed
1524
                    code.error_goto(self.pos)))
1525

Dag Sverre Seljebotn's avatar
Merge  
Dag Sverre Seljebotn committed
1526 1527 1528
    def generate_setitem_code(self, value_code, code):
        if self.index.type.is_int:
            function = "__Pyx_SetItemInt"
1529
            index_code = self.index.result()
Dag Sverre Seljebotn's avatar
Merge  
Dag Sverre Seljebotn committed
1530 1531 1532
        else:
            function = "PyObject_SetItem"
            index_code = self.index.py_result()
1533
        code.putln(
Dag Sverre Seljebotn's avatar
Merge  
Dag Sverre Seljebotn committed
1534 1535
            "if (%s(%s, %s, %s%s) < 0) %s" % (
                function,
1536
                self.base.py_result(),
Dag Sverre Seljebotn's avatar
Merge  
Dag Sverre Seljebotn committed
1537 1538 1539 1540
                index_code,
                value_code,
                self.index_unsigned_parameter(),
                code.error_goto(self.pos)))
1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551

    def generate_buffer_setitem_code(self, rhs, code, op=""):
        # Used from generate_assignment_code and InPlaceAssignmentNode
        ptrexpr = self.buffer_lookup_code(code)
        if self.buffer_type.dtype.is_pyobject:
            # Must manage refcounts. Decref what is already there
            # and incref what we put in.
            ptr = code.funcstate.allocate_temp(self.buffer_type.buffer_ptr_type)
            if rhs.is_temp:
                rhs_code = code.funcstate.allocate_temp(rhs.type)
            else:
1552
                rhs_code = rhs.result()
1553 1554 1555 1556 1557 1558 1559 1560 1561 1562
            code.putln("%s = %s;" % (ptr, ptrexpr))
            code.putln("Py_DECREF(*%s); Py_INCREF(%s);" % (
                ptr, rhs_code
                ))
            code.putln("*%s %s= %s;" % (ptr, op, rhs_code))
            if rhs.is_temp:
                code.funcstate.release_temp(rhs_code)
            code.funcstate.release_temp(ptr)
        else: 
            # Simple case
1563
            code.putln("*%s %s= %s;" % (ptrexpr, op, rhs.result()))
1564

William Stein's avatar
William Stein committed
1565 1566
    def generate_assignment_code(self, rhs, code):
        self.generate_subexpr_evaluation_code(code)
1567
        if self.is_buffer_access:
1568
            self.generate_buffer_setitem_code(rhs, code)
1569
        elif self.type.is_pyobject:
Dag Sverre Seljebotn's avatar
Merge  
Dag Sverre Seljebotn committed
1570
            self.generate_setitem_code(rhs.py_result(), code)
William Stein's avatar
William Stein committed
1571 1572 1573
        else:
            code.putln(
                "%s = %s;" % (
1574
                    self.result(), rhs.result()))
1575
        self.generate_subexpr_disposal_code(code)
William Stein's avatar
William Stein committed
1576 1577 1578 1579
        rhs.generate_disposal_code(code)
    
    def generate_deletion_code(self, code):
        self.generate_subexpr_evaluation_code(code)
Dag Sverre Seljebotn's avatar
Merge  
Dag Sverre Seljebotn committed
1580 1581 1582
        #if self.type.is_pyobject:
        if self.index.type.is_int:
            function = "PySequence_DelItem"
1583
            index_code = self.index.result()
Dag Sverre Seljebotn's avatar
Merge  
Dag Sverre Seljebotn committed
1584 1585 1586 1587 1588 1589
        else:
            function = "PyObject_DelItem"
            index_code = self.index.py_result()
        code.putln(
            "if (%s(%s, %s) < 0) %s" % (
                function,
William Stein's avatar
William Stein committed
1590
                self.base.py_result(),
Dag Sverre Seljebotn's avatar
Merge  
Dag Sverre Seljebotn committed
1591 1592
                index_code,
                code.error_goto(self.pos)))
William Stein's avatar
William Stein committed
1593
        self.generate_subexpr_disposal_code(code)
1594

1595
    def buffer_lookup_code(self, code):
1596
        # Assign indices to temps
1597
        index_temps = [code.funcstate.allocate_temp(i.type) for i in self.indices]
1598
        for temp, index in zip(index_temps, self.indices):
1599
            code.putln("%s = %s;" % (temp, index.result()))
1600 1601
        # Generate buffer access code using these temps
        import Buffer
1602 1603
        # The above could happen because child_attrs is wrong somewhere so that
        # options are not propagated.
1604 1605 1606
        return Buffer.put_buffer_lookup_code(entry=self.base.entry,
                                             index_signeds=[i.type.signed for i in self.indices],
                                             index_cnames=index_temps,
1607
                                             options=code.globalstate.directives,
1608
                                             pos=self.pos, code=code)
William Stein's avatar
William Stein committed
1609 1610 1611 1612 1613 1614 1615 1616 1617 1618

class SliceIndexNode(ExprNode):
    #  2-element slice indexing
    #
    #  base      ExprNode
    #  start     ExprNode or None
    #  stop      ExprNode or None
    
    subexprs = ['base', 'start', 'stop']
    
1619 1620 1621 1622 1623 1624 1625 1626 1627
    def compile_time_value(self, denv):
        base = self.base.compile_time_value(denv)
        start = self.start.compile_time_value(denv)
        stop = self.stop.compile_time_value(denv)
        try:
            return base[start:stop]
        except Exception, e:
            self.compile_time_value_error(e)
    
William Stein's avatar
William Stein committed
1628 1629 1630 1631 1632 1633 1634 1635 1636 1637
    def analyse_target_declaration(self, env):
        pass

    def analyse_types(self, env):
        self.base.analyse_types(env)
        if self.start:
            self.start.analyse_types(env)
        if self.stop:
            self.stop.analyse_types(env)
        self.base = self.base.coerce_to_pyobject(env)
1638
        c_int = PyrexTypes.c_py_ssize_t_type
William Stein's avatar
William Stein committed
1639 1640 1641 1642 1643
        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.type = py_object_type
1644
        self.gil_check(env)
William Stein's avatar
William Stein committed
1645
        self.is_temp = 1
1646 1647 1648

    gil_message = "Slicing Python object"

William Stein's avatar
William Stein committed
1649 1650
    def generate_result_code(self, code):
        code.putln(
Robert Bradshaw's avatar
Robert Bradshaw committed
1651
            "%s = PySequence_GetSlice(%s, %s, %s); %s" % (
1652
                self.result(),
William Stein's avatar
William Stein committed
1653 1654 1655
                self.base.py_result(),
                self.start_code(),
                self.stop_code(),
1656
                code.error_goto_if_null(self.result(), self.pos)))
William Stein's avatar
William Stein committed
1657 1658 1659
    
    def generate_assignment_code(self, rhs, code):
        self.generate_subexpr_evaluation_code(code)
Robert Bradshaw's avatar
Robert Bradshaw committed
1660 1661
        code.put_error_if_neg(self.pos, 
            "PySequence_SetSlice(%s, %s, %s, %s)" % (
William Stein's avatar
William Stein committed
1662 1663 1664
                self.base.py_result(),
                self.start_code(),
                self.stop_code(),
1665
                rhs.result()))
William Stein's avatar
William Stein committed
1666 1667 1668 1669 1670
        self.generate_subexpr_disposal_code(code)
        rhs.generate_disposal_code(code)

    def generate_deletion_code(self, code):
        self.generate_subexpr_evaluation_code(code)
Robert Bradshaw's avatar
Robert Bradshaw committed
1671 1672
        code.put_error_if_neg(self.pos,
            "PySequence_DelSlice(%s, %s, %s)" % (
William Stein's avatar
William Stein committed
1673 1674
                self.base.py_result(),
                self.start_code(),
Robert Bradshaw's avatar
Robert Bradshaw committed
1675
                self.stop_code()))
William Stein's avatar
William Stein committed
1676 1677 1678 1679
        self.generate_subexpr_disposal_code(code)
    
    def start_code(self):
        if self.start:
1680
            return self.start.result()
William Stein's avatar
William Stein committed
1681 1682 1683 1684 1685
        else:
            return "0"
    
    def stop_code(self):
        if self.stop:
1686
            return self.stop.result()
William Stein's avatar
William Stein committed
1687
        else:
1688
            return "PY_SSIZE_T_MAX"
William Stein's avatar
William Stein committed
1689 1690
    
    def calculate_result_code(self):
1691
        # self.result() is not used, but this method must exist
William Stein's avatar
William Stein committed
1692 1693 1694 1695 1696 1697 1698 1699 1700 1701
        return "<unused>"
    

class SliceNode(ExprNode):
    #  start:stop:step in subscript list
    #
    #  start     ExprNode
    #  stop      ExprNode
    #  step      ExprNode
    
1702 1703 1704 1705 1706 1707 1708 1709 1710
    def compile_time_value(self, denv):
        start = self.start.compile_time_value(denv)
        stop = self.stop.compile_time_value(denv)
        step = step.step.compile_time_value(denv)
        try:
            return slice(start, stop, step)
        except Exception, e:
            self.compile_time_value_error(e)

William Stein's avatar
William Stein committed
1711 1712 1713 1714 1715 1716 1717 1718 1719 1720
    subexprs = ['start', 'stop', 'step']
    
    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)
        self.type = py_object_type
1721
        self.gil_check(env)
William Stein's avatar
William Stein committed
1722
        self.is_temp = 1
1723 1724 1725

    gil_message = "Constructing Python slice object"

William Stein's avatar
William Stein committed
1726 1727
    def generate_result_code(self, code):
        code.putln(
Robert Bradshaw's avatar
Robert Bradshaw committed
1728
            "%s = PySlice_New(%s, %s, %s); %s" % (
1729
                self.result(),
William Stein's avatar
William Stein committed
1730 1731 1732
                self.start.py_result(), 
                self.stop.py_result(), 
                self.step.py_result(),
1733
                code.error_goto_if_null(self.result(), self.pos)))
William Stein's avatar
William Stein committed
1734

1735 1736 1737 1738 1739 1740 1741 1742 1743

class CallNode(ExprNode):
    def gil_check(self, env):
        # Make sure we're not in a nogil environment
        if env.nogil:
            error(self.pos, "Calling gil-requiring function without gil")


class SimpleCallNode(CallNode):
William Stein's avatar
William Stein committed
1744 1745 1746 1747 1748 1749 1750
    #  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
1751
    #  wrapper_call   bool                 used internally
1752
    #  has_optional_args   bool            used internally
William Stein's avatar
William Stein committed
1753 1754 1755 1756 1757 1758
    
    subexprs = ['self', 'coerced_self', 'function', 'args', 'arg_tuple']
    
    self = None
    coerced_self = None
    arg_tuple = None
1759
    wrapper_call = False
1760
    has_optional_args = False
William Stein's avatar
William Stein committed
1761
    
1762 1763 1764 1765 1766 1767 1768 1769
    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)

William Stein's avatar
William Stein committed
1770 1771 1772 1773
    def analyse_types(self, env):
        function = self.function
        function.is_called = 1
        self.function.analyse_types(env)
Robert Bradshaw's avatar
Robert Bradshaw committed
1774 1775 1776 1777 1778 1779 1780 1781 1782
        if function.is_attribute and function.is_py_attr and \
           function.attribute == "append" and len(self.args) == 1:
            # L.append(x) is almost always applied to a list
            self.py_func = self.function
            self.function = NameNode(pos=self.function.pos, name="__Pyx_PyObject_Append")
            self.function.analyse_types(env)
            self.self = self.py_func.obj
            function.obj = CloneNode(self.self)
            env.use_utility_code(append_utility_code)
William Stein's avatar
William Stein committed
1783 1784 1785 1786 1787 1788 1789
        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)
        func_type = self.function_type()
        if func_type.is_pyobject:
1790 1791
            self.arg_tuple = TupleNode(self.pos, args = self.args)
            self.arg_tuple.analyse_types(env)
William Stein's avatar
William Stein committed
1792 1793
            self.args = None
            self.type = py_object_type
1794
            self.gil_check(env)
William Stein's avatar
William Stein committed
1795 1796 1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822 1823 1824 1825 1826
            self.is_temp = 1
        else:
            for arg in self.args:
                arg.analyse_types(env)
            if self.self and func_type.args:
                # Coerce 'self' to the type expected by the method.
                expected_type = func_type.args[0].type
                self.coerced_self = CloneNode(self.self).coerce_to(
                    expected_type, env)
                # Insert coerced 'self' argument into argument list.
                self.args.insert(0, self.coerced_self)
            self.analyse_c_function_call(env)
    
    def function_type(self):
        # Return the type of the function being called, coercing a function
        # pointer to a function if necessary.
        func_type = self.function.type
        if func_type.is_ptr:
            func_type = func_type.base_type
        return func_type
    
    def analyse_c_function_call(self, env):
        func_type = self.function_type()
        # Check function type
        if not func_type.is_cfunction:
            if not func_type.is_error:
                error(self.pos, "Calling non-function type '%s'" %
                    func_type)
            self.type = PyrexTypes.error_type
            self.result_code = "<error>"
            return
        # Check no. of args
1827 1828
        max_nargs = len(func_type.args)
        expected_nargs = max_nargs - func_type.optional_arg_count
William Stein's avatar
William Stein committed
1829 1830
        actual_nargs = len(self.args)
        if actual_nargs < expected_nargs \
1831
            or (not func_type.has_varargs and actual_nargs > max_nargs):
William Stein's avatar
William Stein committed
1832 1833 1834
                expected_str = str(expected_nargs)
                if func_type.has_varargs:
                    expected_str = "at least " + expected_str
1835
                elif func_type.optional_arg_count:
1836
                    if actual_nargs < max_nargs:
1837 1838 1839
                        expected_str = "at least " + expected_str
                    else:
                        expected_str = "at most " + str(max_nargs)
William Stein's avatar
William Stein committed
1840 1841 1842 1843 1844 1845 1846
                error(self.pos, 
                    "Call with wrong number of arguments (expected %s, got %s)"
                        % (expected_str, actual_nargs))
                self.args = None
                self.type = PyrexTypes.error_type
                self.result_code = "<error>"
                return
1847 1848 1849 1850 1851
        if func_type.optional_arg_count and expected_nargs != actual_nargs:
            self.has_optional_args = 1
            self.is_temp = 1
            self.opt_arg_struct = env.allocate_temp(func_type.op_arg_struct.base_type)
            env.release_temp(self.opt_arg_struct)
William Stein's avatar
William Stein committed
1852
        # Coerce arguments
1853
        for i in range(min(max_nargs, actual_nargs)):
William Stein's avatar
William Stein committed
1854 1855
            formal_type = func_type.args[i].type
            self.args[i] = self.args[i].coerce_to(formal_type, env)
1856
        for i in range(max_nargs, actual_nargs):
William Stein's avatar
William Stein committed
1857 1858 1859 1860 1861
            if self.args[i].type.is_pyobject:
                error(self.args[i].pos, 
                    "Python object cannot be passed as a varargs parameter")
        # Calc result type and code fragment
        self.type = func_type.return_type
1862 1863 1864
        if self.type.is_pyobject \
            or func_type.exception_value is not None \
            or func_type.exception_check:
William Stein's avatar
William Stein committed
1865
                self.is_temp = 1
1866 1867
                if self.type.is_pyobject:
                    self.result_ctype = py_object_type
Robert Bradshaw's avatar
Robert Bradshaw committed
1868 1869 1870 1871
        # C++ exception handler
        if func_type.exception_check == '+':
            if func_type.exception_value is None:
                env.use_utility_code(cpp_exception_utility_code)
1872 1873 1874
        # Check gil
        if not func_type.nogil:
            self.gil_check(env)
Robert Bradshaw's avatar
Robert Bradshaw committed
1875

William Stein's avatar
William Stein committed
1876 1877 1878 1879 1880 1881 1882 1883 1884
    def calculate_result_code(self):
        return self.c_call_code()
    
    def c_call_code(self):
        func_type = self.function_type()
        if self.args is None or not func_type.is_cfunction:
            return "<error>"
        formal_args = func_type.args
        arg_list_code = []
1885 1886 1887 1888 1889
        args = zip(formal_args, self.args)
        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
1890 1891
                arg_code = actual_arg.result_as(formal_arg.type)
                arg_list_code.append(arg_code)
1892
                
1893 1894 1895
        if func_type.is_overridable:
            arg_list_code.append(str(int(self.wrapper_call or self.function.entry.is_unbound_cmethod)))
                
1896
        if func_type.optional_arg_count:
1897
            if expected_nargs == actual_nargs:
1898
                optional_args = 'NULL'
1899
            else:
1900
                optional_args = "&%s" % self.opt_arg_struct
1901
            arg_list_code.append(optional_args)
1902
            
William Stein's avatar
William Stein committed
1903
        for actual_arg in self.args[len(formal_args):]:
1904 1905
            arg_list_code.append(actual_arg.result())
        result = "%s(%s)" % (self.function.result(),
1906
            join(arg_list_code, ", "))
1907 1908 1909
#        if self.wrapper_call or \
#                self.function.entry.is_unbound_cmethod and self.function.entry.type.is_overridable:
#            result = "(%s = 1, %s)" % (Naming.skip_dispatch_cname, result)
William Stein's avatar
William Stein committed
1910 1911 1912 1913 1914
        return result
    
    def generate_result_code(self, code):
        func_type = self.function_type()
        if func_type.is_pyobject:
1915
            arg_code = self.arg_tuple.py_result()
William Stein's avatar
William Stein committed
1916
            code.putln(
1917
                "%s = PyObject_Call(%s, %s, NULL); %s" % (
1918
                    self.result(),
William Stein's avatar
William Stein committed
1919
                    self.function.py_result(),
1920
                    arg_code,
1921
                    code.error_goto_if_null(self.result(), self.pos)))
William Stein's avatar
William Stein committed
1922
        elif func_type.is_cfunction:
1923 1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934 1935
            if self.has_optional_args:
                actual_nargs = len(self.args)
                expected_nargs = len(func_type.args) - func_type.optional_arg_count
                code.putln("%s.%s = %s;" % (
                        self.opt_arg_struct,
                        Naming.pyrex_prefix + "n",
                        len(self.args) - expected_nargs))
                args = zip(func_type.args, self.args)
                for formal_arg, actual_arg in args[expected_nargs:actual_nargs]:
                    code.putln("%s.%s = %s;" % (
                            self.opt_arg_struct,
                            formal_arg.name,
                            actual_arg.result_as(formal_arg.type)))
William Stein's avatar
William Stein committed
1936 1937
            exc_checks = []
            if self.type.is_pyobject:
1938
                exc_checks.append("!%s" % self.result())
William Stein's avatar
William Stein committed
1939
            else:
1940 1941
                exc_val = func_type.exception_value
                exc_check = func_type.exception_check
William Stein's avatar
William Stein committed
1942
                if exc_val is not None:
1943
                    exc_checks.append("%s == %s" % (self.result(), exc_val))
William Stein's avatar
William Stein committed
1944 1945 1946 1947
                if exc_check:
                    exc_checks.append("PyErr_Occurred()")
            if self.is_temp or exc_checks:
                rhs = self.c_call_code()
1948 1949
                if self.result():
                    lhs = "%s = " % self.result()
William Stein's avatar
William Stein committed
1950 1951 1952 1953 1954 1955 1956
                    if self.is_temp and self.type.is_pyobject:
                        #return_type = self.type # func_type.return_type
                        #print "SimpleCallNode.generate_result_code: casting", rhs, \
                        #	"from", return_type, "to pyobject" ###
                        rhs = typecast(py_object_type, self.type, rhs)
                else:
                    lhs = ""
Felix Wu's avatar
Felix Wu committed
1957
                if func_type.exception_check == '+':
Robert Bradshaw's avatar
Robert Bradshaw committed
1958 1959 1960 1961 1962 1963
                    if func_type.exception_value is None:
                        raise_py_exception = "__Pyx_CppExn2PyErr()"
                    elif func_type.exception_value.type.is_pyobject:
                        raise_py_exception = 'PyErr_SetString(%s, "")' % func_type.exception_value.entry.cname
                    else:
                        raise_py_exception = '%s(); if (!PyErr_Occurred()) PyErr_SetString(PyExc_RuntimeError , "Error converting c++ exception.")' % func_type.exception_value.entry.cname
Felix Wu's avatar
Felix Wu committed
1964
                    code.putln(
Robert Bradshaw's avatar
Robert Bradshaw committed
1965
                    "try {%s%s;} catch(...) {%s; %s}" % (
Felix Wu's avatar
Felix Wu committed
1966 1967
                        lhs,
                        rhs,
Robert Bradshaw's avatar
Robert Bradshaw committed
1968
                        raise_py_exception,
Felix Wu's avatar
Felix Wu committed
1969
                        code.error_goto(self.pos)))
1970 1971 1972 1973 1974 1975
                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))
William Stein's avatar
William Stein committed
1976

1977
class GeneralCallNode(CallNode):
William Stein's avatar
William Stein committed
1978 1979 1980 1981 1982 1983 1984 1985 1986 1987
    #  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
    #  starstar_arg     ExprNode or None  Dict of extra keyword args
    
    subexprs = ['function', 'positional_args', 'keyword_args', 'starstar_arg']

1988 1989 1990 1991 1992 1993 1994 1995 1996 1997 1998
    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)
        starstar_arg = self.starstar_arg.compile_time_value(denv)
        try:
            keyword_args.update(starstar_arg)
            return function(*positional_args, **keyword_args)
        except Exception, e:
            self.compile_time_value_error(e)

William Stein's avatar
William Stein committed
1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012
    def analyse_types(self, env):
        self.function.analyse_types(env)
        self.positional_args.analyse_types(env)
        if self.keyword_args:
            self.keyword_args.analyse_types(env)
        if self.starstar_arg:
            self.starstar_arg.analyse_types(env)
        self.function = self.function.coerce_to_pyobject(env)
        self.positional_args = \
            self.positional_args.coerce_to_pyobject(env)
        if self.starstar_arg:
            self.starstar_arg = \
                self.starstar_arg.coerce_to_pyobject(env)
        self.type = py_object_type
2013
        self.gil_check(env)
William Stein's avatar
William Stein committed
2014 2015 2016 2017
        self.is_temp = 1
        
    def generate_result_code(self, code):
        if self.keyword_args and self.starstar_arg:
Robert Bradshaw's avatar
Robert Bradshaw committed
2018 2019
            code.put_error_if_neg(self.pos, 
                "PyDict_Update(%s, %s)" % (
William Stein's avatar
William Stein committed
2020
                    self.keyword_args.py_result(), 
Robert Bradshaw's avatar
Robert Bradshaw committed
2021
                    self.starstar_arg.py_result()))
William Stein's avatar
William Stein committed
2022 2023 2024 2025 2026 2027 2028 2029
            keyword_code = self.keyword_args.py_result()
        elif self.keyword_args:
            keyword_code = self.keyword_args.py_result()
        elif self.starstar_arg:
            keyword_code = self.starstar_arg.py_result()
        else:
            keyword_code = None
        if not keyword_code:
2030
            call_code = "PyObject_Call(%s, %s, NULL)" % (
William Stein's avatar
William Stein committed
2031 2032 2033 2034 2035 2036 2037 2038
                self.function.py_result(),
                self.positional_args.py_result())
        else:
            call_code = "PyEval_CallObjectWithKeywords(%s, %s, %s)" % (
                self.function.py_result(),
                self.positional_args.py_result(),
                keyword_code)
        code.putln(
Robert Bradshaw's avatar
Robert Bradshaw committed
2039
            "%s = %s; %s" % (
2040
                self.result(),
William Stein's avatar
William Stein committed
2041
                call_code,
2042
                code.error_goto_if_null(self.result(), self.pos)))
William Stein's avatar
William Stein committed
2043 2044 2045 2046 2047 2048 2049 2050 2051 2052


class AsTupleNode(ExprNode):
    #  Convert argument to tuple. Used for normalising
    #  the * argument of a function call.
    #
    #  arg    ExprNode
    
    subexprs = ['arg']
    
2053 2054 2055 2056 2057 2058 2059
    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
2060 2061 2062 2063
    def analyse_types(self, env):
        self.arg.analyse_types(env)
        self.arg = self.arg.coerce_to_pyobject(env)
        self.type = py_object_type
2064
        self.gil_check(env)
William Stein's avatar
William Stein committed
2065
        self.is_temp = 1
2066 2067 2068

    gil_message = "Constructing Python tuple"

William Stein's avatar
William Stein committed
2069 2070
    def generate_result_code(self, code):
        code.putln(
Robert Bradshaw's avatar
Robert Bradshaw committed
2071
            "%s = PySequence_Tuple(%s); %s" % (
2072
                self.result(),
William Stein's avatar
William Stein committed
2073
                self.arg.py_result(),
2074
                code.error_goto_if_null(self.result(), self.pos)))
William Stein's avatar
William Stein committed
2075 2076 2077 2078 2079 2080 2081
    

class AttributeNode(ExprNode):
    #  obj.attribute
    #
    #  obj          ExprNode
    #  attribute    string
2082
    #  needs_none_check boolean        Used if obj is an extension type.
2083
    #                                  If set to True, it is known that the type is not None.
William Stein's avatar
William Stein committed
2084 2085 2086 2087 2088 2089 2090
    #
    #  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
Stefan Behnel's avatar
Stefan Behnel committed
2091
    #  interned_attr_cname  string    C name of interned attribute name
William Stein's avatar
William Stein committed
2092 2093 2094 2095 2096 2097 2098
    
    is_attribute = 1
    subexprs = ['obj']
    
    type = PyrexTypes.error_type
    entry = None
    is_called = 0
2099
    needs_none_check = True
William Stein's avatar
William Stein committed
2100

2101 2102 2103 2104 2105 2106 2107 2108 2109 2110 2111
    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
                self.analyse_as_python_attribute(env) 
                return self
2112
        return ExprNode.coerce_to(self, dst_type, env)
2113
    
2114 2115 2116 2117 2118 2119 2120 2121 2122 2123 2124 2125
    def compile_time_value(self, denv):
        attr = self.attribute
        if attr.beginswith("__") and attr.endswith("__"):
            self.error("Invalid attribute name '%s' in compile-time expression"
                % attr)
            return None
        obj = self.arg.compile_time_value(denv)
        try:
            return getattr(obj, attr)
        except Exception, e:
            self.compile_time_value_error(e)

William Stein's avatar
William Stein committed
2126 2127 2128 2129 2130 2131 2132 2133 2134 2135 2136 2137 2138 2139 2140 2141 2142 2143 2144 2145 2146 2147 2148 2149 2150 2151 2152 2153 2154 2155 2156 2157 2158 2159 2160 2161 2162 2163 2164 2165 2166 2167 2168 2169
    def analyse_target_declaration(self, env):
        pass
    
    def analyse_target_types(self, env):
        self.analyse_types(env, target = 1)
    
    def analyse_types(self, env, target = 0):
        if self.analyse_as_cimported_attribute(env, target):
            return
        if not target and self.analyse_as_unbound_cmethod(env):
            return
        self.analyse_as_ordinary_attribute(env, target)
    
    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)
                    return 1
        return 0
    
    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
2170
                ubcm_entry.is_unbound_cmethod = 1
William Stein's avatar
William Stein committed
2171 2172 2173 2174 2175 2176 2177 2178 2179 2180 2181 2182 2183 2184 2185 2186 2187 2188 2189 2190 2191 2192 2193 2194 2195 2196 2197 2198 2199 2200 2201 2202 2203 2204 2205
                self.mutate_into_name_node(env, ubcm_entry, None)
                return 1
        return 0
    
    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
    
    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
                
    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:
2206
            NameNode.analyse_rvalue_entry(self, env)
William Stein's avatar
William Stein committed
2207 2208 2209 2210 2211
    
    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:
2212 2213
#            error(self.pos, "C method can only be called")
            pass
2214 2215 2216
        ## Reference to C array turns into pointer to first element.
        #while self.type.is_array:
        #	self.type = self.type.element_ptr_type()
William Stein's avatar
William Stein committed
2217 2218 2219 2220 2221 2222 2223 2224 2225 2226 2227 2228
        if self.is_py_attr:
            if not target:
                self.is_temp = 1
                self.result_ctype = py_object_type
    
    def analyse_attribute(self, env):
        # Look up attribute and set self.type and self.member.
        self.is_py_attr = 0
        self.member = self.attribute
        if self.obj.type.is_string:
            self.obj = self.obj.coerce_to_pyobject(env)
        obj_type = self.obj.type
2229
        if obj_type.is_ptr or obj_type.is_array:
William Stein's avatar
William Stein committed
2230 2231 2232 2233 2234 2235 2236 2237 2238 2239
            obj_type = obj_type.base_type
            self.op = "->"
        elif obj_type.is_extension_type:
            self.op = "->"
        else:
            self.op = "."
        if obj_type.has_attributes:
            entry = None
            if obj_type.attributes_known():
                entry = obj_type.scope.lookup_here(self.attribute)
Robert Bradshaw's avatar
Robert Bradshaw committed
2240 2241
                if entry and entry.is_member:
                    entry = None
William Stein's avatar
William Stein committed
2242 2243 2244 2245
            else:
                error(self.pos, 
                    "Cannot select attribute of incomplete type '%s'" 
                    % obj_type)
Robert Bradshaw's avatar
Robert Bradshaw committed
2246 2247
                self.type = PyrexTypes.error_type
                return
William Stein's avatar
William Stein committed
2248 2249
            self.entry = entry
            if entry:
2250 2251
                if obj_type.is_extension_type and entry.name == "__weakref__":
                    error(self.pos, "Illegal use of special attribute __weakref__")
2252 2253
                # methods need the normal attribute lookup
                # because they do not have struct entries
2254 2255 2256 2257
                if entry.is_variable or entry.is_cmethod:
                    self.type = entry.type
                    self.member = entry.cname
                    return
William Stein's avatar
William Stein committed
2258 2259 2260 2261 2262 2263 2264 2265 2266
                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
        # If we get here, the base object is not a struct/union/extension 
        # 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.
2267 2268 2269 2270 2271
        self.analyse_as_python_attribute(env)
                    
    def analyse_as_python_attribute(self, env):
        obj_type = self.obj.type
        self.member = self.attribute
William Stein's avatar
William Stein committed
2272 2273 2274
        if obj_type.is_pyobject:
            self.type = py_object_type
            self.is_py_attr = 1
2275
            self.interned_attr_cname = env.intern_identifier(self.attribute)
2276
            self.gil_check(env)
William Stein's avatar
William Stein committed
2277 2278 2279 2280 2281
        else:
            if not obj_type.is_error:
                error(self.pos, 
                    "Object of type '%s' has no attribute '%s'" %
                    (obj_type, self.attribute))
2282 2283 2284

    gil_message = "Accessing Python attribute"

William Stein's avatar
William Stein committed
2285 2286 2287 2288 2289 2290 2291 2292 2293 2294 2295 2296 2297 2298 2299 2300 2301 2302 2303 2304
    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:
            return 1
        else:
            return NameNode.is_lvalue(self)
    
    def is_ephemeral(self):
        if self.obj:
            return self.obj.is_ephemeral()
        else:
            return NameNode.is_ephemeral(self)
    
    def calculate_result_code(self):
        #print "AttributeNode.calculate_result_code:", self.member ###
2305
        #print "...obj node =", self.obj, "code", self.obj.result() ###
William Stein's avatar
William Stein committed
2306 2307 2308 2309 2310
        #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:
Robert Bradshaw's avatar
Robert Bradshaw committed
2311 2312 2313 2314 2315 2316
            if obj.type.is_extension_type:
                return "((struct %s *)%s%s%s)->%s" % (
                    obj.type.vtabstruct_cname, obj_code, self.op, 
                    obj.type.vtabslot_cname, self.member)
            else:
                return self.member
William Stein's avatar
William Stein committed
2317 2318 2319 2320 2321
        else:
            return "%s%s%s" % (obj_code, self.op, self.member)
    
    def generate_result_code(self, code):
        if self.is_py_attr:
2322 2323
            code.putln(
                '%s = PyObject_GetAttr(%s, %s); %s' % (
2324
                    self.result(),
2325 2326
                    self.obj.py_result(),
                    self.interned_attr_cname,
2327
                    code.error_goto_if_null(self.result(), self.pos)))
2328 2329 2330
        else:
            # result_code contains what is needed, but we may need to insert
            # a check and raise an exception
2331 2332 2333 2334
            if (self.obj.type.is_extension_type
                  and self.needs_none_check
                  and code.globalstate.directives['nonecheck']):
                self.put_nonecheck(code)
William Stein's avatar
William Stein committed
2335 2336 2337 2338
    
    def generate_assignment_code(self, rhs, code):
        self.obj.generate_evaluation_code(code)
        if self.is_py_attr:
2339 2340 2341 2342 2343
            code.put_error_if_neg(self.pos, 
                'PyObject_SetAttr(%s, %s, %s)' % (
                    self.obj.py_result(),
                    self.interned_attr_cname,
                    rhs.py_result()))
William Stein's avatar
William Stein committed
2344 2345
            rhs.generate_disposal_code(code)
        else:
2346 2347 2348 2349 2350
            if (self.obj.type.is_extension_type
                  and self.needs_none_check
                  and code.globalstate.directives['nonecheck']):
                self.put_nonecheck(code)

2351
            select_code = self.result()
William Stein's avatar
William Stein committed
2352 2353 2354 2355 2356 2357
            if self.type.is_pyobject:
                rhs.make_owned_reference(code)
                code.put_decref(select_code, self.ctype())
            code.putln(
                "%s = %s;" % (
                    select_code,
2358
                    rhs.result_as(self.ctype())))
2359
                    #rhs.result()))
William Stein's avatar
William Stein committed
2360 2361 2362 2363 2364 2365
            rhs.generate_post_assignment_code(code)
        self.obj.generate_disposal_code(code)
    
    def generate_deletion_code(self, code):
        self.obj.generate_evaluation_code(code)
        if self.is_py_attr:
2366 2367 2368 2369
            code.put_error_if_neg(self.pos,
                'PyObject_DelAttr(%s, %s)' % (
                    self.obj.py_result(),
                    self.interned_attr_cname))
William Stein's avatar
William Stein committed
2370 2371 2372
        else:
            error(self.pos, "Cannot delete C attribute of extension type")
        self.obj.generate_disposal_code(code)
2373 2374 2375 2376 2377 2378
        
    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
2379

2380 2381 2382 2383 2384 2385 2386 2387
    def put_nonecheck(self, code):
        code.globalstate.use_utility_code(raise_noneattr_error_utility_code)
        code.putln("if (%s) {" % code.unlikely("%s == Py_None") % self.obj.result_as(PyrexTypes.py_object_type))
        code.putln("__Pyx_RaiseNoneAttributeError(\"%s\");" % self.attribute.encode("UTF-8")) # todo: fix encoding
        code.putln(code.error_goto(self.pos))
        code.putln("}")


William Stein's avatar
William Stein committed
2388 2389 2390 2391 2392 2393 2394 2395 2396 2397 2398
#-------------------------------------------------------------------
#
#  Constructor nodes
#
#-------------------------------------------------------------------

class SequenceNode(ExprNode):
    #  Base class for list and tuple constructor nodes.
    #  Contains common code for performing sequence unpacking.
    #
    #  args                    [ExprNode]
2399
    #  iterator                ExprNode
William Stein's avatar
William Stein committed
2400 2401 2402 2403 2404 2405 2406 2407
    #  unpacked_items          [ExprNode] or None
    #  coerced_unpacked_items  [ExprNode] or None
    
    subexprs = ['args']
    
    is_sequence_constructor = 1
    unpacked_items = None
    
2408 2409 2410
    def compile_time_value_list(self, denv):
        return [arg.compile_time_value(denv) for arg in self.args]

William Stein's avatar
William Stein committed
2411 2412 2413 2414
    def analyse_target_declaration(self, env):
        for arg in self.args:
            arg.analyse_target_declaration(env)

2415
    def analyse_types(self, env, skip_children=False):
William Stein's avatar
William Stein committed
2416 2417
        for i in range(len(self.args)):
            arg = self.args[i]
2418
            if not skip_children: arg.analyse_types(env)
William Stein's avatar
William Stein committed
2419 2420
            self.args[i] = arg.coerce_to_pyobject(env)
        self.type = py_object_type
2421
        self.gil_check(env)
William Stein's avatar
William Stein committed
2422
        self.is_temp = 1
2423

William Stein's avatar
William Stein committed
2424
    def analyse_target_types(self, env):
2425 2426
        self.iterator = PyTempNode(self.pos, env)
        self.unpacked_items = []
William Stein's avatar
William Stein committed
2427 2428 2429 2430 2431 2432 2433 2434 2435 2436
        self.coerced_unpacked_items = []
        for arg in self.args:
            arg.analyse_target_types(env)
            unpacked_item = PyTempNode(self.pos, env)
            coerced_unpacked_item = unpacked_item.coerce_to(arg.type, env)
            self.unpacked_items.append(unpacked_item)
            self.coerced_unpacked_items.append(coerced_unpacked_item)
        self.type = py_object_type
        env.use_utility_code(unpacking_utility_code)
    
2437 2438 2439
    def allocate_target_temps(self, env, rhs):
        self.iterator.allocate_temps(env)
        for arg, node in zip(self.args, self.coerced_unpacked_items):
William Stein's avatar
William Stein committed
2440
            node.allocate_temps(env)
2441 2442 2443
            arg.allocate_target_temps(env, node)
            #arg.release_target_temp(env)
            #node.release_temp(env)
2444 2445
        if rhs:
            rhs.release_temp(env)
2446 2447 2448 2449 2450 2451 2452 2453
        self.iterator.release_temp(env)
    
#	def release_target_temp(self, env):
#		#for arg in self.args:
#		#	arg.release_target_temp(env)
#		#for node in self.coerced_unpacked_items:
#		#	node.release_temp(env)
#		self.iterator.release_temp(env)
William Stein's avatar
William Stein committed
2454 2455 2456 2457 2458
    
    def generate_result_code(self, code):
        self.generate_operation_code(code)
    
    def generate_assignment_code(self, rhs, code):
Robert Bradshaw's avatar
Robert Bradshaw committed
2459 2460 2461 2462 2463
        code.putln(
            "if (PyTuple_CheckExact(%s) && PyTuple_GET_SIZE(%s) == %s) {" % (
                rhs.py_result(), 
                rhs.py_result(), 
                len(self.args)))
Stefan Behnel's avatar
Stefan Behnel committed
2464
        code.putln("PyObject* tuple = %s;" % rhs.py_result())
Robert Bradshaw's avatar
Robert Bradshaw committed
2465 2466 2467
        for i in range(len(self.args)):
            item = self.unpacked_items[i]
            code.putln(
Stefan Behnel's avatar
Stefan Behnel committed
2468
                "%s = PyTuple_GET_ITEM(tuple, %s);" % (
2469
                    item.result(),
Robert Bradshaw's avatar
Robert Bradshaw committed
2470
                    i))
2471
            code.put_incref(item.result(), item.ctype())
Robert Bradshaw's avatar
Robert Bradshaw committed
2472 2473 2474 2475
            value_node = self.coerced_unpacked_items[i]
            value_node.generate_evaluation_code(code)
            self.args[i].generate_assignment_code(value_node, code)
            
2476
        rhs.generate_disposal_code(code)
Robert Bradshaw's avatar
Robert Bradshaw committed
2477 2478 2479
        code.putln("}")
        code.putln("else {")

2480
        code.putln(
Robert Bradshaw's avatar
Robert Bradshaw committed
2481
            "%s = PyObject_GetIter(%s); %s" % (
2482
                self.iterator.result(),
2483
                rhs.py_result(),
2484
                code.error_goto_if_null(self.iterator.result(), self.pos)))
2485
        rhs.generate_disposal_code(code)
William Stein's avatar
William Stein committed
2486 2487
        for i in range(len(self.args)):
            item = self.unpacked_items[i]
2488 2489
            unpack_code = "__Pyx_UnpackItem(%s, %d)" % (
                self.iterator.py_result(), i)
William Stein's avatar
William Stein committed
2490
            code.putln(
Robert Bradshaw's avatar
Robert Bradshaw committed
2491
                "%s = %s; %s" % (
2492
                    item.result(),
William Stein's avatar
William Stein committed
2493
                    typecast(item.ctype(), py_object_type, unpack_code),
2494
                    code.error_goto_if_null(item.result(), self.pos)))
William Stein's avatar
William Stein committed
2495 2496 2497
            value_node = self.coerced_unpacked_items[i]
            value_node.generate_evaluation_code(code)
            self.args[i].generate_assignment_code(value_node, code)
Robert Bradshaw's avatar
Robert Bradshaw committed
2498 2499 2500
        code.put_error_if_neg(self.pos, 
            "__Pyx_EndUnpack(%s)" % (
                self.iterator.py_result()))
William Stein's avatar
William Stein committed
2501
        if debug_disposal_code:
Stefan Behnel's avatar
Stefan Behnel committed
2502
            print("UnpackNode.generate_assignment_code:")
2503
            print("...generating disposal code for %s" % self.iterator)
2504
        self.iterator.generate_disposal_code(code)
William Stein's avatar
William Stein committed
2505

2506
        code.putln("}")
2507 2508 2509 2510 2511 2512 2513 2514 2515
        
    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
2516 2517 2518 2519


class TupleNode(SequenceNode):
    #  Tuple constructor.
2520 2521 2522

    gil_message = "Constructing Python tuple"

2523
    def analyse_types(self, env, skip_children=False):
Robert Bradshaw's avatar
Robert Bradshaw committed
2524 2525
        if len(self.args) == 0:
            self.is_temp = 0
2526
            self.is_literal = 1
Robert Bradshaw's avatar
Robert Bradshaw committed
2527
        else:
2528
            SequenceNode.analyse_types(self, env, skip_children)
Robert Bradshaw's avatar
Robert Bradshaw committed
2529
        self.type = tuple_type
Robert Bradshaw's avatar
Robert Bradshaw committed
2530 2531 2532
            
    def calculate_result_code(self):
        if len(self.args) > 0:
2533
            error(self.pos, "Positive length tuples must be constructed.")
Robert Bradshaw's avatar
Robert Bradshaw committed
2534 2535
        else:
            return Naming.empty_tuple
William Stein's avatar
William Stein committed
2536

2537 2538 2539 2540 2541 2542 2543
    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)
    
William Stein's avatar
William Stein committed
2544
    def generate_operation_code(self, code):
Robert Bradshaw's avatar
Robert Bradshaw committed
2545 2546 2547
        if len(self.args) == 0:
            # result_code is Naming.empty_tuple
            return
William Stein's avatar
William Stein committed
2548
        code.putln(
Robert Bradshaw's avatar
Robert Bradshaw committed
2549
            "%s = PyTuple_New(%s); %s" % (
2550
                self.result(),
William Stein's avatar
William Stein committed
2551
                len(self.args),
2552
                code.error_goto_if_null(self.result(), self.pos)))
William Stein's avatar
William Stein committed
2553 2554 2555
        for i in range(len(self.args)):
            arg = self.args[i]
            if not arg.result_in_temp():
2556
                code.put_incref(arg.result(), arg.ctype())
William Stein's avatar
William Stein committed
2557 2558
            code.putln(
                "PyTuple_SET_ITEM(%s, %s, %s);" % (
2559
                    self.result(),
William Stein's avatar
William Stein committed
2560 2561 2562 2563 2564 2565 2566 2567
                    i,
                    arg.py_result()))
    
    def generate_subexpr_disposal_code(self, code):
        # 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:
Dag Sverre Seljebotn's avatar
Merge  
Dag Sverre Seljebotn committed
2568
            arg.generate_post_assignment_code(code)	
William Stein's avatar
William Stein committed
2569 2570 2571 2572


class ListNode(SequenceNode):
    #  List constructor.
2573 2574 2575

    gil_message = "Constructing Python list"

Robert Bradshaw's avatar
Robert Bradshaw committed
2576 2577 2578 2579
    def analyse_types(self, env):
        SequenceNode.analyse_types(self, env)
        self.type = list_type

2580 2581 2582
    def compile_time_value(self, denv):
        return self.compile_time_value_list(denv)

William Stein's avatar
William Stein committed
2583
    def generate_operation_code(self, code):
Robert Bradshaw's avatar
Robert Bradshaw committed
2584
        code.putln("%s = PyList_New(%s); %s" %
2585
            (self.result(),
William Stein's avatar
William Stein committed
2586
            len(self.args),
2587
            code.error_goto_if_null(self.result(), self.pos)))
William Stein's avatar
William Stein committed
2588 2589 2590 2591
        for i in range(len(self.args)):
            arg = self.args[i]
            #if not arg.is_temp:
            if not arg.result_in_temp():
2592
                code.put_incref(arg.result(), arg.ctype())
William Stein's avatar
William Stein committed
2593
            code.putln("PyList_SET_ITEM(%s, %s, %s);" %
2594
                (self.result(),
William Stein's avatar
William Stein committed
2595 2596 2597 2598 2599 2600 2601 2602 2603 2604
                i,
                arg.py_result()))
                
    def generate_subexpr_disposal_code(self, code):
        # We call generate_post_assignment_code here instead
        # of generate_disposal_code, because values were stored
        # in the list using a reference-stealing operation.
        for arg in self.args:
            arg.generate_post_assignment_code(code)		

Robert Bradshaw's avatar
Robert Bradshaw committed
2605 2606 2607 2608
            
class ListComprehensionNode(SequenceNode):

    subexprs = []
2609
    is_sequence_constructor = 0 # not unpackable
Robert Bradshaw's avatar
Robert Bradshaw committed
2610

2611 2612
    child_attrs = ["loop", "append"]

Robert Bradshaw's avatar
Robert Bradshaw committed
2613
    def analyse_types(self, env): 
Robert Bradshaw's avatar
Robert Bradshaw committed
2614
        self.type = list_type
Robert Bradshaw's avatar
Robert Bradshaw committed
2615 2616 2617 2618 2619
        self.is_temp = 1
        self.append.target = self # this is a CloneNode used in the PyList_Append in the inner loop
        
    def allocate_temps(self, env, result = None): 
        if debug_temp_alloc:
Stefan Behnel's avatar
Stefan Behnel committed
2620
            print("%s Allocating temps" % self)
Robert Bradshaw's avatar
Robert Bradshaw committed
2621 2622 2623 2624 2625
        self.allocate_temp(env, result)
        self.loop.analyse_declarations(env)
        self.loop.analyse_expressions(env)
        
    def generate_operation_code(self, code):
Robert Bradshaw's avatar
Robert Bradshaw committed
2626
        code.putln("%s = PyList_New(%s); %s" %
2627
            (self.result(),
Robert Bradshaw's avatar
Robert Bradshaw committed
2628
            0,
2629
            code.error_goto_if_null(self.result(), self.pos)))
Robert Bradshaw's avatar
Robert Bradshaw committed
2630
        self.loop.generate_execution_code(code)
2631 2632 2633
        
    def annotate(self, code):
        self.loop.annotate(code)
Robert Bradshaw's avatar
Robert Bradshaw committed
2634 2635 2636 2637


class ListComprehensionAppendNode(ExprNode):

2638 2639
    # Need to be careful to avoid infinite recursion:
    # target must not be in child_attrs/subexprs
Robert Bradshaw's avatar
Robert Bradshaw committed
2640 2641 2642 2643 2644 2645 2646 2647 2648 2649
    subexprs = ['expr']
    
    def analyse_types(self, env):
        self.expr.analyse_types(env)
        if self.expr.type != py_object_type:
            self.expr = self.expr.coerce_to_pyobject(env)
        self.type = PyrexTypes.c_int_type
        self.is_temp = 1
    
    def generate_result_code(self, code):
2650
        code.putln("%s = PyList_Append(%s, (PyObject*)%s); %s" %
2651 2652 2653 2654
            (self.result(),
            self.target.result(),
            self.expr.result(),
            code.error_goto_if(self.result(), self.pos)))
Robert Bradshaw's avatar
Robert Bradshaw committed
2655

William Stein's avatar
William Stein committed
2656 2657 2658 2659

class DictNode(ExprNode):
    #  Dictionary constructor.
    #
2660 2661 2662
    #  key_value_pairs  [DictItemNode]
    
    subexprs = ['key_value_pairs']
William Stein's avatar
William Stein committed
2663
    
2664
    def compile_time_value(self, denv):
Robert Bradshaw's avatar
Robert Bradshaw committed
2665 2666
        pairs = [(item.key.compile_time_value(denv), item.value.compile_time_value(denv))
            for item in self.key_value_pairs]
2667 2668 2669 2670 2671
        try:
            return dict(pairs)
        except Exception, e:
            self.compile_time_value_error(e)
    
William Stein's avatar
William Stein committed
2672
    def analyse_types(self, env):
Robert Bradshaw's avatar
Robert Bradshaw committed
2673 2674
        for item in self.key_value_pairs:
            item.analyse_types(env)
Robert Bradshaw's avatar
Robert Bradshaw committed
2675
        self.type = dict_type
2676
        self.gil_check(env)
William Stein's avatar
William Stein committed
2677
        self.is_temp = 1
2678 2679 2680

    gil_message = "Constructing Python dict"

William Stein's avatar
William Stein committed
2681 2682 2683 2684
    def allocate_temps(self, env, result = None):
        #  Custom method used here because key-value
        #  pairs are evaluated and used one at a time.
        self.allocate_temp(env, result)
Robert Bradshaw's avatar
Robert Bradshaw committed
2685 2686 2687 2688 2689
        for item in self.key_value_pairs:
            item.key.allocate_temps(env)
            item.value.allocate_temps(env)
            item.key.release_temp(env)
            item.value.release_temp(env)
William Stein's avatar
William Stein committed
2690 2691 2692 2693 2694
    
    def generate_evaluation_code(self, code):
        #  Custom method used here because key-value
        #  pairs are evaluated and used one at a time.
        code.putln(
Robert Bradshaw's avatar
Robert Bradshaw committed
2695
            "%s = PyDict_New(); %s" % (
2696 2697
                self.result(),
                code.error_goto_if_null(self.result(), self.pos)))
Robert Bradshaw's avatar
Robert Bradshaw committed
2698 2699
        for item in self.key_value_pairs:
            item.generate_evaluation_code(code)
Robert Bradshaw's avatar
Robert Bradshaw committed
2700 2701
            code.put_error_if_neg(self.pos, 
                "PyDict_SetItem(%s, %s, %s)" % (
2702
                    self.result(),
Robert Bradshaw's avatar
Robert Bradshaw committed
2703 2704 2705
                    item.key.py_result(),
                    item.value.py_result()))
            item.generate_disposal_code(code)
2706 2707
            
    def annotate(self, code):
Robert Bradshaw's avatar
Robert Bradshaw committed
2708 2709 2710 2711 2712 2713 2714 2715 2716 2717 2718 2719 2720 2721 2722 2723 2724 2725 2726 2727 2728 2729 2730
        for item in self.key_value_pairs:
            item.annotate(code)
            
class DictItemNode(ExprNode):
    # Represents a single item in a DictNode
    #
    # key          ExprNode
    # value        ExprNode
    subexprs = ['key', 'value']
            
    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)
        
    def generate_evaluation_code(self, code):
        self.key.generate_evaluation_code(code)
        self.value.generate_evaluation_code(code)
        
    def generate_disposal_code(self, code):
        self.key.generate_disposal_code(code)
        self.value.generate_disposal_code(code)
William Stein's avatar
William Stein committed
2731

Stefan Behnel's avatar
Stefan Behnel committed
2732

William Stein's avatar
William Stein committed
2733 2734 2735 2736 2737
class ClassNode(ExprNode):
    #  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
2738 2739
    #  name         EncodedString      Name of the class
    #  cname        string             Class name as a Python string
William Stein's avatar
William Stein committed
2740 2741 2742 2743 2744
    #  bases        ExprNode           Base class tuple
    #  dict         ExprNode           Class dict (not owned by this node)
    #  doc          ExprNode or None   Doc string
    #  module_name  string             Name of defining module
    
2745 2746
    subexprs = ['bases', 'doc']

William Stein's avatar
William Stein committed
2747
    def analyse_types(self, env):
2748
        self.cname = env.intern_identifier(self.name)
William Stein's avatar
William Stein committed
2749 2750 2751 2752 2753 2754
        self.bases.analyse_types(env)
        if self.doc:
            self.doc.analyse_types(env)
            self.doc = self.doc.coerce_to_pyobject(env)
        self.module_name = env.global_scope().qualified_name
        self.type = py_object_type
2755
        self.gil_check(env)
William Stein's avatar
William Stein committed
2756 2757
        self.is_temp = 1
        env.use_utility_code(create_class_utility_code);
2758

2759 2760
    gil_message = "Constructing Python class"

William Stein's avatar
William Stein committed
2761 2762
    def generate_result_code(self, code):
        if self.doc:
Robert Bradshaw's avatar
Robert Bradshaw committed
2763 2764
            code.put_error_if_neg(self.pos, 
                'PyDict_SetItemString(%s, "__doc__", %s)' % (
William Stein's avatar
William Stein committed
2765
                    self.dict.py_result(),
Robert Bradshaw's avatar
Robert Bradshaw committed
2766
                    self.doc.py_result()))
William Stein's avatar
William Stein committed
2767
        code.putln(
Robert Bradshaw's avatar
Robert Bradshaw committed
2768
            '%s = __Pyx_CreateClass(%s, %s, %s, "%s"); %s' % (
2769
                self.result(),
William Stein's avatar
William Stein committed
2770 2771
                self.bases.py_result(),
                self.dict.py_result(),
2772
                self.cname,
William Stein's avatar
William Stein committed
2773
                self.module_name,
2774
                code.error_goto_if_null(self.result(), self.pos)))
William Stein's avatar
William Stein committed
2775 2776 2777 2778 2779 2780 2781 2782 2783 2784 2785 2786 2787 2788 2789


class UnboundMethodNode(ExprNode):
    #  Helper class used in the implementation of Python
    #  class definitions. Constructs an unbound method
    #  object from a class and a function.
    #
    #  class_cname   string     C var holding the class object
    #  function      ExprNode   Function object
    
    subexprs = ['function']
    
    def analyse_types(self, env):
        self.function.analyse_types(env)
        self.type = py_object_type
2790
        self.gil_check(env)
William Stein's avatar
William Stein committed
2791
        self.is_temp = 1
2792 2793 2794

    gil_message = "Constructing an unbound method"

William Stein's avatar
William Stein committed
2795 2796
    def generate_result_code(self, code):
        code.putln(
Robert Bradshaw's avatar
Robert Bradshaw committed
2797
            "%s = PyMethod_New(%s, 0, %s); %s" % (
2798
                self.result(),
William Stein's avatar
William Stein committed
2799 2800
                self.function.py_result(),
                self.class_cname,
2801
                code.error_goto_if_null(self.result(), self.pos)))
William Stein's avatar
William Stein committed
2802 2803 2804 2805 2806 2807 2808 2809 2810 2811 2812


class PyCFunctionNode(AtomicExprNode):
    #  Helper class used in the implementation of Python
    #  class definitions. Constructs a PyCFunction object
    #  from a PyMethodDef struct.
    #
    #  pymethdef_cname   string   PyMethodDef structure
    
    def analyse_types(self, env):
        self.type = py_object_type
2813
        self.gil_check(env)
William Stein's avatar
William Stein committed
2814
        self.is_temp = 1
2815 2816 2817

    gil_message = "Constructing Python function"

William Stein's avatar
William Stein committed
2818 2819
    def generate_result_code(self, code):
        code.putln(
Robert Bradshaw's avatar
Robert Bradshaw committed
2820
            "%s = PyCFunction_New(&%s, 0); %s" % (
2821
                self.result(),
William Stein's avatar
William Stein committed
2822
                self.pymethdef_cname,
2823
                code.error_goto_if_null(self.result(), self.pos)))
William Stein's avatar
William Stein committed
2824 2825 2826 2827 2828 2829 2830

#-------------------------------------------------------------------
#
#  Unary operator nodes
#
#-------------------------------------------------------------------

2831 2832 2833 2834 2835 2836 2837
compile_time_unary_operators = {
    'not': operator.not_,
    '~': operator.inv,
    '-': operator.neg,
    '+': operator.pos,
}

William Stein's avatar
William Stein committed
2838 2839 2840 2841 2842 2843 2844 2845 2846 2847 2848 2849 2850 2851
class UnopNode(ExprNode):
    #  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.
    
    subexprs = ['operand']
    
2852 2853 2854 2855 2856 2857 2858 2859 2860 2861 2862 2863
    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)

William Stein's avatar
William Stein committed
2864 2865 2866 2867 2868
    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
2869
            self.gil_check(env)
William Stein's avatar
William Stein committed
2870 2871 2872 2873 2874 2875 2876 2877 2878 2879 2880 2881 2882 2883 2884 2885 2886 2887 2888 2889 2890 2891 2892
            self.is_temp = 1
        else:
            self.analyse_c_operation(env)
    
    def check_const(self):
        self.operand.check_const()
    
    def is_py_operation(self):
        return self.operand.type.is_pyobject
    
    def coerce_operand_to_pyobject(self, env):
        self.operand = self.operand.coerce_to_pyobject(env)
    
    def generate_result_code(self, code):
        if self.operand.type.is_pyobject:
            self.generate_py_operation_code(code)
        else:
            if self.is_temp:
                self.generate_c_operation_code(code)
    
    def generate_py_operation_code(self, code):
        function = self.py_operation_function()
        code.putln(
Robert Bradshaw's avatar
Robert Bradshaw committed
2893
            "%s = %s(%s); %s" % (
2894
                self.result(), 
William Stein's avatar
William Stein committed
2895 2896
                function, 
                self.operand.py_result(),
2897
                code.error_goto_if_null(self.result(), self.pos)))
William Stein's avatar
William Stein committed
2898 2899 2900 2901 2902 2903 2904 2905 2906 2907 2908 2909 2910
        
    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


class NotNode(ExprNode):
    #  'not' operator
    #
    #  operand   ExprNode
    
2911 2912 2913 2914 2915 2916 2917
    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)

William Stein's avatar
William Stein committed
2918 2919 2920 2921 2922
    subexprs = ['operand']
    
    def analyse_types(self, env):
        self.operand.analyse_types(env)
        self.operand = self.operand.coerce_to_boolean(env)
2923
        self.type = PyrexTypes.c_bint_type
William Stein's avatar
William Stein committed
2924 2925
    
    def calculate_result_code(self):
2926
        return "(!%s)" % self.operand.result()
William Stein's avatar
William Stein committed
2927 2928 2929 2930 2931 2932 2933 2934 2935 2936 2937 2938 2939 2940 2941 2942 2943
    
    def generate_result_code(self, code):
        pass


class UnaryPlusNode(UnopNode):
    #  unary '+' operator
    
    operator = '+'
    
    def analyse_c_operation(self, env):
        self.type = self.operand.type
    
    def py_operation_function(self):
        return "PyNumber_Positive"
    
    def calculate_result_code(self):
2944
        return self.operand.result()
William Stein's avatar
William Stein committed
2945 2946 2947 2948 2949 2950 2951 2952 2953 2954 2955 2956 2957 2958 2959 2960 2961


class UnaryMinusNode(UnopNode):
    #  unary '-' operator
    
    operator = '-'
    
    def analyse_c_operation(self, env):
        if self.operand.type.is_numeric:
            self.type = self.operand.type
        else:
            self.type_error()
    
    def py_operation_function(self):
        return "PyNumber_Negative"
    
    def calculate_result_code(self):
2962
        return "(-%s)" % self.operand.result()
William Stein's avatar
William Stein committed
2963 2964 2965 2966 2967 2968 2969 2970 2971 2972 2973 2974 2975 2976 2977


class TildeNode(UnopNode):
    #  unary '~' operator

    def analyse_c_operation(self, env):
        if self.operand.type.is_int:
            self.type = self.operand.type
        else:
            self.type_error()

    def py_operation_function(self):
        return "PyNumber_Invert"
    
    def calculate_result_code(self):
2978
        return "(~%s)" % self.operand.result()
William Stein's avatar
William Stein committed
2979 2980 2981 2982 2983 2984 2985 2986 2987 2988 2989 2990 2991 2992 2993 2994 2995 2996 2997 2998 2999 3000 3001 3002 3003 3004 3005 3006 3007


class AmpersandNode(ExprNode):
    #  The C address-of operator.
    #
    #  operand  ExprNode
    
    subexprs = ['operand']

    def analyse_types(self, env):
        self.operand.analyse_types(env)
        argtype = self.operand.type
        if not (argtype.is_cfunction or self.operand.is_lvalue()):
            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)
    
    def check_const(self):
        self.operand.check_const_addr()
    
    def error(self, mess):
        error(self.pos, mess)
        self.type = PyrexTypes.error_type
        self.result_code = "<error>"
    
    def calculate_result_code(self):
3008
        return "(&%s)" % self.operand.result()
William Stein's avatar
William Stein committed
3009 3010 3011 3012 3013 3014 3015 3016 3017 3018 3019 3020 3021 3022

    def generate_result_code(self, code):
        pass
    

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

def unop_node(pos, operator, operand):
    # Construct unnop node of appropriate class for 
    # given operator.
3023
    if isinstance(operand, IntNode) and operator == '-':
3024
        return IntNode(pos = operand.pos, value = str(-int(operand.value, 0)))
Robert Bradshaw's avatar
Robert Bradshaw committed
3025 3026
    elif isinstance(operand, UnopNode) and operand.operator == operator:
        warning(pos, "Python has no increment/decrement operator: %s%sx = %s(%sx) = x" % ((operator,)*4), 5)
William Stein's avatar
William Stein committed
3027 3028 3029 3030 3031 3032 3033 3034
    return unop_node_classes[operator](pos, 
        operator = operator, 
        operand = operand)


class TypecastNode(ExprNode):
    #  C type cast
    #
3035
    #  operand      ExprNode
William Stein's avatar
William Stein committed
3036 3037
    #  base_type    CBaseTypeNode
    #  declarator   CDeclaratorNode
3038 3039 3040
    #
    #  If used from a transform, one can if wanted specify the attribute
    #  "type" directly and leave base_type and declarator to None
William Stein's avatar
William Stein committed
3041 3042
    
    subexprs = ['operand']
3043
    base_type = declarator = type = None
William Stein's avatar
William Stein committed
3044 3045
    
    def analyse_types(self, env):
3046 3047 3048
        if self.type is None:
            base_type = self.base_type.analyse(env)
            _, self.type = self.declarator.analyse(base_type, env)
3049 3050 3051 3052
        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
3053 3054 3055
        self.operand.analyse_types(env)
        to_py = self.type.is_pyobject
        from_py = self.operand.type.is_pyobject
3056 3057
        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
3058
        if to_py and not from_py:
3059
            if self.operand.type.to_py_function:
Dag Sverre Seljebotn's avatar
Merge  
Dag Sverre Seljebotn committed
3060
                self.result_ctype = py_object_type
3061
                self.operand = self.operand.coerce_to_pyobject(env)
3062 3063
            else:
                warning(self.pos, "No conversion from %s to %s, python object pointer used." % (self.operand.type, self.type))
3064
                self.operand = self.operand.coerce_to_simple(env)
3065 3066 3067
        elif from_py and not to_py:
            if self.type.from_py_function:
                self.operand = self.operand.coerce_to(self.type, env)
3068 3069
            else:
                warning(self.pos, "No conversion from %s to %s, python object pointer used." % (self.type, self.operand.type))
3070 3071 3072
        elif from_py and to_py:
            if self.typecheck and self.type.is_extension_type:
                self.operand = PyTypeTestNode(self.operand, self.type, env)
William Stein's avatar
William Stein committed
3073 3074 3075 3076 3077 3078
    
    def check_const(self):
        self.operand.check_const()
    
    def calculate_result_code(self):
        opnd = self.operand
3079
        return self.type.cast_code(opnd.result())
William Stein's avatar
William Stein committed
3080 3081 3082 3083 3084 3085 3086 3087 3088 3089 3090 3091
    
    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;" % (
3092 3093 3094
                    self.result(),
                    self.operand.result()))
            code.put_incref(self.result(), self.ctype())
William Stein's avatar
William Stein committed
3095 3096 3097 3098 3099 3100 3101 3102 3103 3104 3105 3106 3107 3108 3109 3110 3111 3112 3113 3114 3115


class SizeofNode(ExprNode):
    #  Abstract base class for sizeof(x) expression nodes.

    def check_const(self):
        pass

    def generate_result_code(self, code):
        pass


class SizeofTypeNode(SizeofNode):
    #  C sizeof function applied to a type
    #
    #  base_type   CBaseTypeNode
    #  declarator  CDeclaratorNode
    
    subexprs = []
    
    def analyse_types(self, env):
3116 3117 3118 3119 3120 3121 3122 3123 3124 3125 3126 3127 3128 3129
        # 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
        if self.base_type.module_path:
            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
William Stein's avatar
William Stein committed
3130 3131 3132
        base_type = self.base_type.analyse(env)
        _, arg_type = self.declarator.analyse(base_type, env)
        self.arg_type = arg_type
3133
        if arg_type.is_pyobject and not arg_type.is_extension_type:
William Stein's avatar
William Stein committed
3134 3135 3136 3137 3138 3139 3140 3141
            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)
        self.type = PyrexTypes.c_int_type
        
    def calculate_result_code(self):
3142 3143 3144 3145 3146 3147
        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
3148 3149 3150 3151 3152 3153 3154 3155 3156 3157 3158 3159 3160 3161 3162
        return "(sizeof(%s))" % arg_code
    

class SizeofVarNode(SizeofNode):
    #  C sizeof function applied to a variable
    #
    #  operand   ExprNode
    
    subexprs = ['operand']
    
    def analyse_types(self, env):
        self.operand.analyse_types(env)
        self.type = PyrexTypes.c_int_type
    
    def calculate_result_code(self):
3163
        return "(sizeof(%s))" % self.operand.result()
William Stein's avatar
William Stein committed
3164 3165 3166 3167 3168 3169 3170 3171 3172 3173 3174
    
    def generate_result_code(self, code):
        pass


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

Stefan Behnel's avatar
Stefan Behnel committed
3175 3176 3177
def _not_in(x, seq):
    return x not in seq

3178 3179 3180
compile_time_binary_operators = {
    '<': operator.lt,
    '<=': operator.le,
3181
    '==': operator.eq,
3182 3183 3184 3185 3186 3187 3188 3189 3190 3191 3192 3193 3194 3195 3196 3197 3198 3199
    '!=': operator.ne,
    '>=': operator.ge,
    '>': operator.gt,
    'is': operator.is_,
    'is_not': operator.is_not,
    '+': operator.add,
    '&': operator.and_,
    '/': operator.div,
    '//': operator.floordiv,
    '<<': operator.lshift,
    '%': operator.mod,
    '*': operator.mul,
    '|': operator.or_,
    '**': operator.pow,
    '>>': operator.rshift,
    '-': operator.sub,
    #'/': operator.truediv,
    '^': operator.xor,
Stefan Behnel's avatar
Stefan Behnel committed
3200 3201
    'in': operator.contains,
    'not_in': _not_in,
3202 3203 3204 3205 3206 3207 3208
}

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"
3209
                % node.operator)
3210 3211
    return func

William Stein's avatar
William Stein committed
3212 3213 3214 3215 3216 3217 3218 3219 3220 3221 3222 3223 3224 3225 3226
class BinopNode(ExprNode):
    #  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.
    
    subexprs = ['operand1', 'operand2']
    
3227 3228 3229 3230 3231 3232 3233 3234 3235
    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)

William Stein's avatar
William Stein committed
3236 3237 3238 3239 3240 3241
    def analyse_types(self, env):
        self.operand1.analyse_types(env)
        self.operand2.analyse_types(env)
        if self.is_py_operation():
            self.coerce_operands_to_pyobjects(env)
            self.type = py_object_type
3242
            self.gil_check(env)
William Stein's avatar
William Stein committed
3243
            self.is_temp = 1
3244 3245
            if Options.incref_local_binop and self.operand1.type.is_pyobject:
                self.operand1 = self.operand1.coerce_to_temp(env)
William Stein's avatar
William Stein committed
3246 3247 3248 3249 3250 3251 3252 3253 3254 3255 3256 3257 3258 3259 3260 3261 3262 3263 3264 3265 3266 3267 3268 3269
        else:
            self.analyse_c_operation(env)
    
    def is_py_operation(self):
        return (self.operand1.type.is_pyobject 
            or self.operand2.type.is_pyobject)
    
    def coerce_operands_to_pyobjects(self, env):
        self.operand1 = self.operand1.coerce_to_pyobject(env)
        self.operand2 = self.operand2.coerce_to_pyobject(env)
    
    def check_const(self):
        self.operand1.check_const()
        self.operand2.check_const()
    
    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()
            if function == "PyNumber_Power":
                extra_args = ", Py_None"
            else:
                extra_args = ""
            code.putln(
Robert Bradshaw's avatar
Robert Bradshaw committed
3270
                "%s = %s(%s, %s%s); %s" % (
3271
                    self.result(), 
William Stein's avatar
William Stein committed
3272 3273 3274 3275
                    function, 
                    self.operand1.py_result(),
                    self.operand2.py_result(),
                    extra_args,
3276
                    code.error_goto_if_null(self.result(), self.pos)))
William Stein's avatar
William Stein committed
3277 3278 3279 3280 3281 3282 3283 3284 3285 3286 3287 3288 3289 3290 3291 3292 3293 3294 3295
        else:
            if self.is_temp:
                self.generate_c_operation_code(code)
    
    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)" %
                (self.operator, self.operand1.type, 
                    self.operand2.type))
        self.type = PyrexTypes.error_type


class NumBinopNode(BinopNode):
    #  Binary operation taking numeric arguments.
    
    def analyse_c_operation(self, env):
        type1 = self.operand1.type
        type2 = self.operand2.type
3296 3297 3298 3299
        if self.operator == "**" and type1.is_int and type2.is_int:
            error(self.pos, "** with two C int types is ambiguous")
            self.type = error_type
            return
William Stein's avatar
William Stein committed
3300 3301 3302 3303 3304 3305 3306 3307 3308 3309 3310
        self.type = self.compute_c_result_type(type1, type2)
        if not self.type:
            self.type_error()
    
    def compute_c_result_type(self, type1, type2):
        if self.c_types_okay(type1, type2):
            return PyrexTypes.widest_numeric_type(type1, type2)
        else:
            return None
    
    def c_types_okay(self, type1, type2):
3311 3312 3313
        #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
3314 3315 3316

    def calculate_result_code(self):
        return "(%s %s %s)" % (
3317
            self.operand1.result(), 
William Stein's avatar
William Stein committed
3318
            self.operator, 
3319
            self.operand2.result())
William Stein's avatar
William Stein committed
3320 3321 3322 3323 3324 3325 3326 3327 3328 3329 3330 3331 3332
    
    def py_operation_function(self):
        return self.py_functions[self.operator]

    py_functions = {
        "|":		"PyNumber_Or",
        "^":		"PyNumber_Xor",
        "&":		"PyNumber_And",
        "<<":		"PyNumber_Lshift",
        ">>":		"PyNumber_Rshift",
        "+":		"PyNumber_Add",
        "-":		"PyNumber_Subtract",
        "*":		"PyNumber_Multiply",
Robert Bradshaw's avatar
Robert Bradshaw committed
3333
        "/":		"__Pyx_PyNumber_Divide",
Robert Bradshaw's avatar
Robert Bradshaw committed
3334
        "//":		"PyNumber_FloorDivide",
William Stein's avatar
William Stein committed
3335
        "%":		"PyNumber_Remainder",
3336
        "**":       "PyNumber_Power"
William Stein's avatar
William Stein committed
3337 3338 3339 3340 3341 3342 3343
    }


class IntBinopNode(NumBinopNode):
    #  Binary operation taking integer arguments.
    
    def c_types_okay(self, type1, type2):
3344 3345 3346
        #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
3347 3348 3349 3350 3351 3352 3353 3354 3355 3356 3357 3358 3359

    
class AddNode(NumBinopNode):
    #  '+' operator.
    
    def is_py_operation(self):
        if self.operand1.type.is_string \
            and self.operand2.type.is_string:
                return 1
        else:
            return NumBinopNode.is_py_operation(self)

    def compute_c_result_type(self, type1, type2):
3360 3361
        #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
3362
            return type1
3363
        elif (type2.is_ptr or type2.is_array) and (type1.is_int or type1.is_enum):
William Stein's avatar
William Stein committed
3364 3365 3366 3367 3368 3369 3370 3371 3372 3373
            return type2
        else:
            return NumBinopNode.compute_c_result_type(
                self, type1, type2)


class SubNode(NumBinopNode):
    #  '-' operator.
    
    def compute_c_result_type(self, type1, type2):
3374
        if (type1.is_ptr or type1.is_array) and (type2.is_int or type2.is_enum):
William Stein's avatar
William Stein committed
3375
            return type1
3376
        elif (type1.is_ptr or type1.is_array) and (type2.is_ptr or type2.is_array):
William Stein's avatar
William Stein committed
3377 3378 3379 3380 3381 3382 3383 3384 3385 3386 3387 3388 3389 3390 3391 3392 3393 3394 3395
            return PyrexTypes.c_int_type
        else:
            return NumBinopNode.compute_c_result_type(
                self, type1, type2)


class MulNode(NumBinopNode):
    #  '*' operator.
    
    def is_py_operation(self):
        type1 = self.operand1.type
        type2 = self.operand2.type
        if (type1.is_string and type2.is_int) \
            or (type2.is_string and type1.is_int):
                return 1
        else:
            return NumBinopNode.is_py_operation(self)


Robert Bradshaw's avatar
Robert Bradshaw committed
3396 3397 3398 3399 3400
class FloorDivNode(NumBinopNode):
    #  '//' operator.
    
    def calculate_result_code(self):
        return "(%s %s %s)" % (
3401
            self.operand1.result(), 
Robert Bradshaw's avatar
Robert Bradshaw committed
3402
            "/",  # c division is by default floor-div 
3403
            self.operand2.result())
Robert Bradshaw's avatar
Robert Bradshaw committed
3404 3405


William Stein's avatar
William Stein committed
3406 3407 3408 3409 3410 3411 3412 3413 3414 3415 3416
class ModNode(IntBinopNode):
    #  '%' operator.
    
    def is_py_operation(self):
        return (self.operand1.type.is_string
            or self.operand2.type.is_string
            or IntBinopNode.is_py_operation(self))


class PowNode(NumBinopNode):
    #  '**' operator.
3417

William Stein's avatar
William Stein committed
3418 3419 3420
    def analyse_types(self, env):
        env.pow_function_used = 1
        NumBinopNode.analyse_types(self, env)
3421

William Stein's avatar
William Stein committed
3422 3423 3424 3425 3426
    def compute_c_result_type(self, type1, type2):
        if self.c_types_okay(type1, type2):
            return PyrexTypes.c_double_type
        else:
            return None
3427

3428
    def c_types_okay(self, type1, type2):
3429 3430
        return (type1.is_float or type2.is_float) and \
                NumBinopNode.c_types_okay(self, type1, type2)
3431

3432 3433 3434 3435 3436 3437 3438 3439
    def type_error(self):
        if not (self.operand1.type.is_error or self.operand2.type.is_error):
            if self.operand1.type.is_int and self.operand2.type.is_int:
                error(self.pos, "C has no integer powering, use python ints or floats instead '%s' (%s; %s)" %
                    (self.operator, self.operand1.type, self.operand2.type))
            else:
                NumBinopNode.type_error(self)
        self.type = PyrexTypes.error_type
3440

William Stein's avatar
William Stein committed
3441 3442
    def calculate_result_code(self):
        return "pow(%s, %s)" % (
3443
            self.operand1.result(), self.operand2.result())
3444

William Stein's avatar
William Stein committed
3445 3446 3447 3448 3449 3450 3451 3452 3453 3454 3455 3456 3457

class BoolBinopNode(ExprNode):
    #  Short-circuiting boolean operation.
    #
    #  operator     string
    #  operand1     ExprNode
    #  operand2     ExprNode
    #  temp_bool    ExprNode     used internally
    
    temp_bool = None
    
    subexprs = ['operand1', 'operand2', 'temp_bool']
    
3458 3459 3460 3461 3462 3463 3464 3465
    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)

William Stein's avatar
William Stein committed
3466 3467 3468 3469 3470 3471 3472
    def analyse_types(self, env):
        self.operand1.analyse_types(env)
        self.operand2.analyse_types(env)
        if self.operand1.type.is_pyobject or \
                self.operand2.type.is_pyobject:
            self.operand1 = self.operand1.coerce_to_pyobject(env)
            self.operand2 = self.operand2.coerce_to_pyobject(env)
3473
            self.temp_bool = TempNode(self.pos, PyrexTypes.c_bint_type, env)
William Stein's avatar
William Stein committed
3474
            self.type = py_object_type
3475
            self.gil_check(env)
William Stein's avatar
William Stein committed
3476 3477 3478
        else:
            self.operand1 = self.operand1.coerce_to_boolean(env)
            self.operand2 = self.operand2.coerce_to_boolean(env)
3479
            self.type = PyrexTypes.c_bint_type
William Stein's avatar
William Stein committed
3480 3481 3482 3483 3484
        # For what we're about to do, it's vital that
        # both operands be temp nodes.
        self.operand1 = self.operand1.coerce_to_temp(env) #CTT
        self.operand2 = self.operand2.coerce_to_temp(env)
        self.is_temp = 1
3485 3486 3487

    gil_message = "Truth-testing Python object"

William Stein's avatar
William Stein committed
3488 3489 3490 3491 3492 3493 3494 3495 3496
    def allocate_temps(self, env, result_code = None):
        #  We don't need both operands at the same time, and
        #  one of the operands will also be our result. So we
        #  use an allocation strategy here which results in
        #  this node and both its operands sharing the same
        #  result variable. This allows us to avoid some 
        #  assignments and increfs/decrefs that would otherwise
        #  be necessary.
        self.allocate_temp(env, result_code)
3497
        self.operand1.allocate_temps(env, self.result())
William Stein's avatar
William Stein committed
3498 3499 3500
        if self.temp_bool:
            self.temp_bool.allocate_temp(env)
            self.temp_bool.release_temp(env)
3501
        self.operand2.allocate_temps(env, self.result())
William Stein's avatar
William Stein committed
3502 3503 3504 3505 3506 3507 3508 3509 3510 3511 3512 3513 3514 3515
        #  We haven't called release_temp on either operand,
        #  because although they are temp nodes, they don't own 
        #  their result variable. And because they are temp
        #  nodes, any temps in their subnodes will have been
        #  released before their allocate_temps returned.
        #  Therefore, they contain no temp vars that need to
        #  be released.

    def check_const(self):
        self.operand1.check_const()
        self.operand2.check_const()
    
    def calculate_result_code(self):
        return "(%s %s %s)" % (
3516
            self.operand1.result(),
William Stein's avatar
William Stein committed
3517
            self.py_to_c_op[self.operator],
3518
            self.operand2.result())
William Stein's avatar
William Stein committed
3519 3520 3521 3522 3523 3524 3525 3526 3527 3528 3529 3530 3531 3532 3533 3534 3535 3536 3537 3538 3539 3540
    
    py_to_c_op = {'and': "&&", 'or': "||"}

    def generate_evaluation_code(self, code):
        self.operand1.generate_evaluation_code(code)
        test_result = self.generate_operand1_test(code)
        if self.operator == 'and':
            sense = ""
        else:
            sense = "!"
        code.putln(
            "if (%s%s) {" % (
                sense,
                test_result))
        self.operand1.generate_disposal_code(code)
        self.operand2.generate_evaluation_code(code)
        code.putln(
            "}")
    
    def generate_operand1_test(self, code):
        #  Generate code to test the truth of the first operand.
        if self.type.is_pyobject:
3541
            test_result = self.temp_bool.result()
William Stein's avatar
William Stein committed
3542
            code.putln(
3543
                "%s = __Pyx_PyObject_IsTrue(%s); %s" % (
William Stein's avatar
William Stein committed
3544 3545
                    test_result,
                    self.operand1.py_result(),
Robert Bradshaw's avatar
Robert Bradshaw committed
3546
                    code.error_goto_if_neg(test_result, self.pos)))
William Stein's avatar
William Stein committed
3547
        else:
3548
            test_result = self.operand1.result()
William Stein's avatar
William Stein committed
3549 3550 3551
        return test_result


Robert Bradshaw's avatar
Robert Bradshaw committed
3552 3553 3554 3555 3556 3557 3558 3559
class CondExprNode(ExprNode):
    #  Short-circuiting conditional expression.
    #
    #  test        ExprNode
    #  true_val    ExprNode
    #  false_val   ExprNode
    
    temp_bool = None
3560 3561
    true_val = None
    false_val = None
Robert Bradshaw's avatar
Robert Bradshaw committed
3562 3563 3564 3565 3566 3567 3568 3569 3570
    
    subexprs = ['test', 'true_val', 'false_val']
    
    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)
        self.type = self.compute_result_type(self.true_val.type, self.false_val.type)
3571 3572 3573 3574 3575 3576 3577 3578
        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)
        # must be tmp variables so they can share a result
        self.true_val = self.true_val.coerce_to_temp(env)
        self.false_val = self.false_val.coerce_to_temp(env)
        self.is_temp = 1
        if self.type == PyrexTypes.error_type:
Robert Bradshaw's avatar
Robert Bradshaw committed
3579 3580 3581 3582 3583 3584 3585 3586 3587 3588 3589 3590
            self.type_error()
    
    def allocate_temps(self, env, result_code = None):
        #  We only ever evaluate one side, and this is 
        #  after evaluating the truth value, so we may
        #  use an allocation strategy here which results in
        #  this node and both its operands sharing the same
        #  result variable. This allows us to avoid some 
        #  assignments and increfs/decrefs that would otherwise
        #  be necessary.
        self.allocate_temp(env, result_code)
        self.test.allocate_temps(env, result_code)
3591 3592
        self.true_val.allocate_temps(env, self.result())
        self.false_val.allocate_temps(env, self.result())
Robert Bradshaw's avatar
Robert Bradshaw committed
3593 3594 3595 3596 3597 3598 3599 3600 3601 3602 3603 3604 3605 3606 3607 3608 3609
        #  We haven't called release_temp on either value,
        #  because although they are temp nodes, they don't own 
        #  their result variable. And because they are temp
        #  nodes, any temps in their subnodes will have been
        #  released before their allocate_temps returned.
        #  Therefore, they contain no temp vars that need to
        #  be released.
        
    def compute_result_type(self, type1, type2):
        if type1 == type2:
            return type1
        elif type1.is_numeric and type2.is_numeric:
            return PyrexTypes.widest_numeric_type(type1, type2)
        elif type1.is_extension_type and type1.subtype_of_resolved_type(type2):
            return type2
        elif type2.is_extension_type and type2.subtype_of_resolved_type(type1):
            return type1
3610 3611
        elif type1.is_pyobject or type2.is_pyobject:
            return py_object_type
3612 3613 3614 3615
        elif type1.assignable_from(type2):
            return type1
        elif type2.assignable_from(type1):
            return type2
Robert Bradshaw's avatar
Robert Bradshaw committed
3616
        else:
3617
            return PyrexTypes.error_type
Robert Bradshaw's avatar
Robert Bradshaw committed
3618 3619 3620 3621 3622 3623
        
    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
3624
    
Robert Bradshaw's avatar
Robert Bradshaw committed
3625 3626 3627 3628 3629 3630 3631
    def check_const(self):
        self.test.check_const()
        self.true_val.check_const()
        self.false_val.check_const()
    
    def generate_evaluation_code(self, code):
        self.test.generate_evaluation_code(code)
3632
        code.putln("if (%s) {" % self.test.result() )
Robert Bradshaw's avatar
Robert Bradshaw committed
3633 3634 3635 3636 3637 3638
        self.true_val.generate_evaluation_code(code)
        code.putln("} else {")
        self.false_val.generate_evaluation_code(code)
        code.putln("}")
        self.test.generate_disposal_code(code)

3639 3640 3641 3642 3643 3644 3645 3646 3647 3648
richcmp_constants = {
    "<" : "Py_LT",
    "<=": "Py_LE",
    "==": "Py_EQ",
    "!=": "Py_NE",
    "<>": "Py_NE",
    ">" : "Py_GT",
    ">=": "Py_GE",
}

William Stein's avatar
William Stein committed
3649 3650 3651 3652
class CmpNode:
    #  Mixin class containing code common to PrimaryCmpNodes
    #  and CascadedCmpNodes.
    
3653 3654
    def cascaded_compile_time_value(self, operand1, denv):
        func = get_compile_time_binop(self)
3655
        operand2 = self.operand2.compile_time_value(denv)
3656 3657 3658 3659
        try:
            result = func(operand1, operand2)
        except Exception, e:
            self.compile_time_value_error(e)
3660
            result = None
3661 3662 3663 3664 3665 3666
        if result:
            cascade = self.cascade
            if cascade:
                result = result and cascade.compile_time_value(operand2, denv)
        return result

William Stein's avatar
William Stein committed
3667 3668 3669 3670 3671
    def is_python_comparison(self):
        return (self.has_python_operands()
            or (self.cascade and self.cascade.is_python_comparison())
            or self.operator in ('in', 'not_in'))

3672 3673 3674 3675
    def is_python_result(self):
        return ((self.has_python_operands() and self.operator not in ('is', 'is_not', 'in', 'not_in'))
            or (self.cascade and self.cascade.is_python_result()))

William Stein's avatar
William Stein committed
3676 3677 3678 3679 3680 3681 3682 3683 3684 3685 3686 3687
    def check_types(self, env, operand1, op, operand2):
        if not self.types_okay(operand1, op, operand2):
            error(self.pos, "Invalid types for '%s' (%s, %s)" %
                (self.operator, operand1.type, operand2.type))
    
    def types_okay(self, operand1, op, operand2):
        type1 = operand1.type
        type2 = operand2.type
        if type1.is_error or type2.is_error:
            return 1
        if type1.is_pyobject: # type2 will be, too
            return 1
3688
        elif type1.is_ptr or type1.is_array:
William Stein's avatar
William Stein committed
3689
            return type1.is_null_ptr or type2.is_null_ptr \
3690 3691 3692 3693 3694
                or ((type2.is_ptr or type2.is_array)
                    and type1.base_type.same_as(type2.base_type))
        elif ((type1.is_numeric and type2.is_numeric
                    or type1.is_enum and (type1 is type2 or type2.is_int)
                    or type1.is_int and type2.is_enum)
William Stein's avatar
William Stein committed
3695 3696 3697
                and op not in ('is', 'is_not')):
            return 1
        else:
3698
            return type1.is_cfunction and type1.is_cfunction and type1 == type2
William Stein's avatar
William Stein committed
3699 3700 3701

    def generate_operation_code(self, code, result_code, 
            operand1, op , operand2):
3702 3703 3704 3705 3706 3707
        if self.type is PyrexTypes.py_object_type:
            coerce_result = "__Pyx_PyBool_FromLong"
        else:
            coerce_result = ""
        if 'not' in op: negation = "!"
        else: negation = ""
William Stein's avatar
William Stein committed
3708 3709
        if op == 'in' or op == 'not_in':
            code.putln(
3710
                "%s = %s(%sPySequence_Contains(%s, %s)); %s" % (
William Stein's avatar
William Stein committed
3711
                    result_code, 
3712 3713
                    coerce_result, 
                    negation,
William Stein's avatar
William Stein committed
3714 3715
                    operand2.py_result(), 
                    operand1.py_result(), 
Robert Bradshaw's avatar
Robert Bradshaw committed
3716
                    code.error_goto_if_neg(result_code, self.pos)))
William Stein's avatar
William Stein committed
3717 3718
        elif (operand1.type.is_pyobject
            and op not in ('is', 'is_not')):
3719 3720
                code.putln("%s = PyObject_RichCompare(%s, %s, %s); %s" % (
                        result_code, 
William Stein's avatar
William Stein committed
3721 3722
                        operand1.py_result(), 
                        operand2.py_result(), 
3723 3724
                        richcmp_constants[op],
                        code.error_goto_if_null(result_code, self.pos)))
William Stein's avatar
William Stein committed
3725
        else:
3726 3727 3728 3729 3730
            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
3731 3732
            elif type1.is_numeric:
                common_type = PyrexTypes.widest_numeric_type(type1, type2)
3733
            else:
3734 3735 3736
                common_type = type1
            code1 = operand1.result_as(common_type)
            code2 = operand2.result_as(common_type)
3737
            code.putln("%s = %s(%s %s %s);" % (
William Stein's avatar
William Stein committed
3738
                result_code, 
3739
                coerce_result, 
3740
                code1, 
William Stein's avatar
William Stein committed
3741
                self.c_operator(op), 
3742 3743
                code2))

William Stein's avatar
William Stein committed
3744 3745 3746 3747 3748 3749 3750 3751 3752 3753 3754 3755 3756 3757 3758 3759 3760 3761 3762 3763 3764 3765 3766
    def c_operator(self, op):
        if op == 'is':
            return "=="
        elif op == 'is_not':
            return "!="
        else:
            return op
    

class PrimaryCmpNode(ExprNode, CmpNode):
    #  Non-cascaded comparison or first comparison of
    #  a cascaded sequence.
    #
    #  operator      string
    #  operand1      ExprNode
    #  operand2      ExprNode
    #  cascade       CascadedCmpNode
    
    #  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.
    
Robert Bradshaw's avatar
Robert Bradshaw committed
3767 3768
    child_attrs = ['operand1', 'operand2', 'cascade']
    
William Stein's avatar
William Stein committed
3769 3770
    cascade = None
    
3771
    def compile_time_value(self, denv):
3772
        operand1 = self.operand1.compile_time_value(denv)
3773 3774
        return self.cascaded_compile_time_value(operand1, denv)

William Stein's avatar
William Stein committed
3775 3776 3777 3778 3779 3780 3781 3782
    def analyse_types(self, env):
        self.operand1.analyse_types(env)
        self.operand2.analyse_types(env)
        if self.cascade:
            self.cascade.analyse_types(env, self.operand2)
        self.is_pycmp = self.is_python_comparison()
        if self.is_pycmp:
            self.coerce_operands_to_pyobjects(env)
3783 3784
        if self.has_int_operands():
            self.coerce_chars_to_ints(env)
William Stein's avatar
William Stein committed
3785 3786 3787 3788
        if self.cascade:
            self.operand2 = self.operand2.coerce_to_simple(env)
            self.cascade.coerce_cascaded_operands_to_temp(env)
        self.check_operand_types(env)
3789 3790 3791 3792 3793 3794 3795 3796
        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
3797 3798 3799 3800 3801 3802 3803 3804 3805 3806 3807 3808
        if self.is_pycmp or self.cascade:
            self.is_temp = 1
    
    def check_operand_types(self, env):
        self.check_types(env, 
            self.operand1, self.operator, self.operand2)
        if self.cascade:
            self.cascade.check_operand_types(env, self.operand2)
    
    def has_python_operands(self):
        return (self.operand1.type.is_pyobject
            or self.operand2.type.is_pyobject)
3809
            
William Stein's avatar
William Stein committed
3810 3811 3812 3813 3814 3815
    def coerce_operands_to_pyobjects(self, env):
        self.operand1 = self.operand1.coerce_to_pyobject(env)
        self.operand2 = self.operand2.coerce_to_pyobject(env)
        if self.cascade:
            self.cascade.coerce_operands_to_pyobjects(env)
        
3816 3817 3818 3819 3820
    def has_int_operands(self):
        return (self.operand1.type.is_int or self.operand2.type.is_int) \
           or (self.cascade and self.cascade.has_int_operands())
    
    def coerce_chars_to_ints(self, env):
3821 3822
        # coerce literal single-char strings to c chars
        if self.operand1.type.is_string and isinstance(self.operand1, StringNode):
3823
            self.operand1 = self.operand1.coerce_to(PyrexTypes.c_uchar_type, env)
3824
        if self.operand2.type.is_string and isinstance(self.operand2, StringNode):
3825 3826 3827 3828
            self.operand2 = self.operand2.coerce_to(PyrexTypes.c_uchar_type, env)
        if self.cascade:
            self.cascade.coerce_chars_to_ints(env)
    
William Stein's avatar
William Stein committed
3829 3830 3831 3832 3833 3834 3835 3836 3837 3838 3839 3840 3841 3842 3843 3844 3845 3846 3847 3848
    def allocate_subexpr_temps(self, env):
        self.operand1.allocate_temps(env)
        self.operand2.allocate_temps(env)
        if self.cascade:
            self.cascade.allocate_subexpr_temps(env)
    
    def release_subexpr_temps(self, env):
        self.operand1.release_temp(env)
        self.operand2.release_temp(env)
        if self.cascade:
            self.cascade.release_subexpr_temps(env)
    
    def check_const(self):
        self.operand1.check_const()
        self.operand2.check_const()
        if self.cascade:
            self.not_const()

    def calculate_result_code(self):
        return "(%s %s %s)" % (
3849
            self.operand1.result(),
William Stein's avatar
William Stein committed
3850
            self.c_operator(self.operator),
3851
            self.operand2.result())
William Stein's avatar
William Stein committed
3852 3853 3854 3855 3856
    
    def generate_evaluation_code(self, code):
        self.operand1.generate_evaluation_code(code)
        self.operand2.generate_evaluation_code(code)
        if self.is_temp:
3857
            self.generate_operation_code(code, self.result(), 
William Stein's avatar
William Stein committed
3858 3859 3860
                self.operand1, self.operator, self.operand2)
            if self.cascade:
                self.cascade.generate_evaluation_code(code,
3861
                    self.result(), self.operand2)
William Stein's avatar
William Stein committed
3862 3863 3864 3865 3866 3867 3868 3869
            self.operand1.generate_disposal_code(code)
            self.operand2.generate_disposal_code(code)
    
    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)
3870 3871 3872 3873 3874 3875
        
    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
3876 3877 3878 3879 3880 3881 3882 3883 3884 3885 3886 3887


class CascadedCmpNode(Node, CmpNode):
    #  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 
    #  with the PrimaryCmpNode at the head of the chain.
    #
    #  operator      string
    #  operand2      ExprNode
    #  cascade       CascadedCmpNode

Robert Bradshaw's avatar
Robert Bradshaw committed
3888 3889
    child_attrs = ['operand2', 'cascade']

William Stein's avatar
William Stein committed
3890 3891 3892 3893 3894 3895 3896 3897 3898 3899 3900 3901 3902 3903 3904
    cascade = None
    
    def analyse_types(self, env, operand1):
        self.operand2.analyse_types(env)
        if self.cascade:
            self.cascade.analyse_types(env, self.operand2)
    
    def check_operand_types(self, env, operand1):
        self.check_types(env, 
            operand1, self.operator, self.operand2)
        if self.cascade:
            self.cascade.check_operand_types(env, self.operand2)
    
    def has_python_operands(self):
        return self.operand2.type.is_pyobject
3905
        
William Stein's avatar
William Stein committed
3906 3907 3908 3909 3910
    def coerce_operands_to_pyobjects(self, env):
        self.operand2 = self.operand2.coerce_to_pyobject(env)
        if self.cascade:
            self.cascade.coerce_operands_to_pyobjects(env)

3911 3912 3913 3914
    def has_int_operands(self):
        return self.operand2.type.is_int
        
    def coerce_chars_to_ints(self, env):
3915
        if self.operand2.type.is_string and isinstance(self.operand2, StringNode):
3916 3917
            self.operand2 = self.operand2.coerce_to(PyrexTypes.c_uchar_type, env)

William Stein's avatar
William Stein committed
3918 3919 3920 3921 3922 3923 3924 3925 3926 3927 3928 3929 3930 3931 3932 3933 3934
    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)
    
    def allocate_subexpr_temps(self, env):
        self.operand2.allocate_temps(env)
        if self.cascade:
            self.cascade.allocate_subexpr_temps(env)
    
    def release_subexpr_temps(self, env):
        self.operand2.release_temp(env)
        if self.cascade:
            self.cascade.release_subexpr_temps(env)
    
    def generate_evaluation_code(self, code, result, operand1):
3935 3936 3937 3938
        if self.type.is_pyobject:
            code.putln("if (__Pyx_PyObject_IsTrue(%s)) {" % result)
        else:
            code.putln("if (%s) {" % result)
William Stein's avatar
William Stein committed
3939 3940 3941 3942 3943 3944 3945 3946 3947 3948
        self.operand2.generate_evaluation_code(code)
        self.generate_operation_code(code, result, 
            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)
        code.putln("}")

3949 3950 3951 3952 3953
    def annotate(self, code):
        self.operand2.annotate(code)
        if self.cascade:
            self.cascade.annotate(code)

William Stein's avatar
William Stein committed
3954 3955 3956 3957 3958 3959 3960 3961 3962 3963 3964 3965 3966

binop_node_classes = {
    "or":		BoolBinopNode,
    "and":	BoolBinopNode,
    "|":		IntBinopNode,
    "^":		IntBinopNode,
    "&":		IntBinopNode,
    "<<":		IntBinopNode,
    ">>":		IntBinopNode,
    "+":		AddNode,
    "-":		SubNode,
    "*":		MulNode,
    "/":		NumBinopNode,
Robert Bradshaw's avatar
Robert Bradshaw committed
3967
    "//":		FloorDivNode,
William Stein's avatar
William Stein committed
3968 3969 3970 3971 3972 3973 3974 3975 3976 3977 3978 3979 3980 3981 3982 3983 3984 3985 3986 3987 3988 3989 3990 3991 3992 3993 3994 3995 3996 3997 3998 3999 4000 4001
    "%":		ModNode,
    "**":		PowNode
}

def binop_node(pos, operator, operand1, operand2):
    # Construct binop node of appropriate class for 
    # given operator.
    return binop_node_classes[operator](pos, 
        operator = operator, 
        operand1 = operand1, 
        operand2 = operand2)

#-------------------------------------------------------------------
#
#  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.
#
#-------------------------------------------------------------------

class CoercionNode(ExprNode):
    #  Abstract base class for coercion nodes.
    #
    #  arg       ExprNode       node being coerced
    
    subexprs = ['arg']
    
    def __init__(self, arg):
        self.pos = arg.pos
        self.arg = arg
        if debug_coercion:
Stefan Behnel's avatar
Stefan Behnel committed
4002
            print("%s Coercing %s" % (self, self.arg))
4003 4004 4005 4006 4007 4008
            
    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
4009 4010 4011 4012 4013 4014 4015 4016 4017 4018 4019 4020 4021 4022 4023 4024 4025 4026 4027 4028 4029 4030 4031 4032


class CastNode(CoercionNode):
    #  Wrap a node in a C type cast.
    
    def __init__(self, arg, new_type):
        CoercionNode.__init__(self, arg)
        self.type = new_type
    
    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.

    def __init__(self, arg, dst_type, env):
        #  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
4033
        assert dst_type.is_extension_type or dst_type.is_builtin_type, "PyTypeTest on non extension type"
William Stein's avatar
William Stein committed
4034 4035
        CoercionNode.__init__(self, arg)
        self.type = dst_type
4036
        self.gil_check(env)
William Stein's avatar
William Stein committed
4037 4038
        self.result_ctype = arg.ctype()
        env.use_utility_code(type_test_utility_code)
4039 4040

    gil_message = "Python type test"
William Stein's avatar
William Stein committed
4041
    
4042 4043 4044
    def analyse_types(self, env):
        pass
    
William Stein's avatar
William Stein committed
4045 4046 4047 4048 4049 4050 4051
    def result_in_temp(self):
        return self.arg.result_in_temp()
    
    def is_ephemeral(self):
        return self.arg.is_ephemeral()
    
    def calculate_result_code(self):
4052
        return self.arg.result()
William Stein's avatar
William Stein committed
4053 4054 4055 4056
    
    def generate_result_code(self, code):
        if self.type.typeobj_is_available():
            code.putln(
Robert Bradshaw's avatar
Robert Bradshaw committed
4057 4058
                "if (!(%s)) %s" % (
                    self.type.type_test_code(self.arg.py_result()),
William Stein's avatar
William Stein committed
4059 4060 4061 4062 4063 4064 4065 4066 4067 4068 4069 4070 4071 4072 4073 4074
                    code.error_goto(self.pos)))
        else:
            error(self.pos, "Cannot test type of extern C class "
                "without type object name specification")
                
    def generate_post_assignment_code(self, code):
        self.arg.generate_post_assignment_code(code)
                
                
class CoerceToPyTypeNode(CoercionNode):
    #  This node is used to convert a C data type
    #  to a Python object.

    def __init__(self, arg, env):
        CoercionNode.__init__(self, arg)
        self.type = py_object_type
4075
        self.gil_check(env)
William Stein's avatar
William Stein committed
4076 4077 4078 4079
        self.is_temp = 1
        if not arg.type.to_py_function:
            error(arg.pos,
                "Cannot convert '%s' to Python object" % arg.type)
4080 4081 4082

    gil_message = "Converting to Python object"

4083 4084 4085 4086
    def analyse_types(self, env):
        # The arg is always already analysed
        pass

William Stein's avatar
William Stein committed
4087 4088
    def generate_result_code(self, code):
        function = self.arg.type.to_py_function
Robert Bradshaw's avatar
Robert Bradshaw committed
4089
        code.putln('%s = %s(%s); %s' % (
4090
            self.result(), 
William Stein's avatar
William Stein committed
4091
            function, 
4092 4093
            self.arg.result(), 
            code.error_goto_if_null(self.result(), self.pos)))
William Stein's avatar
William Stein committed
4094 4095 4096 4097 4098 4099 4100 4101 4102 4103 4104 4105 4106 4107 4108 4109 4110


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
        if not result_type.from_py_function:
            error(arg.pos,
                "Cannot convert Python object to '%s'" % result_type)
        if self.type.is_string and self.arg.is_ephemeral():
            error(arg.pos,
                "Obtaining char * from temporary Python value")
    
4111 4112 4113 4114
    def analyse_types(self, env):
        # The arg is always already analysed
        pass

William Stein's avatar
William Stein committed
4115 4116
    def generate_result_code(self, code):
        function = self.type.from_py_function
4117 4118 4119 4120
        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
4121
        code.putln('%s = %s; %s' % (
4122
            self.result(), 
4123
            rhs,
4124
            code.error_goto_if(self.type.error_condition(self.result()), self.pos)))
William Stein's avatar
William Stein committed
4125 4126 4127 4128 4129 4130 4131 4132


class CoerceToBooleanNode(CoercionNode):
    #  This node is used when a result needs to be used
    #  in a boolean context.
    
    def __init__(self, arg, env):
        CoercionNode.__init__(self, arg)
4133
        self.type = PyrexTypes.c_bint_type
William Stein's avatar
William Stein committed
4134
        if arg.type.is_pyobject:
4135 4136
            if env.nogil:
                self.gil_error()
William Stein's avatar
William Stein committed
4137
            self.is_temp = 1
4138 4139

    gil_message = "Truth-testing Python object"
William Stein's avatar
William Stein committed
4140 4141 4142 4143 4144 4145 4146
    
    def check_const(self):
        if self.is_temp:
            self.not_const()
        self.arg.check_const()
    
    def calculate_result_code(self):
4147
        return "(%s != 0)" % self.arg.result()
William Stein's avatar
William Stein committed
4148 4149 4150 4151

    def generate_result_code(self, code):
        if self.arg.type.is_pyobject:
            code.putln(
4152
                "%s = __Pyx_PyObject_IsTrue(%s); %s" % (
4153
                    self.result(), 
William Stein's avatar
William Stein committed
4154
                    self.arg.py_result(), 
4155
                    code.error_goto_if_neg(self.result(), self.pos)))
William Stein's avatar
William Stein committed
4156 4157 4158 4159 4160 4161 4162 4163 4164 4165 4166 4167


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
        self.is_temp = 1
        if self.type.is_pyobject:
4168
            self.gil_check(env)
William Stein's avatar
William Stein committed
4169
            self.result_ctype = py_object_type
4170 4171 4172

    gil_message = "Creating temporary Python reference"

4173 4174 4175 4176
    def analyse_types(self, env):
        # The arg is always already analysed
        pass

William Stein's avatar
William Stein committed
4177 4178 4179 4180
    def generate_result_code(self, code):
        #self.arg.generate_evaluation_code(code) # Already done
        # by generic generate_subexpr_evaluation_code!
        code.putln("%s = %s;" % (
4181
            self.result(), self.arg.result_as(self.ctype())))
William Stein's avatar
William Stein committed
4182
        if self.type.is_pyobject:
4183
            code.put_incref(self.result(), self.ctype())
William Stein's avatar
William Stein committed
4184 4185 4186 4187 4188 4189 4190 4191 4192 4193 4194 4195 4196 4197


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
    #  disposal code for it. The original owner of the argument 
    #  node is responsible for doing those things.
    
    subexprs = [] # Arg is not considered a subexpr
    
    def __init__(self, arg):
        CoercionNode.__init__(self, arg)
4198 4199 4200 4201 4202
        if hasattr(arg, 'type'):
            self.type = arg.type
            self.result_ctype = arg.result_ctype
        if hasattr(arg, 'entry'):
            self.entry = arg.entry
William Stein's avatar
William Stein committed
4203 4204
    
    def calculate_result_code(self):
4205
        return self.arg.result()
Robert Bradshaw's avatar
Robert Bradshaw committed
4206 4207 4208 4209 4210
        
    def analyse_types(self, env):
        self.type = self.arg.type
        self.result_ctype = self.arg.result_ctype
        self.is_temp = 1
4211 4212
        if hasattr(self.arg, 'entry'):
            self.entry = self.arg.entry
William Stein's avatar
William Stein committed
4213 4214 4215 4216 4217 4218
    
    def generate_evaluation_code(self, code):
        pass

    def generate_result_code(self, code):
        pass
4219 4220
        
    def generate_disposal_code(self, code):
4221 4222
        pass
                
4223 4224 4225 4226 4227
    def allocate_temps(self, env):
        self.result_code = self.calculate_result_code()
        
    def release_temp(self, env):
        pass
4228 4229 4230 4231 4232 4233 4234 4235 4236
        
class PersistentNode(ExprNode):
    # A PersistentNode is like a CloneNode except it handles the temporary
    # allocation itself by keeping track of the number of times it has been 
    # used. 
    
    subexprs = ["arg"]
    temp_counter = 0
    generate_counter = 0
Robert Bradshaw's avatar
Robert Bradshaw committed
4237
    analyse_counter = 0
4238 4239 4240 4241 4242 4243 4244 4245
    result_code = None
    
    def __init__(self, arg, uses):
        self.pos = arg.pos
        self.arg = arg
        self.uses = uses
        
    def analyse_types(self, env):
Robert Bradshaw's avatar
Robert Bradshaw committed
4246 4247 4248 4249 4250 4251
        if self.analyse_counter == 0:
            self.arg.analyse_types(env)
            self.type = self.arg.type
            self.result_ctype = self.arg.result_ctype
            self.is_temp = 1
        self.analyse_counter += 1
4252
    
4253
    def calculate_result_code(self):
4254
        return self.result()
4255

4256 4257 4258 4259
    def generate_evaluation_code(self, code):
        if self.generate_counter == 0:
            self.arg.generate_evaluation_code(code)
            code.putln("%s = %s;" % (
4260
                self.result(), self.arg.result_as(self.ctype())))
4261
            if self.type.is_pyobject:
4262
                code.put_incref(self.result(), self.ctype())
4263 4264 4265 4266 4267 4268
            self.arg.generate_disposal_code(code)
        self.generate_counter += 1
                
    def generate_disposal_code(self, code):
        if self.generate_counter == self.uses:
            if self.type.is_pyobject:
4269
                code.put_decref_clear(self.result(), self.ctype())
4270 4271 4272 4273

    def allocate_temps(self, env, result=None):
        if self.temp_counter == 0:
            self.arg.allocate_temps(env)
Robert Bradshaw's avatar
Robert Bradshaw committed
4274
            self.allocate_temp(env, result)
4275 4276 4277
            self.arg.release_temp(env)
        self.temp_counter += 1
        
Robert Bradshaw's avatar
Robert Bradshaw committed
4278 4279 4280 4281 4282 4283
    def allocate_temp(self, env, result=None):
        if result is None:
            self.result_code = env.allocate_temp(self.type)
        else:
            self.result_code = result
        
4284 4285
    def release_temp(self, env):
        if self.temp_counter == self.uses:
4286
            env.release_temp(self.result())
William Stein's avatar
William Stein committed
4287 4288 4289 4290 4291 4292 4293
    
#------------------------------------------------------------------------------------
#
#  Runtime support code
#
#------------------------------------------------------------------------------------

4294
get_name_interned_utility_code = [
William Stein's avatar
William Stein committed
4295
"""
4296 4297
static PyObject *__Pyx_GetName(PyObject *dict, PyObject *name); /*proto*/
""","""
William Stein's avatar
William Stein committed
4298 4299 4300 4301 4302 4303 4304
static PyObject *__Pyx_GetName(PyObject *dict, PyObject *name) {
    PyObject *result;
    result = PyObject_GetAttr(dict, name);
    if (!result)
        PyErr_SetObject(PyExc_NameError, name);
    return result;
}
4305
"""]
William Stein's avatar
William Stein committed
4306 4307 4308

#------------------------------------------------------------------------------------

4309
import_utility_code = [
William Stein's avatar
William Stein committed
4310
"""
4311 4312
static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list); /*proto*/
""","""
William Stein's avatar
William Stein committed
4313 4314 4315 4316 4317 4318 4319 4320 4321 4322 4323 4324 4325 4326 4327 4328 4329 4330 4331 4332 4333 4334 4335 4336 4337 4338 4339 4340 4341 4342 4343 4344 4345 4346 4347
static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list) {
    PyObject *__import__ = 0;
    PyObject *empty_list = 0;
    PyObject *module = 0;
    PyObject *global_dict = 0;
    PyObject *empty_dict = 0;
    PyObject *list;
    __import__ = PyObject_GetAttrString(%(BUILTINS)s, "__import__");
    if (!__import__)
        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;
    module = PyObject_CallFunction(__import__, "OOOO",
        name, global_dict, empty_dict, list);
bad:
    Py_XDECREF(empty_list);
    Py_XDECREF(__import__);
    Py_XDECREF(empty_dict);
    return module;
}
""" % {
    "BUILTINS": Naming.builtins_cname,
    "GLOBALS":  Naming.module_cname,
4348
}]
William Stein's avatar
William Stein committed
4349 4350 4351

#------------------------------------------------------------------------------------

4352
get_exception_utility_code = [
William Stein's avatar
William Stein committed
4353
"""
4354 4355
static PyObject *__Pyx_GetExcValue(void); /*proto*/
""","""
William Stein's avatar
William Stein committed
4356 4357
static PyObject *__Pyx_GetExcValue(void) {
    PyObject *type = 0, *value = 0, *tb = 0;
4358
    PyObject *tmp_type, *tmp_value, *tmp_tb;
William Stein's avatar
William Stein committed
4359 4360 4361 4362 4363 4364 4365 4366 4367 4368
    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);
    }
4369 4370 4371
    tmp_type = tstate->exc_type;
    tmp_value = tstate->exc_value;
    tmp_tb = tstate->exc_traceback;
William Stein's avatar
William Stein committed
4372 4373 4374
    tstate->exc_type = type;
    tstate->exc_value = value;
    tstate->exc_traceback = tb;
4375 4376 4377 4378 4379
    /* 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
4380 4381 4382 4383 4384 4385 4386 4387 4388 4389 4390
    result = value;
    Py_XINCREF(result);
    type = 0;
    value = 0;
    tb = 0;
bad:
    Py_XDECREF(type);
    Py_XDECREF(value);
    Py_XDECREF(tb);
    return result;
}
4391
"""]
William Stein's avatar
William Stein committed
4392 4393 4394

#------------------------------------------------------------------------------------

4395
unpacking_utility_code = [
William Stein's avatar
William Stein committed
4396
"""
4397
static PyObject *__Pyx_UnpackItem(PyObject *, Py_ssize_t index); /*proto*/
4398 4399
static int __Pyx_EndUnpack(PyObject *); /*proto*/
""","""
4400
static PyObject *__Pyx_UnpackItem(PyObject *iter, Py_ssize_t index) {
4401 4402
    PyObject *item;
    if (!(item = PyIter_Next(iter))) {
4403 4404 4405 4406 4407 4408 4409 4410
        if (!PyErr_Occurred()) {
            PyErr_Format(PyExc_ValueError,
                #if PY_VERSION_HEX < 0x02050000
                    "need more than %d values to unpack", (int)index);
                #else
                    "need more than %zd values to unpack", index);
                #endif
        }
4411 4412
    }
    return item;
4413
}
William Stein's avatar
William Stein committed
4414

4415 4416 4417 4418
static int __Pyx_EndUnpack(PyObject *iter) {
    PyObject *item;
    if ((item = PyIter_Next(iter))) {
        Py_DECREF(item);
4419
        PyErr_SetString(PyExc_ValueError, "too many values to unpack");
4420 4421 4422 4423 4424 4425
        return -1;
    }
    else if (!PyErr_Occurred())
        return 0;
    else
        return -1;
4426
}
4427
"""]
William Stein's avatar
William Stein committed
4428 4429 4430

#------------------------------------------------------------------------------------

4431
type_test_utility_code = [
William Stein's avatar
William Stein committed
4432
"""
4433 4434
static int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type); /*proto*/
""","""
William Stein's avatar
William Stein committed
4435 4436 4437 4438 4439 4440 4441 4442
static int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type) {
    if (!type) {
        PyErr_Format(PyExc_SystemError, "Missing type object");
        return 0;
    }
    if (obj == Py_None || PyObject_TypeCheck(obj, type))
        return 1;
    PyErr_Format(PyExc_TypeError, "Cannot convert %s to %s",
4443
        Py_TYPE(obj)->tp_name, type->tp_name);
William Stein's avatar
William Stein committed
4444 4445
    return 0;
}
4446
"""]
William Stein's avatar
William Stein committed
4447 4448 4449

#------------------------------------------------------------------------------------

4450
create_class_utility_code = [
William Stein's avatar
William Stein committed
4451
"""
4452 4453
static PyObject *__Pyx_CreateClass(PyObject *bases, PyObject *dict, PyObject *name, char *modname); /*proto*/
""","""
William Stein's avatar
William Stein committed
4454 4455 4456 4457 4458
static PyObject *__Pyx_CreateClass(
    PyObject *bases, PyObject *dict, PyObject *name, char *modname)
{
    PyObject *py_modname;
    PyObject *result = 0;
4459

4460
    #if PY_MAJOR_VERSION < 3
William Stein's avatar
William Stein committed
4461
    py_modname = PyString_FromString(modname);
4462 4463 4464
    #else
    py_modname = PyUnicode_FromString(modname);
    #endif
William Stein's avatar
William Stein committed
4465 4466 4467 4468
    if (!py_modname)
        goto bad;
    if (PyDict_SetItemString(dict, "__module__", py_modname) < 0)
        goto bad;
4469
    #if PY_MAJOR_VERSION < 3
William Stein's avatar
William Stein committed
4470
    result = PyClass_New(bases, dict, name);
4471 4472 4473
    #else
    result = PyObject_CallFunctionObjArgs((PyObject *)&PyType_Type, name, bases, dict, NULL);
    #endif
William Stein's avatar
William Stein committed
4474 4475 4476 4477
bad:
    Py_XDECREF(py_modname);
    return result;
}
4478
"""]
William Stein's avatar
William Stein committed
4479 4480

#------------------------------------------------------------------------------------
Robert Bradshaw's avatar
Robert Bradshaw committed
4481 4482 4483

cpp_exception_utility_code = [
"""
4484 4485
#ifndef __Pyx_CppExn2PyErr
static void __Pyx_CppExn2PyErr() {
Robert Bradshaw's avatar
Robert Bradshaw committed
4486 4487 4488 4489 4490 4491 4492 4493 4494 4495 4496 4497 4498 4499 4500 4501
  try {
    if (PyErr_Occurred())
      ; // let the latest Python exn pass through and ignore the current one
    else
      throw;
  } catch (const std::out_of_range& exn) {
    // catch out_of_range explicitly so the proper Python exn may be raised
    PyErr_SetString(PyExc_IndexError, exn.what());
  } catch (const std::exception& exn) {
    PyErr_SetString(PyExc_RuntimeError, exn.what());
  }
  catch (...)
  {
    PyErr_SetString(PyExc_RuntimeError, "Unknown exception");
  }
}
4502 4503
#endif
""",""]
Robert Bradshaw's avatar
Robert Bradshaw committed
4504 4505

#------------------------------------------------------------------------------------
Robert Bradshaw's avatar
Robert Bradshaw committed
4506 4507 4508

append_utility_code = [
"""
Stefan Behnel's avatar
Stefan Behnel committed
4509
static INLINE PyObject* __Pyx_PyObject_Append(PyObject* L, PyObject* x) {
Robert Bradshaw's avatar
Robert Bradshaw committed
4510 4511 4512 4513 4514 4515
    if (likely(PyList_CheckExact(L))) {
        if (PyList_Append(L, x) < 0) return NULL;
        Py_INCREF(Py_None);
        return Py_None; // this is just to have an accurate signature
    }
    else {
4516
        return PyObject_CallMethod(L, "append", "(O)", x);
Robert Bradshaw's avatar
Robert Bradshaw committed
4517 4518 4519
    }
}
""",""
4520
]
4521 4522 4523

#------------------------------------------------------------------------------------

Dag Sverre Seljebotn's avatar
Merge  
Dag Sverre Seljebotn committed
4524 4525 4526 4527 4528 4529 4530 4531 4532 4533 4534 4535 4536 4537 4538 4539 4540 4541 4542 4543 4544 4545 4546 4547 4548 4549 4550 4551 4552 4553 4554 4555 4556 4557 4558 4559 4560 4561 4562 4563 4564 4565 4566 4567 4568 4569 4570 4571 4572 4573 4574 4575 4576 4577 4578 4579
# If the is_unsigned flag is set, we need to do some extra work to make 
# sure the index doesn't become negative. 

getitem_int_utility_code = [
"""
static INLINE PyObject *__Pyx_GetItemInt(PyObject *o, Py_ssize_t i, int is_unsigned) {
    PyObject *r;
    if (PyList_CheckExact(o) && 0 <= i && i < PyList_GET_SIZE(o)) {
        r = PyList_GET_ITEM(o, i);
        Py_INCREF(r);
    }
    else if (PyTuple_CheckExact(o) && 0 <= i && i < PyTuple_GET_SIZE(o)) {
        r = PyTuple_GET_ITEM(o, i);
        Py_INCREF(r);
    }
    else if (Py_TYPE(o)->tp_as_sequence && Py_TYPE(o)->tp_as_sequence->sq_item && (likely(i >= 0) || !is_unsigned))
        r = PySequence_GetItem(o, i);
    else {
        PyObject *j = (likely(i >= 0) || !is_unsigned) ? PyInt_FromLong(i) : PyLong_FromUnsignedLongLong((sizeof(unsigned long long) > sizeof(Py_ssize_t) ? (1ULL << (sizeof(Py_ssize_t)*8)) : 0) + i);
        if (!j)
            return 0;
        r = PyObject_GetItem(o, j);
        Py_DECREF(j);
    }
    return r;
}
""",
"""
"""]

#------------------------------------------------------------------------------------

setitem_int_utility_code = [
"""
static INLINE int __Pyx_SetItemInt(PyObject *o, Py_ssize_t i, PyObject *v, int is_unsigned) {
    int r;
    if (PyList_CheckExact(o) && 0 <= i && i < PyList_GET_SIZE(o)) {
        Py_DECREF(PyList_GET_ITEM(o, i));
        Py_INCREF(v);
        PyList_SET_ITEM(o, i, v);
        return 1;
    }
    else if (Py_TYPE(o)->tp_as_sequence && Py_TYPE(o)->tp_as_sequence->sq_ass_item && (likely(i >= 0) || !is_unsigned))
        r = PySequence_SetItem(o, i, v);
    else {
        PyObject *j = (likely(i >= 0) || !is_unsigned) ? PyInt_FromLong(i) : PyLong_FromUnsignedLongLong((sizeof(unsigned long long) > sizeof(Py_ssize_t) ? (1ULL << (sizeof(Py_ssize_t)*8)) : 0) + i);
        if (!j)
            return -1;
        r = PyObject_SetItem(o, j, v);
        Py_DECREF(j);
    }
    return r;
}
""",
"""
"""]
4580 4581 4582 4583 4584 4585 4586 4587 4588 4589
#------------------------------------------------------------------------------------

raise_noneattr_error_utility_code = [
"""
static INLINE void __Pyx_RaiseNoneAttributeError(char* attrname);
""", """
static INLINE void __Pyx_RaiseNoneAttributeError(char* attrname) {
    PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", attrname);
}
"""]