ExprNodes.py 161 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
    #      calculate_result_code
Stefan Behnel's avatar
Stefan Behnel committed
107 108 109
    #        - Called during the Allocate Temps phase. Should return a
    #          C code fragment evaluating to the result. This is only
    #          called when the result is not a temporary.
110 111 112 113 114
    #
    #      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
115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171
    #
    #      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
    #        is provided which uses the following abstract method:
    #
    #          generate_result_code
    #            - Generate any C statements necessary to calculate
    #              the result of this node from the results of its
    #              sub-expressions.
    #
    #      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 207 208 209 210 211 212 213 214 215 216 217 218 219 220
                
    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
    
    def result_as(self, type = None):
        #  Return the result code cast to the specified C type.
        return typecast(type, self.ctype(), self.result_code)
    
    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
    
221 222 223 224 225 226 227 228
    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
229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251
    # ------------- 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)
    
252
    def analyse_target_expression(self, env, rhs):
William Stein's avatar
William Stein committed
253 254 255 256
        #  Convenience routine performing both the Type
        #  Analysis and Temp Allocation phases for the LHS of
        #  an assignment.
        self.analyse_target_types(env)
257
        self.allocate_target_temps(env, rhs)
William Stein's avatar
William Stein committed
258 259 260 261 262 263 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
    
    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)
297 298 299 300 301

    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
302 303 304 305 306 307 308 309 310 311 312
    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")
313 314 315 316 317

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

William Stein's avatar
William Stein committed
318 319 320 321 322 323 324 325 326
    # ----------------- 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
            
327 328
    def allocate_target_temps(self, env, rhs):
        #  Perform temp allocation for the LHS of an assignment.
William Stein's avatar
William Stein committed
329
        if debug_temp_alloc:
Stefan Behnel's avatar
Stefan Behnel committed
330
            print("%s Allocating target temps" % self)
William Stein's avatar
William Stein committed
331 332
        self.allocate_subexpr_temps(env)
        self.result_code = self.target_code()
333 334 335
        if rhs:
            rhs.release_temp(env)
        self.release_subexpr_temps(env)
William Stein's avatar
William Stein committed
336 337 338 339 340 341 342 343
    
    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
344
            print("%s Allocating temps" % self)
William Stein's avatar
William Stein committed
345 346 347 348 349 350 351 352 353
        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
354
            print("%s Allocating temps for: %s" % (self, self.subexprs))
William Stein's avatar
William Stein committed
355 356 357
        for node in self.subexpr_nodes():
            if node:
                if debug_temp_alloc:
Stefan Behnel's avatar
Stefan Behnel committed
358
                    print("%s Allocating temps for %s" % (self, node))
William Stein's avatar
William Stein committed
359 360 361 362 363 364 365 366 367 368
                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
369
            print("%s Allocating temp" % self)
William Stein's avatar
William Stein committed
370 371 372 373 374 375 376 377 378 379 380 381 382
        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
383
                print("%s Allocated result %s" % (self, self.result_code))
William Stein's avatar
William Stein committed
384 385 386 387 388 389 390 391 392 393
        else:
            self.result_code = self.calculate_result_code()
    
    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")
    
394 395 396
#	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
397 398 399 400 401 402

    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
403
                print("%s Releasing result %s" % (self, self.result_code))
William Stein's avatar
William Stein committed
404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423
            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():
            code.put_incref(self.result_code, self.ctype())
    
    def generate_evaluation_code(self, code):
424
        code.mark_pos(self.pos)
William Stein's avatar
William Stein committed
425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476
        #  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:
                code.put_decref_clear(self.result_code, self.ctype())
        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:
                code.putln("%s = 0;" % self.result_code)
        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
    
477 478 479 480 481 482
    # ---------------- Annotation ---------------------
    
    def annotate(self, code):
        for node in self.subexpr_nodes():
            node.annotate(code)
    
William Stein's avatar
William Stein committed
483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501
    # ----------------- 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):
502 503
                if not isinstance(src, NoneNode):
                    src = PyTypeTestNode(src, dst_type, env)
William Stein's avatar
William Stein committed
504 505 506
        elif src.type.is_pyobject:
            src = CoerceFromPyTypeNode(dst_type, src, env)
        else: # neither src nor dst are py types
507
            # Added the string comparison, since for c types that
508
            # is enough, but Cython gets confused when the types are
509
            # in different files.
510
            if not (str(src.type) == str(dst_type) or dst_type.assignable_from(src_type)):
William Stein's avatar
William Stein committed
511 512 513 514 515 516 517 518 519 520 521 522 523 524
                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:
525
            if not type.is_int and not type.is_error:
William Stein's avatar
William Stein committed
526 527 528 529 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
                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.
    
569 570
    is_literal = 1
    
William Stein's avatar
William Stein committed
571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588
    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"
    
589 590 591
    def compile_time_value(self, denv):
        return None
    
William Stein's avatar
William Stein committed
592 593 594 595 596
class EllipsisNode(PyConstNode):
    #  '...' in a subscript list.
    
    value = "Py_Ellipsis"

597 598 599
    def compile_time_value(self, denv):
        return Ellipsis

William Stein's avatar
William Stein committed
600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623

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


624 625 626 627 628 629 630 631
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):
632
        return str(int(self.value))
633

William Stein's avatar
William Stein committed
634 635
class NullNode(ConstNode):
    type = PyrexTypes.c_null_ptr_type
636
    value = "NULL"
William Stein's avatar
William Stein committed
637 638 639 640 641


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


class IntNode(ConstNode):
650 651 652 653 654 655

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

    unsigned = ""
    longness = ""
William Stein's avatar
William Stein committed
656 657
    type = PyrexTypes.c_long_type

658 659 660 661
    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:
662
            self.entry = env.get_py_num(self.value, self.longness)
663 664 665 666 667 668 669 670 671 672
            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:
673
            return str(self.value) + self.unsigned + self.longness
William Stein's avatar
William Stein committed
674

675
    def compile_time_value(self, denv):
676
        return int(self.value, 0)
677 678


William Stein's avatar
William Stein committed
679 680 681
class FloatNode(ConstNode):
    type = PyrexTypes.c_double_type

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

William Stein's avatar
William Stein committed
696 697 698 699 700

class StringNode(ConstNode):
    #  entry   Symtab.Entry
    
    type = PyrexTypes.c_char_ptr_type
701 702

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


740 741 742
class UnicodeNode(PyConstNode):
    #  entry   Symtab.Entry

743
    type = unicode_type
744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760

    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.
761 762 763
        
    def compile_time_value(self, env):
        return self.value
764 765


766 767 768
class IdentifierStringNode(ConstNode):
    # A Python string that behaves like an identifier, e.g. for
    # keyword arguments in a call, or for imported names
769 770 771 772 773 774 775 776 777
    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
778 779 780 781 782
class LongNode(AtomicExprNode):
    #  Python long integer literal
    #
    #  value   string
    
783 784
    def compile_time_value(self, denv):
        return long(self.value)
785 786

    gil_message = "Constructing Python long int"
787
    
William Stein's avatar
William Stein committed
788 789
    def analyse_types(self, env):
        self.type = py_object_type
790
        self.gil_check(env)
William Stein's avatar
William Stein committed
791
        self.is_temp = 1
792 793 794

    gil_message = "Constructing Python long int"

William Stein's avatar
William Stein committed
795 796
    def generate_evaluation_code(self, code):
        code.putln(
Robert Bradshaw's avatar
Robert Bradshaw committed
797
            '%s = PyLong_FromString("%s", 0, 0); %s' % (
William Stein's avatar
William Stein committed
798 799
                self.result_code,
                self.value,
Robert Bradshaw's avatar
Robert Bradshaw committed
800
                code.error_goto_if_null(self.result_code, self.pos)))
William Stein's avatar
William Stein committed
801 802 803 804 805 806 807


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

    gil_message = "Constructing complex number"

William Stein's avatar
William Stein committed
818 819
    def generate_evaluation_code(self, code):
        code.putln(
Robert Bradshaw's avatar
Robert Bradshaw committed
820
            "%s = PyComplex_FromDoubles(0.0, %s); %s" % (
William Stein's avatar
William Stein committed
821 822
                self.result_code,
                self.value,
Robert Bradshaw's avatar
Robert Bradshaw committed
823
                code.error_goto_if_null(self.result_code, self.pos)))
William Stein's avatar
William Stein committed
824 825 826 827 828 829


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

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

    gil_message = "Accessing Python global or builtin"

938 939
    def analyse_entry(self, env):
        #print "NameNode.analyse_entry:", self.name ###
William Stein's avatar
William Stein committed
940
        self.check_identifier_kind()
941 942 943 944 945
        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"
946 947
            self.interned_cname = self.entry.interned_cname = \
                env.intern_identifier(self.entry.name)
948

William Stein's avatar
William Stein committed
949
    def check_identifier_kind(self):
950
        #print "NameNode.check_identifier_kind:", self.entry.name ###
951
        #print self.entry.__dict__ ###
William Stein's avatar
William Stein committed
952
        entry = self.entry
Stefan Behnel's avatar
Stefan Behnel committed
953
        #entry.used = 1
William Stein's avatar
William Stein committed
954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970
        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
971
        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
972 973 974 975
            self.not_const()
    
    def check_const_addr(self):
        entry = self.entry
976
        if not (entry.is_cglobal or entry.is_cfunction or entry.is_builtin):
William Stein's avatar
William Stein committed
977 978 979 980 981 982 983 984 985 986 987
            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
988 989 990
    
    def allocate_temp(self, env, result = None):
        AtomicExprNode.allocate_temp(self, env, result)
Stefan Behnel's avatar
Stefan Behnel committed
991 992 993
        entry = self.entry
        if entry:
            entry.used = 1
994 995 996
            if entry.type.is_buffer:
                import Buffer
                Buffer.used_buffer_aux_vars(entry)
Stefan Behnel's avatar
Stefan Behnel committed
997 998
            if entry.utility_code:
                env.use_utility_code(entry.utility_code)
Stefan Behnel's avatar
Stefan Behnel committed
999
        
William Stein's avatar
William Stein committed
1000
    def calculate_result_code(self):
Stefan Behnel's avatar
Stefan Behnel committed
1001 1002
        entry = self.entry
        if not entry:
William Stein's avatar
William Stein committed
1003
            return "<error>" # There was an error earlier
Stefan Behnel's avatar
Stefan Behnel committed
1004
        return entry.cname
William Stein's avatar
William Stein committed
1005 1006
    
    def generate_result_code(self, code):
1007
        assert hasattr(self, 'entry')
William Stein's avatar
William Stein committed
1008 1009 1010
        entry = self.entry
        if entry is None:
            return # There was an error earlier
1011 1012 1013
        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
1014 1015 1016
            if entry.is_builtin:
                namespace = Naming.builtins_cname
            else: # entry.is_pyglobal
1017
                namespace = entry.scope.namespace_cname
1018 1019 1020 1021 1022
            code.putln(
                '%s = __Pyx_GetName(%s, %s); %s' % (
                self.result_code,
                namespace, 
                self.interned_cname,
Dag Sverre Seljebotn's avatar
Merge  
Dag Sverre Seljebotn committed
1023
                code.error_goto_if_null(self.result_code, self.pos)))
1024 1025
        elif entry.is_local and False:
            # control flow not good enough yet
Robert Bradshaw's avatar
Robert Bradshaw committed
1026
            assigned = entry.scope.control_flow.get_state((entry.name, 'initalized'), self.pos)
1027 1028
            if assigned is False:
                error(self.pos, "local variable '%s' referenced before assignment" % entry.name)
Robert Bradshaw's avatar
Robert Bradshaw committed
1029 1030 1031
            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
1032 1033

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

1076 1077
            if self.type.is_pyobject:
                rhs.make_owned_reference(code)
William Stein's avatar
William Stein committed
1078 1079 1080 1081
                #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() ###
1082 1083 1084 1085 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:
                            code.put_decref(self.result_code, self.ctype())
                        elif initalized is None:
                            code.put_xdecref(self.result_code, self.ctype())
                    else:
Robert Bradshaw's avatar
Robert Bradshaw committed
1090
                        code.put_decref(self.result_code, self.ctype())
1091
            code.putln('%s = %s;' % (self.result_code, rhs.result_as(self.ctype())))
William Stein's avatar
William Stein committed
1092
            if debug_disposal_code:
Stefan Behnel's avatar
Stefan Behnel committed
1093 1094
                print("NameNode.generate_assignment_code:")
                print("...generating post-assignment code for %s" % rhs)
William Stein's avatar
William Stein committed
1095
            rhs.generate_post_assignment_code(code)
1096 1097

    def generate_acquire_buffer(self, rhs, code):
1098
        rhstmp = code.funcstate.allocate_temp(self.entry.type)
1099 1100 1101 1102 1103
        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
1104
        Buffer.put_assign_to_buffer(self.result_code, rhstmp, buffer_aux, self.entry.type,
1105 1106 1107
                                    is_initialized=not self.skip_assignment_decref,
                                    pos=self.pos, code=code)
        code.putln("%s = 0;" % rhstmp)
1108
        code.funcstate.release_temp(rhstmp)
William Stein's avatar
William Stein committed
1109 1110 1111 1112 1113 1114 1115
    
    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
1116 1117
        code.put_error_if_neg(self.pos, 
            'PyObject_DelAttrString(%s, "%s")' % (
William Stein's avatar
William Stein committed
1118
                Naming.module_cname,
Robert Bradshaw's avatar
Robert Bradshaw committed
1119
                self.entry.name))
1120 1121 1122 1123 1124 1125 1126 1127
                
    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
1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139
            
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
1140
        self.gil_check(env)
William Stein's avatar
William Stein committed
1141
        self.is_temp = 1
1142 1143 1144

    gil_message = "Backquote expression"

William Stein's avatar
William Stein committed
1145 1146
    def generate_result_code(self, code):
        code.putln(
Robert Bradshaw's avatar
Robert Bradshaw committed
1147
            "%s = PyObject_Repr(%s); %s" % (
William Stein's avatar
William Stein committed
1148 1149
                self.result_code,
                self.arg.py_result(),
Robert Bradshaw's avatar
Robert Bradshaw committed
1150
                code.error_goto_if_null(self.result_code, self.pos)))
William Stein's avatar
William Stein committed
1151 1152 1153 1154 1155 1156 1157


class ImportNode(ExprNode):
    #  Used as part of import statement implementation.
    #  Implements result = 
    #    __import__(module_name, globals(), None, name_list)
    #
1158 1159
    #  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
1160 1161 1162 1163 1164 1165 1166 1167 1168
    
    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
1169
        self.gil_check(env)
William Stein's avatar
William Stein committed
1170 1171
        self.is_temp = 1
        env.use_utility_code(import_utility_code)
1172 1173 1174

    gil_message = "Python import"

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


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
1200
        self.gil_check(env)
William Stein's avatar
William Stein committed
1201
        self.is_temp = 1
Robert Bradshaw's avatar
Robert Bradshaw committed
1202 1203 1204
        
        self.counter = TempNode(self.pos, PyrexTypes.c_py_ssize_t_type, env)
        self.counter.allocate_temp(env)
1205 1206 1207

    gil_message = "Iterating over Python object"

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


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):
1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264
        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;" % (
                    self.iterator.counter.result_code,
                    py_type,
                    self.iterator.py_result()))
            code.putln(
                "%s = Py%s_GET_ITEM(%s, %s); Py_INCREF(%s); %s++;" % (
                    self.result_code,
                    py_type,
                    self.iterator.py_result(),
                    self.iterator.counter.result_code,
                    self.result_code,
                    self.iterator.counter.result_code))
            code.put("} else ")
        code.putln("{")
William Stein's avatar
William Stein committed
1265 1266 1267 1268 1269 1270 1271
        code.putln(
            "%s = PyIter_Next(%s);" % (
                self.result_code,
                self.iterator.py_result()))
        code.putln(
            "if (!%s) {" %
                self.result_code)
1272
        code.putln(code.error_goto_if_PyErr(self.pos))
Robert Bradshaw's avatar
Robert Bradshaw committed
1273 1274 1275
        code.putln("break;")
        code.putln("}")
        code.putln("}")
1276

William Stein's avatar
William Stein committed
1277 1278 1279 1280 1281 1282

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

William Stein's avatar
William Stein committed
1291
    def generate_result_code(self, code):
1292
        pass
William Stein's avatar
William Stein committed
1293

1294 1295 1296
    def analyse_types(self, env):
        pass

William Stein's avatar
William Stein committed
1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307

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
1308 1309 1310
        
    def analyse_types(self, env):
        return self.type
William Stein's avatar
William Stein committed
1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333
    
    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
1334 1335 1336 1337 1338 1339
    #  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
1340
    
1341 1342 1343 1344 1345 1346
    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
1347
    
1348 1349 1350 1351 1352 1353 1354 1355
    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
1356 1357 1358 1359 1360 1361 1362
    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
1363 1364 1365 1366
        self.analyse_base_and_index_types(env, getting = 1)
    
    def analyse_target_types(self, env):
        self.analyse_base_and_index_types(env, setting = 1)
1367

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

        # 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.
1376 1377
        self.is_buffer_access = False

William Stein's avatar
William Stein committed
1378
        self.base.analyse_types(env)
1379 1380 1381
        # 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)
1382 1383 1384

        skip_child_analysis = False
        buffer_access = False
1385
        if self.base.type.is_buffer:
1386 1387 1388
            assert hasattr(self.base, "entry") # Must be a NameNode-like node
            if self.indices:
                indices = self.indices
1389
            else:
1390 1391 1392 1393 1394 1395
                # 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]
1396
            if len(indices) == self.base.type.ndim:
1397 1398 1399 1400 1401 1402
                buffer_access = True
                skip_child_analysis = True
                for x in indices:
                    x.analyse_types(env)
                    if not x.type.is_int:
                        buffer_access = False
1403

1404 1405
        if buffer_access:
            self.indices = indices
1406
            self.index = None
1407 1408
            self.type = self.base.type.dtype
            self.is_buffer_access = True
1409
            self.buffer_type = self.base.entry.type
1410
           
1411 1412 1413 1414
            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
1415 1416 1417 1418 1419
            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
1420
        else:
1421 1422 1423 1424
            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)
1425
            if self.base.type.is_pyobject:
1426
                if self.index.type.is_int and not self.index.type.is_longlong:
1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437
                    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
1438
            else:
1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452
                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)
1453 1454 1455

    gil_message = "Indexing Python object"

William Stein's avatar
William Stein committed
1456 1457 1458 1459 1460 1461 1462 1463
    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):
1464
        if self.is_buffer_access:
1465
            return "<not used>"
1466 1467 1468
        else:
            return "(%s[%s])" % (
                self.base.result_code, self.index.result_code)
Dag Sverre Seljebotn's avatar
Merge  
Dag Sverre Seljebotn committed
1469 1470 1471 1472 1473 1474 1475 1476 1477
            
    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 ""
1478 1479 1480

    def generate_subexpr_evaluation_code(self, code):
        self.base.generate_evaluation_code(code)
1481
        if not self.indices:
1482 1483
            self.index.generate_evaluation_code(code)
        else:
1484 1485
            for i in self.indices:
                i.generate_evaluation_code(code)
1486
        
1487 1488
    def generate_subexpr_disposal_code(self, code):
        self.base.generate_disposal_code(code)
1489
        if not self.indices:
1490 1491
            self.index.generate_disposal_code(code)
        else:
1492 1493
            for i in self.indices:
                i.generate_disposal_code(code)
1494

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

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

    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:
                rhs_code = rhs.result_code
            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
            code.putln("*%s %s= %s;" % (ptrexpr, op, rhs.result_code))

William Stein's avatar
William Stein committed
1561 1562
    def generate_assignment_code(self, rhs, code):
        self.generate_subexpr_evaluation_code(code)
1563
        if self.is_buffer_access:
1564
            self.generate_buffer_setitem_code(rhs, code)
1565
        elif self.type.is_pyobject:
Dag Sverre Seljebotn's avatar
Merge  
Dag Sverre Seljebotn committed
1566
            self.generate_setitem_code(rhs.py_result(), code)
William Stein's avatar
William Stein committed
1567 1568 1569 1570
        else:
            code.putln(
                "%s = %s;" % (
                    self.result_code, rhs.result_code))
1571
        self.generate_subexpr_disposal_code(code)
William Stein's avatar
William Stein committed
1572 1573 1574 1575
        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
1576 1577 1578 1579 1580 1581 1582 1583 1584 1585
        #if self.type.is_pyobject:
        if self.index.type.is_int:
            function = "PySequence_DelItem"
            index_code = self.index.result_code
        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
1586
                self.base.py_result(),
Dag Sverre Seljebotn's avatar
Merge  
Dag Sverre Seljebotn committed
1587 1588
                index_code,
                code.error_goto(self.pos)))
William Stein's avatar
William Stein committed
1589
        self.generate_subexpr_disposal_code(code)
1590

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

class SliceIndexNode(ExprNode):
    #  2-element slice indexing
    #
    #  base      ExprNode
    #  start     ExprNode or None
    #  stop      ExprNode or None
    
    subexprs = ['base', 'start', 'stop']
    
1615 1616 1617 1618 1619 1620 1621 1622 1623
    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
1624 1625 1626 1627 1628 1629 1630 1631 1632 1633
    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)
1634
        c_int = PyrexTypes.c_py_ssize_t_type
William Stein's avatar
William Stein committed
1635 1636 1637 1638 1639
        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
1640
        self.gil_check(env)
William Stein's avatar
William Stein committed
1641
        self.is_temp = 1
1642 1643 1644

    gil_message = "Slicing Python object"

William Stein's avatar
William Stein committed
1645 1646
    def generate_result_code(self, code):
        code.putln(
Robert Bradshaw's avatar
Robert Bradshaw committed
1647
            "%s = PySequence_GetSlice(%s, %s, %s); %s" % (
William Stein's avatar
William Stein committed
1648 1649 1650 1651
                self.result_code,
                self.base.py_result(),
                self.start_code(),
                self.stop_code(),
Robert Bradshaw's avatar
Robert Bradshaw committed
1652
                code.error_goto_if_null(self.result_code, self.pos)))
William Stein's avatar
William Stein committed
1653 1654 1655
    
    def generate_assignment_code(self, rhs, code):
        self.generate_subexpr_evaluation_code(code)
Robert Bradshaw's avatar
Robert Bradshaw committed
1656 1657
        code.put_error_if_neg(self.pos, 
            "PySequence_SetSlice(%s, %s, %s, %s)" % (
William Stein's avatar
William Stein committed
1658 1659 1660
                self.base.py_result(),
                self.start_code(),
                self.stop_code(),
Robert Bradshaw's avatar
Robert Bradshaw committed
1661
                rhs.result_code))
William Stein's avatar
William Stein committed
1662 1663 1664 1665 1666
        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
1667 1668
        code.put_error_if_neg(self.pos,
            "PySequence_DelSlice(%s, %s, %s)" % (
William Stein's avatar
William Stein committed
1669 1670
                self.base.py_result(),
                self.start_code(),
Robert Bradshaw's avatar
Robert Bradshaw committed
1671
                self.stop_code()))
William Stein's avatar
William Stein committed
1672 1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683
        self.generate_subexpr_disposal_code(code)
    
    def start_code(self):
        if self.start:
            return self.start.result_code
        else:
            return "0"
    
    def stop_code(self):
        if self.stop:
            return self.stop.result_code
        else:
1684
            return "PY_SSIZE_T_MAX"
William Stein's avatar
William Stein committed
1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697
    
    def calculate_result_code(self):
        # self.result_code is not used, but this method must exist
        return "<unused>"
    

class SliceNode(ExprNode):
    #  start:stop:step in subscript list
    #
    #  start     ExprNode
    #  stop      ExprNode
    #  step      ExprNode
    
1698 1699 1700 1701 1702 1703 1704 1705 1706
    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
1707 1708 1709 1710 1711 1712 1713 1714 1715 1716
    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
1717
        self.gil_check(env)
William Stein's avatar
William Stein committed
1718
        self.is_temp = 1
1719 1720 1721

    gil_message = "Constructing Python slice object"

William Stein's avatar
William Stein committed
1722 1723
    def generate_result_code(self, code):
        code.putln(
Robert Bradshaw's avatar
Robert Bradshaw committed
1724
            "%s = PySlice_New(%s, %s, %s); %s" % (
William Stein's avatar
William Stein committed
1725 1726 1727 1728
                self.result_code,
                self.start.py_result(), 
                self.stop.py_result(), 
                self.step.py_result(),
Robert Bradshaw's avatar
Robert Bradshaw committed
1729
                code.error_goto_if_null(self.result_code, self.pos)))
William Stein's avatar
William Stein committed
1730

1731 1732 1733 1734 1735 1736 1737 1738 1739

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
1740 1741 1742 1743 1744 1745 1746
    #  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
1747
    #  wrapper_call   bool                 used internally
1748
    #  has_optional_args   bool            used internally
William Stein's avatar
William Stein committed
1749 1750 1751 1752 1753 1754
    
    subexprs = ['self', 'coerced_self', 'function', 'args', 'arg_tuple']
    
    self = None
    coerced_self = None
    arg_tuple = None
1755
    wrapper_call = False
1756
    has_optional_args = False
William Stein's avatar
William Stein committed
1757
    
1758 1759 1760 1761 1762 1763 1764 1765
    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
1766 1767 1768 1769
    def analyse_types(self, env):
        function = self.function
        function.is_called = 1
        self.function.analyse_types(env)
Robert Bradshaw's avatar
Robert Bradshaw committed
1770 1771 1772 1773 1774 1775 1776 1777 1778
        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
1779 1780 1781 1782 1783 1784 1785
        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:
1786 1787
            self.arg_tuple = TupleNode(self.pos, args = self.args)
            self.arg_tuple.analyse_types(env)
William Stein's avatar
William Stein committed
1788 1789
            self.args = None
            self.type = py_object_type
1790
            self.gil_check(env)
William Stein's avatar
William Stein committed
1791 1792 1793 1794 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
            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
1823 1824
        max_nargs = len(func_type.args)
        expected_nargs = max_nargs - func_type.optional_arg_count
William Stein's avatar
William Stein committed
1825 1826
        actual_nargs = len(self.args)
        if actual_nargs < expected_nargs \
1827
            or (not func_type.has_varargs and actual_nargs > max_nargs):
William Stein's avatar
William Stein committed
1828 1829 1830
                expected_str = str(expected_nargs)
                if func_type.has_varargs:
                    expected_str = "at least " + expected_str
1831
                elif func_type.optional_arg_count:
1832
                    if actual_nargs < max_nargs:
1833 1834 1835
                        expected_str = "at least " + expected_str
                    else:
                        expected_str = "at most " + str(max_nargs)
William Stein's avatar
William Stein committed
1836 1837 1838 1839 1840 1841 1842
                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
1843 1844 1845 1846 1847
        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
1848
        # Coerce arguments
1849
        for i in range(min(max_nargs, actual_nargs)):
William Stein's avatar
William Stein committed
1850 1851
            formal_type = func_type.args[i].type
            self.args[i] = self.args[i].coerce_to(formal_type, env)
1852
        for i in range(max_nargs, actual_nargs):
William Stein's avatar
William Stein committed
1853 1854 1855 1856 1857
            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
1858 1859 1860
        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
1861
                self.is_temp = 1
1862 1863
                if self.type.is_pyobject:
                    self.result_ctype = py_object_type
Robert Bradshaw's avatar
Robert Bradshaw committed
1864 1865 1866 1867
        # C++ exception handler
        if func_type.exception_check == '+':
            if func_type.exception_value is None:
                env.use_utility_code(cpp_exception_utility_code)
1868 1869 1870
        # Check gil
        if not func_type.nogil:
            self.gil_check(env)
Robert Bradshaw's avatar
Robert Bradshaw committed
1871

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

1973
class GeneralCallNode(CallNode):
William Stein's avatar
William Stein committed
1974 1975 1976 1977 1978 1979 1980 1981 1982 1983
    #  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']

1984 1985 1986 1987 1988 1989 1990 1991 1992 1993 1994
    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
1995 1996 1997 1998 1999 2000 2001 2002 2003 2004 2005 2006 2007 2008
    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
2009
        self.gil_check(env)
William Stein's avatar
William Stein committed
2010 2011 2012 2013
        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
2014 2015
            code.put_error_if_neg(self.pos, 
                "PyDict_Update(%s, %s)" % (
William Stein's avatar
William Stein committed
2016
                    self.keyword_args.py_result(), 
Robert Bradshaw's avatar
Robert Bradshaw committed
2017
                    self.starstar_arg.py_result()))
William Stein's avatar
William Stein committed
2018 2019 2020 2021 2022 2023 2024 2025
            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:
2026
            call_code = "PyObject_Call(%s, %s, NULL)" % (
William Stein's avatar
William Stein committed
2027 2028 2029 2030 2031 2032 2033 2034
                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
2035
            "%s = %s; %s" % (
William Stein's avatar
William Stein committed
2036 2037
                self.result_code,
                call_code,
Robert Bradshaw's avatar
Robert Bradshaw committed
2038
                code.error_goto_if_null(self.result_code, self.pos)))
William Stein's avatar
William Stein committed
2039 2040 2041 2042 2043 2044 2045 2046 2047 2048


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

    gil_message = "Constructing Python tuple"

William Stein's avatar
William Stein committed
2065 2066
    def generate_result_code(self, code):
        code.putln(
Robert Bradshaw's avatar
Robert Bradshaw committed
2067
            "%s = PySequence_Tuple(%s); %s" % (
William Stein's avatar
William Stein committed
2068 2069
                self.result_code,
                self.arg.py_result(),
Robert Bradshaw's avatar
Robert Bradshaw committed
2070
                code.error_goto_if_null(self.result_code, self.pos)))
William Stein's avatar
William Stein committed
2071 2072 2073 2074 2075 2076 2077
    

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

2098 2099 2100 2101 2102 2103 2104 2105 2106 2107 2108
    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
2109
        return ExprNode.coerce_to(self, dst_type, env)
2110
    
2111 2112 2113 2114 2115 2116 2117 2118 2119 2120 2121 2122
    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
2123 2124 2125 2126 2127 2128 2129 2130 2131 2132 2133 2134 2135 2136 2137 2138 2139 2140 2141 2142 2143 2144 2145 2146 2147 2148 2149 2150 2151 2152 2153 2154 2155 2156 2157 2158 2159 2160 2161 2162 2163 2164 2165 2166
    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
2167
                ubcm_entry.is_unbound_cmethod = 1
William Stein's avatar
William Stein committed
2168 2169 2170 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
                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:
2203
            NameNode.analyse_rvalue_entry(self, env)
William Stein's avatar
William Stein committed
2204 2205 2206 2207 2208
    
    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:
2209 2210
#            error(self.pos, "C method can only be called")
            pass
2211 2212 2213
        ## 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
2214 2215 2216 2217 2218 2219 2220 2221 2222 2223 2224 2225
        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
2226
        if obj_type.is_ptr or obj_type.is_array:
William Stein's avatar
William Stein committed
2227 2228 2229 2230 2231 2232 2233 2234 2235 2236
            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
2237 2238
                if entry and entry.is_member:
                    entry = None
William Stein's avatar
William Stein committed
2239 2240 2241 2242
            else:
                error(self.pos, 
                    "Cannot select attribute of incomplete type '%s'" 
                    % obj_type)
Robert Bradshaw's avatar
Robert Bradshaw committed
2243 2244
                self.type = PyrexTypes.error_type
                return
William Stein's avatar
William Stein committed
2245 2246
            self.entry = entry
            if entry:
2247 2248
                if obj_type.is_extension_type and entry.name == "__weakref__":
                    error(self.pos, "Illegal use of special attribute __weakref__")
2249 2250
                # methods need the normal attribute lookup
                # because they do not have struct entries
2251 2252 2253 2254
                if entry.is_variable or entry.is_cmethod:
                    self.type = entry.type
                    self.member = entry.cname
                    return
William Stein's avatar
William Stein committed
2255 2256 2257 2258 2259 2260 2261 2262 2263
                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.
2264 2265 2266 2267 2268
        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
2269 2270 2271
        if obj_type.is_pyobject:
            self.type = py_object_type
            self.is_py_attr = 1
2272
            self.interned_attr_cname = env.intern_identifier(self.attribute)
2273
            self.gil_check(env)
William Stein's avatar
William Stein committed
2274 2275 2276 2277 2278
        else:
            if not obj_type.is_error:
                error(self.pos, 
                    "Object of type '%s' has no attribute '%s'" %
                    (obj_type, self.attribute))
2279 2280 2281

    gil_message = "Accessing Python attribute"

William Stein's avatar
William Stein committed
2282 2283 2284 2285 2286 2287 2288 2289 2290 2291 2292 2293 2294 2295 2296 2297 2298 2299 2300 2301 2302 2303 2304 2305 2306 2307
    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 ###
        #print "...obj node =", self.obj, "code", self.obj.result_code ###
        #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
2308 2309 2310 2311 2312 2313
            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
2314 2315 2316 2317 2318
        else:
            return "%s%s%s" % (obj_code, self.op, self.member)
    
    def generate_result_code(self, code):
        if self.is_py_attr:
2319 2320 2321 2322 2323 2324
            code.putln(
                '%s = PyObject_GetAttr(%s, %s); %s' % (
                    self.result_code,
                    self.obj.py_result(),
                    self.interned_attr_cname,
                    code.error_goto_if_null(self.result_code, self.pos)))
2325 2326 2327
        else:
            # result_code contains what is needed, but we may need to insert
            # a check and raise an exception
2328 2329 2330 2331
            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
2332 2333 2334 2335
    
    def generate_assignment_code(self, rhs, code):
        self.obj.generate_evaluation_code(code)
        if self.is_py_attr:
2336 2337 2338 2339 2340
            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
2341 2342
            rhs.generate_disposal_code(code)
        else:
2343 2344 2345 2346 2347
            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
2348 2349 2350 2351 2352 2353 2354
            select_code = self.result_code
            if self.type.is_pyobject:
                rhs.make_owned_reference(code)
                code.put_decref(select_code, self.ctype())
            code.putln(
                "%s = %s;" % (
                    select_code,
2355 2356
                    rhs.result_as(self.ctype())))
                    #rhs.result_code))
William Stein's avatar
William Stein committed
2357 2358 2359 2360 2361 2362
            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:
2363 2364 2365 2366
            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
2367 2368 2369
        else:
            error(self.pos, "Cannot delete C attribute of extension type")
        self.obj.generate_disposal_code(code)
2370 2371 2372 2373 2374 2375
        
    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
2376

2377 2378 2379 2380 2381 2382 2383 2384
    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
2385 2386 2387 2388 2389 2390 2391 2392 2393 2394 2395
#-------------------------------------------------------------------
#
#  Constructor nodes
#
#-------------------------------------------------------------------

class SequenceNode(ExprNode):
    #  Base class for list and tuple constructor nodes.
    #  Contains common code for performing sequence unpacking.
    #
    #  args                    [ExprNode]
2396
    #  iterator                ExprNode
William Stein's avatar
William Stein committed
2397 2398 2399 2400 2401 2402 2403 2404
    #  unpacked_items          [ExprNode] or None
    #  coerced_unpacked_items  [ExprNode] or None
    
    subexprs = ['args']
    
    is_sequence_constructor = 1
    unpacked_items = None
    
2405 2406 2407
    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
2408 2409 2410 2411
    def analyse_target_declaration(self, env):
        for arg in self.args:
            arg.analyse_target_declaration(env)

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

William Stein's avatar
William Stein committed
2421
    def analyse_target_types(self, env):
2422 2423
        self.iterator = PyTempNode(self.pos, env)
        self.unpacked_items = []
William Stein's avatar
William Stein committed
2424 2425 2426 2427 2428 2429 2430 2431 2432 2433
        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)
    
2434 2435 2436
    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
2437
            node.allocate_temps(env)
2438 2439 2440
            arg.allocate_target_temps(env, node)
            #arg.release_target_temp(env)
            #node.release_temp(env)
2441 2442
        if rhs:
            rhs.release_temp(env)
2443 2444 2445 2446 2447 2448 2449 2450
        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
2451 2452 2453 2454 2455
    
    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
2456 2457 2458 2459 2460
        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
2461
        code.putln("PyObject* tuple = %s;" % rhs.py_result())
Robert Bradshaw's avatar
Robert Bradshaw committed
2462 2463 2464
        for i in range(len(self.args)):
            item = self.unpacked_items[i]
            code.putln(
Stefan Behnel's avatar
Stefan Behnel committed
2465
                "%s = PyTuple_GET_ITEM(tuple, %s);" % (
Robert Bradshaw's avatar
Robert Bradshaw committed
2466 2467 2468 2469 2470 2471 2472
                    item.result_code,
                    i))
            code.put_incref(item.result_code, item.ctype())
            value_node = self.coerced_unpacked_items[i]
            value_node.generate_evaluation_code(code)
            self.args[i].generate_assignment_code(value_node, code)
            
2473
        rhs.generate_disposal_code(code)
Robert Bradshaw's avatar
Robert Bradshaw committed
2474 2475 2476
        code.putln("}")
        code.putln("else {")

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

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


class TupleNode(SequenceNode):
    #  Tuple constructor.
2517 2518 2519

    gil_message = "Constructing Python tuple"

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

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


class ListNode(SequenceNode):
    #  List constructor.
2570 2571 2572

    gil_message = "Constructing Python list"

Robert Bradshaw's avatar
Robert Bradshaw committed
2573 2574 2575 2576
    def analyse_types(self, env):
        SequenceNode.analyse_types(self, env)
        self.type = list_type

2577 2578 2579
    def compile_time_value(self, denv):
        return self.compile_time_value_list(denv)

William Stein's avatar
William Stein committed
2580
    def generate_operation_code(self, code):
Robert Bradshaw's avatar
Robert Bradshaw committed
2581
        code.putln("%s = PyList_New(%s); %s" %
William Stein's avatar
William Stein committed
2582 2583
            (self.result_code,
            len(self.args),
Robert Bradshaw's avatar
Robert Bradshaw committed
2584
            code.error_goto_if_null(self.result_code, self.pos)))
William Stein's avatar
William Stein committed
2585 2586 2587 2588 2589 2590 2591 2592 2593 2594 2595 2596 2597 2598 2599 2600 2601
        for i in range(len(self.args)):
            arg = self.args[i]
            #if not arg.is_temp:
            if not arg.result_in_temp():
                code.put_incref(arg.result_code, arg.ctype())
            code.putln("PyList_SET_ITEM(%s, %s, %s);" %
                (self.result_code,
                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
2602 2603 2604 2605
            
class ListComprehensionNode(SequenceNode):

    subexprs = []
2606
    is_sequence_constructor = 0 # not unpackable
Robert Bradshaw's avatar
Robert Bradshaw committed
2607

2608 2609
    child_attrs = ["loop", "append"]

Robert Bradshaw's avatar
Robert Bradshaw committed
2610
    def analyse_types(self, env): 
Robert Bradshaw's avatar
Robert Bradshaw committed
2611
        self.type = list_type
Robert Bradshaw's avatar
Robert Bradshaw committed
2612 2613 2614 2615 2616
        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
2617
            print("%s Allocating temps" % self)
Robert Bradshaw's avatar
Robert Bradshaw committed
2618 2619 2620 2621 2622
        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
2623
        code.putln("%s = PyList_New(%s); %s" %
Robert Bradshaw's avatar
Robert Bradshaw committed
2624 2625
            (self.result_code,
            0,
Robert Bradshaw's avatar
Robert Bradshaw committed
2626
            code.error_goto_if_null(self.result_code, self.pos)))
Robert Bradshaw's avatar
Robert Bradshaw committed
2627
        self.loop.generate_execution_code(code)
2628 2629 2630
        
    def annotate(self, code):
        self.loop.annotate(code)
Robert Bradshaw's avatar
Robert Bradshaw committed
2631 2632 2633 2634


class ListComprehensionAppendNode(ExprNode):

2635 2636
    # Need to be careful to avoid infinite recursion:
    # target must not be in child_attrs/subexprs
Robert Bradshaw's avatar
Robert Bradshaw committed
2637 2638 2639 2640 2641 2642 2643 2644 2645 2646
    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):
2647
        code.putln("%s = PyList_Append(%s, (PyObject*)%s); %s" %
Robert Bradshaw's avatar
Robert Bradshaw committed
2648 2649 2650
            (self.result_code,
            self.target.result_code,
            self.expr.result_code,
Robert Bradshaw's avatar
Robert Bradshaw committed
2651
            code.error_goto_if(self.result_code, self.pos)))
Robert Bradshaw's avatar
Robert Bradshaw committed
2652

William Stein's avatar
William Stein committed
2653 2654 2655 2656

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

    gil_message = "Constructing Python dict"

William Stein's avatar
William Stein committed
2678 2679 2680 2681
    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
2682 2683 2684 2685 2686
        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
2687 2688 2689 2690 2691
    
    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
2692
            "%s = PyDict_New(); %s" % (
William Stein's avatar
William Stein committed
2693
                self.result_code,
Robert Bradshaw's avatar
Robert Bradshaw committed
2694
                code.error_goto_if_null(self.result_code, self.pos)))
Robert Bradshaw's avatar
Robert Bradshaw committed
2695 2696
        for item in self.key_value_pairs:
            item.generate_evaluation_code(code)
Robert Bradshaw's avatar
Robert Bradshaw committed
2697 2698
            code.put_error_if_neg(self.pos, 
                "PyDict_SetItem(%s, %s, %s)" % (
William Stein's avatar
William Stein committed
2699
                    self.result_code,
Robert Bradshaw's avatar
Robert Bradshaw committed
2700 2701 2702
                    item.key.py_result(),
                    item.value.py_result()))
            item.generate_disposal_code(code)
2703 2704
            
    def annotate(self, code):
Robert Bradshaw's avatar
Robert Bradshaw committed
2705 2706 2707 2708 2709 2710 2711 2712 2713 2714 2715 2716 2717 2718 2719 2720 2721 2722 2723 2724 2725 2726 2727
        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
2728

Stefan Behnel's avatar
Stefan Behnel committed
2729

William Stein's avatar
William Stein committed
2730 2731 2732 2733 2734
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
2735 2736
    #  name         EncodedString      Name of the class
    #  cname        string             Class name as a Python string
William Stein's avatar
William Stein committed
2737 2738 2739 2740 2741
    #  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
    
2742 2743
    subexprs = ['bases', 'doc']

William Stein's avatar
William Stein committed
2744
    def analyse_types(self, env):
2745
        self.cname = env.intern_identifier(self.name)
William Stein's avatar
William Stein committed
2746 2747 2748 2749 2750 2751
        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
2752
        self.gil_check(env)
William Stein's avatar
William Stein committed
2753 2754
        self.is_temp = 1
        env.use_utility_code(create_class_utility_code);
2755

2756 2757
    gil_message = "Constructing Python class"

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


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
2787
        self.gil_check(env)
William Stein's avatar
William Stein committed
2788
        self.is_temp = 1
2789 2790 2791

    gil_message = "Constructing an unbound method"

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


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
2810
        self.gil_check(env)
William Stein's avatar
William Stein committed
2811
        self.is_temp = 1
2812 2813 2814

    gil_message = "Constructing Python function"

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

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

2828 2829 2830 2831 2832 2833 2834
compile_time_unary_operators = {
    'not': operator.not_,
    '~': operator.inv,
    '-': operator.neg,
    '+': operator.pos,
}

William Stein's avatar
William Stein committed
2835 2836 2837 2838 2839 2840 2841 2842 2843 2844 2845 2846 2847 2848
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']
    
2849 2850 2851 2852 2853 2854 2855 2856 2857 2858 2859 2860
    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
2861 2862 2863 2864 2865
    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
2866
            self.gil_check(env)
William Stein's avatar
William Stein committed
2867 2868 2869 2870 2871 2872 2873 2874 2875 2876 2877 2878 2879 2880 2881 2882 2883 2884 2885 2886 2887 2888 2889
            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
2890
            "%s = %s(%s); %s" % (
William Stein's avatar
William Stein committed
2891 2892 2893
                self.result_code, 
                function, 
                self.operand.py_result(),
Robert Bradshaw's avatar
Robert Bradshaw committed
2894
                code.error_goto_if_null(self.result_code, self.pos)))
William Stein's avatar
William Stein committed
2895 2896 2897 2898 2899 2900 2901 2902 2903 2904 2905 2906 2907
        
    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
    
2908 2909 2910 2911 2912 2913 2914
    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
2915 2916 2917 2918 2919
    subexprs = ['operand']
    
    def analyse_types(self, env):
        self.operand.analyse_types(env)
        self.operand = self.operand.coerce_to_boolean(env)
2920
        self.type = PyrexTypes.c_bint_type
William Stein's avatar
William Stein committed
2921 2922 2923 2924 2925 2926 2927 2928 2929 2930 2931 2932 2933 2934 2935 2936 2937 2938 2939 2940 2941 2942 2943 2944 2945 2946 2947 2948 2949 2950 2951 2952 2953 2954 2955 2956 2957 2958 2959 2960 2961 2962 2963 2964 2965 2966 2967 2968 2969 2970 2971 2972 2973 2974 2975 2976 2977 2978 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 3008 3009 3010 3011 3012 3013 3014 3015 3016 3017 3018 3019
    
    def calculate_result_code(self):
        return "(!%s)" % self.operand.result_code
    
    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):
        return self.operand.result_code


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):
        return "(-%s)" % self.operand.result_code


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):
        return "(~%s)" % self.operand.result_code


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):
        return "(&%s)" % self.operand.result_code

    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.
3020
    if isinstance(operand, IntNode) and operator == '-':
3021
        return IntNode(pos = operand.pos, value = str(-int(operand.value, 0)))
Robert Bradshaw's avatar
Robert Bradshaw committed
3022 3023
    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
3024 3025 3026 3027 3028 3029 3030 3031
    return unop_node_classes[operator](pos, 
        operator = operator, 
        operand = operand)


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


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):
3114 3115 3116 3117 3118 3119 3120 3121 3122 3123 3124 3125 3126 3127
        # 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
3128 3129 3130
        base_type = self.base_type.analyse(env)
        _, arg_type = self.declarator.analyse(base_type, env)
        self.arg_type = arg_type
3131
        if arg_type.is_pyobject and not arg_type.is_extension_type:
William Stein's avatar
William Stein committed
3132 3133 3134 3135 3136 3137 3138 3139
            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):
3140 3141 3142 3143 3144 3145
        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
3146 3147 3148 3149 3150 3151 3152 3153 3154 3155 3156 3157 3158 3159 3160 3161 3162 3163 3164 3165 3166 3167 3168 3169 3170 3171 3172
        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):
        return "(sizeof(%s))" % self.operand.result_code
    
    def generate_result_code(self, code):
        pass


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

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

3176 3177 3178
compile_time_binary_operators = {
    '<': operator.lt,
    '<=': operator.le,
3179
    '==': operator.eq,
3180 3181 3182 3183 3184 3185 3186 3187 3188 3189 3190 3191 3192 3193 3194 3195 3196 3197
    '!=': 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
3198 3199
    'in': operator.contains,
    'not_in': _not_in,
3200 3201 3202 3203 3204 3205 3206
}

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

William Stein's avatar
William Stein committed
3210 3211 3212 3213 3214 3215 3216 3217 3218 3219 3220 3221 3222 3223 3224
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']
    
3225 3226 3227 3228 3229 3230 3231 3232 3233
    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
3234 3235 3236 3237 3238 3239
    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
3240
            self.gil_check(env)
William Stein's avatar
William Stein committed
3241
            self.is_temp = 1
3242 3243
            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
3244 3245 3246 3247 3248 3249 3250 3251 3252 3253 3254 3255 3256 3257 3258 3259 3260 3261 3262 3263 3264 3265 3266 3267
        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
3268
                "%s = %s(%s, %s%s); %s" % (
William Stein's avatar
William Stein committed
3269 3270 3271 3272 3273
                    self.result_code, 
                    function, 
                    self.operand1.py_result(),
                    self.operand2.py_result(),
                    extra_args,
Robert Bradshaw's avatar
Robert Bradshaw committed
3274
                    code.error_goto_if_null(self.result_code, self.pos)))
William Stein's avatar
William Stein committed
3275 3276 3277 3278 3279 3280 3281 3282 3283 3284 3285 3286 3287 3288 3289 3290 3291 3292 3293
        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
3294 3295 3296 3297
        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
3298 3299 3300 3301 3302 3303 3304 3305 3306 3307 3308
        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):
3309 3310 3311
        #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
3312 3313 3314 3315 3316 3317 3318 3319 3320 3321 3322 3323 3324 3325 3326 3327 3328 3329 3330

    def calculate_result_code(self):
        return "(%s %s %s)" % (
            self.operand1.result_code, 
            self.operator, 
            self.operand2.result_code)
    
    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
3331
        "/":		"__Pyx_PyNumber_Divide",
Robert Bradshaw's avatar
Robert Bradshaw committed
3332
        "//":		"PyNumber_FloorDivide",
William Stein's avatar
William Stein committed
3333
        "%":		"PyNumber_Remainder",
3334
        "**":       "PyNumber_Power"
William Stein's avatar
William Stein committed
3335 3336 3337 3338 3339 3340 3341
    }


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

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


class SubNode(NumBinopNode):
    #  '-' operator.
    
    def compute_c_result_type(self, type1, type2):
3372
        if (type1.is_ptr or type1.is_array) and (type2.is_int or type2.is_enum):
William Stein's avatar
William Stein committed
3373
            return type1
3374
        elif (type1.is_ptr or type1.is_array) and (type2.is_ptr or type2.is_array):
William Stein's avatar
William Stein committed
3375 3376 3377 3378 3379 3380 3381 3382 3383 3384 3385 3386 3387 3388 3389 3390 3391 3392 3393
            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
3394 3395 3396 3397 3398 3399 3400 3401 3402 3403
class FloorDivNode(NumBinopNode):
    #  '//' operator.
    
    def calculate_result_code(self):
        return "(%s %s %s)" % (
            self.operand1.result_code, 
            "/",  # c division is by default floor-div 
            self.operand2.result_code)


William Stein's avatar
William Stein committed
3404 3405 3406 3407 3408 3409 3410 3411 3412 3413 3414
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.
3415

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

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

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

3430 3431 3432 3433 3434 3435 3436 3437
    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
3438

William Stein's avatar
William Stein committed
3439 3440 3441
    def calculate_result_code(self):
        return "pow(%s, %s)" % (
            self.operand1.result_code, self.operand2.result_code)
3442

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

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']
    
3456 3457 3458 3459 3460 3461 3462 3463
    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
3464 3465 3466 3467 3468 3469 3470
    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)
3471
            self.temp_bool = TempNode(self.pos, PyrexTypes.c_bint_type, env)
William Stein's avatar
William Stein committed
3472
            self.type = py_object_type
3473
            self.gil_check(env)
William Stein's avatar
William Stein committed
3474 3475 3476
        else:
            self.operand1 = self.operand1.coerce_to_boolean(env)
            self.operand2 = self.operand2.coerce_to_boolean(env)
3477
            self.type = PyrexTypes.c_bint_type
William Stein's avatar
William Stein committed
3478 3479 3480 3481 3482
        # 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
3483 3484 3485

    gil_message = "Truth-testing Python object"

William Stein's avatar
William Stein committed
3486 3487 3488 3489 3490 3491 3492 3493 3494 3495 3496 3497 3498 3499 3500 3501 3502 3503 3504 3505 3506 3507 3508 3509 3510 3511 3512 3513 3514 3515 3516 3517 3518 3519 3520 3521 3522 3523 3524 3525 3526 3527 3528 3529 3530 3531 3532 3533 3534 3535 3536 3537 3538 3539 3540
    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)
        self.operand1.allocate_temps(env, self.result_code)
        if self.temp_bool:
            self.temp_bool.allocate_temp(env)
            self.temp_bool.release_temp(env)
        self.operand2.allocate_temps(env, self.result_code)
        #  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)" % (
            self.operand1.result_code,
            self.py_to_c_op[self.operator],
            self.operand2.result_code)
    
    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:
            test_result = self.temp_bool.result_code
            code.putln(
3541
                "%s = __Pyx_PyObject_IsTrue(%s); %s" % (
William Stein's avatar
William Stein committed
3542 3543
                    test_result,
                    self.operand1.py_result(),
Robert Bradshaw's avatar
Robert Bradshaw committed
3544
                    code.error_goto_if_neg(test_result, self.pos)))
William Stein's avatar
William Stein committed
3545 3546 3547 3548 3549
        else:
            test_result = self.operand1.result_code
        return test_result


Robert Bradshaw's avatar
Robert Bradshaw committed
3550 3551 3552 3553 3554 3555 3556 3557
class CondExprNode(ExprNode):
    #  Short-circuiting conditional expression.
    #
    #  test        ExprNode
    #  true_val    ExprNode
    #  false_val   ExprNode
    
    temp_bool = None
3558 3559
    true_val = None
    false_val = None
Robert Bradshaw's avatar
Robert Bradshaw committed
3560 3561 3562 3563 3564 3565 3566 3567 3568
    
    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)
3569 3570 3571 3572 3573 3574 3575 3576
        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
3577 3578 3579 3580 3581 3582 3583 3584 3585 3586 3587 3588 3589 3590 3591 3592 3593 3594 3595 3596 3597 3598 3599 3600 3601 3602 3603 3604 3605 3606 3607
            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)
        self.true_val.allocate_temps(env, self.result_code)
        self.false_val.allocate_temps(env, self.result_code)
        #  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
3608 3609
        elif type1.is_pyobject or type2.is_pyobject:
            return py_object_type
3610 3611 3612 3613
        elif type1.assignable_from(type2):
            return type1
        elif type2.assignable_from(type1):
            return type2
Robert Bradshaw's avatar
Robert Bradshaw committed
3614
        else:
3615
            return PyrexTypes.error_type
Robert Bradshaw's avatar
Robert Bradshaw committed
3616 3617 3618 3619 3620 3621
        
    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
3622
    
Robert Bradshaw's avatar
Robert Bradshaw committed
3623 3624 3625 3626 3627 3628 3629 3630 3631 3632 3633 3634 3635 3636
    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)
        code.putln("if (%s) {" % self.test.result_code )
        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)

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

William Stein's avatar
William Stein committed
3647 3648 3649 3650
class CmpNode:
    #  Mixin class containing code common to PrimaryCmpNodes
    #  and CascadedCmpNodes.
    
3651 3652
    def cascaded_compile_time_value(self, operand1, denv):
        func = get_compile_time_binop(self)
3653
        operand2 = self.operand2.compile_time_value(denv)
3654 3655 3656 3657
        try:
            result = func(operand1, operand2)
        except Exception, e:
            self.compile_time_value_error(e)
3658
            result = None
3659 3660 3661 3662 3663 3664
        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
3665 3666 3667 3668 3669
    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'))

3670 3671 3672 3673
    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
3674 3675 3676 3677 3678 3679 3680 3681 3682 3683 3684 3685
    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
3686
        elif type1.is_ptr or type1.is_array:
William Stein's avatar
William Stein committed
3687
            return type1.is_null_ptr or type2.is_null_ptr \
3688 3689 3690 3691 3692
                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
3693 3694 3695
                and op not in ('is', 'is_not')):
            return 1
        else:
3696
            return type1.is_cfunction and type1.is_cfunction and type1 == type2
William Stein's avatar
William Stein committed
3697 3698 3699

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

William Stein's avatar
William Stein committed
3742 3743 3744 3745 3746 3747 3748 3749 3750 3751 3752 3753 3754 3755 3756 3757 3758 3759 3760 3761 3762 3763 3764
    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
3765 3766
    child_attrs = ['operand1', 'operand2', 'cascade']
    
William Stein's avatar
William Stein committed
3767 3768
    cascade = None
    
3769
    def compile_time_value(self, denv):
3770
        operand1 = self.operand1.compile_time_value(denv)
3771 3772
        return self.cascaded_compile_time_value(operand1, denv)

William Stein's avatar
William Stein committed
3773 3774 3775 3776 3777 3778 3779 3780
    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)
3781 3782
        if self.has_int_operands():
            self.coerce_chars_to_ints(env)
William Stein's avatar
William Stein committed
3783 3784 3785 3786
        if self.cascade:
            self.operand2 = self.operand2.coerce_to_simple(env)
            self.cascade.coerce_cascaded_operands_to_temp(env)
        self.check_operand_types(env)
3787 3788 3789 3790 3791 3792 3793 3794
        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
3795 3796 3797 3798 3799 3800 3801 3802 3803 3804 3805 3806
        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)
3807
            
William Stein's avatar
William Stein committed
3808 3809 3810 3811 3812 3813
    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)
        
3814 3815 3816 3817 3818
    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):
3819 3820
        # coerce literal single-char strings to c chars
        if self.operand1.type.is_string and isinstance(self.operand1, StringNode):
3821
            self.operand1 = self.operand1.coerce_to(PyrexTypes.c_uchar_type, env)
3822
        if self.operand2.type.is_string and isinstance(self.operand2, StringNode):
3823 3824 3825 3826
            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
3827 3828 3829 3830 3831 3832 3833 3834 3835 3836 3837 3838 3839 3840 3841 3842 3843 3844 3845 3846 3847 3848 3849 3850 3851 3852 3853 3854 3855 3856 3857 3858 3859 3860 3861 3862 3863 3864 3865 3866 3867
    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)" % (
            self.operand1.result_code,
            self.c_operator(self.operator),
            self.operand2.result_code)
    
    def generate_evaluation_code(self, code):
        self.operand1.generate_evaluation_code(code)
        self.operand2.generate_evaluation_code(code)
        if self.is_temp:
            self.generate_operation_code(code, self.result_code, 
                self.operand1, self.operator, self.operand2)
            if self.cascade:
                self.cascade.generate_evaluation_code(code,
                    self.result_code, self.operand2)
            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)
3868 3869 3870 3871 3872 3873
        
    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
3874 3875 3876 3877 3878 3879 3880 3881 3882 3883 3884 3885


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
3886 3887
    child_attrs = ['operand2', 'cascade']

William Stein's avatar
William Stein committed
3888 3889 3890 3891 3892 3893 3894 3895 3896 3897 3898 3899 3900 3901 3902
    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
3903
        
William Stein's avatar
William Stein committed
3904 3905 3906 3907 3908
    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)

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

William Stein's avatar
William Stein committed
3916 3917 3918 3919 3920 3921 3922 3923 3924 3925 3926 3927 3928 3929 3930 3931 3932
    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):
3933 3934 3935 3936
        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
3937 3938 3939 3940 3941 3942 3943 3944 3945 3946
        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("}")

3947 3948 3949 3950 3951
    def annotate(self, code):
        self.operand2.annotate(code)
        if self.cascade:
            self.cascade.annotate(code)

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

binop_node_classes = {
    "or":		BoolBinopNode,
    "and":	BoolBinopNode,
    "|":		IntBinopNode,
    "^":		IntBinopNode,
    "&":		IntBinopNode,
    "<<":		IntBinopNode,
    ">>":		IntBinopNode,
    "+":		AddNode,
    "-":		SubNode,
    "*":		MulNode,
    "/":		NumBinopNode,
Robert Bradshaw's avatar
Robert Bradshaw committed
3965
    "//":		FloorDivNode,
William Stein's avatar
William Stein committed
3966 3967 3968 3969 3970 3971 3972 3973 3974 3975 3976 3977 3978 3979 3980 3981 3982 3983 3984 3985 3986 3987 3988 3989 3990 3991 3992 3993 3994 3995 3996 3997 3998 3999
    "%":		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
4000
            print("%s Coercing %s" % (self, self.arg))
4001 4002 4003 4004 4005 4006
            
    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
4007 4008 4009 4010 4011 4012 4013 4014 4015 4016 4017 4018 4019 4020 4021 4022 4023 4024 4025 4026 4027 4028 4029 4030


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

    gil_message = "Python type test"
William Stein's avatar
William Stein committed
4039
    
4040 4041 4042
    def analyse_types(self, env):
        pass
    
William Stein's avatar
William Stein committed
4043 4044 4045 4046 4047 4048 4049 4050 4051 4052 4053 4054
    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):
        return self.arg.result_code
    
    def generate_result_code(self, code):
        if self.type.typeobj_is_available():
            code.putln(
Robert Bradshaw's avatar
Robert Bradshaw committed
4055 4056
                "if (!(%s)) %s" % (
                    self.type.type_test_code(self.arg.py_result()),
William Stein's avatar
William Stein committed
4057 4058 4059 4060 4061 4062 4063 4064 4065 4066 4067 4068 4069 4070 4071 4072
                    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
4073
        self.gil_check(env)
William Stein's avatar
William Stein committed
4074 4075 4076 4077
        self.is_temp = 1
        if not arg.type.to_py_function:
            error(arg.pos,
                "Cannot convert '%s' to Python object" % arg.type)
4078 4079 4080

    gil_message = "Converting to Python object"

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

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


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")
    
4109 4110 4111 4112
    def analyse_types(self, env):
        # The arg is always already analysed
        pass

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


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)
4131
        self.type = PyrexTypes.c_bint_type
William Stein's avatar
William Stein committed
4132
        if arg.type.is_pyobject:
4133 4134
            if env.nogil:
                self.gil_error()
William Stein's avatar
William Stein committed
4135
            self.is_temp = 1
4136 4137

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

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


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:
4166
            self.gil_check(env)
William Stein's avatar
William Stein committed
4167
            self.result_ctype = py_object_type
4168 4169 4170

    gil_message = "Creating temporary Python reference"

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

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


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)
4196 4197 4198 4199 4200
        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
4201 4202 4203
    
    def calculate_result_code(self):
        return self.arg.result_code
Robert Bradshaw's avatar
Robert Bradshaw committed
4204 4205 4206 4207 4208
        
    def analyse_types(self, env):
        self.type = self.arg.type
        self.result_ctype = self.arg.result_ctype
        self.is_temp = 1
4209 4210
        if hasattr(self.arg, 'entry'):
            self.entry = self.arg.entry
William Stein's avatar
William Stein committed
4211 4212 4213 4214 4215 4216
    
    def generate_evaluation_code(self, code):
        pass

    def generate_result_code(self, code):
        pass
4217 4218
        
    def generate_disposal_code(self, code):
4219 4220
        pass
                
4221 4222 4223 4224 4225
    def allocate_temps(self, env):
        self.result_code = self.calculate_result_code()
        
    def release_temp(self, env):
        pass
4226 4227 4228 4229 4230 4231 4232 4233 4234
        
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
4235
    analyse_counter = 0
4236 4237 4238 4239 4240 4241 4242 4243
    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
4244 4245 4246 4247 4248 4249
        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
4250
    
4251
    def calculate_result_code(self):
Robert Bradshaw's avatar
Robert Bradshaw committed
4252
        return self.result_code
4253

4254 4255 4256 4257 4258 4259 4260 4261 4262 4263 4264 4265 4266 4267 4268 4269 4270 4271
    def generate_evaluation_code(self, code):
        if self.generate_counter == 0:
            self.arg.generate_evaluation_code(code)
            code.putln("%s = %s;" % (
                self.result_code, self.arg.result_as(self.ctype())))
            if self.type.is_pyobject:
                code.put_incref(self.result_code, self.ctype())
            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:
                code.put_decref_clear(self.result_code, self.ctype())

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

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

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

4307
import_utility_code = [
William Stein's avatar
William Stein committed
4308
"""
4309 4310
static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list); /*proto*/
""","""
William Stein's avatar
William Stein committed
4311 4312 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
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,
4346
}]
William Stein's avatar
William Stein committed
4347 4348 4349

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

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

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

4393
unpacking_utility_code = [
William Stein's avatar
William Stein committed
4394
"""
4395
static PyObject *__Pyx_UnpackItem(PyObject *, Py_ssize_t index); /*proto*/
4396 4397
static int __Pyx_EndUnpack(PyObject *); /*proto*/
""","""
4398
static PyObject *__Pyx_UnpackItem(PyObject *iter, Py_ssize_t index) {
4399 4400
    PyObject *item;
    if (!(item = PyIter_Next(iter))) {
4401 4402 4403 4404 4405 4406 4407 4408
        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
        }
4409 4410
    }
    return item;
4411
}
William Stein's avatar
William Stein committed
4412

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

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

4429
type_test_utility_code = [
William Stein's avatar
William Stein committed
4430
"""
4431 4432
static int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type); /*proto*/
""","""
William Stein's avatar
William Stein committed
4433 4434 4435 4436 4437 4438 4439 4440
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",
4441
        Py_TYPE(obj)->tp_name, type->tp_name);
William Stein's avatar
William Stein committed
4442 4443
    return 0;
}
4444
"""]
William Stein's avatar
William Stein committed
4445 4446 4447

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

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

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

#------------------------------------------------------------------------------------
Robert Bradshaw's avatar
Robert Bradshaw committed
4479 4480 4481

cpp_exception_utility_code = [
"""
4482 4483
#ifndef __Pyx_CppExn2PyErr
static void __Pyx_CppExn2PyErr() {
Robert Bradshaw's avatar
Robert Bradshaw committed
4484 4485 4486 4487 4488 4489 4490 4491 4492 4493 4494 4495 4496 4497 4498 4499
  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");
  }
}
4500 4501
#endif
""",""]
Robert Bradshaw's avatar
Robert Bradshaw committed
4502 4503

#------------------------------------------------------------------------------------
Robert Bradshaw's avatar
Robert Bradshaw committed
4504 4505 4506

append_utility_code = [
"""
Stefan Behnel's avatar
Stefan Behnel committed
4507
static INLINE PyObject* __Pyx_PyObject_Append(PyObject* L, PyObject* x) {
Robert Bradshaw's avatar
Robert Bradshaw committed
4508 4509 4510 4511 4512 4513
    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 {
4514
        return PyObject_CallMethod(L, "append", "(O)", x);
Robert Bradshaw's avatar
Robert Bradshaw committed
4515 4516 4517
    }
}
""",""
4518
]
4519 4520 4521

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

Dag Sverre Seljebotn's avatar
Merge  
Dag Sverre Seljebotn committed
4522 4523 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
# 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;
}
""",
"""
"""]
4578 4579 4580 4581 4582 4583 4584 4585 4586 4587
#------------------------------------------------------------------------------------

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);
}
"""]