/pypy/module/cpyext/test/test_translate.py

from rpython.translator.c.test.test_genc import compile

import pypy.module.cpyext.api

from pypy.module.cpyext.api import cpython_api

from rpython.rtyper.annlowlevel import llhelper

from rpython.rtyper.lltypesystem import lltype

from rpython.rlib.objectmodel import specialize

from rpython.rlib.nonconst import NonConstant



def test_llhelper(monkeypatch):

    """Show how to get function pointers used in type slots"""

    FT = lltype.FuncType([], lltype.Signed)

    FTPTR = lltype.Ptr(FT)



    def make_wrapper(self, space):

        def wrapper():

            return self.callable(space)

        return wrapper

    monkeypatch.setattr(pypy.module.cpyext.api.ApiFunction, '_make_wrapper', make_wrapper)



    @specialize.memo()

    def get_tp_function(space, typedef):

        @cpython_api([], lltype.Signed, error=-1, header=None)

        def slot_tp_function(space):

            return typedef.value



        api_func = slot_tp_function.api_func

        return lambda: llhelper(api_func.functype, api_func.get_wrapper(space))



    class Space:

        _cache = {}

        @specialize.memo()

        def fromcache(self, key):

            try:

                return self._cache[key]

            except KeyError:

                result = self._cache[key] = self.build(key)

                return result

        def _freeze_(self):

            return True

    class TypeDef:

        def __init__(self, value):

            self.value = value

        def _freeze_(self):

            return True

    class W_Type:

        def __init__(self, typedef):

            self.instancetypedef = typedef

        def _freeze(self):

            try:

                del self.funcptr

            except AttributeError:

                pass

            return False



    w_type1 = W_Type(TypeDef(123))

    w_type2 = W_Type(TypeDef(456))

    space = Space()



    def run(x):

        if x:

            w_type = w_type1

        else:

            w_type = w_type2

        typedef = w_type.instancetypedef

        w_type.funcptr = get_tp_function(space, typedef)()

        return w_type.funcptr()



    fn = compile(run, [bool])

    assert fn(True) == 123

    assert fn(False) == 456