예제 #1
0
파일: cdlopen.py 프로젝트: pypyjs/pypy
    def cdlopen_close(self):
        libhandle = self.libhandle
        self.libhandle = rffi.cast(DLLHANDLE, 0)

        if not libhandle:
            raise oefmt(self.ffi.w_FFIError, "library '%s' is already closed",
                        self.libname)

        # Clear the dict to force further accesses to do cdlopen_fetch()
        # again, and fail because the library was closed.  Note that the
        # JIT may have elided some accesses, and so has addresses as
        # constants.  We could work around it with a quasi-immutable flag
        # but unsure it's worth it.
        self.dict_w.clear()

        if dlclose(libhandle) < 0:
            raise oefmt(self.ffi.w_FFIError, "error closing library '%s'",
                        self.libname)
예제 #2
0
    def cdlopen_close(self):
        libhandle = self.libhandle
        self.libhandle = rffi.cast(DLLHANDLE, 0)

        if not libhandle:
            return
        self.may_unregister_rpython_finalizer(self.ffi.space)

        # Clear the dict to force further accesses to do cdlopen_fetch()
        # again, and fail because the library was closed.  Note that the
        # JIT may have elided some accesses, and so has addresses as
        # constants.  We could work around it with a quasi-immutable flag
        # but unsure it's worth it.
        self.dict_w.clear()

        if dlclose(libhandle) < 0:
            raise oefmt(self.ffi.w_FFIError, "error closing library '%s'",
                        self.libname)
예제 #3
0
 def _finalize_(self):
     h = self.handle
     if h != rffi.cast(DLLHANDLE, 0):
         self.handle = rffi.cast(DLLHANDLE, 0)
         dlclose(h)
예제 #4
0
파일: libffi.py 프로젝트: mozillazg/pypy
 def __del__(self):
     if self.lib:
         dlclose(self.lib)
         self.lib = rffi.cast(DLLHANDLE, 0)
예제 #5
0
파일: clibffi.py 프로젝트: Mu-L/pypy
 def __del__(self):
     if self.lib != rffi.cast(DLLHANDLE, -1):
         dlclose(self.lib)
         self.lib = rffi.cast(DLLHANDLE, -1)
예제 #6
0
 def __del__(self):
     h = self.handle
     if h != rffi.cast(DLLHANDLE, 0):
         self.handle = rffi.cast(DLLHANDLE, 0)
         dlclose(h)
예제 #7
0
class _InterpreterProxy(object):
    _immutable_fields_ = ['vm_initialized?']

    def __init__(self):
        self.vm_proxy = lltype.nullptr(VMPtr.TO)
        self.vm_initialized = False
        self.space = None
        self._next_oop = 0
        self.oop_map = {}
        self.object_map = {}
        self.loaded_modules = {}
        self.remappable_objects = []
        self.trace_proxy = objspace.ConstantFlag()
        self.reset()

    def reset(self):
        self.interp = None
        self.s_frame = None
        self.argcount = 0
        self.w_method = None
        self.fail_reason = 0
        self.trace_proxy.deactivate()

    def call(self, signature, interp, s_frame, argcount, w_method):
        self.initialize_from_call(signature, interp, s_frame, argcount, w_method)
        try:
            # eventual errors are caught by the calling function (EXTERNAL_CALL)
            external_function = rffi.cast(func_bool_void,
                            self.loadFunctionFrom(signature[0], signature[1]))
            if interp.is_tracing():
                interp.print_padded("Calling %s >> %s" % (signature[0], signature[1]))
            external_function()

            if not self.fail_reason == 0:
                raise error.PrimitiveFailedError
        finally:
            self.reset()

    def loadFunctionFrom(self, module_name, function_name):
        from rpython.rlib.rdynload import dlsym
        if module_name not in self.loaded_modules:
            module = self.load_and_initialize(module_name)
        else:
            module = self.loaded_modules[module_name]

        if function_name in module[1]:
            return module[1][function_name]
        else:
            try:
                _external_function = dlsym(module[0], function_name)
            except KeyError:
                raise ProxyFunctionFailed
            else:
                module[1][function_name] = _external_function
                return _external_function


    def initialize_from_call(self, signature, interp, s_frame, argcount, w_method):
        self.interp = interp
        self.s_frame = s_frame
        self.argcount = argcount
        self.w_method = w_method
        self.space = interp.space
        self.trace_proxy.set(interp.trace_proxy.is_set())
        # ensure that space.w_nil gets the first possible oop
        self.object_to_oop(self.space.w_nil)

    def failed(self, reason=1):
        assert reason != 0
        self.fail_reason = reason

    def oop_to_object(self, oop):
        try:
            return self.oop_map[oop]
        except KeyError:
            raise ProxyFunctionFailed

    def object_to_oop(self, w_object):
        try:
            return self.object_map[w_object]
        except KeyError:
            new_index = self.next_oop()
            # print "Mapping new Object: %d -> %s" % (new_index, w_object)
            self.oop_map[new_index] = w_object
            self.object_map[w_object] = new_index
            return new_index

    def next_oop(self):
        next_oop = self._next_oop
        self._next_oop = next_oop + 1
        return next_oop

    def pop_remappable(self):
        try:
            return self.remappable_objects.pop()
        except IndexError:
            self.failed()
            return self.space.w_nil

    def push_remappable(self, w_object):
        self.remappable_objects.append(w_object)
        return w_object

    def top_remappable(self):
        if len(self.remappable_objects) == 0:
            raise ProxyFunctionFailed
        return self.remappable_objects[-1]

    def load_and_initialize(self, module_name):
        from rpython.rlib.rdynload import dlopen, dlsym, dlclose, DLOpenError
        import os
        c_name = rffi.str2charp(os.path.join(IProxy.space.executable_path(), module_name))
        try:
            module = dlopen(c_name)
        except DLOpenError, e:
            rffi.free_charp(c_name)
            raise error.PrimitiveFailedError

        try:
            try:
                _getModuleName = dlsym(module, "getModuleName")
            except KeyError:
                pass # the method does not need to exist
            else:
                getModuleName = rffi.cast(func_str_void, _getModuleName)
                if not rffi.charp2str(getModuleName()).startswith(module_name):
                    raise error.PrimitiveFailedError

            try:
                _setInterpreter = dlsym(module, "setInterpreter")
            except KeyError:
                raise error.PrimitiveFailedError
            else:
                setInterpreter = rffi.cast(func_bool_vm, _setInterpreter)
                if not setInterpreter(getInterpreterProxy()):
                    print "Failed setting interpreter on: %s" % module_name
                    raise error.PrimitiveFailedError

            try:
                _initialiseModule = dlsym(module, "initialiseModule")
            except KeyError:
                pass # the method does not need to exist
            else:
                initialiseModule = rffi.cast(func_bool_void, _initialiseModule)
                if not initialiseModule():
                    print "Failed initialization of: %s" % module_name
                    raise error.PrimitiveFailedError

            module_tuple = (module, {})
            self.loaded_modules[module_name] = module_tuple
            return module_tuple
        except error.PrimitiveFailedError:
            dlclose(module)
            raise
        finally:
            rffi.free_charp(c_name)
예제 #8
0
파일: cdlopen.py 프로젝트: pypyjs/pypy
 def __del__(self):
     if self.libhandle:
         dlclose(self.libhandle)
예제 #9
0
 def __del__(self):
     if self.libhandle:
         dlclose(self.libhandle)
예제 #10
0
 def __del__(self):
     h = self.handle
     if h != rffi.cast(DLLHANDLE, 0):
         self.handle = rffi.cast(DLLHANDLE, 0)
         dlclose(h)
예제 #11
0
 def _finalize_(self):
     h = self.handle
     if h != rffi.cast(DLLHANDLE, 0):
         self.handle = rffi.cast(DLLHANDLE, 0)
         dlclose(h)