#

# Parse tree nodes for expressions

#

import cython

cython.declare(error=object, warning=object, warn_once=object, InternalError=object,

CompileError=object, UtilityCode=object, TempitaUtilityCode=object,

StringEncoding=object, operator=object,

Naming=object, Nodes=object, PyrexTypes=object, py_object_type=object,

list_type=object, tuple_type=object, set_type=object, dict_type=object,

unicode_type=object, str_type=object, bytes_type=object, type_type=object,

Builtin=object, Symtab=object, Utils=object, find_coercion_error=object,

debug_disposal_code=object, debug_temp_alloc=object, debug_coercion=object,

bytearray_type=object, slice_type=object)

import sys

import copy

import operator

from Errors import error, warning, warn_once, InternalError, CompileError

from Errors import hold_errors, release_errors, held_errors, report_error

from Code import UtilityCode, TempitaUtilityCode

import StringEncoding

import Naming

import Nodes

from Nodes import Node

import PyrexTypes

from PyrexTypes import py_object_type, c_long_type, typecast, error_type, \

unspecified_type

import TypeSlots

from Builtin import list_type, tuple_type, set_type, dict_type, type_type, \

unicode_type, str_type, bytes_type, bytearray_type, basestring_type, slice_type

import Builtin

import Symtab

from Cython import Utils

from Annotate import AnnotationItem

from Cython.Compiler import Future

from Cython.Debugging import print_call_chain

from DebugFlags import debug_disposal_code, debug_temp_alloc, \

debug_coercion

try:

from __builtin__ import basestring

except ImportError:

basestring = str # Python 3

try:

from builtins import bytes

except ImportError:

bytes = str # Python 2

class NotConstant(object):

_obj = None

def __new__(cls):

if NotConstant._obj is None:

NotConstant._obj = super(NotConstant, cls).__new__(cls)

return NotConstant._obj

def __repr__(self):

return "<NOT CONSTANT>"

not_a_constant = NotConstant()

constant_value_not_set = object()

# error messages when coercing from key[0] to key[1]

coercion_error_dict = {

# string related errors

(Builtin.unicode_type, Builtin.bytes_type) : "Cannot convert Unicode string to 'bytes' implicitly, encoding required.",

(Builtin.unicode_type, Builtin.str_type) : "Cannot convert Unicode string to 'str' implicitly. This is not portable and requires explicit encoding.",

(Builtin.unicode_type, PyrexTypes.c_char_ptr_type) : "Unicode objects only support coercion to Py_UNICODE*.",

(Builtin.unicode_type, PyrexTypes.c_uchar_ptr_type) : "Unicode objects only support coercion to Py_UNICODE*.",

(Builtin.bytes_type, Builtin.unicode_type) : "Cannot convert 'bytes' object to unicode implicitly, decoding required",

(Builtin.bytes_type, Builtin.str_type) : "Cannot convert 'bytes' object to str implicitly. This is not portable to Py3.",

(Builtin.bytes_type, Builtin.basestring_type) : "Cannot convert 'bytes' object to basestring implicitly. This is not portable to Py3.",

(Builtin.bytes_type, PyrexTypes.c_py_unicode_ptr_type) : "Cannot convert 'bytes' object to Py_UNICODE*, use 'unicode'.",

(Builtin.basestring_type, Builtin.bytes_type) : "Cannot convert 'basestring' object to bytes implicitly. This is not portable.",

(Builtin.str_type, Builtin.unicode_type) : "str objects do not support coercion to unicode, use a unicode string literal instead (u'')",

(Builtin.str_type, Builtin.bytes_type) : "Cannot convert 'str' to 'bytes' implicitly. This is not portable.",

(Builtin.str_type, PyrexTypes.c_char_ptr_type) : "'str' objects do not support coercion to C types (use 'bytes'?).",

(Builtin.str_type, PyrexTypes.c_uchar_ptr_type) : "'str' objects do not support coercion to C types (use 'bytes'?).",

(Builtin.str_type, PyrexTypes.c_py_unicode_ptr_type) : "'str' objects do not support coercion to C types (use 'unicode'?).",

(PyrexTypes.c_char_ptr_type, Builtin.unicode_type) : "Cannot convert 'char*' to unicode implicitly, decoding required",

(PyrexTypes.c_uchar_ptr_type, Builtin.unicode_type) : "Cannot convert 'char*' to unicode implicitly, decoding required",

}

def find_coercion_error(type_tuple, default, env):

err = coercion_error_dict.get(type_tuple)

if err is None:

return default

elif ((PyrexTypes.c_char_ptr_type in type_tuple or PyrexTypes.c_uchar_ptr_type in type_tuple)

and env.directives['c_string_encoding']):

if type_tuple[1].is_pyobject:

return default

elif env.directives['c_string_encoding'] in ('ascii', 'default'):

return default

else:

return "'%s' objects do not support coercion to C types with non-ascii or non-default c_string_encoding" % type_tuple[0].name

else:

return err

def default_str_type(env):

return {

'bytes': bytes_type,

'bytearray': bytearray_type,

'str': str_type,

'unicode': unicode_type

}.get(env.directives['c_string_type'])

def check_negative_indices(*nodes):

"""

Raise a warning on nodes that are known to have negative numeric values.

Used to find (potential) bugs inside of "wraparound=False" sections.

"""

for node in nodes:

if (node is None

or not isinstance(node.constant_result, (int, float, long))):

continue

if node.constant_result < 0:

warning(node.pos,

"the result of using negative indices inside of "

"code sections marked as 'wraparound=False' is "

"undefined", level=1)

def infer_sequence_item_type(env, seq_node, index_node=None, seq_type=None):

if not seq_node.is_sequence_constructor:

if seq_type is None:

seq_type = seq_node.infer_type(env)

if seq_type is tuple_type:

# tuples are immutable => we can safely follow assignments

if seq_node.cf_state and len(seq_node.cf_state) == 1:

try:

seq_node = seq_node.cf_state[0].rhs

except AttributeError:

pass

if seq_node is not None and seq_node.is_sequence_constructor:

if index_node is not None and index_node.has_constant_result():

try:

item = seq_node.args[index_node.constant_result]

except (ValueError, TypeError, IndexError):

pass

else:

return item.infer_type(env)

# if we're lucky, all items have the same type

item_types = set([item.infer_type(env) for item in seq_node.args])

if len(item_types) == 1:

return item_types.pop()

return None

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

# is_starred boolean Is a starred expression (e.g. '*a')

# saved_subexpr_nodes

# [ExprNode or [ExprNode or None] or None]

# Cached result of subexpr_nodes()

# use_managed_ref boolean use ref-counted temps/assignments/etc.

# result_is_used boolean indicates that the result will be dropped and the

# result_code/temp_result can safely be set to None

result_ctype = None

type = None

temp_code = None

old_temp = None # error checker for multiple frees etc.

use_managed_ref = True # can be set by optimisation transforms

result_is_used = True

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

#

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

#

# 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 methods:

#

# generate_result_code

# - Generate any C statements necessary to calculate

# the result of this node from the results of its

# sub-expressions.

#

# calculate_result_code

# - Should return a C code fragment evaluating to the

# result. This is only called when the result is not

# a temporary.

#

# 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_string_literal = 0

is_attribute = 0

is_subscript = 0

saved_subexpr_nodes = None

is_temp = 0

is_target = 0

is_starred = 0

constant_result = constant_value_not_set

# whether this node with a memoryview type should be broadcast

memslice_broadcast = False

child_attrs = property(fget=operator.attrgetter('subexprs'))

def not_implemented(self, method_name):

print_call_chain(method_name, "not implemented") ###

raise InternalError(

"%s.%s not implemented" %

(self.__class__.__name__, method_name))

def is_lvalue(self):

return 0

def is_addressable(self):

return self.is_lvalue() and not self.type.is_memoryviewslice

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.

nodes = []

for name in self.subexprs:

item = getattr(self, name)

if item is not None:

if type(item) is list:

nodes.extend(item)

else:

nodes.append(item)

return nodes

def result(self):

if self.is_temp:

return self.temp_code

else:

return self.calculate_result_code()

def result_as(self, type = None):

# Return the result code cast to the specified C type.

if (self.is_temp and self.type.is_pyobject and

type != py_object_type):

# Allocated temporaries are always PyObject *, which may not

# reflect the actual type (e.g. an extension type)

return typecast(type, py_object_type, self.result())

return typecast(type, self.ctype(), self.result())

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

def get_constant_c_result_code(self):

# Return the constant value of this node as a result code

# string, or None if the node is not constant. This method

# can be called when the constant result code is required

# before the code generation phase.

#

# The return value is a string that can represent a simple C

# value, a constant C name or a constant C expression. If the

# node type depends on Python code, this must return None.

return None

def calculate_constant_result(self):

# Calculate the constant compile time result value of this

# expression and store it in ``self.constant_result``. Does

# nothing by default, thus leaving ``self.constant_result``

# unknown. If valid, the result can be an arbitrary Python

# value.

#

# This must only be called when it is assured that all

# sub-expressions have a valid constant_result value. The

# ConstantFolding transform will do this.

pass

def has_constant_result(self):

return self.constant_result is not constant_value_not_set and \

self.constant_result is not not_a_constant

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

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

node = self.analyse_types(env)

node.check_const()

return node

def analyse_expressions(self, env):

# Convenience routine performing both the Type

# Analysis and Temp Allocation phases for a whole

# expression.

return self.analyse_types(env)

def analyse_target_expression(self, env, rhs):

# Convenience routine performing both the Type

# Analysis and Temp Allocation phases for the LHS of

# an assignment.

return self.analyse_target_types(env)

def analyse_boolean_expression(self, env):

# Analyse expression and coerce to a boolean.

node = self.analyse_types(env)

bool = node.coerce_to_boolean(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.

node = self.analyse_types(env)

return node.coerce_to_boolean(env).coerce_to_simple(env)

# --------------- Type Inference -----------------

def type_dependencies(self, env):

# Returns the list of entries whose types must be determined

# before the type of self can be inferred.

if hasattr(self, 'type') and self.type is not None:

return ()

return sum([node.type_dependencies(env) for node in self.subexpr_nodes()], ())

def infer_type(self, env):

# Attempt to deduce the type of self.

# Differs from analyse_types as it avoids unnecessary

# analysis of subexpressions, but can assume everything

# in self.type_dependencies() has been resolved.

if hasattr(self, 'type') and self.type is not None:

return self.type

elif hasattr(self, 'entry') and self.entry is not None:

return self.entry.type

else:

self.not_implemented("infer_type")

def nonlocally_immutable(self):

# Returns whether this variable is a safe reference, i.e.

# can't be modified as part of globals or closures.

return self.is_literal or self.is_temp or self.type.is_array or self.type.is_cfunction

# --------------- 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_type(self, env):

# If this node can be interpreted as a reference to a

# type, return that type, else None.

return None

def analyse_as_extension_type(self, env):

# If this node can be interpreted as a reference to an

# extension type or builtin type, return its type, else None.

return None

def analyse_types(self, env):

self.not_implemented("analyse_types")

def analyse_target_types(self, env):

return self.analyse_types(env)

def nogil_check(self, env):

# By default, any expression based on Python objects is

# prevented in nogil environments. Subtypes must override

# this if they can work without the GIL.

if self.type and self.type.is_pyobject:

self.gil_error()

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

def check_const(self):

self.not_const()

return False

def not_const(self):

error(self.pos, "Not allowed in a constant expression")

def check_const_addr(self):

self.addr_not_const()

return False

def addr_not_const(self):

error(self.pos, "Address is not constant")

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

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

# def release_target_temp(self, env):

# # Release temporaries used by LHS of an assignment.

# self.release_subexpr_temps(env)

def allocate_temp_result(self, code):

if self.temp_code:

raise RuntimeError("Temp allocated multiple times in %r: %r" % (self.__class__.__name__, self.pos))

type = self.type

if not type.is_void:

if type.is_pyobject:

type = PyrexTypes.py_object_type

self.temp_code = code.funcstate.allocate_temp(

type, manage_ref=self.use_managed_ref)

else:

self.temp_code = None

def release_temp_result(self, code):

if not self.temp_code:

if not self.result_is_used:

# not used anyway, so ignore if not set up

return

if self.old_temp:

raise RuntimeError("temp %s released multiple times in %s" % (

self.old_temp, self.__class__.__name__))

else:

raise RuntimeError("no temp, but release requested in %s" % (

self.__class__.__name__))

code.funcstate.release_temp(self.temp_code)

self.old_temp = self.temp_code

self.temp_code = None

# ---------------- Code Generation -----------------

def make_owned_reference(self, code):

"""

If result is a pyobject, make sure we own a reference to it.

If the result is in a temp, it is already a new reference.

"""

if self.type.is_pyobject and not self.result_in_temp():

code.put_incref(self.result(), self.ctype())

def make_owned_memoryviewslice(self, code):

"""

Make sure we own the reference to this memoryview slice.

"""

if not self.result_in_temp():

code.put_incref_memoryviewslice(self.result(),

have_gil=self.in_nogil_context)

def generate_evaluation_code(self, code):

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

code.mark_pos(self.pos)

if self.is_temp:

self.allocate_temp_result(code)

self.generate_result_code(code)

if self.is_temp:

# If we are temp we do not need to wait until this node is disposed

# before disposing children.

self.generate_subexpr_disposal_code(code)

self.free_subexpr_temps(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 self.is_temp:

if self.result():

if self.type.is_pyobject:

code.put_decref_clear(self.result(), self.ctype())

elif self.type.is_memoryviewslice:

code.put_xdecref_memoryviewslice(

self.result(), have_gil=not self.in_nogil_context)

else:

# Already done if self.is_temp

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):

if self.is_temp:

if self.type.is_pyobject:

code.putln("%s = 0;" % self.result())

elif self.type.is_memoryviewslice:

code.putln("%s.memview = NULL;" % self.result())

code.putln("%s.data = NULL;" % self.result())

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, ignore_nonexisting=False):

# Stub method for nodes that are not legal as

# the argument of a del statement. An error

# will have been reported earlier.

pass

def free_temps(self, code):

if self.is_temp:

if not self.type.is_void:

self.release_temp_result(code)

else:

self.free_subexpr_temps(code)

def free_subexpr_temps(self, code):

for sub in self.subexpr_nodes():

sub.free_temps(code)

def generate_function_definitions(self, env, code):

pass

# ---------------- Annotation ---------------------

def annotate(self, code):

for node in self.subexpr_nodes():

node.annotate(code)

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

#

# Note that subclasses that override this (especially

# ConstNodes) must not (re-)set their own .type attribute

# here. Since expression nodes may turn up in different

# places in the tree (e.g. inside of CloneNodes in cascaded

# assignments), this method must return a new node instance

# if it changes the type.

#

src = self

src_type = self.type

if self.check_for_coercion_error(dst_type, env):

return self

if dst_type.is_reference and not src_type.is_reference:

dst_type = dst_type.ref_base_type

if src_type.is_const:

src_type = src_type.const_base_type

if src_type.is_fused or dst_type.is_fused:

# See if we are coercing a fused function to a pointer to a

# specialized function

if (src_type.is_cfunction and not dst_type.is_fused and

dst_type.is_ptr and dst_type.base_type.is_cfunction):

dst_type = dst_type.base_type

for signature in src_type.get_all_specialized_function_types():

if signature.same_as(dst_type):

src.type = signature

src.entry = src.type.entry

src.entry.used = True

return self

if src_type.is_fused:

error(self.pos, "Type is not specialized")

else:

error(self.pos, "Cannot coerce to a type that is not specialized")

self.type = error_type

return self

if self.coercion_type is not None:

# This is purely for error checking purposes!

node = NameNode(self.pos, name='', type=self.coercion_type)

node.coerce_to(dst_type, env)

if dst_type.is_memoryviewslice:

import MemoryView

if not src.type.is_memoryviewslice:

if src.type.is_pyobject:

src = CoerceToMemViewSliceNode(src, dst_type, env)

elif src.type.is_array:

src = CythonArrayNode.from_carray(src, env).coerce_to(

dst_type, env)

elif not src_type.is_error:

error(self.pos,

"Cannot convert '%s' to memoryviewslice" %

(src_type,))

elif not MemoryView.src_conforms_to_dst(

src.type, dst_type, broadcast=self.memslice_broadcast):

if src.type.dtype.same_as(dst_type.dtype):

msg = "Memoryview '%s' not conformable to memoryview '%s'."

tup = src.type, dst_type

else:

msg = "Different base types for memoryviews (%s, %s)"

tup = src.type.dtype, dst_type.dtype

error(self.pos, msg % tup)

elif dst_type.is_pyobject:

if not src.type.is_pyobject:

if dst_type is bytes_type and src.type.is_int:

src = CoerceIntToBytesNode(src, env)

else:

src = CoerceToPyTypeNode(src, env, type=dst_type)

if not src.type.subtype_of(dst_type):

if src.constant_result is not None:

src = PyTypeTestNode(src, dst_type, env)

elif src.type.is_pyobject:

src = CoerceFromPyTypeNode(dst_type, src, env)

elif (dst_type.is_complex

and src_type != dst_type

and dst_type.assignable_from(src_type)):

src = CoerceToComplexNode(src, dst_type, env)

else: # neither src nor dst are py types

# Added the string comparison, since for c types that

# is enough, but Cython gets confused when the types are

# in different pxi files.

if not (str(src.type) == str(dst_type) or dst_type.assignable_from(src_type)):

self.fail_assignment(dst_type)

return src

def fail_assignment(self, dst_type):

error(self.pos, "Cannot assign type '%s' to '%s'" % (self.type, dst_type))

def check_for_coercion_error(self, dst_type, env, fail=False, default=None):

if fail and not default:

default = "Cannot assign type '%(FROM)s' to '%(TO)s'"

message = find_coercion_error((self.type, dst_type), default, env)

if message is not None:

error(self.pos, message % {'FROM': self.type, 'TO': dst_type})

return True

if fail:

self.fail_assignment(dst_type)

return True

return False

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.

# if it's constant, calculate the result now

if self.has_constant_result():

bool_value = bool(self.constant_result)

return BoolNode(self.pos, value=bool_value,

constant_result=bool_value)

type = self.type

if type.is_enum or type.is_error:

return self

elif type.is_pyobject or type.is_int or type.is_ptr or type.is_float:

return CoerceToBooleanNode(self, env)

else:

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

def may_be_none(self):

if self.type and not (self.type.is_pyobject or

self.type.is_memoryviewslice):

return False

if self.has_constant_result():

return self.constant_result is not None

return True

def as_cython_attribute(self):

return None

def as_none_safe_node(self, message, error="PyExc_TypeError", format_args=()):

# Wraps the node in a NoneCheckNode if it is not known to be

# not-None (e.g. because it is a Python literal).

if self.may_be_none():

return NoneCheckNode(self, error, message, format_args)

else:

return self

@classmethod

def from_node(cls, node, **kwargs):

"""Instantiate this node class from another node, properly

copying over all attributes that one would forget otherwise.

"""

attributes = "cf_state cf_maybe_null cf_is_null constant_result".split()

for attr_name in attributes:

if attr_name in kwargs:

continue

try:

value = getattr(node, attr_name)

except AttributeError:

pass

else:

kwargs[attr_name] = value

return cls(node.pos, **kwargs)

class AtomicExprNode(ExprNode):

# Abstract base class for expression nodes which have

# no sub-expressions.

subexprs = []

# Override to optimize -- we know we have no children

def generate_subexpr_evaluation_code(self, code):

pass

def generate_subexpr_disposal_code(self, code):

pass

class PyConstNode(AtomicExprNode):

# Abstract base class for constant Python values.

is_literal = 1

type = py_object_type

def is_simple(self):

return 1

def may_be_none(self):

return False

def analyse_types(self, env):

return self

def calculate_result_code(self):

return self.value

def generate_result_code(self, code):

pass

class NoneNode(PyConstNode):

# The constant value None

is_none = 1

value = "Py_None"

constant_result = None

nogil_check = None

def compile_time_value(self, denv):

return None

def may_be_none(self):

return True

class EllipsisNode(PyConstNode):

# '...' in a subscript list.

value = "Py_Ellipsis"

constant_result = Ellipsis

def compile_time_value(self, denv):

return Ellipsis

class ConstNode(AtomicExprNode):

# Abstract base type for literal constant nodes.

#

# value string C code fragment

is_literal = 1

nogil_check = None

def is_simple(self):

return 1

def nonlocally_immutable(self):

return 1

def may_be_none(self):

return False

def analyse_types(self, env):

return self # Types are held in class variables

def check_const(self):

return True

def get_constant_c_result_code(self):

return self.calculate_result_code()

def calculate_result_code(self):

return str(self.value)

def generate_result_code(self, code):

pass

class BoolNode(ConstNode):

type = PyrexTypes.c_bint_type

# The constant value True or False

def calculate_constant_result(self):

self.constant_result = self.value

def compile_time_value(self, denv):

return self.value

def calculate_result_code(self):

if self.type.is_pyobject:

return self.value and 'Py_True' or 'Py_False'

else:

return str(int(self.value))

def coerce_to(self, dst_type, env):

if dst_type.is_pyobject and self.type.is_int:

return BoolNode(

self.pos, value=self.value,

constant_result=self.constant_result,

type=Builtin.bool_type)

if dst_type.is_int and self.type.is_pyobject:

return BoolNode(

self.pos, value=self.value,

constant_result=self.constant_result,

type=PyrexTypes.c_bint_type)

return ConstNode.coerce_to(self, dst_type, env)

class NullNode(ConstNode):