src='_Py_NoneStruct')
# Get the boxed object '...'
ellipsis_op = load_address_op(name='...',
type=object_rprimitive,
src='_Py_EllipsisObject')
# Get the boxed NotImplemented object
not_implemented_op = load_address_op(name='builtins.NotImplemented',
type=object_rprimitive,
src='_Py_NotImplementedStruct')
# id(obj)
function_op(name='builtins.id',
arg_types=[object_rprimitive],
return_type=int_rprimitive,
c_function_name='CPyTagged_Id',
error_kind=ERR_NEVER)
# Return the result of obj.__await()__ or obj.__iter__() (if no __await__ exists)
coro_op = custom_op(arg_types=[object_rprimitive],
return_type=object_rprimitive,
c_function_name='CPy_GetCoro',
error_kind=ERR_MAGIC)
# Do obj.send(value), or a next(obj) if second arg is None.
# (This behavior is to match the PEP 380 spec for yield from.)
# Like next_raw_op, don't swallow StopIteration,
# but also don't propagate an error.
# Can return NULL: see next_op.
send_op = custom_op(arg_types=[object_rprimitive, object_rprimitive],
dict_next_rtuple_single, dict_next_rtuple_pair,
c_pyssize_t_rprimitive, c_int_rprimitive,
bit_rprimitive)
from mypyc.primitives.registry import (custom_op, method_op, function_op,
binary_op, load_address_op, ERR_NEG_INT)
# Get the 'dict' type object.
load_address_op(name='builtins.dict',
type=object_rprimitive,
src='PyDict_Type')
# Construct an empty dictionary via dict().
function_op(name='builtins.dict',
arg_types=[],
return_type=dict_rprimitive,
c_function_name='PyDict_New',
error_kind=ERR_MAGIC)
# Construct an empty dictionary.
dict_new_op = custom_op(arg_types=[],
return_type=dict_rprimitive,
c_function_name='PyDict_New',
error_kind=ERR_MAGIC)
# Construct a dictionary from keys and values.
# Positional argument is the number of key-value pairs
# Variable arguments are (key1, value1, ..., keyN, valueN).
dict_build_op = custom_op(arg_types=[c_pyssize_t_rprimitive],
return_type=dict_rprimitive,
c_function_name='CPyDict_Build',
arg_types=[tuple_rprimitive, int_rprimitive],
return_type=object_rprimitive,
c_function_name='CPySequenceTuple_GetItem',
error_kind=ERR_MAGIC)
# Construct a boxed tuple from items: (item1, item2, ...)
new_tuple_op = custom_op(arg_types=[c_pyssize_t_rprimitive],
return_type=tuple_rprimitive,
c_function_name='PyTuple_Pack',
error_kind=ERR_MAGIC,
var_arg_type=object_rprimitive)
# Construct tuple from a list.
list_tuple_op = function_op(name='builtins.tuple',
arg_types=[list_rprimitive],
return_type=tuple_rprimitive,
c_function_name='PyList_AsTuple',
error_kind=ERR_MAGIC,
priority=2)
# Construct tuple from an arbitrary (iterable) object.
function_op(name='builtins.tuple',
arg_types=[object_rprimitive],
return_type=tuple_rprimitive,
c_function_name='PySequence_Tuple',
error_kind=ERR_MAGIC)
# tuple[begin:end]
tuple_slice_op = custom_op(
arg_types=[tuple_rprimitive, int_rprimitive, int_rprimitive],
return_type=object_rprimitive,
c_function_name='CPySequenceTuple_GetSlice',
int_rprimitive, list_rprimitive, c_int_rprimitive,
pointer_rprimitive, bool_rprimitive,
bit_rprimitive, c_pyssize_t_rprimitive,
bytes_rprimitive)
from mypyc.primitives.registry import (method_op, binary_op, function_op,
load_address_op, custom_op, ERR_NEG_INT)
# Get the 'str' type object.
load_address_op(name='builtins.str',
type=object_rprimitive,
src='PyUnicode_Type')
# str(obj)
str_op = function_op(name='builtins.str',
arg_types=[object_rprimitive],
return_type=str_rprimitive,
c_function_name='PyObject_Str',
error_kind=ERR_MAGIC)
# str1 + str2
binary_op(name='+',
arg_types=[str_rprimitive, str_rprimitive],
return_type=str_rprimitive,
c_function_name='PyUnicode_Concat',
error_kind=ERR_MAGIC)
# str1 += str2
#
# PyUnicode_Append makes an effort to reuse the LHS when the refcount
# is 1. This is super dodgy but oh well, the interpreter does it.
binary_op(name='+=',
from mypyc.primitives.registry import (
load_address_op, function_op, binary_op, method_op, custom_op, ERR_NEG_INT
)
# Get the 'builtins.list' type object.
load_address_op(
name='builtins.list',
type=object_rprimitive,
src='PyList_Type')
# list(obj)
to_list = function_op(
name='builtins.list',
arg_types=[object_rprimitive],
return_type=list_rprimitive,
c_function_name='PySequence_List',
error_kind=ERR_MAGIC,
)
new_list_op = custom_op(
arg_types=[c_pyssize_t_rprimitive],
return_type=list_rprimitive,
c_function_name='PyList_New',
error_kind=ERR_MAGIC)
# list[index] (for an integer index)
list_get_item_op = method_op(
name='__getitem__',
arg_types=[list_rprimitive, int_rprimitive],
return_type=object_rprimitive,
from mypyc.ir.rtypes import (int_rprimitive, short_int_rprimitive,
list_rprimitive, object_rprimitive,
c_int_rprimitive, c_pyssize_t_rprimitive,
bit_rprimitive)
from mypyc.primitives.registry import (load_address_op, function_op, binary_op,
method_op, custom_op, ERR_NEG_INT)
# Get the 'builtins.list' type object.
load_address_op(name='builtins.list',
type=object_rprimitive,
src='PyList_Type')
# list(obj)
to_list = function_op(name='builtins.list',
arg_types=[object_rprimitive],
return_type=list_rprimitive,
c_function_name='PySequence_List',
error_kind=ERR_MAGIC)
# Construct an empty list via list().
function_op(name='builtins.list',
arg_types=[],
return_type=list_rprimitive,
c_function_name='PyList_New',
error_kind=ERR_MAGIC,
extra_int_constants=[(0, int_rprimitive)])
new_list_op = custom_op(arg_types=[c_pyssize_t_rprimitive],
return_type=list_rprimitive,
c_function_name='PyList_New',
error_kind=ERR_MAGIC)
"""Primitive float ops."""
from mypyc.ir.ops import ERR_MAGIC
from mypyc.ir.rtypes import (str_rprimitive, float_rprimitive)
from mypyc.primitives.registry import (function_op)
# float(str)
function_op(name='builtins.float',
arg_types=[str_rprimitive],
return_type=float_rprimitive,
c_function_name='PyFloat_FromString',
error_kind=ERR_MAGIC)
# abs(float)
function_op(name='builtins.abs',
arg_types=[float_rprimitive],
return_type=float_rprimitive,
c_function_name='PyNumber_Absolute',
error_kind=ERR_MAGIC)
"""Primitive set (and frozenset) ops."""
from mypyc.primitives.registry import function_op, method_op, binary_op, ERR_NEG_INT
from mypyc.ir.ops import ERR_MAGIC, ERR_FALSE
from mypyc.ir.rtypes import (object_rprimitive, bool_rprimitive,
set_rprimitive, c_int_rprimitive,
pointer_rprimitive, bit_rprimitive)
# Construct an empty set.
new_set_op = function_op(name='builtins.set',
arg_types=[],
return_type=set_rprimitive,
c_function_name='PySet_New',
error_kind=ERR_MAGIC,
extra_int_constants=[(0, pointer_rprimitive)])
# set(obj)
function_op(name='builtins.set',
arg_types=[object_rprimitive],
return_type=set_rprimitive,
c_function_name='PySet_New',
error_kind=ERR_MAGIC)
# frozenset(obj)
function_op(name='builtins.frozenset',
arg_types=[object_rprimitive],
return_type=object_rprimitive,
c_function_name='PyFrozenSet_New',
error_kind=ERR_MAGIC)
# item in set
from mypyc.ir.ops import ERR_MAGIC
from mypyc.ir.rtypes import (object_rprimitive, bytes_rprimitive,
list_rprimitive, dict_rprimitive, str_rprimitive,
RUnion)
from mypyc.primitives.registry import (load_address_op, function_op, method_op,
binary_op)
# Get the 'bytes' type object.
load_address_op(name='builtins.bytes',
type=object_rprimitive,
src='PyBytes_Type')
# bytes(obj)
function_op(
name='builtins.bytes',
arg_types=[RUnion([list_rprimitive, dict_rprimitive, str_rprimitive])],
return_type=bytes_rprimitive,
c_function_name='PyBytes_FromObject',
error_kind=ERR_MAGIC)
# bytearray(obj)
function_op(name='builtins.bytearray',
arg_types=[object_rprimitive],
return_type=bytes_rprimitive,
c_function_name='PyByteArray_FromObject',
error_kind=ERR_MAGIC)
# bytes + bytes
# bytearray + bytearray
binary_op(name='+',
arg_types=[bytes_rprimitive, bytes_rprimitive],
return_type=bytes_rprimitive,
c_function_name='PyObject_SetItem',
error_kind=ERR_NEG_INT,
priority=0)
# del obj1[obj2]
method_op(name='__delitem__',
arg_types=[object_rprimitive, object_rprimitive],
return_type=c_int_rprimitive,
c_function_name='PyObject_DelItem',
error_kind=ERR_NEG_INT,
priority=0)
# hash(obj)
function_op(name='builtins.hash',
arg_types=[object_rprimitive],
return_type=int_rprimitive,
c_function_name='CPyObject_Hash',
error_kind=ERR_MAGIC)
# getattr(obj, attr)
py_getattr_op = function_op(name='builtins.getattr',
arg_types=[object_rprimitive, object_rprimitive],
return_type=object_rprimitive,
c_function_name='CPyObject_GetAttr',
error_kind=ERR_MAGIC)
# getattr(obj, attr, default)
function_op(
name='builtins.getattr',
arg_types=[object_rprimitive, object_rprimitive, object_rprimitive],
return_type=object_rprimitive,
RType)
from mypyc.primitives.registry import (load_address_op, c_unary_op,
CFunctionDescription, function_op,
binary_op, custom_op)
# These int constructors produce object_rprimitives that then need to be unboxed
# I guess unboxing ourselves would save a check and branch though?
# Get the type object for 'builtins.int'.
# For ordinary calls to int() we use a load_address to the type
load_address_op(name='builtins.int', type=object_rprimitive, src='PyLong_Type')
# Convert from a float to int. We could do a bit better directly.
function_op(name='builtins.int',
arg_types=[float_rprimitive],
return_type=object_rprimitive,
c_function_name='CPyLong_FromFloat',
error_kind=ERR_MAGIC)
# int(string)
function_op(name='builtins.int',
arg_types=[str_rprimitive],
return_type=object_rprimitive,
c_function_name='CPyLong_FromStr',
error_kind=ERR_MAGIC)
# int(string, base)
function_op(name='builtins.int',
arg_types=[str_rprimitive, int_rprimitive],
return_type=object_rprimitive,
c_function_name='CPyLong_FromStrWithBase',
