def _build_methods(self): assert len(self.methods) == 0 methods_temp = {} for i in range(capi.c_num_methods(self.space, self)): idx = capi.c_method_index_at(self.space, self, i) pyname = helper.map_operator_name(self.space, capi.c_method_name(self.space, self, idx), capi.c_method_num_args(self.space, self, idx), capi.c_method_result_type(self.space, self, idx)) cppmethod = self._make_cppfunction(pyname, idx) methods_temp.setdefault(pyname, []).append(cppmethod) # the following covers the case where the only kind of operator[](idx) # returns are the ones that produce non-const references; these can be # used for __getitem__ just as much as for __setitem__, though if not "__getitem__" in methods_temp: try: for m in methods_temp["__setitem__"]: cppmethod = self._make_cppfunction("__getitem__", m.index) methods_temp.setdefault("__getitem__", []).append(cppmethod) except KeyError: pass # just means there's no __setitem__ either # create the overload methods from the method sets for pyname, methods in methods_temp.iteritems(): CPPMethodSort(methods).sort() overload = W_CPPOverload(self.space, self, methods[:]) self.methods[pyname] = overload
def _find_methods(self): num_methods = capi.c_num_methods(self) args_temp = {} for i in range(num_methods): method_name = capi.c_method_name(self, i) pymethod_name = helper.map_operator_name( method_name, capi.c_method_num_args(self, i), capi.c_method_result_type(self, i) ) if not pymethod_name in self.methods: cppfunction = self._make_cppfunction(i) overload = args_temp.setdefault(pymethod_name, []) overload.append(cppfunction) for name, functions in args_temp.iteritems(): overload = W_CPPOverload(self.space, self, functions[:]) self.methods[name] = overload
def _setup(self, cppthis): self.converters = [ converter.get_converter(self.space, arg_type, arg_dflt) for arg_type, arg_dflt in self.arg_defs ] self.executor = executor.get_executor(self.space, capi.c_method_result_type(self.scope, self.index)) # Each CPPMethod corresponds one-to-one to a C++ equivalent and cppthis # has been offset to the matching class. Hence, the libffi pointer is # uniquely defined and needs to be setup only once. methgetter = capi.c_get_methptr_getter(self.scope, self.index) if methgetter and cppthis: # methods only for now funcptr = methgetter(rffi.cast(capi.C_OBJECT, cppthis)) argtypes_libffi = [conv.libffitype for conv in self.converters if conv.libffitype] if len(argtypes_libffi) == len(self.converters) and self.executor.libffitype: # add c++ this to the arguments libffifunc = libffi.Func( "XXX", [libffi.types.pointer] + argtypes_libffi, self.executor.libffitype, funcptr ) self._libffifunc = libffifunc
def _setup(self, cppthis): self.converters = [converter.get_converter(self.space, arg_type, arg_dflt) for arg_type, arg_dflt in self.arg_defs] self.executor = executor.get_executor( self.space, capi.c_method_result_type(self.space, self.scope, self.index)) for conv in self.converters: if conv.uses_local: self.uses_local = True break # Each CPPMethod corresponds one-to-one to a C++ equivalent and cppthis # has been offset to the matching class. Hence, the libffi pointer is # uniquely defined and needs to be setup only once. methgetter = capi.c_get_methptr_getter(self.space, self.scope, self.index) if methgetter and cppthis: # methods only for now cif_descr = lltype.nullptr(jit_libffi.CIF_DESCRIPTION) try: funcaddr = methgetter(rffi.cast(capi.C_OBJECT, cppthis)) self._funcaddr = rffi.cast(rffi.VOIDP, funcaddr) nargs = self.args_expected + 1 # +1: cppthis # memory block for CIF description (note: not tracked as the life # time of methods is normally the duration of the application) size = llmemory.sizeof(jit_libffi.CIF_DESCRIPTION, nargs) # allocate the buffer cif_descr = lltype.malloc(jit_libffi.CIF_DESCRIPTION_P.TO, llmemory.raw_malloc_usage(size), flavor='raw', track_allocation=False) # array of 'ffi_type*' values, one per argument size = rffi.sizeof(jit_libffi.FFI_TYPE_P) * nargs atypes = lltype.malloc(rffi.CCHARP.TO, llmemory.raw_malloc_usage(size), flavor='raw', track_allocation=False) cif_descr.atypes = rffi.cast(jit_libffi.FFI_TYPE_PP, atypes) # argument type specification cif_descr.atypes[0] = jit_libffi.types.pointer # cppthis for i, conv in enumerate(self.converters): if not conv.libffitype: raise FastCallNotPossible cif_descr.atypes[i+1] = conv.libffitype # result type specification cif_descr.rtype = self.executor.libffitype # exchange --- # first, enough room for an array of 'nargs' pointers exchange_offset = rffi.sizeof(rffi.CCHARP) * nargs exchange_offset = (exchange_offset + 7) & ~7 # alignment cif_descr.exchange_result = exchange_offset cif_descr.exchange_result_libffi = exchange_offset # TODO: left this out while testing (see ctypefunc.py) # For results of precisely these types, libffi has a # strange rule that they will be returned as a whole # 'ffi_arg' if they are smaller. The difference # only matters on big-endian. # then enough room for the result, rounded up to sizeof(ffi_arg) exchange_offset += max(rffi.getintfield(cif_descr.rtype, 'c_size'), jit_libffi.SIZE_OF_FFI_ARG) # loop over args for i in range(nargs): exchange_offset = (exchange_offset + 7) & ~7 # alignment cif_descr.exchange_args[i] = exchange_offset exchange_offset += rffi.getintfield(cif_descr.atypes[i], 'c_size') # store the exchange data size cif_descr.exchange_size = exchange_offset # --- exchange # extra cif_descr.abi = clibffi.FFI_DEFAULT_ABI cif_descr.nargs = self.args_expected + 1 # +1: cppthis res = jit_libffi.jit_ffi_prep_cif(cif_descr) if res != clibffi.FFI_OK: raise FastCallNotPossible except Exception, e: if cif_descr: lltype.free(cif_descr.atypes, flavor='raw', track_allocation=False) lltype.free(cif_descr, flavor='raw', track_allocation=False) cif_descr = lltype.nullptr(jit_libffi.CIF_DESCRIPTION) self._funcaddr = lltype.nullptr(rffi.VOIDP.TO) self.cif_descr = cif_descr