#
# Pyrex - Parse tree nodes for expressions
#
import operator
from string import join
from Errors import error,InternalError
import Naming
from Nodes import Node
import PyrexTypes
from PyrexTypes import py_object_type,c_long_type,typecast,error_type,\
CPtrType, CFuncType, COverloadedFuncType
import Symtab
import Options
from Pyrex.Debugging import print_call_chain
from DebugFlags import debug_disposal_code,debug_temp_alloc,\
debug_coercion
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
# inplace_result string Temp var holding in-place operation result
# 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
# 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. If coercion is needed, 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.
#
# 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.
#
# #calculate_result_code
# # - 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.
#
# 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
# 1. Call generate_evaluation_code for sub-expressions.
# 2. Generate any C statements necessary to calculate
# the result of this node from the results of its
# sub-expressions. If result is not in a temporary, record
# any information that will be needed by this node's
# implementation of calculate_result_code().
# 4. If result is in a temporary, call generate_disposal_code
# on all sub-expressions.
#
# A default implementation of generate_evaluation_code
# is provided which uses the folling abstract methods:
# generate_result_code (for no. 2)
#
# 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.
#
# calculate_result_code
# Return a C code fragment representing the result of this node.
# This is only called if the result is not in a temporary.
#
is_sequence_constructor = 0
is_attribute = 0
saved_subexpr_nodes = None
is_temp = 0
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_inplace_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(self):
# Return a C code fragment for the result of this node.
if self.is_temp:
result_code = self.result_code
else:
result_code = self.calculate_result_code()
return result_code
def result_as(self, type = None):
# Return the result code cast to the specified C type.
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.
return self.result_ctype or self.type
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.
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)
def analyse_target_expression(self, env, rhs):
# Convenience routine performing both the Type
# Analysis and Temp Allocation phases for the LHS of
# an assignment.
self.analyse_target_types(env)
self.allocate_target_temps(env, rhs)
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_function(self, env):
# Analyse types for an expression that is to be called.
self.analyse_types(env)
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_as_cimported_attribute(self, env, *args, **kwds):
# If this node can be interpreted as a cimported name,
# finish type analysis and return true, else return false.
return 0
def analyse_types(self, env):
self.not_implemented("analyse_types")
def analyse_target_types(self, env):
self.analyse_types(env)
def analyse_inplace_types(self, env):
if self.is_inplace_lvalue():
self.analyse_types(env)
else:
error(self.pos, "Invalid target for in-place operation")
self.type = error_type
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()
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")
def gil_check(self, env):
if env.nogil and self.type.is_pyobject:
self.gil_error()
# ----------------- 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 allocate_target_temps(self, env, rhs, inplace = 0):
# Perform temp allocation for the LHS of an assignment.
if debug_temp_alloc:
print self, "Allocating target temps"
self.allocate_subexpr_temps(env)
#self.result_code = self.target_code()
if rhs:
rhs.release_temp(env)
self.release_subexpr_temps(env)
def allocate_inplace_target_temps(self, env, rhs):
if debug_temp_alloc:
print self, "Allocating inplace target temps"
self.allocate_subexpr_temps(env)
#self.result_code = self.target_code()
py_inplace = self.type.is_pyobject
if py_inplace:
self.allocate_temp(env)
self.inplace_result = env.allocate_temp(py_object_type)
self.release_temp(env)
rhs.release_temp(env)
if py_inplace:
env.release_temp(self.inplace_result)
self.release_subexpr_temps(env)
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:
print self, "Allocating temps"
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:
print self, "Allocating temps for:", self.subexprs
for node in self.subexpr_nodes():
if node:
if debug_temp_alloc:
print self, "Allocating temps for", node
node.allocate_temps(env)
def allocate_temp(self, env, result = None):
# If this node requires a temporary variable for its
# result, allocate one. 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:
print self, "Allocating temp"
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:
print self, "Allocated result", self.result_code
#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")
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:
print self, "Releasing result", self.result_code
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 mark_vars_used(self):
for node in self.subexpr_nodes():
node.mark_vars_used()
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.py_result())
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)
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")
inplace_functions = {
"+=": "PyNumber_InPlaceAdd",
"-=": "PyNumber_InPlaceSubtract",
"*=": "PyNumber_InPlaceMultiply",
"/=": "PyNumber_InPlaceDivide",
"%=": "PyNumber_InPlaceRemainder",
"**=": "PyNumber_InPlacePower",
"<<=": "PyNumber_InPlaceLshift",
">>=": "PyNumber_InPlaceRshift",
"&=": "PyNumber_InPlaceAnd",
"^=": "PyNumber_InPlaceXor",
"|=": "PyNumber_InPlaceOr",
}
def generate_inplace_operation_code(self, operator, rhs, code):
args = (self.py_result(), rhs.py_result())
if operator == "**=":
arg_code = "%s, %s, Py_None" % args
else:
arg_code = "%s, %s" % args
code.putln("%s = %s(%s); if (!%s) %s" % (
self.inplace_result,
self.inplace_functions[operator],
arg_code,
self.inplace_result,
code.error_goto(self.pos)))
if self.is_temp:
code.put_decref_clear(self.py_result())
rhs.generate_disposal_code(code)
if self.type.is_extension_type:
code.putln(
"if (!__Pyx_TypeTest(%s, %s)) %s" % (
self.inplace_result,
self.type.typeptr_cname,
code.error_goto(self.pos)))
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.py_result(), 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())
else:
self.generate_subexpr_disposal_code(code)
def generate_inplace_result_disposal_code(self, code):
code.put_decref_clear(self.inplace_result, py_object_type)
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
# ----------------- 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):
if not isinstance(src, NoneNode):
src = PyTypeTestNode(src, dst_type, env)
elif src.type.is_pyobject:
src = CoerceFromPyTypeNode(dst_type, src, env)
else: # neither src nor dst are py types
if not dst_type.assignable_from(src_type):
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:
if not type.is_int and not type.is_error:
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.
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"
def compile_time_value(self, denv):
return None
class EllipsisNode(PyConstNode):
# '...' in a subscript list.
value = "Py_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
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
value = "NULL"
class CharNode(ConstNode):
type = PyrexTypes.c_char_type
def compile_time_value(self, denv):
return ord(self.value)
def calculate_result_code(self):
return "'%s'" % self.value
class IntNode(ConstNode):
type = PyrexTypes.c_long_type
def compile_time_value(self, denv):
return int(self.value, 0)
class FloatNode(ConstNode):
type = PyrexTypes.c_double_type
def compile_time_value(self, denv):
return float(self.value)
def calculate_result_code(self):
strval = str(self.value)
if strval == 'nan':
return "NAN"
elif strval == 'inf':
return "INFINITY"
elif strval == '-inf':
return "(-INFINITY)"
else:
return strval
class StringNode(ConstNode):
# #entry Symtab.Entry
type = PyrexTypes.c_char_ptr_type
def compile_time_value(self, denv):
return eval('"%s"' % self.value)
# def analyse_types(self, env):
# self.entry = env.add_string_const(self.value)
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 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 value 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, type = py_object_type, value = self.value)
def generate_evaluation_code(self, code):
if self.type.is_pyobject:
self.result_code = code.get_py_string_const(self.value)
else:
self.result_code = code.get_string_const(self.value)
def calculate_result_code(self):
return self.result_code
class LongNode(AtomicExprNode):
# Python long integer literal
#
# value string
def compile_time_value(self, denv):
return long(self.value)
gil_message = "Constructing Python long int"
def analyse_types(self, env):
self.type = py_object_type
self.gil_check(env)
self.is_temp = 1
def generate_evaluation_code(self, code):
result = self.result()
code.putln(
'%s = PyLong_FromString("%s", 0, 0); if (!%s) %s' % (
self.result(),
self.value,
self.result(),
code.error_goto(self.pos)))
class ImagNode(AtomicExprNode):
# Imaginary number literal
#
# value float imaginary part
def compile_time_value(self, denv):
return complex(0.0, self.value)
gil_message = "Constructing complex number"
def analyse_types(self, env):
self.type = py_object_type
self.gil_check(env)
self.is_temp = 1
def generate_evaluation_code(self, code):
result = self.result()
code.putln(
"%s = PyComplex_FromDoubles(0.0, %s); if (!%s) %s" % (
self.result(),
self.value,
self.result(),
code.error_goto(self.pos)))
class NameNode(AtomicExprNode):
# Reference to a local or global variable name.
#
# name string Python name of the variable
#
# entry Entry Symbol table entry
# type_entry Entry For extension type names, the original type entry
# interned_cname string
is_name = 1
entry = None
type_entry = None
def compile_time_value(self, denv):
try:
return denv.lookup(self.name)
except KeyError:
error(self.pos, "Compile-time name '%s' not defined" % self.name)
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
if entry.is_cfunction:
var_entry = entry.as_variable
if var_entry:
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)
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:
return entry.type
else:
return None
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)
def analyse_types(self, env):
self.lookup_entry(env)
self.analyse_rvalue_entry(env)
def lookup_entry(self, env):
self.entry = env.lookup(self.name)
if not self.entry:
self.entry = env.declare_builtin(self.name, self.pos)
def analyse_target_types(self, env):
self.analyse_entry(env)
self.finish_analysing_lvalue()
def analyse_inplace_types(self, env):
self.analyse_rvalue_entry(env)
self.finish_analysing_lvalue()
def finish_analysing_lvalue(self):
if self.entry.is_readonly:
error(self.pos, "Assignment to read-only name '%s'"
% self.name)
elif not self.is_lvalue():
error(self.pos, "Assignment to non-lvalue '%s'"
% self.name)
self.type = PyrexTypes.error_type
self.entry.used = 1
def analyse_as_function(self, env):
self.lookup_entry(env)
if self.entry.is_type:
self.analyse_constructor_entry(env)
else:
self.analyse_rvalue_entry(env)
def analyse_constructor_entry(self, env):
entry = self.entry
type = entry.type
if type.is_struct_or_union:
self.type = entry.type.cplus_constructor_type
elif type.is_pyobject:
self.analyse_rvalue_entry(env)
else:
error(self.pos, "Type '%s' not callable as a C++ constructor" % type)
self.type = error_type
def analyse_rvalue_entry(self, env):
#print "NameNode.analyse_rvalue_entry:", self.name ###
#print "Entry:", self.entry.__dict__ ###
self.analyse_entry(env)
entry = self.entry
if entry.is_declared_generic:
self.result_ctype = py_object_type
if entry.is_pyglobal or entry.is_builtin:
self.is_temp = 1
self.gil_check(env)
gil_message = "Accessing Python global or builtin"
def analyse_entry(self, env):
#print "NameNode.analyse_entry:", self.name ###
self.check_identifier_kind()
entry = self.entry
type = entry.type
ctype = entry.ctype
self.type = type
if ctype:
self.result_ctype = ctype
if entry.is_pyglobal or entry.is_builtin:
assert type.is_pyobject, "Python global or builtin not a Python object"
#self.interned_cname = env.intern(self.entry.name)
def check_identifier_kind(self):
# Check that this is an appropriate kind of name for use in an expression.
# Also finds the variable entry associated with an extension type.
entry = self.entry
if entry.is_type and entry.type.is_extension_type:
self.type_entry = entry
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
if not (entry.is_const or entry.is_cfunction):
self.not_const()
def check_const_addr(self):
entry = self.entry
if not (entry.is_cglobal or entry.is_cfunction):
self.addr_not_const()
def is_lvalue(self):
entry = self.entry
return entry.is_variable and \
not entry.type.is_array and \
not entry.is_readonly
def is_inplace_lvalue(self):
return self.is_lvalue()
def is_ephemeral(self):
# Name nodes are never ephemeral, even if the
# result is in a temporary.
return 0
def allocate_temp(self, env, result = None):
AtomicExprNode.allocate_temp(self, env, result)
entry = self.entry
if entry:
entry.used = 1
def calculate_result_code(self):
entry = self.entry
if not entry:
return "<error>" # There was an error earlier
return entry.cname
def generate_result_code(self, code):
assert hasattr(self, 'entry')
entry = self.entry
if entry is None:
return # There was an error earlier
if entry.utility_code:
code.use_utility_code(entry.utility_code)
if entry.is_pyglobal or entry.is_builtin:
if entry.is_builtin:
namespace = Naming.builtins_cname
else: # entry.is_pyglobal
namespace = entry.namespace_cname
result = self.result()
cname = code.intern(self.entry.name)
code.use_utility_code(get_name_interned_utility_code)
code.putln(
'%s = __Pyx_GetName(%s, %s); if (!%s) %s' % (
result,
namespace,
cname,
result,
code.error_goto(self.pos)))
def generate_setattr_code(self, value_code, code):
entry = self.entry
namespace = self.entry.namespace_cname
cname = code.intern(self.entry.name)
code.putln(
'if (PyObject_SetAttr(%s, %s, %s) < 0) %s' % (
namespace,
cname,
value_code,
code.error_goto(self.pos)))
def generate_assignment_code(self, rhs, code):
#print "NameNode.generate_assignment_code:", self.name ###
entry = self.entry
if entry is None:
return # There was an error earlier
if entry.is_pyglobal:
self.generate_setattr_code(rhs.py_result(), code)
if debug_disposal_code:
print "NameNode.generate_assignment_code:"
print "...generating disposal code for", rhs
rhs.generate_disposal_code(code)
else:
if self.type.is_pyobject:
rhs.make_owned_reference(code)
code.put_decref(self.py_result())
code.putln('%s = %s;' % (self.result(), rhs.result_as(self.ctype())))
if debug_disposal_code:
print "NameNode.generate_assignment_code:"
print "...generating post-assignment code for", rhs
rhs.generate_post_assignment_code(code)
def generate_inplace_assignment_code(self, operator, rhs, code):
entry = self.entry
if entry is None:
return # There was an error earlier
if self.type.is_pyobject:
self.generate_result_code(code)
self.generate_inplace_operation_code(operator, rhs, code)
if entry.is_pyglobal:
self.generate_setattr_code(self.inplace_result, code)
self.generate_inplace_result_disposal_code(code)
else:
code.put_decref(self.py_result())
cast_inplace_result = typecast(self.ctype(), py_object_type, self.inplace_result)
code.putln('%s = %s;' % (self.result(), cast_inplace_result))
else:
code.putln("%s %s %s;" % (self.result(), operator, rhs.result()))
rhs.generate_disposal_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
cname = code.intern(self.entry.name)
code.putln(
'if (PyObject_DelAttr(%s, %s) < 0) %s' % (
Naming.module_cname,
cname,
code.error_goto(self.pos)))
def mark_vars_used(self):
if self.entry:
self.entry.used = 1
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
self.gil_check(env)
self.is_temp = 1
gil_message = "Backquote expression"
def generate_result_code(self, code):
result = self.result()
code.putln(
"%s = PyObject_Repr(%s); if (!%s) %s" % (
self.result(),
self.arg.py_result(),
self.result(),
code.error_goto(self.pos)))
class ImportNode(ExprNode):
# Used as part of import statement implementation.
# Implements result =
# __import__(module_name, globals(), None, name_list)
#
# module_name StringNode dotted name of module
# name_list ListNode or None list of names to be imported
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
self.gil_check(env)
self.is_temp = 1
# env.use_utility_code(import_utility_code)
gil_message = "Python import"
def generate_result_code(self, code):
if self.name_list:
name_list_code = self.name_list.py_result()
else:
name_list_code = "0"
code.use_utility_code(import_utility_code)
result = self.result()
code.putln(
"%s = __Pyx_Import(%s, %s); if (!%s) %s" % (
result,
self.module_name.py_result(),
name_list_code,
result,
code.error_goto(self.pos)))
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
self.gil_check(env)
self.is_temp = 1
gil_message = "Iterating over Python object"
def generate_result_code(self, code):
result = self.result()
code.putln(
"%s = PyObject_GetIter(%s); if (!%s) %s" % (
result,
self.sequence.py_result(),
result,
code.error_goto(self.pos)))
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):
result = self.result()
code.putln(
"%s = PyIter_Next(%s);" % (
result,
self.iterator.py_result()))
code.putln(
"if (!%s) {" %
result)
code.putln(
"if (PyErr_Occurred()) %s" %
code.error_goto(self.pos))
code.putln(
"break;")
code.putln(
"}")
class ExcValueNode(AtomicExprNode):
# Node created during analyse_types phase
# of an ExceptClauseNode to fetch the current
# exception or traceback value.
def __init__(self, pos, env, var):
ExprNode.__init__(self, pos)
self.type = py_object_type
self.var = var
def calculate_result_code(self):
return self.var
def generate_result_code(self, code):
pass
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
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
subexprs = ['base', 'index']
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)
def is_ephemeral(self):
return self.base.is_ephemeral()
def analyse_target_declaration(self, env):
pass
def analyse_types(self, env):
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_inplace_types(self, env):
self.analyse_base_and_index_types(env, getting = 1, setting = 1)
def analyse_base_and_index_types(self, env, getting = 0, setting = 0):
self.base.analyse_types(env)
self.index.analyse_types(env)
btype = self.base.type
if btype.is_pyobject:
itype = self.index.type
if not (btype.is_sequence and itype.is_int and itype.signed):
self.index = self.index.coerce_to_pyobject(env)
self.type = py_object_type
self.gil_check(env)
self.is_temp = 1
else:
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)
gil_message = "Indexing Python object"
def check_const_addr(self):
self.base.check_const_addr()
self.index.check_const()
def is_lvalue(self):
return 1
def is_inplace_lvalue(self):
return 1
def calculate_result_code(self):
return "(%s[%s])" % (
self.base.result(), self.index.result())
def generate_result_code(self, code):
if self.type.is_pyobject:
itype = self.index.type
if itype.is_int and itype.signed:
code.use_utility_code(getitem_int_utility_code)
function = "__Pyx_GetItemInt"
index_code = self.index.result()
else:
function = "PyObject_GetItem"
index_code = self.index.py_result()
result = self.result()
code.putln(
"%s = %s(%s, %s); if (!%s) %s" % (
result,
function,
self.base.py_result(),
index_code,
result,
code.error_goto(self.pos)))
def generate_setitem_code(self, value_code, code):
itype = self.index.type
if itype.is_int and itype.signed:
code.use_utility_code(setitem_int_utility_code)
function = "__Pyx_SetItemInt"
index_code = self.index.result()
else:
function = "PyObject_SetItem"
index_code = self.index.py_result()
code.putln(
"if (%s(%s, %s, %s) < 0) %s" % (
function,
self.base.py_result(),
index_code,
value_code,
code.error_goto(self.pos)))
def generate_assignment_code(self, rhs, code):
self.generate_subexpr_evaluation_code(code)
if self.type.is_pyobject:
self.generate_setitem_code(rhs.py_result(), code)
else:
code.putln(
"%s = %s;" % (
self.result(), rhs.result()))
self.generate_subexpr_disposal_code(code)
rhs.generate_disposal_code(code)
def generate_inplace_assignment_code(self, operator, rhs, code):
self.generate_subexpr_evaluation_code(code)
if self.type.is_pyobject:
self.generate_result_code(code)
self.generate_inplace_operation_code(operator, rhs, code)
self.generate_setitem_code(self.inplace_result, code)
self.generate_inplace_result_disposal_code(code)
else:
code.putln("%s %s %s;" % (self.result(), operator, rhs.result()))
rhs.generate_disposal_code(code)
self.generate_subexpr_disposal_code(code)
def generate_deletion_code(self, code):
self.generate_subexpr_evaluation_code(code)
if self.base.type.is_sequence and self.index.type.is_int:
function = "PySequence_DelItem"
index_code = self.index.result()
else:
function = "PyObject_DelItem"
index_code = self.index.py_result()
code.putln(
"if (%s(%s, %s) < 0) %s" % (
function,
self.base.py_result(),
index_code,
code.error_goto(self.pos)))
#else:
# error(self.pos, "Cannot delete non-Python variable")
self.generate_subexpr_disposal_code(code)
class SliceIndexNode(ExprNode):
# 2-element slice indexing
#
# base ExprNode
# start ExprNode or None
# stop ExprNode or None
subexprs = ['base', 'start', 'stop']
def is_inplace_lvalue(self):
return 1
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)
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)
c_int = PyrexTypes.c_py_ssize_t_type
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
self.gil_check(env)
self.is_temp = 1
gil_message = "Slicing Python object"
def generate_result_code(self, code):
result = self.result()
code.putln(
"%s = PySequence_GetSlice(%s, %s, %s); if (!%s) %s" % (
result,
self.base.py_result(),
self.start_code(),
self.stop_code(),
result,
code.error_goto(self.pos)))
def generate_setslice_code(self, value_code, code):
code.putln(
"if (PySequence_SetSlice(%s, %s, %s, %s) < 0) %s" % (
self.base.py_result(),
self.start_code(),
self.stop_code(),
value_code,
code.error_goto(self.pos)))
def generate_assignment_code(self, rhs, code):
self.generate_subexpr_evaluation_code(code)
self.generate_setslice_code(rhs.result(), code)
self.generate_subexpr_disposal_code(code)
rhs.generate_disposal_code(code)
def generate_inplace_assignment_code(self, operator, rhs, code):
self.generate_subexpr_evaluation_code(code)
self.generate_result_code(code)
self.generate_inplace_operation_code(operator, rhs, code)
self.generate_setslice_code(self.inplace_result, code)
self.generate_inplace_result_disposal_code(code)
self.generate_subexpr_disposal_code(code)
def generate_deletion_code(self, code):
self.generate_subexpr_evaluation_code(code)
code.putln(
"if (PySequence_DelSlice(%s, %s, %s) < 0) %s" % (
self.base.py_result(),
self.start_code(),
self.stop_code(),
code.error_goto(self.pos)))
self.generate_subexpr_disposal_code(code)
def start_code(self):
if self.start:
return self.start.result()
else:
return "0"
def stop_code(self):
if self.stop:
return self.stop.result()
else:
return "PY_SSIZE_T_MAX"
# 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
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)
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
self.gil_check(env)
self.is_temp = 1
gil_message = "Constructing Python slice object"
def generate_result_code(self, code):
result = self.result()
code.putln(
"%s = PySlice_New(%s, %s, %s); if (!%s) %s" % (
result,
self.start.py_result(),
self.stop.py_result(),
self.step.py_result(),
result,
code.error_goto(self.pos)))
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):
# 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
# function_type PyrexType used internally
subexprs = ['self', 'coerced_self', 'function', 'args', 'arg_tuple']
self = None
coerced_self = None
arg_tuple = None
is_new = False
cplus_argless_constr_type = CFuncType(None, [])
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)
def analyse_types(self, env):
#print "SimpleCallNode.analyse_types:", self.pos ###
function = self.function
function.is_called = 1
function.analyse_as_function(env)
if function.is_name or function.is_attribute:
#print "SimpleCallNode.analyse_types:", self.pos, "is name or attribute" ###
func_entry = function.entry
if func_entry:
if func_entry.is_cmethod or func_entry.is_builtin_method:
# Take ownership of the object from which the attribute
# was obtained, because we need to pass it as 'self'.
#print "SimpleCallNode: Snarfing self argument" ###
self.self = function.obj
function.obj = CloneNode(self.self)
elif self.is_new:
if not (func_entry.is_type and func_entry.type.is_struct_or_union
and func_entry.type.scope.is_cplus):
error(self.pos, "'new' operator can only be used on a C++ struct type")
self.type = error_type
return
else:
#print "SimpleCallNode.analyse_types:", self.pos, "not name or attribute" ###
if self.is_new:
error(self.pos, "Invalid use of 'new' operator")
self.type = error_type
return
func_type = self.function.type
if func_type.is_ptr:
func_type = func_type.base_type
self.function_type = func_type
if func_type.is_pyobject:
#print "SimpleCallNode: Python call" ###
if self.args:
self.arg_tuple = TupleNode(self.pos, args = self.args)
self.arg_tuple.analyse_types(env)
else:
self.arg_tuple = None
self.args = None
if function.is_name and function.type_entry:
# We are calling an extension type constructor
self.type = function.type_entry.type
self.result_ctype = py_object_type
else:
self.type = py_object_type
self.gil_check(env)
self.is_temp = 1
else:
#print "SimpleCallNode: C call" ###
for arg in self.args:
arg.analyse_types(env)
if func_type.is_cfunction:
self.type = func_type.return_type
if self.is_new:
self.type = CPtrType(self.type)
if func_type.is_overloaded:
func_type = self.resolve_overloading()
if not func_type:
self.type = error_type
return
if self.self and func_type.args:
#print "SimpleCallNode: Inserting self into argument list" ###
# 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 resolve_overloading(self):
func_type = self.function_type
arg_types = [arg.type for arg in self.args]
signatures = func_type.signatures or [self.cplus_argless_constr_type]
for signature in signatures:
if signature.callable_with(arg_types):
signature.return_type = func_type.return_type
self.function_type = signature
return signature
def display_types(types):
return ", ".join([str(type) for type in types])
error(self.pos, "No matching signature found for argument types (%s)"
% display_types(arg_types))
if signatures:
error(self.pos, "Candidates are:")
for signature in signatures:
error(signature.pos, "(%s)" % display_types(signature.args))
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
return
# Check no. of args
expected_nargs = len(func_type.args)
actual_nargs = len(self.args)
if actual_nargs < expected_nargs \
or (not func_type.has_varargs and actual_nargs > expected_nargs):
expected_str = str(expected_nargs)
if func_type.has_varargs:
expected_str = "at least " + expected_str
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
return
# Coerce arguments
for i in range(expected_nargs):
formal_type = func_type.args[i].type
self.args[i] = self.args[i].coerce_to(formal_type, env)
for i in range(expected_nargs, actual_nargs):
if self.args[i].type.is_pyobject:
error(self.args[i].pos,
"Python object cannot be passed as a varargs parameter")
# Calc result code fragment
#print "SimpleCallNode.analyse_c_function_call: self.type =", self.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
# Check gil
if not func_type.nogil:
self.gil_check(env)
if func_type.exception_check and env.nogil:
self.gil_error("Calling 'except ?' or 'except *' function")
def calculate_result_code(self):
return self.c_call_code()
def c_call_code(self):
if self.type.is_error or self.args is None or not self.function_type.is_cfunction:
return "<error>"
func_type = self.function_type
formal_args = func_type.args
arg_list_code = []
for (formal_arg, actual_arg) in zip(formal_args, self.args):
arg_code = actual_arg.result_as(formal_arg.type)
arg_list_code.append(arg_code)
for actual_arg in self.args[len(formal_args):]:
arg_list_code.append(actual_arg.result())
result = "%s(%s)" % (self.function.result(),
join(arg_list_code, ","))
if self.is_new:
result = "new " + result
return result
def generate_result_code(self, code):
if self.type.is_error:
return
func_type = self.function_type
result = self.result()
if func_type.is_pyobject:
if self.arg_tuple:
arg_code = self.arg_tuple.py_result()
else:
arg_code = "0"
code.putln(
"%s = PyObject_CallObject(%s, %s); if (!%s) %s" % (
result,
self.function.py_result(),
arg_code,
result,
code.error_goto(self.pos)))
elif func_type.is_cfunction:
exc_checks = []
if self.type.is_pyobject:
exc_checks.append("!%s" % result)
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(), exc_val))
if exc_check:
exc_checks.append("PyErr_Occurred()")
if self.is_temp or exc_checks:
rhs = self.c_call_code()
result = self.result()
if result:
lhs = "%s = " % result
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 = ""
code.putln(
"%s%s; if (%s) %s" % (
lhs,
rhs,
" && ".join(exc_checks),
code.error_goto(self.pos)))
class GeneralCallNode(CallNode):
# 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']
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)
def analyse_types(self, env):
function = self.function
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)
if function.is_name and function.type_entry:
# We are calling an extension type constructor
self.type = function.type_entry.type
self.result_ctype = py_object_type
else:
self.type = py_object_type
self.gil_check(env)
self.is_temp = 1
def generate_result_code(self, code):
if self.keyword_args and self.starstar_arg:
code.putln(
"if (PyDict_Update(%s, %s) < 0) %s" % (
self.keyword_args.py_result(),
self.starstar_arg.py_result(),
code.error_goto(self.pos)))
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:
call_code = "PyObject_CallObject(%s, %s)" % (
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)
result = self.result()
code.putln(
"%s = %s; if (!%s) %s" % (
result,
call_code,
result,
code.error_goto(self.pos)))
class AsTupleNode(ExprNode):
# Convert argument to tuple. Used for normalising
# the * argument of a function call.
#
# arg ExprNode
subexprs = ['arg']
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)
def analyse_types(self, env):
self.arg.analyse_types(env)
self.arg = self.arg.coerce_to_pyobject(env)
self.type = py_object_type
self.gil_check(env)
self.is_temp = 1
gil_message = "Constructing Python tuple"
def generate_result_code(self, code):
result = self.result()
code.putln(
"%s = PySequence_Tuple(%s); if (!%s) %s" % (
result,
self.arg.py_result(),
result,
code.error_goto(self.pos)))
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
# interned_attr_cname string C name of interned attribute name
is_attribute = 1
subexprs = ['obj']
type = PyrexTypes.error_type
result_code = "<error>"
entry = None
is_called = 0
def compile_time_value(self, denv):
attr = self.attribute
if attr.startswith("__") and attr.endswith("__"):
self.error("Invalid attribute name '%s' in compile-time expression"
% attr)
return None
obj = self.obj.compile_time_value(denv)
try:
return getattr(obj, attr)
except Exception, e:
self.compile_time_value_error(e)
def analyse_target_declaration(self, env):
pass
def analyse_target_types(self, env):
self.analyse_types(env, target = 1)
def analyse_as_function(self, env):
module_scope = self.obj.analyse_as_module(env)
if module_scope:
entry = module_scope.lookup_here(self.attribute)
if entry and entry.is_type:
self.mutate_into_name_node(entry)
self.analyse_constructor_entry(env)
return
self.analyse_types(env)
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 = 0, allow_type = 0):
# 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(entry)
if entry.is_type and allow_type:
pass
elif target:
self.analyse_target_types(env)
else:
self.analyse_rvalue_entry(env)
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
self.mutate_into_name_node(ubcm_entry)
self.analyse_rvalue_entry(env)
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, entry):
# Turn this node into a NameNode with the given entry.
self.__class__ = NameNode
self.name = self.attribute
self.entry = entry
del self.obj
del self.attribute
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:
error(self.pos, "C method can only be called")
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
if obj_type.is_ptr:
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)
else:
error(self.pos,
"Cannot select attribute of incomplete type '%s'"
% obj_type)
obj_type = PyrexTypes.error_type
self.entry = entry
if entry:
if obj_type.is_extension_type and entry.name == "__weakref__":
error(self.pos, "Illegal use of special attribute __weakref__")
if entry.is_variable or entry.is_cmethod:
self.type = entry.type
self.member = entry.cname
return
if entry.is_builtin_method and self.is_called:
# Mutate into NameNode referring to C function
#print "AttributeNode: Mutating builtin method into NameNode" ###
self.type = entry.type
self.__class__ = NameNode
return
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.
if obj_type.is_pyobject:
self.type = py_object_type
self.is_py_attr = 1
#self.interned_attr_cname = env.intern(self.attribute)
self.gil_check(env)
else:
if not obj_type.is_error:
error(self.pos,
"Object of type '%s' has no attribute '%s'" %
(obj_type, self.attribute))
gil_message = "Accessing Python attribute"
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_inplace_lvalue(self):
return self.is_lvalue()
def is_ephemeral(self):
if self.obj:
return self.obj.is_ephemeral()
else:
return NameNode.is_ephemeral(self)
def calculate_result_code(self):
obj = self.obj
obj_code = obj.result_as(obj.type)
if self.entry and self.entry.is_cmethod:
return "((struct %s *)%s%s%s)->%s" % (
obj.type.vtabstruct_cname, obj_code, self.op,
obj.type.vtabslot_cname, self.member)
else:
return "%s%s%s" % (obj_code, self.op, self.member)
def generate_result_code(self, code):
if self.is_py_attr:
result = self.result()
cname = code.intern(self.attribute)
code.putln(
'%s = PyObject_GetAttr(%s, %s); if (!%s) %s' % (
result,
self.obj.py_result(),
cname,
result,
code.error_goto(self.pos)))
def generate_setattr_code(self, value_code, code):
cname = code.intern(self.attribute)
code.putln(
'if (PyObject_SetAttr(%s, %s, %s) < 0) %s' % (
self.obj.py_result(),
cname,
value_code,
code.error_goto(self.pos)))
def generate_assignment_code(self, rhs, code):
self.obj.generate_evaluation_code(code)
if self.is_py_attr:
self.generate_setattr_code(rhs.py_result(), code)
rhs.generate_disposal_code(code)
else:
select_code = self.result()
if self.type.is_pyobject:
rhs.make_owned_reference(code)
code.put_decref(select_code, self.ctype())
code.putln(
"%s = %s;" % (
select_code,
rhs.result_as(self.ctype())))
rhs.generate_post_assignment_code(code)
self.obj.generate_disposal_code(code)
def generate_inplace_assignment_code(self, operator, rhs, code):
self.obj.generate_evaluation_code(code)
select_code = self.result()
if self.type.is_pyobject:
self.generate_result_code(code)
self.generate_inplace_operation_code(operator, rhs, code)
if self.is_py_attr:
self.generate_setattr_code(self.inplace_result, code)
self.generate_inplace_result_disposal_code(code)
else:
code.put_decref(select_code, self.ctype())
cast_inplace_result = typecast(self.ctype(), py_object_type, self.inplace_result)
code.putln("%s = %s;" % (select_code, cast_inplace_result))
else:
code.putln("%s %s %s;" % (select_code, operator, rhs.result()))
rhs.generate_disposal_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:
cname = code.intern(self.attribute)
code.putln(
'if (PyObject_DelAttr(%s, %s) < 0) %s' % (
self.obj.py_result(),
cname,
code.error_goto(self.pos)))
else:
error(self.pos, "Cannot delete C attribute of extension type")
self.obj.generate_disposal_code(code)
#-------------------------------------------------------------------
#
# Constructor nodes
#
#-------------------------------------------------------------------
class SequenceNode(ExprNode):
# Base class for list and tuple constructor nodes.
# Contains common code for performing sequence unpacking.
#
# args [ExprNode]
# iterator ExprNode
# unpacked_items [ExprNode] or None
# coerced_unpacked_items [ExprNode] or None
subexprs = ['args']
is_sequence_constructor = 1
unpacked_items = None
def compile_time_value_list(self, denv):
return [arg.compile_time_value(denv) for arg in self.args]
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
self.gil_check(env)
self.is_temp = 1
def analyse_target_types(self, env):
self.iterator = PyTempNode(self.pos, env)
self.unpacked_items = []
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)
def allocate_target_temps(self, env, rhs):
self.iterator.allocate_temps(env)
if rhs:
rhs.release_temp(env)
for arg, node in zip(self.args, self.coerced_unpacked_items):
node.allocate_temps(env)
arg.allocate_target_temps(env, node)
#arg.release_target_temp(env)
#node.release_temp(env)
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)
def generate_result_code(self, code):
self.generate_operation_code(code)
def generate_assignment_code(self, rhs, code):
iter_result = self.iterator.result()
code.putln(
"%s = PyObject_GetIter(%s); if (!%s) %s" % (
iter_result,
rhs.py_result(),
iter_result,
code.error_goto(self.pos)))
rhs.generate_disposal_code(code)
for i in range(len(self.args)):
item = self.unpacked_items[i]
code.use_utility_code(unpacking_utility_code)
unpack_code = "__Pyx_UnpackItem(%s)" % (
self.iterator.py_result())
item_result = item.result()
code.putln(
"%s = %s; if (!%s) %s" % (
item_result,
typecast(item.ctype(), py_object_type, unpack_code),
item_result,
code.error_goto(self.pos)))
value_node = self.coerced_unpacked_items[i]
value_node.generate_evaluation_code(code)
self.args[i].generate_assignment_code(value_node, code)
code.putln(
"if (__Pyx_EndUnpack(%s) < 0) %s" % (
self.iterator.py_result(),
code.error_goto(self.pos)))
if debug_disposal_code:
print "UnpackNode.generate_assignment_code:"
print "...generating disposal code for", rhs
self.iterator.generate_disposal_code(code)
class TupleNode(SequenceNode):
# Tuple constructor.
gil_message = "Constructing Python tuple"
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)
def generate_operation_code(self, code):
result = self.result()
code.putln(
"%s = PyTuple_New(%s); if (!%s) %s" % (
result,
len(self.args),
result,
code.error_goto(self.pos)))
for i in range(len(self.args)):
arg = self.args[i]
arg_result = arg.py_result()
# ??? Change this to use make_owned_reference?
if not arg.result_in_temp():
code.put_incref(arg_result)
code.putln(
"PyTuple_SET_ITEM(%s, %s, %s);" % (
result,
i,
arg_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:
arg.generate_post_assignment_code(code)
class ListNode(SequenceNode):
# List constructor.
gil_message = "Constructing Python list"
def compile_time_value(self, denv):
return self.compile_time_value_list(denv)
def generate_operation_code(self, code):
result = self.result()
code.putln("%s = PyList_New(%s); if (!%s) %s" %
(result,
len(self.args),
result,
code.error_goto(self.pos)))
for i in range(len(self.args)):
arg = self.args[i]
arg_result = arg.py_result()
#if not arg.is_temp:
if not arg.result_in_temp():
code.put_incref(arg_result)
code.putln("PyList_SET_ITEM(%s, %s, %s);" %
(result,
i,
arg_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)
class DictNode(ExprNode):
# Dictionary constructor.
#
# key_value_pairs [(ExprNode, ExprNode)]
def compile_time_value(self, denv):
pairs = [(key.compile_time_value(denv), value.compile_time_value(denv))
for (key, value) in self.key_value_pairs]
try:
return dict(pairs)
except Exception, e:
self.compile_time_value_error(e)
def analyse_types(self, env):
new_pairs = []
for key, value in self.key_value_pairs:
key.analyse_types(env)
value.analyse_types(env)
key = key.coerce_to_pyobject(env)
value = value.coerce_to_pyobject(env)
new_pairs.append((key, value))
self.key_value_pairs = new_pairs
self.type = py_object_type
self.gil_check(env)
self.is_temp = 1
gil_message = "Constructing Python dict"
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)
for key, value in self.key_value_pairs:
key.allocate_temps(env)
value.allocate_temps(env)
key.release_temp(env)
value.release_temp(env)
def generate_evaluation_code(self, code):
# Custom method used here because key-value
# pairs are evaluated and used one at a time.
result = self.result()
code.putln(
"%s = PyDict_New(); if (!%s) %s" % (
result,
result,
code.error_goto(self.pos)))
for key, value in self.key_value_pairs:
key.generate_evaluation_code(code)
value.generate_evaluation_code(code)
code.putln(
"if (PyDict_SetItem(%s, %s, %s) < 0) %s" % (
result,
key.py_result(),
value.py_result(),
code.error_goto(self.pos)))
key.generate_disposal_code(code)
value.generate_disposal_code(code)
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.
#
# name ExprNode Name of the class
# 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
subexprs = ['name', 'bases', 'doc']
def analyse_types(self, env):
self.name.analyse_types(env)
self.name = self.name.coerce_to_pyobject(env)
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
self.gil_check(env)
self.is_temp = 1
# env.use_utility_code(create_class_utility_code)
gil_message = "Constructing Python class"
def generate_result_code(self, code):
result = self.result()
if self.doc:
code.putln(
'if (PyDict_SetItemString(%s, "__doc__", %s) < 0) %s' % (
self.dict.py_result(),
self.doc.py_result(),
code.error_goto(self.pos)))
code.use_utility_code(create_class_utility_code)
code.putln(
'%s = __Pyx_CreateClass(%s, %s, %s, "%s"); if (!%s) %s' % (
result,
self.bases.py_result(),
self.dict.py_result(),
self.name.py_result(),
self.module_name,
result,
code.error_goto(self.pos)))
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
self.gil_check(env)
self.is_temp = 1
gil_message = "Constructing an unbound method"
def generate_result_code(self, code):
result = self.result()
code.putln(
"%s = PyMethod_New(%s, 0, %s); if (!%s) %s" % (
result,
self.function.py_result(),
self.class_cname,
result,
code.error_goto(self.pos)))
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
# module_name string Name of defining module
def analyse_types(self, env):
self.type = py_object_type
self.module_name = env.global_scope().module_name
self.gil_check(env)
self.is_temp = 1
gil_message = "Constructing Python function"
def generate_result_code(self, code):
result = self.result()
code.putln(
"%s = PyCFunction_NewEx(&%s, 0, %s); if (!%s) %s" % (
result,
self.pymethdef_cname,
code.get_py_string_const(self.module_name),
result,
code.error_goto(self.pos)))
#-------------------------------------------------------------------
#
# Unary operator nodes
#
#-------------------------------------------------------------------
compile_time_unary_operators = {
'not': operator.not_,
'~': operator.inv,
'-': operator.neg,
'+': operator.pos,
}
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']
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)
def analyse_types(self, env):
self.operand.analyse_types(env)
if self.is_py_operation():
self.coerce_operand_to_pyobject(env)
self.type = py_object_type
self.gil_check(env)
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()
result = self.result()
code.putln(
"%s = %s(%s); if (!%s) %s" % (
result,
function,
self.operand.py_result(),
result,
code.error_goto(self.pos)))
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
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)
subexprs = ['operand']
def analyse_types(self, env):
self.operand.analyse_types(env)
self.operand = self.operand.coerce_to_boolean(env)
self.type = PyrexTypes.c_int_type
def calculate_result_code(self):
return "(!%s)" % self.operand.result()
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()
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()
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()
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()
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.
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)
if self.type.is_cfunction:
error(self.pos,
"Cannot cast to a function type")
self.type = PyrexTypes.error_type
self.operand.analyse_types(env)
to_py = self.type.is_pyobject
from_py = self.operand.type.is_pyobject
if from_py and not to_py and self.operand.is_ephemeral():
error(self.pos, "Casting temporary Python object to non-Python type")
# Must do the following, so that the result can be increfed without
# the operand getting evaluated twice.
if to_py and not from_py:
#self.result_ctype = py_object_type
#self.is_temp = 1
self.operand = self.operand.coerce_to_simple(env)
def check_const(self):
self.operand.check_const()
def calculate_result_code(self):
opnd = self.operand
result_code = self.type.cast_code(opnd.result())
return result_code
def result_as(self, type):
if not self.is_temp and type.is_pyobject and self.type.is_pyobject:
# 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 = %s;" % (
self.result(),
self.operand.py_result()))
code.put_incref(self.py_result())
class SizeofNode(ExprNode):
# Base class for sizeof(x) expression nodes.
#
# sizeof_code string
subexprs = []
def check_const(self):
pass
def analyse_types(self, env):
self.analyse_argument(env)
self.type = PyrexTypes.c_size_t_type
def analyse_type_argument(self, arg_type):
if arg_type.is_pyobject:
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)
arg_code = arg_type.declaration_code("")
self.sizeof_code = "(sizeof(%s))" % arg_code
def calculate_result_code(self):
return self.sizeof_code
def generate_result_code(self, code):
pass
class SizeofTypeNode(SizeofNode):
# C sizeof function applied to a type
#
# base_type CBaseTypeNode
# declarator CDeclaratorNode
def analyse_argument(self, env):
base_type = self.base_type.analyse(env)
_, arg_type = self.declarator.analyse(base_type, env)
self.analyse_type_argument(arg_type)
class SizeofVarNode(SizeofNode):
# C sizeof function applied to a variable or qualified name
# (which may actually refer to a type)
#
# operand ExprNode
#subexprs = ['operand']
def analyse_argument(self, env):
is_type = 0
operand = self.operand
if operand.analyse_as_cimported_attribute(env, allow_type = 1):
if operand.entry.is_type:
is_type = 1
self.analyse_type_argument(operand.entry.type)
else:
self.operand.analyse_types(env)
self.operand.mark_vars_used()
if not is_type:
self.sizeof_code = "(sizeof(%s))" % operand.result()
#-------------------------------------------------------------------
#
# Binary operator nodes
#
#-------------------------------------------------------------------
compile_time_binary_operators = {
'<': operator.lt,
'<=': operator.le,
'==': operator.eq,
'!=': 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,
'in': lambda x, y: x in y,
'not_in': lambda x, y: x not in y,
}
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"
% node.operator)
return func
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']
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)
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
self.gil_check(env)
self.is_temp = 1
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 = ""
result = self.result()
code.putln(
"%s = %s(%s, %s%s); if (!%s) %s" % (
result,
function,
self.operand1.py_result(),
self.operand2.py_result(),
extra_args,
result,
code.error_goto(self.pos)))
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
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
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):
#print "NumBinopNode.c_types_okay:", type1, type2 ###
return (type1.is_numeric or type1.is_enum) \
and (type2.is_numeric or type2.is_enum)
def calculate_result_code(self):
return "(%s %s %s)" % (
self.operand1.result(),
self.operator,
self.operand2.result())
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",
"%": "PyNumber_Remainder",
"**": "PyNumber_Power"
}
class IntBinopNode(NumBinopNode):
# Binary operation taking integer arguments.
def c_types_okay(self, type1, type2):
#print "IntBinopNode.c_types_okay:", type1, type2 ###
return (type1.is_int or type1.is_enum) \
and (type2.is_int or type2.is_enum)
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):
#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):
return type1
elif (type2.is_ptr or type2.is_array) and (type1.is_int or type1.is_enum):
return type2
else:
return NumBinopNode.compute_c_result_type(
self, type1, type2)
class SubNode(NumBinopNode):
# '-' operator.
def compute_c_result_type(self, type1, type2):
if (type1.is_ptr or type1.is_array) and (type2.is_int or type2.is_enum):
return type1
elif (type1.is_ptr or type1.is_array) and (type2.is_ptr or type2.is_array):
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)
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.
def analyse_types(self, env):
env.pow_function_used = 1
NumBinopNode.analyse_types(self, env)
def compute_c_result_type(self, type1, type2):
if self.c_types_okay(type1, type2):
return PyrexTypes.c_double_type
else:
return None
def calculate_result_code(self):
return "pow(%s, %s)" % (
self.operand1.result(), self.operand2.result())
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']
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)
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)
self.temp_bool = TempNode(self.pos,
PyrexTypes.c_int_type, env)
self.type = py_object_type
self.gil_check(env)
else:
self.operand1 = self.operand1.coerce_to_boolean(env)
self.operand2 = self.operand2.coerce_to_boolean(env)
self.type = PyrexTypes.c_int_type
# 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
gil_message = "Truth-testing Python object"
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(),
self.py_to_c_op[self.operator],
self.operand2.result())
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.putln(
"%s = PyObject_IsTrue(%s); if (%s < 0) %s" % (
test_result,
self.operand1.py_result(),
test_result,
code.error_goto(self.pos)))
else:
test_result = self.operand1.result()
return test_result
class CmpNode:
# Mixin class containing code common to PrimaryCmpNodes
# and CascadedCmpNodes.
def cascaded_compile_time_value(self, operand1, denv):
func = get_compile_time_binop(self)
operand2 = self.operand2.compile_time_value(denv)
try:
result = func(operand1, operand2)
except Exception, e:
self.compile_time_value_error(e)
result = None
if result:
cascade = self.cascade
if cascade:
result = result and cascade.compile_time_value(operand2, denv)
return result
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'))
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
elif type1.is_ptr or type1.is_array:
return type1.is_null_ptr or type2.is_null_ptr \
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 (type2.is_int or type1.same_as(type2))
or type1.is_int and type2.is_enum)
and op not in ('is', 'is_not')):
return 1
else:
return 0
def generate_operation_code(self, code, result,
operand1, op , operand2):
if op == 'in' or op == 'not_in':
code.putln(
"%s = PySequence_Contains(%s, %s); if (%s < 0) %s" % (
result,
operand2.py_result(),
operand1.py_result(),
result,
code.error_goto(self.pos)))
if op == 'not_in':
code.putln(
"%s = !%s;" % (
result, result))
elif (operand1.type.is_pyobject
and op not in ('is', 'is_not')):
code.putln(
"if (PyObject_Cmp(%s, %s, &%s) < 0) %s" % (
operand1.py_result(),
operand2.py_result(),
result,
code.error_goto(self.pos)))
code.putln(
"%s = %s %s 0;" % (
result, result, op))
else:
type1 = operand1.type
type2 = operand2.type
if (type1.is_extension_type or type2.is_extension_type) \
and not operand1.ctype().same_as(operand2.ctype()):
code1 = operand1.result_as(py_object_type)
code2 = operand2.result_as(py_object_type)
else:
code1 = operand1.result()
code2 = operand2.result()
code.putln("%s = %s %s %s;" % (
result,
code1,
self.c_operator(op),
code2))
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.
cascade = None
def compile_time_value(self, denv):
operand1 = self.operand1.compile_time_value(denv)
return self.cascaded_compile_time_value(operand1, denv)
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)
if self.cascade:
self.operand2 = self.operand2.coerce_to_simple(env)
self.cascade.coerce_cascaded_operands_to_temp(env)
self.check_operand_types(env)
self.type = PyrexTypes.c_int_type
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)
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)
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(),
self.c_operator(self.operator),
self.operand2.result())
def generate_evaluation_code(self, code):
self.operand1.generate_evaluation_code(code)
self.operand2.generate_evaluation_code(code)
if self.is_temp:
result = self.result()
self.generate_operation_code(code, result,
self.operand1, self.operator, self.operand2)
if self.cascade:
self.cascade.generate_evaluation_code(code,
result, 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)
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
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
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)
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):
code.putln("if (%s) {" % result)
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("}")
binop_node_classes = {
"or": BoolBinopNode,
"and": BoolBinopNode,
"|": IntBinopNode,
"^": IntBinopNode,
"&": IntBinopNode,
"<<": IntBinopNode,
">>": IntBinopNode,
"+": AddNode,
"-": SubNode,
"*": MulNode,
"/": NumBinopNode,
"%": 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:
print self, "Coercing", self.arg
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.
assert dst_type.is_extension_type, "PyTypeTest on non extension type"
CoercionNode.__init__(self, arg)
self.type = dst_type
self.result_ctype = arg.ctype()
# env.use_utility_code(type_test_utility_code)
self.gil_check(env)
gil_message = "Python type test"
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()
def generate_result_code(self, code):
if self.type.typeobj_is_available():
code.use_utility_code(type_test_utility_code)
code.putln(
"if (!__Pyx_TypeTest(%s, %s)) %s" % (
self.arg.py_result(),
self.type.typeptr_cname,
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
self.gil_check(env)
self.is_temp = 1
if not arg.type.to_py_function:
error(arg.pos,
"Cannot convert '%s' to Python object" % arg.type)
gil_message = "Converting to Python object"
def generate_result_code(self, code):
function = self.arg.type.to_py_function
result = self.result()
code.putln('%s = %s(%s); if (!%s) %s' % (
result,
function,
self.arg.result(),
result,
code.error_goto(self.pos)))
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
operand = self.arg.py_result()
rhs = "%s(%s)" % (function, operand)
if self.type.is_enum:
rhs = typecast(self.type, c_long_type, rhs)
result = self.result()
if self.type.is_string:
err_code = "!%s" % result
else:
err_code = "PyErr_Occurred()"
code.putln('%s = %s; if (%s) %s' % (
result,
rhs,
err_code,
code.error_goto(self.pos)))
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)
self.type = PyrexTypes.c_int_type
if arg.type.is_pyobject:
if env.nogil:
self.gil_error()
self.is_temp = 1
gil_message = "Truth-testing Python object"
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()
def generate_result_code(self, code):
if self.arg.type.is_pyobject:
result = self.result()
code.putln(
"%s = PyObject_IsTrue(%s); if (%s < 0) %s" % (
result,
self.arg.py_result(),
result,
code.error_goto(self.pos)))
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:
self.gil_check(env)
self.result_ctype = py_object_type
gil_message = "Creating temporary Python reference"
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(), self.arg.result_as(self.ctype())))
if self.type.is_pyobject:
code.put_incref(self.py_result())
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)
self.type = arg.type
self.result_ctype = arg.result_ctype
def calculate_result_code(self):
return self.arg.result()
def generate_evaluation_code(self, code):
pass
def generate_result_code(self, code):
pass
#------------------------------------------------------------------------------------
#
# Runtime support code
#
#------------------------------------------------------------------------------------
get_name_utility_code = [
"""
static PyObject *__Pyx_GetName(PyObject *dict, char *name); /*proto*/
""","""
static PyObject *__Pyx_GetName(PyObject *dict, char *name) {
PyObject *result;
result = PyObject_GetAttrString(dict, name);
if (!result)
PyErr_SetString(PyExc_NameError, name);
return result;
}
"""]
get_name_interned_utility_code = [
"""
static PyObject *__Pyx_GetName(PyObject *dict, PyObject *name); /*proto*/
""","""
static PyObject *__Pyx_GetName(PyObject *dict, PyObject *name) {
PyObject *result;
result = PyObject_GetAttr(dict, name);
if (!result)
PyErr_SetObject(PyExc_NameError, name);
return result;
}
"""]
#------------------------------------------------------------------------------------
import_utility_code = [
"""
static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list); /*proto*/
""","""
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,
}]
#------------------------------------------------------------------------------------
#
#get_exception_utility_code = [
#"""
#static PyObject *__Pyx_GetExcValue(void); /*proto*/
#""","""
#static PyObject *__Pyx_GetExcValue(void) {
# PyObject *type = 0, *value = 0, *tb = 0;
# 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);
# }
# Py_XDECREF(tstate->exc_type);
# Py_XDECREF(tstate->exc_value);
# Py_XDECREF(tstate->exc_traceback);
# tstate->exc_type = type;
# tstate->exc_value = value;
# tstate->exc_traceback = tb;
# result = value;
# Py_XINCREF(result);
# type = 0;
# value = 0;
# tb = 0;
#bad:
# Py_XDECREF(type);
# Py_XDECREF(value);
# Py_XDECREF(tb);
# return result;
#}
#"""]
#
#------------------------------------------------------------------------------------
unpacking_utility_code = [
"""
static PyObject *__Pyx_UnpackItem(PyObject *); /*proto*/
static int __Pyx_EndUnpack(PyObject *); /*proto*/
""","""
static void __Pyx_UnpackError(void) {
PyErr_SetString(PyExc_ValueError, "unpack sequence of wrong size");
}
static PyObject *__Pyx_UnpackItem(PyObject *iter) {
PyObject *item;
if (!(item = PyIter_Next(iter))) {
if (!PyErr_Occurred())
__Pyx_UnpackError();
}
return item;
}
static int __Pyx_EndUnpack(PyObject *iter) {
PyObject *item;
if ((item = PyIter_Next(iter))) {
Py_DECREF(item);
__Pyx_UnpackError();
return -1;
}
else if (!PyErr_Occurred())
return 0;
else
return -1;
}
"""]
#------------------------------------------------------------------------------------
type_test_utility_code = [
"""
static int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type); /*proto*/
""","""
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",
obj->ob_type->tp_name, type->tp_name);
return 0;
}
"""]
#------------------------------------------------------------------------------------
create_class_utility_code = [
"""
static PyObject *__Pyx_CreateClass(PyObject *bases, PyObject *dict, PyObject *name, char *modname); /*proto*/
""","""
static PyObject *__Pyx_CreateClass(
PyObject *bases, PyObject *dict, PyObject *name, char *modname)
{
PyObject *py_modname;
PyObject *result = 0;
py_modname = PyString_FromString(modname);
if (!py_modname)
goto bad;
if (PyDict_SetItemString(dict, "__module__", py_modname) < 0)
goto bad;
result = PyClass_New(bases, dict, name);
bad:
Py_XDECREF(py_modname);
return result;
}
"""]
#------------------------------------------------------------------------------------
getitem_int_utility_code = [
"""
static PyObject *__Pyx_GetItemInt(PyObject *o, Py_ssize_t i); /*proto*/
""","""
static PyObject *__Pyx_GetItemInt(PyObject *o, Py_ssize_t i) {
PyTypeObject *t = o->ob_type;
PyObject *r;
if (t->tp_as_sequence && t->tp_as_sequence->sq_item)
r = PySequence_GetItem(o, i);
else {
PyObject *j = PyInt_FromLong(i);
if (!j)
return 0;
r = PyObject_GetItem(o, j);
Py_DECREF(j);
}
return r;
}
"""]
#------------------------------------------------------------------------------------
setitem_int_utility_code = [
"""
static int __Pyx_SetItemInt(PyObject *o, Py_ssize_t i, PyObject *v); /*proto*/
""","""
static int __Pyx_SetItemInt(PyObject *o, Py_ssize_t i, PyObject *v) {
PyTypeObject *t = o->ob_type;
int r;
if (t->tp_as_sequence && t->tp_as_sequence->sq_item)
r = PySequence_SetItem(o, i, v);
else {
PyObject *j = PyInt_FromLong(i);
if (!j)
return -1;
r = PyObject_SetItem(o, j, v);
Py_DECREF(j);
}
return r;
}
"""]
|