def test_ifdef(): class CConfig: _compilation_info_ = ExternalCompilationInfo( post_include_bits = ['/* a C comment */', '#define XYZZY 42', 'typedef int foo;', ''' struct s { int i; double f; }; ''']) s = rffi_platform.Struct('struct s', [('i', rffi.INT)], ifdef='XYZZY') z = rffi_platform.Struct('struct z', [('i', rffi.INT)], ifdef='FOOBAR') foo = rffi_platform.SimpleType('foo', ifdef='XYZZY') bar = rffi_platform.SimpleType('bar', ifdef='FOOBAR') res = rffi_platform.configure(CConfig) assert res['s'] is not None assert res['z'] is None assert res['foo'] is not None assert res['bar'] is None
def guess_eci(): for eci in try_eci(): class CConfig: _compilation_info_ = eci HAS = rffi_platform.Has("setupterm") if rffi_platform.configure(CConfig)['HAS']: return eci raise ImportError("failed to guess where ncurses is installed. " "You might need to install libncurses5-dev or similar.")
def test_integer_function_result(): class CConfig: _compilation_info_ = ExternalCompilationInfo( pre_include_bits=["""int sum(int a, int b){ return a+b;}"""], ) SUM = rffi_platform.IntegerFunctionResult('sum', [12, 34]) SUM2 = rffi_platform.IntegerFunctionResult('sum', [-12, -34]) res = rffi_platform.configure(CConfig) assert res['SUM'] == 46 assert res['SUM2'] == -46
def test_integer_function_result(): class CConfig: _compilation_info_ = ExternalCompilationInfo( pre_include_bits = ["""int sum(int a, int b){ return a+b;}"""], ) SUM = rffi_platform.IntegerFunctionResult('sum', [12, 34]) SUM2 = rffi_platform.IntegerFunctionResult('sum', [-12, -34]) res = rffi_platform.configure(CConfig) assert res['SUM'] == 46 assert res['SUM2'] == -46
def posix_declaration(try_to_add=None): global STAT_STRUCT, STATVFS_STRUCT LL_STAT_FIELDS = STAT_FIELDS[:] if try_to_add: LL_STAT_FIELDS.append(try_to_add) if TIMESPEC is not None: def _expand(lst, originalname, timespecname): if _MACOS: # fields are named e.g. st_atimespec timespecname = originalname + "spec" else: # fields are named e.g. st_atim, with no e timespecname = originalname[:-1] for i, (_name, _TYPE) in enumerate(lst): if _name == originalname: # replace the 'st_atime' field of type rffi.DOUBLE # with the corresponding 'struct timespec' field lst[i] = (timespecname, TIMESPEC) break _expand(LL_STAT_FIELDS, 'st_atime', 'st_atim') _expand(LL_STAT_FIELDS, 'st_mtime', 'st_mtim') _expand(LL_STAT_FIELDS, 'st_ctime', 'st_ctim') del _expand else: # Replace float fields with integers for name in ('st_atime', 'st_mtime', 'st_ctime', 'st_birthtime'): for i, (_name, _TYPE) in enumerate(LL_STAT_FIELDS): if _name == name: LL_STAT_FIELDS[i] = (_name, lltype.Signed) break class CConfig: _compilation_info_ = compilation_info STAT_STRUCT = platform.Struct('struct %s' % _name_struct_stat, LL_STAT_FIELDS) STATVFS_STRUCT = platform.Struct('struct statvfs', STATVFS_FIELDS) try: config = platform.configure(CConfig, ignore_errors=try_to_add is not None) except platform.CompilationError: if try_to_add: return # failed to add this field, give up raise STAT_STRUCT = lltype.Ptr(config['STAT_STRUCT']) STATVFS_STRUCT = lltype.Ptr(config['STATVFS_STRUCT']) if try_to_add: STAT_FIELDS.append(try_to_add)
def test_padding_in_prebuilt_struct(self): from rpython.rtyper.lltypesystem import rffi from rpython.rtyper.tool import rffi_platform eci = rffi_platform.eci_from_header(""" typedef struct { char c1; /* followed by one byte of padding */ short s1; char c2; /* followed by 3 bytes of padding */ int i2; char c3; /* followed by 3 or 7 bytes of padding */ Signed l3; char c4; /* followed by 3 or 7 bytes of padding */ long l4; char c5; } foobar_t; """) class CConfig: _compilation_info_ = eci STRUCT = rffi_platform.Struct("foobar_t", [("c1", Signed), ("s1", Signed), ("l3", Signed), ("l4", Signed)]) S = rffi_platform.configure(CConfig)['STRUCT'] assert 'get_padding_drop' in S._hints assert 'eci' in S._hints s1 = malloc(S, immortal=True) s1.c_c1 = rffi.cast(S.c_c1, -12) s1.c_s1 = rffi.cast(S.c_s1, -7843) s1.c_l3 = -98765432 s1.c_l4 = rffi.cast(S.c_l4, -91234567) s2 = malloc(S, immortal=True) s2.c_c1 = rffi.cast(S.c_c1, -123) s2.c_s1 = rffi.cast(S.c_s1, -789) s2.c_l3 = -9999999 s2.c_l4 = rffi.cast(S.c_l4, -9111111) # def f(n): if n > 5: s = s1 else: s = s2 return s.c_l3 # fn = self.getcompiled(f, [int]) res = fn(10) assert res == -98765432 res = fn(1) assert res == -9999999
def configure(self, CConfig): classes_seen = self.__dict__.setdefault('__classes_seen', {}) if CConfig in classes_seen: return from rpython.rtyper.tool import rffi_platform as platform # copy some stuff if self.compilation_info is None: self.compilation_info = CConfig._compilation_info_ else: self.compilation_info = self.compilation_info.merge( CConfig._compilation_info_) self.__dict__.update(platform.configure(CConfig)) classes_seen[CConfig] = True
def posix_declaration(try_to_add=None): global STAT_STRUCT, STATVFS_STRUCT LL_STAT_FIELDS = STAT_FIELDS[:] if try_to_add: LL_STAT_FIELDS.append(try_to_add) if TIMESPEC is not None: def _expand(lst, originalname, timespecname): for i, (_name, _TYPE) in enumerate(lst): if _name == originalname: # replace the 'st_atime' field of type rffi.DOUBLE # with a field 'st_atim' of type 'struct timespec' lst[i] = (timespecname, TIMESPEC.TO) break _expand(LL_STAT_FIELDS, "st_atime", "st_atim") _expand(LL_STAT_FIELDS, "st_mtime", "st_mtim") _expand(LL_STAT_FIELDS, "st_ctime", "st_ctim") del _expand else: # Replace float fields with integers for name in ("st_atime", "st_mtime", "st_ctime", "st_birthtime"): for i, (_name, _TYPE) in enumerate(LL_STAT_FIELDS): if _name == name: LL_STAT_FIELDS[i] = (_name, lltype.Signed) break class CConfig: _compilation_info_ = compilation_info STAT_STRUCT = platform.Struct("struct %s" % _name_struct_stat, LL_STAT_FIELDS) STATVFS_STRUCT = platform.Struct("struct statvfs", STATVFS_FIELDS) try: config = platform.configure(CConfig, ignore_errors=try_to_add is not None) except platform.CompilationError: if try_to_add: return # failed to add this field, give up raise STAT_STRUCT = lltype.Ptr(config["STAT_STRUCT"]) STATVFS_STRUCT = lltype.Ptr(config["STATVFS_STRUCT"]) if try_to_add: STAT_FIELDS.append(try_to_add)
def test_configure(): test_h = udir.join('test_ctypes_platform.h') test_h.write('#define XYZZY 42\n') class CConfig: _compilation_info_ = ExternalCompilationInfo(pre_include_bits=[ "/* a C comment */", "#include <stdio.h>", "#include <test_ctypes_platform.h>" ], include_dirs=[str(udir)]) FILE = rffi_platform.Struct('FILE', []) ushort = rffi_platform.SimpleType('unsigned short') XYZZY = rffi_platform.ConstantInteger('XYZZY') res = rffi_platform.configure(CConfig) assert isinstance(res['FILE'], lltype.Struct) assert res == {'FILE': res['FILE'], 'ushort': rffi.USHORT, 'XYZZY': 42}
def test_padding_in_prebuilt_struct(self): from rpython.rtyper.lltypesystem import rffi from rpython.rtyper.tool import rffi_platform eci = rffi_platform.eci_from_header(""" typedef struct { char c1; /* followed by one byte of padding */ short s1; char c2; /* followed by 3 bytes of padding */ int i2; char c3; /* followed by 3 or 7 bytes of padding */ long l3; char c4; } foobar_t; """) class CConfig: _compilation_info_ = eci STRUCT = rffi_platform.Struct("foobar_t", [("c1", Signed), ("s1", Signed), ("l3", Signed)]) S = rffi_platform.configure(CConfig)['STRUCT'] assert 'get_padding_drop' in S._hints assert 'eci' in S._hints s1 = malloc(S, immortal=True) s1.c_c1 = rffi.cast(S.c_c1, -12) s1.c_s1 = rffi.cast(S.c_s1, -7843) s1.c_l3 = -98765432 s2 = malloc(S, immortal=True) s2.c_c1 = rffi.cast(S.c_c1, -123) s2.c_s1 = rffi.cast(S.c_s1, -789) s2.c_l3 = -9999999 # def f(n): if n > 5: s = s1 else: s = s2 return s.c_l3 # fn = self.getcompiled(f, [int]) res = fn(10) assert res == -98765432 res = fn(1) assert res == -9999999
def test_configure(): test_h = udir.join('test_ctypes_platform.h') test_h.write('#define XYZZY 42\n') class CConfig: _compilation_info_ = ExternalCompilationInfo( pre_include_bits = ["/* a C comment */", "#include <stdio.h>", "#include <test_ctypes_platform.h>"], include_dirs = [str(udir)] ) FILE = rffi_platform.Struct('FILE', []) ushort = rffi_platform.SimpleType('unsigned short') XYZZY = rffi_platform.ConstantInteger('XYZZY') res = rffi_platform.configure(CConfig) assert isinstance(res['FILE'], lltype.Struct) assert res == {'FILE': res['FILE'], 'ushort': rffi.USHORT, 'XYZZY': 42}
def configure_boehm_once(cls): """ Configure boehm only once, since we don't cache failures """ if hasattr(cls, 'malloc_fn_ptr'): return cls.malloc_fn_ptr from rpython.rtyper.tool import rffi_platform compilation_info = rffi_platform.configure_boehm() # on some platform GC_init is required before any other # GC_* functions, call it here for the benefit of tests # XXX move this to tests init_fn_ptr = rffi.llexternal("GC_init", [], lltype.Void, compilation_info=compilation_info, sandboxsafe=True, _nowrapper=True) init_fn_ptr() # Versions 6.x of libgc needs to use GC_local_malloc(). # Versions 7.x of libgc removed this function; GC_malloc() has # the same behavior if libgc was compiled with # THREAD_LOCAL_ALLOC. class CConfig: _compilation_info_ = compilation_info HAS_LOCAL_MALLOC = rffi_platform.Has("GC_local_malloc") config = rffi_platform.configure(CConfig) if config['HAS_LOCAL_MALLOC']: GC_MALLOC = "GC_local_malloc" else: GC_MALLOC = "GC_malloc" malloc_fn_ptr = rffi.llexternal( GC_MALLOC, [lltype.Signed], # size_t, but good enough llmemory.GCREF, compilation_info=compilation_info, sandboxsafe=True, _nowrapper=True) cls.malloc_fn_ptr = malloc_fn_ptr return malloc_fn_ptr
def test_ifdef(): class CConfig: _compilation_info_ = ExternalCompilationInfo(post_include_bits=[ '/* a C comment */', '#define XYZZY 42', 'typedef int foo;', ''' struct s { int i; double f; }; ''' ]) s = rffi_platform.Struct('struct s', [('i', rffi.INT)], ifdef='XYZZY') z = rffi_platform.Struct('struct z', [('i', rffi.INT)], ifdef='FOOBAR') foo = rffi_platform.SimpleType('foo', ifdef='XYZZY') bar = rffi_platform.SimpleType('bar', ifdef='FOOBAR') res = rffi_platform.configure(CConfig) assert res['s'] is not None assert res['z'] is None assert res['foo'] is not None assert res['bar'] is None
def test_nested_structs_in_the_opposite_order(): class CConfig: _compilation_info_ = ExternalCompilationInfo( post_include_bits=[""" struct y { int foo; unsigned long bar; }; struct x { char c; struct y y; }; """]) y = rffi_platform.Struct("struct y", [("bar", rffi.SHORT)]) x = rffi_platform.Struct("struct x", [("y", y)]) res = rffi_platform.configure(CConfig) c_x = res["x"] c_y = res["y"] assert isinstance(c_x, lltype.Struct) assert isinstance(c_y, lltype.Struct) assert c_x.c_y is c_y
def configure_boehm_once(cls): """ Configure boehm only once, since we don't cache failures """ if hasattr(cls, 'malloc_fn_ptr'): return cls.malloc_fn_ptr from rpython.rtyper.tool import rffi_platform compilation_info = rffi_platform.configure_boehm() # on some platform GC_init is required before any other # GC_* functions, call it here for the benefit of tests # XXX move this to tests init_fn_ptr = rffi.llexternal("GC_init", [], lltype.Void, compilation_info=compilation_info, sandboxsafe=True, _nowrapper=True) init_fn_ptr() # Versions 6.x of libgc needs to use GC_local_malloc(). # Versions 7.x of libgc removed this function; GC_malloc() has # the same behavior if libgc was compiled with # THREAD_LOCAL_ALLOC. class CConfig: _compilation_info_ = compilation_info HAS_LOCAL_MALLOC = rffi_platform.Has("GC_local_malloc") config = rffi_platform.configure(CConfig) if config['HAS_LOCAL_MALLOC']: GC_MALLOC = "GC_local_malloc" else: GC_MALLOC = "GC_malloc" malloc_fn_ptr = rffi.llexternal(GC_MALLOC, [lltype.Signed], # size_t, but good enough llmemory.GCREF, compilation_info=compilation_info, sandboxsafe=True, _nowrapper=True) cls.malloc_fn_ptr = malloc_fn_ptr return malloc_fn_ptr
def test_nested_structs_in_the_opposite_order(): class CConfig: _compilation_info_ = ExternalCompilationInfo(post_include_bits=[ """ struct y { int foo; unsigned long bar; }; struct x { char c; struct y y; }; """ ]) y = rffi_platform.Struct("struct y", [("bar", rffi.SHORT)]) x = rffi_platform.Struct("struct x", [("y", y)]) res = rffi_platform.configure(CConfig) c_x = res["x"] c_y = res["y"] assert isinstance(c_x, lltype.Struct) assert isinstance(c_y, lltype.Struct) assert c_x.c_y is c_y
def make_utime_impl(traits): from rpython.rlib import rwin32 win32traits = make_win32_traits(traits) from rpython.rtyper.module.ll_os_stat import time_t_to_FILE_TIME class CConfig: _compilation_info_ = ExternalCompilationInfo( includes = ['windows.h'], ) FILE_WRITE_ATTRIBUTES = platform.ConstantInteger( 'FILE_WRITE_ATTRIBUTES') OPEN_EXISTING = platform.ConstantInteger( 'OPEN_EXISTING') FILE_FLAG_BACKUP_SEMANTICS = platform.ConstantInteger( 'FILE_FLAG_BACKUP_SEMANTICS') globals().update(platform.configure(CConfig)) CreateFile = rffi.llexternal( 'CreateFile' + win32traits.apisuffix, [traits.CCHARP, rwin32.DWORD, rwin32.DWORD, rwin32.LPSECURITY_ATTRIBUTES, rwin32.DWORD, rwin32.DWORD, rwin32.HANDLE], rwin32.HANDLE, calling_conv='win') GetSystemTime = rffi.llexternal( 'GetSystemTime', [lltype.Ptr(rwin32.SYSTEMTIME)], lltype.Void, calling_conv='win') SystemTimeToFileTime = rffi.llexternal( 'SystemTimeToFileTime', [lltype.Ptr(rwin32.SYSTEMTIME), lltype.Ptr(rwin32.FILETIME)], rwin32.BOOL, calling_conv='win') SetFileTime = rffi.llexternal( 'SetFileTime', [rwin32.HANDLE, lltype.Ptr(rwin32.FILETIME), lltype.Ptr(rwin32.FILETIME), lltype.Ptr(rwin32.FILETIME)], rwin32.BOOL, calling_conv = 'win') @specialize.argtype(1) def os_utime_llimpl(path, tp): hFile = CreateFile(path, FILE_WRITE_ATTRIBUTES, 0, None, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, rwin32.NULL_HANDLE) if hFile == rwin32.INVALID_HANDLE_VALUE: raise rwin32.lastWindowsError() ctime = lltype.nullptr(rwin32.FILETIME) atime = lltype.malloc(rwin32.FILETIME, flavor='raw') mtime = lltype.malloc(rwin32.FILETIME, flavor='raw') try: if tp is None: now = lltype.malloc(rwin32.SYSTEMTIME, flavor='raw') try: GetSystemTime(now) if (not SystemTimeToFileTime(now, atime) or not SystemTimeToFileTime(now, mtime)): raise rwin32.lastWindowsError() finally: lltype.free(now, flavor='raw') else: actime, modtime = tp time_t_to_FILE_TIME(actime, atime) time_t_to_FILE_TIME(modtime, mtime) if not SetFileTime(hFile, ctime, atime, mtime): raise rwin32.lastWindowsError() finally: rwin32.CloseHandle(hFile) lltype.free(atime, flavor='raw') lltype.free(mtime, flavor='raw') return os_utime_llimpl
_name_struct_stat = 'stat' INCLUDES = ['sys/types.h', 'sys/stat.h', 'sys/statvfs.h', 'unistd.h'] compilation_info = ExternalCompilationInfo( # This must be set to 64 on some systems to enable large file support. #pre_include_bits = ['#define _FILE_OFFSET_BITS 64'], # ^^^ nowadays it's always set in all C files we produce. includes=INCLUDES ) if TIMESPEC is not None: class CConfig_for_timespec: _compilation_info_ = compilation_info TIMESPEC = TIMESPEC TIMESPEC = lltype.Ptr( platform.configure(CConfig_for_timespec)['TIMESPEC']) def posix_declaration(try_to_add=None): global STAT_STRUCT, STATVFS_STRUCT LL_STAT_FIELDS = STAT_FIELDS[:] if try_to_add: LL_STAT_FIELDS.append(try_to_add) if TIMESPEC is not None: def _expand(lst, originalname, timespecname): for i, (_name, _TYPE) in enumerate(lst): if _name == originalname: # replace the 'st_atime' field of type rffi.DOUBLE
if platform.has("setupterm", "#include <curses.h>\n#include <term.h>"): HAVE_CURSES = True setupterm = rffi.llexternal("setupterm", [rffi.CCHARP, rffi.INT, rffi.INTP], rffi.INT, \ compilation_info=eci) tigetstr = rffi.llexternal("tigetstr", [rffi.CCHARP], rffi.CCHARP, compilation_info=eci) else: HAVE_CURSES = False class CConfig: _compilation_info_ = eci OK = platform.DefinedConstantInteger("OK") STDOUT_FILENO = platform.DefinedConstantInteger("STDOUT_FILENO") cconfig = platform.configure(CConfig) OK = cconfig["OK"] STDOUT_FILENO = cconfig["STDOUT_FILENO"] def init(vm): return new_c_con_module(vm, "Curses", "Curses", __file__, import_, \ ["Curses_Exception", "setupterm", "tigetstr"]) @con_object_proc def import_(vm): (mod,),_ = vm.decode_args("O")
if sys.platform != 'win32': for name in """ITIMER_REAL ITIMER_VIRTUAL ITIMER_PROF""".split(): setattr(CConfig, name, rffi_platform.DefinedConstantInteger(name)) CConfig.timeval = rffi_platform.Struct( 'struct timeval', [('tv_sec', rffi.LONG), ('tv_usec', rffi.LONG)]) CConfig.itimerval = rffi_platform.Struct( 'struct itimerval', [('it_value', CConfig.timeval), ('it_interval', CConfig.timeval)]) for k, v in rffi_platform.configure(CConfig).items(): globals()[k] = v def external(name, args, result, **kwds): return rffi.llexternal(name, args, result, compilation_info=eci, sandboxsafe=True, **kwds) pypysig_ignore = external('pypysig_ignore', [rffi.INT], lltype.Void) pypysig_default = external('pypysig_default', [rffi.INT], lltype.Void) pypysig_setflag = external('pypysig_setflag', [rffi.INT], lltype.Void) pypysig_reinstall = external('pypysig_reinstall', [rffi.INT], lltype.Void) pypysig_set_wakeup_fd = external('pypysig_set_wakeup_fd', [rffi.INT], rffi.INT) pypysig_poll = external('pypysig_poll', [], rffi.INT, releasegil=False) # don't bother releasing the GIL around a call to pypysig_poll: it's # pointless and a performance issue pypysig_pushback = external('pypysig_pushback', [rffi.INT], lltype.Void,
locals()[name] = rffi_platform.ConstantInteger(name) for name in xml_model_list: locals()[name] = rffi_platform.ConstantInteger(name) for name in xml_model_list: locals()[name] = rffi_platform.ConstantInteger(name) for name in xml_model_list: locals()[name] = rffi_platform.ConstantInteger(name) for name in xml_model_list: locals()[name] = rffi_platform.ConstantInteger(name) for name in xml_model_list: locals()[name] = rffi_platform.ConstantInteger(name) for name in xml_model_list: locals()[name] = rffi_platform.ConstantInteger(name) XML_Parser_SIZE = rffi_platform.SizeOf("XML_Parser") for k, v in rffi_platform.configure(CConfigure).items(): globals()[k] = v XML_COMBINED_VERSION = 10000*XML_MAJOR_VERSION+100*XML_MINOR_VERSION+XML_MICRO_VERSION XML_Content_Ptr.TO.become(rffi.CArray(XML_Content)) XML_Encoding_Ptr = lltype.Ptr(XML_Encoding) def expat_external(*a, **kw): kw['compilation_info'] = eci return rffi.llexternal(*a, **kw) INTERNED_CCHARP = "INTERNED" HANDLERS = dict(
def make_win32_traits(traits): from rpython.rlib import rwin32 global config_global if traits.str is unicode: suffix = 'W' else: suffix = 'A' class CConfig: _compilation_info_ = ExternalCompilationInfo( includes = ['windows.h', 'winbase.h', 'sys/stat.h'], ) WIN32_FIND_DATA = platform.Struct( 'struct _WIN32_FIND_DATA' + suffix, # Only interesting fields [('dwFileAttributes', rwin32.DWORD), ('ftCreationTime', rwin32.FILETIME), ('ftLastAccessTime', rwin32.FILETIME), ('ftLastWriteTime', rwin32.FILETIME), ('nFileSizeHigh', rwin32.DWORD), ('nFileSizeLow', rwin32.DWORD), ('dwReserved0', rwin32.DWORD), ('dwReserved1', rwin32.DWORD), ('cFileName', lltype.FixedSizeArray(traits.CHAR, 250))]) if config_global is None: config_global = platform.configure(GetCConfigGlobal()) config = config_global.copy() config.update(platform.configure(CConfig)) def external(*args, **kwargs): kwargs['compilation_info'] = CConfig._compilation_info_ llfunc = rffi.llexternal(calling_conv='win', *args, **kwargs) return staticmethod(llfunc) class Win32Traits: apisuffix = suffix for name in '''WIN32_FIND_DATA WIN32_FILE_ATTRIBUTE_DATA BY_HANDLE_FILE_INFORMATION FILE_ATTRIBUTE_TAG_INFO GetFileExInfoStandard FILE_ATTRIBUTE_DIRECTORY FILE_ATTRIBUTE_READONLY INVALID_FILE_ATTRIBUTES _S_IFDIR _S_IFREG _S_IFCHR _S_IFIFO FILE_TYPE_UNKNOWN FILE_TYPE_CHAR FILE_TYPE_PIPE ERROR_INVALID_PARAMETER FILE_TYPE_DISK GENERIC_READ FILE_SHARE_READ FILE_SHARE_WRITE ERROR_NOT_SUPPORTED FILE_FLAG_OPEN_REPARSE_POINT FileAttributeTagInfo FILE_READ_ATTRIBUTES FILE_ATTRIBUTE_NORMAL FILE_WRITE_ATTRIBUTES OPEN_EXISTING VOLUME_NAME_DOS VOLUME_NAME_NT ERROR_FILE_NOT_FOUND ERROR_NO_MORE_FILES ERROR_SHARING_VIOLATION MOVEFILE_REPLACE_EXISTING ERROR_ACCESS_DENIED ERROR_CANT_ACCESS_FILE ERROR_INVALID_FUNCTION FILE_FLAG_BACKUP_SEMANTICS FILE_ATTRIBUTE_REPARSE_POINT _O_RDONLY _O_WRONLY _O_BINARY '''.split(): locals()[name] = config[name] LPWIN32_FIND_DATA = lltype.Ptr(WIN32_FIND_DATA) GET_FILEEX_INFO_LEVELS = rffi.ULONG # an enumeration FindFirstFile = external('FindFirstFile' + suffix, [traits.CCHARP, LPWIN32_FIND_DATA], rwin32.HANDLE, save_err=rffi.RFFI_SAVE_LASTERROR) FindNextFile = external('FindNextFile' + suffix, [rwin32.HANDLE, LPWIN32_FIND_DATA], rwin32.BOOL, save_err=rffi.RFFI_SAVE_LASTERROR) FindClose = external('FindClose', [rwin32.HANDLE], rwin32.BOOL, releasegil=False) GetFileAttributes = external( 'GetFileAttributes' + suffix, [traits.CCHARP], rwin32.DWORD, save_err=rffi.RFFI_SAVE_LASTERROR) SetFileAttributes = external( 'SetFileAttributes' + suffix, [traits.CCHARP, rwin32.DWORD], rwin32.BOOL, save_err=rffi.RFFI_SAVE_LASTERROR) GetFileAttributesEx = external( 'GetFileAttributesEx' + suffix, [traits.CCHARP, GET_FILEEX_INFO_LEVELS, lltype.Ptr(WIN32_FILE_ATTRIBUTE_DATA)], rwin32.BOOL, save_err=rffi.RFFI_SAVE_LASTERROR) GetFileInformationByHandleEx = external( 'GetFileInformationByHandleEx', [rwin32.HANDLE, rffi.INT, rffi.VOIDP, rwin32.DWORD], rwin32.BOOL, save_err=rffi.RFFI_SAVE_LASTERROR) GetFileInformationByHandle = external( 'GetFileInformationByHandle', [rwin32.HANDLE, lltype.Ptr(BY_HANDLE_FILE_INFORMATION)], rwin32.BOOL, save_err=rffi.RFFI_SAVE_LASTERROR) GetFileType = external( 'GetFileType', [rwin32.HANDLE], rwin32.DWORD, save_err=rffi.RFFI_SAVE_LASTERROR) LPSTRP = rffi.CArrayPtr(traits.CCHARP) GetFullPathName = external( 'GetFullPathName' + suffix, [traits.CCHARP, rwin32.DWORD, traits.CCHARP, LPSTRP], rwin32.DWORD, save_err=rffi.RFFI_SAVE_LASTERROR) GetCurrentDirectory = external( 'GetCurrentDirectory' + suffix, [rwin32.DWORD, traits.CCHARP], rwin32.DWORD, save_err=rffi.RFFI_SAVE_LASTERROR) SetCurrentDirectory = external( 'SetCurrentDirectory' + suffix, [traits.CCHARP], rwin32.BOOL, save_err=rffi.RFFI_SAVE_LASTERROR) CreateDirectory = external( 'CreateDirectory' + suffix, [traits.CCHARP, rffi.VOIDP], rwin32.BOOL, save_err=rffi.RFFI_SAVE_LASTERROR) SetEnvironmentVariable = external( 'SetEnvironmentVariable' + suffix, [traits.CCHARP, traits.CCHARP], rwin32.BOOL, save_err=rffi.RFFI_SAVE_LASTERROR) CreateFile = external( 'CreateFile' + apisuffix, [traits.CCHARP, rwin32.DWORD, rwin32.DWORD, rwin32.LPSECURITY_ATTRIBUTES, rwin32.DWORD, rwin32.DWORD, rwin32.HANDLE], rwin32.HANDLE, save_err=rffi.RFFI_SAVE_LASTERROR) DeleteFile = external( 'DeleteFile' + suffix, [traits.CCHARP], rwin32.BOOL, save_err=rffi.RFFI_SAVE_LASTERROR) MoveFileEx = external( 'MoveFileEx' + suffix, [traits.CCHARP, traits.CCHARP, rwin32.DWORD], rwin32.BOOL, save_err=rffi.RFFI_SAVE_LASTERROR) CreateHardLink = external( 'CreateHardLink' + suffix, [traits.CCHARP, traits.CCHARP, rwin32.LPSECURITY_ATTRIBUTES], rwin32.BOOL, save_err=rffi.RFFI_SAVE_LASTERROR) TagInfoSize = 2 * rffi.sizeof(rwin32.DWORD) return Win32Traits
if sys.platform == 'win32': from rpython.rlib import rwin32 eci = ExternalCompilationInfo( includes = ['windows.h', 'wincrypt.h'], libraries = ['advapi32'], ) class CConfig: _compilation_info_ = eci PROV_RSA_FULL = rffi_platform.ConstantInteger( "PROV_RSA_FULL") CRYPT_VERIFYCONTEXT = rffi_platform.ConstantInteger( "CRYPT_VERIFYCONTEXT") globals().update(rffi_platform.configure(CConfig)) HCRYPTPROV = rwin32.ULONG_PTR CryptAcquireContext = rffi.llexternal( 'CryptAcquireContextA', [rffi.CArrayPtr(HCRYPTPROV), rwin32.LPCSTR, rwin32.LPCSTR, rwin32.DWORD, rwin32.DWORD], rwin32.BOOL, calling_conv='win', compilation_info=eci, save_err=rffi.RFFI_SAVE_LASTERROR) CryptGenRandom = rffi.llexternal( 'CryptGenRandom', [HCRYPTPROV, rwin32.DWORD, rffi.CArrayPtr(rwin32.BYTE)],
from rpython.translator.tool.cbuild import ExternalCompilationInfo # rffi-based pwd module eci = ExternalCompilationInfo(includes=['sys/types.h', 'pwd.h', 'grp.h']) class CConfig(object): _compilation_info_ = eci passwd = platform.Struct('struct passwd', [('pw_name', rffi.CCHARP), ('pw_passwd', rffi.CCHARP), ('pw_uid', lltype.Signed), ('pw_gid', lltype.Signed), ('pw_gecos', rffi.CCHARP), ('pw_dir', rffi.CCHARP), ('pw_shell', rffi.CCHARP)]) PASSWD = platform.configure(CConfig)['passwd'] PASSWDPTR = lltype.Ptr(PASSWD) getpwnam = rffi.llexternal('getpwnam', [rffi.CCHARP], PASSWDPTR, compilation_info=eci) getpwuid = rffi.llexternal('getpwuid', [lltype.Signed], PASSWDPTR, compilation_info=eci) initgroups = rffi.llexternal('initgroups', [rffi.CCHARP, lltype.Signed], rffi.INT, compilation_info=eci)
def setup(): INSPECT = { 'b': 'signed char', 'h': 'signed short', 'i': 'signed int', 'l': 'signed long', 'q': 'signed long long', 'n': 'ssize_t', 'B': 'unsigned char', 'H': 'unsigned short', 'I': 'unsigned int', 'L': 'unsigned long', 'Q': 'unsigned long long', 'N': 'size_t', 'P': 'char *', 'f': 'float', 'd': 'double', '?': '_Bool', } pre_include_bits = [ """ #include <sys/types.h> #ifdef _MSC_VER #define _Bool char typedef int ssize_t; /* XXX fixme for 64 bit*/ typedef unsigned int size_t; /* XXX fixme for 64 bit*/ #endif""" ] field_names = dict.fromkeys(INSPECT) for fmtchar, ctype in INSPECT.iteritems(): field_name = ctype.replace(" ", "_").replace("*", "star") field_names[fmtchar] = field_name pre_include_bits.append(""" struct about_%s { char pad; %s field; }; """ % (field_name, ctype)) class CConfig: _compilation_info_ = ExternalCompilationInfo( pre_include_bits=pre_include_bits) for fmtchar, ctype in INSPECT.items(): setattr( CConfig, field_names[fmtchar], rffi_platform.Struct( "struct about_%s" % (field_names[fmtchar], ), [('field', lltype.FixedSizeArray(rffi.CHAR, 1))])) cConfig = rffi_platform.configure(CConfig) for fmtchar, ctype in INSPECT.items(): S = cConfig[field_names[fmtchar]] alignment = rffi.offsetof(S, 'c_field') size = rffi.sizeof(S.c_field) signed = 'a' <= fmtchar <= 'z' if fmtchar == 'f': pack = pack_float unpack = std.unpack_float elif fmtchar == 'd': pack = pack_double unpack = std.unpack_double elif fmtchar == '?': pack = std.pack_bool unpack = std.unpack_bool else: pack = std.make_int_packer(size, signed) unpack = std.make_int_unpacker(size, signed) native_fmttable[fmtchar] = { 'size': size, 'alignment': alignment, 'pack': pack, 'unpack': unpack }
def make_win32_traits(traits): from rpython.rlib import rwin32 if traits.str is unicode: suffix = 'W' else: suffix = 'A' class CConfig: _compilation_info_ = ExternalCompilationInfo( includes=['windows.h', 'winbase.h', 'sys/stat.h'], ) WIN32_FIND_DATA = platform.Struct( 'struct _WIN32_FIND_DATA' + suffix, # Only interesting fields [('dwFileAttributes', rwin32.DWORD), ('nFileSizeHigh', rwin32.DWORD), ('nFileSizeLow', rwin32.DWORD), ('ftCreationTime', rwin32.FILETIME), ('ftLastAccessTime', rwin32.FILETIME), ('ftLastWriteTime', rwin32.FILETIME), ('cFileName', lltype.FixedSizeArray(traits.CHAR, 250))]) ERROR_FILE_NOT_FOUND = platform.ConstantInteger('ERROR_FILE_NOT_FOUND') ERROR_NO_MORE_FILES = platform.ConstantInteger('ERROR_NO_MORE_FILES') GetFileExInfoStandard = platform.ConstantInteger( 'GetFileExInfoStandard') FILE_ATTRIBUTE_DIRECTORY = platform.ConstantInteger( 'FILE_ATTRIBUTE_DIRECTORY') FILE_ATTRIBUTE_READONLY = platform.ConstantInteger( 'FILE_ATTRIBUTE_READONLY') INVALID_FILE_ATTRIBUTES = platform.ConstantInteger( 'INVALID_FILE_ATTRIBUTES') ERROR_SHARING_VIOLATION = platform.ConstantInteger( 'ERROR_SHARING_VIOLATION') MOVEFILE_REPLACE_EXISTING = platform.ConstantInteger( 'MOVEFILE_REPLACE_EXISTING') _S_IFDIR = platform.ConstantInteger('_S_IFDIR') _S_IFREG = platform.ConstantInteger('_S_IFREG') _S_IFCHR = platform.ConstantInteger('_S_IFCHR') _S_IFIFO = platform.ConstantInteger('_S_IFIFO') FILE_TYPE_UNKNOWN = platform.ConstantInteger('FILE_TYPE_UNKNOWN') FILE_TYPE_CHAR = platform.ConstantInteger('FILE_TYPE_CHAR') FILE_TYPE_PIPE = platform.ConstantInteger('FILE_TYPE_PIPE') FILE_WRITE_ATTRIBUTES = platform.ConstantInteger( 'FILE_WRITE_ATTRIBUTES') OPEN_EXISTING = platform.ConstantInteger('OPEN_EXISTING') FILE_FLAG_BACKUP_SEMANTICS = platform.ConstantInteger( 'FILE_FLAG_BACKUP_SEMANTICS') VOLUME_NAME_DOS = platform.ConstantInteger('VOLUME_NAME_DOS') VOLUME_NAME_NT = platform.ConstantInteger('VOLUME_NAME_NT') WIN32_FILE_ATTRIBUTE_DATA = platform.Struct( 'WIN32_FILE_ATTRIBUTE_DATA', [('dwFileAttributes', rwin32.DWORD), ('nFileSizeHigh', rwin32.DWORD), ('nFileSizeLow', rwin32.DWORD), ('ftCreationTime', rwin32.FILETIME), ('ftLastAccessTime', rwin32.FILETIME), ('ftLastWriteTime', rwin32.FILETIME)]) BY_HANDLE_FILE_INFORMATION = platform.Struct( 'BY_HANDLE_FILE_INFORMATION', [('dwFileAttributes', rwin32.DWORD), ('ftCreationTime', rwin32.FILETIME), ('ftLastAccessTime', rwin32.FILETIME), ('ftLastWriteTime', rwin32.FILETIME), ('dwVolumeSerialNumber', rwin32.DWORD), ('nFileSizeHigh', rwin32.DWORD), ('nFileSizeLow', rwin32.DWORD), ('nNumberOfLinks', rwin32.DWORD), ('nFileIndexHigh', rwin32.DWORD), ('nFileIndexLow', rwin32.DWORD)]) config = platform.configure(CConfig) def external(*args, **kwargs): kwargs['compilation_info'] = CConfig._compilation_info_ llfunc = rffi.llexternal(calling_conv='win', *args, **kwargs) return staticmethod(llfunc) class Win32Traits: apisuffix = suffix for name in '''WIN32_FIND_DATA WIN32_FILE_ATTRIBUTE_DATA BY_HANDLE_FILE_INFORMATION GetFileExInfoStandard FILE_ATTRIBUTE_DIRECTORY FILE_ATTRIBUTE_READONLY INVALID_FILE_ATTRIBUTES _S_IFDIR _S_IFREG _S_IFCHR _S_IFIFO FILE_TYPE_UNKNOWN FILE_TYPE_CHAR FILE_TYPE_PIPE FILE_WRITE_ATTRIBUTES OPEN_EXISTING FILE_FLAG_BACKUP_SEMANTICS VOLUME_NAME_DOS VOLUME_NAME_NT ERROR_FILE_NOT_FOUND ERROR_NO_MORE_FILES ERROR_SHARING_VIOLATION MOVEFILE_REPLACE_EXISTING '''.split(): locals()[name] = config[name] LPWIN32_FIND_DATA = lltype.Ptr(WIN32_FIND_DATA) GET_FILEEX_INFO_LEVELS = rffi.ULONG # an enumeration FindFirstFile = external('FindFirstFile' + suffix, [traits.CCHARP, LPWIN32_FIND_DATA], rwin32.HANDLE, save_err=rffi.RFFI_SAVE_LASTERROR) FindNextFile = external('FindNextFile' + suffix, [rwin32.HANDLE, LPWIN32_FIND_DATA], rwin32.BOOL, save_err=rffi.RFFI_SAVE_LASTERROR) FindClose = external('FindClose', [rwin32.HANDLE], rwin32.BOOL) GetFileAttributes = external('GetFileAttributes' + suffix, [traits.CCHARP], rwin32.DWORD, save_err=rffi.RFFI_SAVE_LASTERROR) SetFileAttributes = external('SetFileAttributes' + suffix, [traits.CCHARP, rwin32.DWORD], rwin32.BOOL, save_err=rffi.RFFI_SAVE_LASTERROR) GetFileAttributesEx = external('GetFileAttributesEx' + suffix, [ traits.CCHARP, GET_FILEEX_INFO_LEVELS, lltype.Ptr(WIN32_FILE_ATTRIBUTE_DATA) ], rwin32.BOOL, save_err=rffi.RFFI_SAVE_LASTERROR) GetFileInformationByHandle = external( 'GetFileInformationByHandle', [rwin32.HANDLE, lltype.Ptr(BY_HANDLE_FILE_INFORMATION)], rwin32.BOOL, save_err=rffi.RFFI_SAVE_LASTERROR) GetFileType = external('GetFileType', [rwin32.HANDLE], rwin32.DWORD, save_err=rffi.RFFI_SAVE_LASTERROR) LPSTRP = rffi.CArrayPtr(traits.CCHARP) GetFullPathName = external( 'GetFullPathName' + suffix, [traits.CCHARP, rwin32.DWORD, traits.CCHARP, LPSTRP], rwin32.DWORD, save_err=rffi.RFFI_SAVE_LASTERROR) GetCurrentDirectory = external('GetCurrentDirectory' + suffix, [rwin32.DWORD, traits.CCHARP], rwin32.DWORD, save_err=rffi.RFFI_SAVE_LASTERROR) SetCurrentDirectory = external('SetCurrentDirectory' + suffix, [traits.CCHARP], rwin32.BOOL, save_err=rffi.RFFI_SAVE_LASTERROR) CreateDirectory = external('CreateDirectory' + suffix, [traits.CCHARP, rffi.VOIDP], rwin32.BOOL, save_err=rffi.RFFI_SAVE_LASTERROR) SetEnvironmentVariable = external('SetEnvironmentVariable' + suffix, [traits.CCHARP, traits.CCHARP], rwin32.BOOL, save_err=rffi.RFFI_SAVE_LASTERROR) CreateFile = external('CreateFile' + apisuffix, [ traits.CCHARP, rwin32.DWORD, rwin32.DWORD, rwin32.LPSECURITY_ATTRIBUTES, rwin32.DWORD, rwin32.DWORD, rwin32.HANDLE ], rwin32.HANDLE, save_err=rffi.RFFI_SAVE_LASTERROR) DeleteFile = external('DeleteFile' + suffix, [traits.CCHARP], rwin32.BOOL, save_err=rffi.RFFI_SAVE_LASTERROR) MoveFileEx = external('MoveFileEx' + suffix, [traits.CCHARP, traits.CCHARP, rwin32.DWORD], rwin32.BOOL, save_err=rffi.RFFI_SAVE_LASTERROR) return Win32Traits
_compilation_info_ = eci # XXX If Z_PREFIX was defined for the libz build, then these types are # named z_uInt, z_uLong, and z_Bytef instead. uInt = rffi_platform.SimpleType('uInt', rffi.UINT) uLong = rffi_platform.SimpleType('uLong', rffi.ULONG) Bytef = rffi_platform.SimpleType('Bytef', rffi.UCHAR) voidpf = rffi_platform.SimpleType('voidpf', rffi.VOIDP) ZLIB_VERSION = rffi_platform.DefinedConstantString('ZLIB_VERSION') for _name in constantnames: setattr(SimpleCConfig, _name, rffi_platform.ConstantInteger(_name)) config = rffi_platform.configure(SimpleCConfig) voidpf = config['voidpf'] uInt = config['uInt'] uLong = config['uLong'] Bytef = config['Bytef'] Bytefp = lltype.Ptr(lltype.Array(Bytef, hints={'nolength': True})) ZLIB_VERSION = config['ZLIB_VERSION'] for _name in constantnames: globals()[_name] = config[_name] # The following parameter is copied from zutil.h, version 0.95, # according to CPython's zlibmodule.c DEFLATED = Z_DEFLATED if MAX_MEM_LEVEL >= 8:
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( "OPENSSL_EXPORT_VAR_AS_FUNCTION") OPENSSL_VERSION_NUMBER = rffi_platform.ConstantInteger( "OPENSSL_VERSION_NUMBER") cconfig = rffi_platform.configure(CConfigBootstrap) if cconfig["OPENSSL_EXPORT_VAR_AS_FUNCTION"]: ASN1_ITEM_EXP = lltype.Ptr(lltype.FuncType([], ASN1_ITEM)) else: ASN1_ITEM_EXP = ASN1_ITEM OPENSSL_VERSION_NUMBER = cconfig["OPENSSL_VERSION_NUMBER"] HAVE_TLSv1_2 = OPENSSL_VERSION_NUMBER >= 0x10001000 class CConfig: _compilation_info_ = eci SSLEAY_VERSION = rffi_platform.DefinedConstantString( "SSLEAY_VERSION", "SSLeay_version(SSLEAY_VERSION)") OPENSSL_NO_SSL2 = rffi_platform.Defined("OPENSSL_NO_SSL2") OPENSSL_NO_SSL3 = rffi_platform.Defined("OPENSSL_NO_SSL3")
from topaz.system import IS_WINDOWS if not IS_WINDOWS: class CConstants(object): _compilation_info_ = ExternalCompilationInfo(includes=['fcntl.h']) for const in [ "F_DUPFD", "F_GETFD", "F_GETLK", "F_SETFD", "F_GETFL", "F_SETFL", "F_SETLK", "F_SETLKW", "FD_CLOEXEC", "F_RDLCK", "F_UNLCK", "F_WRLCK", "O_CREAT", "O_EXCL", "O_NOCTTY", "O_TRUNC", "O_APPEND", "O_NONBLOCK", "O_NDELAY", "O_RDONLY", "O_RDWR", "O_WRONLY", "O_ACCMODE" ]: setattr(CConstants, const, rffi_platform.ConstantInteger(const)) fcntl_constants = rffi_platform.configure(CConstants) fcntl = _rsocket_rffi.fcntl else: fcntl_constants = {} def fcntl(fdtype, cmd, arg): raise NotImplementedError class Fcntl(object): moduledef = ModuleDef("Fcntl") @moduledef.setup_module def setup_module(space, w_mod): if not IS_WINDOWS: for key, value in fcntl_constants.items():
_name_struct_stat = 'stat' INCLUDES = ['sys/types.h', 'sys/stat.h', 'sys/statvfs.h', 'unistd.h'] compilation_info = ExternalCompilationInfo( # This must be set to 64 on some systems to enable large file support. #pre_include_bits = ['#define _FILE_OFFSET_BITS 64'], # ^^^ nowadays it's always set in all C files we produce. includes=INCLUDES) if TIMESPEC is not None: class CConfig_for_timespec: _compilation_info_ = compilation_info TIMESPEC = TIMESPEC TIMESPEC = lltype.Ptr(platform.configure(CConfig_for_timespec)['TIMESPEC']) def posix_declaration(try_to_add=None): global STAT_STRUCT, STATVFS_STRUCT LL_STAT_FIELDS = STAT_FIELDS[:] if try_to_add: LL_STAT_FIELDS.append(try_to_add) if TIMESPEC is not None: def _expand(lst, originalname, timespecname): for i, (_name, _TYPE) in enumerate(lst): if _name == originalname: # replace the 'st_atime' field of type rffi.DOUBLE
passwd = platform.Struct('struct passwd', [('pw_name', rffi.CCHARP), ('pw_passwd', rffi.CCHARP), ('pw_uid', lltype.Signed), ('pw_gid', lltype.Signed), ('pw_gecos', rffi.CCHARP), ('pw_dir', rffi.CCHARP), ('pw_shell', rffi.CCHARP)]) group = platform.Struct('struct group', [('gr_name', rffi.CCHARP), ('gr_passwd', rffi.CCHARP), ('gr_gid', lltype.Signed), ('gr_mem', rffi.CCHARPP)]) PASSWD = platform.configure(CConfig)['passwd'] PASSWDPTR = lltype.Ptr(PASSWD) GROUP = platform.configure(CConfig)['group'] GROUPPTR = lltype.Ptr(GROUP) getpwnam = rffi.llexternal('getpwnam', [rffi.CCHARP], PASSWDPTR, compilation_info=eci) getpwuid = rffi.llexternal('getpwuid', [lltype.Signed], PASSWDPTR, compilation_info=eci) initgroups = rffi.llexternal('initgroups', [rffi.CCHARP, lltype.Signed], rffi.INT, compilation_info=eci) getgrgid = rffi.llexternal('getgrgid', [lltype.Signed], GROUPPTR,
("tm_mday", rffi.INT), ("tm_mon", rffi.INT), ("tm_year", rffi.INT), ("tm_wday", rffi.INT), ("tm_yday", rffi.INT), ("tm_isdst", rffi.INT), ("tm_gmtoff", rffi.LONG), ("tm_zone", rffi.CCHARP)]) timeval = platform.Struct("struct timeval", [("tv_sec", rffi.INT), ("tv_usec", rffi.INT)]) _compilation_info_ = eci conf = platform.configure(CConfig) tzinfo = rffi.CArrayPtr(conf['ttinfo']) tm = conf['tm'] tmP = lltype.Ptr(tm) timeval = conf['timeval'] timevalP = lltype.Ptr(timeval) c_strftime = external('strftime', [rffi.CCHARP, rffi.SIZE_T, rffi.CCHARP, tmP], rffi.SIZE_T) c_gettimeofday = external('gettimeofday', [rffi.VOIDP, rffi.VOIDP], rffi.INT) class CConfig(object): timelib_special = platform.Struct('timelib_special', [
REG_NO_LAZY_FLUSH REG_NOTIFY_CHANGE_NAME REG_NOTIFY_CHANGE_ATTRIBUTES REG_NOTIFY_CHANGE_LAST_SET REG_NOTIFY_CHANGE_SECURITY REG_LEGAL_CHANGE_FILTER REG_NONE REG_SZ REG_EXPAND_SZ REG_BINARY REG_DWORD REG_DWORD_LITTLE_ENDIAN REG_DWORD_BIG_ENDIAN REG_LINK REG_MULTI_SZ REG_RESOURCE_LIST REG_FULL_RESOURCE_DESCRIPTOR REG_RESOURCE_REQUIREMENTS_LIST HKEY_LOCAL_MACHINE HKEY_CLASSES_ROOT HKEY_CURRENT_CONFIG HKEY_CURRENT_USER HKEY_DYN_DATA HKEY_LOCAL_MACHINE HKEY_PERFORMANCE_DATA HKEY_USERS ERROR_MORE_DATA '''.split() for name in constant_names: setattr(CConfig, name, platform.DefinedConstantInteger(name)) constants = {} cConfig = platform.configure(CConfig) constants.update(cConfig) globals().update(cConfig) def external(name, args, result, **kwds): return rffi.llexternal(name, args, result, compilation_info=eci, calling_conv='win', **kwds) HKEY = rwin32.HANDLE PHKEY = rffi.CArrayPtr(HKEY)
def configure_types(): for config in (CConfig, CConfig2): for name, TYPE in rffi_platform.configure(config).iteritems(): if name in TYPES: TYPES[name].become(TYPE)
validate_fd(fileno(fp)) return _feof(fp) constant_names = """ Py_TPFLAGS_READY Py_TPFLAGS_READYING Py_TPFLAGS_HAVE_GETCHARBUFFER METH_COEXIST METH_STATIC METH_CLASS METH_NOARGS METH_VARARGS METH_KEYWORDS METH_O Py_TPFLAGS_HEAPTYPE Py_TPFLAGS_HAVE_CLASS Py_LT Py_LE Py_EQ Py_NE Py_GT Py_GE """.split() for name in constant_names: setattr(CConfig_constants, name, rffi_platform.ConstantInteger(name)) udir.join('pypy_decl.h').write("/* Will be filled later */\n") udir.join('pypy_macros.h').write("/* Will be filled later */\n") globals().update(rffi_platform.configure(CConfig_constants)) def copy_header_files(dstdir): assert dstdir.check(dir=True) headers = include_dir.listdir('*.h') + include_dir.listdir('*.inl') for name in ("pypy_decl.h", "pypy_macros.h"): headers.append(udir.join(name)) for header in headers: target = dstdir.join(header.basename) try: header.copy(dstdir) except py.error.EACCES: target.remove() # maybe it was a read-only file header.copy(dstdir) target.chmod(0444) # make the file read-only, to make sure that nobody # edits it by mistake
("tm_mon", rffi.INT), ("tm_year", rffi.INT), ("tm_wday", rffi.INT), ("tm_yday", rffi.INT), ("tm_isdst", rffi.INT), ("tm_gmtoff", rffi.LONG), ("tm_zone", rffi.CCHARP)]) timeval = platform.Struct("struct timeval", [ ("tv_sec", rffi.INT), ("tv_usec", rffi.INT) ]) _compilation_info_ = eci conf = platform.configure(CConfig) tzinfo = rffi.CArrayPtr(conf['ttinfo']) tm = conf['tm'] tmP = lltype.Ptr(tm) timeval = conf['timeval'] timevalP = lltype.Ptr(timeval) c_strftime = external('strftime', [rffi.CCHARP, rffi.SIZE_T, rffi.CCHARP, tmP], rffi.SIZE_T) c_gettimeofday = external('gettimeofday', [rffi.VOIDP, rffi.VOIDP], rffi.INT) class CConfig(object): timelib_special = platform.Struct('timelib_special', [
def is_valid_fp(fp): return is_valid_fd(fileno(fp)) constant_names = """ Py_TPFLAGS_READY Py_TPFLAGS_READYING Py_TPFLAGS_HAVE_GETCHARBUFFER METH_COEXIST METH_STATIC METH_CLASS METH_NOARGS METH_VARARGS METH_KEYWORDS METH_O Py_TPFLAGS_HEAPTYPE Py_TPFLAGS_HAVE_CLASS Py_LT Py_LE Py_EQ Py_NE Py_GT Py_GE """.split() for name in constant_names: setattr(CConfig_constants, name, rffi_platform.ConstantInteger(name)) udir.join('pypy_decl.h').write("/* Will be filled later */\n") udir.join('pypy_macros.h').write("/* Will be filled later */\n") globals().update(rffi_platform.configure(CConfig_constants)) def _copy_header_files(headers, dstdir): for header in headers: target = dstdir.join(header.basename) try: header.copy(dstdir) except py.error.EACCES: target.remove() # maybe it was a read-only file header.copy(dstdir) target.chmod(0444) # make the file read-only, to make sure that nobody # edits it by mistake def copy_header_files(dstdir): # XXX: 20 lines of code to recursively copy a directory, really?? assert dstdir.check(dir=True)
return rffi.llexternal(name, args, result, compilation_info=compilation_info, **kwds) def replace_time_function(name): func = getattr(pytime, name, None) if func is None: return lambda f: f return register_replacement_for(func, sandboxed_name='ll_time.ll_time_%s' % name) config = rffi_platform.configure(CConfig) globals().update(config) # Note: time.time() is used by the framework GC during collect(), # which means that we have to be very careful about not allocating # GC memory here. This is the reason for the _nowrapper=True. if HAVE_GETTIMEOFDAY: if GETTIMEOFDAY_NO_TZ: c_gettimeofday = external('gettimeofday', [lltype.Ptr(TIMEVAL)], rffi.INT, _nowrapper=True, releasegil=False) else: c_gettimeofday = external('gettimeofday', [lltype.Ptr(TIMEVAL), rffi.VOIDP], rffi.INT,
translator_c_dir = py.path.local(cdir) eci = ExternalCompilationInfo( includes = ['src/thread.h'], separate_module_files = [translator_c_dir / 'src' / 'thread.c'], include_dirs = [translator_c_dir], ) class CConfig: _compilation_info_ = eci RPYTHREAD_NAME = rffi_platform.DefinedConstantString('RPYTHREAD_NAME') USE_SEMAPHORES = rffi_platform.Defined('USE_SEMAPHORES') CS_GNU_LIBPTHREAD_VERSION = rffi_platform.DefinedConstantInteger( '_CS_GNU_LIBPTHREAD_VERSION') cconfig = rffi_platform.configure(CConfig) globals().update(cconfig) def llexternal(name, args, result, **kwds): kwds.setdefault('sandboxsafe', True) return rffi.llexternal(name, args, result, compilation_info=eci, **kwds) @not_rpython def _emulated_start_new_thread(func): import thread try: ident = thread.start_new_thread(func, ()) except thread.error: ident = -1
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("OPENSSL_EXPORT_VAR_AS_FUNCTION") OPENSSL_VERSION_NUMBER = rffi_platform.ConstantInteger("OPENSSL_VERSION_NUMBER") cconfig = rffi_platform.configure(CConfigBootstrap) if cconfig["OPENSSL_EXPORT_VAR_AS_FUNCTION"]: ASN1_ITEM_EXP = lltype.Ptr(lltype.FuncType([], ASN1_ITEM)) else: ASN1_ITEM_EXP = ASN1_ITEM OPENSSL_VERSION_NUMBER = cconfig["OPENSSL_VERSION_NUMBER"] class CConfig: _compilation_info_ = eci SSLEAY_VERSION = rffi_platform.DefinedConstantString("SSLEAY_VERSION", "SSLeay_version(SSLEAY_VERSION)") OPENSSL_NO_SSL2 = rffi_platform.Defined("OPENSSL_NO_SSL2") OPENSSL_NO_SSL3 = rffi_platform.Defined("OPENSSL_NO_SSL3") OPENSSL_NO_ECDH = rffi_platform.Defined("OPENSSL_NO_ECDH") OPENSSL_NPN_NEGOTIATED = rffi_platform.Defined("OPENSSL_NPN_NEGOTIATED")
('iMaxSockets', rffi.USHORT), ('iMaxUdpDg', rffi.USHORT), ('lpVendorInfo', CCHARP) ]) CConfig.tcp_keepalive = platform.Struct( 'struct tcp_keepalive', [('onoff', rffi.ULONG), ('keepalivetime', rffi.ULONG), ('keepaliveinterval', rffi.ULONG)]) class cConfig: pass cConfig.__dict__.update(platform.configure(CConfig)) sockaddr_ptr.TO.become(cConfig.sockaddr) addrinfo_ptr.TO.become(cConfig.addrinfo) # fill in missing constants with reasonable defaults cConfig.NI_MAXHOST = cConfig.NI_MAXHOST or 1025 cConfig.NI_MAXSERV = cConfig.NI_MAXSERV or 32 cConfig.INET_ADDRSTRLEN = cConfig.INET_ADDRSTRLEN or 16 for name in constant_names: value = getattr(cConfig, name) if value is not None: constants[name] = value for name, default in constants_w_defaults: value = getattr(cConfig, name)
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 class CConfig: _compilation_info_ = eci OPENSSL_VERSION_NUMBER = rffi_platform.ConstantInteger( "OPENSSL_VERSION_NUMBER") SSLEAY_VERSION = rffi_platform.DefinedConstantString( "SSLEAY_VERSION", "SSLeay_version(SSLEAY_VERSION)") OPENSSL_NO_SSL2 = rffi_platform.Defined("OPENSSL_NO_SSL2") OPENSSL_NO_SSL3 = rffi_platform.Defined("OPENSSL_NO_SSL3") SSL_FILETYPE_PEM = rffi_platform.ConstantInteger("SSL_FILETYPE_PEM")
""" _compilation_info_ = eci # XXX If Z_PREFIX was defined for the libz build, then these types are # named z_uInt, z_uLong, and z_Bytef instead. uInt = rffi_platform.SimpleType('uInt', rffi.UINT) uLong = rffi_platform.SimpleType('uLong', rffi.ULONG) Bytef = rffi_platform.SimpleType('Bytef', rffi.UCHAR) voidpf = rffi_platform.SimpleType('voidpf', rffi.VOIDP) ZLIB_VERSION = rffi_platform.DefinedConstantString('ZLIB_VERSION') for _name in constantnames: setattr(SimpleCConfig, _name, rffi_platform.ConstantInteger(_name)) config = rffi_platform.configure(SimpleCConfig) voidpf = config['voidpf'] uInt = config['uInt'] uLong = config['uLong'] Bytef = config['Bytef'] Bytefp = lltype.Ptr(lltype.Array(Bytef, hints={'nolength': True})) ZLIB_VERSION = config['ZLIB_VERSION'] for _name in constantnames: globals()[_name] = config[_name] # The following parameter is copied from zutil.h, version 0.95, # according to CPython's zlibmodule.c DEFLATED = Z_DEFLATED if MAX_MEM_LEVEL >= 8:
"ERPCMISMATCH", "ESHLIBVERS" ] includes = ['errno.h'] if sys.platform == 'win32': includes.append('winsock2.h') class CConfig: _compilation_info_ = ExternalCompilationInfo(includes=includes) for err_name in errors + win_errors + more_errors: setattr(CConfig, err_name, DefinedConstantInteger(err_name)) config = configure(CConfig) errorcode = {} name2code = {} for err_name in errors: # Note: later names take precedence over earlier ones, if they have the # same value code = config[err_name] if code is not None: errorcode[code] = err_name name2code[err_name] = code for name in win_errors: assert name.startswith('WSA') code = config[name] if code is not None: if name[3:] in errors and name[3:] not in name2code:
float(rffi.getintfield(t, 'c_tv_usec')) * 0.000001) def external(name, args, result, compilation_info=eci, **kwds): return rffi.llexternal(name, args, result, compilation_info=compilation_info, **kwds) def replace_time_function(name): func = getattr(pytime, name, None) if func is None: return lambda f: f return register_replacement_for( func, sandboxed_name='ll_time.ll_time_%s' % name) config = rffi_platform.configure(CConfig) globals().update(config) # Note: time.time() is used by the framework GC during collect(), # which means that we have to be very careful about not allocating # GC memory here. This is the reason for the _nowrapper=True. if HAVE_GETTIMEOFDAY: if GETTIMEOFDAY_NO_TZ: c_gettimeofday = external('gettimeofday', [lltype.Ptr(TIMEVAL)], rffi.INT, _nowrapper=True, releasegil=False) else: c_gettimeofday = external('gettimeofday', [lltype.Ptr(TIMEVAL), rffi.VOIDP], rffi.INT, _nowrapper=True, releasegil=False) if HAVE_FTIME:
def make_win32_traits(traits): from rpython.rlib import rwin32 if traits.str is unicode: suffix = 'W' else: suffix = 'A' class CConfig: _compilation_info_ = ExternalCompilationInfo( includes = ['windows.h', 'winbase.h', 'sys/stat.h'], ) WIN32_FIND_DATA = platform.Struct( 'struct _WIN32_FIND_DATA' + suffix, # Only interesting fields [('dwFileAttributes', rwin32.DWORD), ('nFileSizeHigh', rwin32.DWORD), ('nFileSizeLow', rwin32.DWORD), ('ftCreationTime', rwin32.FILETIME), ('ftLastAccessTime', rwin32.FILETIME), ('ftLastWriteTime', rwin32.FILETIME), ('cFileName', lltype.FixedSizeArray(traits.CHAR, 250))]) ERROR_FILE_NOT_FOUND = platform.ConstantInteger( 'ERROR_FILE_NOT_FOUND') ERROR_NO_MORE_FILES = platform.ConstantInteger( 'ERROR_NO_MORE_FILES') GetFileExInfoStandard = platform.ConstantInteger( 'GetFileExInfoStandard') FILE_ATTRIBUTE_DIRECTORY = platform.ConstantInteger( 'FILE_ATTRIBUTE_DIRECTORY') FILE_ATTRIBUTE_READONLY = platform.ConstantInteger( 'FILE_ATTRIBUTE_READONLY') INVALID_FILE_ATTRIBUTES = platform.ConstantInteger( 'INVALID_FILE_ATTRIBUTES') ERROR_SHARING_VIOLATION = platform.ConstantInteger( 'ERROR_SHARING_VIOLATION') _S_IFDIR = platform.ConstantInteger('_S_IFDIR') _S_IFREG = platform.ConstantInteger('_S_IFREG') _S_IFCHR = platform.ConstantInteger('_S_IFCHR') _S_IFIFO = platform.ConstantInteger('_S_IFIFO') FILE_TYPE_UNKNOWN = platform.ConstantInteger('FILE_TYPE_UNKNOWN') FILE_TYPE_CHAR = platform.ConstantInteger('FILE_TYPE_CHAR') FILE_TYPE_PIPE = platform.ConstantInteger('FILE_TYPE_PIPE') WIN32_FILE_ATTRIBUTE_DATA = platform.Struct( 'WIN32_FILE_ATTRIBUTE_DATA', [('dwFileAttributes', rwin32.DWORD), ('nFileSizeHigh', rwin32.DWORD), ('nFileSizeLow', rwin32.DWORD), ('ftCreationTime', rwin32.FILETIME), ('ftLastAccessTime', rwin32.FILETIME), ('ftLastWriteTime', rwin32.FILETIME)]) BY_HANDLE_FILE_INFORMATION = platform.Struct( 'BY_HANDLE_FILE_INFORMATION', [('dwFileAttributes', rwin32.DWORD), ('nFileSizeHigh', rwin32.DWORD), ('nFileSizeLow', rwin32.DWORD), ('nNumberOfLinks', rwin32.DWORD), ('nFileIndexHigh', rwin32.DWORD), ('nFileIndexLow', rwin32.DWORD), ('ftCreationTime', rwin32.FILETIME), ('ftLastAccessTime', rwin32.FILETIME), ('ftLastWriteTime', rwin32.FILETIME)]) config = platform.configure(CConfig) def external(*args, **kwargs): kwargs['compilation_info'] = CConfig._compilation_info_ llfunc = rffi.llexternal(calling_conv='win', *args, **kwargs) return staticmethod(llfunc) class Win32Traits: apisuffix = suffix for name in '''WIN32_FIND_DATA WIN32_FILE_ATTRIBUTE_DATA BY_HANDLE_FILE_INFORMATION GetFileExInfoStandard FILE_ATTRIBUTE_DIRECTORY FILE_ATTRIBUTE_READONLY INVALID_FILE_ATTRIBUTES _S_IFDIR _S_IFREG _S_IFCHR _S_IFIFO FILE_TYPE_UNKNOWN FILE_TYPE_CHAR FILE_TYPE_PIPE ERROR_FILE_NOT_FOUND ERROR_NO_MORE_FILES ERROR_SHARING_VIOLATION '''.split(): locals()[name] = config[name] LPWIN32_FIND_DATA = lltype.Ptr(WIN32_FIND_DATA) GET_FILEEX_INFO_LEVELS = rffi.ULONG # an enumeration FindFirstFile = external('FindFirstFile' + suffix, [traits.CCHARP, LPWIN32_FIND_DATA], rwin32.HANDLE) FindNextFile = external('FindNextFile' + suffix, [rwin32.HANDLE, LPWIN32_FIND_DATA], rwin32.BOOL) FindClose = external('FindClose', [rwin32.HANDLE], rwin32.BOOL) GetFileAttributes = external( 'GetFileAttributes' + suffix, [traits.CCHARP], rwin32.DWORD) SetFileAttributes = external( 'SetFileAttributes' + suffix, [traits.CCHARP, rwin32.DWORD], rwin32.BOOL) GetFileAttributesEx = external( 'GetFileAttributesEx' + suffix, [traits.CCHARP, GET_FILEEX_INFO_LEVELS, lltype.Ptr(WIN32_FILE_ATTRIBUTE_DATA)], rwin32.BOOL) GetFileInformationByHandle = external( 'GetFileInformationByHandle', [rwin32.HANDLE, lltype.Ptr(BY_HANDLE_FILE_INFORMATION)], rwin32.BOOL) GetFileType = external( 'GetFileType', [rwin32.HANDLE], rwin32.DWORD) LPSTRP = rffi.CArrayPtr(traits.CCHARP) GetFullPathName = external( 'GetFullPathName' + suffix, [traits.CCHARP, rwin32.DWORD, traits.CCHARP, LPSTRP], rwin32.DWORD) GetCurrentDirectory = external( 'GetCurrentDirectory' + suffix, [rwin32.DWORD, traits.CCHARP], rwin32.DWORD) SetCurrentDirectory = external( 'SetCurrentDirectory' + suffix, [traits.CCHARP], rwin32.BOOL) CreateDirectory = external( 'CreateDirectory' + suffix, [traits.CCHARP, rffi.VOIDP], rwin32.BOOL) SetEnvironmentVariable = external( 'SetEnvironmentVariable' + suffix, [traits.CCHARP, traits.CCHARP], rwin32.BOOL) DeleteFile = external( 'DeleteFile' + suffix, [traits.CCHARP], rwin32.BOOL) MoveFile = external( 'MoveFile' + suffix, [traits.CCHARP, traits.CCHARP], rwin32.BOOL) return Win32Traits
('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)]) CConfig.tcp_keepalive = platform.Struct( 'struct tcp_keepalive', [('onoff', rffi.ULONG), ('keepalivetime', rffi.ULONG), ('keepaliveinterval', rffi.ULONG)]) class cConfig: pass cConfig.__dict__.update(platform.configure(CConfig)) sockaddr_ptr.TO.become(cConfig.sockaddr) addrinfo_ptr.TO.become(cConfig.addrinfo) # fill in missing constants with reasonable defaults cConfig.NI_MAXHOST = cConfig.NI_MAXHOST or 1025 cConfig.NI_MAXSERV = cConfig.NI_MAXSERV or 32 cConfig.INET_ADDRSTRLEN = cConfig.INET_ADDRSTRLEN or 16 for name in constant_names: value = getattr(cConfig, name) if value is not None: constants[name] = value for name, default in constants_w_defaults: value = getattr(cConfig, name)
INCLUDES = ["sys/types.h", "sys/stat.h", "sys/statvfs.h", "unistd.h"] compilation_info = ExternalCompilationInfo( # This must be set to 64 on some systems to enable large file support. # pre_include_bits = ['#define _FILE_OFFSET_BITS 64'], # ^^^ nowadays it's always set in all C files we produce. includes=INCLUDES ) if TIMESPEC is not None: class CConfig_for_timespec: _compilation_info_ = compilation_info TIMESPEC = TIMESPEC TIMESPEC = lltype.Ptr(platform.configure(CConfig_for_timespec)["TIMESPEC"]) def posix_declaration(try_to_add=None): global STAT_STRUCT, STATVFS_STRUCT LL_STAT_FIELDS = STAT_FIELDS[:] if try_to_add: LL_STAT_FIELDS.append(try_to_add) if TIMESPEC is not None: def _expand(lst, originalname, timespecname): for i, (_name, _TYPE) in enumerate(lst): if _name == originalname: # replace the 'st_atime' field of type rffi.DOUBLE
# WinSock does not use a bitmask in select, and uses # socket handles greater than FD_SETSIZE if sys.platform == 'win32': MAX_FD_SIZE = None else: from rpython.rlib._rsocket_rffi import FD_SETSIZE as MAX_FD_SIZE 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 class CConfig: _compilation_info_ = eci OPENSSL_VERSION_NUMBER = rffi_platform.ConstantInteger( "OPENSSL_VERSION_NUMBER") SSLEAY_VERSION = rffi_platform.DefinedConstantString( "SSLEAY_VERSION", "SSLeay_version(SSLEAY_VERSION)") OPENSSL_NO_SSL2 = rffi_platform.Defined("OPENSSL_NO_SSL2") SSL_FILETYPE_PEM = rffi_platform.ConstantInteger("SSL_FILETYPE_PEM") SSL_OP_ALL = rffi_platform.ConstantInteger("SSL_OP_ALL") SSL_OP_NO_SSLv2 = rffi_platform.ConstantInteger("SSL_OP_NO_SSLv2")
passwd = platform.Struct('struct passwd', [('pw_name', rffi.CCHARP), ('pw_passwd', rffi.CCHARP), ('pw_uid', lltype.Signed), ('pw_gid', lltype.Signed), ('pw_gecos', rffi.CCHARP), ('pw_dir', rffi.CCHARP), ('pw_shell', rffi.CCHARP)]) group = platform.Struct('struct group', [('gr_name', rffi.CCHARP), ('gr_passwd', rffi.CCHARP), ('gr_gid', lltype.Signed), ('gr_mem', rffi.CCHARPP)]) PASSWD = platform.configure(CConfig)['passwd'] PASSWDPTR = lltype.Ptr(PASSWD) GROUP = platform.configure(CConfig)['group'] GROUPPTR = lltype.Ptr(GROUP) getpwnam = rffi.llexternal('getpwnam', [rffi.CCHARP], PASSWDPTR, compilation_info=eci) getpwuid = rffi.llexternal('getpwuid', [lltype.Signed], PASSWDPTR, compilation_info=eci) initgroups = rffi.llexternal('initgroups', [rffi.CCHARP, lltype.Signed], rffi.INT, compilation_info=eci) getgrgid = rffi.llexternal('getgrgid', [lltype.Signed], GROUPPTR, compilation_info=eci) getgrnam = rffi.llexternal('getgrnam', [rffi.CCHARP], GROUPPTR, compilation_info=eci)
TIOCGSERIAL TIOCGSOFTCAR TIOCGWINSZ TIOCINQ TIOCLINUX TIOCMBIC TIOCMBIS TIOCMGET TIOCMIWAIT TIOCMSET TIOCM_CAR TIOCM_CD TIOCM_CTS TIOCM_DSR TIOCM_DTR TIOCM_LE TIOCM_RI TIOCM_RNG TIOCM_RTS TIOCM_SR TIOCM_ST TIOCNOTTY TIOCNXCL TIOCOUTQ TIOCPKT TIOCPKT_DATA TIOCPKT_DOSTOP TIOCPKT_FLUSHREAD TIOCPKT_FLUSHWRITE TIOCPKT_NOSTOP TIOCPKT_START TIOCPKT_STOP TIOCSCTTY TIOCSERCONFIG TIOCSERGETLSR TIOCSERGETMULTI TIOCSERGSTRUCT TIOCSERGWILD TIOCSERSETMULTI TIOCSERSWILD TIOCSER_TEMT TIOCSETD TIOCSLCKTRMIOS TIOCSPGRP TIOCSSERIAL TIOCSSOFTCAR TIOCSTI TIOCSWINSZ TIOCTTYGSTRUCT """ ).split() for name in CONSTANT_NAMES: setattr(CConfig, name, rffi_platform.DefinedConstantInteger(name)) c_config = rffi_platform.configure(CConfig) # Copy VSWTCH to VSWTC and vice-versa if c_config["VSWTC"] is None: c_config["VSWTC"] = c_config["VSWTCH"] if c_config["VSWTCH"] is None: c_config["VSWTCH"] = c_config["VSWTC"] all_constants = {} for name in CONSTANT_NAMES: value = c_config[name] if value is not None: if value < -sys.maxsize - 1 or value >= 2 * (sys.maxsize + 1): raise AssertionError("termios: %r has value %r, too large" % (name, value)) value = intmask(value) # wrap unsigned long numbers to signed longs globals()[name] = value
PCRE_NO_UTF8_CHECK PCRE_ERROR_NOMATCH PCRE_ERROR_MATCHLIMIT PCRE_ERROR_RECURSIONLIMIT PCRE_ERROR_BADUTF8 PCRE_ERROR_BADUTF8_OFFSET PCRE_INFO_CAPTURECOUNT PCRE_INFO_NAMECOUNT PCRE_INFO_NAMETABLE PCRE_INFO_NAMEENTRYSIZE '''.split(): setattr(CConfig, _name, platform.ConstantInteger(_name)) # list of all integer constants that are optional for _name in ''' PCRE_UCP '''.split(): setattr(CConfig, _name, platform.DefinedConstantInteger(_name)) globals().update(platform.configure(CConfig)) # ____________________________________________________________ CCHARPPP = lltype.Ptr(lltype.Array(rffi.CCHARPP, hints={'nolength': True})) pcre = rffi.CStruct('pcre') pcre_compile = llexternal('pcre_compile', [rffi.CCHARP, rffi.INT, rffi.CCHARPP, rffi.INTP, rffi.CCHARP], lltype.Ptr(pcre), releasegil=False) pcre_exec = llexternal('pcre_exec', [lltype.Ptr(pcre), lltype.Ptr(pcre_extra),
]) RegexList = rffi_platform.Struct('RegexList', [ ('count', rffi.ULONGLONG), ('regex', rffi.VOIDP), ]) class Config: _compilation_info_ = eci regex_transition = RegexTransition regex = Regex regex_list = RegexList config = rffi_platform.configure(Config()) def run_machine(machine, input_data): token_id, init_state, transitions = machine current_state = init_state for char in input_data: places_to_go_next = transitions.get(current_state, {}) if char not in places_to_go_next: return RESULT_FAIL current_state = places_to_go_next[char] what_left = transitions.get(current_state, {}) next_state = what_left.get(chr(0), INVALID_NEXT_STATE)
'bzlib.h', ], include_dirs=['/usr/include/'], library_dirs=[ '/usr/lib/x86_64-linux-gnu/', ], libraries=['bz2']) 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)
def setup(): INSPECT = {'b': 'signed char', 'h': 'signed short', 'i': 'signed int', 'l': 'signed long', 'q': 'signed long long', 'B': 'unsigned char', 'H': 'unsigned short', 'I': 'unsigned int', 'L': 'unsigned long', 'Q': 'unsigned long long', 'P': 'char *', 'f': 'float', 'd': 'double', '?': '_Bool', } pre_include_bits = [""" #ifdef _MSC_VER #define _Bool char #endif"""] field_names = dict.fromkeys(INSPECT) for fmtchar, ctype in INSPECT.iteritems(): field_name = ctype.replace(" ", "_").replace("*", "star") field_names[fmtchar] = field_name pre_include_bits.append(""" struct about_%s { char pad; %s field; }; """ % (field_name, ctype)) class CConfig: _compilation_info_ = ExternalCompilationInfo( pre_include_bits = pre_include_bits ) for fmtchar, ctype in INSPECT.items(): setattr(CConfig, field_names[fmtchar], rffi_platform.Struct( "struct about_%s" % (field_names[fmtchar],), [('field', lltype.FixedSizeArray(rffi.CHAR, 1))])) cConfig = rffi_platform.configure(CConfig) for fmtchar, ctype in INSPECT.items(): S = cConfig[field_names[fmtchar]] alignment = rffi.offsetof(S, 'c_field') size = rffi.sizeof(S.c_field) signed = 'a' <= fmtchar <= 'z' if fmtchar == 'f': pack = pack_float unpack = unpack_float elif fmtchar == 'd': pack = pack_double unpack = unpack_double elif fmtchar == '?': pack = std.pack_bool unpack = std.unpack_bool else: pack = std.make_int_packer(size, signed, True) unpack = std.make_int_unpacker(size, signed) native_fmttable[fmtchar] = {'size': size, 'alignment': alignment, 'pack': pack, 'unpack': unpack}
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 for k, v in platform.configure(CConfig).items(): setattr(cConfig, k, v) if not cConfig.CHECK_LIBRARY: raise ImportError("Invalid bz2 library") for name in constant_names: value = getattr(cConfig, name) if value is not None: constants[name] = value locals().update(constants) off_t = cConfig.off_t bz_stream = lltype.Ptr(cConfig.bz_stream) BUFSIZ = cConfig.BUFSIZ SEEK_SET = cConfig.SEEK_SET BZ_OK = cConfig.BZ_OK
from rpython.rtyper.tool import rffi_platform from topaz.module import ModuleDef from topaz.system import IS_WINDOWS if not IS_WINDOWS: class CConstants(object): _compilation_info_ = ExternalCompilationInfo(includes=['fcntl.h']) for const in ["F_DUPFD", "F_GETFD", "F_GETLK", "F_SETFD", "F_GETFL", "F_SETFL", "F_SETLK", "F_SETLKW", "FD_CLOEXEC", "F_RDLCK", "F_UNLCK", "F_WRLCK", "O_CREAT", "O_EXCL", "O_NOCTTY", "O_TRUNC", "O_APPEND", "O_NONBLOCK", "O_NDELAY", "O_RDONLY", "O_RDWR", "O_WRONLY", "O_ACCMODE"]: setattr(CConstants, const, rffi_platform.ConstantInteger(const)) fcntl_constants = rffi_platform.configure(CConstants) fcntl = _rsocket_rffi.fcntl else: fcntl_constants = {} def fcntl(fdtype, cmd, arg): raise NotImplementedError class Fcntl(object): moduledef = ModuleDef("Fcntl") @moduledef.setup_module def setup_module(space, w_mod): if not IS_WINDOWS: for key, value in fcntl_constants.items():