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',