ptr = cdata.unsafe_escaping_ptr() ptr = rffi.ptradd(ptr, offset) return cdataobj.W_CData(space, ptr, self) else: raise oefmt(space.w_TypeError, "expected a cdata struct/union/array/pointer object") def _fget(self, attrchar): if attrchar == 'i': # item return self.ctitem return W_CTypePtrBase._fget(self, attrchar) # ____________________________________________________________ FILEP = rffi.COpaquePtr("FILE") rffi_fdopen = rffi.llexternal("fdopen", [rffi.INT, rffi.CCHARP], FILEP, save_err=rffi.RFFI_SAVE_ERRNO) rffi_setbuf = rffi.llexternal("setbuf", [FILEP, rffi.CCHARP], lltype.Void) rffi_fclose = rffi.llexternal("fclose", [FILEP], rffi.INT) class CffiFileObj(object): _immutable_ = True def __init__(self, fd, mode): self.llf = rffi_fdopen(fd, mode) if not self.llf: raise OSError(rposix.get_saved_errno(), "fdopen failed") rffi_setbuf(self.llf, lltype.nullptr(rffi.CCHARP.TO))
eci = ExternalCompilationInfo( libraries=libraries, includes=includes, post_include_bits=[ # Unnamed structures are not supported by rffi_platform. # So we replace an attribute access with a macro call. '#define pypy_GENERAL_NAME_dirn(name) (name->d.dirn)', ], ) eci = rffi_platform.configure_external_library('openssl', eci, [ dict(prefix='openssl-', include_dir='inc32', library_dir='out32'), ]) ASN1_STRING = lltype.Ptr(lltype.ForwardReference()) ASN1_ITEM = rffi.COpaquePtr('ASN1_ITEM') X509_NAME = rffi.COpaquePtr('X509_NAME') class CConfigBootstrap: _compilation_info_ = eci OPENSSL_EXPORT_VAR_AS_FUNCTION = rffi_platform.Defined( "OPENSSL_EXPORT_VAR_AS_FUNCTION") if rffi_platform.configure(CConfigBootstrap)["OPENSSL_EXPORT_VAR_AS_FUNCTION"]: ASN1_ITEM_EXP = lltype.Ptr(lltype.FuncType([], ASN1_ITEM)) else: ASN1_ITEM_EXP = ASN1_ITEM
_compilation_info_ = eci TIMEVAL = platform.Struct('struct timeval', [('tv_sec', rffi.LONG), ('tv_usec', rffi.LONG)]) TIMESPEC = platform.Struct('struct timespec', [('tv_sec', rffi.TIME_T), ('tv_nsec', rffi.LONG)]) SEM_FAILED = platform.ConstantInteger('SEM_FAILED') SEM_VALUE_MAX = platform.DefinedConstantInteger('SEM_VALUE_MAX') SEM_TIMED_WAIT = platform.Has('sem_timedwait') SEM_T_SIZE = platform.SizeOf('sem_t') config = platform.configure(CConfig) TIMEVAL = config['TIMEVAL'] TIMESPEC = config['TIMESPEC'] TIMEVALP = rffi.CArrayPtr(TIMEVAL) TIMESPECP = rffi.CArrayPtr(TIMESPEC) SEM_T = rffi.COpaquePtr('sem_t', compilation_info=eci) # rffi.cast(SEM_T, config['SEM_FAILED']) SEM_FAILED = config['SEM_FAILED'] SEM_VALUE_MAX = config['SEM_VALUE_MAX'] if SEM_VALUE_MAX is None: # on Hurd SEM_VALUE_MAX = sys.maxint SEM_TIMED_WAIT = config['SEM_TIMED_WAIT'] SEM_T_SIZE = config['SEM_T_SIZE'] if sys.platform == 'darwin': HAVE_BROKEN_SEM_GETVALUE = True else: HAVE_BROKEN_SEM_GETVALUE = False def external(name, args, result, **kwargs): return rffi.llexternal(name, args,
if IS_WINDOWS: def opendir(_): raise NotImplementedError("directory operations on windows") readdir = closedir = opendir else: eci = ExternalCompilationInfo(includes=["sys/types.h", "dirent.h"]) class CConfig: _compilation_info_ = eci DIRENT = platform.Struct( "struct dirent", [("d_name", lltype.FixedSizeArray(rffi.CHAR, 1))]) config = platform.configure(CConfig) DIRP = rffi.COpaquePtr("DIR") DIRENT = config["DIRENT"] DIRENTP = lltype.Ptr(DIRENT) # XXX macro=True is hack to make sure we get the correct kind of # dirent struct (which depends on defines) os_opendir = rffi.llexternal("opendir", [rffi.CCHARP], DIRP, compilation_info=eci, save_err=rffi.RFFI_SAVE_ERRNO, macro=True) os_readdir = rffi.llexternal("readdir", [DIRP], DIRENTP, compilation_info=eci, save_err=rffi.RFFI_SAVE_ERRNO, macro=True)
from pypy.interpreter.function import ClassMethod, Method, StaticMethod from pypy.interpreter.gateway import interp2app from pypy.interpreter.typedef import (GetSetProperty, TypeDef, interp_attrproperty, interp_attrproperty_w) from pypy.objspace.std.typeobject import W_TypeObject from pypy.module.cpyext.api import (CONST_STRING, METH_CLASS, METH_COEXIST, METH_KEYWORDS, METH_NOARGS, METH_O, METH_STATIC, METH_VARARGS, PyObject, PyObjectFields, bootstrap_function, build_type_checkers, cpython_api, cpython_struct, generic_cpy_call) from pypy.module.cpyext.pyobject import (Py_DecRef, from_ref, make_ref, make_typedescr) PyCFunction_typedef = rffi.COpaquePtr(typedef='PyCFunction') PyCFunction = lltype.Ptr(lltype.FuncType([PyObject, PyObject], PyObject)) PyCFunctionKwArgs = lltype.Ptr( lltype.FuncType([PyObject, PyObject, PyObject], PyObject)) PyMethodDef = cpython_struct('PyMethodDef', [ ('ml_name', rffi.CCHARP), ('ml_meth', PyCFunction_typedef), ('ml_flags', rffi.INT_real), ('ml_doc', rffi.CCHARP), ]) PyCFunctionObjectStruct = cpython_struct( 'PyCFunctionObject', PyObjectFields + ( ('m_ml', lltype.Ptr(PyMethodDef)), ('m_self', PyObject),
globals().update(rffi_platform.configure(CConfig)) init = rffi.llexternal("zmq_init", [rffi.INT], rffi.VOIDP, compilation_info=info) socket = rffi.llexternal("zmq_socket", [rffi.VOIDP, rffi.INT], rffi.VOIDP, compilation_info=info) bind = rffi.llexternal("zmq_bind", [rffi.VOIDP, rffi.CCHARP], rffi.INT, compilation_info=info) msg_t = rffi.COpaquePtr('zmq_msg_t', compilation_info=info) msg_send = rffi.llexternal("zmq_msg_send", [msg_t, rffi.VOIDP, rffi.INT], rffi.INT, compilation_info=info) msg_recv = rffi.llexternal("zmq_msg_recv", [msg_t, rffi.VOIDP, rffi.INT], rffi.INT, compilation_info=info) msg_init_size = rffi.llexternal("zmq_msg_init_size", [msg_t, rffi.SIZE_T], rffi.SIZE_T, compilation_info=info) msg_init = rffi.llexternal("zmq_msg_init", [msg_t], rffi.INT,
rffi.INT, save_err=rffi.RFFI_SAVE_ERRNO) if sys.platform != 'win32': itimervalP = rffi.CArrayPtr(itimerval) c_setitimer = external('setitimer', [rffi.INT, itimervalP, itimervalP], rffi.INT, save_err=rffi.RFFI_SAVE_ERRNO) c_getitimer = external('getitimer', [rffi.INT, itimervalP], rffi.INT) c_pthread_kill = external('pthread_kill', [lltype.Signed, rffi.INT], rffi.INT, save_err=rffi.RFFI_SAVE_ERRNO) if sys.platform != 'win32': c_sigset_t = rffi.COpaquePtr('sigset_t', compilation_info=eci) c_sigemptyset = external('sigemptyset', [c_sigset_t], rffi.INT) c_sigaddset = external('sigaddset', [c_sigset_t, rffi.INT], rffi.INT) c_sigismember = external('sigismember', [c_sigset_t, rffi.INT], rffi.INT) c_sigwait = external('sigwait', [c_sigset_t, rffi.INTP], rffi.INT, releasegil=True, save_err=rffi.RFFI_SAVE_ERRNO) c_sigpending = external('sigpending', [c_sigset_t], rffi.INT, save_err=rffi.RFFI_SAVE_ERRNO) c_pthread_sigmask = external('pthread_sigmask', [rffi.INT, c_sigset_t, c_sigset_t], rffi.INT, save_err=rffi.RFFI_SAVE_ERRNO)
for k, v in rffi_platform.configure(CConfig).items(): globals()[k] = v def winexternal(name, args, result, **kwds): return rffi.llexternal(name, args, result, compilation_info=eci, calling_conv='win', **kwds) if WIN32: HANDLE = rffi.COpaquePtr(typedef='HANDLE') assert rffi.cast(HANDLE, -1) == rffi.cast(HANDLE, -1) LPHANDLE = rffi.CArrayPtr(HANDLE) HMODULE = HANDLE NULL_HANDLE = rffi.cast(HANDLE, 0) INVALID_HANDLE_VALUE = rffi.cast(HANDLE, -1) GENERIC_READ = rffi.cast(DWORD, r_longlong(0x80000000)) GENERIC_WRITE = rffi.cast(DWORD, r_longlong(0x40000000)) GENERIC_EXECUTE = rffi.cast(DWORD, r_longlong(0x20000000)) GENERIC_ALL = rffi.cast(DWORD, r_longlong(0x10000000)) FILE_SHARE_READ = rffi.cast(DWORD, r_longlong(0x00000001)) FILE_SHARE_WRITE = rffi.cast(DWORD, r_longlong(0x00000002)) PFILETIME = rffi.CArrayPtr(FILETIME)
('next_in', rffi.CCHARP), ('avail_in', rffi.UINT), ('total_in_lo32', rffi.UINT), ('total_in_hi32', rffi.UINT), ('next_out', rffi.CCHARP), ('avail_out', rffi.UINT), ('total_out_lo32', rffi.UINT), ('total_out_hi32', rffi.UINT), ('state', rffi.VOIDP), ('bzalloc', lltype.Ptr(_alloc_type)), ('bzfree', lltype.Ptr(_free_type)), ('opaque', rffi.VOIDP), ]) FILE = rffi.COpaquePtr('FILE') BZFILE = rffi.COpaquePtr('BZFILE') constants = {} constant_names = [ 'BZ_RUN', 'BZ_FLUSH', 'BZ_FINISH', 'BZ_OK', 'BZ_RUN_OK', 'BZ_FLUSH_OK', 'BZ_FINISH_OK', 'BZ_STREAM_END', 'BZ_SEQUENCE_ERROR', 'BZ_PARAM_ERROR', 'BZ_MEM_ERROR', 'BZ_DATA_ERROR', 'BZ_DATA_ERROR_MAGIC', 'BZ_IO_ERROR', 'BZ_UNEXPECTED_EOF', 'BZ_OUTBUFF_FULL', 'BZ_CONFIG_ERROR' ] for name in constant_names: setattr(CConfig, name, platform.DefinedConstantInteger(name)) class cConfig(object): pass
rffi_platform.verify_eci(eci.convert_sources_to_files()) def llexternal(name, args, result, **kwds): return rffi.llexternal(name, args, result, compilation_info=eci, _nowrapper=True, **kwds) # ----- types ----- handle = rffi.COpaquePtr(typedef='stacklet_handle', compilation_info=eci) thread_handle = rffi.COpaquePtr(typedef='stacklet_thread_handle', compilation_info=eci) run_fn = lltype.Ptr(lltype.FuncType([handle, llmemory.Address], handle)) # ----- constants ----- null_handle = lltype.nullptr(handle.TO) def is_empty_handle(h): return rffi.cast(lltype.Signed, h) == -1 # ----- functions -----
# So we replace an attribute access with a macro call. '#define pypy_GENERAL_NAME_dirn(name) (name->d.dirn)', '#define pypy_GENERAL_NAME_uri(name) (name->d.uniformResourceIdentifier)', '#define pypy_GENERAL_NAME_pop_free(names) (sk_GENERAL_NAME_pop_free(names, GENERAL_NAME_free))', '#define pypy_X509_OBJECT_data_x509(obj) (obj->data.x509)', '#define pypy_DIST_POINT_fullname(obj) (obj->distpoint->name.fullname)', ], ) eci = rffi_platform.configure_external_library('openssl', eci, [ dict(prefix='openssl-', include_dir='inc32', library_dir='out32'), ]) ASN1_STRING = lltype.Ptr(lltype.ForwardReference()) ASN1_IA5STRING = ASN1_STRING ASN1_ITEM = rffi.COpaquePtr('ASN1_ITEM') ASN1_OBJECT = rffi.COpaquePtr('ASN1_OBJECT') X509_NAME = rffi.COpaquePtr('X509_NAME') X509_VERIFY_PARAM = rffi.COpaquePtr('X509_VERIFY_PARAM') stack_st_X509_OBJECT = rffi.COpaquePtr('STACK_OF(X509_OBJECT)') DIST_POINT = rffi.COpaquePtr('DIST_POINT') stack_st_DIST_POINT = rffi.COpaquePtr('STACK_OF(X509_OBJECT)') DH = rffi.COpaquePtr('DH') EC_KEY = rffi.COpaquePtr('EC_KEY') AUTHORITY_INFO_ACCESS = rffi.COpaquePtr('AUTHORITY_INFO_ACCESS') GENERAL_NAME = lltype.Ptr(lltype.ForwardReference()) class CConfigBootstrap: _compilation_info_ = eci OPENSSL_EXPORT_VAR_AS_FUNCTION = rffi_platform.Defined(
srcdir.join('src', 'cjkcodecs', '_codecs_iso2022.c'), srcdir.join('src', 'cjkcodecs', '_codecs_jp.c'), srcdir.join('src', 'cjkcodecs', '_codecs_kr.c'), srcdir.join('src', 'cjkcodecs', '_codecs_tw.c'), srcdir.join('src', 'cjkcodecs', 'multibytecodec.c'), ], includes=['src/cjkcodecs/multibytecodec.h'], include_dirs=[str(srcdir), cdir], ) MBERR_TOOSMALL = -1 # insufficient output buffer space MBERR_TOOFEW = -2 # incomplete input buffer MBERR_INTERNAL = -3 # internal runtime error MBERR_NOMEMORY = -4 # out of memory MULTIBYTECODEC_P = rffi.COpaquePtr('struct MultibyteCodec_s', compilation_info=eci) def llexternal(*args, **kwds): kwds.setdefault('compilation_info', eci) kwds.setdefault('sandboxsafe', True) kwds.setdefault('_nowrapper', True) return rffi.llexternal(*args, **kwds) def getter_for(name): return llexternal('pypy_cjkcodec_%s' % name, [], MULTIBYTECODEC_P) _codecs_getters = dict([(name, getter_for(name)) for name in codecs]) assert len(_codecs_getters) == len(codecs)
file_flags = { u"RDONLY": cConfig['O_RDONLY'], u"WRONLY": cConfig['O_WRONLY'], u"RDWR": cConfig['O_RDWR'], u"APPEND": cConfig['O_APPEND'], u"CREAT": cConfig['O_CREAT'], u"EXCL": cConfig['O_EXCL'], u"TRUNC": cConfig['O_TRUNC'], } dirent_ptr = lltype.Ptr(cConfig["dirent_t"]) # Handle types loop_ptr = rffi.COpaquePtr("uv_loop_t") handle_ptr = lltype.Ptr(cConfig["handle_t"]) stream_ptr = lltype.Ptr(cConfig["stream_t"]) tcp_ptr = lltype.Ptr(cConfig["tcp_t"]) udp_ptr = lltype.Ptr(cConfig["udp_t"]) pipe_ptr = lltype.Ptr(cConfig["pipe_t"]) tty_ptr = lltype.Ptr(cConfig["tty_t"]) poll_ptr = lltype.Ptr(cConfig["poll_t"]) timer_ptr = lltype.Ptr(cConfig["timer_t"]) prepare_ptr = lltype.Ptr(cConfig["prepare_t"]) check_ptr = lltype.Ptr(cConfig["check_t"]) idle_ptr = lltype.Ptr(cConfig["idle_t"]) async_ptr = lltype.Ptr(cConfig["async_t"]) process_ptr = lltype.Ptr(cConfig["process_t"]) fs_event_ptr = lltype.Ptr(cConfig["fs_event_t"])
CConfig.WSANETWORKEVENTS = platform.Struct( 'struct _WSANETWORKEVENTS', [ ('lNetworkEvents', rffi.LONG), ('iErrorCode', rffi.CFixedArray(rffi.INT, 10)), #FD_MAX_EVENTS ]) CConfig.WSAPROTOCOL_INFO = platform.Struct( 'WSAPROTOCOL_INFOA', []) # Struct is just passed between functions CConfig.FROM_PROTOCOL_INFO = platform.DefinedConstantInteger( 'FROM_PROTOCOL_INFO') CConfig.timeval = platform.Struct('struct timeval', [('tv_sec', rffi.LONG), ('tv_usec', rffi.LONG)]) fd_set = rffi.COpaquePtr('fd_set', compilation_info=eci) if _WIN32: CConfig.WSAData = platform.Struct( 'struct WSAData', [ ('wVersion', rffi.USHORT), ('wHighVersion', rffi.USHORT), ('szDescription', rffi.CFixedArray(lltype.Char, 1)), # (WSADESCRIPTION_LEN+1) ('szSystemStatus', rffi.CFixedArray(lltype.Char, 1)), # (WSASYS_STATUS_LEN+1) ('iMaxSockets', rffi.USHORT), ('iMaxUdpDg', rffi.USHORT), ('lpVendorInfo', CCHARP) ])
class CConfig: _compilation_info_ = eci BZ_OK = platform.DefinedConstantInteger('BZ_OK') BZ_STREAM_END = platform.DefinedConstantInteger('BZ_STREAM_END') globals().update(platform.configure(CConfig)) def external(name, args, result): return rffi.llexternal(name, args, result, compilation_info=eci) BZFILEPTR = rffi.VOIDP FILEP = rffi.COpaquePtr('FILE') c_bz_read_open = external( 'BZ2_bzReadOpen', [rffi.INTP, FILEP, rffi.INT, rffi.INT, rffi.VOIDP, rffi.INT], BZFILEPTR) c_bz_read_close = external('BZ2_bzReadClose', [rffi.INTP, BZFILEPTR], lltype.Void) c_bz_read = external('BZ2_bzRead', [rffi.INTP, BZFILEPTR, rffi.VOIDP, rffi.INT], rffi.INT) c_bz_write_open = external('BZ2_bzWriteOpen', [rffi.INTP, FILEP, rffi.INT, rffi.INT, rffi.INT], BZFILEPTR)
libname = 'expat' pre_include_bits = [] eci = ExternalCompilationInfo( libraries=[libname], library_dirs=platform.preprocess_library_dirs([]), includes=['expat.h'], include_dirs=platform.preprocess_include_dirs([]), pre_include_bits=pre_include_bits, ) eci = rffi_platform.configure_external_library(libname, eci, [ dict(prefix='expat-', include_dir='lib', library_dir='win32/bin/release'), ]) XML_Content_Ptr = lltype.Ptr(lltype.ForwardReference()) XML_Parser = rffi.COpaquePtr(typedef='XML_Parser') xml_error_list = [ "XML_ERROR_NO_MEMORY", "XML_ERROR_SYNTAX", "XML_ERROR_NO_ELEMENTS", "XML_ERROR_INVALID_TOKEN", "XML_ERROR_UNCLOSED_TOKEN", "XML_ERROR_PARTIAL_CHAR", "XML_ERROR_TAG_MISMATCH", "XML_ERROR_DUPLICATE_ATTRIBUTE", "XML_ERROR_JUNK_AFTER_DOC_ELEMENT", "XML_ERROR_PARAM_ENTITY_REF", "XML_ERROR_UNDEFINED_ENTITY", "XML_ERROR_RECURSIVE_ENTITY_REF", "XML_ERROR_ASYNC_ENTITY",
def _emulated_start_new_thread(func): import thread try: ident = thread.start_new_thread(func, ()) except thread.error: ident = -1 return rffi.cast(rffi.LONG, ident) CALLBACK = lltype.Ptr(lltype.FuncType([], lltype.Void)) c_thread_start = llexternal('RPyThreadStart', [CALLBACK], rffi.LONG, _callable=_emulated_start_new_thread, releasegil=True) # release the GIL, but most # importantly, reacquire it # around the callback TLOCKP = rffi.COpaquePtr('struct RPyOpaque_ThreadLock', compilation_info=eci) TLOCKP_SIZE = rffi_platform.sizeof('struct RPyOpaque_ThreadLock', eci) c_thread_lock_init = llexternal('RPyThreadLockInit', [TLOCKP], rffi.INT, releasegil=False) # may add in a global list c_thread_lock_dealloc_NOAUTO = llexternal('RPyOpaqueDealloc_ThreadLock', [TLOCKP], lltype.Void, _nowrapper=True) c_thread_acquirelock = llexternal('RPyThreadAcquireLock', [TLOCKP, rffi.INT], rffi.INT, releasegil=True) # release the GIL c_thread_acquirelock_timed = llexternal('RPyThreadAcquireLockTimed', [TLOCKP, rffi.LONGLONG, rffi.INT], rffi.INT, releasegil=True) # release the GIL c_thread_releaselock = llexternal('RPyThreadReleaseLock', [TLOCKP], lltype.Signed,
library_dirs=Config.LIBPCRE_LIBRARY_DIRS, \ libraries=Config.LIBPCRE_LIBRARIES, \ link_extra=Config.LIBPCRE_LINK_FLAGS, \ link_files=[Config.LIBPCRE_A]) class CConfig: _compilation_info_ = eci PCRE_DOTALL = platform.DefinedConstantInteger("PCRE_DOTALL") PCRE_MULTILINE = platform.DefinedConstantInteger("PCRE_MULTILINE") PCRE_INFO_CAPTURECOUNT = platform.DefinedConstantInteger("PCRE_INFO_CAPTURECOUNT") PCRE_ANCHORED = platform.DefinedConstantInteger("PCRE_ANCHORED") PCRE_ERROR_NOMATCH = platform.DefinedConstantInteger("PCRE_ERROR_NOMATCH") cconfig = platform.configure(CConfig) PCREP = rffi.COpaquePtr("pcre") PCRE_DOTALL = cconfig["PCRE_DOTALL"] PCRE_MULTILINE = cconfig["PCRE_MULTILINE"] PCRE_INFO_CAPTURECOUNT = cconfig["PCRE_INFO_CAPTURECOUNT"] PCRE_ANCHORED = cconfig["PCRE_ANCHORED"] PCRE_ERROR_NOMATCH = cconfig["PCRE_ERROR_NOMATCH"] pcre_compile = rffi.llexternal("pcre_compile", \ [rffi.CCHARP, rffi.INT, rffi.CCHARPP, rffi.INTP, rffi.VOIDP], PCREP, compilation_info=eci) pcre_fullinfo = rffi.llexternal("pcre_fullinfo", \ [PCREP, rffi.VOIDP, rffi.INT, rffi.INTP], rffi.INT, compilation_info=eci) pcre_exec = rffi.llexternal("pcre_exec", \ [PCREP, rffi.VOIDP, rffi.CCHARP, rffi.INT, rffi.INT, rffi.INT, rffi.INTP, rffi.INT], \ rffi.INT, compilation_info=eci)