ExprNodes.py 149 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
William Stein's avatar
William Stein committed
9 10 11
import Naming
from Nodes import Node
import PyrexTypes
12
from PyrexTypes import py_object_type, c_long_type, typecast, error_type
Robert Bradshaw's avatar
Robert Bradshaw committed
13
from Builtin import list_type, tuple_type, dict_type
William Stein's avatar
William Stein committed
14 15
import Symtab
import Options
16
from Annotate import AnnotationItem
William Stein's avatar
William Stein committed
17

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

22

William Stein's avatar
William Stein committed
23 24 25 26 27 28 29 30 31 32 33 34 35
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
36
    type = None
William Stein's avatar
William Stein committed
37 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

    #  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.
    #
97 98 99 100 101 102 103
    #      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
104
    #
105
    #      calculate_result_code
Stefan Behnel's avatar
Stefan Behnel committed
106 107 108
    #        - 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.
109 110 111 112 113
    #
    #      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
114 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
    #
    #      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

171
    def get_child_attrs(self):
172 173
        return self.subexprs
    child_attrs = property(fget=get_child_attrs)
174
        
William Stein's avatar
William Stein committed
175 176 177 178
    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
179
                (self.__class__.__name__, method_name))
William Stein's avatar
William Stein committed
180 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
                
    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
    
220 221 222 223 224 225 226 227
    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
228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250
    # ------------- 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)
    
251
    def analyse_target_expression(self, env, rhs):
William Stein's avatar
William Stein committed
252 253 254 255
        #  Convenience routine performing both the Type
        #  Analysis and Temp Allocation phases for the LHS of
        #  an assignment.
        self.analyse_target_types(env)
256
        self.allocate_target_temps(env, rhs)
William Stein's avatar
William Stein committed
257 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
    
    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)
296 297 298 299 300

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

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

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

    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
402
                print("%s Releasing result %s" % (self, self.result_code))
William Stein's avatar
William Stein committed
403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422
            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):
423
        code.mark_pos(self.pos)
William Stein's avatar
William Stein committed
424 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
        #  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
    
476 477 478 479 480 481
    # ---------------- Annotation ---------------------
    
    def annotate(self, code):
        for node in self.subexpr_nodes():
            node.annotate(code)
    
William Stein's avatar
William Stein committed
482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500
    # ----------------- 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):
501 502
                if not isinstance(src, NoneNode):
                    src = PyTypeTestNode(src, dst_type, env)
William Stein's avatar
William Stein committed
503 504 505
        elif src.type.is_pyobject:
            src = CoerceFromPyTypeNode(dst_type, src, env)
        else: # neither src nor dst are py types
506
            # Added the string comparison, since for c types that
507
            # is enough, but Cython gets confused when the types are
508
            # in different files.
509
            if not (str(src.type) == str(dst_type) or dst_type.assignable_from(src_type)):
William Stein's avatar
William Stein committed
510 511 512 513 514 515 516 517 518 519 520 521 522 523
                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:
524
            if not type.is_int and not type.is_error:
William Stein's avatar
William Stein committed
525 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
                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.
    
568 569
    is_literal = 1
    
William Stein's avatar
William Stein committed
570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587
    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"
    
588 589 590
    def compile_time_value(self, denv):
        return None
    
591 592 593 594
class BoolNode(PyConstNode):
    #  The constant value True or False
    
    def compile_time_value(self, denv):
595
        return self.value
596 597 598 599 600 601 602 603 604 605
    
    def calculate_result_code(self):
        if self.value:
            return "Py_True"
        else:
            return "Py_False"

    def coerce_to(self, dst_type, env):
        value = self.value
        if dst_type.is_numeric:
606
            return IntNode(self.pos, value=int(self.value)).coerce_to(dst_type, env)
607 608
        else:
            return PyConstNode.coerce_to(self, dst_type, env)
William Stein's avatar
William Stein committed
609 610 611 612 613 614

class EllipsisNode(PyConstNode):
    #  '...' in a subscript list.
    
    value = "Py_Ellipsis"

615 616 617
    def compile_time_value(self, denv):
        return Ellipsis

William Stein's avatar
William Stein committed
618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643

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


class NullNode(ConstNode):
    type = PyrexTypes.c_null_ptr_type
644
    value = "NULL"
William Stein's avatar
William Stein committed
645 646 647 648 649


class CharNode(ConstNode):
    type = PyrexTypes.c_char_type
    
650 651 652
    def compile_time_value(self, denv):
        return ord(self.value)
    
William Stein's avatar
William Stein committed
653 654 655 656 657 658 659
    def calculate_result_code(self):
        return "'%s'" % self.value


class IntNode(ConstNode):
    type = PyrexTypes.c_long_type

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

677
    def compile_time_value(self, denv):
678
        return int(self.value, 0)
679 680


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

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

William Stein's avatar
William Stein committed
698 699 700 701 702

class StringNode(ConstNode):
    #  entry   Symtab.Entry
    
    type = PyrexTypes.c_char_ptr_type
703 704

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


743 744 745
class IdentifierStringNode(ConstNode):
    # A Python string that behaves like an identifier, e.g. for
    # keyword arguments in a call, or for imported names
746 747 748 749 750 751 752 753 754
    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
755 756 757 758 759
class LongNode(AtomicExprNode):
    #  Python long integer literal
    #
    #  value   string
    
760 761
    def compile_time_value(self, denv):
        return long(self.value)
762 763

    gil_message = "Constructing Python long int"
764
    
William Stein's avatar
William Stein committed
765 766
    def analyse_types(self, env):
        self.type = py_object_type
767
        self.gil_check(env)
William Stein's avatar
William Stein committed
768
        self.is_temp = 1
769 770 771

    gil_message = "Constructing Python long int"

William Stein's avatar
William Stein committed
772 773
    def generate_evaluation_code(self, code):
        code.putln(
Robert Bradshaw's avatar
Robert Bradshaw committed
774
            '%s = PyLong_FromString("%s", 0, 0); %s' % (
William Stein's avatar
William Stein committed
775 776
                self.result_code,
                self.value,
Robert Bradshaw's avatar
Robert Bradshaw committed
777
                code.error_goto_if_null(self.result_code, self.pos)))
William Stein's avatar
William Stein committed
778 779 780 781 782 783 784


class ImagNode(AtomicExprNode):
    #  Imaginary number literal
    #
    #  value   float    imaginary part
    
785 786 787
    def compile_time_value(self, denv):
        return complex(0.0, self.value)
    
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 complex number"

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 = PyComplex_FromDoubles(0.0, %s); %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


class NameNode(AtomicExprNode):
    #  Reference to a local or global variable name.
    #
    #  name            string    Python name of the variable
807
    #
William Stein's avatar
William Stein committed
808
    #  entry           Entry     Symbol table entry
809
    #  interned_cname  string
William Stein's avatar
William Stein committed
810 811 812
    
    is_name = 1
    
813 814 815 816
    def compile_time_value(self, denv):
        try:
            return denv.lookup(self.name)
        except KeyError:
Stefan Behnel's avatar
Stefan Behnel committed
817
            error(self.pos, "Compile-time name '%s' not defined" % self.name)
818 819 820 821 822 823 824 825
    
    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
826
            if entry and entry.is_cfunction:
827 828
                var_entry = entry.as_variable
                if var_entry:
829 830
                    if var_entry.is_builtin and Options.cache_builtins:
                        var_entry = env.declare_builtin(var_entry.name, self.pos)
831 832 833 834 835 836
                    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
837 838 839 840 841 842 843 844 845 846 847 848 849
    def analyse_as_module(self, env):
        # Try to interpret this as a reference to a cimported module.
        # Returns the module scope, or None.
        entry = env.lookup(self.name)
        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.
        entry = env.lookup(self.name)
        if entry and entry.is_type and entry.type.is_extension_type:
850 851 852
            return entry.type
        else:
            return None
William Stein's avatar
William Stein committed
853 854 855 856 857
    
    def analyse_target_declaration(self, env):
        self.entry = env.lookup_here(self.name)
        if not self.entry:
            self.entry = env.declare_var(self.name, py_object_type, self.pos)
858
        env.control_flow.set_state(self.pos, (self.name, 'initalized'), True)
Robert Bradshaw's avatar
Robert Bradshaw committed
859
        env.control_flow.set_state(self.pos, (self.name, 'source'), 'assignment')
860 861
        if self.entry.is_declared_generic:
            self.result_ctype = py_object_type
862 863
        if self.entry.is_pyglobal and self.entry.is_member:
            env.use_utility_code(type_cache_invalidation_code)
William Stein's avatar
William Stein committed
864 865 866 867 868
    
    def analyse_types(self, env):
        self.entry = env.lookup(self.name)
        if not self.entry:
            self.entry = env.declare_builtin(self.name, self.pos)
869 870 871
        if not self.entry:
            self.type = PyrexTypes.error_type
            return
872 873 874
        self.analyse_rvalue_entry(env)
        
    def analyse_target_types(self, env):
William Stein's avatar
William Stein committed
875
        self.analyse_entry(env)
876 877 878 879
        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
880
        self.entry.used = 1
William Stein's avatar
William Stein committed
881
        
882 883 884 885
    def analyse_rvalue_entry(self, env):
        #print "NameNode.analyse_rvalue_entry:", self.name ###
        #print "Entry:", self.entry.__dict__ ###
        self.analyse_entry(env)
886 887
        entry = self.entry
        if entry.is_declared_generic:
William Stein's avatar
William Stein committed
888
            self.result_ctype = py_object_type
889
        if entry.is_pyglobal or entry.is_builtin:
890 891 892 893
            if Options.cache_builtins and entry.is_builtin:
                self.is_temp = 0
            else:
                self.is_temp = 1
894
            env.use_utility_code(get_name_interned_utility_code)
895 896 897 898
            self.gil_check(env)

    gil_message = "Accessing Python global or builtin"

899 900
    def analyse_entry(self, env):
        #print "NameNode.analyse_entry:", self.name ###
William Stein's avatar
William Stein committed
901
        self.check_identifier_kind()
902 903 904 905 906
        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"
907 908
            self.interned_cname = self.entry.interned_cname = \
                env.intern_identifier(self.entry.name)
909

William Stein's avatar
William Stein committed
910
    def check_identifier_kind(self):
911
        #print "NameNode.check_identifier_kind:", self.entry.name ###
912
        #print self.entry.__dict__ ###
William Stein's avatar
William Stein committed
913
        entry = self.entry
Stefan Behnel's avatar
Stefan Behnel committed
914
        #entry.used = 1
William Stein's avatar
William Stein committed
915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931
        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
932
        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
933 934 935 936
            self.not_const()
    
    def check_const_addr(self):
        entry = self.entry
937
        if not (entry.is_cglobal or entry.is_cfunction or entry.is_builtin):
William Stein's avatar
William Stein committed
938 939 940 941 942 943 944 945 946 947 948
            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
949 950 951
    
    def allocate_temp(self, env, result = None):
        AtomicExprNode.allocate_temp(self, env, result)
Stefan Behnel's avatar
Stefan Behnel committed
952 953 954 955 956
        entry = self.entry
        if entry:
            entry.used = 1
            if entry.utility_code:
                env.use_utility_code(entry.utility_code)
Stefan Behnel's avatar
Stefan Behnel committed
957
        
William Stein's avatar
William Stein committed
958
    def calculate_result_code(self):
Stefan Behnel's avatar
Stefan Behnel committed
959 960
        entry = self.entry
        if not entry:
William Stein's avatar
William Stein committed
961
            return "<error>" # There was an error earlier
Stefan Behnel's avatar
Stefan Behnel committed
962
        return entry.cname
William Stein's avatar
William Stein committed
963 964
    
    def generate_result_code(self, code):
965
        assert hasattr(self, 'entry')
William Stein's avatar
William Stein committed
966 967 968
        entry = self.entry
        if entry is None:
            return # There was an error earlier
969 970 971
        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
972 973 974
            if entry.is_builtin:
                namespace = Naming.builtins_cname
            else: # entry.is_pyglobal
975
                namespace = entry.scope.namespace_cname
976 977 978 979 980
            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
981
                code.error_goto_if_null(self.result_code, self.pos)))
982 983
        elif entry.is_local and False:
            # control flow not good enough yet
Robert Bradshaw's avatar
Robert Bradshaw committed
984
            assigned = entry.scope.control_flow.get_state((entry.name, 'initalized'), self.pos)
985 986
            if assigned is False:
                error(self.pos, "local variable '%s' referenced before assignment" % entry.name)
Robert Bradshaw's avatar
Robert Bradshaw committed
987 988 989
            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
990 991

    def generate_assignment_code(self, rhs, code):
992
        #print "NameNode.generate_assignment_code:", self.name ###
William Stein's avatar
William Stein committed
993 994 995
        entry = self.entry
        if entry is None:
            return # There was an error earlier
996 997 998

        # 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
999
        if entry.is_pyglobal:
1000
            namespace = self.entry.scope.namespace_cname
1001
            if entry.is_member:
Stefan Behnel's avatar
Stefan Behnel committed
1002
                # if the entry is a member we have to cheat: SetAttr does not work
1003
                # on types, so we create a descriptor which is then added to tp_dict
1004 1005 1006 1007 1008
                code.put_error_if_neg(self.pos,
                    'PyDict_SetItem(%s->tp_dict, %s, %s)' % (
                        namespace,
                        self.interned_cname,
                        rhs.py_result()))
1009
                # in Py2.6+, we need to invalidate the method cache
Dag Sverre Seljebotn's avatar
Merge  
Dag Sverre Seljebotn committed
1010
                code.putln("__Pyx_TypeModified(%s);" %
1011
                           entry.scope.parent_type.typeptr_cname)
1012
            else: 
1013 1014 1015 1016 1017
                code.put_error_if_neg(self.pos,
                    'PyObject_SetAttr(%s, %s, %s)' % (
                        namespace,
                        self.interned_cname,
                        rhs.py_result()))
1018
                if debug_disposal_code:
Stefan Behnel's avatar
Stefan Behnel committed
1019 1020
                    print("NameNode.generate_assignment_code:")
                    print("...generating disposal code for %s" % rhs)
1021 1022
                rhs.generate_disposal_code(code)
                
William Stein's avatar
William Stein committed
1023 1024 1025 1026 1027 1028 1029
        else:
            if self.type.is_pyobject:
                #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() ###
                rhs.make_owned_reference(code)
Robert Bradshaw's avatar
Robert Bradshaw committed
1030 1031 1032 1033 1034 1035 1036 1037
                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:
                    code.put_decref(self.result_code, self.ctype())
William Stein's avatar
William Stein committed
1038 1039
            code.putln('%s = %s;' % (self.result_code, rhs.result_as(self.ctype())))
            if debug_disposal_code:
Stefan Behnel's avatar
Stefan Behnel committed
1040 1041
                print("NameNode.generate_assignment_code:")
                print("...generating post-assignment code for %s" % rhs)
William Stein's avatar
William Stein committed
1042 1043 1044 1045 1046 1047 1048 1049
            rhs.generate_post_assignment_code(code)
    
    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
1050 1051
        code.put_error_if_neg(self.pos, 
            'PyObject_DelAttrString(%s, "%s")' % (
William Stein's avatar
William Stein committed
1052
                Naming.module_cname,
Robert Bradshaw's avatar
Robert Bradshaw committed
1053
                self.entry.name))
1054 1055 1056 1057 1058 1059 1060 1061
                
    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
1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073
            
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
1074
        self.gil_check(env)
William Stein's avatar
William Stein committed
1075
        self.is_temp = 1
1076 1077 1078

    gil_message = "Backquote expression"

William Stein's avatar
William Stein committed
1079 1080
    def generate_result_code(self, code):
        code.putln(
Robert Bradshaw's avatar
Robert Bradshaw committed
1081
            "%s = PyObject_Repr(%s); %s" % (
William Stein's avatar
William Stein committed
1082 1083
                self.result_code,
                self.arg.py_result(),
Robert Bradshaw's avatar
Robert Bradshaw committed
1084
                code.error_goto_if_null(self.result_code, self.pos)))
William Stein's avatar
William Stein committed
1085 1086 1087 1088 1089 1090 1091


class ImportNode(ExprNode):
    #  Used as part of import statement implementation.
    #  Implements result = 
    #    __import__(module_name, globals(), None, name_list)
    #
1092 1093
    #  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
1094 1095 1096 1097 1098 1099 1100 1101 1102
    
    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
1103
        self.gil_check(env)
William Stein's avatar
William Stein committed
1104 1105
        self.is_temp = 1
        env.use_utility_code(import_utility_code)
1106 1107 1108

    gil_message = "Python import"

William Stein's avatar
William Stein committed
1109 1110 1111 1112 1113 1114
    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
1115
            "%s = __Pyx_Import(%s, %s); %s" % (
William Stein's avatar
William Stein committed
1116 1117 1118
                self.result_code,
                self.module_name.py_result(),
                name_list_code,
Robert Bradshaw's avatar
Robert Bradshaw committed
1119
                code.error_goto_if_null(self.result_code, self.pos)))
William Stein's avatar
William Stein committed
1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133


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
1134
        self.gil_check(env)
William Stein's avatar
William Stein committed
1135
        self.is_temp = 1
Robert Bradshaw's avatar
Robert Bradshaw committed
1136 1137 1138
        
        self.counter = TempNode(self.pos, PyrexTypes.c_py_ssize_t_type, env)
        self.counter.allocate_temp(env)
1139 1140 1141

    gil_message = "Iterating over Python object"

Robert Bradshaw's avatar
Robert Bradshaw committed
1142 1143 1144
    def release_temp(self, env):
        env.release_temp(self.result_code)
        self.counter.release_temp(env)
William Stein's avatar
William Stein committed
1145 1146 1147
    
    def generate_result_code(self, code):
        code.putln(
Robert Bradshaw's avatar
Robert Bradshaw committed
1148 1149 1150 1151 1152 1153
            "if (PyList_CheckExact(%s)) { %s = 0; %s = %s; Py_INCREF(%s); }" % (
                self.sequence.py_result(),
                self.counter.result_code,
                self.result_code,
                self.sequence.py_result(),
                self.result_code))
Robert Bradshaw's avatar
Robert Bradshaw committed
1154
        code.putln("else { %s = PyObject_GetIter(%s); %s }" % (
William Stein's avatar
William Stein committed
1155 1156
                self.result_code,
                self.sequence.py_result(),
Robert Bradshaw's avatar
Robert Bradshaw committed
1157
                code.error_goto_if_null(self.result_code, self.pos)))
William Stein's avatar
William Stein committed
1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174


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):
Robert Bradshaw's avatar
Robert Bradshaw committed
1175 1176 1177 1178 1179 1180 1181 1182 1183 1184
        code.putln(
            "if (PyList_CheckExact(%s)) { if (%s >= PyList_GET_SIZE(%s)) break; %s = PyList_GET_ITEM(%s, %s++); Py_INCREF(%s); }" % (
                self.iterator.py_result(),
                self.iterator.counter.result_code,
                self.iterator.py_result(),
                self.result_code,
                self.iterator.py_result(),
                self.iterator.counter.result_code,
                self.result_code))
        code.putln("else {")
William Stein's avatar
William Stein committed
1185 1186 1187 1188 1189 1190 1191
        code.putln(
            "%s = PyIter_Next(%s);" % (
                self.result_code,
                self.iterator.py_result()))
        code.putln(
            "if (!%s) {" %
                self.result_code)
1192
        code.putln(code.error_goto_if_PyErr(self.pos))
Robert Bradshaw's avatar
Robert Bradshaw committed
1193 1194 1195
        code.putln("break;")
        code.putln("}")
        code.putln("}")
1196

William Stein's avatar
William Stein committed
1197 1198 1199 1200 1201 1202

class ExcValueNode(AtomicExprNode):
    #  Node created during analyse_types phase
    #  of an ExceptClauseNode to fetch the current
    #  exception value.
    
1203
    def __init__(self, pos, env, var):
William Stein's avatar
William Stein committed
1204 1205
        ExprNode.__init__(self, pos)
        self.type = py_object_type
1206
        self.var = var
William Stein's avatar
William Stein committed
1207
    
1208 1209 1210
    def calculate_result_code(self):
        return self.var

William Stein's avatar
William Stein committed
1211
    def generate_result_code(self, code):
1212
        pass
William Stein's avatar
William Stein committed
1213

1214 1215 1216
    def analyse_types(self, env):
        pass

William Stein's avatar
William Stein committed
1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227

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
1228 1229 1230
        
    def analyse_types(self, env):
        return self.type
William Stein's avatar
William Stein committed
1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254
    
    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
    
Dag Sverre Seljebotn's avatar
Merge  
Dag Sverre Seljebotn committed
1255
    subexprs = ['base', 'index']
William Stein's avatar
William Stein committed
1256
    
1257 1258 1259 1260 1261 1262 1263 1264
    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
1265 1266 1267 1268 1269 1270 1271
    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
1272 1273 1274 1275 1276 1277
        self.analyse_base_and_index_types(env, getting = 1)
    
    def analyse_target_types(self, env):
        self.analyse_base_and_index_types(env, setting = 1)
    
    def analyse_base_and_index_types(self, env, getting = 0, setting = 0):
1278 1279
        self.is_buffer_access = False

William Stein's avatar
William Stein committed
1280
        self.base.analyse_types(env)
1281 1282 1283 1284 1285
        
        if self.base.type.buffer_options is not None:
            if isinstance(self.index, TupleNode):
                indices = self.index.args
#                is_int_indices = 0 == sum([1 for i in self.index.args if not i.type.is_int])
1286
            else:
1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315
#                is_int_indices = self.index.type.is_int
                indices = [self.index]
            all_ints = True
            for index in indices:
                index.analyse_types(env)
                if not index.type.is_int:
                    all_ints = False
            if all_ints:
                self.indices = indices
                self.index = None
                self.type = self.base.type.buffer_options.dtype
                self.is_temp = 1
                self.is_buffer_access = True

        if not self.is_buffer_access:
            self.index.analyse_types(env) # ok to analyse as tuple
            if self.base.type.is_pyobject:
                if self.index.type.is_int:
                    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
1316
            else:
1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330
                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)
1331 1332 1333

    gil_message = "Indexing Python object"

William Stein's avatar
William Stein committed
1334 1335 1336 1337 1338 1339 1340 1341 1342 1343
    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):
        return "(%s[%s])" % (
            self.base.result_code, self.index.result_code)
Dag Sverre Seljebotn's avatar
Merge  
Dag Sverre Seljebotn committed
1344 1345 1346 1347 1348 1349 1350 1351 1352
            
    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 ""
1353 1354 1355

    def generate_subexpr_evaluation_code(self, code):
        self.base.generate_evaluation_code(code)
1356 1357 1358 1359
        if self.index is not None:
            self.index.generate_evaluation_code(code)
        else:
            for i in self.indices: i.generate_evaluation_code(code)
1360 1361 1362
        
    def generate_subexpr_disposal_code(self, code):
        self.base.generate_disposal_code(code)
1363 1364 1365 1366
        if self.index is not None:
            self.index.generate_disposal_code(code)
        else:
            for i in self.indices: i.generate_disposal_code(code)
1367

William Stein's avatar
William Stein committed
1368 1369
    def generate_result_code(self, code):
        if self.type.is_pyobject:
1370
            if self.index.type.is_int:
Dag Sverre Seljebotn's avatar
Merge  
Dag Sverre Seljebotn committed
1371 1372
                function = "__Pyx_GetItemInt"
                index_code = self.index.result_code
1373
            else:
Dag Sverre Seljebotn's avatar
Merge  
Dag Sverre Seljebotn committed
1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385
                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)))
1386

Dag Sverre Seljebotn's avatar
Merge  
Dag Sverre Seljebotn committed
1387 1388 1389 1390 1391 1392 1393
    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()
1394
        code.putln(
Dag Sverre Seljebotn's avatar
Merge  
Dag Sverre Seljebotn committed
1395 1396
            "if (%s(%s, %s, %s%s) < 0) %s" % (
                function,
1397
                self.base.py_result(),
Dag Sverre Seljebotn's avatar
Merge  
Dag Sverre Seljebotn committed
1398 1399 1400 1401 1402
                index_code,
                value_code,
                self.index_unsigned_parameter(),
                code.error_goto(self.pos)))
    
William Stein's avatar
William Stein committed
1403 1404 1405
    def generate_assignment_code(self, rhs, code):
        self.generate_subexpr_evaluation_code(code)
        if self.type.is_pyobject:
Dag Sverre Seljebotn's avatar
Merge  
Dag Sverre Seljebotn committed
1406
            self.generate_setitem_code(rhs.py_result(), code)
William Stein's avatar
William Stein committed
1407 1408 1409 1410
        else:
            code.putln(
                "%s = %s;" % (
                    self.result_code, rhs.result_code))
1411
        self.generate_subexpr_disposal_code(code)
William Stein's avatar
William Stein committed
1412 1413 1414 1415
        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
1416 1417 1418 1419 1420 1421 1422 1423 1424 1425
        #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
1426
                self.base.py_result(),
Dag Sverre Seljebotn's avatar
Merge  
Dag Sverre Seljebotn committed
1427 1428
                index_code,
                code.error_goto(self.pos)))
William Stein's avatar
William Stein committed
1429
        self.generate_subexpr_disposal_code(code)
1430

William Stein's avatar
William Stein committed
1431 1432 1433 1434 1435 1436 1437 1438 1439 1440

class SliceIndexNode(ExprNode):
    #  2-element slice indexing
    #
    #  base      ExprNode
    #  start     ExprNode or None
    #  stop      ExprNode or None
    
    subexprs = ['base', 'start', 'stop']
    
1441 1442 1443 1444 1445 1446 1447 1448 1449
    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
1450 1451 1452 1453 1454 1455 1456 1457 1458 1459
    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)
1460
        c_int = PyrexTypes.c_py_ssize_t_type
William Stein's avatar
William Stein committed
1461 1462 1463 1464 1465
        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
1466
        self.gil_check(env)
William Stein's avatar
William Stein committed
1467
        self.is_temp = 1
1468 1469 1470

    gil_message = "Slicing Python object"

William Stein's avatar
William Stein committed
1471 1472
    def generate_result_code(self, code):
        code.putln(
Robert Bradshaw's avatar
Robert Bradshaw committed
1473
            "%s = PySequence_GetSlice(%s, %s, %s); %s" % (
William Stein's avatar
William Stein committed
1474 1475 1476 1477
                self.result_code,
                self.base.py_result(),
                self.start_code(),
                self.stop_code(),
Robert Bradshaw's avatar
Robert Bradshaw committed
1478
                code.error_goto_if_null(self.result_code, self.pos)))
William Stein's avatar
William Stein committed
1479 1480 1481
    
    def generate_assignment_code(self, rhs, code):
        self.generate_subexpr_evaluation_code(code)
Robert Bradshaw's avatar
Robert Bradshaw committed
1482 1483
        code.put_error_if_neg(self.pos, 
            "PySequence_SetSlice(%s, %s, %s, %s)" % (
William Stein's avatar
William Stein committed
1484 1485 1486
                self.base.py_result(),
                self.start_code(),
                self.stop_code(),
Robert Bradshaw's avatar
Robert Bradshaw committed
1487
                rhs.result_code))
William Stein's avatar
William Stein committed
1488 1489 1490 1491 1492
        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
1493 1494
        code.put_error_if_neg(self.pos,
            "PySequence_DelSlice(%s, %s, %s)" % (
William Stein's avatar
William Stein committed
1495 1496
                self.base.py_result(),
                self.start_code(),
Robert Bradshaw's avatar
Robert Bradshaw committed
1497
                self.stop_code()))
William Stein's avatar
William Stein committed
1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509
        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:
1510
            return "PY_SSIZE_T_MAX"
William Stein's avatar
William Stein committed
1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523
    
    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
    
1524 1525 1526 1527 1528 1529 1530 1531 1532
    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
1533 1534 1535 1536 1537 1538 1539 1540 1541 1542
    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
1543
        self.gil_check(env)
William Stein's avatar
William Stein committed
1544
        self.is_temp = 1
1545 1546 1547

    gil_message = "Constructing Python slice object"

William Stein's avatar
William Stein committed
1548 1549
    def generate_result_code(self, code):
        code.putln(
Robert Bradshaw's avatar
Robert Bradshaw committed
1550
            "%s = PySlice_New(%s, %s, %s); %s" % (
William Stein's avatar
William Stein committed
1551 1552 1553 1554
                self.result_code,
                self.start.py_result(), 
                self.stop.py_result(), 
                self.step.py_result(),
Robert Bradshaw's avatar
Robert Bradshaw committed
1555
                code.error_goto_if_null(self.result_code, self.pos)))
William Stein's avatar
William Stein committed
1556

1557 1558 1559 1560 1561 1562 1563 1564 1565

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
1566 1567 1568 1569 1570 1571 1572
    #  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
1573
    #  wrapper_call   bool                 used internally
William Stein's avatar
William Stein committed
1574 1575 1576 1577 1578 1579
    
    subexprs = ['self', 'coerced_self', 'function', 'args', 'arg_tuple']
    
    self = None
    coerced_self = None
    arg_tuple = None
1580
    wrapper_call = False
William Stein's avatar
William Stein committed
1581
    
1582 1583 1584 1585 1586 1587 1588 1589
    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
1590 1591 1592 1593
    def analyse_types(self, env):
        function = self.function
        function.is_called = 1
        self.function.analyse_types(env)
Robert Bradshaw's avatar
Robert Bradshaw committed
1594 1595 1596 1597 1598 1599 1600 1601 1602
        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
1603 1604 1605 1606 1607 1608 1609
        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:
1610 1611
            self.arg_tuple = TupleNode(self.pos, args = self.args)
            self.arg_tuple.analyse_types(env)
William Stein's avatar
William Stein committed
1612 1613
            self.args = None
            self.type = py_object_type
1614
            self.gil_check(env)
William Stein's avatar
William Stein committed
1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646
            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
1647 1648
        max_nargs = len(func_type.args)
        expected_nargs = max_nargs - func_type.optional_arg_count
William Stein's avatar
William Stein committed
1649 1650
        actual_nargs = len(self.args)
        if actual_nargs < expected_nargs \
1651
            or (not func_type.has_varargs and actual_nargs > max_nargs):
William Stein's avatar
William Stein committed
1652 1653 1654
                expected_str = str(expected_nargs)
                if func_type.has_varargs:
                    expected_str = "at least " + expected_str
1655
                elif func_type.optional_arg_count:
1656
                    if actual_nargs < max_nargs:
1657 1658 1659
                        expected_str = "at least " + expected_str
                    else:
                        expected_str = "at most " + str(max_nargs)
William Stein's avatar
William Stein committed
1660 1661 1662 1663 1664 1665 1666 1667
                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
        # Coerce arguments
1668
        for i in range(min(max_nargs, actual_nargs)):
William Stein's avatar
William Stein committed
1669 1670
            formal_type = func_type.args[i].type
            self.args[i] = self.args[i].coerce_to(formal_type, env)
1671
        for i in range(max_nargs, actual_nargs):
William Stein's avatar
William Stein committed
1672 1673 1674 1675 1676 1677 1678 1679 1680 1681 1682
            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
        if self.type.is_pyobject \
            or func_type.exception_value is not None \
            or func_type.exception_check:
                self.is_temp = 1
                if self.type.is_pyobject:
                    self.result_ctype = py_object_type
Robert Bradshaw's avatar
Robert Bradshaw committed
1683 1684 1685 1686
        # C++ exception handler
        if func_type.exception_check == '+':
            if func_type.exception_value is None:
                env.use_utility_code(cpp_exception_utility_code)
1687 1688 1689
        # Check gil
        if not func_type.nogil:
            self.gil_check(env)
Robert Bradshaw's avatar
Robert Bradshaw committed
1690

William Stein's avatar
William Stein committed
1691 1692 1693 1694 1695 1696 1697 1698 1699
    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 = []
1700 1701 1702 1703 1704
        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
1705 1706
                arg_code = actual_arg.result_as(formal_arg.type)
                arg_list_code.append(arg_code)
1707
                
1708
        if func_type.optional_arg_count:
1709
            if expected_nargs == actual_nargs:
1710
                optional_args = 'NULL'
1711 1712 1713 1714 1715 1716 1717 1718
            else:
                optional_arg_code = [str(actual_nargs - expected_nargs)]
                for formal_arg, actual_arg in args[expected_nargs:actual_nargs]:
                    arg_code = actual_arg.result_as(formal_arg.type)
                    optional_arg_code.append(arg_code)
#                for formal_arg in formal_args[actual_nargs:max_nargs]:
#                    optional_arg_code.append(formal_arg.type.cast_code('0'))
                optional_arg_struct = '{%s}' % ','.join(optional_arg_code)
1719 1720
                optional_args = PyrexTypes.c_void_ptr_type.cast_code(
                    '&' + func_type.op_arg_struct.base_type.cast_code(optional_arg_struct))
1721
            arg_list_code.append(optional_args)
1722
            
William Stein's avatar
William Stein committed
1723 1724 1725
        for actual_arg in self.args[len(formal_args):]:
            arg_list_code.append(actual_arg.result_code)
        result = "%s(%s)" % (self.function.result_code,
1726
            join(arg_list_code, ", "))
1727
        if self.wrapper_call or \
1728
                self.function.entry.is_unbound_cmethod and self.function.entry.type.is_overridable:
1729
            result = "(%s = 1, %s)" % (Naming.skip_dispatch_cname, result)
William Stein's avatar
William Stein committed
1730 1731 1732 1733 1734
        return result
    
    def generate_result_code(self, code):
        func_type = self.function_type()
        if func_type.is_pyobject:
1735
            arg_code = self.arg_tuple.py_result()
William Stein's avatar
William Stein committed
1736
            code.putln(
1737
                "%s = PyObject_Call(%s, %s, NULL); %s" % (
William Stein's avatar
William Stein committed
1738 1739
                    self.result_code,
                    self.function.py_result(),
1740
                    arg_code,
Robert Bradshaw's avatar
Robert Bradshaw committed
1741
                    code.error_goto_if_null(self.result_code, self.pos)))
William Stein's avatar
William Stein committed
1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763
        elif func_type.is_cfunction:
            exc_checks = []
            if self.type.is_pyobject:
                exc_checks.append("!%s" % self.result_code)
            else:
                exc_val = func_type.exception_value
                exc_check = func_type.exception_check
                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
1764
                if func_type.exception_check == '+':
Robert Bradshaw's avatar
Robert Bradshaw committed
1765 1766 1767 1768 1769 1770
                    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
1771
                    code.putln(
Robert Bradshaw's avatar
Robert Bradshaw committed
1772
                    "try {%s%s;} catch(...) {%s; %s}" % (
Felix Wu's avatar
Felix Wu committed
1773 1774
                        lhs,
                        rhs,
Robert Bradshaw's avatar
Robert Bradshaw committed
1775
                        raise_py_exception,
Felix Wu's avatar
Felix Wu committed
1776 1777
                        code.error_goto(self.pos)))
                    return
William Stein's avatar
William Stein committed
1778
                code.putln(
Robert Bradshaw's avatar
Robert Bradshaw committed
1779
                    "%s%s; %s" % (
William Stein's avatar
William Stein committed
1780 1781
                        lhs,
                        rhs,
Robert Bradshaw's avatar
Robert Bradshaw committed
1782
                        code.error_goto_if(" && ".join(exc_checks), self.pos)))    
William Stein's avatar
William Stein committed
1783

1784
class GeneralCallNode(CallNode):
William Stein's avatar
William Stein committed
1785 1786 1787 1788 1789 1790 1791 1792 1793 1794
    #  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']

1795 1796 1797 1798 1799 1800 1801 1802 1803 1804 1805
    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
1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819
    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
1820
        self.gil_check(env)
William Stein's avatar
William Stein committed
1821 1822 1823 1824
        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
1825 1826
            code.put_error_if_neg(self.pos, 
                "PyDict_Update(%s, %s)" % (
William Stein's avatar
William Stein committed
1827
                    self.keyword_args.py_result(), 
Robert Bradshaw's avatar
Robert Bradshaw committed
1828
                    self.starstar_arg.py_result()))
William Stein's avatar
William Stein committed
1829 1830 1831 1832 1833 1834 1835 1836
            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:
1837
            call_code = "PyObject_Call(%s, %s, NULL)" % (
William Stein's avatar
William Stein committed
1838 1839 1840 1841 1842 1843 1844 1845
                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
1846
            "%s = %s; %s" % (
William Stein's avatar
William Stein committed
1847 1848
                self.result_code,
                call_code,
Robert Bradshaw's avatar
Robert Bradshaw committed
1849
                code.error_goto_if_null(self.result_code, self.pos)))
William Stein's avatar
William Stein committed
1850 1851 1852 1853 1854 1855 1856 1857 1858 1859


class AsTupleNode(ExprNode):
    #  Convert argument to tuple. Used for normalising
    #  the * argument of a function call.
    #
    #  arg    ExprNode
    
    subexprs = ['arg']
    
1860 1861 1862 1863 1864 1865 1866
    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
1867 1868 1869 1870
    def analyse_types(self, env):
        self.arg.analyse_types(env)
        self.arg = self.arg.coerce_to_pyobject(env)
        self.type = py_object_type
1871
        self.gil_check(env)
William Stein's avatar
William Stein committed
1872
        self.is_temp = 1
1873 1874 1875

    gil_message = "Constructing Python tuple"

William Stein's avatar
William Stein committed
1876 1877
    def generate_result_code(self, code):
        code.putln(
Robert Bradshaw's avatar
Robert Bradshaw committed
1878
            "%s = PySequence_Tuple(%s); %s" % (
William Stein's avatar
William Stein committed
1879 1880
                self.result_code,
                self.arg.py_result(),
Robert Bradshaw's avatar
Robert Bradshaw committed
1881
                code.error_goto_if_null(self.result_code, self.pos)))
William Stein's avatar
William Stein committed
1882 1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895
    

class AttributeNode(ExprNode):
    #  obj.attribute
    #
    #  obj          ExprNode
    #  attribute    string
    #
    #  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
1896
    #  interned_attr_cname  string    C name of interned attribute name
William Stein's avatar
William Stein committed
1897 1898 1899 1900 1901 1902 1903 1904 1905
    
    is_attribute = 1
    subexprs = ['obj']
    
    type = PyrexTypes.error_type
    result = "<error>"
    entry = None
    is_called = 0

1906 1907 1908 1909 1910 1911 1912 1913 1914 1915 1916
    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
1917
        return ExprNode.coerce_to(self, dst_type, env)
1918
    
1919 1920 1921 1922 1923 1924 1925 1926 1927 1928 1929 1930
    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
1931 1932 1933 1934 1935 1936 1937 1938 1939 1940 1941 1942 1943 1944 1945 1946 1947 1948 1949 1950 1951 1952 1953 1954 1955 1956 1957 1958 1959 1960 1961 1962 1963 1964 1965 1966 1967 1968 1969 1970 1971 1972 1973 1974
    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
1975
                ubcm_entry.is_unbound_cmethod = 1
William Stein's avatar
William Stein committed
1976 1977 1978 1979 1980 1981 1982 1983 1984 1985 1986 1987 1988 1989 1990 1991 1992 1993 1994 1995 1996 1997 1998 1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010
                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:
2011
            NameNode.analyse_rvalue_entry(self, env)
William Stein's avatar
William Stein committed
2012 2013 2014 2015 2016
    
    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:
2017 2018
#            error(self.pos, "C method can only be called")
            pass
2019 2020 2021
        ## 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
2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033
        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
2034
        if obj_type.is_ptr or obj_type.is_array:
William Stein's avatar
William Stein committed
2035 2036 2037 2038 2039 2040 2041 2042 2043 2044
            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
2045 2046
                if entry and entry.is_member:
                    entry = None
William Stein's avatar
William Stein committed
2047 2048 2049 2050
            else:
                error(self.pos, 
                    "Cannot select attribute of incomplete type '%s'" 
                    % obj_type)
Robert Bradshaw's avatar
Robert Bradshaw committed
2051 2052
                self.type = PyrexTypes.error_type
                return
William Stein's avatar
William Stein committed
2053 2054
            self.entry = entry
            if entry:
2055 2056
                if obj_type.is_extension_type and entry.name == "__weakref__":
                    error(self.pos, "Illegal use of special attribute __weakref__")
2057 2058
                # methods need the normal attribute lookup
                # because they do not have struct entries
2059 2060 2061 2062
                if entry.is_variable or entry.is_cmethod:
                    self.type = entry.type
                    self.member = entry.cname
                    return
William Stein's avatar
William Stein committed
2063 2064 2065 2066 2067 2068 2069 2070 2071
                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.
2072 2073 2074 2075 2076
        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
2077 2078 2079
        if obj_type.is_pyobject:
            self.type = py_object_type
            self.is_py_attr = 1
2080
            self.interned_attr_cname = env.intern_identifier(self.attribute)
2081
            self.gil_check(env)
William Stein's avatar
William Stein committed
2082 2083 2084 2085 2086
        else:
            if not obj_type.is_error:
                error(self.pos, 
                    "Object of type '%s' has no attribute '%s'" %
                    (obj_type, self.attribute))
2087 2088 2089

    gil_message = "Accessing Python attribute"

William Stein's avatar
William Stein committed
2090 2091 2092 2093 2094 2095 2096 2097 2098 2099 2100 2101 2102 2103 2104 2105 2106 2107 2108 2109 2110 2111 2112 2113 2114 2115
    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
2116 2117 2118 2119 2120 2121
            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
2122 2123 2124 2125 2126
        else:
            return "%s%s%s" % (obj_code, self.op, self.member)
    
    def generate_result_code(self, code):
        if self.is_py_attr:
2127 2128 2129 2130 2131 2132
            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)))
William Stein's avatar
William Stein committed
2133 2134 2135 2136
    
    def generate_assignment_code(self, rhs, code):
        self.obj.generate_evaluation_code(code)
        if self.is_py_attr:
2137 2138 2139 2140 2141
            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
2142 2143 2144 2145 2146 2147 2148 2149 2150
            rhs.generate_disposal_code(code)
        else:
            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,
2151 2152
                    rhs.result_as(self.ctype())))
                    #rhs.result_code))
William Stein's avatar
William Stein committed
2153 2154 2155 2156 2157 2158
            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:
2159 2160 2161 2162
            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
2163 2164 2165
        else:
            error(self.pos, "Cannot delete C attribute of extension type")
        self.obj.generate_disposal_code(code)
2166 2167 2168 2169 2170 2171
        
    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
2172 2173 2174 2175 2176 2177 2178 2179 2180 2181 2182 2183

#-------------------------------------------------------------------
#
#  Constructor nodes
#
#-------------------------------------------------------------------

class SequenceNode(ExprNode):
    #  Base class for list and tuple constructor nodes.
    #  Contains common code for performing sequence unpacking.
    #
    #  args                    [ExprNode]
2184
    #  iterator                ExprNode
William Stein's avatar
William Stein committed
2185 2186 2187 2188 2189 2190 2191 2192
    #  unpacked_items          [ExprNode] or None
    #  coerced_unpacked_items  [ExprNode] or None
    
    subexprs = ['args']
    
    is_sequence_constructor = 1
    unpacked_items = None
    
2193 2194 2195
    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
2196 2197 2198 2199 2200 2201 2202 2203 2204 2205
    def analyse_target_declaration(self, env):
        for arg in self.args:
            arg.analyse_target_declaration(env)

    def analyse_types(self, env):
        for i in range(len(self.args)):
            arg = self.args[i]
            arg.analyse_types(env)
            self.args[i] = arg.coerce_to_pyobject(env)
        self.type = py_object_type
2206
        self.gil_check(env)
William Stein's avatar
William Stein committed
2207
        self.is_temp = 1
2208

William Stein's avatar
William Stein committed
2209
    def analyse_target_types(self, env):
2210 2211
        self.iterator = PyTempNode(self.pos, env)
        self.unpacked_items = []
William Stein's avatar
William Stein committed
2212 2213 2214 2215 2216 2217 2218 2219 2220 2221
        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)
    
2222 2223 2224
    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
2225
            node.allocate_temps(env)
2226 2227 2228
            arg.allocate_target_temps(env, node)
            #arg.release_target_temp(env)
            #node.release_temp(env)
2229 2230
        if rhs:
            rhs.release_temp(env)
2231 2232 2233 2234 2235 2236 2237 2238
        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
2239 2240 2241 2242 2243
    
    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
2244 2245 2246 2247 2248
        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
2249
        code.putln("PyObject* tuple = %s;" % rhs.py_result())
Robert Bradshaw's avatar
Robert Bradshaw committed
2250 2251 2252
        for i in range(len(self.args)):
            item = self.unpacked_items[i]
            code.putln(
Stefan Behnel's avatar
Stefan Behnel committed
2253
                "%s = PyTuple_GET_ITEM(tuple, %s);" % (
Robert Bradshaw's avatar
Robert Bradshaw committed
2254 2255 2256 2257 2258 2259 2260
                    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)
            
2261
        rhs.generate_disposal_code(code)
Robert Bradshaw's avatar
Robert Bradshaw committed
2262 2263 2264
        code.putln("}")
        code.putln("else {")

2265
        code.putln(
Robert Bradshaw's avatar
Robert Bradshaw committed
2266
            "%s = PyObject_GetIter(%s); %s" % (
2267 2268
                self.iterator.result_code,
                rhs.py_result(),
Robert Bradshaw's avatar
Robert Bradshaw committed
2269
                code.error_goto_if_null(self.iterator.result_code, self.pos)))
2270
        rhs.generate_disposal_code(code)
William Stein's avatar
William Stein committed
2271 2272
        for i in range(len(self.args)):
            item = self.unpacked_items[i]
2273 2274
            unpack_code = "__Pyx_UnpackItem(%s, %d)" % (
                self.iterator.py_result(), i)
William Stein's avatar
William Stein committed
2275
            code.putln(
Robert Bradshaw's avatar
Robert Bradshaw committed
2276
                "%s = %s; %s" % (
William Stein's avatar
William Stein committed
2277 2278
                    item.result_code,
                    typecast(item.ctype(), py_object_type, unpack_code),
Robert Bradshaw's avatar
Robert Bradshaw committed
2279
                    code.error_goto_if_null(item.result_code, self.pos)))
William Stein's avatar
William Stein committed
2280 2281 2282
            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
2283 2284 2285
        code.put_error_if_neg(self.pos, 
            "__Pyx_EndUnpack(%s)" % (
                self.iterator.py_result()))
William Stein's avatar
William Stein committed
2286
        if debug_disposal_code:
Stefan Behnel's avatar
Stefan Behnel committed
2287
            print("UnpackNode.generate_assignment_code:")
2288
            print("...generating disposal code for %s" % self.iterator)
2289
        self.iterator.generate_disposal_code(code)
William Stein's avatar
William Stein committed
2290

2291
        code.putln("}")
2292 2293 2294 2295 2296 2297 2298 2299 2300
        
    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
2301 2302 2303 2304


class TupleNode(SequenceNode):
    #  Tuple constructor.
2305 2306 2307

    gil_message = "Constructing Python tuple"

Robert Bradshaw's avatar
Robert Bradshaw committed
2308 2309 2310
    def analyse_types(self, env):
        if len(self.args) == 0:
            self.is_temp = 0
2311
            self.is_literal = 1
Robert Bradshaw's avatar
Robert Bradshaw committed
2312 2313
        else:
            SequenceNode.analyse_types(self, env)
Robert Bradshaw's avatar
Robert Bradshaw committed
2314
        self.type = tuple_type
Robert Bradshaw's avatar
Robert Bradshaw committed
2315 2316 2317
            
    def calculate_result_code(self):
        if len(self.args) > 0:
2318
            error(self.pos, "Positive length tuples must be constructed.")
Robert Bradshaw's avatar
Robert Bradshaw committed
2319 2320
        else:
            return Naming.empty_tuple
William Stein's avatar
William Stein committed
2321

2322 2323 2324 2325 2326 2327 2328
    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
2329
    def generate_operation_code(self, code):
Robert Bradshaw's avatar
Robert Bradshaw committed
2330 2331 2332
        if len(self.args) == 0:
            # result_code is Naming.empty_tuple
            return
William Stein's avatar
William Stein committed
2333
        code.putln(
Robert Bradshaw's avatar
Robert Bradshaw committed
2334
            "%s = PyTuple_New(%s); %s" % (
William Stein's avatar
William Stein committed
2335 2336
                self.result_code,
                len(self.args),
Robert Bradshaw's avatar
Robert Bradshaw committed
2337
                code.error_goto_if_null(self.result_code, self.pos)))
William Stein's avatar
William Stein committed
2338 2339 2340 2341 2342 2343 2344 2345 2346 2347 2348 2349 2350 2351 2352
        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
2353
            arg.generate_post_assignment_code(code)	
William Stein's avatar
William Stein committed
2354 2355 2356 2357


class ListNode(SequenceNode):
    #  List constructor.
2358 2359 2360

    gil_message = "Constructing Python list"

Robert Bradshaw's avatar
Robert Bradshaw committed
2361 2362 2363 2364
    def analyse_types(self, env):
        SequenceNode.analyse_types(self, env)
        self.type = list_type

2365 2366 2367
    def compile_time_value(self, denv):
        return self.compile_time_value_list(denv)

William Stein's avatar
William Stein committed
2368
    def generate_operation_code(self, code):
Robert Bradshaw's avatar
Robert Bradshaw committed
2369
        code.putln("%s = PyList_New(%s); %s" %
William Stein's avatar
William Stein committed
2370 2371
            (self.result_code,
            len(self.args),
Robert Bradshaw's avatar
Robert Bradshaw committed
2372
            code.error_goto_if_null(self.result_code, self.pos)))
William Stein's avatar
William Stein committed
2373 2374 2375 2376 2377 2378 2379 2380 2381 2382 2383 2384 2385 2386 2387 2388 2389
        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
2390 2391 2392 2393
            
class ListComprehensionNode(SequenceNode):

    subexprs = []
2394
    is_sequence_constructor = 0 # not unpackable
Robert Bradshaw's avatar
Robert Bradshaw committed
2395 2396

    def analyse_types(self, env): 
Robert Bradshaw's avatar
Robert Bradshaw committed
2397
        self.type = list_type
Robert Bradshaw's avatar
Robert Bradshaw committed
2398 2399 2400 2401 2402
        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
2403
            print("%s Allocating temps" % self)
Robert Bradshaw's avatar
Robert Bradshaw committed
2404 2405 2406 2407 2408
        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
2409
        code.putln("%s = PyList_New(%s); %s" %
Robert Bradshaw's avatar
Robert Bradshaw committed
2410 2411
            (self.result_code,
            0,
Robert Bradshaw's avatar
Robert Bradshaw committed
2412
            code.error_goto_if_null(self.result_code, self.pos)))
Robert Bradshaw's avatar
Robert Bradshaw committed
2413
        self.loop.generate_execution_code(code)
2414 2415 2416
        
    def annotate(self, code):
        self.loop.annotate(code)
Robert Bradshaw's avatar
Robert Bradshaw committed
2417 2418 2419 2420 2421 2422 2423 2424 2425 2426 2427 2428 2429 2430


class ListComprehensionAppendNode(ExprNode):

    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):
Robert Bradshaw's avatar
Robert Bradshaw committed
2431
        code.putln("%s = PyList_Append(%s, %s); %s" %
Robert Bradshaw's avatar
Robert Bradshaw committed
2432 2433 2434
            (self.result_code,
            self.target.result_code,
            self.expr.result_code,
Robert Bradshaw's avatar
Robert Bradshaw committed
2435
            code.error_goto_if(self.result_code, self.pos)))
Robert Bradshaw's avatar
Robert Bradshaw committed
2436

William Stein's avatar
William Stein committed
2437 2438 2439 2440

class DictNode(ExprNode):
    #  Dictionary constructor.
    #
2441 2442 2443
    #  key_value_pairs  [DictItemNode]
    
    subexprs = ['key_value_pairs']
William Stein's avatar
William Stein committed
2444
    
2445
    def compile_time_value(self, denv):
Robert Bradshaw's avatar
Robert Bradshaw committed
2446 2447
        pairs = [(item.key.compile_time_value(denv), item.value.compile_time_value(denv))
            for item in self.key_value_pairs]
2448 2449 2450 2451 2452
        try:
            return dict(pairs)
        except Exception, e:
            self.compile_time_value_error(e)
    
William Stein's avatar
William Stein committed
2453
    def analyse_types(self, env):
Robert Bradshaw's avatar
Robert Bradshaw committed
2454 2455
        for item in self.key_value_pairs:
            item.analyse_types(env)
Robert Bradshaw's avatar
Robert Bradshaw committed
2456
        self.type = dict_type
2457
        self.gil_check(env)
William Stein's avatar
William Stein committed
2458
        self.is_temp = 1
2459 2460 2461

    gil_message = "Constructing Python dict"

William Stein's avatar
William Stein committed
2462 2463 2464 2465
    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
2466 2467 2468 2469 2470
        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
2471 2472 2473 2474 2475
    
    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
2476
            "%s = PyDict_New(); %s" % (
William Stein's avatar
William Stein committed
2477
                self.result_code,
Robert Bradshaw's avatar
Robert Bradshaw committed
2478
                code.error_goto_if_null(self.result_code, self.pos)))
Robert Bradshaw's avatar
Robert Bradshaw committed
2479 2480
        for item in self.key_value_pairs:
            item.generate_evaluation_code(code)
Robert Bradshaw's avatar
Robert Bradshaw committed
2481 2482
            code.put_error_if_neg(self.pos, 
                "PyDict_SetItem(%s, %s, %s)" % (
William Stein's avatar
William Stein committed
2483
                    self.result_code,
Robert Bradshaw's avatar
Robert Bradshaw committed
2484 2485 2486
                    item.key.py_result(),
                    item.value.py_result()))
            item.generate_disposal_code(code)
2487 2488
            
    def annotate(self, code):
Robert Bradshaw's avatar
Robert Bradshaw committed
2489 2490 2491 2492 2493 2494 2495 2496 2497 2498 2499 2500 2501 2502 2503 2504 2505 2506 2507 2508 2509 2510 2511
        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
2512

Stefan Behnel's avatar
Stefan Behnel committed
2513

William Stein's avatar
William Stein committed
2514 2515 2516 2517 2518
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
2519 2520
    #  name         EncodedString      Name of the class
    #  cname        string             Class name as a Python string
William Stein's avatar
William Stein committed
2521 2522 2523 2524 2525
    #  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
    
2526 2527
    subexprs = ['bases', 'doc']

William Stein's avatar
William Stein committed
2528
    def analyse_types(self, env):
2529
        self.cname = env.intern_identifier(self.name)
William Stein's avatar
William Stein committed
2530 2531 2532 2533 2534 2535
        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
2536
        self.gil_check(env)
William Stein's avatar
William Stein committed
2537 2538
        self.is_temp = 1
        env.use_utility_code(create_class_utility_code);
2539

2540 2541
    gil_message = "Constructing Python class"

William Stein's avatar
William Stein committed
2542 2543
    def generate_result_code(self, code):
        if self.doc:
Robert Bradshaw's avatar
Robert Bradshaw committed
2544 2545
            code.put_error_if_neg(self.pos, 
                'PyDict_SetItemString(%s, "__doc__", %s)' % (
William Stein's avatar
William Stein committed
2546
                    self.dict.py_result(),
Robert Bradshaw's avatar
Robert Bradshaw committed
2547
                    self.doc.py_result()))
William Stein's avatar
William Stein committed
2548
        code.putln(
Robert Bradshaw's avatar
Robert Bradshaw committed
2549
            '%s = __Pyx_CreateClass(%s, %s, %s, "%s"); %s' % (
William Stein's avatar
William Stein committed
2550 2551 2552
                self.result_code,
                self.bases.py_result(),
                self.dict.py_result(),
2553
                self.cname,
William Stein's avatar
William Stein committed
2554
                self.module_name,
Robert Bradshaw's avatar
Robert Bradshaw committed
2555
                code.error_goto_if_null(self.result_code, self.pos)))
William Stein's avatar
William Stein committed
2556 2557 2558 2559 2560 2561 2562 2563 2564 2565 2566 2567 2568 2569 2570


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
2571
        self.gil_check(env)
William Stein's avatar
William Stein committed
2572
        self.is_temp = 1
2573 2574 2575

    gil_message = "Constructing an unbound method"

William Stein's avatar
William Stein committed
2576 2577
    def generate_result_code(self, code):
        code.putln(
Robert Bradshaw's avatar
Robert Bradshaw committed
2578
            "%s = PyMethod_New(%s, 0, %s); %s" % (
William Stein's avatar
William Stein committed
2579 2580 2581
                self.result_code,
                self.function.py_result(),
                self.class_cname,
Robert Bradshaw's avatar
Robert Bradshaw committed
2582
                code.error_goto_if_null(self.result_code, self.pos)))
William Stein's avatar
William Stein committed
2583 2584 2585 2586 2587 2588 2589 2590 2591 2592 2593


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
2594
        self.gil_check(env)
William Stein's avatar
William Stein committed
2595
        self.is_temp = 1
2596 2597 2598

    gil_message = "Constructing Python function"

William Stein's avatar
William Stein committed
2599 2600
    def generate_result_code(self, code):
        code.putln(
Robert Bradshaw's avatar
Robert Bradshaw committed
2601
            "%s = PyCFunction_New(&%s, 0); %s" % (
William Stein's avatar
William Stein committed
2602 2603
                self.result_code,
                self.pymethdef_cname,
Robert Bradshaw's avatar
Robert Bradshaw committed
2604
                code.error_goto_if_null(self.result_code, self.pos)))
William Stein's avatar
William Stein committed
2605 2606 2607 2608 2609 2610 2611

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

2612 2613 2614 2615 2616 2617 2618
compile_time_unary_operators = {
    'not': operator.not_,
    '~': operator.inv,
    '-': operator.neg,
    '+': operator.pos,
}

William Stein's avatar
William Stein committed
2619 2620 2621 2622 2623 2624 2625 2626 2627 2628 2629 2630 2631 2632
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']
    
2633 2634 2635 2636 2637 2638 2639 2640 2641 2642 2643 2644
    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
2645 2646 2647 2648 2649
    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
2650
            self.gil_check(env)
William Stein's avatar
William Stein committed
2651 2652 2653 2654 2655 2656 2657 2658 2659 2660 2661 2662 2663 2664 2665 2666 2667 2668 2669 2670 2671 2672 2673
            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
2674
            "%s = %s(%s); %s" % (
William Stein's avatar
William Stein committed
2675 2676 2677
                self.result_code, 
                function, 
                self.operand.py_result(),
Robert Bradshaw's avatar
Robert Bradshaw committed
2678
                code.error_goto_if_null(self.result_code, self.pos)))
William Stein's avatar
William Stein committed
2679 2680 2681 2682 2683 2684 2685 2686 2687 2688 2689 2690 2691
        
    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
    
2692 2693 2694 2695 2696 2697 2698
    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
2699 2700 2701 2702 2703
    subexprs = ['operand']
    
    def analyse_types(self, env):
        self.operand.analyse_types(env)
        self.operand = self.operand.coerce_to_boolean(env)
2704
        self.type = PyrexTypes.c_bint_type
William Stein's avatar
William Stein committed
2705 2706 2707 2708 2709 2710 2711 2712 2713 2714 2715 2716 2717 2718 2719 2720 2721 2722 2723 2724 2725 2726 2727 2728 2729 2730 2731 2732 2733 2734 2735 2736 2737 2738 2739 2740 2741 2742 2743 2744 2745 2746 2747 2748 2749 2750 2751 2752 2753 2754 2755 2756 2757 2758 2759 2760 2761 2762 2763 2764 2765 2766 2767 2768 2769 2770 2771 2772 2773 2774 2775 2776 2777 2778 2779 2780 2781 2782 2783 2784 2785 2786 2787 2788 2789 2790 2791 2792 2793 2794 2795 2796 2797 2798 2799 2800 2801 2802 2803
    
    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.
2804
    if isinstance(operand, IntNode) and operator == '-':
2805
        return IntNode(pos = operand.pos, value = str(-int(operand.value, 0)))
Robert Bradshaw's avatar
Robert Bradshaw committed
2806 2807
    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
2808 2809 2810 2811 2812 2813 2814 2815 2816 2817 2818 2819 2820 2821 2822 2823 2824
    return unop_node_classes[operator](pos, 
        operator = operator, 
        operand = operand)


class TypecastNode(ExprNode):
    #  C type cast
    #
    #  base_type    CBaseTypeNode
    #  declarator   CDeclaratorNode
    #  operand      ExprNode
    
    subexprs = ['operand']
    
    def analyse_types(self, env):
        base_type = self.base_type.analyse(env)
        _, self.type = self.declarator.analyse(base_type, env)
2825 2826 2827 2828
        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
2829 2830 2831
        self.operand.analyse_types(env)
        to_py = self.type.is_pyobject
        from_py = self.operand.type.is_pyobject
2832 2833
        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
2834
        if to_py and not from_py:
2835
            if self.operand.type.to_py_function:
Dag Sverre Seljebotn's avatar
Merge  
Dag Sverre Seljebotn committed
2836
                self.result_ctype = py_object_type
2837
                self.operand = self.operand.coerce_to_pyobject(env)
2838 2839
            else:
                warning(self.pos, "No conversion from %s to %s, python object pointer used." % (self.operand.type, self.type))
2840 2841 2842
        elif from_py and not to_py:
            if self.type.from_py_function:
                self.operand = self.operand.coerce_to(self.type, env)
2843 2844
            else:
                warning(self.pos, "No conversion from %s to %s, python object pointer used." % (self.type, self.operand.type))
2845 2846 2847
        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
2848 2849 2850 2851 2852 2853 2854 2855 2856 2857 2858 2859 2860 2861 2862 2863 2864 2865 2866 2867 2868 2869 2870 2871 2872 2873 2874 2875 2876 2877 2878 2879 2880 2881 2882 2883 2884 2885 2886 2887 2888 2889 2890 2891 2892 2893 2894
    
    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):
        base_type = self.base_type.analyse(env)
        _, arg_type = self.declarator.analyse(base_type, env)
        self.arg_type = arg_type
2895
        if arg_type.is_pyobject and not arg_type.is_extension_type:
William Stein's avatar
William Stein committed
2896 2897 2898 2899 2900 2901 2902 2903
            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):
2904 2905 2906 2907 2908 2909
        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
2910 2911 2912 2913 2914 2915 2916 2917 2918 2919 2920 2921 2922 2923 2924 2925 2926 2927 2928 2929 2930 2931 2932 2933 2934 2935 2936
        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
2937 2938 2939
def _not_in(x, seq):
    return x not in seq

2940 2941 2942
compile_time_binary_operators = {
    '<': operator.lt,
    '<=': operator.le,
2943
    '==': operator.eq,
2944 2945 2946 2947 2948 2949 2950 2951 2952 2953 2954 2955 2956 2957 2958 2959 2960 2961
    '!=': 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
2962 2963
    'in': operator.contains,
    'not_in': _not_in,
2964 2965 2966 2967 2968 2969 2970
}

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"
2971
                % node.operator)
2972 2973
    return func

William Stein's avatar
William Stein committed
2974 2975 2976 2977 2978 2979 2980 2981 2982 2983 2984 2985 2986 2987 2988
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']
    
2989 2990 2991 2992 2993 2994 2995 2996 2997
    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
2998 2999 3000 3001 3002 3003
    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
3004
            self.gil_check(env)
William Stein's avatar
William Stein committed
3005
            self.is_temp = 1
3006 3007
            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
3008 3009 3010 3011 3012 3013 3014 3015 3016 3017 3018 3019 3020 3021 3022 3023 3024 3025 3026 3027 3028 3029 3030 3031
        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
3032
                "%s = %s(%s, %s%s); %s" % (
William Stein's avatar
William Stein committed
3033 3034 3035 3036 3037
                    self.result_code, 
                    function, 
                    self.operand1.py_result(),
                    self.operand2.py_result(),
                    extra_args,
Robert Bradshaw's avatar
Robert Bradshaw committed
3038
                    code.error_goto_if_null(self.result_code, self.pos)))
William Stein's avatar
William Stein committed
3039 3040 3041 3042 3043 3044 3045 3046 3047 3048 3049 3050 3051 3052 3053 3054 3055 3056 3057
        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
3058 3059 3060 3061
        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
3062 3063 3064 3065 3066 3067 3068 3069 3070 3071 3072
        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):
3073 3074 3075
        #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
3076 3077 3078 3079 3080 3081 3082 3083 3084 3085 3086 3087 3088 3089 3090 3091 3092 3093 3094 3095

    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",
        "/":		"PyNumber_Divide",
Robert Bradshaw's avatar
Robert Bradshaw committed
3096
        "//":		"PyNumber_FloorDivide",
William Stein's avatar
William Stein committed
3097
        "%":		"PyNumber_Remainder",
3098
        "**":       "PyNumber_Power"
William Stein's avatar
William Stein committed
3099 3100 3101 3102 3103 3104 3105
    }


class IntBinopNode(NumBinopNode):
    #  Binary operation taking integer arguments.
    
    def c_types_okay(self, type1, type2):
3106 3107 3108
        #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
3109 3110 3111 3112 3113 3114 3115 3116 3117 3118 3119 3120 3121

    
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):
3122 3123
        #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
3124
            return type1
3125
        elif (type2.is_ptr or type2.is_array) and (type1.is_int or type1.is_enum):
William Stein's avatar
William Stein committed
3126 3127 3128 3129 3130 3131 3132 3133 3134 3135
            return type2
        else:
            return NumBinopNode.compute_c_result_type(
                self, type1, type2)


class SubNode(NumBinopNode):
    #  '-' operator.
    
    def compute_c_result_type(self, type1, type2):
3136
        if (type1.is_ptr or type1.is_array) and (type2.is_int or type2.is_enum):
William Stein's avatar
William Stein committed
3137
            return type1
3138
        elif (type1.is_ptr or type1.is_array) and (type2.is_ptr or type2.is_array):
William Stein's avatar
William Stein committed
3139 3140 3141 3142 3143 3144 3145 3146 3147 3148 3149 3150 3151 3152 3153 3154 3155 3156 3157
            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
3158 3159 3160 3161 3162 3163 3164 3165 3166 3167
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
3168 3169 3170 3171 3172 3173 3174 3175 3176 3177 3178
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.
3179

William Stein's avatar
William Stein committed
3180 3181 3182
    def analyse_types(self, env):
        env.pow_function_used = 1
        NumBinopNode.analyse_types(self, env)
3183

William Stein's avatar
William Stein committed
3184 3185 3186 3187 3188
    def compute_c_result_type(self, type1, type2):
        if self.c_types_okay(type1, type2):
            return PyrexTypes.c_double_type
        else:
            return None
3189

3190
    def c_types_okay(self, type1, type2):
3191 3192
        return (type1.is_float or type2.is_float) and \
                NumBinopNode.c_types_okay(self, type1, type2)
3193

3194 3195 3196 3197 3198 3199 3200 3201
    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
3202

William Stein's avatar
William Stein committed
3203 3204 3205
    def calculate_result_code(self):
        return "pow(%s, %s)" % (
            self.operand1.result_code, self.operand2.result_code)
3206

William Stein's avatar
William Stein committed
3207 3208 3209 3210 3211 3212 3213 3214 3215 3216 3217 3218 3219

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']
    
3220 3221 3222 3223 3224 3225 3226 3227
    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
3228 3229 3230 3231 3232 3233 3234
    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)
3235
            self.temp_bool = TempNode(self.pos, PyrexTypes.c_bint_type, env)
William Stein's avatar
William Stein committed
3236
            self.type = py_object_type
3237
            self.gil_check(env)
William Stein's avatar
William Stein committed
3238 3239 3240
        else:
            self.operand1 = self.operand1.coerce_to_boolean(env)
            self.operand2 = self.operand2.coerce_to_boolean(env)
3241
            self.type = PyrexTypes.c_bint_type
William Stein's avatar
William Stein committed
3242 3243 3244 3245 3246
        # 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
3247 3248 3249

    gil_message = "Truth-testing Python object"

William Stein's avatar
William Stein committed
3250 3251 3252 3253 3254 3255 3256 3257 3258 3259 3260 3261 3262 3263 3264 3265 3266 3267 3268 3269 3270 3271 3272 3273 3274 3275 3276 3277 3278 3279 3280 3281 3282 3283 3284 3285 3286 3287 3288 3289 3290 3291 3292 3293 3294 3295 3296 3297 3298 3299 3300 3301 3302 3303 3304
    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(
3305
                "%s = __Pyx_PyObject_IsTrue(%s); %s" % (
William Stein's avatar
William Stein committed
3306 3307
                    test_result,
                    self.operand1.py_result(),
Robert Bradshaw's avatar
Robert Bradshaw committed
3308
                    code.error_goto_if_neg(test_result, self.pos)))
William Stein's avatar
William Stein committed
3309 3310 3311 3312 3313
        else:
            test_result = self.operand1.result_code
        return test_result


Robert Bradshaw's avatar
Robert Bradshaw committed
3314 3315 3316 3317 3318 3319 3320 3321
class CondExprNode(ExprNode):
    #  Short-circuiting conditional expression.
    #
    #  test        ExprNode
    #  true_val    ExprNode
    #  false_val   ExprNode
    
    temp_bool = None
3322 3323
    true_val = None
    false_val = None
Robert Bradshaw's avatar
Robert Bradshaw committed
3324 3325 3326 3327 3328 3329 3330 3331 3332
    
    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)
3333 3334 3335 3336 3337 3338 3339 3340
        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
3341 3342 3343 3344 3345 3346 3347 3348 3349 3350 3351 3352 3353 3354 3355 3356 3357 3358 3359 3360 3361 3362 3363 3364 3365 3366 3367 3368 3369 3370 3371
            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
3372 3373
        elif type1.is_pyobject or type2.is_pyobject:
            return py_object_type
3374 3375 3376 3377
        elif type1.assignable_from(type2):
            return type1
        elif type2.assignable_from(type1):
            return type2
Robert Bradshaw's avatar
Robert Bradshaw committed
3378
        else:
3379
            return PyrexTypes.error_type
Robert Bradshaw's avatar
Robert Bradshaw committed
3380 3381 3382 3383 3384 3385
        
    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
3386
    
Robert Bradshaw's avatar
Robert Bradshaw committed
3387 3388 3389 3390 3391 3392 3393 3394 3395 3396 3397 3398 3399 3400
    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)

3401 3402 3403 3404 3405 3406 3407 3408 3409 3410
richcmp_constants = {
    "<" : "Py_LT",
    "<=": "Py_LE",
    "==": "Py_EQ",
    "!=": "Py_NE",
    "<>": "Py_NE",
    ">" : "Py_GT",
    ">=": "Py_GE",
}

William Stein's avatar
William Stein committed
3411 3412 3413 3414
class CmpNode:
    #  Mixin class containing code common to PrimaryCmpNodes
    #  and CascadedCmpNodes.
    
3415 3416
    def cascaded_compile_time_value(self, operand1, denv):
        func = get_compile_time_binop(self)
3417
        operand2 = self.operand2.compile_time_value(denv)
3418 3419 3420 3421
        try:
            result = func(operand1, operand2)
        except Exception, e:
            self.compile_time_value_error(e)
3422
            result = None
3423 3424 3425 3426 3427 3428
        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
3429 3430 3431 3432 3433
    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'))

3434 3435 3436 3437
    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
3438 3439 3440 3441 3442 3443 3444 3445 3446 3447 3448 3449
    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
3450
        elif type1.is_ptr or type1.is_array:
William Stein's avatar
William Stein committed
3451
            return type1.is_null_ptr or type2.is_null_ptr \
3452 3453 3454 3455 3456
                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
3457 3458 3459
                and op not in ('is', 'is_not')):
            return 1
        else:
3460
            return type1.is_cfunction and type1.is_cfunction and type1 == type2
William Stein's avatar
William Stein committed
3461 3462 3463

    def generate_operation_code(self, code, result_code, 
            operand1, op , operand2):
3464 3465 3466 3467 3468 3469
        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
3470 3471
        if op == 'in' or op == 'not_in':
            code.putln(
3472
                "%s = %s(%sPySequence_Contains(%s, %s)); %s" % (
William Stein's avatar
William Stein committed
3473
                    result_code, 
3474 3475
                    coerce_result, 
                    negation,
William Stein's avatar
William Stein committed
3476 3477
                    operand2.py_result(), 
                    operand1.py_result(), 
Robert Bradshaw's avatar
Robert Bradshaw committed
3478
                    code.error_goto_if_neg(result_code, self.pos)))
William Stein's avatar
William Stein committed
3479 3480
        elif (operand1.type.is_pyobject
            and op not in ('is', 'is_not')):
3481 3482
                code.putln("%s = PyObject_RichCompare(%s, %s, %s); %s" % (
                        result_code, 
William Stein's avatar
William Stein committed
3483 3484
                        operand1.py_result(), 
                        operand2.py_result(), 
3485 3486
                        richcmp_constants[op],
                        code.error_goto_if_null(result_code, self.pos)))
William Stein's avatar
William Stein committed
3487
        else:
3488 3489 3490 3491 3492
            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
3493 3494
            elif type1.is_numeric:
                common_type = PyrexTypes.widest_numeric_type(type1, type2)
3495
            else:
3496 3497 3498
                common_type = type1
            code1 = operand1.result_as(common_type)
            code2 = operand2.result_as(common_type)
3499
            code.putln("%s = %s(%s %s %s);" % (
William Stein's avatar
William Stein committed
3500
                result_code, 
3501
                coerce_result, 
3502
                code1, 
William Stein's avatar
William Stein committed
3503
                self.c_operator(op), 
3504 3505
                code2))

William Stein's avatar
William Stein committed
3506 3507 3508 3509 3510 3511 3512 3513 3514 3515 3516 3517 3518 3519 3520 3521 3522 3523 3524 3525 3526 3527 3528
    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
3529 3530
    child_attrs = ['operand1', 'operand2', 'cascade']
    
William Stein's avatar
William Stein committed
3531 3532
    cascade = None
    
3533
    def compile_time_value(self, denv):
3534
        operand1 = self.operand1.compile_time_value(denv)
3535 3536
        return self.cascaded_compile_time_value(operand1, denv)

William Stein's avatar
William Stein committed
3537 3538 3539 3540 3541 3542 3543 3544
    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)
3545 3546
        if self.has_int_operands():
            self.coerce_chars_to_ints(env)
William Stein's avatar
William Stein committed
3547 3548 3549 3550
        if self.cascade:
            self.operand2 = self.operand2.coerce_to_simple(env)
            self.cascade.coerce_cascaded_operands_to_temp(env)
        self.check_operand_types(env)
3551 3552 3553 3554 3555 3556 3557 3558
        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
3559 3560 3561 3562 3563 3564 3565 3566 3567 3568 3569 3570
        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)
3571
            
William Stein's avatar
William Stein committed
3572 3573 3574 3575 3576 3577
    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)
        
3578 3579 3580 3581 3582
    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):
3583 3584
        # coerce literal single-char strings to c chars
        if self.operand1.type.is_string and isinstance(self.operand1, StringNode):
3585
            self.operand1 = self.operand1.coerce_to(PyrexTypes.c_uchar_type, env)
3586
        if self.operand2.type.is_string and isinstance(self.operand2, StringNode):
3587 3588 3589 3590
            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
3591 3592 3593 3594 3595 3596 3597 3598 3599 3600 3601 3602 3603 3604 3605 3606 3607 3608 3609 3610 3611 3612 3613 3614 3615 3616 3617 3618 3619 3620 3621 3622 3623 3624 3625 3626 3627 3628 3629 3630 3631
    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)
3632 3633 3634 3635 3636 3637
        
    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
3638 3639 3640 3641 3642 3643 3644 3645 3646 3647 3648 3649


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

William Stein's avatar
William Stein committed
3652 3653 3654 3655 3656 3657 3658 3659 3660 3661 3662 3663 3664 3665 3666
    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
3667
        
William Stein's avatar
William Stein committed
3668 3669 3670 3671 3672
    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)

3673 3674 3675 3676
    def has_int_operands(self):
        return self.operand2.type.is_int
        
    def coerce_chars_to_ints(self, env):
3677
        if self.operand2.type.is_string and isinstance(self.operand2, StringNode):
3678 3679
            self.operand2 = self.operand2.coerce_to(PyrexTypes.c_uchar_type, env)

William Stein's avatar
William Stein committed
3680 3681 3682 3683 3684 3685 3686 3687 3688 3689 3690 3691 3692 3693 3694 3695 3696
    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):
3697 3698 3699 3700
        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
3701 3702 3703 3704 3705 3706 3707 3708 3709 3710
        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("}")

3711 3712 3713 3714 3715
    def annotate(self, code):
        self.operand2.annotate(code)
        if self.cascade:
            self.cascade.annotate(code)

William Stein's avatar
William Stein committed
3716 3717 3718 3719 3720 3721 3722 3723 3724 3725 3726 3727 3728

binop_node_classes = {
    "or":		BoolBinopNode,
    "and":	BoolBinopNode,
    "|":		IntBinopNode,
    "^":		IntBinopNode,
    "&":		IntBinopNode,
    "<<":		IntBinopNode,
    ">>":		IntBinopNode,
    "+":		AddNode,
    "-":		SubNode,
    "*":		MulNode,
    "/":		NumBinopNode,
Robert Bradshaw's avatar
Robert Bradshaw committed
3729
    "//":		FloorDivNode,
William Stein's avatar
William Stein committed
3730 3731 3732 3733 3734 3735 3736 3737 3738 3739 3740 3741 3742 3743 3744 3745 3746 3747 3748 3749 3750 3751 3752 3753 3754 3755 3756 3757 3758 3759 3760 3761 3762 3763
    "%":		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
3764
            print("%s Coercing %s" % (self, self.arg))
3765 3766 3767 3768 3769 3770
            
    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
3771 3772 3773 3774 3775 3776 3777 3778 3779 3780 3781 3782 3783 3784 3785 3786 3787 3788 3789 3790 3791 3792 3793 3794


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
3795
        assert dst_type.is_extension_type or dst_type.is_builtin_type, "PyTypeTest on non extension type"
William Stein's avatar
William Stein committed
3796 3797
        CoercionNode.__init__(self, arg)
        self.type = dst_type
3798
        self.gil_check(env)
William Stein's avatar
William Stein committed
3799 3800
        self.result_ctype = arg.ctype()
        env.use_utility_code(type_test_utility_code)
3801 3802

    gil_message = "Python type test"
William Stein's avatar
William Stein committed
3803
    
3804 3805 3806
    def analyse_types(self, env):
        pass
    
William Stein's avatar
William Stein committed
3807 3808 3809 3810 3811 3812 3813 3814 3815 3816 3817 3818
    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
3819 3820
                "if (!(%s)) %s" % (
                    self.type.type_test_code(self.arg.py_result()),
William Stein's avatar
William Stein committed
3821 3822 3823 3824 3825 3826 3827 3828 3829 3830 3831 3832 3833 3834 3835 3836
                    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
3837
        self.gil_check(env)
William Stein's avatar
William Stein committed
3838 3839 3840 3841
        self.is_temp = 1
        if not arg.type.to_py_function:
            error(arg.pos,
                "Cannot convert '%s' to Python object" % arg.type)
3842 3843 3844

    gil_message = "Converting to Python object"

William Stein's avatar
William Stein committed
3845 3846
    def generate_result_code(self, code):
        function = self.arg.type.to_py_function
Robert Bradshaw's avatar
Robert Bradshaw committed
3847
        code.putln('%s = %s(%s); %s' % (
William Stein's avatar
William Stein committed
3848 3849 3850
            self.result_code, 
            function, 
            self.arg.result_code, 
Robert Bradshaw's avatar
Robert Bradshaw committed
3851
            code.error_goto_if_null(self.result_code, self.pos)))
William Stein's avatar
William Stein committed
3852 3853 3854 3855 3856 3857 3858 3859 3860 3861 3862 3863 3864 3865 3866 3867 3868 3869 3870


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")
    
    def generate_result_code(self, code):
        function = self.type.from_py_function
3871 3872 3873 3874
        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
3875
        code.putln('%s = %s; %s' % (
William Stein's avatar
William Stein committed
3876
            self.result_code, 
3877
            rhs,
3878
            code.error_goto_if(self.type.error_condition(self.result_code), self.pos)))
William Stein's avatar
William Stein committed
3879 3880 3881 3882 3883 3884 3885 3886


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)
3887
        self.type = PyrexTypes.c_bint_type
William Stein's avatar
William Stein committed
3888
        if arg.type.is_pyobject:
3889 3890
            if env.nogil:
                self.gil_error()
William Stein's avatar
William Stein committed
3891
            self.is_temp = 1
3892 3893

    gil_message = "Truth-testing Python object"
William Stein's avatar
William Stein committed
3894 3895 3896 3897 3898 3899 3900 3901 3902 3903 3904 3905
    
    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(
3906
                "%s = __Pyx_PyObject_IsTrue(%s); %s" % (
William Stein's avatar
William Stein committed
3907 3908
                    self.result_code, 
                    self.arg.py_result(), 
Robert Bradshaw's avatar
Robert Bradshaw committed
3909
                    code.error_goto_if_neg(self.result_code, self.pos)))
William Stein's avatar
William Stein committed
3910 3911 3912 3913 3914 3915 3916 3917 3918 3919 3920 3921


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:
3922
            self.gil_check(env)
William Stein's avatar
William Stein committed
3923
            self.result_ctype = py_object_type
3924 3925 3926

    gil_message = "Creating temporary Python reference"

William Stein's avatar
William Stein committed
3927 3928 3929 3930 3931 3932 3933 3934 3935 3936 3937 3938 3939 3940 3941 3942 3943 3944 3945 3946 3947
    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)
3948 3949 3950 3951 3952
        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
3953 3954 3955
    
    def calculate_result_code(self):
        return self.arg.result_code
Robert Bradshaw's avatar
Robert Bradshaw committed
3956 3957 3958 3959 3960
        
    def analyse_types(self, env):
        self.type = self.arg.type
        self.result_ctype = self.arg.result_ctype
        self.is_temp = 1
3961 3962
        if hasattr(self.arg, 'entry'):
            self.entry = self.arg.entry
William Stein's avatar
William Stein committed
3963 3964 3965 3966 3967 3968
    
    def generate_evaluation_code(self, code):
        pass

    def generate_result_code(self, code):
        pass
3969 3970
        
    def generate_disposal_code(self, code):
3971 3972
        pass
                
3973 3974 3975 3976 3977
    def allocate_temps(self, env):
        self.result_code = self.calculate_result_code()
        
    def release_temp(self, env):
        pass
William Stein's avatar
William Stein committed
3978 3979 3980 3981 3982 3983 3984
    
#------------------------------------------------------------------------------------
#
#  Runtime support code
#
#------------------------------------------------------------------------------------

3985
get_name_interned_utility_code = [
William Stein's avatar
William Stein committed
3986
"""
3987 3988
static PyObject *__Pyx_GetName(PyObject *dict, PyObject *name); /*proto*/
""","""
William Stein's avatar
William Stein committed
3989 3990 3991 3992 3993 3994 3995
static PyObject *__Pyx_GetName(PyObject *dict, PyObject *name) {
    PyObject *result;
    result = PyObject_GetAttr(dict, name);
    if (!result)
        PyErr_SetObject(PyExc_NameError, name);
    return result;
}
3996
"""]
William Stein's avatar
William Stein committed
3997 3998 3999

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

4000
import_utility_code = [
William Stein's avatar
William Stein committed
4001
"""
4002 4003
static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list); /*proto*/
""","""
William Stein's avatar
William Stein committed
4004 4005 4006 4007 4008 4009 4010 4011 4012 4013 4014 4015 4016 4017 4018 4019 4020 4021 4022 4023 4024 4025 4026 4027 4028 4029 4030 4031 4032 4033 4034 4035 4036 4037 4038
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,
4039
}]
William Stein's avatar
William Stein committed
4040 4041 4042

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

4043
get_exception_utility_code = [
William Stein's avatar
William Stein committed
4044
"""
4045 4046
static PyObject *__Pyx_GetExcValue(void); /*proto*/
""","""
William Stein's avatar
William Stein committed
4047 4048
static PyObject *__Pyx_GetExcValue(void) {
    PyObject *type = 0, *value = 0, *tb = 0;
4049
    PyObject *tmp_type, *tmp_value, *tmp_tb;
William Stein's avatar
William Stein committed
4050 4051 4052 4053 4054 4055 4056 4057 4058 4059
    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);
    }
4060 4061 4062
    tmp_type = tstate->exc_type;
    tmp_value = tstate->exc_value;
    tmp_tb = tstate->exc_traceback;
William Stein's avatar
William Stein committed
4063 4064 4065
    tstate->exc_type = type;
    tstate->exc_value = value;
    tstate->exc_traceback = tb;
4066 4067 4068 4069 4070
    /* 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
4071 4072 4073 4074 4075 4076 4077 4078 4079 4080 4081
    result = value;
    Py_XINCREF(result);
    type = 0;
    value = 0;
    tb = 0;
bad:
    Py_XDECREF(type);
    Py_XDECREF(value);
    Py_XDECREF(tb);
    return result;
}
4082
"""]
William Stein's avatar
William Stein committed
4083 4084 4085

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

4086
unpacking_utility_code = [
William Stein's avatar
William Stein committed
4087
"""
4088
static PyObject *__Pyx_UnpackItem(PyObject *, Py_ssize_t index); /*proto*/
4089 4090
static int __Pyx_EndUnpack(PyObject *); /*proto*/
""","""
4091
static PyObject *__Pyx_UnpackItem(PyObject *iter, Py_ssize_t index) {
4092 4093
    PyObject *item;
    if (!(item = PyIter_Next(iter))) {
4094 4095 4096 4097 4098 4099 4100 4101
        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
        }
4102 4103
    }
    return item;
4104
}
William Stein's avatar
William Stein committed
4105

4106 4107 4108 4109
static int __Pyx_EndUnpack(PyObject *iter) {
    PyObject *item;
    if ((item = PyIter_Next(iter))) {
        Py_DECREF(item);
4110
        PyErr_SetString(PyExc_ValueError, "too many values to unpack");
4111 4112 4113 4114 4115 4116
        return -1;
    }
    else if (!PyErr_Occurred())
        return 0;
    else
        return -1;
4117
}
4118
"""]
William Stein's avatar
William Stein committed
4119 4120 4121

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

4122
type_test_utility_code = [
William Stein's avatar
William Stein committed
4123
"""
4124 4125
static int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type); /*proto*/
""","""
William Stein's avatar
William Stein committed
4126 4127 4128 4129 4130 4131 4132 4133
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",
4134
        Py_TYPE(obj)->tp_name, type->tp_name);
William Stein's avatar
William Stein committed
4135 4136
    return 0;
}
4137
"""]
William Stein's avatar
William Stein committed
4138 4139 4140

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

4141
create_class_utility_code = [
William Stein's avatar
William Stein committed
4142
"""
4143 4144
static PyObject *__Pyx_CreateClass(PyObject *bases, PyObject *dict, PyObject *name, char *modname); /*proto*/
""","""
William Stein's avatar
William Stein committed
4145 4146 4147 4148 4149
static PyObject *__Pyx_CreateClass(
    PyObject *bases, PyObject *dict, PyObject *name, char *modname)
{
    PyObject *py_modname;
    PyObject *result = 0;
4150

4151
    #if PY_MAJOR_VERSION < 3
William Stein's avatar
William Stein committed
4152
    py_modname = PyString_FromString(modname);
4153 4154 4155
    #else
    py_modname = PyUnicode_FromString(modname);
    #endif
William Stein's avatar
William Stein committed
4156 4157 4158 4159
    if (!py_modname)
        goto bad;
    if (PyDict_SetItemString(dict, "__module__", py_modname) < 0)
        goto bad;
4160
    #if PY_MAJOR_VERSION < 3
William Stein's avatar
William Stein committed
4161
    result = PyClass_New(bases, dict, name);
4162 4163 4164
    #else
    result = PyObject_CallFunctionObjArgs((PyObject *)&PyType_Type, name, bases, dict, NULL);
    #endif
William Stein's avatar
William Stein committed
4165 4166 4167 4168
bad:
    Py_XDECREF(py_modname);
    return result;
}
4169
"""]
William Stein's avatar
William Stein committed
4170 4171

#------------------------------------------------------------------------------------
Robert Bradshaw's avatar
Robert Bradshaw committed
4172 4173 4174

cpp_exception_utility_code = [
"""
4175 4176
#ifndef __Pyx_CppExn2PyErr
static void __Pyx_CppExn2PyErr() {
Robert Bradshaw's avatar
Robert Bradshaw committed
4177 4178 4179 4180 4181 4182 4183 4184 4185 4186 4187 4188 4189 4190 4191 4192
  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");
  }
}
4193 4194
#endif
""",""]
Robert Bradshaw's avatar
Robert Bradshaw committed
4195 4196

#------------------------------------------------------------------------------------
Robert Bradshaw's avatar
Robert Bradshaw committed
4197 4198 4199

append_utility_code = [
"""
Stefan Behnel's avatar
Stefan Behnel committed
4200
static INLINE PyObject* __Pyx_PyObject_Append(PyObject* L, PyObject* x) {
Robert Bradshaw's avatar
Robert Bradshaw committed
4201 4202 4203 4204 4205 4206
    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 {
4207
        return PyObject_CallMethod(L, "append", "(O)", x);
Robert Bradshaw's avatar
Robert Bradshaw committed
4208 4209 4210
    }
}
""",""
4211
]
4212 4213 4214 4215 4216 4217

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

type_cache_invalidation_code = [
"""
#if PY_VERSION_HEX >= 0x02060000
Dag Sverre Seljebotn's avatar
Merge  
Dag Sverre Seljebotn committed
4218
/* #define __Pyx_TypeModified(t) PyType_Modified(t) */  /* Py3.0beta1 */
4219 4220 4221 4222 4223 4224 4225 4226 4227 4228 4229 4230 4231 4232 4233 4234 4235 4236 4237 4238 4239 4240 4241 4242 4243 4244 4245 4246 4247 4248
static void __Pyx_TypeModified(PyTypeObject* type); /*proto*/
#else
  #define __Pyx_TypeModified(t)
#endif
""","""
#if PY_VERSION_HEX >= 0x02060000
/* copied from typeobject.c in Python 3.0a5 */
static void __Pyx_TypeModified(PyTypeObject* type) {
    PyObject *raw, *ref;
    Py_ssize_t i, n;

    if (!PyType_HasFeature(type, Py_TPFLAGS_VALID_VERSION_TAG))
        return;

    raw = type->tp_subclasses;
    if (raw != NULL) {
        n = PyList_GET_SIZE(raw);
        for (i = 0; i < n; i++) {
            ref = PyList_GET_ITEM(raw, i);
            ref = PyWeakref_GET_OBJECT(ref);
            if (ref != Py_None) {
                __Pyx_TypeModified((PyTypeObject *)ref);
            }
        }
    }
    type->tp_flags &= ~Py_TPFLAGS_VALID_VERSION_TAG;
}
#endif
"""
]
Dag Sverre Seljebotn's avatar
Merge  
Dag Sverre Seljebotn committed
4249 4250 4251 4252 4253 4254 4255 4256 4257 4258 4259 4260 4261 4262 4263 4264 4265 4266 4267 4268 4269 4270 4271 4272 4273 4274 4275 4276 4277 4278 4279 4280 4281 4282 4283 4284 4285 4286 4287 4288 4289 4290 4291 4292 4293 4294 4295 4296 4297 4298 4299 4300 4301 4302 4303 4304 4305 4306 4307

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

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