Ejemplo n.º 1
0
               error_kind=ERR_MAGIC,
               priority=0)

c_unary_op(
    name='not',
    arg_type=object_rprimitive,
    return_type=c_int_rprimitive,
    c_function_name='PyObject_Not',
    error_kind=ERR_NEG_INT,
    truncated_type=bool_rprimitive,
    priority=0)

# obj1[obj2]
c_method_op(name='__getitem__',
            arg_types=[object_rprimitive, object_rprimitive],
            return_type=object_rprimitive,
            c_function_name='PyObject_GetItem',
            error_kind=ERR_MAGIC,
            priority=0)

# obj1[obj2] = obj3
c_method_op(
    name='__setitem__',
    arg_types=[object_rprimitive, object_rprimitive, object_rprimitive],
    return_type=c_int_rprimitive,
    c_function_name='PyObject_SetItem',
    error_kind=ERR_NEG_INT,
    priority=0)

# del obj1[obj2]
c_method_op(
    name='__delitem__',
Ejemplo n.º 2
0
    name='builtins.list',
    arg_types=[object_rprimitive],
    return_type=list_rprimitive,
    c_function_name='PySequence_List',
    error_kind=ERR_MAGIC,
)

new_list_op = c_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 = c_method_op(name='__getitem__',
                               arg_types=[list_rprimitive, int_rprimitive],
                               return_type=object_rprimitive,
                               c_function_name='CPyList_GetItem',
                               error_kind=ERR_MAGIC)

# Version with no int bounds check for when it is known to be short
c_method_op(name='__getitem__',
            arg_types=[list_rprimitive, short_int_rprimitive],
            return_type=object_rprimitive,
            c_function_name='CPyList_GetItemShort',
            error_kind=ERR_MAGIC,
            priority=2)

# This is unsafe because it assumes that the index is a non-negative short integer
# that is in-bounds for the list.
list_get_item_unsafe_op = c_custom_op(
    arg_types=[list_rprimitive, short_int_rprimitive],
Ejemplo n.º 3
0
              arg_types=[object_rprimitive],
              return_type=str_rprimitive,
              c_function_name='PyObject_Str',
              error_kind=ERR_MAGIC)

# str1 + str2
c_binary_op(name='+',
            arg_types=[str_rprimitive, str_rprimitive],
            return_type=str_rprimitive,
            c_function_name='PyUnicode_Concat',
            error_kind=ERR_MAGIC)

# str.join(obj)
c_method_op(name='join',
            arg_types=[str_rprimitive, object_rprimitive],
            return_type=str_rprimitive,
            c_function_name='PyUnicode_Join',
            error_kind=ERR_MAGIC)

# str[index] (for an int index)
c_method_op(name='__getitem__',
            arg_types=[str_rprimitive, int_rprimitive],
            return_type=str_rprimitive,
            c_function_name='CPyStr_GetItem',
            error_kind=ERR_MAGIC)

# str.split(...)
str_split_types = [str_rprimitive, str_rprimitive,
                   int_rprimitive]  # type: List[RType]
str_split_functions = ['PyUnicode_Split', 'PyUnicode_Split', 'CPyStr_Split']
str_split_constants = [[(0, pointer_rprimitive), (-1, c_int_rprimitive)],
Ejemplo n.º 4
0
              arg_types=[object_rprimitive],
              return_type=str_rprimitive,
              c_function_name='PyObject_Str',
              error_kind=ERR_MAGIC)

# str1 + str2
c_binary_op(name='+',
            arg_types=[str_rprimitive, str_rprimitive],
            return_type=str_rprimitive,
            c_function_name='PyUnicode_Concat',
            error_kind=ERR_MAGIC)

# str.join(obj)
c_method_op(name='join',
            arg_types=[str_rprimitive, object_rprimitive],
            return_type=str_rprimitive,
            c_function_name='PyUnicode_Join',
            error_kind=ERR_MAGIC)

# str[index] (for an int index)
c_method_op(name='__getitem__',
            arg_types=[str_rprimitive, int_rprimitive],
            return_type=str_rprimitive,
            c_function_name='CPyStr_GetItem',
            error_kind=ERR_MAGIC)

# str.split(...)
str_split_types = [str_rprimitive, str_rprimitive,
                   int_rprimitive]  # type: List[RType]
str_split_emits = [simple_emit('{dest} = PyUnicode_Split({args[0]}, NULL, -1);'),
                   simple_emit('{dest} = PyUnicode_Split({args[0]}, {args[1]}, -1);'),
Ejemplo n.º 5
0
        arg_types=[object_rprimitive],
        result_type=str_rprimitive,
        error_kind=ERR_MAGIC,
        emit=call_emit('PyObject_Str'))

# str1 + str2
binary_op(op='+',
          arg_types=[str_rprimitive, str_rprimitive],
          result_type=str_rprimitive,
          error_kind=ERR_MAGIC,
          emit=call_emit('PyUnicode_Concat'))

# str.join(obj)
c_method_op(name='join',
            arg_types=[str_rprimitive, object_rprimitive],
            return_type=str_rprimitive,
            c_function_name='PyUnicode_Join',
            error_kind=ERR_MAGIC)

# str[index] (for an int index)
method_op(name='__getitem__',
          arg_types=[str_rprimitive, int_rprimitive],
          result_type=str_rprimitive,
          error_kind=ERR_MAGIC,
          emit=call_emit('CPyStr_GetItem'))

# str.split(...)
str_split_types = [str_rprimitive, str_rprimitive,
                   int_rprimitive]  # type: List[RType]
str_split_emits = [simple_emit('{dest} = PyUnicode_Split({args[0]}, NULL, -1);'),
                   simple_emit('{dest} = PyUnicode_Split({args[0]}, {args[1]}, -1);'),
Ejemplo n.º 6
0
    emit=emit_len,
)

# item in set
binary_op(
    op='in',
    arg_types=[object_rprimitive, set_rprimitive],
    result_type=bool_rprimitive,
    error_kind=ERR_MAGIC,
    format_str='{dest} = {args[0]} in {args[1]} :: set',
    emit=negative_int_emit('{dest} = PySet_Contains({args[1]}, {args[0]});'))

# set.remove(obj)
c_method_op(name='remove',
            arg_types=[set_rprimitive, object_rprimitive],
            return_type=bool_rprimitive,
            c_function_name='CPySet_Remove',
            error_kind=ERR_FALSE)

# set.discard(obj)
c_method_op(name='discard',
            arg_types=[set_rprimitive, object_rprimitive],
            return_type=c_int_rprimitive,
            c_function_name='PySet_Discard',
            error_kind=ERR_NEG_INT)

# set.add(obj)
set_add_op = method_op(name='add',
                       arg_types=[set_rprimitive, object_rprimitive],
                       result_type=bool_rprimitive,
                       error_kind=ERR_FALSE,
Ejemplo n.º 7
0
                             bool_rprimitive, int_rprimitive, list_rprimitive,
                             dict_next_rtuple_single, dict_next_rtuple_pair,
                             c_pyssize_t_rprimitive, c_int_rprimitive)

from mypyc.primitives.registry import (c_custom_op, c_method_op, c_function_op,
                                       c_binary_op, load_address_op)

# Get the 'dict' type object.
load_address_op(name='builtins.dict',
                type=object_rprimitive,
                src='PyDict_Type')

# dict[key]
dict_get_item_op = c_method_op(name='__getitem__',
                               arg_types=[dict_rprimitive, object_rprimitive],
                               return_type=object_rprimitive,
                               c_function_name='CPyDict_GetItem',
                               error_kind=ERR_MAGIC)

# dict[key] = value
dict_set_item_op = c_method_op(
    name='__setitem__',
    arg_types=[dict_rprimitive, object_rprimitive, object_rprimitive],
    return_type=c_int_rprimitive,
    c_function_name='CPyDict_SetItem',
    error_kind=ERR_NEG_INT)

# key in dict
c_binary_op(name='in',
            arg_types=[object_rprimitive, dict_rprimitive],
            return_type=c_int_rprimitive,
Ejemplo n.º 8
0
    error_kind=ERR_FALSE,
    emit=call_negative_bool_emit('CPyDict_UpdateInDisplay'),
    format_str='{dest} = {args[0]}.update({args[1]}) (display) :: dict',
)

# dict.update(obj)
method_op(name='update',
          arg_types=[dict_rprimitive, object_rprimitive],
          result_type=bool_rprimitive,
          error_kind=ERR_FALSE,
          emit=call_negative_bool_emit('CPyDict_UpdateFromAny'))

# dict.get(key, default)
c_method_op(name='get',
            arg_types=[dict_rprimitive, object_rprimitive, object_rprimitive],
            return_type=object_rprimitive,
            c_function_name='CPyDict_Get',
            error_kind=ERR_MAGIC)

# dict.get(key)
method_op(
    name='get',
    arg_types=[dict_rprimitive, object_rprimitive],
    result_type=object_rprimitive,
    error_kind=ERR_MAGIC,
    emit=simple_emit('{dest} = CPyDict_Get({args[0]}, {args[1]}, Py_None);'))

# Construct an empty dictionary.
dict_new_op = c_custom_op(arg_types=[],
                          return_type=dict_rprimitive,
                          c_function_name='PyDict_New',
Ejemplo n.º 9
0
objects, i.e. tuple_rprimitive (RPrimitive), not RTuple.
"""

from mypyc.ir.ops import ERR_MAGIC
from mypyc.ir.rtypes import (
    tuple_rprimitive, int_rprimitive, list_rprimitive, object_rprimitive, c_pyssize_t_rprimitive
)
from mypyc.primitives.registry import (
    c_method_op, c_function_op, c_custom_op
)


# tuple[index] (for an int index)
tuple_get_item_op = c_method_op(
    name='__getitem__',
    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 = c_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 = c_function_op(
    name='builtins.tuple',
    arg_types=[list_rprimitive],
Ejemplo n.º 10
0
                          arg_types=[list_rprimitive],
                          result_type=object_rprimitive,
                          error_kind=ERR_MAGIC,
                          emit=call_emit('CPyList_PopLast'))

# list.pop(index)
list_pop = method_op(name='pop',
                     arg_types=[list_rprimitive, int_rprimitive],
                     result_type=object_rprimitive,
                     error_kind=ERR_MAGIC,
                     emit=call_emit('CPyList_Pop'))

# list.count(obj)
c_method_op(name='count',
            arg_types=[list_rprimitive, object_rprimitive],
            return_type=short_int_rprimitive,
            c_function_name='CPyList_Count',
            error_kind=ERR_MAGIC)

# list * int
c_binary_op(name='*',
            arg_types=[list_rprimitive, int_rprimitive],
            return_type=list_rprimitive,
            c_function_name='CPySequence_Multiply',
            error_kind=ERR_MAGIC)

# int * list
c_binary_op(name='*',
            arg_types=[int_rprimitive, list_rprimitive],
            return_type=list_rprimitive,
            c_function_name='CPySequence_RMultiply',
Ejemplo n.º 11
0
              c_function_name='PyFrozenSet_New',
              error_kind=ERR_MAGIC)

# item in set
c_binary_op(name='in',
            arg_types=[object_rprimitive, set_rprimitive],
            return_type=c_int_rprimitive,
            c_function_name='PySet_Contains',
            error_kind=ERR_NEG_INT,
            truncated_type=bool_rprimitive,
            ordering=[1, 0])

# set.remove(obj)
c_method_op(name='remove',
            arg_types=[set_rprimitive, object_rprimitive],
            return_type=bit_rprimitive,
            c_function_name='CPySet_Remove',
            error_kind=ERR_FALSE)

# set.discard(obj)
c_method_op(name='discard',
            arg_types=[set_rprimitive, object_rprimitive],
            return_type=c_int_rprimitive,
            c_function_name='PySet_Discard',
            error_kind=ERR_NEG_INT)

# set.add(obj)
set_add_op = c_method_op(name='add',
                         arg_types=[set_rprimitive, object_rprimitive],
                         return_type=c_int_rprimitive,
                         c_function_name='PySet_Add',