class ComplexCConfig: _compilation_info_ = CConfig._compilation_info_ SYSINFO_STRUCT = rffi.CStruct( 'SYSINFO_STRUCT', ("wProcessorArchitecture", WORD), ("wReserved", WORD), ) SYSINFO_UNION = rffi.CStruct( 'union SYSINFO_UNION', ("dwOemId", DWORD), ("_struct_", SYSINFO_STRUCT), ) # sorry, I can't find a way to insert the above # because the union field has no name SYSTEM_INFO = rffi_platform.Struct( 'SYSTEM_INFO', [ ## ("_union_", SYSINFO_UNION), ## instead, we put the smaller fields, here ("wProcessorArchitecture", WORD), ("wReserved", WORD), ## should be a union. dwOemId is obsolete, anyway ("dwPageSize", DWORD), ("lpMinimumApplicationAddress", LPVOID), ("lpMaximumApplicationAddress", LPVOID), ("dwActiveProcessorMask", DWORD_PTR), ("dwNumberOfProcessors", DWORD), ("dwProcessorType", DWORD), ("dwAllocationGranularity", DWORD), ("wProcessorLevel", WORD), ("wProcessorRevision", WORD), ])
def build_result(self, info, config_result): if self.ifdef is not None: if not info['defined']: return None layout = [None] * info['size'] for fieldname, fieldtype in self.interesting_fields: if isinstance(fieldtype, Struct): offset = info['fldofs ' + fieldname] size = info['fldsize ' + fieldname] c_fieldtype = config_result.get_entry_result(fieldtype) layout_addfield(layout, offset, c_fieldtype, fieldname) else: offset = info['fldofs ' + fieldname] size = info['fldsize ' + fieldname] sign = info.get('fldunsigned ' + fieldname, False) if (size, sign) != rffi.size_and_sign(fieldtype): fieldtype = fixup_ctype(fieldtype, fieldname, (size, sign)) layout_addfield(layout, offset, fieldtype, fieldname) n = 0 padfields = [] for i, cell in enumerate(layout): if cell is not None: continue name = '_pad%d' % (n, ) layout_addfield(layout, i, rffi.UCHAR, name) padfields.append('c_' + name) n += 1 # build the lltype Structure seen = {} fields = [] fieldoffsets = [] for offset, cell in enumerate(layout): if cell in seen: continue fields.append((cell.name, cell.ctype)) fieldoffsets.append(offset) seen[cell] = True allfields = tuple(['c_' + name for name, _ in fields]) padfields = tuple(padfields) name = self.name eci = config_result.CConfig._compilation_info_ padding_drop = PaddingDrop(name, allfields, padfields, eci) hints = { 'align': info['align'], 'size': info['size'], 'fieldoffsets': tuple(fieldoffsets), 'padding': padfields, 'get_padding_drop': padding_drop, 'eci': eci } if name.startswith('struct '): name = name[7:] else: hints['typedef'] = True kwds = {'hints': hints} return rffi.CStruct(name, *fields, **kwds)
def __init__(self, namespace): for k, v in namespace.iteritems(): setattr(self, k, v) def _freeze_(self): return True # --- copy a few declarations from src/vmprof_stack.h --- VMPROF_CODE_TAG = 1 VMPROFSTACK = lltype.ForwardReference() PVMPROFSTACK = lltype.Ptr(VMPROFSTACK) VMPROFSTACK.become( rffi.CStruct("vmprof_stack_s", ('next', PVMPROFSTACK), ('value', lltype.Signed), ('kind', lltype.Signed))) # ---------- vmprof_tl_stack = rthread.ThreadLocalField(PVMPROFSTACK, "vmprof_tl_stack") do_use_eci = rffi.llexternal_use_eci( ExternalCompilationInfo(includes=['vmprof_stack.h'], include_dirs=[SRC])) def enter_code(unique_id): do_use_eci() s = lltype.malloc(VMPROFSTACK, flavor='raw') s.c_next = vmprof_tl_stack.get_or_make_raw() s.c_value = unique_id s.c_kind = VMPROF_CODE_TAG vmprof_tl_stack.setraw(s) return s
pre_include_bits=['#define _CFFI_INTERNAL'], ) def llexternal(name, args, result, **kwds): return rffi.llexternal(name, args, result, compilation_info=eci, _nowrapper=True, **kwds) _CFFI_OPCODE_T = rffi.VOIDP GLOBAL_S = rffi.CStruct('_cffi_global_s', ('name', rffi.CCHARP), ('address', rffi.VOIDP), ('type_op', _CFFI_OPCODE_T), ('size_or_direct_fn', rffi.CCHARP)) CDL_INTCONST_S = lltype.Struct('cdl_intconst_s', ('value', rffi.ULONGLONG), ('neg', rffi.INT)) STRUCT_UNION_S = rffi.CStruct('_cffi_struct_union_s', ('name', rffi.CCHARP), ('type_index', rffi.INT), ('flags', rffi.INT), ('size', rffi.SIZE_T), ('alignment', rffi.INT), ('first_field_index', rffi.INT), ('num_fields', rffi.INT)) FIELD_S = rffi.CStruct('_cffi_field_s', ('name', rffi.CCHARP), ('field_offset', rffi.SIZE_T), ('field_size', rffi.SIZE_T), ('field_type_op', _CFFI_OPCODE_T)) ENUM_S = rffi.CStruct('_cffi_enum_s', ('name', rffi.CCHARP), ('type_index', rffi.INT), ('type_prim', rffi.INT), ('enumerators', rffi.CCHARP))
'''.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)) pcre_exec = llexternal('pcre_exec', [ lltype.Ptr(pcre), lltype.Ptr(pcre_extra), rffi.CCHARP, rffi.INT, rffi.INT, rffi.INT, rffi.INTP, rffi.INT ], rffi.INT) pcre_fullinfo = llexternal( 'pcre_fullinfo', [lltype.Ptr(pcre),
eci = ExternalCompilationInfo(libraries=['testlib'], library_dirs=[os.path.abspath('.')],#/testlib.so')], includes=[os.path.abspath('./stdlib.h')]) external_function = rffi.llexternal('myprint', [], lltype.Void, compilation_info=eci) # Note to self: UUID4 has some fixed bits # struct.unpack('>qq', uuid.UUID(int=uuid.UUID(bytes=os.urandom(16)).int | (1 << 127)).bytes) INTEGER = (-6855051840143784798, -7880198636693933229) STRING = (-5744892467500213749, 739713154171887357) DOUBLE = (-5419088552942547567, 806613043255133199) TYPE_BFG_OBJECT = rffi.CStruct('bfg_object', # ('GUID_high', rffi.ULONGLONG), # unneeded? # ('GUID_low', rffi.ULONGLONG), # unneeded? ('metadata', rffi.ULONGLONG), ('data', rffi.VOIDP)) SIZE_BFG_OBJECT = rffi.cast(rffi.UINT, rffi.sizeof(TYPE_BFG_OBJECT)) TYPE_BFG_OBJECT_PTR = lltype.Ptr(TYPE_BFG_OBJECT) TYPE_BFG_OBJECT_ARRAY = rffi.CArray(TYPE_BFG_OBJECT) TYPE_BFG_OBJECT_ARRAY_PTR = lltype.Ptr(TYPE_BFG_OBJECT_ARRAY) TYPE_BFG_TYPE_SPACE = rffi.CStruct('bfg_type_space', ('GUID_high', rffi.ULONGLONG), ('GUID_low', rffi.ULONGLONG), ('index', rffi.ULONGLONG), ('length', rffi.ULONGLONG), ('alloc_length', rffi.ULONGLONG),
from rpython.translator.tool.cbuild import ExternalCompilationInfo from rpython.rtyper.tool import rffi_platform as platform from rpython.translator.platform import platform as trans_plaform ROOT = py.path.local(rpythonroot).join('rpython', 'rlib', 'rutf8') SRC = ROOT.join('src') if sys.platform.startswith('linux'): _libs = ['dl'] else: _libs = [] IDXTAB = lltype.ForwardReference() IDXTAB.become( rffi.CStruct("fu8_idxtab", ('character_step', rffi.INT), ('byte_positions', rffi.SIZE_TP), ('bytepos_table_length', rffi.SIZE_T))) IDXTABP = lltype.Ptr(IDXTAB) def setup(): compile_extra = ['-DRPYTHON_LL2CTYPES', '-DALLOW_SURROGATES=0', '-fPIC'] eci_kwds = dict(include_dirs=[SRC], includes=['utf8.h'], libraries=_libs, compile_extra=compile_extra) # compile the SSE4.1 and AVX version compile_extra.append('-msse4.1') ofile_eci = ExternalCompilationInfo(**eci_kwds) sse4_o, = trans_plaform._compile_o_files([SRC.join('utf8-sse4.c')], ofile_eci)
import os import sys from sota.constants import LIBDIR, PYPYDIR, CLIDIR sys.path.insert(0, PYPYDIR) from rpython.rtyper.lltypesystem import rffi from rpython.translator.tool.cbuild import ExternalCompilationInfo cli_eci = ExternalCompilationInfo(include_dirs=[CLIDIR], includes=['cli.h'], library_dirs=[LIBDIR], libraries=['cli'], use_cpp_linker=True) CliToken = rffi.CStruct('CliToken', ('name', rffi.CCHARP), ('value', rffi.CCHARP)) CliTokenPtr = rffi.CArrayPtr(CliToken) CliTokensPtr = rffi.CStructPtr('CliTokens', ('count', rffi.LONG), ('tokens', CliTokenPtr)) c_parse = rffi.llexternal('parse', [rffi.LONG, rffi.CCHARPP], CliTokensPtr, compilation_info=cli_eci) c_clean = rffi.llexternal('clean', [CliTokensPtr], rffi.LONG, compilation_info=cli_eci) #class CliParseError(Exception): # ''' # CliParseError # ''' # def __init__(self, result):
DIRENT_DIR:u"dir", DIRENT_LINK:u"link", DIRENT_FIFO:u"fifo", DIRENT_SOCKET:u"socket", DIRENT_CHAR:u"char", DIRENT_BLOCK:u"block" } #setup_args = llexternal("uv_setup_args", [rffi.INT, rffi.CCHARPP], rffi.CCHARPP) #get_process_title = llexternal("uv_get_process_title", [rffi.CCHARP, rffi.SIZE_T], rffi.INT) #set_process_title = llexternal("uv_set_process_title", [rffi.CCHARP], rffi.INT) #resident_set_memory = llexternal("uv_resident_set_memory", [rffi.SIZE_TP], rffi.INT) #uptime = llexternal("uv_uptime", [rffi.CArrayPtr(rffi.DOUBLE)], rffi.INT) timeval_t = rffi.CStruct("uv_timeval_t", ("tv_sec", rffi.LONG), ("tv_usec", rffi.LONG)) rusage_t = rffi.CStruct("uv_rusage_t", ("ru_utime", timeval_t), # user CPU time used ("ru_stime", timeval_t), # system CPU time used ("ru_maxrss", uint64_t), # maximum resident set size ("ru_ixrss", uint64_t), # integral shared memory size ("ru_idrss", uint64_t), # integral unshared data size ("ru_isrss", uint64_t), # integral unshared stack size ("ru_minflt", uint64_t), # page reclaims (soft page faults) ("ru_majflt", uint64_t), # page faults (hard page faults) ("ru_nswap", uint64_t), # swaps ("ru_inblock", uint64_t), # block input operations ("ru_oublock", uint64_t), # block output operations
import os from rpython.rlib.rposix import get_saved_errno from rpython.rtyper.lltypesystem import lltype, rffi from rpython.translator.tool.cbuild import ExternalCompilationInfo eci = ExternalCompilationInfo(includes=["mqueue.h"], libraries=["rt"]) mqd_t = rffi.platform.inttype("mqd_t", "mqd_t", True, add_source="#include <mqueue.h>") mq_attr = rffi.CStruct("mq_attr", ("mq_flags", rffi.LONG), ("mq_maxmsg", rffi.LONG), ("mq_msgsize", rffi.LONG), ("mq_curmsgs", rffi.LONG)) mq_attrp = rffi.lltype.Ptr(mq_attr) mq_open = rffi.llexternal("mq_open", [rffi.CCHARP, rffi.INT, rffi.MODE_T, mq_attrp], mqd_t, compilation_info=eci, save_err=rffi.RFFI_SAVE_ERRNO) mq_close = rffi.llexternal("mq_close", [mqd_t], rffi.INT, compilation_info=eci, save_err=rffi.RFFI_SAVE_ERRNO) mq_unlink = rffi.llexternal("mq_unlink", [rffi.CCHARP],
from rpython.rtyper.lltypesystem import lltype, rffi from pypy.module.cpyext.api import (PyObjectFields, bootstrap_function, cpython_api, cpython_struct, PyObject, build_type_checkers) from pypy.module.cpyext.pyobject import (make_typedescr, track_reference, from_ref) from pypy.module.cpyext.floatobject import PyFloat_AsDouble from pypy.objspace.std.complexobject import W_ComplexObject from pypy.interpreter.error import oefmt PyComplex_Check, PyComplex_CheckExact = build_type_checkers("Complex") Py_complex_t = rffi.CStruct('Py_complex_t', ('real', rffi.DOUBLE), ('imag', rffi.DOUBLE), hints={'size': 2 * rffi.sizeof(rffi.DOUBLE)}) Py_complex_ptr = lltype.Ptr(Py_complex_t) PyComplexObjectStruct = lltype.ForwardReference() PyComplexObject = lltype.Ptr(PyComplexObjectStruct) PyComplexObjectFields = PyObjectFields + \ (("cval", Py_complex_t),) cpython_struct("PyComplexObject", PyComplexObjectFields, PyComplexObjectStruct) @bootstrap_function def init_complexobject(space): "Type description of PyComplexObject" make_typedescr(space.w_complex.layout.typedef, basestruct=PyComplexObject.TO, attach=complex_attach, realize=complex_realize)
LIBDIR = py.path.local(__file__).join('..', 'lib/') subprocess.check_call(['make', '-C', str(LIBDIR)]) eci = ExternalCompilationInfo(includes=['timelib.h', 'sys/time.h', 'time.h'], include_dirs=[LIBDIR], libraries=['timelib1'], testonly_libraries=['timelib'], library_dirs=[str(LIBDIR)]) def external(*args): return rffi.llexternal(*args, compilation_info=eci) timelib_error_message = rffi.CStruct('timelib_error_message', ('position', rffi.INT), ('character', lltype.Char), ('message', rffi.CCHARP)) class CConfig(object): ttinfo = platform.Struct('ttinfo', [ ('offset', rffi.INT), ('isdst', rffi.INT), ('abbr_idx', lltype.Unsigned), ('isstdcnt', lltype.Unsigned), ('isgmtcnt', lltype.Unsigned), ]) tm = platform.Struct("struct tm", [("tm_sec", rffi.INT), ("tm_min", rffi.INT), ("tm_hour", rffi.INT),
import os from rpython.rtyper.lltypesystem import rffi, lltype from rpython.translator.tool.cbuild import ExternalCompilationInfo from sast.tokens import Token #pylint: disable=invalid-name CTOKEN = rffi.CStruct('CToken', ('start', rffi.LONG), ('end', rffi.LONG), ('kind', rffi.LONG), ('line', rffi.LONG), ('pos', rffi.LONG), ('skip', rffi.LONG)) CTOKENP = rffi.CArrayPtr(CTOKEN) CTOKENPP = rffi.CArrayPtr(CTOKENP) def deref(obj): return obj[0] def escape(old): new = '' for char in old: if char == '\n': new += '\\' new += 'n' else: new += char return new